* Fixes several memory leaks
[modest] / src / maemo / modest-platform.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 #include <config.h>
31 #include <glib/gi18n.h>
32 #include <modest-platform.h>
33 #include <modest-runtime.h>
34 #include <modest-main-window.h>
35 #include <modest-header-view.h>
36 #include "maemo/modest-maemo-global-settings-dialog.h"
37 #include "modest-widget-memory.h"
38 #include <modest-hildon-includes.h>
39 #include <modest-maemo-utils.h>
40 #include <dbus_api/modest-dbus-callbacks.h>
41 #include <maemo/modest-osso-autosave-callbacks.h>
42 #include <libosso.h>
43 #include <tny-maemo-conic-device.h>
44 #include <tny-simple-list.h>
45 #include <tny-folder.h>
46 #include <tny-camel-imap-store-account.h>
47 #include <tny-camel-pop-store-account.h>
48 #include <gtk/gtkicontheme.h>
49 #include <gtk/gtkmenuitem.h>
50 #include <gtk/gtkmain.h>
51 #include <modest-text-utils.h>
52 #include "modest-tny-folder.h"
53 #include "modest-tny-account.h"
54 #include <string.h>
55 #include <libgnomevfs/gnome-vfs-mime-utils.h>
56 #include <modest-account-settings-dialog.h>
57 #include <easysetup/modest-easysetup-wizard-dialog.h>
58 #include "modest-hildon-sort-dialog.h"
59 #include <hildon/hildon-sound.h>
60 #include <osso-mem.h>
61
62 #ifdef MODEST_HAVE_MCE
63 #include <mce/dbus-names.h>
64 #endif /*MODEST_HAVE_MCE*/
65
66 #ifdef MODEST_HAVE_ABOOK
67 #include <libosso-abook/osso-abook.h>
68 #endif /*MODEST_HAVE_ABOOK*/
69
70 #ifdef MODEST_HAVE_LIBALARM
71 #include <alarmd/alarm_event.h> /* For alarm_event_add(), etc. */
72 #endif /*MODEST_HAVE_LIBALARM*/
73
74
75 #define HILDON_OSSO_URI_ACTION "uri-action"
76 #define URI_ACTION_COPY "copy:"
77 #define MODEST_NEW_MAIL_SOUND_FILE "/usr/share/sounds/ui-new_email.wav"
78 #define MODEST_NEW_MAIL_LIGHTING_PATTERN "PatternCommunicationEmail"
79
80 static void     
81 on_modest_conf_update_interval_changed (ModestConf* self, 
82                                         const gchar *key, 
83                                         ModestConfEvent event,
84                                         ModestConfNotificationId id, 
85                                         gpointer user_data)
86 {
87         g_return_if_fail (key);
88         
89         if (strcmp (key, MODEST_CONF_UPDATE_INTERVAL) == 0) {
90                 const guint update_interval_minutes = 
91                         modest_conf_get_int (self, MODEST_CONF_UPDATE_INTERVAL, NULL);
92                 modest_platform_set_update_interval (update_interval_minutes);
93         }
94 }
95
96
97
98 static gboolean
99 check_required_files (void)
100 {
101         FILE *mcc_file = modest_maemo_open_mcc_mapping_file ();
102         if (!mcc_file) {
103                 g_printerr ("modest: check for mcc file failed\n");
104                 return FALSE;
105         } else 
106                 fclose (mcc_file);
107         
108         if (access(MODEST_PROVIDER_DATA_FILE, R_OK) != 0 &&
109             access(MODEST_MAEMO_PROVIDER_DATA_FILE, R_OK) != 0) {
110                 g_printerr ("modest: cannot find providers data\n");
111                 return FALSE;
112         }
113         
114         return TRUE;
115 }
116
117
118 /* the gpointer here is the osso_context. */
119 gboolean
120 modest_platform_init (int argc, char *argv[])
121 {
122         osso_context_t *osso_context;
123         
124         osso_hw_state_t hw_state = { 0 };
125         DBusConnection *con;    
126         GSList *acc_names;
127         
128         if (!check_required_files ()) {
129                 g_printerr ("modest: missing required files\n");
130                 return FALSE;
131         }
132         
133         osso_context =  osso_initialize(PACKAGE,PACKAGE_VERSION,
134                                         FALSE, NULL);   
135         if (!osso_context) {
136                 g_printerr ("modest: failed to acquire osso context\n");
137                 return FALSE;
138         }
139         modest_maemo_utils_set_osso_context (osso_context);
140
141         if ((con = osso_get_dbus_connection (osso_context)) == NULL) {
142                 g_printerr ("modest: could not get dbus connection\n");
143                 return FALSE;
144         }
145
146         /* Add a D-Bus handler to be used when the main osso-rpc 
147          * D-Bus handler has not handled something.
148          * We use this for D-Bus methods that need to use more complex types 
149          * than osso-rpc supports. 
150          */
151         if (!dbus_connection_add_filter (con,
152                                          modest_dbus_req_filter,
153                                          NULL,
154                                          NULL)) {
155
156                 g_printerr ("modest: Could not add D-Bus filter\n");
157                 return FALSE;
158         }
159
160         /* Register our simple D-Bus callbacks, via the osso API: */
161         osso_return_t result = osso_rpc_set_cb_f(osso_context, 
162                                MODEST_DBUS_SERVICE, 
163                                MODEST_DBUS_OBJECT, 
164                                MODEST_DBUS_IFACE,
165                                modest_dbus_req_handler, NULL /* user_data */);
166         if (result != OSSO_OK) {
167                 g_printerr ("modest: Error setting D-BUS callback (%d)\n", result);
168                 return FALSE;
169         }
170
171         /* Register hardware event dbus callback: */
172         hw_state.shutdown_ind = TRUE;
173         osso_hw_set_event_cb(osso_context, NULL, NULL, NULL);
174
175         /* Register osso auto-save callbacks: */
176         result = osso_application_set_autosave_cb (osso_context, 
177                 modest_on_osso_application_autosave, NULL /* user_data */);
178         if (result != OSSO_OK) {
179                 g_printerr ("modest: osso_application_set_autosave_cb() failed.\n");
180                 return FALSE;
181         }
182         
183
184         /* Make sure that the update interval is changed whenever its gconf key 
185          * is changed */
186         /* CAUTION: we're not using here the
187            modest_conf_listen_to_namespace because we know that there
188            are other parts of Modest listening for this namespace, so
189            we'll receive the notifications anyway. We basically do not
190            use it because there is no easy way to do the
191            modest_conf_forget_namespace */
192         ModestConf *conf = modest_runtime_get_conf ();
193         g_signal_connect (G_OBJECT(conf),
194                           "key_changed",
195                           G_CALLBACK (on_modest_conf_update_interval_changed), 
196                           NULL);
197
198         /* only force the setting of the default interval, if there are actually
199          * any accounts */
200         acc_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(), TRUE);
201         if (acc_names) {
202                 /* Get the initial update interval from gconf: */
203                 on_modest_conf_update_interval_changed(conf, MODEST_CONF_UPDATE_INTERVAL,
204                                                        MODEST_CONF_EVENT_KEY_CHANGED, 0, NULL);
205                 modest_account_mgr_free_account_names (acc_names);
206         }
207
208         
209 #ifdef MODEST_HAVE_ABOOK
210         /* initialize the addressbook */
211         if (!osso_abook_init (&argc, &argv, osso_context)) {
212                 g_printerr ("modest: failed to initialized addressbook\n");
213                 return FALSE;
214         }
215 #endif /*MODEST_HAVE_ABOOK*/
216
217         return TRUE;
218 }
219
220 gboolean
221 modest_platform_uninit (void)
222 {
223         osso_context_t *osso_context =
224                 modest_maemo_utils_get_osso_context ();
225         if (osso_context)
226                 osso_deinitialize (osso_context);
227
228         return TRUE;
229 }
230
231
232
233
234 TnyDevice*
235 modest_platform_get_new_device (void)
236 {
237         return TNY_DEVICE (tny_maemo_conic_device_new ());
238 }
239
240 gchar*
241 modest_platform_get_file_icon_name (const gchar* name, const gchar* mime_type,
242                                     gchar **effective_mime_type)
243 {
244         GString *mime_str = NULL;
245         gchar *icon_name  = NULL;
246         gchar **icons, **cursor;
247         
248         if (!mime_type || g_ascii_strcasecmp (mime_type, "application/octet-stream") == 0) 
249                 mime_str = g_string_new (gnome_vfs_get_mime_type_for_name (name));
250         else {
251                 mime_str = g_string_new (mime_type);
252                 g_string_ascii_down (mime_str);
253         }
254         
255         icons = hildon_mime_get_icon_names (mime_str->str, NULL);
256         
257         for (cursor = icons; cursor; ++cursor) {
258                 if (!g_ascii_strcasecmp (*cursor, "gnome-mime-message") ||
259                     !g_ascii_strcasecmp (*cursor, "gnome-mime-message-rfc822")) {
260                         icon_name = g_strdup ("qgn_list_messagin");
261                         break;
262                 } else if (gtk_icon_theme_has_icon (gtk_icon_theme_get_default(), *cursor)) {
263                         icon_name = g_strdup (*cursor);
264                         break;
265                 }
266         }
267         g_strfreev (icons);
268
269         if (effective_mime_type)
270                 *effective_mime_type = g_string_free (mime_str, FALSE);
271         else
272                 g_string_free (mime_str, TRUE);
273         
274         return icon_name;
275 }
276
277
278 static gboolean
279 checked_hildon_uri_open (const gchar *uri, HildonURIAction *action)
280 {
281         GError *err = NULL;
282         gboolean result;
283
284         g_return_val_if_fail (uri, FALSE);
285         
286         result = hildon_uri_open (uri, action, &err);
287         if (!result) {
288                 g_printerr ("modest: hildon_uri_open ('%s', %p) failed: %s",
289                             uri, action,  err && err->message ? err->message : "unknown error");
290                 if (err)
291                         g_error_free (err);
292         }
293         return result;
294 }
295
296
297
298 gboolean 
299 modest_platform_activate_uri (const gchar *uri)
300 {
301         HildonURIAction *action;
302         gboolean result = FALSE;
303         GSList *actions, *iter = NULL;
304         
305         g_return_val_if_fail (uri, FALSE);
306         if (!uri)
307                 return FALSE;
308
309         /* don't try to activate file: uri's -- they might confuse the user,
310          * and/or might have security implications */
311         if (!g_str_has_prefix (uri, "file:")) {
312                 
313                 actions = hildon_uri_get_actions_by_uri (uri, -1, NULL);
314                 
315                 for (iter = actions; iter; iter = g_slist_next (iter)) {
316                         action = (HildonURIAction*) iter->data;
317                         if (action && strcmp (hildon_uri_action_get_service (action),
318                                               "com.nokia.modest") == 0) {
319                                 result = checked_hildon_uri_open (uri, action);
320                                 break;
321                         }
322                 }
323                 
324                 /* if we could not open it with email, try something else */
325                 if (!result)
326                         result = checked_hildon_uri_open (uri, NULL);   
327         } 
328         
329         if (!result) {
330                 ModestWindow *parent =
331                         modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(), FALSE);
332                 hildon_banner_show_information (parent ? GTK_WIDGET(parent): NULL, NULL,
333                                                 _("mcen_ib_unsupported_link"));
334                 g_warning ("%s: cannot open uri '%s'", __FUNCTION__,uri);
335         } 
336         
337         return result;
338 }
339
340 gboolean 
341 modest_platform_activate_file (const gchar *path, const gchar *mime_type)
342 {
343         gint result = 0;
344         DBusConnection *con;
345         gchar *uri_path = NULL;
346         
347         uri_path = gnome_vfs_get_uri_from_local_path (path);    
348         con = osso_get_dbus_connection (modest_maemo_utils_get_osso_context());
349         
350         if (mime_type)
351                 result = hildon_mime_open_file_with_mime_type (con, uri_path, mime_type);
352         if (result != 1)
353                 result = hildon_mime_open_file (con, uri_path);
354         if (result != 1)
355                 modest_platform_run_information_dialog (NULL, _("mcen_ni_noregistered_viewer"), FALSE);
356         
357         return result != 1;
358 }
359
360 typedef struct  {
361         GSList *actions;
362         gchar  *uri;
363 } ModestPlatformPopupInfo;
364
365 static gboolean
366 delete_uri_popup (GtkWidget *menu,
367                   GdkEvent *event,
368                   gpointer userdata)
369 {
370         ModestPlatformPopupInfo *popup_info = (ModestPlatformPopupInfo *) userdata;
371
372         g_free (popup_info->uri);
373         hildon_uri_free_actions (popup_info->actions);
374
375         return FALSE;
376 }
377
378 static void
379 activate_uri_popup_item (GtkMenuItem *menu_item,
380                          gpointer userdata)
381 {
382         GSList *node;
383         ModestPlatformPopupInfo *popup_info = (ModestPlatformPopupInfo *) userdata;
384         const gchar* action_name;
385
386         action_name = g_object_get_data (G_OBJECT(menu_item), HILDON_OSSO_URI_ACTION);
387         if (!action_name) {
388                 g_printerr ("modest: no action name defined\n");
389                 return;
390         }
391
392         /* special handling for the copy menu item -- copy the uri to the clipboard */
393         /* if it's a copy thingy, the uri will look like 'copy:http://slashdot.org' */
394         if (g_str_has_prefix (action_name, URI_ACTION_COPY)) {
395                 GtkClipboard *clipboard = gtk_clipboard_get (GDK_NONE);
396                 action_name += strlen(URI_ACTION_COPY); /* jump past the prefix */
397
398                 if (g_str_has_prefix (action_name, "mailto:")) /* ignore mailto: prefixes */
399                         action_name += strlen ("mailto:");
400                 
401                 gtk_clipboard_set_text (clipboard, action_name, strlen (action_name));
402                 modest_platform_information_banner (NULL, NULL, _CS("ecoc_ib_edwin_copied"));
403                 return; /* we're done */
404         }
405         
406         /* now, the real uri-actions... */
407         for (node = popup_info->actions; node != NULL; node = g_slist_next (node)) {
408                 HildonURIAction *action = (HildonURIAction *) node->data;
409                 if (strcmp (action_name, hildon_uri_action_get_name (action))==0) {
410                         if (!checked_hildon_uri_open (popup_info->uri, action)) {
411                                 ModestWindow *parent =
412                                         modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(), FALSE);
413                                 hildon_banner_show_information (parent ? GTK_WIDGET(parent): NULL, NULL,
414                                                                 _("mcen_ib_unsupported_link"));
415                         }
416                         break;
417                 }
418         }
419 }
420
421 gboolean 
422 modest_platform_show_uri_popup (const gchar *uri)
423 {
424         GSList *actions_list;
425
426         if (uri == NULL)
427                 return FALSE;
428         
429         actions_list = hildon_uri_get_actions_by_uri (uri, -1, NULL);
430         if (actions_list) {
431
432                 GtkWidget *menu = gtk_menu_new ();
433                 ModestPlatformPopupInfo *popup_info = g_new0 (ModestPlatformPopupInfo, 1);
434
435                 /* don't add actions for file: uri's -- they might confuse the user,
436                  * and/or might have security implications
437                  * we still allow to copy the url though
438                  */
439                 if (!g_str_has_prefix (uri, "file:")) {                 
440                 
441                         GSList *node;                   
442                         popup_info->actions = actions_list;
443                         popup_info->uri = g_strdup (uri);
444                         
445                         for (node = actions_list; node != NULL; node = g_slist_next (node)) {
446                                 GtkWidget *menu_item;
447                                 const gchar *action_name;
448                                 const gchar *translation_domain;
449                                 HildonURIAction *action = (HildonURIAction *) node->data;
450                                 action_name = hildon_uri_action_get_name (action);
451                                 translation_domain = hildon_uri_action_get_translation_domain (action);
452                                 menu_item = gtk_menu_item_new_with_label (dgettext(translation_domain, action_name));
453                                 g_object_set_data (G_OBJECT(menu_item), HILDON_OSSO_URI_ACTION, (gpointer)action_name);  /* hack */
454                                 g_signal_connect (G_OBJECT (menu_item), "activate", G_CALLBACK (activate_uri_popup_item),
455                                                   popup_info);
456                                 
457                                 if (hildon_uri_is_default_action (action, NULL)) {
458                                         gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
459                                 } else {
460                                         gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
461                                 }
462                                 gtk_widget_show (menu_item);
463                         }
464                 }
465
466                 /* always add the copy item */
467                 GtkWidget* menu_item = gtk_menu_item_new_with_label (dgettext("osso-uri",
468                                                                               "uri_link_copy_link_location"));
469                 g_object_set_data_full (G_OBJECT(menu_item), HILDON_OSSO_URI_ACTION,
470                                         g_strconcat (URI_ACTION_COPY, uri, NULL),
471                                         g_free);
472                 g_signal_connect (G_OBJECT (menu_item), "activate", G_CALLBACK (activate_uri_popup_item),NULL);
473                 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
474                 gtk_widget_show (menu_item);
475
476                 
477                 /* and what to do when the link is deleted */
478                 g_signal_connect (G_OBJECT (menu), "delete-event", G_CALLBACK (delete_uri_popup), popup_info);
479                 gtk_menu_popup (GTK_MENU(menu), NULL, NULL, NULL, NULL, 1, gtk_get_current_event_time ());
480                                                   
481         } else {
482                 hildon_banner_show_information (NULL, NULL, _("mcen_ib_unsupported_link"));
483         }
484         
485         return TRUE;
486 }
487
488
489 GdkPixbuf*
490 modest_platform_get_icon (const gchar *name, guint icon_size)
491 {
492         GError *err = NULL;
493         GdkPixbuf* pixbuf = NULL;
494         GtkIconTheme *current_theme = NULL;
495
496         g_return_val_if_fail (name, NULL);
497
498         /* strlen == 0 is not really an error; it just
499          * means the icon is not available
500          */
501         if (!name || strlen(name) == 0)
502                 return NULL;
503         
504         current_theme = gtk_icon_theme_get_default ();
505         pixbuf = gtk_icon_theme_load_icon (current_theme, name, icon_size,
506                                            GTK_ICON_LOOKUP_NO_SVG,
507                                            &err);
508         if (!pixbuf) {
509                 g_printerr ("modest: error loading theme icon '%s': %s\n",
510                             name, err->message);
511                 g_error_free (err);
512         } 
513         return pixbuf;
514 }
515
516 const gchar*
517 modest_platform_get_app_name (void)
518 {
519         return _("mcen_ap_name");
520 }
521
522 static void 
523 entry_insert_text (GtkEditable *editable,
524                    const gchar *text,
525                    gint         length,
526                    gint        *position,
527                    gpointer     data)
528 {
529         gchar *chars;
530         gint chars_length;
531
532         chars = gtk_editable_get_chars (editable, 0, -1);
533         chars_length = g_utf8_strlen (chars, -1);
534         g_free (chars);
535
536         /* Show WID-INF036 */
537         if (chars_length >= 20) {
538                 hildon_banner_show_information  (gtk_widget_get_parent (GTK_WIDGET (data)), NULL,
539                                                  _CS("ckdg_ib_maximum_characters_reached"));
540         } else {
541                 if (modest_text_utils_is_forbidden_char (*text, FOLDER_NAME_FORBIDDEN_CHARS)) {
542                         /* Show an error */
543                         gchar *tmp, *msg;
544                         
545                         tmp = g_strndup (folder_name_forbidden_chars, 
546                                          FOLDER_NAME_FORBIDDEN_CHARS_LENGTH);
547                         msg = g_strdup_printf (_CS("ckdg_ib_illegal_characters_entered"), tmp);
548                         hildon_banner_show_information  (gtk_widget_get_parent (GTK_WIDGET (data)), 
549                                                          NULL, msg);
550                         g_free (msg);
551                         g_free (tmp);
552                 } else {        
553                         /* Write the text in the entry if it's valid */
554                         g_signal_handlers_block_by_func (editable,
555                                                          (gpointer) entry_insert_text, data);
556                         gtk_editable_insert_text (editable, text, length, position);
557                         g_signal_handlers_unblock_by_func (editable,
558                                                            (gpointer) entry_insert_text, data);
559                 }
560         }
561         /* Do not allow further processing */
562         g_signal_stop_emission_by_name (editable, "insert_text");
563 }
564
565 static void
566 entry_changed (GtkEditable *editable,
567                gpointer     user_data)
568 {
569         gchar *chars;
570         GtkWidget *ok_button;
571         GList *buttons;
572
573         buttons = gtk_container_get_children (GTK_CONTAINER (GTK_DIALOG (user_data)->action_area));
574         ok_button = GTK_WIDGET (buttons->next->data);
575         
576         chars = gtk_editable_get_chars (editable, 0, -1);
577         g_return_if_fail (chars != NULL);
578
579         
580         if (g_utf8_strlen (chars,-1) >= 21)
581                 hildon_banner_show_information  (gtk_widget_get_parent (GTK_WIDGET (user_data)), NULL,
582                                                  _CS("ckdg_ib_maximum_characters_reached"));
583         else
584                 gtk_widget_set_sensitive (ok_button, modest_text_utils_validate_folder_name(chars));
585                 
586         /* Free */
587         g_list_free (buttons);
588         g_free (chars);
589 }
590
591
592
593 static void
594 on_response (GtkDialog *dialog,
595              gint response,
596              gpointer user_data)
597 {
598         GList *child_vbox, *child_hbox;
599         GtkWidget *hbox, *entry;
600         TnyFolderStore *parent;
601         const gchar *new_name;
602         gboolean exists;
603
604         if (response != GTK_RESPONSE_ACCEPT)
605                 return;
606         
607         /* Get entry */
608         child_vbox = gtk_container_get_children (GTK_CONTAINER (dialog->vbox));
609         hbox = child_vbox->data;
610         child_hbox = gtk_container_get_children (GTK_CONTAINER (hbox));
611         entry = child_hbox->next->data;
612         
613         parent = TNY_FOLDER_STORE (user_data);
614         new_name = gtk_entry_get_text (GTK_ENTRY (entry));
615         exists = FALSE;
616         
617         /* Look for another folder with the same name */
618         if (modest_tny_folder_has_subfolder_with_name (parent, 
619                                                        new_name,
620                                                        TRUE)) {
621                 exists = TRUE;
622         }
623         
624         if (!exists) {
625                 if (TNY_IS_ACCOUNT (parent) &&
626                     modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent)) &&
627                     modest_tny_local_folders_account_folder_name_in_use (MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (parent),
628                                                                          new_name)) {
629                         exists = TRUE;
630                 }
631         }
632         
633         if (exists) {
634                 
635                 /* Show an error */
636                 hildon_banner_show_information (gtk_widget_get_parent (GTK_WIDGET (dialog)), 
637                                                 NULL, _CS("ckdg_ib_folder_already_exists"));
638                 /* Select the text */
639                 gtk_entry_select_region (GTK_ENTRY (entry), 0, -1);
640                 gtk_widget_grab_focus (entry);
641                 /* Do not close the dialog */
642                 g_signal_stop_emission_by_name (dialog, "response");
643         }
644 }
645
646
647
648 static gint
649 modest_platform_run_folder_name_dialog (GtkWindow *parent_window,
650                                         TnyFolderStore *parent,
651                                         const gchar *dialog_title,
652                                         const gchar *label_text,
653                                         const gchar *suggested_name,
654                                         gchar **folder_name)
655 {
656         GtkWidget *accept_btn = NULL; 
657         GtkWidget *dialog, *entry, *label, *hbox;
658         GList *buttons = NULL;
659         gint result;
660
661         /* Ask the user for the folder name */
662         dialog = gtk_dialog_new_with_buttons (dialog_title,
663                                               parent_window,
664                                               GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
665                                               _("mcen_bd_dialog_ok"),
666                                               GTK_RESPONSE_ACCEPT,
667                                               _("mcen_bd_dialog_cancel"),
668                                               GTK_RESPONSE_REJECT,
669                                               NULL);
670
671         /* Add accept button (with unsensitive handler) */
672         buttons = gtk_container_get_children (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area));
673         accept_btn = GTK_WIDGET (buttons->next->data);
674         /* Create label and entry */
675         label = gtk_label_new (label_text);
676         /* TODO: check that the suggested name does not exist */
677         /* We set 21 as maximum because we want to show WID-INF036
678            when the user inputs more that 20 */
679         entry = gtk_entry_new_with_max_length (21);
680         if (suggested_name)
681                 gtk_entry_set_text (GTK_ENTRY (entry), suggested_name);
682         else
683                 gtk_entry_set_text (GTK_ENTRY (entry), _("mcen_ia_default_folder_name"));
684         gtk_entry_set_width_chars (GTK_ENTRY (entry),
685                                    MAX (g_utf8_strlen (gtk_entry_get_text (GTK_ENTRY (entry)), -1),
686                                         g_utf8_strlen (_("mcen_ia_default_folder_name"), -1)));
687         gtk_entry_select_region (GTK_ENTRY (entry), 0, -1);
688
689         /* Connect to the response method to avoid closing the dialog
690            when an invalid name is selected*/
691         g_signal_connect (dialog,
692                           "response",
693                           G_CALLBACK (on_response),
694                           parent);
695
696         /* Track entry changes */
697         g_signal_connect (entry,
698                           "insert-text",
699                           G_CALLBACK (entry_insert_text),
700                           dialog);
701         g_signal_connect (entry,
702                           "changed",
703                           G_CALLBACK (entry_changed),
704                           dialog);
705
706
707         /* Some locales like pt_BR need this to get the full window
708            title shown */
709         gtk_widget_set_size_request (GTK_WIDGET (dialog), 300, -1);
710
711         /* Create the hbox */
712         hbox = gtk_hbox_new (FALSE, 12);
713         gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
714         gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
715
716         /* Add hbox to dialog */
717         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), 
718                             hbox, FALSE, FALSE, 0);
719         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), 
720                                      GTK_WINDOW (dialog), GTK_WINDOW (parent_window));
721         gtk_widget_show_all (GTK_WIDGET(dialog));
722                 
723         result = gtk_dialog_run (GTK_DIALOG(dialog));
724         if (result == GTK_RESPONSE_ACCEPT)
725                 *folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
726
727         gtk_widget_destroy (dialog);
728
729         while (gtk_events_pending ())
730                 gtk_main_iteration ();
731
732         return result;
733 }
734
735 gint
736 modest_platform_run_new_folder_dialog (GtkWindow *parent_window,
737                                        TnyFolderStore *parent_folder,
738                                        gchar *suggested_name,
739                                        gchar **folder_name)
740 {
741         gchar *real_suggested_name = NULL, *tmp = NULL;
742         gint result;
743
744         if(suggested_name == NULL)
745         {
746                 const gchar *default_name = _("mcen_ia_default_folder_name");
747                 unsigned int i;
748                 gchar num_str[3];
749
750                 for(i = 0; i < 100; ++ i) {
751                         gboolean exists = FALSE;
752
753                         sprintf(num_str, "%.2u", i);
754
755                         if (i == 0)
756                                 real_suggested_name = g_strdup (default_name);
757                         else
758                                 real_suggested_name = g_strdup_printf (_("mcen_ia_default_folder_name_s"),
759                                                                        num_str);
760                         exists = modest_tny_folder_has_subfolder_with_name (parent_folder,
761                                                                             real_suggested_name,
762                                                                             TRUE);
763
764                         if (!exists)
765                                 break;
766
767                         g_free (real_suggested_name);
768                 }
769
770                 /* Didn't find a free number */
771                 if (i == 100)
772                         real_suggested_name = g_strdup (default_name);
773         } else {
774                 real_suggested_name = suggested_name;
775         }
776
777         tmp = g_strconcat (_("mcen_fi_new_folder_name"), ":", NULL);
778         result = modest_platform_run_folder_name_dialog (parent_window, 
779                                                          parent_folder,
780                                                          _("mcen_ti_new_folder"),
781                                                          tmp,
782                                                          real_suggested_name,
783                                                          folder_name);
784         g_free (tmp);
785
786         if (suggested_name == NULL)
787                 g_free(real_suggested_name);
788
789         return result;
790 }
791
792 gint
793 modest_platform_run_rename_folder_dialog (GtkWindow *parent_window,
794                                           TnyFolderStore *parent_folder,
795                                           const gchar *suggested_name,
796                                           gchar **folder_name)
797 {
798         g_return_val_if_fail (TNY_IS_FOLDER_STORE (parent_folder), GTK_RESPONSE_REJECT);
799
800         return modest_platform_run_folder_name_dialog (parent_window, 
801                                                        parent_folder,
802                                                        _HL("ckdg_ti_rename_folder"),
803                                                        _HL("ckdg_fi_rename_name"),
804                                                        suggested_name,
805                                                        folder_name);
806 }
807
808
809
810 static void
811 on_destroy_dialog (GtkWidget *dialog)
812 {
813         /* This could happen when the dialogs get programatically
814            hidden or destroyed (for example when closing the
815            application while a dialog is being shown) */
816         if (!GTK_IS_WIDGET (dialog))
817                 return;
818
819         gtk_widget_destroy (dialog);
820
821         if (gtk_events_pending ())
822                 gtk_main_iteration ();
823 }
824
825 gint
826 modest_platform_run_confirmation_dialog (GtkWindow *parent_window,
827                                          const gchar *message)
828 {
829         GtkWidget *dialog;
830         gint response;
831         
832         dialog = hildon_note_new_confirmation (parent_window, message);
833         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), 
834                                      GTK_WINDOW (dialog), GTK_WINDOW (parent_window));
835
836         response = gtk_dialog_run (GTK_DIALOG (dialog));
837
838         on_destroy_dialog (dialog);
839
840         return response;
841 }
842
843 gint
844 modest_platform_run_confirmation_dialog_with_buttons (GtkWindow *parent_window,
845                                                       const gchar *message,
846                                                       const gchar *button_accept,
847                                                       const gchar *button_cancel)
848 {
849         GtkWidget *dialog;
850         gint response;
851         
852         dialog = hildon_note_new_confirmation_add_buttons (parent_window, message,
853                                                            button_accept, GTK_RESPONSE_ACCEPT,
854                                                            button_cancel, GTK_RESPONSE_CANCEL,
855                                                            NULL);
856         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), 
857                                      GTK_WINDOW (dialog), GTK_WINDOW (parent_window));
858
859         response = gtk_dialog_run (GTK_DIALOG (dialog));
860
861         on_destroy_dialog (dialog);
862
863         return response;
864 }
865         
866 gint
867 modest_platform_run_yes_no_dialog (GtkWindow *parent_window,
868                                    const gchar *message)
869 {
870         GtkWidget *dialog;
871         gint response;
872         
873         dialog = hildon_note_new_confirmation_add_buttons (parent_window, message,
874                                                            _("mcen_bd_yes"), GTK_RESPONSE_YES,
875                                                            _("mcen_bd_no"), GTK_RESPONSE_NO,
876                                                            NULL);
877         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), 
878                                      GTK_WINDOW (dialog), GTK_WINDOW (parent_window));
879         response = gtk_dialog_run (GTK_DIALOG (dialog));
880         
881         on_destroy_dialog (dialog);
882
883         return response;
884 }
885
886
887
888 void
889 modest_platform_run_information_dialog (GtkWindow *parent_window,
890                                         const gchar *message,
891                                         gboolean block)
892 {
893         GtkWidget *note;
894         
895         note = hildon_note_new_information (parent_window, message);
896         if (block)
897                 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
898                                              GTK_WINDOW (note), GTK_WINDOW (parent_window));
899         
900         if (block) {
901                 gtk_dialog_run (GTK_DIALOG (note));
902         
903                 on_destroy_dialog (note);
904         } else {
905                 g_signal_connect_swapped (note,
906                                           "response", 
907                                           G_CALLBACK (on_destroy_dialog),
908                                           note);
909
910                 gtk_widget_show_all (note);
911         }
912 }
913
914 typedef struct _ConnectAndWaitData {
915         GMutex *mutex;
916         GMainLoop *wait_loop;
917         gboolean has_callback;
918         gulong handler;
919 } ConnectAndWaitData;
920
921
922 static void
923 quit_wait_loop (TnyAccount *account,
924                 ConnectAndWaitData *data) 
925 {
926         /* Set the has_callback to TRUE (means that the callback was
927            executed and wake up every code waiting for cond to be
928            TRUE */
929         g_mutex_lock (data->mutex);
930         data->has_callback = TRUE;
931         if (data->wait_loop)
932                 g_main_loop_quit (data->wait_loop);
933         g_mutex_unlock (data->mutex);
934 }
935
936 static void
937 on_connection_status_changed (TnyAccount *account, 
938                               TnyConnectionStatus status,
939                               gpointer user_data)
940 {
941         TnyConnectionStatus conn_status;
942         ConnectAndWaitData *data;
943                         
944         /* Ignore if reconnecting or disconnected */
945         conn_status = tny_account_get_connection_status (account);
946         if (conn_status == TNY_CONNECTION_STATUS_RECONNECTING ||
947             conn_status == TNY_CONNECTION_STATUS_DISCONNECTED)
948                 return;
949
950         /* Remove the handler */
951         data = (ConnectAndWaitData *) user_data;
952         g_signal_handler_disconnect (account, data->handler);
953
954         /* Quit from wait loop */
955         quit_wait_loop (account, (ConnectAndWaitData *) user_data);
956 }
957
958 static void
959 on_tny_camel_account_set_online_cb (TnyCamelAccount *account, 
960                                     gboolean canceled, 
961                                     GError *err, 
962                                     gpointer user_data)
963 {
964         /* Quit from wait loop */
965         quit_wait_loop (TNY_ACCOUNT (account), (ConnectAndWaitData *) user_data);
966 }
967
968 gboolean 
969 modest_platform_connect_and_wait (GtkWindow *parent_window, 
970                                   TnyAccount *account)
971 {
972         ConnectAndWaitData *data = NULL;
973         gboolean device_online;
974         TnyDevice *device;
975         TnyConnectionStatus conn_status;
976         gboolean user_requested;
977         
978         device = modest_runtime_get_device();
979         device_online = tny_device_is_online (device);
980
981         /* Whether the connection is user requested or automatically
982            requested, for example via D-Bus */
983         user_requested = (parent_window) ? TRUE : FALSE;
984
985         /* If there is no account check only the device status */
986         if (!account) {
987                 if (device_online)
988                         return TRUE;
989                 else
990                         return tny_maemo_conic_device_connect (TNY_MAEMO_CONIC_DEVICE (device), 
991                                                                NULL, user_requested);
992         }
993
994         /* Return if the account is already connected */
995         conn_status = tny_account_get_connection_status (account);
996         if (device_online && conn_status == TNY_CONNECTION_STATUS_CONNECTED)
997                 return TRUE;
998
999         /* Create the helper */
1000         data = g_slice_new0 (ConnectAndWaitData);
1001         data->mutex = g_mutex_new ();
1002         data->has_callback = FALSE;
1003
1004         /* Connect the device */
1005         if (!device_online) {
1006                 /* Track account connection status changes */
1007                 data->handler = g_signal_connect (account, "connection-status-changed",                                     
1008                                                   G_CALLBACK (on_connection_status_changed),
1009                                                   data);
1010                 /* Try to connect the device */
1011                 device_online = tny_maemo_conic_device_connect (TNY_MAEMO_CONIC_DEVICE (device), 
1012                                                                 NULL, user_requested);
1013
1014                 /* If the device connection failed then exit */
1015                 if (!device_online && data->handler)
1016                         goto frees;
1017         } else {
1018                 /* Force a reconnection of the account */
1019                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (account), TRUE, 
1020                                               on_tny_camel_account_set_online_cb, data);
1021         }
1022
1023         /* Wait until the callback is executed */
1024         g_mutex_lock (data->mutex);
1025         if (!data->has_callback) {
1026                 data->wait_loop = g_main_loop_new (g_main_context_new (), FALSE);
1027                 gdk_threads_leave ();
1028                 g_mutex_unlock (data->mutex);
1029                 g_main_loop_run (data->wait_loop);
1030                 g_mutex_lock (data->mutex);
1031                 gdk_threads_enter ();
1032         }
1033         g_mutex_unlock (data->mutex);
1034
1035  frees:
1036         if (data) {
1037                 if (g_signal_handler_is_connected (account, data->handler))
1038                         g_signal_handler_disconnect (account, data->handler);
1039                 g_mutex_free (data->mutex);
1040                 g_main_loop_unref (data->wait_loop);
1041                 g_slice_free (ConnectAndWaitData, data);
1042         }
1043
1044         conn_status = tny_account_get_connection_status (account);
1045         return (conn_status == TNY_CONNECTION_STATUS_CONNECTED) ? TRUE: FALSE;
1046 }
1047
1048 gboolean 
1049 modest_platform_connect_and_wait_if_network_account (GtkWindow *parent_window, TnyAccount *account)
1050 {
1051         if (tny_account_get_account_type (account) == TNY_ACCOUNT_TYPE_STORE) {
1052                 if (!TNY_IS_CAMEL_POP_STORE_ACCOUNT (account) &&
1053                     !TNY_IS_CAMEL_IMAP_STORE_ACCOUNT (account)) {
1054                         /* This must be a maildir account, which does not require a connection: */
1055                         return TRUE;
1056                 }
1057         }
1058
1059         return modest_platform_connect_and_wait (parent_window, account);
1060 }
1061
1062 gboolean 
1063 modest_platform_connect_and_wait_if_network_folderstore (GtkWindow *parent_window, TnyFolderStore *folder_store)
1064 {
1065         if (!folder_store)
1066                 return TRUE; /* Maybe it is something local. */
1067                 
1068         gboolean result = TRUE;
1069         if (TNY_IS_FOLDER (folder_store)) {
1070                 /* Get the folder's parent account: */
1071                 TnyAccount *account = tny_folder_get_account(TNY_FOLDER (folder_store));
1072                 if (account != NULL) {
1073                         result = modest_platform_connect_and_wait_if_network_account (NULL, account);
1074                         g_object_unref (account);
1075                 }
1076         } else if (TNY_IS_ACCOUNT (folder_store)) {
1077                 /* Use the folder store as an account: */
1078                 result = modest_platform_connect_and_wait_if_network_account (NULL, TNY_ACCOUNT (folder_store));
1079         }
1080
1081         return result;
1082 }
1083
1084 GtkWidget *
1085 modest_platform_create_sort_dialog       (GtkWindow *parent_window)
1086 {
1087         GtkWidget *dialog;
1088
1089         dialog = modest_hildon_sort_dialog_new (parent_window);
1090
1091         hildon_help_dialog_help_enable (GTK_DIALOG(dialog),
1092                                         "applications_email_sort",
1093                                         modest_maemo_utils_get_osso_context());
1094
1095         return dialog;
1096 }
1097
1098
1099 gboolean 
1100 modest_platform_set_update_interval (guint minutes)
1101 {
1102 #ifdef MODEST_HAVE_LIBALARM
1103         
1104         ModestConf *conf = modest_runtime_get_conf ();
1105         if (!conf)
1106                 return FALSE;
1107                 
1108         cookie_t alarm_cookie = modest_conf_get_int (conf, MODEST_CONF_ALARM_ID, NULL);
1109
1110         /* Delete any existing alarm,
1111          * because we will replace it: */
1112         if (alarm_cookie) {
1113                 if (alarm_event_del(alarm_cookie) != 1)
1114                         g_warning ("%s: alarm %d was not on the queue", __FUNCTION__, (int)alarm_cookie);
1115                 alarm_cookie = 0;
1116                 modest_conf_set_int (conf, MODEST_CONF_ALARM_ID, 0, NULL);
1117         }
1118         
1119         /* 0 means no updates: */
1120         if (minutes == 0)
1121                 return TRUE;
1122         
1123      
1124         /* Register alarm: */
1125         
1126         /* Set the interval in alarm_event_t structure: */
1127         alarm_event_t *event = g_new0(alarm_event_t, 1);
1128         event->alarm_time = minutes * 60; /* seconds */
1129         
1130         /* Set recurrence every few minutes: */
1131         event->recurrence = minutes;
1132         event->recurrence_count = -1; /* Means infinite */
1133
1134         /* Specify what should happen when the alarm happens:
1135          * It should call this D-Bus method: */
1136          
1137         event->dbus_path = g_strdup(MODEST_DBUS_OBJECT);
1138         event->dbus_interface = g_strdup (MODEST_DBUS_IFACE);
1139         event->dbus_service = g_strdup (MODEST_DBUS_SERVICE);
1140         event->dbus_name = g_strdup (MODEST_DBUS_METHOD_SEND_RECEIVE);
1141
1142         /* Use ALARM_EVENT_NO_DIALOG: Otherwise, a dialog will be shown if 
1143          * exec_name or dbus_path is NULL, even though we have specified no dialog text.
1144          * Also use ALARM_EVENT_ACTIVATION so that modest is started (without UI) to get emails 
1145          * This is why we want to use the Alarm API instead of just g_timeout_add().
1146          * (The old maemo email-client did this, though it isn't specified in the UI spec.)
1147          * ALARM_EVENT_CONNECTED will prevent the alarm from being called in case that the device is offline
1148          */
1149         event->flags = ALARM_EVENT_NO_DIALOG | ALARM_EVENT_ACTIVATION | ALARM_EVENT_CONNECTED;
1150         
1151         alarm_cookie = alarm_event_add (event);
1152
1153         /* now, free it */
1154         alarm_event_free (event);
1155         
1156         /* Store the alarm ID in GConf, so we can remove it later:
1157          * This is apparently valid between application instances. */
1158         modest_conf_set_int (conf, MODEST_CONF_ALARM_ID, alarm_cookie, NULL);
1159         
1160         if (!alarm_cookie) {
1161             /* Error */
1162             const alarm_error_t alarm_error = alarmd_get_error ();
1163             g_debug ("Error setting alarm event. Error code: '%d'\n", alarm_error);
1164             
1165             /* Give people some clue: */
1166             /* The alarm API should have a function for this: */
1167             if (alarm_error == ALARMD_ERROR_DBUS) {
1168                 g_debug ("  ALARMD_ERROR_DBUS: An error with D-Bus occurred, probably coudn't get a D-Bus connection.\n");
1169             } else if (alarm_error == ALARMD_ERROR_CONNECTION) {
1170                 g_debug ("  ALARMD_ERROR_CONNECTION: Could not contact alarmd via D-Bus.\n");
1171             } else if (alarm_error == ALARMD_ERROR_INTERNAL) {
1172                 g_debug ("  ALARMD_ERROR_INTERNAL: Some alarmd or libalarm internal error, possibly a version mismatch.\n");
1173             } else if (alarm_error == ALARMD_ERROR_MEMORY) {
1174                 g_debug ("  ALARMD_ERROR_MEMORY: A memory allocation failed.\n");
1175             } else if (alarm_error == ALARMD_ERROR_ARGUMENT) {
1176                 g_debug ("  ALARMD_ERROR_ARGUMENT: An argument given by caller was invalid.\n");
1177             } else if (alarm_error == ALARMD_ERROR_NOT_RUNNING) {
1178                 g_debug ("  ALARMD_ERROR_NOT_RUNNING: alarmd is not running.\n");
1179             }
1180             
1181             return FALSE;
1182         }
1183 #endif /* MODEST_HAVE_LIBALARM */       
1184         return TRUE;
1185 }
1186
1187 void
1188 modest_platform_push_email_notification(void)
1189 {
1190         gboolean play_sound;
1191         ModestWindow *main_window;
1192         gboolean screen_on = TRUE, app_in_foreground;
1193
1194         /* Check whether or not we should play a sound */
1195         play_sound = modest_conf_get_bool (modest_runtime_get_conf (),
1196                                            MODEST_CONF_PLAY_SOUND_MSG_ARRIVE,
1197                                            NULL);
1198
1199         /* Get the screen status */
1200         main_window = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (), FALSE);
1201         if (main_window)
1202                 screen_on = modest_main_window_screen_is_on (MODEST_MAIN_WINDOW (main_window));
1203
1204         /* Get the window status */
1205         app_in_foreground = hildon_program_get_is_topmost (hildon_program_get_instance ());
1206
1207         /* If the screen is on and the app is in the
1208            foreground we don't show anything */
1209         if (!(screen_on && app_in_foreground)) {
1210                 /* Play a sound */
1211                 if (play_sound)
1212                         hildon_play_system_sound (MODEST_NEW_MAIL_SOUND_FILE);
1213
1214                 /* Activate LED. This must be deactivated by
1215                    modest_platform_remove_new_mail_notifications */
1216 #ifdef MODEST_HAVE_MCE
1217                 osso_rpc_run_system (modest_maemo_utils_get_osso_context (),
1218                                      MCE_SERVICE,
1219                                      MCE_REQUEST_PATH,
1220                                      MCE_REQUEST_IF,
1221                                      MCE_ACTIVATE_LED_PATTERN,
1222                                      NULL,
1223                                      DBUS_TYPE_STRING, MODEST_NEW_MAIL_LIGHTING_PATTERN,
1224                                      DBUS_TYPE_INVALID);
1225 #endif
1226         }
1227 }
1228
1229 void 
1230 modest_platform_on_new_headers_received (TnyList *header_list,
1231                                          gboolean show_visual)
1232 {
1233         g_return_if_fail (TNY_IS_LIST(header_list));
1234
1235         if (tny_list_get_length(header_list) == 0) {
1236                 g_warning ("%s: header list is empty", __FUNCTION__);
1237                 return;
1238         }
1239         
1240         if (!show_visual) {
1241                 modest_platform_push_email_notification ();
1242                 /* We do a return here to avoid indentation with an else */
1243                 return;
1244         }
1245
1246 #ifdef MODEST_HAVE_HILDON_NOTIFY
1247         gboolean play_sound;
1248
1249         /* Check whether or not we should play a sound */
1250         play_sound = modest_conf_get_bool (modest_runtime_get_conf (),
1251                                            MODEST_CONF_PLAY_SOUND_MSG_ARRIVE,
1252                                            NULL);
1253
1254         HildonNotification *notification;
1255         TnyIterator *iter;
1256         GSList *notifications_list = NULL;
1257
1258         /* Get previous notifications ids */
1259         notifications_list = modest_conf_get_list (modest_runtime_get_conf (), 
1260                                                    MODEST_CONF_NOTIFICATION_IDS, 
1261                                                    MODEST_CONF_VALUE_INT, NULL);
1262
1263         iter = tny_list_create_iterator (header_list);
1264         while (!tny_iterator_is_done (iter)) {
1265                 gchar *url = NULL, *display_address = NULL,  *summary = NULL;
1266                 const gchar *display_date;
1267                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1268                 TnyFolder *folder = tny_header_get_folder (header);
1269                 gboolean first_notification = TRUE;
1270                 gint notif_id;
1271                 gchar *str;
1272
1273                 /* constant string, don't free */
1274                 display_date = modest_text_utils_get_display_date (tny_header_get_date_received (header));
1275
1276                 display_address = tny_header_dup_from (header);
1277                 modest_text_utils_get_display_address (display_address); /* string is changed in-place */
1278                 
1279                 summary = g_strdup_printf ("%s - %s", display_date, display_address);
1280                 str = tny_header_dup_subject (header);
1281                 notification = hildon_notification_new (summary,
1282                                                         str,
1283                                                         "qgn_list_messagin",
1284                                                         "email.arrive");
1285                 g_free (str);
1286                 /* Create the message URL */
1287                 str = tny_header_dup_uid (header);
1288                 url = g_strdup_printf ("%s/%s", tny_folder_get_url_string (folder), 
1289                                        str);
1290                 g_free (str);
1291
1292                 hildon_notification_add_dbus_action(notification,
1293                                                     "default",
1294                                                     "Cancel",
1295                                                     MODEST_DBUS_SERVICE,
1296                                                     MODEST_DBUS_OBJECT,
1297                                                     MODEST_DBUS_IFACE,
1298                                                     MODEST_DBUS_METHOD_OPEN_MESSAGE,
1299                                                     G_TYPE_STRING, url,
1300                                                     -1);
1301
1302                 /* Play sound if the user wants. Show the LED
1303                    pattern. Show and play just one */
1304                 if (G_UNLIKELY (first_notification)) {
1305                         first_notification = FALSE;
1306                         if (play_sound)  {
1307                                 notify_notification_set_hint_string(NOTIFY_NOTIFICATION (notification),
1308                                                                     "sound-file", MODEST_NEW_MAIL_SOUND_FILE);
1309                         }
1310
1311                         /* Set the led pattern */
1312                         notify_notification_set_hint_int32 (NOTIFY_NOTIFICATION (notification),
1313                                                             "dialog-type", 4);
1314                         notify_notification_set_hint_string(NOTIFY_NOTIFICATION (notification),
1315                                                             "led-pattern",
1316                                                             MODEST_NEW_MAIL_LIGHTING_PATTERN);                  
1317                 }
1318
1319                 /* Notify. We need to do this in an idle because this function
1320                    could be called from a thread */
1321                 notify_notification_show (NOTIFY_NOTIFICATION (notification), NULL);
1322
1323                 /* Save id in the list */
1324                 g_object_get(G_OBJECT(notification), "id", &notif_id, NULL);
1325                 notifications_list = g_slist_prepend (notifications_list, GINT_TO_POINTER(notif_id));
1326                 /* We don't listen for the "closed" signal, because we
1327                    don't care about if the notification was removed or
1328                    not to store the list in gconf */
1329         
1330                 /* Free & carry on */
1331                 g_free (display_address);
1332                 g_free (summary);
1333                 g_free (url);
1334                 g_object_unref (folder);
1335                 g_object_unref (header);
1336                 tny_iterator_next (iter);
1337         }
1338         g_object_unref (iter);
1339
1340         /* Save the ids */
1341         modest_conf_set_list (modest_runtime_get_conf (), MODEST_CONF_NOTIFICATION_IDS, 
1342                               notifications_list, MODEST_CONF_VALUE_INT, NULL);
1343
1344         g_slist_free (notifications_list);
1345         
1346 #endif /*MODEST_HAVE_HILDON_NOTIFY*/
1347 }
1348
1349 void
1350 modest_platform_remove_new_mail_notifications (gboolean only_visuals) 
1351 {
1352         if (only_visuals) {
1353 #ifdef MODEST_HAVE_MCE
1354                 osso_rpc_run_system (modest_maemo_utils_get_osso_context (),
1355                                      MCE_SERVICE,
1356                                      MCE_REQUEST_PATH,
1357                                      MCE_REQUEST_IF,
1358                                      MCE_DEACTIVATE_LED_PATTERN,
1359                                      NULL,
1360                                      DBUS_TYPE_STRING, MODEST_NEW_MAIL_LIGHTING_PATTERN,
1361                                      DBUS_TYPE_INVALID);
1362 #endif
1363                 return;
1364         }
1365
1366 #ifdef MODEST_HAVE_HILDON_NOTIFY
1367         GSList *notif_list = NULL;
1368
1369         /* Get previous notifications ids */
1370         notif_list = modest_conf_get_list (modest_runtime_get_conf (), 
1371                                            MODEST_CONF_NOTIFICATION_IDS, 
1372                                            MODEST_CONF_VALUE_INT, NULL);
1373
1374         while (notif_list) {
1375                 gint notif_id;
1376                 NotifyNotification *notif;
1377
1378                 /* Nasty HACK to remove the notifications, set the id
1379                    of the existing ones and then close them */
1380                 notif_id = GPOINTER_TO_INT(notif_list->data);
1381                 notif = notify_notification_new("dummy", NULL, NULL, NULL);
1382                 g_object_set(G_OBJECT(notif), "id", notif_id, NULL);
1383
1384                 /* Close the notification, note that some ids could be
1385                    already invalid, but we don't care because it does
1386                    not fail */
1387                 notify_notification_close(notif, NULL);
1388                 g_object_unref(notif);
1389
1390                 /* Delete the link, it's like going to the next */
1391                 notif_list = g_slist_delete_link (notif_list, notif_list);
1392         }
1393
1394         /* Save the ids */
1395         modest_conf_set_list (modest_runtime_get_conf (), MODEST_CONF_NOTIFICATION_IDS, 
1396                               notif_list, MODEST_CONF_VALUE_INT, NULL);
1397
1398         g_slist_free (notif_list);
1399
1400 #endif /* MODEST_HAVE_HILDON_NOTIFY */
1401 }
1402
1403
1404
1405 GtkWidget * 
1406 modest_platform_get_global_settings_dialog ()
1407 {
1408         return modest_maemo_global_settings_dialog_new ();
1409 }
1410
1411 void
1412 modest_platform_show_help (GtkWindow *parent_window, 
1413                            const gchar *help_id)
1414 {
1415         osso_return_t result;
1416         g_return_if_fail (help_id);
1417
1418         result = hildon_help_show (modest_maemo_utils_get_osso_context(),
1419                                    help_id, HILDON_HELP_SHOW_DIALOG);
1420         
1421         if (result != OSSO_OK) {
1422                 gchar *error_msg;
1423                 error_msg = g_strdup_printf ("FIXME The help topic %s could not be found", help_id); 
1424                 hildon_banner_show_information (GTK_WIDGET (parent_window),
1425                                                 NULL,
1426                                                 error_msg);
1427                 g_free (error_msg);
1428         }
1429 }
1430
1431 void 
1432 modest_platform_show_search_messages (GtkWindow *parent_window)
1433 {
1434         osso_return_t result = OSSO_ERROR;
1435         
1436         result = osso_rpc_run_with_defaults (modest_maemo_utils_get_osso_context(),
1437                                              "osso_global_search",
1438                                              "search_email", NULL, DBUS_TYPE_INVALID);
1439
1440         if (result != OSSO_OK) {
1441                 g_warning ("%s: osso_rpc_run_with_defaults() failed.\n", __FUNCTION__);
1442         }
1443 }
1444
1445 void 
1446 modest_platform_show_addressbook (GtkWindow *parent_window)
1447 {
1448         osso_return_t result = OSSO_ERROR;
1449         
1450         result = osso_rpc_run_with_defaults (modest_maemo_utils_get_osso_context(),
1451                                              "osso_addressbook",
1452                                              "top_application", NULL, DBUS_TYPE_INVALID);
1453
1454         if (result != OSSO_OK) {
1455                 g_warning ("%s: osso_rpc_run_with_defaults() failed.\n", __FUNCTION__);
1456         }
1457 }
1458
1459 GtkWidget *
1460 modest_platform_create_folder_view (TnyFolderStoreQuery *query)
1461 {
1462         GtkWidget *widget = modest_folder_view_new (query);
1463
1464         /* Show one account by default */
1465         modest_folder_view_set_style (MODEST_FOLDER_VIEW (widget),
1466                                       MODEST_FOLDER_VIEW_STYLE_SHOW_ONE);
1467
1468         /* Restore settings */
1469         modest_widget_memory_restore (modest_runtime_get_conf(), 
1470                                       G_OBJECT (widget),
1471                                       MODEST_CONF_FOLDER_VIEW_KEY);
1472
1473         return widget;
1474 }
1475
1476 void
1477 banner_finish (gpointer data, GObject *object)
1478 {
1479         ModestWindowMgr *mgr = (ModestWindowMgr *) data;
1480         modest_window_mgr_unregister_banner (mgr);
1481         g_object_unref (mgr);
1482 }
1483
1484 void 
1485 modest_platform_information_banner (GtkWidget *parent,
1486                                     const gchar *icon_name,
1487                                     const gchar *text)
1488 {
1489         GtkWidget *banner, *banner_parent = NULL;
1490         ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
1491
1492         if (modest_window_mgr_num_windows (mgr) == 0)
1493                 return;
1494
1495         if (parent && GTK_IS_WINDOW (parent)) {
1496                 /* If the window is the active one then show the
1497                    banner on top of this window */
1498                 if (gtk_window_is_active (GTK_WINDOW (parent)))
1499                         banner_parent = parent;
1500                 /* If the window is not the topmost but it's visible
1501                    (it's minimized for example) then show the banner
1502                    with no parent */ 
1503                 else if (GTK_WIDGET_VISIBLE (parent))
1504                         banner_parent = NULL;
1505                 /* If the window is hidden (like the main window when
1506                    running in the background) then do not show
1507                    anything */
1508                 else 
1509                         return;
1510         }
1511
1512
1513         banner = hildon_banner_show_information (banner_parent, icon_name, text);
1514
1515         modest_window_mgr_register_banner (mgr);
1516         g_object_ref (mgr);
1517         g_object_weak_ref ((GObject *) banner, banner_finish, mgr);
1518 }
1519
1520 void
1521 modest_platform_information_banner_with_timeout (GtkWidget *parent,
1522                                                  const gchar *icon_name,
1523                                                  const gchar *text,
1524                                                  gint timeout)
1525 {
1526         GtkWidget *banner;
1527
1528         if (modest_window_mgr_num_windows (modest_runtime_get_window_mgr ()) == 0)
1529                 return;
1530
1531         banner = hildon_banner_show_information (parent, icon_name, text);
1532         hildon_banner_set_timeout(HILDON_BANNER(banner), timeout);
1533 }
1534
1535 GtkWidget *
1536 modest_platform_animation_banner (GtkWidget *parent,
1537                                   const gchar *animation_name,
1538                                   const gchar *text)
1539 {
1540         GtkWidget *inf_note = NULL;
1541
1542         g_return_val_if_fail (text != NULL, NULL);
1543
1544         if (modest_window_mgr_num_windows (modest_runtime_get_window_mgr ()) == 0)
1545                 return NULL;
1546
1547         /* If the parent is not visible then do not show */
1548         if (parent && !GTK_WIDGET_VISIBLE (parent))
1549                 return NULL;
1550
1551         inf_note = hildon_banner_show_animation (parent, animation_name, text);
1552
1553         return inf_note;
1554 }
1555
1556 typedef struct
1557 {
1558         GMainLoop* loop;
1559         TnyAccount *account;
1560         gboolean is_online;
1561         gint count_tries;
1562 } CheckAccountIdleData;
1563
1564 #define NUMBER_OF_TRIES 10 /* Try approx every second, ten times. */
1565
1566 static gboolean 
1567 on_timeout_check_account_is_online(CheckAccountIdleData* data)
1568 {
1569         gboolean stop_trying = FALSE;
1570         g_return_val_if_fail (data && data->account, FALSE);
1571         
1572         printf ("DEBUG: %s: tny_account_get_connection_status()==%d\n", __FUNCTION__,
1573                 tny_account_get_connection_status (data->account));     
1574         
1575         if (data && data->account && 
1576                 /* We want to wait until TNY_CONNECTION_STATUS_INIT has changed to something else,
1577                  * after which the account is likely to be usable, or never likely to be usable soon: */
1578                 (tny_account_get_connection_status (data->account) != TNY_CONNECTION_STATUS_INIT) )
1579         {
1580                 data->is_online = TRUE;
1581                 
1582                 stop_trying = TRUE;
1583         } else {
1584                 /* Give up if we have tried too many times: */
1585                 if (data->count_tries >= NUMBER_OF_TRIES) {
1586                         stop_trying = TRUE;
1587                 } else {
1588                         /* Wait for another timeout: */
1589                         ++(data->count_tries);
1590                 }
1591         }
1592         
1593         if (stop_trying) {
1594                 /* Allow the function that requested this idle callback to continue: */
1595                 if (data->loop)
1596                         g_main_loop_quit (data->loop);
1597                         
1598                 if (data->account)
1599                         g_object_unref (data->account);
1600                 
1601                 return FALSE; /* Don't call this again. */
1602         } else {
1603                 return TRUE; /* Call this timeout callback again. */
1604         }
1605 }
1606
1607 /* Return TRUE immediately if the account is already online,
1608  * otherwise check every second for NUMBER_OF_TRIES seconds and return TRUE as 
1609  * soon as the account is online, or FALSE if the account does 
1610  * not become online in the NUMBER_OF_TRIES seconds.
1611  * This is useful when the D-Bus method was run immediately after 
1612  * the application was started (when using D-Bus activation), 
1613  * because the account usually takes a short time to go online.
1614  * The return value is maybe not very useful.
1615  */
1616 gboolean
1617 modest_platform_check_and_wait_for_account_is_online(TnyAccount *account)
1618 {
1619         gboolean is_online;
1620
1621         g_return_val_if_fail (account, FALSE);
1622         
1623         printf ("DEBUG: %s: account id=%s\n", __FUNCTION__, tny_account_get_id (account));
1624         
1625         if (!tny_device_is_online (modest_runtime_get_device())) {
1626                 printf ("DEBUG: %s: device is offline.\n", __FUNCTION__);
1627                 return FALSE;
1628         }
1629         
1630         /* The local_folders account never seems to leave TNY_CONNECTION_STATUS_INIT,
1631          * so we avoid wait unnecessarily: */
1632         if (!TNY_IS_CAMEL_POP_STORE_ACCOUNT (account) && 
1633                 !TNY_IS_CAMEL_IMAP_STORE_ACCOUNT (account) ) {
1634                 return TRUE;            
1635         }
1636                 
1637         printf ("DEBUG: %s: tny_account_get_connection_status()==%d\n",
1638                 __FUNCTION__, tny_account_get_connection_status (account));
1639         
1640         /* The POP & IMAP store accounts seem to be TNY_CONNECTION_STATUS_DISCONNECTED, 
1641          * and that seems to be an OK time to use them. Maybe it's just TNY_CONNECTION_STATUS_INIT that 
1642          * we want to avoid. */
1643         if (tny_account_get_connection_status (account) != TNY_CONNECTION_STATUS_INIT)
1644                 return TRUE;
1645                 
1646         /* This blocks on the result: */
1647         CheckAccountIdleData *data = g_slice_new0 (CheckAccountIdleData);
1648         data->is_online = FALSE;
1649         data->account = account;
1650         g_object_ref (data->account);
1651         data->count_tries = 0;
1652                 
1653         GMainContext *context = NULL; /* g_main_context_new (); */
1654         data->loop = g_main_loop_new (context, FALSE /* not running */);
1655
1656         g_timeout_add (1000, (GSourceFunc)(on_timeout_check_account_is_online), data);
1657
1658         /* This main loop will run until the idle handler has stopped it: */
1659         g_main_loop_run (data->loop);
1660
1661         g_main_loop_unref (data->loop);
1662         /* g_main_context_unref (context); */
1663
1664         is_online = data->is_online;
1665         g_slice_free (CheckAccountIdleData, data);
1666         
1667         return is_online;       
1668 }
1669
1670
1671
1672 static void
1673 on_cert_dialog_response (GtkDialog *dialog, gint response_id,  const gchar* cert)
1674 {
1675         /* GTK_RESPONSE_HELP means we need to show the certificate */
1676         if (response_id == GTK_RESPONSE_APPLY) {
1677                 GtkWidget *note;
1678                 gchar *msg;
1679                 
1680                 /* Do not close the dialog */
1681                 g_signal_stop_emission_by_name (dialog, "response");
1682
1683                 msg = g_strdup_printf (_("mcen_ni_view_unknown_certificate"), cert);    
1684                 note = hildon_note_new_information (GTK_WINDOW(dialog), msg);
1685                 gtk_dialog_run (GTK_DIALOG(note));
1686                 gtk_widget_destroy (note);
1687         }
1688 }
1689
1690
1691 gboolean
1692 modest_platform_run_certificate_confirmation_dialog (const gchar* server_name,
1693                                                      const gchar *certificate)
1694 {
1695         GtkWidget *note;
1696         gint response;
1697         ModestWindow *main_win;
1698         
1699         if (!modest_window_mgr_main_window_exists (modest_runtime_get_window_mgr())) {
1700                 g_warning ("%s: don't show dialogs if there's no main window; assuming 'Cancel'",
1701                            __FUNCTION__);
1702                 return FALSE;
1703         }
1704
1705         /* don't create it */
1706         main_win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(), FALSE);
1707         g_return_val_if_fail (main_win, FALSE); /* should not happen */
1708         
1709         
1710         gchar *question = g_strdup_printf (_("mcen_nc_unknown_certificate"),
1711                                            server_name);
1712         
1713         /* We use GTK_RESPONSE_APPLY because we want the button in the
1714            middle of OK and CANCEL the same as the browser does for
1715            example. With GTK_RESPONSE_HELP the view button is aligned
1716            to the left while the other two to the right */
1717         note = hildon_note_new_confirmation_add_buttons  (
1718                 GTK_WINDOW(main_win),
1719                 question,
1720                 _("mcen_bd_dialog_ok"),     GTK_RESPONSE_OK,
1721                 _("mcen_bd_view"),          GTK_RESPONSE_APPLY,   /* abusing this... */
1722                 _("mcen_bd_dialog_cancel"), GTK_RESPONSE_CANCEL,
1723                 NULL, NULL);
1724         
1725         g_signal_connect (G_OBJECT(note), "response", 
1726                           G_CALLBACK(on_cert_dialog_response),
1727                           (gpointer) certificate);
1728         
1729         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1730                                      GTK_WINDOW (note), (GtkWindow *) main_win);
1731         response = gtk_dialog_run(GTK_DIALOG(note));
1732
1733         on_destroy_dialog (note);
1734         g_free (question);
1735         
1736         return response == GTK_RESPONSE_OK;
1737 }
1738
1739 gboolean
1740 modest_platform_run_alert_dialog (const gchar* prompt, 
1741                                   gboolean is_question)
1742 {       
1743         ModestWindow *main_win; 
1744
1745         if (!modest_window_mgr_main_window_exists (modest_runtime_get_window_mgr())) {
1746                 g_warning ("%s:\n'%s'\ndon't show dialogs if there's no main window;"
1747                            " assuming 'Cancel' for questions, 'Ok' otherwise", prompt, __FUNCTION__);
1748                 return is_question ? FALSE : TRUE;
1749         }
1750
1751         main_win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (), FALSE);
1752         g_return_val_if_fail (main_win, FALSE); /* should not happen */
1753         
1754         gboolean retval = TRUE;
1755         if (is_question) {
1756                 /* The Tinymail documentation says that we should show Yes and No buttons, 
1757                  * when it is a question.
1758                  * Obviously, we need tinymail to use more specific error codes instead,
1759                  * so we know what buttons to show. */
1760                 GtkWidget *dialog = GTK_WIDGET (hildon_note_new_confirmation (GTK_WINDOW (main_win), 
1761                                                                               prompt));
1762                 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1763                                              GTK_WINDOW (dialog), (GtkWindow *) main_win);
1764                 
1765                 const int response = gtk_dialog_run (GTK_DIALOG (dialog));
1766                 retval = (response == GTK_RESPONSE_YES) || (response == GTK_RESPONSE_OK);
1767                 
1768                 on_destroy_dialog (dialog);             
1769         } else {
1770                 /* Just show the error text and use the default response: */
1771                 modest_platform_run_information_dialog (GTK_WINDOW (main_win), 
1772                                                         prompt, FALSE);
1773         }
1774         return retval;
1775 }
1776
1777 /***************/
1778 typedef struct {
1779         GtkWindow *parent_window;
1780         ModestConnectedPerformer callback;
1781         TnyAccount *account;
1782         gpointer user_data;
1783         gchar *iap;
1784         TnyDevice *device;
1785 } OnWentOnlineInfo;
1786  
1787 static void 
1788 on_went_online_info_free (OnWentOnlineInfo *info)
1789 {
1790         /* And if we cleanup, we DO cleanup  :-)  */
1791         
1792         if (info->device)
1793                 g_object_unref (info->device);
1794         if (info->iap)
1795                 g_free (info->iap);
1796         if (info->parent_window)
1797                 g_object_unref (info->parent_window);
1798         if (info->account)
1799                 g_object_unref (info->account);
1800         
1801         g_slice_free (OnWentOnlineInfo, info);
1802         
1803         /* We're done ... */
1804         
1805         return;
1806 }
1807  
1808 static void
1809 on_account_went_online (TnyCamelAccount *account, gboolean canceled, GError *err, gpointer user_data)
1810 {
1811         OnWentOnlineInfo *info = (OnWentOnlineInfo *) user_data;
1812  
1813         /* Now it's really time to callback to the caller. If going online didn't succeed,
1814          * err will be set. We don't free it, Tinymail does that! If a cancel happened,
1815          * canceled will be set. Etcetera etcetera. */
1816         
1817         if (info->callback) {
1818                 info->callback (canceled, err, info->parent_window, info->account, info->user_data);
1819         }
1820         
1821         /* This is our last call, we must cleanup here if we didn't yet do that */
1822         on_went_online_info_free (info);
1823         
1824         return;
1825 }
1826  
1827  
1828 static void
1829 on_conic_device_went_online (TnyMaemoConicDevice *device, const gchar* iap_id, gboolean canceled, GError *err, gpointer user_data)
1830 {
1831         OnWentOnlineInfo *info = (OnWentOnlineInfo *) user_data;
1832         info->iap = g_strdup (iap_id);
1833         
1834         if (canceled || err || !info->account) {
1835         
1836                 /* If there's a problem or if there's no account (then that's it for us, we callback
1837                  * the caller's callback now. He'll have to handle err or canceled, of course.
1838                  * We are not really online, as the account is not really online here ... */    
1839                 
1840                 /* We'll use the err and the canceled of this cb. TnyMaemoConicDevice delivered us
1841                  * this info. We don't cleanup err, Tinymail does that! */
1842                 
1843                 if (info->callback) {
1844                         
1845                         /* info->account can be NULL here, this means that the user did not
1846                          * provide a nice account instance. We'll assume that the user knows
1847                          * what he's doing and is happy with just the device going online. 
1848                          * 
1849                          * We can't do magic, we don't know what account the user wants to
1850                          * see going online. So just the device goes online, end of story */
1851                         
1852                         info->callback (canceled, err, info->parent_window, info->account, info->user_data);
1853                 }
1854                 
1855         } else if (info->account) {
1856                 
1857                 /* If there's no problem and if we have an account, we'll put the account
1858                  * online too. When done, the callback of bringing the account online
1859                  * will callback the caller's callback. This is the most normal case. */
1860  
1861                 info->device = TNY_DEVICE (g_object_ref (device));
1862                 
1863                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (info->account), TRUE,
1864                                               on_account_went_online, info);
1865                 
1866                 /* The on_account_went_online cb frees up the info, go look if you
1867                  * don't believe me! (so we return here) */
1868                 
1869                 return;
1870         }
1871         
1872         /* We cleanup if we are not bringing the account online too */
1873         on_went_online_info_free (info);
1874  
1875         return; 
1876 }
1877         
1878 void 
1879 modest_platform_connect_and_perform (GtkWindow *parent_window, 
1880                                      gboolean force,
1881                                      TnyAccount *account, 
1882                                      ModestConnectedPerformer callback, 
1883                                      gpointer user_data)
1884 {
1885         gboolean device_online;
1886         TnyDevice *device;
1887         TnyConnectionStatus conn_status;
1888         OnWentOnlineInfo *info;
1889         
1890         device = modest_runtime_get_device();
1891         device_online = tny_device_is_online (device);
1892
1893         /* If there is no account check only the device status */
1894         if (!account) {
1895                 
1896                 if (device_online) {
1897  
1898                         /* We promise to instantly perform the callback, so ... */
1899                         if (callback) {
1900                                 callback (FALSE, NULL, parent_window, account, user_data);
1901                         }
1902                         
1903                 } else {
1904                         
1905                         info = g_slice_new0 (OnWentOnlineInfo);
1906                         
1907                         info->iap = NULL;
1908                         info->device = NULL;
1909                         info->account = NULL;
1910                 
1911                         if (parent_window)
1912                                 info->parent_window = (GtkWindow *) g_object_ref (parent_window);
1913                         else
1914                                 info->parent_window = NULL;
1915                         info->user_data = user_data;
1916                         info->callback = callback;
1917                 
1918                         tny_maemo_conic_device_connect_async (TNY_MAEMO_CONIC_DEVICE (device), NULL,
1919                                                               force, on_conic_device_went_online, 
1920                                                               info);
1921  
1922                         /* We'll cleanup in on_conic_device_went_online */
1923                 }
1924  
1925                 /* The other code has no more reason to run. This is all that we can do for the
1926                  * caller (he should have given us a nice and clean account instance!). We
1927                  * can't do magic, we don't know what account he intends to bring online. So
1928                  * we'll just bring the device online (and await his false bug report). */
1929                 
1930                 return;
1931         }
1932  
1933         
1934         /* Return if the account is already connected */
1935         
1936         conn_status = tny_account_get_connection_status (account);
1937         if (device_online && conn_status == TNY_CONNECTION_STATUS_CONNECTED) {
1938  
1939                 /* We promise to instantly perform the callback, so ... */
1940                 if (callback) {
1941                         callback (FALSE, NULL, parent_window, account, user_data);
1942                 }
1943                 
1944                 return;
1945         }
1946         
1947         /* Else, we are in a state that requires that we go online before we
1948          * call the caller's callback. */
1949         
1950         info = g_slice_new0 (OnWentOnlineInfo);
1951         
1952         info->device = NULL;
1953         info->iap = NULL;
1954         info->account = TNY_ACCOUNT (g_object_ref (account));
1955         
1956         if (parent_window)
1957                 info->parent_window = (GtkWindow *) g_object_ref (parent_window);
1958         else
1959                 info->parent_window = NULL;
1960         
1961         /* So we'll put the callback away for later ... */
1962         
1963         info->user_data = user_data;
1964         info->callback = callback;
1965         
1966         if (!device_online) {
1967  
1968                 /* If also the device is offline, then we connect both the device 
1969                  * and the account */
1970                 
1971                 tny_maemo_conic_device_connect_async (TNY_MAEMO_CONIC_DEVICE (device), NULL,
1972                                                       force, on_conic_device_went_online, 
1973                                                       info);
1974                 
1975         } else {
1976                 
1977                 /* If the device is online, we'll just connect the account */
1978                 
1979                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (account), TRUE, 
1980                                               on_account_went_online, info);
1981         }
1982  
1983         /* The info gets freed by on_account_went_online or on_conic_device_went_online
1984          * in both situations, go look if you don't believe me! */
1985         
1986         return;
1987 }
1988
1989 void
1990 modest_platform_connect_if_remote_and_perform (GtkWindow *parent_window, 
1991                                                gboolean force,
1992                                                TnyFolderStore *folder_store, 
1993                                                ModestConnectedPerformer callback, 
1994                                                gpointer user_data)
1995 {
1996         TnyAccount *account = NULL;
1997         
1998         if (!folder_store) {
1999                 /* We promise to instantly perform the callback, so ... */
2000                 if (callback) {
2001                         callback (FALSE, NULL, parent_window, NULL, user_data);
2002                 }
2003                 return; 
2004                 
2005                 /* Original comment: Maybe it is something local. */
2006                 /* PVH's comment: maybe we should KNOW this in stead of assuming? */
2007                 
2008         } else if (TNY_IS_FOLDER (folder_store)) {
2009                 /* Get the folder's parent account: */
2010                 account = tny_folder_get_account (TNY_FOLDER (folder_store));
2011         } else if (TNY_IS_ACCOUNT (folder_store)) {
2012                 /* Use the folder store as an account: */
2013                 account = TNY_ACCOUNT (g_object_ref (folder_store));
2014         }
2015  
2016         if (tny_account_get_account_type (account) == TNY_ACCOUNT_TYPE_STORE) {
2017                 if (!TNY_IS_CAMEL_POP_STORE_ACCOUNT (account) &&
2018                     !TNY_IS_CAMEL_IMAP_STORE_ACCOUNT (account)) {
2019  
2020                         /* No need to connect a local account */
2021                         if (callback)
2022                                 callback (FALSE, NULL, parent_window, account, user_data);
2023
2024                         goto clean;
2025                 }
2026         }
2027         modest_platform_connect_and_perform (parent_window, force, account, callback, user_data);
2028  
2029  clean:
2030         if (account)
2031                 g_object_unref (account);
2032 }
2033
2034 static void
2035 src_account_connect_performer (gboolean canceled, 
2036                                GError *err,
2037                                GtkWindow *parent_window, 
2038                                TnyAccount *src_account, 
2039                                gpointer user_data)
2040 {
2041         DoubleConnectionInfo *info = (DoubleConnectionInfo *) user_data;
2042
2043         if (canceled || err) {
2044                 /* If there was any error call the user callback */
2045                 info->callback (canceled, err, parent_window, src_account, info->data);
2046         } else {
2047                 /* Connect the destination account */
2048                 modest_platform_connect_if_remote_and_perform (parent_window, TRUE, 
2049                                                                TNY_FOLDER_STORE (info->dst_account),
2050                                                                info->callback, info->data);
2051         }
2052
2053         /* Free the info object */
2054         g_object_unref (info->dst_account);
2055         g_slice_free (DoubleConnectionInfo, info);
2056 }
2057
2058
2059 void 
2060 modest_platform_double_connect_and_perform (GtkWindow *parent_window, 
2061                                             gboolean force,
2062                                             TnyFolderStore *folder_store,
2063                                             DoubleConnectionInfo *connect_info)
2064 {
2065         modest_platform_connect_if_remote_and_perform(parent_window, 
2066                                                       force,
2067                                                       folder_store, 
2068                                                       src_account_connect_performer, 
2069                                                       connect_info);
2070 }
2071
2072 GtkWidget *
2073 modest_platform_get_account_settings_wizard (void)
2074 {
2075         ModestEasysetupWizardDialog *dialog = modest_easysetup_wizard_dialog_new ();
2076
2077         return GTK_WIDGET (dialog);
2078 }
2079
2080 ModestConnectedVia
2081 modest_platform_get_current_connection (void)
2082 {
2083         TnyDevice *device = NULL;
2084         ModestConnectedVia retval = MODEST_CONNECTED_VIA_ANY;
2085         
2086         device = modest_runtime_get_device ();
2087
2088         if (!tny_device_is_online (device))
2089                 return MODEST_CONNECTED_VIA_ANY;
2090
2091 #ifdef MODEST_HAVE_CONIC
2092         /* Get iap id */
2093         const gchar *iap_id = tny_maemo_conic_device_get_current_iap_id (TNY_MAEMO_CONIC_DEVICE (device));
2094         if (iap_id) {
2095                 ConIcIap *iap = tny_maemo_conic_device_get_iap (
2096                         TNY_MAEMO_CONIC_DEVICE (device), iap_id);
2097                 const gchar *bearer_type = con_ic_iap_get_bearer_type (iap);
2098                 if (bearer_type) {
2099                         if (!strcmp (bearer_type, CON_IC_BEARER_WLAN_INFRA) ||
2100                             !strcmp (bearer_type, CON_IC_BEARER_WLAN_ADHOC) ||
2101                             !strcmp (bearer_type, "WIMAX")) {
2102                                 retval = MODEST_CONNECTED_VIA_WLAN_OR_WIMAX;
2103                         } else {
2104                                 retval = MODEST_CONNECTED_VIA_ANY;
2105                         }
2106                 }       
2107                 g_object_unref (iap);
2108         }
2109 #else
2110         retval = MODEST_CONNECTED_VIA_WLAN_OR_WIMAX; /* assume WLAN (fast) internet */  
2111 #endif /* MODEST_HAVE_CONIC */
2112         return retval;
2113 }
2114
2115
2116
2117 gboolean
2118 modest_platform_check_memory_low (ModestWindow *win,
2119                                   gboolean visuals)
2120 {
2121         gboolean lowmem;
2122         
2123         /* are we in low memory state? */
2124         lowmem = osso_mem_in_lowmem_state () ? TRUE : FALSE;
2125         
2126         if (win && lowmem && visuals)
2127                 modest_platform_run_information_dialog (
2128                         GTK_WINDOW(win),
2129                         dgettext("ke-recv","memr_ib_operation_disabled"),
2130                         TRUE);
2131
2132         if (lowmem)
2133                 g_debug ("%s: low memory reached. disallowing some operations",
2134                          __FUNCTION__);
2135
2136         return lowmem;
2137 }