1 /* Copyright (c) 2006, Nokia Corporation
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * * Neither the name of the Nokia Corporation nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
18 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
20 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
21 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 #endif /*HAVE_CONFIG_H*/
34 #include <glib/gi18n.h>
35 #include <glib/gprintf.h>
37 #include <modest-runtime.h>
38 #include <modest-tny-folder.h>
39 #include <modest-tny-msg.h>
40 #include <modest-tny-account.h>
41 #include <modest-address-book.h>
42 #include "modest-error.h"
43 #include "modest-ui-actions.h"
45 #include "modest-tny-platform-factory.h"
46 #include "modest-platform.h"
48 #ifdef MODEST_PLATFORM_MAEMO
49 #include "maemo/modest-osso-state-saving.h"
50 #endif /* MODEST_PLATFORM_MAEMO */
52 #include "widgets/modest-ui-constants.h"
53 #include <widgets/modest-main-window.h>
54 #include <widgets/modest-msg-view-window.h>
55 #include <widgets/modest-account-view-window.h>
56 #include <widgets/modest-details-dialog.h>
57 #include <widgets/modest-attachments-view.h>
58 #include "widgets/modest-folder-view.h"
59 #include "widgets/modest-global-settings-dialog.h"
60 #include "modest-connection-specific-smtp-window.h"
61 #include "modest-account-mgr-helpers.h"
62 #include "modest-mail-operation.h"
63 #include "modest-text-utils.h"
65 #ifdef MODEST_HAVE_EASYSETUP
66 #include "easysetup/modest-easysetup-wizard.h"
67 #endif /* MODEST_HAVE_EASYSETUP */
69 #include <modest-widget-memory.h>
70 #include <tny-error.h>
71 #include <tny-simple-list.h>
72 #include <tny-msg-view.h>
73 #include <tny-device.h>
74 #include <tny-merge-folder.h>
76 typedef struct _GetMsgAsyncHelper {
78 ModestMailOperation *mail_op;
85 typedef enum _ReplyForwardAction {
91 typedef struct _ReplyForwardHelper {
92 guint reply_forward_type;
93 ReplyForwardAction action;
95 GtkWidget *parent_window;
99 * The do_headers_action uses this kind of functions to perform some
100 * action to each member of a list of headers
102 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
105 do_headers_action (ModestWindow *win,
110 static void open_msg_cb (ModestMailOperation *mail_op,
115 static void reply_forward_cb (ModestMailOperation *mail_op,
120 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
122 static gchar* ask_for_folder_name (GtkWindow *parent_window, const gchar *title);
125 static void _on_send_receive_progress_changed (ModestMailOperation *mail_op,
126 ModestMailOperationState *state,
132 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
135 const gchar *authors[] = {
136 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
139 about = gtk_about_dialog_new ();
140 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
141 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
142 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
143 _("Copyright (c) 2006, Nokia Corporation\n"
144 "All rights reserved."));
145 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
146 _("a modest e-mail client\n\n"
147 "design and implementation: Dirk-Jan C. Binnema\n"
148 "contributions from the fine people at KC and Ig\n"
149 "uses the tinymail email framework written by Philip van Hoof"));
150 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
151 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
153 gtk_dialog_run (GTK_DIALOG (about));
154 gtk_widget_destroy(about);
158 * Gets the list of currently selected messages. If the win is the
159 * main window, then it returns a newly allocated list of the headers
160 * selected in the header view. If win is the msg view window, then
161 * the value returned is a list with just a single header.
163 * The caller of this funcion must free the list.
166 get_selected_headers (ModestWindow *win)
168 if (MODEST_IS_MAIN_WINDOW(win)) {
169 GtkWidget *header_view;
171 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
172 MODEST_WIDGET_TYPE_HEADER_VIEW);
173 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
175 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
176 /* for MsgViewWindows, we simply return a list with one element */
178 TnyList *list = NULL;
180 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
181 if (header != NULL) {
182 list = tny_simple_list_new ();
183 tny_list_prepend (list, G_OBJECT(header));
184 g_object_unref (G_OBJECT(header));
194 headers_action_mark_as_read (TnyHeader *header,
198 TnyHeaderFlags flags;
200 g_return_if_fail (TNY_IS_HEADER(header));
202 flags = tny_header_get_flags (header);
203 if (flags & TNY_HEADER_FLAG_SEEN) return;
204 tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN);
208 headers_action_mark_as_unread (TnyHeader *header,
212 TnyHeaderFlags flags;
214 g_return_if_fail (TNY_IS_HEADER(header));
216 flags = tny_header_get_flags (header);
217 if (flags & TNY_HEADER_FLAG_SEEN) {
218 tny_header_unset_flags (header, TNY_HEADER_FLAG_SEEN);
224 headers_action_delete (TnyHeader *header,
228 ModestMailOperation *mail_op = NULL;
230 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE, G_OBJECT(win));
231 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
234 /* Always delete. TODO: Move to trash still not supported */
235 modest_mail_operation_remove_msg (mail_op, header, FALSE);
236 g_object_unref (G_OBJECT (mail_op));
240 modest_ui_actions_on_delete (GtkAction *action, ModestWindow *win)
242 TnyList *header_list = NULL;
243 TnyIterator *iter = NULL;
244 TnyHeader *header = NULL;
245 gchar *message = NULL;
249 ModestWindowMgr *mgr;
251 g_return_if_fail (MODEST_IS_WINDOW(win));
253 header_list = get_selected_headers (win);
254 if (!header_list) return;
256 /* Check if any of the headers is already opened */
257 iter = tny_list_create_iterator (header_list);
259 mgr = modest_runtime_get_window_mgr ();
260 while (!tny_iterator_is_done (iter) && !found) {
261 header = TNY_HEADER (tny_iterator_get_current (iter));
262 if (modest_window_mgr_find_window_by_header (mgr, header))
264 g_object_unref (header);
265 tny_iterator_next (iter);
267 g_object_unref (iter);
272 num = g_strdup_printf ("%d", tny_list_get_length (header_list));
273 msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"), num);
275 modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
279 g_object_unref (header_list);
284 if (tny_list_get_length(header_list) > 1)
285 message = g_strdup(_("emev_nc_delete_messages"));
287 iter = tny_list_create_iterator (header_list);
288 header = TNY_HEADER (tny_iterator_get_current (iter));
289 desc = g_strdup_printf ("%s", tny_header_get_subject (header));
290 message = g_strdup_printf(_("emev_nc_delete_message"), desc);
291 g_object_unref (header);
292 g_object_unref (iter);
295 /* Confirmation dialog */
296 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
300 if (response == GTK_RESPONSE_OK) {
301 if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
303 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
307 /* Remove each header */
308 do_headers_action (win, headers_action_delete, NULL);
310 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
311 gtk_widget_destroy (GTK_WIDGET(win));
318 g_object_unref (header_list);
323 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
325 #ifdef MODEST_PLATFORM_MAEMO
326 modest_osso_save_state();
327 #endif /* MODEST_PLATFORM_MAEMO */
333 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
335 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
336 gtk_widget_destroy (GTK_WIDGET (win));
337 } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
339 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
340 } else if (MODEST_IS_WINDOW (win)) {
341 gtk_widget_destroy (GTK_WIDGET (win));
343 g_return_if_reached ();
348 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
350 GtkClipboard *clipboard = NULL;
351 gchar *selection = NULL;
353 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
354 selection = gtk_clipboard_wait_for_text (clipboard);
356 /* Question: why is the clipboard being used here?
357 * It doesn't really make a lot of sense. */
361 modest_address_book_add_address (selection);
367 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
369 /* This is currently only implemented for Maemo,
370 * because it requires a providers preset file which is not publically available.
372 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
373 gboolean accounts_exist = modest_account_mgr_has_accounts(
374 modest_runtime_get_account_mgr(), TRUE);
376 if (!accounts_exist) {
377 /* If there are no accounts yet, just show the easy-setup wizard, as per the UI spec: */
378 ModestEasysetupWizardDialog *wizard = modest_easysetup_wizard_dialog_new ();
379 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
380 gtk_dialog_run (GTK_DIALOG (wizard));
381 gtk_widget_destroy (GTK_WIDGET (wizard));
383 /* Show the list of accounts: */
384 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
385 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW(win));
386 gtk_dialog_run (account_win);
387 gtk_widget_destroy (GTK_WIDGET(account_win));
390 GtkWidget *dialog, *label;
392 /* Create the widgets */
394 dialog = gtk_dialog_new_with_buttons ("Message",
396 GTK_DIALOG_DESTROY_WITH_PARENT,
400 label = gtk_label_new ("Hello World!");
402 /* Ensure that the dialog box is destroyed when the user responds. */
404 g_signal_connect_swapped (dialog, "response",
405 G_CALLBACK (gtk_widget_destroy),
408 /* Add the label, and show everything we've added to the dialog. */
410 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
412 gtk_widget_show_all (dialog);
413 #endif /* MODEST_PLATFORM_MAEMO */
417 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
419 ModestWindow *main_window = MODEST_WINDOW (user_data);
421 /* Save any changes. */
422 modest_connection_specific_smtp_window_save_server_accounts (
423 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window),
424 modest_window_get_active_account (main_window));
425 gtk_widget_destroy (GTK_WIDGET (window));
429 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
431 /* This is currently only implemented for Maemo,
432 * because it requires an API (libconic) to detect different connection
435 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
437 /* Create the window if necessary: */
438 const gchar *active_account_name = modest_window_get_active_account (win);
440 /* TODO: Dim the menu item (not in the UI spec)? or show a warning,
441 * or show the default account?
442 * If we show the default account then the account name should be shown in
443 * the window when we show it. */
444 if (!active_account_name) {
445 g_warning ("%s: No account is active.", __FUNCTION__);
449 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
450 modest_connection_specific_smtp_window_fill_with_connections (
451 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
452 modest_runtime_get_account_mgr(),
453 active_account_name);
455 /* Show the window: */
456 gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
457 gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
458 gtk_widget_show (specific_window);
460 /* Save changes when the window is hidden: */
461 g_signal_connect (specific_window, "hide",
462 G_CALLBACK (on_smtp_servers_window_hide), win);
463 #endif /* MODEST_PLATFORM_MAEMO */
467 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
469 ModestWindow *msg_win;
471 TnyFolder *folder = NULL;
472 gchar *account_name = NULL;
473 gchar *from_str = NULL;
474 /* GError *err = NULL; */
475 TnyAccount *account = NULL;
476 ModestWindowMgr *mgr;
477 gchar *signature = NULL, *blank_and_signature = NULL;
479 account_name = g_strdup(modest_window_get_active_account (win));
481 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
483 g_printerr ("modest: no account found\n");
487 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
489 TNY_ACCOUNT_TYPE_STORE);
491 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
495 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
497 g_printerr ("modest: failed get from string for '%s'\n", account_name);
501 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr (), account_name,
502 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
503 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (), account_name,
504 MODEST_ACCOUNT_SIGNATURE, FALSE);
505 blank_and_signature = g_strconcat ("\n", signature, NULL);
508 blank_and_signature = g_strdup ("");
511 msg = modest_tny_msg_new ("", from_str, "", "", "", blank_and_signature, NULL);
513 g_printerr ("modest: failed to create new msg\n");
517 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
519 g_printerr ("modest: failed to find Drafts folder\n");
523 /* tny_folder_add_msg (folder, msg, &err); */
525 /* g_printerr ("modest: error adding msg to Drafts folder: %s", */
527 /* g_error_free (err); */
531 /* Create and register edit window */
532 /* This is destroyed by TOOD. */
533 msg_win = modest_msg_edit_window_new (msg, account_name);
534 mgr = modest_runtime_get_window_mgr ();
535 modest_window_mgr_register_window (mgr, msg_win);
538 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
540 gtk_widget_show_all (GTK_WIDGET (msg_win));
543 g_free (account_name);
545 g_free (blank_and_signature);
547 g_object_unref (G_OBJECT(account));
549 g_object_unref (G_OBJECT(msg));
551 g_object_unref (G_OBJECT(folder));
555 open_msg_cb (ModestMailOperation *mail_op,
560 ModestWindowMgr *mgr = NULL;
561 ModestWindow *parent_win = NULL;
562 ModestWindow *win = NULL;
563 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
564 gchar *account = NULL;
567 /* TODO: Show an error? (review the specs) */
571 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
572 folder = tny_header_get_folder (header);
574 /* Mark header as read */
575 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
578 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
580 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
582 /* Gets folder type (OUTBOX headers will be opened in edit window */
583 if (modest_tny_folder_is_local_folder (folder))
584 folder_type = modest_tny_folder_get_local_folder_type (folder);
586 /* If the header is in the drafts folder then open the editor,
587 else the message view window */
588 if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
589 win = modest_msg_edit_window_new (msg, account);
591 gchar *uid = modest_tny_folder_get_header_unique_id (header);
593 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
594 GtkWidget *header_view;
595 GtkTreeSelection *sel;
596 GList *sel_list = NULL;
599 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
600 MODEST_WIDGET_TYPE_HEADER_VIEW);
602 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
603 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
605 if (sel_list != NULL) {
606 GtkTreeRowReference *row_reference;
608 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
609 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
610 g_list_free (sel_list);
612 win = modest_msg_view_window_new_with_header_model (msg,
617 gtk_tree_row_reference_free (row_reference);
619 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
622 win = modest_msg_view_window_new (msg, account, (const gchar*) uid);
627 /* Register and show new window */
629 mgr = modest_runtime_get_window_mgr ();
630 modest_window_mgr_register_window (mgr, win);
631 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
632 gtk_widget_show_all (GTK_WIDGET(win));
637 g_object_unref (msg);
638 g_object_unref (folder);
639 g_object_unref (header);
643 * This function is the error handler of the
644 * modest_mail_operation_get_msgs_full operation
647 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
652 error = modest_mail_operation_get_error (mail_op);
653 if (error->code == MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT) {
654 GObject *win = modest_mail_operation_get_source (mail_op);
656 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
662 * This function is used by both modest_ui_actions_on_open and
663 * modest_ui_actions_on_header_activated. This way we always do the
664 * same when trying to open messages.
667 _modest_ui_actions_open (TnyList *headers, ModestWindow *win)
669 ModestWindowMgr *mgr;
671 ModestMailOperation *mail_op;
672 TnyList *not_opened_headers;
674 /* Look if we already have a message view for each header. If
675 true, then remove the header from the list of headers to
677 mgr = modest_runtime_get_window_mgr ();
678 iter = tny_list_create_iterator (headers);
679 not_opened_headers = tny_simple_list_new ();
680 while (!tny_iterator_is_done (iter)) {
681 ModestWindow *window;
684 header = TNY_HEADER (tny_iterator_get_current (iter));
685 window = modest_window_mgr_find_window_by_header (mgr, header);
686 /* Do not open again the message and present the
687 window to the user */
689 gtk_window_present (GTK_WINDOW (window));
691 tny_list_append (not_opened_headers, G_OBJECT (header));
693 g_object_unref (header);
694 tny_iterator_next (iter);
697 /* Open each message */
698 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
700 modest_ui_actions_get_msgs_full_error_handler,
702 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
703 modest_mail_operation_get_msgs_full (mail_op,
709 g_object_unref (not_opened_headers);
710 g_object_unref (iter);
711 g_object_unref (mail_op);
715 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
720 headers = get_selected_headers (win);
725 _modest_ui_actions_open (headers, win);
727 g_object_unref(headers);
732 free_reply_forward_helper (gpointer data)
734 ReplyForwardHelper *helper;
736 helper = (ReplyForwardHelper *) data;
737 g_free (helper->account_name);
738 g_slice_free (ReplyForwardHelper, helper);
742 reply_forward_cb (ModestMailOperation *mail_op,
748 ReplyForwardHelper *rf_helper;
749 ModestWindow *msg_win;
750 ModestEditType edit_type;
752 TnyAccount *account = NULL;
753 ModestWindowMgr *mgr;
754 gchar *signature = NULL;
756 g_return_if_fail (user_data != NULL);
757 rf_helper = (ReplyForwardHelper *) user_data;
759 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
760 rf_helper->account_name);
761 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
762 rf_helper->account_name,
763 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
764 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
765 rf_helper->account_name,
766 MODEST_ACCOUNT_SIGNATURE, FALSE);
769 /* Create reply mail */
770 switch (rf_helper->action) {
773 modest_tny_msg_create_reply_msg (msg, from, signature,
774 rf_helper->reply_forward_type,
775 MODEST_TNY_MSG_REPLY_MODE_SENDER);
777 case ACTION_REPLY_TO_ALL:
779 modest_tny_msg_create_reply_msg (msg, from, signature, rf_helper->reply_forward_type,
780 MODEST_TNY_MSG_REPLY_MODE_ALL);
781 edit_type = MODEST_EDIT_TYPE_REPLY;
785 modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
786 edit_type = MODEST_EDIT_TYPE_FORWARD;
789 g_return_if_reached ();
796 g_printerr ("modest: failed to create message\n");
800 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
801 rf_helper->account_name,
802 TNY_ACCOUNT_TYPE_STORE);
804 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
808 /* Create and register the windows */
809 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
810 mgr = modest_runtime_get_window_mgr ();
811 modest_window_mgr_register_window (mgr, msg_win);
813 if (rf_helper->parent_window != NULL) {
816 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
817 modest_window_set_zoom (msg_win, parent_zoom);
820 /* Show edit window */
821 gtk_widget_show_all (GTK_WIDGET (msg_win));
825 g_object_unref (G_OBJECT (new_msg));
827 g_object_unref (G_OBJECT (account));
828 g_object_unref (msg);
829 g_object_unref (header);
833 * Checks a list of headers. If any of them are not currently
834 * downloaded (CACHED) then it asks the user for permission to
837 * Returns FALSE if the user does not want to download the
838 * messages. Returns TRUE if the user allowed the download or if all
839 * of them are currently downloaded
842 download_uncached_messages (TnyList *header_list, GtkWindow *win)
845 gboolean found, retval;
847 iter = tny_list_create_iterator (header_list);
849 while (!tny_iterator_is_done (iter) && !found) {
851 TnyHeaderFlags flags;
853 header = TNY_HEADER (tny_iterator_get_current (iter));
854 flags = tny_header_get_flags (header);
855 /* TODO: is this the right flag?, it seems that some
856 headers that have been previously downloaded do not
858 found = !(flags & TNY_HEADER_FLAG_CACHED);
859 g_object_unref (header);
860 tny_iterator_next (iter);
862 g_object_unref (iter);
864 /* Ask for user permission to download the messages */
867 GtkResponseType response;
869 modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
870 _("mcen_nc_get_multi_msg_txt"));
871 if (response == GTK_RESPONSE_CANCEL)
879 * Common code for the reply and forward actions
882 reply_forward (ReplyForwardAction action, ModestWindow *win)
884 ModestMailOperation *mail_op = NULL;
885 TnyList *header_list = NULL;
886 ReplyForwardHelper *rf_helper = NULL;
887 guint reply_forward_type;
888 gboolean continue_download;
890 g_return_if_fail (MODEST_IS_WINDOW(win));
892 header_list = get_selected_headers (win);
896 /* Check that the messages have been previously downloaded */
897 continue_download = download_uncached_messages (header_list, GTK_WINDOW (win));
898 if (!continue_download) {
899 g_object_unref (header_list);
904 modest_conf_get_int (modest_runtime_get_conf (),
905 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
907 /* We assume that we can only select messages of the
908 same folder and that we reply all of them from the
909 same account. In fact the interface currently only
910 allows single selection */
913 rf_helper = g_slice_new0 (ReplyForwardHelper);
914 rf_helper->reply_forward_type = reply_forward_type;
915 rf_helper->action = action;
916 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
917 if ((win != NULL) && (MODEST_IS_WINDOW (win)))
918 rf_helper->parent_window = GTK_WIDGET (win);
919 if (!rf_helper->account_name)
920 rf_helper->account_name =
921 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
923 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
926 /* Get header and message. Do not free them here, the
927 reply_forward_cb must do it */
928 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
929 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
930 if (!msg || !header) {
932 g_object_unref (msg);
934 g_object_unref (header);
935 g_printerr ("modest: no message found\n");
938 reply_forward_cb (NULL, header, msg, rf_helper);
940 /* Retrieve messages */
941 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
943 modest_ui_actions_get_msgs_full_error_handler,
945 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
946 modest_mail_operation_get_msgs_full (mail_op,
950 free_reply_forward_helper);
953 g_object_unref(mail_op);
957 g_object_unref (header_list);
961 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
963 g_return_if_fail (MODEST_IS_WINDOW(win));
965 reply_forward (ACTION_REPLY, win);
969 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
971 g_return_if_fail (MODEST_IS_WINDOW(win));
973 reply_forward (ACTION_FORWARD, win);
977 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
979 g_return_if_fail (MODEST_IS_WINDOW(win));
981 reply_forward (ACTION_REPLY_TO_ALL, win);
985 modest_ui_actions_on_next (GtkAction *action,
986 ModestWindow *window)
988 if (MODEST_IS_MAIN_WINDOW (window)) {
989 GtkWidget *header_view;
991 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
992 MODEST_WIDGET_TYPE_HEADER_VIEW);
996 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
997 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
998 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
1000 g_return_if_reached ();
1005 modest_ui_actions_on_prev (GtkAction *action,
1006 ModestWindow *window)
1008 g_return_if_fail (MODEST_IS_WINDOW(window));
1010 if (MODEST_IS_MAIN_WINDOW (window)) {
1011 GtkWidget *header_view;
1012 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1013 MODEST_WIDGET_TYPE_HEADER_VIEW);
1017 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1018 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1019 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1021 g_return_if_reached ();
1026 modest_ui_actions_on_sort (GtkAction *action,
1027 ModestWindow *window)
1029 g_return_if_fail (MODEST_IS_WINDOW(window));
1031 if (MODEST_IS_MAIN_WINDOW (window)) {
1032 GtkWidget *header_view;
1033 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1034 MODEST_WIDGET_TYPE_HEADER_VIEW);
1038 /* Show sorting dialog */
1039 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1044 * This function performs the send & receive required actions. The
1045 * window is used to create the mail operation. Typically it should
1046 * always be the main window, but we pass it as argument in order to
1050 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
1052 gchar *acc_name = NULL;
1053 ModestMailOperation *mail_op;
1055 /* If no account name was provided then get the current account, and if
1056 there is no current account then pick the default one: */
1057 if (!account_name) {
1058 acc_name = g_strdup (modest_window_get_active_account(win));
1060 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1062 g_printerr ("modest: cannot get default account\n");
1066 acc_name = g_strdup (account_name);
1069 /* Set send/receive operation in progress */
1070 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW(win));
1072 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
1073 g_signal_connect (G_OBJECT(mail_op), "progress-changed",
1074 G_CALLBACK (_on_send_receive_progress_changed),
1077 /* Send & receive. */
1078 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
1079 /* Receive and then send. The operation is tagged initially as
1080 a receive operation because the account update performs a
1081 receive and then a send. The operation changes its type
1082 internally, so the progress objects will receive the proper
1083 progress information */
1084 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1085 modest_mail_operation_update_account (mail_op, acc_name);
1086 g_object_unref (G_OBJECT (mail_op));
1093 * Refreshes all accounts. This function will be used by automatic
1097 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1099 GSList *account_names, *iter;
1101 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1104 iter = account_names;
1106 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1107 iter = g_slist_next (iter);
1110 g_slist_foreach (account_names, (GFunc) g_free, NULL);
1111 g_slist_free (account_names);
1115 * Handler of the click on Send&Receive button in the main toolbar
1118 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1120 /* Check if accounts exist */
1121 gboolean accounts_exist =
1122 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1124 /* If not, allow the user to create an account before trying to send/receive. */
1125 if (!accounts_exist)
1126 modest_ui_actions_on_accounts (NULL, win);
1128 /* Refresh the active account */
1129 modest_ui_actions_do_send_receive (NULL, win);
1134 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1137 GtkWidget *header_view;
1139 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1141 header_view = modest_main_window_get_child_widget (main_window,
1142 MODEST_WIDGET_TYPE_HEADER_VIEW);
1146 conf = modest_runtime_get_conf ();
1148 /* what is saved/restored is depending on the style; thus; we save with
1149 * old style, then update the style, and restore for this new style
1151 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1153 if (modest_header_view_get_style
1154 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1155 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1156 MODEST_HEADER_VIEW_STYLE_TWOLINES);
1158 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1159 MODEST_HEADER_VIEW_STYLE_DETAILS);
1161 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1162 MODEST_CONF_HEADER_VIEW_KEY);
1167 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1169 ModestMainWindow *main_window)
1171 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1172 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
1174 /* If no header has been selected then exit */
1178 /* Update Main window title */
1179 if (GTK_WIDGET_HAS_FOCUS (header_view)) {
1180 const gchar *subject = tny_header_get_subject (header);
1181 if (subject && strlen(subject) > 0)
1182 gtk_window_set_title (GTK_WINDOW (main_window), subject);
1184 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
1187 /* Update toolbar dimming state */
1188 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1192 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1194 ModestMainWindow *main_window)
1198 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1203 headers = tny_simple_list_new ();
1204 tny_list_prepend (headers, G_OBJECT (header));
1206 _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1208 g_object_unref (headers);
1212 set_active_account_from_tny_account (TnyAccount *account,
1213 ModestWindow *window)
1215 const gchar *server_acc_name = tny_account_get_id (account);
1217 /* We need the TnyAccount provided by the
1218 account store because that is the one that
1219 knows the name of the Modest account */
1220 TnyAccount *modest_server_account = modest_server_account =
1221 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
1222 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1225 const gchar *modest_acc_name =
1226 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1227 modest_window_set_active_account (window, modest_acc_name);
1228 g_object_unref (modest_server_account);
1232 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1233 TnyFolderStore *folder_store,
1235 ModestMainWindow *main_window)
1238 GtkWidget *header_view;
1240 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1242 header_view = modest_main_window_get_child_widget(main_window,
1243 MODEST_WIDGET_TYPE_HEADER_VIEW);
1247 conf = modest_runtime_get_conf ();
1249 if (TNY_IS_ACCOUNT (folder_store)) {
1250 /* Update active account */
1251 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1252 /* Show account details */
1253 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1255 if (TNY_IS_FOLDER (folder_store) && selected) {
1257 if (!TNY_IS_MERGE_FOLDER (folder_store)) { /* TnyMergeFolder can have no get_account() implementation. */
1258 /* Update the active account */
1259 TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
1260 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1261 g_object_unref (account);
1264 /* Set folder on header view */
1265 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1266 TNY_FOLDER (folder_store));
1268 /* Resore configuration */
1269 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1270 MODEST_CONF_HEADER_VIEW_KEY);
1272 /* Set main view style */
1273 /* modest_main_window_set_contents_style (main_window, */
1274 /* MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS); */
1275 /* modest_widget_memory_restore (conf, G_OBJECT(header_view), */
1276 /* MODEST_CONF_HEADER_VIEW_KEY); */
1279 /* Update the active account */
1280 modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1281 /* Do not show folder */
1282 modest_widget_memory_save (conf, G_OBJECT (header_view), MODEST_CONF_HEADER_VIEW_KEY);
1283 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view), NULL);
1287 /* Update toolbar dimming state */
1288 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1292 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1299 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1301 if (g_main_depth > 0)
1302 gdk_threads_enter ();
1303 online = tny_device_is_online (modest_runtime_get_device());
1306 /* already online -- the item is simply not there... */
1307 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1309 GTK_MESSAGE_WARNING,
1311 _("The %s you selected cannot be found"),
1313 gtk_dialog_run (GTK_DIALOG(dialog));
1315 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1319 GTK_RESPONSE_REJECT,
1321 GTK_RESPONSE_ACCEPT,
1323 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1324 "Do you want to get online?"), item);
1325 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1326 gtk_label_new (txt), FALSE, FALSE, 0);
1327 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1330 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1331 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1332 // modest_platform_connect_and_wait ();
1335 gtk_widget_destroy (dialog);
1336 if (g_main_depth > 0)
1337 gdk_threads_leave ();
1341 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1344 /* g_message ("%s %s", __FUNCTION__, link); */
1349 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1352 modest_platform_activate_uri (link);
1356 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1359 modest_platform_show_uri_popup (link);
1363 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1366 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
1370 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1371 const gchar *address,
1374 /* g_message ("%s %s", __FUNCTION__, address); */
1378 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1380 TnyTransportAccount *transport_account;
1381 ModestMailOperation *mail_operation;
1383 gchar *account_name, *from;
1384 ModestAccountMgr *account_mgr;
1386 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1388 data = modest_msg_edit_window_get_msg_data (edit_window);
1390 account_mgr = modest_runtime_get_account_mgr();
1391 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1393 account_name = modest_account_mgr_get_default_account (account_mgr);
1394 if (!account_name) {
1395 g_printerr ("modest: no account found\n");
1396 modest_msg_edit_window_free_msg_data (edit_window, data);
1400 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1401 account_name = g_strdup (data->account_name);
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);
1411 g_free (account_name);
1412 modest_msg_edit_window_free_msg_data (edit_window, data);
1415 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1417 /* Create the mail operation */
1418 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
1419 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1421 modest_mail_operation_save_to_drafts (mail_operation,
1432 data->priority_flags);
1435 g_free (account_name);
1436 g_object_unref (G_OBJECT (transport_account));
1437 g_object_unref (G_OBJECT (mail_operation));
1439 modest_msg_edit_window_free_msg_data (edit_window, data);
1441 /* Save settings and close the window */
1442 gtk_widget_destroy (GTK_WIDGET (edit_window));
1445 /* For instance, when clicking the Send toolbar button when editing a message: */
1447 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1449 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1451 if (!modest_msg_edit_window_check_names (edit_window))
1454 /* FIXME: Code added just for testing. The final version will
1455 use the send queue provided by tinymail and some
1457 ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
1458 gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1460 account_name = modest_account_mgr_get_default_account (account_mgr);
1462 if (!account_name) {
1463 g_printerr ("modest: no account found\n");
1467 MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
1469 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1470 account_name = g_strdup (data->account_name);
1473 /* Get the currently-active transport account for this modest account: */
1474 TnyTransportAccount *transport_account =
1475 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1476 (modest_runtime_get_account_store(),
1478 if (!transport_account) {
1479 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1480 g_free (account_name);
1481 modest_msg_edit_window_free_msg_data (edit_window, data);
1485 gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
1487 /* mail content checks and dialogs */
1488 if (data->subject == NULL || data->subject[0] == '\0') {
1489 GtkResponseType response;
1490 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1491 _("mcen_nc_subject_is_empty_send"));
1492 if (response == GTK_RESPONSE_CANCEL) {
1493 g_free (account_name);
1498 if (data->plain_body == NULL || data->plain_body[0] == '\0') {
1499 GtkResponseType response;
1500 gchar *note_message;
1501 gchar *note_subject = data->subject;
1502 if (note_subject == NULL || note_subject[0] == '\0')
1503 note_subject = _("mail_va_no_subject");
1504 note_message = g_strdup_printf (_("emev_ni_ui_smtp_message_null"), note_subject);
1505 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (edit_window),
1507 g_free (note_message);
1508 if (response == GTK_RESPONSE_CANCEL) {
1509 g_free (account_name);
1514 /* Create the mail operation */
1515 ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
1516 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1518 modest_mail_operation_send_new_mail (mail_operation,
1529 data->priority_flags);
1533 g_free (account_name);
1534 g_object_unref (G_OBJECT (transport_account));
1535 g_object_unref (G_OBJECT (mail_operation));
1537 modest_msg_edit_window_free_msg_data (edit_window, data);
1539 /* Save settings and close the window: */
1540 gtk_widget_destroy (GTK_WIDGET (edit_window));
1544 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
1545 ModestMsgEditWindow *window)
1547 ModestMsgEditFormatState *format_state = NULL;
1549 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1550 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1552 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1555 format_state = modest_msg_edit_window_get_format_state (window);
1556 g_return_if_fail (format_state != NULL);
1558 format_state->bold = gtk_toggle_action_get_active (action);
1559 modest_msg_edit_window_set_format_state (window, format_state);
1560 g_free (format_state);
1565 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
1566 ModestMsgEditWindow *window)
1568 ModestMsgEditFormatState *format_state = NULL;
1570 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1571 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1573 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1576 format_state = modest_msg_edit_window_get_format_state (window);
1577 g_return_if_fail (format_state != NULL);
1579 format_state->italics = gtk_toggle_action_get_active (action);
1580 modest_msg_edit_window_set_format_state (window, format_state);
1581 g_free (format_state);
1586 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
1587 ModestMsgEditWindow *window)
1589 ModestMsgEditFormatState *format_state = NULL;
1591 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1592 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1594 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1597 format_state = modest_msg_edit_window_get_format_state (window);
1598 g_return_if_fail (format_state != NULL);
1600 format_state->bullet = gtk_toggle_action_get_active (action);
1601 modest_msg_edit_window_set_format_state (window, format_state);
1602 g_free (format_state);
1607 modest_ui_actions_on_change_justify (GtkRadioAction *action,
1608 GtkRadioAction *selected,
1609 ModestMsgEditWindow *window)
1611 ModestMsgEditFormatState *format_state = NULL;
1612 GtkJustification value;
1614 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1616 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1619 value = gtk_radio_action_get_current_value (selected);
1621 format_state = modest_msg_edit_window_get_format_state (window);
1622 g_return_if_fail (format_state != NULL);
1624 format_state->justification = value;
1625 modest_msg_edit_window_set_format_state (window, format_state);
1626 g_free (format_state);
1630 modest_ui_actions_on_select_editor_color (GtkAction *action,
1631 ModestMsgEditWindow *window)
1633 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1634 g_return_if_fail (GTK_IS_ACTION (action));
1636 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1639 modest_msg_edit_window_select_color (window);
1643 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
1644 ModestMsgEditWindow *window)
1646 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1647 g_return_if_fail (GTK_IS_ACTION (action));
1649 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1652 modest_msg_edit_window_select_background_color (window);
1656 modest_ui_actions_on_insert_image (GtkAction *action,
1657 ModestMsgEditWindow *window)
1659 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1660 g_return_if_fail (GTK_IS_ACTION (action));
1662 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1665 modest_msg_edit_window_insert_image (window);
1669 modest_ui_actions_on_attach_file (GtkAction *action,
1670 ModestMsgEditWindow *window)
1672 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1673 g_return_if_fail (GTK_IS_ACTION (action));
1675 modest_msg_edit_window_attach_file (window);
1679 modest_ui_actions_on_remove_attachments (GtkAction *action,
1680 ModestMsgEditWindow *window)
1682 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1683 g_return_if_fail (GTK_IS_ACTION (action));
1685 modest_msg_edit_window_remove_attachments (window, NULL);
1689 * Shows a dialog with an entry that asks for some text. The returned
1690 * value must be freed by the caller. The dialog window title will be
1694 ask_for_folder_name (GtkWindow *parent_window,
1697 GtkWidget *dialog, *entry;
1698 gchar *folder_name = NULL;
1700 /* Ask for folder name */
1701 dialog = gtk_dialog_new_with_buttons (_("New Folder Name"),
1705 GTK_RESPONSE_REJECT,
1707 GTK_RESPONSE_ACCEPT,
1709 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1710 gtk_label_new(title),
1713 entry = gtk_entry_new_with_max_length (40);
1714 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1718 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1720 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
1721 folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
1723 gtk_widget_destroy (dialog);
1729 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
1731 TnyFolderStore *parent_folder;
1732 GtkWidget *folder_view;
1734 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1736 folder_view = modest_main_window_get_child_widget (main_window,
1737 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1741 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1743 if (parent_folder) {
1744 gboolean finished = FALSE;
1746 gchar *folder_name = NULL, *suggested_name = NULL;
1748 /* Run the new folder dialog */
1750 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (main_window),
1755 if (result == GTK_RESPONSE_REJECT) {
1758 ModestMailOperation *mail_op;
1759 TnyFolder *new_folder = NULL;
1761 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO,
1762 G_OBJECT(main_window));
1763 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1765 new_folder = modest_mail_operation_create_folder (mail_op,
1767 (const gchar *) folder_name);
1769 g_object_unref (new_folder);
1772 g_object_unref (mail_op);
1774 g_free (folder_name);
1778 g_object_unref (parent_folder);
1783 modest_ui_actions_on_rename_folder (GtkAction *action,
1784 ModestMainWindow *main_window)
1786 TnyFolderStore *folder;
1787 GtkWidget *folder_view;
1788 GtkWidget *header_view;
1790 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1792 folder_view = modest_main_window_get_child_widget (main_window,
1793 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1797 header_view = modest_main_window_get_child_widget (main_window,
1798 MODEST_WIDGET_TYPE_HEADER_VIEW);
1803 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1805 if (folder && TNY_IS_FOLDER (folder)) {
1807 folder_name = ask_for_folder_name (GTK_WINDOW (main_window),
1808 _("Please enter a new name for the folder"));
1810 if (folder_name != NULL && strlen (folder_name) > 0) {
1811 ModestMailOperation *mail_op;
1813 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(main_window));
1814 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1817 modest_header_view_set_folder (MODEST_HEADER_VIEW (header_view), NULL);
1819 modest_mail_operation_rename_folder (mail_op,
1820 TNY_FOLDER (folder),
1821 (const gchar *) folder_name);
1823 g_object_unref (mail_op);
1824 g_free (folder_name);
1826 g_object_unref (folder);
1831 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
1834 GObject *win = modest_mail_operation_get_source (mail_op);
1836 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
1837 _("mail_in_ui_folder_delete_error"));
1841 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
1843 TnyFolderStore *folder;
1844 GtkWidget *folder_view;
1848 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1850 folder_view = modest_main_window_get_child_widget (main_window,
1851 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1855 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1857 /* Show an error if it's an account */
1858 if (!TNY_IS_FOLDER (folder)) {
1859 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
1860 _("mail_in_ui_folder_delete_error"));
1865 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
1866 tny_folder_get_name (TNY_FOLDER (folder)));
1867 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
1868 (const gchar *) message);
1871 if (response == GTK_RESPONSE_OK) {
1872 ModestMailOperation *mail_op =
1873 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_DELETE,
1874 G_OBJECT(main_window),
1875 modest_ui_actions_delete_folder_error_handler,
1878 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1880 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
1881 g_object_unref (G_OBJECT (mail_op));
1884 g_object_unref (G_OBJECT (folder));
1888 modest_ui_actions_on_delete_folder (GtkAction *action,
1889 ModestMainWindow *main_window)
1891 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1893 delete_folder (main_window, FALSE);
1897 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
1899 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1901 delete_folder (main_window, TRUE);
1905 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
1906 const gchar* server_account_name,
1911 ModestMainWindow *main_window)
1913 g_return_if_fail(server_account_name);
1914 /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
1916 /* Initalize output parameters: */
1923 #ifdef MODEST_PLATFORM_MAEMO
1924 /* Maemo uses a different (awkward) button order,
1925 * It should probably just use gtk_alternative_dialog_button_order ().
1927 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
1931 GTK_RESPONSE_ACCEPT,
1933 GTK_RESPONSE_REJECT,
1936 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
1940 GTK_RESPONSE_REJECT,
1942 GTK_RESPONSE_ACCEPT,
1944 #endif /* MODEST_PLATFORM_MAEMO */
1946 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
1948 gchar *server_name = modest_server_account_get_hostname (
1949 modest_runtime_get_account_mgr(), server_account_name);
1950 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
1951 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
1956 /* This causes a warning because the logical ID has no %s in it,
1957 * though the translation does, but there is not much we can do about that: */
1958 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
1959 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
1962 g_free (server_name);
1966 gchar *initial_username = modest_server_account_get_username (
1967 modest_runtime_get_account_mgr(), server_account_name);
1969 GtkWidget *entry_username = gtk_entry_new ();
1970 if (initial_username)
1971 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
1972 /* Dim this if a connection has ever succeeded with this username,
1973 * as per the UI spec: */
1974 const gboolean username_known =
1975 modest_server_account_get_username_has_succeeded(
1976 modest_runtime_get_account_mgr(), server_account_name);
1977 gtk_widget_set_sensitive (entry_username, !username_known);
1979 #ifdef MODEST_PLATFORM_MAEMO
1980 /* Auto-capitalization is the default, so let's turn it off: */
1981 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
1983 /* Create a size group to be used by all captions.
1984 * Note that HildonCaption does not create a default size group if we do not specify one.
1985 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
1986 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
1988 GtkWidget *caption = hildon_caption_new (sizegroup,
1989 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
1990 gtk_widget_show (entry_username);
1991 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
1992 FALSE, FALSE, MODEST_MARGIN_HALF);
1993 gtk_widget_show (caption);
1995 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
1997 #endif /* MODEST_PLATFORM_MAEMO */
2000 GtkWidget *entry_password = gtk_entry_new ();
2001 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
2002 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
2004 #ifdef MODEST_PLATFORM_MAEMO
2005 /* Auto-capitalization is the default, so let's turn it off: */
2006 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
2007 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
2009 caption = hildon_caption_new (sizegroup,
2010 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
2011 gtk_widget_show (entry_password);
2012 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2013 FALSE, FALSE, MODEST_MARGIN_HALF);
2014 gtk_widget_show (caption);
2015 g_object_unref (sizegroup);
2017 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
2019 #endif /* MODEST_PLATFORM_MAEMO */
2021 /* This is not in the Maemo UI spec:
2022 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
2023 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
2027 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2029 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2031 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
2033 modest_server_account_set_username (
2034 modest_runtime_get_account_mgr(), server_account_name,
2037 const gboolean username_was_changed =
2038 (strcmp (*username, initial_username) != 0);
2039 if (username_was_changed) {
2040 /* To actually use a changed username,
2041 * we must reset the connection, according to pvanhoof.
2042 * This _might_ be a sensible way to do that: */
2043 TnyDevice *device = modest_runtime_get_device();
2044 tny_device_force_offline (device);
2045 tny_device_force_online (device);
2050 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
2052 /* We do not save the password in the configuration,
2053 * because this function is only called for passwords that should
2054 * not be remembered:
2055 modest_server_account_set_password (
2056 modest_runtime_get_account_mgr(), server_account_name,
2075 /* This is not in the Maemo UI spec:
2076 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
2082 gtk_widget_destroy (dialog);
2084 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
2088 modest_ui_actions_on_cut (GtkAction *action,
2089 ModestWindow *window)
2091 GtkWidget *focused_widget;
2093 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2094 if (GTK_IS_EDITABLE (focused_widget)) {
2095 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
2096 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2097 GtkTextBuffer *buffer;
2098 GtkClipboard *clipboard;
2100 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2101 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2102 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
2107 modest_ui_actions_on_copy (GtkAction *action,
2108 ModestWindow *window)
2110 GtkClipboard *clipboard;
2111 GtkWidget *focused_widget;
2113 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2114 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2115 if (GTK_IS_LABEL (focused_widget)) {
2116 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
2117 } else if (GTK_IS_EDITABLE (focused_widget)) {
2118 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
2119 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2120 GtkTextBuffer *buffer;
2122 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2123 gtk_text_buffer_copy_clipboard (buffer, clipboard);
2128 modest_ui_actions_on_undo (GtkAction *action,
2129 ModestWindow *window)
2131 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2132 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2134 g_return_if_reached ();
2139 modest_ui_actions_on_paste (GtkAction *action,
2140 ModestWindow *window)
2142 GtkWidget *focused_widget;
2144 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2145 if (GTK_IS_EDITABLE (focused_widget)) {
2146 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
2147 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2148 GtkTextBuffer *buffer;
2149 GtkClipboard *clipboard;
2151 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2152 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2153 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
2158 modest_ui_actions_on_select_all (GtkAction *action,
2159 ModestWindow *window)
2161 GtkWidget *focused_widget;
2163 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2164 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
2165 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
2166 } else if (GTK_IS_LABEL (focused_widget)) {
2167 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
2168 } else if (GTK_IS_EDITABLE (focused_widget)) {
2169 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
2170 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2171 GtkTextBuffer *buffer;
2172 GtkTextIter start, end;
2174 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2175 gtk_text_buffer_get_start_iter (buffer, &start);
2176 gtk_text_buffer_get_end_iter (buffer, &end);
2177 gtk_text_buffer_select_range (buffer, &start, &end);
2179 else if ((MODEST_IS_FOLDER_VIEW (focused_widget)) ||
2180 (MODEST_IS_HEADER_VIEW (focused_widget))) {
2182 GtkTreeSelection *selection = NULL;
2184 /* Get header view */
2185 GtkWidget *header_view = focused_widget;
2186 if (MODEST_IS_FOLDER_VIEW (focused_widget))
2187 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
2188 MODEST_WIDGET_TYPE_HEADER_VIEW);
2190 /* Select all messages */
2191 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
2192 gtk_tree_selection_select_all (selection);
2197 modest_ui_actions_on_mark_as_read (GtkAction *action,
2198 ModestWindow *window)
2200 g_return_if_fail (MODEST_IS_WINDOW(window));
2202 /* Mark each header as read */
2203 do_headers_action (window, headers_action_mark_as_read, NULL);
2207 modest_ui_actions_on_mark_as_unread (GtkAction *action,
2208 ModestWindow *window)
2210 g_return_if_fail (MODEST_IS_WINDOW(window));
2212 /* Mark each header as read */
2213 do_headers_action (window, headers_action_mark_as_unread, NULL);
2217 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
2218 GtkRadioAction *selected,
2219 ModestWindow *window)
2223 value = gtk_radio_action_get_current_value (selected);
2224 if (MODEST_IS_WINDOW (window)) {
2225 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
2229 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
2230 GtkRadioAction *selected,
2231 ModestWindow *window)
2233 TnyHeaderFlags flags;
2234 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2236 flags = gtk_radio_action_get_current_value (selected);
2237 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
2240 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
2241 GtkRadioAction *selected,
2242 ModestWindow *window)
2246 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2248 file_format = gtk_radio_action_get_current_value (selected);
2249 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
2254 modest_ui_actions_on_zoom_plus (GtkAction *action,
2255 ModestWindow *window)
2257 g_return_if_fail (MODEST_IS_WINDOW (window));
2259 modest_window_zoom_plus (MODEST_WINDOW (window));
2263 modest_ui_actions_on_zoom_minus (GtkAction *action,
2264 ModestWindow *window)
2266 g_return_if_fail (MODEST_IS_WINDOW (window));
2268 modest_window_zoom_minus (MODEST_WINDOW (window));
2272 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
2273 ModestWindow *window)
2275 ModestWindowMgr *mgr;
2276 gboolean fullscreen, active;
2277 g_return_if_fail (MODEST_IS_WINDOW (window));
2279 mgr = modest_runtime_get_window_mgr ();
2281 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
2282 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2284 if (active != fullscreen) {
2285 modest_window_mgr_set_fullscreen_mode (mgr, active);
2286 gtk_window_present (GTK_WINDOW (window));
2291 modest_ui_actions_on_change_fullscreen (GtkAction *action,
2292 ModestWindow *window)
2294 ModestWindowMgr *mgr;
2295 gboolean fullscreen;
2297 g_return_if_fail (MODEST_IS_WINDOW (window));
2299 mgr = modest_runtime_get_window_mgr ();
2300 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
2301 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
2303 gtk_window_present (GTK_WINDOW (window));
2307 * Used by modest_ui_actions_on_details to call do_headers_action
2310 headers_action_show_details (TnyHeader *header,
2311 ModestWindow *window,
2318 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
2321 gtk_widget_show_all (dialog);
2322 gtk_dialog_run (GTK_DIALOG (dialog));
2324 gtk_widget_destroy (dialog);
2328 * Show the folder details in a ModestDetailsDialog widget
2331 show_folder_details (TnyFolder *folder,
2337 dialog = modest_details_dialog_new_with_folder (window, folder);
2340 gtk_widget_show_all (dialog);
2341 gtk_dialog_run (GTK_DIALOG (dialog));
2343 gtk_widget_destroy (dialog);
2347 * Show the header details in a ModestDetailsDialog widget
2350 modest_ui_actions_on_details (GtkAction *action,
2353 TnyList * headers_list;
2357 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2360 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2363 g_object_unref (msg);
2365 headers_list = get_selected_headers (win);
2369 iter = tny_list_create_iterator (headers_list);
2371 header = TNY_HEADER (tny_iterator_get_current (iter));
2372 headers_action_show_details (header, win, NULL);
2373 g_object_unref (header);
2375 g_object_unref (iter);
2376 g_object_unref (headers_list);
2378 } else if (MODEST_IS_MAIN_WINDOW (win)) {
2379 GtkWidget *folder_view, *header_view;
2381 /* Check which widget has the focus */
2382 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2383 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2384 if (gtk_widget_is_focus (folder_view)) {
2387 folder = (TnyFolder *) modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2389 /* Show only when it's a folder */
2390 if (!folder || !TNY_IS_FOLDER (folder))
2393 show_folder_details (folder, GTK_WINDOW (win));
2396 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2397 MODEST_WIDGET_TYPE_HEADER_VIEW);
2398 /* Show details of each header */
2399 do_headers_action (win, headers_action_show_details, header_view);
2405 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
2406 ModestMsgEditWindow *window)
2408 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2410 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
2414 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
2415 ModestMsgEditWindow *window)
2417 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2419 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
2423 modest_ui_actions_toggle_folders_view (GtkAction *action,
2424 ModestMainWindow *main_window)
2428 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2430 conf = modest_runtime_get_conf ();
2432 if (modest_main_window_get_style (main_window) == MODEST_MAIN_WINDOW_STYLE_SPLIT)
2433 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
2435 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
2439 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
2440 ModestWindow *window)
2442 gboolean active, fullscreen = FALSE;
2443 ModestWindowMgr *mgr;
2445 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
2447 /* Check if we want to toggle the toolbar vuew in fullscreen
2449 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
2450 "ViewShowToolbarFullScreen")) {
2454 /* Toggle toolbar */
2455 mgr = modest_runtime_get_window_mgr ();
2456 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
2460 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
2461 ModestMsgEditWindow *window)
2463 modest_msg_edit_window_select_font (window);
2467 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
2468 const gchar *display_name,
2471 /* Do not change the application name if the widget has not
2472 the focus. This callback could be called even if the folder
2473 view has not the focus, because the handled signal could be
2474 emitted when the folder view is redrawn */
2475 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
2477 gtk_window_set_title (window, display_name);
2479 gtk_window_set_title (window, " ");
2484 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
2486 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2487 modest_msg_edit_window_select_contacts (window);
2491 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
2493 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2494 modest_msg_edit_window_check_names (window);
2499 create_move_to_dialog (ModestWindow *win,
2500 GtkWidget *folder_view,
2501 GtkWidget **tree_view)
2503 GtkWidget *dialog, *scroll;
2505 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
2507 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
2509 GTK_RESPONSE_ACCEPT,
2511 GTK_RESPONSE_REJECT,
2514 /* Create scrolled window */
2515 scroll = gtk_scrolled_window_new (NULL, NULL);
2516 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
2517 GTK_POLICY_AUTOMATIC,
2518 GTK_POLICY_AUTOMATIC);
2520 /* Create folder view */
2521 *tree_view = modest_folder_view_new (NULL);
2523 /* It could happen that we're trying to move a message from a
2524 window (msg window for example) after the main window was
2525 closed, so we can not just get the model of the folder
2527 if (MODEST_IS_FOLDER_VIEW (folder_view))
2528 gtk_tree_view_set_model (GTK_TREE_VIEW (*tree_view),
2529 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
2531 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
2532 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
2534 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
2536 /* Add scroll to dialog */
2537 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
2538 scroll, FALSE, FALSE, 0);
2540 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2546 * Returns TRUE if at least one of the headers of the list belongs to
2547 * a message that has been fully retrieved.
2550 has_retrieved_msgs (TnyList *list)
2553 gboolean found = FALSE;
2555 iter = tny_list_create_iterator (list);
2556 while (tny_iterator_is_done (iter) && !found) {
2558 TnyHeaderFlags flags;
2560 header = TNY_HEADER (tny_iterator_get_current (iter));
2561 flags = tny_header_get_flags (header);
2562 if (!(flags & TNY_HEADER_FLAG_PARTIAL))
2566 tny_iterator_next (iter);
2568 g_object_unref (iter);
2574 * Shows a confirmation dialog to the user when we're moving messages
2575 * from a remote server to the local storage. Returns the dialog
2576 * response. If it's other kind of movement the it always returns
2580 msgs_move_to_confirmation (GtkWindow *win,
2581 TnyFolder *dest_folder,
2584 gint response = GTK_RESPONSE_OK;
2586 /* If the destination is a local folder */
2587 if (modest_tny_folder_is_local_folder (dest_folder)) {
2588 TnyFolder *src_folder;
2592 /* Get source folder */
2593 iter = tny_list_create_iterator (headers);
2594 header = TNY_HEADER (tny_iterator_get_current (iter));
2595 src_folder = tny_header_get_folder (header);
2596 g_object_unref (header);
2597 g_object_unref (iter);
2599 /* If the source is a remote folder */
2600 if (!modest_tny_folder_is_local_folder (src_folder)) {
2601 const gchar *message;
2603 if (tny_list_get_length (headers) == 1)
2604 if (has_retrieved_msgs (headers))
2605 message = _("mcen_nc_move_retrieve");
2607 message = _("mcen_nc_move_header");
2609 if (has_retrieved_msgs (headers))
2610 message = _("mcen_nc_move_retrieves");
2612 message = _("mcen_nc_move_headers");
2614 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
2615 (const gchar *) message);
2617 g_object_unref (src_folder);
2624 tranasfer_msgs_from_viewer_cb (const GObject *object, gpointer user_data)
2626 ModestMsgViewWindow *self = NULL;
2627 gboolean found = FALSE;
2629 g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (object));
2630 self = MODEST_MSG_VIEW_WINDOW (object);
2632 found = modest_msg_view_window_select_first_message (self);
2633 g_return_if_fail (found);
2637 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
2640 GObject *win = modest_mail_operation_get_source (mail_op);
2642 /* TODO: show error message */
2643 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2644 _("mail_in_ui_folder_move_target_error"));
2648 * UI handler for the "Move to" action when invoked from the
2652 modest_ui_actions_on_main_window_move_to (GtkAction *action,
2653 ModestMainWindow *win)
2655 GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
2656 GtkWidget *header_view = NULL;
2658 TnyFolderStore *folder_store = NULL;
2659 ModestMailOperation *mail_op = NULL;
2661 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
2663 /* Get the folder view */
2664 folder_view = modest_main_window_get_child_widget (win,
2665 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2667 /* Get header view */
2668 header_view = modest_main_window_get_child_widget (win,
2669 MODEST_WIDGET_TYPE_HEADER_VIEW);
2671 /* Create and run the dialog */
2672 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2673 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
2674 result = gtk_dialog_run (GTK_DIALOG(dialog));
2675 g_object_ref (tree_view);
2677 /* We do this to save an indentation level ;-) */
2678 if (result != GTK_RESPONSE_ACCEPT)
2681 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2683 if (TNY_IS_ACCOUNT (folder_store))
2686 /* Get folder or messages to transfer */
2687 if (gtk_widget_is_focus (folder_view)) {
2688 TnyFolderStore *src_folder;
2689 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2691 /* Clean folder on header view before moving it */
2692 modest_header_view_set_folder (MODEST_HEADER_VIEW (header_view), NULL);
2694 if (TNY_IS_FOLDER (src_folder)) {
2696 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
2698 modest_ui_actions_move_folder_error_handler,
2700 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
2702 modest_mail_operation_xfer_folder (mail_op,
2703 TNY_FOLDER (src_folder),
2706 /* Unref mail operation */
2707 g_object_unref (G_OBJECT (mail_op));
2711 g_object_unref (G_OBJECT (src_folder));
2713 if (gtk_widget_is_focus (header_view)) {
2717 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
2719 /* Ask for user confirmation */
2720 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2721 TNY_FOLDER (folder_store),
2724 /* Transfer messages */
2725 if (response == GTK_RESPONSE_OK) {
2726 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
2727 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2730 modest_mail_operation_xfer_msgs (mail_op,
2732 TNY_FOLDER (folder_store),
2737 g_object_unref (G_OBJECT (mail_op));
2739 g_object_unref (headers);
2742 g_object_unref (folder_store);
2744 gtk_widget_destroy (dialog);
2749 * UI handler for the "Move to" action when invoked from the
2750 * ModestMsgViewWindow
2753 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
2754 ModestMsgViewWindow *win)
2756 GtkWidget *dialog, *folder_view, *tree_view = NULL;
2758 ModestMainWindow *main_window;
2762 /* Get the folder view */
2763 main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
2765 folder_view = modest_main_window_get_child_widget (main_window,
2766 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2770 /* Create and run the dialog */
2771 dialog = create_move_to_dialog (MODEST_WINDOW (win), folder_view, &tree_view);
2772 result = gtk_dialog_run (GTK_DIALOG(dialog));
2773 g_object_ref (tree_view);
2775 if (result == GTK_RESPONSE_ACCEPT) {
2776 TnyFolderStore *folder_store;
2779 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
2781 /* Create header list */
2782 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
2783 headers = tny_simple_list_new ();
2784 tny_list_prepend (headers, G_OBJECT (header));
2785 g_object_unref (header);
2787 /* Ask user for confirmation. MSG-NOT404 */
2788 response = msgs_move_to_confirmation (GTK_WINDOW (win),
2789 TNY_FOLDER (folder_store),
2792 /* Transfer current msg */
2793 if (response == GTK_RESPONSE_OK) {
2794 ModestMailOperation *mail_op;
2796 /* Create mail op */
2797 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(win));
2798 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2801 /* Transfer messages */
2802 modest_mail_operation_xfer_msgs (mail_op,
2804 TNY_FOLDER (folder_store),
2806 tranasfer_msgs_from_viewer_cb,
2808 g_object_unref (G_OBJECT (mail_op));
2810 g_object_unref (headers);
2811 g_object_unref (folder_store);
2813 gtk_widget_destroy (dialog);
2817 modest_ui_actions_on_move_to (GtkAction *action,
2820 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
2821 MODEST_IS_MSG_VIEW_WINDOW (win));
2823 if (MODEST_IS_MAIN_WINDOW (win))
2824 modest_ui_actions_on_main_window_move_to (action,
2825 MODEST_MAIN_WINDOW (win));
2827 modest_ui_actions_on_msg_view_window_move_to (action,
2828 MODEST_MSG_VIEW_WINDOW (win));
2832 * Calls #HeadersFunc for each header already selected in the main
2833 * window or the message currently being shown in the msg view window
2836 do_headers_action (ModestWindow *win,
2840 TnyList *headers_list;
2844 headers_list = get_selected_headers (win);
2848 /* Call the function for each header */
2849 iter = tny_list_create_iterator (headers_list);
2850 while (!tny_iterator_is_done (iter)) {
2853 header = TNY_HEADER (tny_iterator_get_current (iter));
2854 func (header, win, user_data);
2855 g_object_unref (header);
2856 tny_iterator_next (iter);
2858 g_object_unref (iter);
2859 g_object_unref (headers_list);
2863 modest_ui_actions_view_attachment (GtkAction *action,
2864 ModestWindow *window)
2866 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2867 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
2869 /* not supported window for this action */
2870 g_return_if_reached ();
2875 modest_ui_actions_save_attachments (GtkAction *action,
2876 ModestWindow *window)
2878 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2879 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
2881 /* not supported window for this action */
2882 g_return_if_reached ();
2887 modest_ui_actions_remove_attachments (GtkAction *action,
2888 ModestWindow *window)
2890 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2891 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
2893 /* not supported window for this action */
2894 g_return_if_reached ();
2899 modest_ui_actions_on_settings (GtkAction *action,
2904 dialog = modest_platform_get_global_settings_dialog ();
2905 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
2906 gtk_widget_show (dialog);
2908 gtk_dialog_run (GTK_DIALOG (dialog));
2910 gtk_widget_destroy (dialog);
2914 modest_ui_actions_on_help (GtkAction *action,
2917 const gchar *help_id = NULL;
2919 if (MODEST_IS_MAIN_WINDOW (win)) {
2920 const gchar *action_name;
2921 action_name = gtk_action_get_name (action);
2923 if (!strcmp (action_name, "FolderViewCSMHelp") ||
2924 !strcmp (action_name, "HeaderViewCSMHelp")) {
2925 GtkWidget *folder_view;
2926 TnyFolderStore *folder_store;
2927 /* Get selected folder */
2928 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2929 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2930 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2932 /* Switch help_id */
2933 if (TNY_IS_FOLDER (folder_store)) {
2934 switch (tny_folder_get_folder_type (TNY_FOLDER (folder_store))) {
2935 case TNY_FOLDER_TYPE_NORMAL:
2936 help_id = "applications_email_userfolder";
2938 case TNY_FOLDER_TYPE_INBOX:
2939 help_id = "applications_email_inbox";
2941 case TNY_FOLDER_TYPE_OUTBOX:
2942 help_id = "applications_email_outbox";
2944 case TNY_FOLDER_TYPE_SENT:
2945 help_id = "applications_email_sent";
2947 case TNY_FOLDER_TYPE_DRAFTS:
2948 help_id = "applications_email_drafts";
2950 case TNY_FOLDER_TYPE_ARCHIVE:
2951 help_id = "applications_email_archive";
2958 help_id = "applications_email_mainview";
2960 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2961 help_id = "applications_email_viewer";
2962 } else if (MODEST_IS_MSG_EDIT_WINDOW (win))
2963 help_id = "applications_email_editor";
2965 modest_platform_show_help (GTK_WINDOW (win), help_id);
2969 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
2970 ModestWindow *window)
2972 ModestMailOperation *mail_op;
2976 headers = get_selected_headers (window);
2980 /* Create mail operation */
2981 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
2983 modest_ui_actions_get_msgs_full_error_handler,
2985 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
2986 modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
2989 g_object_unref (headers);
2990 g_object_unref (mail_op);
2994 modest_ui_actions_on_email_menu_activated (GtkAction *action,
2995 ModestWindow *window)
2997 g_return_if_fail (MODEST_IS_WINDOW (window));
3000 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3004 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
3005 ModestWindow *window)
3007 g_return_if_fail (MODEST_IS_WINDOW (window));
3010 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3014 modest_ui_actions_on_view_menu_activated (GtkAction *action,
3015 ModestWindow *window)
3017 g_return_if_fail (MODEST_IS_WINDOW (window));
3020 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3024 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
3025 ModestWindow *window)
3027 g_return_if_fail (MODEST_IS_WINDOW (window));
3030 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3034 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
3035 ModestWindow *window)
3037 g_return_if_fail (MODEST_IS_WINDOW (window));
3040 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3044 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
3045 ModestWindow *window)
3047 g_return_if_fail (MODEST_IS_WINDOW (window));
3050 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3054 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
3055 ModestWindow *window)
3057 g_return_if_fail (MODEST_IS_WINDOW (window));
3060 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3064 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
3065 ModestWindow *window)
3067 g_return_if_fail (MODEST_IS_WINDOW (window));
3070 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
3074 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
3076 g_return_if_fail (MODEST_IS_WINDOW (window));
3079 modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
3083 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
3085 g_return_if_fail (MODEST_IS_WINDOW (window));
3087 modest_platform_show_search_messages (GTK_WINDOW (window));
3091 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
3093 g_return_if_fail (MODEST_IS_WINDOW (win));
3094 modest_platform_show_addressbook (GTK_WINDOW (win));
3099 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
3100 ModestWindow *window)
3102 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3104 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
3108 _on_send_receive_progress_changed (ModestMailOperation *mail_op,
3109 ModestMailOperationState *state,
3112 g_return_if_fail (MODEST_IS_MAIN_WINDOW(user_data));
3114 /* Set send/receive operation finished */
3115 if (state->status != MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
3116 modest_main_window_notify_send_receive_completed (MODEST_MAIN_WINDOW(user_data));