Removed an old comment
[modest] / src / modest-ui-actions.c
1 /* Copyright (c) 2006, Nokia Corporation
2  * All rights reserved. 
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
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.
16  *
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.
28  */
29  
30 #ifdef HAVE_CONFIG_H
31 #include <config.h>
32 #endif /*HAVE_CONFIG_H*/
33
34 #include <glib/gi18n.h>
35 #include <glib/gprintf.h>
36 #include <string.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"
44 #include "modest-protocol-info.h"
45 #include "modest-tny-platform-factory.h"
46 #include "modest-platform.h"
47 #include "modest-debug.h"
48 #include <tny-mime-part.h>
49 #include <tny-camel-folder.h>
50 #include <tny-camel-imap-folder.h>
51 #include <tny-camel-pop-folder.h>
52
53 #ifdef MODEST_PLATFORM_MAEMO
54 #include "maemo/modest-osso-state-saving.h"
55 #include "maemo/modest-hildon-includes.h"
56 #include "maemo/modest-connection-specific-smtp-window.h"
57 #endif /* MODEST_PLATFORM_MAEMO */
58 #include <modest-utils.h>
59
60 #include "widgets/modest-ui-constants.h"
61 #include <widgets/modest-main-window.h>
62 #include <widgets/modest-msg-view-window.h>
63 #include <widgets/modest-account-view-window.h>
64 #include <widgets/modest-details-dialog.h>
65 #include <widgets/modest-attachments-view.h>
66 #include "widgets/modest-folder-view.h"
67 #include "widgets/modest-global-settings-dialog.h"
68 #include "modest-account-mgr-helpers.h"
69 #include "modest-mail-operation.h"
70 #include "modest-text-utils.h"
71
72 #ifdef MODEST_HAVE_EASYSETUP
73 #include "easysetup/modest-easysetup-wizard.h"
74 #endif /* MODEST_HAVE_EASYSETUP */
75
76 #include <modest-widget-memory.h>
77 #include <tny-error.h>
78 #include <tny-simple-list.h>
79 #include <tny-msg-view.h>
80 #include <tny-device.h>
81 #include <tny-merge-folder.h>
82
83 #include <gtkhtml/gtkhtml.h>
84
85 typedef struct _GetMsgAsyncHelper {     
86         ModestWindow *window;
87         ModestMailOperation *mail_op;
88         TnyIterator *iter;
89         guint num_ops;
90         GFunc func;     
91         gpointer user_data;
92 } GetMsgAsyncHelper;
93
94 typedef enum _ReplyForwardAction {
95         ACTION_REPLY,
96         ACTION_REPLY_TO_ALL,
97         ACTION_FORWARD
98 } ReplyForwardAction;
99
100 typedef struct _ReplyForwardHelper {
101         guint reply_forward_type;
102         ReplyForwardAction action;
103         gchar *account_name;
104         GtkWidget *parent_window;
105 } ReplyForwardHelper;
106
107 typedef struct _MoveToHelper {
108         GtkTreeRowReference *reference;
109         GtkWidget *banner;
110 } MoveToHelper;
111
112 typedef struct _PasteAsAttachmentHelper {
113         ModestMsgEditWindow *window;
114         GtkWidget *banner;
115 } PasteAsAttachmentHelper;
116
117
118 /*
119  * The do_headers_action uses this kind of functions to perform some
120  * action to each member of a list of headers
121  */
122 typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
123
124 static void     do_headers_action     (ModestWindow *win, 
125                                        HeadersFunc func,
126                                        gpointer user_data);
127
128 static void     open_msg_cb            (ModestMailOperation *mail_op, 
129                                         TnyHeader *header, 
130                                         gboolean canceled,
131                                         TnyMsg *msg,
132                                         GError *err,
133                                         gpointer user_data);
134
135 static void     reply_forward_cb       (ModestMailOperation *mail_op, 
136                                         TnyHeader *header, 
137                                         gboolean canceled,
138                                         TnyMsg *msg,
139                                         GError *err,
140                                         gpointer user_data);
141
142 static void     reply_forward          (ReplyForwardAction action, ModestWindow *win);
143
144 static void     folder_refreshed_cb    (ModestMailOperation *mail_op, 
145                                         TnyFolder *folder, 
146                                         gpointer user_data);
147
148 static void     on_send_receive_finished (ModestMailOperation  *mail_op, 
149                                           gpointer user_data);
150
151 static gint header_list_count_uncached_msgs (TnyList *header_list);
152
153 static gboolean connect_to_get_msg (ModestWindow *win,
154                                     gint num_of_uncached_msgs,
155                                     TnyAccount *account);
156
157 static gboolean remote_folder_is_pop (TnyFolderStore *folder);
158
159 static void     do_create_folder (GtkWindow *window, 
160                                   TnyFolderStore *parent_folder, 
161                                   const gchar *suggested_name);
162
163 static GtkWidget* get_folder_view_from_move_to_dialog (GtkWidget *move_to_dialog);
164
165 static TnyAccount *get_account_from_folder_store (TnyFolderStore *folder_store);
166
167 static void transfer_messages_helper (GtkWindow *win,
168                                       TnyFolder *src_folder,
169                                       TnyList *headers,
170                                       TnyFolder *dst_folder);
171
172 /*
173  * This function checks whether a TnyFolderStore is a pop account
174  */
175 static gboolean
176 remote_folder_is_pop (TnyFolderStore *folder)
177 {
178         const gchar *proto = NULL;
179         TnyAccount *account = NULL;
180
181         g_return_val_if_fail (TNY_IS_FOLDER_STORE (folder), FALSE);
182         
183         account = get_account_from_folder_store (folder);
184         proto = tny_account_get_proto (account);
185         g_object_unref (account);
186
187         return (modest_protocol_info_get_transport_store_protocol (proto) == MODEST_PROTOCOL_STORE_POP);
188 }
189
190 /* FIXME: this should be merged with the similar code in modest-account-view-window */
191 /* Show the account creation wizard dialog.
192  * returns: TRUE if an account was created. FALSE if the user cancelled.
193  */
194 gboolean
195 modest_ui_actions_run_account_setup_wizard (ModestWindow *win)
196 {
197         gboolean result = FALSE;        
198         GtkWindow *dialog, *wizard;
199         gint dialog_response;
200
201         /* Show the easy-setup wizard: */       
202         dialog = modest_window_mgr_get_modal (modest_runtime_get_window_mgr());
203         if (dialog) {
204                 /* old wizard is active already; 
205                  */
206                 gtk_window_present (GTK_WINDOW(dialog));
207                 return FALSE;
208         }
209         
210
211         /* there is no such wizard yet */       
212         wizard = GTK_WINDOW (modest_platform_get_account_settings_wizard ());
213         modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), wizard);
214
215         /* always present a main window in the background 
216          * we do it here, so we cannot end up with two wizards (as this
217          * function might be called in modest_window_mgr_get_main_window as well */
218         if (!win) 
219                 win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(),
220                                                          TRUE);  /* create if not existent */
221         
222         /* make sure the mainwindow is visible */
223         gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
224         gtk_widget_show_all (GTK_WIDGET(win));
225         gtk_window_present (GTK_WINDOW(win));
226         
227         dialog_response = gtk_dialog_run (GTK_DIALOG (wizard));
228         gtk_widget_destroy (GTK_WIDGET (wizard));
229         if (gtk_events_pending ())
230                 gtk_main_iteration ();
231
232         if (dialog_response == GTK_RESPONSE_CANCEL) {
233                 result = FALSE;
234         } else {
235                 /* Check whether an account was created: */
236                 result = modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
237         }
238         return result;
239 }
240
241
242 void   
243 modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
244 {
245         GtkWidget *about;
246         const gchar *authors[] = {
247                 "Dirk-Jan C. Binnema <dirk-jan.binnema@nokia.com>",
248                 NULL
249         };
250         about = gtk_about_dialog_new ();
251         gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
252         gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
253         gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about),
254                                         _("Copyright (c) 2006, Nokia Corporation\n"
255                                           "All rights reserved."));
256         gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about),
257                                        _("a modest e-mail client\n\n"
258                                          "design and implementation: Dirk-Jan C. Binnema\n"
259                                          "contributions from the fine people at KC and Ig\n"
260                                          "uses the tinymail email framework written by Philip van Hoof"));
261         gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
262         gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
263         gtk_window_set_transient_for (GTK_WINDOW (about), GTK_WINDOW (win));
264         gtk_window_set_modal (GTK_WINDOW (about), TRUE);
265         
266         gtk_dialog_run (GTK_DIALOG (about));
267         gtk_widget_destroy(about);
268 }
269
270 /*
271  * Gets the list of currently selected messages. If the win is the
272  * main window, then it returns a newly allocated list of the headers
273  * selected in the header view. If win is the msg view window, then
274  * the value returned is a list with just a single header.
275  *
276  * The caller of this funcion must free the list.
277  */
278 static TnyList *
279 get_selected_headers (ModestWindow *win)
280 {
281         if (MODEST_IS_MAIN_WINDOW(win)) {
282                 GtkWidget *header_view;         
283                 
284                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
285                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
286                 return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
287                 
288         } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
289                 /* for MsgViewWindows, we simply return a list with one element */
290                 TnyHeader *header;
291                 TnyList *list = NULL;
292                 
293                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
294                 if (header != NULL) {
295                         list = tny_simple_list_new ();
296                         tny_list_prepend (list, G_OBJECT(header));
297                         g_object_unref (G_OBJECT(header));
298                 }
299
300                 return list;
301
302         } else
303                 return NULL;
304 }
305
306 static GtkTreeRowReference *
307 get_next_after_selected_headers (ModestHeaderView *header_view)
308 {
309         GtkTreeSelection *sel;
310         GList *selected_rows, *node;
311         GtkTreePath *path;
312         GtkTreeRowReference *result;
313         GtkTreeModel *model;
314
315         model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
316         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
317         selected_rows = gtk_tree_selection_get_selected_rows (sel, NULL);
318
319         if (selected_rows == NULL)
320                 return NULL;
321
322         node = g_list_last (selected_rows);
323         path = gtk_tree_path_copy ((GtkTreePath *) node->data);
324         gtk_tree_path_next (path);
325
326         result = gtk_tree_row_reference_new (model, path);
327
328         gtk_tree_path_free (path);
329         g_list_foreach (selected_rows, (GFunc) gtk_tree_path_free, NULL);
330         g_list_free (selected_rows);
331
332         return result;
333 }
334
335 static void
336 headers_action_mark_as_read (TnyHeader *header,
337                              ModestWindow *win,
338                              gpointer user_data)
339 {
340         TnyHeaderFlags flags;
341
342         g_return_if_fail (TNY_IS_HEADER(header));
343
344         flags = tny_header_get_flags (header);
345         if (flags & TNY_HEADER_FLAG_SEEN) return;
346         tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN);
347 }
348
349 static void
350 headers_action_mark_as_unread (TnyHeader *header,
351                                ModestWindow *win,
352                                gpointer user_data)
353 {
354         TnyHeaderFlags flags;
355
356         g_return_if_fail (TNY_IS_HEADER(header));
357
358         flags = tny_header_get_flags (header);
359         if (flags & TNY_HEADER_FLAG_SEEN)  {
360                 tny_header_unset_flag (header, TNY_HEADER_FLAG_SEEN);
361         }
362 }
363
364 /** After deleing a message that is currently visible in a window, 
365  * show the next message from the list, or close the window if there are no more messages.
366  **/
367 void 
368 modest_ui_actions_refresh_message_window_after_delete (ModestMsgViewWindow* win)
369 {
370         /* Close msg view window or select next */
371         if (!modest_msg_view_window_select_next_message (win) &&
372             !modest_msg_view_window_select_previous_message (win)) {
373                 gboolean ret_value;
374                 g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);       
375         }
376 }
377
378
379 void
380 modest_ui_actions_on_delete_message (GtkAction *action, ModestWindow *win)
381 {
382         TnyList *header_list = NULL;
383         TnyIterator *iter = NULL;
384         TnyHeader *header = NULL;
385         gchar *message = NULL;
386         gchar *desc = NULL;
387         gint response;
388         ModestWindowMgr *mgr;
389         GtkWidget *header_view = NULL;
390
391         g_return_if_fail (MODEST_IS_WINDOW(win));
392         
393         /* Check first if the header view has the focus */
394         if (MODEST_IS_MAIN_WINDOW (win)) {
395                 header_view = 
396                         modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
397                                                              MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
398                 if (!gtk_widget_is_focus (header_view))
399                         return;
400         }
401         
402         /* Get the headers, either from the header view (if win is the main window),
403          * or from the message view window: */
404         header_list = get_selected_headers (win);
405         if (!header_list) return;
406                         
407         /* Check if any of the headers are already opened, or in the process of being opened */
408         if (MODEST_IS_MAIN_WINDOW (win)) {
409                 gint opened_headers = 0;
410
411                 iter = tny_list_create_iterator (header_list);
412                 mgr = modest_runtime_get_window_mgr ();
413                 while (!tny_iterator_is_done (iter)) {
414                         header = TNY_HEADER (tny_iterator_get_current (iter));
415                         if (header) {
416                                 if (modest_window_mgr_find_registered_header (mgr, header, NULL))
417                                         opened_headers++;
418                                 g_object_unref (header);
419                         }
420                         tny_iterator_next (iter);
421                 }
422                 g_object_unref (iter);
423
424                 if (opened_headers > 0) {
425                         gchar *msg;
426
427                         msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"), 
428                                                opened_headers);
429
430                         modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg);
431                         
432                         g_free (msg);
433                         g_object_unref (header_list);
434                         return;
435                 }
436         }
437
438         /* Select message */
439         if (tny_list_get_length(header_list) == 1) {
440                 iter = tny_list_create_iterator (header_list);
441                 header = TNY_HEADER (tny_iterator_get_current (iter));
442                 if (header) {
443                         desc = g_strdup_printf ("%s", tny_header_get_subject (header)); 
444                         g_object_unref (header);
445                 }
446
447                 g_object_unref (iter);
448         }
449         message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages", 
450                                            tny_list_get_length(header_list)), desc);
451
452         /* Confirmation dialog */
453         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
454                                                             message);
455         
456
457         if (response == GTK_RESPONSE_OK) {      
458                 ModestWindow *main_window = NULL;
459                 ModestWindowMgr *mgr = NULL;
460                 GtkTreeModel *model = NULL;
461                 GtkTreeSelection *sel = NULL;
462                 GList *sel_list = NULL, *tmp = NULL;
463                 GtkTreeRowReference *next_row_reference = NULL;
464                 GtkTreeRowReference *prev_row_reference = NULL;
465                 GtkTreePath *next_path = NULL;
466                 GtkTreePath *prev_path = NULL;
467                 ModestMailOperation *mail_op = NULL;
468
469                 /* Find last selected row */                    
470                 if (MODEST_IS_MAIN_WINDOW (win)) {
471                         model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
472                         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
473                         sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
474                         for (tmp=sel_list; tmp; tmp=tmp->next) {
475                                 if (tmp->next == NULL) {
476                                         prev_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
477                                         next_path = gtk_tree_path_copy((GtkTreePath *) tmp->data);
478
479                                         gtk_tree_path_prev (prev_path);
480                                         gtk_tree_path_next (next_path);
481
482                                         prev_row_reference = gtk_tree_row_reference_new (model, prev_path);
483                                         next_row_reference = gtk_tree_row_reference_new (model, next_path);
484                                 }
485                         }
486                 }
487                 
488                 /* Disable window dimming management */
489                 modest_window_disable_dimming (MODEST_WINDOW(win));
490
491                 /* Remove each header. If it's a view window header_view == NULL */
492                 mail_op = modest_mail_operation_new ((GObject *) win);
493                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
494                                                  mail_op);
495                 modest_mail_operation_remove_msgs (mail_op, header_list, FALSE);
496                 g_object_unref (mail_op);
497                 
498                 /* Enable window dimming management */
499                 if (sel != NULL) {
500                         gtk_tree_selection_unselect_all (sel);
501                 }
502                 modest_window_enable_dimming (MODEST_WINDOW(win));
503                 
504                 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
505                         modest_ui_actions_refresh_message_window_after_delete (MODEST_MSG_VIEW_WINDOW (win));
506                         
507                         /* Get main window */
508                         mgr = modest_runtime_get_window_mgr ();
509                         main_window = modest_window_mgr_get_main_window (mgr, FALSE); /* don't create */
510                 } else {                        
511                         /* Move cursor to next row */
512                         main_window = win; 
513
514                         /* Select next or previous row */
515                         if (gtk_tree_row_reference_valid (next_row_reference)) {
516 /*                              next_path = gtk_tree_row_reference_get_path (row_reference); */
517                                 gtk_tree_selection_select_path (sel, next_path);
518                         }
519                         else if (gtk_tree_row_reference_valid (prev_row_reference)) {                           
520                                 gtk_tree_selection_select_path (sel, prev_path);
521                         }
522
523                         /* Free */
524                         if (next_row_reference != NULL) 
525                                 gtk_tree_row_reference_free (next_row_reference);
526                         if (next_path != NULL) 
527                                 gtk_tree_path_free (next_path);                         
528                         if (prev_row_reference != NULL) 
529                                 gtk_tree_row_reference_free (prev_row_reference);
530                         if (prev_path != NULL) 
531                                 gtk_tree_path_free (prev_path);                         
532                 }
533                 
534                 /* Update toolbar dimming state */
535                 if (main_window)
536                         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
537
538                 /* Free */
539                 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
540                 g_list_free (sel_list);
541         }
542
543         /* Free*/
544         g_free(message);
545         g_free(desc);
546         g_object_unref (header_list);
547 }
548
549
550
551
552 /* delete either message or folder, based on where we are */
553 void
554 modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
555 {
556         g_return_if_fail (MODEST_IS_WINDOW(win));
557         
558         /* Check first if the header view has the focus */
559         if (MODEST_IS_MAIN_WINDOW (win)) {
560                 GtkWidget *w;
561                 w = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
562                                                          MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
563                 if (gtk_widget_is_focus (w)) {
564                         modest_ui_actions_on_delete_folder (action, MODEST_MAIN_WINDOW(win));
565                         return;
566                 }
567         }
568         modest_ui_actions_on_delete_message (action, win);
569 }
570
571 void
572 modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
573 {       
574         ModestWindowMgr *mgr = NULL;
575         
576 #ifdef MODEST_PLATFORM_MAEMO
577         modest_osso_save_state();
578 #endif /* MODEST_PLATFORM_MAEMO */
579
580         g_debug ("closing down, clearing %d item(s) from operation queue",
581                  modest_mail_operation_queue_num_elements
582                  (modest_runtime_get_mail_operation_queue()));
583
584         /* cancel all outstanding operations */
585         modest_mail_operation_queue_cancel_all 
586                 (modest_runtime_get_mail_operation_queue());
587         
588         g_debug ("queue has been cleared");
589
590
591         /* Check if there are opened editing windows */ 
592         mgr = modest_runtime_get_window_mgr ();
593         modest_window_mgr_close_all_windows (mgr);
594
595         /* note: when modest-tny-account-store is finalized,
596            it will automatically set all network connections
597            to offline */
598
599 /*      gtk_main_quit (); */
600 }
601
602 void
603 modest_ui_actions_on_close_window (GtkAction *action, ModestWindow *win)
604 {
605         gboolean ret_value;
606
607         g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
608
609 /*      if (MODEST_IS_MSG_VIEW_WINDOW (win)) { */
610 /*              gtk_widget_destroy (GTK_WIDGET (win)); */
611 /*      } else if (MODEST_IS_MSG_EDIT_WINDOW (win)) { */
612 /*              gboolean ret_value; */
613 /*              g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value); */
614 /*      } else if (MODEST_IS_WINDOW (win)) { */
615 /*              gtk_widget_destroy (GTK_WIDGET (win)); */
616 /*      } else { */
617 /*              g_return_if_reached (); */
618 /*      } */
619 }
620
621 void
622 modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
623 {
624         GtkClipboard *clipboard = NULL;
625         gchar *selection = NULL;
626
627         clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
628         selection = gtk_clipboard_wait_for_text (clipboard);
629
630         /* Question: why is the clipboard being used here? 
631          * It doesn't really make a lot of sense. */
632
633         if (selection)
634         {
635                 modest_address_book_add_address (selection);
636                 g_free (selection);
637         }
638 }
639
640 void
641 modest_ui_actions_on_accounts (GtkAction *action, 
642                                ModestWindow *win)
643 {
644         /* This is currently only implemented for Maemo */
645         if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE)) {
646                 if (!modest_ui_actions_run_account_setup_wizard (win)) 
647                         g_debug ("%s: wizard was already running", __FUNCTION__);
648                 
649                 return;
650         } else {
651                 /* Show the list of accounts */
652                 GtkWindow *account_win = GTK_WINDOW (modest_account_view_window_new ());
653                 gtk_window_set_transient_for (account_win, GTK_WINDOW (win));
654                 
655                 /* The accounts dialog must be modal */
656                 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), account_win);
657                 modest_utils_show_dialog_and_forget (GTK_WINDOW (win), GTK_DIALOG (account_win)); 
658         }
659 }
660
661 #ifdef MODEST_PLATFORM_MAEMO
662 static void
663 on_smtp_servers_window_hide (GtkWindow* window, gpointer user_data)
664 {
665         /* Save any changes. */
666         modest_connection_specific_smtp_window_save_server_accounts (
667                         MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (window));
668         gtk_widget_destroy (GTK_WIDGET (window));
669 }
670 #endif
671
672
673 void
674 modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
675 {
676         /* This is currently only implemented for Maemo,
677          * because it requires an API (libconic) to detect different connection 
678          * possiblities.
679          */
680 #ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
681         
682         /* Create the window if necessary: */
683         GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
684         modest_connection_specific_smtp_window_fill_with_connections (
685                 MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window), 
686                 modest_runtime_get_account_mgr());
687
688         /* Show the window: */  
689         gtk_window_set_transient_for (GTK_WINDOW (specific_window), GTK_WINDOW (win));
690         gtk_window_set_modal (GTK_WINDOW (specific_window), TRUE);
691         gtk_widget_show (specific_window);
692     
693         /* Save changes when the window is hidden: */
694         g_signal_connect (specific_window, "hide", 
695                 G_CALLBACK (on_smtp_servers_window_hide), win);
696 #endif /* MODEST_PLATFORM_MAEMO */
697 }
698
699 void
700 modest_ui_actions_compose_msg(ModestWindow *win,
701                               const gchar *to_str,
702                               const gchar *cc_str,
703                               const gchar *bcc_str,
704                               const gchar *subject_str,
705                               const gchar *body_str,
706                               GSList *attachments,
707                               gboolean set_as_modified)
708 {
709         gchar *account_name = NULL;
710         TnyMsg *msg = NULL;
711         TnyAccount *account = NULL;
712         TnyFolder *folder = NULL;
713         gchar *from_str = NULL, *signature = NULL, *body = NULL;
714         gboolean use_signature = FALSE;
715         ModestWindow *msg_win = NULL;
716         ModestAccountMgr *mgr = modest_runtime_get_account_mgr();
717         ModestTnyAccountStore *store = modest_runtime_get_account_store();
718
719         account_name = modest_account_mgr_get_default_account(mgr);
720         if (!account_name) {
721                 g_printerr ("modest: no account found\n");
722                 goto cleanup;
723         }
724         account = modest_tny_account_store_get_server_account (store, account_name, TNY_ACCOUNT_TYPE_STORE);
725         if (!account) {
726                 g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
727                 goto cleanup;
728         }
729         folder = modest_tny_account_get_special_folder (account, TNY_FOLDER_TYPE_DRAFTS);
730         if (!folder) {
731                 g_printerr ("modest: failed to find Drafts folder\n");
732                 goto cleanup;
733         }
734         from_str = modest_account_mgr_get_from_string (mgr, account_name);
735         if (!from_str) {
736                 g_printerr ("modest: failed get from string for '%s'\n", account_name);
737                 goto cleanup;
738         }
739
740         signature = modest_account_mgr_get_signature (mgr, account_name, &use_signature);
741         if (body_str != NULL) {
742                 body = use_signature ? g_strconcat(body_str, "\n", signature, NULL) : g_strdup(body_str);
743         } else {
744                 body = use_signature ? g_strconcat("\n", signature, NULL) : g_strdup("");
745         }
746
747         msg = modest_tny_msg_new (to_str, from_str, cc_str, bcc_str, subject_str, body, NULL);
748         if (!msg) {
749                 g_printerr ("modest: failed to create new msg\n");
750                 goto cleanup;
751         }
752
753         /* Create and register edit window */
754         /* This is destroyed by TODO. */
755         msg_win = modest_msg_edit_window_new (msg, account_name, FALSE);
756         while (attachments) {
757                 modest_msg_edit_window_attach_file_one((ModestMsgEditWindow *)msg_win,
758                                                        attachments->data);
759                 attachments = g_slist_next(attachments);
760         }
761         modest_window_mgr_register_window (modest_runtime_get_window_mgr(), msg_win);
762         modest_msg_edit_window_set_modified (MODEST_MSG_EDIT_WINDOW (msg_win), set_as_modified);
763
764         gtk_widget_show_all (GTK_WIDGET (msg_win));
765
766 cleanup:
767         g_free (from_str);
768         g_free (signature);
769         g_free (body);
770         g_free (account_name);
771         if (account) g_object_unref (G_OBJECT(account));
772         if (folder) g_object_unref (G_OBJECT(folder));
773         if (msg_win) g_object_unref (G_OBJECT(msg_win));
774         if (msg) g_object_unref (G_OBJECT(msg));
775 }
776
777 void
778 modest_ui_actions_on_new_msg (GtkAction *action, ModestWindow *win)
779 {
780         /* if there are no accounts yet, just show the wizard */
781         if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE))
782                 if (!modest_ui_actions_run_account_setup_wizard (win))
783                         return;
784                 
785         modest_ui_actions_compose_msg(win, NULL, NULL, NULL, NULL, NULL, NULL, FALSE);
786 }
787
788
789 gboolean 
790 modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
791                                        TnyHeader *header,
792                                        TnyMsg *msg)
793 {
794         ModestMailOperationStatus status;
795
796         /* If there is no message or the operation was not successful */
797         status = modest_mail_operation_get_status (mail_op);
798         if (!msg || status != MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
799
800                 /* Remove the header from the preregistered uids */
801                 modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),  
802                                                      header);
803
804                 return FALSE;
805         }
806
807         return TRUE;
808 }
809
810 typedef struct {
811         guint idle_handler;
812         gchar *message;
813         GtkWidget *banner;
814 } OpenMsgBannerInfo;
815
816 gboolean
817 open_msg_banner_idle (gpointer userdata)
818 {
819         OpenMsgBannerInfo *banner_info = (OpenMsgBannerInfo *) userdata;
820
821         gdk_threads_enter ();
822         banner_info->idle_handler = 0;
823         banner_info->banner = modest_platform_animation_banner (NULL, NULL, banner_info->message);
824         g_object_ref (banner_info->banner);
825         
826         gdk_threads_leave ();
827
828         return FALSE;
829         
830 }
831
832 static void
833 open_msg_cb (ModestMailOperation *mail_op, 
834              TnyHeader *header,  
835              gboolean canceled,
836              TnyMsg *msg, 
837              GError *err,
838              gpointer user_data)
839 {
840         ModestWindowMgr *mgr = NULL;
841         ModestWindow *parent_win = NULL;
842         ModestWindow *win = NULL;
843         TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
844         gchar *account = NULL;
845         TnyFolder *folder;
846         gboolean open_in_editor = FALSE;
847         OpenMsgBannerInfo *banner_info = (OpenMsgBannerInfo *) user_data;
848         
849         /* Do nothing if there was any problem with the mail
850            operation. The error will be shown by the error_handler of
851            the mail operation */
852         if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
853                 goto banner_cleanup;
854
855         parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
856         folder = tny_header_get_folder (header);
857
858         /* Mark header as read */
859         headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
860
861         /* Gets folder type (OUTBOX headers will be opened in edit window */
862         if (modest_tny_folder_is_local_folder (folder)) {
863                 folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
864                 if (folder_type == TNY_FOLDER_TYPE_INVALID)
865                         g_warning ("%s: BUG: TNY_FOLDER_TYPE_INVALID", __FUNCTION__);
866         }
867
868                 
869         if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
870                 TnyTransportAccount *traccount = NULL;
871                 ModestTnyAccountStore *accstore = modest_runtime_get_account_store();
872                 traccount = modest_tny_account_store_get_transport_account_from_outbox_header(accstore, header);
873                 if (traccount) {
874                         ModestTnySendQueue *send_queue = NULL;
875                         ModestTnySendQueueStatus status;
876                         char *msg_id;
877                         account = g_strdup(modest_tny_account_get_parent_modest_account_name_for_server_account(
878                                                    TNY_ACCOUNT(traccount)));
879                         send_queue = modest_runtime_get_send_queue(traccount);
880                         msg_id = modest_tny_send_queue_get_msg_id (header);
881                         status = modest_tny_send_queue_get_msg_status(send_queue, msg_id);
882                         /* Only open messages in outbox with the editor if they are in Failed state */
883                         if (status == MODEST_TNY_SEND_QUEUE_FAILED) {
884                                 open_in_editor = TRUE;
885                         }
886                         g_free(msg_id);
887                         g_object_unref(traccount);
888                 } else {
889                         g_warning("Cannot get transport account for message in outbox!!");
890                 }
891         } else if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
892                 open_in_editor = TRUE; /* Open in editor if the message is in the Drafts folder */
893         }
894
895         /* Get account */
896         if (!account)
897                 account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
898         if (!account)
899                 account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
900         
901         if (open_in_editor) {
902                 ModestAccountMgr *mgr = modest_runtime_get_account_mgr ();
903                 const gchar *from_header = NULL;
904
905                 from_header = tny_header_get_from (header);
906
907                 /* we cannot edit without a valid account... */
908                 if (!modest_account_mgr_has_accounts(mgr, TRUE)) {
909                         if (!modest_ui_actions_run_account_setup_wizard(parent_win))
910                                 goto cleanup;
911                 }
912                 
913                 if (from_header) {
914                         GSList *accounts = modest_account_mgr_account_names (mgr, TRUE);
915                         GSList *node = NULL;
916                         for (node = accounts; node != NULL; node = g_slist_next (node)) {
917                                 gchar *from = modest_account_mgr_get_from_string (mgr, node->data);
918                                 
919                                 if (from && (strcmp (from_header, from) == 0)) {
920                                         g_free (account);
921                                         account = g_strdup (node->data);
922                                         g_free (from);
923                                         break;
924                                 }
925                                 g_free (from);
926                         }
927                         g_slist_foreach (accounts, (GFunc) g_free, NULL);
928                         g_slist_free (accounts);
929                 }
930
931                 win = modest_msg_edit_window_new (msg, account, TRUE);
932
933
934
935         } else {
936                 gchar *uid = modest_tny_folder_get_header_unique_id (header);
937                 
938                 if (MODEST_IS_MAIN_WINDOW (parent_win)) {
939                         GtkWidget *header_view;
940                         GtkTreeSelection *sel;
941                         GList *sel_list = NULL;
942                         GtkTreeModel *model;
943                         
944                         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_win),
945                                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
946
947                         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
948                         sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
949
950                         if (sel_list != NULL) {
951                                 GtkTreeRowReference *row_reference;
952
953                                 row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list->data);
954                                 g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
955                                 g_list_free (sel_list);
956                                 
957                                 win = modest_msg_view_window_new_with_header_model (
958                                                 msg, account, (const gchar*) uid,
959                                                 model, row_reference);
960                                 gtk_tree_row_reference_free (row_reference);
961                         } else {
962                                 win = modest_msg_view_window_new_for_attachment (msg, account, (const gchar*) uid);
963                         }
964                 } else {
965                         win = modest_msg_view_window_new_for_attachment (msg, account, (const gchar*) uid);
966                 }
967                 g_free (uid);
968         }
969         
970         /* Register and show new window */
971         if (win != NULL) {
972                 mgr = modest_runtime_get_window_mgr ();
973                 modest_window_mgr_register_window (mgr, win);
974                 g_object_unref (win);
975                 gtk_widget_show_all (GTK_WIDGET(win));
976         }
977
978         /* Update toolbar dimming state */
979         if (MODEST_IS_MAIN_WINDOW (parent_win)) {
980                 modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_win));
981         }
982
983 cleanup:
984         /* Free */
985         g_free(account);
986         g_object_unref (parent_win);
987         g_object_unref (folder);
988 banner_cleanup:
989         if (banner_info) {
990                 g_free (banner_info->message);
991                 if (banner_info->idle_handler > 0) {
992                         g_source_remove (banner_info->idle_handler);
993                         banner_info->idle_handler = 0;
994                 }
995                 if (banner_info->banner != NULL) {
996                         gtk_widget_destroy (banner_info->banner);
997                         g_object_unref (banner_info->banner);
998                         banner_info->banner = NULL;
999                 }
1000                 g_slice_free (OpenMsgBannerInfo, banner_info);
1001         }
1002 }
1003
1004 void
1005 modest_ui_actions_get_msgs_full_error_handler (ModestMailOperation *mail_op,
1006                                                gpointer user_data)
1007 {
1008         const GError *error;
1009         GObject *win = NULL;
1010
1011         win = modest_mail_operation_get_source (mail_op);
1012         error = modest_mail_operation_get_error (mail_op);
1013
1014         /* Show error */
1015         if (error->code == TNY_SYSTEM_ERROR_MEMORY ||
1016             error->code == TNY_IO_ERROR_WRITE ||
1017             error->code == TNY_IO_ERROR_READ) {
1018                 ModestMailOperationStatus st = modest_mail_operation_get_status (mail_op);
1019                 /* If the mail op has been cancelled then it's not an error: don't show any message */
1020                 if (st != MODEST_MAIL_OPERATION_STATUS_CANCELED) {
1021                         modest_platform_information_banner ((GtkWidget *) win,
1022                                                             NULL, dgettext("ke-recv",
1023                                                                            "cerm_device_memory_full"));
1024                 }
1025         } else if (user_data) {
1026                 modest_platform_information_banner ((GtkWidget *) win, 
1027                                                     NULL, user_data);
1028         }
1029
1030         if (win)
1031                 g_object_unref (win);
1032 }
1033
1034 /**
1035  * Returns the account a list of headers belongs to. It returns a
1036  * *new* reference so don't forget to unref it
1037  */
1038 static TnyAccount*
1039 get_account_from_header_list (TnyList *headers)
1040 {
1041         TnyAccount *account = NULL;
1042
1043         if (tny_list_get_length (headers) > 0) {
1044                 TnyIterator *iter = tny_list_create_iterator (headers);
1045                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1046                 TnyFolder *folder = tny_header_get_folder (header);
1047                 account = tny_folder_get_account (folder);
1048                 g_object_unref (folder);
1049                 g_object_unref (header);
1050                 g_object_unref (iter);
1051         }
1052         return account;
1053 }
1054
1055 static void 
1056 foreach_unregister_headers (gpointer data,
1057                             gpointer user_data)
1058 {
1059         ModestWindowMgr *mgr = (ModestWindowMgr *) user_data;
1060         TnyHeader *header = TNY_HEADER (data);
1061
1062         modest_window_mgr_unregister_header (mgr, header);
1063 }
1064
1065 static void
1066 open_msgs_performer(gboolean canceled, 
1067                     GError *err,
1068                     GtkWindow *parent_window,
1069                     TnyAccount *account,
1070                     gpointer user_data)
1071 {
1072         ModestMailOperation *mail_op = NULL;
1073         const gchar *proto_name;
1074         gchar *error_msg;
1075         ModestTransportStoreProtocol proto;
1076         TnyList *not_opened_headers;
1077         TnyConnectionStatus status;
1078         gboolean show_open_draft = FALSE;
1079         OpenMsgBannerInfo *banner_info = NULL;
1080
1081         not_opened_headers = TNY_LIST (user_data);
1082
1083         status = tny_account_get_connection_status (account);
1084         if (err || canceled) {
1085                 /* Unregister the already registered headers */
1086                 tny_list_foreach (not_opened_headers, foreach_unregister_headers, 
1087                                   modest_runtime_get_window_mgr ());
1088                 goto clean;
1089         }
1090
1091         /* Get the error message depending on the protocol */
1092         proto_name = tny_account_get_proto (account);
1093         if (proto_name != NULL) {
1094                 proto = modest_protocol_info_get_transport_store_protocol (proto_name);
1095         } else {
1096                 proto = MODEST_PROTOCOL_STORE_MAILDIR;
1097         }
1098         
1099         /* Create the error messages */
1100         if (tny_list_get_length (not_opened_headers) == 1) {
1101                 if (proto == MODEST_PROTOCOL_STORE_POP) {
1102                         error_msg = g_strdup (_("emev_ni_ui_pop3_msg_recv_error"));
1103                 } else if (proto == MODEST_PROTOCOL_STORE_IMAP) {
1104                         TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
1105                         TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1106                         error_msg = g_strdup_printf (_("emev_ni_ui_imap_message_not_available_in_server"),
1107                                                      tny_header_get_subject (header));
1108                         g_object_unref (header);
1109                         g_object_unref (iter);
1110                 } else {
1111                         TnyHeader *header;
1112                         TnyFolder *folder;
1113                         TnyIterator *iter;
1114                         TnyFolderType folder_type;
1115
1116                         iter = tny_list_create_iterator (not_opened_headers);
1117                         header = TNY_HEADER (tny_iterator_get_current (iter));
1118                         folder = tny_header_get_folder (header);
1119                         folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
1120                         show_open_draft = (folder_type == TNY_FOLDER_TYPE_DRAFTS);
1121                         g_object_unref (folder);
1122                         g_object_unref (header);
1123                         g_object_unref (iter);
1124                         error_msg = g_strdup (_("mail_ni_ui_folder_get_msg_folder_error"));
1125                 }
1126         } else {
1127                 error_msg = g_strdup (_("mail_ni_ui_folder_get_msg_folder_error"));
1128         }
1129
1130         /* Create the mail operation */
1131         mail_op = 
1132                 modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
1133                                                                modest_ui_actions_get_msgs_full_error_handler,
1134                                                                error_msg, g_free);
1135         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1136                                          mail_op);
1137
1138         if (show_open_draft) {
1139                 banner_info = g_slice_new (OpenMsgBannerInfo);
1140                 banner_info->message = g_strdup (_("mail_ib_opening_draft_message"));
1141                 banner_info->banner = NULL;
1142                 banner_info->idle_handler = g_timeout_add (500, open_msg_banner_idle, banner_info);
1143         }
1144
1145         modest_mail_operation_get_msgs_full (mail_op,
1146                                              not_opened_headers,
1147                                              open_msg_cb,
1148                                              banner_info,
1149                                              NULL);
1150
1151         /* Frees */
1152  clean:
1153         if (mail_op)
1154                 g_object_unref (mail_op);
1155         g_object_unref (not_opened_headers);
1156         g_object_unref (account);
1157 }
1158
1159 /*
1160  * This function is used by both modest_ui_actions_on_open and
1161  * modest_ui_actions_on_header_activated. This way we always do the
1162  * same when trying to open messages.
1163  */
1164 static void
1165 open_msgs_from_headers (TnyList *headers, ModestWindow *win)
1166 {
1167         ModestWindowMgr *mgr = NULL;
1168         TnyIterator *iter = NULL, *iter_not_opened = NULL;
1169         TnyList *not_opened_headers = NULL;
1170         TnyHeaderFlags flags = 0;
1171         TnyAccount *account;
1172         gint uncached_msgs = 0;
1173                 
1174         g_return_if_fail (headers != NULL);
1175
1176         /* Check that only one message is selected for opening */
1177         if (tny_list_get_length (headers) != 1) {
1178                 modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
1179                                                         _("mcen_ib_select_one_message"));
1180                 return;
1181         }
1182
1183         mgr = modest_runtime_get_window_mgr ();
1184         iter = tny_list_create_iterator (headers);
1185
1186         /* Get the account */
1187         account = get_account_from_header_list (headers);
1188         
1189         /* Look if we already have a message view for each header. If
1190            true, then remove the header from the list of headers to
1191            open */
1192         not_opened_headers = tny_simple_list_new ();
1193         while (!tny_iterator_is_done (iter)) {
1194
1195                 ModestWindow *window = NULL;
1196                 TnyHeader *header = NULL;
1197                 gboolean found = FALSE;
1198                 
1199                 header = TNY_HEADER (tny_iterator_get_current (iter));
1200                 if (header)
1201                         flags = tny_header_get_flags (header);
1202
1203                 window = NULL;
1204                 found = modest_window_mgr_find_registered_header (mgr, header, &window);
1205                 
1206                 /* Do not open again the message and present the
1207                    window to the user */
1208                 if (found) {
1209                         if (window)
1210                                 gtk_window_present (GTK_WINDOW (window));
1211                         else
1212                                 /* the header has been registered already, we don't do
1213                                  * anything but wait for the window to come up*/
1214                                 g_debug ("header %p already registered, waiting for window", header);
1215                 } else {
1216                         tny_list_append (not_opened_headers, G_OBJECT (header));
1217                 }
1218
1219                 if (header)
1220                         g_object_unref (header);
1221
1222                 tny_iterator_next (iter);
1223         }
1224         g_object_unref (iter);
1225         iter = NULL;
1226
1227         /* Open each message */
1228         if (tny_list_get_length (not_opened_headers) == 0)
1229                 goto cleanup;
1230         
1231         /* If some messages would have to be downloaded, ask the user to 
1232          * make a connection. It's generally easier to do this here (in the mainloop) 
1233          * than later in a thread:
1234          */
1235         if (tny_list_get_length (not_opened_headers) > 0) {
1236                 uncached_msgs = header_list_count_uncached_msgs (not_opened_headers);
1237
1238                 if (uncached_msgs > 0) {
1239                         /* Allways download if we are online. */
1240                         if (!tny_device_is_online (modest_runtime_get_device ())) {
1241                                 gint response;
1242
1243                                 /* If ask for user permission to download the messages */
1244                                 response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1245                                                                                     ngettext("mcen_nc_get_msg",
1246                                                                                              "mcen_nc_get_msgs",
1247                                                                                              uncached_msgs));
1248
1249                                 /* End if the user does not want to continue */
1250                                 if (response == GTK_RESPONSE_CANCEL)
1251                                         goto cleanup;
1252                         }
1253                 }
1254         }
1255         
1256         /* Register the headers before actually creating the windows: */
1257         iter_not_opened = tny_list_create_iterator (not_opened_headers);
1258         while (!tny_iterator_is_done (iter_not_opened)) {
1259                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_not_opened));
1260                 if (header) {
1261                         modest_window_mgr_register_header (mgr, header, NULL);
1262                         g_object_unref (header);
1263                 }
1264                 tny_iterator_next (iter_not_opened);
1265         }
1266         g_object_unref (iter_not_opened);
1267         iter_not_opened = NULL;
1268
1269         /* Connect to the account and perform */
1270         if (uncached_msgs > 0) {
1271                 modest_platform_connect_and_perform ((GtkWindow *) win, TRUE, g_object_ref (account), 
1272                                                      open_msgs_performer, g_object_ref (not_opened_headers));
1273         } else {
1274                 /* Call directly the performer, do not need to connect */
1275                 open_msgs_performer (FALSE, NULL, (GtkWindow *) win, g_object_ref (account),
1276                                      g_object_ref (not_opened_headers));
1277         }
1278 cleanup:
1279         /* Clean */
1280         if (account)
1281                 g_object_unref (account);
1282         if (not_opened_headers)
1283                 g_object_unref (not_opened_headers);
1284 }
1285
1286 void
1287 modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
1288 {
1289         TnyList *headers;
1290
1291         /* Get headers */
1292         headers = get_selected_headers (win);
1293         if (!headers)
1294                 return;
1295
1296         /* Open them */
1297         open_msgs_from_headers (headers, win);
1298
1299         g_object_unref(headers);
1300 }
1301
1302
1303 static void
1304 free_reply_forward_helper (gpointer data)
1305 {
1306         ReplyForwardHelper *helper;
1307
1308         helper = (ReplyForwardHelper *) data;
1309         g_free (helper->account_name);
1310         g_slice_free (ReplyForwardHelper, helper);
1311 }
1312
1313 static void
1314 reply_forward_cb (ModestMailOperation *mail_op,  
1315                   TnyHeader *header, 
1316                   gboolean canceled,
1317                   TnyMsg *msg,
1318                   GError *err,
1319                   gpointer user_data)
1320 {
1321         TnyMsg *new_msg;
1322         ReplyForwardHelper *rf_helper;
1323         ModestWindow *msg_win = NULL;
1324         ModestEditType edit_type;
1325         gchar *from = NULL;
1326         TnyAccount *account = NULL;
1327         ModestWindowMgr *mgr = NULL;
1328         gchar *signature = NULL;
1329         gboolean use_signature;
1330
1331         /* If there was any error. The mail operation could be NULL,
1332            this means that we already have the message downloaded and
1333            that we didn't do a mail operation to retrieve it */
1334         if (mail_op && !modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
1335                 return;
1336                         
1337         g_return_if_fail (user_data != NULL);
1338         rf_helper = (ReplyForwardHelper *) user_data;
1339
1340         from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
1341                                                    rf_helper->account_name);
1342         signature = modest_account_mgr_get_signature (modest_runtime_get_account_mgr(), 
1343                                                       rf_helper->account_name, 
1344                                                       &use_signature);
1345
1346         /* Create reply mail */
1347         switch (rf_helper->action) {
1348         case ACTION_REPLY:
1349                 new_msg = 
1350                         modest_tny_msg_create_reply_msg (msg, header, from, 
1351                                                          (use_signature) ? signature : NULL,
1352                                                          rf_helper->reply_forward_type,
1353                                                          MODEST_TNY_MSG_REPLY_MODE_SENDER);
1354                 break;
1355         case ACTION_REPLY_TO_ALL:
1356                 new_msg = 
1357                         modest_tny_msg_create_reply_msg (msg, header, from, 
1358                                                          (use_signature) ? signature : NULL, 
1359                                                          rf_helper->reply_forward_type,
1360                                                          MODEST_TNY_MSG_REPLY_MODE_ALL);
1361                 edit_type = MODEST_EDIT_TYPE_REPLY;
1362                 break;
1363         case ACTION_FORWARD:
1364                 new_msg = 
1365                         modest_tny_msg_create_forward_msg (msg, from, (use_signature) ? signature : NULL, 
1366                                                            rf_helper->reply_forward_type);
1367                 edit_type = MODEST_EDIT_TYPE_FORWARD;
1368                 break;
1369         default:
1370                 g_return_if_reached ();
1371                 return;
1372         }
1373
1374         g_free (signature);
1375
1376         if (!new_msg) {
1377                 g_printerr ("modest: failed to create message\n");
1378                 goto cleanup;
1379         }
1380
1381         account = modest_tny_account_store_get_server_account (modest_runtime_get_account_store(),
1382                                                                        rf_helper->account_name,
1383                                                                        TNY_ACCOUNT_TYPE_STORE);
1384         if (!account) {
1385                 g_printerr ("modest: failed to get tnyaccount for '%s'\n", rf_helper->account_name);
1386                 goto cleanup;
1387         }
1388
1389         /* Create and register the windows */
1390         msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name, FALSE);
1391         mgr = modest_runtime_get_window_mgr ();
1392         modest_window_mgr_register_window (mgr, msg_win);
1393
1394         if (rf_helper->parent_window != NULL) {
1395                 gdouble parent_zoom;
1396
1397                 parent_zoom = modest_window_get_zoom (MODEST_WINDOW (rf_helper->parent_window));
1398                 modest_window_set_zoom (msg_win, parent_zoom);
1399         }
1400
1401         /* Show edit window */
1402         gtk_widget_show_all (GTK_WIDGET (msg_win));
1403
1404 cleanup:
1405         if (msg_win)
1406                 g_object_unref (msg_win);
1407         if (new_msg)
1408                 g_object_unref (G_OBJECT (new_msg));
1409         if (account)
1410                 g_object_unref (G_OBJECT (account));
1411 /*      g_object_unref (msg); */
1412         free_reply_forward_helper (rf_helper);
1413 }
1414
1415 /* Checks a list of headers. If any of them are not currently
1416  * downloaded (CACHED) then returns TRUE else returns FALSE.
1417  */
1418 static gint
1419 header_list_count_uncached_msgs (TnyList *header_list)
1420 {
1421         TnyIterator *iter;
1422         gint uncached_messages = 0;
1423
1424         iter = tny_list_create_iterator (header_list);
1425         while (!tny_iterator_is_done (iter)) {
1426                 TnyHeader *header;
1427
1428                 header = TNY_HEADER (tny_iterator_get_current (iter));
1429                 if (header) {
1430                         if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED))
1431                                 uncached_messages ++;
1432                         g_object_unref (header);
1433                 }
1434
1435                 tny_iterator_next (iter);
1436         }
1437         g_object_unref (iter);
1438
1439         return uncached_messages;
1440 }
1441
1442 /* Returns FALSE if the user does not want to download the
1443  * messages. Returns TRUE if the user allowed the download.
1444  */
1445 static gboolean
1446 connect_to_get_msg (ModestWindow *win,
1447                     gint num_of_uncached_msgs,
1448                     TnyAccount *account)
1449 {
1450         GtkResponseType response;
1451
1452         /* Allways download if we are online. */
1453         if (tny_device_is_online (modest_runtime_get_device ()))
1454                 return TRUE;
1455
1456         /* If offline, then ask for user permission to download the messages */
1457         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
1458                         ngettext("mcen_nc_get_msg",
1459                         "mcen_nc_get_msgs",
1460                         num_of_uncached_msgs));
1461
1462         if (response == GTK_RESPONSE_CANCEL)
1463                 return FALSE;
1464
1465         return modest_platform_connect_and_wait((GtkWindow *) win, account);
1466 }
1467
1468 /*
1469  * Common code for the reply and forward actions
1470  */
1471 static void
1472 reply_forward (ReplyForwardAction action, ModestWindow *win)
1473 {
1474         ModestMailOperation *mail_op = NULL;
1475         TnyList *header_list = NULL;
1476         ReplyForwardHelper *rf_helper = NULL;
1477         guint reply_forward_type;
1478         gboolean continue_download = TRUE;
1479         gboolean do_retrieve = TRUE;
1480         
1481         g_return_if_fail (MODEST_IS_WINDOW(win));
1482
1483         /* we need an account when editing */
1484         if (!modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE)) {
1485                 if (!modest_ui_actions_run_account_setup_wizard (win))
1486                         return;
1487         }
1488         
1489         header_list = get_selected_headers (win);
1490         if (!header_list)
1491                 return;
1492
1493         reply_forward_type = 
1494                 modest_conf_get_int (modest_runtime_get_conf (),
1495                                      (action == ACTION_FORWARD) ? MODEST_CONF_FORWARD_TYPE : MODEST_CONF_REPLY_TYPE,
1496                                      NULL);
1497
1498         /* check if we need to download msg before asking about it */
1499         do_retrieve = (action == ACTION_FORWARD) ||
1500                         (reply_forward_type != MODEST_TNY_MSG_REPLY_TYPE_CITE);
1501
1502         if (do_retrieve){
1503                 gint num_of_unc_msgs;
1504
1505                 /* check that the messages have been previously downloaded */
1506                 num_of_unc_msgs = header_list_count_uncached_msgs(header_list);
1507                 /* If there are any uncached message ask the user
1508                  * whether he/she wants to download them. */
1509                 if (num_of_unc_msgs) {
1510                         TnyAccount *account = get_account_from_header_list (header_list);
1511                         continue_download = connect_to_get_msg (win, num_of_unc_msgs, account);
1512                         g_object_unref (account);
1513                 }
1514         }
1515
1516         if (!continue_download) {
1517                 g_object_unref (header_list);
1518                 return;
1519         }
1520         
1521         /* We assume that we can only select messages of the
1522            same folder and that we reply all of them from the
1523            same account. In fact the interface currently only
1524            allows single selection */
1525         
1526         /* Fill helpers */
1527         rf_helper = g_slice_new0 (ReplyForwardHelper);
1528         rf_helper->reply_forward_type = reply_forward_type;
1529         rf_helper->action = action;
1530         rf_helper->account_name = g_strdup (modest_window_get_active_account (win));
1531         
1532         if ((win != NULL) && (MODEST_IS_WINDOW (win)))
1533                 rf_helper->parent_window = GTK_WIDGET (win);
1534         if (!rf_helper->account_name)
1535                 rf_helper->account_name =
1536                         modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1537
1538         if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1539                 TnyMsg *msg;
1540                 TnyHeader *header;
1541                 /* Get header and message. Do not free them here, the
1542                    reply_forward_cb must do it */
1543                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
1544                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1545                 if (!msg || !header) {
1546                         if (msg)
1547                                 g_object_unref (msg);
1548                         g_printerr ("modest: no message found\n");
1549                         return;
1550                 } else {
1551                         reply_forward_cb (NULL, header, FALSE, msg, NULL, rf_helper);
1552                 }
1553                 if (header)
1554                         g_object_unref (header);
1555         } else {
1556                 TnyHeader *header;
1557                 TnyIterator *iter;
1558
1559                 /* Only reply/forward to one message */
1560                 iter = tny_list_create_iterator (header_list);
1561                 header = TNY_HEADER (tny_iterator_get_current (iter));
1562                 g_object_unref (iter);
1563
1564                 if (header) {
1565                         /* Retrieve messages */
1566                         if (do_retrieve) {
1567                                 mail_op = 
1568                                         modest_mail_operation_new_with_error_handling (G_OBJECT(win),
1569                                                                                        modest_ui_actions_get_msgs_full_error_handler, 
1570                                                                                        NULL, NULL);
1571                                 modest_mail_operation_queue_add (
1572                                         modest_runtime_get_mail_operation_queue (), mail_op);
1573                                 
1574                                 modest_mail_operation_get_msg (mail_op,
1575                                                                header,
1576                                                                reply_forward_cb,
1577                                                                rf_helper);
1578                                 /* Clean */
1579                                 g_object_unref(mail_op);
1580                         } else {
1581                                 /* we put a ref here to prevent double unref as the reply
1582                                  * forward callback unrefs the header at its end */
1583                                 reply_forward_cb (NULL, header, FALSE, NULL, NULL, rf_helper);
1584                         }
1585
1586
1587                         g_object_unref (header);
1588                 }
1589
1590         }
1591
1592         /* Free */
1593         g_object_unref (header_list);
1594 }
1595
1596 void
1597 modest_ui_actions_on_reply (GtkAction *action, ModestWindow *win)
1598 {
1599         g_return_if_fail (MODEST_IS_WINDOW(win));
1600
1601         reply_forward (ACTION_REPLY, win);
1602 }
1603
1604 void
1605 modest_ui_actions_on_forward (GtkAction *action, ModestWindow *win)
1606 {
1607         g_return_if_fail (MODEST_IS_WINDOW(win));
1608
1609         reply_forward (ACTION_FORWARD, win);
1610 }
1611
1612 void
1613 modest_ui_actions_on_reply_all (GtkAction *action, ModestWindow *win)
1614 {
1615         g_return_if_fail (MODEST_IS_WINDOW(win));
1616
1617         reply_forward (ACTION_REPLY_TO_ALL, win);
1618 }
1619
1620 void 
1621 modest_ui_actions_on_next (GtkAction *action, 
1622                            ModestWindow *window)
1623 {
1624         if (MODEST_IS_MAIN_WINDOW (window)) {
1625                 GtkWidget *header_view;
1626
1627                 header_view = modest_main_window_get_child_widget (
1628                                 MODEST_MAIN_WINDOW(window),
1629                                 MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
1630                 if (!header_view)
1631                         return;
1632         
1633                 modest_header_view_select_next (
1634                                 MODEST_HEADER_VIEW(header_view)); 
1635         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1636                 modest_msg_view_window_select_next_message (
1637                                 MODEST_MSG_VIEW_WINDOW (window));
1638         } else {
1639                 g_return_if_reached ();
1640         }
1641 }
1642
1643 void 
1644 modest_ui_actions_on_prev (GtkAction *action, 
1645                            ModestWindow *window)
1646 {
1647         g_return_if_fail (MODEST_IS_WINDOW(window));
1648
1649         if (MODEST_IS_MAIN_WINDOW (window)) {
1650                 GtkWidget *header_view;
1651                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1652                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
1653                 if (!header_view)
1654                         return;
1655                 
1656                 modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view)); 
1657         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
1658                 modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
1659         } else {
1660                 g_return_if_reached ();
1661         }
1662 }
1663
1664 void 
1665 modest_ui_actions_on_sort (GtkAction *action, 
1666                            ModestWindow *window)
1667 {
1668         g_return_if_fail (MODEST_IS_WINDOW(window));
1669
1670         if (MODEST_IS_MAIN_WINDOW (window)) {
1671                 GtkWidget *header_view;
1672                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(window),
1673                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
1674                 if (!header_view) {
1675                         modest_platform_information_banner (NULL, NULL, _CS("ckdg_ib_nothing_to_sort"));
1676
1677                         return;
1678                 }
1679
1680                 /* Show sorting dialog */
1681                 modest_platform_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);     
1682         }
1683 }
1684
1685 static void
1686 new_messages_arrived (ModestMailOperation *self, 
1687                       TnyList *new_headers,
1688                       gpointer user_data)
1689 {
1690         GObject *source;
1691         gboolean show_visual_notifications;
1692
1693         source = modest_mail_operation_get_source (self);
1694         show_visual_notifications = (source) ? FALSE : TRUE;
1695         if (source)
1696                 g_object_unref (source);
1697
1698         /* Notify new messages have been downloaded. If the
1699            send&receive was invoked by the user then do not show any
1700            visual notification, only play a sound and activate the LED
1701            (for the Maemo version) */
1702         if (TNY_IS_LIST(new_headers) && (tny_list_get_length (new_headers)) > 0)
1703                 modest_platform_on_new_headers_received (new_headers, 
1704                                                          show_visual_notifications);
1705
1706 }
1707
1708 gboolean
1709 retrieve_all_messages_cb (GObject *source,
1710                           guint num_msgs,
1711                           guint retrieve_limit)
1712 {
1713         GtkWindow *window;
1714         gchar *msg;
1715         gint response;
1716
1717         window = GTK_WINDOW (source);
1718         msg = g_strdup_printf (_("mail_nc_msg_count_limit_exceeded"), 
1719                                num_msgs, retrieve_limit);
1720
1721         /* Ask the user if they want to retrieve all the messages */
1722         response = 
1723                 modest_platform_run_confirmation_dialog_with_buttons (window, msg,
1724                                                                       _("mcen_bd_get_all"),
1725                                                                       _("mcen_bd_newest_only"));
1726         /* Free and return */
1727         g_free (msg);
1728         return (response == GTK_RESPONSE_ACCEPT) ? TRUE : FALSE;
1729 }
1730
1731 typedef struct {
1732         TnyAccount *account;
1733         ModestWindow *win;
1734         gchar *account_name;
1735 } SendReceiveInfo;
1736
1737 static void
1738 do_send_receive_performer (gboolean canceled, 
1739                            GError *err,
1740                            GtkWindow *parent_window, 
1741                            TnyAccount *account, 
1742                            gpointer user_data)
1743 {
1744         ModestMailOperation *mail_op;
1745         SendReceiveInfo *info;
1746
1747         info = (SendReceiveInfo *) user_data;
1748
1749         if (err || canceled) {
1750                 goto clean;
1751         }
1752
1753         /* Set send/receive operation in progress */    
1754         if (info->win && MODEST_IS_MAIN_WINDOW (info->win)) {
1755                 modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW (info->win));
1756         }
1757         
1758         mail_op = modest_mail_operation_new_with_error_handling ((info->win) ? G_OBJECT (info->win) : NULL,
1759                                                                  modest_ui_actions_send_receive_error_handler,
1760                                                                  NULL, NULL);
1761
1762         if (info->win && MODEST_IS_MAIN_WINDOW (info->win))
1763                 g_signal_connect (G_OBJECT(mail_op), "operation-finished", 
1764                                   G_CALLBACK (on_send_receive_finished), 
1765                                   info->win);
1766
1767         /* Send & receive. */
1768         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
1769         modest_mail_operation_update_account (mail_op, info->account_name, (info->win) ? FALSE : TRUE,
1770                                               (info->win) ? retrieve_all_messages_cb : NULL, 
1771                                               new_messages_arrived, info->win);
1772         g_object_unref (G_OBJECT (mail_op));
1773         
1774  clean:
1775         /* Frees */
1776         if (info->account_name)
1777                 g_free (info->account_name);
1778         if (info->win)
1779                 g_object_unref (info->win);
1780         if (info->account)
1781                 g_object_unref (info->account);
1782         g_slice_free (SendReceiveInfo, info);
1783 }
1784
1785 /*
1786  * This function performs the send & receive required actions. The
1787  * window is used to create the mail operation. Typically it should
1788  * always be the main window, but we pass it as argument in order to
1789  * be more flexible.
1790  */
1791 void
1792 modest_ui_actions_do_send_receive (const gchar *account_name, 
1793                                    gboolean force_connection,
1794                                    ModestWindow *win)
1795 {
1796         gchar *acc_name = NULL;
1797         SendReceiveInfo *info;
1798         ModestTnyAccountStore *acc_store;
1799
1800         /* If no account name was provided then get the current account, and if
1801            there is no current account then pick the default one: */
1802         if (!account_name) {
1803                 if (win)
1804                         acc_name = g_strdup (modest_window_get_active_account (win));
1805                 if (!acc_name)
1806                         acc_name  = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
1807                 if (!acc_name) {
1808                         g_printerr ("modest: cannot get default account\n");
1809                         return;
1810                 }
1811         } else {
1812                 acc_name = g_strdup (account_name);
1813         }
1814
1815         acc_store = modest_runtime_get_account_store ();
1816
1817         /* Create the info for the connect and perform */
1818         info = g_slice_new (SendReceiveInfo);
1819         info->account_name = acc_name;
1820         info->win = (win) ? g_object_ref (win) : NULL;
1821         info->account = modest_tny_account_store_get_server_account (acc_store, acc_name,
1822                                                                      TNY_ACCOUNT_TYPE_STORE);
1823
1824         /* Invoke the connect and perform */
1825         modest_platform_connect_and_perform ((win) ? GTK_WINDOW (win) : NULL, 
1826                                              force_connection, info->account, 
1827                                              do_send_receive_performer, info);
1828 }
1829
1830
1831 static void
1832 modest_ui_actions_do_cancel_send (const gchar *account_name,  
1833                                   ModestWindow *win)
1834 {
1835         TnyTransportAccount *transport_account;
1836         TnySendQueue *send_queue = NULL;
1837         GError *error = NULL;
1838
1839         /* Get transport account */
1840         transport_account =
1841                 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
1842                                       (modest_runtime_get_account_store(),
1843                                        account_name,
1844                                        TNY_ACCOUNT_TYPE_TRANSPORT));
1845         if (!transport_account) {
1846                 g_printerr ("modest: no transport account found for '%s'\n", account_name);
1847                 goto frees;
1848         }
1849
1850         /* Get send queue*/
1851         send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
1852         if (!TNY_IS_SEND_QUEUE(send_queue)) {
1853                 g_set_error (&error, MODEST_MAIL_OPERATION_ERROR,
1854                              MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
1855                              "modest: could not find send queue for account\n");
1856         } else {
1857                 /* Cancel the current send */
1858                 tny_account_cancel (TNY_ACCOUNT (transport_account));
1859
1860                 /* Suspend all pending messages */
1861                 tny_send_queue_cancel (send_queue, TNY_SEND_QUEUE_CANCEL_ACTION_SUSPEND, &error);
1862         }
1863
1864  frees:
1865         if (transport_account != NULL) 
1866                 g_object_unref (G_OBJECT (transport_account));
1867 }
1868
1869 static void
1870 modest_ui_actions_cancel_send_all (ModestWindow *win) 
1871 {
1872         GSList *account_names, *iter;
1873
1874         account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(), 
1875                                                           TRUE);
1876
1877         iter = account_names;
1878         while (iter) {                  
1879                 modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
1880                 iter = g_slist_next (iter);
1881         }
1882
1883         modest_account_mgr_free_account_names (account_names);
1884         account_names = NULL;
1885 }
1886
1887 void
1888 modest_ui_actions_cancel_send (GtkAction *action,  ModestWindow *win)
1889
1890 {
1891         /* Check if accounts exist */
1892         gboolean accounts_exist = 
1893                 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1894         
1895         /* If not, allow the user to create an account before trying to send/receive. */
1896         if (!accounts_exist)
1897                 modest_ui_actions_on_accounts (NULL, win);
1898         
1899         /* Cancel all sending operaitons */     
1900         modest_ui_actions_cancel_send_all (win);
1901 }
1902
1903 /*
1904  * Refreshes all accounts. This function will be used by automatic
1905  * updates
1906  */
1907 void
1908 modest_ui_actions_do_send_receive_all (ModestWindow *win, 
1909                                        gboolean force_connection)
1910 {
1911         GSList *account_names, *iter;
1912
1913         account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(), 
1914                                                           TRUE);
1915
1916         iter = account_names;
1917         while (iter) {                  
1918                 modest_ui_actions_do_send_receive ((const char*) iter->data, force_connection, win);
1919                 iter = g_slist_next (iter);
1920         }
1921
1922         modest_account_mgr_free_account_names (account_names);
1923         account_names = NULL;
1924 }
1925
1926 /*
1927  * Handler of the click on Send&Receive button in the main toolbar
1928  */
1929 void
1930 modest_ui_actions_on_send_receive (GtkAction *action, ModestWindow *win)
1931 {
1932         /* Check if accounts exist */
1933         gboolean accounts_exist;
1934
1935         accounts_exist =
1936                 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
1937         
1938         /* If not, allow the user to create an account before trying to send/receive. */
1939         if (!accounts_exist)
1940                 modest_ui_actions_on_accounts (NULL, win);
1941         
1942         /* Refresh the current folder. The if is always TRUE it's just an extra check */
1943         if (MODEST_IS_MAIN_WINDOW (win)) {
1944                 GtkWidget *folder_view;
1945                 TnyFolderStore *folder_store;
1946
1947                 folder_view = 
1948                         modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win), 
1949                                                              MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
1950                 if (!folder_view)
1951                         return;
1952                 
1953                 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
1954         
1955                 if (folder_store)
1956                         g_object_unref (folder_store);
1957         }       
1958         
1959         /* Refresh the active account. Force the connection if needed */
1960         modest_ui_actions_do_send_receive (NULL, TRUE, win);
1961 }
1962
1963
1964 void
1965 modest_ui_actions_toggle_header_list_view (GtkAction *action, ModestMainWindow *main_window)
1966 {
1967         ModestConf *conf;
1968         GtkWidget *header_view;
1969         
1970         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
1971
1972         header_view = modest_main_window_get_child_widget (main_window,
1973                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
1974         if (!header_view)
1975                 return;
1976
1977         conf = modest_runtime_get_conf ();
1978         
1979         /* what is saved/restored is depending on the style; thus; we save with
1980          * old style, then update the style, and restore for this new style
1981          */
1982         modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
1983         
1984         if (modest_header_view_get_style
1985             (MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
1986                 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1987                                               MODEST_HEADER_VIEW_STYLE_TWOLINES);
1988         else
1989                 modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
1990                                               MODEST_HEADER_VIEW_STYLE_DETAILS);
1991
1992         modest_widget_memory_restore (conf, G_OBJECT(header_view),
1993                                       MODEST_CONF_HEADER_VIEW_KEY);
1994 }
1995
1996
1997 void 
1998 modest_ui_actions_on_header_selected (ModestHeaderView *header_view, 
1999                                       TnyHeader *header,
2000                                       ModestMainWindow *main_window)
2001 {
2002         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2003         g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
2004         
2005         /* in the case the folder is empty, show the empty folder message and focus
2006          * folder view */
2007         if (!header && gtk_widget_is_focus (GTK_WIDGET (header_view))) {
2008                 if (modest_header_view_is_empty (header_view)) {
2009                         TnyFolder *folder = modest_header_view_get_folder (header_view);
2010                         GtkWidget *folder_view = 
2011                                 modest_main_window_get_child_widget (main_window,
2012                                                                      MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2013                         if (folder != NULL) 
2014                                 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view), folder, FALSE);
2015                         gtk_widget_grab_focus (GTK_WIDGET (folder_view));
2016                         return;
2017                 }
2018         }
2019         /* If no header has been selected then exit */
2020         if (!header)
2021                 return;
2022
2023         /* Update focus */
2024         if (!gtk_widget_is_focus (GTK_WIDGET(header_view)))
2025             gtk_widget_grab_focus (GTK_WIDGET(header_view));
2026
2027         /* Update toolbar dimming state */
2028         modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
2029         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2030 }
2031
2032 void
2033 modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
2034                                        TnyHeader *header,
2035                                        ModestMainWindow *main_window)
2036 {
2037         TnyList *headers;
2038
2039         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2040
2041         if (!header)
2042                 return;
2043
2044         if (modest_header_view_count_selected_headers (header_view) > 1) {
2045                 modest_platform_information_banner (NULL, NULL, _("mcen_ib_select_one_message"));
2046                 return;
2047         }
2048
2049
2050 /*      headers = tny_simple_list_new (); */
2051 /*      tny_list_prepend (headers, G_OBJECT (header)); */
2052         headers = modest_header_view_get_selected_headers (header_view);
2053
2054         open_msgs_from_headers (headers, MODEST_WINDOW (main_window));
2055
2056         g_object_unref (headers);
2057 }
2058
2059 static void
2060 set_active_account_from_tny_account (TnyAccount *account,
2061                                      ModestWindow *window)
2062 {
2063         const gchar *server_acc_name = tny_account_get_id (account);
2064         
2065         /* We need the TnyAccount provided by the
2066            account store because that is the one that
2067            knows the name of the Modest account */
2068         TnyAccount *modest_server_account = modest_server_account = 
2069                 modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
2070                                                              MODEST_TNY_ACCOUNT_STORE_QUERY_ID, 
2071                                                              server_acc_name);
2072         if (!modest_server_account) {
2073                 g_warning ("%s: could not get tny account\n", __FUNCTION__);
2074                 return;
2075         }
2076
2077         /* Update active account, but only if it's not a pseudo-account */
2078         if ((!modest_tny_account_is_virtual_local_folders(modest_server_account)) &&
2079             (!modest_tny_account_is_memory_card_account(modest_server_account))) {
2080                 const gchar *modest_acc_name = 
2081                         modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
2082                 if (modest_acc_name)
2083                         modest_window_set_active_account (window, modest_acc_name);
2084         }
2085         
2086         g_object_unref (modest_server_account);
2087 }
2088
2089
2090 static void
2091 folder_refreshed_cb (ModestMailOperation *mail_op, 
2092                      TnyFolder *folder, 
2093                      gpointer user_data)
2094 {
2095         ModestMainWindow *win = NULL;
2096         GtkWidget *header_view;
2097
2098         g_return_if_fail (TNY_IS_FOLDER (folder));
2099
2100         win = MODEST_MAIN_WINDOW (user_data);
2101         header_view = 
2102                 modest_main_window_get_child_widget(win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2103
2104         if (header_view) {
2105                 TnyFolder *current_folder;
2106
2107                 current_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
2108                 if (current_folder != NULL && folder != current_folder) {
2109                         g_object_unref (current_folder);
2110                         return;
2111                 } else if (current_folder)
2112                         g_object_unref (current_folder);
2113         }
2114
2115         /* Check if folder is empty and set headers view contents style */
2116         if (tny_folder_get_all_count (folder) == 0)
2117                 modest_main_window_set_contents_style (win,
2118                                                        MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
2119 }
2120
2121 void 
2122 modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
2123                                                TnyFolderStore *folder_store, 
2124                                                gboolean selected,
2125                                                ModestMainWindow *main_window)
2126 {
2127         ModestConf *conf;
2128         GtkWidget *header_view;
2129
2130         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2131
2132         header_view = modest_main_window_get_child_widget(main_window,
2133                                                           MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2134         if (!header_view)
2135                 return;
2136         
2137         conf = modest_runtime_get_conf ();
2138
2139         if (TNY_IS_ACCOUNT (folder_store)) {
2140                 if (selected) {
2141                         set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
2142                         
2143                         /* Show account details */
2144                         modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
2145                 }
2146         } else {
2147                 if (TNY_IS_FOLDER (folder_store) && selected) {
2148                         
2149                         /* Update the active account */
2150                         TnyAccount *account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
2151                         if (account) {
2152                                 set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
2153                                 g_object_unref (account);
2154                                 account = NULL;
2155                         }
2156
2157                         /* Set the header style by default, it could
2158                            be changed later by the refresh callback to
2159                            empty */
2160                         modest_main_window_set_contents_style (main_window, 
2161                                                                MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
2162
2163                         /* Set folder on header view. This function
2164                            will call tny_folder_refresh_async so we
2165                            pass a callback that will be called when
2166                            finished. We use that callback to set the
2167                            empty view if there are no messages */
2168                         modest_header_view_set_folder (MODEST_HEADER_VIEW(header_view),
2169                                                        TNY_FOLDER (folder_store),
2170                                                        folder_refreshed_cb,
2171                                                        main_window);
2172                         
2173                         /* Restore configuration. We need to do this
2174                            *after* the set_folder because the widget
2175                            memory asks the header view about its
2176                            folder  */
2177                         modest_widget_memory_restore (modest_runtime_get_conf (), 
2178                                                       G_OBJECT(header_view),
2179                                                       MODEST_CONF_HEADER_VIEW_KEY);
2180                 } else {
2181                         /* Update the active account */
2182                         //modest_window_set_active_account (MODEST_WINDOW (main_window), NULL);
2183                         /* Save only if we're seeing headers */
2184                         if (modest_main_window_get_contents_style (main_window) ==
2185                             MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
2186                                 modest_widget_memory_save (conf, G_OBJECT (header_view), 
2187                                                            MODEST_CONF_HEADER_VIEW_KEY);
2188                         modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
2189                 }
2190         }
2191
2192         /* Update toolbar dimming state */
2193         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2194 }
2195
2196 void 
2197 modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
2198                                      ModestWindow *win)
2199 {
2200         GtkWidget *dialog;
2201         gchar *txt, *item;
2202         gboolean online;
2203
2204         item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
2205         
2206         online = tny_device_is_online (modest_runtime_get_device());
2207
2208         if (online) {
2209                 /* already online -- the item is simply not there... */
2210                 dialog = gtk_message_dialog_new (GTK_WINDOW (win),
2211                                                  GTK_DIALOG_MODAL,
2212                                                  GTK_MESSAGE_WARNING,
2213                                                  GTK_BUTTONS_NONE,
2214                                                  _("The %s you selected cannot be found"),
2215                                                  item);
2216                 gtk_dialog_add_button (GTK_DIALOG (dialog),_("mcen_bd_dialog_ok"), GTK_RESPONSE_ACCEPT);
2217                 gtk_dialog_run (GTK_DIALOG(dialog));
2218         } else {
2219                 dialog = gtk_dialog_new_with_buttons (_("Connection requested"),
2220                                                       GTK_WINDOW (win),
2221                                                       GTK_DIALOG_MODAL,
2222                                                       _("mcen_bd_dialog_cancel"),
2223                                                       GTK_RESPONSE_REJECT,
2224                                                       _("mcen_bd_dialog_ok"),
2225                                                       GTK_RESPONSE_ACCEPT,
2226                                                       NULL);
2227                 txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
2228                                          "Do you want to get online?"), item);
2229                 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), 
2230                                     gtk_label_new (txt), FALSE, FALSE, 0);
2231                 gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
2232                 g_free (txt);
2233
2234                 gtk_window_set_default_size (GTK_WINDOW(dialog), 300, 300);
2235                 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2236                         /* TODO: Comment about why is this commented out: */
2237                         /* modest_platform_connect_and_wait (); */
2238                 }
2239         }
2240         gtk_widget_destroy (dialog);
2241 }
2242
2243 void
2244 modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
2245                                      ModestWindow *win)
2246 {
2247         /* g_message ("%s %s", __FUNCTION__, link); */
2248 }       
2249
2250
2251 void
2252 modest_ui_actions_on_msg_link_clicked (ModestMsgView *msgview, const gchar* link,
2253                                         ModestWindow *win)
2254 {
2255         modest_platform_activate_uri (link);
2256 }
2257
2258 void
2259 modest_ui_actions_on_msg_link_contextual (ModestMsgView *msgview, const gchar* link,
2260                                           ModestWindow *win)
2261 {
2262         modest_platform_show_uri_popup (link);
2263 }
2264
2265 void
2266 modest_ui_actions_on_msg_attachment_clicked (ModestMsgView *msgview, TnyMimePart *mime_part,
2267                                              ModestWindow *win)
2268 {
2269         modest_msg_view_window_view_attachment (MODEST_MSG_VIEW_WINDOW (win), mime_part);
2270 }
2271
2272 void
2273 modest_ui_actions_on_msg_recpt_activated (ModestMsgView *msgview,
2274                                           const gchar *address,
2275                                           ModestWindow *win)
2276 {
2277         /* g_message ("%s %s", __FUNCTION__, address); */
2278 }
2279
2280 static void
2281 on_save_to_drafts_cb (ModestMailOperation *mail_op, 
2282                       TnyMsg *saved_draft,
2283                       gpointer user_data)
2284 {
2285         ModestMsgEditWindow *edit_window;
2286         ModestMainWindow *win;
2287
2288         /* FIXME. Make the header view sensitive again. This is a
2289          * temporary hack. See modest_ui_actions_on_save_to_drafts()
2290          * for details */
2291         win = MODEST_MAIN_WINDOW(modest_window_mgr_get_main_window(
2292                                          modest_runtime_get_window_mgr(), FALSE));
2293         if (win != NULL) {
2294                 GtkWidget *hdrview = modest_main_window_get_child_widget(
2295                         win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2296                 if (hdrview) gtk_widget_set_sensitive(hdrview, TRUE);
2297         }
2298
2299         edit_window = MODEST_MSG_EDIT_WINDOW (user_data);
2300
2301         /* It might not be a good idea to do nothing if there was an error,
2302          * so let's at least show a generic error banner. */
2303         /* TODO error while saving attachment, show "Saving draft failed" banner */
2304         if (modest_mail_operation_get_error (mail_op) != NULL) {
2305                 g_warning ("%s failed: %s\n", __FUNCTION__, (modest_mail_operation_get_error (mail_op))->message);
2306                 modest_platform_information_banner (NULL, NULL, _("mail_ib_file_operation_failed"));
2307         } else {
2308                 modest_msg_edit_window_set_draft (edit_window, saved_draft);
2309         }
2310         g_object_unref(edit_window);
2311 }
2312
2313 gboolean
2314 modest_ui_actions_on_save_to_drafts (GtkWidget *widget, ModestMsgEditWindow *edit_window)
2315 {
2316         TnyTransportAccount *transport_account;
2317         ModestMailOperation *mail_operation;
2318         MsgData *data;
2319         gchar *account_name, *from;
2320         ModestAccountMgr *account_mgr;
2321 /*      char *info_text; */
2322         gboolean had_error = FALSE;
2323         guint64 available_disk, expected_size;
2324         gint parts_count;
2325         guint64 parts_size;
2326         ModestMainWindow *win;
2327
2328         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), FALSE);
2329         
2330         data = modest_msg_edit_window_get_msg_data (edit_window);
2331
2332         /* Check size */
2333         available_disk = modest_folder_available_space (NULL);
2334         modest_msg_edit_window_get_parts_size (edit_window, &parts_count, &parts_size);
2335         expected_size = modest_tny_msg_estimate_size (data->plain_body,
2336                                                  data->html_body,
2337                                                  parts_count,
2338                                                  parts_size);
2339
2340         if ((available_disk != -1) && expected_size > available_disk) {
2341                 modest_msg_edit_window_free_msg_data (edit_window, data);
2342
2343                 modest_platform_information_banner (NULL, NULL, dgettext("ke-recv", "cerm_device_memory_full"));
2344                 return FALSE;
2345         }
2346
2347         account_name = g_strdup (data->account_name);
2348         account_mgr = modest_runtime_get_account_mgr();
2349         if (!account_name)
2350                 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
2351         if (!account_name) 
2352                 account_name = modest_account_mgr_get_default_account (account_mgr);
2353         if (!account_name) {
2354                 g_printerr ("modest: no account found\n");
2355                 modest_msg_edit_window_free_msg_data (edit_window, data);
2356                 return FALSE;
2357         }
2358
2359         if (!strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
2360                 account_name = g_strdup (data->account_name);
2361         }
2362
2363         transport_account =
2364                 TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
2365                                       (modest_runtime_get_account_store(),
2366                                        account_name,
2367                                        TNY_ACCOUNT_TYPE_TRANSPORT));
2368         if (!transport_account) {
2369                 g_printerr ("modest: no transport account found for '%s'\n", account_name);
2370                 g_free (account_name);
2371                 modest_msg_edit_window_free_msg_data (edit_window, data);
2372                 return FALSE;
2373         }
2374         from = modest_account_mgr_get_from_string (account_mgr, account_name);
2375
2376         /* Create the mail operation */         
2377         mail_operation = modest_mail_operation_new (NULL);
2378         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
2379
2380         modest_mail_operation_save_to_drafts (mail_operation,
2381                                               transport_account,
2382                                               data->draft_msg,
2383                                               from,
2384                                               data->to, 
2385                                               data->cc, 
2386                                               data->bcc,
2387                                               data->subject, 
2388                                               data->plain_body, 
2389                                               data->html_body,
2390                                               data->attachments,
2391                                               data->images,
2392                                               data->priority_flags,
2393                                               on_save_to_drafts_cb,
2394                                               g_object_ref(edit_window));
2395
2396         /* Use the main window as the parent of the banner, if the
2397            main window does not exist it won't be shown, if the parent
2398            window exists then it's properly shown. We don't use the
2399            editor window because it could be closed (save to drafts
2400            could happen after closing the window */
2401         win = (ModestMainWindow *)
2402                 modest_window_mgr_get_main_window( modest_runtime_get_window_mgr(), FALSE);
2403         if (win) {
2404                 gchar *text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
2405                 modest_platform_information_banner (GTK_WIDGET (win), NULL, text);
2406                 g_free (text);
2407         }
2408         modest_msg_edit_window_set_modified (edit_window, FALSE);
2409
2410         /* Frees */
2411         g_free (from);
2412         g_free (account_name);
2413         g_object_unref (G_OBJECT (transport_account));
2414         g_object_unref (G_OBJECT (mail_operation));
2415
2416         modest_msg_edit_window_free_msg_data (edit_window, data);
2417
2418         /* ** FIXME **
2419          * If the drafts folder is selected then make the header view
2420          * insensitive while the message is being saved to drafts
2421          * (it'll be sensitive again in on_save_to_drafts_cb()). This
2422          * is not very clean but it avoids letting the drafts folder
2423          * in an inconsistent state: the user could edit the message
2424          * being saved and undesirable things would happen.
2425          * In the average case the user won't notice anything at
2426          * all. In the worst case (the user is editing a really big
2427          * file from Drafts) the header view will be insensitive
2428          * during the saving process (10 or 20 seconds, depending on
2429          * the message). Anyway this is just a quick workaround: once
2430          * we find a better solution it should be removed
2431          * See NB#65125 (commend #18) for details.
2432          */
2433         if (!had_error && win != NULL) {
2434                 ModestFolderView *view = MODEST_FOLDER_VIEW(modest_main_window_get_child_widget(
2435                         win, MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW));
2436                 if (view != NULL) {
2437                         TnyFolder *folder = TNY_FOLDER(modest_folder_view_get_selected(view));
2438                         if (folder) {
2439                                 if (modest_tny_folder_is_local_folder(folder)) {
2440                                         TnyFolderType folder_type;
2441                                         folder_type = modest_tny_folder_get_local_or_mmc_folder_type(folder);
2442                                         if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
2443                                                 GtkWidget *hdrview = modest_main_window_get_child_widget(
2444                                                         win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2445                                                 if (hdrview) gtk_widget_set_sensitive(hdrview, FALSE);
2446                                         }
2447                                 }
2448                         }
2449                         if (folder != NULL) g_object_unref(folder);
2450                 }
2451         }
2452
2453         return !had_error;
2454 }
2455
2456 /* For instance, when clicking the Send toolbar button when editing a message: */
2457 gboolean
2458 modest_ui_actions_on_send (GtkWidget *widget, ModestMsgEditWindow *edit_window)
2459 {
2460         TnyTransportAccount *transport_account = NULL;
2461         gboolean had_error = FALSE;
2462         guint64 available_disk, expected_size;
2463         gint parts_count;
2464         guint64 parts_size;
2465
2466         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), TRUE);
2467
2468         if (!modest_msg_edit_window_check_names (edit_window, TRUE))
2469                 return TRUE;
2470         
2471         MsgData *data = modest_msg_edit_window_get_msg_data (edit_window);
2472
2473         /* Check size */
2474         available_disk = modest_folder_available_space (NULL);
2475         modest_msg_edit_window_get_parts_size (edit_window, &parts_count, &parts_size);
2476         expected_size = modest_tny_msg_estimate_size (data->plain_body,
2477                                                  data->html_body,
2478                                                  parts_count,
2479                                                  parts_size);
2480
2481         if ((available_disk != -1) && expected_size > available_disk) {
2482                 modest_msg_edit_window_free_msg_data (edit_window, data);
2483
2484                 modest_platform_information_banner (NULL, NULL, dgettext("ke-recv", "cerm_device_memory_full"));
2485                 return FALSE;
2486         }
2487
2488         ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
2489         gchar *account_name = g_strdup (data->account_name);
2490         if (!account_name)
2491                 account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
2492
2493         if (!account_name) 
2494                 account_name = modest_account_mgr_get_default_account (account_mgr);
2495                 
2496         if (!account_name) {
2497                 modest_msg_edit_window_free_msg_data (edit_window, data);
2498                 /* Run account setup wizard */
2499                 if (!modest_ui_actions_run_account_setup_wizard (MODEST_WINDOW(edit_window))) {
2500                         return TRUE;
2501                 }
2502         }
2503         
2504         /* Get the currently-active transport account for this modest account: */
2505         if (strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID) != 0) {
2506                 transport_account = TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
2507                                                           (modest_runtime_get_account_store(),
2508                                                            account_name, TNY_ACCOUNT_TYPE_TRANSPORT));
2509         }
2510         
2511         if (!transport_account) {
2512                 modest_msg_edit_window_free_msg_data (edit_window, data);
2513                 /* Run account setup wizard */
2514                 if (!modest_ui_actions_run_account_setup_wizard(MODEST_WINDOW(edit_window)))
2515                         return TRUE;
2516         }
2517         
2518         gchar *from = modest_account_mgr_get_from_string (account_mgr, account_name);
2519
2520         /* Create the mail operation */
2521         ModestMailOperation *mail_operation = modest_mail_operation_new (NULL);
2522         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
2523
2524         modest_mail_operation_send_new_mail (mail_operation,
2525                                              transport_account,
2526                                              data->draft_msg,
2527                                              from,
2528                                              data->to, 
2529                                              data->cc, 
2530                                              data->bcc,
2531                                              data->subject, 
2532                                              data->plain_body, 
2533                                              data->html_body,
2534                                              data->attachments,
2535                                              data->images,
2536                                              data->priority_flags);
2537
2538         if (modest_mail_operation_get_status (mail_operation) == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
2539                 modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
2540
2541
2542         if (modest_mail_operation_get_error (mail_operation) != NULL) {
2543                 const GError *error = modest_mail_operation_get_error (mail_operation);
2544                 if (error->code == MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED) {
2545                         g_warning ("%s failed: %s\n", __FUNCTION__, (modest_mail_operation_get_error (mail_operation))->message);
2546                         modest_platform_information_banner (NULL, NULL, _CS("sfil_ni_not_enough_memory"));
2547                         had_error = TRUE;
2548                 }
2549         }
2550                                              
2551         /* Free data: */
2552         g_free (from);
2553         g_free (account_name);
2554         g_object_unref (G_OBJECT (transport_account));
2555         g_object_unref (G_OBJECT (mail_operation));
2556
2557         modest_msg_edit_window_free_msg_data (edit_window, data);
2558
2559         if (!had_error) {
2560                 modest_msg_edit_window_set_sent (edit_window, TRUE);
2561
2562                 /* Save settings and close the window: */
2563                 modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (edit_window));
2564         }
2565
2566         return !had_error;
2567 }
2568
2569 void 
2570 modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
2571                                   ModestMsgEditWindow *window)
2572 {
2573         ModestMsgEditFormatState *format_state = NULL;
2574
2575         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2576         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2577
2578         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2579                 return;
2580
2581         format_state = modest_msg_edit_window_get_format_state (window);
2582         g_return_if_fail (format_state != NULL);
2583
2584         format_state->bold = gtk_toggle_action_get_active (action);
2585         modest_msg_edit_window_set_format_state (window, format_state);
2586         g_free (format_state);
2587         
2588 }
2589
2590 void 
2591 modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
2592                                      ModestMsgEditWindow *window)
2593 {
2594         ModestMsgEditFormatState *format_state = NULL;
2595
2596         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2597         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2598
2599         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2600                 return;
2601
2602         format_state = modest_msg_edit_window_get_format_state (window);
2603         g_return_if_fail (format_state != NULL);
2604
2605         format_state->italics = gtk_toggle_action_get_active (action);
2606         modest_msg_edit_window_set_format_state (window, format_state);
2607         g_free (format_state);
2608         
2609 }
2610
2611 void 
2612 modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
2613                                      ModestMsgEditWindow *window)
2614 {
2615         ModestMsgEditFormatState *format_state = NULL;
2616
2617         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2618         g_return_if_fail (GTK_IS_TOGGLE_ACTION (action));
2619
2620         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2621                 return;
2622
2623         format_state = modest_msg_edit_window_get_format_state (window);
2624         g_return_if_fail (format_state != NULL);
2625
2626         format_state->bullet = gtk_toggle_action_get_active (action);
2627         modest_msg_edit_window_set_format_state (window, format_state);
2628         g_free (format_state);
2629         
2630 }
2631
2632 void 
2633 modest_ui_actions_on_change_justify (GtkRadioAction *action,
2634                                      GtkRadioAction *selected,
2635                                      ModestMsgEditWindow *window)
2636 {
2637         ModestMsgEditFormatState *format_state = NULL;
2638         GtkJustification value;
2639
2640         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2641
2642         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2643                 return;
2644
2645         value = gtk_radio_action_get_current_value (selected);
2646
2647         format_state = modest_msg_edit_window_get_format_state (window);
2648         g_return_if_fail (format_state != NULL);
2649
2650         format_state->justification = value;
2651         modest_msg_edit_window_set_format_state (window, format_state);
2652         g_free (format_state);
2653 }
2654
2655 void 
2656 modest_ui_actions_on_select_editor_color (GtkAction *action,
2657                                           ModestMsgEditWindow *window)
2658 {
2659         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2660         g_return_if_fail (GTK_IS_ACTION (action));
2661
2662         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2663                 return;
2664
2665         modest_msg_edit_window_select_color (window);
2666 }
2667
2668 void 
2669 modest_ui_actions_on_select_editor_background_color (GtkAction *action,
2670                                                      ModestMsgEditWindow *window)
2671 {
2672         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2673         g_return_if_fail (GTK_IS_ACTION (action));
2674
2675         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2676                 return;
2677
2678         modest_msg_edit_window_select_background_color (window);
2679 }
2680
2681 void 
2682 modest_ui_actions_on_insert_image (GtkAction *action,
2683                                    ModestMsgEditWindow *window)
2684 {
2685         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2686         g_return_if_fail (GTK_IS_ACTION (action));
2687
2688         if (modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW(window)) == MODEST_MSG_EDIT_FORMAT_TEXT)
2689                 return;
2690
2691         modest_msg_edit_window_insert_image (window);
2692 }
2693
2694 void 
2695 modest_ui_actions_on_attach_file (GtkAction *action,
2696                                   ModestMsgEditWindow *window)
2697 {
2698         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2699         g_return_if_fail (GTK_IS_ACTION (action));
2700
2701         modest_msg_edit_window_offer_attach_file (window);
2702 }
2703
2704 void 
2705 modest_ui_actions_on_remove_attachments (GtkAction *action,
2706                                          ModestMsgEditWindow *window)
2707 {
2708         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
2709         g_return_if_fail (GTK_IS_ACTION (action));
2710
2711         modest_msg_edit_window_remove_attachments (window, NULL);
2712 }
2713
2714 static void
2715 do_create_folder_cb (ModestMailOperation *mail_op,
2716                      TnyFolderStore *parent_folder, 
2717                      TnyFolder *new_folder,
2718                      gpointer user_data)
2719 {
2720         gchar *suggested_name = (gchar *) user_data;
2721         GtkWindow *source_win = (GtkWindow *) modest_mail_operation_get_source (mail_op);
2722
2723         if (modest_mail_operation_get_error (mail_op)) {
2724                 /* Show an error */
2725                 modest_platform_information_banner (GTK_WIDGET (source_win), NULL,
2726                                                     _("mail_in_ui_folder_create_error"));
2727
2728                 /* Try again */
2729                 do_create_folder (source_win, parent_folder, (const gchar *) suggested_name);
2730         } else {
2731                 /* the 'source_win' is either the ModestMainWindow, or the 'Move to folder'-dialog
2732                  * FIXME: any other? */         
2733                 GtkWidget *folder_view;
2734
2735                 if (MODEST_IS_MAIN_WINDOW(source_win)) 
2736                         folder_view = 
2737                                 modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (source_win),
2738                                                                      MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2739                 else
2740                         folder_view =
2741                                 get_folder_view_from_move_to_dialog (GTK_WIDGET(source_win));
2742                 
2743                 /* Select the newly created folder */
2744                 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
2745                                                   new_folder, FALSE);
2746                 g_object_unref (new_folder);
2747         }
2748         /* Free. Note that the first time it'll be NULL so noop */
2749         g_free (suggested_name);
2750         g_object_unref (source_win);
2751 }
2752
2753 static void
2754 do_create_folder (GtkWindow *parent_window, 
2755                   TnyFolderStore *parent_folder, 
2756                   const gchar *suggested_name)
2757 {
2758         gint result;
2759         gchar *folder_name = NULL;
2760
2761         result = modest_platform_run_new_folder_dialog (GTK_WINDOW (parent_window),
2762                                                         parent_folder,
2763                                                         (gchar *) suggested_name,
2764                                                         &folder_name);
2765         
2766         if (result == GTK_RESPONSE_ACCEPT) {
2767                 ModestMailOperation *mail_op;
2768                 
2769                 mail_op  = modest_mail_operation_new (G_OBJECT(parent_window));
2770                         
2771                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), 
2772                                                  mail_op);
2773                 modest_mail_operation_create_folder (mail_op,
2774                                                      parent_folder,
2775                                                      (const gchar *) folder_name,
2776                                                      do_create_folder_cb,
2777                                                      folder_name);
2778                 g_object_unref (mail_op);
2779         }
2780 }
2781
2782 static void
2783 create_folder_performer (gboolean canceled, 
2784                          GError *err,
2785                          GtkWindow *parent_window, 
2786                          TnyAccount *account, 
2787                          gpointer user_data)
2788 {
2789         TnyFolderStore *parent_folder = TNY_FOLDER_STORE (user_data);
2790
2791         if (canceled || err) {
2792                 goto frees;
2793         }
2794
2795         /* Run the new folder dialog */
2796         do_create_folder (GTK_WINDOW (parent_window), parent_folder, NULL);
2797
2798  frees:
2799         g_object_unref (parent_folder);
2800 }
2801
2802 static void
2803 modest_ui_actions_create_folder(GtkWidget *parent_window,
2804                                 GtkWidget *folder_view)
2805 {
2806         TnyFolderStore *parent_folder;
2807
2808         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2809         
2810         if (parent_folder) {
2811                 /* The parent folder will be freed in the callback */
2812                 modest_platform_connect_if_remote_and_perform (GTK_WINDOW (parent_window), 
2813                                                                TRUE,
2814                                                                parent_folder,
2815                                                                create_folder_performer, 
2816                                                                parent_folder);
2817         }
2818 }
2819
2820 void 
2821 modest_ui_actions_on_new_folder (GtkAction *action, ModestMainWindow *main_window)
2822 {
2823         GtkWidget *folder_view;
2824         
2825         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2826
2827         folder_view = modest_main_window_get_child_widget (main_window,
2828                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2829         if (!folder_view)
2830                 return;
2831
2832         modest_ui_actions_create_folder (GTK_WIDGET (main_window), folder_view);
2833 }
2834
2835 static void
2836 modest_ui_actions_rename_folder_error_handler (ModestMailOperation *mail_op,
2837                                                gpointer user_data)
2838 {
2839         ModestMainWindow *window = MODEST_MAIN_WINDOW (user_data);
2840         const GError *error = NULL;
2841         const gchar *message = NULL;
2842         
2843         /* Get error message */
2844         error = modest_mail_operation_get_error (mail_op);
2845         if (!error)
2846                 g_return_if_reached ();
2847
2848         switch (error->code) {
2849         case MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS:
2850                 message = _CS("ckdg_ib_folder_already_exists");
2851                 break;
2852         default:
2853                 g_warning ("%s: BUG: unexpected error:[%d]: %s", __FUNCTION__,
2854                            error->code, error->message);
2855                 return;
2856         }
2857
2858         modest_platform_information_banner (GTK_WIDGET (window), NULL, message);
2859 }
2860
2861 typedef struct {
2862         TnyFolderStore *folder;
2863         gchar *new_name;
2864 } RenameFolderInfo;
2865
2866 static void
2867 on_rename_folder_cb (ModestMailOperation *mail_op, 
2868                      TnyFolder *new_folder,
2869                      gpointer user_data)
2870 {
2871         /* Select now */
2872         modest_folder_view_select_folder (MODEST_FOLDER_VIEW (user_data),
2873                                           new_folder, FALSE);
2874 }
2875
2876 static void
2877 on_rename_folder_performer (gboolean canceled, 
2878                             GError *err, 
2879                             GtkWindow *parent_window, 
2880                             TnyAccount *account, 
2881                             gpointer user_data)
2882 {
2883         ModestMailOperation *mail_op = NULL;
2884         GtkTreeSelection *sel = NULL;
2885         GtkWidget *folder_view = NULL;
2886         RenameFolderInfo *data = (RenameFolderInfo*)user_data;
2887
2888         if (!canceled && (err == NULL) && MODEST_IS_MAIN_WINDOW(parent_window)) {
2889
2890                 folder_view = modest_main_window_get_child_widget (
2891                                 MODEST_MAIN_WINDOW (parent_window),
2892                                 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2893
2894                 mail_op = 
2895                         modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
2896                                         modest_ui_actions_rename_folder_error_handler,
2897                                         parent_window, NULL);
2898
2899                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2900                                 mail_op);
2901
2902                 /* Clear the headers view */
2903                 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
2904                 gtk_tree_selection_unselect_all (sel);
2905
2906                 /* Actually rename the folder */
2907                 modest_mail_operation_rename_folder (mail_op,
2908                                                      TNY_FOLDER (data->folder),
2909                                                      (const gchar *) (data->new_name),
2910                                                      on_rename_folder_cb,
2911                                                      folder_view);
2912         }
2913
2914         g_object_unref (mail_op);
2915         g_free (data->new_name);
2916         g_free (data);
2917 }
2918
2919 void 
2920 modest_ui_actions_on_rename_folder (GtkAction *action,
2921                                      ModestMainWindow *main_window)
2922 {
2923         TnyFolderStore *folder;
2924         GtkWidget *folder_view;
2925         GtkWidget *header_view; 
2926
2927         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
2928
2929         folder_view = modest_main_window_get_child_widget (main_window,
2930                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2931         if (!folder_view)
2932                 return;
2933
2934         header_view = modest_main_window_get_child_widget (main_window,
2935                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
2936         
2937         if (!header_view)
2938                 return;
2939
2940         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2941
2942         if (!folder)
2943                 return;
2944
2945         if (TNY_IS_FOLDER (folder)) {
2946                 gchar *folder_name;
2947                 gint response;
2948                 const gchar *current_name;
2949                 TnyFolderStore *parent;
2950                 gboolean do_rename = TRUE;
2951
2952                 current_name = tny_folder_get_name (TNY_FOLDER (folder));
2953                 parent = tny_folder_get_folder_store (TNY_FOLDER (folder));
2954                 response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (main_window), 
2955                                                                      parent, current_name, 
2956                                                                      &folder_name);
2957                 g_object_unref (parent);
2958
2959                 if (response != GTK_RESPONSE_ACCEPT || strlen (folder_name) == 0) {
2960                         do_rename = FALSE;
2961                 } else {
2962                         RenameFolderInfo *rename_folder_data = g_new0 (RenameFolderInfo, 1);
2963                         rename_folder_data->folder = folder;
2964                         rename_folder_data->new_name = folder_name;
2965                         modest_platform_connect_if_remote_and_perform (GTK_WINDOW(main_window), TRUE,
2966                                         folder, on_rename_folder_performer, rename_folder_data);
2967                 }
2968         }
2969         g_object_unref (folder);
2970 }
2971
2972 static void
2973 modest_ui_actions_delete_folder_error_handler (ModestMailOperation *mail_op,
2974                                                gpointer user_data)
2975 {
2976         GObject *win = modest_mail_operation_get_source (mail_op);
2977
2978         modest_platform_run_information_dialog ((win) ? GTK_WINDOW (win) : NULL,
2979                                                 _("mail_in_ui_folder_delete_error"));
2980         g_object_unref (win);
2981 }
2982
2983 typedef struct {
2984         TnyFolderStore *folder;
2985         gboolean move_to_trash;
2986 } DeleteFolderInfo;
2987
2988 static void
2989 on_delete_folder_cb (gboolean canceled, 
2990                   GError *err,
2991                   GtkWindow *parent_window, 
2992                   TnyAccount *account, 
2993                   gpointer user_data)
2994 {
2995         DeleteFolderInfo *info = (DeleteFolderInfo*) user_data;
2996         GtkWidget *folder_view;
2997         ModestMailOperation *mail_op;
2998         GtkTreeSelection *sel;
2999         
3000         if (!MODEST_IS_MAIN_WINDOW(parent_window) || canceled || (err!=NULL)) {
3001                 g_object_unref (G_OBJECT (info->folder));
3002                 g_free (info);
3003                 return;
3004         }
3005         
3006         folder_view = modest_main_window_get_child_widget (
3007                         MODEST_MAIN_WINDOW (parent_window),
3008                         MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3009
3010         /* Unselect the folder before deleting it to free the headers */
3011         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
3012         gtk_tree_selection_unselect_all (sel);
3013
3014         /* Create the mail operation */
3015         mail_op =
3016                 modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
3017                                 modest_ui_actions_delete_folder_error_handler,
3018                                 NULL, NULL);
3019
3020         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
3021                         mail_op);
3022         modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (info->folder), info->move_to_trash);
3023         
3024         modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (folder_view));
3025
3026         g_object_unref (G_OBJECT (mail_op));
3027         g_object_unref (G_OBJECT (info->folder));
3028         g_free (info);
3029 }
3030
3031 static void
3032 delete_folder (ModestMainWindow *main_window, gboolean move_to_trash)
3033 {
3034         TnyFolderStore *folder;
3035         GtkWidget *folder_view;
3036         gint response;
3037         gchar *message;
3038         
3039         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3040
3041         folder_view = modest_main_window_get_child_widget (main_window,
3042                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
3043         if (!folder_view)
3044                 return;
3045
3046         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
3047
3048         /* Show an error if it's an account */
3049         if (!TNY_IS_FOLDER (folder)) {
3050                 modest_platform_run_information_dialog (GTK_WINDOW (main_window),
3051                                                         _("mail_in_ui_folder_delete_error"));
3052                 g_object_unref (G_OBJECT (folder));
3053                 return;
3054         }
3055
3056         /* Ask the user */      
3057         message =  g_strdup_printf (_("mcen_nc_delete_folder_text"), 
3058                                     tny_folder_get_name (TNY_FOLDER (folder)));
3059         response = modest_platform_run_confirmation_dialog (GTK_WINDOW (main_window),
3060                                                             (const gchar *) message);
3061         g_free (message);
3062
3063         if (response == GTK_RESPONSE_OK) {
3064                 DeleteFolderInfo *info;
3065                 info = g_new0(DeleteFolderInfo, 1);
3066                 info->folder = folder;
3067                 info->move_to_trash = move_to_trash;
3068                 g_object_ref (G_OBJECT (info->folder));
3069                 TnyAccount *account = tny_folder_get_account (TNY_FOLDER (folder));
3070                 modest_platform_connect_if_remote_and_perform (GTK_WINDOW (main_window), 
3071                                                                TRUE,
3072                                                                TNY_FOLDER_STORE (account), 
3073                                                                on_delete_folder_cb, info);
3074                 g_object_unref (account);
3075         }
3076         g_object_unref (G_OBJECT (folder));
3077 }
3078
3079 void 
3080 modest_ui_actions_on_delete_folder (GtkAction *action,
3081                                      ModestMainWindow *main_window)
3082 {
3083         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3084         
3085         delete_folder (main_window, FALSE);
3086 }
3087
3088 void 
3089 modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
3090 {
3091         g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
3092         
3093         delete_folder (main_window, TRUE);
3094 }
3095
3096
3097 void
3098 modest_ui_actions_on_password_requested (TnyAccountStore *account_store, 
3099                                          const gchar* server_account_name,
3100                                          gchar **username,
3101                                          gchar **password, 
3102                                          gboolean *cancel, 
3103                                          gboolean *remember,
3104                                          ModestMainWindow *main_window)
3105 {
3106         g_return_if_fail(server_account_name);
3107         gboolean completed = FALSE;
3108         
3109         /* Initalize output parameters: */
3110         if (cancel)
3111                 *cancel = FALSE;
3112                 
3113         if (remember)
3114                 *remember = TRUE;
3115                 
3116 #ifdef MODEST_PLATFORM_MAEMO
3117         /* Maemo uses a different (awkward) button order,
3118          * It should probably just use gtk_alternative_dialog_button_order ().
3119          */
3120         GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
3121                                               NULL,
3122                                               GTK_DIALOG_MODAL,
3123                                               _("mcen_bd_dialog_ok"),
3124                                               GTK_RESPONSE_ACCEPT,
3125                                               _("mcen_bd_dialog_cancel"),
3126                                               GTK_RESPONSE_REJECT,
3127                                               NULL);
3128 #else
3129         GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
3130                                               NULL,
3131                                               GTK_DIALOG_MODAL,
3132                                               GTK_STOCK_CANCEL,
3133                                               GTK_RESPONSE_REJECT,
3134                                               GTK_STOCK_OK,
3135                                               GTK_RESPONSE_ACCEPT,
3136                                               NULL);
3137 #endif /* MODEST_PLATFORM_MAEMO */
3138
3139         modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), GTK_WINDOW (dialog));
3140         
3141         gchar *server_name = modest_account_mgr_get_server_account_hostname (
3142                 modest_runtime_get_account_mgr(), server_account_name);
3143         if (!server_name) {/* This happened once, though I don't know why. murrayc. */
3144                 g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
3145                 if (cancel)
3146                         *cancel = TRUE;
3147                 return;
3148         }
3149         
3150         /* This causes a warning because the logical ID has no %s in it, 
3151          * though the translation does, but there is not much we can do about that: */
3152         gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
3153         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
3154                             FALSE, FALSE, 0);
3155         g_free (txt);
3156         g_free (server_name);
3157         server_name = NULL;
3158
3159         /* username: */
3160         gchar *initial_username = modest_account_mgr_get_server_account_username (
3161                 modest_runtime_get_account_mgr(), server_account_name);
3162         
3163         GtkWidget *entry_username = gtk_entry_new ();
3164         if (initial_username)
3165                 gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
3166         /* Dim this if a connection has ever succeeded with this username,
3167          * as per the UI spec: */
3168         const gboolean username_known = 
3169                 modest_account_mgr_get_server_account_username_has_succeeded(
3170                         modest_runtime_get_account_mgr(), server_account_name);
3171         gtk_widget_set_sensitive (entry_username, !username_known);
3172         
3173 #ifdef MODEST_PLATFORM_MAEMO
3174         /* Auto-capitalization is the default, so let's turn it off: */
3175         hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
3176         
3177         /* Create a size group to be used by all captions.
3178          * Note that HildonCaption does not create a default size group if we do not specify one.
3179          * We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
3180         GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
3181         
3182         GtkWidget *caption = hildon_caption_new (sizegroup, 
3183                 _("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
3184         gtk_widget_show (entry_username);
3185         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption, 
3186                 FALSE, FALSE, MODEST_MARGIN_HALF);
3187         gtk_widget_show (caption);
3188 #else 
3189         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
3190                             TRUE, FALSE, 0);
3191 #endif /* MODEST_PLATFORM_MAEMO */      
3192                             
3193         /* password: */
3194         GtkWidget *entry_password = gtk_entry_new ();
3195         gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
3196         /* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
3197         
3198 #ifdef MODEST_PLATFORM_MAEMO
3199         /* Auto-capitalization is the default, so let's turn it off: */
3200         hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password), 
3201                 HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
3202         
3203         caption = hildon_caption_new (sizegroup, 
3204                 _("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
3205         gtk_widget_show (entry_password);
3206         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption, 
3207                 FALSE, FALSE, MODEST_MARGIN_HALF);
3208         gtk_widget_show (caption);
3209         g_object_unref (sizegroup);
3210 #else 
3211         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
3212                             TRUE, FALSE, 0);
3213 #endif /* MODEST_PLATFORM_MAEMO */      
3214
3215         if (initial_username != NULL)
3216                 gtk_widget_grab_focus (GTK_WIDGET (entry_password));
3217                                 
3218 /* This is not in the Maemo UI spec:
3219         remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
3220         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
3221                             TRUE, FALSE, 0);
3222 */
3223
3224         gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
3225
3226         while (!completed) {
3227         
3228                 if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
3229                         if (username) {
3230                                 *username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
3231                                 
3232                                 /* Note that an empty field becomes the "" string */
3233                                 if (*username && strlen (*username) > 0) {
3234                                         modest_account_mgr_set_server_account_username (modest_runtime_get_account_mgr(), 
3235                                                                                         server_account_name, 
3236                                                                                         *username);