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), _CS("ckdg_va_new_folder_name_stub"));
 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 (_CS("ckdg_va_new_folder_name_stub"), -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 = _CS("ckdg_va_new_folder_name_stub");
 996                 unsigned int i;
 997
 998                 for(i = 0; i < 100; ++ i) {
 999                         gboolean exists = FALSE;
1000
1001                         if (i == 0)
1002                                 real_suggested_name = g_strdup (default_name);
1003                         else
1004                                 real_suggested_name = g_strdup_printf ("%s(%d)",
1005                                                                        _CS("ckdg_va_new_folder_name_stub"),
1006                                                                        i);
1007                         exists = modest_tny_folder_has_subfolder_with_name (suggested_folder,
1008                                                                             real_suggested_name,
1009                                                                             TRUE);
1010
1011                         if (!exists)
1012                                 break;
1013
1014                         g_free (real_suggested_name);
1015                 }
1016
1017                 /* Didn't find a free number */
1018                 if (i == 100)
1019                         real_suggested_name = g_strdup (default_name);
1020         } else {
1021                 real_suggested_name = suggested_name;
1022         }
1023
1024         /* In hildon 2.2 we always suggest the archive folder as parent */
1025         acc_store = modest_runtime_get_account_store ();
1026         account = modest_tny_account_store_get_mmc_folders_account (acc_store);
1027         if (account) {
1028                 suggested_folder = (TnyFolderStore *)
1029                         modest_tny_account_get_special_folder (account,
1030                                                                TNY_FOLDER_TYPE_ARCHIVE);
1031                 g_object_unref (account);
1032                 account = NULL;
1033         }
1034
1035         /* If there is not archive folder then fallback to local folders account */
1036         if (!suggested_folder)
1037                 suggested_folder = (TnyFolderStore *)
1038                         modest_tny_account_store_get_local_folders_account (acc_store);
1039
1040         tmp = g_strconcat (_CS("ckdg_fi_new_folder_name"), ":", NULL);
1041         result = modest_platform_run_folder_common_dialog (parent_window,
1042                                                            suggested_folder,
1043                                                            _CS("ckdg_fi_new_folder_name"),
1044                                                            tmp,
1045                                                            real_suggested_name,
1046                                                            TRUE,
1047                                                            TRUE,
1048                                                            folder_name,
1049                                                            parent_folder);
1050         g_free (tmp);
1051
1052         if (suggested_name == NULL)
1053                 g_free(real_suggested_name);
1054
1055         return result;
1056 }
1057
1058 gint
1059 modest_platform_run_rename_folder_dialog (GtkWindow *parent_window,
1060                                           TnyFolderStore *parent_folder,
1061                                           const gchar *suggested_name,
1062                                           gchar **folder_name)
1063 {
1064         g_return_val_if_fail (TNY_IS_FOLDER_STORE (parent_folder), GTK_RESPONSE_REJECT);
1065
1066         return modest_platform_run_folder_common_dialog (parent_window,
1067                                                          parent_folder,
1068                                                          _HL("ckdg_ti_rename_folder"),
1069                                                          _HL("ckdg_fi_rename_name"),
1070                                                          suggested_name,
1071                                                          TRUE,
1072                                                          FALSE,
1073                                                          folder_name,
1074                                                          NULL);
1075 }
1076
1077
1078
1079 static void
1080 on_destroy_dialog (GtkWidget *dialog)
1081 {
1082         /* This could happen when the dialogs get programatically
1083            hidden or destroyed (for example when closing the
1084            application while a dialog is being shown) */
1085         if (!GTK_IS_WIDGET (dialog))
1086                 return;
1087
1088         gtk_widget_destroy (dialog);
1089
1090         if (gtk_events_pending ())
1091                 gtk_main_iteration ();
1092 }
1093
1094 gint
1095 modest_platform_run_confirmation_dialog (GtkWindow *parent_window,
1096                                          const gchar *message)
1097 {
1098         GtkWidget *dialog;
1099         gint response;
1100
1101         dialog = hildon_note_new_confirmation (parent_window, message);
1102         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1103                                      GTK_WINDOW (dialog), parent_window);
1104
1105         response = gtk_dialog_run (GTK_DIALOG (dialog));
1106
1107         on_destroy_dialog (dialog);
1108
1109         return response;
1110 }
1111
1112 gint
1113 modest_platform_run_confirmation_dialog_with_buttons (GtkWindow *parent_window,
1114                                                       const gchar *message,
1115                                                       const gchar *button_accept,
1116                                                       const gchar *button_cancel)
1117 {
1118         GtkWidget *dialog;
1119         gint response;
1120
1121         dialog = hildon_note_new_confirmation_add_buttons (parent_window, message,
1122                                                            button_accept, GTK_RESPONSE_ACCEPT,
1123                                                            button_cancel, GTK_RESPONSE_CANCEL,
1124                                                            NULL);
1125
1126         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1127                                      GTK_WINDOW (dialog), parent_window);
1128
1129         response = gtk_dialog_run (GTK_DIALOG (dialog));
1130
1131         on_destroy_dialog (dialog);
1132
1133         return response;
1134 }
1135
1136 void
1137 modest_platform_run_information_dialog (GtkWindow *parent_window,
1138                                         const gchar *message,
1139                                         gboolean block)
1140 {
1141         GtkWidget *note;
1142
1143         note = hildon_note_new_information (parent_window, message);
1144         if (block)
1145                 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1146                                              GTK_WINDOW (note), parent_window);
1147
1148         if (block) {
1149                 gtk_dialog_run (GTK_DIALOG (note));
1150
1151                 on_destroy_dialog (note);
1152         } else {
1153                 g_signal_connect_swapped (note,
1154                                           "response",
1155                                           G_CALLBACK (on_destroy_dialog),
1156                                           note);
1157
1158                 gtk_widget_show_all (note);
1159         }
1160 }
1161
1162 typedef struct _ConnectAndWaitData {
1163         GMutex *mutex;
1164         GMainLoop *wait_loop;
1165         gboolean has_callback;
1166         gulong handler;
1167 } ConnectAndWaitData;
1168
1169
1170 static void
1171 quit_wait_loop (TnyAccount *account,
1172                 ConnectAndWaitData *data)
1173 {
1174         /* Set the has_callback to TRUE (means that the callback was
1175            executed and wake up every code waiting for cond to be
1176            TRUE */
1177         g_mutex_lock (data->mutex);
1178         data->has_callback = TRUE;
1179         if (data->wait_loop)
1180                 g_main_loop_quit (data->wait_loop);
1181         g_mutex_unlock (data->mutex);
1182 }
1183
1184 static void
1185 on_connection_status_changed (TnyAccount *account,
1186                               TnyConnectionStatus status,
1187                               gpointer user_data)
1188 {
1189         TnyConnectionStatus conn_status;
1190         ConnectAndWaitData *data;
1191
1192         /* Ignore if reconnecting or disconnected */
1193         conn_status = tny_account_get_connection_status (account);
1194         if (conn_status == TNY_CONNECTION_STATUS_RECONNECTING ||
1195             conn_status == TNY_CONNECTION_STATUS_DISCONNECTED)
1196                 return;
1197
1198         /* Remove the handler */
1199         data = (ConnectAndWaitData *) user_data;
1200         g_signal_handler_disconnect (account, data->handler);
1201
1202         /* Quit from wait loop */
1203         quit_wait_loop (account, (ConnectAndWaitData *) user_data);
1204 }
1205
1206 static void
1207 on_tny_camel_account_set_online_cb (TnyCamelAccount *account,
1208                                     gboolean canceled,
1209                                     GError *err,
1210                                     gpointer user_data)
1211 {
1212         /* Quit from wait loop */
1213         quit_wait_loop (TNY_ACCOUNT (account), (ConnectAndWaitData *) user_data);
1214 }
1215
1216 gboolean
1217 modest_platform_connect_and_wait (GtkWindow *parent_window,
1218                                   TnyAccount *account)
1219 {
1220         ConnectAndWaitData *data = NULL;
1221         gboolean device_online;
1222         TnyDevice *device;
1223         TnyConnectionStatus conn_status;
1224         gboolean user_requested;
1225
1226         device = modest_runtime_get_device();
1227         device_online = tny_device_is_online (device);
1228
1229         /* Whether the connection is user requested or automatically
1230            requested, for example via D-Bus */
1231         user_requested = (parent_window) ? TRUE : FALSE;
1232
1233         /* If there is no account check only the device status */
1234         if (!account) {
1235                 if (device_online)
1236                         return TRUE;
1237                 else
1238                         return tny_maemo_conic_device_connect (TNY_MAEMO_CONIC_DEVICE (device),
1239                                                                NULL, user_requested);
1240         }
1241
1242         /* Return if the account is already connected */
1243         conn_status = tny_account_get_connection_status (account);
1244         if (device_online && conn_status == TNY_CONNECTION_STATUS_CONNECTED)
1245                 return TRUE;
1246
1247         /* Create the helper */
1248         data = g_slice_new0 (ConnectAndWaitData);
1249         data->mutex = g_mutex_new ();
1250         data->has_callback = FALSE;
1251
1252         /* Connect the device */
1253         if (!device_online) {
1254                 /* Track account connection status changes */
1255                 data->handler = g_signal_connect (account, "connection-status-changed",
1256                                                   G_CALLBACK (on_connection_status_changed),
1257                                                   data);
1258                 /* Try to connect the device */
1259                 device_online = tny_maemo_conic_device_connect (TNY_MAEMO_CONIC_DEVICE (device),
1260                                                                 NULL, user_requested);
1261
1262                 /* If the device connection failed then exit */
1263                 if (!device_online && data->handler)
1264                         goto frees;
1265         } else {
1266                 /* Force a reconnection of the account */
1267                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (account), TRUE,
1268                                               on_tny_camel_account_set_online_cb, data);
1269         }
1270
1271         /* Wait until the callback is executed */
1272         g_mutex_lock (data->mutex);
1273         if (!data->has_callback) {
1274                 data->wait_loop = g_main_loop_new (g_main_context_new (), FALSE);
1275                 gdk_threads_leave ();
1276                 g_mutex_unlock (data->mutex);
1277                 g_main_loop_run (data->wait_loop);
1278                 g_mutex_lock (data->mutex);
1279                 gdk_threads_enter ();
1280         }
1281         g_mutex_unlock (data->mutex);
1282
1283  frees:
1284         if (data) {
1285                 if (g_signal_handler_is_connected (account, data->handler))
1286                         g_signal_handler_disconnect (account, data->handler);
1287                 g_mutex_free (data->mutex);
1288                 g_main_loop_unref (data->wait_loop);
1289                 g_slice_free (ConnectAndWaitData, data);
1290         }
1291
1292         conn_status = tny_account_get_connection_status (account);
1293         return (conn_status == TNY_CONNECTION_STATUS_CONNECTED) ? TRUE: FALSE;
1294 }
1295
1296 gboolean
1297 modest_platform_connect_and_wait_if_network_account (GtkWindow *parent_window, TnyAccount *account)
1298 {
1299         if (tny_account_get_account_type (account) == TNY_ACCOUNT_TYPE_STORE) {
1300                 if (!modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account))) {
1301                         /* This must be a maildir account, which does not require a connection: */
1302                         return TRUE;
1303                 }
1304         }
1305
1306         return modest_platform_connect_and_wait (parent_window, account);
1307 }
1308
1309 gboolean
1310 modest_platform_connect_and_wait_if_network_folderstore (GtkWindow *parent_window, TnyFolderStore *folder_store)
1311 {
1312         if (!folder_store)
1313                 return TRUE; /* Maybe it is something local. */
1314
1315         gboolean result = TRUE;
1316         if (TNY_IS_FOLDER (folder_store)) {
1317                 /* Get the folder's parent account: */
1318                 TnyAccount *account = tny_folder_get_account(TNY_FOLDER (folder_store));
1319                 if (account != NULL) {
1320                         result = modest_platform_connect_and_wait_if_network_account (NULL, account);
1321                         g_object_unref (account);
1322                 }
1323         } else if (TNY_IS_ACCOUNT (folder_store)) {
1324                 /* Use the folder store as an account: */
1325                 result = modest_platform_connect_and_wait_if_network_account (NULL, TNY_ACCOUNT (folder_store));
1326         }
1327
1328         return result;
1329 }
1330
1331 GtkWidget *
1332 modest_platform_create_sort_dialog       (GtkWindow *parent_window)
1333 {
1334         GtkWidget *dialog;
1335
1336         dialog = modest_hildon2_sort_dialog_new (parent_window);
1337
1338         return dialog;
1339 }
1340
1341
1342 gboolean
1343 modest_platform_set_update_interval (guint minutes)
1344 {
1345 #ifdef MODEST_HAVE_LIBALARM
1346
1347         ModestConf *conf = modest_runtime_get_conf ();
1348         if (!conf)
1349                 return FALSE;
1350
1351         cookie_t alarm_cookie = modest_conf_get_int (conf, MODEST_CONF_ALARM_ID, NULL);
1352
1353         /* Delete any existing alarm,
1354          * because we will replace it: */
1355         if (alarm_cookie) {
1356                 if (alarmd_event_del(alarm_cookie) != 0)
1357                         g_warning ("%s: alarm %d was not on the queue", __FUNCTION__, (int)alarm_cookie);
1358                 alarm_cookie = 0;
1359                 modest_conf_set_int (conf, MODEST_CONF_ALARM_ID, 0, NULL);
1360         }
1361
1362         /* 0 means no updates: */
1363         if (minutes == 0)
1364                 return TRUE;
1365
1366
1367         /* Register alarm: */
1368
1369         /* Set the interval in alarm_event_t structure: */
1370         alarm_event_t *event = alarm_event_create ();
1371         alarm_event_add_actions (event, 1);
1372         alarm_action_t *action = alarm_event_get_action (event, 0);
1373         alarm_event_set_alarm_appid (event, MODEST_ALARMD_APPID);
1374         event->alarm_time = minutes * 60; /* seconds */
1375
1376         /* Set recurrence every few minutes: */
1377         event->recur_secs = minutes*60;
1378         event->recur_count = -1; /* Means infinite */
1379
1380         /* Specify what should happen when the alarm happens:
1381          * It should call this D-Bus method: */
1382
1383         action->dbus_path = g_strdup(MODEST_DBUS_OBJECT);
1384         action->dbus_interface = g_strdup (MODEST_DBUS_IFACE);
1385         action->dbus_service = g_strdup (MODEST_DBUS_SERVICE);
1386         action->dbus_name = g_strdup (MODEST_DBUS_METHOD_SEND_RECEIVE);
1387         action->flags = ALARM_ACTION_WHEN_TRIGGERED | ALARM_ACTION_TYPE_DBUS | ALARM_ACTION_DBUS_USE_ACTIVATION;
1388
1389         /* Use ALARM_EVENT_NO_DIALOG: Otherwise, a dialog will be shown if
1390          * exec_name or dbus_path is NULL, even though we have specified no dialog text.
1391          * Also use ALARM_EVENT_ACTIVATION so that modest is started (without UI) to get emails
1392          * This is why we want to use the Alarm API instead of just g_timeout_add().
1393          * (The old maemo email-client did this, though it isn't specified in the UI spec.)
1394          * ALARM_EVENT_CONNECTED will prevent the alarm from being called in case that the device is offline
1395          */
1396         event->flags = ALARM_EVENT_CONNECTED;
1397
1398         alarm_cookie = alarmd_event_add (event);
1399
1400         /* now, free it */
1401         alarm_event_delete (event);
1402
1403         /* Store the alarm ID in GConf, so we can remove it later:
1404          * This is apparently valid between application instances. */
1405         modest_conf_set_int (conf, MODEST_CONF_ALARM_ID, alarm_cookie, NULL);
1406
1407         if (!alarm_cookie) {
1408             /* Error */
1409             g_debug ("Error setting alarm event. \n");
1410
1411             return FALSE;
1412         }
1413 #endif /* MODEST_HAVE_LIBALARM */
1414         return TRUE;
1415 }
1416
1417 void
1418 modest_platform_push_email_notification(void)
1419 {
1420         gboolean screen_on, app_in_foreground;
1421
1422         /* Get the window status */
1423         app_in_foreground = hildon_program_get_is_topmost (hildon_program_get_instance ());
1424
1425         screen_on = modest_window_mgr_screen_is_on (modest_runtime_get_window_mgr ());
1426
1427         /* If the screen is on and the app is in the
1428            foreground we don't show anything */
1429         if (!(screen_on && app_in_foreground)) {
1430
1431                 _modest_platform_play_email_tone ();
1432
1433                 /* Activate LED. This must be deactivated by
1434                    modest_platform_remove_new_mail_notifications */
1435 #ifdef MODEST_HAVE_MCE
1436                 osso_rpc_run_system (modest_maemo_utils_get_osso_context (),
1437                                      MCE_SERVICE,
1438                                      MCE_REQUEST_PATH,
1439                                      MCE_REQUEST_IF,
1440                                      MCE_ACTIVATE_LED_PATTERN,
1441                                      NULL,
1442                                      DBUS_TYPE_STRING, MODEST_NEW_MAIL_LIGHTING_PATTERN,
1443                                      DBUS_TYPE_INVALID);
1444 #endif
1445         }
1446 }
1447
1448 void
1449 modest_platform_on_new_headers_received (TnyList *header_list,
1450                                          gboolean show_visual)
1451 {
1452         g_return_if_fail (TNY_IS_LIST(header_list));
1453
1454         if (tny_list_get_length(header_list) == 0) {
1455                 g_warning ("%s: header list is empty", __FUNCTION__);
1456                 return;
1457         }
1458
1459         if (!show_visual) {
1460                 modest_platform_push_email_notification ();
1461                 /* We do a return here to avoid indentation with an else */
1462                 return;
1463         }
1464
1465 #ifdef MODEST_HAVE_HILDON_NOTIFY
1466         HildonNotification *notification;
1467         TnyIterator *iter;
1468         GSList *notifications_list = NULL;
1469
1470         /* Get previous notifications ids */
1471         notifications_list = modest_conf_get_list (modest_runtime_get_conf (),
1472                                                    MODEST_CONF_NOTIFICATION_IDS,
1473                                                    MODEST_CONF_VALUE_INT, NULL);
1474
1475         iter = tny_list_create_iterator (header_list);
1476         while (!tny_iterator_is_done (iter)) {
1477                 gchar *url = NULL, *display_address = NULL;
1478                 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
1479                 TnyFolder *folder = tny_header_get_folder (header);
1480                 gboolean first_notification = TRUE;
1481                 gint notif_id;
1482                 gchar *str;
1483
1484                 display_address = tny_header_dup_from (header);
1485                 /* string is changed in-place */
1486                 modest_text_utils_get_display_address (display_address);
1487
1488                 str = tny_header_dup_subject (header);
1489                 notification = hildon_notification_new (display_address,
1490                                                         str,
1491                                                         "qgn_list_messagin",
1492                                                         "email-message");
1493                 g_free (str);
1494                 /* Create the message URL */
1495                 str = tny_header_dup_uid (header);
1496                 url = g_strdup_printf ("%s/%s", tny_folder_get_url_string (folder),
1497                                        str);
1498                 g_free (str);
1499
1500                 hildon_notification_add_dbus_action(notification,
1501                                                     "default",
1502                                                     "Cancel",
1503                                                     MODEST_DBUS_SERVICE,
1504                                                     MODEST_DBUS_OBJECT,
1505                                                     MODEST_DBUS_IFACE,
1506                                                     MODEST_DBUS_METHOD_OPEN_MESSAGE,
1507                                                     G_TYPE_STRING, url,
1508                                                     -1);
1509
1510                 /* Play sound if the user wants. Show the LED
1511                    pattern. Show and play just one */
1512                 if (G_UNLIKELY (first_notification)) {
1513                         gchar *active_profile;
1514                         gchar *mail_tone;
1515                         gchar *mail_volume;
1516                         gint mail_volume_int;
1517
1518                         first_notification = FALSE;
1519
1520                         active_profile = profile_get_profile ();
1521                         mail_tone = profile_get_value (active_profile, PROFILE_MAIL_TONE);
1522                         mail_volume = profile_get_value (active_profile, PROFILE_MAIL_VOLUME);
1523                         mail_volume_int = profile_parse_int (mail_volume);
1524
1525                         if (mail_volume_int > 0)
1526                                 notify_notification_set_hint_string(NOTIFY_NOTIFICATION (notification),
1527                                                                     "sound-file", mail_tone);
1528
1529                         g_free (mail_volume);
1530                         g_free (mail_tone);
1531                         g_free (active_profile);
1532
1533                         /* Set the led pattern */
1534                         notify_notification_set_hint_int32 (NOTIFY_NOTIFICATION (notification),
1535                                                             "dialog-type", 4);
1536                         notify_notification_set_hint_string(NOTIFY_NOTIFICATION (notification),
1537                                                             "led-pattern",
1538                                                             MODEST_NEW_MAIL_LIGHTING_PATTERN);
1539                 }
1540
1541                 /* Notify. We need to do this in an idle because this function
1542                    could be called from a thread */
1543                 notify_notification_show (NOTIFY_NOTIFICATION (notification), NULL);
1544
1545                 /* Save id in the list */
1546                 g_object_get(G_OBJECT(notification), "id", &notif_id, NULL);
1547                 notifications_list = g_slist_prepend (notifications_list, GINT_TO_POINTER(notif_id));
1548                 /* We don't listen for the "closed" signal, because we
1549                    don't care about if the notification was removed or
1550                    not to store the list in gconf */
1551
1552                 /* Free & carry on */
1553                 g_free (display_address);
1554                 g_free (url);
1555                 g_object_unref (folder);
1556                 g_object_unref (header);
1557                 tny_iterator_next (iter);
1558         }
1559         g_object_unref (iter);
1560
1561         /* Save the ids */
1562         modest_conf_set_list (modest_runtime_get_conf (), MODEST_CONF_NOTIFICATION_IDS,
1563                               notifications_list, MODEST_CONF_VALUE_INT, NULL);
1564
1565         g_slist_free (notifications_list);
1566
1567 #endif /*MODEST_HAVE_HILDON_NOTIFY*/
1568 }
1569
1570 void
1571 modest_platform_remove_new_mail_notifications (gboolean only_visuals)
1572 {
1573         if (only_visuals) {
1574 #ifdef MODEST_HAVE_MCE
1575                 osso_rpc_run_system (modest_maemo_utils_get_osso_context (),
1576                                      MCE_SERVICE,
1577                                      MCE_REQUEST_PATH,
1578                                      MCE_REQUEST_IF,
1579                                      MCE_DEACTIVATE_LED_PATTERN,
1580                                      NULL,
1581                                      DBUS_TYPE_STRING, MODEST_NEW_MAIL_LIGHTING_PATTERN,
1582                                      DBUS_TYPE_INVALID);
1583 #endif
1584                 return;
1585         }
1586
1587 #ifdef MODEST_HAVE_HILDON_NOTIFY
1588         GSList *notif_list = NULL;
1589
1590         /* Get previous notifications ids */
1591         notif_list = modest_conf_get_list (modest_runtime_get_conf (),
1592                                            MODEST_CONF_NOTIFICATION_IDS,
1593                                            MODEST_CONF_VALUE_INT, NULL);
1594
1595         while (notif_list) {
1596                 gint notif_id;
1597                 NotifyNotification *notif;
1598
1599                 /* Nasty HACK to remove the notifications, set the id
1600                    of the existing ones and then close them */
1601                 notif_id = GPOINTER_TO_INT(notif_list->data);
1602                 notif = notify_notification_new("dummy", NULL, NULL, NULL);
1603                 g_object_set(G_OBJECT(notif), "id", notif_id, NULL);
1604
1605                 /* Close the notification, note that some ids could be
1606                    already invalid, but we don't care because it does
1607                    not fail */
1608                 notify_notification_close(notif, NULL);
1609                 g_object_unref(notif);
1610
1611                 /* Delete the link, it's like going to the next */
1612                 notif_list = g_slist_delete_link (notif_list, notif_list);
1613         }
1614
1615         /* Save the ids */
1616         modest_conf_set_list (modest_runtime_get_conf (), MODEST_CONF_NOTIFICATION_IDS,
1617                               notif_list, MODEST_CONF_VALUE_INT, NULL);
1618
1619         g_slist_free (notif_list);
1620
1621 #endif /* MODEST_HAVE_HILDON_NOTIFY */
1622 }
1623
1624
1625
1626 GtkWidget *
1627 modest_platform_get_global_settings_dialog ()
1628 {
1629         return modest_hildon2_global_settings_dialog_new ();
1630 }
1631
1632 void
1633 modest_platform_show_help (GtkWindow *parent_window,
1634                            const gchar *help_id)
1635 {
1636         return;
1637 }
1638
1639 void
1640 modest_platform_show_search_messages (GtkWindow *parent_window)
1641 {
1642         osso_return_t result = OSSO_ERROR;
1643
1644         result = osso_rpc_run_with_defaults (modest_maemo_utils_get_osso_context(),
1645                                              "osso_global_search",
1646                                              "search_email", NULL, DBUS_TYPE_INVALID);
1647
1648         if (result != OSSO_OK) {
1649                 g_warning ("%s: osso_rpc_run_with_defaults() failed.\n", __FUNCTION__);
1650         }
1651 }
1652
1653 void
1654 modest_platform_show_addressbook (GtkWindow *parent_window)
1655 {
1656         osso_return_t result = OSSO_ERROR;
1657
1658         result = osso_rpc_run_with_defaults (modest_maemo_utils_get_osso_context(),
1659                                              "osso_addressbook",
1660                                              "top_application", NULL, DBUS_TYPE_INVALID);
1661
1662         if (result != OSSO_OK) {
1663                 g_warning ("%s: osso_rpc_run_with_defaults() failed.\n", __FUNCTION__);
1664         }
1665 }
1666
1667 GtkWidget *
1668 modest_platform_create_folder_view (TnyFolderStoreQuery *query)
1669 {
1670         GtkWidget *widget = modest_folder_view_new (query);
1671
1672         /* Show one account by default */
1673         modest_folder_view_set_style (MODEST_FOLDER_VIEW (widget),
1674                                       MODEST_FOLDER_VIEW_STYLE_SHOW_ONE);
1675
1676         /* Restore settings */
1677         modest_widget_memory_restore (modest_runtime_get_conf(),
1678                                       G_OBJECT (widget),
1679                                       MODEST_CONF_FOLDER_VIEW_KEY);
1680
1681         return widget;
1682 }
1683
1684 void
1685 banner_finish (gpointer data, GObject *object)
1686 {
1687         ModestWindowMgr *mgr = (ModestWindowMgr *) data;
1688         modest_window_mgr_unregister_banner (mgr);
1689         g_object_unref (mgr);
1690 }
1691
1692 void
1693 modest_platform_information_banner (GtkWidget *parent,
1694                                     const gchar *icon_name,
1695                                     const gchar *text)
1696 {
1697         GtkWidget *banner, *banner_parent = NULL;
1698         ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
1699
1700         if (modest_window_mgr_get_num_windows (mgr) == 0)
1701                 return;
1702
1703         if (parent && GTK_IS_WINDOW (parent)) {
1704                 /* If the window is the active one then show the
1705                    banner on top of this window */
1706                 if (gtk_window_is_active (GTK_WINDOW (parent)))
1707                         banner_parent = parent;
1708                 /* If the window is not the topmost but it's visible
1709                    (it's minimized for example) then show the banner
1710                    with no parent */
1711                 else if (GTK_WIDGET_VISIBLE (parent))
1712                         banner_parent = NULL;
1713                 /* If the window is hidden (like the main window when
1714                    running in the background) then do not show
1715                    anything */
1716                 else
1717                         return;
1718         }
1719
1720
1721         banner = hildon_banner_show_information (banner_parent, icon_name, text);
1722
1723         modest_window_mgr_register_banner (mgr);
1724         g_object_ref (mgr);
1725         g_object_weak_ref ((GObject *) banner, banner_finish, mgr);
1726 }
1727
1728 void
1729 modest_platform_information_banner_with_timeout (GtkWidget *parent,
1730                                                  const gchar *icon_name,
1731                                                  const gchar *text,
1732                                                  gint timeout)
1733 {
1734         GtkWidget *banner;
1735
1736         if (modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()) == 0)
1737                 return;
1738
1739         banner = hildon_banner_show_information (parent, icon_name, text);
1740         hildon_banner_set_timeout(HILDON_BANNER(banner), timeout);
1741 }
1742
1743 GtkWidget *
1744 modest_platform_animation_banner (GtkWidget *parent,
1745                                   const gchar *animation_name,
1746                                   const gchar *text)
1747 {
1748         GtkWidget *inf_note = NULL;
1749
1750         g_return_val_if_fail (text != NULL, NULL);
1751
1752         if (modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()) == 0)
1753                 return NULL;
1754
1755         /* If the parent is not visible then do not show */
1756         if (parent && !GTK_WIDGET_VISIBLE (parent))
1757                 return NULL;
1758
1759         inf_note = hildon_banner_show_animation (parent, animation_name, text);
1760
1761         return inf_note;
1762 }
1763
1764 typedef struct
1765 {
1766         GMainLoop* loop;
1767         TnyAccount *account;
1768         gboolean is_online;
1769         gint count_tries;
1770 } CheckAccountIdleData;
1771
1772 #define NUMBER_OF_TRIES 10 /* Try approx every second, ten times. */
1773
1774 static gboolean
1775 on_timeout_check_account_is_online(CheckAccountIdleData* data)
1776 {
1777         gboolean stop_trying = FALSE;
1778         g_return_val_if_fail (data && data->account, FALSE);
1779
1780         printf ("DEBUG: %s: tny_account_get_connection_status()==%d\n", __FUNCTION__,
1781                 tny_account_get_connection_status (data->account));
1782
1783         if (data && data->account &&
1784                 /* We want to wait until TNY_CONNECTION_STATUS_INIT has changed to something else,
1785                  * after which the account is likely to be usable, or never likely to be usable soon: */
1786                 (tny_account_get_connection_status (data->account) != TNY_CONNECTION_STATUS_INIT) )
1787         {
1788                 data->is_online = TRUE;
1789
1790                 stop_trying = TRUE;
1791         } else {
1792                 /* Give up if we have tried too many times: */
1793                 if (data->count_tries >= NUMBER_OF_TRIES) {
1794                         stop_trying = TRUE;
1795                 } else {
1796                         /* Wait for another timeout: */
1797                         ++(data->count_tries);
1798                 }
1799         }
1800
1801         if (stop_trying) {
1802                 /* Allow the function that requested this idle callback to continue: */
1803                 if (data->loop)
1804                         g_main_loop_quit (data->loop);
1805
1806                 if (data->account)
1807                         g_object_unref (data->account);
1808
1809                 return FALSE; /* Don't call this again. */
1810         } else {
1811                 return TRUE; /* Call this timeout callback again. */
1812         }
1813 }
1814
1815 /* Return TRUE immediately if the account is already online,
1816  * otherwise check every second for NUMBER_OF_TRIES seconds and return TRUE as
1817  * soon as the account is online, or FALSE if the account does
1818  * not become online in the NUMBER_OF_TRIES seconds.
1819  * This is useful when the D-Bus method was run immediately after
1820  * the application was started (when using D-Bus activation),
1821  * because the account usually takes a short time to go online.
1822  * The return value is maybe not very useful.
1823  */
1824 gboolean
1825 modest_platform_check_and_wait_for_account_is_online(TnyAccount *account)
1826 {
1827         gboolean is_online;
1828
1829         g_return_val_if_fail (account, FALSE);
1830
1831         if (!tny_device_is_online (modest_runtime_get_device())) {
1832                 printf ("DEBUG: %s: device is offline.\n", __FUNCTION__);
1833                 return FALSE;
1834         }
1835
1836         /* The local_folders account never seems to leave TNY_CONNECTION_STATUS_INIT,
1837          * so we avoid wait unnecessarily: */
1838         if (!modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account)))
1839                 return TRUE;
1840
1841         /* The POP & IMAP store accounts seem to be TNY_CONNECTION_STATUS_DISCONNECTED,
1842          * and that seems to be an OK time to use them. Maybe it's just TNY_CONNECTION_STATUS_INIT that
1843          * we want to avoid. */
1844         if (tny_account_get_connection_status (account) != TNY_CONNECTION_STATUS_INIT)
1845                 return TRUE;
1846
1847         /* This blocks on the result: */
1848         CheckAccountIdleData *data = g_slice_new0 (CheckAccountIdleData);
1849         data->is_online = FALSE;
1850         data->account = account;
1851         g_object_ref (data->account);
1852         data->count_tries = 0;
1853
1854         GMainContext *context = NULL; /* g_main_context_new (); */
1855         data->loop = g_main_loop_new (context, FALSE /* not running */);
1856
1857         g_timeout_add (1000, (GSourceFunc)(on_timeout_check_account_is_online), data);
1858
1859         /* This main loop will run until the idle handler has stopped it: */
1860         g_main_loop_run (data->loop);
1861
1862         g_main_loop_unref (data->loop);
1863         /* g_main_context_unref (context); */
1864
1865         is_online = data->is_online;
1866         g_slice_free (CheckAccountIdleData, data);
1867
1868         return is_online;
1869 }
1870
1871
1872
1873 static void
1874 on_cert_dialog_response (GtkDialog *dialog, gint response_id,  const gchar* cert)
1875 {
1876         /* GTK_RESPONSE_HELP means we need to show the certificate */
1877         if (response_id == GTK_RESPONSE_APPLY) {
1878                 GtkWidget *note;
1879                 gchar *msg;
1880
1881                 /* Do not close the dialog */
1882                 g_signal_stop_emission_by_name (dialog, "response");
1883
1884                 msg = g_strdup_printf (_("mcen_ni_view_unknown_certificate"), cert);
1885                 note = hildon_note_new_information (GTK_WINDOW(dialog), msg);
1886                 gtk_dialog_run (GTK_DIALOG(note));
1887                 gtk_widget_destroy (note);
1888         }
1889 }
1890
1891
1892 gboolean
1893 modest_platform_run_certificate_confirmation_dialog (const gchar* server_name,
1894                                                      const gchar *certificate)
1895 {
1896         GtkWidget *note;
1897         gint response;
1898         ModestWindow *win;
1899         HildonWindowStack *stack;
1900
1901         stack = hildon_window_stack_get_default ();
1902         win = MODEST_WINDOW (hildon_window_stack_peek (stack));
1903
1904         if (!win) {
1905           g_warning ("%s: don't show dialogs if there's no window shown; assuming 'Cancel'",
1906                            __FUNCTION__);
1907                 return FALSE;
1908         }
1909
1910         gchar *question = g_strdup_printf (_("mcen_nc_unknown_certificate"),
1911                                            server_name);
1912
1913         /* We use GTK_RESPONSE_APPLY because we want the button in the
1914            middle of OK and CANCEL the same as the browser does for
1915            example. With GTK_RESPONSE_HELP the view button is aligned
1916            to the left while the other two to the right */
1917         note = hildon_note_new_confirmation_add_buttons  (
1918                 NULL,
1919                 question,
1920                 _HL("wdgt_bd_yes"),     GTK_RESPONSE_OK,
1921                 _HL("wdgt_bd_view"),          GTK_RESPONSE_APPLY,   /* abusing this... */
1922                 _HL("wdgt_bd_no"), GTK_RESPONSE_CANCEL,
1923                 NULL, NULL);
1924
1925         g_signal_connect (G_OBJECT(note), "response",
1926                           G_CALLBACK(on_cert_dialog_response),
1927                           (gpointer) certificate);
1928
1929         response = gtk_dialog_run(GTK_DIALOG(note));
1930
1931         on_destroy_dialog (note);
1932         g_free (question);
1933
1934         return response == GTK_RESPONSE_OK;
1935 }
1936
1937 gboolean
1938 modest_platform_run_alert_dialog (const gchar* prompt,
1939                                   gboolean is_question)
1940 {
1941         ModestWindow *top_win;
1942         HildonWindowStack *stack;
1943
1944         stack = hildon_window_stack_get_default ();
1945         top_win = MODEST_WINDOW (hildon_window_stack_peek (stack));
1946
1947         if (!top_win) {
1948                 g_warning ("%s: don't show dialogs if there's no window shown; assuming 'Cancel'",
1949                            __FUNCTION__);
1950                 return FALSE;
1951         }
1952
1953         gboolean retval = TRUE;
1954         if (is_question) {
1955                 /* The Tinymail documentation says that we should show Yes and No buttons,
1956                  * when it is a question.
1957                  * Obviously, we need tinymail to use more specific error codes instead,
1958                  * so we know what buttons to show. */
1959                 GtkWidget *dialog = GTK_WIDGET (hildon_note_new_confirmation (GTK_WINDOW (top_win),
1960                                                                               prompt));
1961                 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1962                                              GTK_WINDOW (dialog), GTK_WINDOW (top_win));
1963
1964                 const int response = gtk_dialog_run (GTK_DIALOG (dialog));
1965                 retval = (response == GTK_RESPONSE_YES) || (response == GTK_RESPONSE_OK);
1966
1967                 on_destroy_dialog (dialog);
1968         } else {
1969                 /* Just show the error text and use the default response: */
1970                 modest_platform_run_information_dialog (GTK_WINDOW (top_win),
1971                                                         prompt, FALSE);
1972         }
1973         return retval;
1974 }
1975
1976 /***************/
1977 typedef struct {
1978         GtkWindow *parent_window;
1979         ModestConnectedPerformer callback;
1980         TnyAccount *account;
1981         gpointer user_data;
1982         gchar *iap;
1983         TnyDevice *device;
1984 } OnWentOnlineInfo;
1985
1986 static void
1987 on_went_online_info_free (OnWentOnlineInfo *info)
1988 {
1989         /* And if we cleanup, we DO cleanup  :-)  */
1990
1991         if (info->device)
1992                 g_object_unref (info->device);
1993         if (info->iap)
1994                 g_free (info->iap);
1995         if (info->parent_window)
1996                 g_object_unref (info->parent_window);
1997         if (info->account)
1998                 g_object_unref (info->account);
1999
2000         g_slice_free (OnWentOnlineInfo, info);
2001
2002         /* We're done ... */
2003
2004         return;
2005 }
2006
2007 static void
2008 on_account_went_online (TnyCamelAccount *account, gboolean canceled, GError *err, gpointer user_data)
2009 {
2010         OnWentOnlineInfo *info = (OnWentOnlineInfo *) user_data;
2011
2012         /* Now it's really time to callback to the caller. If going online didn't succeed,
2013          * err will be set. We don't free it, Tinymail does that! If a cancel happened,
2014          * canceled will be set. Etcetera etcetera. */
2015
2016         if (info->callback) {
2017                 info->callback (canceled, err, info->parent_window, info->account, info->user_data);
2018         }
2019
2020         /* This is our last call, we must cleanup here if we didn't yet do that */
2021         on_went_online_info_free (info);
2022
2023         return;
2024 }
2025
2026
2027 static void
2028 on_conic_device_went_online (TnyMaemoConicDevice *device, const gchar* iap_id, gboolean canceled, GError *err, gpointer user_data)
2029 {
2030         OnWentOnlineInfo *info = (OnWentOnlineInfo *) user_data;
2031         info->iap = g_strdup (iap_id);
2032
2033         if (canceled || err || !info->account) {
2034
2035                 /* If there's a problem or if there's no account (then that's it for us, we callback
2036                  * the caller's callback now. He'll have to handle err or canceled, of course.
2037                  * We are not really online, as the account is not really online here ... */
2038
2039                 /* We'll use the err and the canceled of this cb. TnyMaemoConicDevice delivered us
2040                  * this info. We don't cleanup err, Tinymail does that! */
2041
2042                 if (info->callback) {
2043
2044                         /* info->account can be NULL here, this means that the user did not
2045                          * provide a nice account instance. We'll assume that the user knows
2046                          * what he's doing and is happy with just the device going online.
2047                          *
2048                          * We can't do magic, we don't know what account the user wants to
2049                          * see going online. So just the device goes online, end of story */
2050
2051                         info->callback (canceled, err, info->parent_window, info->account, info->user_data);
2052                 }
2053
2054         } else if (info->account) {
2055
2056                 /* If there's no problem and if we have an account, we'll put the account
2057                  * online too. When done, the callback of bringing the account online
2058                  * will callback the caller's callback. This is the most normal case. */
2059
2060                 info->device = TNY_DEVICE (g_object_ref (device));
2061
2062                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (info->account), TRUE,
2063                                               on_account_went_online, info);
2064
2065                 /* The on_account_went_online cb frees up the info, go look if you
2066                  * don't believe me! (so we return here) */
2067
2068                 return;
2069         }
2070
2071         /* We cleanup if we are not bringing the account online too */
2072         on_went_online_info_free (info);
2073
2074         return;
2075 }
2076
2077 void
2078 modest_platform_connect_and_perform (GtkWindow *parent_window,
2079                                      gboolean force,
2080                                      TnyAccount *account,
2081                                      ModestConnectedPerformer callback,
2082                                      gpointer user_data)
2083 {
2084         gboolean device_online;
2085         TnyDevice *device;
2086         TnyConnectionStatus conn_status;
2087         OnWentOnlineInfo *info;
2088
2089         device = modest_runtime_get_device();
2090         device_online = tny_device_is_online (device);
2091
2092         /* If there is no account check only the device status */
2093         if (!account) {
2094
2095                 if (device_online) {
2096
2097                         /* We promise to instantly perform the callback, so ... */
2098                         if (callback) {
2099                                 callback (FALSE, NULL, parent_window, account, user_data);
2100                         }
2101
2102                 } else {
2103
2104                         info = g_slice_new0 (OnWentOnlineInfo);
2105
2106                         info->iap = NULL;
2107                         info->device = NULL;
2108                         info->account = NULL;
2109
2110                         if (parent_window)
2111                                 info->parent_window = (GtkWindow *) g_object_ref (parent_window);
2112                         else
2113                                 info->parent_window = NULL;
2114                         info->user_data = user_data;
2115                         info->callback = callback;
2116
2117                         tny_maemo_conic_device_connect_async (TNY_MAEMO_CONIC_DEVICE (device), NULL,
2118                                                               force, on_conic_device_went_online,
2119                                                               info);
2120
2121                         /* We'll cleanup in on_conic_device_went_online */
2122                 }
2123
2124                 /* The other code has no more reason to run. This is all that we can do for the
2125                  * caller (he should have given us a nice and clean account instance!). We
2126                  * can't do magic, we don't know what account he intends to bring online. So
2127                  * we'll just bring the device online (and await his false bug report). */
2128
2129                 return;
2130         }
2131
2132
2133         /* Return if the account is already connected */
2134
2135         conn_status = tny_account_get_connection_status (account);
2136         if (device_online && conn_status == TNY_CONNECTION_STATUS_CONNECTED) {
2137
2138                 /* We promise to instantly perform the callback, so ... */
2139                 if (callback) {
2140                         callback (FALSE, NULL, parent_window, account, user_data);
2141                 }
2142
2143                 return;
2144         }
2145
2146         /* Else, we are in a state that requires that we go online before we
2147          * call the caller's callback. */
2148
2149         info = g_slice_new0 (OnWentOnlineInfo);
2150
2151         info->device = NULL;
2152         info->iap = NULL;
2153         info->account = TNY_ACCOUNT (g_object_ref (account));
2154
2155         if (parent_window)
2156                 info->parent_window = (GtkWindow *) g_object_ref (parent_window);
2157         else
2158                 info->parent_window = NULL;
2159
2160         /* So we'll put the callback away for later ... */
2161
2162         info->user_data = user_data;
2163         info->callback = callback;
2164
2165         if (!device_online) {
2166
2167                 /* If also the device is offline, then we connect both the device
2168                  * and the account */
2169
2170                 tny_maemo_conic_device_connect_async (TNY_MAEMO_CONIC_DEVICE (device), NULL,
2171                                                       force, on_conic_device_went_online,
2172                                                       info);
2173
2174         } else {
2175
2176                 /* If the device is online, we'll just connect the account */
2177
2178                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (account), TRUE,
2179                                               on_account_went_online, info);
2180         }
2181
2182         /* The info gets freed by on_account_went_online or on_conic_device_went_online
2183          * in both situations, go look if you don't believe me! */
2184
2185         return;
2186 }
2187
2188 void
2189 modest_platform_connect_if_remote_and_perform (GtkWindow *parent_window,
2190                                                gboolean force,
2191                                                TnyFolderStore *folder_store,
2192                                                ModestConnectedPerformer callback,
2193                                                gpointer user_data)
2194 {
2195         TnyAccount *account = NULL;
2196
2197         if (!folder_store ||
2198             (TNY_IS_MERGE_FOLDER (folder_store) &&
2199              (tny_folder_get_folder_type (TNY_FOLDER(folder_store)) == TNY_FOLDER_TYPE_OUTBOX))) {
2200
2201                 /* We promise to instantly perform the callback, so ... */
2202                 if (callback) {
2203                         GError *error = NULL;
2204                         g_set_error (&error, TNY_ERROR_DOMAIN, TNY_SERVICE_ERROR_UNKNOWN,
2205                                      "Unable to move or not found folder");
2206                         callback (FALSE, error, parent_window, NULL, user_data);
2207                         g_error_free (error);
2208                 }
2209                 return;
2210
2211         } else if (TNY_IS_FOLDER (folder_store)) {
2212                 /* Get the folder's parent account: */
2213                 account = tny_folder_get_account (TNY_FOLDER (folder_store));
2214         } else if (TNY_IS_ACCOUNT (folder_store)) {
2215                 /* Use the folder store as an account: */
2216                 account = TNY_ACCOUNT (g_object_ref (folder_store));
2217         }
2218
2219         if (tny_account_get_account_type (account) == TNY_ACCOUNT_TYPE_STORE) {
2220                 if (!modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account))) {
2221                         /* No need to connect a local account */
2222                         if (callback)
2223                                 callback (FALSE, NULL, parent_window, account, user_data);
2224
2225                         goto clean;
2226                 }
2227         }
2228         modest_platform_connect_and_perform (parent_window, force, account, callback, user_data);
2229
2230  clean:
2231         if (account)
2232                 g_object_unref (account);
2233 }
2234
2235 static void
2236 src_account_connect_performer (gboolean canceled,
2237                                GError *err,
2238                                GtkWindow *parent_window,
2239                                TnyAccount *src_account,
2240                                gpointer user_data)
2241 {
2242         DoubleConnectionInfo *info = (DoubleConnectionInfo *) user_data;
2243
2244         if (canceled || err) {
2245                 /* If there was any error call the user callback */
2246                 info->callback (canceled, err, parent_window, src_account, info->data);
2247         } else {
2248                 /* Connect the destination account */
2249                 modest_platform_connect_if_remote_and_perform (parent_window, TRUE,
2250                                                                TNY_FOLDER_STORE (info->dst_account),
2251                                                                info->callback, info->data);
2252         }
2253
2254         /* Free the info object */
2255         g_object_unref (info->dst_account);
2256         g_slice_free (DoubleConnectionInfo, info);
2257 }
2258
2259
2260 void
2261 modest_platform_double_connect_and_perform (GtkWindow *parent_window,
2262                                             gboolean force,
2263                                             TnyFolderStore *folder_store,
2264                                             DoubleConnectionInfo *connect_info)
2265 {
2266         modest_platform_connect_if_remote_and_perform(parent_window,
2267                                                       force,
2268                                                       folder_store,
2269                                                       src_account_connect_performer,
2270                                                       connect_info);
2271 }
2272
2273 GtkWidget *
2274 modest_platform_get_account_settings_wizard (void)
2275 {
2276         ModestEasysetupWizardDialog *dialog = modest_easysetup_wizard_dialog_new ();
2277
2278         return GTK_WIDGET (dialog);
2279 }
2280
2281 ModestConnectedVia
2282 modest_platform_get_current_connection (void)
2283 {
2284         TnyDevice *device = NULL;
2285         ModestConnectedVia retval = MODEST_CONNECTED_VIA_ANY;
2286
2287         device = modest_runtime_get_device ();
2288
2289         if (!tny_device_is_online (device))
2290                 return MODEST_CONNECTED_VIA_ANY;
2291
2292 #ifdef MODEST_HAVE_CONIC
2293         /* Get iap id */
2294         const gchar *iap_id = tny_maemo_conic_device_get_current_iap_id (TNY_MAEMO_CONIC_DEVICE (device));
2295         if (iap_id) {
2296                 ConIcIap *iap = tny_maemo_conic_device_get_iap (
2297                         TNY_MAEMO_CONIC_DEVICE (device), iap_id);
2298                 const gchar *bearer_type = con_ic_iap_get_bearer_type (iap);
2299                 if (bearer_type) {
2300                         if (!strcmp (bearer_type, CON_IC_BEARER_WLAN_INFRA) ||
2301                             !strcmp (bearer_type, CON_IC_BEARER_WLAN_ADHOC) ||
2302                             !strcmp (bearer_type, "WIMAX")) {
2303                                 retval = MODEST_CONNECTED_VIA_WLAN_OR_WIMAX;
2304                         } else {
2305                                 retval = MODEST_CONNECTED_VIA_ANY;
2306                         }
2307                 }
2308                 g_object_unref (iap);
2309         }
2310 #else
2311         retval = MODEST_CONNECTED_VIA_WLAN_OR_WIMAX; /* assume WLAN (fast) internet */
2312 #endif /* MODEST_HAVE_CONIC */
2313         return retval;
2314 }
2315
2316
2317
2318 gboolean
2319 modest_platform_check_memory_low (ModestWindow *win,
2320                                   gboolean visuals)
2321 {
2322         gboolean lowmem;
2323
2324         /* are we in low memory state? */
2325         lowmem = osso_mem_in_lowmem_state () ? TRUE : FALSE;
2326
2327         if (win && lowmem && visuals)
2328                 modest_platform_run_information_dialog (
2329                         GTK_WINDOW(win),
2330                         _KR("memr_ib_operation_disabled"),
2331                         TRUE);
2332
2333         if (lowmem)
2334                 g_debug ("%s: low memory reached. disallowing some operations",
2335                          __FUNCTION__);
2336
2337         return lowmem;
2338 }
2339
2340 void
2341 modest_platform_run_folder_details_dialog (GtkWindow *parent_window,
2342                                            TnyFolder *folder)
2343 {
2344         GtkWidget *dialog;
2345
2346         /* Create dialog */
2347         dialog = modest_hildon2_details_dialog_new_with_folder (parent_window, folder);
2348
2349         /* Run dialog */
2350         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
2351                                      GTK_WINDOW (dialog),
2352                                      parent_window);
2353         gtk_widget_show_all (dialog);
2354
2355         g_signal_connect_swapped (dialog, "response",
2356                                   G_CALLBACK (gtk_widget_destroy),
2357                                   dialog);
2358 }
2359
2360 void
2361 modest_platform_run_header_details_dialog (GtkWindow *parent_window,
2362                                            TnyHeader *header)
2363 {
2364         GtkWidget *dialog;
2365
2366         /* Create dialog */
2367         dialog = modest_hildon2_details_dialog_new_with_header (parent_window, header);
2368
2369         /* Run dialog */
2370         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
2371                                      GTK_WINDOW (dialog),
2372                                      parent_window);
2373         gtk_widget_show_all (dialog);
2374
2375         g_signal_connect_swapped (dialog, "response",
2376                                   G_CALLBACK (gtk_widget_destroy),
2377                                   dialog);
2378 }
2379
2380 osso_context_t *
2381 modest_platform_get_osso_context (void)
2382 {
2383         return modest_maemo_utils_get_osso_context ();
2384 }
2385
2386 static void
2387 _modest_platform_play_email_tone (void)
2388 {
2389         gchar *active_profile;
2390         gchar *mail_tone;
2391         gchar *mail_volume;
2392         gint mail_volume_int;
2393         int ret;
2394         ca_context *ca_con = NULL;
2395         ca_proplist *pl = NULL;
2396
2397         active_profile = profile_get_profile ();
2398         mail_tone = profile_get_value (active_profile, PROFILE_MAIL_TONE);
2399         mail_volume = profile_get_value (active_profile, PROFILE_MAIL_VOLUME);
2400         mail_volume_int = profile_parse_int (mail_volume);
2401
2402         if (mail_volume_int > 0) {
2403
2404                 if ((ret = ca_context_create(&ca_con)) != CA_SUCCESS) {
2405                         g_warning("ca_context_create: %s\n", ca_strerror(ret));
2406                         return;
2407                 }
2408
2409                 if ((ret = ca_context_open(ca_con)) != CA_SUCCESS) {
2410                         g_warning("ca_context_open: %s\n", ca_strerror(ret));
2411                         ca_context_destroy(ca_con);
2412                         return;
2413                 }
2414
2415                 ca_proplist_create(&pl);
2416                 ca_proplist_sets(pl, CA_PROP_MEDIA_FILENAME, mail_tone);
2417                 ca_proplist_setf(pl, CA_PROP_CANBERRA_VOLUME, "%f", (gfloat) mail_volume_int);
2418
2419                 ret = ca_context_play_full(ca_con, 0, pl, NULL, NULL);
2420                 g_debug("ca_context_play_full (vol %f): %s\n", (gfloat) mail_volume_int, ca_strerror(ret));
2421
2422                 ca_proplist_destroy(pl);
2423                 ca_context_destroy(ca_con);
2424         }
2425
2426         g_free (mail_volume);
2427         g_free (mail_tone);
2428         g_free (active_profile);
2429 }
2430
2431 static void
2432 on_move_to_dialog_folder_activated (GtkTreeView       *tree_view,
2433                                     GtkTreePath       *path,
2434                                     GtkTreeViewColumn *column,
2435                                     gpointer           user_data)
2436 {
2437         gtk_dialog_response (GTK_DIALOG (user_data), GTK_RESPONSE_OK);
2438 }
2439
2440 GtkWidget *
2441 modest_platform_create_move_to_dialog (GtkWindow *parent_window,
2442                                        GtkWidget **folder_view)
2443 {
2444         GtkWidget *dialog, *folder_view_container;
2445
2446         /* Create dialog. We cannot use a touch selector because we
2447            need to use here the folder view widget directly */
2448         dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
2449                                               GTK_WINDOW (parent_window),
2450                                               GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR |
2451                                               GTK_DIALOG_DESTROY_WITH_PARENT,
2452                                               _HL("wdgt_bd_new"), MODEST_GTK_RESPONSE_NEW_FOLDER,
2453                                               NULL);
2454
2455         /* Create folder view */
2456         *folder_view = modest_platform_create_folder_view (NULL);
2457
2458         /* Simulate the behaviour of a HildonPickerDialog by emitting
2459            a response when a folder is selected */
2460         g_signal_connect (*folder_view, "row-activated",
2461                           G_CALLBACK (on_move_to_dialog_folder_activated),
2462                           dialog);
2463
2464         tny_account_store_view_set_account_store (TNY_ACCOUNT_STORE_VIEW (*folder_view),
2465                                                   (TnyAccountStore *) modest_runtime_get_account_store ());
2466
2467         /* Create pannable and add it to the dialog */
2468         folder_view_container = hildon_pannable_area_new ();
2469         gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), folder_view_container);
2470         gtk_container_add (GTK_CONTAINER (folder_view_container), *folder_view);
2471
2472         gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 300);
2473
2474         gtk_widget_show (GTK_DIALOG (dialog)->vbox);
2475         gtk_widget_show (folder_view_container);
2476         gtk_widget_show (*folder_view);
2477
2478         return dialog;
2479 }
2480
2481 TnyList *
2482 modest_platform_get_list_to_move (ModestWindow *window)
2483 {
2484         TnyList *list = NULL;
2485
2486         if (MODEST_IS_HEADER_WINDOW (window)) {
2487                 ModestHeaderView *header_view;
2488
2489                 header_view = modest_header_window_get_header_view (MODEST_HEADER_WINDOW (window));
2490                 list = modest_header_view_get_selected_headers (header_view);
2491         } else if (MODEST_IS_FOLDER_WINDOW (window)) {
2492                 ModestFolderView *folder_view;
2493                 TnyFolderStore *selected_folder;
2494
2495                 list = TNY_LIST (tny_simple_list_new ());
2496                 folder_view = modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window));
2497                 selected_folder = modest_folder_view_get_selected (folder_view);
2498                 if (selected_folder) {
2499                         tny_list_prepend (list, G_OBJECT (selected_folder));
2500                         g_object_unref (selected_folder);
2501                 }
2502                 return list;
2503         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
2504                 TnyHeader *header;
2505
2506                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (window));
2507                 if (header) {
2508                         list = TNY_LIST (tny_simple_list_new ());
2509                         tny_list_prepend (list, G_OBJECT (header));
2510                         g_object_unref (header);
2511                 }
2512         } else {
2513                 g_return_val_if_reached (NULL);
2514         }
2515
2516         return list;
2517 }