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 #include "maemo/modest-hildon-includes.h"
53 #endif /* MODEST_PLATFORM_MAEMO */
55 #include "widgets/modest-ui-constants.h"
56 #include <widgets/modest-main-window.h>
57 #include <widgets/modest-msg-view-window.h>
58 #include <widgets/modest-account-view-window.h>
59 #include <widgets/modest-details-dialog.h>
60 #include <widgets/modest-attachments-view.h>
61 #include "widgets/modest-folder-view.h"
62 #include "widgets/modest-global-settings-dialog.h"
63 #include "modest-connection-specific-smtp-window.h"
64 #include "modest-account-mgr-helpers.h"
65 #include "modest-mail-operation.h"
66 #include "modest-text-utils.h"
68 #ifdef MODEST_HAVE_EASYSETUP
69 #include "easysetup/modest-easysetup-wizard.h"
70 #endif /* MODEST_HAVE_EASYSETUP */
72 #include <modest-widget-memory.h>
73 #include <tny-error.h>
74 #include <tny-simple-list.h>
75 #include <tny-msg-view.h>
76 #include <tny-device.h>
77 #include <tny-merge-folder.h>
79 #include <gtkhtml/gtkhtml.h>
81 typedef struct _GetMsgAsyncHelper {
83 ModestMailOperation *mail_op;
90 typedef enum _ReplyForwardAction {
96 typedef struct _ReplyForwardHelper {
97 guint reply_forward_type;
98 ReplyForwardAction action;
100 GtkWidget *parent_window;
101 } ReplyForwardHelper;
105 * The do_headers_action uses this kind of functions to perform some
106 * action to each member of a list of headers
108 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
110 static void do_headers_action (ModestWindow *win,
114 static void open_msg_cb (ModestMailOperation *mail_op,
119 static void reply_forward_cb (ModestMailOperation *mail_op,
124 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
126 static void folder_refreshed_cb (ModestMailOperation *mail_op,
130 static void _on_send_receive_progress_changed (ModestMailOperation *mail_op,
131 ModestMailOperationState *state,
137 run_account_setup_wizard (ModestWindow *win)
139 ModestEasysetupWizardDialog *wizard;
141 g_return_if_fail (MODEST_IS_WINDOW(win));
143 wizard = modest_easysetup_wizard_dialog_new ();
144 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
145 gtk_dialog_run (GTK_DIALOG (wizard));
146 gtk_widget_destroy (GTK_WIDGET (wizard));
151 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
154 const gchar *authors[] = {
155 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
158 about = gtk_about_dialog_new ();
159 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
160 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
161 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
162 _("Copyright (c) 2006, Nokia Corporation\n"
163 "All rights reserved."));
164 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
165 _("a modest e-mail client\n\n"
166 "design and implementation: Dirk-Jan C. Binnema\n"
167 "contributions from the fine people at KC and Ig\n"
168 "uses the tinymail email framework written by Philip van Hoof"));
169 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
170 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
172 gtk_dialog_run (GTK_DIALOG (about));
173 gtk_widget_destroy(about);
177 * Gets the list of currently selected messages. If the win is the
178 * main window, then it returns a newly allocated list of the headers
179 * selected in the header view. If win is the msg view window, then
180 * the value returned is a list with just a single header.
182 * The caller of this funcion must free the list.
185 get_selected_headers (ModestWindow *win)
187 if (MODEST_IS_MAIN_WINDOW(win)) {
188 GtkWidget *header_view;
190 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
191 MODEST_WIDGET_TYPE_HEADER_VIEW);
192 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
194 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
195 /* for MsgViewWindows, we simply return a list with one element */
197 TnyList *list = NULL;
199 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
200 if (header != NULL) {
201 list = tny_simple_list_new ();
202 tny_list_prepend (list, G_OBJECT(header));
203 g_object_unref (G_OBJECT(header));
213 headers_action_mark_as_read (TnyHeader *header,
217 TnyHeaderFlags flags;
219 g_return_if_fail (TNY_IS_HEADER(header));
221 flags = tny_header_get_flags (header);
222 if (flags & TNY_HEADER_FLAG_SEEN) return;
223 tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN);
227 headers_action_mark_as_unread (TnyHeader *header,
231 TnyHeaderFlags flags;
233 g_return_if_fail (TNY_IS_HEADER(header));
235 flags = tny_header_get_flags (header);
236 if (flags & TNY_HEADER_FLAG_SEEN) {
237 tny_header_unset_flags (header, TNY_HEADER_FLAG_SEEN);
241 /** A convenience method, because deleting a message is
242 * otherwise complicated, and it's best to change it in one place
245 void modest_do_message_delete (TnyHeader *header, ModestWindow *win)
247 ModestMailOperation *mail_op = NULL;
248 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE,
249 win ? G_OBJECT(win) : NULL);
250 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
253 /* Always delete. TODO: Move to trash still not supported */
254 modest_mail_operation_remove_msg (mail_op, header, FALSE);
255 g_object_unref (G_OBJECT (mail_op));
259 headers_action_delete (TnyHeader *header,
263 modest_do_message_delete (header, win);
265 /* refilter treemodel to hide marked-as-deleted rows */
266 /* if (MODEST_IS_HEADER_VIEW (user_data)) */
267 /* modest_header_view_refilter (MODEST_HEADER_VIEW (user_data)); */
270 /** After deleing a message that is currently visible in a window,
271 * show the next message from the list, or close the window if there are no more messages.
273 void modest_ui_actions_refresh_message_window_after_delete (ModestMsgViewWindow* win)
275 /* Close msg view window or select next */
276 if (modest_msg_view_window_last_message_selected (win) &&
277 modest_msg_view_window_first_message_selected (win)) {
278 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (win));
280 modest_msg_view_window_select_next_message (win);
285 modest_ui_actions_on_delete_message (GtkAction *action, ModestWindow *win)
287 TnyList *header_list = NULL;
288 TnyIterator *iter = NULL;
289 TnyHeader *header = NULL;
290 gchar *message = NULL;
293 ModestWindowMgr *mgr;
294 GtkWidget *header_view = NULL;
296 g_return_if_fail (MODEST_IS_WINDOW(win));
298 /* Check first if the header view has the focus */
299 if (MODEST_IS_MAIN_WINDOW (win)) {
301 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
302 MODEST_WIDGET_TYPE_HEADER_VIEW);
303 if (!gtk_widget_is_focus (header_view))
307 header_list = get_selected_headers (win);
308 if (!header_list) return;
310 /* Check if any of the headers are already opened, or in the process of being opened */
311 if (MODEST_IS_MAIN_WINDOW (win)) {
313 iter = tny_list_create_iterator (header_list);
315 mgr = modest_runtime_get_window_mgr ();
316 while (!tny_iterator_is_done (iter) && !found) {
317 header = TNY_HEADER (tny_iterator_get_current (iter));
319 found = modest_window_mgr_find_registered_header (mgr, header, NULL);
320 g_object_unref (header);
323 tny_iterator_next (iter);
325 g_object_unref (iter);
330 num = g_strdup_printf ("%d", tny_list_get_length (header_list));
331 msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"), num);
333 modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
337 g_object_unref (header_list);
343 if (tny_list_get_length(header_list) == 1) {
344 iter = tny_list_create_iterator (header_list);
345 header = TNY_HEADER (tny_iterator_get_current (iter));
347 desc = g_strdup_printf ("%s", tny_header_get_subject (header));
348 g_object_unref (header);
351 g_object_unref (iter);
353 message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
354 tny_list_get_length(header_list)), desc);
356 /* Confirmation dialog */
357 printf("DEBUG: %s\n", __FUNCTION__);
358 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
362 if (response == GTK_RESPONSE_OK) {
363 ModestWindow *main_window = NULL;
364 ModestWindowMgr *mgr = NULL;
365 GtkTreeModel *model = NULL;
366 GtkTreeSelection *sel = NULL;
367 GList *sel_list = NULL, *tmp = NULL;
368 GtkTreeRowReference *row_reference = NULL;
369 GtkTreePath *next_path = NULL;
371 /* Find last selected row */
372 if (MODEST_IS_MAIN_WINDOW (win)) {
373 model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
374 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
375 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
376 for (tmp=sel_list; tmp; tmp=tmp->next) {
377 if (tmp->next == NULL) {
378 next_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
379 gtk_tree_path_next (next_path);
380 row_reference = gtk_tree_row_reference_new (model, next_path);
381 gtk_tree_path_free (next_path);
386 /* Remove each header. If it's a view window header_view == NULL */
387 do_headers_action (win, headers_action_delete, header_view);
389 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
390 modest_ui_actions_refresh_message_window_after_delete (MODEST_MSG_VIEW_WINDOW (win));
392 /* Get main window */
393 mgr = modest_runtime_get_window_mgr ();
394 main_window = modest_window_mgr_get_main_window (mgr);
397 /* Move cursor to next row */
400 /* Select next row */
401 if (gtk_tree_row_reference_valid (row_reference)) {
402 next_path = gtk_tree_row_reference_get_path (row_reference);
403 gtk_tree_selection_select_path (sel, next_path);
404 gtk_tree_path_free (next_path);
406 if (row_reference != NULL)
407 gtk_tree_row_reference_free (row_reference);
410 /* Update toolbar dimming state */
411 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
414 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
415 g_list_free (sel_list);
421 g_object_unref (header_list);
427 /* delete either message or folder, based on where we are */
429 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
431 g_return_if_fail (MODEST_IS_WINDOW(win));
433 /* Check first if the header view has the focus */
434 if (MODEST_IS_MAIN_WINDOW (win)) {
436 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
437 MODEST_WIDGET_TYPE_FOLDER_VIEW);
438 if (gtk_widget_is_focus (w)) {
439 modest_ui_actions_on_delete_folder (action, MODEST_MAIN_WINDOW(win));
443 modest_ui_actions_on_delete_message (action, win);
449 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
451 #ifdef MODEST_PLATFORM_MAEMO
452 modest_osso_save_state();
453 #endif /* MODEST_PLATFORM_MAEMO */
455 g_debug ("closing down, clearing %d item(s) from operation queue",
456 modest_mail_operation_queue_num_elements
457 (modest_runtime_get_mail_operation_queue()));
459 /* cancel all outstanding operations */
460 modest_mail_operation_queue_cancel_all
461 (modest_runtime_get_mail_operation_queue());
463 g_debug ("queue has been cleared");
465 /* note: when modest-tny-account-store is finalized,
466 it will automatically set all network connections
473 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
477 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
479 /* if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
480 /* gtk_widget_destroy (GTK_WIDGET (win)); */
481 /* } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
482 /* gboolean ret_value; */
483 /* g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
484 /* } else if (MODEST_IS_WINDOW (win)) { */
485 /* gtk_widget_destroy (GTK_WIDGET (win)); */
487 /* g_return_if_reached (); */
492 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
494 GtkClipboard *clipboard = NULL;
495 gchar *selection = NULL;
497 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
498 selection = gtk_clipboard_wait_for_text (clipboard);
500 /* Question: why is the clipboard being used here?
501 * It doesn't really make a lot of sense. */
505 modest_address_book_add_address (selection);
511 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
513 /* This is currently only implemented for Maemo */
514 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
515 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
516 run_account_setup_wizard (win);
519 /* Show the list of accounts: */
520 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
521 modest_maemo_show_dialog_and_forget (GTK_WINDOW (win), account_win);
524 GtkWidget *dialog, *label;
526 /* Create the widgets */
528 dialog = gtk_dialog_new_with_buttons ("Message",
530 GTK_DIALOG_DESTROY_WITH_PARENT,
534 label = gtk_label_new ("Hello World!");
536 /* Ensure that the dialog box is destroyed when the user responds. */
538 g_signal_connect_swapped (dialog, "response",
539 G_CALLBACK (gtk_widget_destroy),
542 /* Add the label, and show everything we've added to the dialog. */
544 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
546 gtk_widget_show_all (dialog);
547 #endif /* MODEST_PLATFORM_MAEMO */
551 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
553 ModestWindow *main_window = MODEST_WINDOW (user_data);
555 /* Save any changes. */
556 modest_connection_specific_smtp_window_save_server_accounts (
557 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window),
558 modest_window_get_active_account (main_window));
559 gtk_widget_destroy (GTK_WIDGET (window));
565 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
567 /* This is currently only implemented for Maemo,
568 * because it requires an API (libconic) to detect different connection
571 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
573 /* Create the window if necessary: */
574 const gchar *active_account_name = modest_window_get_active_account (win);
576 /* TODO: Dim the menu item (not in the UI spec)? or show a warning,
577 * or show the default account?
578 * If we show the default account then the account name should be shown in
579 * the window when we show it. */
580 if (!active_account_name) {
581 g_warning ("%s: No account is active.", __FUNCTION__);
585 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
586 modest_connection_specific_smtp_window_fill_with_connections (
587 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
588 modest_runtime_get_account_mgr(),
589 active_account_name);
591 /* Show the window: */
592 gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
593 gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
594 gtk_widget_show (specific_window);
596 /* Save changes when the window is hidden: */
597 g_signal_connect (specific_window, "hide",
598 G_CALLBACK (on_smtp_servers_window_hide), win);
599 #endif /* MODEST_PLATFORM_MAEMO */
603 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
605 ModestWindow *msg_win = NULL;
607 TnyFolder *folder = NULL;
608 gchar *account_name = NULL;
609 gchar *from_str = NULL;
610 /* GError *err = NULL; */
611 TnyAccount *account = NULL;
612 ModestWindowMgr *mgr;
613 gchar *signature = NULL, *blank_and_signature = NULL;
615 /* if there are no accounts yet, just show the wizard */
616 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
617 run_account_setup_wizard (win);
621 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
623 account_name = g_strdup (modest_window_get_active_account (win));
625 g_printerr ("modest: no account found\n");
629 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
631 TNY_ACCOUNT_TYPE_STORE);
633 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
637 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
639 g_printerr ("modest: failed get from string for '%s'\n", account_name);
643 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
644 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
645 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
646 MODEST_ACCOUNT_SIGNATURE, FALSE);
647 blank_and_signature = g_strconcat ("\n", signature, NULL);
650 blank_and_signature = g_strdup ("");
653 msg = modest_tny_msg_new ("", from_str, "", "", "", blank_and_signature, NULL);
655 g_printerr ("modest: failed to create new msg\n");
659 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
661 g_printerr ("modest: failed to find Drafts folder\n");
666 /* Create and register edit window */
667 /* This is destroyed by TOOD. */
668 msg_win = modest_msg_edit_window_new (msg, account_name);
669 mgr = modest_runtime_get_window_mgr ();
670 modest_window_mgr_register_window (mgr, msg_win);
673 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
675 gtk_widget_show_all (GTK_WIDGET (msg_win));
678 g_free (account_name);
680 g_free (blank_and_signature);
682 g_object_unref (msg_win);
684 g_object_unref (G_OBJECT(account));
686 g_object_unref (G_OBJECT(msg));
688 g_object_unref (G_OBJECT(folder));
692 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
696 ModestMailOperationStatus status;
698 /* If there is no message or the operation was not successful */
699 status = modest_mail_operation_get_status (mail_op);
700 if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
702 /* Remove the header from the preregistered uids */
703 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
713 open_msg_cb (ModestMailOperation *mail_op,
718 ModestWindowMgr *mgr = NULL;
719 ModestWindow *parent_win = NULL;
720 ModestWindow *win = NULL;
721 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
722 gchar *account = NULL;
725 /* Do nothing if there was any problem with the mail
726 operation. The error will be shown by the error_handler of
727 the mail operation */
728 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
732 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
733 folder = tny_header_get_folder (header);
735 /* Mark header as read */
736 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
739 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
741 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
743 /* Gets folder type (OUTBOX headers will be opened in edit window */
744 if (modest_tny_folder_is_local_folder (folder))
745 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
747 /* If the header is in the drafts folder then open the editor,
748 else the message view window */
749 if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
750 /* we cannot edit without a valid account... */
751 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
752 run_account_setup_wizard(parent_win);
755 win = modest_msg_edit_window_new (msg, account);
757 gchar *uid = modest_tny_folder_get_header_unique_id (header);
759 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
760 GtkWidget *header_view;
761 GtkTreeSelection *sel;
762 GList *sel_list = NULL;
765 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
766 MODEST_WIDGET_TYPE_HEADER_VIEW);
768 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
769 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
771 if (sel_list != NULL) {
772 GtkTreeRowReference *row_reference;
774 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
775 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
776 g_list_free (sel_list);
778 win = modest_msg_view_window_new_with_header_model (msg,
783 gtk_tree_row_reference_free (row_reference);
785 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
788 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
793 /* Register and show new window */
795 mgr = modest_runtime_get_window_mgr ();
796 modest_window_mgr_register_window (mgr, win);
797 g_object_unref (win);
798 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
799 gtk_widget_show_all (GTK_WIDGET(win));
802 /* Update toolbar dimming state */
803 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
804 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
810 g_object_unref (parent_win);
811 g_object_unref (folder);
815 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
819 GObject *win = modest_mail_operation_get_source (mail_op);
821 error = modest_mail_operation_get_error (mail_op);
822 printf ("DEBUG: %s: Error: code=%d, text=%s\n", __FUNCTION__, error->code, error->message);
824 if (error->code == MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT) {
826 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
829 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
830 _("mail_ni_ui_folder_get_msg_folder_error"));
834 g_object_unref (win);
838 * This function is used by both modest_ui_actions_on_open and
839 * modest_ui_actions_on_header_activated. This way we always do the
840 * same when trying to open messages.
843 _modest_ui_actions_open (TnyList *headers, ModestWindow *win)
845 ModestWindowMgr *mgr = NULL;
846 TnyIterator *iter = NULL;
847 ModestMailOperation *mail_op = NULL;
848 TnyList *not_opened_headers = NULL;
849 TnyHeaderFlags flags = 0;
851 /* Look if we already have a message view for each header. If
852 true, then remove the header from the list of headers to
854 mgr = modest_runtime_get_window_mgr ();
855 iter = tny_list_create_iterator (headers);
856 not_opened_headers = tny_simple_list_new ();
858 while (!tny_iterator_is_done (iter)) {
860 ModestWindow *window = NULL;
861 TnyHeader *header = NULL;
862 gboolean found = FALSE;
864 header = TNY_HEADER (tny_iterator_get_current (iter));
866 flags = tny_header_get_flags (header);
869 found = modest_window_mgr_find_registered_header (mgr, header, &window);
871 /* Do not open again the message and present the
872 window to the user */
875 gtk_window_present (GTK_WINDOW (window));
877 /* the header has been registered already, we don't do
878 * anything but wait for the window to come up*/
879 g_debug ("header %p already registered, waiting for window", header);
881 tny_list_append (not_opened_headers, G_OBJECT (header));
885 g_object_unref (header);
887 tny_iterator_next (iter);
889 g_object_unref (iter);
892 /* If some messages would have to be downloaded, ask the user to
893 * make a connection. It's generally easier to do this here (in the mainloop)
894 * than later in a thread:
896 if (tny_list_get_length (not_opened_headers) > 0) {
897 gboolean connected = modest_platform_connect_and_wait (GTK_WINDOW (win), NULL);
899 /* Don't go further if a connection would be necessary but none is available: */
901 g_object_unref (not_opened_headers);
906 /* Register the headers before actually creating the windows: */
907 TnyIterator *iter_not_opened = tny_list_create_iterator (not_opened_headers);
908 while (!tny_iterator_is_done (iter_not_opened)) {
909 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_not_opened));
911 modest_window_mgr_register_header (mgr, header);
912 g_object_unref (header);
915 tny_iterator_next (iter_not_opened);
917 g_object_unref (iter_not_opened);
918 iter_not_opened = NULL;
920 /* Open each message */
921 if (tny_list_get_length (not_opened_headers) > 0) {
922 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
924 modest_ui_actions_get_msgs_full_error_handler,
926 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
927 if (tny_list_get_length (not_opened_headers) > 1) {
928 modest_mail_operation_get_msgs_full (mail_op,
934 TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
935 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
936 modest_mail_operation_get_msg (mail_op, header, open_msg_cb, NULL);
937 g_object_unref (header);
938 g_object_unref (iter);
940 g_object_unref (mail_op);
944 if (not_opened_headers != NULL)
945 g_object_unref (not_opened_headers);
949 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
954 headers = get_selected_headers (win);
959 _modest_ui_actions_open (headers, win);
961 g_object_unref(headers);
966 free_reply_forward_helper (gpointer data)
968 ReplyForwardHelper *helper;
970 helper = (ReplyForwardHelper *) data;
971 g_free (helper->account_name);
972 g_slice_free (ReplyForwardHelper, helper);
976 reply_forward_cb (ModestMailOperation *mail_op,
982 ReplyForwardHelper *rf_helper;
983 ModestWindow *msg_win = NULL;
984 ModestEditType edit_type;
986 TnyAccount *account = NULL;
987 ModestWindowMgr *mgr = NULL;
988 gchar *signature = NULL;
990 /* If there was any error. The mail operation could be NULL,
991 this means that we already have the message downloaded and
992 that we didn't do a mail operation to retrieve it */
993 if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
996 g_return_if_fail (user_data != NULL);
997 rf_helper = (ReplyForwardHelper *) user_data;
999 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
1000 rf_helper->account_name);
1001 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
1002 rf_helper->account_name,
1003 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
1004 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
1005 rf_helper->account_name,
1006 MODEST_ACCOUNT_SIGNATURE, FALSE);
1009 /* Create reply mail */
1010 switch (rf_helper->action) {
1013 modest_tny_msg_create_reply_msg (msg, from, signature,
1014 rf_helper->reply_forward_type,
1015 MODEST_TNY_MSG_REPLY_MODE_SENDER);
1017 case ACTION_REPLY_TO_ALL:
1019 modest_tny_msg_create_reply_msg (msg, from, signature, rf_helper->reply_forward_type,
1020 MODEST_TNY_MSG_REPLY_MODE_ALL);
1021 edit_type = MODEST_EDIT_TYPE_REPLY;
1023 case ACTION_FORWARD:
1025 modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
1026 edit_type = MODEST_EDIT_TYPE_FORWARD;
1029 g_return_if_reached ();
1036 g_printerr ("modest: failed to create message\n");
1040 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1041 rf_helper->account_name,
1042 TNY_ACCOUNT_TYPE_STORE);
1044 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
1048 /* Create and register the windows */
1049 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
1050 mgr = modest_runtime_get_window_mgr ();
1051 modest_window_mgr_register_window (mgr, msg_win);
1053 if (rf_helper->parent_window != NULL) {
1054 gdouble parent_zoom;
1056 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1057 modest_window_set_zoom (msg_win, parent_zoom);
1060 /* Show edit window */
1061 gtk_widget_show_all (GTK_WIDGET (msg_win));
1065 g_object_unref (msg_win);
1067 g_object_unref (G_OBJECT (new_msg));
1069 g_object_unref (G_OBJECT (account));
1070 /* g_object_unref (msg); */
1071 g_object_unref (header);
1072 free_reply_forward_helper (rf_helper);
1076 * Checks a list of headers. If any of them are not currently
1077 * downloaded (CACHED) then it asks the user for permission to
1080 * Returns FALSE if the user does not want to download the
1081 * messages. Returns TRUE if the user allowed the download or if all
1082 * of them are currently downloaded
1085 download_uncached_messages (TnyList *header_list, GtkWindow *win,
1090 gint uncached_messages = 0;
1092 iter = tny_list_create_iterator (header_list);
1093 while (!tny_iterator_is_done (iter)) {
1095 TnyHeaderFlags flags;
1097 header = TNY_HEADER (tny_iterator_get_current (iter));
1099 flags = tny_header_get_flags (header);
1100 /* TODO: is this the right flag?, it seems that some
1101 headers that have been previously downloaded do not
1103 if (! (flags & TNY_HEADER_FLAG_CACHED))
1104 uncached_messages ++;
1105 g_object_unref (header);
1108 tny_iterator_next (iter);
1110 g_object_unref (iter);
1112 /* Ask for user permission to download the messages */
1114 if (uncached_messages > 0) {
1115 GtkResponseType response;
1117 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1118 _("emev_nc_include_original"));
1121 modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1122 ngettext("mcen_nc_get_msg",
1124 uncached_messages));
1125 if (response == GTK_RESPONSE_CANCEL)
1128 /* If a download will be necessary, make sure that we have a connection: */
1129 retval = modest_platform_connect_and_wait(win, NULL);
1137 * Common code for the reply and forward actions
1140 reply_forward (ReplyForwardAction action, ModestWindow *win)
1142 ModestMailOperation *mail_op = NULL;
1143 TnyList *header_list = NULL;
1144 ReplyForwardHelper *rf_helper = NULL;
1145 guint reply_forward_type;
1146 gboolean continue_download;
1148 g_return_if_fail (MODEST_IS_WINDOW(win));
1150 /* we need an account when editing */
1151 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1152 run_account_setup_wizard (win);
1156 header_list = get_selected_headers (win);
1160 /* Check that the messages have been previously downloaded */
1161 continue_download = download_uncached_messages (header_list, GTK_WINDOW (win), TRUE);
1162 if (!continue_download) {
1163 g_object_unref (header_list);
1167 reply_forward_type =
1168 modest_conf_get_int (modest_runtime_get_conf (),
1169 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
1171 /* We assume that we can only select messages of the
1172 same folder and that we reply all of them from the
1173 same account. In fact the interface currently only
1174 allows single selection */
1177 rf_helper = g_slice_new0 (ReplyForwardHelper);
1178 rf_helper->reply_forward_type = reply_forward_type;
1179 rf_helper->action = action;
1180 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
1182 if ((win != NULL) && (MODEST_IS_WINDOW (win)))
1183 rf_helper->parent_window = GTK_WIDGET (win);
1184 if (!rf_helper->account_name)
1185 rf_helper->account_name =
1186 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1188 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1191 /* Get header and message. Do not free them here, the
1192 reply_forward_cb must do it */
1193 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1194 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1195 if (!msg || !header) {
1197 g_object_unref (msg);
1199 g_object_unref (header);
1200 g_printerr ("modest: no message found\n");
1203 reply_forward_cb (NULL, header, msg, rf_helper);
1209 /* Retrieve messages */
1210 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1212 modest_ui_actions_get_msgs_full_error_handler,
1214 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1216 /* Only reply/forward to one message */
1217 iter = tny_list_create_iterator (header_list);
1218 header = TNY_HEADER (tny_iterator_get_current (iter));
1219 g_object_unref (iter);
1222 modest_mail_operation_get_msg (mail_op,
1227 /* modest_mail_operation_get_msgs_full (mail_op, */
1229 /* reply_forward_cb, */
1231 /* free_reply_forward_helper); */
1233 g_object_unref (header);
1237 g_object_unref(mail_op);
1241 g_object_unref (header_list);
1245 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
1247 g_return_if_fail (MODEST_IS_WINDOW(win));
1249 reply_forward (ACTION_REPLY, win);
1253 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1255 g_return_if_fail (MODEST_IS_WINDOW(win));
1257 reply_forward (ACTION_FORWARD, win);
1261 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1263 g_return_if_fail (MODEST_IS_WINDOW(win));
1265 reply_forward (ACTION_REPLY_TO_ALL, win);
1269 modest_ui_actions_on_next (GtkAction *action,
1270 ModestWindow *window)
1272 if (MODEST_IS_MAIN_WINDOW (window)) {
1273 GtkWidget *header_view;
1275 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1276 MODEST_WIDGET_TYPE_HEADER_VIEW);
1280 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
1281 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1282 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
1284 g_return_if_reached ();
1289 modest_ui_actions_on_prev (GtkAction *action,
1290 ModestWindow *window)
1292 g_return_if_fail (MODEST_IS_WINDOW(window));
1294 if (MODEST_IS_MAIN_WINDOW (window)) {
1295 GtkWidget *header_view;
1296 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1297 MODEST_WIDGET_TYPE_HEADER_VIEW);
1301 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1302 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1303 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1305 g_return_if_reached ();
1310 modest_ui_actions_on_sort (GtkAction *action,
1311 ModestWindow *window)
1313 g_return_if_fail (MODEST_IS_WINDOW(window));
1315 if (MODEST_IS_MAIN_WINDOW (window)) {
1316 GtkWidget *header_view;
1317 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1318 MODEST_WIDGET_TYPE_HEADER_VIEW);
1320 modest_platform_information_banner (NULL, NULL, _CS("ckdg_ib_nothing_to_sort"));
1325 /* Show sorting dialog */
1326 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1331 new_messages_arrived (ModestMailOperation *self,
1335 if (new_messages == 0)
1338 modest_platform_on_new_msg ();
1342 * This function performs the send & receive required actions. The
1343 * window is used to create the mail operation. Typically it should
1344 * always be the main window, but we pass it as argument in order to
1348 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
1350 gchar *acc_name = NULL;
1351 ModestMailOperation *mail_op;
1353 /* If no account name was provided then get the current account, and if
1354 there is no current account then pick the default one: */
1355 if (!account_name) {
1356 acc_name = g_strdup (modest_window_get_active_account(win));
1358 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1360 g_printerr ("modest: cannot get default account\n");
1364 acc_name = g_strdup (account_name);
1367 /* Set send/receive operation in progress */
1368 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW(win));
1370 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1372 modest_ui_actions_send_receive_error_handler,
1375 g_signal_connect (G_OBJECT(mail_op), "progress-changed",
1376 G_CALLBACK (_on_send_receive_progress_changed),
1379 /* Send & receive. */
1380 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
1381 /* Receive and then send. The operation is tagged initially as
1382 a receive operation because the account update performs a
1383 receive and then a send. The operation changes its type
1384 internally, so the progress objects will receive the proper
1385 progress information */
1386 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1387 modest_mail_operation_update_account (mail_op, acc_name, new_messages_arrived, NULL);
1388 g_object_unref (G_OBJECT (mail_op));
1396 modest_ui_actions_do_cancel_send (const gchar *account_name,
1399 TnyTransportAccount *transport_account;
1400 TnySendQueue *send_queue = NULL;
1401 GError *error = NULL;
1403 /* Get transport account */
1405 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1406 (modest_runtime_get_account_store(),
1408 TNY_ACCOUNT_TYPE_TRANSPORT));
1409 if (!transport_account) {
1410 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1415 send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
1416 if (!TNY_IS_SEND_QUEUE(send_queue)) {
1417 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
1418 MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1419 "modest: could not find send queue for account\n");
1421 /* Keeep messages in outbox folder */
1422 tny_send_queue_cancel (send_queue, FALSE, &error);
1426 if (transport_account != NULL)
1427 g_object_unref (G_OBJECT (transport_account));
1431 modest_ui_actions_cancel_send_all (ModestWindow *win)
1433 GSList *account_names, *iter;
1435 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1438 iter = account_names;
1440 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
1441 iter = g_slist_next (iter);
1444 modest_account_mgr_free_account_names (account_names);
1445 account_names = NULL;
1449 modest_ui_actions_cancel_send (GtkAction *action, ModestWindow *win)
1452 /* Check if accounts exist */
1453 gboolean accounts_exist =
1454 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1456 /* If not, allow the user to create an account before trying to send/receive. */
1457 if (!accounts_exist)
1458 modest_ui_actions_on_accounts (NULL, win);
1460 /* Cancel all sending operaitons */
1461 modest_ui_actions_cancel_send_all (win);
1465 * Refreshes all accounts. This function will be used by automatic
1469 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1471 GSList *account_names, *iter;
1473 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1476 iter = account_names;
1478 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1479 iter = g_slist_next (iter);
1482 modest_account_mgr_free_account_names (account_names);
1483 account_names = NULL;
1487 modest_do_refresh_current_folder(ModestWindow *win)
1489 /* Refresh currently selected folder. Note that if we only
1490 want to retreive the headers, then the refresh only will
1491 invoke a poke_status over all folders, i.e., only the
1492 total/unread count will be updated */
1493 if (MODEST_IS_MAIN_WINDOW (win)) {
1494 GtkWidget *header_view, *folder_view;
1495 TnyFolderStore *folder_store;
1497 /* Get folder and header view */
1499 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1500 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1502 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1504 if (folder_store && TNY_IS_FOLDER (folder_store)) {
1506 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1507 MODEST_WIDGET_TYPE_HEADER_VIEW);
1509 /* We do not need to set the contents style
1510 because it hasn't changed. We also do not
1511 need to save the widget status. Just force
1513 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1514 TNY_FOLDER (folder_store),
1515 folder_refreshed_cb,
1516 MODEST_MAIN_WINDOW (win));
1520 g_object_unref (folder_store);
1526 * Handler of the click on Send&Receive button in the main toolbar
1529 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1531 /* Check if accounts exist */
1532 gboolean accounts_exist =
1533 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1535 /* If not, allow the user to create an account before trying to send/receive. */
1536 if (!accounts_exist)
1537 modest_ui_actions_on_accounts (NULL, win);
1539 modest_do_refresh_current_folder (win);
1541 /* Refresh the active account */
1542 modest_ui_actions_do_send_receive (NULL, win);
1547 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1550 GtkWidget *header_view;
1552 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1554 header_view = modest_main_window_get_child_widget (main_window,
1555 MODEST_WIDGET_TYPE_HEADER_VIEW);
1559 conf = modest_runtime_get_conf ();
1561 /* what is saved/restored is depending on the style; thus; we save with
1562 * old style, then update the style, and restore for this new style
1564 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1566 if (modest_header_view_get_style
1567 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1568 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1569 MODEST_HEADER_VIEW_STYLE_TWOLINES);
1571 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1572 MODEST_HEADER_VIEW_STYLE_DETAILS);
1574 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1575 MODEST_CONF_HEADER_VIEW_KEY);
1580 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1582 ModestMainWindow *main_window)
1584 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1585 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
1587 /* If no header has been selected then exit */
1592 if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
1593 gtk_widget_grab_focus (GTK_WIDGET(header_view));
1595 /* Update Main window title */
1596 if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
1597 const gchar *subject = tny_header_get_subject (header);
1598 if (subject && strlen(subject) > 0)
1599 gtk_window_set_title (GTK_WINDOW (main_window), subject);
1601 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
1604 /* Update toolbar dimming state */
1605 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1609 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1611 ModestMainWindow *main_window)
1615 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1620 headers = tny_simple_list_new ();
1621 tny_list_prepend (headers, G_OBJECT (header));
1623 _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1625 g_object_unref (headers);
1629 set_active_account_from_tny_account (TnyAccount *account,
1630 ModestWindow *window)
1632 const gchar *server_acc_name = tny_account_get_id (account);
1634 /* We need the TnyAccount provided by the
1635 account store because that is the one that
1636 knows the name of the Modest account */
1637 TnyAccount *modest_server_account = modest_server_account =
1638 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
1639 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1642 const gchar *modest_acc_name =
1643 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1644 modest_window_set_active_account (window, modest_acc_name);
1645 g_object_unref (modest_server_account);
1650 folder_refreshed_cb (ModestMailOperation *mail_op,
1654 ModestMainWindow *win = NULL;
1655 GtkWidget *header_view;
1656 TnyFolder *current_folder;
1658 g_return_if_fail (TNY_IS_FOLDER (folder));
1660 win = MODEST_MAIN_WINDOW (user_data);
1662 modest_main_window_get_child_widget(win, MODEST_WIDGET_TYPE_HEADER_VIEW);
1665 current_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
1666 if (current_folder != NULL && folder != current_folder) {
1671 /* Check if folder is empty and set headers view contents style */
1672 if (tny_folder_get_all_count (folder) == 0) {
1673 printf ("DEBUG: %s: tny_folder_get_all_count() returned 0.\n", __FUNCTION__);
1674 modest_main_window_set_contents_style (win,
1675 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
1677 printf ("DEBUG: %s: tny_folder_get_all_count() returned >0.\n", __FUNCTION__);
1682 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1683 TnyFolderStore *folder_store,
1685 ModestMainWindow *main_window)
1688 GtkWidget *header_view;
1690 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1692 header_view = modest_main_window_get_child_widget(main_window,
1693 MODEST_WIDGET_TYPE_HEADER_VIEW);
1697 conf = modest_runtime_get_conf ();
1699 if (TNY_IS_ACCOUNT (folder_store)) {
1701 /* Update active account */
1702 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1703 /* Show account details */
1704 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1707 if (TNY_IS_FOLDER (folder_store) && selected) {
1709 /* Update the active account */
1710 TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
1712 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1713 g_object_unref (account);
1717 /* Set the header style by default, it could
1718 be changed later by the refresh callback to
1720 modest_main_window_set_contents_style (main_window,
1721 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1723 /* Set folder on header view. This function
1724 will call tny_folder_refresh_async so we
1725 pass a callback that will be called when
1726 finished. We use that callback to set the
1727 empty view if there are no messages */
1728 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1729 TNY_FOLDER (folder_store),
1730 folder_refreshed_cb,
1733 /* Restore configuration. We need to do this
1734 *after* the set_folder because the widget
1735 memory asks the header view about its
1737 modest_widget_memory_restore (modest_runtime_get_conf (),
1738 G_OBJECT(header_view),
1739 MODEST_CONF_HEADER_VIEW_KEY);
1741 /* Update the active account */
1742 modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1743 /* Save only if we're seeing headers */
1744 if (modest_main_window_get_contents_style (main_window) ==
1745 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
1746 modest_widget_memory_save (conf, G_OBJECT (header_view),
1747 MODEST_CONF_HEADER_VIEW_KEY);
1748 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
1752 /* Update toolbar dimming state */
1753 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1757 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1764 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1766 online = tny_device_is_online (modest_runtime_get_device());
1769 /* already online -- the item is simply not there... */
1770 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1772 GTK_MESSAGE_WARNING,
1774 _("The %s you selected cannot be found"),
1776 gtk_dialog_run (GTK_DIALOG(dialog));
1778 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1782 GTK_RESPONSE_REJECT,
1784 GTK_RESPONSE_ACCEPT,
1786 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1787 "Do you want to get online?"), item);
1788 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1789 gtk_label_new (txt), FALSE, FALSE, 0);
1790 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1793 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1794 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1795 // modest_platform_connect_and_wait ();
1798 gtk_widget_destroy (dialog);
1802 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1805 /* g_message ("%s %s", __FUNCTION__, link); */
1810 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1813 modest_platform_activate_uri (link);
1817 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1820 modest_platform_show_uri_popup (link);
1824 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1827 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1831 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1832 const gchar *address,
1835 /* g_message ("%s %s", __FUNCTION__, address); */
1839 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1841 TnyTransportAccount *transport_account;
1842 ModestMailOperation *mail_operation;
1844 gchar *account_name, *from;
1845 ModestAccountMgr *account_mgr;
1846 gchar *info_text = NULL;
1848 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1850 data = modest_msg_edit_window_get_msg_data (edit_window);
1852 account_mgr = modest_runtime_get_account_mgr();
1853 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1855 account_name = modest_account_mgr_get_default_account (account_mgr);
1856 if (!account_name) {
1857 g_printerr ("modest: no account found\n");
1858 modest_msg_edit_window_free_msg_data (edit_window, data);
1862 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1863 account_name = g_strdup (data->account_name);
1867 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1868 (modest_runtime_get_account_store(),
1870 TNY_ACCOUNT_TYPE_TRANSPORT));
1871 if (!transport_account) {
1872 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1873 g_free (account_name);
1874 modest_msg_edit_window_free_msg_data (edit_window, data);
1877 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1879 /* Create the mail operation */
1880 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
1881 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1883 modest_mail_operation_save_to_drafts (mail_operation,
1895 data->priority_flags);
1898 g_free (account_name);
1899 g_object_unref (G_OBJECT (transport_account));
1900 g_object_unref (G_OBJECT (mail_operation));
1902 modest_msg_edit_window_free_msg_data (edit_window, data);
1904 info_text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
1905 modest_platform_information_banner (NULL, NULL, info_text);
1909 /* For instance, when clicking the Send toolbar button when editing a message: */
1911 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1913 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1915 if (!modest_msg_edit_window_check_names (edit_window, TRUE))
1918 /* Offer the connection dialog, if necessary: */
1919 if (!modest_platform_connect_and_wait (GTK_WINDOW (edit_window), NULL))
1922 /* FIXME: Code added just for testing. The final version will
1923 use the send queue provided by tinymail and some
1925 ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
1926 gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1928 account_name = modest_account_mgr_get_default_account (account_mgr);
1930 if (!account_name) {
1931 g_printerr ("modest: no account found\n");
1935 MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
1937 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1938 account_name = g_strdup (data->account_name);
1941 /* Get the currently-active transport account for this modest account: */
1942 TnyTransportAccount *transport_account =
1943 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1944 (modest_runtime_get_account_store(),
1946 if (!transport_account) {
1947 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1948 g_free (account_name);
1949 modest_msg_edit_window_free_msg_data (edit_window, data);
1953 gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
1955 /* mail content checks and dialogs */
1956 if (data->subject == NULL || data->subject[0] == '\0') {
1957 GtkResponseType response;
1958 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1959 _("mcen_nc_subject_is_empty_send"));
1960 if (response == GTK_RESPONSE_CANCEL) {
1961 g_free (account_name);
1966 if (data->plain_body == NULL || data->plain_body[0] == '\0') {
1967 GtkResponseType response;
1968 gchar *note_message;
1969 gchar *note_subject = data->subject;
1970 if (note_subject == NULL || note_subject[0] == '\0')
1971 note_subject = _("mail_va_no_subject");
1972 note_message = g_strdup_printf (_("emev_ni_ui_smtp_message_null"), note_subject);
1973 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1975 g_free (note_message);
1976 if (response == GTK_RESPONSE_CANCEL) {
1977 g_free (account_name);
1982 modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
1984 /* Create the mail operation */
1985 ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
1986 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1988 modest_mail_operation_send_new_mail (mail_operation,
1999 data->priority_flags);
2003 g_free (account_name);
2004 g_object_unref (G_OBJECT (transport_account));
2005 g_object_unref (G_OBJECT (mail_operation));
2007 modest_msg_edit_window_free_msg_data (edit_window, data);
2008 modest_msg_edit_window_set_sent (edit_window, TRUE);
2010 /* Save settings and close the window: */
2011 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
2015 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
2016 ModestMsgEditWindow *window)
2018 ModestMsgEditFormatState *format_state = NULL;
2020 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2021 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2023 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2026 format_state = modest_msg_edit_window_get_format_state (window);
2027 g_return_if_fail (format_state != NULL);
2029 format_state->bold = gtk_toggle_action_get_active (action);
2030 modest_msg_edit_window_set_format_state (window, format_state);
2031 g_free (format_state);
2036 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
2037 ModestMsgEditWindow *window)
2039 ModestMsgEditFormatState *format_state = NULL;
2041 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2042 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2044 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2047 format_state = modest_msg_edit_window_get_format_state (window);
2048 g_return_if_fail (format_state != NULL);
2050 format_state->italics = gtk_toggle_action_get_active (action);
2051 modest_msg_edit_window_set_format_state (window, format_state);
2052 g_free (format_state);
2057 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
2058 ModestMsgEditWindow *window)
2060 ModestMsgEditFormatState *format_state = NULL;
2062 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2063 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2065 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2068 format_state = modest_msg_edit_window_get_format_state (window);
2069 g_return_if_fail (format_state != NULL);
2071 format_state->bullet = gtk_toggle_action_get_active (action);
2072 modest_msg_edit_window_set_format_state (window, format_state);
2073 g_free (format_state);
2078 modest_ui_actions_on_change_justify (GtkRadioAction *action,
2079 GtkRadioAction *selected,
2080 ModestMsgEditWindow *window)
2082 ModestMsgEditFormatState *format_state = NULL;
2083 GtkJustification value;
2085 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2087 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2090 value = gtk_radio_action_get_current_value (selected);
2092 format_state = modest_msg_edit_window_get_format_state (window);
2093 g_return_if_fail (format_state != NULL);
2095 format_state->justification = value;
2096 modest_msg_edit_window_set_format_state (window, format_state);
2097 g_free (format_state);
2101 modest_ui_actions_on_select_editor_color (GtkAction *action,
2102 ModestMsgEditWindow *window)
2104 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2105 g_return_if_fail (GTK_IS_ACTION (action));
2107 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2110 modest_msg_edit_window_select_color (window);
2114 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
2115 ModestMsgEditWindow *window)
2117 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2118 g_return_if_fail (GTK_IS_ACTION (action));
2120 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2123 modest_msg_edit_window_select_background_color (window);
2127 modest_ui_actions_on_insert_image (GtkAction *action,
2128 ModestMsgEditWindow *window)
2130 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2131 g_return_if_fail (GTK_IS_ACTION (action));
2133 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2136 modest_msg_edit_window_insert_image (window);
2140 modest_ui_actions_on_attach_file (GtkAction *action,
2141 ModestMsgEditWindow *window)
2143 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2144 g_return_if_fail (GTK_IS_ACTION (action));
2146 modest_msg_edit_window_offer_attach_file (window);
2150 modest_ui_actions_on_remove_attachments (GtkAction *action,
2151 ModestMsgEditWindow *window)
2153 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2154 g_return_if_fail (GTK_IS_ACTION (action));
2156 modest_msg_edit_window_remove_attachments (window, NULL);
2160 modest_ui_actions_new_folder_error_handler (ModestMailOperation *mail_op,
2163 ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2164 const GError *error = modest_mail_operation_get_error (mail_op);
2168 modest_platform_information_banner (GTK_WIDGET (window), NULL,
2169 modest_mail_operation_get_error (mail_op)->message);
2174 modest_ui_actions_create_folder(GtkWidget *parent_window,
2175 GtkWidget *folder_view)
2177 TnyFolderStore *parent_folder;
2179 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2181 if (parent_folder) {
2182 gboolean finished = FALSE;
2184 gchar *folder_name = NULL, *suggested_name = NULL;
2186 /* Run the new folder dialog */
2188 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (parent_window),
2193 g_free (suggested_name);
2194 suggested_name = NULL;
2196 if (result == GTK_RESPONSE_REJECT) {
2199 ModestMailOperation *mail_op;
2200 TnyFolder *new_folder = NULL;
2202 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2203 G_OBJECT(parent_window),
2204 modest_ui_actions_new_folder_error_handler,
2207 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2209 new_folder = modest_mail_operation_create_folder (mail_op,
2211 (const gchar *) folder_name);
2213 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2216 g_object_unref (new_folder);
2219 g_object_unref (mail_op);
2222 suggested_name = folder_name;
2226 g_object_unref (parent_folder);
2231 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
2233 GtkWidget *folder_view;
2235 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2237 folder_view = modest_main_window_get_child_widget (main_window,
2238 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2242 modest_ui_actions_create_folder (GTK_WIDGET (main_window), folder_view);
2246 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
2249 GObject *win = modest_mail_operation_get_source (mail_op);
2250 const GError *error = NULL;
2251 const gchar *message = NULL;
2253 /* Get error message */
2254 error = modest_mail_operation_get_error (mail_op);
2255 if (error != NULL && error->message != NULL) {
2256 message = error->message;
2258 message = _("!!! FIXME: Unable to rename");
2261 /* Show notification dialog */
2262 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
2263 g_object_unref (win);
2267 modest_ui_actions_on_rename_folder (GtkAction *action,
2268 ModestMainWindow *main_window)
2270 TnyFolderStore *folder;
2271 GtkWidget *folder_view;
2272 GtkWidget *header_view;
2274 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2276 folder_view = modest_main_window_get_child_widget (main_window,
2277 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2281 header_view = modest_main_window_get_child_widget (main_window,
2282 MODEST_WIDGET_TYPE_HEADER_VIEW);
2287 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2291 /* Offer the connection dialog if necessary: */
2292 if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2293 g_object_unref (G_OBJECT (folder));
2298 if (TNY_IS_FOLDER (folder)) {
2301 const gchar *current_name;
2303 current_name = tny_folder_get_name (TNY_FOLDER (folder));
2304 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (main_window), NULL,
2305 current_name, &folder_name);
2307 if (response == GTK_RESPONSE_ACCEPT && strlen (folder_name) > 0) {
2308 ModestMailOperation *mail_op;
2311 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2312 G_OBJECT(main_window),
2313 modest_ui_actions_rename_folder_error_handler,
2317 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2320 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
2322 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2323 TNY_FOLDER(folder), TRUE);
2326 modest_header_view_clear ((ModestHeaderView *) header_view);
2328 modest_mail_operation_rename_folder (mail_op,
2329 TNY_FOLDER (folder),
2330 (const gchar *) folder_name);
2332 g_object_unref (mail_op);
2333 g_free (folder_name);
2336 g_object_unref (folder);
2340 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
2343 GObject *win = modest_mail_operation_get_source (mail_op);
2345 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2346 _("mail_in_ui_folder_delete_error"));
2347 g_object_unref (win);
2351 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
2353 TnyFolderStore *folder;
2354 GtkWidget *folder_view;
2358 g_return_if_fail (MODEST_IS_MAIN_WINDOW (main_window));
2360 folder_view = modest_main_window_get_child_widget (main_window,
2361 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2365 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2367 /* Show an error if it's an account */
2368 if (!TNY_IS_FOLDER (folder)) {
2369 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
2370 _("mail_in_ui_folder_delete_error"));
2371 g_object_unref (G_OBJECT (folder));
2375 /* Offer the connection dialog if necessary: */
2376 if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, folder)) {
2377 g_object_unref (G_OBJECT (folder));
2382 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
2383 tny_folder_get_name (TNY_FOLDER (folder)));
2384 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
2385 (const gchar *) message);
2388 if (response == GTK_RESPONSE_OK) {
2389 ModestMailOperation *mail_op =
2390 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_DELETE,
2391 G_OBJECT(main_window),
2392 modest_ui_actions_delete_folder_error_handler,
2395 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2397 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
2398 g_object_unref (G_OBJECT (mail_op));
2401 g_object_unref (G_OBJECT (folder));
2405 modest_ui_actions_on_delete_folder (GtkAction *action,
2406 ModestMainWindow *main_window)
2408 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2410 delete_folder (main_window, FALSE);
2414 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
2416 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2418 delete_folder (main_window, TRUE);
2423 show_error (GtkWidget *parent_widget, const gchar* text)
2425 hildon_banner_show_information(parent_widget, NULL, text);
2428 GtkDialog *dialog = GTK_DIALOG (hildon_note_new_information (parent_window, text)); */
2430 GtkDialog *dialog = GTK_DIALOG (gtk_message_dialog_new (parent_window,
2437 gtk_dialog_run (dialog);
2438 gtk_widget_destroy (GTK_WIDGET (dialog));
2443 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
2444 const gchar* server_account_name,
2449 ModestMainWindow *main_window)
2451 g_return_if_fail(server_account_name);
2452 /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
2454 /* Initalize output parameters: */
2461 #ifdef MODEST_PLATFORM_MAEMO
2462 /* Maemo uses a different (awkward) button order,
2463 * It should probably just use gtk_alternative_dialog_button_order ().
2465 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2469 GTK_RESPONSE_ACCEPT,
2471 GTK_RESPONSE_REJECT,
2474 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2478 GTK_RESPONSE_REJECT,
2480 GTK_RESPONSE_ACCEPT,
2482 #endif /* MODEST_PLATFORM_MAEMO */
2484 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
2486 gchar *server_name = modest_server_account_get_hostname (
2487 modest_runtime_get_account_mgr(), server_account_name);
2488 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
2489 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
2494 /* This causes a warning because the logical ID has no %s in it,
2495 * though the translation does, but there is not much we can do about that: */
2496 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
2497 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
2500 g_free (server_name);
2504 gchar *initial_username = modest_server_account_get_username (
2505 modest_runtime_get_account_mgr(), server_account_name);
2507 GtkWidget *entry_username = gtk_entry_new ();
2508 if (initial_username)
2509 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
2510 /* Dim this if a connection has ever succeeded with this username,
2511 * as per the UI spec: */
2512 const gboolean username_known =
2513 modest_server_account_get_username_has_succeeded(
2514 modest_runtime_get_account_mgr(), server_account_name);
2515 gtk_widget_set_sensitive (entry_username, !username_known);
2517 #ifdef MODEST_PLATFORM_MAEMO
2518 /* Auto-capitalization is the default, so let's turn it off: */
2519 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
2521 /* Create a size group to be used by all captions.
2522 * Note that HildonCaption does not create a default size group if we do not specify one.
2523 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
2524 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2526 GtkWidget *caption = hildon_caption_new (sizegroup,
2527 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
2528 gtk_widget_show (entry_username);
2529 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2530 FALSE, FALSE, MODEST_MARGIN_HALF);
2531 gtk_widget_show (caption);
2533 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
2535 #endif /* MODEST_PLATFORM_MAEMO */
2538 GtkWidget *entry_password = gtk_entry_new ();
2539 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
2540 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
2542 #ifdef MODEST_PLATFORM_MAEMO
2543 /* Auto-capitalization is the default, so let's turn it off: */
2544 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
2545 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
2547 caption = hildon_caption_new (sizegroup,
2548 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
2549 gtk_widget_show (entry_password);
2550 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2551 FALSE, FALSE, MODEST_MARGIN_HALF);
2552 gtk_widget_show (caption);
2553 g_object_unref (sizegroup);
2555 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
2557 #endif /* MODEST_PLATFORM_MAEMO */
2559 /* This is not in the Maemo UI spec:
2560 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
2561 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
2565 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2567 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2569 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
2571 modest_server_account_set_username (
2572 modest_runtime_get_account_mgr(), server_account_name,
2575 const gboolean username_was_changed =
2576 (strcmp (*username, initial_username) != 0);
2577 if (username_was_changed) {
2578 g_warning ("%s: tinymail does not yet support changing the "
2579 "username in the get_password() callback.\n", __FUNCTION__);
2584 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
2586 /* We do not save the password in the configuration,
2587 * because this function is only called for passwords that should
2588 * not be remembered:
2589 modest_server_account_set_password (
2590 modest_runtime_get_account_mgr(), server_account_name,
2599 show_error(GTK_WIDGET (main_window), _("mail_ib_login_cancelled"));
2611 /* This is not in the Maemo UI spec:
2612 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
2618 gtk_widget_destroy (dialog);
2620 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
2624 modest_ui_actions_on_cut (GtkAction *action,
2625 ModestWindow *window)
2627 GtkWidget *focused_widget;
2629 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2630 if (GTK_IS_EDITABLE (focused_widget)) {
2631 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
2632 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2633 GtkTextBuffer *buffer;
2634 GtkClipboard *clipboard;
2636 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2637 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2638 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
2639 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2640 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2641 modest_header_view_cut_selection (MODEST_HEADER_VIEW (focused_widget));
2642 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2643 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
2648 modest_ui_actions_on_copy (GtkAction *action,
2649 ModestWindow *window)
2651 GtkClipboard *clipboard;
2652 GtkWidget *focused_widget;
2654 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2655 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2657 if (GTK_IS_LABEL (focused_widget)) {
2658 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
2659 } else if (GTK_IS_EDITABLE (focused_widget)) {
2660 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
2661 } else if (GTK_IS_HTML (focused_widget)) {
2662 gtk_html_copy (GTK_HTML (focused_widget));
2663 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2664 GtkTextBuffer *buffer;
2665 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2666 gtk_text_buffer_copy_clipboard (buffer, clipboard);
2667 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2668 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2669 TnyList *header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (focused_widget));
2670 TnyIterator *iter = tny_list_create_iterator (header_list);
2671 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
2673 gboolean ask = FALSE;
2675 TnyFolder *folder = tny_header_get_folder (header);
2676 TnyAccount *account = tny_folder_get_account (folder);
2677 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2678 /* If it's POP then ask */
2679 ask = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2680 MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
2681 g_object_unref (account);
2682 g_object_unref (folder);
2683 g_object_unref (header);
2686 g_object_unref (iter);
2688 /* Check that the messages have been previously downloaded */
2689 gboolean continue_download = TRUE;
2691 continue_download = download_uncached_messages (header_list, GTK_WINDOW (window), FALSE);
2692 if (continue_download)
2693 modest_header_view_copy_selection (MODEST_HEADER_VIEW (focused_widget));
2694 g_object_unref (header_list);
2695 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2696 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
2699 /* Show information banner */
2700 modest_platform_information_banner (NULL, NULL, _CS("ecoc_ib_edwin_copied"));
2705 modest_ui_actions_on_undo (GtkAction *action,
2706 ModestWindow *window)
2708 ModestEmailClipboard *clipboard = NULL;
2710 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2711 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2712 } else if (MODEST_IS_MAIN_WINDOW (window)) {
2713 /* Clear clipboard source */
2714 clipboard = modest_runtime_get_email_clipboard ();
2715 modest_email_clipboard_clear (clipboard);
2718 g_return_if_reached ();
2723 modest_ui_actions_on_redo (GtkAction *action,
2724 ModestWindow *window)
2726 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2727 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
2730 g_return_if_reached ();
2736 paste_msgs_cb (const GObject *object, gpointer user_data)
2738 g_return_if_fail (MODEST_IS_MAIN_WINDOW (object));
2739 g_return_if_fail (GTK_IS_WIDGET (user_data));
2741 /* destroy information note */
2742 gtk_widget_destroy (GTK_WIDGET(user_data));
2746 modest_ui_actions_on_paste (GtkAction *action,
2747 ModestWindow *window)
2749 GtkWidget *focused_widget = NULL;
2750 GtkWidget *inf_note = NULL;
2751 ModestMailOperation *mail_op = NULL;
2753 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2754 if (GTK_IS_EDITABLE (focused_widget)) {
2755 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
2756 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2757 GtkTextBuffer *buffer;
2758 GtkClipboard *clipboard;
2760 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2761 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2762 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
2763 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2764 ModestEmailClipboard *clipboard = NULL;
2765 TnyFolder *src_folder = NULL;
2766 TnyFolderStore *folder_store = NULL;
2767 TnyList *data = NULL;
2768 gboolean delete = FALSE;
2770 /* Check clipboard source */
2771 clipboard = modest_runtime_get_email_clipboard ();
2772 if (modest_email_clipboard_cleared (clipboard))
2775 /* Get elements to paste */
2776 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
2778 /* Create a new mail operation */
2779 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
2780 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2783 /* Get destination folder */
2784 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
2786 /* Launch notification */
2787 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
2788 _CS("ckct_nw_pasting"));
2789 if (inf_note != NULL) {
2790 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
2791 gtk_widget_show (GTK_WIDGET(inf_note));
2794 /* transfer messages */
2796 modest_mail_operation_xfer_msgs (mail_op,
2798 TNY_FOLDER (folder_store),
2803 } else if (src_folder != NULL) {
2804 modest_mail_operation_xfer_folder (mail_op,
2814 g_object_unref (data);
2815 if (src_folder != NULL)
2816 g_object_unref (src_folder);
2817 if (folder_store != NULL)
2818 g_object_unref (folder_store);
2824 modest_ui_actions_on_select_all (GtkAction *action,
2825 ModestWindow *window)
2827 GtkWidget *focused_widget;
2829 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2830 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
2831 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
2832 } else if (GTK_IS_LABEL (focused_widget)) {
2833 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
2834 } else if (GTK_IS_EDITABLE (focused_widget)) {
2835 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
2836 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2837 GtkTextBuffer *buffer;
2838 GtkTextIter start, end;
2840 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2841 gtk_text_buffer_get_start_iter (buffer, &start);
2842 gtk_text_buffer_get_end_iter (buffer, &end);
2843 gtk_text_buffer_select_range (buffer, &start, &end);
2844 } else if (GTK_IS_HTML (focused_widget)) {
2845 gtk_html_select_all (GTK_HTML (focused_widget));
2846 } else if (MODEST_IS_MAIN_WINDOW (window)) {
2847 GtkWidget *header_view = focused_widget;
2848 GtkTreeSelection *selection = NULL;
2850 if (!(MODEST_IS_HEADER_VIEW (focused_widget)))
2851 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
2852 MODEST_WIDGET_TYPE_HEADER_VIEW);
2854 /* Select all messages */
2855 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
2856 gtk_tree_selection_select_all (selection);
2858 /* Set focuse on header view */
2859 gtk_widget_grab_focus (header_view);
2865 modest_ui_actions_on_mark_as_read (GtkAction *action,
2866 ModestWindow *window)
2868 g_return_if_fail (MODEST_IS_WINDOW(window));
2870 /* Mark each header as read */
2871 do_headers_action (window, headers_action_mark_as_read, NULL);
2875 modest_ui_actions_on_mark_as_unread (GtkAction *action,
2876 ModestWindow *window)
2878 g_return_if_fail (MODEST_IS_WINDOW(window));
2880 /* Mark each header as read */
2881 do_headers_action (window, headers_action_mark_as_unread, NULL);
2885 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
2886 GtkRadioAction *selected,
2887 ModestWindow *window)
2891 value = gtk_radio_action_get_current_value (selected);
2892 if (MODEST_IS_WINDOW (window)) {
2893 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
2897 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
2898 GtkRadioAction *selected,
2899 ModestWindow *window)
2901 TnyHeaderFlags flags;
2902 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2904 flags = gtk_radio_action_get_current_value (selected);
2905 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
2908 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
2909 GtkRadioAction *selected,
2910 ModestWindow *window)
2914 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2916 file_format = gtk_radio_action_get_current_value (selected);
2917 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
2922 modest_ui_actions_on_zoom_plus (GtkAction *action,
2923 ModestWindow *window)
2925 g_return_if_fail (MODEST_IS_WINDOW (window));
2927 modest_window_zoom_plus (MODEST_WINDOW (window));
2931 modest_ui_actions_on_zoom_minus (GtkAction *action,
2932 ModestWindow *window)
2934 g_return_if_fail (MODEST_IS_WINDOW (window));
2936 modest_window_zoom_minus (MODEST_WINDOW (window));
2940 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
2941 ModestWindow *window)
2943 ModestWindowMgr *mgr;
2944 gboolean fullscreen, active;
2945 g_return_if_fail (MODEST_IS_WINDOW (window));
2947 mgr = modest_runtime_get_window_mgr ();
2949 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
2950 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2952 if (active != fullscreen) {
2953 modest_window_mgr_set_fullscreen_mode (mgr, active);
2954 gtk_window_present (GTK_WINDOW (window));
2959 modest_ui_actions_on_change_fullscreen (GtkAction *action,
2960 ModestWindow *window)
2962 ModestWindowMgr *mgr;
2963 gboolean fullscreen;
2965 g_return_if_fail (MODEST_IS_WINDOW (window));
2967 mgr = modest_runtime_get_window_mgr ();
2968 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2969 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
2971 gtk_window_present (GTK_WINDOW (window));
2975 * Used by modest_ui_actions_on_details to call do_headers_action
2978 headers_action_show_details (TnyHeader *header,
2979 ModestWindow *window,
2986 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
2989 gtk_widget_show_all (dialog);
2990 gtk_dialog_run (GTK_DIALOG (dialog));
2992 gtk_widget_destroy (dialog);
2996 * Show the folder details in a ModestDetailsDialog widget
2999 show_folder_details (TnyFolder *folder,
3005 dialog = modest_details_dialog_new_with_folder (window, folder);
3008 gtk_widget_show_all (dialog);
3009 gtk_dialog_run (GTK_DIALOG (dialog));
3011 gtk_widget_destroy (dialog);
3015 * Show the header details in a ModestDetailsDialog widget
3018 modest_ui_actions_on_details (GtkAction *action,
3021 TnyList * headers_list;
3025 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3028 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
3031 g_object_unref (msg);
3033 headers_list = get_selected_headers (win);
3037 iter = tny_list_create_iterator (headers_list);
3039 header = TNY_HEADER (tny_iterator_get_current (iter));
3041 headers_action_show_details (header, win, NULL);
3042 g_object_unref (header);
3045 g_object_unref (iter);
3046 g_object_unref (headers_list);
3048 } else if (MODEST_IS_MAIN_WINDOW (win)) {
3049 GtkWidget *folder_view, *header_view;
3051 /* Check which widget has the focus */
3052 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3053 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3054 if (gtk_widget_is_focus (folder_view)) {
3055 TnyFolderStore *folder_store
3056 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3057 if (!folder_store) {
3058 g_warning ("%s: No item was selected.\n", __FUNCTION__);
3061 /* Show only when it's a folder */
3062 /* This function should not be called for account items,
3063 * because we dim the menu item for them. */
3064 if (TNY_IS_FOLDER (folder_store)) {
3065 show_folder_details (TNY_FOLDER (folder_store), GTK_WINDOW (win));
3068 g_object_unref (folder_store);
3071 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3072 MODEST_WIDGET_TYPE_HEADER_VIEW);
3073 /* Show details of each header */
3074 do_headers_action (win, headers_action_show_details, header_view);
3080 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
3081 ModestMsgEditWindow *window)
3083 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3085 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
3089 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
3090 ModestMsgEditWindow *window)
3092 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3094 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
3098 modest_ui_actions_toggle_folders_view (GtkAction *action,
3099 ModestMainWindow *main_window)
3101 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3103 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
3104 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
3106 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
3110 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
3111 ModestWindow *window)
3113 gboolean active, fullscreen = FALSE;
3114 ModestWindowMgr *mgr;
3116 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
3118 /* Check if we want to toggle the toolbar vuew in fullscreen
3120 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
3121 "ViewShowToolbarFullScreen")) {
3125 /* Toggle toolbar */
3126 mgr = modest_runtime_get_window_mgr ();
3127 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
3131 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
3132 ModestMsgEditWindow *window)
3134 modest_msg_edit_window_select_font (window);
3138 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
3139 const gchar *display_name,
3142 /* Do not change the application name if the widget has not
3143 the focus. This callback could be called even if the folder
3144 view has not the focus, because the handled signal could be
3145 emitted when the folder view is redrawn */
3146 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
3148 gtk_window_set_title (window, display_name);
3150 gtk_window_set_title (window, " ");
3155 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
3157 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3158 modest_msg_edit_window_select_contacts (window);
3162 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
3164 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3165 modest_msg_edit_window_check_names (window, FALSE);
3169 create_move_to_dialog_on_new_folder(GtkWidget *button, gpointer user_data)
3171 modest_ui_actions_create_folder (gtk_widget_get_toplevel (button),
3172 GTK_WIDGET (user_data));
3176 create_move_to_dialog (GtkWindow *win,
3177 GtkWidget *folder_view,
3178 GtkWidget **tree_view)
3180 GtkWidget *dialog, *scroll;
3181 GtkWidget *new_button;
3183 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
3185 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
3188 gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT);
3189 /* We do this manually so GTK+ does not associate a response ID for
3191 new_button = gtk_button_new_from_stock (GTK_STOCK_NEW);
3192 gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog)->action_area), new_button, FALSE, FALSE, 0);
3193 gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT);
3195 /* Create scrolled window */
3196 scroll = gtk_scrolled_window_new (NULL, NULL);
3197 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
3198 GTK_POLICY_AUTOMATIC,
3199 GTK_POLICY_AUTOMATIC);
3201 /* Create folder view */
3202 *tree_view = modest_platform_create_folder_view (NULL);
3204 g_signal_connect (G_OBJECT (new_button), "clicked", G_CALLBACK(create_move_to_dialog_on_new_folder), *tree_view);
3206 /* It could happen that we're trying to move a message from a
3207 window (msg window for example) after the main window was
3208 closed, so we can not just get the model of the folder
3210 if (MODEST_IS_FOLDER_VIEW (folder_view))
3211 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
3212 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
3214 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
3215 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
3217 modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (*tree_view), FALSE);
3219 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
3221 /* Add scroll to dialog */
3222 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
3223 scroll, TRUE, TRUE, 0);
3225 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
3226 gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 300);
3232 * Returns TRUE if at least one of the headers of the list belongs to
3233 * a message that has been fully retrieved.
3236 has_retrieved_msgs (TnyList *list)
3239 gboolean found = FALSE;
3241 iter = tny_list_create_iterator (list);
3242 while (tny_iterator_is_done (iter) && !found) {
3244 TnyHeaderFlags flags = 0;
3246 header = TNY_HEADER (tny_iterator_get_current (iter));
3248 flags = tny_header_get_flags (header);
3249 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
3252 g_object_unref (header);
3256 tny_iterator_next (iter);
3258 g_object_unref (iter);
3264 * Shows a confirmation dialog to the user when we're moving messages
3265 * from a remote server to the local storage. Returns the dialog
3266 * response. If it's other kind of movement the it always returns
3270 msgs_move_to_confirmation (GtkWindow *win,
3271 TnyFolder *dest_folder,
3274 gint response = GTK_RESPONSE_OK;
3276 /* If the destination is a local folder */
3277 if (modest_tny_folder_is_local_folder (dest_folder)) {
3278 TnyFolder *src_folder = NULL;
3279 TnyIterator *iter = NULL;
3280 TnyHeader *header = NULL;
3282 /* Get source folder */
3283 iter = tny_list_create_iterator (headers);
3284 header = TNY_HEADER (tny_iterator_get_current (iter));
3286 src_folder = tny_header_get_folder (header);
3287 g_object_unref (header);
3290 g_object_unref (iter);
3292 /* if no src_folder, message may be an attahcment */
3293 if (src_folder == NULL)
3294 return GTK_RESPONSE_CANCEL;
3296 /* If the source is a remote folder */
3297 if (!modest_tny_folder_is_local_folder (src_folder)) {
3298 const gchar *message;
3300 if (has_retrieved_msgs (headers))
3301 message = ngettext ("mcen_nc_move_retrieve", "mcen_nc_move_retrieves",
3302 tny_list_get_length (headers));
3304 message = ngettext ("mcen_nc_move_header", "mcen_nc_move_headers",
3305 tny_list_get_length (headers));
3307 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
3308 (const gchar *) message);
3311 g_object_unref (src_folder);
3320 transfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
3322 ModestMsgViewWindow *self = NULL;
3324 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
3325 self = MODEST_MSG_VIEW_WINDOW (object);
3327 if (!modest_msg_view_window_select_next_message (self))
3328 if (!modest_msg_view_window_select_previous_message (self))
3329 /* No more messages to view, so close this window */
3330 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
3334 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
3337 GObject *win = modest_mail_operation_get_source (mail_op);
3338 const GError *error = NULL;
3339 const gchar *message = NULL;
3341 /* Get error message */
3342 error = modest_mail_operation_get_error (mail_op);
3343 if (error != NULL && error->message != NULL) {
3344 message = error->message;
3346 message = _("mail_in_ui_folder_move_target_error");
3349 /* Show notification dialog */
3350 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
3351 g_object_unref (win);
3355 modest_ui_actions_send_receive_error_handler (ModestMailOperation *mail_op,
3358 GObject *win = modest_mail_operation_get_source (mail_op);
3359 const GError *error = modest_mail_operation_get_error (mail_op);
3361 g_return_if_fail (error != NULL);
3362 if (error->message != NULL)
3363 g_printerr ("modest: %s\n", error->message);
3365 g_printerr ("modest: unkonw error on send&receive operation");
3367 /* Show error message */
3368 /* if (modest_mail_operation_get_id (mail_op) == MODEST_MAIL_OPERATION_TYPE_RECEIVE) */
3369 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3370 /* _CS("sfil_ib_unable_to_receive")); */
3372 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3373 /* _CS("sfil_ib_unable_to_send")); */
3374 g_object_unref (win);
3378 open_msg_for_purge_cb (ModestMailOperation *mail_op,
3385 gint pending_purges = 0;
3386 gboolean some_purged = FALSE;
3387 ModestWindow *win = MODEST_WINDOW (user_data);
3388 ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
3390 /* If there was any error */
3391 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
3392 modest_window_mgr_unregister_header (mgr, header);
3396 /* Once the message has been retrieved for purging, we check if
3397 * it's all ok for purging */
3399 parts = tny_simple_list_new ();
3400 tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
3401 iter = tny_list_create_iterator (parts);
3403 while (!tny_iterator_is_done (iter)) {
3405 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3406 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))) {
3407 if (tny_mime_part_is_purged (part))
3414 g_object_unref (part);
3416 tny_iterator_next (iter);
3419 if (pending_purges>0) {
3421 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
3423 if (response == GTK_RESPONSE_OK) {
3424 modest_platform_information_banner (NULL, NULL, _("mcen_ib_removing_attachment"));
3425 tny_iterator_first (iter);
3426 while (!tny_iterator_is_done (iter)) {
3429 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3430 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)))
3431 tny_mime_part_set_purged (part);
3434 g_object_unref (part);
3436 tny_iterator_next (iter);
3439 tny_msg_rewrite_cache (msg);
3442 modest_platform_information_banner (NULL, NULL, _("mail_ib_attachment_already_purged"));
3445 /* remove attachments */
3446 tny_iterator_first (iter);
3447 while (!tny_iterator_is_done (iter)) {
3450 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3452 /* One for the reference given by tny_iterator_get_current(): */
3453 g_object_unref (part);
3455 /* TODO: Is this meant to remove the attachment by doing another unref()?
3456 * Otherwise, this seems useless. */
3459 tny_iterator_next (iter);
3461 modest_window_mgr_unregister_header (mgr, header);
3463 g_object_unref (iter);
3464 g_object_unref (parts);
3468 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
3469 ModestMainWindow *win)
3471 GtkWidget *header_view;
3472 TnyList *header_list;
3475 TnyHeaderFlags flags;
3476 ModestWindow *msg_view_window = NULL;
3479 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3481 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3482 MODEST_WIDGET_TYPE_HEADER_VIEW);
3484 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
3486 if (tny_list_get_length (header_list) == 1) {
3487 iter = tny_list_create_iterator (header_list);
3488 header = TNY_HEADER (tny_iterator_get_current (iter));
3489 g_object_unref (iter);
3494 found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
3495 header, &msg_view_window);
3496 flags = tny_header_get_flags (header);
3497 if (!(flags & TNY_HEADER_FLAG_CACHED))
3500 if (msg_view_window != NULL)
3501 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
3503 /* do nothing; uid was registered before, so window is probably on it's way */
3504 g_warning ("debug: header %p has already been registered", header);
3507 ModestMailOperation *mail_op = NULL;
3508 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header);
3509 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3511 modest_ui_actions_get_msgs_full_error_handler,
3513 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3514 modest_mail_operation_get_msg (mail_op, header, open_msg_for_purge_cb, win);
3516 g_object_unref (mail_op);
3519 g_object_unref (header);
3521 g_object_unref (header_list);
3525 * Utility function that transfer messages from both the main window
3526 * and the msg view window when using the "Move to" dialog
3529 modest_ui_actions_xfer_messages_from_move_to (TnyFolderStore *dst_folder,
3532 TnyList *headers = NULL;
3535 if (!TNY_IS_FOLDER (dst_folder)) {
3536 modest_platform_information_banner (GTK_WIDGET (win),
3538 _CS("ckdg_ib_unable_to_move_to_current_location"));
3542 /* Get selected headers */
3543 headers = get_selected_headers (MODEST_WINDOW (win));
3545 /* Ask for user confirmation */
3546 response = msgs_move_to_confirmation (GTK_WINDOW (win),
3547 TNY_FOLDER (dst_folder),
3550 /* Transfer messages */
3551 if (response == GTK_RESPONSE_OK) {
3552 ModestMailOperation *mail_op =
3553 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3555 modest_ui_actions_move_folder_error_handler,
3557 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3560 modest_mail_operation_xfer_msgs (mail_op,
3562 TNY_FOLDER (dst_folder),
3564 (MODEST_IS_MSG_VIEW_WINDOW (win)) ? transfer_msgs_from_viewer_cb : NULL,
3567 g_object_unref (G_OBJECT (mail_op));
3569 g_object_unref (headers);
3574 * UI handler for the "Move to" action when invoked from the
3578 modest_ui_actions_on_main_window_move_to (GtkAction *action,
3579 GtkWidget *folder_view,
3580 TnyFolderStore *dst_folder,
3581 ModestMainWindow *win)
3583 GtkWidget *header_view = NULL;
3584 ModestMailOperation *mail_op = NULL;
3585 TnyFolderStore *src_folder;
3587 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3589 /* Get the source folder */
3590 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3592 /* Offer the connection dialog if necessary, if the source folder is in a networked account: */
3593 if (!modest_platform_connect_and_wait_if_network_folderstore (GTK_WINDOW (win),
3597 /* Get header view */
3599 modest_main_window_get_child_widget (win, MODEST_WIDGET_TYPE_HEADER_VIEW);
3601 /* Get folder or messages to transfer */
3602 if (gtk_widget_is_focus (folder_view)) {
3604 /* Allow only to transfer folders to the local root folder */
3605 if (TNY_IS_ACCOUNT (dst_folder) &&
3606 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder))
3609 /* Clean folder on header view before moving it */
3610 modest_header_view_clear (MODEST_HEADER_VIEW (header_view));
3612 if (TNY_IS_FOLDER (src_folder)) {
3614 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3616 modest_ui_actions_move_folder_error_handler,
3618 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3621 modest_mail_operation_xfer_folder (mail_op,
3622 TNY_FOLDER (src_folder),
3625 /* Unref mail operation */
3626 g_object_unref (G_OBJECT (mail_op));
3628 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
3630 } else if (gtk_widget_is_focus (header_view)) {
3631 /* Transfer messages */
3632 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
3637 g_object_unref (src_folder);
3642 * UI handler for the "Move to" action when invoked from the
3643 * ModestMsgViewWindow
3646 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
3647 TnyFolderStore *dst_folder,
3648 ModestMsgViewWindow *win)
3650 TnyHeader *header = NULL;
3651 TnyFolder *src_folder;
3653 /* Create header list */
3654 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
3655 src_folder = tny_header_get_folder(header);
3656 g_object_unref (header);
3658 /* Transfer the message */
3659 if (modest_platform_connect_and_wait_if_network_folderstore (NULL, TNY_FOLDER_STORE (src_folder)))
3660 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
3662 g_object_unref (src_folder);
3666 modest_ui_actions_on_move_to (GtkAction *action,
3669 GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
3671 TnyFolderStore *dst_folder = NULL;
3672 ModestMainWindow *main_window;
3674 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
3675 MODEST_IS_MSG_VIEW_WINDOW (win));
3677 /* Get the main window if exists */
3678 if (MODEST_IS_MAIN_WINDOW (win))
3679 main_window = MODEST_MAIN_WINDOW (win);
3682 MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
3684 /* Get the folder view widget if exists */
3686 folder_view = modest_main_window_get_child_widget (main_window,
3687 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3691 /* Create and run the dialog */
3692 dialog = create_move_to_dialog (GTK_WINDOW (win), folder_view, &tree_view);
3693 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
3694 result = gtk_dialog_run (GTK_DIALOG(dialog));
3695 g_object_ref (tree_view);
3696 gtk_widget_destroy (dialog);
3698 if (result != GTK_RESPONSE_ACCEPT)
3701 dst_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
3702 /* Offer the connection dialog if necessary: */
3703 if (modest_platform_connect_and_wait_if_network_folderstore (GTK_WINDOW (win),
3706 /* Do window specific stuff */
3707 if (MODEST_IS_MAIN_WINDOW (win))
3708 modest_ui_actions_on_main_window_move_to (action,
3711 MODEST_MAIN_WINDOW (win));
3713 modest_ui_actions_on_msg_view_window_move_to (action,
3715 MODEST_MSG_VIEW_WINDOW (win));
3718 g_object_unref (dst_folder);
3722 * Calls #HeadersFunc for each header already selected in the main
3723 * window or the message currently being shown in the msg view window
3726 do_headers_action (ModestWindow *win,
3730 TnyList *headers_list = NULL;
3731 TnyIterator *iter = NULL;
3732 TnyHeader *header = NULL;
3733 TnyFolder *folder = NULL;
3736 headers_list = get_selected_headers (win);
3740 /* Get the folder */
3741 iter = tny_list_create_iterator (headers_list);
3742 header = TNY_HEADER (tny_iterator_get_current (iter));
3744 folder = tny_header_get_folder (header);
3745 g_object_unref (header);
3748 /* Call the function for each header */
3749 while (!tny_iterator_is_done (iter)) {
3750 header = TNY_HEADER (tny_iterator_get_current (iter));
3751 func (header, win, user_data);
3752 g_object_unref (header);
3753 tny_iterator_next (iter);
3756 /* Trick: do a poke status in order to speed up the signaling
3758 tny_folder_poke_status (folder);
3761 g_object_unref (folder);
3762 g_object_unref (iter);
3763 g_object_unref (headers_list);
3767 modest_ui_actions_view_attachment (GtkAction *action,
3768 ModestWindow *window)
3770 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3771 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
3773 /* not supported window for this action */
3774 g_return_if_reached ();
3779 modest_ui_actions_save_attachments (GtkAction *action,
3780 ModestWindow *window)
3782 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3783 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
3785 /* not supported window for this action */
3786 g_return_if_reached ();
3791 modest_ui_actions_remove_attachments (GtkAction *action,
3792 ModestWindow *window)
3794 if (MODEST_IS_MAIN_WINDOW (window)) {
3795 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
3796 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3797 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
3799 /* not supported window for this action */
3800 g_return_if_reached ();
3805 modest_ui_actions_on_settings (GtkAction *action,
3810 dialog = modest_platform_get_global_settings_dialog ();
3811 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
3812 gtk_widget_show_all (dialog);
3814 gtk_dialog_run (GTK_DIALOG (dialog));
3816 gtk_widget_destroy (dialog);
3820 modest_ui_actions_on_help (GtkAction *action,
3823 const gchar *help_id = NULL;
3825 if (MODEST_IS_MAIN_WINDOW (win)) {
3826 const gchar *action_name;
3827 action_name = gtk_action_get_name (action);
3829 if (!strcmp (action_name, "FolderViewCSMHelp") ||
3830 !strcmp (action_name, "HeaderViewCSMHelp")) {
3831 GtkWidget *folder_view;
3832 TnyFolderStore *folder_store;
3833 /* Get selected folder */
3834 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3835 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3836 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3838 /* Switch help_id */
3839 if (TNY_IS_FOLDER (folder_store)) {
3840 switch (modest_tny_folder_guess_folder_type (TNY_FOLDER (folder_store))) {
3841 case TNY_FOLDER_TYPE_NORMAL:
3842 help_id = "applications_email_managefolders";
3844 case TNY_FOLDER_TYPE_INBOX:
3845 help_id = "applications_email_inbox";
3847 case TNY_FOLDER_TYPE_OUTBOX:
3848 help_id = "applications_email_outbox";
3850 case TNY_FOLDER_TYPE_SENT:
3851 help_id = "applications_email_sent";
3853 case TNY_FOLDER_TYPE_DRAFTS:
3854 help_id = "applications_email_drafts";
3856 case TNY_FOLDER_TYPE_ARCHIVE:
3857 help_id = "applications_email_managefolders";
3860 help_id = "applications_email_managefolders";
3863 help_id = "applications_email_mainview";
3865 g_object_unref (folder_store);
3867 help_id = "applications_email_mainview";
3869 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3870 help_id = "applications_email_viewer";
3871 } else if (MODEST_IS_MSG_EDIT_WINDOW (win))
3872 help_id = "applications_email_editor";
3874 modest_platform_show_help (GTK_WINDOW (win), help_id);
3878 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
3879 ModestWindow *window)
3881 ModestMailOperation *mail_op;
3885 headers = get_selected_headers (window);
3889 /* Create mail operation */
3890 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3892 modest_ui_actions_get_msgs_full_error_handler,
3894 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3895 modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
3898 g_object_unref (headers);
3899 g_object_unref (mail_op);
3903 modest_ui_actions_on_email_menu_activated (GtkAction *action,
3904 ModestWindow *window)
3906 g_return_if_fail (MODEST_IS_WINDOW (window));
3909 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3913 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
3914 ModestWindow *window)
3916 g_return_if_fail (MODEST_IS_WINDOW (window));
3919 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3923 modest_ui_actions_on_view_menu_activated (GtkAction *action,
3924 ModestWindow *window)
3926 g_return_if_fail (MODEST_IS_WINDOW (window));
3929 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3933 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
3934 ModestWindow *window)
3936 g_return_if_fail (MODEST_IS_WINDOW (window));
3939 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3943 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
3944 ModestWindow *window)
3946 g_return_if_fail (MODEST_IS_WINDOW (window));
3949 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3953 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
3954 ModestWindow *window)
3956 g_return_if_fail (MODEST_IS_WINDOW (window));
3959 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3963 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
3964 ModestWindow *window)
3966 g_return_if_fail (MODEST_IS_WINDOW (window));
3969 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3973 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
3974 ModestWindow *window)
3976 g_return_if_fail (MODEST_IS_WINDOW (window));
3979 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3983 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
3985 g_return_if_fail (MODEST_IS_WINDOW (window));
3988 modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
3992 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
3994 g_return_if_fail (MODEST_IS_WINDOW (window));
3996 modest_platform_show_search_messages (GTK_WINDOW (window));
4000 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
4002 g_return_if_fail (MODEST_IS_WINDOW (win));
4003 modest_platform_show_addressbook (GTK_WINDOW (win));
4008 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
4009 ModestWindow *window)
4011 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4013 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
4017 _on_send_receive_progress_changed (ModestMailOperation *mail_op,
4018 ModestMailOperationState *state,
4021 g_return_if_fail (MODEST_IS_MAIN_WINDOW(user_data));
4023 /* Set send/receive operation finished */
4024 if (state->status != MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
4025 modest_main_window_notify_send_receive_completed (MODEST_MAIN_WINDOW(user_data));