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