git.maemo.org Git - modest/blob - src/hildon2/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 "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 <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 <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/libalarm.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
 535         /* Show WID-INF036 */
 536         if (chars_length >= 20) {
 537                 hildon_banner_show_information  (gtk_widget_get_parent (GTK_WIDGET (data)), NULL,
 538                                                  _CS("ckdg_ib_maximum_characters_reached"));
 539         } else {
 540                 if (modest_text_utils_is_forbidden_char (*text, FOLDER_NAME_FORBIDDEN_CHARS)) {
 541                         /* Show an error */
 542                         gchar *tmp, *msg;
 543
 544                         tmp = g_strndup (folder_name_forbidden_chars,
 545                                          FOLDER_NAME_FORBIDDEN_CHARS_LENGTH);
 546                         msg = g_strdup_printf (_CS("ckdg_ib_illegal_characters_entered"), tmp);
 547                         hildon_banner_show_information  (gtk_widget_get_parent (GTK_WIDGET (data)),
 548                                                          NULL, msg);
 549                         g_free (msg);
 550                         g_free (tmp);
 551                 } else {
 552                         /* Write the text in the entry if it's valid */
 553                         g_signal_handlers_block_by_func (editable,
 554                                                          (gpointer) entry_insert_text, data);
 555                         gtk_editable_insert_text (editable, text, length, position);
 556                         g_signal_handlers_unblock_by_func (editable,
 557                                                            (gpointer) entry_insert_text, data);
 558                 }
 559         }
 560         /* Do not allow further processing */
 561         g_signal_stop_emission_by_name (editable, "insert_text");
 562 }
 563
 564 static void
 565 entry_changed (GtkEditable *editable,
 566                gpointer     user_data)
 567 {
 568         gchar *chars;
 569         GtkWidget *ok_button;
 570         GList *buttons;
 571
 572         buttons = gtk_container_get_children (GTK_CONTAINER (GTK_DIALOG (user_data)->action_area));
 573         ok_button = GTK_WIDGET (buttons->next->data);
 574
 575         chars = gtk_editable_get_chars (editable, 0, -1);
 576         g_return_if_fail (chars != NULL);
 577
 578
 579         if (g_utf8_strlen (chars,-1) >= 21)
 580                 hildon_banner_show_information  (gtk_widget_get_parent (GTK_WIDGET (user_data)), NULL,
 581                                                  _CS("ckdg_ib_maximum_characters_reached"));
 582         else
 583                 gtk_widget_set_sensitive (ok_button, modest_text_utils_validate_folder_name(chars));
 584
 585         /* Free */
 586         g_list_free (buttons);
 587         g_free (chars);
 588 }
 589
 590
 591
 592 static void
 593 on_response (GtkDialog *dialog,
 594              gint response,
 595              gpointer user_data)
 596 {
 597         GList *child_vbox, *child_hbox;
 598         GtkWidget *hbox, *entry;
 599         TnyFolderStore *parent;
 600         const gchar *new_name;
 601         gboolean exists;
 602
 603         if (response != GTK_RESPONSE_ACCEPT)
 604                 return;
 605
 606         /* Get entry */
 607         child_vbox = gtk_container_get_children (GTK_CONTAINER (dialog->vbox));
 608         hbox = child_vbox->data;
 609         child_hbox = gtk_container_get_children (GTK_CONTAINER (hbox));
 610         entry = child_hbox->next->data;
 611
 612         parent = TNY_FOLDER_STORE (user_data);
 613         new_name = gtk_entry_get_text (GTK_ENTRY (entry));
 614         exists = FALSE;
 615
 616         /* Look for another folder with the same name */
 617         if (modest_tny_folder_has_subfolder_with_name (parent,
 618                                                        new_name,
 619                                                        TRUE)) {
 620                 exists = TRUE;
 621         }
 622
 623         if (!exists) {
 624                 if (TNY_IS_ACCOUNT (parent) &&
 625                     modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent)) &&
 626                     modest_tny_local_folders_account_folder_name_in_use (MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (parent),
 627                                                                          new_name)) {
 628                         exists = TRUE;
 629                 }
 630         }
 631
 632         if (exists) {
 633
 634                 /* Show an error */
 635                 hildon_banner_show_information (gtk_widget_get_parent (GTK_WIDGET (dialog)),
 636                                                 NULL, _CS("ckdg_ib_folder_already_exists"));
 637                 /* Select the text */
 638                 gtk_entry_select_region (GTK_ENTRY (entry), 0, -1);
 639                 gtk_widget_grab_focus (entry);
 640                 /* Do not close the dialog */
 641                 g_signal_stop_emission_by_name (dialog, "response");
 642         }
 643 }
 644
 645
 646
 647 static gint
 648 modest_platform_run_folder_name_dialog (GtkWindow *parent_window,
 649                                         TnyFolderStore *parent,
 650                                         const gchar *dialog_title,
 651                                         const gchar *label_text,
 652                                         const gchar *suggested_name,
 653                                         gchar **folder_name)
 654 {
 655         GtkWidget *accept_btn = NULL;
 656         GtkWidget *dialog, *entry, *label, *hbox;
 657         GList *buttons = NULL;
 658         gint result;
 659
 660         /* Ask the user for the folder name */
 661         dialog = gtk_dialog_new_with_buttons (dialog_title,
 662                                               parent_window,
 663                                               GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
 664                                               _("mcen_bd_dialog_ok"),
 665                                               GTK_RESPONSE_ACCEPT,
 666                                               _("mcen_bd_dialog_cancel"),
 667                                               GTK_RESPONSE_REJECT,
 668                                               NULL);
 669
 670         /* Add accept button (with unsensitive handler) */
 671         buttons = gtk_container_get_children (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area));
 672         accept_btn = GTK_WIDGET (buttons->next->data);
 673         /* Create label and entry */
 674         label = gtk_label_new (label_text);
 675         /* TODO: check that the suggested name does not exist */
 676         /* We set 21 as maximum because we want to show WID-INF036
 677            when the user inputs more that 20 */
 678         entry = gtk_entry_new_with_max_length (21);
 679         if (suggested_name)
 680                 gtk_entry_set_text (GTK_ENTRY (entry), suggested_name);
 681         else
 682                 gtk_entry_set_text (GTK_ENTRY (entry), _("mcen_ia_default_folder_name"));
 683         gtk_entry_set_width_chars (GTK_ENTRY (entry),
 684                                    MAX (g_utf8_strlen (gtk_entry_get_text (GTK_ENTRY (entry)), -1),
 685                                         g_utf8_strlen (_("mcen_ia_default_folder_name"), -1)));
 686         gtk_entry_select_region (GTK_ENTRY (entry), 0, -1);
 687
 688         /* Connect to the response method to avoid closing the dialog
 689            when an invalid name is selected*/
 690         g_signal_connect (dialog,
 691                           "response",
 692                           G_CALLBACK (on_response),
 693                           parent);
 694
 695         /* Track entry changes */
 696         g_signal_connect (entry,
 697                           "insert-text",
 698                           G_CALLBACK (entry_insert_text),
 699                           dialog);
 700         g_signal_connect (entry,
 701                           "changed",
 702                           G_CALLBACK (entry_changed),
 703                           dialog);
 704
 705
 706         /* Some locales like pt_BR need this to get the full window
 707            title shown */
 708         gtk_widget_set_size_request (GTK_WIDGET (dialog), 300, -1);
 709
 710         /* Create the hbox */
 711         hbox = gtk_hbox_new (FALSE, 12);
 712         gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 713         gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
 714
 715         /* Add hbox to dialog */
 716         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
 717                             hbox, FALSE, FALSE, 0);
 718         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
 719                                      GTK_WINDOW (dialog));
 720         gtk_widget_show_all (GTK_WIDGET(dialog));
 721
 722         result = gtk_dialog_run (GTK_DIALOG(dialog));
 723         if (result == GTK_RESPONSE_ACCEPT)
 724                 *folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
 725
 726         gtk_widget_destroy (dialog);
 727
 728         while (gtk_events_pending ())
 729                 gtk_main_iteration ();
 730
 731         return result;
 732 }
 733
 734 gint
 735 modest_platform_run_new_folder_dialog (GtkWindow *parent_window,
 736                                        TnyFolderStore *parent_folder,
 737                                        gchar *suggested_name,
 738                                        gchar **folder_name)
 739 {
 740         gchar *real_suggested_name = NULL, *tmp = NULL;
 741         gint result;
 742
 743         if(suggested_name == NULL)
 744         {
 745                 const gchar *default_name = _("mcen_ia_default_folder_name");
 746                 unsigned int i;
 747                 gchar num_str[3];
 748
 749                 for(i = 0; i < 100; ++ i) {
 750                         gboolean exists = FALSE;
 751
 752                         sprintf(num_str, "%.2u", i);
 753
 754                         if (i == 0)
 755                                 real_suggested_name = g_strdup (default_name);
 756                         else
 757                                 real_suggested_name = g_strdup_printf (_("mcen_ia_default_folder_name_s"),
 758                                                                        num_str);
 759                         exists = modest_tny_folder_has_subfolder_with_name (parent_folder,
 760                                                                             real_suggested_name,
 761                                                                             TRUE);
 762
 763                         if (!exists)
 764                                 break;
 765
 766                         g_free (real_suggested_name);
 767                 }
 768
 769                 /* Didn't find a free number */
 770                 if (i == 100)
 771                         real_suggested_name = g_strdup (default_name);
 772         } else {
 773                 real_suggested_name = suggested_name;
 774         }
 775
 776         tmp = g_strconcat (_("mcen_fi_new_folder_name"), ":", NULL);
 777         result = modest_platform_run_folder_name_dialog (parent_window,
 778                                                          parent_folder,
 779                                                          _("mcen_ti_new_folder"),
 780                                                          tmp,
 781                                                          real_suggested_name,
 782                                                          folder_name);
 783         g_free (tmp);
 784
 785         if (suggested_name == NULL)
 786                 g_free(real_suggested_name);
 787
 788         return result;
 789 }
 790
 791 gint
 792 modest_platform_run_rename_folder_dialog (GtkWindow *parent_window,
 793                                           TnyFolderStore *parent_folder,
 794                                           const gchar *suggested_name,
 795                                           gchar **folder_name)
 796 {
 797         g_return_val_if_fail (TNY_IS_FOLDER_STORE (parent_folder), GTK_RESPONSE_REJECT);
 798
 799         return modest_platform_run_folder_name_dialog (parent_window,
 800                                                        parent_folder,
 801                                                        _HL("ckdg_ti_rename_folder"),
 802                                                        _HL("ckdg_fi_rename_name"),
 803                                                        suggested_name,
 804                                                        folder_name);
 805 }
 806
 807
 808
 809 static void
 810 on_destroy_dialog (GtkWidget *dialog)
 811 {
 812         /* This could happen when the dialogs get programatically
 813            hidden or destroyed (for example when closing the
 814            application while a dialog is being shown) */
 815         if (!GTK_IS_WIDGET (dialog))
 816                 return;
 817
 818         gtk_widget_destroy (dialog);
 819
 820         if (gtk_events_pending ())
 821                 gtk_main_iteration ();
 822 }
 823
 824 gint
 825 modest_platform_run_confirmation_dialog (GtkWindow *parent_window,
 826                                          const gchar *message)
 827 {
 828         GtkWidget *dialog;
 829         gint response;
 830
 831         dialog = hildon_note_new_confirmation (parent_window, message);
 832         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
 833                                      GTK_WINDOW (dialog));
 834
 835         response = gtk_dialog_run (GTK_DIALOG (dialog));
 836
 837         on_destroy_dialog (dialog);
 838
 839         return response;
 840 }
 841
 842 gint
 843 modest_platform_run_confirmation_dialog_with_buttons (GtkWindow *parent_window,
 844                                                       const gchar *message,
 845                                                       const gchar *button_accept,
 846                                                       const gchar *button_cancel)
 847 {
 848         GtkWidget *dialog;
 849         gint response;
 850
 851         dialog = hildon_note_new_confirmation_add_buttons (parent_window, message,
 852                                                            button_accept, GTK_RESPONSE_ACCEPT,
 853                                                            button_cancel, GTK_RESPONSE_CANCEL,
 854                                                            NULL);
 855         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
 856                                      GTK_WINDOW (dialog));
 857
 858         response = gtk_dialog_run (GTK_DIALOG (dialog));
 859
 860         on_destroy_dialog (dialog);
 861
 862         return response;
 863 }
 864
 865 gint
 866 modest_platform_run_yes_no_dialog (GtkWindow *parent_window,
 867                                    const gchar *message)
 868 {
 869         GtkWidget *dialog;
 870         gint response;
 871
 872         dialog = hildon_note_new_confirmation_add_buttons (parent_window, message,
 873                                                            _("mcen_bd_yes"), GTK_RESPONSE_YES,
 874                                                            _("mcen_bd_no"), GTK_RESPONSE_NO,
 875                                                            NULL);
 876         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (dialog));
 877         response = gtk_dialog_run (GTK_DIALOG (dialog));
 878
 879         on_destroy_dialog (dialog);
 880
 881         return response;
 882 }
 883
 884
 885
 886 void
 887 modest_platform_run_information_dialog (GtkWindow *parent_window,
 888                                         const gchar *message,
 889                                         gboolean block)
 890 {
 891         GtkWidget *note;
 892
 893         note = hildon_note_new_information (parent_window, message);
 894         if (block)
 895                 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
 896                                              GTK_WINDOW (note));
 897
 898         if (block) {
 899                 gtk_dialog_run (GTK_DIALOG (note));
 900
 901                 on_destroy_dialog (note);
 902         } else {
 903                 g_signal_connect_swapped (note,
 904                                           "response",
 905                                           G_CALLBACK (on_destroy_dialog),
 906                                           note);
 907
 908                 gtk_widget_show_all (note);
 909         }
 910 }
 911
 912 typedef struct _ConnectAndWaitData {
 913         GMutex *mutex;
 914         GMainLoop *wait_loop;
 915         gboolean has_callback;
 916         gulong handler;
 917 } ConnectAndWaitData;
 918
 919
 920 static void
 921 quit_wait_loop (TnyAccount *account,
 922                 ConnectAndWaitData *data)
 923 {
 924         /* Set the has_callback to TRUE (means that the callback was
 925            executed and wake up every code waiting for cond to be
 926            TRUE */
 927         g_mutex_lock (data->mutex);
 928         data->has_callback = TRUE;
 929         if (data->wait_loop)
 930                 g_main_loop_quit (data->wait_loop);
 931         g_mutex_unlock (data->mutex);
 932 }
 933
 934 static void
 935 on_connection_status_changed (TnyAccount *account,
 936                               TnyConnectionStatus status,
 937                               gpointer user_data)
 938 {
 939         TnyConnectionStatus conn_status;
 940         ConnectAndWaitData *data;
 941
 942         /* Ignore if reconnecting or disconnected */
 943         conn_status = tny_account_get_connection_status (account);
 944         if (conn_status == TNY_CONNECTION_STATUS_RECONNECTING ||
 945             conn_status == TNY_CONNECTION_STATUS_DISCONNECTED)
 946                 return;
 947
 948         /* Remove the handler */
 949         data = (ConnectAndWaitData *) user_data;
 950         g_signal_handler_disconnect (account, data->handler);
 951
 952         /* Quit from wait loop */
 953         quit_wait_loop (account, (ConnectAndWaitData *) user_data);
 954 }
 955
 956 static void
 957 on_tny_camel_account_set_online_cb (TnyCamelAccount *account,
 958                                     gboolean canceled,
 959                                     GError *err,
 960                                     gpointer user_data)
 961 {
 962         /* Quit from wait loop */
 963         quit_wait_loop (TNY_ACCOUNT (account), (ConnectAndWaitData *) user_data);
 964 }
 965
 966 gboolean
 967 modest_platform_connect_and_wait (GtkWindow *parent_window,
 968                                   TnyAccount *account)
 969 {
 970         ConnectAndWaitData *data = NULL;
 971         gboolean device_online;
 972         TnyDevice *device;
 973         TnyConnectionStatus conn_status;
 974         gboolean user_requested;
 975
 976         device = modest_runtime_get_device();
 977         device_online = tny_device_is_online (device);
 978
 979         /* Whether the connection is user requested or automatically
 980            requested, for example via D-Bus */
 981         user_requested = (parent_window) ? TRUE : FALSE;
 982
 983         /* If there is no account check only the device status */
 984         if (!account) {
 985                 if (device_online)
 986                         return TRUE;
 987                 else
 988                         return tny_maemo_conic_device_connect (TNY_MAEMO_CONIC_DEVICE (device),
 989                                                                NULL, user_requested);
 990         }
 991
 992         /* Return if the account is already connected */
 993         conn_status = tny_account_get_connection_status (account);
 994         if (device_online && conn_status == TNY_CONNECTION_STATUS_CONNECTED)
 995                 return TRUE;
 996
 997         /* Create the helper */
 998         data = g_slice_new0 (ConnectAndWaitData);
 999         data->mutex = g_mutex_new ();
1000         data->has_callback = FALSE;
1001
1002         /* Connect the device */
1003         if (!device_online) {
1004                 /* Track account connection status changes */
1005                 data->handler = g_signal_connect (account, "connection-status-changed",
1006                                                   G_CALLBACK (on_connection_status_changed),
1007                                                   data);
1008                 /* Try to connect the device */
1009                 device_online = tny_maemo_conic_device_connect (TNY_MAEMO_CONIC_DEVICE (device),
1010                                                                 NULL, user_requested);
1011
1012                 /* If the device connection failed then exit */
1013                 if (!device_online && data->handler)
1014                         goto frees;
1015         } else {
1016                 /* Force a reconnection of the account */
1017                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (account), TRUE,
1018                                               on_tny_camel_account_set_online_cb, data);
1019         }
1020
1021         /* Wait until the callback is executed */
1022         g_mutex_lock (data->mutex);
1023         if (!data->has_callback) {
1024                 data->wait_loop = g_main_loop_new (g_main_context_new (), FALSE);
1025                 gdk_threads_leave ();
1026                 g_mutex_unlock (data->mutex);
1027                 g_main_loop_run (data->wait_loop);
1028                 g_mutex_lock (data->mutex);
1029                 gdk_threads_enter ();
1030         }
1031         g_mutex_unlock (data->mutex);
1032
1033  frees:
1034         if (data) {
1035                 if (g_signal_handler_is_connected (account, data->handler))
1036                         g_signal_handler_disconnect (account, data->handler);
1037                 g_mutex_free (data->mutex);
1038                 g_main_loop_unref (data->wait_loop);
1039                 g_slice_free (ConnectAndWaitData, data);
1040         }
1041
1042         conn_status = tny_account_get_connection_status (account);
1043         return (conn_status == TNY_CONNECTION_STATUS_CONNECTED) ? TRUE: FALSE;
1044 }
1045
1046 gboolean
1047 modest_platform_connect_and_wait_if_network_account (GtkWindow *parent_window, TnyAccount *account)
1048 {
1049         if (tny_account_get_account_type (account) == TNY_ACCOUNT_TYPE_STORE) {
1050                 if (!TNY_IS_CAMEL_POP_STORE_ACCOUNT (account) &&
1051                     !TNY_IS_CAMEL_IMAP_STORE_ACCOUNT (account)) {
1052                         /* This must be a maildir account, which does not require a connection: */
1053                         return TRUE;
1054                 }
1055         }
1056
1057         return modest_platform_connect_and_wait (parent_window, account);
1058 }
1059
1060 gboolean
1061 modest_platform_connect_and_wait_if_network_folderstore (GtkWindow *parent_window, TnyFolderStore *folder_store)
1062 {
1063         if (!folder_store)
1064                 return TRUE; /* Maybe it is something local. */
1065
1066         gboolean result = TRUE;
1067         if (TNY_IS_FOLDER (folder_store)) {
1068                 /* Get the folder's parent account: */
1069                 TnyAccount *account = tny_folder_get_account(TNY_FOLDER (folder_store));
1070                 if (account != NULL) {
1071                         result = modest_platform_connect_and_wait_if_network_account (NULL, account);
1072                         g_object_unref (account);
1073                 }
1074         } else if (TNY_IS_ACCOUNT (folder_store)) {
1075                 /* Use the folder store as an account: */
1076                 result = modest_platform_connect_and_wait_if_network_account (NULL, TNY_ACCOUNT (folder_store));
1077         }
1078
1079         return result;
1080 }
1081
1082 GtkWidget *
1083 modest_platform_create_sort_dialog       (GtkWindow *parent_window)
1084 {
1085         GtkWidget *dialog;
1086
1087         dialog = modest_hildon_sort_dialog_new (parent_window);
1088
1089         hildon_help_dialog_help_enable (GTK_DIALOG(dialog),
1090                                         "applications_email_sort",
1091                                         modest_maemo_utils_get_osso_context());
1092
1093         return dialog;
1094 }
1095
1096
1097 gboolean
1098 modest_platform_set_update_interval (guint minutes)
1099 {
1100 #ifdef MODEST_HAVE_LIBALARM
1101
1102         ModestConf *conf = modest_runtime_get_conf ();
1103         if (!conf)
1104                 return FALSE;
1105
1106         cookie_t alarm_cookie = modest_conf_get_int (conf, MODEST_CONF_ALARM_ID, NULL);
1107
1108         /* Delete any existing alarm,
1109          * because we will replace it: */
1110         if (alarm_cookie) {
1111                 if (alarmd_event_del(alarm_cookie) != 1)
1112                         g_warning ("%s: alarm %d was not on the queue", __FUNCTION__, (int)alarm_cookie);
1113                 alarm_cookie = 0;
1114                 modest_conf_set_int (conf, MODEST_CONF_ALARM_ID, 0, NULL);
1115         }
1116
1117         /* 0 means no updates: */
1118         if (minutes == 0)
1119                 return TRUE;
1120
1121
1122         /* Register alarm: */
1123
1124         /* Set the interval in alarm_event_t structure: */
1125         alarm_event_t *event = alarm_event_create ();
1126         alarm_event_add_actions (event, 1);
1127         alarm_action_t *action = alarm_event_get_action (event, 0);
1128         event->alarm_time = minutes * 60; /* seconds */
1129
1130         /* Set recurrence every few minutes: */
1131         event->recur_secs = minutes*60;
1132         event->recur_count = -1; /* Means infinite */
1133
1134         /* Specify what should happen when the alarm happens:
1135          * It should call this D-Bus method: */
1136
1137         action->dbus_path = g_strdup(MODEST_DBUS_OBJECT);
1138         action->dbus_interface = g_strdup (MODEST_DBUS_IFACE);
1139         action->dbus_service = g_strdup (MODEST_DBUS_SERVICE);
1140         action->dbus_name = g_strdup (MODEST_DBUS_METHOD_SEND_RECEIVE);
1141         action->flags = ALARM_ACTION_TYPE_DBUS | ALARM_ACTION_DBUS_USE_ACTIVATION;
1142
1143         /* Use ALARM_EVENT_NO_DIALOG: Otherwise, a dialog will be shown if
1144          * exec_name or dbus_path is NULL, even though we have specified no dialog text.
1145          * Also use ALARM_EVENT_ACTIVATION so that modest is started (without UI) to get emails
1146          * This is why we want to use the Alarm API instead of just g_timeout_add().
1147          * (The old maemo email-client did this, though it isn't specified in the UI spec.)
1148          * ALARM_EVENT_CONNECTED will prevent the alarm from being called in case that the device is offline
1149          */
1150         event->flags = ALARM_EVENT_CONNECTED;
1151
1152         alarm_cookie = alarmd_event_add (event);
1153
1154         /* now, free it */
1155         alarm_event_delete (event);
1156
1157         /* Store the alarm ID in GConf, so we can remove it later:
1158          * This is apparently valid between application instances. */
1159         modest_conf_set_int (conf, MODEST_CONF_ALARM_ID, alarm_cookie, NULL);
1160
1161         if (!alarm_cookie) {
1162             /* Error */
1163             g_debug ("Error setting alarm event. \n");
1164
1165             return FALSE;
1166         }
1167 #endif /* MODEST_HAVE_LIBALARM */
1168         return TRUE;
1169 }
1170
1171 void
1172 modest_platform_push_email_notification(void)
1173 {
1174         gboolean play_sound;
1175         ModestWindow *main_window;
1176         gboolean screen_on = TRUE, app_in_foreground;
1177
1178         /* Check whether or not we should play a sound */
1179         play_sound = modest_conf_get_bool (modest_runtime_get_conf (),
1180                                            MODEST_CONF_PLAY_SOUND_MSG_ARRIVE,
1181                                            NULL);
1182
1183         /* Get the screen status */
1184         main_window = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (), FALSE);
1185         if (main_window)
1186                 screen_on = modest_main_window_screen_is_on (MODEST_MAIN_WINDOW (main_window));
1187
1188         /* Get the window status */
1189         app_in_foreground = hildon_program_get_is_topmost (hildon_program_get_instance ());
1190
1191         /* If the screen is on and the app is in the
1192            foreground we don't show anything */
1193         if (!(screen_on && app_in_foreground)) {
1194                 /* Play a sound */
1195                 if (play_sound)
1196                         hildon_play_system_sound (MODEST_NEW_MAIL_SOUND_FILE);
1197
1198                 /* Activate LED. This must be deactivated by
1199                    modest_platform_remove_new_mail_notifications */
1200 #ifdef MODEST_HAVE_MCE
1201                 osso_rpc_run_system (modest_maemo_utils_get_osso_context (),
1202                                      MCE_SERVICE,
1203                                      MCE_REQUEST_PATH,
1204                                      MCE_REQUEST_IF,
1205                                      MCE_ACTIVATE_LED_PATTERN,
1206                                      NULL,
1207                                      DBUS_TYPE_STRING, MODEST_NEW_MAIL_LIGHTING_PATTERN,
1208                                      DBUS_TYPE_INVALID);
1209 #endif
1210         }
1211 }
1212
1213 void
1214 modest_platform_on_new_headers_received (TnyList *header_list,
1215                                          gboolean show_visual)
1216 {
1217         g_return_if_fail (TNY_IS_LIST(header_list));
1218
1219         if (tny_list_get_length(header_list) == 0) {
1220                 g_warning ("%s: header list is empty", __FUNCTION__);
1221                 return;
1222         }
1223
1224         if (!show_visual) {
1225                 modest_platform_push_email_notification ();
1226                 /* We do a return here to avoid indentation with an else */
1227                 return;
1228         }
1229
1230 #ifdef MODEST_HAVE_HILDON_NOTIFY
1231         gboolean play_sound;
1232
1233         /* Check whether or not we should play a sound */
1234         play_sound = modest_conf_get_bool (modest_runtime_get_conf (),
1235                                            MODEST_CONF_PLAY_SOUND_MSG_ARRIVE,
1236                                            NULL);
1237
1238         HildonNotification *notification;
1239         TnyIterator *iter;
1240         GSList *notifications_list = NULL;
1241
1242         /* Get previous notifications ids */
1243         notifications_list = modest_conf_get_list (modest_runtime_get_conf (),
1244                                                    MODEST_CONF_NOTIFICATION_IDS,
1245                                                    MODEST_CONF_VALUE_INT, NULL);
1246
1247         iter = tny_list_create_iterator (header_list);
1248         while (!tny_iterator_is_done (iter)) {
1249                 gchar *url = NULL, *display_address = NULL,  *summary = NULL;
1250                 const gchar *display_date;
1251                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1252                 TnyFolder *folder = tny_header_get_folder (header);
1253                 gboolean first_notification = TRUE;
1254                 gint notif_id;
1255                 gchar *str;
1256
1257                 /* constant string, don't free */
1258                 display_date = modest_text_utils_get_display_date (tny_header_get_date_received (header));
1259
1260                 display_address = tny_header_dup_from (header);
1261                 modest_text_utils_get_display_address (display_address); /* string is changed in-place */
1262
1263                 summary = g_strdup_printf ("%s - %s", display_date, display_address);
1264                 str = tny_header_dup_subject (header);
1265                 notification = hildon_notification_new (summary,
1266                                                         str,
1267                                                         "qgn_list_messagin",
1268                                                         "email.arrive");
1269                 g_free (str);
1270                 /* Create the message URL */
1271                 str = tny_header_dup_uid (header);
1272                 url = g_strdup_printf ("%s/%s", tny_folder_get_url_string (folder),
1273                                        str);
1274                 g_free (str);
1275
1276                 hildon_notification_add_dbus_action(notification,
1277                                                     "default",
1278                                                     "Cancel",
1279                                                     MODEST_DBUS_SERVICE,
1280                                                     MODEST_DBUS_OBJECT,
1281                                                     MODEST_DBUS_IFACE,
1282                                                     MODEST_DBUS_METHOD_OPEN_MESSAGE,
1283                                                     G_TYPE_STRING, url,
1284                                                     -1);
1285
1286                 /* Play sound if the user wants. Show the LED
1287                    pattern. Show and play just one */
1288                 if (G_UNLIKELY (first_notification)) {
1289                         first_notification = FALSE;
1290                         if (play_sound)  {
1291                                 notify_notification_set_hint_string(NOTIFY_NOTIFICATION (notification),
1292                                                                     "sound-file", MODEST_NEW_MAIL_SOUND_FILE);
1293                         }
1294
1295                         /* Set the led pattern */
1296                         notify_notification_set_hint_int32 (NOTIFY_NOTIFICATION (notification),
1297                                                             "dialog-type", 4);
1298                         notify_notification_set_hint_string(NOTIFY_NOTIFICATION (notification),
1299                                                             "led-pattern",
1300                                                             MODEST_NEW_MAIL_LIGHTING_PATTERN);
1301                 }
1302
1303                 /* Notify. We need to do this in an idle because this function
1304                    could be called from a thread */
1305                 notify_notification_show (NOTIFY_NOTIFICATION (notification), NULL);
1306
1307                 /* Save id in the list */
1308                 g_object_get(G_OBJECT(notification), "id", &notif_id, NULL);
1309                 notifications_list = g_slist_prepend (notifications_list, GINT_TO_POINTER(notif_id));
1310                 /* We don't listen for the "closed" signal, because we
1311                    don't care about if the notification was removed or
1312                    not to store the list in gconf */
1313
1314                 /* Free & carry on */
1315                 g_free (display_address);
1316                 g_free (summary);
1317                 g_free (url);
1318                 g_object_unref (folder);
1319                 g_object_unref (header);
1320                 tny_iterator_next (iter);
1321         }
1322         g_object_unref (iter);
1323
1324         /* Save the ids */
1325         modest_conf_set_list (modest_runtime_get_conf (), MODEST_CONF_NOTIFICATION_IDS,
1326                               notifications_list, MODEST_CONF_VALUE_INT, NULL);
1327
1328         g_slist_free (notifications_list);
1329
1330 #endif /*MODEST_HAVE_HILDON_NOTIFY*/
1331 }
1332
1333 void
1334 modest_platform_remove_new_mail_notifications (gboolean only_visuals)
1335 {
1336         if (only_visuals) {
1337 #ifdef MODEST_HAVE_MCE
1338                 osso_rpc_run_system (modest_maemo_utils_get_osso_context (),
1339                                      MCE_SERVICE,
1340                                      MCE_REQUEST_PATH,
1341                                      MCE_REQUEST_IF,
1342                                      MCE_DEACTIVATE_LED_PATTERN,
1343                                      NULL,
1344                                      DBUS_TYPE_STRING, MODEST_NEW_MAIL_LIGHTING_PATTERN,
1345                                      DBUS_TYPE_INVALID);
1346 #endif
1347                 return;
1348         }
1349
1350 #ifdef MODEST_HAVE_HILDON_NOTIFY
1351         GSList *notif_list = NULL;
1352
1353         /* Get previous notifications ids */
1354         notif_list = modest_conf_get_list (modest_runtime_get_conf (),
1355                                            MODEST_CONF_NOTIFICATION_IDS,
1356                                            MODEST_CONF_VALUE_INT, NULL);
1357
1358         while (notif_list) {
1359                 gint notif_id;
1360                 NotifyNotification *notif;
1361
1362                 /* Nasty HACK to remove the notifications, set the id
1363                    of the existing ones and then close them */
1364                 notif_id = GPOINTER_TO_INT(notif_list->data);
1365                 notif = notify_notification_new("dummy", NULL, NULL, NULL);
1366                 g_object_set(G_OBJECT(notif), "id", notif_id, NULL);
1367
1368                 /* Close the notification, note that some ids could be
1369                    already invalid, but we don't care because it does
1370                    not fail */
1371                 notify_notification_close(notif, NULL);
1372                 g_object_unref(notif);
1373
1374                 /* Delete the link, it's like going to the next */
1375                 notif_list = g_slist_delete_link (notif_list, notif_list);
1376         }
1377
1378         /* Save the ids */
1379         modest_conf_set_list (modest_runtime_get_conf (), MODEST_CONF_NOTIFICATION_IDS,
1380                               notif_list, MODEST_CONF_VALUE_INT, NULL);
1381
1382         g_slist_free (notif_list);
1383
1384 #endif /* MODEST_HAVE_HILDON_NOTIFY */
1385 }
1386
1387
1388
1389 GtkWidget *
1390 modest_platform_get_global_settings_dialog ()
1391 {
1392         return modest_maemo_global_settings_dialog_new ();
1393 }
1394
1395 void
1396 modest_platform_show_help (GtkWindow *parent_window,
1397                            const gchar *help_id)
1398 {
1399         osso_return_t result;
1400         g_return_if_fail (help_id);
1401
1402         result = hildon_help_show (modest_maemo_utils_get_osso_context(),
1403                                    help_id, HILDON_HELP_SHOW_DIALOG);
1404
1405         if (result != OSSO_OK) {
1406                 gchar *error_msg;
1407                 error_msg = g_strdup_printf ("FIXME The help topic %s could not be found", help_id);
1408                 hildon_banner_show_information (GTK_WIDGET (parent_window),
1409                                                 NULL,
1410                                                 error_msg);
1411                 g_free (error_msg);
1412         }
1413 }
1414
1415 void
1416 modest_platform_show_search_messages (GtkWindow *parent_window)
1417 {
1418         osso_return_t result = OSSO_ERROR;
1419
1420         result = osso_rpc_run_with_defaults (modest_maemo_utils_get_osso_context(),
1421                                              "osso_global_search",
1422                                              "search_email", NULL, DBUS_TYPE_INVALID);
1423
1424         if (result != OSSO_OK) {
1425                 g_warning ("%s: osso_rpc_run_with_defaults() failed.\n", __FUNCTION__);
1426         }
1427 }
1428
1429 void
1430 modest_platform_show_addressbook (GtkWindow *parent_window)
1431 {
1432         osso_return_t result = OSSO_ERROR;
1433
1434         result = osso_rpc_run_with_defaults (modest_maemo_utils_get_osso_context(),
1435                                              "osso_addressbook",
1436                                              "top_application", NULL, DBUS_TYPE_INVALID);
1437
1438         if (result != OSSO_OK) {
1439                 g_warning ("%s: osso_rpc_run_with_defaults() failed.\n", __FUNCTION__);
1440         }
1441 }
1442
1443 GtkWidget *
1444 modest_platform_create_folder_view (TnyFolderStoreQuery *query)
1445 {
1446         GtkWidget *widget = modest_folder_view_new (query);
1447
1448         /* Show one account by default */
1449         modest_folder_view_set_style (MODEST_FOLDER_VIEW (widget),
1450                                       MODEST_FOLDER_VIEW_STYLE_SHOW_ONE);
1451
1452         /* Restore settings */
1453         modest_widget_memory_restore (modest_runtime_get_conf(),
1454                                       G_OBJECT (widget),
1455                                       MODEST_CONF_FOLDER_VIEW_KEY);
1456
1457         return widget;
1458 }
1459
1460 void
1461 banner_finish (gpointer data, GObject *object)
1462 {
1463         ModestWindowMgr *mgr = (ModestWindowMgr *) data;
1464         modest_window_mgr_unregister_banner (mgr);
1465         g_object_unref (mgr);
1466 }
1467
1468 void
1469 modest_platform_information_banner (GtkWidget *parent,
1470                                     const gchar *icon_name,
1471                                     const gchar *text)
1472 {
1473         GtkWidget *banner, *banner_parent = NULL;
1474         ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
1475
1476         if (modest_window_mgr_num_windows (mgr) == 0)
1477                 return;
1478
1479         if (parent && GTK_IS_WINDOW (parent)) {
1480                 /* If the window is the active one then show the
1481                    banner on top of this window */
1482                 if (gtk_window_is_active (GTK_WINDOW (parent)))
1483                         banner_parent = parent;
1484                 /* If the window is not the topmost but it's visible
1485                    (it's minimized for example) then show the banner
1486                    with no parent */
1487                 else if (GTK_WIDGET_VISIBLE (parent))
1488                         banner_parent = NULL;
1489                 /* If the window is hidden (like the main window when
1490                    running in the background) then do not show
1491                    anything */
1492                 else
1493                         return;
1494         }
1495
1496
1497         banner = hildon_banner_show_information (banner_parent, icon_name, text);
1498
1499         modest_window_mgr_register_banner (mgr);
1500         g_object_ref (mgr);
1501         g_object_weak_ref ((GObject *) banner, banner_finish, mgr);
1502 }
1503
1504 void
1505 modest_platform_information_banner_with_timeout (GtkWidget *parent,
1506                                                  const gchar *icon_name,
1507                                                  const gchar *text,
1508                                                  gint timeout)
1509 {
1510         GtkWidget *banner;
1511
1512         if (modest_window_mgr_num_windows (modest_runtime_get_window_mgr ()) == 0)
1513                 return;
1514
1515         banner = hildon_banner_show_information (parent, icon_name, text);
1516         hildon_banner_set_timeout(HILDON_BANNER(banner), timeout);
1517 }
1518
1519 GtkWidget *
1520 modest_platform_animation_banner (GtkWidget *parent,
1521                                   const gchar *animation_name,
1522                                   const gchar *text)
1523 {
1524         GtkWidget *inf_note = NULL;
1525
1526         g_return_val_if_fail (text != NULL, NULL);
1527
1528         if (modest_window_mgr_num_windows (modest_runtime_get_window_mgr ()) == 0)
1529                 return NULL;
1530
1531         /* If the parent is not visible then do not show */
1532         if (parent && !GTK_WIDGET_VISIBLE (parent))
1533                 return NULL;
1534
1535         inf_note = hildon_banner_show_animation (parent, animation_name, text);
1536
1537         return inf_note;
1538 }
1539
1540 typedef struct
1541 {
1542         GMainLoop* loop;
1543         TnyAccount *account;
1544         gboolean is_online;
1545         gint count_tries;
1546 } CheckAccountIdleData;
1547
1548 #define NUMBER_OF_TRIES 10 /* Try approx every second, ten times. */
1549
1550 static gboolean
1551 on_timeout_check_account_is_online(CheckAccountIdleData* data)
1552 {
1553         gboolean stop_trying = FALSE;
1554         g_return_val_if_fail (data && data->account, FALSE);
1555
1556         printf ("DEBUG: %s: tny_account_get_connection_status()==%d\n", __FUNCTION__,
1557                 tny_account_get_connection_status (data->account));
1558
1559         if (data && data->account &&
1560                 /* We want to wait until TNY_CONNECTION_STATUS_INIT has changed to something else,
1561                  * after which the account is likely to be usable, or never likely to be usable soon: */
1562                 (tny_account_get_connection_status (data->account) != TNY_CONNECTION_STATUS_INIT) )
1563         {
1564                 data->is_online = TRUE;
1565
1566                 stop_trying = TRUE;
1567         } else {
1568                 /* Give up if we have tried too many times: */
1569                 if (data->count_tries >= NUMBER_OF_TRIES) {
1570                         stop_trying = TRUE;
1571                 } else {
1572                         /* Wait for another timeout: */
1573                         ++(data->count_tries);
1574                 }
1575         }
1576
1577         if (stop_trying) {
1578                 /* Allow the function that requested this idle callback to continue: */
1579                 if (data->loop)
1580                         g_main_loop_quit (data->loop);
1581
1582                 if (data->account)
1583                         g_object_unref (data->account);
1584
1585                 return FALSE; /* Don't call this again. */
1586         } else {
1587                 return TRUE; /* Call this timeout callback again. */
1588         }
1589 }
1590
1591 /* Return TRUE immediately if the account is already online,
1592  * otherwise check every second for NUMBER_OF_TRIES seconds and return TRUE as
1593  * soon as the account is online, or FALSE if the account does
1594  * not become online in the NUMBER_OF_TRIES seconds.
1595  * This is useful when the D-Bus method was run immediately after
1596  * the application was started (when using D-Bus activation),
1597  * because the account usually takes a short time to go online.
1598  * The return value is maybe not very useful.
1599  */
1600 gboolean
1601 modest_platform_check_and_wait_for_account_is_online(TnyAccount *account)
1602 {
1603         g_return_val_if_fail (account, FALSE);
1604
1605         printf ("DEBUG: %s: account id=%s\n", __FUNCTION__, tny_account_get_id (account));
1606
1607         if (!tny_device_is_online (modest_runtime_get_device())) {
1608                 printf ("DEBUG: %s: device is offline.\n", __FUNCTION__);
1609                 return FALSE;
1610         }
1611
1612         /* The local_folders account never seems to leave TNY_CONNECTION_STATUS_INIT,
1613          * so we avoid wait unnecessarily: */
1614         if (!TNY_IS_CAMEL_POP_STORE_ACCOUNT (account) &&
1615                 !TNY_IS_CAMEL_IMAP_STORE_ACCOUNT (account) ) {
1616                 return TRUE;
1617         }
1618
1619         printf ("DEBUG: %s: tny_account_get_connection_status()==%d\n",
1620                 __FUNCTION__, tny_account_get_connection_status (account));
1621
1622         /* The POP & IMAP store accounts seem to be TNY_CONNECTION_STATUS_DISCONNECTED,
1623          * and that seems to be an OK time to use them. Maybe it's just TNY_CONNECTION_STATUS_INIT that
1624          * we want to avoid. */
1625         if (tny_account_get_connection_status (account) != TNY_CONNECTION_STATUS_INIT)
1626                 return TRUE;
1627
1628         /* This blocks on the result: */
1629         CheckAccountIdleData *data = g_slice_new0 (CheckAccountIdleData);
1630         data->is_online = FALSE;
1631         data->account = account;
1632         g_object_ref (data->account);
1633         data->count_tries = 0;
1634
1635         GMainContext *context = NULL; /* g_main_context_new (); */
1636         data->loop = g_main_loop_new (context, FALSE /* not running */);
1637
1638         g_timeout_add (1000, (GSourceFunc)(on_timeout_check_account_is_online), data);
1639
1640         /* This main loop will run until the idle handler has stopped it: */
1641         g_main_loop_run (data->loop);
1642
1643         g_main_loop_unref (data->loop);
1644         /* g_main_context_unref (context); */
1645
1646         g_slice_free (CheckAccountIdleData, data);
1647
1648         return data->is_online;
1649 }
1650
1651
1652
1653 static void
1654 on_cert_dialog_response (GtkDialog *dialog, gint response_id,  const gchar* cert)
1655 {
1656         /* GTK_RESPONSE_HELP means we need to show the certificate */
1657         if (response_id == GTK_RESPONSE_APPLY) {
1658                 GtkWidget *note;
1659                 gchar *msg;
1660
1661                 /* Do not close the dialog */
1662                 g_signal_stop_emission_by_name (dialog, "response");
1663
1664                 msg = g_strdup_printf (_("mcen_ni_view_unknown_certificate"), cert);
1665                 note = hildon_note_new_information (GTK_WINDOW(dialog), msg);
1666                 gtk_dialog_run (GTK_DIALOG(note));
1667                 gtk_widget_destroy (note);
1668         }
1669 }
1670
1671
1672 gboolean
1673 modest_platform_run_certificate_confirmation_dialog (const gchar* server_name,
1674                                                      const gchar *certificate)
1675 {
1676         GtkWidget *note;
1677         gint response;
1678         ModestWindow *main_win;
1679
1680         if (!modest_window_mgr_main_window_exists (modest_runtime_get_window_mgr())) {
1681                 g_warning ("%s: don't show dialogs if there's no main window; assuming 'Cancel'",
1682                            __FUNCTION__);
1683                 return FALSE;
1684         }
1685
1686         /* don't create it */
1687         main_win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(), FALSE);
1688         g_return_val_if_fail (main_win, FALSE); /* should not happen */
1689
1690
1691         gchar *question = g_strdup_printf (_("mcen_nc_unknown_certificate"),
1692                                            server_name);
1693
1694         /* We use GTK_RESPONSE_APPLY because we want the button in the
1695            middle of OK and CANCEL the same as the browser does for
1696            example. With GTK_RESPONSE_HELP the view button is aligned
1697            to the left while the other two to the right */
1698         note = hildon_note_new_confirmation_add_buttons  (
1699                 GTK_WINDOW(main_win),
1700                 question,
1701                 _("mcen_bd_dialog_ok"),     GTK_RESPONSE_OK,
1702                 _("mcen_bd_view"),          GTK_RESPONSE_APPLY,   /* abusing this... */
1703                 _("mcen_bd_dialog_cancel"), GTK_RESPONSE_CANCEL,
1704                 NULL, NULL);
1705
1706         g_signal_connect (G_OBJECT(note), "response",
1707                           G_CALLBACK(on_cert_dialog_response),
1708                           (gpointer) certificate);
1709
1710         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1711                                      GTK_WINDOW (note));
1712         response = gtk_dialog_run(GTK_DIALOG(note));
1713
1714         on_destroy_dialog (note);
1715         g_free (question);
1716
1717         return response == GTK_RESPONSE_OK;
1718 }
1719
1720 gboolean
1721 modest_platform_run_alert_dialog (const gchar* prompt,
1722                                   gboolean is_question)
1723 {
1724         ModestWindow *main_win;
1725
1726         if (!modest_window_mgr_main_window_exists (modest_runtime_get_window_mgr())) {
1727                 g_warning ("%s:\n'%s'\ndon't show dialogs if there's no main window;"
1728                            " assuming 'Cancel' for questions, 'Ok' otherwise", prompt, __FUNCTION__);
1729                 return is_question ? FALSE : TRUE;
1730         }
1731
1732         main_win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (), FALSE);
1733         g_return_val_if_fail (main_win, FALSE); /* should not happen */
1734
1735         gboolean retval = TRUE;
1736         if (is_question) {
1737                 /* The Tinymail documentation says that we should show Yes and No buttons,
1738                  * when it is a question.
1739                  * Obviously, we need tinymail to use more specific error codes instead,
1740                  * so we know what buttons to show. */
1741                 GtkWidget *dialog = GTK_WIDGET (hildon_note_new_confirmation (GTK_WINDOW (main_win),
1742                                                                               prompt));
1743                 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1744                                              GTK_WINDOW (dialog));
1745
1746                 const int response = gtk_dialog_run (GTK_DIALOG (dialog));
1747                 retval = (response == GTK_RESPONSE_YES) || (response == GTK_RESPONSE_OK);
1748
1749                 on_destroy_dialog (dialog);
1750         } else {
1751                 /* Just show the error text and use the default response: */
1752                 modest_platform_run_information_dialog (GTK_WINDOW (main_win),
1753                                                         prompt, FALSE);
1754         }
1755         return retval;
1756 }
1757
1758 /***************/
1759 typedef struct {
1760         GtkWindow *parent_window;
1761         ModestConnectedPerformer callback;
1762         TnyAccount *account;
1763         gpointer user_data;
1764         gchar *iap;
1765         TnyDevice *device;
1766 } OnWentOnlineInfo;
1767
1768 static void
1769 on_went_online_info_free (OnWentOnlineInfo *info)
1770 {
1771         /* And if we cleanup, we DO cleanup  :-)  */
1772
1773         if (info->device)
1774                 g_object_unref (info->device);
1775         if (info->iap)
1776                 g_free (info->iap);
1777         if (info->parent_window)
1778                 g_object_unref (info->parent_window);
1779         if (info->account)
1780                 g_object_unref (info->account);
1781
1782         g_slice_free (OnWentOnlineInfo, info);
1783
1784         /* We're done ... */
1785
1786         return;
1787 }
1788
1789 static void
1790 on_account_went_online (TnyCamelAccount *account, gboolean canceled, GError *err, gpointer user_data)
1791 {
1792         OnWentOnlineInfo *info = (OnWentOnlineInfo *) user_data;
1793
1794         /* Now it's really time to callback to the caller. If going online didn't succeed,
1795          * err will be set. We don't free it, Tinymail does that! If a cancel happened,
1796          * canceled will be set. Etcetera etcetera. */
1797
1798         if (info->callback) {
1799                 info->callback (canceled, err, info->parent_window, info->account, info->user_data);
1800         }
1801
1802         /* This is our last call, we must cleanup here if we didn't yet do that */
1803         on_went_online_info_free (info);
1804
1805         return;
1806 }
1807
1808
1809 static void
1810 on_conic_device_went_online (TnyMaemoConicDevice *device, const gchar* iap_id, gboolean canceled, GError *err, gpointer user_data)
1811 {
1812         OnWentOnlineInfo *info = (OnWentOnlineInfo *) user_data;
1813         info->iap = g_strdup (iap_id);
1814
1815         if (canceled || err || !info->account) {
1816
1817                 /* If there's a problem or if there's no account (then that's it for us, we callback
1818                  * the caller's callback now. He'll have to handle err or canceled, of course.
1819                  * We are not really online, as the account is not really online here ... */
1820
1821                 /* We'll use the err and the canceled of this cb. TnyMaemoConicDevice delivered us
1822                  * this info. We don't cleanup err, Tinymail does that! */
1823
1824                 if (info->callback) {
1825
1826                         /* info->account can be NULL here, this means that the user did not
1827                          * provide a nice account instance. We'll assume that the user knows
1828                          * what he's doing and is happy with just the device going online.
1829                          *
1830                          * We can't do magic, we don't know what account the user wants to
1831                          * see going online. So just the device goes online, end of story */
1832
1833                         info->callback (canceled, err, info->parent_window, info->account, info->user_data);
1834                 }
1835
1836         } else if (info->account) {
1837
1838                 /* If there's no problem and if we have an account, we'll put the account
1839                  * online too. When done, the callback of bringing the account online
1840                  * will callback the caller's callback. This is the most normal case. */
1841
1842                 info->device = TNY_DEVICE (g_object_ref (device));
1843
1844                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (info->account), TRUE,
1845                                               on_account_went_online, info);
1846
1847                 /* The on_account_went_online cb frees up the info, go look if you
1848                  * don't believe me! (so we return here) */
1849
1850                 return;
1851         }
1852
1853         /* We cleanup if we are not bringing the account online too */
1854         on_went_online_info_free (info);
1855
1856         return;
1857 }
1858
1859 void
1860 modest_platform_connect_and_perform (GtkWindow *parent_window,
1861                                      gboolean force,
1862                                      TnyAccount *account,
1863                                      ModestConnectedPerformer callback,
1864                                      gpointer user_data)
1865 {
1866         gboolean device_online;
1867         TnyDevice *device;
1868         TnyConnectionStatus conn_status;
1869         OnWentOnlineInfo *info;
1870
1871         device = modest_runtime_get_device();
1872         device_online = tny_device_is_online (device);
1873
1874         /* If there is no account check only the device status */
1875         if (!account) {
1876
1877                 if (device_online) {
1878
1879                         /* We promise to instantly perform the callback, so ... */
1880                         if (callback) {
1881                                 callback (FALSE, NULL, parent_window, account, user_data);
1882                         }
1883
1884                 } else {
1885
1886                         info = g_slice_new0 (OnWentOnlineInfo);
1887
1888                         info->iap = NULL;
1889                         info->device = NULL;
1890                         info->account = NULL;
1891
1892                         if (parent_window)
1893                                 info->parent_window = (GtkWindow *) g_object_ref (parent_window);
1894                         else
1895                                 info->parent_window = NULL;
1896                         info->user_data = user_data;
1897                         info->callback = callback;
1898
1899                         tny_maemo_conic_device_connect_async (TNY_MAEMO_CONIC_DEVICE (device), NULL,
1900                                                               force, on_conic_device_went_online,
1901                                                               info);
1902
1903                         /* We'll cleanup in on_conic_device_went_online */
1904                 }
1905
1906                 /* The other code has no more reason to run. This is all that we can do for the
1907                  * caller (he should have given us a nice and clean account instance!). We
1908                  * can't do magic, we don't know what account he intends to bring online. So
1909                  * we'll just bring the device online (and await his false bug report). */
1910
1911                 return;
1912         }
1913
1914
1915         /* Return if the account is already connected */
1916
1917         conn_status = tny_account_get_connection_status (account);
1918         if (device_online && conn_status == TNY_CONNECTION_STATUS_CONNECTED) {
1919
1920                 /* We promise to instantly perform the callback, so ... */
1921                 if (callback) {
1922                         callback (FALSE, NULL, parent_window, account, user_data);
1923                 }
1924
1925                 return;
1926         }
1927
1928         /* Else, we are in a state that requires that we go online before we
1929          * call the caller's callback. */
1930
1931         info = g_slice_new0 (OnWentOnlineInfo);
1932
1933         info->device = NULL;
1934         info->iap = NULL;
1935         info->account = TNY_ACCOUNT (g_object_ref (account));
1936
1937         if (parent_window)
1938                 info->parent_window = (GtkWindow *) g_object_ref (parent_window);
1939         else
1940                 info->parent_window = NULL;
1941
1942         /* So we'll put the callback away for later ... */
1943
1944         info->user_data = user_data;
1945         info->callback = callback;
1946
1947         if (!device_online) {
1948
1949                 /* If also the device is offline, then we connect both the device
1950                  * and the account */
1951
1952                 tny_maemo_conic_device_connect_async (TNY_MAEMO_CONIC_DEVICE (device), NULL,
1953                                                       force, on_conic_device_went_online,
1954                                                       info);
1955
1956         } else {
1957
1958                 /* If the device is online, we'll just connect the account */
1959
1960                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (account), TRUE,
1961                                               on_account_went_online, info);
1962         }
1963
1964         /* The info gets freed by on_account_went_online or on_conic_device_went_online
1965          * in both situations, go look if you don't believe me! */
1966
1967         return;
1968 }
1969
1970 void
1971 modest_platform_connect_if_remote_and_perform (GtkWindow *parent_window,
1972                                                gboolean force,
1973                                                TnyFolderStore *folder_store,
1974                                                ModestConnectedPerformer callback,
1975                                                gpointer user_data)
1976 {
1977         TnyAccount *account = NULL;
1978
1979         if (!folder_store) {
1980                 /* We promise to instantly perform the callback, so ... */
1981                 if (callback) {
1982                         callback (FALSE, NULL, parent_window, NULL, user_data);
1983                 }
1984                 return;
1985
1986                 /* Original comment: Maybe it is something local. */
1987                 /* PVH's comment: maybe we should KNOW this in stead of assuming? */
1988
1989         } else if (TNY_IS_FOLDER (folder_store)) {
1990                 /* Get the folder's parent account: */
1991                 account = tny_folder_get_account (TNY_FOLDER (folder_store));
1992         } else if (TNY_IS_ACCOUNT (folder_store)) {
1993                 /* Use the folder store as an account: */
1994                 account = TNY_ACCOUNT (g_object_ref (folder_store));
1995         }
1996
1997         if (tny_account_get_account_type (account) == TNY_ACCOUNT_TYPE_STORE) {
1998                 if (!TNY_IS_CAMEL_POP_STORE_ACCOUNT (account) &&
1999                     !TNY_IS_CAMEL_IMAP_STORE_ACCOUNT (account)) {
2000
2001                         /* No need to connect a local account */
2002                         if (callback)
2003                                 callback (FALSE, NULL, parent_window, account, user_data);
2004
2005                         goto clean;
2006                 }
2007         }
2008         modest_platform_connect_and_perform (parent_window, force, account, callback, user_data);
2009
2010  clean:
2011         if (account)
2012                 g_object_unref (account);
2013 }
2014
2015 static void
2016 src_account_connect_performer (gboolean canceled,
2017                                GError *err,
2018                                GtkWindow *parent_window,
2019                                TnyAccount *src_account,
2020                                gpointer user_data)
2021 {
2022         DoubleConnectionInfo *info = (DoubleConnectionInfo *) user_data;
2023
2024         if (canceled || err) {
2025                 /* If there was any error call the user callback */
2026                 info->callback (canceled, err, parent_window, src_account, info->data);
2027         } else {
2028                 /* Connect the destination account */
2029                 modest_platform_connect_if_remote_and_perform (parent_window, TRUE,
2030                                                                TNY_FOLDER_STORE (info->dst_account),
2031                                                                info->callback, info->data);
2032         }
2033
2034         /* Free the info object */
2035         g_object_unref (info->dst_account);
2036         g_slice_free (DoubleConnectionInfo, info);
2037 }
2038
2039
2040 void
2041 modest_platform_double_connect_and_perform (GtkWindow *parent_window,
2042                                             gboolean force,
2043                                             TnyFolderStore *folder_store,
2044                                             DoubleConnectionInfo *connect_info)
2045 {
2046         modest_platform_connect_if_remote_and_perform(parent_window,
2047                                                       force,
2048                                                       folder_store,
2049                                                       src_account_connect_performer,
2050                                                       connect_info);
2051 }
2052
2053 GtkWidget *
2054 modest_platform_get_account_settings_wizard (void)
2055 {
2056         ModestEasysetupWizardDialog *dialog = modest_easysetup_wizard_dialog_new ();
2057
2058         return GTK_WIDGET (dialog);
2059 }
2060
2061 ModestConnectedVia
2062 modest_platform_get_current_connection (void)
2063 {
2064         TnyDevice *device = NULL;
2065         ModestConnectedVia retval = MODEST_CONNECTED_VIA_ANY;
2066
2067         device = modest_runtime_get_device ();
2068
2069         if (!tny_device_is_online (device))
2070                 return MODEST_CONNECTED_VIA_ANY;
2071
2072 #ifdef MODEST_HAVE_CONIC
2073         /* Get iap id */
2074         const gchar *iap_id = tny_maemo_conic_device_get_current_iap_id (TNY_MAEMO_CONIC_DEVICE (device));
2075         if (iap_id) {
2076                 ConIcIap *iap = tny_maemo_conic_device_get_iap (
2077                         TNY_MAEMO_CONIC_DEVICE (device), iap_id);
2078                 const gchar *bearer_type = con_ic_iap_get_bearer_type (iap);
2079                 if (bearer_type) {
2080                         if (!strcmp (bearer_type, CON_IC_BEARER_WLAN_INFRA) ||
2081                             !strcmp (bearer_type, CON_IC_BEARER_WLAN_ADHOC) ||
2082                             !strcmp (bearer_type, "WIMAX")) {
2083                                 retval = MODEST_CONNECTED_VIA_WLAN_OR_WIMAX;
2084                         } else {
2085                                 retval = MODEST_CONNECTED_VIA_ANY;
2086                         }
2087                 }
2088                 g_object_unref (iap);
2089         }
2090 #else
2091         retval = MODEST_CONNECTED_VIA_WLAN_OR_WIMAX; /* assume WLAN (fast) internet */
2092 #endif /* MODEST_HAVE_CONIC */
2093         return retval;
2094 }
2095
2096
2097
2098 gboolean
2099 modest_platform_check_memory_low (ModestWindow *win,
2100                                   gboolean visuals)
2101 {
2102         gboolean lowmem;
2103
2104         /* are we in low memory state? */
2105         lowmem = osso_mem_in_lowmem_state () ? TRUE : FALSE;
2106
2107         if (win && lowmem && visuals)
2108                 modest_platform_run_information_dialog (
2109                         GTK_WINDOW(win),
2110                         dgettext("ke-recv","memr_ib_operation_disabled"),
2111                         TRUE);
2112
2113         if (lowmem)
2114                 g_debug ("%s: low memory reached. disallowing some operations",
2115                          __FUNCTION__);
2116
2117         return lowmem;
2118 }