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>
36 #include <modest-runtime.h>
37 #include <modest-tny-folder.h>
38 #include <modest-tny-msg.h>
39 #include <modest-tny-account.h>
40 #include <modest-address-book.h>
42 #include "modest-ui-actions.h"
44 #include "modest-tny-platform-factory.h"
45 #include "modest-platform.h"
47 #include <widgets/modest-main-window.h>
48 #include <widgets/modest-msg-view-window.h>
49 #include <widgets/modest-account-view-window.h>
50 #include <widgets/modest-details-dialog.h>
52 #include "modest-account-mgr-helpers.h"
53 #include "modest-mail-operation.h"
54 #include "modest-text-utils.h"
56 #ifdef MODEST_HAVE_EASYSETUP
57 #include "easysetup/modest-easysetup-wizard.h"
58 #endif /*MODEST_HAVE_EASYSETUP*/
60 #include <modest-widget-memory.h>
61 #include <tny-error.h>
62 #include <tny-simple-list.h>
63 #include <tny-msg-view.h>
64 #include <tny-device.h>
66 typedef struct _GetMsgAsyncHelper {
73 typedef enum _ReplyForwardAction {
79 typedef struct _ReplyForwardHelper {
80 guint reply_forward_type;
81 ReplyForwardAction action;
86 static void reply_forward_func (gpointer data, gpointer user_data);
87 static void read_msg_func (gpointer data, gpointer user_data);
88 static void get_msg_cb (TnyFolder *folder, TnyMsg *msg, GError **err,
90 static void reply_forward (ReplyForwardAction action, ModestWindow *win);
92 static gchar* ask_for_folder_name (GtkWindow *parent_window, const gchar *title);
96 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
99 const gchar *authors[] = {
100 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
103 about = gtk_about_dialog_new ();
104 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
105 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
106 gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
107 _("Copyright (c) 2006, Nokia Corporation\n"
108 "All rights reserved."));
109 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
110 _("a modest e-mail client\n\n"
111 "design and implementation: Dirk-Jan C. Binnema\n"
112 "contributions from the fine people at KC and Ig\n"
113 "uses the tinymail email framework written by Philip van Hoof"));
114 gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
115 gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
117 gtk_dialog_run (GTK_DIALOG (about));
118 gtk_widget_destroy(about);
123 get_selected_headers (ModestWindow *win)
125 if (MODEST_IS_MAIN_WINDOW(win)) {
126 GtkWidget *header_view;
128 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
129 MODEST_WIDGET_TYPE_HEADER_VIEW);
130 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
132 } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
133 /* for MsgViewWindows, we simply return a list with one element */
136 TnyList *list = NULL;
138 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
140 header = tny_msg_get_header (msg);
141 list = tny_simple_list_new ();
142 tny_list_prepend (list, G_OBJECT(header));
143 g_object_unref (G_OBJECT(header));
152 modest_ui_actions_on_delete (GtkAction *action, ModestWindow *win)
154 TnyList *header_list;
157 g_return_if_fail (MODEST_IS_WINDOW(win));
159 header_list = get_selected_headers (win);
162 iter = tny_list_create_iterator (header_list);
165 ModestMailOperation *mail_op;
167 header = TNY_HEADER (tny_iterator_get_current (iter));
168 /* TODO: thick grain mail operation involving
169 a list of objects. Composite pattern ??? */
170 /* TODO: add confirmation dialog */
171 mail_op = modest_mail_operation_new ();
172 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
175 /* Always delete. TODO: Move to trash still not supported */
176 modest_mail_operation_remove_msg (mail_op, header, FALSE);
179 g_object_unref (G_OBJECT (mail_op));
180 g_object_unref (G_OBJECT (header));
182 tny_iterator_next (iter);
184 } while (!tny_iterator_is_done (iter));
187 g_object_unref (G_OBJECT (iter));
190 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
191 gtk_widget_destroy (GTK_WIDGET(win));
197 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
203 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
205 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
206 gtk_widget_destroy (GTK_WIDGET (win));
207 } else if (MODEST_IS_WINDOW (win)) {
208 gtk_widget_destroy (GTK_WIDGET (win));
210 g_return_if_reached ();
215 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
217 GtkClipboard *clipboard = NULL;
218 gchar *selection = NULL;
220 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
221 selection = gtk_clipboard_wait_for_text (clipboard);
223 modest_address_book_add_address (selection);
228 modest_ui_actions_on_accounts (GtkAction *action, ModestWindow *win)
231 /* This is currently only implemented for Maemo,
232 * because it requires a providers preset file which is not publically available.
234 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
235 GSList *account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr());
236 gboolean accounts_exist = account_names != NULL;
237 g_slist_free (account_names);
239 /* To test, while modest_account_mgr_account_names() is broken: accounts_exist = TRUE; */
240 if (!accounts_exist) {
241 /* If there are no accounts yet, just show the easy-setup wizard, as per the UI spec: */
242 ModestEasysetupWizardDialog *wizard = modest_easysetup_wizard_dialog_new ();
243 gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
244 gtk_dialog_run (GTK_DIALOG (wizard));
245 gtk_widget_destroy (GTK_WIDGET (wizard));
247 /* Show the list of accounts: */
248 GtkDialog *account_win = GTK_DIALOG(modest_account_view_window_new ());
249 gtk_window_set_transient_for (GTK_WINDOW (account_win), GTK_WINDOW(win));
250 gtk_dialog_run (account_win);
251 gtk_widget_destroy (GTK_WIDGET(account_win));
254 GtkWidget *dialog, *label;
256 /* Create the widgets */
258 dialog = gtk_dialog_new_with_buttons ("Message",
260 GTK_DIALOG_DESTROY_WITH_PARENT,
264 label = gtk_label_new ("Hello World!");
266 /* Ensure that the dialog box is destroyed when the user responds. */
268 g_signal_connect_swapped (dialog, "response",
269 G_CALLBACK (gtk_widget_destroy),
272 /* Add the label, and show everything we've added to the dialog. */
274 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
276 gtk_widget_show_all (dialog);
277 #endif /* MODEST_PLATFORM_MAEMO */
281 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
283 ModestWindow *msg_win;
285 TnyFolder *folder = NULL;
286 gchar *account_name = NULL;
287 gchar *from_str = NULL;
289 TnyAccount *account = NULL;
290 ModestWindowMgr *mgr;
292 account_name = g_strdup(modest_window_get_active_account (win));
294 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
296 g_printerr ("modest: no account found\n");
300 account = modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
302 TNY_ACCOUNT_TYPE_STORE);
304 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
308 from_str = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(), account_name);
310 g_printerr ("modest: failed get from string for '%s'\n", account_name);
314 msg = modest_tny_msg_new ("", from_str, "", "", "", "", NULL);
316 g_printerr ("modest: failed to create new msg\n");
320 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
322 g_printerr ("modest: failed to find Drafts folder\n");
326 tny_folder_add_msg (folder, msg, &err);
328 g_printerr ("modest: error adding msg to Drafts folder: %s",
334 /* Create and register edit window */
335 msg_win = modest_msg_edit_window_new (msg, account_name);
336 mgr = modest_runtime_get_window_mgr ();
337 modest_window_mgr_register_window (mgr, msg_win);
340 gtk_window_set_transient_for (GTK_WINDOW (msg_win),
342 gtk_widget_show_all (GTK_WIDGET (msg_win));
345 g_free (account_name);
348 g_object_unref (G_OBJECT(account));
350 g_object_unref (G_OBJECT(msg));
352 g_object_unref (G_OBJECT(folder));
357 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
359 modest_runtime_not_implemented (GTK_WINDOW(win)); /* FIXME */
365 reply_forward_func (gpointer data, gpointer user_data)
367 TnyMsg *msg, *new_msg;
368 GetMsgAsyncHelper *helper;
369 ReplyForwardHelper *rf_helper;
370 ModestWindow *msg_win;
371 ModestEditType edit_type;
374 TnyFolder *folder = NULL;
375 TnyAccount *account = NULL;
376 ModestWindowMgr *mgr;
378 msg = TNY_MSG (data);
379 helper = (GetMsgAsyncHelper *) user_data;
380 rf_helper = (ReplyForwardHelper *) helper->user_data;
382 from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
383 rf_helper->account_name);
384 /* Create reply mail */
385 switch (rf_helper->action) {
388 modest_tny_msg_create_reply_msg (msg, from,
389 rf_helper->reply_forward_type,
390 MODEST_TNY_MSG_REPLY_MODE_SENDER);
392 case ACTION_REPLY_TO_ALL:
394 modest_tny_msg_create_reply_msg (msg, from, rf_helper->reply_forward_type,
395 MODEST_TNY_MSG_REPLY_MODE_ALL);
396 edit_type = MODEST_EDIT_TYPE_REPLY;
400 modest_tny_msg_create_forward_msg (msg, from, rf_helper->reply_forward_type);
401 edit_type = MODEST_EDIT_TYPE_FORWARD;
404 g_return_if_reached ();
409 g_printerr ("modest: failed to create message\n");
413 account = modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
414 rf_helper->account_name,
415 TNY_ACCOUNT_TYPE_STORE);
417 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
421 folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
423 g_printerr ("modest: failed to find Drafts folder\n");
427 tny_folder_add_msg (folder, msg, &err);
429 g_printerr ("modest: error adding msg to Drafts folder: %s",
435 /* Create and register the windows */
436 msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name);
437 mgr = modest_runtime_get_window_mgr ();
438 modest_window_mgr_register_window (mgr, msg_win);
440 /* Show edit window */
441 gtk_widget_show_all (GTK_WIDGET (msg_win));
445 g_object_unref (G_OBJECT (new_msg));
447 g_object_unref (G_OBJECT (folder));
449 g_object_unref (G_OBJECT (account));
451 g_free (rf_helper->account_name);
452 g_slice_free (ReplyForwardHelper, rf_helper);
455 * Common code for the reply and forward actions
458 reply_forward (ReplyForwardAction action, ModestWindow *win)
460 TnyList *header_list;
461 guint reply_forward_type;
464 GetMsgAsyncHelper *helper;
465 ReplyForwardHelper *rf_helper;
467 g_return_if_fail (MODEST_IS_WINDOW(win));
469 header_list = get_selected_headers (win);
473 reply_forward_type = modest_conf_get_int (modest_runtime_get_conf (),
474 (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
476 /* We assume that we can only select messages of the
477 same folder and that we reply all of them from the
478 same account. In fact the interface currently only
479 allows single selection */
482 rf_helper = g_slice_new0 (ReplyForwardHelper);
483 rf_helper->reply_forward_type = reply_forward_type;
484 rf_helper->action = action;
486 rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
487 if (!rf_helper->account_name)
488 rf_helper->account_name =
489 modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
491 helper = g_slice_new0 (GetMsgAsyncHelper);
492 helper->window = win;
493 helper->func = reply_forward_func;
494 helper->iter = tny_list_create_iterator (header_list);
495 helper->user_data = rf_helper;
497 if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
499 msg = modest_msg_view_window_get_message(MODEST_MSG_VIEW_WINDOW(win));
501 g_printerr ("modest: no message found\n");
504 reply_forward_func (msg, helper);
506 header = TNY_HEADER (tny_iterator_get_current (helper->iter));
507 folder = tny_header_get_folder (header);
509 /* The callback will call it per each header */
510 tny_folder_get_msg_async (folder, header, get_msg_cb, NULL, helper);
511 g_object_unref (G_OBJECT (folder));
513 g_printerr ("modest: no folder for header\n");
516 g_object_unref (G_OBJECT (header));
522 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
524 g_return_if_fail (MODEST_IS_WINDOW(win));
526 reply_forward (ACTION_REPLY, win);
530 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
532 g_return_if_fail (MODEST_IS_WINDOW(win));
534 reply_forward (ACTION_FORWARD, win);
538 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
540 g_return_if_fail (MODEST_IS_WINDOW(win));
542 reply_forward (ACTION_REPLY_TO_ALL, win);
546 modest_ui_actions_on_next (GtkAction *action,
547 ModestWindow *window)
549 if (MODEST_IS_MAIN_WINDOW (window)) {
550 GtkWidget *header_view;
552 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
553 MODEST_WIDGET_TYPE_HEADER_VIEW);
557 modest_header_view_select_next (MODEST_HEADER_VIEW(header_view));
558 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
559 modest_msg_view_window_select_next_message (MODEST_MSG_VIEW_WINDOW (window));
561 g_return_if_reached ();
566 modest_ui_actions_on_prev (GtkAction *action,
567 ModestWindow *window)
569 g_return_if_fail (MODEST_IS_WINDOW(window));
571 if (MODEST_IS_MAIN_WINDOW (window)) {
572 GtkWidget *header_view;
573 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
574 MODEST_WIDGET_TYPE_HEADER_VIEW);
578 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
579 } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
580 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
582 g_return_if_reached ();
587 modest_ui_actions_on_sort (GtkAction *action,
588 ModestWindow *window)
590 ModestWindowMgr *mgr;
592 g_return_if_fail (MODEST_IS_WINDOW(window));
594 /* Show sorting dialog */
595 mgr = modest_runtime_get_window_mgr ();
601 action_send (const gchar* account_name)
603 TnyAccount *tny_account;
604 ModestTnySendQueue *send_queue;
606 g_return_val_if_fail (account_name, FALSE);
608 /* Get the transport account according to the open connection,
609 * because the account might specify connection-specific SMTP servers.
612 modest_tny_account_store_get_transport_account_for_open_connection (modest_runtime_get_account_store(),
615 g_printerr ("modest: cannot get tny transport account for %s\n", account_name);
619 send_queue = modest_tny_send_queue_new (TNY_CAMEL_TRANSPORT_ACCOUNT(tny_account));
621 g_object_unref (G_OBJECT(tny_account));
622 g_printerr ("modest: cannot get send queue for %s\n", account_name);
626 //modest_tny_send_queue_flush (send_queue);
628 g_object_unref (G_OBJECT(send_queue));
629 g_object_unref (G_OBJECT(tny_account));
636 action_receive (const gchar* account_name)
638 TnyAccount *tny_account;
639 ModestMailOperation *mail_op;
641 g_return_val_if_fail (account_name, FALSE);
644 modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store(),
646 TNY_ACCOUNT_TYPE_STORE);
648 g_printerr ("modest: cannot get tny store account for %s\n", account_name);
652 /* Create the mail operation */
653 /* TODO: The spec wants us to first do any pending deletions, before receiving. */
654 mail_op = modest_mail_operation_new ();
655 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
656 modest_mail_operation_update_account (mail_op, TNY_STORE_ACCOUNT(tny_account));
658 g_object_unref (G_OBJECT(tny_account));
659 g_object_unref (G_OBJECT (mail_op));
664 /** Check that an appropriate connection is open.
666 gboolean check_for_connection (const gchar *account_name)
668 TnyDevice *device = modest_runtime_get_device ();
671 g_assert (TNY_IS_MAEMO_CONIC_DEVICE (device));
673 TnyMaemoConicDevice *maemo_device = TNY_MAEMO_CONIC_DEVICE (device);
676 if (tny_device_is_online (device))
679 modest_platform_connect_and_wait (NULL);
681 /* TODO: Wait until a result. */
687 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
692 g_message ("%s: online? %s", __FUNCTION__,
693 tny_device_is_online(modest_runtime_get_device()) ? "yes":"no");
695 /* As per the UI spec, only the active account should be affected,
696 * else the default folder if there is no active account: */
698 g_strdup(modest_window_get_active_account(MODEST_WINDOW(win)));
700 account_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
702 g_printerr ("modest: cannot get default account\n");
706 /* Do not continue if no suitable connection is open: */
707 if (!check_for_connection (account_name))
710 /* As per the UI spec,
711 * for POP accounts, we should receive,
712 * for IMAP we should synchronize everything, including receiving,
713 * for SMTP we should send,
714 * first receiving, then sending:
716 if (!action_receive(account_name))
717 g_printerr ("modest: failed to receive\n");
718 if (!action_send(account_name))
719 g_printerr ("modest: failed to send\n");
726 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
729 GtkWidget *header_view;
731 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
733 header_view = modest_main_window_get_child_widget (main_window,
734 MODEST_WIDGET_TYPE_HEADER_VIEW);
738 conf = modest_runtime_get_conf ();
740 /* what is saved/restored is depending on the style; thus; we save with
741 * old style, then update the style, and restore for this new style
743 modest_widget_memory_save (conf, G_OBJECT(header_view), "header-view");
745 if (modest_header_view_get_style
746 (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
747 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
748 MODEST_HEADER_VIEW_STYLE_TWOLINES);
750 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
751 MODEST_HEADER_VIEW_STYLE_DETAILS);
753 modest_widget_memory_restore (conf, G_OBJECT(header_view),
760 * Marks a message as read and passes it to the msg preview widget
763 read_msg_func (gpointer data, gpointer user_data)
767 GetMsgAsyncHelper *helper;
768 TnyHeaderFlags header_flags;
769 GtkWidget *msg_preview;
771 msg = TNY_MSG (data);
772 helper = (GetMsgAsyncHelper *) user_data;
774 msg_preview = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (helper->window),
775 MODEST_WIDGET_TYPE_MSG_PREVIEW);
779 header = TNY_HEADER (tny_iterator_get_current (helper->iter));
780 header_flags = tny_header_get_flags (header);
781 tny_header_set_flags (header, header_flags | TNY_HEADER_FLAG_SEEN);
782 g_object_unref (G_OBJECT (header));
784 /* Set message on msg view */
785 modest_msg_view_set_message (MODEST_MSG_VIEW(msg_preview), msg);
789 * This function is a generic handler for the tny_folder_get_msg_async
790 * call. It expects as user_data a #GetMsgAsyncHelper. This helper
791 * contains a user provided function that is called inside this
792 * method. This will allow us to use this callback in many different
793 * places. This callback performs the common actions for the
794 * get_msg_async call, more specific actions will be done by the user
798 get_msg_cb (TnyFolder *folder, TnyMsg *msg, GError **err, gpointer user_data)
800 GetMsgAsyncHelper *helper;
802 helper = (GetMsgAsyncHelper *) user_data;
804 if ((*err && ((*err)->code == TNY_FOLDER_ERROR_GET_MSG)) || !msg) {
805 modest_ui_actions_on_item_not_found (NULL,
806 MODEST_ITEM_TYPE_MESSAGE,
811 /* Call user function */
812 helper->func (msg, user_data);
814 /* Process next element (if exists) */
815 tny_iterator_next (helper->iter);
816 if (tny_iterator_is_done (helper->iter)) {
818 headers = tny_iterator_get_list (helper->iter);
820 g_object_unref (G_OBJECT (headers));
821 g_object_unref (G_OBJECT (helper->iter));
822 g_slice_free (GetMsgAsyncHelper, helper);
825 header = TNY_HEADER (tny_iterator_get_current (helper->iter));
826 tny_folder_get_msg_async (folder, header,
827 get_msg_cb, NULL, helper);
828 g_object_unref (G_OBJECT(header));
833 modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
835 ModestMainWindow *main_window)
838 GetMsgAsyncHelper *helper;
841 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
843 /* when there's no header, clear the msgview */
845 GtkWidget *msg_preview;
847 /* Clear msg preview if exists */
848 msg_preview = modest_main_window_get_child_widget(main_window,
849 MODEST_WIDGET_TYPE_MSG_PREVIEW);
852 modest_msg_view_set_message (MODEST_MSG_VIEW(msg_preview), NULL);
856 /* Update Main window title */
857 if (GTK_WIDGET_HAS_FOCUS (header_view)) {
858 const gchar *subject = tny_header_get_subject (header);
859 if (subject && strcmp (subject, ""))
860 gtk_window_set_title (GTK_WINDOW (main_window), subject);
862 gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
866 list = tny_simple_list_new ();
867 tny_list_prepend (list, G_OBJECT (header));
869 /* Fill helper data */
870 helper = g_slice_new0 (GetMsgAsyncHelper);
871 helper->window = MODEST_WINDOW (main_window);
872 helper->iter = tny_list_create_iterator (list);
873 helper->func = read_msg_func;
875 folder = tny_header_get_folder (TNY_HEADER(header));
877 tny_folder_get_msg_async (TNY_FOLDER(folder),
882 g_object_unref (G_OBJECT (folder));
888 modest_ui_actions_on_header_activated (ModestHeaderView *folder_view, TnyHeader *header,
889 ModestMainWindow *main_window)
891 ModestWindow *win = NULL;
892 TnyFolder *folder = NULL;
894 ModestWindowMgr *mgr;
896 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
901 folder = tny_header_get_folder (header);
903 g_printerr ("modest: cannot get folder for header\n");
907 /* FIXME: make async?; check error */
908 msg = tny_folder_get_msg (folder, header, NULL);
910 g_printerr ("modest: cannot get msg for header\n");
914 /* Look if we already have a message view for that header */
915 mgr = modest_runtime_get_window_mgr ();
916 win = modest_window_mgr_find_window_by_msguid (mgr, tny_header_get_uid (header));
918 /* If not, create a new window */
922 account = g_strdup(modest_window_get_active_account(MODEST_WINDOW(main_window)));
924 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
926 win = modest_msg_view_window_new (msg, account);
927 modest_window_mgr_register_window (mgr, win);
929 gtk_window_set_transient_for (GTK_WINDOW (win),
930 GTK_WINDOW (main_window));
933 gtk_widget_show_all (GTK_WIDGET(win));
935 g_object_unref (G_OBJECT (msg));
938 g_object_unref (G_OBJECT (folder));
942 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
943 TnyFolderStore *folder_store,
945 ModestMainWindow *main_window)
948 GtkWidget *header_view;
950 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
952 header_view = modest_main_window_get_child_widget(main_window,
953 MODEST_WIDGET_TYPE_HEADER_VIEW);
957 conf = modest_runtime_get_conf ();
959 if (TNY_IS_FOLDER (folder_store)) {
961 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
964 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
965 TNY_FOLDER (folder_store));
966 modest_widget_memory_restore (conf, G_OBJECT(header_view),
969 modest_widget_memory_save (conf, G_OBJECT (header_view), "header-view");
970 modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view), NULL);
972 } else if (TNY_IS_ACCOUNT (folder_store)) {
974 modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
979 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
986 item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
988 if (g_main_depth > 0)
989 gdk_threads_enter ();
990 online = tny_device_is_online (modest_runtime_get_device());
993 /* already online -- the item is simply not there... */
994 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
998 _("The %s you selected cannot be found"),
1000 gtk_dialog_run (GTK_DIALOG(dialog));
1002 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
1006 GTK_RESPONSE_REJECT,
1008 GTK_RESPONSE_ACCEPT,
1010 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
1011 "Do you want to get online?"), item);
1012 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1013 gtk_label_new (txt), FALSE, FALSE, 0);
1014 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1017 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
1018 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1019 // modest_platform_connect_and_wait ();;
1022 gtk_widget_destroy (dialog);
1023 if (g_main_depth > 0)
1024 gdk_threads_leave ();
1028 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
1031 g_message ("%s %s", __FUNCTION__, link);
1036 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
1039 modest_platform_activate_uri (link);
1043 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
1046 modest_platform_show_uri_popup (link);
1050 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
1053 g_message (__FUNCTION__);
1058 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
1059 const gchar *address,
1062 g_message ("%s %s", __FUNCTION__, address);
1066 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
1068 TnyTransportAccount *transport_account;
1069 ModestMailOperation *mail_operation;
1071 gchar *account_name, *from;
1072 ModestAccountMgr *account_mgr;
1074 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window));
1076 data = modest_msg_edit_window_get_msg_data (edit_window);
1078 /* FIXME: Code added just for testing. The final version will
1079 use the send queue provided by tinymail and some
1081 account_mgr = modest_runtime_get_account_mgr();
1082 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
1084 account_name = modest_account_mgr_get_default_account (account_mgr);
1085 if (!account_name) {
1086 g_printerr ("modest: no account found\n");
1087 modest_msg_edit_window_free_msg_data (edit_window, data);
1091 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_transport_account_for_open_connection
1092 (modest_runtime_get_account_store(),
1094 if (!transport_account) {
1095 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1096 g_free (account_name);
1097 modest_msg_edit_window_free_msg_data (edit_window, data);
1100 from = modest_account_mgr_get_from_string (account_mgr, account_name);
1102 /* Create the mail operation */
1103 mail_operation = modest_mail_operation_new ();
1104 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
1106 modest_mail_operation_send_new_mail (mail_operation,
1116 data->priority_flags);
1119 g_free (account_name);
1120 g_object_unref (G_OBJECT (transport_account));
1121 g_object_unref (G_OBJECT (mail_operation));
1123 modest_msg_edit_window_free_msg_data (edit_window, data);
1125 /* Save settings and close the window */
1126 gtk_widget_destroy (GTK_WIDGET (edit_window));
1130 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
1131 ModestMsgEditWindow *window)
1133 ModestMsgEditFormatState *format_state = NULL;
1135 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1136 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1138 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1141 format_state = modest_msg_edit_window_get_format_state (window);
1142 g_return_if_fail (format_state != NULL);
1144 format_state->bold = gtk_toggle_action_get_active (action);
1145 modest_msg_edit_window_set_format_state (window, format_state);
1146 g_free (format_state);
1151 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
1152 ModestMsgEditWindow *window)
1154 ModestMsgEditFormatState *format_state = NULL;
1156 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1157 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1159 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1162 format_state = modest_msg_edit_window_get_format_state (window);
1163 g_return_if_fail (format_state != NULL);
1165 format_state->italics = gtk_toggle_action_get_active (action);
1166 modest_msg_edit_window_set_format_state (window, format_state);
1167 g_free (format_state);
1172 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
1173 ModestMsgEditWindow *window)
1175 ModestMsgEditFormatState *format_state = NULL;
1177 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1178 g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
1180 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1183 format_state = modest_msg_edit_window_get_format_state (window);
1184 g_return_if_fail (format_state != NULL);
1186 format_state->bullet = gtk_toggle_action_get_active (action);
1187 modest_msg_edit_window_set_format_state (window, format_state);
1188 g_free (format_state);
1193 modest_ui_actions_on_change_justify (GtkRadioAction *action,
1194 GtkRadioAction *selected,
1195 ModestMsgEditWindow *window)
1197 ModestMsgEditFormatState *format_state = NULL;
1198 GtkJustification value;
1200 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1202 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1205 value = gtk_radio_action_get_current_value (selected);
1207 format_state = modest_msg_edit_window_get_format_state (window);
1208 g_return_if_fail (format_state != NULL);
1210 format_state->justification = value;
1211 modest_msg_edit_window_set_format_state (window, format_state);
1212 g_free (format_state);
1216 modest_ui_actions_on_select_editor_color (GtkAction *action,
1217 ModestMsgEditWindow *window)
1219 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1220 g_return_if_fail (GTK_IS_ACTION (action));
1222 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1225 modest_msg_edit_window_select_color (window);
1229 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
1230 ModestMsgEditWindow *window)
1232 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1233 g_return_if_fail (GTK_IS_ACTION (action));
1235 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1238 modest_msg_edit_window_select_background_color (window);
1242 modest_ui_actions_on_insert_image (GtkAction *action,
1243 ModestMsgEditWindow *window)
1245 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1246 g_return_if_fail (GTK_IS_ACTION (action));
1248 if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
1251 modest_msg_edit_window_insert_image (window);
1255 * Shows a dialog with an entry that asks for some text. The returned
1256 * value must be freed by the caller. The dialog window title will be
1260 ask_for_folder_name (GtkWindow *parent_window,
1263 GtkWidget *dialog, *entry;
1264 gchar *folder_name = NULL;
1266 /* Ask for folder name */
1267 dialog = gtk_dialog_new_with_buttons (_("New Folder Name"),
1271 GTK_RESPONSE_REJECT,
1273 GTK_RESPONSE_ACCEPT,
1275 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1276 gtk_label_new(title),
1279 entry = gtk_entry_new_with_max_length (40);
1280 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
1284 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1286 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
1287 folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
1289 gtk_widget_destroy (dialog);
1295 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
1297 TnyFolderStore *parent_folder;
1298 GtkWidget *folder_view;
1300 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1302 folder_view = modest_main_window_get_child_widget (main_window,
1303 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1307 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1309 if (parent_folder) {
1310 gboolean finished = FALSE;
1312 gchar *folder_name = NULL, *suggested_name = NULL;
1314 /* Run the new folder dialog */
1316 result = modest_platform_run_new_folder_dialog (GTK_WINDOW (main_window),
1321 if (result == GTK_RESPONSE_REJECT) {
1324 ModestMailOperation *mail_op = modest_mail_operation_new ();
1325 TnyFolder *new_folder = NULL;
1327 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1330 new_folder = modest_mail_operation_create_folder (mail_op,
1332 (const gchar *) folder_name);
1334 g_object_unref (new_folder);
1338 /* /\* TODO: check error and follow proper actions *\/ */
1339 /* /\* suggested_name = X; *\/ */
1340 /* /\* Show error to the user *\/ */
1341 /* modest_platform_run_information_dialog (GTK_WINDOW (main_window), */
1342 /* MODEST_INFORMATION_CREATE_FOLDER); */
1344 g_object_unref (mail_op);
1346 g_free (folder_name);
1350 g_object_unref (parent_folder);
1355 modest_ui_actions_on_rename_folder (GtkAction *action,
1356 ModestMainWindow *main_window)
1358 TnyFolderStore *folder;
1359 GtkWidget *folder_view;
1361 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1363 folder_view = modest_main_window_get_child_widget (main_window,
1364 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1368 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1370 if (folder && TNY_IS_FOLDER (folder)) {
1372 folder_name = ask_for_folder_name (GTK_WINDOW (main_window),
1373 _("Please enter a new name for the folder"));
1375 if (folder_name != NULL && strlen (folder_name) > 0) {
1376 ModestMailOperation *mail_op;
1378 mail_op = modest_mail_operation_new ();
1379 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1382 modest_mail_operation_rename_folder (mail_op,
1383 TNY_FOLDER (folder),
1384 (const gchar *) folder_name);
1386 g_object_unref (mail_op);
1387 g_free (folder_name);
1389 g_object_unref (folder);
1394 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
1396 TnyFolderStore *folder;
1397 GtkWidget *folder_view;
1401 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1403 folder_view = modest_main_window_get_child_widget (main_window,
1404 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1408 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1411 message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
1412 tny_folder_get_name (TNY_FOLDER (folder)));
1413 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
1414 (const gchar *) message);
1417 if (response == GTK_RESPONSE_OK) {
1418 ModestMailOperation *mail_op = modest_mail_operation_new ();
1420 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1422 modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (folder), move_to_trash);
1424 /* Show error if happened */
1425 if (modest_mail_operation_get_error (mail_op))
1426 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
1427 MODEST_INFORMATION_DELETE_FOLDER);
1429 g_object_unref (G_OBJECT (mail_op));
1432 g_object_unref (G_OBJECT (folder));
1436 modest_ui_actions_on_delete_folder (GtkAction *action,
1437 ModestMainWindow *main_window)
1439 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1441 delete_folder (main_window, FALSE);
1445 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
1447 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1449 delete_folder (main_window, TRUE);
1453 modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
1454 const gchar* account_name,
1458 ModestMainWindow *main_window)
1461 GtkWidget *dialog, *entry, *remember_pass_check;
1463 dialog = gtk_dialog_new_with_buttons (_("Password requested"),
1467 GTK_RESPONSE_REJECT,
1469 GTK_RESPONSE_ACCEPT,
1471 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(main_window));
1473 txt = g_strdup_printf (_("Please enter your password for %s"), account_name);
1474 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
1478 entry = gtk_entry_new_with_max_length (40);
1479 gtk_entry_set_visibility (GTK_ENTRY(entry), FALSE);
1480 gtk_entry_set_invisible_char (GTK_ENTRY(entry), 0x2022); /* bullet unichar */
1482 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry,
1485 remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
1486 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
1489 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1491 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1492 *password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry)));
1499 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (remember_pass_check)))
1504 gtk_widget_destroy (dialog);
1508 modest_ui_actions_on_cut (GtkAction *action,
1509 ModestWindow *window)
1511 GtkWidget *focused_widget;
1513 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1514 if (GTK_IS_EDITABLE (focused_widget)) {
1515 gtk_editable_cut_clipboard (GTK_EDITABLE(focused_widget));
1516 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1517 GtkTextBuffer *buffer;
1518 GtkClipboard *clipboard;
1520 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1521 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1522 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
1527 modest_ui_actions_on_copy (GtkAction *action,
1528 ModestWindow *window)
1530 GtkClipboard *clipboard;
1531 GtkWidget *focused_widget;
1533 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1534 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1535 if (GTK_IS_LABEL (focused_widget)) {
1536 gtk_clipboard_set_text (clipboard, gtk_label_get_text (GTK_LABEL (focused_widget)), -1);
1537 } else if (GTK_IS_EDITABLE (focused_widget)) {
1538 gtk_editable_copy_clipboard (GTK_EDITABLE(focused_widget));
1539 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1540 GtkTextBuffer *buffer;
1542 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1543 gtk_text_buffer_copy_clipboard (buffer, clipboard);
1548 modest_ui_actions_on_undo (GtkAction *action,
1549 ModestWindow *window)
1551 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
1552 modest_msg_edit_window_undo (MODEST_MSG_EDIT_WINDOW (window));
1554 g_return_if_reached ();
1559 modest_ui_actions_on_paste (GtkAction *action,
1560 ModestWindow *window)
1562 GtkWidget *focused_widget;
1564 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1565 if (GTK_IS_EDITABLE (focused_widget)) {
1566 gtk_editable_paste_clipboard (GTK_EDITABLE(focused_widget));
1567 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1568 GtkTextBuffer *buffer;
1569 GtkClipboard *clipboard;
1571 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1572 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1573 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
1578 modest_ui_actions_on_select_all (GtkAction *action,
1579 ModestWindow *window)
1581 GtkWidget *focused_widget;
1583 focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
1584 if (GTK_IS_LABEL (focused_widget)) {
1585 gtk_label_select_region (GTK_LABEL (focused_widget), 0, -1);
1586 } else if (GTK_IS_EDITABLE (focused_widget)) {
1587 gtk_editable_select_region (GTK_EDITABLE(focused_widget), 0, -1);
1588 } else if (GTK_IS_TEXT_VIEW (focused_widget)) {
1589 GtkTextBuffer *buffer;
1590 GtkTextIter start, end;
1592 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused_widget));
1593 gtk_text_buffer_get_start_iter (buffer, &start);
1594 gtk_text_buffer_get_end_iter (buffer, &end);
1595 gtk_text_buffer_select_range (buffer, &start, &end);
1600 modest_ui_actions_on_change_zoom (GtkRadioAction *action,
1601 GtkRadioAction *selected,
1602 ModestWindow *window)
1606 value = gtk_radio_action_get_current_value (selected);
1607 if (MODEST_IS_WINDOW (window)) {
1608 modest_window_set_zoom (MODEST_WINDOW (window), ((gdouble)value)/100);
1612 void modest_ui_actions_msg_edit_on_change_priority (GtkRadioAction *action,
1613 GtkRadioAction *selected,
1614 ModestWindow *window)
1616 TnyHeaderFlags flags;
1617 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1619 flags = gtk_radio_action_get_current_value (selected);
1620 modest_msg_edit_window_set_priority_flags (MODEST_MSG_EDIT_WINDOW (window), flags);
1623 void modest_ui_actions_msg_edit_on_change_file_format (GtkRadioAction *action,
1624 GtkRadioAction *selected,
1625 ModestWindow *window)
1629 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1631 file_format = gtk_radio_action_get_current_value (selected);
1632 modest_msg_edit_window_set_file_format (MODEST_MSG_EDIT_WINDOW (window), file_format);
1637 modest_ui_actions_on_zoom_plus (GtkAction *action,
1638 ModestWindow *window)
1640 g_return_if_fail (MODEST_IS_WINDOW (window));
1642 modest_window_zoom_plus (MODEST_WINDOW (window));
1646 modest_ui_actions_on_zoom_minus (GtkAction *action,
1647 ModestWindow *window)
1649 g_return_if_fail (MODEST_IS_WINDOW (window));
1651 modest_window_zoom_minus (MODEST_WINDOW (window));
1655 modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
1656 ModestWindow *window)
1658 ModestWindowMgr *mgr;
1659 gboolean fullscreen, active;
1660 g_return_if_fail (MODEST_IS_WINDOW (window));
1662 mgr = modest_runtime_get_window_mgr ();
1664 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle)))?1:0;
1665 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
1667 if (active != fullscreen) {
1668 modest_window_mgr_set_fullscreen_mode (mgr, active);
1669 gtk_window_present (GTK_WINDOW (window));
1674 modest_ui_actions_on_change_fullscreen (GtkAction *action,
1675 ModestWindow *window)
1677 ModestWindowMgr *mgr;
1678 gboolean fullscreen;
1680 g_return_if_fail (MODEST_IS_WINDOW (window));
1682 mgr = modest_runtime_get_window_mgr ();
1683 fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
1684 modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
1686 gtk_window_present (GTK_WINDOW (window));
1690 * Show the header details in a ModestDetailsDialog widget
1693 show_header_details (TnyHeader *header,
1699 dialog = modest_details_dialog_new_with_header (window, header);
1702 gtk_widget_show_all (dialog);
1703 gtk_dialog_run (GTK_DIALOG (dialog));
1705 gtk_widget_destroy (dialog);
1709 * Show the folder details in a ModestDetailsDialog widget
1712 show_folder_details (TnyFolder *folder,
1718 dialog = modest_details_dialog_new_with_folder (window, folder);
1721 gtk_widget_show_all (dialog);
1722 gtk_dialog_run (GTK_DIALOG (dialog));
1724 gtk_widget_destroy (dialog);
1729 modest_ui_actions_on_details (GtkAction *action,
1732 TnyList * headers_list;
1736 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1739 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
1743 headers_list = get_selected_headers (win);
1747 iter = tny_list_create_iterator (headers_list);
1749 header = TNY_HEADER (tny_iterator_get_current (iter));
1750 show_header_details (header, GTK_WINDOW (win));
1751 g_object_unref (header);
1753 g_object_unref (iter);
1755 } else if (MODEST_IS_MAIN_WINDOW (win)) {
1756 GtkWidget *folder_view, *header_view;
1758 /* Check which widget has the focus */
1759 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1760 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1761 if (gtk_widget_is_focus (folder_view)) {
1764 folder = (TnyFolder *) modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1766 /* Show only when it's a folder */
1767 if (!folder || !TNY_IS_FOLDER (folder))
1770 show_folder_details (folder, GTK_WINDOW (win));
1773 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1774 MODEST_WIDGET_TYPE_HEADER_VIEW);
1775 if (!gtk_widget_is_focus (header_view))
1778 headers_list = get_selected_headers (win);
1782 iter = tny_list_create_iterator (headers_list);
1783 while (!tny_iterator_is_done (iter)) {
1785 header = TNY_HEADER (tny_iterator_get_current (iter));
1786 show_header_details (header, GTK_WINDOW (win));
1787 g_object_unref (header);
1789 tny_iterator_next (iter);
1791 g_object_unref (iter);
1797 modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
1798 ModestMsgEditWindow *window)
1800 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1802 modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
1806 modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
1807 ModestMsgEditWindow *window)
1809 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1811 modest_msg_edit_window_show_bcc (window, gtk_toggle_action_get_active (toggle));
1815 modest_ui_actions_toggle_folders_view (GtkAction *action,
1816 ModestMainWindow *main_window)
1820 g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1822 conf = modest_runtime_get_conf ();
1824 if (modest_main_window_get_style (main_window) == MODEST_MAIN_WINDOW_STYLE_SPLIT)
1825 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
1827 modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SPLIT);
1831 modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
1832 ModestWindow *window)
1834 gboolean active, fullscreen = FALSE;
1835 ModestWindowMgr *mgr;
1837 active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
1839 /* Check if we want to toggle the toolbar vuew in fullscreen
1841 if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
1842 "ViewShowToolbarFullScreen")) {
1846 /* Toggle toolbar */
1847 mgr = modest_runtime_get_window_mgr ();
1848 modest_window_mgr_show_toolbars (mgr, active, fullscreen);
1852 modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
1853 ModestMsgEditWindow *window)
1855 modest_msg_edit_window_select_font (window);
1859 modest_ui_actions_on_folder_display_name_changed (ModestFolderView *folder_view,
1860 const gchar *display_name,
1863 /* Do not change the application name if the widget has not
1864 the focus. This callback could be called even if the folder
1865 view has not the focus, because the handled signal could be
1866 emitted when the folder view is redrawn */
1867 if (gtk_widget_is_focus (GTK_WIDGET (folder_view))) {
1869 gtk_window_set_title (window, display_name);
1871 gtk_window_set_title (window, " ");
1876 modest_ui_actions_on_select_contacts (GtkAction *action, ModestMsgEditWindow *window)
1878 g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
1879 modest_msg_edit_window_select_contacts (window);
1884 modest_ui_actions_on_move_to (GtkAction *action,
1887 GtkWidget *dialog, *scroll, *folder_view, *tree_view;
1889 TnyFolderStore *folder_store;
1890 ModestMailOperation *mail_op;
1891 ModestMainWindow *main_window;
1893 g_return_if_fail (MODEST_IS_MAIN_WINDOW (win) ||
1894 MODEST_IS_MSG_VIEW_WINDOW (win));
1896 dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
1898 GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
1900 GTK_RESPONSE_ACCEPT,
1902 GTK_RESPONSE_REJECT,
1905 /* Create scrolled window */
1906 scroll = gtk_scrolled_window_new (NULL, NULL);
1907 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
1908 GTK_POLICY_AUTOMATIC,
1909 GTK_POLICY_AUTOMATIC);
1911 /* Create folder view */
1912 main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
1914 folder_view = modest_main_window_get_child_widget (main_window,
1915 MODEST_WIDGET_TYPE_FOLDER_VIEW);
1916 tree_view = modest_folder_view_new (NULL);
1917 gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view),
1918 gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view)));
1920 gtk_container_add (GTK_CONTAINER (scroll), tree_view);
1922 /* Add scroll to dialog */
1923 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
1924 scroll, FALSE, FALSE, 0);
1926 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
1928 result = gtk_dialog_run (GTK_DIALOG(dialog));
1930 /* We do this to save an indentation level ;-) */
1931 if (result != GTK_RESPONSE_ACCEPT)
1934 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (tree_view));
1936 /* We use the goto to save an indentation level ;-) */
1937 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1942 /* Create header list */
1943 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
1944 header = tny_msg_get_header (msg);
1945 headers = tny_simple_list_new ();
1946 tny_list_prepend (headers, G_OBJECT (header));
1947 g_object_unref (header);
1948 g_object_unref (msg);
1950 /* Transfer current msg */
1951 modest_mail_operation_xfer_msgs (mail_op,
1953 TNY_FOLDER (folder_store),
1958 if (TNY_IS_ACCOUNT (folder_store))
1961 /* Create mail operation */
1962 mail_op = modest_mail_operation_new ();
1963 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1966 /* Get folder or messages to transfer */
1967 if (gtk_widget_is_focus (folder_view)) {
1968 TnyFolderStore *src_folder;
1969 src_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1971 if (TNY_IS_FOLDER (src_folder))
1972 modest_mail_operation_xfer_folder (mail_op,
1973 TNY_FOLDER (src_folder),
1978 g_object_unref (G_OBJECT (src_folder));
1980 GtkWidget *header_view;
1981 header_view = modest_main_window_get_child_widget (main_window,
1982 MODEST_WIDGET_TYPE_HEADER_VIEW);
1983 if (gtk_widget_is_focus (header_view)) {
1986 headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (header_view));
1988 /* Transfer messages */
1989 modest_mail_operation_xfer_msgs (mail_op,
1991 TNY_FOLDER (folder_store),
1995 g_object_unref (G_OBJECT (mail_op));
1997 g_object_unref (folder_store);
2000 gtk_widget_destroy (dialog);