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