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>
48 #include <tny-camel-folder.h>
49 #include <tny-camel-imap-folder.h>
50 #include <tny-camel-pop-folder.h>
52 #ifdef MODEST_PLATFORM_MAEMO
53 #include "maemo/modest-osso-state-saving.h"
54 #include "maemo/modest-maemo-utils.h"
55 #include "maemo/modest-hildon-includes.h"
56 #endif /* MODEST_PLATFORM_MAEMO */
58 #include "widgets/modest-ui-constants.h"
59 #include <widgets/modest-main-window.h>
60 #include <widgets/modest-msg-view-window.h>
61 #include <widgets/modest-account-view-window.h>
62 #include <widgets/modest-details-dialog.h>
63 #include <widgets/modest-attachments-view.h>
64 #include "widgets/modest-folder-view.h"
65 #include "widgets/modest-global-settings-dialog.h"
66 #include "modest-connection-specific-smtp-window.h"
67 #include "modest-account-mgr-helpers.h"
68 #include "modest-mail-operation.h"
69 #include "modest-text-utils.h"
71 #ifdef MODEST_HAVE_EASYSETUP
72 #include "easysetup/modest-easysetup-wizard.h"
73 #endif /* MODEST_HAVE_EASYSETUP */
75 #include <modest-widget-memory.h>
76 #include <tny-error.h>
77 #include <tny-simple-list.h>
78 #include <tny-msg-view.h>
79 #include <tny-device.h>
80 #include <tny-merge-folder.h>
82 #include <gtkhtml/gtkhtml.h>
84 typedef struct _GetMsgAsyncHelper {
86 ModestMailOperation *mail_op;
93 typedef enum _ReplyForwardAction {
99 typedef struct _ReplyForwardHelper {
100 guint reply_forward_type;
101 ReplyForwardAction action;
103 GtkWidget *parent_window;
104 } ReplyForwardHelper;
106 typedef struct _MoveToHelper {
107 ModestMailOperation *mail_op;
111 typedef struct _PasteAsAttachmentHelper {
112 ModestMsgEditWindow *window;
114 } PasteAsAttachmentHelper;
118 * The do_headers_action uses this kind of functions to perform some
119 * action to each member of a list of headers
121 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
123 static void do_headers_action (ModestWindow *win,
127 static void open_msg_cb (ModestMailOperation *mail_op,
132 static void reply_forward_cb (ModestMailOperation *mail_op,
137 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
139 static void folder_refreshed_cb (ModestMailOperation *mail_op,
143 static void _on_send_receive_progress_changed (ModestMailOperation *mail_op,
144 ModestMailOperationState *state,
147 static gint header_list_count_uncached_msgs (
148 TnyList *header_list,
150 static gboolean connect_to_get_msg (
152 gint num_of_uncached_msgs);
156 /* Show the account creation wizard dialog.
157 * returns: TRUE if an account was created. FALSE if the user cancelled.
160 modest_run_account_setup_wizard (ModestWindow *win)
162 gboolean result = FALSE;
165 wizard = modest_window_mgr_get_easysetup_dialog
166 (modest_runtime_get_window_mgr());
168 /* old wizard is active already; present it and
169 * act as if the user cancelled the non-existing
172 printf ("wizard already active\n");
175 /* there is no such wizard yet */
176 wizard = GTK_DIALOG(modest_easysetup_wizard_dialog_new ());
177 modest_window_mgr_set_easysetup_dialog
178 (modest_runtime_get_window_mgr(), GTK_DIALOG(wizard));
182 /* always present a main window in the background
183 * we do it here, so we cannot end up with to wizards (as this
184 * function might be called in modest_window_mgr_get_main_window as well */
186 win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr());
188 /* make sure the mainwindow is visible */
189 gtk_widget_show_all (GTK_WIDGET(win));
190 gtk_window_present (GTK_WINDOW(win));
193 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
195 /* Don't make this a modal window, because secondary windows will then
196 * be unusable, freezing the UI: */
197 /* gtk_window_set_modal (GTK_WINDOW (wizard), TRUE); */
199 gint dialog_response = gtk_dialog_run (GTK_DIALOG (wizard));
200 if (dialog_response == GTK_RESPONSE_CANCEL)
203 /* Check whether an account was created: */
204 result = modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
207 gtk_widget_destroy (GTK_WIDGET (wizard));
209 /* clear it from the window mgr */
210 modest_window_mgr_set_easysetup_dialog
211 (modest_runtime_get_window_mgr(), NULL);
218 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
221 const gchar *authors[] = {
222 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
225 about = gtk_about_dialog_new ();
226 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
227 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
228 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
229 _("Copyright (c) 2006, Nokia Corporation\n"
230 "All rights reserved."));
231 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
232 _("a modest e-mail client\n\n"
233 "design and implementation: Dirk-Jan C. Binnema\n"
234 "contributions from the fine people at KC and Ig\n"
235 "uses the tinymail email framework written by Philip van Hoof"));
236 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
237 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
238 gtk_window_set_transient_for (GTK_WINDOW (about), GTK_WINDOW (win));
239 gtk_window_set_modal (GTK_WINDOW (about), TRUE);
241 gtk_dialog_run (GTK_DIALOG (about));
242 gtk_widget_destroy(about);
246 * Gets the list of currently selected messages. If the win is the
247 * main window, then it returns a newly allocated list of the headers
248 * selected in the header view. If win is the msg view window, then
249 * the value returned is a list with just a single header.
251 * The caller of this funcion must free the list.
254 get_selected_headers (ModestWindow *win)
256 if (MODEST_IS_MAIN_WINDOW(win)) {
257 GtkWidget *header_view;
259 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
260 MODEST_WIDGET_TYPE_HEADER_VIEW);
261 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
263 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
264 /* for MsgViewWindows, we simply return a list with one element */
266 TnyList *list = NULL;
268 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
269 if (header != NULL) {
270 list = tny_simple_list_new ();
271 tny_list_prepend (list, G_OBJECT(header));
272 g_object_unref (G_OBJECT(header));
282 headers_action_mark_as_read (TnyHeader *header,
286 TnyHeaderFlags flags;
288 g_return_if_fail (TNY_IS_HEADER(header));
290 flags = tny_header_get_flags (header);
291 if (flags & TNY_HEADER_FLAG_SEEN) return;
292 tny_header_set_flags (header, TNY_HEADER_FLAG_SEEN);
296 headers_action_mark_as_unread (TnyHeader *header,
300 TnyHeaderFlags flags;
302 g_return_if_fail (TNY_IS_HEADER(header));
304 flags = tny_header_get_flags (header);
305 if (flags & TNY_HEADER_FLAG_SEEN) {
306 tny_header_unset_flags (header, TNY_HEADER_FLAG_SEEN);
310 /** A convenience method, because deleting a message is
311 * otherwise complicated, and it's best to change it in one place
314 void modest_do_message_delete (TnyHeader *header, ModestWindow *win)
316 ModestMailOperation *mail_op = NULL;
317 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE,
318 win ? G_OBJECT(win) : NULL);
319 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
322 /* Always delete. TODO: Move to trash still not supported */
323 modest_mail_operation_remove_msg (mail_op, header, FALSE);
324 g_object_unref (G_OBJECT (mail_op));
327 /** A convenience method, because deleting a message is
328 * otherwise complicated, and it's best to change it in one place
331 void modest_do_messages_delete (TnyList *headers, ModestWindow *win)
333 ModestMailOperation *mail_op = NULL;
334 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_DELETE,
335 win ? G_OBJECT(win) : NULL);
336 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
339 /* Always delete. TODO: Move to trash still not supported */
340 modest_mail_operation_remove_msgs (mail_op, headers, FALSE);
341 g_object_unref (G_OBJECT (mail_op));
345 /* headers_action_delete (TnyHeader *header, */
346 /* ModestWindow *win, */
347 /* gpointer user_data) */
349 /* modest_do_message_delete (header, win); */
353 /** After deleing a message that is currently visible in a window,
354 * show the next message from the list, or close the window if there are no more messages.
356 void modest_ui_actions_refresh_message_window_after_delete (ModestMsgViewWindow* win)
358 /* Close msg view window or select next */
359 if (modest_msg_view_window_last_message_selected (win) &&
360 modest_msg_view_window_first_message_selected (win)) {
361 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (win));
363 if (!modest_msg_view_window_select_next_message (win)) {
365 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
371 modest_ui_actions_on_delete_message (GtkAction *action, ModestWindow *win)
373 TnyList *header_list = NULL;
374 TnyIterator *iter = NULL;
375 TnyHeader *header = NULL;
376 gchar *message = NULL;
379 ModestWindowMgr *mgr;
380 GtkWidget *header_view = NULL;
382 g_return_if_fail (MODEST_IS_WINDOW(win));
384 /* Check first if the header view has the focus */
385 if (MODEST_IS_MAIN_WINDOW (win)) {
387 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
388 MODEST_WIDGET_TYPE_HEADER_VIEW);
389 if (!gtk_widget_is_focus (header_view))
393 /* Get the headers, either from the header view (if win is the main window),
394 * or from the message view window: */
395 header_list = get_selected_headers (win);
396 if (!header_list) return;
398 /* Check if any of the headers are already opened, or in the process of being opened */
399 if (MODEST_IS_MAIN_WINDOW (win)) {
401 iter = tny_list_create_iterator (header_list);
403 mgr = modest_runtime_get_window_mgr ();
404 while (!tny_iterator_is_done (iter) && !found) {
405 header = TNY_HEADER (tny_iterator_get_current (iter));
407 found = modest_window_mgr_find_registered_header (mgr, header, NULL);
408 g_object_unref (header);
411 tny_iterator_next (iter);
413 g_object_unref (iter);
418 num = g_strdup_printf ("%d", tny_list_get_length (header_list));
419 msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"), num);
421 modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
425 g_object_unref (header_list);
431 if (tny_list_get_length(header_list) == 1) {
432 iter = tny_list_create_iterator (header_list);
433 header = TNY_HEADER (tny_iterator_get_current (iter));
435 desc = g_strdup_printf ("%s", tny_header_get_subject (header));
436 g_object_unref (header);
439 g_object_unref (iter);
441 message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
442 tny_list_get_length(header_list)), desc);
444 /* Confirmation dialog */
445 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
449 if (response == GTK_RESPONSE_OK) {
450 ModestWindow *main_window = NULL;
451 ModestWindowMgr *mgr = NULL;
452 GtkTreeModel *model = NULL;
453 GtkTreeSelection *sel = NULL;
454 GList *sel_list = NULL, *tmp = NULL;
455 GtkTreeRowReference *row_reference = NULL;
456 GtkTreePath *next_path = NULL;
459 /* Find last selected row */
460 if (MODEST_IS_MAIN_WINDOW (win)) {
461 model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
462 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
463 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
464 for (tmp=sel_list; tmp; tmp=tmp->next) {
465 if (tmp->next == NULL) {
466 next_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
467 gtk_tree_path_next (next_path);
468 row_reference = gtk_tree_row_reference_new (model, next_path);
469 gtk_tree_path_free (next_path);
474 /* Disable window dimming management */
475 modest_window_disable_dimming (MODEST_WINDOW(win));
477 /* Remove each header. If it's a view window header_view == NULL */
478 /* do_headers_action (win, headers_action_delete, header_view); */
479 modest_do_messages_delete (header_list, win);
482 /* Enable window dimming management */
483 gtk_tree_selection_unselect_all (sel);
484 modest_window_enable_dimming (MODEST_WINDOW(win));
486 /* FIXME: May be folder_monitor will also refilter treemode on EXPUNGE changes ? */
487 /* refresh the header view (removing marked-as-deleted) */
488 /* modest_header_view_refilter (MODEST_HEADER_VIEW(header_view)); */
490 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
491 modest_ui_actions_refresh_message_window_after_delete (MODEST_MSG_VIEW_WINDOW (win));
493 /* Get main window */
494 mgr = modest_runtime_get_window_mgr ();
495 main_window = modest_window_mgr_get_main_window (mgr);
498 /* Move cursor to next row */
501 /* Select next row */
502 if (gtk_tree_row_reference_valid (row_reference)) {
503 next_path = gtk_tree_row_reference_get_path (row_reference);
504 gtk_tree_selection_select_path (sel, next_path);
505 gtk_tree_path_free (next_path);
507 if (row_reference != NULL)
508 gtk_tree_row_reference_free (row_reference);
512 printf ("DEBUG: %s: Error: code=%d, text=%s\n", __FUNCTION__, err->code, err->message);
516 /* Update toolbar dimming state */
517 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
520 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
521 g_list_free (sel_list);
527 g_object_unref (header_list);
533 /* delete either message or folder, based on where we are */
535 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
537 g_return_if_fail (MODEST_IS_WINDOW(win));
539 /* Check first if the header view has the focus */
540 if (MODEST_IS_MAIN_WINDOW (win)) {
542 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
543 MODEST_WIDGET_TYPE_FOLDER_VIEW);
544 if (gtk_widget_is_focus (w)) {
545 modest_ui_actions_on_delete_folder (action, MODEST_MAIN_WINDOW(win));
549 modest_ui_actions_on_delete_message (action, win);
555 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
557 ModestWindowMgr *mgr = NULL;
559 #ifdef MODEST_PLATFORM_MAEMO
560 modest_osso_save_state();
561 #endif /* MODEST_PLATFORM_MAEMO */
563 g_debug ("closing down, clearing %d item(s) from operation queue",
564 modest_mail_operation_queue_num_elements
565 (modest_runtime_get_mail_operation_queue()));
567 /* cancel all outstanding operations */
568 modest_mail_operation_queue_cancel_all
569 (modest_runtime_get_mail_operation_queue());
571 g_debug ("queue has been cleared");
574 /* Check if there are opened editing windows */
575 mgr = modest_runtime_get_window_mgr ();
576 modest_window_mgr_close_all_windows (mgr);
578 /* note: when modest-tny-account-store is finalized,
579 it will automatically set all network connections
582 /* gtk_main_quit (); */
586 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
590 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
592 /* if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
593 /* gtk_widget_destroy (GTK_WIDGET (win)); */
594 /* } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
595 /* gboolean ret_value; */
596 /* g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
597 /* } else if (MODEST_IS_WINDOW (win)) { */
598 /* gtk_widget_destroy (GTK_WIDGET (win)); */
600 /* g_return_if_reached (); */
605 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
607 GtkClipboard *clipboard = NULL;
608 gchar *selection = NULL;
610 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
611 selection = gtk_clipboard_wait_for_text (clipboard);
613 /* Question: why is the clipboard being used here?
614 * It doesn't really make a lot of sense. */
618 modest_address_book_add_address (selection);
624 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
626 /* This is currently only implemented for Maemo */
627 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
628 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
629 modest_run_account_setup_wizard (win);
632 /* Show the list of accounts: */
633 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
634 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW (win));
636 /* Don't make this a modal window, because secondary windows will then
637 * be unusable, freezing the UI: */
638 /* gtk_window_set_modal (GTK_WINDOW (account_win), TRUE); */
639 modest_maemo_show_dialog_and_forget (GTK_WINDOW (win), account_win);
642 GtkWidget *dialog, *label;
644 /* Create the widgets */
646 dialog = gtk_dialog_new_with_buttons ("Message",
648 GTK_DIALOG_DESTROY_WITH_PARENT,
652 label = gtk_label_new ("Hello World!");
654 /* Ensure that the dialog box is destroyed when the user responds. */
656 g_signal_connect_swapped (dialog, "response",
657 G_CALLBACK (gtk_widget_destroy),
660 /* Add the label, and show everything we've added to the dialog. */
662 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
664 gtk_widget_show_all (dialog);
665 #endif /* MODEST_PLATFORM_MAEMO */
669 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
671 /* Save any changes. */
672 modest_connection_specific_smtp_window_save_server_accounts (
673 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window));
674 gtk_widget_destroy (GTK_WIDGET (window));
680 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
682 /* This is currently only implemented for Maemo,
683 * because it requires an API (libconic) to detect different connection
686 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
688 /* Create the window if necessary: */
689 GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
690 modest_connection_specific_smtp_window_fill_with_connections (
691 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
692 modest_runtime_get_account_mgr());
694 /* Show the window: */
695 gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
696 gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
697 gtk_widget_show (specific_window);
699 /* Save changes when the window is hidden: */
700 g_signal_connect (specific_window, "hide",
701 G_CALLBACK (on_smtp_servers_window_hide), win);
702 #endif /* MODEST_PLATFORM_MAEMO */
706 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
708 ModestWindow *msg_win = NULL;
710 TnyFolder *folder = NULL;
711 gchar *account_name = NULL;
712 gchar *from_str = NULL;
713 /* GError *err = NULL; */
714 TnyAccount *account = NULL;
715 ModestWindowMgr *mgr;
716 gchar *signature = NULL, *blank_and_signature = NULL;
718 /* if there are no accounts yet, just show the wizard */
719 if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
720 const gboolean created = modest_run_account_setup_wizard (win);
725 account_name = g_strdup (modest_window_get_active_account (win));
727 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
729 g_printerr ("modest: no account found\n");
733 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
735 TNY_ACCOUNT_TYPE_STORE);
737 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
741 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
743 g_printerr ("modest: failed get from string for '%s'\n", account_name);
747 gboolean use_signature = FALSE;
748 signature = modest_account_mgr_get_signature (modest_runtime_get_account_mgr (), account_name, &use_signature);
751 blank_and_signature = g_strconcat ("\n", signature, NULL);
753 blank_and_signature = g_strdup ("");
758 msg = modest_tny_msg_new ("", from_str, "", "", "", blank_and_signature, NULL);
760 g_printerr ("modest: failed to create new msg\n");
764 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
766 g_printerr ("modest: failed to find Drafts folder\n");
771 /* Create and register edit window */
772 /* This is destroyed by TODO. */
773 msg_win = modest_msg_edit_window_new (msg, account_name, FALSE);
774 mgr = modest_runtime_get_window_mgr ();
775 modest_window_mgr_register_window (mgr, msg_win);
778 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
780 gtk_widget_show_all (GTK_WIDGET (msg_win));
783 g_free (account_name);
785 g_free (blank_and_signature);
787 g_object_unref (msg_win);
789 g_object_unref (G_OBJECT(account));
791 g_object_unref (G_OBJECT(msg));
793 g_object_unref (G_OBJECT(folder));
797 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
801 ModestMailOperationStatus status;
803 /* If there is no message or the operation was not successful */
804 status = modest_mail_operation_get_status (mail_op);
805 if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
807 /* Remove the header from the preregistered uids */
808 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
818 open_msg_cb (ModestMailOperation *mail_op, TnyHeader *header, TnyMsg *msg, gpointer user_data)
820 ModestWindowMgr *mgr = NULL;
821 ModestWindow *parent_win = NULL;
822 ModestWindow *win = NULL;
823 TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
824 gchar *account = NULL;
827 /* Do nothing if there was any problem with the mail
828 operation. The error will be shown by the error_handler of
829 the mail operation */
830 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
833 parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
834 folder = tny_header_get_folder (header);
836 /* Mark header as read */
837 headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
840 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
842 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
844 /* Gets folder type (OUTBOX headers will be opened in edit window */
845 if (modest_tny_folder_is_local_folder (folder))
846 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
848 /* If the header is in the drafts folder then open the editor,
849 else the message view window */
850 if ((folder_type == TNY_FOLDER_TYPE_DRAFTS) ||
851 (folder_type == TNY_FOLDER_TYPE_OUTBOX)) {
852 /* we cannot edit without a valid account... */
853 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
854 const gboolean created = modest_run_account_setup_wizard(parent_win);
858 win = modest_msg_edit_window_new (msg, account, TRUE);
862 modest_platform_information_banner (NULL, NULL, _("mail_ib_opening_draft_message"));
865 gchar *uid = modest_tny_folder_get_header_unique_id (header);
867 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
868 GtkWidget *header_view;
869 GtkTreeSelection *sel;
870 GList *sel_list = NULL;
873 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
874 MODEST_WIDGET_TYPE_HEADER_VIEW);
876 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
877 sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
879 if (sel_list != NULL) {
880 GtkTreeRowReference *row_reference;
882 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
883 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
884 g_list_free (sel_list);
886 win = modest_msg_view_window_new_with_header_model (
887 msg, account, (const gchar*) uid,
888 model, row_reference);
889 gtk_tree_row_reference_free (row_reference);
891 win = modest_msg_view_window_new_for_attachment (msg, account, (const gchar*) uid);
894 win = modest_msg_view_window_new_for_attachment (msg, account, (const gchar*) uid);
899 /* Register and show new window */
901 mgr = modest_runtime_get_window_mgr ();
902 modest_window_mgr_register_window (mgr, win);
903 g_object_unref (win);
904 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parent_win));
905 gtk_widget_show_all (GTK_WIDGET(win));
908 /* Update toolbar dimming state */
909 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
910 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
916 g_object_unref (parent_win);
917 g_object_unref (folder);
921 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
925 GObject *win = modest_mail_operation_get_source (mail_op);
927 error = modest_mail_operation_get_error (mail_op);
928 printf ("DEBUG: %s: Error: code=%d, text=%s\n", __FUNCTION__, error->code, error->message);
930 if (error->code == MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT) {
932 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
935 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
936 _("mail_ni_ui_folder_get_msg_folder_error"));
940 g_object_unref (win);
944 * This function is used by both modest_ui_actions_on_open and
945 * modest_ui_actions_on_header_activated. This way we always do the
946 * same when trying to open messages.
949 _modest_ui_actions_open (TnyList *headers, ModestWindow *win)
951 ModestWindowMgr *mgr = NULL;
952 TnyIterator *iter = NULL;
953 ModestMailOperation *mail_op = NULL;
954 TnyList *not_opened_headers = NULL;
955 TnyHeaderFlags flags = 0;
957 g_return_if_fail (headers != NULL);
959 /* Check that only one message is selected for opening */
960 if (tny_list_get_length (headers) != 1) {
961 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
962 _("mcen_ib_select_one_message"));
967 /* Look if we already have a message view for each header. If
968 true, then remove the header from the list of headers to
970 mgr = modest_runtime_get_window_mgr ();
971 iter = tny_list_create_iterator (headers);
972 not_opened_headers = tny_simple_list_new ();
974 while (!tny_iterator_is_done (iter)) {
976 ModestWindow *window = NULL;
977 TnyHeader *header = NULL;
978 gboolean found = FALSE;
980 header = TNY_HEADER (tny_iterator_get_current (iter));
982 flags = tny_header_get_flags (header);
985 found = modest_window_mgr_find_registered_header (mgr, header, &window);
987 /* Do not open again the message and present the
988 window to the user */
991 gtk_window_present (GTK_WINDOW (window));
993 /* the header has been registered already, we don't do
994 * anything but wait for the window to come up*/
995 g_debug ("header %p already registered, waiting for window", header);
997 tny_list_append (not_opened_headers, G_OBJECT (header));
1001 g_object_unref (header);
1003 tny_iterator_next (iter);
1005 g_object_unref (iter);
1008 /* If some messages would have to be downloaded, ask the user to
1009 * make a connection. It's generally easier to do this here (in the mainloop)
1010 * than later in a thread:
1012 if (tny_list_get_length (not_opened_headers) > 0) {
1014 gboolean found = FALSE;
1016 iter = tny_list_create_iterator (not_opened_headers);
1017 while (!tny_iterator_is_done (iter) && !found) {
1018 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1019 if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
1022 tny_iterator_next (iter);
1024 g_object_unref (header);
1026 g_object_unref (iter);
1028 if (found && !modest_platform_connect_and_wait (GTK_WINDOW (win), NULL)) {
1029 g_object_unref (not_opened_headers);
1034 /* Register the headers before actually creating the windows: */
1035 TnyIterator *iter_not_opened = tny_list_create_iterator (not_opened_headers);
1036 while (!tny_iterator_is_done (iter_not_opened)) {
1037 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_not_opened));
1039 modest_window_mgr_register_header (mgr, header);
1040 g_object_unref (header);
1043 tny_iterator_next (iter_not_opened);
1045 g_object_unref (iter_not_opened);
1046 iter_not_opened = NULL;
1048 /* Open each message */
1049 if (tny_list_get_length (not_opened_headers) > 0) {
1050 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1052 modest_ui_actions_get_msgs_full_error_handler,
1054 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1055 if (tny_list_get_length (not_opened_headers) > 1) {
1056 modest_mail_operation_get_msgs_full (mail_op,
1062 TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
1063 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1064 modest_mail_operation_get_msg (mail_op, header, open_msg_cb, NULL);
1065 g_object_unref (header);
1066 g_object_unref (iter);
1068 g_object_unref (mail_op);
1072 if (not_opened_headers != NULL)
1073 g_object_unref (not_opened_headers);
1077 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
1082 headers = get_selected_headers (win);
1087 _modest_ui_actions_open (headers, win);
1089 g_object_unref(headers);
1094 free_reply_forward_helper (gpointer data)
1096 ReplyForwardHelper *helper;
1098 helper = (ReplyForwardHelper *) data;
1099 g_free (helper->account_name);
1100 g_slice_free (ReplyForwardHelper, helper);
1104 reply_forward_cb (ModestMailOperation *mail_op, TnyHeader *header, TnyMsg *msg,
1108 ReplyForwardHelper *rf_helper;
1109 ModestWindow *msg_win = NULL;
1110 ModestEditType edit_type;
1112 TnyAccount *account = NULL;
1113 ModestWindowMgr *mgr = NULL;
1114 gchar *signature = NULL;
1116 /* If there was any error. The mail operation could be NULL,
1117 this means that we already have the message downloaded and
1118 that we didn't do a mail operation to retrieve it */
1119 if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1122 g_return_if_fail (user_data != NULL);
1123 rf_helper = (ReplyForwardHelper *) user_data;
1125 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
1126 rf_helper->account_name);
1127 if (modest_account_mgr_get_bool (modest_runtime_get_account_mgr(),
1128 rf_helper->account_name,
1129 MODEST_ACCOUNT_USE_SIGNATURE, FALSE)) {
1130 signature = modest_account_mgr_get_string (modest_runtime_get_account_mgr (),
1131 rf_helper->account_name,
1132 MODEST_ACCOUNT_SIGNATURE, FALSE);
1135 /* Create reply mail */
1136 switch (rf_helper->action) {
1139 modest_tny_msg_create_reply_msg (msg, header, from, signature,
1140 rf_helper->reply_forward_type,
1141 MODEST_TNY_MSG_REPLY_MODE_SENDER);
1143 case ACTION_REPLY_TO_ALL:
1145 modest_tny_msg_create_reply_msg (msg, header, from, signature, rf_helper->reply_forward_type,
1146 MODEST_TNY_MSG_REPLY_MODE_ALL);
1147 edit_type = MODEST_EDIT_TYPE_REPLY;
1149 case ACTION_FORWARD:
1151 modest_tny_msg_create_forward_msg (msg, from, signature, rf_helper->reply_forward_type);
1152 edit_type = MODEST_EDIT_TYPE_FORWARD;
1155 g_return_if_reached ();
1162 g_printerr ("modest: failed to create message\n");
1166 account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1167 rf_helper->account_name,
1168 TNY_ACCOUNT_TYPE_STORE);
1170 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
1174 /* Create and register the windows */
1175 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name, FALSE);
1176 mgr = modest_runtime_get_window_mgr ();
1177 modest_window_mgr_register_window (mgr, msg_win);
1179 if (rf_helper->parent_window != NULL) {
1180 gdouble parent_zoom;
1182 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1183 modest_window_set_zoom (msg_win, parent_zoom);
1186 /* Show edit window */
1187 gtk_widget_show_all (GTK_WIDGET (msg_win));
1191 g_object_unref (msg_win);
1193 g_object_unref (G_OBJECT (new_msg));
1195 g_object_unref (G_OBJECT (account));
1196 /* g_object_unref (msg); */
1197 free_reply_forward_helper (rf_helper);
1200 /* Checks a list of headers. If any of them are not currently
1201 * downloaded (CACHED) then returns TRUE else returns FALSE.
1204 header_list_count_uncached_msgs (
1205 TnyList *header_list,
1209 gint uncached_messages = 0;
1211 iter = tny_list_create_iterator (header_list);
1212 while (!tny_iterator_is_done (iter)) {
1215 header = TNY_HEADER (tny_iterator_get_current (iter));
1217 if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
1218 uncached_messages ++;
1219 g_object_unref (header);
1222 tny_iterator_next (iter);
1224 g_object_unref (iter);
1226 return uncached_messages;
1229 /* Returns FALSE if the user does not want to download the
1230 * messages. Returns TRUE if the user allowed the download.
1233 connect_to_get_msg (GtkWindow *win,
1234 gint num_of_uncached_msgs)
1236 /* Allways download if we are online. */
1237 if (tny_device_is_online (modest_runtime_get_device ()))
1240 /* If offline, then ask for user permission to download the messages */
1241 GtkResponseType response;
1242 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1243 ngettext("mcen_nc_get_msg",
1245 num_of_uncached_msgs));
1246 if (response == GTK_RESPONSE_CANCEL)
1249 return modest_platform_connect_and_wait(win, NULL);
1253 * Common code for the reply and forward actions
1256 reply_forward (ReplyForwardAction action, ModestWindow *win)
1258 ModestMailOperation *mail_op = NULL;
1259 TnyList *header_list = NULL;
1260 ReplyForwardHelper *rf_helper = NULL;
1261 guint reply_forward_type;
1262 gboolean continue_download = TRUE;
1263 gboolean do_retrieve = TRUE;
1265 g_return_if_fail (MODEST_IS_WINDOW(win));
1267 /* we need an account when editing */
1268 if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1269 const gboolean created = modest_run_account_setup_wizard (win);
1274 header_list = get_selected_headers (win);
1278 reply_forward_type =
1279 modest_conf_get_int (modest_runtime_get_conf (),
1280 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
1283 /* check if we need to download msg before asking about it */
1284 do_retrieve = (action == ACTION_FORWARD) ||
1285 (reply_forward_type != MODEST_TNY_MSG_REPLY_TYPE_CITE);
1288 gint num_of_unc_msgs;
1289 /* check that the messages have been previously downloaded */
1290 num_of_unc_msgs = header_list_count_uncached_msgs(
1293 /* If there are any uncached message ask the user
1294 * whether he/she wants to download them. */
1295 if (num_of_unc_msgs)
1296 continue_download = connect_to_get_msg (
1301 if (!continue_download) {
1302 g_object_unref (header_list);
1306 /* We assume that we can only select messages of the
1307 same folder and that we reply all of them from the
1308 same account. In fact the interface currently only
1309 allows single selection */
1312 rf_helper = g_slice_new0 (ReplyForwardHelper);
1313 rf_helper->reply_forward_type = reply_forward_type;
1314 rf_helper->action = action;
1315 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
1317 if ((win != NULL) && (MODEST_IS_WINDOW (win)))
1318 rf_helper->parent_window = GTK_WIDGET (win);
1319 if (!rf_helper->account_name)
1320 rf_helper->account_name =
1321 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1323 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1326 /* Get header and message. Do not free them here, the
1327 reply_forward_cb must do it */
1328 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1329 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1330 if (!msg || !header) {
1332 g_object_unref (msg);
1333 g_printerr ("modest: no message found\n");
1336 reply_forward_cb (NULL, header, msg, rf_helper);
1339 g_object_unref (header);
1344 /* Only reply/forward to one message */
1345 iter = tny_list_create_iterator (header_list);
1346 header = TNY_HEADER (tny_iterator_get_current (iter));
1347 g_object_unref (iter);
1350 /* Retrieve messages */
1352 mail_op = modest_mail_operation_new_with_error_handling (
1353 MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1355 modest_ui_actions_get_msgs_full_error_handler,
1357 modest_mail_operation_queue_add (
1358 modest_runtime_get_mail_operation_queue (), mail_op);
1360 modest_mail_operation_get_msg (mail_op,
1365 g_object_unref(mail_op);
1367 /* we put a ref here to prevent double unref as the reply
1368 * forward callback unrefs the header at its end */
1369 reply_forward_cb (NULL, header, NULL, rf_helper);
1373 g_object_unref (header);
1379 g_object_unref (header_list);
1383 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
1385 g_return_if_fail (MODEST_IS_WINDOW(win));
1387 reply_forward (ACTION_REPLY, win);
1391 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1393 g_return_if_fail (MODEST_IS_WINDOW(win));
1395 reply_forward (ACTION_FORWARD, win);
1399 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1401 g_return_if_fail (MODEST_IS_WINDOW(win));
1403 reply_forward (ACTION_REPLY_TO_ALL, win);
1407 modest_ui_actions_on_next (GtkAction *action,
1408 ModestWindow *window)
1410 if (MODEST_IS_MAIN_WINDOW (window)) {
1411 GtkWidget *header_view;
1413 header_view = modest_main_window_get_child_widget (
1414 MODEST_MAIN_WINDOW(window),
1415 MODEST_WIDGET_TYPE_HEADER_VIEW);
1419 modest_header_view_select_next (
1420 MODEST_HEADER_VIEW(header_view));
1421 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1422 modest_msg_view_window_select_next_message (
1423 MODEST_MSG_VIEW_WINDOW (window));
1425 g_return_if_reached ();
1430 modest_ui_actions_on_prev (GtkAction *action,
1431 ModestWindow *window)
1433 g_return_if_fail (MODEST_IS_WINDOW(window));
1435 if (MODEST_IS_MAIN_WINDOW (window)) {
1436 GtkWidget *header_view;
1437 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1438 MODEST_WIDGET_TYPE_HEADER_VIEW);
1442 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
1443 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1444 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1446 g_return_if_reached ();
1451 modest_ui_actions_on_sort (GtkAction *action,
1452 ModestWindow *window)
1454 g_return_if_fail (MODEST_IS_WINDOW(window));
1456 if (MODEST_IS_MAIN_WINDOW (window)) {
1457 GtkWidget *header_view;
1458 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1459 MODEST_WIDGET_TYPE_HEADER_VIEW);
1461 modest_platform_information_banner (NULL, NULL, _CS("ckdg_ib_nothing_to_sort"));
1466 /* Show sorting dialog */
1467 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
1472 new_messages_arrived (ModestMailOperation *self,
1476 ModestMainWindow *win = NULL;
1477 GtkWidget *folder_view = NULL;
1478 TnyFolderStore *folder = NULL;
1479 gboolean folder_empty = FALSE;
1481 g_return_if_fail (MODEST_IS_MAIN_WINDOW (user_data));
1482 win = MODEST_MAIN_WINDOW (user_data);
1484 /* Set contents style of headers view */
1485 if (modest_main_window_get_contents_style (win) == MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY) {
1486 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1487 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1488 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1491 folder_empty = (tny_folder_get_all_count (TNY_FOLDER (folder)) == 0);
1494 modest_main_window_set_contents_style (win,
1495 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1498 /* Notify new messages have been downloaded */
1499 if (new_messages > 0)
1500 modest_platform_on_new_msg ();
1504 * This function performs the send & receive required actions. The
1505 * window is used to create the mail operation. Typically it should
1506 * always be the main window, but we pass it as argument in order to
1510 modest_ui_actions_do_send_receive (const gchar *account_name, ModestWindow *win)
1512 gchar *acc_name = NULL;
1513 ModestMailOperation *mail_op;
1515 /* If no account name was provided then get the current account, and if
1516 there is no current account then pick the default one: */
1517 if (!account_name) {
1518 acc_name = g_strdup (modest_window_get_active_account(win));
1520 acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1522 g_printerr ("modest: cannot get default account\n");
1526 acc_name = g_strdup (account_name);
1529 /* Set send/receive operation in progress */
1530 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW(win));
1532 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1534 modest_ui_actions_send_receive_error_handler,
1537 g_signal_connect (G_OBJECT(mail_op), "progress-changed",
1538 G_CALLBACK (_on_send_receive_progress_changed),
1541 /* Send & receive. */
1542 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
1543 /* Receive and then send. The operation is tagged initially as
1544 a receive operation because the account update performs a
1545 receive and then a send. The operation changes its type
1546 internally, so the progress objects will receive the proper
1547 progress information */
1548 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1549 modest_mail_operation_update_account (mail_op, acc_name, new_messages_arrived, win);
1550 g_object_unref (G_OBJECT (mail_op));
1558 modest_ui_actions_do_cancel_send (const gchar *account_name,
1561 TnyTransportAccount *transport_account;
1562 TnySendQueue *send_queue = NULL;
1563 GError *error = NULL;
1565 /* Get transport account */
1567 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1568 (modest_runtime_get_account_store(),
1570 TNY_ACCOUNT_TYPE_TRANSPORT));
1571 if (!transport_account) {
1572 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1577 send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
1578 if (!TNY_IS_SEND_QUEUE(send_queue)) {
1579 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
1580 MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1581 "modest: could not find send queue for account\n");
1583 /* Keeep messages in outbox folder */
1584 tny_send_queue_cancel (send_queue, FALSE, &error);
1588 if (transport_account != NULL)
1589 g_object_unref (G_OBJECT (transport_account));
1593 modest_ui_actions_cancel_send_all (ModestWindow *win)
1595 GSList *account_names, *iter;
1597 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1600 iter = account_names;
1602 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
1603 iter = g_slist_next (iter);
1606 modest_account_mgr_free_account_names (account_names);
1607 account_names = NULL;
1611 modest_ui_actions_cancel_send (GtkAction *action, ModestWindow *win)
1614 /* Check if accounts exist */
1615 gboolean accounts_exist =
1616 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1618 /* If not, allow the user to create an account before trying to send/receive. */
1619 if (!accounts_exist)
1620 modest_ui_actions_on_accounts (NULL, win);
1622 /* Cancel all sending operaitons */
1623 modest_ui_actions_cancel_send_all (win);
1627 * Refreshes all accounts. This function will be used by automatic
1631 modest_ui_actions_do_send_receive_all (ModestWindow *win)
1633 GSList *account_names, *iter;
1635 account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
1638 iter = account_names;
1640 modest_ui_actions_do_send_receive ((const char*) iter->data, win);
1641 iter = g_slist_next (iter);
1644 modest_account_mgr_free_account_names (account_names);
1645 account_names = NULL;
1649 modest_do_refresh_current_folder(ModestWindow *win)
1651 /* Refresh currently selected folder. Note that if we only
1652 want to retreive the headers, then the refresh only will
1653 invoke a poke_status over all folders, i.e., only the
1654 total/unread count will be updated */
1655 if (MODEST_IS_MAIN_WINDOW (win)) {
1656 GtkWidget *header_view, *folder_view;
1657 TnyFolderStore *folder_store;
1659 /* Get folder and header view */
1661 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1662 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1666 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1668 if (folder_store && TNY_IS_FOLDER (folder_store)) {
1670 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1671 MODEST_WIDGET_TYPE_HEADER_VIEW);
1673 /* We do not need to set the contents style
1674 because it hasn't changed. We also do not
1675 need to save the widget status. Just force
1677 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1678 TNY_FOLDER (folder_store),
1679 folder_refreshed_cb,
1680 MODEST_MAIN_WINDOW (win));
1684 g_object_unref (folder_store);
1690 * Handler of the click on Send&Receive button in the main toolbar
1693 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1695 /* Check if accounts exist */
1696 gboolean accounts_exist =
1697 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1699 /* If not, allow the user to create an account before trying to send/receive. */
1700 if (!accounts_exist)
1701 modest_ui_actions_on_accounts (NULL, win);
1703 modest_do_refresh_current_folder (win);
1705 /* Refresh the active account */
1706 modest_ui_actions_do_send_receive (NULL, win);
1711 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1714 GtkWidget *header_view;
1716 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1718 header_view = modest_main_window_get_child_widget (main_window,
1719 MODEST_WIDGET_TYPE_HEADER_VIEW);
1723 conf = modest_runtime_get_conf ();
1725 /* what is saved/restored is depending on the style; thus; we save with
1726 * old style, then update the style, and restore for this new style
1728 modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1730 if (modest_header_view_get_style
1731 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1732 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1733 MODEST_HEADER_VIEW_STYLE_TWOLINES);
1735 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1736 MODEST_HEADER_VIEW_STYLE_DETAILS);
1738 modest_widget_memory_restore (conf, G_OBJECT(header_view),
1739 MODEST_CONF_HEADER_VIEW_KEY);
1744 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
1746 ModestMainWindow *main_window)
1748 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1749 g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
1751 /* in the case the folder is empty, show the empty folder message and focus
1753 if (!header && gtk_widget_is_focus (GTK_WIDGET (header_view))) {
1754 if (modest_header_view_is_empty (header_view)) {
1755 TnyFolder *folder = modest_header_view_get_folder (header_view);
1756 GtkWidget *folder_view =
1757 modest_main_window_get_child_widget (main_window,
1758 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1760 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), folder, FALSE);
1761 gtk_widget_grab_focus (GTK_WIDGET (folder_view));
1765 /* If no header has been selected then exit */
1770 if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
1771 gtk_widget_grab_focus (GTK_WIDGET(header_view));
1773 /* Update toolbar dimming state */
1774 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1778 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
1780 ModestMainWindow *main_window)
1784 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1790 /* headers = tny_simple_list_new (); */
1791 /* tny_list_prepend (headers, G_OBJECT (header)); */
1792 headers = modest_header_view_get_selected_headers (header_view);
1794 _modest_ui_actions_open (headers, MODEST_WINDOW (main_window));
1796 g_object_unref (headers);
1800 set_active_account_from_tny_account (TnyAccount *account,
1801 ModestWindow *window)
1803 const gchar *server_acc_name = tny_account_get_id (account);
1805 /* We need the TnyAccount provided by the
1806 account store because that is the one that
1807 knows the name of the Modest account */
1808 TnyAccount *modest_server_account = modest_server_account =
1809 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
1810 MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1812 if (!modest_server_account) {
1813 g_warning ("%s: could not get tny account\n", __FUNCTION__);
1817 /* Update active account, but only if it's not a pseudo-account */
1818 if ((!modest_tny_account_is_virtual_local_folders(modest_server_account)) &&
1819 (!modest_tny_account_is_memory_card_account(modest_server_account))) {
1820 const gchar *modest_acc_name =
1821 modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
1822 if (modest_acc_name)
1823 modest_window_set_active_account (window, modest_acc_name);
1826 g_object_unref (modest_server_account);
1831 folder_refreshed_cb (ModestMailOperation *mail_op,
1835 ModestMainWindow *win = NULL;
1836 GtkWidget *header_view;
1837 gboolean folder_empty = FALSE;
1838 gboolean all_marked_as_deleted = FALSE;
1840 g_return_if_fail (TNY_IS_FOLDER (folder));
1842 win = MODEST_MAIN_WINDOW (user_data);
1844 modest_main_window_get_child_widget(win, MODEST_WIDGET_TYPE_HEADER_VIEW);
1847 TnyFolder *current_folder;
1849 current_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
1850 if (current_folder != NULL && folder != current_folder) {
1851 g_object_unref (current_folder);
1854 g_object_unref (current_folder);
1857 /* Check if folder is empty and set headers view contents style */
1858 folder_empty = (tny_folder_get_all_count (folder) == 0);
1859 all_marked_as_deleted = modest_header_view_is_empty (MODEST_HEADER_VIEW(header_view));
1860 if (folder_empty || all_marked_as_deleted)
1861 modest_main_window_set_contents_style (win,
1862 MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
1866 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
1867 TnyFolderStore *folder_store,
1869 ModestMainWindow *main_window)
1872 GtkWidget *header_view;
1874 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1876 header_view = modest_main_window_get_child_widget(main_window,
1877 MODEST_WIDGET_TYPE_HEADER_VIEW);
1881 conf = modest_runtime_get_conf ();
1883 if (TNY_IS_ACCOUNT (folder_store)) {
1885 set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
1887 /* Show account details */
1888 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
1891 if (TNY_IS_FOLDER (folder_store) && selected) {
1893 /* Update the active account */
1894 TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
1896 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
1897 g_object_unref (account);
1901 /* Set the header style by default, it could
1902 be changed later by the refresh callback to
1904 modest_main_window_set_contents_style (main_window,
1905 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1907 /* Set folder on header view. This function
1908 will call tny_folder_refresh_async so we
1909 pass a callback that will be called when
1910 finished. We use that callback to set the
1911 empty view if there are no messages */
1912 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
1913 TNY_FOLDER (folder_store),
1914 folder_refreshed_cb,
1917 /* Restore configuration. We need to do this
1918 *after* the set_folder because the widget
1919 memory asks the header view about its
1921 modest_widget_memory_restore (modest_runtime_get_conf (),
1922 G_OBJECT(header_view),
1923 MODEST_CONF_HEADER_VIEW_KEY);
1925 /* Update the active account */
1926 //modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
1927 /* Save only if we're seeing headers */
1928 if (modest_main_window_get_contents_style (main_window) ==
1929 MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
1930 modest_widget_memory_save (conf, G_OBJECT (header_view),
1931 MODEST_CONF_HEADER_VIEW_KEY);
1932 modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
1936 /* Update toolbar dimming state */
1937 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
1941 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
1948 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
1950 online = tny_device_is_online (modest_runtime_get_device());
1953 /* already online -- the item is simply not there... */
1954 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
1956 GTK_MESSAGE_WARNING,
1958 _("The %s you selected cannot be found"),
1960 gtk_dialog_add_button (GTK_DIALOG (dialog),_("mcen_bd_dialog_ok"), GTK_RESPONSE_ACCEPT);
1961 gtk_dialog_run (GTK_DIALOG(dialog));
1963 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1966 _("mcen_bd_dialog_cancel"),
1967 GTK_RESPONSE_REJECT,
1968 _("mcen_bd_dialog_ok"),
1969 GTK_RESPONSE_ACCEPT,
1971 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1972 "Do you want to get online?"), item);
1973 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1974 gtk_label_new (txt), FALSE, FALSE, 0);
1975 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1978 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1979 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1980 /* TODO: Comment about why is this commented out: */
1981 /* modest_platform_connect_and_wait (); */
1984 gtk_widget_destroy (dialog);
1988 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1991 /* g_message ("%s %s", __FUNCTION__, link); */
1996 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1999 modest_platform_activate_uri (link);
2003 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
2006 modest_platform_show_uri_popup (link);
2010 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
2013 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
2017 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
2018 const gchar *address,
2021 /* g_message ("%s %s", __FUNCTION__, address); */
2025 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
2027 TnyTransportAccount *transport_account;
2028 ModestMailOperation *mail_operation;
2030 gchar *account_name, *from;
2031 ModestAccountMgr *account_mgr;
2032 gchar *info_text = NULL;
2034 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
2036 data = modest_msg_edit_window_get_msg_data (edit_window);
2038 account_mgr = modest_runtime_get_account_mgr();
2039 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
2041 account_name = modest_account_mgr_get_default_account (account_mgr);
2042 if (!account_name) {
2043 g_printerr ("modest: no account found\n");
2044 modest_msg_edit_window_free_msg_data (edit_window, data);
2048 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
2049 account_name = g_strdup (data->account_name);
2053 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
2054 (modest_runtime_get_account_store(),
2056 TNY_ACCOUNT_TYPE_TRANSPORT));
2057 if (!transport_account) {
2058 g_printerr ("modest: no transport account found for '%s'\n", account_name);
2059 g_free (account_name);
2060 modest_msg_edit_window_free_msg_data (edit_window, data);
2063 from = modest_account_mgr_get_from_string (account_mgr, account_name);
2065 /* Create the mail operation */
2066 mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_INFO, G_OBJECT(edit_window));
2067 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
2069 modest_mail_operation_save_to_drafts (mail_operation,
2081 data->priority_flags);
2084 g_free (account_name);
2085 g_object_unref (G_OBJECT (transport_account));
2086 g_object_unref (G_OBJECT (mail_operation));
2088 modest_msg_edit_window_free_msg_data (edit_window, data);
2090 info_text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
2091 modest_platform_information_banner (NULL, NULL, info_text);
2095 /* For instance, when clicking the Send toolbar button when editing a message: */
2097 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
2099 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
2101 if (!modest_msg_edit_window_check_names (edit_window, TRUE))
2104 /* Offer the connection dialog, if necessary: */
2105 if (!modest_platform_connect_and_wait (GTK_WINDOW (edit_window), NULL))
2108 /* FIXME: Code added just for testing. The final version will
2109 use the send queue provided by tinymail and some
2111 ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
2112 gchar *account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
2114 account_name = modest_account_mgr_get_default_account (account_mgr);
2116 if (!account_name) {
2117 /* Run account setup wizard */
2118 const gboolean created = modest_run_account_setup_wizard(MODEST_WINDOW(edit_window));
2123 MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
2125 if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
2126 account_name = g_strdup (data->account_name);
2129 /* Get the currently-active transport account for this modest account: */
2130 TnyTransportAccount *transport_account =
2131 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
2132 (modest_runtime_get_account_store(),
2134 if (!transport_account) {
2135 /* Run account setup wizard */
2136 const gboolean created = modest_run_account_setup_wizard(MODEST_WINDOW(edit_window));
2141 gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
2143 /* Create the mail operation */
2144 ModestMailOperation *mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_SEND, G_OBJECT(edit_window));
2145 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
2147 modest_mail_operation_send_new_mail (mail_operation,
2158 data->priority_flags);
2162 g_free (account_name);
2163 g_object_unref (G_OBJECT (transport_account));
2164 g_object_unref (G_OBJECT (mail_operation));
2166 modest_msg_edit_window_free_msg_data (edit_window, data);
2167 modest_msg_edit_window_set_sent (edit_window, TRUE);
2169 /* Save settings and close the window: */
2170 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
2174 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
2175 ModestMsgEditWindow *window)
2177 ModestMsgEditFormatState *format_state = NULL;
2179 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2180 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2182 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2185 format_state = modest_msg_edit_window_get_format_state (window);
2186 g_return_if_fail (format_state != NULL);
2188 format_state->bold = gtk_toggle_action_get_active (action);
2189 modest_msg_edit_window_set_format_state (window, format_state);
2190 g_free (format_state);
2195 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
2196 ModestMsgEditWindow *window)
2198 ModestMsgEditFormatState *format_state = NULL;
2200 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2201 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2203 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2206 format_state = modest_msg_edit_window_get_format_state (window);
2207 g_return_if_fail (format_state != NULL);
2209 format_state->italics = gtk_toggle_action_get_active (action);
2210 modest_msg_edit_window_set_format_state (window, format_state);
2211 g_free (format_state);
2216 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
2217 ModestMsgEditWindow *window)
2219 ModestMsgEditFormatState *format_state = NULL;
2221 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2222 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2224 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2227 format_state = modest_msg_edit_window_get_format_state (window);
2228 g_return_if_fail (format_state != NULL);
2230 format_state->bullet = gtk_toggle_action_get_active (action);
2231 modest_msg_edit_window_set_format_state (window, format_state);
2232 g_free (format_state);
2237 modest_ui_actions_on_change_justify (GtkRadioAction *action,
2238 GtkRadioAction *selected,
2239 ModestMsgEditWindow *window)
2241 ModestMsgEditFormatState *format_state = NULL;
2242 GtkJustification value;
2244 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2246 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2249 value = gtk_radio_action_get_current_value (selected);
2251 format_state = modest_msg_edit_window_get_format_state (window);
2252 g_return_if_fail (format_state != NULL);
2254 format_state->justification = value;
2255 modest_msg_edit_window_set_format_state (window, format_state);
2256 g_free (format_state);
2260 modest_ui_actions_on_select_editor_color (GtkAction *action,
2261 ModestMsgEditWindow *window)
2263 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2264 g_return_if_fail (GTK_IS_ACTION (action));
2266 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2269 modest_msg_edit_window_select_color (window);
2273 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
2274 ModestMsgEditWindow *window)
2276 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2277 g_return_if_fail (GTK_IS_ACTION (action));
2279 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2282 modest_msg_edit_window_select_background_color (window);
2286 modest_ui_actions_on_insert_image (GtkAction *action,
2287 ModestMsgEditWindow *window)
2289 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2290 g_return_if_fail (GTK_IS_ACTION (action));
2292 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2295 modest_msg_edit_window_insert_image (window);
2299 modest_ui_actions_on_attach_file (GtkAction *action,
2300 ModestMsgEditWindow *window)
2302 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2303 g_return_if_fail (GTK_IS_ACTION (action));
2305 modest_msg_edit_window_offer_attach_file (window);
2309 modest_ui_actions_on_remove_attachments (GtkAction *action,
2310 ModestMsgEditWindow *window)
2312 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2313 g_return_if_fail (GTK_IS_ACTION (action));
2315 modest_msg_edit_window_remove_attachments (window, NULL);
2319 modest_ui_actions_new_folder_error_handler (ModestMailOperation *mail_op,
2322 ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2323 const GError *error = modest_mail_operation_get_error (mail_op);
2327 modest_platform_information_banner (GTK_WIDGET (window), NULL,
2328 modest_mail_operation_get_error (mail_op)->message);
2333 modest_ui_actions_create_folder(GtkWidget *parent_window,
2334 GtkWidget *folder_view)
2336 TnyFolderStore *parent_folder;
2338 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2340 if (parent_folder) {
2341 gboolean finished = FALSE;
2343 gchar *folder_name = NULL, *suggested_name = NULL;
2344 const gchar *proto_str = NULL;
2345 TnyAccount *account;
2347 if (TNY_IS_ACCOUNT (parent_folder))
2348 account = g_object_ref (parent_folder);
2350 account = tny_folder_get_account (TNY_FOLDER (parent_folder));
2351 proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2353 if (proto_str && modest_protocol_info_get_transport_store_protocol (proto_str) ==
2354 MODEST_PROTOCOL_STORE_POP) {
2356 hildon_banner_show_information (NULL, NULL, _("mail_in_ui_folder_create_error"));
2358 g_object_unref (account);
2360 /* Run the new folder dialog */
2362 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (parent_window),
2367 g_free (suggested_name);
2368 suggested_name = NULL;
2370 if (result == GTK_RESPONSE_REJECT) {
2373 ModestMailOperation *mail_op;
2374 TnyFolder *new_folder = NULL;
2376 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2377 G_OBJECT(parent_window),
2378 modest_ui_actions_new_folder_error_handler,
2381 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2383 new_folder = modest_mail_operation_create_folder (mail_op,
2385 (const gchar *) folder_name);
2387 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2390 g_object_unref (new_folder);
2393 g_object_unref (mail_op);
2396 suggested_name = folder_name;
2400 g_object_unref (parent_folder);
2405 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
2407 GtkWidget *folder_view;
2409 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2411 folder_view = modest_main_window_get_child_widget (main_window,
2412 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2416 modest_ui_actions_create_folder (GTK_WIDGET (main_window), folder_view);
2420 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
2423 ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2424 const GError *error = NULL;
2425 const gchar *message = NULL;
2427 /* Get error message */
2428 error = modest_mail_operation_get_error (mail_op);
2430 g_return_if_reached ();
2432 switch (error->code) {
2433 case MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS:
2434 message = _CS("ckdg_ib_folder_already_exists");
2437 g_return_if_reached ();
2440 modest_platform_information_banner (GTK_WIDGET (window), NULL, message);
2444 modest_ui_actions_on_rename_folder (GtkAction *action,
2445 ModestMainWindow *main_window)
2447 TnyFolderStore *folder;
2448 GtkWidget *folder_view;
2449 GtkWidget *header_view;
2451 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2453 folder_view = modest_main_window_get_child_widget (main_window,
2454 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2458 header_view = modest_main_window_get_child_widget (main_window,
2459 MODEST_WIDGET_TYPE_HEADER_VIEW);
2464 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2469 if (TNY_IS_FOLDER (folder)) {
2472 const gchar *current_name;
2473 TnyFolderStore *parent;
2474 gboolean do_rename = TRUE;
2476 current_name = tny_folder_get_name (TNY_FOLDER (folder));
2477 parent = tny_folder_get_folder_store (TNY_FOLDER (folder));
2478 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (main_window),
2479 parent, current_name,
2481 g_object_unref (parent);
2483 if (response != GTK_RESPONSE_ACCEPT || strlen (folder_name) == 0) {
2485 } else if (modest_platform_is_network_folderstore(folder) &&
2486 !tny_device_is_online (modest_runtime_get_device())) {
2487 TnyAccount *account = tny_folder_get_account(TNY_FOLDER(folder));
2488 do_rename = modest_platform_connect_and_wait(GTK_WINDOW(main_window), account);
2489 g_object_unref(account);
2493 ModestMailOperation *mail_op;
2494 GtkTreeSelection *sel = NULL;
2497 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_INFO,
2498 G_OBJECT(main_window),
2499 modest_ui_actions_rename_folder_error_handler,
2502 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2505 /* Clear the headers view */
2506 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
2507 gtk_tree_selection_unselect_all (sel);
2509 /* Select *after* the changes */
2510 modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view),
2511 TNY_FOLDER(folder), TRUE);
2513 /* Actually rename the folder */
2514 modest_mail_operation_rename_folder (mail_op,
2515 TNY_FOLDER (folder),
2516 (const gchar *) folder_name);
2518 g_object_unref (mail_op);
2519 g_free (folder_name);
2522 g_object_unref (folder);
2526 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
2529 GObject *win = modest_mail_operation_get_source (mail_op);
2531 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2532 _("mail_in_ui_folder_delete_error"));
2533 g_object_unref (win);
2537 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
2539 TnyFolderStore *folder;
2540 GtkWidget *folder_view;
2543 gboolean do_delete = TRUE;
2545 g_return_if_fail (MODEST_IS_MAIN_WINDOW (main_window));
2547 folder_view = modest_main_window_get_child_widget (main_window,
2548 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2552 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2554 /* Show an error if it's an account */
2555 if (!TNY_IS_FOLDER (folder)) {
2556 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
2557 _("mail_in_ui_folder_delete_error"));
2558 g_object_unref (G_OBJECT (folder));
2563 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
2564 tny_folder_get_name (TNY_FOLDER (folder)));
2565 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
2566 (const gchar *) message);
2569 if (response != GTK_RESPONSE_OK) {
2571 } else if (modest_platform_is_network_folderstore(folder) &&
2572 !tny_device_is_online (modest_runtime_get_device())) {
2573 TnyAccount *account = tny_folder_get_account(TNY_FOLDER(folder));
2574 do_delete = modest_platform_connect_and_wait(GTK_WINDOW(main_window), account);
2575 g_object_unref(account);
2579 ModestMailOperation *mail_op;
2580 GtkTreeSelection *sel;
2582 /* Unselect the folder before deleting it to free the headers */
2583 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
2584 gtk_tree_selection_unselect_all (sel);
2586 /* Create the mail operation */
2588 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_DELETE,
2589 G_OBJECT(main_window),
2590 modest_ui_actions_delete_folder_error_handler,
2593 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2595 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
2596 g_object_unref (G_OBJECT (mail_op));
2599 g_object_unref (G_OBJECT (folder));
2603 modest_ui_actions_on_delete_folder (GtkAction *action,
2604 ModestMainWindow *main_window)
2606 GtkWidget *folder_view;
2607 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2609 delete_folder (main_window, FALSE);
2610 folder_view = modest_main_window_get_child_widget (main_window,
2611 MODEST_WIDGET_TYPE_FOLDER_VIEW);
2614 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (folder_view));
2618 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
2620 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2622 delete_folder (main_window, TRUE);
2627 show_error (GtkWidget *parent_widget, const gchar* text)
2629 hildon_banner_show_information(parent_widget, NULL, text);
2632 GtkDialog *dialog = GTK_DIALOG (hildon_note_new_information (parent_window, text)); */
2634 GtkDialog *dialog = GTK_DIALOG (gtk_message_dialog_new (parent_window,
2641 gtk_dialog_run (dialog);
2642 gtk_widget_destroy (GTK_WIDGET (dialog));
2647 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
2648 const gchar* server_account_name,
2653 ModestMainWindow *main_window)
2655 g_return_if_fail(server_account_name);
2656 /* printf("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
2658 /* Initalize output parameters: */
2665 #ifdef MODEST_PLATFORM_MAEMO
2666 /* Maemo uses a different (awkward) button order,
2667 * It should probably just use gtk_alternative_dialog_button_order ().
2669 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2672 _("mcen_bd_dialog_ok"),
2673 GTK_RESPONSE_ACCEPT,
2674 _("mcen_bd_dialog_cancel"),
2675 GTK_RESPONSE_REJECT,
2678 GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
2682 GTK_RESPONSE_REJECT,
2684 GTK_RESPONSE_ACCEPT,
2686 #endif /* MODEST_PLATFORM_MAEMO */
2688 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
2690 gchar *server_name = modest_server_account_get_hostname (
2691 modest_runtime_get_account_mgr(), server_account_name);
2692 if (!server_name) {/* This happened once, though I don't know why. murrayc. */
2693 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
2698 /* This causes a warning because the logical ID has no %s in it,
2699 * though the translation does, but there is not much we can do about that: */
2700 gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
2701 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
2704 g_free (server_name);
2708 gchar *initial_username = modest_server_account_get_username (
2709 modest_runtime_get_account_mgr(), server_account_name);
2711 GtkWidget *entry_username = gtk_entry_new ();
2712 if (initial_username)
2713 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
2714 /* Dim this if a connection has ever succeeded with this username,
2715 * as per the UI spec: */
2716 const gboolean username_known =
2717 modest_server_account_get_username_has_succeeded(
2718 modest_runtime_get_account_mgr(), server_account_name);
2719 gtk_widget_set_sensitive (entry_username, !username_known);
2721 #ifdef MODEST_PLATFORM_MAEMO
2722 /* Auto-capitalization is the default, so let's turn it off: */
2723 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
2725 /* Create a size group to be used by all captions.
2726 * Note that HildonCaption does not create a default size group if we do not specify one.
2727 * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
2728 GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2730 GtkWidget *caption = hildon_caption_new (sizegroup,
2731 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
2732 gtk_widget_show (entry_username);
2733 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2734 FALSE, FALSE, MODEST_MARGIN_HALF);
2735 gtk_widget_show (caption);
2737 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
2739 #endif /* MODEST_PLATFORM_MAEMO */
2742 GtkWidget *entry_password = gtk_entry_new ();
2743 gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
2744 /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
2746 #ifdef MODEST_PLATFORM_MAEMO
2747 /* Auto-capitalization is the default, so let's turn it off: */
2748 hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
2749 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
2751 caption = hildon_caption_new (sizegroup,
2752 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
2753 gtk_widget_show (entry_password);
2754 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
2755 FALSE, FALSE, MODEST_MARGIN_HALF);
2756 gtk_widget_show (caption);
2757 g_object_unref (sizegroup);
2759 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
2761 #endif /* MODEST_PLATFORM_MAEMO */
2763 /* This is not in the Maemo UI spec:
2764 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
2765 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
2769 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2771 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2773 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
2775 modest_server_account_set_username (
2776 modest_runtime_get_account_mgr(), server_account_name,
2779 const gboolean username_was_changed =
2780 (strcmp (*username, initial_username) != 0);
2781 if (username_was_changed) {
2782 g_warning ("%s: tinymail does not yet support changing the "
2783 "username in the get_password() callback.\n", __FUNCTION__);
2788 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
2790 /* We do not save the password in the configuration,
2791 * because this function is only called for passwords that should
2792 * not be remembered:
2793 modest_server_account_set_password (
2794 modest_runtime_get_account_mgr(), server_account_name,
2803 show_error(GTK_WIDGET (main_window), _("mail_ib_login_cancelled"));
2815 /* This is not in the Maemo UI spec:
2816 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
2822 gtk_widget_destroy (dialog);
2824 /* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
2828 modest_ui_actions_on_cut (GtkAction *action,
2829 ModestWindow *window)
2831 GtkWidget *focused_widget;
2832 GtkClipboard *clipboard;
2834 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2835 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2836 if (GTK_IS_EDITABLE (focused_widget)) {
2837 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
2838 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2839 gtk_clipboard_store (clipboard);
2840 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2841 GtkTextBuffer *buffer;
2843 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2844 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
2845 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2846 gtk_clipboard_store (clipboard);
2847 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2848 TnyList *header_list = modest_header_view_get_selected_headers (
2849 MODEST_HEADER_VIEW (focused_widget));
2850 gboolean continue_download = FALSE;
2851 gint num_of_unc_msgs;
2853 num_of_unc_msgs = header_list_count_uncached_msgs(
2854 header_list, GTK_WINDOW (window));
2856 if (num_of_unc_msgs)
2857 continue_download = connect_to_get_msg(
2858 GTK_WINDOW (window),
2861 if (num_of_unc_msgs == 0 || continue_download) {
2862 /* modest_platform_information_banner (
2863 NULL, NULL, _CS("mcen_ib_getting_items"));*/
2864 modest_header_view_cut_selection (
2865 MODEST_HEADER_VIEW (focused_widget));
2868 g_object_unref (header_list);
2869 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2870 modest_folder_view_cut_selection (MODEST_FOLDER_VIEW (focused_widget));
2875 modest_ui_actions_on_copy (GtkAction *action,
2876 ModestWindow *window)
2878 GtkClipboard *clipboard;
2879 GtkWidget *focused_widget;
2880 gboolean copied = TRUE;
2882 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
2883 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
2885 if (GTK_IS_LABEL (focused_widget)) {
2886 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
2887 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2888 gtk_clipboard_store (clipboard);
2889 } else if (GTK_IS_EDITABLE (focused_widget)) {
2890 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
2891 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2892 gtk_clipboard_store (clipboard);
2893 } else if (GTK_IS_HTML (focused_widget)) {
2894 gtk_html_copy (GTK_HTML (focused_widget));
2895 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2896 gtk_clipboard_store (clipboard);
2897 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
2898 GtkTextBuffer *buffer;
2899 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
2900 gtk_text_buffer_copy_clipboard (buffer, clipboard);
2901 gtk_clipboard_set_can_store (clipboard, NULL, 0);
2902 gtk_clipboard_store (clipboard);
2903 } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
2904 TnyList *header_list = modest_header_view_get_selected_headers (
2905 MODEST_HEADER_VIEW (focused_widget));
2906 gboolean continue_download = FALSE;
2907 gint num_of_unc_msgs;
2909 num_of_unc_msgs = header_list_count_uncached_msgs(
2911 GTK_WINDOW (window));
2913 if (num_of_unc_msgs)
2914 continue_download = connect_to_get_msg(
2915 GTK_WINDOW (window),
2918 if (num_of_unc_msgs == 0 || continue_download) {
2919 modest_platform_information_banner (
2920 NULL, NULL, _CS("mcen_ib_getting_items"));
2921 modest_header_view_copy_selection (
2922 MODEST_HEADER_VIEW (focused_widget));
2926 g_object_unref (header_list);
2928 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
2929 modest_folder_view_copy_selection (MODEST_FOLDER_VIEW (focused_widget));
2932 /* Show information banner if there was a copy to clipboard */
2934 modest_platform_information_banner (
2935 NULL, NULL, _CS("ecoc_ib_edwin_copied"));
2939 modest_ui_actions_on_undo (GtkAction *action,
2940 ModestWindow *window)
2942 ModestEmailClipboard *clipboard = NULL;
2944 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2945 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
2946 } else if (MODEST_IS_MAIN_WINDOW (window)) {
2947 /* Clear clipboard source */
2948 clipboard = modest_runtime_get_email_clipboard ();
2949 modest_email_clipboard_clear (clipboard);
2952 g_return_if_reached ();
2957 modest_ui_actions_on_redo (GtkAction *action,
2958 ModestWindow *window)
2960 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
2961 modest_msg_edit_window_redo (MODEST_MSG_EDIT_WINDOW (window));
2964 g_return_if_reached ();
2970 paste_msgs_cb (const GObject *object, gpointer user_data)
2972 g_return_if_fail (MODEST_IS_MAIN_WINDOW (object));
2973 g_return_if_fail (GTK_IS_WIDGET (user_data));
2975 /* destroy information note */
2976 gtk_widget_destroy (GTK_WIDGET(user_data));
2981 paste_as_attachment_free (gpointer data)
2983 PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) data;
2985 gtk_widget_destroy (helper->banner);
2986 g_object_unref (helper->banner);
2991 paste_msg_as_attachment_cb (ModestMailOperation *mail_op,
2996 PasteAsAttachmentHelper *helper = (PasteAsAttachmentHelper *) userdata;
2997 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (helper->window));
3002 modest_msg_edit_window_add_part (MODEST_MSG_EDIT_WINDOW (helper->window), TNY_MIME_PART (msg));
3007 modest_ui_actions_on_paste (GtkAction *action,
3008 ModestWindow *window)
3010 GtkWidget *focused_widget = NULL;
3011 GtkWidget *inf_note = NULL;
3012 ModestMailOperation *mail_op = NULL;
3014 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
3015 if (GTK_IS_EDITABLE (focused_widget)) {
3016 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
3017 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
3018 ModestEmailClipboard *e_clipboard = NULL;
3019 e_clipboard = modest_runtime_get_email_clipboard ();
3020 if (modest_email_clipboard_cleared (e_clipboard)) {
3021 GtkTextBuffer *buffer;
3022 GtkClipboard *clipboard;
3024 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
3025 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
3026 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
3027 } else if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
3028 ModestMailOperation *mail_op;
3029 TnyFolder *src_folder;
3032 PasteAsAttachmentHelper *helper = g_new0 (PasteAsAttachmentHelper, 1);
3033 helper->window = MODEST_MSG_EDIT_WINDOW (window);
3034 helper->banner = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
3035 _CS("ckct_nw_pasting"));
3036 modest_email_clipboard_get_data (e_clipboard, &src_folder, &data, &delete);
3037 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
3039 if (helper->banner != NULL) {
3040 g_object_ref (G_OBJECT (helper->banner));
3041 gtk_window_set_modal (GTK_WINDOW (helper->banner), FALSE);
3042 gtk_widget_show (GTK_WIDGET (helper->banner));
3046 modest_mail_operation_get_msgs_full (mail_op,
3048 (GetMsgAsyncUserCallback) paste_msg_as_attachment_cb,
3050 paste_as_attachment_free);
3053 } else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
3054 ModestEmailClipboard *clipboard = NULL;
3055 TnyFolder *src_folder = NULL;
3056 TnyFolderStore *folder_store = NULL;
3057 TnyList *data = NULL;
3058 gboolean delete = FALSE;
3060 /* Check clipboard source */
3061 clipboard = modest_runtime_get_email_clipboard ();
3062 if (modest_email_clipboard_cleared (clipboard))
3065 /* Get elements to paste */
3066 modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
3068 /* Create a new mail operation */
3069 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, G_OBJECT(window));
3071 /* Get destination folder */
3072 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
3074 /* transfer messages */
3078 /* Ask for user confirmation */
3079 response = msgs_move_to_confirmation (GTK_WINDOW (window),
3080 TNY_FOLDER (folder_store),
3084 if (response == GTK_RESPONSE_OK) {
3085 /* Launch notification */
3086 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
3087 _CS("ckct_nw_pasting"));
3088 if (inf_note != NULL) {
3089 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
3090 gtk_widget_show (GTK_WIDGET(inf_note));
3093 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3094 modest_mail_operation_xfer_msgs (mail_op,
3096 TNY_FOLDER (folder_store),
3101 g_object_unref (mail_op);
3104 } else if (src_folder != NULL) {
3105 /* Launch notification */
3106 inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
3107 _CS("ckct_nw_pasting"));
3108 if (inf_note != NULL) {
3109 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
3110 gtk_widget_show (GTK_WIDGET(inf_note));
3113 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
3114 modest_mail_operation_xfer_folder (mail_op,
3124 g_object_unref (data);
3125 if (src_folder != NULL)
3126 g_object_unref (src_folder);
3127 if (folder_store != NULL)
3128 g_object_unref (folder_store);
3134 modest_ui_actions_on_select_all (GtkAction *action,
3135 ModestWindow *window)
3137 GtkWidget *focused_widget;
3139 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
3140 if (MODEST_IS_ATTACHMENTS_VIEW (focused_widget)) {
3141 modest_attachments_view_select_all (MODEST_ATTACHMENTS_VIEW (focused_widget));
3142 } else if (GTK_IS_LABEL (focused_widget)) {
3143 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
3144 } else if (GTK_IS_EDITABLE (focused_widget)) {
3145 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
3146 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
3147 GtkTextBuffer *buffer;
3148 GtkTextIter start, end;
3150 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
3151 gtk_text_buffer_get_start_iter (buffer, &start);
3152 gtk_text_buffer_get_end_iter (buffer, &end);
3153 gtk_text_buffer_select_range (buffer, &start, &end);
3154 } else if (GTK_IS_HTML (focused_widget)) {
3155 gtk_html_select_all (GTK_HTML (focused_widget));
3156 } else if (MODEST_IS_MAIN_WINDOW (window)) {
3157 GtkWidget *header_view = focused_widget;
3158 GtkTreeSelection *selection = NULL;
3160 if (!(MODEST_IS_HEADER_VIEW (focused_widget))) {
3161 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
3162 MODEST_WIDGET_TYPE_HEADER_VIEW);
3165 /* Disable window dimming management */
3166 modest_window_disable_dimming (MODEST_WINDOW(window));
3168 /* Select all messages */
3169 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
3170 gtk_tree_selection_select_all (selection);
3172 /* Set focuse on header view */
3173 gtk_widget_grab_focus (header_view);
3176 /* Enable window dimming management */
3177 modest_window_enable_dimming (MODEST_WINDOW(window));
3178 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window));
3184 modest_ui_actions_on_mark_as_read (GtkAction *action,
3185 ModestWindow *window)
3187 g_return_if_fail (MODEST_IS_WINDOW(window));
3189 /* Mark each header as read */
3190 do_headers_action (window, headers_action_mark_as_read, NULL);
3194 modest_ui_actions_on_mark_as_unread (GtkAction *action,
3195 ModestWindow *window)
3197 g_return_if_fail (MODEST_IS_WINDOW(window));
3199 /* Mark each header as read */
3200 do_headers_action (window, headers_action_mark_as_unread, NULL);
3204 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
3205 GtkRadioAction *selected,
3206 ModestWindow *window)
3210 value = gtk_radio_action_get_current_value (selected);
3211 if (MODEST_IS_WINDOW (window)) {
3212 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
3217 modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
3218 GtkRadioAction *selected,
3219 ModestWindow *window)
3221 TnyHeaderFlags flags;
3222 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3224 flags = gtk_radio_action_get_current_value (selected);
3225 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
3229 modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
3230 GtkRadioAction *selected,
3231 ModestWindow *window)
3235 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3237 file_format = gtk_radio_action_get_current_value (selected);
3238 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
3243 modest_ui_actions_on_zoom_plus (GtkAction *action,
3244 ModestWindow *window)
3246 g_return_if_fail (MODEST_IS_WINDOW (window));
3248 modest_window_zoom_plus (MODEST_WINDOW (window));
3252 modest_ui_actions_on_zoom_minus (GtkAction *action,
3253 ModestWindow *window)
3255 g_return_if_fail (MODEST_IS_WINDOW (window));
3257 modest_window_zoom_minus (MODEST_WINDOW (window));
3261 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
3262 ModestWindow *window)
3264 ModestWindowMgr *mgr;
3265 gboolean fullscreen, active;
3266 g_return_if_fail (MODEST_IS_WINDOW (window));
3268 mgr = modest_runtime_get_window_mgr ();
3270 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
3271 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
3273 if (active != fullscreen) {
3274 modest_window_mgr_set_fullscreen_mode (mgr, active);
3275 gtk_window_present (GTK_WINDOW (window));
3280 modest_ui_actions_on_change_fullscreen (GtkAction *action,
3281 ModestWindow *window)
3283 ModestWindowMgr *mgr;
3284 gboolean fullscreen;
3286 g_return_if_fail (MODEST_IS_WINDOW (window));
3288 mgr = modest_runtime_get_window_mgr ();
3289 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
3290 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
3292 gtk_window_present (GTK_WINDOW (window));
3296 * Used by modest_ui_actions_on_details to call do_headers_action
3299 headers_action_show_details (TnyHeader *header,
3300 ModestWindow *window,
3307 dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
3310 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
3311 gtk_widget_show_all (dialog);
3312 gtk_dialog_run (GTK_DIALOG (dialog));
3314 gtk_widget_destroy (dialog);
3318 * Show the folder details in a ModestDetailsDialog widget
3321 show_folder_details (TnyFolder *folder,
3327 dialog = modest_details_dialog_new_with_folder (window, folder);
3330 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
3331 gtk_widget_show_all (dialog);
3332 gtk_dialog_run (GTK_DIALOG (dialog));
3334 gtk_widget_destroy (dialog);
3338 * Show the header details in a ModestDetailsDialog widget
3341 modest_ui_actions_on_details (GtkAction *action,
3344 TnyList * headers_list;
3348 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
3351 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
3354 g_object_unref (msg);
3356 headers_list = get_selected_headers (win);
3360 iter = tny_list_create_iterator (headers_list);
3362 header = TNY_HEADER (tny_iterator_get_current (iter));
3364 headers_action_show_details (header, win, NULL);
3365 g_object_unref (header);
3368 g_object_unref (iter);
3369 g_object_unref (headers_list);
3371 } else if (MODEST_IS_MAIN_WINDOW (win)) {
3372 GtkWidget *folder_view, *header_view;
3374 /* Check which widget has the focus */
3375 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3376 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3377 if (gtk_widget_is_focus (folder_view)) {
3378 TnyFolderStore *folder_store
3379 = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3380 if (!folder_store) {
3381 g_warning ("%s: No item was selected.\n", __FUNCTION__);
3384 /* Show only when it's a folder */
3385 /* This function should not be called for account items,
3386 * because we dim the menu item for them. */
3387 if (TNY_IS_FOLDER (folder_store)) {
3388 show_folder_details (TNY_FOLDER (folder_store), GTK_WINDOW (win));
3391 g_object_unref (folder_store);
3394 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3395 MODEST_WIDGET_TYPE_HEADER_VIEW);
3396 /* Show details of each header */
3397 do_headers_action (win, headers_action_show_details, header_view);
3403 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
3404 ModestMsgEditWindow *window)
3406 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3408 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
3412 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
3413 ModestMsgEditWindow *window)
3415 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3417 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
3421 modest_ui_actions_toggle_folders_view (GtkAction *action,
3422 ModestMainWindow *main_window)
3424 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3426 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
3427 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
3429 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
3433 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
3434 ModestWindow *window)
3436 gboolean active, fullscreen = FALSE;
3437 ModestWindowMgr *mgr;
3439 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
3441 /* Check if we want to toggle the toolbar vuew in fullscreen
3443 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
3444 "ViewShowToolbarFullScreen")) {
3448 /* Toggle toolbar */
3449 mgr = modest_runtime_get_window_mgr ();
3450 modest_window_mgr_show_toolbars (mgr, G_TYPE_FROM_INSTANCE (window), active, fullscreen);
3454 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
3455 ModestMsgEditWindow *window)
3457 modest_msg_edit_window_select_font (window);
3461 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
3462 const gchar *display_name,
3465 /* Do not change the application name if the widget has not
3466 the focus. This callback could be called even if the folder
3467 view has not the focus, because the handled signal could be
3468 emitted when the folder view is redrawn */
3469 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
3471 gtk_window_set_title (window, display_name);
3473 gtk_window_set_title (window, " ");
3478 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
3480 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3481 modest_msg_edit_window_select_contacts (window);
3485 modest_ui_actions_on_check_names (GtkAction *action, ModestMsgEditWindow *window)
3487 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
3488 modest_msg_edit_window_check_names (window, FALSE);
3492 create_move_to_dialog_on_new_folder(GtkWidget *button, gpointer user_data)
3494 modest_ui_actions_create_folder (gtk_widget_get_toplevel (button),
3495 GTK_WIDGET (user_data));
3499 * This function is used to track changes in the selection of the
3500 * folder view that is inside the "move to" dialog to enable/disable
3501 * the OK button because we do not want the user to select a disallowed
3502 * destination for a folder.
3503 * The user also not desired to be able to use NEW button on items where
3504 * folder creation is not possibel.
3507 on_move_to_dialog_folder_selection_changed (ModestFolderView* self,
3508 TnyFolderStore *folder_store,
3512 GtkWidget *dialog = NULL;
3513 GtkWidget *ok_button = NULL, *new_button = NULL;
3514 GList *children = NULL;
3515 gboolean ok_sensitive = TRUE, new_sensitive = TRUE;
3516 gboolean moving_folder = FALSE;
3517 gboolean is_local_account = TRUE;
3518 GtkWidget *folder_view = NULL;
3519 ModestTnyFolderRules rules;
3524 /* Get the OK button */
3525 dialog = gtk_widget_get_ancestor (GTK_WIDGET (self), GTK_TYPE_DIALOG);
3529 children = gtk_container_get_children (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area));
3530 ok_button = GTK_WIDGET (children->next->next->data);
3531 new_button = GTK_WIDGET (children->next->data);
3532 g_list_free (children);
3534 /* check if folder_store is an remote account */
3535 if (TNY_IS_ACCOUNT (folder_store)) {
3536 TnyAccount *local_account = NULL;
3537 ModestTnyAccountStore *account_store = NULL;
3539 account_store = modest_runtime_get_account_store ();
3540 local_account = modest_tny_account_store_get_local_folders_account (account_store);
3542 if ((gpointer) local_account != (gpointer) folder_store) {
3543 is_local_account = FALSE;
3544 /* New button should be dimmed on remote
3546 new_sensitive = FALSE;
3548 g_object_unref (local_account);
3551 /* Check the target folder rules */
3552 if (TNY_IS_FOLDER (folder_store)) {
3553 rules = modest_tny_folder_get_rules (TNY_FOLDER (folder_store));
3554 if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
3555 ok_sensitive = FALSE;
3556 new_sensitive = FALSE;
3561 /* Check if we're moving a folder */
3562 if (MODEST_IS_MAIN_WINDOW (user_data)) {
3563 /* Get the widgets */
3564 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (user_data),
3565 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3566 if (gtk_widget_is_focus (folder_view))
3567 moving_folder = TRUE;
3570 if (moving_folder) {
3571 TnyFolderStore *moved_folder = NULL, *parent = NULL;
3573 /* Get the folder to move */
3574 moved_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3576 /* Check that we're not moving to the same folder */
3577 if (TNY_IS_FOLDER (moved_folder)) {
3578 parent = tny_folder_get_folder_store (TNY_FOLDER (moved_folder));
3579 if (parent == folder_store)
3580 ok_sensitive = FALSE;
3581 g_object_unref (parent);
3584 if (ok_sensitive && TNY_IS_ACCOUNT (folder_store)) {
3585 /* Do not allow to move to an account unless it's the
3586 local folders account */
3587 if (!is_local_account)
3588 ok_sensitive = FALSE;
3591 if (ok_sensitive && (moved_folder == folder_store)) {
3592 /* Do not allow to move to itself */
3593 ok_sensitive = FALSE;
3595 g_object_unref (moved_folder);
3597 TnyHeader *header = NULL;
3598 TnyFolder *src_folder = NULL;
3600 /* Moving a message */
3601 if (MODEST_IS_MSG_VIEW_WINDOW (user_data)) {
3602 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (user_data));
3603 src_folder = tny_header_get_folder (header);
3604 g_object_unref (header);
3607 TNY_FOLDER (modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view)));
3610 /* Do not allow to move the msg to the same folder */
3611 /* Do not allow to move the msg to an account */
3612 if ((gpointer) src_folder == (gpointer) folder_store ||
3613 TNY_IS_ACCOUNT (folder_store))
3614 ok_sensitive = FALSE;
3615 g_object_unref (src_folder);
3619 /* Set sensitivity of the OK button */
3620 gtk_widget_set_sensitive (ok_button, ok_sensitive);
3621 /* Set sensitivity of the NEW button */
3622 gtk_widget_set_sensitive (new_button, new_sensitive);
3626 create_move_to_dialog (GtkWindow *win,
3627 GtkWidget *folder_view,
3628 GtkWidget **tree_view)
3630 GtkWidget *dialog, *scroll;
3631 GtkWidget *new_button;
3633 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
3635 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
3638 gtk_dialog_add_button (GTK_DIALOG (dialog), _("mcen_bd_dialog_ok"), GTK_RESPONSE_ACCEPT);
3639 /* We do this manually so GTK+ does not associate a response ID for
3641 new_button = gtk_button_new_from_stock (_("mcen_bd_new"));
3642 gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog)->action_area), new_button, FALSE, FALSE, 0);
3643 gtk_dialog_add_button (GTK_DIALOG (dialog), _("mcen_bd_dialog_cancel"), GTK_RESPONSE_REJECT);
3645 /* Create scrolled window */
3646 scroll = gtk_scrolled_window_new (NULL, NULL);
3647 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
3648 GTK_POLICY_AUTOMATIC,
3649 GTK_POLICY_AUTOMATIC);
3651 /* Create folder view */
3652 *tree_view = modest_platform_create_folder_view (NULL);
3654 /* Track changes in the selection to
3655 * disable the OK button whenever "Move to" is not possible
3656 * disbale NEW button whenever New is not possible */
3657 g_signal_connect (*tree_view,
3658 "folder_selection_changed",
3659 G_CALLBACK (on_move_to_dialog_folder_selection_changed),
3662 /* Listen to clicks on New button */
3663 g_signal_connect (G_OBJECT (new_button),
3665 G_CALLBACK(create_move_to_dialog_on_new_folder),
3668 /* It could happen that we're trying to move a message from a
3669 window (msg window for example) after the main window was
3670 closed, so we can not just get the model of the folder
3672 if (MODEST_IS_FOLDER_VIEW (folder_view)) {
3673 const gchar *visible_id = NULL;
3675 modest_folder_view_copy_model (MODEST_FOLDER_VIEW(folder_view),
3676 MODEST_FOLDER_VIEW(*tree_view));
3679 modest_folder_view_get_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(folder_view));
3681 /* Show the same account than the one that is shown in the main window */
3682 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(*tree_view),
3685 const gchar *active_account_name = NULL;
3686 ModestAccountMgr *mgr = NULL;
3687 ModestAccountData *acc_data = NULL;
3689 modest_folder_view_update_model (MODEST_FOLDER_VIEW (*tree_view),
3690 TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
3692 active_account_name = modest_window_get_active_account (MODEST_WINDOW (win));
3693 mgr = modest_runtime_get_account_mgr ();
3694 acc_data = modest_account_mgr_get_account_data (mgr, active_account_name);
3696 /* Set the new visible & active account */
3697 if (acc_data && acc_data->store_account) {
3698 modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW (*tree_view),
3699 acc_data->store_account->account_name);
3700 modest_account_mgr_free_account_data (mgr, acc_data);
3704 /* Hide special folders */
3705 modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (*tree_view), FALSE);
3707 gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
3709 /* Add scroll to dialog */
3710 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
3711 scroll, TRUE, TRUE, 0);
3713 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
3714 gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 300);
3720 * Returns TRUE if at least one of the headers of the list belongs to
3721 * a message that has been fully retrieved.
3723 #if 0 /* no longer in use. delete in 2007.10 */
3725 has_retrieved_msgs (TnyList *list)
3728 gboolean found = FALSE;
3730 iter = tny_list_create_iterator (list);
3731 while (!tny_iterator_is_done (iter) && !found) {
3733 TnyHeaderFlags flags = 0;
3735 header = TNY_HEADER (tny_iterator_get_current (iter));
3737 flags = tny_header_get_flags (header);
3738 if (flags & TNY_HEADER_FLAG_CACHED)
3739 /* if (!(flags & TNY_HEADER_FLAG_PARTIAL)) */
3742 g_object_unref (header);
3746 tny_iterator_next (iter);
3748 g_object_unref (iter);
3756 * Shows a confirmation dialog to the user when we're moving messages
3757 * from a remote server to the local storage. Returns the dialog
3758 * response. If it's other kind of movement then it always returns
3761 * This one is used by the next functions:
3762 * modest_ui_actions_xfer_messages_from_move_to
3763 * modest_ui_actions_on_paste - commented out
3764 * drag_and_drop_from_header_view (for d&d in modest_folder_view.c)
3767 msgs_move_to_confirmation (GtkWindow *win,
3768 TnyFolder *dest_folder,
3772 gint response = GTK_RESPONSE_OK;
3774 /* return with OK if the destination is a remote folder */
3775 if (modest_tny_folder_is_remote_folder (dest_folder))
3776 return GTK_RESPONSE_OK;
3778 TnyFolder *src_folder = NULL;
3779 TnyIterator *iter = NULL;
3780 TnyHeader *header = NULL;
3782 /* Get source folder */
3783 iter = tny_list_create_iterator (headers);
3784 header = TNY_HEADER (tny_iterator_get_current (iter));
3786 src_folder = tny_header_get_folder (header);
3787 g_object_unref (header);
3789 g_object_unref (iter);
3791 /* if no src_folder, message may be an attahcment */
3792 if (src_folder == NULL)
3793 return GTK_RESPONSE_CANCEL;
3795 /* If the source is a local or MMC folder */
3796 if (!modest_tny_folder_is_remote_folder (src_folder)) {
3797 g_object_unref (src_folder);
3798 return GTK_RESPONSE_OK;
3800 g_object_unref (src_folder);
3802 /* now if offline we ask the user */
3803 if(connect_to_get_msg( GTK_WINDOW (win),
3804 tny_list_get_length (headers)))
3805 response = GTK_RESPONSE_OK;
3807 response = GTK_RESPONSE_CANCEL;
3815 move_to_cb (const GObject *object, gpointer user_data)
3817 ModestMsgViewWindow *self = NULL;
3818 g_return_if_fail (GTK_IS_WIDGET (user_data));
3819 g_return_if_fail (MODEST_IS_WINDOW (object));
3821 if (MODEST_IS_MSG_VIEW_WINDOW (object)) {
3822 self = MODEST_MSG_VIEW_WINDOW (object);
3824 if (!modest_msg_view_window_select_next_message (self))
3825 if (!modest_msg_view_window_select_previous_message (self))
3826 /* No more messages to view, so close this window */
3827 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
3829 gtk_widget_destroy (GTK_WIDGET(user_data));
3833 modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
3836 ModestMainWindow *main_window = NULL;
3837 GtkWidget *folder_view = NULL;
3838 GObject *win = modest_mail_operation_get_source (mail_op);
3839 const GError *error = NULL;
3840 const gchar *message = NULL;
3842 /* Get error message */
3843 error = modest_mail_operation_get_error (mail_op);
3844 if (error != NULL && error->message != NULL) {
3845 message = error->message;
3847 message = _("mail_in_ui_folder_move_target_error");
3850 /* Disable next automatic folder selection */
3851 if (MODEST_IS_MAIN_WINDOW (user_data)) {
3852 main_window = MODEST_MAIN_WINDOW(user_data);
3853 folder_view = modest_main_window_get_child_widget (main_window,
3854 MODEST_WIDGET_TYPE_FOLDER_VIEW);
3855 modest_folder_view_disable_next_folder_selection (MODEST_FOLDER_VIEW(folder_view));
3858 /* Show notification dialog */
3859 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, message);
3860 g_object_unref (win);
3864 modest_ui_actions_send_receive_error_handler (ModestMailOperation *mail_op,
3867 GObject *win = modest_mail_operation_get_source (mail_op);
3868 const GError *error = modest_mail_operation_get_error (mail_op);
3870 g_return_if_fail (error != NULL);
3871 if (error->message != NULL)
3872 g_printerr ("modest: %s\n", error->message);
3874 g_printerr ("modest: unkonw error on send&receive operation");
3876 /* Show error message */
3877 /* if (modest_mail_operation_get_id (mail_op) == MODEST_MAIL_OPERATION_TYPE_RECEIVE) */
3878 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3879 /* _CS("sfil_ib_unable_to_receive")); */
3881 /* modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL, */
3882 /* _CS("sfil_ib_unable_to_send")); */
3883 g_object_unref (win);
3887 open_msg_for_purge_cb (ModestMailOperation *mail_op,
3894 gint pending_purges = 0;
3895 gboolean some_purged = FALSE;
3896 ModestWindow *win = MODEST_WINDOW (user_data);
3897 ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
3899 /* If there was any error */
3900 if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
3901 modest_window_mgr_unregister_header (mgr, header);
3905 /* Once the message has been retrieved for purging, we check if
3906 * it's all ok for purging */
3908 parts = tny_simple_list_new ();
3909 tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
3910 iter = tny_list_create_iterator (parts);
3912 while (!tny_iterator_is_done (iter)) {
3914 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3915 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part))) {
3916 if (tny_mime_part_is_purged (part))
3923 g_object_unref (part);
3925 tny_iterator_next (iter);
3928 if (pending_purges>0) {
3930 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),_("mcen_nc_purge_file_text_inbox"));
3932 if (response == GTK_RESPONSE_OK) {
3933 modest_platform_information_banner (NULL, NULL, _("mcen_ib_removing_attachment"));
3934 tny_iterator_first (iter);
3935 while (!tny_iterator_is_done (iter)) {
3938 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3939 if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)))
3940 tny_mime_part_set_purged (part);
3943 g_object_unref (part);
3945 tny_iterator_next (iter);
3948 tny_msg_rewrite_cache (msg);
3951 modest_platform_information_banner (NULL, NULL, _("mail_ib_attachment_already_purged"));
3954 /* remove attachments */
3955 tny_iterator_first (iter);
3956 while (!tny_iterator_is_done (iter)) {
3959 part = TNY_MIME_PART (tny_iterator_get_current (iter));
3961 /* One for the reference given by tny_iterator_get_current(): */
3962 g_object_unref (part);
3964 /* TODO: Is this meant to remove the attachment by doing another unref()?
3965 * Otherwise, this seems useless. */
3968 tny_iterator_next (iter);
3970 modest_window_mgr_unregister_header (mgr, header);
3972 g_object_unref (iter);
3973 g_object_unref (parts);
3977 modest_ui_actions_on_main_window_remove_attachments (GtkAction *action,
3978 ModestMainWindow *win)
3980 GtkWidget *header_view;
3981 TnyList *header_list;
3984 TnyHeaderFlags flags;
3985 ModestWindow *msg_view_window = NULL;
3988 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
3990 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
3991 MODEST_WIDGET_TYPE_HEADER_VIEW);
3993 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
3995 if (tny_list_get_length (header_list) == 1) {
3996 iter = tny_list_create_iterator (header_list);
3997 header = TNY_HEADER (tny_iterator_get_current (iter));
3998 g_object_unref (iter);
4003 found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
4004 header, &msg_view_window);
4005 flags = tny_header_get_flags (header);
4006 if (!(flags & TNY_HEADER_FLAG_CACHED))
4009 if (msg_view_window != NULL)
4010 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
4012 /* do nothing; uid was registered before, so window is probably on it's way */
4013 g_warning ("debug: header %p has already been registered", header);
4016 ModestMailOperation *mail_op = NULL;
4017 modest_window_mgr_register_header (modest_runtime_get_window_mgr (), header);
4018 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
4020 modest_ui_actions_get_msgs_full_error_handler,
4022 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4023 modest_mail_operation_get_msg (mail_op, header, open_msg_for_purge_cb, win);
4025 g_object_unref (mail_op);
4028 g_object_unref (header);
4030 g_object_unref (header_list);
4034 * Utility function that transfer messages from both the main window
4035 * and the msg view window when using the "Move to" dialog
4038 modest_ui_actions_xfer_messages_from_move_to (TnyFolderStore *dst_folder,
4041 TnyList *headers = NULL;
4043 TnyAccount *dst_account = NULL;
4044 const gchar *proto_str = NULL;
4045 gboolean dst_is_pop = FALSE;
4047 if (!TNY_IS_FOLDER (dst_folder)) {
4048 modest_platform_information_banner (GTK_WIDGET (win),
4050 _CS("ckdg_ib_unable_to_move_to_current_location"));
4054 dst_account = tny_folder_get_account (TNY_FOLDER (dst_folder));
4055 proto_str = tny_account_get_proto (dst_account);
4057 /* tinymail will return NULL for local folders it seems */
4058 dst_is_pop = proto_str &&
4059 (modest_protocol_info_get_transport_store_protocol (proto_str) ==
4060 MODEST_PROTOCOL_STORE_POP);
4062 g_object_unref (dst_account);
4064 /* Get selected headers */
4065 headers = get_selected_headers (MODEST_WINDOW (win));
4068 modest_platform_information_banner (GTK_WIDGET (win),
4070 ngettext("mail_in_ui_folder_move_target_error",
4071 "mail_in_ui_folder_move_targets_error",
4072 tny_list_get_length (headers)));
4073 g_object_unref (headers);
4077 /* Ask for user confirmation */
4078 response = msgs_move_to_confirmation (GTK_WINDOW (win),
4079 TNY_FOLDER (dst_folder),
4083 /* Transfer messages */
4084 if (response == GTK_RESPONSE_OK) {
4085 GtkWidget *inf_note;
4086 inf_note = modest_platform_animation_banner (GTK_WIDGET (win), NULL,
4087 _CS("ckct_nw_pasting"));
4088 if (inf_note != NULL) {
4089 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
4090 gtk_widget_show (GTK_WIDGET(inf_note));
4093 ModestMailOperation *mail_op =
4094 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
4096 modest_ui_actions_move_folder_error_handler,
4098 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
4101 modest_mail_operation_xfer_msgs (mail_op,
4103 TNY_FOLDER (dst_folder),
4108 g_object_unref (G_OBJECT (mail_op));
4110 g_object_unref (headers);
4114 * UI handler for the "Move to" action when invoked from the
4118 modest_ui_actions_on_main_window_move_to (GtkAction *action,
4119 GtkWidget *folder_view,
4120 TnyFolderStore *dst_folder,
4121 ModestMainWindow *win)
4123 ModestHeaderView *header_view = NULL;
4124 ModestMailOperation *mail_op = NULL;
4125 TnyFolderStore *src_folder;
4126 gboolean online = (tny_device_is_online (modest_runtime_get_device()));
4128 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win));
4130 /* Get the source folder */
4131 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
4133 /* Get header view */
4134 header_view = MODEST_HEADER_VIEW(modest_main_window_get_child_widget (win, MODEST_WIDGET_TYPE_HEADER_VIEW));
4136 /* Get folder or messages to transfer */
4137 if (gtk_widget_is_focus (folder_view)) {
4138 GtkTreeSelection *sel;
4139 gboolean do_xfer = TRUE;
4141 /* Allow only to transfer folders to the local root folder */
4142 if (TNY_IS_ACCOUNT (dst_folder) &&
4143 !MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder)) {
4145 } else if (!TNY_IS_FOLDER (src_folder)) {
4146 g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
4148 } else if (!online && modest_platform_is_network_folderstore(src_folder)) {
4149 guint num_headers = tny_folder_get_all_count(TNY_FOLDER(src_folder));
4150 if (!connect_to_get_msg(GTK_WINDOW(win), num_headers)) {
4156 GtkWidget *inf_note;
4157 inf_note = modest_platform_animation_banner (GTK_WIDGET (win), NULL,
4158 _CS("ckct_nw_pasting"));
4159 if (inf_note != NULL) {
4160 gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
4161 gtk_widget_show (GTK_WIDGET(inf_note));
4163 /* Clean folder on header view before moving it */
4164 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
4165 gtk_tree_selection_unselect_all (sel);
4168 modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
4170 modest_ui_actions_move_folder_error_handler,
4172 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
4175 /* Select *after* the changes */
4176 /* TODO: this function hangs UI after transfer */
4177 /* modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view), */
4178 /* TNY_FOLDER (src_folder), TRUE); */
4180 modest_mail_operation_xfer_folder (mail_op,
4181 TNY_FOLDER (src_folder),
4183 TRUE, move_to_cb, inf_note);
4184 /* Unref mail operation */
4185 g_object_unref (G_OBJECT (mail_op));
4187 } else if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
4188 gboolean do_xfer = TRUE;
4189 /* Ask for confirmation if the source folder is remote and we're not connected */
4190 if (!online && modest_platform_is_network_folderstore(src_folder)) {
4191 guint num_headers = modest_header_view_count_selected_headers(header_view);
4192 if (!connect_to_get_msg(GTK_WINDOW(win), num_headers)) {
4196 if (do_xfer) /* Transfer messages */
4197 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
4201 g_object_unref (src_folder);
4206 * UI handler for the "Move to" action when invoked from the
4207 * ModestMsgViewWindow
4210 modest_ui_actions_on_msg_view_window_move_to (GtkAction *action,
4211 TnyFolderStore *dst_folder,
4212 ModestMsgViewWindow *win)
4214 TnyHeader *header = NULL;
4215 TnyFolderStore *src_folder;
4217 /* Create header list */
4218 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
4219 src_folder = TNY_FOLDER_STORE(tny_header_get_folder(header));
4220 g_object_unref (header);
4222 /* Transfer the message if online or confirmed by the user */
4223 if (tny_device_is_online (modest_runtime_get_device()) ||
4224 (modest_platform_is_network_folderstore(src_folder) && connect_to_get_msg(GTK_WINDOW(win), 1))) {
4225 modest_ui_actions_xfer_messages_from_move_to (dst_folder, MODEST_WINDOW (win));
4228 g_object_unref (src_folder);
4232 modest_ui_actions_on_move_to (GtkAction *action,
4235 GtkWidget *dialog = NULL, *folder_view = NULL, *tree_view = NULL;
4237 TnyFolderStore *dst_folder = NULL;
4238 ModestMainWindow *main_window;
4240 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
4241 MODEST_IS_MSG_VIEW_WINDOW (win));
4243 /* Get the main window if exists */
4244 if (MODEST_IS_MAIN_WINDOW (win))
4245 main_window = MODEST_MAIN_WINDOW (win);
4248 MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
4250 /* Get the folder view widget if exists */
4252 folder_view = modest_main_window_get_child_widget (main_window,
4253 MODEST_WIDGET_TYPE_FOLDER_VIEW);
4257 /* Create and run the dialog */
4258 dialog = create_move_to_dialog (GTK_WINDOW (win), folder_view, &tree_view);
4259 modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
4260 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
4261 result = gtk_dialog_run (GTK_DIALOG(dialog));
4262 g_object_ref (tree_view);
4263 gtk_widget_destroy (dialog);
4265 if (result != GTK_RESPONSE_ACCEPT)
4268 dst_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
4269 /* Do window specific stuff */
4270 if (MODEST_IS_MAIN_WINDOW (win)) {
4271 modest_ui_actions_on_main_window_move_to (action,
4274 MODEST_MAIN_WINDOW (win));
4276 modest_ui_actions_on_msg_view_window_move_to (action,
4278 MODEST_MSG_VIEW_WINDOW (win));
4282 g_object_unref (dst_folder);
4286 * Calls #HeadersFunc for each header already selected in the main
4287 * window or the message currently being shown in the msg view window
4290 do_headers_action (ModestWindow *win,
4294 TnyList *headers_list = NULL;
4295 TnyIterator *iter = NULL;
4296 TnyHeader *header = NULL;
4297 TnyFolder *folder = NULL;
4300 headers_list = get_selected_headers (win);
4304 /* Get the folder */
4305 iter = tny_list_create_iterator (headers_list);
4306 header = TNY_HEADER (tny_iterator_get_current (iter));
4308 folder = tny_header_get_folder (header);
4309 g_object_unref (header);
4312 /* Call the function for each header */
4313 while (!tny_iterator_is_done (iter)) {
4314 header = TNY_HEADER (tny_iterator_get_current (iter));
4315 func (header, win, user_data);
4316 g_object_unref (header);
4317 tny_iterator_next (iter);
4320 /* Trick: do a poke status in order to speed up the signaling
4322 tny_folder_poke_status (folder);
4325 g_object_unref (folder);
4326 g_object_unref (iter);
4327 g_object_unref (headers_list);
4331 modest_ui_actions_view_attachment (GtkAction *action,
4332 ModestWindow *window)
4334 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4335 modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (window), NULL);
4337 /* not supported window for this action */
4338 g_return_if_reached ();
4343 modest_ui_actions_save_attachments (GtkAction *action,
4344 ModestWindow *window)
4346 if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4347 modest_msg_view_window_save_attachments (MODEST_MSG_VIEW_WINDOW (window), NULL);
4349 /* not supported window for this action */
4350 g_return_if_reached ();
4355 modest_ui_actions_remove_attachments (GtkAction *action,
4356 ModestWindow *window)
4358 if (MODEST_IS_MAIN_WINDOW (window)) {
4359 modest_ui_actions_on_main_window_remove_attachments (action, MODEST_MAIN_WINDOW (window));
4360 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
4361 modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (window), FALSE);
4363 /* not supported window for this action */
4364 g_return_if_reached ();
4369 modest_ui_actions_on_settings (GtkAction *action,
4374 dialog = modest_platform_get_global_settings_dialog ();
4375 gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (win));
4376 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
4377 gtk_widget_show_all (dialog);
4379 gtk_dialog_run (GTK_DIALOG (dialog));
4381 gtk_widget_destroy (dialog);
4385 modest_ui_actions_on_help (GtkAction *action,
4388 const gchar *help_id = NULL;
4390 if (MODEST_IS_MAIN_WINDOW (win)) {
4391 GtkWidget *folder_view;
4392 TnyFolderStore *folder_store;
4394 /* Get selected folder */
4395 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
4396 MODEST_WIDGET_TYPE_FOLDER_VIEW);
4397 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
4399 /* Switch help_id */
4400 if (TNY_IS_FOLDER (folder_store)) {
4401 switch (modest_tny_folder_guess_folder_type (TNY_FOLDER (folder_store))) {
4402 case TNY_FOLDER_TYPE_NORMAL:
4403 help_id = "applications_email_managefolders";
4405 case TNY_FOLDER_TYPE_INBOX:
4406 help_id = "applications_email_inbox";
4408 case TNY_FOLDER_TYPE_OUTBOX:
4409 help_id = "applications_email_outbox";
4411 case TNY_FOLDER_TYPE_SENT:
4412 help_id = "applications_email_sent";
4414 case TNY_FOLDER_TYPE_DRAFTS:
4415 help_id = "applications_email_drafts";
4417 case TNY_FOLDER_TYPE_ARCHIVE:
4418 help_id = "applications_email_managefolders";
4421 help_id = "applications_email_managefolders";
4424 help_id = "applications_email_mainview";
4426 g_object_unref (folder_store);
4427 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
4428 help_id = "applications_email_viewer";
4429 } else if (MODEST_IS_MSG_EDIT_WINDOW (win))
4430 help_id = "applications_email_editor";
4432 modest_platform_show_help (GTK_WINDOW (win), help_id);
4436 modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
4437 ModestWindow *window)
4439 ModestMailOperation *mail_op;
4443 headers = get_selected_headers (window);
4447 /* Create mail operation */
4448 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
4450 modest_ui_actions_get_msgs_full_error_handler,
4452 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
4453 modest_mail_operation_get_msgs_full (mail_op, headers, NULL, NULL, NULL);
4456 g_object_unref (headers);
4457 g_object_unref (mail_op);
4461 modest_ui_actions_on_email_menu_activated (GtkAction *action,
4462 ModestWindow *window)
4464 g_return_if_fail (MODEST_IS_WINDOW (window));
4467 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4471 modest_ui_actions_on_edit_menu_activated (GtkAction *action,
4472 ModestWindow *window)
4474 g_return_if_fail (MODEST_IS_WINDOW (window));
4477 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4481 modest_ui_actions_on_view_menu_activated (GtkAction *action,
4482 ModestWindow *window)
4484 g_return_if_fail (MODEST_IS_WINDOW (window));
4487 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4491 modest_ui_actions_on_tools_menu_activated (GtkAction *action,
4492 ModestWindow *window)
4494 g_return_if_fail (MODEST_IS_WINDOW (window));
4497 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4501 modest_ui_actions_on_attachment_menu_activated (GtkAction *action,
4502 ModestWindow *window)
4504 g_return_if_fail (MODEST_IS_WINDOW (window));
4507 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4511 modest_ui_actions_on_toolbar_csm_menu_activated (GtkAction *action,
4512 ModestWindow *window)
4514 g_return_if_fail (MODEST_IS_WINDOW (window));
4517 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4521 modest_ui_actions_on_folder_view_csm_menu_activated (GtkAction *action,
4522 ModestWindow *window)
4524 g_return_if_fail (MODEST_IS_WINDOW (window));
4527 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4531 modest_ui_actions_on_header_view_csm_menu_activated (GtkAction *action,
4532 ModestWindow *window)
4534 g_return_if_fail (MODEST_IS_WINDOW (window));
4537 modest_window_check_dimming_rules_group (window, "ModestMenuDimmingRules");
4541 modest_ui_actions_check_toolbar_dimming_rules (ModestWindow *window)
4543 g_return_if_fail (MODEST_IS_WINDOW (window));
4546 modest_window_check_dimming_rules_group (window, "ModestToolbarDimmingRules");
4550 modest_ui_actions_on_search_messages (GtkAction *action, ModestWindow *window)
4552 g_return_if_fail (MODEST_IS_WINDOW (window));
4554 modest_platform_show_search_messages (GTK_WINDOW (window));
4558 modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
4560 g_return_if_fail (MODEST_IS_WINDOW (win));
4561 modest_platform_show_addressbook (GTK_WINDOW (win));
4566 modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
4567 ModestWindow *window)
4569 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
4571 modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
4575 _on_send_receive_progress_changed (ModestMailOperation *mail_op,
4576 ModestMailOperationState *state,
4579 g_return_if_fail (MODEST_IS_MAIN_WINDOW(user_data));
4581 /* Set send/receive operation finished */
4582 if (state->status != MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
4583 modest_main_window_notify_send_receive_completed (MODEST_MAIN_WINDOW(user_data));