git.maemo.org Git - modest/blob - src/widgets/modest-folder-view.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 <glib/gi18n.h>
  31 #include <string.h>
  32 #include <gdk/gdkkeysyms.h>
  33 #include <tny-account-store-view.h>
  34 #include <tny-gtk-account-list-model.h>
  35 #include <tny-gtk-folder-store-tree-model.h>
  36 #include <tny-gtk-header-list-model.h>
  37 #include <tny-folder.h>
  38 #include <tny-folder-store-observer.h>
  39 #include <tny-account-store.h>
  40 #include <tny-account.h>
  41 #include <tny-folder.h>
  42 #include <tny-camel-folder.h>
  43 #include <tny-simple-list.h>
  44 #include <modest-tny-account.h>
  45 #include <modest-tny-folder.h>
  46 #include <modest-tny-local-folders-account.h>
  47 #include <modest-tny-outbox-account.h>
  48 #include <modest-marshal.h>
  49 #include <modest-icon-names.h>
  50 #include <modest-tny-account-store.h>
  51 #include <modest-text-utils.h>
  52 #include <modest-runtime.h>
  53 #include "modest-folder-view.h"
  54 #include <modest-dnd.h>
  55 #include <modest-platform.h>
  56 #include <modest-widget-memory.h>
  57 #include <modest-ui-actions.h>
  58
  59 /* 'private'/'protected' functions */
  60 static void modest_folder_view_class_init  (ModestFolderViewClass *klass);
  61 static void modest_folder_view_init        (ModestFolderView *obj);
  62 static void modest_folder_view_finalize    (GObject *obj);
  63
  64 static void         tny_account_store_view_init (gpointer g,
  65                                                  gpointer iface_data);
  66
  67 static void         modest_folder_view_set_account_store (TnyAccountStoreView *self,
  68                                                           TnyAccountStore     *account_store);
  69
  70 static void         on_selection_changed   (GtkTreeSelection *sel, gpointer data);
  71
  72 static void         on_account_update      (TnyAccountStore *account_store,
  73                                             const gchar *account,
  74                                             gpointer user_data);
  75
  76 static void         on_account_removed     (TnyAccountStore *self,
  77                                             TnyAccount *account,
  78                                             gpointer user_data);
  79
  80 static void         on_accounts_reloaded   (TnyAccountStore *store,
  81                                             gpointer user_data);
  82
  83 static gint         cmp_rows               (GtkTreeModel *tree_model,
  84                                             GtkTreeIter *iter1,
  85                                             GtkTreeIter *iter2,
  86                                             gpointer user_data);
  87
  88 static gboolean     filter_row             (GtkTreeModel *model,
  89                                             GtkTreeIter *iter,
  90                                             gpointer data);
  91
  92 static gboolean     on_key_pressed         (GtkWidget *self,
  93                                             GdkEventKey *event,
  94                                             gpointer user_data);
  95
  96 static void         on_configuration_key_changed         (ModestConf* conf,
  97                                                           const gchar *key,
  98                                                           ModestConfEvent event,
  99                                                           ModestFolderView *self);
 100
 101 /* DnD functions */
 102 static void         on_drag_data_get       (GtkWidget *widget,
 103                                             GdkDragContext *context,
 104                                             GtkSelectionData *selection_data,
 105                                             guint info,
 106                                             guint time,
 107                                             gpointer data);
 108
 109 static void         on_drag_data_received  (GtkWidget *widget,
 110                                             GdkDragContext *context,
 111                                             gint x,
 112                                             gint y,
 113                                             GtkSelectionData *selection_data,
 114                                             guint info,
 115                                             guint time,
 116                                             gpointer data);
 117
 118 static gboolean     on_drag_motion         (GtkWidget      *widget,
 119                                             GdkDragContext *context,
 120                                             gint            x,
 121                                             gint            y,
 122                                             guint           time,
 123                                             gpointer        user_data);
 124
 125 static gint         expand_row_timeout     (gpointer data);
 126
 127 static void         setup_drag_and_drop    (GtkTreeView *self);
 128
 129 static gboolean     _clipboard_set_selected_data (ModestFolderView *folder_view, gboolean delete);
 130
 131 static void         _clear_hidding_filter (ModestFolderView *folder_view);
 132
 133
 134
 135 enum {
 136         FOLDER_SELECTION_CHANGED_SIGNAL,
 137         FOLDER_DISPLAY_NAME_CHANGED_SIGNAL,
 138         LAST_SIGNAL
 139 };
 140
 141 typedef struct _ModestFolderViewPrivate ModestFolderViewPrivate;
 142 struct _ModestFolderViewPrivate {
 143         TnyAccountStore      *account_store;
 144         TnyFolderStore       *cur_folder_store;
 145
 146         gulong                account_update_signal;
 147         gulong                changed_signal;
 148         gulong                accounts_reloaded_signal;
 149         gulong                account_removed_signal;
 150         gulong                conf_key_signal;
 151
 152         /* not unref this object, its a singlenton */
 153         ModestEmailClipboard *clipboard;
 154
 155         /* Filter tree model */
 156         gchar **hidding_ids;
 157         guint n_selected;
 158
 159         TnyFolderStoreQuery  *query;
 160         guint                 timer_expander;
 161
 162         gchar                *local_account_name;
 163         gchar                *visible_account_id;
 164         ModestFolderViewStyle style;
 165
 166         gboolean              reselect; /* we use this to force a reselection of the INBOX */
 167 };
 168 #define MODEST_FOLDER_VIEW_GET_PRIVATE(o)                       \
 169         (G_TYPE_INSTANCE_GET_PRIVATE((o),                       \
 170                                      MODEST_TYPE_FOLDER_VIEW,   \
 171                                      ModestFolderViewPrivate))
 172 /* globals */
 173 static GObjectClass *parent_class = NULL;
 174
 175 static guint signals[LAST_SIGNAL] = {0};
 176
 177 GType
 178 modest_folder_view_get_type (void)
 179 {
 180         static GType my_type = 0;
 181         if (!my_type) {
 182                 static const GTypeInfo my_info = {
 183                         sizeof(ModestFolderViewClass),
 184                         NULL,           /* base init */
 185                         NULL,           /* base finalize */
 186                         (GClassInitFunc) modest_folder_view_class_init,
 187                         NULL,           /* class finalize */
 188                         NULL,           /* class data */
 189                         sizeof(ModestFolderView),
 190                         1,              /* n_preallocs */
 191                         (GInstanceInitFunc) modest_folder_view_init,
 192                         NULL
 193                 };
 194
 195                 static const GInterfaceInfo tny_account_store_view_info = {
 196                         (GInterfaceInitFunc) tny_account_store_view_init, /* interface_init */
 197                         NULL,         /* interface_finalize */
 198                         NULL          /* interface_data */
 199                 };
 200
 201
 202                 my_type = g_type_register_static (GTK_TYPE_TREE_VIEW,
 203                                                   "ModestFolderView",
 204                                                   &my_info, 0);
 205
 206                 g_type_add_interface_static (my_type,
 207                                              TNY_TYPE_ACCOUNT_STORE_VIEW,
 208                                              &tny_account_store_view_info);
 209         }
 210         return my_type;
 211 }
 212
 213 static void
 214 modest_folder_view_class_init (ModestFolderViewClass *klass)
 215 {
 216         GObjectClass *gobject_class;
 217         gobject_class = (GObjectClass*) klass;
 218
 219         parent_class            = g_type_class_peek_parent (klass);
 220         gobject_class->finalize = modest_folder_view_finalize;
 221
 222         g_type_class_add_private (gobject_class,
 223                                   sizeof(ModestFolderViewPrivate));
 224
 225         signals[FOLDER_SELECTION_CHANGED_SIGNAL] =
 226                 g_signal_new ("folder_selection_changed",
 227                               G_TYPE_FROM_CLASS (gobject_class),
 228                               G_SIGNAL_RUN_FIRST,
 229                               G_STRUCT_OFFSET (ModestFolderViewClass,
 230                                                folder_selection_changed),
 231                               NULL, NULL,
 232                               modest_marshal_VOID__POINTER_BOOLEAN,
 233                               G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_BOOLEAN);
 234
 235         /*
 236          * This signal is emitted whenever the currently selected
 237          * folder display name is computed. Note that the name could
 238          * be different to the folder name, because we could append
 239          * the unread messages count to the folder name to build the
 240          * folder display name
 241          */
 242         signals[FOLDER_DISPLAY_NAME_CHANGED_SIGNAL] =
 243                 g_signal_new ("folder-display-name-changed",
 244                               G_TYPE_FROM_CLASS (gobject_class),
 245                               G_SIGNAL_RUN_FIRST,
 246                               G_STRUCT_OFFSET (ModestFolderViewClass,
 247                                                folder_display_name_changed),
 248                               NULL, NULL,
 249                               g_cclosure_marshal_VOID__STRING,
 250                               G_TYPE_NONE, 1, G_TYPE_STRING);
 251 }
 252
 253 /* Simplify checks for NULLs: */
 254 static gboolean strings_are_equal (const gchar *a, const gchar *b)
 255 {
 256         if (!a && !b)
 257                 return TRUE;
 258         if (a && b)
 259         {
 260                 return (strcmp (a, b) == 0);
 261         }
 262         else
 263                 return FALSE;
 264 }
 265
 266 static gboolean on_model_foreach_set_name(GtkTreeModel *model, GtkTreePath *path,  GtkTreeIter *iter, gpointer data)
 267 {
 268         GObject *instance = NULL;
 269
 270         gtk_tree_model_get (model, iter,
 271                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &instance,
 272                             -1);
 273
 274         if (!instance)
 275                 return FALSE; /* keep walking */
 276
 277         if (!TNY_IS_ACCOUNT (instance)) {
 278                 g_object_unref (instance);
 279                 return FALSE; /* keep walking */
 280         }
 281
 282         /* Check if this is the looked-for account: */
 283         TnyAccount *this_account = TNY_ACCOUNT (instance);
 284         TnyAccount *account = TNY_ACCOUNT (data);
 285
 286         const gchar *this_account_id = tny_account_get_id(this_account);
 287         const gchar *account_id = tny_account_get_id(account);
 288         g_object_unref (instance);
 289         instance = NULL;
 290
 291         /* printf ("DEBUG: %s: this_account_id=%s, account_id=%s\n", __FUNCTION__, this_account_id, account_id); */
 292         if (strings_are_equal(this_account_id, account_id)) {
 293                 /* Tell the model that the data has changed, so that
 294                  * it calls the cell_data_func callbacks again: */
 295                 /* TODO: This does not seem to actually cause the new string to be shown: */
 296                 gtk_tree_model_row_changed (model, path, iter);
 297
 298                 return TRUE; /* stop walking */
 299         }
 300
 301         return FALSE; /* keep walking */
 302 }
 303
 304 typedef struct
 305 {
 306         ModestFolderView *self;
 307         gchar *previous_name;
 308 } GetMmcAccountNameData;
 309
 310 static void on_get_mmc_account_name (TnyStoreAccount* account, gpointer user_data)
 311 {
 312         /* printf ("DEBU1G: %s: account name=%s\n", __FUNCTION__, tny_account_get_name (TNY_ACCOUNT(account))); */
 313
 314         GetMmcAccountNameData *data = (GetMmcAccountNameData*)user_data;
 315
 316         if (!strings_are_equal (
 317                 tny_account_get_name(TNY_ACCOUNT(account)),
 318                 data->previous_name)) {
 319
 320                 /* Tell the model that the data has changed, so that
 321                  * it calls the cell_data_func callbacks again: */
 322                 ModestFolderView *self = data->self;
 323                 GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
 324                 if (model)
 325                         gtk_tree_model_foreach(model, on_model_foreach_set_name, account);
 326         }
 327
 328         g_free (data->previous_name);
 329         g_slice_free (GetMmcAccountNameData, data);
 330 }
 331
 332 static void
 333 text_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 334                  GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer data)
 335 {
 336         ModestFolderViewPrivate *priv;
 337         GObject *rendobj;
 338         gchar *fname = NULL;
 339         gint unread = 0;
 340         gint all = 0;
 341         TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
 342         GObject *instance = NULL;
 343
 344         g_return_if_fail (column);
 345         g_return_if_fail (tree_model);
 346
 347         gtk_tree_model_get (tree_model, iter,
 348                             TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, &fname,
 349                             TNY_GTK_FOLDER_STORE_TREE_MODEL_ALL_COLUMN, &all,
 350                             TNY_GTK_FOLDER_STORE_TREE_MODEL_UNREAD_COLUMN, &unread,
 351                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &type,
 352                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &instance,
 353                             -1);
 354         rendobj = G_OBJECT(renderer);
 355
 356         if (!fname)
 357                 return;
 358
 359         if (!instance) {
 360                 g_free (fname);
 361                 return;
 362         }
 363
 364         ModestFolderView *self = MODEST_FOLDER_VIEW (data);
 365         priv =  MODEST_FOLDER_VIEW_GET_PRIVATE (self);
 366
 367         gchar *item_name = NULL;
 368         gint item_weight = 400;
 369
 370         if (type != TNY_FOLDER_TYPE_ROOT) {
 371                 gint number = 0;
 372
 373                 if (modest_tny_folder_is_local_folder (TNY_FOLDER (instance))) {
 374                         type = modest_tny_folder_get_local_folder_type (TNY_FOLDER (instance));
 375                         if (type != TNY_FOLDER_TYPE_UNKNOWN) {
 376                                 g_free (fname);
 377                                 fname = g_strdup(modest_local_folder_info_get_type_display_name (type));
 378                         }
 379                 }
 380
 381                 /* Select the number to show: the unread or unsent messages */
 382                 if ((type == TNY_FOLDER_TYPE_DRAFTS) || (type == TNY_FOLDER_TYPE_OUTBOX))
 383                         number = all;
 384                 else
 385                         number = unread;
 386
 387                 /* Use bold font style if there are unread or unset messages */
 388                 if (number > 0) {
 389                         item_name = g_strdup_printf ("%s (%d)", fname, number);
 390                         item_weight = 800;
 391                 } else {
 392                         item_name = g_strdup (fname);
 393                         item_weight = 400;
 394                 }
 395
 396         } else if (TNY_IS_ACCOUNT (instance)) {
 397                 /* If it's a server account */
 398                 if (modest_tny_account_is_virtual_local_folders (
 399                                 TNY_ACCOUNT (instance))) {
 400                         item_name = g_strdup (priv->local_account_name);
 401                         item_weight = 800;
 402                 } else if (modest_tny_account_is_memory_card_account (
 403                                 TNY_ACCOUNT (instance))) {
 404                         /* fname is only correct when the items are first
 405                          * added to the model, not when the account is
 406                          * changed later, so get the name from the account
 407                          * instance: */
 408                         item_name = g_strdup (tny_account_get_name (
 409                                 TNY_ACCOUNT (instance)));
 410                         item_weight = 800;
 411                 } else {
 412                         item_name = g_strdup (fname);
 413                         item_weight = 800;
 414                 }
 415         }
 416
 417         if (!item_name)
 418                 item_name = g_strdup ("unknown");
 419
 420         if (item_name && item_weight) {
 421                 /* Set the name in the treeview cell: */
 422                 g_object_set (rendobj,"text", item_name, "weight", item_weight, NULL);
 423
 424                 /* Notify display name observers */
 425                 /* TODO: What listens for this signal, and how can it use only the new name? */
 426                 if (G_OBJECT (priv->cur_folder_store) == instance) {
 427                         g_signal_emit (G_OBJECT(self),
 428                                                signals[FOLDER_DISPLAY_NAME_CHANGED_SIGNAL], 0,
 429                                                item_name);
 430                 }
 431
 432                 g_free (item_name);
 433
 434         }
 435
 436         /* If it is a Memory card account, make sure that we have the correct name.
 437          * This function will be trigerred again when the name has been retrieved: */
 438         if (TNY_IS_STORE_ACCOUNT (instance) &&
 439                 modest_tny_account_is_memory_card_account (TNY_ACCOUNT (instance))) {
 440
 441                 /* Get the account name asynchronously: */
 442                 GetMmcAccountNameData *callback_data =
 443                         g_slice_new0(GetMmcAccountNameData);
 444                 callback_data->self = self;
 445
 446                 const gchar *name = tny_account_get_name (TNY_ACCOUNT(instance));
 447                 if (name)
 448                         callback_data->previous_name = g_strdup (name);
 449
 450                 modest_tny_account_get_mmc_account_name (TNY_STORE_ACCOUNT (instance),
 451                         on_get_mmc_account_name, callback_data);
 452         }
 453
 454         g_object_unref (G_OBJECT (instance));
 455         g_free (fname);
 456 }
 457
 458
 459
 460 static void
 461 icon_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 462                  GtkTreeModel *tree_model,  GtkTreeIter *iter, gpointer data)
 463 {
 464         GObject *rendobj = NULL, *instance = NULL;
 465         GdkPixbuf *pixbuf = NULL;
 466         TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
 467         gchar *fname = NULL;
 468         const gchar *account_id = NULL;
 469         gint unread = 0;
 470
 471         rendobj = G_OBJECT(renderer);
 472         gtk_tree_model_get (tree_model, iter,
 473                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &type,
 474                             TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, &fname,
 475                             TNY_GTK_FOLDER_STORE_TREE_MODEL_UNREAD_COLUMN, &unread,
 476                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &instance,
 477                             -1);
 478
 479         if (!fname)
 480                 return;
 481
 482         if (!instance) {
 483                 g_free (fname);
 484                 return;
 485         }
 486
 487         /* We include the MERGE type here because it's used to create
 488            the local OUTBOX folder */
 489         if (type == TNY_FOLDER_TYPE_NORMAL ||
 490             type == TNY_FOLDER_TYPE_UNKNOWN ||
 491             type == TNY_FOLDER_TYPE_MERGE) {
 492                 type = modest_tny_folder_guess_folder_type (TNY_FOLDER (instance));
 493         }
 494
 495         switch (type) {
 496         case TNY_FOLDER_TYPE_ROOT:
 497                 if (TNY_IS_ACCOUNT (instance)) {
 498
 499                         if (modest_tny_account_is_virtual_local_folders (
 500                                 TNY_ACCOUNT (instance))) {
 501                                 pixbuf = modest_platform_get_icon (MODEST_FOLDER_ICON_LOCAL_FOLDERS);
 502                         }
 503                         else {
 504                                 account_id = tny_account_get_id (TNY_ACCOUNT (instance));
 505
 506                                 if (!strcmp (account_id, MODEST_MMC_ACCOUNT_ID))
 507                                         pixbuf = modest_platform_get_icon (MODEST_FOLDER_ICON_MMC);
 508                                 else
 509                                         pixbuf = modest_platform_get_icon (MODEST_FOLDER_ICON_ACCOUNT);
 510                         }
 511                 }
 512                 break;
 513         case TNY_FOLDER_TYPE_INBOX:
 514             pixbuf = modest_platform_get_icon (MODEST_FOLDER_ICON_INBOX);
 515             break;
 516         case TNY_FOLDER_TYPE_OUTBOX:
 517                 pixbuf = modest_platform_get_icon (MODEST_FOLDER_ICON_OUTBOX);
 518                 break;
 519         case TNY_FOLDER_TYPE_JUNK:
 520                 pixbuf = modest_platform_get_icon (MODEST_FOLDER_ICON_JUNK);
 521                 break;
 522         case TNY_FOLDER_TYPE_SENT:
 523                 pixbuf = modest_platform_get_icon (MODEST_FOLDER_ICON_SENT);
 524                 break;
 525         case TNY_FOLDER_TYPE_TRASH:
 526                 pixbuf = modest_platform_get_icon (MODEST_FOLDER_ICON_TRASH);
 527                 break;
 528         case TNY_FOLDER_TYPE_DRAFTS:
 529                 pixbuf = modest_platform_get_icon (MODEST_FOLDER_ICON_DRAFTS);
 530                 break;
 531         case TNY_FOLDER_TYPE_NORMAL:
 532         default:
 533                 pixbuf = modest_platform_get_icon (MODEST_FOLDER_ICON_NORMAL);
 534                 break;
 535         }
 536
 537         g_object_unref (G_OBJECT (instance));
 538         g_free (fname);
 539
 540         /* Set pixbuf */
 541         g_object_set (rendobj, "pixbuf", pixbuf, NULL);
 542
 543         if (pixbuf != NULL)
 544                 g_object_unref (pixbuf);
 545 }
 546
 547 static void
 548 add_columns (GtkWidget *treeview)
 549 {
 550         GtkTreeViewColumn *column;
 551         GtkCellRenderer *renderer;
 552         GtkTreeSelection *sel;
 553
 554         /* Create column */
 555         column = gtk_tree_view_column_new ();
 556
 557         /* Set icon and text render function */
 558         renderer = gtk_cell_renderer_pixbuf_new();
 559         gtk_tree_view_column_pack_start (column, renderer, FALSE);
 560         gtk_tree_view_column_set_cell_data_func(column, renderer,
 561                                                 icon_cell_data, treeview, NULL);
 562
 563         renderer = gtk_cell_renderer_text_new();
 564         gtk_tree_view_column_pack_start (column, renderer, FALSE);
 565         gtk_tree_view_column_set_cell_data_func(column, renderer,
 566                                                 text_cell_data, treeview, NULL);
 567
 568         /* Set selection mode */
 569         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW(treeview));
 570         gtk_tree_selection_set_mode (sel, GTK_SELECTION_SINGLE);
 571
 572         /* Set treeview appearance */
 573         gtk_tree_view_column_set_spacing (column, 2);
 574         gtk_tree_view_column_set_resizable (column, TRUE);
 575         gtk_tree_view_column_set_fixed_width (column, TRUE);
 576         gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW(treeview), FALSE);
 577         gtk_tree_view_set_enable_search (GTK_TREE_VIEW(treeview), FALSE);
 578
 579         /* Add column */
 580         gtk_tree_view_append_column (GTK_TREE_VIEW(treeview),column);
 581 }
 582
 583 static void
 584 modest_folder_view_init (ModestFolderView *obj)
 585 {
 586         ModestFolderViewPrivate *priv;
 587         ModestConf *conf;
 588
 589         priv =  MODEST_FOLDER_VIEW_GET_PRIVATE(obj);
 590
 591         priv->timer_expander = 0;
 592         priv->account_store  = NULL;
 593         priv->query          = NULL;
 594         priv->style          = MODEST_FOLDER_VIEW_STYLE_SHOW_ALL;
 595         priv->cur_folder_store   = NULL;
 596         priv->visible_account_id = NULL;
 597
 598         /* Initialize the local account name */
 599         conf = modest_runtime_get_conf();
 600         priv->local_account_name = modest_conf_get_string (conf, MODEST_CONF_DEVICE_NAME, NULL);
 601
 602         /* Init email clipboard */
 603         priv->clipboard = modest_runtime_get_email_clipboard ();
 604         priv->hidding_ids = NULL;
 605         priv->n_selected = 0;
 606         priv->reselect = FALSE;
 607
 608         /* Build treeview */
 609         add_columns (GTK_WIDGET (obj));
 610
 611         /* Setup drag and drop */
 612         setup_drag_and_drop (GTK_TREE_VIEW(obj));
 613
 614         /* Connect signals */
 615         g_signal_connect (G_OBJECT (obj),
 616                           "key-press-event",
 617                           G_CALLBACK (on_key_pressed), NULL);
 618
 619         /*
 620          * Track changes in the local account name (in the device it
 621          * will be the device name)
 622          */
 623         priv->conf_key_signal =
 624                 g_signal_connect (G_OBJECT(conf),
 625                                   "key_changed",
 626                                   G_CALLBACK(on_configuration_key_changed), obj);
 627 }
 628
 629 static void
 630 tny_account_store_view_init (gpointer g, gpointer iface_data)
 631 {
 632         TnyAccountStoreViewIface *klass = (TnyAccountStoreViewIface *)g;
 633
 634         klass->set_account_store_func = modest_folder_view_set_account_store;
 635
 636         return;
 637 }
 638
 639 static void
 640 modest_folder_view_finalize (GObject *obj)
 641 {
 642         ModestFolderViewPrivate *priv;
 643         GtkTreeSelection    *sel;
 644
 645         g_return_if_fail (obj);
 646
 647         priv =  MODEST_FOLDER_VIEW_GET_PRIVATE(obj);
 648
 649         if (priv->timer_expander != 0) {
 650                 g_source_remove (priv->timer_expander);
 651                 priv->timer_expander = 0;
 652         }
 653
 654         if (priv->account_store) {
 655                 g_signal_handler_disconnect (G_OBJECT(priv->account_store),
 656                                              priv->account_update_signal);
 657                 g_signal_handler_disconnect (G_OBJECT(priv->account_store),
 658                                              priv->accounts_reloaded_signal);
 659                 g_signal_handler_disconnect (G_OBJECT(priv->account_store),
 660                                              priv->account_removed_signal);
 661                 g_object_unref (G_OBJECT(priv->account_store));
 662                 priv->account_store = NULL;
 663         }
 664
 665         if (priv->query) {
 666                 g_object_unref (G_OBJECT (priv->query));
 667                 priv->query = NULL;
 668         }
 669
 670         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW(obj));
 671         if (sel)
 672                 g_signal_handler_disconnect (G_OBJECT(sel), priv->changed_signal);
 673
 674         g_free (priv->local_account_name);
 675         g_free (priv->visible_account_id);
 676
 677         if (priv->conf_key_signal) {
 678                 g_signal_handler_disconnect (modest_runtime_get_conf (),
 679                                              priv->conf_key_signal);
 680                 priv->conf_key_signal = 0;
 681         }
 682
 683         if (priv->cur_folder_store) {
 684                 if (TNY_IS_FOLDER(priv->cur_folder_store))
 685                         tny_folder_sync (TNY_FOLDER(priv->cur_folder_store), FALSE, NULL);
 686                         /* FALSE --> expunge the message */
 687
 688                 g_object_unref (priv->cur_folder_store);
 689                 priv->cur_folder_store = NULL;
 690         }
 691
 692         /* Clear hidding array created by cut operation */
 693         _clear_hidding_filter (MODEST_FOLDER_VIEW (obj));
 694
 695         G_OBJECT_CLASS(parent_class)->finalize (obj);
 696 }
 697
 698
 699 static void
 700 modest_folder_view_set_account_store (TnyAccountStoreView *self, TnyAccountStore *account_store)
 701 {
 702         ModestFolderViewPrivate *priv;
 703         TnyDevice *device;
 704
 705         g_return_if_fail (MODEST_IS_FOLDER_VIEW (self));
 706         g_return_if_fail (TNY_IS_ACCOUNT_STORE (account_store));
 707
 708         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (self);
 709         device = tny_account_store_get_device (account_store);
 710
 711         if (G_UNLIKELY (priv->account_store)) {
 712
 713                 if (g_signal_handler_is_connected (G_OBJECT (priv->account_store),
 714                                                    priv->account_update_signal))
 715                         g_signal_handler_disconnect (G_OBJECT (priv->account_store),
 716                                                      priv->account_update_signal);
 717                 if (g_signal_handler_is_connected (G_OBJECT (priv->account_store),
 718                                                    priv->accounts_reloaded_signal))
 719                         g_signal_handler_disconnect (G_OBJECT (priv->account_store),
 720                                                      priv->accounts_reloaded_signal);
 721                 if (g_signal_handler_is_connected (G_OBJECT (priv->account_store),
 722                                                    priv->account_removed_signal))
 723                         g_signal_handler_disconnect (G_OBJECT (priv->account_store),
 724                                                      priv->account_removed_signal);
 725
 726                 g_object_unref (G_OBJECT (priv->account_store));
 727         }
 728
 729         priv->account_store = g_object_ref (G_OBJECT (account_store));
 730
 731         priv->account_update_signal =
 732                 g_signal_connect (G_OBJECT(account_store), "account_update",
 733                                   G_CALLBACK (on_account_update), self);
 734
 735         priv->account_removed_signal =
 736                 g_signal_connect (G_OBJECT(account_store), "account_removed",
 737                                   G_CALLBACK (on_account_removed), self);
 738
 739         priv->accounts_reloaded_signal =
 740                 g_signal_connect (G_OBJECT(account_store), "accounts_reloaded",
 741                                   G_CALLBACK (on_accounts_reloaded), self);
 742
 743         g_signal_connect (G_OBJECT(account_store), "connecting_finished",
 744                                 G_CALLBACK (on_accounts_reloaded), self);
 745
 746         on_accounts_reloaded (account_store, (gpointer ) self);
 747
 748         g_object_unref (G_OBJECT (device));
 749 }
 750
 751 static void
 752 on_account_removed (TnyAccountStore *account_store,
 753                     TnyAccount *account,
 754                     gpointer user_data)
 755 {
 756         ModestFolderView *self = MODEST_FOLDER_VIEW (user_data);
 757         ModestFolderViewPrivate *priv;
 758
 759         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (self);
 760
 761         /* If the removed account is the currently viewed one then
 762            clear the configuration value. The new visible account will be the default account */
 763         if (!strcmp (priv->visible_account_id, tny_account_get_id (account))) {
 764                 modest_folder_view_set_account_id_of_visible_server_account (self, NULL);
 765         }
 766 }
 767
 768 static void
 769 on_account_update (TnyAccountStore *account_store,
 770                    const gchar *account,
 771                    gpointer user_data)
 772 {
 773         ModestFolderView *self = NULL;
 774         ModestFolderViewPrivate *priv;
 775
 776         g_return_if_fail (MODEST_IS_FOLDER_VIEW (user_data));
 777         self = MODEST_FOLDER_VIEW (user_data);
 778         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (self);
 779
 780         if (!priv->visible_account_id)
 781                 modest_widget_memory_restore (modest_runtime_get_conf(), G_OBJECT(self),
 782                                               MODEST_CONF_FOLDER_VIEW_KEY);
 783
 784         if (!modest_folder_view_update_model (self, account_store))
 785                 g_printerr ("modest: failed to update model for changes in '%s'",
 786                             account);
 787 }
 788
 789 static void
 790 on_accounts_reloaded   (TnyAccountStore *account_store,
 791                         gpointer user_data)
 792 {
 793         g_return_if_fail (MODEST_IS_FOLDER_VIEW (user_data));
 794         modest_folder_view_update_model (MODEST_FOLDER_VIEW (user_data), account_store);
 795 }
 796
 797 void
 798 modest_folder_view_set_title (ModestFolderView *self, const gchar *title)
 799 {
 800         GtkTreeViewColumn *col;
 801
 802         g_return_if_fail (self);
 803
 804         col = gtk_tree_view_get_column (GTK_TREE_VIEW(self), 0);
 805         if (!col) {
 806                 g_printerr ("modest: failed get column for title\n");
 807                 return;
 808         }
 809
 810         gtk_tree_view_column_set_title (col, title);
 811         gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(self),
 812                                            title != NULL);
 813 }
 814
 815 static gboolean
 816 modest_folder_view_on_map (ModestFolderView *self,
 817                            GdkEventExpose *event,
 818                            gpointer data)
 819 {
 820         ModestFolderViewPrivate *priv;
 821
 822         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (self);
 823
 824         /* This won't happen often */
 825         if (G_UNLIKELY (priv->reselect)) {
 826                 /* Select the first inbox or the local account if not found */
 827
 828                 /* TODO: this could cause a lock at startup, so we
 829                    comment it for the moment. We know that this will
 830                    be a bug, because the INBOX is not selected, but we
 831                    need to rewrite some parts of Modest to avoid the
 832                    deathlock situation */
 833 /*              modest_folder_view_select_first_inbox_or_local (self); */
 834                 priv->reselect = FALSE;
 835         }
 836         return FALSE;
 837 }
 838
 839 GtkWidget*
 840 modest_folder_view_new (TnyFolderStoreQuery *query)
 841 {
 842         GObject *self;
 843         ModestFolderViewPrivate *priv;
 844         GtkTreeSelection *sel;
 845
 846         self = G_OBJECT (g_object_new (MODEST_TYPE_FOLDER_VIEW, NULL));
 847         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (self);
 848
 849         if (query)
 850                 priv->query = g_object_ref (query);
 851
 852         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(self));
 853         priv->changed_signal = g_signal_connect (sel, "changed",
 854                                                  G_CALLBACK (on_selection_changed), self);
 855
 856         g_signal_connect (self, "expose-event", G_CALLBACK (modest_folder_view_on_map), NULL);
 857
 858         return GTK_WIDGET(self);
 859 }
 860
 861 /* this feels dirty; any other way to expand all the root items? */
 862 static void
 863 expand_root_items (ModestFolderView *self)
 864 {
 865         GtkTreePath *path;
 866         path = gtk_tree_path_new_first ();
 867
 868         /* all folders should have child items, so.. */
 869         while (gtk_tree_view_expand_row (GTK_TREE_VIEW(self), path, FALSE))
 870                 gtk_tree_path_next (path);
 871
 872         gtk_tree_path_free (path);
 873 }
 874
 875 /*
 876  * We use this function to implement the
 877  * MODEST_FOLDER_VIEW_STYLE_SHOW_ONE style. We only show the default
 878  * account in this case, and the local folders.
 879  */
 880 static gboolean
 881 filter_row (GtkTreeModel *model,
 882             GtkTreeIter *iter,
 883             gpointer data)
 884 {
 885         ModestFolderViewPrivate *priv;
 886         gboolean retval = TRUE;
 887         TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
 888         GObject *instance = NULL;
 889         const gchar *id = NULL;
 890         guint i;
 891         gboolean found = FALSE;
 892         gboolean cleared = FALSE;
 893
 894         g_return_val_if_fail (MODEST_IS_FOLDER_VIEW (data), FALSE);
 895         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (data);
 896
 897         gtk_tree_model_get (model, iter,
 898                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &type,
 899                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &instance,
 900                             -1);
 901
 902         /* Do not show if there is no instance, this could indeed
 903            happen when the model is being modified while it's being
 904            drawn. This could occur for example when moving folders
 905            using drag&drop */
 906         if (!instance)
 907                 return FALSE;
 908
 909         if (type == TNY_FOLDER_TYPE_ROOT) {
 910                 /* TNY_FOLDER_TYPE_ROOT means that the instance is an
 911                    account instead of a folder. */
 912                 if (TNY_IS_ACCOUNT (instance)) {
 913                         TnyAccount *acc = TNY_ACCOUNT (instance);
 914                         const gchar *account_id = tny_account_get_id (acc);
 915
 916                         /* If it isn't a special folder,
 917                          * don't show it unless it is the visible account: */
 918                         if (!modest_tny_account_is_virtual_local_folders (acc) &&
 919                                 strcmp (account_id, MODEST_MMC_ACCOUNT_ID)) {
 920                                 /* Show only the visible account id */
 921                                 if (priv->visible_account_id && strcmp (account_id, priv->visible_account_id))
 922                                         retval = FALSE;
 923                         }
 924
 925                         /* Never show these to the user. They are merged into one folder
 926                          * in the local-folders account instead: */
 927                         if (retval && MODEST_IS_TNY_OUTBOX_ACCOUNT (acc))
 928                                 retval = FALSE;
 929                 }
 930         }
 931
 932         /* The virtual local-folders folder store is also shown by default. */
 933
 934         /* Check hiding (if necessary) */
 935         cleared = modest_email_clipboard_cleared (priv->clipboard);
 936         if ((retval) && (!cleared) && (TNY_IS_FOLDER (instance))) {
 937                 id = tny_folder_get_id (TNY_FOLDER(instance));
 938                 if (priv->hidding_ids != NULL)
 939                         for (i=0; i < priv->n_selected && !found; i++)
 940                                 if (priv->hidding_ids[i] != NULL && id != NULL)
 941                                         found = (!strcmp (priv->hidding_ids[i], id));
 942
 943                 retval = !found;
 944         }
 945
 946         /* Free */
 947         g_object_unref (instance);
 948
 949         return retval;
 950 }
 951
 952 gboolean
 953 modest_folder_view_update_model (ModestFolderView *self,
 954                                  TnyAccountStore *account_store)
 955 {
 956         ModestFolderViewPrivate *priv;
 957         GtkTreeModel *model /* , *old_model */;
 958         /* TnyAccount *local_account; */
 959         TnyList *model_as_list;
 960
 961         g_return_val_if_fail (MODEST_IS_FOLDER_VIEW (self), FALSE);
 962         g_return_val_if_fail (account_store, FALSE);
 963
 964         priv =  MODEST_FOLDER_VIEW_GET_PRIVATE(self);
 965
 966         /* Notify that there is no folder selected */
 967         g_signal_emit (G_OBJECT(self),
 968                        signals[FOLDER_SELECTION_CHANGED_SIGNAL], 0,
 969                        NULL, FALSE);
 970         if (priv->cur_folder_store) {
 971                 g_object_unref (priv->cur_folder_store);
 972                 priv->cur_folder_store = NULL;
 973         }
 974
 975         /* FIXME: the local accounts are not shown when the query
 976            selects only the subscribed folders. */
 977 /*      model        = tny_gtk_folder_store_tree_model_new (TRUE, priv->query); */
 978         model        = tny_gtk_folder_store_tree_model_new (TRUE, NULL);
 979
 980         /* Deal with the model via its TnyList Interface,
 981          * filling the TnyList via a get_accounts() call: */
 982         model_as_list = TNY_LIST(model);
 983
 984         /* Get the accounts: */
 985         tny_account_store_get_accounts (TNY_ACCOUNT_STORE(account_store),
 986                                         model_as_list,
 987                                         TNY_ACCOUNT_STORE_STORE_ACCOUNTS);
 988         g_object_unref (model_as_list);
 989         model_as_list = NULL;
 990
 991         GtkTreeModel *filter_model = NULL, *sortable = NULL;
 992
 993         sortable = gtk_tree_model_sort_new_with_model (model);
 994         gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(sortable),
 995                                               TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN,
 996                                               GTK_SORT_ASCENDING);
 997         gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sortable),
 998                                          TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN,
 999                                          cmp_rows, NULL, NULL);
