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
 951         button = hildon_button_new (MODEST_EDITABLE_SIZE,
 952                                     HILDON_BUTTON_ARRANGEMENT_HORIZONTAL);
 953
 954         hildon_button_set_alignment (HILDON_BUTTON (button), 0.0, 0.5, 1.0, 1.0);
 955
 956         if (suggested) {
 957                 const gchar *acc_id = NULL;
 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                 if (!acc_id)
 974                         modest_folder_view_get_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(helper->folder_view));
 975
 976                 g_object_set_data_full (G_OBJECT (button), FOLDER_PICKER_ORIGINAL_ACCOUNT,
 977                                         g_strdup (acc_id), (GDestroyNotify) g_free);
 978         }
 979
 980         g_signal_connect (G_OBJECT (button), "clicked",
 981                           G_CALLBACK (folder_picker_clicked),
 982                           helper);
 983
 984         return button;
 985 }
 986
 987
 988 static gint
 989 modest_platform_run_folder_common_dialog (GtkWindow *parent_window,
 990                                           TnyFolderStore *suggested_parent,
 991                                           const gchar *dialog_title,
 992                                           const gchar *label_text,
 993                                           const gchar *suggested_name,
 994                                           gboolean show_name,
 995                                           gboolean show_parent,
 996                                           gchar **folder_name,
 997                                           TnyFolderStore **parent)
 998 {
 999         GtkWidget *accept_btn = NULL;
1000         GtkWidget *dialog, *entry = NULL, *label_entry = NULL,  *label_location = NULL, *hbox;
1001         GtkWidget *account_picker = NULL;
1002         GList *buttons = NULL;
1003         gint result;
1004         GtkSizeGroup *sizegroup;
1005         ModestFolderView *folder_view;
1006         ModestWindow *folder_window;
1007         ModestHildon2WindowMgr *window_mgr;
1008         FolderPickerHelper *helper = NULL;
1009         GtkWidget *top_vbox, *top_align;
1010
1011         window_mgr = (ModestHildon2WindowMgr *) modest_runtime_get_window_mgr ();
1012         folder_window = modest_hildon2_window_mgr_get_folder_window (window_mgr);
1013         g_return_val_if_fail (MODEST_IS_FOLDER_WINDOW (folder_window), GTK_RESPONSE_NONE);
1014
1015         folder_view = modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (folder_window));
1016
1017         top_vbox = gtk_vbox_new (FALSE, 0);
1018         top_align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
1019         gtk_alignment_set_padding (GTK_ALIGNMENT (top_align), 0, 0, MODEST_MARGIN_DOUBLE, 0);
1020
1021         /* Ask the user for the folder name */
1022         dialog = gtk_dialog_new_with_buttons (dialog_title,
1023                                               parent_window,
1024                                               GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
1025                                               _FM("ckdg_bd_new_folder_dialog_ok"),
1026                                               GTK_RESPONSE_ACCEPT,
1027                                               NULL);
1028
1029         /* Add accept button (with unsensitive handler) */
1030         buttons = gtk_container_get_children (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area));
1031         accept_btn = GTK_WIDGET (buttons->data);
1032
1033         sizegroup = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
1034
1035         if (show_name) {
1036                 label_entry = gtk_label_new (label_text);
1037                 entry = hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
1038                 gtk_entry_set_max_length (GTK_ENTRY (entry), 20);
1039
1040                 gtk_misc_set_alignment (GTK_MISC (label_entry), 0.0, 0.5);
1041                 gtk_size_group_add_widget (sizegroup, label_entry);
1042
1043                 if (suggested_name)
1044                   gtk_entry_set_text (GTK_ENTRY (entry), suggested_name);
1045                 else
1046                         gtk_entry_set_text (GTK_ENTRY (entry), _FM("ckdg_va_new_folder_name_stub"));
1047                 gtk_entry_set_width_chars (GTK_ENTRY (entry),
1048                                            MAX (g_utf8_strlen (gtk_entry_get_text (GTK_ENTRY (entry)), -1),
1049                                                 g_utf8_strlen (_FM("ckdg_va_new_folder_name_stub"), -1)));
1050                 gtk_entry_select_region (GTK_ENTRY (entry), 0, -1);
1051         }
1052
1053         if (show_parent) {
1054
1055                 label_location = gtk_label_new (_FM("ckdg_fi_new_folder_location"));
1056
1057                 gtk_misc_set_alignment (GTK_MISC (label_location), 0.0, 0.5);
1058                 gtk_size_group_add_widget (sizegroup, label_location);
1059
1060                 helper = g_slice_new0 (FolderPickerHelper);
1061                 helper->folder_view = folder_view;
1062                 helper->entry = (GtkEntry *) entry;
1063
1064                 account_picker = folder_picker_new (suggested_parent, helper);
1065         }
1066
1067         g_object_unref (sizegroup);
1068
1069         /* Connect to the response method to avoid closing the dialog
1070            when an invalid name is selected*/
1071         g_signal_connect (dialog,
1072                           "response",
1073                           G_CALLBACK (on_response),
1074                           suggested_parent);
1075
1076         if (show_name) {
1077                 /* Track entry changes */
1078                 g_signal_connect (entry,
1079                                   "insert-text",
1080                                   G_CALLBACK (entry_insert_text),
1081                                   dialog);
1082                 g_signal_connect (entry,
1083                                   "changed",
1084                                   G_CALLBACK (entry_changed),
1085                                   dialog);
1086         }
1087
1088
1089         /* Some locales like pt_BR need this to get the full window
1090            title shown */
1091         gtk_widget_set_size_request (GTK_WIDGET (dialog), 300, -1);
1092
1093         /* Create the hbox */
1094         if (show_name) {
1095                 hbox = gtk_hbox_new (FALSE, 12);
1096                 gtk_box_pack_start (GTK_BOX (hbox), label_entry, FALSE, FALSE, 0);
1097                 gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
1098
1099                 /* Add hbox to dialog */
1100                 gtk_box_pack_start (GTK_BOX (top_vbox),
1101                                     hbox, FALSE, FALSE, 0);
1102                 g_object_set_data (G_OBJECT (dialog), COMMON_FOLDER_DIALOG_ENTRY, entry);
1103         }
1104
1105         if (show_parent) {
1106                 hbox = gtk_hbox_new (FALSE, 12);
1107                 gtk_box_pack_start (GTK_BOX (hbox), label_location, FALSE, FALSE, 0);
1108                 gtk_box_pack_start (GTK_BOX (hbox), account_picker, TRUE, TRUE, 0);
1109
1110                 /* Add hbox to dialog */
1111                 gtk_box_pack_start (GTK_BOX (top_vbox),
1112                                     hbox, FALSE, FALSE, 0);
1113                 g_object_set_data (G_OBJECT (dialog), COMMON_FOLDER_DIALOG_ACCOUNT_PICKER, account_picker);
1114         }
1115         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1116                                      GTK_WINDOW (dialog), parent_window);
1117
1118         gtk_container_add (GTK_CONTAINER (top_align), top_vbox);
1119         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), top_align, TRUE, TRUE, 0);
1120
1121         gtk_widget_show_all (GTK_WIDGET(dialog));
1122
1123         result = gtk_dialog_run (GTK_DIALOG(dialog));
1124         if (result == GTK_RESPONSE_ACCEPT) {
1125                 if (show_name)
1126                         *folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
1127                 if (show_parent) {
1128                         *parent = g_object_get_data (G_OBJECT (account_picker), FOLDER_PICKER_CURRENT_FOLDER);
1129                         if (*parent)
1130                                 g_object_ref (*parent);
1131                 }
1132         }
1133
1134         gtk_widget_destroy (dialog);
1135
1136         if (helper)
1137                 g_slice_free (FolderPickerHelper, helper);
1138
1139         while (gtk_events_pending ())
1140                 gtk_main_iteration ();
1141
1142         return result;
1143 }
1144
1145 gint
1146 modest_platform_run_new_folder_dialog (GtkWindow *parent_window,
1147                                        TnyFolderStore *suggested_folder,
1148                                        gchar *suggested_name,
1149                                        gchar **folder_name,
1150                                        TnyFolderStore **parent_folder)
1151 {
1152         gchar *real_suggested_name = NULL;
1153         gint result;
1154         ModestTnyAccountStore *acc_store;
1155         TnyAccount *account;
1156         gboolean do_free = FALSE;
1157
1158         real_suggested_name = get_next_folder_name ((const gchar *) suggested_name,
1159                                                     suggested_folder);
1160
1161         /* In hildon 2.2 we always suggest the archive folder as parent */
1162         if (!suggested_folder) {
1163                 acc_store = modest_runtime_get_account_store ();
1164                 account = modest_tny_account_store_get_mmc_folders_account (acc_store);
1165                 if (account) {
1166                         suggested_folder = (TnyFolderStore *)
1167                                 modest_tny_account_get_special_folder (account,
1168                                                                        TNY_FOLDER_TYPE_ARCHIVE);
1169                         g_object_unref (account);
1170                         account = NULL;
1171                 }
1172         }
1173
1174         /* If there is not archive folder then fallback to local folders account */
1175         if (!suggested_folder) {
1176                 do_free = TRUE;
1177                 suggested_folder = (TnyFolderStore *)
1178                         modest_tny_account_store_get_local_folders_account (acc_store);
1179         }
1180
1181         result = modest_platform_run_folder_common_dialog (parent_window,
1182                                                            suggested_folder,
1183                                                            _HL("ckdg_ti_new_folder"),
1184                                                            _FM("ckdg_fi_new_folder_name"),
1185                                                            real_suggested_name,
1186                                                            TRUE,
1187                                                            TRUE,
1188                                                            folder_name,
1189                                                            parent_folder);
1190
1191         if (do_free)
1192                 g_object_unref (suggested_folder);
1193
1194         g_free(real_suggested_name);
1195
1196         return result;
1197 }
1198
1199 gint
1200 modest_platform_run_rename_folder_dialog (GtkWindow *parent_window,
1201                                           TnyFolderStore *parent_folder,
1202                                           const gchar *suggested_name,
1203                                           gchar **folder_name)
1204 {
1205         g_return_val_if_fail (TNY_IS_FOLDER_STORE (parent_folder), GTK_RESPONSE_REJECT);
1206
1207         return modest_platform_run_folder_common_dialog (parent_window,
1208                                                          parent_folder,
1209                                                          _HL("ckdg_ti_rename_folder"),
1210                                                          _HL("ckdg_fi_rename_name"),
1211                                                          suggested_name,
1212                                                          TRUE,
1213                                                          FALSE,
1214                                                          folder_name,
1215                                                          NULL);
1216 }
1217
1218
1219
1220 static void
1221 on_destroy_dialog (GtkWidget *dialog)
1222 {
1223         /* This could happen when the dialogs get programatically
1224            hidden or destroyed (for example when closing the
1225            application while a dialog is being shown) */
1226         if (!GTK_IS_WIDGET (dialog))
1227                 return;
1228
1229         gtk_widget_destroy (dialog);
1230
1231         if (gtk_events_pending ())
1232                 gtk_main_iteration ();
1233 }
1234
1235 gint
1236 modest_platform_run_confirmation_dialog (GtkWindow *parent_window,
1237                                          const gchar *message)
1238 {
1239         GtkWidget *dialog;
1240         gint response;
1241
1242         dialog = hildon_note_new_confirmation (parent_window, message);
1243         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1244                                      GTK_WINDOW (dialog), parent_window);
1245
1246         response = gtk_dialog_run (GTK_DIALOG (dialog));
1247
1248         on_destroy_dialog (dialog);
1249
1250         return response;
1251 }
1252
1253 gint
1254 modest_platform_run_confirmation_dialog_with_buttons (GtkWindow *parent_window,
1255                                                       const gchar *message,
1256                                                       const gchar *button_accept,
1257                                                       const gchar *button_cancel)
1258 {
1259         GtkWidget *dialog;
1260         gint response;
1261
1262         dialog = hildon_note_new_confirmation_add_buttons (parent_window, message,
1263                                                            button_accept, GTK_RESPONSE_ACCEPT,
1264                                                            button_cancel, GTK_RESPONSE_CANCEL,
1265                                                            NULL);
1266
1267         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1268                                      GTK_WINDOW (dialog), parent_window);
1269
1270         response = gtk_dialog_run (GTK_DIALOG (dialog));
1271
1272         on_destroy_dialog (dialog);
1273
1274         return response;
1275 }
1276
1277 void
1278 modest_platform_run_information_dialog (GtkWindow *parent_window,
1279                                         const gchar *message,
1280                                         gboolean block)
1281 {
1282         GtkWidget *note;
1283
1284         note = hildon_note_new_information (parent_window, message);
1285         if (block)
1286                 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
1287                                              GTK_WINDOW (note), parent_window);
1288
1289         if (block) {
1290                 gtk_dialog_run (GTK_DIALOG (note));
1291
1292                 on_destroy_dialog (note);
1293         } else {
1294                 g_signal_connect_swapped (note,
1295                                           "response",
1296                                           G_CALLBACK (on_destroy_dialog),
1297                                           note);
1298
1299                 gtk_widget_show_all (note);
1300         }
1301 }
1302
1303 typedef struct _ConnectAndWaitData {
1304         GMutex *mutex;
1305         GMainLoop *wait_loop;
1306         gboolean has_callback;
1307         gulong handler;
1308 } ConnectAndWaitData;
1309
1310
1311 static void
1312 quit_wait_loop (TnyAccount *account,
1313                 ConnectAndWaitData *data)
1314 {
1315         /* Set the has_callback to TRUE (means that the callback was
1316            executed and wake up every code waiting for cond to be
1317            TRUE */
1318         g_mutex_lock (data->mutex);
1319         data->has_callback = TRUE;
1320         if (data->wait_loop)
1321                 g_main_loop_quit (data->wait_loop);
1322         g_mutex_unlock (data->mutex);
1323 }
1324
1325 static void
1326 on_connection_status_changed (TnyAccount *account,
1327                               TnyConnectionStatus status,
1328                               gpointer user_data)
1329 {
1330         TnyConnectionStatus conn_status;
1331         ConnectAndWaitData *data;
1332
1333         /* Ignore if reconnecting or disconnected */
1334         conn_status = tny_account_get_connection_status (account);
1335         if (conn_status == TNY_CONNECTION_STATUS_RECONNECTING ||
1336             conn_status == TNY_CONNECTION_STATUS_DISCONNECTED)
1337                 return;
1338
1339         /* Remove the handler */
1340         data = (ConnectAndWaitData *) user_data;
1341         g_signal_handler_disconnect (account, data->handler);
1342
1343         /* Quit from wait loop */
1344         quit_wait_loop (account, (ConnectAndWaitData *) user_data);
1345 }
1346
1347 static void
1348 on_tny_camel_account_set_online_cb (TnyCamelAccount *account,
1349                                     gboolean canceled,
1350                                     GError *err,
1351                                     gpointer user_data)
1352 {
1353         /* Quit from wait loop */
1354         quit_wait_loop (TNY_ACCOUNT (account), (ConnectAndWaitData *) user_data);
1355 }
1356
1357 gboolean
1358 modest_platform_connect_and_wait (GtkWindow *parent_window,
1359                                   TnyAccount *account)
1360 {
1361         ConnectAndWaitData *data = NULL;
1362         gboolean device_online;
1363         TnyDevice *device;
1364         TnyConnectionStatus conn_status;
1365         gboolean user_requested;
1366
1367         device = modest_runtime_get_device();
1368         device_online = tny_device_is_online (device);
1369
1370         /* Whether the connection is user requested or automatically
1371            requested, for example via D-Bus */
1372         user_requested = (parent_window) ? TRUE : FALSE;
1373
1374         /* If there is no account check only the device status */
1375         if (!account) {
1376                 if (device_online)
1377                         return TRUE;
1378                 else
1379                         return tny_maemo_conic_device_connect (TNY_MAEMO_CONIC_DEVICE (device),
1380                                                                NULL, user_requested);
1381         }
1382
1383         /* Return if the account is already connected */
1384         conn_status = tny_account_get_connection_status (account);
1385         if (device_online && conn_status == TNY_CONNECTION_STATUS_CONNECTED)
1386                 return TRUE;
1387
1388         /* Create the helper */
1389         data = g_slice_new0 (ConnectAndWaitData);
1390         data->mutex = g_mutex_new ();
1391         data->has_callback = FALSE;
1392
1393         /* Connect the device */
1394         if (!device_online) {
1395                 /* Track account connection status changes */
1396                 data->handler = g_signal_connect (account, "connection-status-changed",
1397                                                   G_CALLBACK (on_connection_status_changed),
1398                                                   data);
1399                 /* Try to connect the device */
1400                 device_online = tny_maemo_conic_device_connect (TNY_MAEMO_CONIC_DEVICE (device),
1401                                                                 NULL, user_requested);
1402
1403                 /* If the device connection failed then exit */
1404                 if (!device_online && data->handler)
1405                         goto frees;
1406         } else {
1407                 /* Force a reconnection of the account */
1408                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (account), TRUE,
1409                                               on_tny_camel_account_set_online_cb, data);
1410         }
1411
1412         /* Wait until the callback is executed */
1413         g_mutex_lock (data->mutex);
1414         if (!data->has_callback) {
1415                 data->wait_loop = g_main_loop_new (g_main_context_new (), FALSE);
1416                 gdk_threads_leave ();
1417                 g_mutex_unlock (data->mutex);
1418                 g_main_loop_run (data->wait_loop);
1419                 g_mutex_lock (data->mutex);
1420                 gdk_threads_enter ();
1421         }
1422         g_mutex_unlock (data->mutex);
1423
1424  frees:
1425         if (g_signal_handler_is_connected (account, data->handler))
1426                 g_signal_handler_disconnect (account, data->handler);
1427         g_mutex_free (data->mutex);
1428         g_main_loop_unref (data->wait_loop);
1429         g_slice_free (ConnectAndWaitData, data);
1430
1431         conn_status = tny_account_get_connection_status (account);
1432         return (conn_status == TNY_CONNECTION_STATUS_CONNECTED) ? TRUE: FALSE;
1433 }
1434
1435 gboolean
1436 modest_platform_connect_and_wait_if_network_account (GtkWindow *parent_window, TnyAccount *account)
1437 {
1438         if (tny_account_get_account_type (account) == TNY_ACCOUNT_TYPE_STORE) {
1439                 if (!modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account))) {
1440                         /* This must be a maildir account, which does not require a connection: */
1441                         return TRUE;
1442                 }
1443         }
1444
1445         return modest_platform_connect_and_wait (parent_window, account);
1446 }
1447
1448 gboolean
1449 modest_platform_connect_and_wait_if_network_folderstore (GtkWindow *parent_window, TnyFolderStore *folder_store)
1450 {
1451         if (!folder_store)
1452                 return TRUE; /* Maybe it is something local. */
1453
1454         gboolean result = TRUE;
1455         if (TNY_IS_FOLDER (folder_store)) {
1456                 /* Get the folder's parent account: */
1457                 TnyAccount *account = tny_folder_get_account(TNY_FOLDER (folder_store));
1458                 if (account != NULL) {
1459                         result = modest_platform_connect_and_wait_if_network_account (NULL, account);
1460                         g_object_unref (account);
1461                 }
1462         } else if (TNY_IS_ACCOUNT (folder_store)) {
1463                 /* Use the folder store as an account: */
1464                 result = modest_platform_connect_and_wait_if_network_account (NULL, TNY_ACCOUNT (folder_store));
1465         }
1466
1467         return result;
1468 }
1469
1470 GtkWidget *
1471 modest_platform_create_sort_dialog       (GtkWindow *parent_window)
1472 {
1473         GtkWidget *dialog;
1474
1475         dialog = modest_hildon2_sort_dialog_new (parent_window);
1476
1477         return dialog;
1478 }
1479
1480
1481 gboolean
1482 modest_platform_set_update_interval (guint minutes)
1483 {
1484 #ifdef MODEST_HAVE_LIBALARM
1485
1486         ModestConf *conf = modest_runtime_get_conf ();
1487         if (!conf)
1488                 return FALSE;
1489
1490         cookie_t alarm_cookie = modest_conf_get_int (conf, MODEST_CONF_ALARM_ID, NULL);
1491
1492         /* Delete any existing alarm,
1493          * because we will replace it: */
1494         if (alarm_cookie) {
1495                 if (alarmd_event_del(alarm_cookie) != 0)
1496                         g_debug ("%s: alarm %d was not on the queue", __FUNCTION__, (int)alarm_cookie);
1497                 alarm_cookie = 0;
1498                 modest_conf_set_int (conf, MODEST_CONF_ALARM_ID, 0, NULL);
1499         }
1500
1501         /* 0 means no updates: */
1502         if (minutes == 0)
1503                 return TRUE;
1504
1505
1506         /* Register alarm: */
1507
1508         /* Set the interval in alarm_event_t structure: */
1509         alarm_event_t *event = alarm_event_create ();
1510         alarm_event_add_actions (event, 1);
1511         alarm_action_t *action = alarm_event_get_action (event, 0);
1512         alarm_event_set_alarm_appid (event, MODEST_ALARMD_APPID);
1513         event->alarm_time = minutes * 60; /* seconds */
1514
1515         /* Set recurrence every few minutes: */
1516         event->recur_secs = minutes*60;
1517         event->recur_count = -1; /* Means infinite */
1518
1519         /* Specify what should happen when the alarm happens:
1520          * It should call this D-Bus method: */
1521
1522         action->dbus_path = g_strdup(MODEST_DBUS_OBJECT);
1523         action->dbus_interface = g_strdup (MODEST_DBUS_IFACE);
1524         action->dbus_service = g_strdup (MODEST_DBUS_SERVICE);
1525         action->dbus_name = g_strdup (MODEST_DBUS_METHOD_SEND_RECEIVE);
1526         action->flags = ALARM_ACTION_WHEN_TRIGGERED | ALARM_ACTION_TYPE_DBUS | ALARM_ACTION_DBUS_USE_ACTIVATION;
1527
1528         /* Use ALARM_EVENT_NO_DIALOG: Otherwise, a dialog will be shown if
1529          * exec_name or dbus_path is NULL, even though we have specified no dialog text.
1530          * Also use ALARM_EVENT_ACTIVATION so that modest is started (without UI) to get emails
1531          * This is why we want to use the Alarm API instead of just g_timeout_add().
1532          * (The old maemo email-client did this, though it isn't specified in the UI spec.)
1533          * ALARM_EVENT_CONNECTED will prevent the alarm from being called in case that the device is offline
1534          */
1535         event->flags = ALARM_EVENT_CONNECTED;
1536
1537         alarm_cookie = alarmd_event_add (event);
1538
1539         /* now, free it */
1540         alarm_event_delete (event);
1541
1542         /* Store the alarm ID in GConf, so we can remove it later:
1543          * This is apparently valid between application instances. */
1544         modest_conf_set_int (conf, MODEST_CONF_ALARM_ID, alarm_cookie, NULL);
1545
1546         if (!alarm_cookie) {
1547             /* Error */
1548             g_warning ("Error setting alarm event. \n");
1549
1550             return FALSE;
1551         }
1552 #endif /* MODEST_HAVE_LIBALARM */
1553         return TRUE;
1554 }
1555
1556 void
1557 modest_platform_push_email_notification(void)
1558 {
1559         gboolean screen_on, app_in_foreground;
1560
1561         /* Get the window status */
1562         app_in_foreground = hildon_program_get_is_topmost (hildon_program_get_instance ());
1563
1564         screen_on = modest_window_mgr_screen_is_on (modest_runtime_get_window_mgr ());
1565
1566         /* If the screen is on and the app is in the
1567            foreground we don't show anything */
1568         if (!(screen_on && app_in_foreground)) {
1569
1570                 modest_platform_play_email_tone ();
1571
1572                 /* Activate LED. This must be deactivated by
1573                    modest_platform_remove_new_mail_notifications */
1574 #ifdef MODEST_HAVE_MCE
1575                 osso_rpc_run_system (modest_maemo_utils_get_osso_context (),
1576                                      MCE_SERVICE,
1577                                      MCE_REQUEST_PATH,
1578                                      MCE_REQUEST_IF,
1579                                      MCE_ACTIVATE_LED_PATTERN,
1580                                      NULL,
1581                                      DBUS_TYPE_STRING, MODEST_NEW_MAIL_LIGHTING_PATTERN,
1582                                      DBUS_TYPE_INVALID);
1583 #endif
1584         }
1585 }
1586
1587 void
1588 modest_platform_on_new_headers_received (GList *URI_list,
1589                                          gboolean show_visual)
1590 {
1591         gboolean screen_on, app_in_foreground;
1592
1593         /* Get the window status */
1594         app_in_foreground = hildon_program_get_is_topmost (hildon_program_get_instance ());
1595         screen_on = modest_window_mgr_screen_is_on (modest_runtime_get_window_mgr ());
1596
1597         /* If the screen is on and the app is in the
1598            foreground we don't show anything */
1599         if (screen_on && app_in_foreground)
1600                 return;
1601
1602         if (g_list_length (URI_list) == 0)
1603                 return;
1604
1605 #ifdef MODEST_HAVE_HILDON_NOTIFY
1606         /* For any other case issue a notification */
1607         HildonNotification *notification;
1608         ModestMsgNotificationData *data;
1609         gint notif_id;
1610         gchar *from;
1611         TnyAccountStore *acc_store;
1612         TnyAccount *account;
1613
1614         data = (ModestMsgNotificationData *) URI_list->data;
1615
1616         /* String is changed in-place. There is no need to
1617            actually dup the data->from string but we just do
1618            it in order not to modify the original contents */
1619         from = g_strdup (data->from);
1620         modest_text_utils_get_display_address (from);
1621
1622         /* Create notification */
1623         notification = hildon_notification_new (from,
1624                                                 data->subject,
1625                                                 "qgn_list_messagin",
1626                                                 MODEST_NOTIFICATION_CATEGORY);
1627         g_free (from);
1628
1629         /* Add DBus action */
1630         hildon_notification_add_dbus_action(notification,
1631                                             "default",
1632                                             "Cancel",
1633                                             MODEST_DBUS_SERVICE,
1634                                             MODEST_DBUS_OBJECT,
1635                                             MODEST_DBUS_IFACE,
1636                                             MODEST_DBUS_METHOD_OPEN_MESSAGE,
1637                                             G_TYPE_STRING, data->uri,
1638                                             -1);
1639
1640         /* Set the led pattern */
1641         notify_notification_set_hint_int32 (NOTIFY_NOTIFICATION (notification),
1642                                             "dialog-type", 4);
1643         notify_notification_set_hint_string(NOTIFY_NOTIFICATION (notification),
1644                                             "led-pattern",
1645                                             MODEST_NEW_MAIL_LIGHTING_PATTERN);
1646
1647         /* Make the notification persistent */
1648         notify_notification_set_hint_byte (NOTIFY_NOTIFICATION (notification),
1649                                            "persistent", TRUE);
1650
1651         /* Set the number of new notifications */
1652         notify_notification_set_hint_int32 (NOTIFY_NOTIFICATION (notification),
1653                                             "amount", g_list_length (URI_list));
1654
1655         /* Set the account of the headers */
1656         acc_store = (TnyAccountStore *) modest_runtime_get_account_store ();
1657         account = tny_account_store_find_account (acc_store, data->uri);
1658         if (account) {
1659                 const gchar *acc_name;
1660                 acc_name =
1661                         modest_tny_account_get_parent_modest_account_name_for_server_account (account);
1662                 notify_notification_set_hint_string(NOTIFY_NOTIFICATION (notification),
1663                                                     "email-account",
1664                                                     acc_name);
1665                 g_object_unref (account);
1666         }
1667
1668         /* Play sound */
1669         modest_platform_play_email_tone ();
1670         if (notify_notification_show (NOTIFY_NOTIFICATION (notification), NULL)) {
1671                 GSList *notifications_list = NULL;
1672
1673                 /* Get previous notifications ids */
1674                 notifications_list = modest_conf_get_list (modest_runtime_get_conf (),
1675                                                            MODEST_CONF_NOTIFICATION_IDS,
1676                                                            MODEST_CONF_VALUE_INT, NULL);
1677
1678                 /* Save id in the list */
1679                 g_object_get(G_OBJECT (notification), "id", &notif_id, NULL);
1680                 notifications_list = g_slist_prepend (notifications_list, GINT_TO_POINTER(notif_id));
1681
1682                 /* We don't listen for the "closed" signal, because we
1683                    don't care about if the notification was removed or
1684                    not to store the list in gconf */
1685
1686                 /* Save the ids */
1687                 modest_conf_set_list (modest_runtime_get_conf (), MODEST_CONF_NOTIFICATION_IDS,
1688                                       notifications_list, MODEST_CONF_VALUE_INT, NULL);
1689
1690                 g_slist_free (notifications_list);
1691         } else {
1692                 g_warning ("Failed to send notification");
1693         }
1694
1695 #endif /*MODEST_HAVE_HILDON_NOTIFY*/
1696 }
1697
1698 void
1699 modest_platform_remove_new_mail_notifications (gboolean only_visuals)
1700 {
1701         if (only_visuals) {
1702 #ifdef MODEST_HAVE_MCE
1703                 osso_rpc_run_system (modest_maemo_utils_get_osso_context (),
1704                                      MCE_SERVICE,
1705                                      MCE_REQUEST_PATH,
1706                                      MCE_REQUEST_IF,
1707                                      MCE_DEACTIVATE_LED_PATTERN,
1708                                      NULL,
1709                                      DBUS_TYPE_STRING, MODEST_NEW_MAIL_LIGHTING_PATTERN,
1710                                      DBUS_TYPE_INVALID);
1711 #endif
1712                 return;
1713         }
1714
1715 #ifdef MODEST_HAVE_HILDON_NOTIFY
1716         GSList *notif_list = NULL;
1717
1718         /* Get previous notifications ids */
1719         notif_list = modest_conf_get_list (modest_runtime_get_conf (),
1720                                            MODEST_CONF_NOTIFICATION_IDS,
1721                                            MODEST_CONF_VALUE_INT, NULL);
1722
1723         while (notif_list) {
1724                 gint notif_id;
1725                 NotifyNotification *notif;
1726
1727                 /* Nasty HACK to remove the notifications, set the id
1728                    of the existing ones and then close them */
1729                 notif_id = GPOINTER_TO_INT(notif_list->data);
1730                 notif = notify_notification_new("dummy", NULL, NULL, NULL);
1731                 g_object_set(G_OBJECT(notif), "id", notif_id, NULL);
1732
1733                 /* Close the notification, note that some ids could be
1734                    already invalid, but we don't care because it does
1735                    not fail */
1736                 notify_notification_close(notif, NULL);
1737                 g_object_unref(notif);
1738
1739                 /* Delete the link, it's like going to the next */
1740                 notif_list = g_slist_delete_link (notif_list, notif_list);
1741         }
1742
1743         /* Save the ids */
1744         modest_conf_set_list (modest_runtime_get_conf (), MODEST_CONF_NOTIFICATION_IDS,
1745                               notif_list, MODEST_CONF_VALUE_INT, NULL);
1746
1747         g_slist_free (notif_list);
1748
1749 #endif /* MODEST_HAVE_HILDON_NOTIFY */
1750 }
1751
1752
1753
1754 GtkWidget *
1755 modest_platform_get_global_settings_dialog ()
1756 {
1757         return modest_hildon2_global_settings_dialog_new ();
1758 }
1759
1760 void
1761 modest_platform_show_help (GtkWindow *parent_window,
1762                            const gchar *help_id)
1763 {
1764         return;
1765 }
1766
1767 void
1768 modest_platform_show_search_messages (GtkWindow *parent_window)
1769 {
1770         osso_return_t result = OSSO_ERROR;
1771
1772         result = osso_rpc_run_with_defaults (modest_maemo_utils_get_osso_context(),
1773                                              "osso_global_search",
1774                                              "search_email", NULL, DBUS_TYPE_INVALID);
1775
1776         if (result != OSSO_OK) {
1777                 g_warning ("%s: osso_rpc_run_with_defaults() failed.\n", __FUNCTION__);
1778         }
1779 }
1780
1781 void
1782 modest_platform_show_addressbook (GtkWindow *parent_window)
1783 {
1784         osso_return_t result = OSSO_ERROR;
1785
1786         result = osso_rpc_run_with_defaults (modest_maemo_utils_get_osso_context(),
1787                                              "osso_addressbook",
1788                                              "top_application", NULL, DBUS_TYPE_INVALID);
1789
1790         if (result != OSSO_OK) {
1791                 g_warning ("%s: osso_rpc_run_with_defaults() failed.\n", __FUNCTION__);
1792         }
1793 }
1794
1795 static GtkWidget *
1796 modest_platform_create_folder_view_full (TnyFolderStoreQuery *query, gboolean do_refresh)
1797 {
1798         GtkWidget *widget = modest_folder_view_new_full (query, do_refresh);
1799
1800         /* Show one account by default */
1801         modest_folder_view_set_style (MODEST_FOLDER_VIEW (widget),
1802                                       MODEST_FOLDER_VIEW_STYLE_SHOW_ONE);
1803
1804         return widget;
1805 }
1806
1807 GtkWidget *
1808 modest_platform_create_folder_view (TnyFolderStoreQuery *query)
1809 {
1810         return modest_platform_create_folder_view_full (query, TRUE);
1811 }
1812
1813 void
1814 banner_finish (gpointer data, GObject *object)
1815 {
1816         ModestWindowMgr *mgr = (ModestWindowMgr *) data;
1817         modest_window_mgr_unregister_banner (mgr);
1818         g_object_unref (mgr);
1819 }
1820
1821 void
1822 modest_platform_information_banner (GtkWidget *parent,
1823                                     const gchar *icon_name,
1824                                     const gchar *text)
1825 {
1826         GtkWidget *banner_parent = NULL;
1827         ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
1828
1829         if (modest_window_mgr_get_num_windows (mgr) == 0)
1830                 return;
1831
1832         if (parent && GTK_IS_WINDOW (parent)) {
1833                 /* If the window is the active one then show the
1834                    banner on top of this window */
1835                 if (gtk_window_is_active (GTK_WINDOW (parent)))
1836                         banner_parent = parent;
1837                 /* If the window is not the topmost but it's visible
1838                    (it's minimized for example) then show the banner
1839                    with no parent */
1840                 else if (GTK_WIDGET_VISIBLE (parent))
1841                         banner_parent = NULL;
1842                 /* If the window is hidden (like the main window when
1843                    running in the background) then do not show
1844                    anything */
1845                 else
1846                         return;
1847         }
1848
1849         modest_platform_system_banner (banner_parent, icon_name, text);
1850 }
1851
1852 void
1853 modest_platform_system_banner (GtkWidget *parent,
1854                                const gchar *icon_name,
1855                                const gchar *text)
1856 {
1857         GtkWidget *banner = NULL;
1858         ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
1859
1860         if (parent && GTK_IS_WINDOW (parent)) {
1861                 if (!gtk_window_is_active (GTK_WINDOW (parent)))
1862                         parent = NULL;
1863         }
1864
1865         banner = hildon_banner_show_information (parent, icon_name, text);
1866
1867         modest_window_mgr_register_banner (mgr);
1868         g_object_ref (mgr);
1869         g_object_weak_ref ((GObject *) banner, banner_finish, mgr);
1870 }
1871
1872 void
1873 modest_platform_information_banner_with_timeout (GtkWidget *parent,
1874                                                  const gchar *icon_name,
1875                                                  const gchar *text,
1876                                                  gint timeout)
1877 {
1878         GtkWidget *banner;
1879
1880         if (modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()) == 0)
1881                 return;
1882
1883         banner = hildon_banner_show_information (parent, icon_name, text);
1884         hildon_banner_set_timeout(HILDON_BANNER(banner), timeout);
1885 }
1886
1887 GtkWidget *
1888 modest_platform_animation_banner (GtkWidget *parent,
1889                                   const gchar *animation_name,
1890                                   const gchar *text)
1891 {
1892         GtkWidget *inf_note = NULL;
1893
1894         g_return_val_if_fail (text != NULL, NULL);
1895
1896         if (modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()) == 0)
1897                 return NULL;
1898
1899         /* If the parent is not visible then do not show */
1900         if (parent && !GTK_WIDGET_VISIBLE (parent))
1901                 return NULL;
1902
1903         inf_note = hildon_banner_show_animation (parent, animation_name, text);
1904
1905         return inf_note;
1906 }
1907
1908 typedef struct
1909 {
1910         GMainLoop* loop;
1911         TnyAccount *account;
1912         gboolean is_online;
1913         gint count_tries;
1914 } CheckAccountIdleData;
1915
1916 #define NUMBER_OF_TRIES 10 /* Try approx every second, ten times. */
1917
1918 static gboolean
1919 on_timeout_check_account_is_online(CheckAccountIdleData* data)
1920 {
1921         gboolean stop_trying = FALSE;
1922         g_return_val_if_fail (data && data->account, FALSE);
1923
1924         printf ("DEBUG: %s: tny_account_get_connection_status()==%d\n", __FUNCTION__,
1925                 tny_account_get_connection_status (data->account));
1926
1927         if (data && data->account &&
1928                 /* We want to wait until TNY_CONNECTION_STATUS_INIT has changed to something else,
1929                  * after which the account is likely to be usable, or never likely to be usable soon: */
1930                 (tny_account_get_connection_status (data->account) != TNY_CONNECTION_STATUS_INIT) )
1931         {
1932                 data->is_online = TRUE;
1933
1934                 stop_trying = TRUE;
1935         } else {
1936                 /* Give up if we have tried too many times: */
1937                 if (data->count_tries >= NUMBER_OF_TRIES) {
1938                         stop_trying = TRUE;
1939                 } else {
1940                         /* Wait for another timeout: */
1941                         ++(data->count_tries);
1942                 }
1943         }
1944
1945         if (stop_trying) {
1946                 /* Allow the function that requested this idle callback to continue: */
1947                 if (data->loop)
1948                         g_main_loop_quit (data->loop);
1949
1950                 if (data->account)
1951                         g_object_unref (data->account);
1952
1953                 return FALSE; /* Don't call this again. */
1954         } else {
1955                 return TRUE; /* Call this timeout callback again. */
1956         }
1957 }
1958
1959 /* Return TRUE immediately if the account is already online,
1960  * otherwise check every second for NUMBER_OF_TRIES seconds and return TRUE as
1961  * soon as the account is online, or FALSE if the account does
1962  * not become online in the NUMBER_OF_TRIES seconds.
1963  * This is useful when the D-Bus method was run immediately after
1964  * the application was started (when using D-Bus activation),
1965  * because the account usually takes a short time to go online.
1966  * The return value is maybe not very useful.
1967  */
1968 gboolean
1969 modest_platform_check_and_wait_for_account_is_online(TnyAccount *account)
1970 {
1971         gboolean is_online;
1972
1973         g_return_val_if_fail (account, FALSE);
1974
1975         if (!tny_device_is_online (modest_runtime_get_device())) {
1976                 printf ("DEBUG: %s: device is offline.\n", __FUNCTION__);
1977                 return FALSE;
1978         }
1979
1980         /* The local_folders account never seems to leave TNY_CONNECTION_STATUS_INIT,
1981          * so we avoid wait unnecessarily: */
1982         if (!modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account)))
1983                 return TRUE;
1984
1985         /* The POP & IMAP store accounts seem to be TNY_CONNECTION_STATUS_DISCONNECTED,
1986          * and that seems to be an OK time to use them. Maybe it's just TNY_CONNECTION_STATUS_INIT that
1987          * we want to avoid. */
1988         if (tny_account_get_connection_status (account) != TNY_CONNECTION_STATUS_INIT)
1989                 return TRUE;
1990
1991         /* This blocks on the result: */
1992         CheckAccountIdleData *data = g_slice_new0 (CheckAccountIdleData);
1993         data->is_online = FALSE;
1994         data->account = account;
1995         g_object_ref (data->account);
1996         data->count_tries = 0;
1997
1998         GMainContext *context = NULL; /* g_main_context_new (); */
1999         data->loop = g_main_loop_new (context, FALSE /* not running */);
2000
2001         g_timeout_add (1000, (GSourceFunc)(on_timeout_check_account_is_online), data);
2002
2003         /* This main loop will run until the idle handler has stopped it: */
2004         g_main_loop_run (data->loop);
2005
2006         g_main_loop_unref (data->loop);
2007         /* g_main_context_unref (context); */
2008
2009         is_online = data->is_online;
2010         g_slice_free (CheckAccountIdleData, data);
2011
2012         return is_online;
2013 }
2014
2015
2016
2017 static void
2018 on_cert_dialog_response (GtkDialog *dialog, gint response_id,  const gchar* cert)
2019 {
2020         /* GTK_RESPONSE_HELP means we need to show the certificate */
2021         if (response_id == GTK_RESPONSE_APPLY) {
2022                 GtkWidget *note;
2023                 gchar *msg;
2024
2025                 /* Do not close the dialog */
2026                 g_signal_stop_emission_by_name (dialog, "response");
2027
2028                 msg = g_strdup_printf (_("mcen_ni_view_unknown_certificate"), cert);
2029                 note = hildon_note_new_information (NULL, msg);
2030                 gtk_dialog_run (GTK_DIALOG(note));
2031                 gtk_widget_destroy (note);
2032         }
2033 }
2034
2035
2036 gboolean
2037 modest_platform_run_certificate_confirmation_dialog (const gchar* server_name,
2038                                                      const gchar *certificate)
2039 {
2040         GtkWidget *note;
2041         gint response;
2042         ModestWindow *win;
2043         HildonWindowStack *stack;
2044
2045         stack = hildon_window_stack_get_default ();
2046         win = MODEST_WINDOW (hildon_window_stack_peek (stack));
2047
2048         if (!win) {
2049                 g_debug ("%s: don't show dialogs if there's no window shown; assuming 'Cancel'",
2050                          __FUNCTION__);
2051                 return FALSE;
2052         }
2053
2054         gchar *question = g_strdup_printf (_("mcen_nc_unknown_certificate"),
2055                                            server_name);
2056
2057         /* We use GTK_RESPONSE_APPLY because we want the button in the
2058            middle of OK and CANCEL the same as the browser does for
2059            example. With GTK_RESPONSE_HELP the view button is aligned
2060            to the left while the other two to the right */
2061         note = hildon_note_new_confirmation_add_buttons  (
2062                 NULL,
2063                 question,
2064                 _HL("wdgt_bd_yes"),     GTK_RESPONSE_OK,
2065                 _HL("wdgt_bd_view"),          GTK_RESPONSE_APPLY,   /* abusing this... */
2066                 _HL("wdgt_bd_no"), GTK_RESPONSE_CANCEL,
2067                 NULL, NULL);
2068
2069         g_signal_connect (G_OBJECT(note), "response",
2070                           G_CALLBACK(on_cert_dialog_response),
2071                           (gpointer) certificate);
2072
2073         response = gtk_dialog_run(GTK_DIALOG(note));
2074
2075         on_destroy_dialog (note);
2076         g_free (question);
2077
2078         return response == GTK_RESPONSE_OK;
2079 }
2080
2081 gboolean
2082 modest_platform_run_alert_dialog (const gchar* prompt,
2083                                   gboolean is_question)
2084 {
2085         ModestWindow *top_win;
2086         HildonWindowStack *stack;
2087
2088         stack = hildon_window_stack_get_default ();
2089         top_win = MODEST_WINDOW (hildon_window_stack_peek (stack));
2090
2091         if (!top_win) {
2092                 g_debug ("%s: don't show dialogs if there's no window shown; assuming 'Cancel'",
2093                          __FUNCTION__);
2094                 return FALSE;
2095         }
2096
2097         gboolean retval = TRUE;
2098         if (is_question) {
2099                 /* The Tinymail documentation says that we should show Yes and No buttons,
2100                  * when it is a question.
2101                  * Obviously, we need tinymail to use more specific error codes instead,
2102                  * so we know what buttons to show. */
2103                 GtkWidget *dialog = GTK_WIDGET (hildon_note_new_confirmation (GTK_WINDOW (top_win),
2104                                                                               prompt));
2105                 modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
2106                                              GTK_WINDOW (dialog), GTK_WINDOW (top_win));
2107
2108                 const int response = gtk_dialog_run (GTK_DIALOG (dialog));
2109                 retval = (response == GTK_RESPONSE_YES) || (response == GTK_RESPONSE_OK);
2110
2111                 on_destroy_dialog (dialog);
2112         } else {
2113                 /* Just show the error text and use the default response: */
2114                 modest_platform_run_information_dialog (GTK_WINDOW (top_win),
2115                                                         prompt, FALSE);
2116         }
2117         return retval;
2118 }
2119
2120 /***************/
2121 typedef struct {
2122         GtkWindow *parent_window;
2123         ModestConnectedPerformer callback;
2124         TnyAccount *account;
2125         gpointer user_data;
2126         gchar *iap;
2127         TnyDevice *device;
2128 } OnWentOnlineInfo;
2129
2130 static void
2131 on_went_online_info_free (OnWentOnlineInfo *info)
2132 {
2133         /* And if we cleanup, we DO cleanup  :-)  */
2134
2135         if (info->device)
2136                 g_object_unref (info->device);
2137         if (info->iap)
2138                 g_free (info->iap);
2139         if (info->parent_window)
2140                 g_object_unref (info->parent_window);
2141         if (info->account)
2142                 g_object_unref (info->account);
2143
2144         g_slice_free (OnWentOnlineInfo, info);
2145
2146         /* We're done ... */
2147
2148         return;
2149 }
2150
2151 static void
2152 on_account_went_online (TnyCamelAccount *account, gboolean canceled, GError *err, gpointer user_data)
2153 {
2154         OnWentOnlineInfo *info = (OnWentOnlineInfo *) user_data;
2155
2156         /* Now it's really time to callback to the caller. If going online didn't succeed,
2157          * err will be set. We don't free it, Tinymail does that! If a cancel happened,
2158          * canceled will be set. Etcetera etcetera. */
2159
2160         if (info->callback) {
2161                 info->callback (canceled, err, info->parent_window, info->account, info->user_data);
2162         }
2163
2164         /* This is our last call, we must cleanup here if we didn't yet do that */
2165         on_went_online_info_free (info);
2166
2167         return;
2168 }
2169
2170
2171 static void
2172 on_conic_device_went_online (TnyMaemoConicDevice *device, const gchar* iap_id, gboolean canceled, GError *err, gpointer user_data)
2173 {
2174         OnWentOnlineInfo *info = (OnWentOnlineInfo *) user_data;
2175         info->iap = g_strdup (iap_id);
2176
2177         if (canceled || err || !info->account) {
2178
2179                 /* If there's a problem or if there's no account (then that's it for us, we callback
2180                  * the caller's callback now. He'll have to handle err or canceled, of course.
2181                  * We are not really online, as the account is not really online here ... */
2182
2183                 /* We'll use the err and the canceled of this cb. TnyMaemoConicDevice delivered us
2184                  * this info. We don't cleanup err, Tinymail does that! */
2185
2186                 if (info->callback) {
2187
2188                         /* info->account can be NULL here, this means that the user did not
2189                          * provide a nice account instance. We'll assume that the user knows
2190                          * what he's doing and is happy with just the device going online.
2191                          *
2192                          * We can't do magic, we don't know what account the user wants to
2193                          * see going online. So just the device goes online, end of story */
2194
2195                         info->callback (canceled, err, info->parent_window, info->account, info->user_data);
2196                 }
2197
2198         } else if (info->account) {
2199
2200                 /* If there's no problem and if we have an account, we'll put the account
2201                  * online too. When done, the callback of bringing the account online
2202                  * will callback the caller's callback. This is the most normal case. */
2203
2204                 info->device = TNY_DEVICE (g_object_ref (device));
2205
2206                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (info->account), TRUE,
2207                                               on_account_went_online, info);
2208
2209                 /* The on_account_went_online cb frees up the info, go look if you
2210                  * don't believe me! (so we return here) */
2211
2212                 return;
2213         }
2214
2215         /* We cleanup if we are not bringing the account online too */
2216         on_went_online_info_free (info);
2217
2218         return;
2219 }
2220
2221 void
2222 modest_platform_connect_and_perform (GtkWindow *parent_window,
2223                                      gboolean force,
2224                                      TnyAccount *account,
2225                                      ModestConnectedPerformer callback,
2226                                      gpointer user_data)
2227 {
2228         gboolean device_online;
2229         TnyDevice *device;
2230         TnyConnectionStatus conn_status;
2231         OnWentOnlineInfo *info;
2232
2233         device = modest_runtime_get_device();
2234         device_online = tny_device_is_online (device);
2235
2236         /* If there is no account check only the device status */
2237         if (!account) {
2238
2239                 if (device_online) {
2240
2241                         /* We promise to instantly perform the callback, so ... */
2242                         if (callback) {
2243                                 callback (FALSE, NULL, parent_window, account, user_data);
2244                         }
2245
2246                 } else {
2247
2248                         info = g_slice_new0 (OnWentOnlineInfo);
2249
2250                         info->iap = NULL;
2251                         info->device = NULL;
2252                         info->account = NULL;
2253
2254                         if (parent_window)
2255                                 info->parent_window = (GtkWindow *) g_object_ref (parent_window);
2256                         else
2257                                 info->parent_window = NULL;
2258                         info->user_data = user_data;
2259                         info->callback = callback;
2260
2261                         tny_maemo_conic_device_connect_async (TNY_MAEMO_CONIC_DEVICE (device), NULL,
2262                                                               force, on_conic_device_went_online,
2263                                                               info);
2264
2265                         /* We'll cleanup in on_conic_device_went_online */
2266                 }
2267
2268                 /* The other code has no more reason to run. This is all that we can do for the
2269                  * caller (he should have given us a nice and clean account instance!). We
2270                  * can't do magic, we don't know what account he intends to bring online. So
2271                  * we'll just bring the device online (and await his false bug report). */
2272
2273                 return;
2274         }
2275
2276
2277         /* Return if the account is already connected */
2278
2279         conn_status = tny_account_get_connection_status (account);
2280         if (device_online && conn_status == TNY_CONNECTION_STATUS_CONNECTED) {
2281
2282                 /* We promise to instantly perform the callback, so ... */
2283                 if (callback) {
2284                         callback (FALSE, NULL, parent_window, account, user_data);
2285                 }
2286
2287                 return;
2288         }
2289
2290         /* Else, we are in a state that requires that we go online before we
2291          * call the caller's callback. */
2292
2293         info = g_slice_new0 (OnWentOnlineInfo);
2294
2295         info->device = NULL;
2296         info->iap = NULL;
2297         info->account = TNY_ACCOUNT (g_object_ref (account));
2298
2299         if (parent_window)
2300                 info->parent_window = (GtkWindow *) g_object_ref (parent_window);
2301         else
2302                 info->parent_window = NULL;
2303
2304         /* So we'll put the callback away for later ... */
2305
2306         info->user_data = user_data;
2307         info->callback = callback;
2308
2309         if (!device_online) {
2310
2311                 /* If also the device is offline, then we connect both the device
2312                  * and the account */
2313
2314                 tny_maemo_conic_device_connect_async (TNY_MAEMO_CONIC_DEVICE (device), NULL,
2315                                                       force, on_conic_device_went_online,
2316                                                       info);
2317
2318         } else {
2319
2320                 /* If the device is online, we'll just connect the account */
2321
2322                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (account), TRUE,
2323                                               on_account_went_online, info);
2324         }
2325
2326         /* The info gets freed by on_account_went_online or on_conic_device_went_online
2327          * in both situations, go look if you don't believe me! */
2328
2329         return;
2330 }
2331
2332 void
2333 modest_platform_connect_if_remote_and_perform (GtkWindow *parent_window,
2334                                                gboolean force,
2335                                                TnyFolderStore *folder_store,
2336                                                ModestConnectedPerformer callback,
2337                                                gpointer user_data)
2338 {
2339         TnyAccount *account = NULL;
2340
2341         if (!folder_store ||
2342             (TNY_IS_MERGE_FOLDER (folder_store) &&
2343              (tny_folder_get_folder_type (TNY_FOLDER(folder_store)) == TNY_FOLDER_TYPE_OUTBOX))) {
2344
2345                 /* We promise to instantly perform the callback, so ... */
2346                 if (callback) {
2347                         GError *error = NULL;
2348                         g_set_error (&error, TNY_ERROR_DOMAIN, TNY_SERVICE_ERROR_UNKNOWN,
2349                                      "Unable to move or not found folder");
2350                         callback (FALSE, error, parent_window, NULL, user_data);
2351                         g_error_free (error);
2352                 }
2353                 return;
2354
2355         } else if (TNY_IS_FOLDER (folder_store)) {
2356                 /* Get the folder's parent account: */
2357                 account = tny_folder_get_account (TNY_FOLDER (folder_store));
2358         } else if (TNY_IS_ACCOUNT (folder_store)) {
2359                 /* Use the folder store as an account: */
2360                 account = TNY_ACCOUNT (g_object_ref (folder_store));
2361         }
2362
2363         if (account && (tny_account_get_account_type (account) == TNY_ACCOUNT_TYPE_STORE)) {
2364                 if (!modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account))) {
2365                         /* No need to connect a local account */
2366                         if (callback)
2367                                 callback (FALSE, NULL, parent_window, account, user_data);
2368
2369                         goto clean;
2370                 }
2371         }
2372         modest_platform_connect_and_perform (parent_window, force, account, callback, user_data);
2373
2374  clean:
2375         if (account)
2376                 g_object_unref (account);
2377 }
2378
2379 static void
2380 src_account_connect_performer (gboolean canceled,
2381                                GError *err,
2382                                GtkWindow *parent_window,
2383                                TnyAccount *src_account,
2384                                gpointer user_data)
2385 {
2386         DoubleConnectionInfo *info = (DoubleConnectionInfo *) user_data;
2387
2388         if (canceled || err) {
2389                 /* If there was any error call the user callback */
2390                 info->callback (canceled, err, parent_window, src_account, info->data);
2391         } else {
2392                 /* Connect the destination account */
2393                 modest_platform_connect_if_remote_and_perform (parent_window, TRUE,
2394                                                                TNY_FOLDER_STORE (info->dst_account),
2395                                                                info->callback, info->data);
2396         }
2397
2398         /* Free the info object */
2399         g_object_unref (info->dst_account);
2400         g_slice_free (DoubleConnectionInfo, info);
2401 }
2402
2403
2404 void
2405 modest_platform_double_connect_and_perform (GtkWindow *parent_window,
2406                                             gboolean force,
2407                                             TnyFolderStore *folder_store,
2408                                             DoubleConnectionInfo *connect_info)
2409 {
2410         modest_platform_connect_if_remote_and_perform(parent_window,
2411                                                       force,
2412                                                       folder_store,
2413                                                       src_account_connect_performer,
2414                                                       connect_info);
2415 }
2416
2417 GtkWidget *
2418 modest_platform_get_account_settings_wizard (void)
2419 {
2420         ModestEasysetupWizardDialog *dialog = modest_easysetup_wizard_dialog_new ();
2421
2422         return GTK_WIDGET (dialog);
2423 }
2424
2425 ModestConnectedVia
2426 modest_platform_get_current_connection (void)
2427 {
2428         TnyDevice *device = NULL;
2429         ModestConnectedVia retval = MODEST_CONNECTED_VIA_ANY;
2430
2431         device = modest_runtime_get_device ();
2432
2433         if (!tny_device_is_online (device))
2434                 return MODEST_CONNECTED_VIA_ANY;
2435
2436 #ifdef MODEST_HAVE_CONIC
2437         /* Get iap id */
2438         const gchar *iap_id = tny_maemo_conic_device_get_current_iap_id (TNY_MAEMO_CONIC_DEVICE (device));
2439         if (iap_id) {
2440                 ConIcIap *iap = tny_maemo_conic_device_get_iap (
2441                         TNY_MAEMO_CONIC_DEVICE (device), iap_id);
2442                 const gchar *bearer_type = con_ic_iap_get_bearer_type (iap);
2443                 if (bearer_type) {
2444                         if (!strcmp (bearer_type, CON_IC_BEARER_WLAN_INFRA) ||
2445                             !strcmp (bearer_type, CON_IC_BEARER_WLAN_ADHOC) ||
2446                             !strcmp (bearer_type, "WIMAX")) {
2447                                 retval = MODEST_CONNECTED_VIA_WLAN_OR_WIMAX;
2448                         } else {
2449                                 retval = MODEST_CONNECTED_VIA_ANY;
2450                         }
2451                 }
2452                 g_object_unref (iap);
2453         }
2454 #else
2455         retval = MODEST_CONNECTED_VIA_WLAN_OR_WIMAX; /* assume WLAN (fast) internet */
2456 #endif /* MODEST_HAVE_CONIC */
2457         return retval;
2458 }
2459
2460
2461
2462 gboolean
2463 modest_platform_check_memory_low (ModestWindow *win,
2464                                   gboolean visuals)
2465 {
2466         gboolean lowmem;
2467
2468         /* are we in low memory state? */
2469         lowmem = osso_mem_in_lowmem_state () ? TRUE : FALSE;
2470
2471         if (win && lowmem && visuals)
2472                 modest_platform_run_information_dialog (
2473                         GTK_WINDOW(win),
2474                         _KR("memr_ib_operation_disabled"),
2475                         TRUE);
2476
2477         if (lowmem)
2478                 g_debug ("%s: low memory reached. disallowing some operations",
2479                          __FUNCTION__);
2480
2481         return lowmem;
2482 }
2483
2484 void
2485 modest_platform_run_folder_details_dialog (GtkWindow *parent_window,
2486                                            TnyFolder *folder)
2487 {
2488         GtkWidget *dialog;
2489
2490         /* Create dialog */
2491         dialog = modest_hildon2_details_dialog_new_with_folder (parent_window, folder);
2492
2493         /* Run dialog */
2494         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
2495                                      GTK_WINDOW (dialog),
2496                                      parent_window);
2497         gtk_widget_show_all (dialog);
2498
2499         g_signal_connect_swapped (dialog, "response",
2500                                   G_CALLBACK (gtk_widget_destroy),
2501                                   dialog);
2502 }
2503
2504 typedef struct _HeaderDetailsGetSizeInfo {
2505         GtkWidget *dialog;
2506         TnyMimePart *part;
2507         guint total;
2508 } HeaderDetailsGetSizeInfo;
2509
2510 static void
2511 header_details_dialog_destroy (gpointer userdata,
2512                                GObject *object)
2513 {
2514         HeaderDetailsGetSizeInfo *info = (HeaderDetailsGetSizeInfo *) userdata;
2515
2516         info->dialog = NULL;
2517 }
2518
2519 static gboolean
2520 idle_get_mime_part_size_cb (gpointer userdata)
2521 {
2522         HeaderDetailsGetSizeInfo *info = (HeaderDetailsGetSizeInfo *) userdata;
2523         gdk_threads_enter ();
2524
2525         if (info->dialog && GTK_WIDGET_VISIBLE (info->dialog)) {
2526                 modest_details_dialog_set_message_size (MODEST_DETAILS_DIALOG (info->dialog),
2527                                                         info->total);
2528         }
2529
2530         if (info->dialog) {
2531                 g_object_weak_unref (G_OBJECT (info->dialog), header_details_dialog_destroy, info);
2532                 info->dialog = NULL;
2533         }
2534         g_object_unref (info->part);
2535         g_slice_free (HeaderDetailsGetSizeInfo, info);
2536
2537         gdk_threads_leave ();
2538
2539         return FALSE;
2540 }
2541
2542 static gpointer
2543 get_mime_part_size_thread (gpointer thr_user_data)
2544 {
2545         HeaderDetailsGetSizeInfo *info = (HeaderDetailsGetSizeInfo *) thr_user_data;
2546         gssize result = 0;
2547         TnyStream *count_stream;
2548
2549         count_stream = modest_count_stream_new ();
2550         result = tny_mime_part_decode_to_stream (info->part, count_stream, NULL);
2551         info->total = modest_count_stream_get_count(MODEST_COUNT_STREAM (count_stream));
2552         if (info->total == 0) {
2553                 modest_count_stream_reset_count(MODEST_COUNT_STREAM (count_stream));
2554                 result = tny_mime_part_write_to_stream (info->part, count_stream, NULL);
2555                 info->total = modest_count_stream_get_count(MODEST_COUNT_STREAM (count_stream));
2556         }
2557
2558         /* if there was an error, don't set the size (this is pretty uncommon) */
2559         if (result < 0) {
2560                 g_warning ("%s: error while writing mime part to stream\n", __FUNCTION__);
2561         }
2562         g_idle_add (idle_get_mime_part_size_cb, info);
2563
2564         return NULL;
2565 }
2566
2567 void
2568 modest_platform_run_header_details_dialog (GtkWindow *parent_window,
2569                                            TnyHeader *header,
2570                                            gboolean async_get_size,
2571                                            TnyMsg *msg)
2572 {
2573         GtkWidget *dialog;
2574
2575         /* Create dialog */
2576         dialog = modest_hildon2_details_dialog_new_with_header (parent_window, header, !async_get_size);
2577
2578         if (async_get_size && msg && TNY_IS_MSG (msg)) {
2579                 HeaderDetailsGetSizeInfo *info;
2580                 info = g_slice_new (HeaderDetailsGetSizeInfo);
2581                 info->dialog = dialog;
2582                 info->total = 0;
2583                 info->part = TNY_MIME_PART (g_object_ref (msg));
2584
2585                 g_object_weak_ref (G_OBJECT (dialog), header_details_dialog_destroy, info);
2586                 g_thread_create (get_mime_part_size_thread, info, FALSE, NULL);
2587         }
2588
2589         /* Run dialog */
2590         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
2591                                      GTK_WINDOW (dialog),
2592                                      parent_window);
2593         gtk_widget_show_all (dialog);
2594
2595         g_signal_connect_swapped (dialog, "response",
2596                                   G_CALLBACK (gtk_widget_destroy),
2597                                   dialog);
2598 }
2599
2600 osso_context_t *
2601 modest_platform_get_osso_context (void)
2602 {
2603         return modest_maemo_utils_get_osso_context ();
2604 }
2605
2606 static void
2607 modest_platform_play_email_tone (void)
2608 {
2609         gchar *mail_tone;
2610         gint mail_volume_int;
2611         int ret;
2612         ca_proplist *pl = NULL;
2613
2614 #ifdef MODEST_USE_PROFILE
2615         gchar *active_profile;
2616         gchar *mail_volume;
2617
2618         active_profile = profile_get_profile ();
2619         mail_tone = profile_get_value (active_profile, PROFILE_MAIL_TONE);
2620         mail_volume = profile_get_value (active_profile, PROFILE_MAIL_VOLUME);
2621         mail_volume_int = profile_parse_int (mail_volume);
2622         g_free (mail_volume);
2623         g_free (active_profile);
2624 #else
2625         mail_tone = MAIL_TONE;
2626         mail_volume_int = 100;
2627 #endif
2628
2629         if (mail_tone && !strstr (mail_tone, "/")) {
2630                 gchar *tmp;
2631
2632                 tmp = g_strconcat ("/usr/share/sounds", mail_tone, NULL);
2633                 g_free (mail_tone);
2634                 mail_tone = tmp;
2635         }
2636
2637         if (mail_volume_int > 0) {
2638
2639                 if (ca_con == NULL) {
2640                         if ((ret = ca_context_create (&ca_con)) != CA_SUCCESS) {
2641                                 g_warning("ca_context_create: %s\n", ca_strerror(ret));
2642                                 return;
2643                         }
2644                 }
2645
2646                 if ((ret = ca_context_open(ca_con)) != CA_SUCCESS) {
2647                         g_warning("ca_context_open: %s\n", ca_strerror(ret));
2648                         return;
2649                 }
2650
2651                 ca_proplist_create(&pl);
2652                 ca_proplist_sets(pl, CA_PROP_MEDIA_FILENAME, mail_tone);
2653                 ca_proplist_setf(pl, CA_PROP_CANBERRA_VOLUME, "%f", (gfloat) mail_volume_int);
2654
2655                 ret = ca_context_play_full(ca_con, 0, pl, NULL, NULL);
2656                 g_debug("ca_context_play_full (vol %f): %s\n", (gfloat) mail_volume_int, ca_strerror(ret));
2657
2658                 ca_proplist_destroy(pl);
2659         }
2660
2661         g_free (mail_tone);
2662 }
2663
2664 #define MOVE_TO_DIALOG_FOLDER_VIEW "folder-view"
2665 #define MOVE_TO_DIALOG_BACK_BUTTON "back-button"
2666 #define MOVE_TO_DIALOG_ACTION_BUTTON "action-button"
2667 #define MOVE_TO_DIALOG_SHOWING_FOLDERS "showing-folders"
2668 #define MOVE_TO_DIALOG_PANNABLE "pannable"
2669 #define MOVE_TO_FOLDER_SEPARATOR "/"
2670
2671 static void
2672 translate_path (gchar **path)
2673 {
2674         gchar **parts;
2675         gchar **current;
2676         GString *output;
2677         gboolean add_separator;
2678
2679         parts = g_strsplit (*path, MOVE_TO_FOLDER_SEPARATOR, 0);
2680         g_free (*path);
2681
2682         current = parts;
2683         output = g_string_new ("");
2684         add_separator = FALSE;
2685
2686         while (*current != NULL) {
2687                 TnyFolderType folder_type;
2688                 gchar *downcase;
2689
2690                 if (add_separator) {
2691                         output = g_string_append (output, MOVE_TO_FOLDER_SEPARATOR);
2692                 } else {
2693                         add_separator = TRUE;
2694                 }
2695
2696                 downcase = g_ascii_strdown (*current, -1);
2697                 folder_type = modest_local_folder_info_get_type (downcase);
2698                 if (strcmp (downcase, "inbox") == 0) {
2699                         output = g_string_append (output, _("mcen_me_folder_inbox"));
2700                 } else if (folder_type == TNY_FOLDER_TYPE_ARCHIVE ||
2701                     folder_type == TNY_FOLDER_TYPE_DRAFTS ||
2702                     folder_type == TNY_FOLDER_TYPE_SENT ||
2703                     folder_type == TNY_FOLDER_TYPE_OUTBOX) {
2704                         output = g_string_append (output, modest_local_folder_info_get_type_display_name (folder_type));
2705                 } else {
2706                         output = g_string_append (output, *current);
2707                 }
2708                 g_free (downcase);
2709
2710                 current++;
2711         }
2712
2713         g_strfreev (parts);
2714         *path = g_string_free (output, FALSE);
2715 }
2716
2717 static void
2718 move_to_dialog_set_selected_folder_store (GtkWidget *dialog,
2719                                           TnyFolderStore *folder_store)
2720 {
2721         GtkWidget *action_button;
2722         GtkWidget *image = NULL;
2723         TnyAccount *account;
2724         gchar *account_name = NULL, *short_name = NULL;
2725
2726         action_button = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_ACTION_BUTTON));
2727
2728         /* Get account name */
2729         if (TNY_IS_FOLDER (folder_store))
2730                 account = tny_folder_get_account (TNY_FOLDER (folder_store));
2731         else
2732                 account = g_object_ref (folder_store);
2733
2734         if (modest_tny_account_is_virtual_local_folders (account))
2735                 account_name = modest_conf_get_string (modest_runtime_get_conf(),
2736                                                        MODEST_CONF_DEVICE_NAME, NULL);
2737
2738         if (!account_name)
2739                 account_name = g_strdup (tny_account_get_name (account));
2740
2741         g_object_unref (account);
2742
2743         /* Set title of button: account or folder name */
2744         if (TNY_IS_FOLDER (folder_store))
2745                 short_name = folder_store_get_display_name (folder_store);
2746         else
2747                 short_name = g_strdup (account_name);
2748
2749         hildon_button_set_title (HILDON_BUTTON (action_button), short_name);
2750
2751         /* Set value of button, folder full name */
2752         if (TNY_IS_CAMEL_FOLDER (folder_store)) {
2753                 const gchar *camel_full_name;
2754                 gchar *last_slash, *full_name;
2755
2756                 camel_full_name = tny_camel_folder_get_full_name (TNY_CAMEL_FOLDER (folder_store));
2757                 last_slash = g_strrstr (camel_full_name, "/");
2758                 if (last_slash) {
2759                         gchar *prefix = g_strndup (camel_full_name, last_slash - camel_full_name + 1);
2760                         full_name = g_strconcat (account_name, MOVE_TO_FOLDER_SEPARATOR, prefix, short_name, NULL);
2761                         g_free (prefix);
2762                 } else {
2763                         full_name = g_strconcat (account_name, MOVE_TO_FOLDER_SEPARATOR,
2764                                                  short_name,
2765                                                  NULL);
2766                 }
2767                 translate_path (&full_name);
2768                 hildon_button_set_value (HILDON_BUTTON (action_button), full_name);
2769                 g_free (full_name);
2770         }
2771         g_free (account_name);
2772         g_free (short_name);
2773
2774         /* Set image for the button */
2775         image = get_image_for_folder_store (folder_store, MODEST_ICON_SIZE_BIG);
2776         if (image)
2777                 hildon_button_set_image (HILDON_BUTTON (action_button), image);
2778 }
2779
2780 static void
2781 move_to_dialog_show_accounts (GtkWidget *dialog)
2782 {
2783         GtkWidget *back_button;
2784         GtkWidget *folder_view;
2785         GtkWidget *pannable;
2786         GtkWidget *action_button;
2787
2788         back_button = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_BACK_BUTTON));
2789         action_button = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_ACTION_BUTTON));
2790         folder_view = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_FOLDER_VIEW));
2791         pannable = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_PANNABLE));
2792
2793         gtk_widget_set_sensitive (back_button, FALSE);
2794         gtk_widget_set_sensitive (action_button, FALSE);
2795
2796         /* Need to set this here, otherwise callbacks called because
2797            of filtering won't perform correctly */
2798         g_object_set_data (G_OBJECT (dialog), MOVE_TO_DIALOG_SHOWING_FOLDERS, GINT_TO_POINTER (FALSE));
2799
2800         /* Reset action button */
2801         hildon_button_set_title (HILDON_BUTTON (action_button), NULL);
2802         hildon_button_set_value (HILDON_BUTTON (action_button), NULL);
2803         hildon_button_set_image (HILDON_BUTTON (action_button), NULL);
2804
2805         modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW (folder_view), NULL);
2806         modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (folder_view), TRUE);
2807         modest_folder_view_set_style (MODEST_FOLDER_VIEW (folder_view), MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
2808         modest_folder_view_unset_filter (MODEST_FOLDER_VIEW (folder_view),
2809                                          MODEST_FOLDER_VIEW_FILTER_HIDE_MCC_FOLDERS);
2810         modest_folder_view_unset_filter (MODEST_FOLDER_VIEW (folder_view),
2811                                        MODEST_FOLDER_VIEW_FILTER_HIDE_LOCAL_FOLDERS);
2812         modest_folder_view_unset_filter (MODEST_FOLDER_VIEW (folder_view),
2813                                          MODEST_FOLDER_VIEW_FILTER_HIDE_ACCOUNTS);
2814         modest_folder_view_set_filter (MODEST_FOLDER_VIEW (folder_view),
2815                                        MODEST_FOLDER_VIEW_FILTER_HIDE_FOLDERS);
2816         hildon_pannable_area_jump_to (HILDON_PANNABLE_AREA (pannable), 0, 0);
2817 }
2818
2819 static void
2820 move_to_dialog_show_folders (GtkWidget *dialog, TnyFolderStore *folder_store)
2821 {
2822         GtkWidget *back_button;
2823         GtkWidget *folder_view;
2824         TnyAccount *account;
2825         const gchar *account_id;
2826         GtkWidget *pannable;
2827         GtkWidget *action_button;
2828
2829         back_button =
2830                 GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_BACK_BUTTON));
2831         action_button =
2832                 GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_ACTION_BUTTON));
2833         folder_view =
2834                 GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_FOLDER_VIEW));
2835         pannable =
2836                 GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_PANNABLE));
2837
2838         gtk_widget_set_sensitive (back_button, TRUE);
2839         gtk_widget_set_sensitive (action_button, TRUE);
2840
2841         /* Need to set this here, otherwise callbacks called because
2842            of filtering won't perform correctly */
2843         g_object_set_data (G_OBJECT (dialog),
2844                            MOVE_TO_DIALOG_SHOWING_FOLDERS,
2845                            GINT_TO_POINTER (TRUE));
2846
2847         account = TNY_ACCOUNT (folder_store);
2848         if (modest_tny_account_is_virtual_local_folders (account)) {
2849                 account_id = tny_account_get_id (account);
2850                 modest_folder_view_set_filter (MODEST_FOLDER_VIEW (folder_view),
2851                                                MODEST_FOLDER_VIEW_FILTER_HIDE_MCC_FOLDERS);
2852         } else if (modest_tny_account_is_memory_card_account (account)) {
2853                 account_id = tny_account_get_id (account);
2854                 modest_folder_view_set_filter (MODEST_FOLDER_VIEW (folder_view),
2855                                                MODEST_FOLDER_VIEW_FILTER_HIDE_LOCAL_FOLDERS);
2856         } else {
2857                 account_id = tny_account_get_id (account);
2858                 modest_folder_view_set_filter (MODEST_FOLDER_VIEW (folder_view),
2859                                                MODEST_FOLDER_VIEW_FILTER_HIDE_LOCAL_FOLDERS);
2860                 modest_folder_view_set_filter (MODEST_FOLDER_VIEW (folder_view),
2861                                                MODEST_FOLDER_VIEW_FILTER_HIDE_MCC_FOLDERS);
2862         }
2863
2864         move_to_dialog_set_selected_folder_store (dialog, folder_store);
2865         modest_folder_view_set_account_id_of_visible_server_account (MODEST_FOLDER_VIEW (folder_view),
2866                                                                      account_id);
2867
2868         modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (folder_view), FALSE);
2869         modest_folder_view_set_style (MODEST_FOLDER_VIEW (folder_view), MODEST_FOLDER_VIEW_STYLE_SHOW_ONE);
2870         modest_folder_view_set_filter (MODEST_FOLDER_VIEW (folder_view), MODEST_FOLDER_VIEW_FILTER_HIDE_ACCOUNTS);
2871         modest_folder_view_unset_filter (MODEST_FOLDER_VIEW (folder_view), MODEST_FOLDER_VIEW_FILTER_HIDE_FOLDERS);
2872         hildon_pannable_area_jump_to (HILDON_PANNABLE_AREA (pannable), 0, 0);
2873 }
2874
2875 static void
2876 on_move_to_dialog_back_clicked (GtkButton *button,
2877                                 gpointer userdata)
2878 {
2879         GtkWidget *dialog = (GtkWidget *) userdata;
2880
2881         /* Back to show accounts */
2882         move_to_dialog_show_accounts (dialog);
2883 }
2884
2885 static void
2886 on_move_to_dialog_row_activated (GtkTreeView       *tree_view,
2887                                     GtkTreePath       *path,
2888                                     GtkTreeViewColumn *column,
2889                                     gpointer           user_data)
2890 {
2891         TnyFolderStore *selected = NULL;
2892         GtkWidget *dialog;
2893         GtkWidget *folder_view;
2894         gboolean showing_folders;
2895
2896         dialog = (GtkWidget *) user_data;
2897         showing_folders = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dialog),
2898                                                               MOVE_TO_DIALOG_SHOWING_FOLDERS));
2899
2900         folder_view = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog),
2901                                                      MOVE_TO_DIALOG_FOLDER_VIEW));
2902
2903         selected = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2904         if (!selected)
2905                 return;
2906
2907         if (!showing_folders) {
2908                 gboolean valid = TRUE;
2909
2910                 if (TNY_IS_ACCOUNT (selected) &&
2911                     modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (selected))) {
2912                         ModestProtocolType protocol_type;
2913
2914                         protocol_type = modest_tny_account_get_protocol_type (TNY_ACCOUNT (selected));
2915                         valid  = !modest_protocol_registry_protocol_type_has_tag
2916                                 (modest_runtime_get_protocol_registry (),
2917                                  protocol_type,
2918                                  MODEST_PROTOCOL_REGISTRY_STORE_FORBID_MESSAGE_ADD);
2919                 }
2920                 if (valid)
2921                         move_to_dialog_show_folders (dialog, selected);
2922         } else {
2923                 move_to_dialog_set_selected_folder_store (dialog, selected);
2924         }
2925 }
2926
2927 static void
2928 on_move_to_dialog_selection_changed (GtkTreeSelection *selection,
2929                                      gpointer          user_data)
2930 {
2931         gboolean showing_folders;
2932         GtkWidget *dialog;
2933
2934         dialog = (GtkWidget *) user_data;
2935         showing_folders = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_SHOWING_FOLDERS));
2936         if (showing_folders) {
2937                 TnyFolderStore *selected;
2938                 GtkWidget *folder_view;
2939
2940                 folder_view = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_FOLDER_VIEW));
2941                 selected = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2942
2943                 if (selected) {
2944                         move_to_dialog_set_selected_folder_store (dialog, selected);
2945                         g_object_unref (selected);
2946                 }
2947         }
2948 }
2949
2950 static void
2951 on_move_to_dialog_action_clicked (GtkButton *selection,
2952                                   gpointer   user_data)
2953 {
2954         GtkWidget *dialog;
2955         gboolean showing_folders;
2956
2957         dialog = (GtkWidget *) user_data;
2958         showing_folders = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_SHOWING_FOLDERS));
2959         if (showing_folders) {
2960                 TnyFolderStore *selected;
2961                 GtkWidget *folder_view;
2962
2963                 folder_view = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), MOVE_TO_DIALOG_FOLDER_VIEW));
2964                 selected = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
2965
2966                 if (selected) {
2967                         /* It's not possible to select root folders as
2968                            targets unless they're the local account or
2969                            the memory card account */
2970                         if ((TNY_IS_FOLDER (selected) && !TNY_IS_MERGE_FOLDER (selected)) ||
2971                             (TNY_IS_ACCOUNT (selected) &&
2972                              (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (selected)) ||
2973                               modest_tny_account_is_memory_card_account (TNY_ACCOUNT (selected)))))
2974                                 gtk_dialog_response  (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
2975                         g_object_unref (selected);
2976                 }
2977         }
2978 }
2979
2980 static void
2981 move_to_dialog_activity_changed (ModestFolderView *folder_view, gboolean activity, GtkDialog *dialog)
2982 {
2983         hildon_gtk_window_set_progress_indicator (GTK_WINDOW (dialog), activity?1:0);
2984 }
2985
2986 GtkWidget *
2987 modest_platform_create_move_to_dialog (GtkWindow *parent_window,
2988                                        GtkWidget **folder_view)
2989 {
2990         GtkWidget *dialog, *folder_view_container;
2991         GtkWidget *align;
2992         GtkWidget *buttons_hbox;
2993         GtkWidget *back_button;
2994         GdkPixbuf *back_pixbuf;
2995         GtkWidget *top_vbox;
2996         GtkWidget *action_button;
2997         GtkTreeSelection *selection;
2998
2999         /* Create dialog. We cannot use a touch selector because we
3000            need to use here the folder view widget directly */
3001         dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
3002                                               GTK_WINDOW (parent_window),
3003                                               GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR |
3004                                               GTK_DIALOG_DESTROY_WITH_PARENT,
3005                                               _HL("wdgt_bd_new"), MODEST_GTK_RESPONSE_NEW_FOLDER,
3006                                               NULL);
3007
3008         align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
3009         gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, MODEST_MARGIN_DOUBLE, MODEST_MARGIN_NONE);
3010         top_vbox = gtk_vbox_new (FALSE, MODEST_MARGIN_HALF);
3011
3012         /* Create folder view */
3013         *folder_view = modest_platform_create_folder_view_full (NULL, FALSE);
3014         g_signal_connect (G_OBJECT (*folder_view), "activity-changed", G_CALLBACK (move_to_dialog_activity_changed),
3015                           dialog);
3016
3017         modest_folder_view_set_cell_style (MODEST_FOLDER_VIEW (*folder_view),
3018                                            MODEST_FOLDER_VIEW_CELL_STYLE_COMPACT);
3019         modest_folder_view_show_message_count (MODEST_FOLDER_VIEW (*folder_view),
3020                                                FALSE);
3021         tny_account_store_view_set_account_store (TNY_ACCOUNT_STORE_VIEW (*folder_view),
3022                                                   (TnyAccountStore *) modest_runtime_get_account_store ());
3023
3024         buttons_hbox = gtk_hbox_new (FALSE, MODEST_MARGIN_HALF);
3025         back_button = gtk_button_new ();
3026         back_pixbuf = modest_platform_get_icon (_FM("filemanager_folder_up"), MODEST_ICON_SIZE_BIG);
3027         if (back_pixbuf) {
3028                 gtk_button_set_image (GTK_BUTTON (back_button), gtk_image_new_from_pixbuf (back_pixbuf));
3029                 g_object_unref (back_pixbuf);
3030         }
3031
3032         action_button = hildon_button_new (HILDON_SIZE_AUTO_WIDTH | HILDON_SIZE_FINGER_HEIGHT,
3033                                            HILDON_BUTTON_ARRANGEMENT_VERTICAL);
3034         gtk_button_set_alignment (GTK_BUTTON (action_button), 0.0, 0.5);
3035
3036         gtk_box_pack_start (GTK_BOX (buttons_hbox), back_button, FALSE, FALSE, 0);
3037         gtk_box_pack_start (GTK_BOX (buttons_hbox), action_button, TRUE, TRUE, 0);
3038         gtk_widget_set_sensitive (GTK_WIDGET (back_button), FALSE);
3039         gtk_widget_set_sensitive (GTK_WIDGET (action_button), FALSE);
3040         gtk_box_pack_start (GTK_BOX (top_vbox), buttons_hbox, FALSE, FALSE, 0);
3041
3042         /* Create pannable and add it to the dialog */
3043         folder_view_container = hildon_pannable_area_new ();
3044         gtk_container_add (GTK_CONTAINER (folder_view_container), *folder_view);
3045         gtk_box_pack_start (GTK_BOX (top_vbox), folder_view_container, TRUE, TRUE, 0);
3046
3047         gtk_container_add (GTK_CONTAINER (align), top_vbox);
3048         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), align, TRUE, TRUE, 0);
3049
3050         gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 300);
3051
3052         gtk_widget_show (GTK_DIALOG (dialog)->vbox);
3053         gtk_widget_show (folder_view_container);
3054         gtk_widget_show (align);
3055         gtk_widget_show (top_vbox);
3056         gtk_widget_show (*folder_view);
3057         gtk_widget_show_all (back_button);
3058         gtk_widget_show (action_button);
3059         gtk_widget_show (buttons_hbox);
3060         gtk_widget_show (dialog);
3061
3062         g_object_set_data (G_OBJECT (dialog), MOVE_TO_DIALOG_FOLDER_VIEW, *folder_view);
3063         g_object_set_data (G_OBJECT (dialog), MOVE_TO_DIALOG_BACK_BUTTON, back_button);
3064         g_object_set_data (G_OBJECT (dialog), MOVE_TO_DIALOG_ACTION_BUTTON, action_button);
3065         g_object_set_data (G_OBJECT (dialog), MOVE_TO_DIALOG_PANNABLE, folder_view_container);
3066
3067         /* Simulate the behaviour of a HildonPickerDialog by emitting
3068            a response when a folder is selected */
3069         g_signal_connect (*folder_view, "row-activated",
3070                           G_CALLBACK (on_move_to_dialog_row_activated),
3071                           dialog);
3072
3073         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (*folder_view));
3074         g_signal_connect (selection, "changed",
3075                           G_CALLBACK (on_move_to_dialog_selection_changed),
3076                           dialog);
3077
3078         g_signal_connect (action_button, "clicked",
3079                           G_CALLBACK (on_move_to_dialog_action_clicked),
3080                           dialog);
3081
3082         g_signal_connect (back_button, "clicked",
3083                           G_CALLBACK (on_move_to_dialog_back_clicked),
3084                           dialog);
3085
3086         move_to_dialog_show_accounts (dialog);
3087
3088         return dialog;
3089 }
3090
3091 TnyList *
3092 modest_platform_get_list_to_move (ModestWindow *window)
3093 {
3094         TnyList *list = NULL;
3095
3096         if (MODEST_IS_HEADER_WINDOW (window)) {
3097                 ModestHeaderView *header_view;
3098
3099                 header_view = modest_header_window_get_header_view (MODEST_HEADER_WINDOW (window));
3100                 list = modest_header_view_get_selected_headers (header_view);
3101         } else if (MODEST_IS_FOLDER_WINDOW (window)) {
3102                 ModestFolderView *folder_view;
3103                 TnyFolderStore *selected_folder;
3104
3105                 list = TNY_LIST (tny_simple_list_new ());
3106                 folder_view = modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window));
3107                 selected_folder = modest_folder_view_get_selected (folder_view);
3108                 if (selected_folder) {
3109                         tny_list_prepend (list, G_OBJECT (selected_folder));
3110                         g_object_unref (selected_folder);
3111                 }
3112                 return list;
3113         } else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
3114                 TnyHeader *header;
3115
3116                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (window));
3117                 if (header) {
3118                         list = TNY_LIST (tny_simple_list_new ());
3119                         tny_list_prepend (list, G_OBJECT (header));
3120                         g_object_unref (header);
3121                 }
3122         } else {
3123                 g_return_val_if_reached (NULL);
3124         }
3125
3126         return list;
3127 }