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"
48 #ifdef MODEST_PLATFORM_MAEMO
49 #include "maemo/modest-osso-state-saving.h"
50 #endif /* MODEST_PLATFORM_MAEMO */
52 #include "widgets/modest-ui-constants.h"
53 #include <widgets/modest-main-window.h>
54 #include <widgets/modest-msg-view-window.h>
55 #include <widgets/modest-account-view-window.h>
56 #include <widgets/modest-details-dialog.h>
57 #include <widgets/modest-attachments-view.h>
58 #include "widgets/modest-folder-view.h"
59 #include "widgets/modest-global-settings-dialog.h"
60 #include "modest-connection-specific-smtp-window.h"
61 #include "modest-account-mgr-helpers.h"
62 #include "modest-mail-operation.h"
63 #include "modest-text-utils.h"
65 #ifdef MODEST_HAVE_EASYSETUP
66 #include "easysetup/modest-easysetup-wizard.h"
67 #endif /* MODEST_HAVE_EASYSETUP */
69 #include <modest-widget-memory.h>
70 #include <tny-error.h>
71 #include <tny-simple-list.h>
72 #include <tny-msg-view.h>
73 #include <tny-device.h>
74 #include <tny-merge-folder.h>
76 #include <gtkhtml/gtkhtml.h>
78 typedef struct _GetMsgAsyncHelper {
80 ModestMailOperation *mail_op;
87 typedef enum _ReplyForwardAction {
93 typedef struct _ReplyForwardHelper {
94 guint reply_forward_type;
95 ReplyForwardAction action;
97 GtkWidget *parent_window;
102 * The do_headers_action uses this kind of functions to perform some
103 * action to each member of a list of headers
105 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
108 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 gchar* ask_for_folder_name (GtkWindow *parent_window, const gchar *title);
128 static void _on_send_receive_progress_changed (ModestMailOperation *mail_op,
129 ModestMailOperationState *state,
135 run_account_setup_wizard (ModestWindow *win)
137 ModestEasysetupWizardDialog *wizard;
139 g_return_if_fail (MODEST_IS_WINDOW(win));
141 wizard = modest_easysetup_wizard_dialog_new ();
142 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
143 gtk_dialog_run (GTK_DIALOG (wizard));
144 gtk_widget_destroy (GTK_WIDGET (wizard));
149 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
152 const gchar *authors[] = {
153 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
156 about = gtk_about_dialog_new ();
157 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
158 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
159 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
160 _("Copyright (c) 2006, Nokia Corporation\n"
161 "All rights reserved."));
162 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
163 _("a modest e-mail client\n\n"
164 "design and implementation: Dirk-Jan C. Binnema\n"
165 "contributions from the fine people at KC and Ig\n"
166 "uses the tinymail email framework written by Philip van Hoof"));
167 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
168 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
170 gtk_dialog_run (GTK_DIALOG (about));
171 gtk_widget_destroy(about);
175 * Gets the list of currently selected messages. If the win is the
176 * main window, then it returns a newly allocated list of the headers
177 * selected in the header view. If win is the msg view window, then
178 * the value returned is a list with just a single header.
180 * The caller of this funcion must free the list.
183 get_selected_headers (ModestWindow *win)
185 if (MODEST_IS_MAIN_WINDOW(win)) {
186 GtkWidget *header_view;
188 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
189 MODEST_WIDGET_TYPE_HEADER_VIEW);
190 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
192 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
193 /* for MsgViewWindows, we simply return a list with one element */
195 TnyList *list = NULL;
197 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
198 if (header != NULL) {
199 list = tny_simple_list_new ();
200 tny_list_prepend (list, G_OBJECT(header));
201 g_object_unref (G_OBJECT(header));
211 headers_action_mark_as_read (TnyHeader *header,
215 TnyHeaderFlags flags;
217 g_return_if_fail (TNY_IS_HEADER(header));
219 flags = tny_header_get_flags (header);
220 if (flags & TNY_HEADER_FLAG_SEEN) return;
221 tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN);
225 headers_action_mark_as_unread (TnyHeader *header,
229 TnyHeaderFlags flags;
231 g_return_if_fail (TNY_IS_HEADER(header));
233 flags = tny_header_get_flags (header);
234 if (flags & TNY_HEADER_FLAG_SEEN) {
235 tny_header_unset_flags (header, TNY_HEADER_FLAG_SEEN);
241 headers_action_delete (TnyHeader *header,
245 ModestMailOperation *mail_op = NULL;
247 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE, G_OBJECT(win));
248 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
251 /* Always delete. TODO: Move to trash still not supported */
252 modest_mail_operation_remove_msg (mail_op, header, FALSE);
253 g_object_unref (G_OBJECT (mail_op));
257 modest_ui_actions_on_delete (GtkAction *action, ModestWindow *win)
259 TnyList *header_list = NULL;
260 TnyIterator *iter = NULL;
261 TnyHeader *header = NULL;
262 gchar *message = NULL;
266 ModestWindowMgr *mgr;
267 GtkWidget *header_view;
269 g_return_if_fail (MODEST_IS_WINDOW(win));
271 /* Check first if the header view has the focus */
272 if (MODEST_IS_MAIN_WINDOW (win)) {
273 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
274 MODEST_WIDGET_TYPE_HEADER_VIEW);
275 if (!gtk_widget_is_focus (header_view))
279 header_list = get_selected_headers (win);
280 if (!header_list) return;
282 /* Check if any of the headers is already opened */
283 iter = tny_list_create_iterator (header_list);
285 mgr = modest_runtime_get_window_mgr ();
286 while (!tny_iterator_is_done (iter) && !found) {
287 header = TNY_HEADER (tny_iterator_get_current (iter));
288 if (modest_window_mgr_find_window_by_header (mgr, header))
290 g_object_unref (header);
291 tny_iterator_next (iter);
293 g_object_unref (iter);
298 num = g_strdup_printf ("%d", tny_list_get_length (header_list));
299 msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"), num);
301 modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
305 g_object_unref (header_list);
310 if (tny_list_get_length(header_list) == 1) {
311 iter = tny_list_create_iterator (header_list);
312 header = TNY_HEADER (tny_iterator_get_current (iter));
313 desc = g_strdup_printf ("%s", tny_header_get_subject (header));
314 g_object_unref (header);
315 g_object_unref (iter);
317 message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
318 tny_list_get_length(header_list)), desc);
320 /* Confirmation dialog */
321 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
325 if (response == GTK_RESPONSE_OK) {
326 if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
328 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
332 /* Remove each header */
333 do_headers_action (win, headers_action_delete, NULL);
335 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
336 gtk_widget_destroy (GTK_WIDGET(win));
343 g_object_unref (header_list);
348 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
350 #ifdef MODEST_PLATFORM_MAEMO
351 modest_osso_save_state();
352 #endif /* MODEST_PLATFORM_MAEMO */
358 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
360 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
361 gtk_widget_destroy (GTK_WIDGET (win));
362 } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
364 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
365 } else if (MODEST_IS_WINDOW (win)) {
366 gtk_widget_destroy (GTK_WIDGET (win));
368 g_return_if_reached ();
373 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
375 GtkClipboard *clipboard = NULL;
376 gchar *selection = NULL;
378 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
379 selection = gtk_clipboard_wait_for_text (clipboard);
381 /* Question: why is the clipboard being used here?
382 * It doesn't really make a lot of sense. */
386 modest_address_book_add_address (selection);
392 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
394 /* This is currently only implemented for Maemo */
395 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
396 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
397 run_account_setup_wizard (win);
400 /* Show the list of accounts: */
401 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
402 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW(win));
403 gtk_dialog_run (account_win);
404 gtk_widget_destroy (GTK_WIDGET(account_win));
407 GtkWidget *dialog, *label;
409 /* Create the widgets */
411 dialog = gtk_dialog_new_with_buttons ("Message",
413 GTK_DIALOG_DESTROY_WITH_PARENT,
417 label = gtk_label_new ("Hello World!");
419 /* Ensure that the dialog box is destroyed when the user responds. */
421 g_signal_connect_swapped (dialog, "response",
422 G_CALLBACK (gtk_widget_destroy),
425 /* Add the label, and show everything we've added to the dialog. */
427 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
429 gtk_widget_show_all (dialog);
430 #endif /* MODEST_PLATFORM_MAEMO */
434 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
436 ModestWindow *main_window = MODEST_WINDOW (user_data);
438 /* Save any changes. */
439 modest_connection_specific_smtp_window_save_server_accounts (
440 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window),
441 modest_window_get_active_account (main_window));
442 gtk_widget_destroy (GTK_WIDGET (window));
448 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
450 /* This is currently only implemented for Maemo,
451 * because it requires an API (libconic) to detect different connection
454 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
456 /* Create the window if necessary: */
457 const gchar *active_account_name = modest_window_get_active_account (win);
459 /* TODO: Dim the menu item (not in the UI spec)? or show a warning,
460 * or show the default account?
461 * If we show the default account then the account name should be shown in
462 * the window when we show it. */
463 if (!active_account_name) {
464 g_warning ("%s: No account is active.", __FUNCTION__);
468 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
469 modest_connection_specific_smtp_window_fill_with_connections (
470 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
471 modest_runtime_get_account_mgr(),
472 active_account_name);
474 /* Show the window: */
475 gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
476 gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
477 gtk_widget_show (specific_window);
479 /* Save changes when the window is hidden: */
480 g_signal_connect (specific_window, "hide",
481 G_CALLBACK (on_smtp_servers_window_hide), win);
482 #endif /* MODEST_PLATFORM_MAEMO */
486 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
488 ModestWindow *msg_win;
490 TnyFolder *folder = NULL;
491 gchar *account_name = NULL;
492 gchar *from_str = NULL;
493 /* GError *err = NULL; */
494 TnyAccount *account = NULL;
495 ModestWindowMgr *mgr;
496 gchar *signature = NULL, *blank_and_signature = NULL;
498 /* if there are no accounts yet, just show the wizard */
499 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
500 run_account_setup_wizard (win);
504 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
506 account_name = g_strdup (modest_window_get_active_account (win));
508 g_printerr ("modest: no account found\n");
512 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
514 TNY_ACCOUNT_TYPE_STORE);
516 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
520 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
522 g_printerr ("modest: failed get from string for '%s'\n", account_name);
526 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
527 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
528 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
529 MODEST_ACCOUNT_SIGNATURE, FALSE);
530 blank_and_signature = g_strconcat ("\n", signature, NULL);
533 blank_and_signature = g_strdup ("");
536 msg = modest_tny_msg_new ("", from_str, "", "", "", blank_and_signature, NULL);
538 g_printerr ("modest: failed to create new msg\n");
542 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
544 g_printerr ("modest: failed to find Drafts folder\n");
549 /* Create and register edit window */
550 /* This is destroyed by TOOD. */
551 msg_win = modest_msg_edit_window_new (msg, account_name);
552 mgr = modest_runtime_get_window_mgr ();
553 modest_window_mgr_register_window (mgr, msg_win);
556 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
558 gtk_widget_show_all (GTK_WIDGET (msg_win));
561 g_free (account_name);
563 g_free (blank_and_signature);
565 g_object_unref (G_OBJECT(account));
567 g_object_unref (G_OBJECT(msg));
569 g_object_unref (G_OBJECT(folder));
573 open_msg_cb (ModestMailOperation *mail_op,
578 ModestWindowMgr *mgr = NULL;
579 ModestWindow *parent_win = NULL;
580 ModestWindow *win = NULL;
581 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
582 gchar *account = NULL;
585 /* TODO: Show an error? (review the specs) */
589 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
590 folder = tny_header_get_folder (header);
592 /* Mark header as read */
593 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
596 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
598 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
600 /* Gets folder type (OUTBOX headers will be opened in edit window */
601 if (modest_tny_folder_is_local_folder (folder))
602 folder_type = modest_tny_folder_get_local_folder_type (folder);
604 /* If the header is in the drafts folder then open the editor,
605 else the message view window */
606 if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
607 /* we cannot edit without a valid account... */
608 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
609 run_account_setup_wizard(parent_win);
612 win = modest_msg_edit_window_new (msg, account);
614 gchar *uid = modest_tny_folder_get_header_unique_id (header);
616 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
617 GtkWidget *header_view;
618 GtkTreeSelection *sel;
619 GList *sel_list = NULL;
622 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
623 MODEST_WIDGET_TYPE_HEADER_VIEW);
625 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
626 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
628 if (sel_list != NULL) {
629 GtkTreeRowReference *row_reference;
631 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
632 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
633 g_list_free (sel_list);
635 win = modest_msg_view_window_new_with_header_model (msg,
640 gtk_tree_row_reference_free (row_reference);
642 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
645 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
650 /* Register and show new window */
652 mgr = modest_runtime_get_window_mgr ();
653 modest_window_mgr_register_window (mgr, win);
654 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
655 gtk_widget_show_all (GTK_WIDGET(win));
661 g_object_unref (parent_win);
662 g_object_unref (msg);
663 g_object_unref (folder);
664 g_object_unref (header);
668 * This function is the error handler of the
669 * modest_mail_operation_get_msgs_full operation
672 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
677 error = modest_mail_operation_get_error (mail_op);
678 if (error->code == MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT) {
679 GObject *win = modest_mail_operation_get_source (mail_op);
681 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
683 g_object_unref (win);
688 * This function is used by both modest_ui_actions_on_open and
689 * modest_ui_actions_on_header_activated. This way we always do the
690 * same when trying to open messages.
693 _modest_ui_actions_open (TnyList *headers, ModestWindow *win)
695 ModestWindowMgr *mgr;
697 ModestMailOperation *mail_op;
698 TnyList *not_opened_headers;
700 /* Look if we already have a message view for each header. If
701 true, then remove the header from the list of headers to
703 mgr = modest_runtime_get_window_mgr ();
704 iter = tny_list_create_iterator (headers);
705 not_opened_headers = tny_simple_list_new ();
706 while (!tny_iterator_is_done (iter)) {
707 ModestWindow *window;
710 header = TNY_HEADER (tny_iterator_get_current (iter));
711 window = modest_window_mgr_find_window_by_header (mgr, header);
712 /* Do not open again the message and present the
713 window to the user */
715 gtk_window_present (GTK_WINDOW (window));
717 tny_list_append (not_opened_headers, G_OBJECT (header));
719 g_object_unref (header);
720 tny_iterator_next (iter);
723 /* Open each message */
724 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
726 modest_ui_actions_get_msgs_full_error_handler,
728 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
729 modest_mail_operation_get_msgs_full (mail_op,
735 g_object_unref (not_opened_headers);
736 g_object_unref (iter);
737 g_object_unref (mail_op);
741 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
746 headers = get_selected_headers (win);
751 _modest_ui_actions_open (headers, win);
753 g_object_unref(headers);
758 free_reply_forward_helper (gpointer data)
760 ReplyForwardHelper *helper;
762 helper = (ReplyForwardHelper *) data;
763 g_free (helper->account_name);
764 g_slice_free (ReplyForwardHelper, helper);
768 reply_forward_cb (ModestMailOperation *mail_op,
774 ReplyForwardHelper *rf_helper;
775 ModestWindow *msg_win;
776 ModestEditType edit_type;
778 TnyAccount *account = NULL;
779 ModestWindowMgr *mgr;
780 gchar *signature = NULL;
782 g_return_if_fail (user_data != NULL);
783 rf_helper = (ReplyForwardHelper *) user_data;
785 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
786 rf_helper->account_name);
787 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
788 rf_helper->account_name,
789 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
790 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
791 rf_helper->account_name,
792 MODEST_ACCOUNT_SIGNATURE, FALSE);
795 /* Create reply mail */
796 switch (rf_helper->action) {
799 modest_tny_msg_create_reply_msg (msg, from, signature,
800 rf_helper->reply_forward_type,
801 MODEST_TNY_MSG_REPLY_MODE_SENDER);
803 case ACTION_REPLY_TO_ALL:
805 modest_tny_msg_create_reply_msg (msg, from, signature, rf_helper->reply_forward_type,
806 MODEST_TNY_MSG_REPLY_MODE_ALL);
807 edit_type = MODEST_EDIT_TYPE_REPLY;
811 modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
812 edit_type = MODEST_EDIT_TYPE_FORWARD;
815 g_return_if_reached ();
822 g_printerr ("modest: failed to create message\n");
826 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
827 rf_helper->account_name,
828 TNY_ACCOUNT_TYPE_STORE);
830 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
834 /* Create and register the windows */
835 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
836 mgr = modest_runtime_get_window_mgr ();
837 modest_window_mgr_register_window (mgr, msg_win);
839 if (rf_helper->parent_window != NULL) {
842 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
843 modest_window_set_zoom (msg_win, parent_zoom);
846 /* Show edit window */
847 gtk_widget_show_all (GTK_WIDGET (msg_win));
851 g_object_unref (G_OBJECT (new_msg));
853 g_object_unref (G_OBJECT (account));
854 g_object_unref (msg);
855 g_object_unref (header);
859 * Checks a list of headers. If any of them are not currently
860 * downloaded (CACHED) then it asks the user for permission to
863 * Returns FALSE if the user does not want to download the
864 * messages. Returns TRUE if the user allowed the download or if all
865 * of them are currently downloaded
868 download_uncached_messages (TnyList *header_list, GtkWindow *win)
871 gboolean found, retval;
873 iter = tny_list_create_iterator (header_list);
875 while (!tny_iterator_is_done (iter) && !found) {
877 TnyHeaderFlags flags;
879 header = TNY_HEADER (tny_iterator_get_current (iter));
880 flags = tny_header_get_flags (header);
881 /* TODO: is this the right flag?, it seems that some
882 headers that have been previously downloaded do not
884 found = !(flags & TNY_HEADER_FLAG_CACHED);
885 g_object_unref (header);
886 tny_iterator_next (iter);
888 g_object_unref (iter);
890 /* Ask for user permission to download the messages */
893 GtkResponseType response;
895 modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
896 _("mcen_nc_get_multi_msg_txt"));
897 if (response == GTK_RESPONSE_CANCEL)
905 * Common code for the reply and forward actions
908 reply_forward (ReplyForwardAction action, ModestWindow *win)
910 ModestMailOperation *mail_op = NULL;
911 TnyList *header_list = NULL;
912 ReplyForwardHelper *rf_helper = NULL;
913 guint reply_forward_type;
914 gboolean continue_download;
916 g_return_if_fail (MODEST_IS_WINDOW(win));
918 /* we need an account when editing */
919 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
920 run_account_setup_wizard (win);
924 header_list = get_selected_headers (win);
928 /* Check that the messages have been previously downloaded */
929 continue_download = download_uncached_messages (header_list, GTK_WINDOW (win));
930 if (!continue_download) {
931 g_object_unref (header_list);
936 modest_conf_get_int (modest_runtime_get_conf (),
937 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
939 /* We assume that we can only select messages of the
940 same folder and that we reply all of them from the
941 same account. In fact the interface currently only
942 allows single selection */
945 rf_helper = g_slice_new0 (ReplyForwardHelper);
946 rf_helper->reply_forward_type = reply_forward_type;
947 rf_helper->action = action;
948 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
949 if ((win != NULL) && (MODEST_IS_WINDOW (win)))
950 rf_helper->parent_window = GTK_WIDGET (win);
951 if (!rf_helper->account_name)
952 rf_helper->account_name =
953 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
955 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
958 /* Get header and message. Do not free them here, the
959 reply_forward_cb must do it */
960 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
961 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
962 if (!msg || !header) {
964 g_object_unref (msg);
966 g_object_unref (header);
967 g_printerr ("modest: no message found\n");
970 reply_forward_cb (NULL, header, msg, rf_helper);
972 /* Retrieve messages */
973 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
975 modest_ui_actions_get_msgs_full_error_handler,
977 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
978 modest_mail_operation_get_msgs_full (mail_op,
982 free_reply_forward_helper);
985 g_object_unref(mail_op);
989 g_object_unref (header_list);
993 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
995 g_return_if_fail (MODEST_IS_WINDOW(win));
997 reply_forward (ACTION_REPLY, win);
1001 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1003 g_return_if_fail (MODEST_IS_WINDOW(win));
1005 reply_forward (ACTION_FORWARD, win);
1009 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1011 g_return_if_fail (MODEST_IS_WINDOW(win));
1013 reply_forward (ACTION_REPLY_TO_ALL, win);
1017 modest_ui_actions_on_next (GtkAction *action,
1018 ModestWindow *window)
1020 if (MODEST_IS_MAIN_WINDOW (window)) {
1021 GtkWidget *header_view;
1023 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1024 MODEST_WIDGET_TYPE_HEADER_VIEW);
1028 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
1029 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1030 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
1032 g_return_if_reached ();
1037 modest_ui_actions_on_prev (GtkAction *action,
1038 ModestWindow *window)
1040 g_return_if_fail (MODEST_IS_WINDOW(window));
1042 if (MODEST_IS_MAIN_WINDOW (window)) {
1043 GtkWidget *header_view;
1044 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1045 MODEST_WIDGET_TYPE_HEADER_VIEW);
1049 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1050 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1051 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1053 g_return_if_reached ();
1058 modest_ui_actions_on_sort (GtkAction *action,
1059 ModestWindow *window)
1061 g_return_if_fail (MODEST_IS_WINDOW(window));
1063 if (MODEST_IS_MAIN_WINDOW (window)) {
1064 GtkWidget *header_view;
1065 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1066 MODEST_WIDGET_TYPE_HEADER_VIEW);
1070 /* Show sorting dialog */
1071 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1076 * This function performs the send & receive required actions. The
1077 * window is used to create the mail operation. Typically it should
1078 * always be the main window, but we pass it as argument in order to
1082 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
1084 gchar *acc_name = NULL;
1085 ModestMailOperation *mail_op;
1087 /* If no account name was provided then get the current account, and if
1088 there is no current account then pick the default one: */
1089 if (!account_name) {
1090 acc_name = g_strdup (modest_window_get_active_account(win));
1092 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1094 g_printerr ("modest: cannot get default account\n");
1098 acc_name = g_strdup (account_name);
1101 /* Set send/receive operation in progress */
1102 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW(win));
1104 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
1105 g_signal_connect (G_OBJECT(mail_op), "progress-changed",
1106 G_CALLBACK (_on_send_receive_progress_changed),
1109 /* Send & receive. */
1110 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
1111 /* Receive and then send. The operation is tagged initially as
1112 a receive operation because the account update performs a
1113 receive and then a send. The operation changes its type
1114 internally, so the progress objects will receive the proper
1115 progress information */
1116 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1117 modest_mail_operation_update_account (mail_op, acc_name);
1118 g_object_unref (G_OBJECT (mail_op));
1125 * Refreshes all accounts. This function will be used by automatic
1129 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1131 GSList *account_names, *iter;
1133 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1136 iter = account_names;
1138 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1139 iter = g_slist_next (iter);
1142 modest_account_mgr_free_account_names (account_names);
1143 account_names = NULL;
1147 * Handler of the click on Send&Receive button in the main toolbar
1150 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1152 /* Check if accounts exist */
1153 gboolean accounts_exist =
1154 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1156 /* If not, allow the user to create an account before trying to send/receive. */
1157 if (!accounts_exist)
1158 modest_ui_actions_on_accounts (NULL, win);
1160 /* Refresh the active account */
1161 modest_ui_actions_do_send_receive (NULL, win);
1166 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1169 GtkWidget *header_view;
1171 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1173 header_view = modest_main_window_get_child_widget (main_window,
1174 MODEST_WIDGET_TYPE_HEADER_VIEW);
1178 conf = modest_runtime_get_conf ();
1180 /* what is saved/restored is depending on the style; thus; we save with
1181 * old style, then update the style, and restore for this new style
1183 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1185 if (modest_header_view_get_style
1186 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1187 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1188 MODEST_HEADER_VIEW_STYLE_TWOLINES);
1190 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1191 MODEST_HEADER_VIEW_STYLE_DETAILS);
1193 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1194 MODEST_CONF_HEADER_VIEW_KEY);
1199 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1201 ModestMainWindow *main_window)
1203 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1204 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
1206 /* If no header has been selected then exit */
1210 /* Update Main window title */
1211 if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
1212 const gchar *subject = tny_header_get_subject (header);
1213 if (subject && strlen(subject) > 0)
1214 gtk_window_set_title (GTK_WINDOW (main_window), subject);
1216 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
1219 /* Update toolbar dimming state */
1220 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1224 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1226 ModestMainWindow *main_window)
1230 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1235 headers = tny_simple_list_new ();
1236 tny_list_prepend (headers, G_OBJECT (header));
1238 _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1240 g_object_unref (headers);
1244 set_active_account_from_tny_account (TnyAccount *account,
1245 ModestWindow *window)
1247 const gchar *server_acc_name = tny_account_get_id (account);
1249 /* We need the TnyAccount provided by the
1250 account store because that is the one that
1251 knows the name of the Modest account */
1252 TnyAccount *modest_server_account = modest_server_account =
1253 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
1254 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1257 const gchar *modest_acc_name =
1258 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1259 modest_window_set_active_account (window, modest_acc_name);
1260 g_object_unref (modest_server_account);
1265 folder_refreshed_cb (const GObject *obj,
1269 /* printf ("DEBUG: %s\n", __FUNCTION__); */
1270 ModestMainWindow *win = NULL;
1271 GtkWidget *header_view;
1273 g_return_if_fail (TNY_IS_FOLDER (folder));
1275 win = MODEST_MAIN_WINDOW (user_data);
1277 modest_main_window_get_child_widget(win, MODEST_WIDGET_TYPE_HEADER_VIEW);
1279 /* Check if folder is empty and set headers view contents style */
1280 if (tny_folder_get_all_count (folder) == 0) {
1281 printf ("DEBUG: %s: tny_folder_get_all_count() returned 0.\n", __FUNCTION__);
1282 modest_main_window_set_contents_style (win,
1283 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
1285 printf ("DEBUG: %s: tny_folder_get_all_count() returned >0.\n", __FUNCTION__);
1290 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1291 TnyFolderStore *folder_store,
1293 ModestMainWindow *main_window)
1296 GtkWidget *header_view;
1298 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1300 header_view = modest_main_window_get_child_widget(main_window,
1301 MODEST_WIDGET_TYPE_HEADER_VIEW);
1305 conf = modest_runtime_get_conf ();
1307 if (TNY_IS_ACCOUNT (folder_store)) {
1309 /* Update active account */
1310 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1311 /* Show account details */
1312 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1315 if (TNY_IS_FOLDER (folder_store) && selected) {
1317 /* Update the active account */
1318 TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
1320 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1321 g_object_unref (account);
1325 /* Set the header style by default, it could
1326 be changed later by the refresh callback to
1328 modest_main_window_set_contents_style (main_window,
1329 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1331 /* Set folder on header view. This function
1332 will call tny_folder_refresh_async so we
1333 pass a callback that will be called when
1334 finished. We use that callback to set the
1335 empty view if there are no messages */
1336 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1337 TNY_FOLDER (folder_store),
1338 folder_refreshed_cb,
1341 /* Restore configuration. We need to do this
1342 *after* the set_folder because the widget
1343 memory asks the header view about its
1345 modest_widget_memory_restore (modest_runtime_get_conf (),
1346 G_OBJECT(header_view),
1347 MODEST_CONF_HEADER_VIEW_KEY);
1349 /* Update the active account */
1350 modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1351 /* Do not show folder */
1352 modest_widget_memory_save (conf, G_OBJECT (header_view), MODEST_CONF_HEADER_VIEW_KEY);
1353 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
1357 /* Update toolbar dimming state */
1358 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1362 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1369 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1371 if (g_main_depth > 0)
1372 gdk_threads_enter ();
1373 online = tny_device_is_online (modest_runtime_get_device());
1376 /* already online -- the item is simply not there... */
1377 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1379 GTK_MESSAGE_WARNING,
1381 _("The %s you selected cannot be found"),
1383 gtk_dialog_run (GTK_DIALOG(dialog));
1385 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1389 GTK_RESPONSE_REJECT,
1391 GTK_RESPONSE_ACCEPT,
1393 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1394 "Do you want to get online?"), item);
1395 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1396 gtk_label_new (txt), FALSE, FALSE, 0);
1397 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1400 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1401 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1402 // modest_platform_connect_and_wait ();
1405 gtk_widget_destroy (dialog);
1406 if (g_main_depth > 0)
1407 gdk_threads_leave ();
1411 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1414 /* g_message ("%s %s", __FUNCTION__, link); */
1419 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1422 modest_platform_activate_uri (link);
1426 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1429 modest_platform_show_uri_popup (link);
1433 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1436 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1440 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1441 const gchar *address,
1444 /* g_message ("%s %s", __FUNCTION__, address); */
1448 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1450 TnyTransportAccount *transport_account;
1451 ModestMailOperation *mail_operation;
1453 gchar *account_name, *from;
1454 ModestAccountMgr *account_mgr;
1456 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1458 data = modest_msg_edit_window_get_msg_data (edit_window);
1460 account_mgr = modest_runtime_get_account_mgr();
1461 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1463 account_name = modest_account_mgr_get_default_account (account_mgr);
1464 if (!account_name) {
1465 g_printerr ("modest: no account found\n");
1466 modest_msg_edit_window_free_msg_data (edit_window, data);
1470 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1471 account_name = g_strdup (data->account_name);
1475 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1476 (modest_runtime_get_account_store(),
1478 TNY_ACCOUNT_TYPE_TRANSPORT));
1479 if (!transport_account) {
1480 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1481 g_free (account_name);
1482 modest_msg_edit_window_free_msg_data (edit_window, data);
1485 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1487 /* Create the mail operation */
1488 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
1489 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1491 modest_mail_operation_save_to_drafts (mail_operation,
1502 data->priority_flags);
1505 g_free (account_name);
1506 g_object_unref (G_OBJECT (transport_account));
1507 g_object_unref (G_OBJECT (mail_operation));
1509 modest_msg_edit_window_free_msg_data (edit_window, data);
1511 /* Save settings and close the window */
1512 gtk_widget_destroy (GTK_WIDGET (edit_window));
1515 /* For instance, when clicking the Send toolbar button when editing a message: */
1517 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1519 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1521 if (!modest_msg_edit_window_check_names (edit_window))
1524 /* FIXME: Code added just for testing. The final version will
1525 use the send queue provided by tinymail and some
1527 ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
1528 gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1530 account_name = modest_account_mgr_get_default_account (account_mgr);
1532 if (!account_name) {
1533 g_printerr ("modest: no account found\n");
1537 MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
1539 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1540 account_name = g_strdup (data->account_name);
1543 /* Get the currently-active transport account for this modest account: */
1544 TnyTransportAccount *transport_account =
1545 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1546 (modest_runtime_get_account_store(),
1548 if (!transport_account) {
1549 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1550 g_free (account_name);
1551 modest_msg_edit_window_free_msg_data (edit_window, data);
1555 gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
1557 /* mail content checks and dialogs */
1558 if (data->subject == NULL || data->subject[0] == '\0') {
1559 GtkResponseType response;
1560 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1561 _("mcen_nc_subject_is_empty_send"));
1562 if (response == GTK_RESPONSE_CANCEL) {
1563 g_free (account_name);
1568 if (data->plain_body == NULL || data->plain_body[0] == '\0') {
1569 GtkResponseType response;
1570 gchar *note_message;
1571 gchar *note_subject = data->subject;
1572 if (note_subject == NULL || note_subject[0] == '\0')
1573 note_subject = _("mail_va_no_subject");
1574 note_message = g_strdup_printf (_("emev_ni_ui_smtp_message_null"), note_subject);
1575 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1577 g_free (note_message);
1578 if (response == GTK_RESPONSE_CANCEL) {
1579 g_free (account_name);
1584 /* Create the mail operation */
1585 ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
1586 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1588 modest_mail_operation_send_new_mail (mail_operation,
1599 data->priority_flags);
1603 g_free (account_name);
1604 g_object_unref (G_OBJECT (transport_account));
1605 g_object_unref (G_OBJECT (mail_operation));
1607 modest_msg_edit_window_free_msg_data (edit_window, data);
1609 /* Save settings and close the window: */
1610 gtk_widget_destroy (GTK_WIDGET (edit_window));
1614 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
1615 ModestMsgEditWindow *window)
1617 ModestMsgEditFormatState *format_state = NULL;
1619 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1620 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1622 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1625 format_state = modest_msg_edit_window_get_format_state (window);
1626 g_return_if_fail (format_state != NULL);
1628 format_state->bold = gtk_toggle_action_get_active (action);
1629 modest_msg_edit_window_set_format_state (window, format_state);
1630 g_free (format_state);
1635 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
1636 ModestMsgEditWindow *window)
1638 ModestMsgEditFormatState *format_state = NULL;
1640 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1641 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1643 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1646 format_state = modest_msg_edit_window_get_format_state (window);
1647 g_return_if_fail (format_state != NULL);
1649 format_state->italics = gtk_toggle_action_get_active (action);
1650 modest_msg_edit_window_set_format_state (window, format_state);
1651 g_free (format_state);
1656 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
1657 ModestMsgEditWindow *window)
1659 ModestMsgEditFormatState *format_state = NULL;
1661 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1662 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1664 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1667 format_state = modest_msg_edit_window_get_format_state (window);
1668 g_return_if_fail (format_state != NULL);
1670 format_state->bullet = gtk_toggle_action_get_active (action);
1671 modest_msg_edit_window_set_format_state (window, format_state);
1672 g_free (format_state);
1677 modest_ui_actions_on_change_justify (GtkRadioAction *action,
1678 GtkRadioAction *selected,
1679 ModestMsgEditWindow *window)
1681 ModestMsgEditFormatState *format_state = NULL;
1682 GtkJustification value;
1684 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1686 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1689 value = gtk_radio_action_get_current_value (selected);
1691 format_state = modest_msg_edit_window_get_format_state (window);
1692 g_return_if_fail (format_state != NULL);
1694 format_state->justification = value;
1695 modest_msg_edit_window_set_format_state (window, format_state);
1696 g_free (format_state);
1700 modest_ui_actions_on_select_editor_color (GtkAction *action,
1701 ModestMsgEditWindow *window)
1703 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1704 g_return_if_fail (GTK_IS_ACTION (action));
1706 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1709 modest_msg_edit_window_select_color (window);
1713 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
1714 ModestMsgEditWindow *window)
1716 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1717 g_return_if_fail (GTK_IS_ACTION (action));
1719 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1722 modest_msg_edit_window_select_background_color (window);
1726 modest_ui_actions_on_insert_image (GtkAction *action,
1727 ModestMsgEditWindow *window)
1729 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1730 g_return_if_fail (GTK_IS_ACTION (action));
1732 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1735 modest_msg_edit_window_insert_image (window);
1739 modest_ui_actions_on_attach_file (GtkAction *action,
1740 ModestMsgEditWindow *window)
1742 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1743 g_return_if_fail (GTK_IS_ACTION (action));
1745 modest_msg_edit_window_attach_file (window);
1749 modest_ui_actions_on_remove_attachments (GtkAction *action,
1750 ModestMsgEditWindow *window)
1752 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1753 g_return_if_fail (GTK_IS_ACTION (action));
1755 modest_msg_edit_window_remove_attachments (window, NULL);
1759 * Shows a dialog with an entry that asks for some text. The returned
1760 * value must be freed by the caller. The dialog window title will be
1764 ask_for_folder_name (GtkWindow *parent_window,
1767 GtkWidget *dialog, *entry;
1768 gchar *folder_name = NULL;
1770 /* Ask for folder name */
1771 dialog = gtk_dialog_new_with_buttons (_("New Folder Name"),
1775 GTK_RESPONSE_REJECT,
1777 GTK_RESPONSE_ACCEPT,
1779 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1780 gtk_label_new(title),
1783 entry = gtk_entry_new_with_max_length (40);
1784 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1788 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1790 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
1791 folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
1793 gtk_widget_destroy (dialog);
1799 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
1801 TnyFolderStore *parent_folder;
1802 GtkWidget *folder_view;
1804 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1806 folder_view = modest_main_window_get_child_widget (main_window,
1807 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1811 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1813 if (parent_folder) {
1814 gboolean finished = FALSE;
1816 gchar *folder_name = NULL, *suggested_name = NULL;
1818 /* Run the new folder dialog */
1820 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (main_window),
1825 if (result == GTK_RESPONSE_REJECT) {
1828 ModestMailOperation *mail_op;
1829 TnyFolder *new_folder = NULL;
1831 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO,
1832 G_OBJECT(main_window));
1833 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1835 new_folder = modest_mail_operation_create_folder (mail_op,
1837 (const gchar *) folder_name);
1839 g_object_unref (new_folder);
1842 g_object_unref (mail_op);
1844 g_free (folder_name);
1848 g_object_unref (parent_folder);
1853 modest_ui_actions_on_rename_folder (GtkAction *action,
1854 ModestMainWindow *main_window)
1856 TnyFolderStore *folder;
1857 GtkWidget *folder_view;
1858 GtkWidget *header_view;
1860 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1862 folder_view = modest_main_window_get_child_widget (main_window,
1863 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1867 header_view = modest_main_window_get_child_widget (main_window,
1868 MODEST_WIDGET_TYPE_HEADER_VIEW);
1873 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1875 if (folder && TNY_IS_FOLDER (folder)) {
1877 folder_name = ask_for_folder_name (GTK_WINDOW (main_window),
1878 _("Please enter a new name for the folder"));
1880 if (folder_name != NULL && strlen (folder_name) > 0) {
1881 ModestMailOperation *mail_op;
1883 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(main_window));
1884 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1887 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
1889 modest_mail_operation_rename_folder (mail_op,
1890 TNY_FOLDER (folder),
1891 (const gchar *) folder_name);
1893 g_object_unref (mail_op);
1894 g_free (folder_name);
1896 g_object_unref (folder);
1901 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
1904 GObject *win = modest_mail_operation_get_source (mail_op);
1906 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
1907 _("mail_in_ui_folder_delete_error"));
1908 g_object_unref (win);
1912 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
1914 TnyFolderStore *folder;
1915 GtkWidget *folder_view;
1919 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1921 folder_view = modest_main_window_get_child_widget (main_window,
1922 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1926 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1928 /* Show an error if it's an account */
1929 if (!TNY_IS_FOLDER (folder)) {
1930 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
1931 _("mail_in_ui_folder_delete_error"));
1936 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
1937 tny_folder_get_name (TNY_FOLDER (folder)));
1938 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
1939 (const gchar *) message);
1942 if (response == GTK_RESPONSE_OK) {
1943 ModestMailOperation *mail_op =
1944 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_DELETE,
1945 G_OBJECT(main_window),
1946 modest_ui_actions_delete_folder_error_handler,
1949 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1951 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
1952 g_object_unref (G_OBJECT (mail_op));
1955 g_object_unref (G_OBJECT (folder));
1959 modest_ui_actions_on_delete_folder (GtkAction *action,
1960 ModestMainWindow *main_window)
1962 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1964 delete_folder (main_window, FALSE);
1968 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
1970 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1972 delete_folder (main_window, TRUE);
1976 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
1977 const gchar* server_account_name,
1982 ModestMainWindow *main_window)
1984 g_return_if_fail(server_account_name);
1985 /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
1987 /* Initalize output parameters: */
1994 #ifdef MODEST_PLATFORM_MAEMO
1995 /* Maemo uses a different (awkward) button order,
1996 * It should probably just use gtk_alternative_dialog_button_order ().
1998 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2002 GTK_RESPONSE_ACCEPT,
2004 GTK_RESPONSE_REJECT,
2007 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2011 GTK_RESPONSE_REJECT,
2013 GTK_RESPONSE_ACCEPT,
2015 #endif /* MODEST_PLATFORM_MAEMO */
2017 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
2019 gchar *server_name = modest_server_account_get_hostname (
2020 modest_runtime_get_account_mgr(), server_account_name);
2021 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
2022 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
2027 /* This causes a warning because the logical ID has no %s in it,
2028 * though the translation does, but there is not much we can do about that: */
2029 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
2030 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
2033 g_free (server_name);
2037 gchar *initial_username = modest_server_account_get_username (
2038 modest_runtime_get_account_mgr(), server_account_name);
2040 GtkWidget *entry_username = gtk_entry_new ();
2041 if (initial_username)
2042 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
2043 /* Dim this if a connection has ever succeeded with this username,
2044 * as per the UI spec: */
2045 const gboolean username_known =
2046 modest_server_account_get_username_has_succeeded(
2047 modest_runtime_get_account_mgr(), server_account_name);
2048 gtk_widget_set_sensitive (entry_username, !username_known);
2050 #ifdef MODEST_PLATFORM_MAEMO
2051 /* Auto-capitalization is the default, so let's turn it off: */
2052 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
2054 /* Create a size group to be used by all captions.
2055 * Note that HildonCaption does not create a default size group if we do not specify one.
2056 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
2057 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2059 GtkWidget *caption = hildon_caption_new (sizegroup,
2060 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
2061 gtk_widget_show (entry_username);
2062 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2063 FALSE, FALSE, MODEST_MARGIN_HALF);
2064 gtk_widget_show (caption);
2066 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
2068 #endif /* MODEST_PLATFORM_MAEMO */
2071 GtkWidget *entry_password = gtk_entry_new ();
2072 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
2073 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
2075 #ifdef MODEST_PLATFORM_MAEMO
2076 /* Auto-capitalization is the default, so let's turn it off: */
2077 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
2078 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
2080 caption = hildon_caption_new (sizegroup,
2081 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
2082 gtk_widget_show (entry_password);
2083 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2084 FALSE, FALSE, MODEST_MARGIN_HALF);
2085 gtk_widget_show (caption);
2086 g_object_unref (sizegroup);
2088 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
2090 #endif /* MODEST_PLATFORM_MAEMO */
2092 /* This is not in the Maemo UI spec:
2093 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
2094 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
2098 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2100 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2102 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
2104 modest_server_account_set_username (
2105 modest_runtime_get_account_mgr(), server_account_name,
2108 const gboolean username_was_changed =
2109 (strcmp (*username, initial_username) != 0);
2110 if (username_was_changed) {
2111 /* To actually use a changed username,
2112 * we must reset the connection, according to pvanhoof.
2113 * This _might_ be a sensible way to do that: */
2114 TnyDevice *device = modest_runtime_get_device();
2115 tny_device_force_offline (device);
2116 tny_device_force_online (device);
2121 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
2123 /* We do not save the password in the configuration,
2124 * because this function is only called for passwords that should
2125 * not be remembered:
2126 modest_server_account_set_password (
2127 modest_runtime_get_account_mgr(), server_account_name,
2146 /* This is not in the Maemo UI spec:
2147 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
2153 gtk_widget_destroy (dialog);
2155 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
2159 modest_ui_actions_on_cut (GtkAction *action,
2160 ModestWindow *window)
2162 GtkWidget *focused_widget;
2164 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2165 if (GTK_IS_EDITABLE (focused_widget)) {
2166 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
2167 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2168 GtkTextBuffer *buffer;
2169 GtkClipboard *clipboard;
2171 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2172 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2173 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
2174 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2175 modest_header_view_cut_selection (MODEST_HEADER_VIEW (focused_widget));
2176 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2177 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
2182 modest_ui_actions_on_copy (GtkAction *action,
2183 ModestWindow *window)
2185 GtkClipboard *clipboard;
2186 GtkWidget *focused_widget;
2188 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2189 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2191 if (GTK_IS_LABEL (focused_widget)) {
2192 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
2193 } else if (GTK_IS_EDITABLE (focused_widget)) {
2194 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
2195 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2196 GtkTextBuffer *buffer;
2197 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2198 gtk_text_buffer_copy_clipboard (buffer, clipboard);
2199 modest_header_view_copy_selection (MODEST_HEADER_VIEW (focused_widget));
2200 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2201 TnyList *header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (focused_widget));
2202 TnyIterator *iter = tny_list_create_iterator (header_list);
2203 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
2204 TnyFolder *folder = tny_header_get_folder (header);
2205 TnyAccount *account = tny_folder_get_account (folder);
2206 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2207 /* If it's POP then ask */
2208 gboolean ask = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2209 MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
2210 g_object_unref (account);
2211 g_object_unref (folder);
2212 g_object_unref (header);
2213 g_object_unref (iter);
2215 /* Check that the messages have been previously downloaded */
2216 gboolean continue_download = TRUE;
2218 continue_download = download_uncached_messages (header_list, GTK_WINDOW (window));
2219 if (continue_download)
2220 modest_header_view_copy_selection (MODEST_HEADER_VIEW (focused_widget));
2221 g_object_unref (header_list);
2222 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2223 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
2228 modest_ui_actions_on_undo (GtkAction *action,
2229 ModestWindow *window)
2231 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2232 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2234 g_return_if_reached ();
2239 modest_ui_actions_on_paste (GtkAction *action,
2240 ModestWindow *window)
2242 GtkWidget *focused_widget;
2243 ModestMailOperation *mail_op = NULL;
2245 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2246 if (GTK_IS_EDITABLE (focused_widget)) {
2247 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
2248 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2249 GtkTextBuffer *buffer;
2250 GtkClipboard *clipboard;
2252 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2253 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2254 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
2255 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2256 ModestEmailClipboard *clipboard = NULL;
2257 TnyFolder *src_folder = NULL;
2258 TnyFolderStore *folder_store = NULL;
2259 TnyList *data = NULL;
2260 gboolean delete = FALSE;
2262 /* Check clipboard source */
2263 clipboard = modest_runtime_get_email_clipboard ();
2264 if (modest_email_clipboard_cleared (clipboard))
2267 /* Get elements to paste */
2268 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
2270 /* Create a new mail operation */
2271 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
2272 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2275 /* Get destination folder */
2276 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
2278 /* transfer messages */
2280 modest_mail_operation_xfer_msgs (mail_op,
2282 TNY_FOLDER (folder_store),
2287 } else if (src_folder != NULL) {
2288 modest_mail_operation_xfer_folder (mail_op,
2296 g_object_unref (data);
2297 if (src_folder != NULL)
2298 g_object_unref (src_folder);
2299 if (folder_store != NULL)
2300 g_object_unref (folder_store);
2305 modest_ui_actions_on_select_all (GtkAction *action,
2306 ModestWindow *window)
2308 GtkWidget *focused_widget;
2310 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2311 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
2312 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
2313 } else if (GTK_IS_LABEL (focused_widget)) {
2314 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
2315 } else if (GTK_IS_EDITABLE (focused_widget)) {
2316 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
2317 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2318 GtkTextBuffer *buffer;
2319 GtkTextIter start, end;
2321 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2322 gtk_text_buffer_get_start_iter (buffer, &start);
2323 gtk_text_buffer_get_end_iter (buffer, &end);
2324 gtk_text_buffer_select_range (buffer, &start, &end);
2326 else if ((MODEST_IS_FOLDER_VIEW (focused_widget)) ||
2327 (MODEST_IS_HEADER_VIEW (focused_widget))) {
2329 GtkTreeSelection *selection = NULL;
2331 /* Get header view */
2332 GtkWidget *header_view = focused_widget;
2333 if (MODEST_IS_FOLDER_VIEW (focused_widget))
2334 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
2335 MODEST_WIDGET_TYPE_HEADER_VIEW);
2337 /* Select all messages */
2338 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
2339 gtk_tree_selection_select_all (selection);
2341 /* Set focuse on header view */
2342 gtk_widget_grab_focus (header_view);
2344 } else if (GTK_IS_HTML (focused_widget)) {
2345 gtk_html_select_all (GTK_HTML (focused_widget));
2350 modest_ui_actions_on_mark_as_read (GtkAction *action,
2351 ModestWindow *window)
2353 g_return_if_fail (MODEST_IS_WINDOW(window));
2355 /* Mark each header as read */
2356 do_headers_action (window, headers_action_mark_as_read, NULL);
2360 modest_ui_actions_on_mark_as_unread (GtkAction *action,
2361 ModestWindow *window)
2363 g_return_if_fail (MODEST_IS_WINDOW(window));
2365 /* Mark each header as read */
2366 do_headers_action (window, headers_action_mark_as_unread, NULL);
2370 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
2371 GtkRadioAction *selected,
2372 ModestWindow *window)
2376 value = gtk_radio_action_get_current_value (selected);
2377 if (MODEST_IS_WINDOW (window)) {
2378 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
2382 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
2383 GtkRadioAction *selected,
2384 ModestWindow *window)
2386 TnyHeaderFlags flags;
2387 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2389 flags = gtk_radio_action_get_current_value (selected);
2390 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
2393 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
2394 GtkRadioAction *selected,
2395 ModestWindow *window)
2399 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2401 file_format = gtk_radio_action_get_current_value (selected);
2402 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
2407 modest_ui_actions_on_zoom_plus (GtkAction *action,
2408 ModestWindow *window)
2410 g_return_if_fail (MODEST_IS_WINDOW (window));
2412 modest_window_zoom_plus (MODEST_WINDOW (window));
2416 modest_ui_actions_on_zoom_minus (GtkAction *action,
2417 ModestWindow *window)
2419 g_return_if_fail (MODEST_IS_WINDOW (window));
2421 modest_window_zoom_minus (MODEST_WINDOW (window));
2425 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
2426 ModestWindow *window)
2428 ModestWindowMgr *mgr;
2429 gboolean fullscreen, active;
2430 g_return_if_fail (MODEST_IS_WINDOW (window));
2432 mgr = modest_runtime_get_window_mgr ();
2434 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
2435 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2437 if (active != fullscreen) {
2438 modest_window_mgr_set_fullscreen_mode (mgr, active);
2439 gtk_window_present (GTK_WINDOW (window));
2444 modest_ui_actions_on_change_fullscreen (GtkAction *action,
2445 ModestWindow *window)
2447 ModestWindowMgr *mgr;
2448 gboolean fullscreen;
2450 g_return_if_fail (MODEST_IS_WINDOW (window));
2452 mgr = modest_runtime_get_window_mgr ();
2453 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2454 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
2456 gtk_window_present (GTK_WINDOW (window));
2460 * Used by modest_ui_actions_on_details to call do_headers_action
2463 headers_action_show_details (TnyHeader *header,
2464 ModestWindow *window,
2471 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
2474 gtk_widget_show_all (dialog);
2475 gtk_dialog_run (GTK_DIALOG (dialog));
2477 gtk_widget_destroy (dialog);
2481 * Show the folder details in a ModestDetailsDialog widget
2484 show_folder_details (TnyFolder *folder,
2490 dialog = modest_details_dialog_new_with_folder (window, folder);
2493 gtk_widget_show_all (dialog);
2494 gtk_dialog_run (GTK_DIALOG (dialog));
2496 gtk_widget_destroy (dialog);
2500 * Show the header details in a ModestDetailsDialog widget
2503 modest_ui_actions_on_details (GtkAction *action,
2506 TnyList * headers_list;
2510 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2513 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2516 g_object_unref (msg);
2518 headers_list = get_selected_headers (win);
2522 iter = tny_list_create_iterator (headers_list);
2524 header = TNY_HEADER (tny_iterator_get_current (iter));
2525 headers_action_show_details (header, win, NULL);
2526 g_object_unref (header);
2528 g_object_unref (iter);
2529 g_object_unref (headers_list);
2531 } else if (MODEST_IS_MAIN_WINDOW (win)) {
2532 GtkWidget *folder_view, *header_view;
2534 /* Check which widget has the focus */
2535 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2536 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2537 if (gtk_widget_is_focus (folder_view)) {
2540 folder = (TnyFolder *) modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2542 /* Show only when it's a folder */
2543 if (!folder || !TNY_IS_FOLDER (folder))
2546 show_folder_details (folder, GTK_WINDOW (win));
2547 g_object_unref (folder);
2550 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2551 MODEST_WIDGET_TYPE_HEADER_VIEW);
2552 /* Show details of each header */
2553 do_headers_action (win, headers_action_show_details, header_view);
2559 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
2560 ModestMsgEditWindow *window)
2562 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2564 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
2568 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
2569 ModestMsgEditWindow *window)
2571 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2573 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
2577 modest_ui_actions_toggle_folders_view (GtkAction *action,
2578 ModestMainWindow *main_window)
2582 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2584 conf = modest_runtime_get_conf ();
2586 if (modest_main_window_get_style (main_window) == MODEST_MAIN_WINDOW_STYLE_SPLIT)
2587 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
2589 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
2593 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
2594 ModestWindow *window)
2596 gboolean active, fullscreen = FALSE;
2597 ModestWindowMgr *mgr;
2599 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
2601 /* Check if we want to toggle the toolbar vuew in fullscreen
2603 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
2604 "ViewShowToolbarFullScreen")) {
2608 /* Toggle toolbar */
2609 mgr = modest_runtime_get_window_mgr ();
2610 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
2614 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
2615 ModestMsgEditWindow *window)
2617 modest_msg_edit_window_select_font (window);
2621 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
2622 const gchar *display_name,
2625 /* Do not change the application name if the widget has not
2626 the focus. This callback could be called even if the folder
2627 view has not the focus, because the handled signal could be
2628 emitted when the folder view is redrawn */
2629 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
2631 gtk_window_set_title (window, display_name);
2633 gtk_window_set_title (window, " ");
2638 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
2640 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2641 modest_msg_edit_window_select_contacts (window);
2645 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
2647 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2648 modest_msg_edit_window_check_names (window);
2653 create_move_to_dialog (ModestWindow *win,
2654 GtkWidget *folder_view,
2655 GtkWidget **tree_view)
2657 GtkWidget *dialog, *scroll;
2659 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
2661 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
2663 GTK_RESPONSE_ACCEPT,
2665 GTK_RESPONSE_REJECT,
2668 /* Create scrolled window */
2669 scroll = gtk_scrolled_window_new (NULL, NULL);
2670 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
2671 GTK_POLICY_AUTOMATIC,
2672 GTK_POLICY_AUTOMATIC);
2674 /* Create folder view */
2675 *tree_view = modest_platform_create_folder_view (NULL);
2677 /* It could happen that we're trying to move a message from a
2678 window (msg window for example) after the main window was
2679 closed, so we can not just get the model of the folder
2681 if (MODEST_IS_FOLDER_VIEW (folder_view))
2682 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
2683 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
2685 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
2686 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
2688 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
2690 /* Add scroll to dialog */
2691 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
2692 scroll, FALSE, FALSE, 0);
2694 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2696 /* Select INBOX or local account */
2697 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (*tree_view));
2703 * Returns TRUE if at least one of the headers of the list belongs to
2704 * a message that has been fully retrieved.
2707 has_retrieved_msgs (TnyList *list)
2710 gboolean found = FALSE;
2712 iter = tny_list_create_iterator (list);
2713 while (tny_iterator_is_done (iter) && !found) {
2715 TnyHeaderFlags flags;
2717 header = TNY_HEADER (tny_iterator_get_current (iter));
2718 flags = tny_header_get_flags (header);
2719 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
2723 tny_iterator_next (iter);
2725 g_object_unref (iter);
2731 * Shows a confirmation dialog to the user when we're moving messages
2732 * from a remote server to the local storage. Returns the dialog
2733 * response. If it's other kind of movement the it always returns
2737 msgs_move_to_confirmation (GtkWindow *win,
2738 TnyFolder *dest_folder,
2741 gint response = GTK_RESPONSE_OK;
2743 /* If the destination is a local folder */
2744 if (modest_tny_folder_is_local_folder (dest_folder)) {
2745 TnyFolder *src_folder;
2749 /* Get source folder */
2750 iter = tny_list_create_iterator (headers);
2751 header = TNY_HEADER (tny_iterator_get_current (iter));
2752 src_folder = tny_header_get_folder (header);
2753 g_object_unref (header);
2754 g_object_unref (iter);
2756 /* If the source is a remote folder */
2757 if (!modest_tny_folder_is_local_folder (src_folder)) {
2758 const gchar *message;
2760 if (has_retrieved_msgs (headers))
2761 message = ngettext ("mcen_nc_move_retrieve", "mcen_nc_move_retrieves",
2762 tny_list_get_length (headers));
2764 message = ngettext ("mcen_nc_move_header", "mcen_nc_move_headers",
2765 tny_list_get_length (headers));
2767 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2768 (const gchar *) message);
2770 g_object_unref (src_folder);
2777 transfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
2779 ModestMsgViewWindow *self = NULL;
2781 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
2782 self = MODEST_MSG_VIEW_WINDOW (object);
2784 /* If there are not more messages don't do anything. The
2785 viewer will show the same message */
2786 if (!modest_msg_view_window_select_first_message (self))
2791 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
2794 GObject *win = modest_mail_operation_get_source (mail_op);
2796 /* TODO: show error message */
2797 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2798 _("mail_in_ui_folder_move_target_error"));
2799 g_object_unref (win);
2803 * UI handler for the "Move to" action when invoked from the
2807 modest_ui_actions_on_main_window_move_to (GtkAction *action,
2808 ModestMainWindow *win)
2810 GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
2811 GtkWidget *header_view = NULL;
2813 TnyFolderStore *folder_store = NULL;
2814 ModestMailOperation *mail_op = NULL;
2816 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
2818 /* Get the folder view */
2819 folder_view = modest_main_window_get_child_widget (win,
2820 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2822 /* Get header view */
2823 header_view = modest_main_window_get_child_widget (win,
2824 MODEST_WIDGET_TYPE_HEADER_VIEW);
2826 /* Create and run the dialog */
2827 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2828 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
2829 result = gtk_dialog_run (GTK_DIALOG(dialog));
2830 g_object_ref (tree_view);
2832 /* We do this to save an indentation level ;-) */
2833 if (result != GTK_RESPONSE_ACCEPT)
2836 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2838 if (TNY_IS_ACCOUNT (folder_store))
2841 /* Get folder or messages to transfer */
2842 if (gtk_widget_is_focus (folder_view)) {
2843 TnyFolderStore *src_folder;
2844 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2846 /* Clean folder on header view before moving it */
2847 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
2849 if (TNY_IS_FOLDER (src_folder)) {
2851 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
2853 modest_ui_actions_move_folder_error_handler,
2855 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
2857 modest_mail_operation_xfer_folder (mail_op,
2858 TNY_FOLDER (src_folder),
2861 /* Unref mail operation */
2862 g_object_unref (G_OBJECT (mail_op));
2866 g_object_unref (G_OBJECT (src_folder));
2868 if (gtk_widget_is_focus (header_view)) {
2872 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
2874 /* Ask for user confirmation */
2875 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2876 TNY_FOLDER (folder_store),
2879 /* Transfer messages */
2880 if (response == GTK_RESPONSE_OK) {
2881 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
2882 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2885 modest_mail_operation_xfer_msgs (mail_op,
2887 TNY_FOLDER (folder_store),
2892 g_object_unref (G_OBJECT (mail_op));
2894 g_object_unref (headers);
2897 g_object_unref (folder_store);
2899 gtk_widget_destroy (dialog);
2904 * UI handler for the "Move to" action when invoked from the
2905 * ModestMsgViewWindow
2908 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
2909 ModestMsgViewWindow *win)
2911 GtkWidget *dialog, *folder_view, *tree_view = NULL;
2913 ModestMainWindow *main_window;
2917 /* Get the folder view */
2918 main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
2920 folder_view = modest_main_window_get_child_widget (main_window,
2921 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2925 /* Create and run the dialog */
2926 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2927 result = gtk_dialog_run (GTK_DIALOG(dialog));
2928 g_object_ref (tree_view);
2930 if (result == GTK_RESPONSE_ACCEPT) {
2931 TnyFolderStore *folder_store;
2934 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2936 /* Create header list */
2937 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
2938 headers = tny_simple_list_new ();
2939 tny_list_prepend (headers, G_OBJECT (header));
2940 g_object_unref (header);
2942 /* Ask user for confirmation. MSG-NOT404 */
2943 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2944 TNY_FOLDER (folder_store),
2947 /* Transfer current msg */
2948 if (response == GTK_RESPONSE_OK) {
2949 ModestMailOperation *mail_op;
2951 /* Create mail op */
2952 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
2953 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2956 /* Transfer messages */
2957 modest_mail_operation_xfer_msgs (mail_op,
2959 TNY_FOLDER (folder_store),
2961 transfer_msgs_from_viewer_cb,
2963 g_object_unref (G_OBJECT (mail_op));
2965 g_object_unref (headers);
2966 g_object_unref (folder_store);
2968 gtk_widget_destroy (dialog);
2972 modest_ui_actions_on_move_to (GtkAction *action,
2975 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
2976 MODEST_IS_MSG_VIEW_WINDOW (win));
2978 if (MODEST_IS_MAIN_WINDOW (win))
2979 modest_ui_actions_on_main_window_move_to (action,
2980 MODEST_MAIN_WINDOW (win));
2982 modest_ui_actions_on_msg_view_window_move_to (action,
2983 MODEST_MSG_VIEW_WINDOW (win));
2987 * Calls #HeadersFunc for each header already selected in the main
2988 * window or the message currently being shown in the msg view window
2991 do_headers_action (ModestWindow *win,
2995 TnyList *headers_list;
3001 headers_list = get_selected_headers (win);
3005 /* Get the folder */
3006 iter = tny_list_create_iterator (headers_list);
3007 header = TNY_HEADER (tny_iterator_get_current (iter));
3008 folder = tny_header_get_folder (header);
3009 g_object_unref (header);
3011 /* Call the function for each header */
3012 while (!tny_iterator_is_done (iter)) {
3013 header = TNY_HEADER (tny_iterator_get_current (iter));
3014 func (header, win, user_data);
3015 g_object_unref (header);
3016 tny_iterator_next (iter);
3019 /* Trick: do a poke status in order to speed up the signaling
3021 tny_folder_poke_status (folder);
3024 g_object_unref (folder);
3025 g_object_unref (iter);
3026 g_object_unref (headers_list);
3030 modest_ui_actions_view_attachment (GtkAction *action,
3031 ModestWindow *window)
3033 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3034 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
3036 /* not supported window for this action */
3037 g_return_if_reached ();
3042 modest_ui_actions_save_attachments (GtkAction *action,
3043 ModestWindow *window)
3045 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3046 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
3048 /* not supported window for this action */
3049 g_return_if_reached ();
3054 modest_ui_actions_remove_attachments (GtkAction *action,
3055 ModestWindow *window)
3057 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3058 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
3060 /* not supported window for this action */
3061 g_return_if_reached ();
3066 modest_ui_actions_on_settings (GtkAction *action,
3071 dialog = modest_platform_get_global_settings_dialog ();
3072 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
3073 gtk_widget_show (dialog);
3075 gtk_dialog_run (GTK_DIALOG (dialog));
3077 gtk_widget_destroy (dialog);
3081 modest_ui_actions_on_help (GtkAction *action,
3084 const gchar *help_id = NULL;
3086 if (MODEST_IS_MAIN_WINDOW (win)) {
3087 const gchar *action_name;
3088 action_name = gtk_action_get_name (action);
3090 if (!strcmp (action_name, "FolderViewCSMHelp") ||
3091 !strcmp (action_name, "HeaderViewCSMHelp")) {
3092 GtkWidget *folder_view;
3093 TnyFolderStore *folder_store;
3094 /* Get selected folder */
3095 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3096 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3097 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3099 /* Switch help_id */
3100 if (TNY_IS_FOLDER (folder_store)) {
3101 switch (tny_folder_get_folder_type (TNY_FOLDER (folder_store))) {
3102 case TNY_FOLDER_TYPE_NORMAL:
3103 help_id = "applications_email_userfolder";
3105 case TNY_FOLDER_TYPE_INBOX:
3106 help_id = "applications_email_inbox";
3108 case TNY_FOLDER_TYPE_OUTBOX:
3109 help_id = "applications_email_outbox";
3111 case TNY_FOLDER_TYPE_SENT:
3112 help_id = "applications_email_sent";
3114 case TNY_FOLDER_TYPE_DRAFTS:
3115 help_id = "applications_email_drafts";
3117 case TNY_FOLDER_TYPE_ARCHIVE:
3118 help_id = "applications_email_archive";
3124 g_object_unref (folder_store);
3126 help_id = "applications_email_mainview";
3128 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3129 help_id = "applications_email_viewer";
3130 } else if (MODEST_IS_MSG_EDIT_WINDOW (win))
3131 help_id = "applications_email_editor";
3133 modest_platform_show_help (GTK_WINDOW (win), help_id);
3137 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
3138 ModestWindow *window)
3140 ModestMailOperation *mail_op;
3144 headers = get_selected_headers (window);
3148 /* Create mail operation */
3149 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3151 modest_ui_actions_get_msgs_full_error_handler,
3153 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3154 modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
3157 g_object_unref (headers);
3158 g_object_unref (mail_op);
3162 modest_ui_actions_on_email_menu_activated (GtkAction *action,
3163 ModestWindow *window)
3165 g_return_if_fail (MODEST_IS_WINDOW (window));
3168 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3172 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
3173 ModestWindow *window)
3175 g_return_if_fail (MODEST_IS_WINDOW (window));
3178 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3182 modest_ui_actions_on_view_menu_activated (GtkAction *action,
3183 ModestWindow *window)
3185 g_return_if_fail (MODEST_IS_WINDOW (window));
3188 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3192 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
3193 ModestWindow *window)
3195 g_return_if_fail (MODEST_IS_WINDOW (window));
3198 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3202 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
3203 ModestWindow *window)
3205 g_return_if_fail (MODEST_IS_WINDOW (window));
3208 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3212 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
3213 ModestWindow *window)
3215 g_return_if_fail (MODEST_IS_WINDOW (window));
3218 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3222 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
3223 ModestWindow *window)
3225 g_return_if_fail (MODEST_IS_WINDOW (window));
3228 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3232 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
3233 ModestWindow *window)
3235 g_return_if_fail (MODEST_IS_WINDOW (window));
3238 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3242 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
3244 g_return_if_fail (MODEST_IS_WINDOW (window));
3247 modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
3251 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
3253 g_return_if_fail (MODEST_IS_WINDOW (window));
3255 modest_platform_show_search_messages (GTK_WINDOW (window));
3259 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
3261 g_return_if_fail (MODEST_IS_WINDOW (win));
3262 modest_platform_show_addressbook (GTK_WINDOW (win));
3267 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
3268 ModestWindow *window)
3270 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3272 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
3276 _on_send_receive_progress_changed (ModestMailOperation *mail_op,
3277 ModestMailOperationState *state,
3280 g_return_if_fail (MODEST_IS_MAIN_WINDOW(user_data));
3282 /* Set send/receive operation finished */
3283 if (state->status != MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
3284 modest_main_window_notify_send_receive_completed (MODEST_MAIN_WINDOW(user_data));