1000
1001         /* Create filter model */
1002         filter_model = gtk_tree_model_filter_new (sortable, NULL);
1003         gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter_model),
1004                                                 filter_row,
1005                                                 self,
1006                                                 NULL);
1007 /*      if (priv->style == MODEST_FOLDER_VIEW_STYLE_SHOW_ONE) { */
1008 /*              filter_model = gtk_tree_model_filter_new (sortable, NULL); */
1009 /*              gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter_model), */
1010 /*                                                      filter_row, */
1011 /*                                                      self, */
1012 /*                                                      NULL); */
1013 /*      } */
1014
1015         /* Set new model */
1016         gtk_tree_view_set_model (GTK_TREE_VIEW(self), filter_model);
1017 /*      gtk_tree_view_set_model (GTK_TREE_VIEW(self),  */
1018 /*                               (filter_model) ? filter_model : sortable); */
1019
1020         g_object_unref (model);
1021         g_object_unref (filter_model);
1022 /*      if (filter_model) */
1023 /*              g_object_unref (filter_model); */
1024
1025         g_object_unref (sortable);
1026
1027         /* Force a reselection of the INBOX next time the widget is shown */
1028         priv->reselect = TRUE;
1029
1030         return TRUE;
1031 }
1032
1033
1034 static void
1035 on_selection_changed (GtkTreeSelection *sel, gpointer user_data)
1036 {
1037         GtkTreeModel            *model;
1038         TnyFolderStore          *folder = NULL;
1039         GtkTreeIter             iter;
1040         ModestFolderView        *tree_view;
1041         ModestFolderViewPrivate *priv;
1042
1043         g_return_if_fail (sel);
1044         g_return_if_fail (user_data);
1045
1046         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(user_data);
1047
1048         if(!gtk_tree_selection_get_selected (sel, &model, &iter))
1049                 return;
1050
1051         /* Notify the display name observers */
1052         g_signal_emit (G_OBJECT(user_data),
1053                        signals[FOLDER_DISPLAY_NAME_CHANGED_SIGNAL], 0,
1054                        NULL);
1055
1056         tree_view = MODEST_FOLDER_VIEW (user_data);
1057         gtk_tree_model_get (model, &iter,
1058                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &folder,
1059                             -1);
1060
1061         /* If the folder is the same do not notify */
1062         if (priv->cur_folder_store == folder && folder) {
1063                 g_object_unref (folder);
1064                 return;
1065         }
1066
1067         /* Current folder was unselected */
1068         if (priv->cur_folder_store) {
1069                 if (TNY_IS_FOLDER(priv->cur_folder_store))
1070                         tny_folder_sync (TNY_FOLDER(priv->cur_folder_store), FALSE, NULL);
1071                 /* FALSE --> don't expunge the messages */
1072
1073                 g_signal_emit (G_OBJECT(tree_view), signals[FOLDER_SELECTION_CHANGED_SIGNAL], 0,
1074                                priv->cur_folder_store, FALSE);
1075                 g_object_unref (priv->cur_folder_store);
1076                 priv->cur_folder_store = NULL;
1077         }
1078
1079         /* New current references */
1080         priv->cur_folder_store = folder;
1081
1082         /* New folder has been selected */
1083         g_signal_emit (G_OBJECT(tree_view),
1084                        signals[FOLDER_SELECTION_CHANGED_SIGNAL],
1085                        0, priv->cur_folder_store, TRUE);
1086 }
1087
1088 TnyFolderStore *
1089 modest_folder_view_get_selected (ModestFolderView *self)
1090 {
1091         ModestFolderViewPrivate *priv;
1092
1093         g_return_val_if_fail (self, NULL);
1094
1095         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
1096         if (priv->cur_folder_store)
1097                 g_object_ref (priv->cur_folder_store);
1098
1099         return priv->cur_folder_store;
1100 }
1101
1102 static gint
1103 get_cmp_rows_type_pos (GObject *folder)
1104 {
1105         /* Remote accounts -> Local account -> MMC account .*/
1106         /* 0, 1, 2 */
1107
1108         if (TNY_IS_ACCOUNT (folder) &&
1109                 modest_tny_account_is_virtual_local_folders (
1110                         TNY_ACCOUNT (folder))) {
1111                 return 1;
1112         } else if (TNY_IS_ACCOUNT (folder)) {
1113                 TnyAccount *account = TNY_ACCOUNT (folder);
1114                 const gchar *account_id = tny_account_get_id (account);
1115                 if (!strcmp (account_id, MODEST_MMC_ACCOUNT_ID))
1116                         return 2;
1117                 else
1118                         return 0;
1119         }
1120         else {
1121                 printf ("DEBUG: %s: unexpected type.\n", __FUNCTION__);
1122                 return -1; /* Should never happen */
1123         }
1124 }
1125
1126 static gint
1127 get_cmp_subfolder_type_pos (TnyFolderType t)
1128 {
1129         /* Outbox, Drafts, Sent, User */
1130         /* 0, 1, 2, 3 */
1131
1132         switch (t) {
1133         case TNY_FOLDER_TYPE_OUTBOX:
1134                 return 0;
1135                 break;
1136         case TNY_FOLDER_TYPE_DRAFTS:
1137                 return 1;
1138                 break;
1139         case TNY_FOLDER_TYPE_SENT:
1140                 return 2;
1141                 break;
1142         default:
1143                 return 3;
1144         }
1145 }
1146
1147 /*
1148  * This function orders the mail accounts according to these rules:
1149  * 1st - remote accounts
1150  * 2nd - local account
1151  * 3rd - MMC account
1152  */
1153 static gint
1154 cmp_rows (GtkTreeModel *tree_model, GtkTreeIter *iter1, GtkTreeIter *iter2,
1155           gpointer user_data)
1156 {
1157         gint cmp;
1158         gchar *name1 = NULL;
1159         gchar *name2 = NULL;
1160         TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
1161         TnyFolderType type2 = TNY_FOLDER_TYPE_UNKNOWN;
1162         GObject *folder1 = NULL;
1163         GObject *folder2 = NULL;
1164
1165         gtk_tree_model_get (tree_model, iter1,
1166                             TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, &name1,
1167                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &type,
1168                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &folder1,
1169                             -1);
1170         gtk_tree_model_get (tree_model, iter2,
1171                             TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, &name2,
1172                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &type2,
1173                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &folder2,
1174                             -1);
1175
1176         /* Return if we get no folder. This could happen when folder
1177            operations are happening. The model is updated after the
1178            folder copy/move actually occurs, so there could be
1179            situations where the model to be drawn is not correct */
1180         if (!folder1 || !folder2)
1181                 return 0;
1182
1183         if (type == TNY_FOLDER_TYPE_ROOT) {
1184                 /* Compare the types, so that
1185                  * Remote accounts -> Local account -> MMC account .*/
1186                 const gint pos1 = get_cmp_rows_type_pos (folder1);
1187                 const gint pos2 = get_cmp_rows_type_pos (folder2);
1188                 /* printf ("DEBUG: %s:\n  type1=%s, pos1=%d\n  type2=%s, pos2=%d\n",
1189                         __FUNCTION__, G_OBJECT_TYPE_NAME(folder1), pos1, G_OBJECT_TYPE_NAME(folder2), pos2); */
1190                 if (pos1 <  pos2)
1191                         cmp = -1;
1192                 else if (pos1 > pos2)
1193                         cmp = 1;
1194                 else {
1195                         /* Compare items of the same type: */
1196
1197                         TnyAccount *account1 = NULL;
1198                         if (TNY_IS_ACCOUNT (folder1))
1199                                 account1 = TNY_ACCOUNT (folder1);
1200
1201                         TnyAccount *account2 = NULL;
1202                         if (TNY_IS_ACCOUNT (folder2))
1203                                 account2 = TNY_ACCOUNT (folder2);
1204
1205                         const gchar *account_id = account1 ? tny_account_get_id (account1) : NULL;
1206                         const gchar *account_id2 = account2 ? tny_account_get_id (account2) : NULL;
1207
1208                         if (!account_id && !account_id2)
1209                                 return 0;
1210                         else if (!account_id)
1211                                 return -1;
1212                         else if (!account_id2)
1213                                 return +1;
1214                         else if (!strcmp (account_id, MODEST_MMC_ACCOUNT_ID))
1215                                 cmp = +1;
1216                         else
1217                                 cmp = modest_text_utils_utf8_strcmp (name1, name2, TRUE);
1218                 }
1219         } else {
1220                 GtkTreeIter parent;
1221                 gboolean has_parent;
1222                 gint cmp1 = 0, cmp2 = 0;
1223                 /* get the parent to know if it's a local folder */
1224                 has_parent = gtk_tree_model_iter_parent (tree_model, &parent, iter1);
1225                 if (has_parent) {
1226                         GObject *parent_folder;
1227                         TnyFolderType parent_type = TNY_FOLDER_TYPE_UNKNOWN;
1228                         gtk_tree_model_get (tree_model, &parent,
1229                                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &parent_type,
1230                                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &parent_folder,
1231                                             -1);
1232                         if ((parent_type == TNY_FOLDER_TYPE_ROOT) &&
1233                             TNY_IS_ACCOUNT (parent_folder) &&
1234                             modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
1235                                 cmp1 = get_cmp_subfolder_type_pos (modest_tny_folder_get_local_folder_type (TNY_FOLDER (folder1)));
1236                                 cmp2 = get_cmp_subfolder_type_pos (modest_tny_folder_get_local_folder_type (TNY_FOLDER (folder2)));
1237                         }
1238                         g_object_unref (parent_folder);
1239                 }
1240                 if (cmp1 == cmp2)
1241                         cmp = modest_text_utils_utf8_strcmp (name1, name2, TRUE);
1242                 else
1243                         cmp = (cmp1 - cmp2);
1244         }
1245
1246         if (folder1)
1247                 g_object_unref(G_OBJECT(folder1));
1248         if (folder2)
1249                 g_object_unref(G_OBJECT(folder2));
1250
1251         g_free (name1);
1252         g_free (name2);
1253
1254         return cmp;
1255 }
1256
1257 /*****************************************************************************/
1258 /*                        DRAG and DROP stuff                                */
1259 /*****************************************************************************/
1260
1261 /*
1262  * This function fills the #GtkSelectionData with the row and the
1263  * model that has been dragged. It's called when this widget is a
1264  * source for dnd after the event drop happened
1265  */
1266 static void
1267 on_drag_data_get (GtkWidget *widget,
1268                   GdkDragContext *context,
1269                   GtkSelectionData *selection_data,
1270                   guint info,
1271                   guint time,
1272                   gpointer data)
1273 {
1274         GtkTreeSelection *selection;
1275         GtkTreeModel *model;
1276         GtkTreeIter iter;
1277         GtkTreePath *source_row;
1278
1279         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
1280         gtk_tree_selection_get_selected (selection, &model, &iter);
1281         source_row = gtk_tree_model_get_path (model, &iter);
1282
1283         gtk_tree_set_row_drag_data (selection_data,
1284                                     model,
1285                                     source_row);
1286
1287         gtk_tree_path_free (source_row);
1288 }
1289
1290 typedef struct _DndHelper {
1291         gboolean delete_source;
1292         GtkTreePath *source_row;
1293         GdkDragContext *context;
1294         guint time;
1295 } DndHelper;
1296
1297
1298 /*
1299  * This function is the callback of the
1300  * modest_mail_operation_xfer_msgs () and
1301  * modest_mail_operation_xfer_folder() calls. We check here if the
1302  * message/folder was correctly asynchronously transferred. The reason
1303  * to use the same callback is that the code is the same, it only has
1304  * to check that the operation went fine and then finalize the drag
1305  * and drop action
1306  */
1307 static void
1308 on_progress_changed (ModestMailOperation *mail_op,
1309                      ModestMailOperationState *state,
1310                      gpointer user_data)
1311 {
1312         gboolean success;
1313         DndHelper *helper;
1314
1315         helper = (DndHelper *) user_data;
1316
1317         if (!state->finished)
1318                 return;
1319
1320         if (state->status == MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
1321                 success = TRUE;
1322         } else {
1323                 success = FALSE;
1324         }
1325
1326         /* Notify the drag source. Never call delete, the monitor will
1327            do the job if needed */
1328         gtk_drag_finish (helper->context, success, FALSE, helper->time);
1329
1330         /* Free the helper */
1331         gtk_tree_path_free (helper->source_row);
1332         g_slice_free (DndHelper, helper);
1333 }
1334
1335 /*
1336  * This function is used by drag_data_received_cb to manage drag and
1337  * drop of a header, i.e, and drag from the header view to the folder
1338  * view.
1339  */
1340 static void
1341 drag_and_drop_from_header_view (GtkTreeModel *source_model,
1342                                 GtkTreeModel *dest_model,
1343                                 GtkTreePath  *dest_row,
1344                                 DndHelper    *helper)
1345 {
1346         TnyList *headers = NULL;
1347         TnyHeader *header = NULL;
1348         TnyFolder *folder = NULL;
1349         ModestMailOperation *mail_op = NULL;
1350         GtkTreeIter source_iter, dest_iter;
1351
1352         g_return_if_fail (GTK_IS_TREE_MODEL(source_model));
1353         g_return_if_fail (GTK_IS_TREE_MODEL(dest_model));
1354         g_return_if_fail (dest_row);
1355         g_return_if_fail (helper);
1356
1357         /* Get header */
1358         gtk_tree_model_get_iter (source_model, &source_iter, helper->source_row);
1359         gtk_tree_model_get (source_model, &source_iter,
1360                             TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
1361                             &header, -1);
1362         if (!TNY_IS_HEADER(header)) {
1363                 g_warning ("BUG: %s could not get a valid header", __FUNCTION__);
1364                 goto cleanup;
1365         }
1366
1367         /* Get Folder */
1368         gtk_tree_model_get_iter (dest_model, &dest_iter, dest_row);
1369         gtk_tree_model_get (dest_model, &dest_iter,
1370                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,
1371                             &folder, -1);
1372
1373         if (!TNY_IS_FOLDER(folder)) {
1374                 g_warning ("BUG: %s could not get a valid folder", __FUNCTION__);
1375                 goto cleanup;
1376         }
1377
1378         /* Transfer message */
1379         mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, NULL);
1380         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1381                                          mail_op);
1382         g_signal_connect (G_OBJECT (mail_op), "progress-changed",
1383                           G_CALLBACK (on_progress_changed), helper);
1384
1385         headers = tny_simple_list_new ();
1386         tny_list_append (headers, G_OBJECT (header));
1387         modest_mail_operation_xfer_msgs (mail_op,
1388                                          headers,
1389                                          folder,
1390                                          helper->delete_source,
1391                                          NULL, NULL);
1392
1393         /* Frees */
1394 cleanup:
1395         if (G_IS_OBJECT(mail_op))
1396                 g_object_unref (G_OBJECT (mail_op));
1397         if (G_IS_OBJECT(header))
1398                 g_object_unref (G_OBJECT (header));
1399         if (G_IS_OBJECT(folder))
1400                 g_object_unref (G_OBJECT (folder));
1401         if (G_IS_OBJECT(headers))
1402                 g_object_unref (headers);
1403 }
1404
1405 /*
1406  * This function is used by drag_data_received_cb to manage drag and
1407  * drop of a folder, i.e, and drag from the folder view to the same
1408  * folder view.
1409  */
1410 static void
1411 drag_and_drop_from_folder_view (GtkTreeModel     *source_model,
1412                                 GtkTreeModel     *dest_model,
1413                                 GtkTreePath      *dest_row,
1414                                 GtkSelectionData *selection_data,
1415                                 DndHelper        *helper)
1416 {
1417         ModestMailOperation *mail_op = NULL;
1418         GtkTreeIter parent_iter, iter;
1419         TnyFolderStore *parent_folder = NULL;
1420         TnyFolder *folder = NULL;
1421
1422         /* Check if the drag is possible */
1423 /*      if (!gtk_tree_path_compare (helper->source_row, dest_row) || */
1424 /*          !gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (dest_model), */
1425 /*                                                 dest_row, */
1426 /*                                                 selection_data)) { */
1427         if (!gtk_tree_path_compare (helper->source_row, dest_row)) {
1428
1429                 gtk_drag_finish (helper->context, FALSE, FALSE, helper->time);
1430                 gtk_tree_path_free (helper->source_row);
1431                 g_slice_free (DndHelper, helper);
1432                 return;
1433         }
1434
1435         /* Get data */
1436         gtk_tree_model_get_iter (source_model, &parent_iter, dest_row);
1437         gtk_tree_model_get_iter (source_model, &iter, helper->source_row);
1438         gtk_tree_model_get (source_model, &parent_iter,
1439                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,
1440                             &parent_folder, -1);
1441         gtk_tree_model_get (source_model, &iter,
1442                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,
1443                             &folder, -1);
1444
1445         /* Offer the connection dialog if necessary, for the destination parent folder and source folder: */
1446         if (modest_platform_connect_and_wait_if_network_folderstore (NULL, parent_folder) &&
1447                 modest_platform_connect_and_wait_if_network_folderstore (NULL, TNY_FOLDER_STORE (folder))) {
1448                 /* Do the mail operation */
1449                 mail_op = modest_mail_operation_new_with_error_handling (MODEST_MAIL_OPERATION_TYPE_RECEIVE,
1450                                                                  NULL,
1451                                                                  modest_ui_actions_move_folder_error_handler,
1452                                                                  NULL);
1453                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
1454                                          mail_op);
1455                 g_signal_connect (G_OBJECT (mail_op), "progress-changed",
1456                                   G_CALLBACK (on_progress_changed), helper);
1457
1458                 modest_mail_operation_xfer_folder (mail_op,
1459                                            folder,
1460                                            parent_folder,
1461                                            helper->delete_source,
1462                                            NULL,
1463                                            NULL);
1464         }
1465
1466         /* Frees */
1467         g_object_unref (G_OBJECT (parent_folder));
1468         g_object_unref (G_OBJECT (folder));
1469         g_object_unref (G_OBJECT (mail_op));
1470 }
1471
1472 /*
1473  * This function receives the data set by the "drag-data-get" signal
1474  * handler. This information comes within the #GtkSelectionData. This
1475  * function will manage both the drags of folders of the treeview and
1476  * drags of headers of the header view widget.
1477  */
1478 static void
1479 on_drag_data_received (GtkWidget *widget,
1480                        GdkDragContext *context,
1481                        gint x,
1482                        gint y,
1483                        GtkSelectionData *selection_data,
1484                        guint target_type,
1485                        guint time,
1486                        gpointer data)
1487 {
1488         GtkWidget *source_widget;
1489         GtkTreeModel *dest_model, *source_model;
1490         GtkTreePath *source_row, *dest_row;
1491         GtkTreeViewDropPosition pos;
1492         gboolean success = FALSE, delete_source = FALSE;
1493         DndHelper *helper = NULL;
1494
1495         /* Do not allow further process */
1496         g_signal_stop_emission_by_name (widget, "drag-data-received");
1497         source_widget = gtk_drag_get_source_widget (context);
1498
1499         /* Get the action */
1500         if (context->action == GDK_ACTION_MOVE) {
1501                 delete_source = TRUE;
1502
1503                 /* Notify that there is no folder selected. We need to
1504                    do this in order to update the headers view (and
1505                    its monitors, because when moving, the old folder
1506                    won't longer exist. We can not wait for the end of
1507                    the operation, because the operation won't start if
1508                    the folder is in use */
1509                 if (source_widget == widget) {
1510                         ModestFolderViewPrivate *priv;
1511
1512                         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (widget);
1513                         if (priv->cur_folder_store) {
1514                                 g_object_unref (priv->cur_folder_store);
1515                                 priv->cur_folder_store = NULL;
1516                         }
1517
1518                         g_signal_emit (G_OBJECT (widget),
1519                                        signals[FOLDER_SELECTION_CHANGED_SIGNAL], 0, NULL, FALSE);
1520                 }
1521         }
1522
1523         /* Check if the get_data failed */
1524         if (selection_data == NULL || selection_data->length < 0)
1525                 gtk_drag_finish (context, success, FALSE, time);
1526
1527         /* Get the models */
1528         gtk_tree_get_row_drag_data (selection_data,
1529                                     &source_model,
1530                                     &source_row);
1531
1532         /* Select the destination model */
1533         if (source_widget == widget) {
1534                 dest_model = source_model;
1535         } else {
1536                 dest_model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
1537         }
1538
1539         /* Get the path to the destination row. Can not call
1540            gtk_tree_view_get_drag_dest_row() because the source row
1541            is not selected anymore */
1542         gtk_tree_view_get_dest_row_at_pos (GTK_TREE_VIEW (widget), x, y,
1543                                            &dest_row, &pos);
1544
1545         /* Only allow drops IN other rows */
1546         if (!dest_row || pos == GTK_TREE_VIEW_DROP_BEFORE || pos == GTK_TREE_VIEW_DROP_AFTER)
1547                 gtk_drag_finish (context, success, FALSE, time);
1548
1549         /* Create the helper */
1550         helper = g_slice_new0 (DndHelper);
1551         helper->delete_source = delete_source;
1552         helper->source_row = gtk_tree_path_copy (source_row);
1553         helper->context = context;
1554         helper->time = time;
1555
1556         /* Drags from the header view */
1557         if (source_widget != widget) {
1558
1559                 drag_and_drop_from_header_view (source_model,
1560                                                 dest_model,
1561                                                 dest_row,
1562                                                 helper);
1563         } else {
1564
1565
1566                 drag_and_drop_from_folder_view (source_model,
1567                                                 dest_model,
1568                                                 dest_row,
1569                                                 selection_data,
1570                                                 helper);
1571         }
1572
1573         /* Frees */
1574         gtk_tree_path_free (source_row);
1575         gtk_tree_path_free (dest_row);
1576 }
1577
1578 /*
1579  * We define a "drag-drop" signal handler because we do not want to
1580  * use the default one, because the default one always calls
1581  * gtk_drag_finish and we prefer to do it in the "drag-data-received"
1582  * signal handler, because there we have all the information available
1583  * to know if the dnd was a success or not.
1584  */
1585 static gboolean
1586 drag_drop_cb (GtkWidget      *widget,
1587               GdkDragContext *context,
1588               gint            x,
1589               gint            y,
1590               guint           time,
1591               gpointer        user_data)
1592 {
1593         gpointer target;
1594
1595         if (!context->targets)
1596                 return FALSE;
1597
1598         /* Check if we're dragging a folder row */
1599         target = gtk_drag_dest_find_target (widget, context, NULL);
1600
1601         /* Request the data from the source. */
1602         gtk_drag_get_data(widget, context, target, time);
1603
1604     return TRUE;
1605 }
1606
1607 /*
1608  * This function expands a node of a tree view if it's not expanded
1609  * yet. Not sure why it needs the threads stuff, but gtk+`example code
1610  * does that, so that's why they're here.
1611  */
1612 static gint
1613 expand_row_timeout (gpointer data)
1614 {
1615         GtkTreeView *tree_view = data;
1616         GtkTreePath *dest_path = NULL;
1617         GtkTreeViewDropPosition pos;
1618         gboolean result = FALSE;
1619
1620         GDK_THREADS_ENTER ();
1621
1622         gtk_tree_view_get_drag_dest_row (tree_view,
1623                                          &dest_path,
1624                                          &pos);
1625
1626         if (dest_path &&
1627             (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
1628              pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)) {
1629                 gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
1630                 gtk_tree_path_free (dest_path);
1631         }
1632         else {
1633                 if (dest_path)
1634                         gtk_tree_path_free (dest_path);
1635
1636                 result = TRUE;
1637         }
1638
1639         GDK_THREADS_LEAVE ();
1640
1641         return result;
1642 }
1643
1644 /*
1645  * This function is called whenever the pointer is moved over a widget
1646  * while dragging some data. It installs a timeout that will expand a
1647  * node of the treeview if not expanded yet. This function also calls
1648  * gdk_drag_status in order to set the suggested action that will be
1649  * used by the "drag-data-received" signal handler to know if we
1650  * should do a move or just a copy of the data.
1651  */
1652 static gboolean
1653 on_drag_motion (GtkWidget      *widget,
1654                 GdkDragContext *context,
1655                 gint            x,
1656                 gint            y,
1657                 guint           time,
1658                 gpointer        user_data)
1659 {
1660         GtkTreeViewDropPosition pos;
1661         GtkTreePath *dest_row;
1662         ModestFolderViewPrivate *priv;
1663         GdkDragAction suggested_action;
1664         gboolean valid_location = FALSE;
1665
1666         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (widget);
1667
1668         if (priv->timer_expander != 0) {
1669                 g_source_remove (priv->timer_expander);
1670                 priv->timer_expander = 0;
1671         }
1672
1673         gtk_tree_view_get_dest_row_at_pos (GTK_TREE_VIEW (widget),
1674                                            x, y,
1675                                            &dest_row,
1676                                            &pos);
1677
1678         /* Do not allow drops between folders */
1679         if (!dest_row ||
1680             pos == GTK_TREE_VIEW_DROP_BEFORE ||
1681             pos == GTK_TREE_VIEW_DROP_AFTER) {
1682                 gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW (widget), NULL, 0);
1683                 gdk_drag_status(context, 0, time);
1684                 valid_location = FALSE;
1685                 goto out;
1686         } else {
1687                 valid_location = TRUE;
1688         }
1689
1690         /* Expand the selected row after 1/2 second */
1691         if (!gtk_tree_view_row_expanded (GTK_TREE_VIEW (widget), dest_row)) {
1692                 gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget), dest_row, pos);
1693                 priv->timer_expander = g_timeout_add (500, expand_row_timeout, widget);
1694         }
1695
1696         /* Select the desired action. By default we pick MOVE */
1697         suggested_action = GDK_ACTION_MOVE;
1698
1699         if (context->actions == GDK_ACTION_COPY)
1700             gdk_drag_status(context, GDK_ACTION_COPY, time);
1701         else if (context->actions == GDK_ACTION_MOVE)
1702             gdk_drag_status(context, GDK_ACTION_MOVE, time);
1703         else if (context->actions & suggested_action)
1704             gdk_drag_status(context, suggested_action, time);
1705         else
1706             gdk_drag_status(context, GDK_ACTION_DEFAULT, time);
1707
1708  out:
1709         if (dest_row)
1710                 gtk_tree_path_free (dest_row);
1711         g_signal_stop_emission_by_name (widget, "drag-motion");
1712         return valid_location;
1713 }
1714
1715
1716 /* Folder view drag types */
1717 const GtkTargetEntry folder_view_drag_types[] =
1718 {
1719         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, MODEST_FOLDER_ROW },
1720         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP,    MODEST_HEADER_ROW }
1721 };
1722
1723 /*
1724  * This function sets the treeview as a source and a target for dnd
1725  * events. It also connects all the requirede signals.
1726  */
1727 static void
1728 setup_drag_and_drop (GtkTreeView *self)
1729 {
1730         /* Set up the folder view as a dnd destination. Set only the
1731            highlight flag, otherwise gtk will have a different
1732            behaviour */
1733         gtk_drag_dest_set (GTK_WIDGET (self),
1734                            GTK_DEST_DEFAULT_HIGHLIGHT,
1735                            folder_view_drag_types,
1736                            G_N_ELEMENTS (folder_view_drag_types),
1737                            GDK_ACTION_MOVE | GDK_ACTION_COPY);
1738
1739         g_signal_connect (G_OBJECT (self),
1740                           "drag_data_received",
1741                           G_CALLBACK (on_drag_data_received),
1742                           NULL);
1743
1744
1745         /* Set up the treeview as a dnd source */
1746         gtk_drag_source_set (GTK_WIDGET (self),
1747                              GDK_BUTTON1_MASK,
1748                              folder_view_drag_types,
1749                              G_N_ELEMENTS (folder_view_drag_types),
1750                              GDK_ACTION_MOVE | GDK_ACTION_COPY);
1751
1752         g_signal_connect (G_OBJECT (self),
1753                           "drag_motion",
1754                           G_CALLBACK (on_drag_motion),
1755                           NULL);
1756
1757         g_signal_connect (G_OBJECT (self),
1758                           "drag_data_get",
1759                           G_CALLBACK (on_drag_data_get),
1760                           NULL);
1761
1762         g_signal_connect (G_OBJECT (self),
1763                           "drag_drop",
1764                           G_CALLBACK (drag_drop_cb),
1765                           NULL);
1766 }
1767
1768 /*
1769  * This function manages the navigation through the folders using the
1770  * keyboard or the hardware keys in the device
1771  */
1772 static gboolean
1773 on_key_pressed (GtkWidget *self,
1774                 GdkEventKey *event,
1775                 gpointer user_data)
1776 {
1777         GtkTreeSelection *selection;
1778         GtkTreeIter iter;
1779         GtkTreeModel *model;
1780         gboolean retval = FALSE;
1781
1782         /* Up and Down are automatically managed by the treeview */
1783         if (event->keyval == GDK_Return) {
1784                 /* Expand/Collapse the selected row */
1785                 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
1786                 if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
1787                         GtkTreePath *path;
1788
1789                         path = gtk_tree_model_get_path (model, &iter);
1790
1791                         if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (self), path))
1792                                 gtk_tree_view_collapse_row (GTK_TREE_VIEW (self), path);
1793                         else
1794                                 gtk_tree_view_expand_row (GTK_TREE_VIEW (self), path, FALSE);
1795                         gtk_tree_path_free (path);
1796                 }
1797                 /* No further processing */
1798                 retval = TRUE;
1799         }
1800
1801         return retval;
1802 }
1803
1804 /*
1805  * We listen to the changes in the local folder account name key,
1806  * because we want to show the right name in the view. The local
1807  * folder account name corresponds to the device name in the Maemo
1808  * version. We do this because we do not want to query gconf on each
1809  * tree view refresh. It's better to cache it and change whenever
1810  * necessary.
1811  */
1812 static void
1813 on_configuration_key_changed (ModestConf* conf,
1814                               const gchar *key,
1815                               ModestConfEvent event,
1816                               ModestFolderView *self)
1817 {
1818         ModestFolderViewPrivate *priv;
1819
1820         if (!key)
1821                 return;
1822
1823         g_return_if_fail (MODEST_IS_FOLDER_VIEW (self));
1824         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
1825
1826         if (!strcmp (key, MODEST_CONF_DEVICE_NAME)) {
1827                 g_free (priv->local_account_name);
1828
1829                 if (event == MODEST_CONF_EVENT_KEY_UNSET)
1830                         priv->local_account_name = g_strdup (MODEST_LOCAL_FOLDERS_DEFAULT_DISPLAY_NAME);
1831                 else
1832                         priv->local_account_name = modest_conf_get_string (modest_runtime_get_conf(),
1833                                                                            MODEST_CONF_DEVICE_NAME, NULL);
1834
1835                 /* Force a redraw */
1836 #if GTK_CHECK_VERSION(2, 8, 0) /* gtk_tree_view_column_queue_resize is only available in GTK+ 2.8 */
1837                 GtkTreeViewColumn * tree_column = gtk_tree_view_get_column (GTK_TREE_VIEW (self),
1838                                                                             TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN);
1839                 gtk_tree_view_column_queue_resize (tree_column);
1840 #endif
1841         }
1842 }
1843
1844 void
1845 modest_folder_view_set_style (ModestFolderView *self,
1846                               ModestFolderViewStyle style)
1847 {
1848         ModestFolderViewPrivate *priv;
1849
1850         g_return_if_fail (self);
1851
1852         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
1853
1854         priv->style = style;
1855 }
1856
1857 void
1858 modest_folder_view_set_account_id_of_visible_server_account (ModestFolderView *self,
1859                                                              const gchar *account_id)
1860 {
1861         ModestFolderViewPrivate *priv;
1862         GtkTreeModel *model;
1863
1864         g_return_if_fail (self);
1865
1866         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
1867
1868         /* This will be used by the filter_row callback,
1869          * to decided which rows to show: */
1870         if (priv->visible_account_id) {
1871                 g_free (priv->visible_account_id);
1872                 priv->visible_account_id = NULL;
1873         }
1874         if (account_id)
1875                 priv->visible_account_id = g_strdup (account_id);
1876
1877         /* Refilter */
1878         model = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
1879         if (GTK_IS_TREE_MODEL_FILTER (model))
1880                 gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
1881
1882         /* Save settings to gconf */
1883         modest_widget_memory_save (modest_runtime_get_conf (), G_OBJECT(self),
1884                                    MODEST_CONF_FOLDER_VIEW_KEY);
1885 }
1886
1887 const gchar *
1888 modest_folder_view_get_account_id_of_visible_server_account (ModestFolderView *self)
1889 {
1890         ModestFolderViewPrivate *priv;
1891
1892         g_return_val_if_fail (self, NULL);
1893
1894         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
1895
1896         return (const gchar *) priv->visible_account_id;
1897 }
1898
1899 static gboolean
1900 find_inbox_iter (GtkTreeModel *model, GtkTreeIter *iter, GtkTreeIter *inbox_iter)
1901 {
1902         do {
1903                 GtkTreeIter child;
1904                 TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
1905                 gchar *name = NULL;
1906
1907                 gtk_tree_model_get (model, iter,
1908                                     TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, &name,
1909                                     TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN,
1910                                     &type, -1);
1911
1912                 /*
1913                 printf ("DEBUG: %s: name=%s, type=%d, TNY_FOLDER_TYPE_INBOX=%d\n",
1914                         __FUNCTION__, name, type, TNY_FOLDER_TYPE_INBOX);
1915                 */
1916
1917                 gboolean result = FALSE;
1918                 if (type == TNY_FOLDER_TYPE_INBOX) {
1919                         result = TRUE;
1920                 } else if (type == TNY_FOLDER_TYPE_NORMAL) {
1921                         /* tinymail's camel implementation only provides TNY_FOLDER_TYPE_NORMAL
1922                          * when getting folders from the cache, before connectin, so we do
1923                          * an extra check. We could fix this in tinymail, but it's easier
1924                          * to do here.
1925                          */
1926                          if (strcmp (name, "Inbox") == 0)
1927                                 result = TRUE;
1928                 }
1929
1930                 g_free (name);
1931
1932                 if (result) {
1933                         *inbox_iter = *iter;
1934                         return TRUE;
1935                 }
1936
1937                 if (gtk_tree_model_iter_children (model, &child, iter)) {
1938                         if (find_inbox_iter (model, &child, inbox_iter))
1939                                 return TRUE;
1940                 }
1941
1942         } while (gtk_tree_model_iter_next (model, iter));
1943
1944         return FALSE;
1945 }
1946
1947 void
1948 modest_folder_view_select_first_inbox_or_local (ModestFolderView *self)
1949 {
1950         GtkTreeModel *model;
1951         GtkTreeIter iter, inbox_iter;
1952         GtkTreeSelection *sel;
1953
1954 /*      /\* Do not set it if the folder view was not painted *\/ */
1955 /*      if (!GTK_WIDGET_MAPPED (self)) */
1956 /*              return; */
1957
1958         model = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
1959         if (!model)
1960                 return;
1961
1962         expand_root_items (self);
1963         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
1964
1965         gtk_tree_model_get_iter_first (model, &iter);
1966         if (find_inbox_iter (model, &iter, &inbox_iter)) {
1967                 gtk_tree_selection_select_iter (sel, &inbox_iter);
1968         }
1969         else {
1970                 gtk_tree_model_get_iter_first (model, &iter);
1971                 gtk_tree_selection_select_iter (sel, &iter);
1972         }
1973 }
1974
1975 void
1976 modest_folder_view_copy_selection (ModestFolderView *folder_view)
1977 {
1978         /* Copy selection */
1979         _clipboard_set_selected_data (folder_view, FALSE);
1980 }
1981
1982 void
1983 modest_folder_view_cut_selection (ModestFolderView *folder_view)
1984 {
1985         ModestFolderViewPrivate *priv = NULL;
1986         GtkTreeModel *model = NULL;
1987         const gchar **hidding = NULL;
1988         guint i, n_selected;
1989
1990         g_return_if_fail (MODEST_IS_FOLDER_VIEW (folder_view));
1991         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (folder_view);
1992
1993         /* Copy selection */
1994         if (!_clipboard_set_selected_data (folder_view, TRUE))
1995                 return;
1996
1997         /* Get hidding ids */
1998         hidding = modest_email_clipboard_get_hidding_ids (priv->clipboard, &n_selected);
1999
2000         /* Clear hidding array created by previous cut operation */
2001         _clear_hidding_filter (MODEST_FOLDER_VIEW (folder_view));
2002
2003         /* Copy hidding array */
2004         priv->n_selected = n_selected;
2005         priv->hidding_ids = g_malloc0(sizeof(gchar *) * n_selected);
2006         for (i=0; i < n_selected; i++)
2007                 priv->hidding_ids[i] = g_strdup(hidding[i]);
2008
2009         /* Hide cut folders */
2010         model = gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view));
2011         gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
2012 }
2013
2014 /* Returns FALSE if it did not selected anything */
2015 static gboolean
2016 _clipboard_set_selected_data (ModestFolderView *folder_view,
2017                               gboolean delete)
2018 {
2019         ModestFolderViewPrivate *priv = NULL;
2020         TnyFolderStore *folder = NULL;
2021         gboolean retval = FALSE;
2022
2023         g_return_val_if_fail (MODEST_IS_FOLDER_VIEW (folder_view), FALSE);
2024         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (folder_view);
2025
2026         /* Set selected data on clipboard   */
2027         g_return_val_if_fail (MODEST_IS_EMAIL_CLIPBOARD (priv->clipboard), FALSE);
2028         folder = modest_folder_view_get_selected (folder_view);
2029
2030         /* Do not allow to select an account */
2031         if (TNY_IS_FOLDER (folder)) {
2032                 modest_email_clipboard_set_data (priv->clipboard, TNY_FOLDER(folder), NULL, delete);
2033                 retval = TRUE;
2034         }
2035
2036         /* Free */
2037         g_object_unref (folder);
2038
2039         return retval;
2040 }
2041
2042 static void
2043 _clear_hidding_filter (ModestFolderView *folder_view)
2044 {
2045         ModestFolderViewPrivate *priv;
2046         guint i;
2047
2048         g_return_if_fail (MODEST_IS_FOLDER_VIEW (folder_view));
2049         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(folder_view);
2050
2051         if (priv->hidding_ids != NULL) {
2052                 for (i=0; i < priv->n_selected; i++)
2053                         g_free (priv->hidding_ids[i]);
2054                 g_free(priv->hidding_ids);
2055         }
2056 }