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