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         cookie_t alarm_cookie = modest_conf_get_int (conf, MODEST_CONF_ALARM_ID, NULL);
1492
1493         /* Delete any existing alarm,
1494          * because we will replace it: */
1495         if (alarm_cookie) {
1496                 if (alarmd_event_del(alarm_cookie) != 0)
1497                         g_debug ("%s: alarm %d was not on the queue", __FUNCTION__, (int)alarm_cookie);
1498                 alarm_cookie = 0;
1499                 modest_conf_set_int (conf, MODEST_CONF_ALARM_ID, 0, NULL);
1500         }
1501
1502         /* 0 means no updates: */
1503         if (minutes == 0)
1504                 return TRUE;
1505
1506
1507         /* Register alarm: */
1508
1509         /* Set the interval in alarm_event_t structure: */
1510         alarm_event_t *event = alarm_event_create ();
1511         alarm_event_add_actions (event, 1);
1512         alarm_action_t *action = alarm_event_get_action (event, 0);
1513         alarm_event_set_alarm_appid (event, MODEST_ALARMD_APPID);
1514         event->alarm_time = minutes * 60; /* seconds */
1515
1516         /* Set recurrence every few minutes: */
1517         event->recur_secs = minutes*60;
1518         event->recur_count = -1; /* Means infinite */
1519
1520         /* Specify what should happen when the alarm happens:
1521          * It should call this D-Bus method: */
1522
1523         action->dbus_path = g_strdup(MODEST_DBUS_OBJECT);
1524         action->dbus_interface = g_strdup (MODEST_DBUS_IFACE);
1525         action->dbus_service = g_strdup (MODEST_DBUS_SERVICE);
1526         action->dbus_name = g_strdup (MODEST_DBUS_METHOD_SEND_RECEIVE);
1527         action->flags = ALARM_ACTION_WHEN_TRIGGERED | ALARM_ACTION_TYPE_DBUS | ALARM_ACTION_DBUS_USE_ACTIVATION;
1528
1529         /* Use ALARM_EVENT_NO_DIALOG: Otherwise, a dialog will be shown if
1530          * exec_name or dbus_path is NULL, even though we have specified no dialog text.
1531          * Also use ALARM_EVENT_ACTIVATION so that modest is started (without UI) to get emails
1532          * This is why we want to use the Alarm API instead of just g_timeout_add().
1533          * (The old maemo email-client did this, though it isn't specified in the UI spec.)
1534          * ALARM_EVENT_CONNECTED will prevent the alarm from being called in case that the device is offline
1535          */
1536         event->flags = ALARM_EVENT_CONNECTED;
1537
1538         alarm_cookie = alarmd_event_add (event);
1539
1540         /* now, free it */
1541         alarm_event_delete (event);
1542
1543         /* Store the alarm ID in GConf, so we can remove it later:
1544          * This is apparently valid between application instances. */
1545         modest_conf_set_int (conf, MODEST_CONF_ALARM_ID, alarm_cookie, NULL);
1546
1547         if (!alarm_cookie) {
1548             /* Error */
1549             g_warning ("Error setting alarm event. \n");
1550
1551             return FALSE;
1552         }
1553 #endif /* MODEST_HAVE_LIBALARM */
1554         return TRUE;
1555 }
1556
1557 void
1558 modest_platform_push_email_notification(void)
1559 {
1560         gboolean screen_on, app_in_foreground;
1561
1562         /* Get the window status */
1563         app_in_foreground = hildon_program_get_is_topmost (hildon_program_get_instance ());
1564
1565         screen_on = modest_window_mgr_screen_is_on (modest_runtime_get_window_mgr ());
1566
1567         /* If the screen is on and the app is in the
1568            foreground we don't show anything */
1569         if (!(screen_on && app_in_foreground)) {
1570
1571                 modest_platform_play_email_tone ();
1572
1573                 /* Activate LED. This must be deactivated by
1574                    modest_platform_remove_new_mail_notifications */
1575 #ifdef MODEST_HAVE_MCE
1576                 osso_rpc_run_system (modest_maemo_utils_get_osso_context (),
1577                                      MCE_SERVICE,
1578                                      MCE_REQUEST_PATH,
1579                                      MCE_REQUEST_IF,
1580                                      MCE_ACTIVATE_LED_PATTERN,
1581                                      NULL,
1582                                      DBUS_TYPE_STRING, MODEST_NEW_MAIL_LIGHTING_PATTERN,
1583                                      DBUS_TYPE_INVALID);
1584 #endif
1585         }
1586 }
1587
1588 void
1589 modest_platform_on_new_headers_received (GList *URI_list,
1590                                          gboolean show_visual)
1591 {
1592         gboolean screen_on, app_in_foreground;
1593
1594         /* Get the window status */
1595         app_in_foreground = hildon_program_get_is_topmost (hildon_program_get_instance ());
1596         screen_on = modest_window_mgr_screen_is_on (modest_runtime_get_window_mgr ());
1597
1598         /* If the screen is on and the app is in the
1599            foreground we don't show anything */
1600         if (screen_on && app_in_foreground)
1601                 return;
1602
1603         if (g_list_length (URI_list) == 0)
1604                 return;
1605
1606 #ifdef MODEST_HAVE_HILDON_NOTIFY
1607         /* For any other case issue a notification */
1608         HildonNotification *notification;
1609         ModestMsgNotificationData *data;
1610         gint notif_id;
1611         gchar *from;
1612         TnyAccountStore *acc_store;
1613         TnyAccount *account;
1614
1615         data = (ModestMsgNotificationData *) URI_list->data;
1616
1617         /* String is changed in-place. There is no need to
1618            actually dup the data->from string but we just do
1619            it in order not to modify the original contents */
1620         from = g_strdup (data->from);
1621         modest_text_utils_get_display_address (from);
1622
1623         /* Create notification */
1624         notification = hildon_notification_new (from,
1625                                                 data->subject,
1626                                                 "qgn_list_messagin",
1627                                                 MODEST_NOTIFICATION_CATEGORY);
1628         g_free (from);
1629
1630         /* Add DBus action */
1631         hildon_notification_add_dbus_action(notification,
1632                                             "default",
1633                                             "Cancel",
1634                                             MODEST_DBUS_SERVICE,
1635                                             MODEST_DBUS_OBJECT,
1636                                             MODEST_DBUS_IFACE,
1637                                             MODEST_DBUS_METHOD_OPEN_MESSAGE,
1638                                             G_TYPE_STRING, data->uri,
1639                                             -1);
1640
1641         /* Set the led pattern */
1642         notify_notification_set_hint_int32 (NOTIFY_NOTIFICATION (notification),
1643                                             "dialog-type", 4);
1644         notify_notification_set_hint_string(NOTIFY_NOTIFICATION (notification),
1645                                             "led-pattern",
1646                                             MODEST_NEW_MAIL_LIGHTING_PATTERN);
1647
1648         /* Make the notification persistent */
1649         notify_notification_set_hint_byte (NOTIFY_NOTIFICATION (notification),
1650                                            "persistent", TRUE);
1651
1652         /* Set the number of new notifications */
1653         notify_notification_set_hint_int32 (NOTIFY_NOTIFICATION (notification),
1654                                             "amount", g_list_length (URI_list));
1655
1656         /* Set the account of the headers */
1657         acc_store = (TnyAccountStore *) modest_runtime_get_account_store ();
1658         account = tny_account_store_find_account (acc_store, data->uri);
1659         if (account) {
1660                 const gchar *acc_name;
1661                 acc_name =
1662                         modest_tny_account_get_parent_modest_account_name_for_server_account (account);
1663                 notify_notification_set_hint_string(NOTIFY_NOTIFICATION (notification),
1664                                                     "email-account",
1665                                                     acc_name);
1666                 g_object_unref (account);
1667         }
1668
1669         /* Play sound */
1670         modest_platform_play_email_tone ();
1671         if (notify_notification_show (NOTIFY_NOTIFICATION (notification), NULL)) {
1672                 GSList *notifications_list = NULL;
1673
1674                 /* Get previous notifications ids */
1675                 notifications_list = modest_conf_get_list (modest_runtime_get_conf (),
1676                                                            MODEST_CONF_NOTIFICATION_IDS,
1677                                                            MODEST_CONF_VALUE_INT, NULL);
1678
1679                 /* Save id in the list */
1680                 g_object_get(G_OBJECT (notification), "id", &notif_id, NULL);
1681                 notifications_list = g_slist_prepend (notifications_list, GINT_TO_POINTER(notif_id));
1682
1683                 /* We don't listen for the "closed" signal, because we
1684                    don't care about if the notification was removed or
1685                    not to store the list in gconf */
1686
1687                 /* Save the ids */
1688                 modest_conf_set_list (modest_runtime_get_conf (), MODEST_CONF_NOTIFICATION_IDS,
1689                                       notifications_list, MODEST_CONF_VALUE_INT, NULL);
1690
1691                 g_slist_free (notifications_list);
1692         } else {
1693                 g_warning ("Failed to send notification");
1694         }
1695
1696 #endif /*MODEST_HAVE_HILDON_NOTIFY*/
1697 }
1698
1699 void
1700 modest_platform_remove_new_mail_notifications (gboolean only_visuals)
1701 {
1702         if (only_visuals) {
1703 #ifdef MODEST_HAVE_MCE
1704                 osso_rpc_run_system (modest_maemo_utils_get_osso_context (),
1705                                      MCE_SERVICE,
1706                                      MCE_REQUEST_PATH,
1707                                      MCE_REQUEST_IF,
1708                                      MCE_DEACTIVATE_LED_PATTERN,
1709                                      NULL,
1710                                      DBUS_TYPE_STRING, MODEST_NEW_MAIL_LIGHTING_PATTERN,
1711                                      DBUS_TYPE_INVALID);
1712 #endif
1713                 return;
1714         }
1715
1716 #ifdef MODEST_HAVE_HILDON_NOTIFY
1717         GSList *notif_list = NULL;
1718
1719         /* Get previous notifications ids */
1720         notif_list = modest_conf_get_list (modest_runtime_get_conf (),
1721                                            MODEST_CONF_NOTIFICATION_IDS,
1722                                            MODEST_CONF_VALUE_INT, NULL);
1723
1724         while (notif_list) {
1725                 gint notif_id;
1726                 NotifyNotification *notif;
1727
1728                 /* Nasty HACK to remove the notifications, set the id
1729                    of the existing ones and then close them */
1730                 notif_id = GPOINTER_TO_INT(notif_list->data);
1731                 notif = notify_notification_new("dummy", NULL, NULL, NULL);
1732                 g_object_set(G_OBJECT(notif), "id", notif_id, NULL);
1733
1734                 /* Close the notification, note that some ids could be
1735                    already invalid, but we don't care because it does
1736                    not fail */
1737                 notify_notification_close(notif, NULL);
1738                 g_object_unref(notif);
1739
1740                 /* Delete the link, it's like going to the next */
1741                 notif_list = g_slist_delete_link (notif_list, notif_list);
1742         }
1743
1744         /* Save the ids */
1745         modest_conf_set_list (modest_runtime_get_conf (), MODEST_CONF_NOTIFICATION_IDS,
1746                               notif_list, MODEST_CONF_VALUE_INT, NULL);
1747
1748         g_slist_free (notif_list);
1749
1750 #endif /* MODEST_HAVE_HILDON_NOTIFY */
1751 }
1752
1753
1754
1755 GtkWidget *
1756 modest_platform_get_global_settings_dialog ()
1757 {
1758         return modest_hildon2_global_settings_dialog_new ();
1759 }
1760
1761 void
1762 modest_platform_show_help (GtkWindow *parent_window,
1763                            const gchar *help_id)
1764 {
1765         return;
1766 }
1767
1768 void
1769 modest_platform_show_search_messages (GtkWindow *parent_window)
1770 {
1771         osso_return_t result = OSSO_ERROR;
1772
1773         result = osso_rpc_run_with_defaults (modest_maemo_utils_get_osso_context(),
1774                                              "osso_global_search",
1775                                              "search_email", NULL, DBUS_TYPE_INVALID);
1776
1777         if (result != OSSO_OK) {
1778                 g_warning ("%s: osso_rpc_run_with_defaults() failed.\n", __FUNCTION__);
1779         }
1780 }
1781
1782 void
1783 modest_platform_show_addressbook (GtkWindow *parent_window)
1784 {
1785         osso_return_t result = OSSO_ERROR;
1786
1787         result = osso_rpc_run_with_defaults (modest_maemo_utils_get_osso_context(),
1788                                              "osso_addressbook",
1789                                              "top_application", NULL, DBUS_TYPE_INVALID);
1790
1791         if (result != OSSO_OK) {
1792                 g_warning ("%s: osso_rpc_run_with_defaults() failed.\n", __FUNCTION__);
1793         }
1794 }
1795
1796 static GtkWidget *
1797 modest_platform_create_folder_view_full (TnyFolderStoreQuery *query, gboolean do_refresh)
1798 {
1799         GtkWidget *widget = modest_folder_view_new_full (query, do_refresh);
1800
1801         /* Show one account by default */
1802         modest_folder_view_set_style (MODEST_FOLDER_VIEW (widget),
1803                                       MODEST_FOLDER_VIEW_STYLE_SHOW_ONE);
1804
1805         return widget;
1806 }
1807
1808 GtkWidget *
1809 modest_platform_create_folder_view (TnyFolderStoreQuery *query)
1810 {
1811         return modest_platform_create_folder_view_full (query, TRUE);
1812 }
1813
1814 void
1815 banner_finish (gpointer data, GObject *object)
1816 {
1817         ModestWindowMgr *mgr = (ModestWindowMgr *) data;
1818         modest_window_mgr_unregister_banner (mgr);
1819         g_object_unref (mgr);
1820 }
1821
1822 void
1823 modest_platform_information_banner (GtkWidget *parent,
1824                                     const gchar *icon_name,
1825                                     const gchar *text)
1826 {
1827         GtkWidget *banner_parent = NULL;
1828         ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
1829
1830         if (modest_window_mgr_get_num_windows (mgr) == 0)
1831                 return;
1832
1833         if (parent && GTK_IS_WINDOW (parent)) {
1834                 /* If the window is the active one then show the
1835                    banner on top of this window */
1836                 if (gtk_window_is_active (GTK_WINDOW (parent)))
1837                         banner_parent = parent;
1838                 /* If the window is not the topmost but it's visible
1839                    (it's minimized for example) then show the banner
1840                    with no parent */
1841                 else if (GTK_WIDGET_VISIBLE (parent))
1842                         banner_parent = NULL;
1843                 /* If the window is hidden (like the main window when
1844                    running in the background) then do not show
1845                    anything */
1846                 else
1847                         return;
1848         }
1849
1850         modest_platform_system_banner (banner_parent, icon_name, text);
1851 }
1852
1853 void
1854 modest_platform_system_banner (GtkWidget *parent,
1855                                const gchar *icon_name,
1856                                const gchar *text)
1857 {
1858         GtkWidget *banner = NULL;
1859         ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
1860
1861         if (parent && GTK_IS_WINDOW (parent)) {
1862                 if (!gtk_window_is_active (GTK_WINDOW (parent)))
1863                         parent = NULL;
1864         }
1865
1866         banner = hildon_banner_show_information (parent, icon_name, text);
1867
1868         modest_window_mgr_register_banner (mgr);
1869         g_object_ref (mgr);
1870         g_object_weak_ref ((GObject *) banner, banner_finish, mgr);
1871 }
1872
1873 void
1874 modest_platform_information_banner_with_timeout (GtkWidget *parent,
1875                                                  const gchar *icon_name,
1876                                                  const gchar *text,
1877                                                  gint timeout)
1878 {
1879         GtkWidget *banner;
1880
1881         if (modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()) == 0)
1882                 return;
1883
1884         banner = hildon_banner_show_information (parent, icon_name, text);
1885         hildon_banner_set_timeout(HILDON_BANNER(banner), timeout);
1886 }
1887
1888 GtkWidget *
1889 modest_platform_animation_banner (GtkWidget *parent,
1890                                   const gchar *animation_name,
1891                                   const gchar *text)
1892 {
1893         GtkWidget *inf_note = NULL;
1894
1895         g_return_val_if_fail (text != NULL, NULL);
1896
1897         if (modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()) == 0)
1898                 return NULL;
1899
1900         /* If the parent is not visible then do not show */
1901         if (parent && !GTK_WIDGET_VISIBLE (parent))
1902                 return NULL;
1903
1904         inf_note = hildon_banner_show_animation (parent, animation_name, text);
1905
1906         return inf_note;
1907 }
1908
1909 typedef struct
1910 {
1911         GMainLoop* loop;
1912         TnyAccount *account;
1913         gboolean is_online;
1914         gint count_tries;
1915 } CheckAccountIdleData;
1916
1917 #define NUMBER_OF_TRIES 10 /* Try approx every second, ten times. */
1918
1919 static gboolean
1920 on_timeout_check_account_is_online(CheckAccountIdleData* data)
1921 {
1922         gboolean stop_trying = FALSE;
1923         g_return_val_if_fail (data && data->account, FALSE);
1924
1925         printf ("DEBUG: %s: tny_account_get_connection_status()==%d\n", __FUNCTION__,
1926                 tny_account_get_connection_status (data->account));
1927
1928         if (data && data->account &&
1929                 /* We want to wait until TNY_CONNECTION_STATUS_INIT has changed to something else,
1930                  * after which the account is likely to be usable, or never likely to be usable soon: */
1931                 (tny_account_get_connection_status (data->account) != TNY_CONNECTION_STATUS_INIT) )
1932         {
1933                 data->is_online = TRUE;
1934
1935                 stop_trying = TRUE;
1936         } else {
1937                 /* Give up if we have tried too many times: */
1938                 if (data->count_tries >= NUMBER_OF_TRIES) {
1939                         stop_trying = TRUE;
1940                 } else {
1941                         /* Wait for another timeout: */
1942                         ++(data->count_tries);
1943                 }
1944         }
1945
1946         if (stop_trying) {
1947                 /* Allow the function that requested this idle callback to continue: */
1948                 if (data->loop)
1949                         g_main_loop_quit (data->loop);
1950
1951                 if (data->account)
1952                         g_object_unref (data->account);
1953
1954                 return FALSE; /* Don't call this again. */
1955         } else {
1956                 return TRUE; /* Call this timeout callback again. */
1957         }
1958 }
1959
1960 /* Return TRUE immediately if the account is already online,
1961  * otherwise check every second for NUMBER_OF_TRIES seconds and return TRUE as
1962  * soon as the account is online, or FALSE if the account does
1963  * not become online in the NUMBER_OF_TRIES seconds.
1964  * This is useful when the D-Bus method was run immediately after
1965  * the application was started (when using D-Bus activation),
1966  * because the account usually takes a short time to go online.
1967  * The return value is maybe not very useful.
1968  */
1969 gboolean
1970 modest_platform_check_and_wait_for_account_is_online(TnyAccount *account)
1971 {
1972         gboolean is_online;
1973
1974         g_return_val_if_fail (account, FALSE);
1975
1976         if (!tny_device_is_online (modest_runtime_get_device())) {
1977                 printf ("DEBUG: %s: device is offline.\n", __FUNCTION__);
1978                 return FALSE;
1979         }
1980
1981         /* The local_folders account never seems to leave TNY_CONNECTION_STATUS_INIT,
1982          * so we avoid wait unnecessarily: */
1983         if (!modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account)))
1984                 return TRUE;
1985
1986         /* The POP & IMAP store accounts seem to be TNY_CONNECTION_STATUS_DISCONNECTED,
1987          * and that seems to be an OK time to use them. Maybe it's just TNY_CONNECTION_STATUS_INIT that
1988          * we want to avoid. */
1989         if (tny_account_get_connection_status (account) != TNY_CONNECTION_STATUS_INIT)
1990                 return TRUE;
1991
1992         /* This blocks on the result: */
1993         CheckAccountIdleData *data = g_slice_new0 (CheckAccountIdleData);
1994         data->is_online = FALSE;
1995         data->account = account;
1996         g_object_ref (data->account);
1997         data->count_tries = 0;
1998
1999         GMainContext *context = NULL; /* g_main_context_new (); */
2000         data->loop = g_main_loop_new (context, FALSE /* not running */);
2001
2002         g_timeout_add (1000, (GSourceFunc)(on_timeout_check_account_is_online), data);
2003
2004         /* This main loop will run until the idle handler has stopped it: */
2005         g_main_loop_run (data->loop);
2006
2007         g_main_loop_unref (data->loop);
2008         /* g_main_context_unref (context); */
2009
2010         is_online = data->is_online;
2011         g_slice_free (CheckAccountIdleData, data);
2012
2013         return is_online;
2014 }
2015
2016
2017
2018 static void
2019 on_cert_dialog_response (GtkDialog *dialog, gint response_id,  const gchar* cert)
2020 {
2021         /* GTK_RESPONSE_HELP means we need to show the certificate */
2022         if (response_id == GTK_RESPONSE_APPLY) {
2023                 GtkWidget *note;
2024                 gchar *msg;
2025
2026                 /* Do not close the dialog */
2027                 g_signal_stop_emission_by_name (dialog, "response");
2028
2029                 msg = g_strdup_printf (_("mcen_ni_view_unknown_certificate"), cert);
2030                 note = hildon_note_new_information (NULL, msg);
2031                 gtk_dialog_run (GTK_DIALOG(note));
2032                 gtk_widget_destroy (note);
2033         }
2034 }
2035
2036
2037 gboolean
2038 modest_platform_run_certificate_confirmation_dialog (const gchar* server_name,
2039                                                      const gchar *certificate)
2040 {
2041         GtkWidget *note;
2042         gint response;
2043         ModestWindow *win;
2044         HildonWindowStack *stack;
2045
2046         stack = hildon_window_stack_get_default ();
2047         win = MODEST_WINDOW (hildon_window_stack_peek (stack));
2048
2049         if (!win) {
2050                 g_debug ("%s: don't show dialogs if there's no window shown; assuming 'Cancel'",
2051                          __FUNCTION__);
2052                 return FALSE;
2053         }
2054
2055         gchar *question = g_strdup_printf (_("mcen_nc_unknown_certificate"),
2056                                            server_name);
2057
2058         /* We use GTK_RESPONSE_APPLY because we want the button in the
2059            middle of OK and CANCEL the same as the browser does for
2060            example. With GTK_RESPONSE_HELP the view button is aligned
2061            to the left while the other two to the right */
2062         note = hildon_note_new_confirmation_add_buttons  (
2063                 NULL,
2064                 question,
2065                 _HL("wdgt_bd_yes"),     GTK_RESPONSE_OK,
2066                 _HL("wdgt_bd_view"),          GTK_RESPONSE_APPLY,   /* abusing this... */
2067                 _HL("wdgt_bd_no"), GTK_RESPONSE_CANCEL,
2068                 NULL, NULL);
2069
2070         g_signal_connect (G_OBJECT(note), "response",
2071                           G_CALLBACK(on_cert_dialog_response),
2072                           (gpointer) certificate);
2073
2074         response = gtk_dialog_run(GTK_DIALOG(note));
2075
2076         on_destroy_dialog (note);
2077         g_free (question);
2078
2079         return response == GTK_RESPONSE_OK;
2080 }
2081
2082 gboolean
2083 modest_platform_run_alert_dialog (const gchar* prompt,
2084                                   gboolean is_question)
2085 {
2086         ModestWindow *top_win;
2087         HildonWindowStack *stack;
2088
2089         stack = hildon_window_stack_get_default ();
2090         top_win = MODEST_WINDOW (hildon_window_stack_peek (stack));
2091
2092         if (!top_win) {
2093                 g_debug ("%s: don't show dialogs if there's no window shown; assuming 'Cancel'",
2094                          __FUNCTION__);
2095                 return FALSE;
2096         }
2097
2098         gboolean retval = TRUE;
2099         if (is_question) {
2100                 /* The Tinymail documentation says that we should show Yes and No buttons,
2101                  * when it is a question.
2102                  * Obviously, we need tinymail to use more specific error codes instead,
2103                  * so we know what buttons to show. */
2104                 GtkWidget *dialog = GTK_WIDGET (hildon_note_new_confirmation (GTK_WINDOW (top_win),
2105                                                                               prompt));
2106                 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
2107                                              GTK_WINDOW (dialog), GTK_WINDOW (top_win));
2108
2109                 const int response = gtk_dialog_run (GTK_DIALOG (dialog));
2110                 retval = (response == GTK_RESPONSE_YES) || (response == GTK_RESPONSE_OK);
2111
2112                 on_destroy_dialog (dialog);
2113         } else {
2114                 /* Just show the error text and use the default response: */
2115                 modest_platform_run_information_dialog (GTK_WINDOW (top_win),
2116                                                         prompt, FALSE);
2117         }
2118         return retval;
2119 }
2120
2121 /***************/
2122 typedef struct {
2123         GtkWindow *parent_window;
2124         ModestConnectedPerformer callback;
2125         TnyAccount *account;
2126         gpointer user_data;
2127         gchar *iap;
2128         TnyDevice *device;
2129 } OnWentOnlineInfo;
2130
2131 static void
2132 on_went_online_info_free (OnWentOnlineInfo *info)
2133 {
2134         /* And if we cleanup, we DO cleanup  :-)  */
2135
2136         if (info->device)
2137                 g_object_unref (info->device);
2138         if (info->iap)
2139                 g_free (info->iap);
2140         if (info->parent_window)
2141                 g_object_unref (info->parent_window);
2142         if (info->account)
2143                 g_object_unref (info->account);
2144
2145         g_slice_free (OnWentOnlineInfo, info);
2146
2147         /* We're done ... */
2148
2149         return;
2150 }
2151
2152 static void
2153 on_account_went_online (TnyCamelAccount *account, gboolean canceled, GError *err, gpointer user_data)
2154 {
2155         OnWentOnlineInfo *info = (OnWentOnlineInfo *) user_data;
2156
2157         /* Now it's really time to callback to the caller. If going online didn't succeed,
2158          * err will be set. We don't free it, Tinymail does that! If a cancel happened,
2159          * canceled will be set. Etcetera etcetera. */
2160
2161         if (info->callback) {
2162                 info->callback (canceled, err, info->parent_window, info->account, info->user_data);
2163         }
2164
2165         /* This is our last call, we must cleanup here if we didn't yet do that */
2166         on_went_online_info_free (info);
2167
2168         return;
2169 }
2170
2171
2172 static void
2173 on_conic_device_went_online (TnyMaemoConicDevice *device, const gchar* iap_id, gboolean canceled, GError *err, gpointer user_data)
2174 {
2175         OnWentOnlineInfo *info = (OnWentOnlineInfo *) user_data;
2176         info->iap = g_strdup (iap_id);
2177
2178         if (canceled || err || !info->account) {
2179
2180                 /* If there's a problem or if there's no account (then that's it for us, we callback
2181                  * the caller's callback now. He'll have to handle err or canceled, of course.
2182                  * We are not really online, as the account is not really online here ... */
2183
2184                 /* We'll use the err and the canceled of this cb. TnyMaemoConicDevice delivered us
2185                  * this info. We don't cleanup err, Tinymail does that! */
2186
2187                 if (info->callback) {
2188
2189                         /* info->account can be NULL here, this means that the user did not
2190                          * provide a nice account instance. We'll assume that the user knows
2191                          * what he's doing and is happy with just the device going online.
2192                          *
2193                          * We can't do magic, we don't know what account the user wants to
2194                          * see going online. So just the device goes online, end of story */
2195
2196                         info->callback (canceled, err, info->parent_window, info->account, info->user_data);
2197                 }
2198
2199         } else if (info->account) {
2200
2201                 /* If there's no problem and if we have an account, we'll put the account
2202                  * online too. When done, the callback of bringing the account online
2203                  * will callback the caller's callback. This is the most normal case. */
2204
2205                 info->device = TNY_DEVICE (g_object_ref (device));
2206
2207                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (info->account), TRUE,
2208                                               on_account_went_online, info);
2209
2210                 /* The on_account_went_online cb frees up the info, go look if you
2211                  * don't believe me! (so we return here) */
2212
2213                 return;
2214         }
2215
2216         /* We cleanup if we are not bringing the account online too */
2217         on_went_online_info_free (info);
2218
2219         return;
2220 }
2221
2222 void
2223 modest_platform_connect_and_perform (GtkWindow *parent_window,
2224                                      gboolean force,
2225                                      TnyAccount *account,
2226                                      ModestConnectedPerformer callback,
2227                                      gpointer user_data)
2228 {
2229         gboolean device_online;
2230         TnyDevice *device;
2231         TnyConnectionStatus conn_status;
2232         OnWentOnlineInfo *info;
2233
2234         device = modest_runtime_get_device();
2235         device_online = tny_device_is_online (device);
2236
2237         /* If there is no account check only the device status */
2238         if (!account) {
2239
2240                 if (device_online) {
2241
2242                         /* We promise to instantly perform the callback, so ... */
2243                         if (callback) {
2244                                 callback (FALSE, NULL, parent_window, account, user_data);
2245                         }
2246
2247                 } else {
2248
2249                         info = g_slice_new0 (OnWentOnlineInfo);
2250
2251                         info->iap = NULL;
2252                         info->device = NULL;
2253                         info->account = NULL;
2254
2255                         if (parent_window)
2256                                 info->parent_window = (GtkWindow *) g_object_ref (parent_window);
2257                         else
2258                                 info->parent_window = NULL;
2259                         info->user_data = user_data;
2260                         info->callback = callback;
2261
2262                         tny_maemo_conic_device_connect_async (TNY_MAEMO_CONIC_DEVICE (device), NULL,
2263                                                               force, on_conic_device_went_online,
2264                                                               info);
2265
2266                         /* We'll cleanup in on_conic_device_went_online */
2267                 }
2268
2269                 /* The other code has no more reason to run. This is all that we can do for the
2270                  * caller (he should have given us a nice and clean account instance!). We
2271                  * can't do magic, we don't know what account he intends to bring online. So
2272                  * we'll just bring the device online (and await his false bug report). */
2273
2274                 return;
2275         }
2276
2277
2278         /* Return if the account is already connected */
2279
2280         conn_status = tny_account_get_connection_status (account);
2281         if (device_online && conn_status == TNY_CONNECTION_STATUS_CONNECTED) {
2282
2283                 /* We promise to instantly perform the callback, so ... */
2284                 if (callback) {
2285                         callback (FALSE, NULL, parent_window, account, user_data);
2286                 }
2287
2288                 return;
2289         }
2290
2291         /* Else, we are in a state that requires that we go online before we
2292          * call the caller's callback. */
2293
2294         info = g_slice_new0 (OnWentOnlineInfo);
2295
2296         info->device = NULL;
2297         info->iap = NULL;
2298         info->account = TNY_ACCOUNT (g_object_ref (account));
2299
2300         if (parent_window)
2301                 info->parent_window = (GtkWindow *) g_object_ref (parent_window);
2302         else
2303                 info->parent_window = NULL;
2304
2305         /* So we'll put the callback away for later ... */
2306
2307         info->user_data = user_data;
2308         info->callback = callback;
2309
2310         if (!device_online) {
2311
2312                 /* If also the device is offline, then we connect both the device
2313                  * and the account */
2314
2315                 tny_maemo_conic_device_connect_async (TNY_MAEMO_CONIC_DEVICE (device), NULL,
2316                                                       force, on_conic_device_went_online,
2317                                                       info);
2318
2319         } else {
2320
2321                 /* If the device is online, we'll just connect the account */
2322
2323                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (account), TRUE,
2324                                               on_account_went_online, info);
2325         }
2326
2327         /* The info gets freed by on_account_went_online or on_conic_device_went_online
2328          * in both situations, go look if you don't believe me! */
2329
2330         return;
2331 }
2332
2333 void
2334 modest_platform_connect_if_remote_and_perform (GtkWindow *parent_window,
2335                                                gboolean force,
2336                                                TnyFolderStore *folder_store,
2337                                                ModestConnectedPerformer callback,
2338                                                gpointer user_data)
2339 {
2340         TnyAccount *account = NULL;
2341
2342         if (!folder_store ||
2343             (TNY_IS_MERGE_FOLDER (folder_store) &&
2344              (tny_folder_get_folder_type (TNY_FOLDER(folder_store)) == TNY_FOLDER_TYPE_OUTBOX))) {
2345
2346                 /* We promise to instantly perform the callback, so ... */
2347                 if (callback) {
2348                         GError *error = NULL;
2349                         g_set_error (&error, TNY_ERROR_DOMAIN, TNY_SERVICE_ERROR_UNKNOWN,
2350                                      "Unable to move or not found folder");
2351                         callback (FALSE, error, parent_window, NULL, user_data);
2352                         g_error_free (error);
2353                 }
2354                 return;
2355
2356         } else if (TNY_IS_FOLDER (folder_store)) {
2357                 /* Get the folder's parent account: */
2358                 account = tny_folder_get_account (TNY_FOLDER (folder_store));
2359         } else if (TNY_IS_ACCOUNT (folder_store)) {
2360                 /* Use the folder store as an account: */
2361                 account = TNY_ACCOUNT (g_object_ref (folder_store));
2362         }
2363
2364         if (account && (tny_account_get_account_type (account) == TNY_ACCOUNT_TYPE_STORE)) {
2365                 if (!modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account))) {
2366                         /* No need to connect a local account */
2367                         if (callback)
2368                                 callback (FALSE, NULL, parent_window, account, user_data);
2369
2370                         goto clean;
2371                 }
2372         }
2373         modest_platform_connect_and_perform (parent_window, force, account, callback, user_data);
2374
2375  clean:
2376         if (account)
2377                 g_object_unref (account);
2378 }
2379
2380 static void
2381 src_account_connect_performer (gboolean canceled,
2382                                GError *err,
2383                                GtkWindow *parent_window,
2384                                TnyAccount *src_account,
2385                                gpointer user_data)
2386 {
2387         DoubleConnectionInfo *info = (DoubleConnectionInfo *) user_data;
2388
2389         if (canceled || err) {
2390                 /* If there was any error call the user callback */
2391                 info->callback (canceled, err, parent_window, src_account, info->data);
2392         } else {
2393                 /* Connect the destination account */
2394                 modest_platform_connect_if_remote_and_perform (parent_window, TRUE,
2395                                                                TNY_FOLDER_STORE (info->dst_account),
2396                                                                info->callback, info->data);
2397         }
2398
2399         /* Free the info object */
2400         g_object_unref (info->dst_account);
2401         g_slice_free (DoubleConnectionInfo, info);
2402 }
2403
2404
2405 void
2406 modest_platform_double_connect_and_perform (GtkWindow *parent_window,
2407                                             gboolean force,
2408                                             TnyFolderStore *folder_store,
2409                                             DoubleConnectionInfo *connect_info)
2410 {
2411         modest_platform_connect_if_remote_and_perform(parent_window,
2412                                                       force,
2413                                                       folder_store,
2414                                                       src_account_connect_performer,
2415                                                       connect_info);
2416 }
2417
2418 GtkWidget *
2419 modest_platform_get_account_settings_wizard (void)
2420 {
2421         ModestEasysetupWizardDialog *dialog = modest_easysetup_wizard_dialog_new ();
2422
2423         return GTK_WIDGET (dialog);
2424 }
2425
2426 ModestConnectedVia
2427 modest_platform_get_current_connection (void)
2428 {
2429         TnyDevice *device = NULL;
2430         ModestConnectedVia retval = MODEST_CONNECTED_VIA_ANY;
2431
2432         device = modest_runtime_get_device ();
2433
2434         if (!tny_device_is_online (device))
2435                 return MODEST_CONNECTED_VIA_ANY;
2436
2437 #ifdef MODEST_HAVE_CONIC
2438         /* Get iap id */
2439         const gchar *iap_id = tny_maemo_conic_device_get_current_iap_id (TNY_MAEMO_CONIC_DEVICE (device));
2440         if (iap_id) {
2441                 ConIcIap *iap = tny_maemo_conic_device_get_iap (
2442                         TNY_MAEMO_CONIC_DEVICE (device), iap_id);
2443                 const gchar *bearer_type = con_ic_iap_get_bearer_type (iap);
2444                 if (bearer_type) {
2445                         if (!strcmp (bearer_type, CON_IC_BEARER_WLAN_INFRA) ||
2446                             !strcmp (bearer_type, CON_IC_BEARER_WLAN_ADHOC) ||
2447                             !strcmp (bearer_type, "WIMAX")) {
2448                                 retval = MODEST_CONNECTED_VIA_WLAN_OR_WIMAX;
2449                         } else {
2450                                 retval = MODEST_CONNECTED_VIA_ANY;
2451                         }
2452                 }
2453                 g_object_unref (iap);
2454         }
2455 #else
2456         retval = MODEST_CONNECTED_VIA_WLAN_OR_WIMAX; /* assume WLAN (fast) internet */
2457 #endif /* MODEST_HAVE_CONIC */
2458         return retval;
2459 }
2460
2461
2462
2463 gboolean
2464 modest_platform_check_memory_low (ModestWindow *win,
2465                                   gboolean visuals)
2466 {
2467         gboolean lowmem;
2468
2469         /* are we in low memory state? */
2470         lowmem = osso_mem_in_lowmem_state () ? TRUE : FALSE;
2471
2472         if (win && lowmem && visuals)
2473                 modest_platform_run_information_dialog (
2474                         GTK_WINDOW(win),
2475                         _KR("memr_ib_operation_disabled"),
2476                         TRUE);
2477
2478         if (lowmem)
2479                 g_debug ("%s: low memory reached. disallowing some operations",
2480                          __FUNCTION__);
2481
2482         return lowmem;
2483 }
2484
2485 void
2486 modest_platform_run_folder_details_dialog (GtkWindow *parent_window,
2487                                            TnyFolder *folder)
2488 {
2489         GtkWidget *dialog;
2490
2491         /* Create dialog */
2492         dialog = modest_hildon2_details_dialog_new_with_folder (parent_window, folder);
2493
2494         /* Run dialog */
2495         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
2496                                      GTK_WINDOW (dialog),
2497                                      parent_window);
2498         gtk_widget_show_all (dialog);
2499
2500         g_signal_connect_swapped (dialog, "response",
2501                                   G_CALLBACK (gtk_widget_destroy),
2502                                   dialog);
2503 }
2504
2505 typedef struct _HeaderDetailsGetSizeInfo {
2506         GtkWidget *dialog;
2507         TnyMimePart *part;
2508         guint total;
2509 } HeaderDetailsGetSizeInfo;
2510
2511 static void
2512 header_details_dialog_destroy (gpointer userdata,
2513                                GObject *object)
2514 {
2515         HeaderDetailsGetSizeInfo *info = (HeaderDetailsGetSizeInfo *) userdata;
2516
2517         info->dialog = NULL;
2518 }
2519
2520 static gboolean
2521 idle_get_mime_part_size_cb (gpointer userdata)
2522 {
2523         HeaderDetailsGetSizeInfo *info = (HeaderDetailsGetSizeInfo *) userdata;
2524         gdk_threads_enter ();
2525
2526         if (info->dialog && GTK_WIDGET_VISIBLE (info->dialog)) {
2527                 modest_details_dialog_set_message_size (MODEST_DETAILS_DIALOG (info->dialog),
2528                                                         info->total);
2529         }
2530
2531         if (info->dialog) {
2532                 g_object_weak_unref (G_OBJECT (info->dialog), header_details_dialog_destroy, info);
2533                 info->dialog = NULL;
2534         }
2535         g_object_unref (info->part);
2536         g_slice_free (HeaderDetailsGetSizeInfo, info);
2537
2538         gdk_threads_leave ();
2539
2540         return FALSE;
2541 }
2542
2543 static gpointer
2544 get_mime_part_size_thread (gpointer thr_user_data)
2545 {
2546         HeaderDetailsGetSizeInfo *info = (HeaderDetailsGetSizeInfo *) thr_user_data;
2547         gssize result = 0;
2548         TnyStream *count_stream;
2549
2550         count_stream = modest_count_stream_new ();
2551         result = tny_mime_part_decode_to_stream (info->part, count_stream, NULL);
2552         info->total = modest_count_stream_get_count(MODEST_COUNT_STREAM (count_stream));
2553         if (info->total == 0) {
2554                 modest_count_stream_reset_count(MODEST_COUNT_STREAM (count_stream));
2555                 result = tny_mime_part_write_to_stream (info->part, count_stream, NULL);
2556                 info->total = modest_count_stream_get_count(MODEST_COUNT_STREAM (count_stream));
2557         }
2558
2559         /* if there was an error, don't set the size (this is pretty uncommon) */
2560         if (result < 0) {
2561                 g_warning ("%s: error while writing mime part to stream\n", __FUNCTION__);
2562         }
2563         g_idle_add (idle_get_mime_part_size_cb, info);
2564
2565         return NULL;
2566 }
2567
2568 void
2569 modest_platform_run_header_details_dialog (GtkWindow *parent_window,
2570                                            TnyHeader *header,
2571                                            gboolean async_get_size,
2572                                            TnyMsg *msg)
2573 {
2574         GtkWidget *dialog;
2575
2576         /* Create dialog */
2577         dialog = modest_hildon2_details_dialog_new_with_header (parent_window, header, !async_get_size);
2578
2579         if (async_get_size && msg && TNY_IS_MSG (msg)) {
2580                 HeaderDetailsGetSizeInfo *info;
2581                 info = g_slice_new (HeaderDetailsGetSizeInfo);
2582                 info->dialog = dialog;
2583                 info->total = 0;
2584                 info->part = TNY_MIME_PART (g_object_ref (msg));
2585
2586                 g_object_weak_ref (G_OBJECT (dialog), header_details_dialog_destroy, info);
2587                 g_thread_create (get_mime_part_size_thread, info, FALSE, NULL);
2588         }
2589
2590         /* Run dialog */
2591         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
2592                                      GTK_WINDOW (dialog),
2593                                      parent_window);
2594         gtk_widget_show_all (dialog);
2595
2596         g_signal_connect_swapped (dialog, "response",
2597                                   G_CALLBACK (gtk_widget_destroy),
2598                                   dialog);
2599 }
2600
2601 osso_context_t *
2602 modest_platform_get_osso_context (void)
2603 {
2604         return modest_maemo_utils_get_osso_context ();
2605 }
2606
2607 static void
2608 modest_platform_play_email_tone (void)
2609 {
2610         gchar *mail_tone;
2611         gint mail_volume_int;
2612         int ret;
2613         ca_proplist *pl = NULL;
2614
2615 #ifdef MODEST_USE_PROFILE
2616         gchar *active_profile;
2617         gchar *mail_volume;
2618
2619         active_profile = profile_get_profile ();
2620         mail_tone = profile_get_value (active_profile, PROFILE_MAIL_TONE);
2621         mail_volume = profile_get_value (active_profile, PROFILE_MAIL_VOLUME);
2622         mail_volume_int = profile_parse_int (mail_volume);
2623         g_free (mail_volume);
2624         g_free (active_profile);
2625 #else
2626         mail_tone = MAIL_TONE;
2627         mail_volume_int = 100;
2628 #endif
2629
2630         if (mail_tone && !strstr (mail_tone, "/")) {
2631                 gchar *tmp;
2632
2633                 tmp = g_strconcat ("/usr/share/sounds", mail_tone, NULL);
2634                 g_free (mail_tone);
2635                 mail_tone = tmp;
2636         }
2637
2638         if (mail_volume_int > 0) {
2639
2640                 if (ca_con == NULL) {
2641                         if ((ret = ca_context_create (&ca_con)) != CA_SUCCESS) {
2642                                 g_warning("ca_context_create: %s\n", ca_strerror(ret));
2643                                 return;
2644                         }
2645                 }
2646
2647                 if ((ret = ca_context_open(ca_con)) != CA_SUCCESS) {
2648                         g_warning("ca_context_open: %s\n", ca_strerror(ret));
2649                         return;
2650                 }
2651
2652                 ca_proplist_create(&pl);
2653                 ca_proplist_sets(pl, CA_PROP_MEDIA_FILENAME, mail_tone);
2654                 ca_proplist_setf(pl, CA_PROP_CANBERRA_VOLUME, "%f", (gfloat) mail_volume_int);
2655
2656                 ret = ca_context_play_full(ca_con, 0, pl, NULL, NULL);
2657                 g_debug("ca_context_play_full (vol %f): %s\n", (gfloat) mail_volume_int, ca_strerror(ret));
2658
2659                 ca_proplist_destroy(pl);
2660         }
2661
2662         g_free (mail_tone);
2663 }
2664
2665 #define MOVE_TO_DIALOG_FOLDER_VIEW "folder-view"
2666 #define MOVE_TO_DIALOG_BACK_BUTTON "back-button"
2667 #define MOVE_TO_DIALOG_ACTION_BUTTON "action-button"
2668 #define MOVE_TO_DIALOG_SHOWING_FOLDERS "showing-folders"
2669 #define MOVE_TO_DIALOG_PANNABLE "pannable"
2670 #define MOVE_TO_FOLDER_SEPARATOR "/"
2671
2672 static void
2673 translate_path (gchar **path)
2674 {
2675         gchar **parts;
2676         gchar **current;
2677         GString *output;
2678         gboolean add_separator;
2679
2680         parts = g_strsplit (*path, MOVE_TO_FOLDER_SEPARATOR, 0);
2681         g_free (*path);
2682
2683         current = parts;
2684         output = g_string_new ("");
2685         add_separator = FALSE;
2686
2687         while (*current != NULL) {
2688                 TnyFolderType folder_type;
2689                 gchar *downcase;
2690
2691                 if (add_separator) {
2692                         output = g_string_append (output, MOVE_TO_FOLDER_SEPARATOR);
2693                 } else {
2694                         add_separator = TRUE;
2695                 }
2696
2697                 downcase = g_ascii_strdown (*current, -1);
2698                 folder_type = modest_local_folder_info_get_type (downcase);
2699                 if (strcmp (downcase, "inbox") == 0) {
2700                         output = g_string_append (output, _("mcen_me_folder_inbox"));
2701                 } else if (folder_type == TNY_FOLDER_TYPE_ARCHIVE ||
2702                     folder_type == TNY_FOLDER_TYPE_DRAFTS ||
2703                     folder_type == TNY_FOLDER_TYPE_SENT ||
2704                     folder_type == TNY_FOLDER_TYPE_OUTBOX) {
2705                         output = g_string_append (output, modest_local_folder_info_get_type_display_name (folder_type));
2706                 } else {
2707                         output = g_string_append (output, *current);
2708                 }
2709                 g_free (downcase);
2710
2711                 current++;
2712         }
2713
2714         g_strfreev (parts);
2715         *path = g_string_free (output, FALSE);
2716 }
2717
2718 static void
2719 move_to_dialog_set_selected_folder_store (GtkWidget *dialog,
2720                                           TnyFolderStore *folder_store)
2721 {
2722         GtkWidget *action_button;
2723         GtkWidget *image = NULL;
2724         TnyAccount *account;
2725         gchar *account_name = NULL, *short_name = NULL;
2726
2727         action_button = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_ACTION_BUTTON));
2728
2729         /* Get account name */
2730         if (TNY_IS_FOLDER (folder_store))
2731                 account = tny_folder_get_account (TNY_FOLDER (folder_store));
2732         else
2733                 account = g_object_ref (folder_store);
2734
2735         if (modest_tny_account_is_virtual_local_folders (account))
2736                 account_name = modest_conf_get_string (modest_runtime_get_conf(),
2737                                                        MODEST_CONF_DEVICE_NAME, NULL);
2738
2739         if (!account_name)
2740                 account_name = g_strdup (tny_account_get_name (account));
2741
2742         g_object_unref (account);
2743
2744         /* Set title of button: account or folder name */
2745         if (TNY_IS_FOLDER (folder_store))
2746                 short_name = folder_store_get_display_name (folder_store);
2747         else
2748                 short_name = g_strdup (account_name);
2749
2750         hildon_button_set_title (HILDON_BUTTON (action_button), short_name);
2751
2752         /* Set value of button, folder full name */
2753         if (TNY_IS_CAMEL_FOLDER (folder_store)) {
2754                 const gchar *camel_full_name;
2755                 gchar *last_slash, *full_name;
2756
2757                 camel_full_name = tny_camel_folder_get_full_name (TNY_CAMEL_FOLDER (folder_store));
2758                 last_slash = g_strrstr (camel_full_name, "/");
2759                 if (last_slash) {
2760                         gchar *prefix = g_strndup (camel_full_name, last_slash - camel_full_name + 1);
2761                         full_name = g_strconcat (account_name, MOVE_TO_FOLDER_SEPARATOR, prefix, short_name, NULL);
2762                         g_free (prefix);
2763                 } else {
2764                         full_name = g_strconcat (account_name, MOVE_TO_FOLDER_SEPARATOR,
2765                                                  short_name,
2766                                                  NULL);
2767                 }
2768                 translate_path (&full_name);
2769                 hildon_button_set_value (HILDON_BUTTON (action_button), full_name);
2770                 g_free (full_name);
2771         }
2772         g_free (account_name);
2773         g_free (short_name);
2774
2775         /* Set image for the button */
2776         image = get_image_for_folder_store (folder_store, MODEST_ICON_SIZE_BIG);
2777         if (image)
2778                 hildon_button_set_image (HILDON_BUTTON (action_button), image);
2779 }
2780
2781 static void
2782 move_to_dialog_show_accounts (GtkWidget *dialog)
2783 {
2784         GtkWidget *back_button;
2785         GtkWidget *folder_view;
2786         GtkWidget *pannable;
2787         GtkWidget *action_button;
2788
2789         back_button = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_BACK_BUTTON));
2790         action_button = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_ACTION_BUTTON));
2791         folder_view = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_FOLDER_VIEW));
2792         pannable = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_PANNABLE));
2793
2794         gtk_widget_set_sensitive (back_button, FALSE);
2795         gtk_widget_set_sensitive (action_button, FALSE);
2796
2797         /* Need to set this here, otherwise callbacks called because
2798            of filtering won't perform correctly */
2799         g_object_set_data (G_OBJECT (dialog), MOVE_TO_DIALOG_SHOWING_FOLDERS, GINT_TO_POINTER (FALSE));
2800
2801         /* Reset action button */
2802         hildon_button_set_title (HILDON_BUTTON (action_button), NULL);
2803         hildon_button_set_value (HILDON_BUTTON (action_button), NULL);
2804         hildon_button_set_image (HILDON_BUTTON (action_button), NULL);
2805
2806         modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW (folder_view), NULL);
2807         modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (folder_view), TRUE);
2808         modest_folder_view_set_style (MODEST_FOLDER_VIEW (folder_view), MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
2809         modest_folder_view_unset_filter (MODEST_FOLDER_VIEW (folder_view),
2810                                          MODEST_FOLDER_VIEW_FILTER_HIDE_MCC_FOLDERS);
2811         modest_folder_view_unset_filter (MODEST_FOLDER_VIEW (folder_view),
2812                                        MODEST_FOLDER_VIEW_FILTER_HIDE_LOCAL_FOLDERS);
2813         modest_folder_view_unset_filter (MODEST_FOLDER_VIEW (folder_view),
2814                                          MODEST_FOLDER_VIEW_FILTER_HIDE_ACCOUNTS);
2815         modest_folder_view_set_filter (MODEST_FOLDER_VIEW (folder_view),
2816                                        MODEST_FOLDER_VIEW_FILTER_HIDE_FOLDERS);
2817         hildon_pannable_area_jump_to (HILDON_PANNABLE_AREA (pannable), 0, 0);
2818 }
2819
2820 static void
2821 move_to_dialog_show_folders (GtkWidget *dialog, TnyFolderStore *folder_store)
2822 {
2823         GtkWidget *back_button;
2824         GtkWidget *folder_view;
2825         TnyAccount *account;
2826         const gchar *account_id;
2827         GtkWidget *pannable;
2828         GtkWidget *action_button;
2829
2830         back_button =
2831                 GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_BACK_BUTTON));
2832         action_button =
2833                 GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_ACTION_BUTTON));
2834         folder_view =
2835                 GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_FOLDER_VIEW));
2836         pannable =
2837                 GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_PANNABLE));
2838
2839         gtk_widget_set_sensitive (back_button, TRUE);
2840         gtk_widget_set_sensitive (action_button, TRUE);
2841
2842         /* Need to set this here, otherwise callbacks called because
2843            of filtering won't perform correctly */
2844         g_object_set_data (G_OBJECT (dialog),
2845                            MOVE_TO_DIALOG_SHOWING_FOLDERS,
2846                            GINT_TO_POINTER (TRUE));
2847
2848         account = TNY_ACCOUNT (folder_store);
2849         if (modest_tny_account_is_virtual_local_folders (account)) {
2850                 account_id = tny_account_get_id (account);
2851                 modest_folder_view_set_filter (MODEST_FOLDER_VIEW (folder_view),
2852                                                MODEST_FOLDER_VIEW_FILTER_HIDE_MCC_FOLDERS);
2853         } else if (modest_tny_account_is_memory_card_account (account)) {
2854                 account_id = tny_account_get_id (account);
2855                 modest_folder_view_set_filter (MODEST_FOLDER_VIEW (folder_view),
2856                                                MODEST_FOLDER_VIEW_FILTER_HIDE_LOCAL_FOLDERS);
2857         } else {
2858                 account_id = tny_account_get_id (account);
2859                 modest_folder_view_set_filter (MODEST_FOLDER_VIEW (folder_view),
2860                                                MODEST_FOLDER_VIEW_FILTER_HIDE_LOCAL_FOLDERS);
2861                 modest_folder_view_set_filter (MODEST_FOLDER_VIEW (folder_view),
2862                                                MODEST_FOLDER_VIEW_FILTER_HIDE_MCC_FOLDERS);
2863         }
2864
2865         move_to_dialog_set_selected_folder_store (dialog, folder_store);
2866         modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW (folder_view),
2867                                                                      account_id);
2868
2869         modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (folder_view), FALSE);
2870         modest_folder_view_set_style (MODEST_FOLDER_VIEW (folder_view), MODEST_FOLDER_VIEW_STYLE_SHOW_ONE);
2871         modest_folder_view_set_filter (MODEST_FOLDER_VIEW (folder_view), MODEST_FOLDER_VIEW_FILTER_HIDE_ACCOUNTS);
2872         modest_folder_view_unset_filter (MODEST_FOLDER_VIEW (folder_view), MODEST_FOLDER_VIEW_FILTER_HIDE_FOLDERS);
2873         hildon_pannable_area_jump_to (HILDON_PANNABLE_AREA (pannable), 0, 0);
2874 }
2875
2876 static void
2877 on_move_to_dialog_back_clicked (GtkButton *button,
2878                                 gpointer userdata)
2879 {
2880         GtkWidget *dialog = (GtkWidget *) userdata;
2881
2882         /* Back to show accounts */
2883         move_to_dialog_show_accounts (dialog);
2884 }
2885
2886 static void
2887 on_move_to_dialog_row_activated (GtkTreeView       *tree_view,
2888                                     GtkTreePath       *path,
2889                                     GtkTreeViewColumn *column,
2890                                     gpointer           user_data)
2891 {
2892         TnyFolderStore *selected = NULL;
2893         GtkWidget *dialog;
2894         GtkWidget *folder_view;
2895         gboolean showing_folders;
2896
2897         dialog = (GtkWidget *) user_data;
2898         showing_folders = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dialog),
2899                                                               MOVE_TO_DIALOG_SHOWING_FOLDERS));
2900
2901         folder_view = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog),
2902                                                      MOVE_TO_DIALOG_FOLDER_VIEW));
2903
2904         selected = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2905         if (!selected)
2906                 return;
2907
2908         if (!showing_folders) {
2909                 gboolean valid = TRUE;
2910
2911                 if (TNY_IS_ACCOUNT (selected) &&
2912                     modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (selected))) {
2913                         ModestProtocolType protocol_type;
2914
2915                         protocol_type = modest_tny_account_get_protocol_type (TNY_ACCOUNT (selected));
2916                         valid  = !modest_protocol_registry_protocol_type_has_tag
2917                                 (modest_runtime_get_protocol_registry (),
2918                                  protocol_type,
2919                                  MODEST_PROTOCOL_REGISTRY_STORE_FORBID_MESSAGE_ADD);
2920                 }
2921                 if (valid)
2922                         move_to_dialog_show_folders (dialog, selected);
2923         } else {
2924                 move_to_dialog_set_selected_folder_store (dialog, selected);
2925         }
2926 }
2927
2928 static void
2929 on_move_to_dialog_selection_changed (GtkTreeSelection *selection,
2930                                      gpointer          user_data)
2931 {
2932         gboolean showing_folders;
2933         GtkWidget *dialog;
2934
2935         dialog = (GtkWidget *) user_data;
2936         showing_folders = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_SHOWING_FOLDERS));
2937         if (showing_folders) {
2938                 TnyFolderStore *selected;
2939                 GtkWidget *folder_view;
2940
2941                 folder_view = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_FOLDER_VIEW));
2942                 selected = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2943
2944                 if (selected) {
2945                         move_to_dialog_set_selected_folder_store (dialog, selected);
2946                         g_object_unref (selected);
2947                 }
2948         }
2949 }
2950
2951 static void
2952 on_move_to_dialog_action_clicked (GtkButton *selection,
2953                                   gpointer   user_data)
2954 {
2955         GtkWidget *dialog;
2956         gboolean showing_folders;
2957
2958         dialog = (GtkWidget *) user_data;
2959         showing_folders = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_SHOWING_FOLDERS));
2960         if (showing_folders) {
2961                 TnyFolderStore *selected;
2962                 GtkWidget *folder_view;
2963
2964                 folder_view = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_FOLDER_VIEW));
2965                 selected = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2966
2967                 if (selected) {
2968                         /* It's not possible to select root folders as
2969                            targets unless they're the local account or
2970                            the memory card account */
2971                         if ((TNY_IS_FOLDER (selected) && !TNY_IS_MERGE_FOLDER (selected)) ||
2972                             (TNY_IS_ACCOUNT (selected) &&
2973                              (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (selected)) ||
2974                               modest_tny_account_is_memory_card_account (TNY_ACCOUNT (selected)))))
2975                                 gtk_dialog_response  (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
2976                         g_object_unref (selected);
2977                 }
2978         }
2979 }
2980
2981 static void
2982 move_to_dialog_activity_changed (ModestFolderView *folder_view, gboolean activity, GtkDialog *dialog)
2983 {
2984         hildon_gtk_window_set_progress_indicator (GTK_WINDOW (dialog), activity?1:0);
2985 }
2986
2987 GtkWidget *
2988 modest_platform_create_move_to_dialog (GtkWindow *parent_window,
2989                                        GtkWidget **folder_view)
2990 {
2991         GtkWidget *dialog, *folder_view_container;
2992         GtkWidget *align;
2993         GtkWidget *buttons_hbox;
2994         GtkWidget *back_button;
2995         GdkPixbuf *back_pixbuf;
2996         GtkWidget *top_vbox;
2997         GtkWidget *action_button;
2998         GtkTreeSelection *selection;
2999
3000         /* Create dialog. We cannot use a touch selector because we
3001            need to use here the folder view widget directly */
3002         dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
3003                                               GTK_WINDOW (parent_window),
3004                                               GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR |
3005                                               GTK_DIALOG_DESTROY_WITH_PARENT,
3006                                               _HL("wdgt_bd_new"), MODEST_GTK_RESPONSE_NEW_FOLDER,
3007                                               NULL);
3008
3009         align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
3010         gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, MODEST_MARGIN_DOUBLE, MODEST_MARGIN_NONE);
3011         top_vbox = gtk_vbox_new (FALSE, MODEST_MARGIN_HALF);
3012
3013         /* Create folder view */
3014         *folder_view = modest_platform_create_folder_view_full (NULL, FALSE);
3015         g_signal_connect (G_OBJECT (*folder_view), "activity-changed", G_CALLBACK (move_to_dialog_activity_changed),
3016                           dialog);
3017
3018         modest_folder_view_set_cell_style (MODEST_FOLDER_VIEW (*folder_view),
3019                                            MODEST_FOLDER_VIEW_CELL_STYLE_COMPACT);
3020         modest_folder_view_show_message_count (MODEST_FOLDER_VIEW (*folder_view),
3021                                                FALSE);
3022         tny_account_store_view_set_account_store (TNY_ACCOUNT_STORE_VIEW (*folder_view),
3023                                                   (TnyAccountStore *) modest_runtime_get_account_store ());
3024
3025         buttons_hbox = gtk_hbox_new (FALSE, MODEST_MARGIN_HALF);
3026         back_button = gtk_button_new ();
3027         back_pixbuf = modest_platform_get_icon (_FM("filemanager_folder_up"), MODEST_ICON_SIZE_BIG);
3028         if (back_pixbuf) {
3029                 gtk_button_set_image (GTK_BUTTON (back_button), gtk_image_new_from_pixbuf (back_pixbuf));
3030                 g_object_unref (back_pixbuf);
3031         }
3032
3033         action_button = hildon_button_new (HILDON_SIZE_AUTO_WIDTH | HILDON_SIZE_FINGER_HEIGHT,
3034                                            HILDON_BUTTON_ARRANGEMENT_VERTICAL);
3035         gtk_button_set_alignment (GTK_BUTTON (action_button), 0.0, 0.5);
3036
3037         gtk_box_pack_start (GTK_BOX (buttons_hbox), back_button, FALSE, FALSE, 0);
3038         gtk_box_pack_start (GTK_BOX (buttons_hbox), action_button, TRUE, TRUE, 0);
3039         gtk_widget_set_sensitive (GTK_WIDGET (back_button), FALSE);
3040         gtk_widget_set_sensitive (GTK_WIDGET (action_button), FALSE);
3041         gtk_box_pack_start (GTK_BOX (top_vbox), buttons_hbox, FALSE, FALSE, 0);
3042
3043         /* Create pannable and add it to the dialog */
3044         folder_view_container = hildon_pannable_area_new ();
3045         gtk_container_add (GTK_CONTAINER (folder_view_container), *folder_view);
3046         gtk_box_pack_start (GTK_BOX (top_vbox), folder_view_container, TRUE, TRUE, 0);
3047
3048         gtk_container_add (GTK_CONTAINER (align), top_vbox);
3049         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), align, TRUE, TRUE, 0);
3050
3051         gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 300);
3052
3053         gtk_widget_show (GTK_DIALOG (dialog)->vbox);
3054         gtk_widget_show (folder_view_container);
3055         gtk_widget_show (align);
3056         gtk_widget_show (top_vbox);
3057         gtk_widget_show (*folder_view);
3058         gtk_widget_show_all (back_button);
3059         gtk_widget_show (action_button);
3060         gtk_widget_show (buttons_hbox);
3061         gtk_widget_show (dialog);
3062
3063         g_object_set_data (G_OBJECT (dialog), MOVE_TO_DIALOG_FOLDER_VIEW, *folder_view);
3064         g_object_set_data (G_OBJECT (dialog), MOVE_TO_DIALOG_BACK_BUTTON, back_button);
3065         g_object_set_data (G_OBJECT (dialog), MOVE_TO_DIALOG_ACTION_BUTTON, action_button);
3066         g_object_set_data (G_OBJECT (dialog), MOVE_TO_DIALOG_PANNABLE, folder_view_container);
3067
3068         /* Simulate the behaviour of a HildonPickerDialog by emitting
3069            a response when a folder is selected */
3070         g_signal_connect (*folder_view, "row-activated",
3071                           G_CALLBACK (on_move_to_dialog_row_activated),
3072                           dialog);
3073
3074         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (*folder_view));
3075         g_signal_connect (selection, "changed",
3076                           G_CALLBACK (on_move_to_dialog_selection_changed),
3077                           dialog);
3078
3079         g_signal_connect (action_button, "clicked",
3080                           G_CALLBACK (on_move_to_dialog_action_clicked),
3081                           dialog);
3082
3083         g_signal_connect (back_button, "clicked",
3084                           G_CALLBACK (on_move_to_dialog_back_clicked),
3085                           dialog);
3086
3087         move_to_dialog_show_accounts (dialog);
3088
3089         return dialog;
3090 }
3091
3092 TnyList *
3093 modest_platform_get_list_to_move (ModestWindow *window)
3094 {
3095         TnyList *list = NULL;
3096
3097         if (MODEST_IS_HEADER_WINDOW (window)) {
3098                 ModestHeaderView *header_view;
3099
3100                 header_view = modest_header_window_get_header_view (MODEST_HEADER_WINDOW (window));
3101                 list = modest_header_view_get_selected_headers (header_view);
3102         } else if (MODEST_IS_FOLDER_WINDOW (window)) {
3103                 ModestFolderView *folder_view;
3104                 TnyFolderStore *selected_folder;
3105
3106                 list = TNY_LIST (tny_simple_list_new ());
3107                 folder_view = modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window));
3108                 selected_folder = modest_folder_view_get_selected (folder_view);
3109                 if (selected_folder) {
3110                         tny_list_prepend (list, G_OBJECT (selected_folder));
3111                         g_object_unref (selected_folder);
3112                 }
3113                 return list;
3114         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3115                 TnyHeader *header;
3116
3117                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (window));
3118                 if (header) {
3119                         list = TNY_LIST (tny_simple_list_new ());
3120                         tny_list_prepend (list, G_OBJECT (header));
3121                         g_object_unref (header);
3122                 }
3123         } else {
3124                 g_return_val_if_reached (NULL);
3125         }
3126
3127         return list;
3128 }