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
  33 #include <modest-platform.h>
  34 #include <modest-defs.h>
  35 #include <modest-runtime.h>
  36 #include <modest-main-window.h>
  37 #include <modest-header-view.h>
  38 #include "modest-hildon2-global-settings-dialog.h"
  39 #include "modest-widget-memory.h"
  40 #include <modest-hildon-includes.h>
  41 #include <modest-maemo-utils.h>
  42 #include <dbus_api/modest-dbus-callbacks.h>
  43 #include <modest-osso-autosave-callbacks.h>
  44 #include <libosso.h>
  45 #include <tny-maemo-conic-device.h>
  46 #include <tny-simple-list.h>
  47 #include <tny-merge-folder.h>
  48 #include <tny-error.h>
  49 #include <tny-folder.h>
  50 #include <tny-account-store-view.h>
  51 #include <gtk/gtkicontheme.h>
  52 #include <gtk/gtkmenuitem.h>
  53 #include <gtk/gtkmain.h>
  54 #include <modest-text-utils.h>
  55 #include "modest-tny-folder.h"
  56 #include "modest-tny-account.h"
  57 #include <string.h>
  58 #include <libgnomevfs/gnome-vfs-mime-utils.h>
  59 #include <modest-account-settings-dialog.h>
  60 #include <modest-easysetup-wizard-dialog.h>
  61 #include "modest-hildon2-sort-dialog.h"
  62 #include <hildon/hildon.h>
  63 #include <osso-mem.h>
  64 #include "hildon2/modest-hildon2-details-dialog.h"
  65 #include "hildon2/modest-hildon2-window-mgr.h"
  66 #include <keys_nokia.h>
  67 #include <libprofile.h>
  68 #include <canberra.h>
  69 #include <modest-datetime-formatter.h>
  70 #include "modest-header-window.h"
  71 #include <modest-folder-window.h>
  72 #include <modest-account-mgr.h>
  73 #include <modest-account-mgr-helpers.h>
  74 #include <modest-ui-constants.h>
  75 #include <modest-selector-picker.h>
  76 #include <modest-icon-names.h>
  77
  78 #ifdef MODEST_HAVE_MCE
  79 #include <mce/dbus-names.h>
  80 #endif /*MODEST_HAVE_MCE*/
  81
  82 #ifdef MODEST_HAVE_ABOOK
  83 #include <libosso-abook/osso-abook.h>
  84 #endif /*MODEST_HAVE_ABOOK*/
  85
  86 #ifdef MODEST_HAVE_LIBALARM
  87 #include <alarmd/libalarm.h> /* For alarm_event_add(), etc. */
  88 #endif /*MODEST_HAVE_LIBALARM*/
  89
  90
  91 #define HILDON_OSSO_URI_ACTION "uri-action"
  92 #define URI_ACTION_COPY "copy:"
  93 #define MODEST_NOTIFICATION_CATEGORY "email-message"
  94 #define MODEST_NEW_MAIL_LIGHTING_PATTERN "PatternCommunicationEmail"
  95 #define PROFILE_MAIL_TONE PROFILEKEY_EMAIL_ALERT_TONE
  96 #define PROFILE_MAIL_VOLUME PROFILEKEY_EMAIL_ALERT_VOLUME
  97
  98 #define COMMON_FOLDER_DIALOG_ENTRY "entry"
  99 #define COMMON_FOLDER_DIALOG_ACCOUNT_PICKER "account-picker"
 100 #define FOLDER_PICKER_CURRENT_FOLDER "current-folder"
 101 #define MODEST_ALARMD_APPID PACKAGE_NAME
 102
 103
 104 static void _modest_platform_play_email_tone (void);
 105
 106
 107 static void
 108 on_modest_conf_update_interval_changed (ModestConf* self,
 109                                         const gchar *key,
 110                                         ModestConfEvent event,
 111                                         ModestConfNotificationId id,
 112                                         gpointer user_data)
 113 {
 114         g_return_if_fail (key);
 115
 116         if (strcmp (key, MODEST_CONF_UPDATE_INTERVAL) == 0) {
 117                 const guint update_interval_minutes =
 118                         modest_conf_get_int (self, MODEST_CONF_UPDATE_INTERVAL, NULL);
 119                 modest_platform_set_update_interval (update_interval_minutes);
 120         }
 121 }
 122
 123
 124
 125 static gboolean
 126 check_required_files (void)
 127 {
 128         FILE *mcc_file = modest_maemo_open_mcc_mapping_file ();
 129         if (!mcc_file) {
 130                 g_printerr ("modest: check for mcc file failed\n");
 131                 return FALSE;
 132         } else
 133                 fclose (mcc_file);
 134
 135         if (access(MODEST_PROVIDER_DATA_FILE, R_OK) != 0 &&
 136             access(MODEST_MAEMO_PROVIDER_DATA_FILE, R_OK) != 0) {
 137                 g_printerr ("modest: cannot find providers data\n");
 138                 return FALSE;
 139         }
 140
 141         return TRUE;
 142 }
 143
 144
 145 /* the gpointer here is the osso_context. */
 146 gboolean
 147 modest_platform_init (int argc, char *argv[])
 148 {
 149         osso_context_t *osso_context;
 150
 151         osso_hw_state_t hw_state = { 0 };
 152         DBusConnection *con;
 153         GSList *acc_names;
 154
 155         if (!check_required_files ()) {
 156                 g_printerr ("modest: missing required files\n");
 157                 return FALSE;
 158         }
 159
 160         osso_context =  osso_initialize(PACKAGE,PACKAGE_VERSION,
 161                                         FALSE, NULL);
 162         if (!osso_context) {
 163                 g_printerr ("modest: failed to acquire osso context\n");
 164                 return FALSE;
 165         }
 166         modest_maemo_utils_set_osso_context (osso_context);
 167
 168         if ((con = osso_get_dbus_connection (osso_context)) == NULL) {
 169                 g_printerr ("modest: could not get dbus connection\n");
 170                 return FALSE;
 171         }
 172
 173         /* Add a D-Bus handler to be used when the main osso-rpc
 174          * D-Bus handler has not handled something.
 175          * We use this for D-Bus methods that need to use more complex types
 176          * than osso-rpc supports.
 177          */
 178         if (!dbus_connection_add_filter (con,
 179                                          modest_dbus_req_filter,
 180                                          NULL,
 181                                          NULL)) {
 182
 183                 g_printerr ("modest: Could not add D-Bus filter\n");
 184                 return FALSE;
 185         }
 186
 187         /* Register our simple D-Bus callbacks, via the osso API: */
 188         osso_return_t result = osso_rpc_set_cb_f(osso_context,
 189                                MODEST_DBUS_SERVICE,
 190                                MODEST_DBUS_OBJECT,
 191                                MODEST_DBUS_IFACE,
 192                                modest_dbus_req_handler, NULL /* user_data */);
 193         if (result != OSSO_OK) {
 194                 g_printerr ("modest: Error setting D-BUS callback (%d)\n", result);
 195                 return FALSE;
 196         }
 197
 198         /* Register hardware event dbus callback: */
 199         hw_state.shutdown_ind = TRUE;
 200         osso_hw_set_event_cb(osso_context, NULL, NULL, NULL);
 201
 202         /* Register osso auto-save callbacks: */
 203         result = osso_application_set_autosave_cb (osso_context,
 204                 modest_on_osso_application_autosave, NULL /* user_data */);
 205         if (result != OSSO_OK) {
 206                 g_printerr ("modest: osso_application_set_autosave_cb() failed.\n");
 207                 return FALSE;
 208         }
 209
 210
 211         /* Make sure that the update interval is changed whenever its gconf key
 212          * is changed */
 213         /* CAUTION: we're not using here the
 214            modest_conf_listen_to_namespace because we know that there
 215            are other parts of Modest listening for this namespace, so
 216            we'll receive the notifications anyway. We basically do not
 217            use it because there is no easy way to do the
 218            modest_conf_forget_namespace */
 219         ModestConf *conf = modest_runtime_get_conf ();
 220         g_signal_connect (G_OBJECT(conf),
 221                           "key_changed",
 222                           G_CALLBACK (on_modest_conf_update_interval_changed),
 223                           NULL);
 224
 225         /* only force the setting of the default interval, if there are actually
 226          * any accounts */
 227         acc_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(), TRUE);
 228         if (acc_names) {
 229                 /* Get the initial update interval from gconf: */
 230                 on_modest_conf_update_interval_changed(conf, MODEST_CONF_UPDATE_INTERVAL,
 231                                                        MODEST_CONF_EVENT_KEY_CHANGED, 0, NULL);
 232                 modest_account_mgr_free_account_names (acc_names);
 233         }
 234
 235
 236 #ifdef MODEST_HAVE_ABOOK
 237         /* initialize the addressbook */
 238         if (!osso_abook_init (&argc, &argv, osso_context)) {
 239                 g_printerr ("modest: failed to initialized addressbook\n");
 240                 return FALSE;
 241         }
 242 #endif /*MODEST_HAVE_ABOOK*/
 243
 244         return TRUE;
 245 }
 246
 247 gboolean
 248 modest_platform_uninit (void)
 249 {
 250         osso_context_t *osso_context =
 251                 modest_maemo_utils_get_osso_context ();
 252         if (osso_context)
 253                 osso_deinitialize (osso_context);
 254
 255         return TRUE;
 256 }
 257
 258
 259
 260
 261 TnyDevice*
 262 modest_platform_get_new_device (void)
 263 {
 264         return TNY_DEVICE (tny_maemo_conic_device_new ());
 265 }
 266
 267 gchar*
 268 modest_platform_get_file_icon_name (const gchar* name, const gchar* mime_type,
 269                                     gchar **effective_mime_type)
 270 {
 271         GString *mime_str = NULL;
 272         gchar *icon_name  = NULL;
 273         gchar **icons, **cursor;
 274
 275         if (!mime_type || g_ascii_strcasecmp (mime_type, "application/octet-stream") == 0)
 276                 mime_str = g_string_new (gnome_vfs_get_mime_type_for_name (name));
 277         else {
 278                 mime_str = g_string_new (mime_type);
 279                 g_string_ascii_down (mime_str);
 280         }
 281
 282         icons = hildon_mime_get_icon_names (mime_str->str, NULL);
 283
 284         for (cursor = icons; cursor; ++cursor) {
 285                 if (!g_ascii_strcasecmp (*cursor, "gnome-mime-message") ||
 286                     !g_ascii_strcasecmp (*cursor, "gnome-mime-message-rfc822")) {
 287                         icon_name = g_strdup ("qgn_list_messagin");
 288                         break;
 289                 } else if (gtk_icon_theme_has_icon (gtk_icon_theme_get_default(), *cursor)) {
 290                         icon_name = g_strdup (*cursor);
 291                         break;
 292                 }
 293         }
 294         g_strfreev (icons);
 295
 296         if (effective_mime_type)
 297                 *effective_mime_type = g_string_free (mime_str, FALSE);
 298         else
 299                 g_string_free (mime_str, TRUE);
 300
 301         return icon_name;
 302 }
 303
 304
 305 static gboolean
 306 checked_hildon_uri_open (const gchar *uri, HildonURIAction *action)
 307 {
 308         GError *err = NULL;
 309         gboolean result;
 310
 311         g_return_val_if_fail (uri, FALSE);
 312
 313         result = hildon_uri_open (uri, action, &err);
 314         if (!result) {
 315                 g_printerr ("modest: hildon_uri_open ('%s', %p) failed: %s",
 316                             uri, action,  err && err->message ? err->message : "unknown error");
 317                 if (err)
 318                         g_error_free (err);
 319         }
 320         return result;
 321 }
 322
 323
 324
 325 gboolean
 326 modest_platform_activate_uri (const gchar *uri)
 327 {
 328         HildonURIAction *action;
 329         gboolean result = FALSE;
 330         GSList *actions, *iter = NULL;
 331
 332         g_return_val_if_fail (uri, FALSE);
 333         if (!uri)
 334                 return FALSE;
 335
 336         /* don't try to activate file: uri's -- they might confuse the user,
 337          * and/or might have security implications */
 338         if (!g_str_has_prefix (uri, "file:")) {
 339
 340                 actions = hildon_uri_get_actions_by_uri (uri, -1, NULL);
 341
 342                 for (iter = actions; iter; iter = g_slist_next (iter)) {
 343                         action = (HildonURIAction*) iter->data;
 344                         if (action && strcmp (hildon_uri_action_get_service (action),
 345                                               "com.nokia.modest") == 0) {
 346                                 result = checked_hildon_uri_open (uri, action);
 347                                 break;
 348                         }
 349                 }
 350
 351                 /* if we could not open it with email, try something else */
 352                 if (!result)
 353                         result = checked_hildon_uri_open (uri, NULL);
 354         }
 355
 356         if (!result) {
 357                 ModestWindow *parent =
 358                         modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(), FALSE);
 359                 hildon_banner_show_information (parent ? GTK_WIDGET(parent): NULL, NULL,
 360                                                 _("mcen_ib_unsupported_link"));
 361                 g_warning ("%s: cannot open uri '%s'", __FUNCTION__,uri);
 362         }
 363
 364         return result;
 365 }
 366
 367 gboolean
 368 modest_platform_activate_file (const gchar *path, const gchar *mime_type)
 369 {
 370         gint result = 0;
 371         DBusConnection *con;
 372         gchar *uri_path = NULL;
 373
 374         uri_path = gnome_vfs_get_uri_from_local_path (path);
 375         con = osso_get_dbus_connection (modest_maemo_utils_get_osso_context());
 376
 377         if (mime_type)
 378                 result = hildon_mime_open_file_with_mime_type (con, uri_path, mime_type);
 379         if (result != 1)
 380                 result = hildon_mime_open_file (con, uri_path);
 381         if (result != 1)
 382                 modest_platform_run_information_dialog (NULL, _("mcen_ni_noregistered_viewer"), FALSE);
 383
 384         return result != 1;
 385 }
 386
 387 typedef struct  {
 388         GSList *actions;
 389         gchar  *uri;
 390 } ModestPlatformPopupInfo;
 391
 392 static gboolean
 393 delete_uri_popup (GtkWidget *menu,
 394                   GdkEvent *event,
 395                   gpointer userdata)
 396 {
 397         ModestPlatformPopupInfo *popup_info = (ModestPlatformPopupInfo *) userdata;
 398
 399         g_free (popup_info->uri);
 400         hildon_uri_free_actions (popup_info->actions);
 401
 402         return FALSE;
 403 }
 404
 405 static void
 406 activate_uri_popup_item (GtkMenuItem *menu_item,
 407                          gpointer userdata)
 408 {
 409         GSList *node;
 410         ModestPlatformPopupInfo *popup_info = (ModestPlatformPopupInfo *) userdata;
 411         const gchar* action_name;
 412
 413         action_name = g_object_get_data (G_OBJECT(menu_item), HILDON_OSSO_URI_ACTION);
 414         if (!action_name) {
 415                 g_printerr ("modest: no action name defined\n");
 416                 return;
 417         }
 418
 419         /* special handling for the copy menu item -- copy the uri to the clipboard */
 420         /* if it's a copy thingy, the uri will look like 'copy:http://slashdot.org' */
 421         if (g_str_has_prefix (action_name, URI_ACTION_COPY)) {
 422                 GtkClipboard *clipboard = gtk_clipboard_get (GDK_NONE);
 423                 action_name += strlen(URI_ACTION_COPY); /* jump past the prefix */
 424
 425                 if (g_str_has_prefix (action_name, "mailto:")) /* ignore mailto: prefixes */
 426                         action_name += strlen ("mailto:");
 427
 428                 gtk_clipboard_set_text (clipboard, action_name, strlen (action_name));
 429                 modest_platform_information_banner (NULL, NULL, _CS("ecoc_ib_edwin_copied"));
 430                 return; /* we're done */
 431         }
 432
 433         /* now, the real uri-actions... */
 434         for (node = popup_info->actions; node != NULL; node = g_slist_next (node)) {
 435                 HildonURIAction *action = (HildonURIAction *) node->data;
 436                 if (strcmp (action_name, hildon_uri_action_get_name (action))==0) {
 437                         if (!checked_hildon_uri_open (popup_info->uri, action)) {
 438                                 ModestWindow *parent =
 439                                         modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(), FALSE);
 440                                 hildon_banner_show_information (parent ? GTK_WIDGET(parent): NULL, NULL,
 441                                                                 _("mcen_ib_unsupported_link"));
 442                         }
 443                         break;
 444                 }
 445         }
 446 }
 447
 448 gboolean
 449 modest_platform_show_uri_popup (const gchar *uri)
 450 {
 451         GSList *actions_list;
 452
 453         if (uri == NULL)
 454                 return FALSE;
 455
 456         actions_list = hildon_uri_get_actions_by_uri (uri, -1, NULL);
 457         if (actions_list) {
 458
 459                 GtkWidget *menu = gtk_menu_new ();
 460                 ModestPlatformPopupInfo *popup_info = g_new0 (ModestPlatformPopupInfo, 1);
 461
 462                 /* don't add actions for file: uri's -- they might confuse the user,
 463                  * and/or might have security implications
 464                  * we still allow to copy the url though
 465                  */
 466                 if (!g_str_has_prefix (uri, "file:")) {
 467
 468                         GSList *node;
 469                         popup_info->actions = actions_list;
 470                         popup_info->uri = g_strdup (uri);
 471
 472                         for (node = actions_list; node != NULL; node = g_slist_next (node)) {
 473                                 GtkWidget *menu_item;
 474                                 const gchar *action_name;
 475                                 const gchar *translation_domain;
 476                                 HildonURIAction *action = (HildonURIAction *) node->data;
 477                                 action_name = hildon_uri_action_get_name (action);
 478                                 translation_domain = hildon_uri_action_get_translation_domain (action);
 479                                 menu_item = gtk_menu_item_new_with_label (dgettext(translation_domain, action_name));
 480                                 g_object_set_data (G_OBJECT(menu_item), HILDON_OSSO_URI_ACTION, (gpointer)action_name);  /* hack */
 481                                 g_signal_connect (G_OBJECT (menu_item), "activate", G_CALLBACK (activate_uri_popup_item),
 482                                                   popup_info);
 483
 484                                 if (hildon_uri_is_default_action (action, NULL)) {
 485                                         gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
 486                                 } else {
 487                                         gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
 488                                 }
 489                                 gtk_widget_show (menu_item);
 490                         }
 491                 }
 492
 493
 494                 /* and what to do when the link is deleted */
 495                 g_signal_connect (G_OBJECT (menu), "delete-event", G_CALLBACK (delete_uri_popup), popup_info);
 496                 gtk_menu_popup (GTK_MENU(menu), NULL, NULL, NULL, NULL, 1, gtk_get_current_event_time ());
 497
 498         } else {
 499                 hildon_banner_show_information (NULL, NULL, _("mcen_ib_unsupported_link"));
 500         }
 501
 502         return TRUE;
 503 }
 504
 505
 506 GdkPixbuf*
 507 modest_platform_get_icon (const gchar *name, guint icon_size)
 508 {
 509         GError *err = NULL;
 510         GdkPixbuf* pixbuf = NULL;
 511         GtkIconTheme *current_theme = NULL;
 512
 513         g_return_val_if_fail (name, NULL);
 514
 515         /* strlen == 0 is not really an error; it just
 516          * means the icon is not available
 517          */
 518         if (!name || strlen(name) == 0)
 519                 return NULL;
 520
 521         current_theme = gtk_icon_theme_get_default ();
 522         pixbuf = gtk_icon_theme_load_icon (current_theme, name, icon_size,
 523                                            GTK_ICON_LOOKUP_NO_SVG,
 524                                            &err);
 525         if (!pixbuf) {
 526                 g_printerr ("modest: error loading theme icon '%s': %s\n",
 527                             name, err->message);
 528                 g_error_free (err);
 529         }
 530         return pixbuf;
 531 }
 532
 533 const gchar*
 534 modest_platform_get_app_name (void)
 535 {
 536         return _("mcen_ap_name");
 537 }
 538
 539 static void
 540 entry_insert_text (GtkEditable *editable,
 541                    const gchar *text,
 542                    gint         length,
 543                    gint        *position,
 544                    gpointer     data)
 545 {
 546         gchar *chars;
 547         gint chars_length;
 548
 549         chars = gtk_editable_get_chars (editable, 0, -1);
 550         chars_length = g_utf8_strlen (chars, -1);
 551         g_free (chars);
 552
 553         /* Show WID-INF036 */
 554         if (chars_length >= 20) {
 555                 hildon_banner_show_information  (gtk_widget_get_parent (GTK_WIDGET (data)), NULL,
 556                                                  _CS("ckdg_ib_maximum_characters_reached"));
 557         } else {
 558                 if (modest_text_utils_is_forbidden_char (*text, FOLDER_NAME_FORBIDDEN_CHARS)) {
 559                         /* Show an error */
 560                         gchar *tmp, *msg;
 561
 562                         tmp = g_strndup (folder_name_forbidden_chars,
 563                                          FOLDER_NAME_FORBIDDEN_CHARS_LENGTH);
 564                         msg = g_strdup_printf (_CS("ckdg_ib_illegal_characters_entered"), tmp);
 565                         hildon_banner_show_information  (gtk_widget_get_parent (GTK_WIDGET (data)),
 566                                                          NULL, msg);
 567                         g_free (msg);
 568                         g_free (tmp);
 569                 } else {
 570                         if (length >= 20) {
 571                                 hildon_banner_show_information  (gtk_widget_get_parent (GTK_WIDGET (data)), NULL,
 572                                                                  _CS("ckdg_ib_maximum_characters_reached"));
 573                         }
 574                         /* Write the text in the entry if it's valid */
 575                         g_signal_handlers_block_by_func (editable,
 576                                                          (gpointer) entry_insert_text, data);
 577                         gtk_editable_insert_text (editable, text, length, position);
 578                         g_signal_handlers_unblock_by_func (editable,
 579                                                            (gpointer) entry_insert_text, data);
 580                 }
 581         }
 582         /* Do not allow further processing */
 583         g_signal_stop_emission_by_name (editable, "insert_text");
 584 }
 585
 586 static void
 587 entry_changed (GtkEditable *editable,
 588                gpointer     user_data)
 589 {
 590         gchar *chars;
 591         GtkWidget *ok_button;
 592         GList *buttons;
 593
 594         buttons = gtk_container_get_children (GTK_CONTAINER (GTK_DIALOG (user_data)->action_area));
 595         ok_button = GTK_WIDGET (buttons->data);
 596
 597         chars = gtk_editable_get_chars (editable, 0, -1);
 598         g_return_if_fail (chars != NULL);
 599
 600
 601         if (g_utf8_strlen (chars,-1) >= 20) {
 602                 hildon_banner_show_information  (gtk_widget_get_parent (GTK_WIDGET (user_data)), NULL,
 603                                                  _CS("ckdg_ib_maximum_characters_reached"));
 604         }
 605         gtk_widget_set_sensitive (ok_button, modest_text_utils_validate_folder_name(chars));
 606
 607         /* Free */
 608         g_list_free (buttons);
 609         g_free (chars);
 610 }
 611
 612
 613
 614 static void
 615 on_response (GtkDialog *dialog,
 616              gint response,
 617              gpointer user_data)
 618 {
 619         GtkWidget *entry, *picker;
 620         TnyFolderStore *parent;
 621         const gchar *new_name;
 622         gboolean exists;
 623
 624         if (response != GTK_RESPONSE_ACCEPT)
 625                 return;
 626
 627         /* Get entry */
 628         entry = g_object_get_data (G_OBJECT (dialog), COMMON_FOLDER_DIALOG_ENTRY);
 629         picker = g_object_get_data (G_OBJECT (dialog), COMMON_FOLDER_DIALOG_ACCOUNT_PICKER);
 630
 631         parent = TNY_FOLDER_STORE (user_data);
 632         new_name = gtk_entry_get_text (GTK_ENTRY (entry));
 633         exists = FALSE;
 634
 635         if (picker != NULL) {
 636
 637                 parent = g_object_get_data (G_OBJECT (picker), FOLDER_PICKER_CURRENT_FOLDER);
 638         }
 639
 640         /* Look for another folder with the same name */
 641         if (modest_tny_folder_has_subfolder_with_name (parent,
 642                                                        new_name,
 643                                                        TRUE)) {
 644                 exists = TRUE;
 645         }
 646
 647         if (!exists) {
 648                 if (TNY_IS_ACCOUNT (parent) &&
 649                     modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent)) &&
 650                     modest_tny_local_folders_account_folder_name_in_use (MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (parent),
 651                                                                          new_name)) {
 652                         exists = TRUE;
 653                 }
 654         }
 655
 656         if (exists) {
 657
 658                 /* Show an error */
 659                 hildon_banner_show_information (gtk_widget_get_parent (GTK_WIDGET (dialog)),
 660                                                 NULL, _CS("ckdg_ib_folder_already_exists"));
 661                 /* Select the text */
 662                 gtk_entry_select_region (GTK_ENTRY (entry), 0, -1);
 663                 gtk_widget_grab_focus (entry);
 664                 /* Do not close the dialog */
 665                 g_signal_stop_emission_by_name (dialog, "response");
 666         }
 667
 668 }
 669
 670 typedef struct _FolderChooserData {
 671         TnyFolderStore *store;
 672         GtkWidget *dialog;
 673 } FolderChooserData;
 674
 675 static void
 676 folder_chooser_activated (ModestFolderView *folder_view,
 677                           TnyFolderStore *folder,
 678                           FolderChooserData *userdata)
 679 {
 680         userdata->store = folder;
 681         gtk_dialog_response (GTK_DIALOG (userdata->dialog), GTK_RESPONSE_OK);
 682 }
 683
 684 static TnyFolderStore *
 685 folder_chooser_dialog_run (ModestFolderView *original)
 686 {
 687         GtkWidget *folder_view;
 688         FolderChooserData userdata = {NULL, NULL};
 689         GtkWidget *pannable;
 690         const gchar *visible_id = NULL;
 691
 692         userdata.dialog = hildon_dialog_new ();
 693         pannable = hildon_pannable_area_new ();
 694         folder_view = modest_platform_create_folder_view (NULL);
 695
 696         gtk_window_set_title (GTK_WINDOW (userdata.dialog), _FM("ckdg_ti_change_folder"));
 697
 698         modest_folder_view_copy_model (MODEST_FOLDER_VIEW (original),
 699                                        MODEST_FOLDER_VIEW (folder_view));
 700
 701         visible_id =
 702                 modest_folder_view_get_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(original));
 703         modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(folder_view),
 704                                                                      visible_id);
 705
 706         gtk_container_add (GTK_CONTAINER (GTK_DIALOG (userdata.dialog)->vbox), pannable);
 707         gtk_container_add (GTK_CONTAINER (pannable), folder_view);
 708         gtk_widget_set_size_request (pannable, -1, 320);
 709
 710         gtk_widget_show (folder_view);
 711         gtk_widget_show (pannable);
 712         gtk_widget_show (userdata.dialog);
 713         g_signal_connect (G_OBJECT (folder_view), "folder-activated",
 714                           G_CALLBACK (folder_chooser_activated),
 715                           (gpointer) &userdata);
 716
 717         gtk_dialog_run (GTK_DIALOG (userdata.dialog));
 718         gtk_widget_destroy (userdata.dialog);
 719
 720         return userdata.store;
 721 }
 722
 723 static gchar *
 724 folder_store_get_display_name (TnyFolderStore *store)
 725 {
 726         if (TNY_IS_ACCOUNT (store)) {
 727                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (store)))
 728                         return modest_conf_get_string (modest_runtime_get_conf(),
 729                                                        MODEST_CONF_DEVICE_NAME, NULL);
 730                 else
 731                         return g_strdup (tny_account_get_name (TNY_ACCOUNT (store)));
 732         } else {
 733                 gchar *fname;
 734                 TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
 735
 736                 fname = g_strdup (tny_folder_get_name (TNY_FOLDER (store)));
 737                 type = tny_folder_get_folder_type (TNY_FOLDER (store));
 738                 if (modest_tny_folder_is_local_folder (TNY_FOLDER (store)) ||
 739                     modest_tny_folder_is_memory_card_folder (TNY_FOLDER (store))) {
 740                         type = modest_tny_folder_get_local_or_mmc_folder_type (TNY_FOLDER (store));
 741                         if (type != TNY_FOLDER_TYPE_UNKNOWN) {
 742                                 g_free (fname);
 743                                 fname = g_strdup (modest_local_folder_info_get_type_display_name (type));
 744                         }
 745                 } else {
 746                         /* Sometimes an special folder is reported by the server as
 747                            NORMAL, like some versions of Dovecot */
 748                         if (type == TNY_FOLDER_TYPE_NORMAL ||
 749                             type == TNY_FOLDER_TYPE_UNKNOWN) {
 750                                 type = modest_tny_folder_guess_folder_type (TNY_FOLDER (store));
 751                         }
 752                 }
 753
 754                 if (type == TNY_FOLDER_TYPE_INBOX) {
 755                         g_free (fname);
 756                         fname = g_strdup (_("mcen_me_folder_inbox"));
 757                 }
 758                 return fname;
 759         }
 760 }
 761
 762 static void
 763 folder_picker_set_store (GtkButton *button, TnyFolderStore *store)
 764 {
 765         gchar *name;
 766
 767         if (store == NULL) {
 768                 g_object_set_data (G_OBJECT (button), FOLDER_PICKER_CURRENT_FOLDER, NULL);
 769         } else {
 770                 GdkPixbuf *pixbuf;
 771                 const gchar *icon_name = NULL;
 772
 773                 g_object_ref (store);
 774                 g_object_set_data_full (G_OBJECT (button), FOLDER_PICKER_CURRENT_FOLDER,
 775                                         store, (GDestroyNotify) g_object_unref);
 776                 name = folder_store_get_display_name (store);
 777                 hildon_button_set_value (HILDON_BUTTON (button), name);
 778                 g_free (name);
 779
 780                 /* Select icon */
 781                 if (TNY_IS_ACCOUNT (store)) {
 782                         if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (store)))
 783                             icon_name = MODEST_FOLDER_ICON_LOCAL_FOLDERS;
 784                         else if (modest_tny_account_is_memory_card_account (TNY_ACCOUNT (store)))
 785                                 icon_name = MODEST_FOLDER_ICON_MMC;
 786                         else
 787                                 icon_name = MODEST_FOLDER_ICON_ACCOUNT;
 788                 } else {
 789                         if (modest_tny_folder_is_remote_folder (TNY_FOLDER (store))) {
 790                                 TnyFolderType type = modest_tny_folder_guess_folder_type (TNY_FOLDER (store));
 791                                 switch (type) {
 792                                 case TNY_FOLDER_TYPE_INBOX:
 793                                         icon_name = MODEST_FOLDER_ICON_INBOX;
 794                                         break;
 795                                 default:
 796                                         icon_name = MODEST_FOLDER_ICON_ACCOUNT;
 797                                 }
 798                         } else if (modest_tny_folder_is_local_folder (TNY_FOLDER (store)))
 799                                 icon_name = MODEST_FOLDER_ICON_NORMAL;
 800                         else if (modest_tny_folder_is_memory_card_folder (TNY_FOLDER (store)))
 801                                 icon_name = MODEST_FOLDER_ICON_MMC_FOLDER;
 802                 }
 803
 804                 /* Set icon */
 805                 pixbuf = modest_platform_get_icon (icon_name, MODEST_ICON_SIZE_SMALL);
 806
 807                 if (pixbuf) {
 808                         hildon_button_set_image (HILDON_BUTTON (button),
 809                                                  gtk_image_new_from_pixbuf (pixbuf));
 810                         g_object_unref (pixbuf);
 811                 }
 812         }
 813 }
 814
 815 static void
 816 folder_picker_clicked (GtkButton *button,
 817                        ModestFolderView *folder_view)
 818 {
 819         TnyFolderStore *store;
 820
 821         store = folder_chooser_dialog_run (folder_view);
 822         if (store) {
 823                 folder_picker_set_store (GTK_BUTTON (button), store);
 824         }
 825 }
 826
 827 static GtkWidget *
 828 folder_picker_new (ModestFolderView *folder_view, TnyFolderStore *suggested)
 829 {
 830         GtkWidget *button;
 831
 832         button = hildon_button_new (MODEST_EDITABLE_SIZE,
 833                                     HILDON_BUTTON_ARRANGEMENT_HORIZONTAL);
 834
 835         hildon_button_set_alignment (HILDON_BUTTON (button), 0.0, 0.5, 1.0, 1.0);
 836
 837         if (suggested) {
 838                 folder_picker_set_store (GTK_BUTTON (button), suggested);
 839         }
 840
 841         g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (folder_picker_clicked), folder_view);
 842
 843         return button;
 844 }
 845
 846
 847 static gint
 848 modest_platform_run_folder_common_dialog (GtkWindow *parent_window,
 849                                           TnyFolderStore *suggested_parent,
 850                                           const gchar *dialog_title,
 851                                           const gchar *label_text,
 852                                           const gchar *suggested_name,
 853                                           gboolean show_name,
 854                                           gboolean show_parent,
 855                                           gchar **folder_name,
 856                                           TnyFolderStore **parent)
 857 {
 858         GtkWidget *accept_btn = NULL;
 859         GtkWidget *dialog, *entry = NULL, *label_entry = NULL,  *label_location = NULL, *hbox;
 860         GtkWidget *account_picker = NULL;
 861         GList *buttons = NULL;
 862         gint result;
 863         GtkSizeGroup *sizegroup;
 864         ModestFolderView *folder_view;
 865         ModestWindow *folder_window;
 866         ModestHildon2WindowMgr *window_mgr;
 867
 868         window_mgr = (ModestHildon2WindowMgr *) modest_runtime_get_window_mgr ();
 869         folder_window = modest_hildon2_window_mgr_get_folder_window (window_mgr);
 870         g_return_val_if_fail (MODEST_IS_FOLDER_WINDOW (folder_window), GTK_RESPONSE_NONE);
 871
 872         folder_view = modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (folder_window));
 873
 874         /* Ask the user for the folder name */
 875         dialog = gtk_dialog_new_with_buttons (dialog_title,
 876                                               parent_window,
 877                                               GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
 878                                               _FM("ckdg_bd_new_folder_dialog_ok"),
 879                                               GTK_RESPONSE_ACCEPT,
 880                                               NULL);
 881
 882         /* Add accept button (with unsensitive handler) */
 883         buttons = gtk_container_get_children (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area));
 884         accept_btn = GTK_WIDGET (buttons->data);
 885
 886         sizegroup = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
 887
 888         if (show_name) {
 889                 label_entry = gtk_label_new (label_text);
 890                 entry = hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
 891                 gtk_entry_set_max_length (GTK_ENTRY (entry), 20);
 892
 893                 gtk_misc_set_alignment (GTK_MISC (label_entry), 0.0, 0.5);
 894                 gtk_size_group_add_widget (sizegroup, label_entry);
 895
 896                 if (suggested_name)
 897                         gtk_entry_set_text (GTK_ENTRY (entry), suggested_name);
 898                 else
 899                         gtk_entry_set_text (GTK_ENTRY (entry), _FM("ckdg_va_new_folder_name_stub"));
 900                 gtk_entry_set_width_chars (GTK_ENTRY (entry),
 901                                            MAX (g_utf8_strlen (gtk_entry_get_text (GTK_ENTRY (entry)), -1),
 902                                                 g_utf8_strlen (_FM("ckdg_va_new_folder_name_stub"), -1)));
 903                 gtk_entry_select_region (GTK_ENTRY (entry), 0, -1);
 904         }
 905
 906         if (show_parent) {
 907
 908                 label_location = gtk_label_new (_FM("ckdg_fi_new_folder_location"));
 909
 910                 gtk_misc_set_alignment (GTK_MISC (label_location), 0.0, 0.5);
 911                 gtk_size_group_add_widget (sizegroup, label_location);
 912
 913                 account_picker = folder_picker_new (folder_view, suggested_parent);
 914         }
 915
 916         g_object_unref (sizegroup);
 917
 918         /* Connect to the response method to avoid closing the dialog
 919            when an invalid name is selected*/
 920         g_signal_connect (dialog,
 921                           "response",
 922                           G_CALLBACK (on_response),
 923                           suggested_parent);
 924
 925         if (show_name) {
 926                 /* Track entry changes */
 927                 g_signal_connect (entry,
 928                                   "insert-text",
 929                                   G_CALLBACK (entry_insert_text),
 930                                   dialog);
 931                 g_signal_connect (entry,
 932                                   "changed",
 933                                   G_CALLBACK (entry_changed),
 934                                   dialog);
 935         }
 936
 937
 938         /* Some locales like pt_BR need this to get the full window
 939            title shown */
 940         gtk_widget_set_size_request (GTK_WIDGET (dialog), 300, -1);
 941
 942         /* Create the hbox */
 943         if (show_name) {
 944                 hbox = gtk_hbox_new (FALSE, 12);
 945                 gtk_box_pack_start (GTK_BOX (hbox), label_entry, FALSE, FALSE, 0);
 946                 gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
 947
 948                 /* Add hbox to dialog */
 949                 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
 950                                     hbox, FALSE, FALSE, 0);
 951                 g_object_set_data (G_OBJECT (dialog), COMMON_FOLDER_DIALOG_ENTRY, entry);
 952         }
 953
 954         if (show_parent) {
 955                 hbox = gtk_hbox_new (FALSE, 12);
 956                 gtk_box_pack_start (GTK_BOX (hbox), label_location, FALSE, FALSE, 0);
 957                 gtk_box_pack_start (GTK_BOX (hbox), account_picker, TRUE, TRUE, 0);
 958
 959                 /* Add hbox to dialog */
 960                 gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
 961                                     hbox, FALSE, FALSE, 0);
 962                 g_object_set_data (G_OBJECT (dialog), COMMON_FOLDER_DIALOG_ACCOUNT_PICKER, account_picker);
 963         }
 964         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
 965                                      GTK_WINDOW (dialog), parent_window);
 966         gtk_widget_show_all (GTK_WIDGET(dialog));
 967
 968         result = gtk_dialog_run (GTK_DIALOG(dialog));
 969         if (result == GTK_RESPONSE_ACCEPT) {
 970                 if (show_name)
 971                         *folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
 972                 if (show_parent) {
 973                         *parent = g_object_get_data (G_OBJECT (account_picker), FOLDER_PICKER_CURRENT_FOLDER);
 974                         if (*parent)
 975                                 g_object_ref (*parent);
 976                 }
 977         }
 978
 979         gtk_widget_destroy (dialog);
 980
 981         while (gtk_events_pending ())
 982                 gtk_main_iteration ();
 983
 984         return result;
 985 }
 986
 987 gint
 988 modest_platform_run_new_folder_dialog (GtkWindow *parent_window,
 989                                        TnyFolderStore *suggested_folder,
 990                                        gchar *suggested_name,
 991                                        gchar **folder_name,
 992                                        TnyFolderStore **parent_folder)
 993 {
 994         gchar *real_suggested_name = NULL;
 995         gint result;
 996         ModestTnyAccountStore *acc_store;
 997         TnyAccount *account;
 998
 999         if(suggested_name == NULL)
1000         {
1001                 const gchar *default_name = _FM("ckdg_va_new_folder_name_stub");
1002                 unsigned int i;
1003
1004                 for(i = 0; i < 100; ++ i) {
1005                         gboolean exists = FALSE;
1006
1007                         if (i == 0)
1008                                 real_suggested_name = g_strdup (default_name);
1009                         else
1010                                 real_suggested_name = g_strdup_printf ("%s(%d)",
1011                                                                        _FM("ckdg_va_new_folder_name_stub"),
1012                                                                        i);
1013                         exists = modest_tny_folder_has_subfolder_with_name (suggested_folder,
1014                                                                             real_suggested_name,
1015                                                                             TRUE);
1016
1017                         if (!exists)
1018                                 break;
1019
1020                         g_free (real_suggested_name);
1021                 }
1022
1023                 /* Didn't find a free number */
1024                 if (i == 100)
1025                         real_suggested_name = g_strdup (default_name);
1026         } else {
1027                 real_suggested_name = suggested_name;
1028         }
1029
1030         /* In hildon 2.2 we always suggest the archive folder as parent */
1031         acc_store = modest_runtime_get_account_store ();
1032         account = modest_tny_account_store_get_mmc_folders_account (acc_store);
1033         if (account) {
1034                 suggested_folder = (TnyFolderStore *)
1035                         modest_tny_account_get_special_folder (account,
1036                                                                TNY_FOLDER_TYPE_ARCHIVE);
1037                 g_object_unref (account);
1038                 account = NULL;
1039         }
1040
1041         /* If there is not archive folder then fallback to local folders account */
1042         if (!suggested_folder)
1043                 suggested_folder = (TnyFolderStore *)
1044                         modest_tny_account_store_get_local_folders_account (acc_store);
1045
1046         result = modest_platform_run_folder_common_dialog (parent_window,
1047                                                            suggested_folder,
1048                                                            _HL("ckdg_ti_new_folder"),
1049                                                            _FM("ckdg_fi_new_folder_name"),
1050                                                            real_suggested_name,
1051                                                            TRUE,
1052                                                            TRUE,
1053                                                            folder_name,
1054                                                            parent_folder);
1055
1056         if (suggested_name == NULL)
1057                 g_free(real_suggested_name);
1058
1059         return result;
1060 }
1061
1062 gint
1063 modest_platform_run_rename_folder_dialog (GtkWindow *parent_window,
1064                                           TnyFolderStore *parent_folder,
1065                                           const gchar *suggested_name,
1066                                           gchar **folder_name)
1067 {
1068         g_return_val_if_fail (TNY_IS_FOLDER_STORE (parent_folder), GTK_RESPONSE_REJECT);
1069
1070         return modest_platform_run_folder_common_dialog (parent_window,
1071                                                          parent_folder,
1072                                                          _HL("ckdg_ti_rename_folder"),
1073                                                          _HL("ckdg_fi_rename_name"),
1074                                                          suggested_name,
1075                                                          TRUE,
1076                                                          FALSE,
1077                                                          folder_name,
1078                                                          NULL);
1079 }
1080
1081
1082
1083 static void
1084 on_destroy_dialog (GtkWidget *dialog)
1085 {
1086         /* This could happen when the dialogs get programatically
1087            hidden or destroyed (for example when closing the
1088            application while a dialog is being shown) */
1089         if (!GTK_IS_WIDGET (dialog))
1090                 return;
1091
1092         gtk_widget_destroy (dialog);
1093
1094         if (gtk_events_pending ())
1095                 gtk_main_iteration ();
1096 }
1097
1098 gint
1099 modest_platform_run_confirmation_dialog (GtkWindow *parent_window,
1100                                          const gchar *message)
1101 {
1102         GtkWidget *dialog;
1103         gint response;
1104
1105         dialog = hildon_note_new_confirmation (parent_window, message);
1106         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1107                                      GTK_WINDOW (dialog), parent_window);
1108
1109         response = gtk_dialog_run (GTK_DIALOG (dialog));
1110
1111         on_destroy_dialog (dialog);
1112
1113         return response;
1114 }
1115
1116 gint
1117 modest_platform_run_confirmation_dialog_with_buttons (GtkWindow *parent_window,
1118                                                       const gchar *message,
1119                                                       const gchar *button_accept,
1120                                                       const gchar *button_cancel)
1121 {
1122         GtkWidget *dialog;
1123         gint response;
1124
1125         dialog = hildon_note_new_confirmation_add_buttons (parent_window, message,
1126                                                            button_accept, GTK_RESPONSE_ACCEPT,
1127                                                            button_cancel, GTK_RESPONSE_CANCEL,
1128                                                            NULL);
1129
1130         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1131                                      GTK_WINDOW (dialog), parent_window);
1132
1133         response = gtk_dialog_run (GTK_DIALOG (dialog));
1134
1135         on_destroy_dialog (dialog);
1136
1137         return response;
1138 }
1139
1140 void
1141 modest_platform_run_information_dialog (GtkWindow *parent_window,
1142                                         const gchar *message,
1143                                         gboolean block)
1144 {
1145         GtkWidget *note;
1146
1147         note = hildon_note_new_information (parent_window, message);
1148         if (block)
1149                 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1150                                              GTK_WINDOW (note), parent_window);
1151
1152         if (block) {
1153                 gtk_dialog_run (GTK_DIALOG (note));
1154
1155                 on_destroy_dialog (note);
1156         } else {
1157                 g_signal_connect_swapped (note,
1158                                           "response",
1159                                           G_CALLBACK (on_destroy_dialog),
1160                                           note);
1161
1162                 gtk_widget_show_all (note);
1163         }
1164 }
1165
1166 typedef struct _ConnectAndWaitData {
1167         GMutex *mutex;
1168         GMainLoop *wait_loop;
1169         gboolean has_callback;
1170         gulong handler;
1171 } ConnectAndWaitData;
1172
1173
1174 static void
1175 quit_wait_loop (TnyAccount *account,
1176                 ConnectAndWaitData *data)
1177 {
1178         /* Set the has_callback to TRUE (means that the callback was
1179            executed and wake up every code waiting for cond to be
1180            TRUE */
1181         g_mutex_lock (data->mutex);
1182         data->has_callback = TRUE;
1183         if (data->wait_loop)
1184                 g_main_loop_quit (data->wait_loop);
1185         g_mutex_unlock (data->mutex);
1186 }
1187
1188 static void
1189 on_connection_status_changed (TnyAccount *account,
1190                               TnyConnectionStatus status,
1191                               gpointer user_data)
1192 {
1193         TnyConnectionStatus conn_status;
1194         ConnectAndWaitData *data;
1195
1196         /* Ignore if reconnecting or disconnected */
1197         conn_status = tny_account_get_connection_status (account);
1198         if (conn_status == TNY_CONNECTION_STATUS_RECONNECTING ||
1199             conn_status == TNY_CONNECTION_STATUS_DISCONNECTED)
1200                 return;
1201
1202         /* Remove the handler */
1203         data = (ConnectAndWaitData *) user_data;
1204         g_signal_handler_disconnect (account, data->handler);
1205
1206         /* Quit from wait loop */
1207         quit_wait_loop (account, (ConnectAndWaitData *) user_data);
1208 }
1209
1210 static void
1211 on_tny_camel_account_set_online_cb (TnyCamelAccount *account,
1212                                     gboolean canceled,
1213                                     GError *err,
1214                                     gpointer user_data)
1215 {
1216         /* Quit from wait loop */
1217         quit_wait_loop (TNY_ACCOUNT (account), (ConnectAndWaitData *) user_data);
1218 }
1219
1220 gboolean
1221 modest_platform_connect_and_wait (GtkWindow *parent_window,
1222                                   TnyAccount *account)
1223 {
1224         ConnectAndWaitData *data = NULL;
1225         gboolean device_online;
1226         TnyDevice *device;
1227         TnyConnectionStatus conn_status;
1228         gboolean user_requested;
1229
1230         device = modest_runtime_get_device();
1231         device_online = tny_device_is_online (device);
1232
1233         /* Whether the connection is user requested or automatically
1234            requested, for example via D-Bus */
1235         user_requested = (parent_window) ? TRUE : FALSE;
1236
1237         /* If there is no account check only the device status */
1238         if (!account) {
1239                 if (device_online)
1240                         return TRUE;
1241                 else
1242                         return tny_maemo_conic_device_connect (TNY_MAEMO_CONIC_DEVICE (device),
1243                                                                NULL, user_requested);
1244         }
1245
1246         /* Return if the account is already connected */
1247         conn_status = tny_account_get_connection_status (account);
1248         if (device_online && conn_status == TNY_CONNECTION_STATUS_CONNECTED)
1249                 return TRUE;
1250
1251         /* Create the helper */
1252         data = g_slice_new0 (ConnectAndWaitData);
1253         data->mutex = g_mutex_new ();
1254         data->has_callback = FALSE;
1255
1256         /* Connect the device */
1257         if (!device_online) {
1258                 /* Track account connection status changes */
1259                 data->handler = g_signal_connect (account, "connection-status-changed",
1260                                                   G_CALLBACK (on_connection_status_changed),
1261                                                   data);
1262                 /* Try to connect the device */
1263                 device_online = tny_maemo_conic_device_connect (TNY_MAEMO_CONIC_DEVICE (device),
1264                                                                 NULL, user_requested);
1265
1266                 /* If the device connection failed then exit */
1267                 if (!device_online && data->handler)
1268                         goto frees;
1269         } else {
1270                 /* Force a reconnection of the account */
1271                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (account), TRUE,
1272                                               on_tny_camel_account_set_online_cb, data);
1273         }
1274
1275         /* Wait until the callback is executed */
1276         g_mutex_lock (data->mutex);
1277         if (!data->has_callback) {
1278                 data->wait_loop = g_main_loop_new (g_main_context_new (), FALSE);
1279                 gdk_threads_leave ();
1280                 g_mutex_unlock (data->mutex);
1281                 g_main_loop_run (data->wait_loop);
1282                 g_mutex_lock (data->mutex);
1283                 gdk_threads_enter ();
1284         }
1285         g_mutex_unlock (data->mutex);
1286
1287  frees:
1288         if (data) {
1289                 if (g_signal_handler_is_connected (account, data->handler))
1290                         g_signal_handler_disconnect (account, data->handler);
1291                 g_mutex_free (data->mutex);
1292                 g_main_loop_unref (data->wait_loop);
1293                 g_slice_free (ConnectAndWaitData, data);
1294         }
1295
1296         conn_status = tny_account_get_connection_status (account);
1297         return (conn_status == TNY_CONNECTION_STATUS_CONNECTED) ? TRUE: FALSE;
1298 }
1299
1300 gboolean
1301 modest_platform_connect_and_wait_if_network_account (GtkWindow *parent_window, TnyAccount *account)
1302 {
1303         if (tny_account_get_account_type (account) == TNY_ACCOUNT_TYPE_STORE) {
1304                 if (!modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account))) {
1305                         /* This must be a maildir account, which does not require a connection: */
1306                         return TRUE;
1307                 }
1308         }
1309
1310         return modest_platform_connect_and_wait (parent_window, account);
1311 }
1312
1313 gboolean
1314 modest_platform_connect_and_wait_if_network_folderstore (GtkWindow *parent_window, TnyFolderStore *folder_store)
1315 {
1316         if (!folder_store)
1317                 return TRUE; /* Maybe it is something local. */
1318
1319         gboolean result = TRUE;
1320         if (TNY_IS_FOLDER (folder_store)) {
1321                 /* Get the folder's parent account: */
1322                 TnyAccount *account = tny_folder_get_account(TNY_FOLDER (folder_store));
1323                 if (account != NULL) {
1324                         result = modest_platform_connect_and_wait_if_network_account (NULL, account);
1325                         g_object_unref (account);
1326                 }
1327         } else if (TNY_IS_ACCOUNT (folder_store)) {
1328                 /* Use the folder store as an account: */
1329                 result = modest_platform_connect_and_wait_if_network_account (NULL, TNY_ACCOUNT (folder_store));
1330         }
1331
1332         return result;
1333 }
1334
1335 GtkWidget *
1336 modest_platform_create_sort_dialog       (GtkWindow *parent_window)
1337 {
1338         GtkWidget *dialog;
1339
1340         dialog = modest_hildon2_sort_dialog_new (parent_window);
1341
1342         return dialog;
1343 }
1344
1345
1346 gboolean
1347 modest_platform_set_update_interval (guint minutes)
1348 {
1349 #ifdef MODEST_HAVE_LIBALARM
1350
1351         ModestConf *conf = modest_runtime_get_conf ();
1352         if (!conf)
1353                 return FALSE;
1354
1355         cookie_t alarm_cookie = modest_conf_get_int (conf, MODEST_CONF_ALARM_ID, NULL);
1356
1357         /* Delete any existing alarm,
1358          * because we will replace it: */
1359         if (alarm_cookie) {
1360                 if (alarmd_event_del(alarm_cookie) != 0)
1361                         g_warning ("%s: alarm %d was not on the queue", __FUNCTION__, (int)alarm_cookie);
1362                 alarm_cookie = 0;
1363                 modest_conf_set_int (conf, MODEST_CONF_ALARM_ID, 0, NULL);
1364         }
1365
1366         /* 0 means no updates: */
1367         if (minutes == 0)
1368                 return TRUE;
1369
1370
1371         /* Register alarm: */
1372
1373         /* Set the interval in alarm_event_t structure: */
1374         alarm_event_t *event = alarm_event_create ();
1375         alarm_event_add_actions (event, 1);
1376         alarm_action_t *action = alarm_event_get_action (event, 0);
1377         alarm_event_set_alarm_appid (event, MODEST_ALARMD_APPID);
1378         event->alarm_time = minutes * 60; /* seconds */
1379
1380         /* Set recurrence every few minutes: */
1381         event->recur_secs = minutes*60;
1382         event->recur_count = -1; /* Means infinite */
1383
1384         /* Specify what should happen when the alarm happens:
1385          * It should call this D-Bus method: */
1386
1387         action->dbus_path = g_strdup(MODEST_DBUS_OBJECT);
1388         action->dbus_interface = g_strdup (MODEST_DBUS_IFACE);
1389         action->dbus_service = g_strdup (MODEST_DBUS_SERVICE);
1390         action->dbus_name = g_strdup (MODEST_DBUS_METHOD_SEND_RECEIVE);
1391         action->flags = ALARM_ACTION_WHEN_TRIGGERED | ALARM_ACTION_TYPE_DBUS | ALARM_ACTION_DBUS_USE_ACTIVATION;
1392
1393         /* Use ALARM_EVENT_NO_DIALOG: Otherwise, a dialog will be shown if
1394          * exec_name or dbus_path is NULL, even though we have specified no dialog text.
1395          * Also use ALARM_EVENT_ACTIVATION so that modest is started (without UI) to get emails
1396          * This is why we want to use the Alarm API instead of just g_timeout_add().
1397          * (The old maemo email-client did this, though it isn't specified in the UI spec.)
1398          * ALARM_EVENT_CONNECTED will prevent the alarm from being called in case that the device is offline
1399          */
1400         event->flags = ALARM_EVENT_CONNECTED;
1401
1402         alarm_cookie = alarmd_event_add (event);
1403
1404         /* now, free it */
1405         alarm_event_delete (event);
1406
1407         /* Store the alarm ID in GConf, so we can remove it later:
1408          * This is apparently valid between application instances. */
1409         modest_conf_set_int (conf, MODEST_CONF_ALARM_ID, alarm_cookie, NULL);
1410
1411         if (!alarm_cookie) {
1412             /* Error */
1413             g_debug ("Error setting alarm event. \n");
1414
1415             return FALSE;
1416         }
1417 #endif /* MODEST_HAVE_LIBALARM */
1418         return TRUE;
1419 }
1420
1421 void
1422 modest_platform_push_email_notification(void)
1423 {
1424         gboolean screen_on, app_in_foreground;
1425
1426         /* Get the window status */
1427         app_in_foreground = hildon_program_get_is_topmost (hildon_program_get_instance ());
1428
1429         screen_on = modest_window_mgr_screen_is_on (modest_runtime_get_window_mgr ());
1430
1431         /* If the screen is on and the app is in the
1432            foreground we don't show anything */
1433         if (!(screen_on && app_in_foreground)) {
1434
1435                 _modest_platform_play_email_tone ();
1436
1437                 /* Activate LED. This must be deactivated by
1438                    modest_platform_remove_new_mail_notifications */
1439 #ifdef MODEST_HAVE_MCE
1440                 osso_rpc_run_system (modest_maemo_utils_get_osso_context (),
1441                                      MCE_SERVICE,
1442                                      MCE_REQUEST_PATH,
1443                                      MCE_REQUEST_IF,
1444                                      MCE_ACTIVATE_LED_PATTERN,
1445                                      NULL,
1446                                      DBUS_TYPE_STRING, MODEST_NEW_MAIL_LIGHTING_PATTERN,
1447                                      DBUS_TYPE_INVALID);
1448 #endif
1449         }
1450 }
1451
1452 void
1453 modest_platform_on_new_headers_received (TnyList *header_list,
1454                                          gboolean show_visual)
1455 {
1456         g_return_if_fail (TNY_IS_LIST(header_list));
1457
1458         if (tny_list_get_length(header_list) == 0) {
1459                 g_warning ("%s: header list is empty", __FUNCTION__);
1460                 return;
1461         }
1462
1463         if (!show_visual) {
1464                 modest_platform_push_email_notification ();
1465                 /* We do a return here to avoid indentation with an else */
1466                 return;
1467         }
1468
1469 #ifdef MODEST_HAVE_HILDON_NOTIFY
1470         HildonNotification *notification;
1471         TnyIterator *iter;
1472         GSList *notifications_list = NULL;
1473
1474         /* Get previous notifications ids */
1475         notifications_list = modest_conf_get_list (modest_runtime_get_conf (),
1476                                                    MODEST_CONF_NOTIFICATION_IDS,
1477                                                    MODEST_CONF_VALUE_INT, NULL);
1478
1479         iter = tny_list_create_iterator (header_list);
1480         while (!tny_iterator_is_done (iter)) {
1481                 gchar *url = NULL, *display_address = NULL;
1482                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1483                 TnyFolder *folder = tny_header_get_folder (header);
1484                 gboolean first_notification = TRUE;
1485                 gint notif_id;
1486                 gchar *str;
1487
1488                 display_address = tny_header_dup_from (header);
1489                 /* string is changed in-place */
1490                 modest_text_utils_get_display_address (display_address);
1491
1492                 str = tny_header_dup_subject (header);
1493                 notification = hildon_notification_new (display_address,
1494                                                         str,
1495                                                         "qgn_list_messagin",
1496                                                         MODEST_NOTIFICATION_CATEGORY);
1497                 g_free (str);
1498                 /* Create the message URL */
1499                 str = tny_header_dup_uid (header);
1500                 url = g_strdup_printf ("%s/%s", tny_folder_get_url_string (folder),
1501                                        str);
1502                 g_free (str);
1503
1504                 hildon_notification_add_dbus_action(notification,
1505                                                     "default",
1506                                                     "Cancel",
1507                                                     MODEST_DBUS_SERVICE,
1508                                                     MODEST_DBUS_OBJECT,
1509                                                     MODEST_DBUS_IFACE,
1510                                                     MODEST_DBUS_METHOD_OPEN_MESSAGE,
1511                                                     G_TYPE_STRING, url,
1512                                                     -1);
1513
1514                 /* Play sound if the user wants. Show the LED
1515                    pattern. Show and play just one */
1516                 if (G_UNLIKELY (first_notification)) {
1517
1518                         first_notification = FALSE;
1519
1520                         /* Set the led pattern */
1521                         notify_notification_set_hint_int32 (NOTIFY_NOTIFICATION (notification),
1522                                                             "dialog-type", 4);
1523                         notify_notification_set_hint_string(NOTIFY_NOTIFICATION (notification),
1524                                                             "led-pattern",
1525                                                             MODEST_NEW_MAIL_LIGHTING_PATTERN);
1526                 }
1527
1528                 /* Notify. We need to do this in an idle because this function
1529                    could be called from a thread */
1530                 notify_notification_show (NOTIFY_NOTIFICATION (notification), NULL);
1531
1532                 /* Save id in the list */
1533                 g_object_get(G_OBJECT(notification), "id", &notif_id, NULL);
1534                 notifications_list = g_slist_prepend (notifications_list, GINT_TO_POINTER(notif_id));
1535                 /* We don't listen for the "closed" signal, because we
1536                    don't care about if the notification was removed or
1537                    not to store the list in gconf */
1538
1539                 /* Free & carry on */
1540                 g_free (display_address);
1541                 g_free (url);
1542                 g_object_unref (folder);
1543                 g_object_unref (header);
1544                 tny_iterator_next (iter);
1545         }
1546         g_object_unref (iter);
1547
1548         /* Save the ids */
1549         modest_conf_set_list (modest_runtime_get_conf (), MODEST_CONF_NOTIFICATION_IDS,
1550                               notifications_list, MODEST_CONF_VALUE_INT, NULL);
1551
1552         g_slist_free (notifications_list);
1553
1554 #endif /*MODEST_HAVE_HILDON_NOTIFY*/
1555 }
1556
1557 void
1558 modest_platform_remove_new_mail_notifications (gboolean only_visuals)
1559 {
1560         if (only_visuals) {
1561 #ifdef MODEST_HAVE_MCE
1562                 osso_rpc_run_system (modest_maemo_utils_get_osso_context (),
1563                                      MCE_SERVICE,
1564                                      MCE_REQUEST_PATH,
1565                                      MCE_REQUEST_IF,
1566                                      MCE_DEACTIVATE_LED_PATTERN,
1567                                      NULL,
1568                                      DBUS_TYPE_STRING, MODEST_NEW_MAIL_LIGHTING_PATTERN,
1569                                      DBUS_TYPE_INVALID);
1570 #endif
1571                 return;
1572         }
1573
1574 #ifdef MODEST_HAVE_HILDON_NOTIFY
1575         GSList *notif_list = NULL;
1576
1577         /* Get previous notifications ids */
1578         notif_list = modest_conf_get_list (modest_runtime_get_conf (),
1579                                            MODEST_CONF_NOTIFICATION_IDS,
1580                                            MODEST_CONF_VALUE_INT, NULL);
1581
1582         while (notif_list) {
1583                 gint notif_id;
1584                 NotifyNotification *notif;
1585
1586                 /* Nasty HACK to remove the notifications, set the id
1587                    of the existing ones and then close them */
1588                 notif_id = GPOINTER_TO_INT(notif_list->data);
1589                 notif = notify_notification_new("dummy", NULL, NULL, NULL);
1590                 g_object_set(G_OBJECT(notif), "id", notif_id, NULL);
1591
1592                 /* Close the notification, note that some ids could be
1593                    already invalid, but we don't care because it does
1594                    not fail */
1595                 notify_notification_close(notif, NULL);
1596                 g_object_unref(notif);
1597
1598                 /* Delete the link, it's like going to the next */
1599                 notif_list = g_slist_delete_link (notif_list, notif_list);
1600         }
1601
1602         /* Save the ids */
1603         modest_conf_set_list (modest_runtime_get_conf (), MODEST_CONF_NOTIFICATION_IDS,
1604                               notif_list, MODEST_CONF_VALUE_INT, NULL);
1605
1606         g_slist_free (notif_list);
1607
1608 #endif /* MODEST_HAVE_HILDON_NOTIFY */
1609 }
1610
1611
1612
1613 GtkWidget *
1614 modest_platform_get_global_settings_dialog ()
1615 {
1616         return modest_hildon2_global_settings_dialog_new ();
1617 }
1618
1619 void
1620 modest_platform_show_help (GtkWindow *parent_window,
1621                            const gchar *help_id)
1622 {
1623         return;
1624 }
1625
1626 void
1627 modest_platform_show_search_messages (GtkWindow *parent_window)
1628 {
1629         osso_return_t result = OSSO_ERROR;
1630
1631         result = osso_rpc_run_with_defaults (modest_maemo_utils_get_osso_context(),
1632                                              "osso_global_search",
1633                                              "search_email", NULL, DBUS_TYPE_INVALID);
1634
1635         if (result != OSSO_OK) {
1636                 g_warning ("%s: osso_rpc_run_with_defaults() failed.\n", __FUNCTION__);
1637         }
1638 }
1639
1640 void
1641 modest_platform_show_addressbook (GtkWindow *parent_window)
1642 {
1643         osso_return_t result = OSSO_ERROR;
1644
1645         result = osso_rpc_run_with_defaults (modest_maemo_utils_get_osso_context(),
1646                                              "osso_addressbook",
1647                                              "top_application", NULL, DBUS_TYPE_INVALID);
1648
1649         if (result != OSSO_OK) {
1650                 g_warning ("%s: osso_rpc_run_with_defaults() failed.\n", __FUNCTION__);
1651         }
1652 }
1653
1654 GtkWidget *
1655 modest_platform_create_folder_view (TnyFolderStoreQuery *query)
1656 {
1657         GtkWidget *widget = modest_folder_view_new (query);
1658
1659         /* Show one account by default */
1660         modest_folder_view_set_style (MODEST_FOLDER_VIEW (widget),
1661                                       MODEST_FOLDER_VIEW_STYLE_SHOW_ONE);
1662
1663         /* Restore settings */
1664         modest_widget_memory_restore (modest_runtime_get_conf(),
1665                                       G_OBJECT (widget),
1666                                       MODEST_CONF_FOLDER_VIEW_KEY);
1667
1668         return widget;
1669 }
1670
1671 void
1672 banner_finish (gpointer data, GObject *object)
1673 {
1674         ModestWindowMgr *mgr = (ModestWindowMgr *) data;
1675         modest_window_mgr_unregister_banner (mgr);
1676         g_object_unref (mgr);
1677 }
1678
1679 void
1680 modest_platform_information_banner (GtkWidget *parent,
1681                                     const gchar *icon_name,
1682                                     const gchar *text)
1683 {
1684         GtkWidget *banner, *banner_parent = NULL;
1685         ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
1686
1687         if (modest_window_mgr_get_num_windows (mgr) == 0)
1688                 return;
1689
1690         if (parent && GTK_IS_WINDOW (parent)) {
1691                 /* If the window is the active one then show the
1692                    banner on top of this window */
1693                 if (gtk_window_is_active (GTK_WINDOW (parent)))
1694                         banner_parent = parent;
1695                 /* If the window is not the topmost but it's visible
1696                    (it's minimized for example) then show the banner
1697                    with no parent */
1698                 else if (GTK_WIDGET_VISIBLE (parent))
1699                         banner_parent = NULL;
1700                 /* If the window is hidden (like the main window when
1701                    running in the background) then do not show
1702                    anything */
1703                 else
1704                         return;
1705         }
1706
1707
1708         banner = hildon_banner_show_information (banner_parent, icon_name, text);
1709
1710         modest_window_mgr_register_banner (mgr);
1711         g_object_ref (mgr);
1712         g_object_weak_ref ((GObject *) banner, banner_finish, mgr);
1713 }
1714
1715 void
1716 modest_platform_information_banner_with_timeout (GtkWidget *parent,
1717                                                  const gchar *icon_name,
1718                                                  const gchar *text,
1719                                                  gint timeout)
1720 {
1721         GtkWidget *banner;
1722
1723         if (modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()) == 0)
1724                 return;
1725
1726         banner = hildon_banner_show_information (parent, icon_name, text);
1727         hildon_banner_set_timeout(HILDON_BANNER(banner), timeout);
1728 }
1729
1730 GtkWidget *
1731 modest_platform_animation_banner (GtkWidget *parent,
1732                                   const gchar *animation_name,
1733                                   const gchar *text)
1734 {
1735         GtkWidget *inf_note = NULL;
1736
1737         g_return_val_if_fail (text != NULL, NULL);
1738
1739         if (modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()) == 0)
1740                 return NULL;
1741
1742         /* If the parent is not visible then do not show */
1743         if (parent && !GTK_WIDGET_VISIBLE (parent))
1744                 return NULL;
1745
1746         inf_note = hildon_banner_show_animation (parent, animation_name, text);
1747
1748         return inf_note;
1749 }
1750
1751 typedef struct
1752 {
1753         GMainLoop* loop;
1754         TnyAccount *account;
1755         gboolean is_online;
1756         gint count_tries;
1757 } CheckAccountIdleData;
1758
1759 #define NUMBER_OF_TRIES 10 /* Try approx every second, ten times. */
1760
1761 static gboolean
1762 on_timeout_check_account_is_online(CheckAccountIdleData* data)
1763 {
1764         gboolean stop_trying = FALSE;
1765         g_return_val_if_fail (data && data->account, FALSE);
1766
1767         printf ("DEBUG: %s: tny_account_get_connection_status()==%d\n", __FUNCTION__,
1768                 tny_account_get_connection_status (data->account));
1769
1770         if (data && data->account &&
1771                 /* We want to wait until TNY_CONNECTION_STATUS_INIT has changed to something else,
1772                  * after which the account is likely to be usable, or never likely to be usable soon: */
1773                 (tny_account_get_connection_status (data->account) != TNY_CONNECTION_STATUS_INIT) )
1774         {
1775                 data->is_online = TRUE;
1776
1777                 stop_trying = TRUE;
1778         } else {
1779                 /* Give up if we have tried too many times: */
1780                 if (data->count_tries >= NUMBER_OF_TRIES) {
1781                         stop_trying = TRUE;
1782                 } else {
1783                         /* Wait for another timeout: */
1784                         ++(data->count_tries);
1785                 }
1786         }
1787
1788         if (stop_trying) {
1789                 /* Allow the function that requested this idle callback to continue: */
1790                 if (data->loop)
1791                         g_main_loop_quit (data->loop);
1792
1793                 if (data->account)
1794                         g_object_unref (data->account);
1795
1796                 return FALSE; /* Don't call this again. */
1797         } else {
1798                 return TRUE; /* Call this timeout callback again. */
1799         }
1800 }
1801
1802 /* Return TRUE immediately if the account is already online,
1803  * otherwise check every second for NUMBER_OF_TRIES seconds and return TRUE as
1804  * soon as the account is online, or FALSE if the account does
1805  * not become online in the NUMBER_OF_TRIES seconds.
1806  * This is useful when the D-Bus method was run immediately after
1807  * the application was started (when using D-Bus activation),
1808  * because the account usually takes a short time to go online.
1809  * The return value is maybe not very useful.
1810  */
1811 gboolean
1812 modest_platform_check_and_wait_for_account_is_online(TnyAccount *account)
1813 {
1814         gboolean is_online;
1815
1816         g_return_val_if_fail (account, FALSE);
1817
1818         if (!tny_device_is_online (modest_runtime_get_device())) {
1819                 printf ("DEBUG: %s: device is offline.\n", __FUNCTION__);
1820                 return FALSE;
1821         }
1822
1823         /* The local_folders account never seems to leave TNY_CONNECTION_STATUS_INIT,
1824          * so we avoid wait unnecessarily: */
1825         if (!modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account)))
1826                 return TRUE;
1827
1828         /* The POP & IMAP store accounts seem to be TNY_CONNECTION_STATUS_DISCONNECTED,
1829          * and that seems to be an OK time to use them. Maybe it's just TNY_CONNECTION_STATUS_INIT that
1830          * we want to avoid. */
1831         if (tny_account_get_connection_status (account) != TNY_CONNECTION_STATUS_INIT)
1832                 return TRUE;
1833
1834         /* This blocks on the result: */
1835         CheckAccountIdleData *data = g_slice_new0 (CheckAccountIdleData);
1836         data->is_online = FALSE;
1837         data->account = account;
1838         g_object_ref (data->account);
1839         data->count_tries = 0;
1840
1841         GMainContext *context = NULL; /* g_main_context_new (); */
1842         data->loop = g_main_loop_new (context, FALSE /* not running */);
1843
1844         g_timeout_add (1000, (GSourceFunc)(on_timeout_check_account_is_online), data);
1845
1846         /* This main loop will run until the idle handler has stopped it: */
1847         g_main_loop_run (data->loop);
1848
1849         g_main_loop_unref (data->loop);
1850         /* g_main_context_unref (context); */
1851
1852         is_online = data->is_online;
1853         g_slice_free (CheckAccountIdleData, data);
1854
1855         return is_online;
1856 }
1857
1858
1859
1860 static void
1861 on_cert_dialog_response (GtkDialog *dialog, gint response_id,  const gchar* cert)
1862 {
1863         /* GTK_RESPONSE_HELP means we need to show the certificate */
1864         if (response_id == GTK_RESPONSE_APPLY) {
1865                 GtkWidget *note;
1866                 gchar *msg;
1867
1868                 /* Do not close the dialog */
1869                 g_signal_stop_emission_by_name (dialog, "response");
1870
1871                 msg = g_strdup_printf (_("mcen_ni_view_unknown_certificate"), cert);
1872                 note = hildon_note_new_information (GTK_WINDOW(dialog), msg);
1873                 gtk_dialog_run (GTK_DIALOG(note));
1874                 gtk_widget_destroy (note);
1875         }
1876 }
1877
1878
1879 gboolean
1880 modest_platform_run_certificate_confirmation_dialog (const gchar* server_name,
1881                                                      const gchar *certificate)
1882 {
1883         GtkWidget *note;
1884         gint response;
1885         ModestWindow *win;
1886         HildonWindowStack *stack;
1887
1888         stack = hildon_window_stack_get_default ();
1889         win = MODEST_WINDOW (hildon_window_stack_peek (stack));
1890
1891         if (!win) {
1892           g_warning ("%s: don't show dialogs if there's no window shown; assuming 'Cancel'",
1893                            __FUNCTION__);
1894                 return FALSE;
1895         }
1896
1897         gchar *question = g_strdup_printf (_("mcen_nc_unknown_certificate"),
1898                                            server_name);
1899
1900         /* We use GTK_RESPONSE_APPLY because we want the button in the
1901            middle of OK and CANCEL the same as the browser does for
1902            example. With GTK_RESPONSE_HELP the view button is aligned
1903            to the left while the other two to the right */
1904         note = hildon_note_new_confirmation_add_buttons  (
1905                 NULL,
1906                 question,
1907                 _HL("wdgt_bd_yes"),     GTK_RESPONSE_OK,
1908                 _HL("wdgt_bd_view"),          GTK_RESPONSE_APPLY,   /* abusing this... */
1909                 _HL("wdgt_bd_no"), GTK_RESPONSE_CANCEL,
1910                 NULL, NULL);
1911
1912         g_signal_connect (G_OBJECT(note), "response",
1913                           G_CALLBACK(on_cert_dialog_response),
1914                           (gpointer) certificate);
1915
1916         response = gtk_dialog_run(GTK_DIALOG(note));
1917
1918         on_destroy_dialog (note);
1919         g_free (question);
1920
1921         return response == GTK_RESPONSE_OK;
1922 }
1923
1924 gboolean
1925 modest_platform_run_alert_dialog (const gchar* prompt,
1926                                   gboolean is_question)
1927 {
1928         ModestWindow *top_win;
1929         HildonWindowStack *stack;
1930
1931         stack = hildon_window_stack_get_default ();
1932         top_win = MODEST_WINDOW (hildon_window_stack_peek (stack));
1933
1934         if (!top_win) {
1935                 g_warning ("%s: don't show dialogs if there's no window shown; assuming 'Cancel'",
1936                            __FUNCTION__);
1937                 return FALSE;
1938         }
1939
1940         gboolean retval = TRUE;
1941         if (is_question) {
1942                 /* The Tinymail documentation says that we should show Yes and No buttons,
1943                  * when it is a question.
1944                  * Obviously, we need tinymail to use more specific error codes instead,
1945                  * so we know what buttons to show. */
1946                 GtkWidget *dialog = GTK_WIDGET (hildon_note_new_confirmation (GTK_WINDOW (top_win),
1947                                                                               prompt));
1948                 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1949                                              GTK_WINDOW (dialog), GTK_WINDOW (top_win));
1950
1951                 const int response = gtk_dialog_run (GTK_DIALOG (dialog));
1952                 retval = (response == GTK_RESPONSE_YES) || (response == GTK_RESPONSE_OK);
1953
1954                 on_destroy_dialog (dialog);
1955         } else {
1956                 /* Just show the error text and use the default response: */
1957                 modest_platform_run_information_dialog (GTK_WINDOW (top_win),
1958                                                         prompt, FALSE);
1959         }
1960         return retval;
1961 }
1962
1963 /***************/
1964 typedef struct {
1965         GtkWindow *parent_window;
1966         ModestConnectedPerformer callback;
1967         TnyAccount *account;
1968         gpointer user_data;
1969         gchar *iap;
1970         TnyDevice *device;
1971 } OnWentOnlineInfo;
1972
1973 static void
1974 on_went_online_info_free (OnWentOnlineInfo *info)
1975 {
1976         /* And if we cleanup, we DO cleanup  :-)  */
1977
1978         if (info->device)
1979                 g_object_unref (info->device);
1980         if (info->iap)
1981                 g_free (info->iap);
1982         if (info->parent_window)
1983                 g_object_unref (info->parent_window);
1984         if (info->account)
1985                 g_object_unref (info->account);
1986
1987         g_slice_free (OnWentOnlineInfo, info);
1988
1989         /* We're done ... */
1990
1991         return;
1992 }
1993
1994 static void
1995 on_account_went_online (TnyCamelAccount *account, gboolean canceled, GError *err, gpointer user_data)
1996 {
1997         OnWentOnlineInfo *info = (OnWentOnlineInfo *) user_data;
1998
1999         /* Now it's really time to callback to the caller. If going online didn't succeed,
2000          * err will be set. We don't free it, Tinymail does that! If a cancel happened,
2001          * canceled will be set. Etcetera etcetera. */
2002
2003         if (info->callback) {
2004                 info->callback (canceled, err, info->parent_window, info->account, info->user_data);
2005         }
2006
2007         /* This is our last call, we must cleanup here if we didn't yet do that */
2008         on_went_online_info_free (info);
2009
2010         return;
2011 }
2012
2013
2014 static void
2015 on_conic_device_went_online (TnyMaemoConicDevice *device, const gchar* iap_id, gboolean canceled, GError *err, gpointer user_data)
2016 {
2017         OnWentOnlineInfo *info = (OnWentOnlineInfo *) user_data;
2018         info->iap = g_strdup (iap_id);
2019
2020         if (canceled || err || !info->account) {
2021
2022                 /* If there's a problem or if there's no account (then that's it for us, we callback
2023                  * the caller's callback now. He'll have to handle err or canceled, of course.
2024                  * We are not really online, as the account is not really online here ... */
2025
2026                 /* We'll use the err and the canceled of this cb. TnyMaemoConicDevice delivered us
2027                  * this info. We don't cleanup err, Tinymail does that! */
2028
2029                 if (info->callback) {
2030
2031                         /* info->account can be NULL here, this means that the user did not
2032                          * provide a nice account instance. We'll assume that the user knows
2033                          * what he's doing and is happy with just the device going online.
2034                          *
2035                          * We can't do magic, we don't know what account the user wants to
2036                          * see going online. So just the device goes online, end of story */
2037
2038                         info->callback (canceled, err, info->parent_window, info->account, info->user_data);
2039                 }
2040
2041         } else if (info->account) {
2042
2043                 /* If there's no problem and if we have an account, we'll put the account
2044                  * online too. When done, the callback of bringing the account online
2045                  * will callback the caller's callback. This is the most normal case. */
2046
2047                 info->device = TNY_DEVICE (g_object_ref (device));
2048
2049                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (info->account), TRUE,
2050                                               on_account_went_online, info);
2051
2052                 /* The on_account_went_online cb frees up the info, go look if you
2053                  * don't believe me! (so we return here) */
2054
2055                 return;
2056         }
2057
2058         /* We cleanup if we are not bringing the account online too */
2059         on_went_online_info_free (info);
2060
2061         return;
2062 }
2063
2064 void
2065 modest_platform_connect_and_perform (GtkWindow *parent_window,
2066                                      gboolean force,
2067                                      TnyAccount *account,
2068                                      ModestConnectedPerformer callback,
2069                                      gpointer user_data)
2070 {
2071         gboolean device_online;
2072         TnyDevice *device;
2073         TnyConnectionStatus conn_status;
2074         OnWentOnlineInfo *info;
2075
2076         device = modest_runtime_get_device();
2077         device_online = tny_device_is_online (device);
2078
2079         /* If there is no account check only the device status */
2080         if (!account) {
2081
2082                 if (device_online) {
2083
2084                         /* We promise to instantly perform the callback, so ... */
2085                         if (callback) {
2086                                 callback (FALSE, NULL, parent_window, account, user_data);
2087                         }
2088
2089                 } else {
2090
2091                         info = g_slice_new0 (OnWentOnlineInfo);
2092
2093                         info->iap = NULL;
2094                         info->device = NULL;
2095                         info->account = NULL;
2096
2097                         if (parent_window)
2098                                 info->parent_window = (GtkWindow *) g_object_ref (parent_window);
2099                         else
2100                                 info->parent_window = NULL;
2101                         info->user_data = user_data;
2102                         info->callback = callback;
2103
2104                         tny_maemo_conic_device_connect_async (TNY_MAEMO_CONIC_DEVICE (device), NULL,
2105                                                               force, on_conic_device_went_online,
2106                                                               info);
2107
2108                         /* We'll cleanup in on_conic_device_went_online */
2109                 }
2110
2111                 /* The other code has no more reason to run. This is all that we can do for the
2112                  * caller (he should have given us a nice and clean account instance!). We
2113                  * can't do magic, we don't know what account he intends to bring online. So
2114                  * we'll just bring the device online (and await his false bug report). */
2115
2116                 return;
2117         }
2118
2119
2120         /* Return if the account is already connected */
2121
2122         conn_status = tny_account_get_connection_status (account);
2123         if (device_online && conn_status == TNY_CONNECTION_STATUS_CONNECTED) {
2124
2125                 /* We promise to instantly perform the callback, so ... */
2126                 if (callback) {
2127                         callback (FALSE, NULL, parent_window, account, user_data);
2128                 }
2129
2130                 return;
2131         }
2132
2133         /* Else, we are in a state that requires that we go online before we
2134          * call the caller's callback. */
2135
2136         info = g_slice_new0 (OnWentOnlineInfo);
2137
2138         info->device = NULL;
2139         info->iap = NULL;
2140         info->account = TNY_ACCOUNT (g_object_ref (account));
2141
2142         if (parent_window)
2143                 info->parent_window = (GtkWindow *) g_object_ref (parent_window);
2144         else
2145                 info->parent_window = NULL;
2146
2147         /* So we'll put the callback away for later ... */
2148
2149         info->user_data = user_data;
2150         info->callback = callback;
2151
2152         if (!device_online) {
2153
2154                 /* If also the device is offline, then we connect both the device
2155                  * and the account */
2156
2157                 tny_maemo_conic_device_connect_async (TNY_MAEMO_CONIC_DEVICE (device), NULL,
2158                                                       force, on_conic_device_went_online,
2159                                                       info);
2160
2161         } else {
2162
2163                 /* If the device is online, we'll just connect the account */
2164
2165                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (account), TRUE,
2166                                               on_account_went_online, info);
2167         }
2168
2169         /* The info gets freed by on_account_went_online or on_conic_device_went_online
2170          * in both situations, go look if you don't believe me! */
2171
2172         return;
2173 }
2174
2175 void
2176 modest_platform_connect_if_remote_and_perform (GtkWindow *parent_window,
2177                                                gboolean force,
2178                                                TnyFolderStore *folder_store,
2179                                                ModestConnectedPerformer callback,
2180                                                gpointer user_data)
2181 {
2182         TnyAccount *account = NULL;
2183
2184         if (!folder_store ||
2185             (TNY_IS_MERGE_FOLDER (folder_store) &&
2186              (tny_folder_get_folder_type (TNY_FOLDER(folder_store)) == TNY_FOLDER_TYPE_OUTBOX))) {
2187
2188                 /* We promise to instantly perform the callback, so ... */
2189                 if (callback) {
2190                         GError *error = NULL;
2191                         g_set_error (&error, TNY_ERROR_DOMAIN, TNY_SERVICE_ERROR_UNKNOWN,
2192                                      "Unable to move or not found folder");
2193                         callback (FALSE, error, parent_window, NULL, user_data);
2194                         g_error_free (error);
2195                 }
2196                 return;
2197
2198         } else if (TNY_IS_FOLDER (folder_store)) {
2199                 /* Get the folder's parent account: */
2200                 account = tny_folder_get_account (TNY_FOLDER (folder_store));
2201         } else if (TNY_IS_ACCOUNT (folder_store)) {
2202                 /* Use the folder store as an account: */
2203                 account = TNY_ACCOUNT (g_object_ref (folder_store));
2204         }
2205
2206         if (tny_account_get_account_type (account) == TNY_ACCOUNT_TYPE_STORE) {
2207                 if (!modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account))) {
2208                         /* No need to connect a local account */
2209                         if (callback)
2210                                 callback (FALSE, NULL, parent_window, account, user_data);
2211
2212                         goto clean;
2213                 }
2214         }
2215         modest_platform_connect_and_perform (parent_window, force, account, callback, user_data);
2216
2217  clean:
2218         if (account)
2219                 g_object_unref (account);
2220 }
2221
2222 static void
2223 src_account_connect_performer (gboolean canceled,
2224                                GError *err,
2225                                GtkWindow *parent_window,
2226                                TnyAccount *src_account,
2227                                gpointer user_data)
2228 {
2229         DoubleConnectionInfo *info = (DoubleConnectionInfo *) user_data;
2230
2231         if (canceled || err) {
2232                 /* If there was any error call the user callback */
2233                 info->callback (canceled, err, parent_window, src_account, info->data);
2234         } else {
2235                 /* Connect the destination account */
2236                 modest_platform_connect_if_remote_and_perform (parent_window, TRUE,
2237                                                                TNY_FOLDER_STORE (info->dst_account),
2238                                                                info->callback, info->data);
2239         }
2240
2241         /* Free the info object */
2242         g_object_unref (info->dst_account);
2243         g_slice_free (DoubleConnectionInfo, info);
2244 }
2245
2246
2247 void
2248 modest_platform_double_connect_and_perform (GtkWindow *parent_window,
2249                                             gboolean force,
2250                                             TnyFolderStore *folder_store,
2251                                             DoubleConnectionInfo *connect_info)
2252 {
2253         modest_platform_connect_if_remote_and_perform(parent_window,
2254                                                       force,
2255                                                       folder_store,
2256                                                       src_account_connect_performer,
2257                                                       connect_info);
2258 }
2259
2260 GtkWidget *
2261 modest_platform_get_account_settings_wizard (void)
2262 {
2263         ModestEasysetupWizardDialog *dialog = modest_easysetup_wizard_dialog_new ();
2264
2265         return GTK_WIDGET (dialog);
2266 }
2267
2268 ModestConnectedVia
2269 modest_platform_get_current_connection (void)
2270 {
2271         TnyDevice *device = NULL;
2272         ModestConnectedVia retval = MODEST_CONNECTED_VIA_ANY;
2273
2274         device = modest_runtime_get_device ();
2275
2276         if (!tny_device_is_online (device))
2277                 return MODEST_CONNECTED_VIA_ANY;
2278
2279 #ifdef MODEST_HAVE_CONIC
2280         /* Get iap id */
2281         const gchar *iap_id = tny_maemo_conic_device_get_current_iap_id (TNY_MAEMO_CONIC_DEVICE (device));
2282         if (iap_id) {
2283                 ConIcIap *iap = tny_maemo_conic_device_get_iap (
2284                         TNY_MAEMO_CONIC_DEVICE (device), iap_id);
2285                 const gchar *bearer_type = con_ic_iap_get_bearer_type (iap);
2286                 if (bearer_type) {
2287                         if (!strcmp (bearer_type, CON_IC_BEARER_WLAN_INFRA) ||
2288                             !strcmp (bearer_type, CON_IC_BEARER_WLAN_ADHOC) ||
2289                             !strcmp (bearer_type, "WIMAX")) {
2290                                 retval = MODEST_CONNECTED_VIA_WLAN_OR_WIMAX;
2291                         } else {
2292                                 retval = MODEST_CONNECTED_VIA_ANY;
2293                         }
2294                 }
2295                 g_object_unref (iap);
2296         }
2297 #else
2298         retval = MODEST_CONNECTED_VIA_WLAN_OR_WIMAX; /* assume WLAN (fast) internet */
2299 #endif /* MODEST_HAVE_CONIC */
2300         return retval;
2301 }
2302
2303
2304
2305 gboolean
2306 modest_platform_check_memory_low (ModestWindow *win,
2307                                   gboolean visuals)
2308 {
2309         gboolean lowmem;
2310
2311         /* are we in low memory state? */
2312         lowmem = osso_mem_in_lowmem_state () ? TRUE : FALSE;
2313
2314         if (win && lowmem && visuals)
2315                 modest_platform_run_information_dialog (
2316                         GTK_WINDOW(win),
2317                         _KR("memr_ib_operation_disabled"),
2318                         TRUE);
2319
2320         if (lowmem)
2321                 g_debug ("%s: low memory reached. disallowing some operations",
2322                          __FUNCTION__);
2323
2324         return lowmem;
2325 }
2326
2327 void
2328 modest_platform_run_folder_details_dialog (GtkWindow *parent_window,
2329                                            TnyFolder *folder)
2330 {
2331         GtkWidget *dialog;
2332
2333         /* Create dialog */
2334         dialog = modest_hildon2_details_dialog_new_with_folder (parent_window, folder);
2335
2336         /* Run dialog */
2337         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
2338                                      GTK_WINDOW (dialog),
2339                                      parent_window);
2340         gtk_widget_show_all (dialog);
2341
2342         g_signal_connect_swapped (dialog, "response",
2343                                   G_CALLBACK (gtk_widget_destroy),
2344                                   dialog);
2345 }
2346
2347 void
2348 modest_platform_run_header_details_dialog (GtkWindow *parent_window,
2349                                            TnyHeader *header)
2350 {
2351         GtkWidget *dialog;
2352
2353         /* Create dialog */
2354         dialog = modest_hildon2_details_dialog_new_with_header (parent_window, header);
2355
2356         /* Run dialog */
2357         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
2358                                      GTK_WINDOW (dialog),
2359                                      parent_window);
2360         gtk_widget_show_all (dialog);
2361
2362         g_signal_connect_swapped (dialog, "response",
2363                                   G_CALLBACK (gtk_widget_destroy),
2364                                   dialog);
2365 }
2366
2367 osso_context_t *
2368 modest_platform_get_osso_context (void)
2369 {
2370         return modest_maemo_utils_get_osso_context ();
2371 }
2372
2373 static void
2374 _modest_platform_play_email_tone (void)
2375 {
2376         gchar *active_profile;
2377         gchar *mail_tone;
2378         gchar *mail_volume;
2379         gint mail_volume_int;
2380         int ret;
2381         ca_context *ca_con = NULL;
2382         ca_proplist *pl = NULL;
2383
2384         active_profile = profile_get_profile ();
2385         mail_tone = profile_get_value (active_profile, PROFILE_MAIL_TONE);
2386         mail_volume = profile_get_value (active_profile, PROFILE_MAIL_VOLUME);
2387         mail_volume_int = profile_parse_int (mail_volume);
2388
2389         if (mail_tone && !strstr (mail_tone, "/")) {
2390                 gchar *tmp;
2391
2392                 tmp = g_strconcat ("/usr/share/sounds", mail_tone, NULL);
2393                 g_free (mail_tone);
2394                 mail_tone = tmp;
2395         }
2396
2397         if (mail_volume_int > 0) {
2398
2399                 if ((ret = ca_context_create(&ca_con)) != CA_SUCCESS) {
2400                         g_warning("ca_context_create: %s\n", ca_strerror(ret));
2401                         return;
2402                 }
2403
2404                 if ((ret = ca_context_open(ca_con)) != CA_SUCCESS) {
2405                         g_warning("ca_context_open: %s\n", ca_strerror(ret));
2406                         ca_context_destroy(ca_con);
2407                         return;
2408                 }
2409
2410                 ca_proplist_create(&pl);
2411                 ca_proplist_sets(pl, CA_PROP_MEDIA_FILENAME, mail_tone);
2412                 ca_proplist_setf(pl, CA_PROP_CANBERRA_VOLUME, "%f", (gfloat) mail_volume_int);
2413
2414                 ret = ca_context_play_full(ca_con, 0, pl, NULL, NULL);
2415                 g_debug("ca_context_play_full (vol %f): %s\n", (gfloat) mail_volume_int, ca_strerror(ret));
2416
2417                 ca_proplist_destroy(pl);
2418                 ca_context_destroy(ca_con);
2419         }
2420
2421         g_free (mail_volume);
2422         g_free (mail_tone);
2423         g_free (active_profile);
2424 }
2425
2426 #define MOVE_TO_DIALOG_FOLDER_VIEW "folder-view"
2427 #define MOVE_TO_DIALOG_BACK_BUTTON "back-button"
2428 #define MOVE_TO_DIALOG_SELECTION_LABEL "selection-label"
2429 #define MOVE_TO_DIALOG_SHOWING_FOLDERS "showing-folders"
2430 #define MOVE_TO_DIALOG_PANNABLE "pannable"
2431
2432 static void
2433 move_to_dialog_show_accounts (GtkWidget *dialog)
2434 {
2435         GtkWidget *selection_label;
2436         GtkWidget *back_button;
2437         GtkWidget *folder_view;
2438         GtkWidget *pannable;
2439
2440         selection_label = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_SELECTION_LABEL));
2441         back_button = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_BACK_BUTTON));
2442         folder_view = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_FOLDER_VIEW));
2443         pannable = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_PANNABLE));
2444
2445         gtk_widget_set_sensitive (back_button, FALSE);
2446
2447         gtk_label_set_text (GTK_LABEL (selection_label), "");
2448         modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (folder_view), TRUE);
2449         modest_folder_view_set_style (MODEST_FOLDER_VIEW (folder_view), MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
2450         modest_folder_view_set_filter (MODEST_FOLDER_VIEW (folder_view), MODEST_FOLDER_VIEW_FILTER_HIDE_FOLDERS);
2451         modest_folder_view_unset_filter (MODEST_FOLDER_VIEW (folder_view), MODEST_FOLDER_VIEW_FILTER_HIDE_LOCAL_FOLDERS);
2452         hildon_pannable_area_jump_to (HILDON_PANNABLE_AREA (pannable), 0, 0);
2453
2454         g_object_set_data (G_OBJECT (dialog), MOVE_TO_DIALOG_SHOWING_FOLDERS, GINT_TO_POINTER (FALSE));
2455 }
2456
2457 static void
2458 move_to_dialog_show_folders (GtkWidget *dialog, TnyFolderStore *folder_store)
2459 {
2460         GtkWidget *selection_label;
2461         GtkWidget *back_button;
2462         GtkWidget *folder_view;
2463         TnyAccount *account;
2464         const gchar *account_id;
2465         gchar *selection_label_text;
2466         GtkWidget *pannable;
2467
2468         selection_label = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_SELECTION_LABEL));
2469         back_button = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_BACK_BUTTON));
2470         folder_view = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_FOLDER_VIEW));
2471         pannable = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_PANNABLE));
2472
2473         gtk_widget_set_sensitive (back_button, TRUE);
2474
2475         account = TNY_ACCOUNT (folder_store);
2476         if (modest_tny_account_is_virtual_local_folders (account)) {
2477                 gchar *device_name;
2478                 account_id = tny_account_get_id (account);
2479                 device_name = modest_conf_get_string (modest_runtime_get_conf(),
2480                                                       MODEST_CONF_DEVICE_NAME, NULL);
2481                 if (device_name) {
2482                         selection_label_text = g_strconcat (device_name, "/", NULL);
2483                         g_free (device_name);
2484                 } else {
2485                         selection_label_text = g_strconcat (tny_account_get_name (account), "/", NULL);
2486                 }
2487         } else if (modest_tny_account_is_memory_card_account (account)) {
2488                 account_id = tny_account_get_id (account);
2489                 selection_label_text = g_strconcat (tny_account_get_name (account), "/", NULL);
2490         } else {
2491                 account_id = tny_account_get_id (account);
2492
2493                 selection_label_text = g_strconcat (tny_account_get_name (account), "/", NULL);
2494                 modest_folder_view_set_filter (MODEST_FOLDER_VIEW (folder_view),
2495                                                MODEST_FOLDER_VIEW_FILTER_HIDE_LOCAL_FOLDERS);
2496         }
2497         gtk_label_set_text (GTK_LABEL (selection_label), selection_label_text);
2498         g_free (selection_label_text);
2499
2500         modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW (folder_view),
2501                                                                      account_id);
2502
2503         modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (folder_view), FALSE);
2504         modest_folder_view_set_style (MODEST_FOLDER_VIEW (folder_view), MODEST_FOLDER_VIEW_STYLE_SHOW_ONE);
2505         modest_folder_view_unset_filter (MODEST_FOLDER_VIEW (folder_view), MODEST_FOLDER_VIEW_FILTER_HIDE_FOLDERS);
2506         hildon_pannable_area_jump_to (HILDON_PANNABLE_AREA (pannable), 0, 0);
2507
2508         g_object_set_data (G_OBJECT (dialog), MOVE_TO_DIALOG_SHOWING_FOLDERS, GINT_TO_POINTER (TRUE));
2509 }
2510
2511 static void
2512 on_move_to_dialog_back_clicked (GtkButton *button,
2513                                 gpointer userdata)
2514 {
2515         GtkWidget *dialog = (GtkWidget *) userdata;
2516
2517         move_to_dialog_show_accounts (dialog);
2518 }
2519
2520 static void
2521 on_move_to_dialog_folder_activated (GtkTreeView       *tree_view,
2522                                     GtkTreePath       *path,
2523                                     GtkTreeViewColumn *column,
2524                                     gpointer           user_data)
2525 {
2526         TnyFolderStore *selected;
2527         GtkWidget *dialog;
2528         GtkWidget *folder_view;
2529         gboolean showing_folders;
2530
2531         dialog = (GtkWidget *) user_data;
2532         showing_folders = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_SHOWING_FOLDERS));
2533         if (showing_folders) {
2534                 gtk_dialog_response (GTK_DIALOG (user_data), GTK_RESPONSE_OK);
2535         } else {
2536                 folder_view = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_FOLDER_VIEW));
2537
2538                 selected = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2539                 if (selected) {
2540                         move_to_dialog_show_folders (dialog, selected);
2541                 }
2542         }
2543 }
2544
2545 GtkWidget *
2546 modest_platform_create_move_to_dialog (GtkWindow *parent_window,
2547                                        GtkWidget **folder_view)
2548 {
2549         GtkWidget *dialog, *folder_view_container;
2550         GtkWidget *buttons_hbox;
2551         GtkWidget *back_button, *selection_label;
2552         GdkPixbuf *back_pixbuf;
2553
2554         /* Create dialog. We cannot use a touch selector because we
2555            need to use here the folder view widget directly */
2556         dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
2557                                               GTK_WINDOW (parent_window),
2558                                               GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR |
2559                                               GTK_DIALOG_DESTROY_WITH_PARENT,
2560                                               _HL("wdgt_bd_new"), MODEST_GTK_RESPONSE_NEW_FOLDER,
2561                                               NULL);
2562
2563         /* Create folder view */
2564         *folder_view = modest_platform_create_folder_view (NULL);
2565
2566         tny_account_store_view_set_account_store (TNY_ACCOUNT_STORE_VIEW (*folder_view),
2567                                                   (TnyAccountStore *) modest_runtime_get_account_store ());
2568
2569         buttons_hbox = gtk_hbox_new (FALSE, MODEST_MARGIN_HALF);
2570         back_button = gtk_button_new ();
2571         back_pixbuf = modest_platform_get_icon (_FM("filemanager_folder_up"), MODEST_ICON_SIZE_BIG);
2572         if (back_pixbuf) {
2573                 gtk_button_set_image (GTK_BUTTON (back_button), gtk_image_new_from_pixbuf (back_pixbuf));
2574                 g_object_unref (back_pixbuf);
2575         }
2576         selection_label = gtk_label_new ("");
2577         gtk_misc_set_alignment (GTK_MISC (selection_label), 0.0, 0.5);
2578         gtk_box_pack_start (GTK_BOX (buttons_hbox), back_button, FALSE, FALSE, 0);
2579         gtk_box_pack_start (GTK_BOX (buttons_hbox), selection_label, TRUE, TRUE, 0);
2580         gtk_widget_set_sensitive (GTK_WIDGET (back_button), FALSE);
2581         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), buttons_hbox, FALSE, FALSE, 0);
2582
2583         /* Create pannable and add it to the dialog */
2584         folder_view_container = hildon_pannable_area_new ();
2585         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), folder_view_container, TRUE, TRUE, 0);
2586         gtk_container_add (GTK_CONTAINER (folder_view_container), *folder_view);
2587
2588         gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 300);
2589
2590         gtk_widget_show (GTK_DIALOG (dialog)->vbox);
2591         gtk_widget_show (folder_view_container);
2592         gtk_widget_show (*folder_view);
2593         gtk_widget_show_all (back_button);
2594         gtk_widget_show (selection_label);
2595         gtk_widget_show (buttons_hbox);
2596
2597         g_object_set_data (G_OBJECT (dialog), MOVE_TO_DIALOG_FOLDER_VIEW, *folder_view);
2598         g_object_set_data (G_OBJECT (dialog), MOVE_TO_DIALOG_BACK_BUTTON, back_button);
2599         g_object_set_data (G_OBJECT (dialog), MOVE_TO_DIALOG_SELECTION_LABEL, selection_label);
2600         g_object_set_data (G_OBJECT (dialog), MOVE_TO_DIALOG_PANNABLE, folder_view_container);
2601
2602         /* Simulate the behaviour of a HildonPickerDialog by emitting
2603            a response when a folder is selected */
2604         g_signal_connect (*folder_view, "row-activated",
2605                           G_CALLBACK (on_move_to_dialog_folder_activated),
2606                           dialog);
2607
2608         g_signal_connect (back_button, "clicked",
2609                           G_CALLBACK (on_move_to_dialog_back_clicked),
2610                           dialog);
2611
2612         move_to_dialog_show_accounts (dialog);
2613
2614         return dialog;
2615 }
2616
2617 TnyList *
2618 modest_platform_get_list_to_move (ModestWindow *window)
2619 {
2620         TnyList *list = NULL;
2621
2622         if (MODEST_IS_HEADER_WINDOW (window)) {
2623                 ModestHeaderView *header_view;
2624
2625                 header_view = modest_header_window_get_header_view (MODEST_HEADER_WINDOW (window));
2626                 list = modest_header_view_get_selected_headers (header_view);
2627         } else if (MODEST_IS_FOLDER_WINDOW (window)) {
2628                 ModestFolderView *folder_view;
2629                 TnyFolderStore *selected_folder;
2630
2631                 list = TNY_LIST (tny_simple_list_new ());
2632                 folder_view = modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window));
2633                 selected_folder = modest_folder_view_get_selected (folder_view);
2634                 if (selected_folder) {
2635                         tny_list_prepend (list, G_OBJECT (selected_folder));
2636                         g_object_unref (selected_folder);
2637                 }
2638                 return list;
2639         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2640                 TnyHeader *header;
2641
2642                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (window));
2643                 if (header) {
2644                         list = TNY_LIST (tny_simple_list_new ());
2645                         tny_list_prepend (list, G_OBJECT (header));
2646                         g_object_unref (header);
2647                 }
2648         } else {
2649                 g_return_val_if_reached (NULL);
2650         }
2651
2652         return list;
2653 }