git.maemo.org Git - modest/blob - src/hildon2/modest-platform.c

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