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 <tny-camel-account.h>
  45 #include <modest-tny-account.h>
  46 #include <modest-tny-folder.h>
  47 #include <modest-tny-local-folders-account.h>
  48 #include <modest-tny-outbox-account.h>
  49 #include <modest-marshal.h>
  50 #include <modest-icon-names.h>
  51 #include <modest-tny-account-store.h>
  52 #include <modest-text-utils.h>
  53 #include <modest-runtime.h>
  54 #include "modest-folder-view.h"
  55 #include <modest-platform.h>
  56 #include <modest-widget-memory.h>
  57 #include <modest-ui-actions.h>
  58 #include "modest-dnd.h"
  59 #include "widgets/modest-window.h"
  60
  61 /* Folder view drag types */
  62 const GtkTargetEntry folder_view_drag_types[] =
  63 {
  64         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, MODEST_FOLDER_ROW },
  65         { GTK_TREE_PATH_AS_STRING_LIST, GTK_TARGET_SAME_APP, MODEST_HEADER_ROW }
  66 };
  67
  68 /* 'private'/'protected' functions */
  69 static void modest_folder_view_class_init  (ModestFolderViewClass *klass);
  70 static void modest_folder_view_init        (ModestFolderView *obj);
  71 static void modest_folder_view_finalize    (GObject *obj);
  72
  73 static void         tny_account_store_view_init (gpointer g,
  74                                                  gpointer iface_data);
  75
  76 static void         modest_folder_view_set_account_store (TnyAccountStoreView *self,
  77                                                           TnyAccountStore     *account_store);
  78
  79 static void         on_selection_changed   (GtkTreeSelection *sel,
  80                                             gpointer data);
  81
  82 static void         on_account_removed     (TnyAccountStore *self,
  83                                             TnyAccount *account,
  84                                             gpointer user_data);
  85
  86 static void         on_account_inserted    (TnyAccountStore *self,
  87                                             TnyAccount *account,
  88                                             gpointer user_data);
  89
  90 static void         on_account_changed    (TnyAccountStore *self,
  91                                             TnyAccount *account,
  92                                             gpointer user_data);
  93
  94 static gint         cmp_rows               (GtkTreeModel *tree_model,
  95                                             GtkTreeIter *iter1,
  96                                             GtkTreeIter *iter2,
  97                                             gpointer user_data);
  98
  99 static gboolean     filter_row             (GtkTreeModel *model,
 100                                             GtkTreeIter *iter,
 101                                             gpointer data);
 102
 103 static gboolean     on_key_pressed         (GtkWidget *self,
 104                                             GdkEventKey *event,
 105                                             gpointer user_data);
 106
 107 static void         on_configuration_key_changed  (ModestConf* conf,
 108                                                    const gchar *key,
 109                                                    ModestConfEvent event,
 110                                                    ModestConfNotificationId notification_id,
 111                                                    ModestFolderView *self);
 112
 113 /* DnD functions */
 114 static void         on_drag_data_get       (GtkWidget *widget,
 115                                             GdkDragContext *context,
 116                                             GtkSelectionData *selection_data,
 117                                             guint info,
 118                                             guint time,
 119                                             gpointer data);
 120
 121 static void         on_drag_data_received  (GtkWidget *widget,
 122                                             GdkDragContext *context,
 123                                             gint x,
 124                                             gint y,
 125                                             GtkSelectionData *selection_data,
 126                                             guint info,
 127                                             guint time,
 128                                             gpointer data);
 129
 130 static gboolean     on_drag_motion         (GtkWidget      *widget,
 131                                             GdkDragContext *context,
 132                                             gint            x,
 133                                             gint            y,
 134                                             guint           time,
 135                                             gpointer        user_data);
 136
 137 static void         expand_root_items (ModestFolderView *self);
 138
 139 static gint         expand_row_timeout     (gpointer data);
 140
 141 static void         setup_drag_and_drop    (GtkTreeView *self);
 142
 143 static gboolean     _clipboard_set_selected_data (ModestFolderView *folder_view,
 144                                                   gboolean delete);
 145
 146 static void         _clear_hidding_filter (ModestFolderView *folder_view);
 147
 148 static void         on_row_inserted_maybe_select_folder (GtkTreeModel     *tree_model,
 149                                                          GtkTreePath      *path,
 150                                                          GtkTreeIter      *iter,
 151                                                          ModestFolderView *self);
 152
 153 static void         on_display_name_changed (ModestAccountMgr *self,
 154                                              const gchar *account,
 155                                              gpointer user_data);
 156
 157 enum {
 158         FOLDER_SELECTION_CHANGED_SIGNAL,
 159         FOLDER_DISPLAY_NAME_CHANGED_SIGNAL,
 160         LAST_SIGNAL
 161 };
 162
 163 typedef struct _ModestFolderViewPrivate ModestFolderViewPrivate;
 164 struct _ModestFolderViewPrivate {
 165         TnyAccountStore      *account_store;
 166         TnyFolderStore       *cur_folder_store;
 167
 168         TnyFolder            *folder_to_select; /* folder to select after the next update */
 169
 170         gulong                changed_signal;
 171         gulong                account_inserted_signal;
 172         gulong                account_removed_signal;
 173         gulong                account_changed_signal;
 174         gulong                conf_key_signal;
 175         gulong                display_name_changed_signal;
 176
 177         /* not unref this object, its a singlenton */
 178         ModestEmailClipboard *clipboard;
 179
 180         /* Filter tree model */
 181         gchar **hidding_ids;
 182         guint n_selected;
 183
 184         TnyFolderStoreQuery  *query;
 185         guint                 timer_expander;
 186
 187         gchar                *local_account_name;
 188         gchar                *visible_account_id;
 189         ModestFolderViewStyle style;
 190
 191         gboolean  reselect; /* we use this to force a reselection of the INBOX */
 192         gboolean  show_non_move;
 193         gboolean  reexpand; /* next time we expose, we'll expand all root folders */
 194 };
 195 #define MODEST_FOLDER_VIEW_GET_PRIVATE(o)                       \
 196         (G_TYPE_INSTANCE_GET_PRIVATE((o),                       \
 197                                      MODEST_TYPE_FOLDER_VIEW,   \
 198                                      ModestFolderViewPrivate))
 199 /* globals */
 200 static GObjectClass *parent_class = NULL;
 201
 202 static guint signals[LAST_SIGNAL] = {0};
 203
 204 GType
 205 modest_folder_view_get_type (void)
 206 {
 207         static GType my_type = 0;
 208         if (!my_type) {
 209                 static const GTypeInfo my_info = {
 210                         sizeof(ModestFolderViewClass),
 211                         NULL,           /* base init */
 212                         NULL,           /* base finalize */
 213                         (GClassInitFunc) modest_folder_view_class_init,
 214                         NULL,           /* class finalize */
 215                         NULL,           /* class data */
 216                         sizeof(ModestFolderView),
 217                         1,              /* n_preallocs */
 218                         (GInstanceInitFunc) modest_folder_view_init,
 219                         NULL
 220                 };
 221
 222                 static const GInterfaceInfo tny_account_store_view_info = {
 223                         (GInterfaceInitFunc) tny_account_store_view_init, /* interface_init */
 224                         NULL,         /* interface_finalize */
 225                         NULL          /* interface_data */
 226                 };
 227
 228
 229                 my_type = g_type_register_static (GTK_TYPE_TREE_VIEW,
 230                                                   "ModestFolderView",
 231                                                   &my_info, 0);
 232
 233                 g_type_add_interface_static (my_type,
 234                                              TNY_TYPE_ACCOUNT_STORE_VIEW,
 235                                              &tny_account_store_view_info);
 236         }
 237         return my_type;
 238 }
 239
 240 static void
 241 modest_folder_view_class_init (ModestFolderViewClass *klass)
 242 {
 243         GObjectClass *gobject_class;
 244         gobject_class = (GObjectClass*) klass;
 245
 246         parent_class            = g_type_class_peek_parent (klass);
 247         gobject_class->finalize = modest_folder_view_finalize;
 248
 249         g_type_class_add_private (gobject_class,
 250                                   sizeof(ModestFolderViewPrivate));
 251
 252         signals[FOLDER_SELECTION_CHANGED_SIGNAL] =
 253                 g_signal_new ("folder_selection_changed",
 254                               G_TYPE_FROM_CLASS (gobject_class),
 255                               G_SIGNAL_RUN_FIRST,
 256                               G_STRUCT_OFFSET (ModestFolderViewClass,
 257                                                folder_selection_changed),
 258                               NULL, NULL,
 259                               modest_marshal_VOID__POINTER_BOOLEAN,
 260                               G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_BOOLEAN);
 261
 262         /*
 263          * This signal is emitted whenever the currently selected
 264          * folder display name is computed. Note that the name could
 265          * be different to the folder name, because we could append
 266          * the unread messages count to the folder name to build the
 267          * folder display name
 268          */
 269         signals[FOLDER_DISPLAY_NAME_CHANGED_SIGNAL] =
 270                 g_signal_new ("folder-display-name-changed",
 271                               G_TYPE_FROM_CLASS (gobject_class),
 272                               G_SIGNAL_RUN_FIRST,
 273                               G_STRUCT_OFFSET (ModestFolderViewClass,
 274                                                folder_display_name_changed),
 275                               NULL, NULL,
 276                               g_cclosure_marshal_VOID__STRING,
 277                               G_TYPE_NONE, 1, G_TYPE_STRING);
 278 }
 279
 280 /* Simplify checks for NULLs: */
 281 static gboolean
 282 strings_are_equal (const gchar *a, const gchar *b)
 283 {
 284         if (!a && !b)
 285                 return TRUE;
 286         if (a && b)
 287         {
 288                 return (strcmp (a, b) == 0);
 289         }
 290         else
 291                 return FALSE;
 292 }
 293
 294 static gboolean
 295 on_model_foreach_set_name(GtkTreeModel *model, GtkTreePath *path,  GtkTreeIter *iter, gpointer data)
 296 {
 297         GObject *instance = NULL;
 298
 299         gtk_tree_model_get (model, iter,
 300                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &instance,
 301                             -1);
 302
 303         if (!instance)
 304                 return FALSE; /* keep walking */
 305
 306         if (!TNY_IS_ACCOUNT (instance)) {
 307                 g_object_unref (instance);
 308                 return FALSE; /* keep walking */
 309         }
 310
 311         /* Check if this is the looked-for account: */
 312         TnyAccount *this_account = TNY_ACCOUNT (instance);
 313         TnyAccount *account = TNY_ACCOUNT (data);
 314
 315         const gchar *this_account_id = tny_account_get_id(this_account);
 316         const gchar *account_id = tny_account_get_id(account);
 317         g_object_unref (instance);
 318         instance = NULL;
 319
 320         /* printf ("DEBUG: %s: this_account_id=%s, account_id=%s\n", __FUNCTION__, this_account_id, account_id); */
 321         if (strings_are_equal(this_account_id, account_id)) {
 322                 /* Tell the model that the data has changed, so that
 323                  * it calls the cell_data_func callbacks again: */
 324                 /* TODO: This does not seem to actually cause the new string to be shown: */
 325                 gtk_tree_model_row_changed (model, path, iter);
 326
 327                 return TRUE; /* stop walking */
 328         }
 329
 330         return FALSE; /* keep walking */
 331 }
 332
 333 typedef struct
 334 {
 335         ModestFolderView *self;
 336         gchar *previous_name;
 337 } GetMmcAccountNameData;
 338
 339 static void
 340 on_get_mmc_account_name (TnyStoreAccount* account, gpointer user_data)
 341 {
 342         /* printf ("DEBU1G: %s: account name=%s\n", __FUNCTION__, tny_account_get_name (TNY_ACCOUNT(account))); */
 343
 344         GetMmcAccountNameData *data = (GetMmcAccountNameData*)user_data;
 345
 346         if (!strings_are_equal (
 347                 tny_account_get_name(TNY_ACCOUNT(account)),
 348                 data->previous_name)) {
 349
 350                 /* Tell the model that the data has changed, so that
 351                  * it calls the cell_data_func callbacks again: */
 352                 ModestFolderView *self = data->self;
 353                 GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
 354                 if (model)
 355                         gtk_tree_model_foreach(model, on_model_foreach_set_name, account);
 356         }
 357
 358         g_free (data->previous_name);
 359         g_slice_free (GetMmcAccountNameData, data);
 360 }
 361
 362 static void
 363 text_cell_data  (GtkTreeViewColumn *column,
 364                  GtkCellRenderer *renderer,
 365                  GtkTreeModel *tree_model,
 366                  GtkTreeIter *iter,
 367                  gpointer data)
 368 {
 369         ModestFolderViewPrivate *priv;
 370         GObject *rendobj = (GObject *) renderer;
 371         gchar *fname = NULL;
 372         TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
 373         GObject *instance = NULL;
 374
 375         gtk_tree_model_get (tree_model, iter,
 376                             TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, &fname,
 377                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &type,
 378                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &instance,
 379                             -1);
 380         if (!fname)
 381                 return;
 382
 383         if (!instance) {
 384                 g_free (fname);
 385                 return;
 386         }
 387
 388         ModestFolderView *self = MODEST_FOLDER_VIEW (data);
 389         priv =  MODEST_FOLDER_VIEW_GET_PRIVATE (self);
 390
 391         gchar *item_name = NULL;
 392         gint item_weight = 400;
 393
 394         if (type != TNY_FOLDER_TYPE_ROOT) {
 395                 gint number = 0;
 396
 397                 if (modest_tny_folder_is_local_folder (TNY_FOLDER (instance)) ||
 398                     modest_tny_folder_is_memory_card_folder (TNY_FOLDER (instance))) {
 399                         type = modest_tny_folder_get_local_or_mmc_folder_type (TNY_FOLDER (instance));
 400                         if (type != TNY_FOLDER_TYPE_UNKNOWN) {
 401                                 g_free (fname);
 402                                 fname = g_strdup (modest_local_folder_info_get_type_display_name (type));
 403                         }
 404                 }
 405
 406                 /* note: we cannot reliably get the counts from the tree model, we need
 407                  * to use explicit calls on tny_folder for some reason.
 408                  */
 409                 /* Select the number to show: the unread or unsent messages. in case of outbox/drafts, show all */
 410                 if ((type == TNY_FOLDER_TYPE_DRAFTS) ||
 411                     (type == TNY_FOLDER_TYPE_OUTBOX) ||
 412                     (type == TNY_FOLDER_TYPE_MERGE)) /* _OUTBOX actually returns _MERGE... */
 413                         number = tny_folder_get_all_count (TNY_FOLDER(instance));
 414                 else
 415                         number = tny_folder_get_unread_count (TNY_FOLDER(instance));
 416
 417                 /* Use bold font style if there are unread or unset messages */
 418                 if (number > 0) {
 419                         item_name = g_strdup_printf ("%s (%d)", fname, number);
 420                         item_weight = 800;
 421                 } else {
 422                         item_name = g_strdup (fname);
 423                         item_weight = 400;
 424                 }
 425
 426         } else if (TNY_IS_ACCOUNT (instance)) {
 427                 /* If it's a server account */
 428                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (instance))) {
 429                         item_name = g_strdup (priv->local_account_name);
 430                         item_weight = 800;
 431                 } else if (modest_tny_account_is_memory_card_account (TNY_ACCOUNT (instance))) {
 432                         /* fname is only correct when the items are first
 433                          * added to the model, not when the account is
 434                          * changed later, so get the name from the account
 435                          * instance: */
 436                         item_name = g_strdup (tny_account_get_name (TNY_ACCOUNT (instance)));
 437                         item_weight = 800;
 438                 } else {
 439                         item_name = g_strdup (fname);
 440                         item_weight = 800;
 441                 }
 442         }
 443
 444         if (!item_name)
 445                 item_name = g_strdup ("unknown");
 446
 447         if (item_name && item_weight) {
 448                 /* Set the name in the treeview cell: */
 449                 g_object_set (rendobj,"text", item_name, "weight", item_weight, NULL);
 450
 451                 /* Notify display name observers */
 452                 /* TODO: What listens for this signal, and how can it use only the new name? */
 453                 if (((GObject *) priv->cur_folder_store) == instance) {
 454                         g_signal_emit (G_OBJECT(self),
 455                                                signals[FOLDER_DISPLAY_NAME_CHANGED_SIGNAL], 0,
 456                                                item_name);
 457                 }
 458                 g_free (item_name);
 459
 460         }
 461
 462         /* If it is a Memory card account, make sure that we have the correct name.
 463          * This function will be trigerred again when the name has been retrieved: */
 464         if (TNY_IS_STORE_ACCOUNT (instance) &&
 465                 modest_tny_account_is_memory_card_account (TNY_ACCOUNT (instance))) {
 466
 467                 /* Get the account name asynchronously: */
 468                 GetMmcAccountNameData *callback_data =
 469                         g_slice_new0(GetMmcAccountNameData);
 470                 callback_data->self = self;
 471
 472                 const gchar *name = tny_account_get_name (TNY_ACCOUNT(instance));
 473                 if (name)
 474                         callback_data->previous_name = g_strdup (name);
 475
 476                 modest_tny_account_get_mmc_account_name (TNY_STORE_ACCOUNT (instance),
 477                                                          on_get_mmc_account_name, callback_data);
 478         }
 479
 480         g_object_unref (G_OBJECT (instance));
 481         g_free (fname);
 482 }
 483
 484
 485 typedef struct {
 486         GdkPixbuf *pixbuf;
 487         GdkPixbuf *pixbuf_open;
 488         GdkPixbuf *pixbuf_close;
 489 } ThreePixbufs;
 490
 491
 492 static ThreePixbufs*
 493 get_folder_icons (TnyFolderType type, GObject *instance)
 494 {
 495         GdkPixbuf *pixbuf = NULL;
 496         GdkPixbuf *pixbuf_open = NULL;
 497         GdkPixbuf *pixbuf_close = NULL;
 498         ThreePixbufs *retval = g_slice_new (ThreePixbufs);
 499
 500         static GdkPixbuf *inbox_pixbuf = NULL, *outbox_pixbuf = NULL,
 501                 *junk_pixbuf = NULL, *sent_pixbuf = NULL,
 502                 *trash_pixbuf = NULL, *draft_pixbuf = NULL,
 503                 *normal_pixbuf = NULL, *anorm_pixbuf = NULL,
 504                 *ammc_pixbuf = NULL, *avirt_pixbuf = NULL;
 505
 506         static GdkPixbuf *inbox_pixbuf_open = NULL, *outbox_pixbuf_open = NULL,
 507                 *junk_pixbuf_open = NULL, *sent_pixbuf_open = NULL,
 508                 *trash_pixbuf_open = NULL, *draft_pixbuf_open = NULL,
 509                 *normal_pixbuf_open = NULL, *anorm_pixbuf_open = NULL,
 510                 *ammc_pixbuf_open = NULL, *avirt_pixbuf_open = NULL;
 511
 512         static GdkPixbuf *inbox_pixbuf_close = NULL, *outbox_pixbuf_close = NULL,
 513                 *junk_pixbuf_close = NULL, *sent_pixbuf_close = NULL,
 514                 *trash_pixbuf_close = NULL, *draft_pixbuf_close = NULL,
 515                 *normal_pixbuf_close = NULL, *anorm_pixbuf_close = NULL,
 516                 *ammc_pixbuf_close = NULL, *avirt_pixbuf_close = NULL;
 517
 518
 519         /* MERGE is not needed anymore as the folder now has the correct type jschmid */
 520         /* We include the MERGE type here because it's used to create
 521            the local OUTBOX folder */
 522         if (type == TNY_FOLDER_TYPE_NORMAL ||
 523             type == TNY_FOLDER_TYPE_UNKNOWN) {
 524                 type = modest_tny_folder_guess_folder_type (TNY_FOLDER (instance));
 525         }
 526
 527         switch (type) {
 528         case TNY_FOLDER_TYPE_INVALID:
 529                 g_warning ("%s: BUG: TNY_FOLDER_TYPE_INVALID", __FUNCTION__);
 530                 break;
 531
 532         case TNY_FOLDER_TYPE_ROOT:
 533                 if (TNY_IS_ACCOUNT (instance)) {
 534
 535                         if (modest_tny_account_is_virtual_local_folders (
 536                                 TNY_ACCOUNT (instance))) {
 537
 538                             if (!avirt_pixbuf)
 539                                     avirt_pixbuf = gdk_pixbuf_copy (modest_platform_get_icon (MODEST_FOLDER_ICON_LOCAL_FOLDERS,
 540                                                                                               MODEST_ICON_SIZE_SMALL));
 541
 542                             if (!avirt_pixbuf_open) {
 543                                     GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_exp",
 544                                                                                   MODEST_ICON_SIZE_SMALL);
 545                                     avirt_pixbuf_open = gdk_pixbuf_copy (avirt_pixbuf);
 546                                     gdk_pixbuf_composite (emblem, avirt_pixbuf_open, 0, 0,
 547                                                           MIN (gdk_pixbuf_get_width (emblem),
 548                                                                gdk_pixbuf_get_width (avirt_pixbuf_open)),
 549                                                           MIN (gdk_pixbuf_get_height (emblem),
 550                                                                gdk_pixbuf_get_height (avirt_pixbuf_open)),
 551                                                           0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 552                                     g_object_unref (emblem);
 553                             }
 554
 555                             if (!avirt_pixbuf_close) {
 556                                     GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_clp",
 557                                                                                   MODEST_ICON_SIZE_SMALL);
 558                                 avirt_pixbuf_close = gdk_pixbuf_copy (avirt_pixbuf);
 559                                 gdk_pixbuf_composite (emblem, avirt_pixbuf_close, 0, 0,
 560                                                       MIN (gdk_pixbuf_get_width (emblem),
 561                                                            gdk_pixbuf_get_width (avirt_pixbuf_close)),
 562                                                       MIN (gdk_pixbuf_get_height (emblem),
 563                                                            gdk_pixbuf_get_height (avirt_pixbuf_close)),
 564                                                       0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 565                                 g_object_unref (emblem);
 566                             }
 567
 568
 569                             pixbuf = g_object_ref (avirt_pixbuf);
 570                             pixbuf_open = g_object_ref (avirt_pixbuf_open);
 571                             pixbuf_close = g_object_ref (avirt_pixbuf_close);
 572
 573                         }
 574                         else {
 575                                 const gchar *account_id = tny_account_get_id (TNY_ACCOUNT (instance));
 576
 577                                 if (!strcmp (account_id, MODEST_MMC_ACCOUNT_ID)) {
 578                                     if (!ammc_pixbuf)
 579                                             ammc_pixbuf = gdk_pixbuf_copy (modest_platform_get_icon (MODEST_FOLDER_ICON_MMC,
 580                                                                                                      MODEST_ICON_SIZE_SMALL));
 581
 582                                     if (!ammc_pixbuf_open) {
 583                                             GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_exp",
 584                                                                                           MODEST_ICON_SIZE_SMALL);
 585                                         ammc_pixbuf_open = gdk_pixbuf_copy (ammc_pixbuf);
 586                                         gdk_pixbuf_composite (emblem, ammc_pixbuf_open, 0, 0,
 587                                                               MIN (gdk_pixbuf_get_width (emblem),
 588                                                                    gdk_pixbuf_get_width (ammc_pixbuf_open)),
 589                                                               MIN (gdk_pixbuf_get_height (emblem),
 590                                                                    gdk_pixbuf_get_height (ammc_pixbuf_open)),
 591                                                               0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 592                                         g_object_unref (emblem);
 593                                     }
 594
 595                                     if (!ammc_pixbuf_close) {
 596                                             GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_clp",
 597                                                                                           MODEST_ICON_SIZE_SMALL);
 598                                         ammc_pixbuf_close = gdk_pixbuf_copy (ammc_pixbuf);
 599                                         gdk_pixbuf_composite (emblem, ammc_pixbuf_close, 0, 0,
 600                                                               MIN (gdk_pixbuf_get_width (emblem),
 601                                                                    gdk_pixbuf_get_width (ammc_pixbuf_close)),
 602                                                               MIN (gdk_pixbuf_get_height (emblem),
 603                                                                    gdk_pixbuf_get_height (ammc_pixbuf_close)),
 604                                                               0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 605                                         g_object_unref (emblem);
 606                                     }
 607
 608
 609                                     pixbuf = g_object_ref (ammc_pixbuf);
 610                                     pixbuf_open = g_object_ref (ammc_pixbuf_open);
 611                                     pixbuf_close = g_object_ref (ammc_pixbuf_close);
 612
 613                                 } else {
 614
 615                                     if (!anorm_pixbuf)
 616                                             anorm_pixbuf = gdk_pixbuf_copy (modest_platform_get_icon (MODEST_FOLDER_ICON_ACCOUNT,
 617                                                                                                       MODEST_ICON_SIZE_SMALL));
 618                                     if (!anorm_pixbuf_open) {
 619                                             GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_exp",
 620                                                                                           MODEST_ICON_SIZE_SMALL);
 621                                         anorm_pixbuf_open = gdk_pixbuf_copy (anorm_pixbuf);
 622                                         gdk_pixbuf_composite (emblem, anorm_pixbuf_open, 0, 0,
 623                                                               MIN (gdk_pixbuf_get_width (emblem),
 624                                                                    gdk_pixbuf_get_width (anorm_pixbuf_open)),
 625                                                               MIN (gdk_pixbuf_get_height (emblem),
 626                                                                    gdk_pixbuf_get_height (anorm_pixbuf_open)),
 627                                                               0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 628                                         g_object_unref (emblem);
 629                                     }
 630
 631                                     if (!anorm_pixbuf_close) {
 632                                             GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_clp",
 633                                                                                           MODEST_ICON_SIZE_SMALL);
 634                                         anorm_pixbuf_close = gdk_pixbuf_copy (anorm_pixbuf);
 635                                         gdk_pixbuf_composite (emblem, anorm_pixbuf_close, 0, 0,
 636                                                               MIN (gdk_pixbuf_get_width (emblem),
 637                                                                    gdk_pixbuf_get_width (anorm_pixbuf_close)),
 638                                                               MIN (gdk_pixbuf_get_height (emblem),
 639                                                                    gdk_pixbuf_get_height (anorm_pixbuf_close)),
 640                                                               0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 641                                         g_object_unref (emblem);
 642                                     }
 643
 644
 645                                     pixbuf = g_object_ref (anorm_pixbuf);
 646                                     pixbuf_open = g_object_ref (anorm_pixbuf_open);
 647                                     pixbuf_close = g_object_ref (anorm_pixbuf_close);
 648
 649                                 }
 650                         }
 651                 }
 652                 break;
 653         case TNY_FOLDER_TYPE_INBOX:
 654
 655             if (!inbox_pixbuf)
 656                     inbox_pixbuf = gdk_pixbuf_copy (modest_platform_get_icon (MODEST_FOLDER_ICON_INBOX,
 657                                                                               MODEST_ICON_SIZE_SMALL));
 658
 659             if (!inbox_pixbuf_open) {
 660                     GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_exp",
 661                                                                   MODEST_ICON_SIZE_SMALL);
 662                     inbox_pixbuf_open = gdk_pixbuf_copy (inbox_pixbuf);
 663                     gdk_pixbuf_composite (emblem, inbox_pixbuf_open, 0, 0,
 664                                           MIN (gdk_pixbuf_get_width (emblem),
 665                                                gdk_pixbuf_get_width (inbox_pixbuf_open)),
 666                                           MIN (gdk_pixbuf_get_height (emblem),
 667                                                gdk_pixbuf_get_height (inbox_pixbuf_open)),
 668                                           0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 669                     g_object_unref (emblem);
 670             }
 671
 672             if (!inbox_pixbuf_close) {
 673                     GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_clp",
 674                                                                   MODEST_ICON_SIZE_SMALL);
 675                     inbox_pixbuf_close = gdk_pixbuf_copy (inbox_pixbuf);
 676                     gdk_pixbuf_composite (emblem, inbox_pixbuf_close, 0, 0,
 677                                           MIN (gdk_pixbuf_get_width (emblem),
 678                                                gdk_pixbuf_get_width (inbox_pixbuf_close)),
 679                                           MIN (gdk_pixbuf_get_height (emblem),
 680                                                gdk_pixbuf_get_height (inbox_pixbuf_close)),
 681                                           0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 682                     g_object_unref (emblem);
 683             }
 684
 685
 686             pixbuf = g_object_ref (inbox_pixbuf);
 687             pixbuf_open = g_object_ref (inbox_pixbuf_open);
 688             pixbuf_close = g_object_ref (inbox_pixbuf_close);
 689
 690             break;
 691         case TNY_FOLDER_TYPE_OUTBOX:
 692                 if (!outbox_pixbuf)
 693                         outbox_pixbuf = gdk_pixbuf_copy (modest_platform_get_icon (MODEST_FOLDER_ICON_OUTBOX,
 694                                                                                    MODEST_ICON_SIZE_SMALL));
 695
 696                 if (!outbox_pixbuf_open) {
 697                         GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_exp",
 698                                                                       MODEST_ICON_SIZE_SMALL);
 699                         outbox_pixbuf_open = gdk_pixbuf_copy (outbox_pixbuf);
 700                         gdk_pixbuf_composite (emblem, outbox_pixbuf_open, 0, 0,
 701                                               MIN (gdk_pixbuf_get_width (emblem),
 702                                                    gdk_pixbuf_get_width (outbox_pixbuf_open)),
 703                                               MIN (gdk_pixbuf_get_height (emblem),
 704                                                    gdk_pixbuf_get_height (outbox_pixbuf_open)),
 705                                               0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 706                         g_object_unref (emblem);
 707             }
 708
 709             if (!outbox_pixbuf_close) {
 710                     GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_clp",
 711                                                                   MODEST_ICON_SIZE_SMALL);
 712                 outbox_pixbuf_close = gdk_pixbuf_copy (outbox_pixbuf);
 713                 gdk_pixbuf_composite (emblem, outbox_pixbuf_close, 0, 0,
 714                                       MIN (gdk_pixbuf_get_width (emblem),
 715                                            gdk_pixbuf_get_width (outbox_pixbuf_close)),
 716                                       MIN (gdk_pixbuf_get_height (emblem),
 717                                            gdk_pixbuf_get_height (outbox_pixbuf_close)),
 718                                       0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 719                 g_object_unref (emblem);
 720             }
 721
 722
 723             pixbuf = g_object_ref (outbox_pixbuf);
 724             pixbuf_open = g_object_ref (outbox_pixbuf_open);
 725             pixbuf_close = g_object_ref (outbox_pixbuf_close);
 726
 727             break;
 728         case TNY_FOLDER_TYPE_JUNK:
 729             if (!junk_pixbuf)
 730                     junk_pixbuf = gdk_pixbuf_copy (modest_platform_get_icon (MODEST_FOLDER_ICON_JUNK,
 731                                                                              MODEST_ICON_SIZE_SMALL));
 732             if (!junk_pixbuf_open) {
 733                     GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_exp",
 734                                                                   MODEST_ICON_SIZE_SMALL);
 735                     junk_pixbuf_open = gdk_pixbuf_copy (junk_pixbuf);
 736                     gdk_pixbuf_composite (emblem, junk_pixbuf_open, 0, 0,
 737                                           MIN (gdk_pixbuf_get_width (emblem),
 738                                                gdk_pixbuf_get_width (junk_pixbuf_open)),
 739                                           MIN (gdk_pixbuf_get_height (emblem),
 740                                                gdk_pixbuf_get_height (junk_pixbuf_open)),
 741                                           0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 742                     g_object_unref (emblem);
 743             }
 744
 745             if (!junk_pixbuf_close) {
 746                     GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_clp",
 747                                                                   MODEST_ICON_SIZE_SMALL);
 748                     junk_pixbuf_close = gdk_pixbuf_copy (junk_pixbuf);
 749                     gdk_pixbuf_composite (emblem, junk_pixbuf_close, 0, 0,
 750                                           MIN (gdk_pixbuf_get_width (emblem),
 751                                                gdk_pixbuf_get_width (junk_pixbuf_close)),
 752                                           MIN (gdk_pixbuf_get_height (emblem),
 753                                                gdk_pixbuf_get_height (junk_pixbuf_close)),
 754                                           0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 755                     g_object_unref (emblem);
 756             }
 757
 758
 759             pixbuf = g_object_ref (junk_pixbuf);
 760             pixbuf_open = g_object_ref (junk_pixbuf_open);
 761             pixbuf_close = g_object_ref (junk_pixbuf_close);
 762
 763             break;
 764
 765         case TNY_FOLDER_TYPE_SENT:
 766                 if (!sent_pixbuf)
 767                         sent_pixbuf = gdk_pixbuf_copy (modest_platform_get_icon (MODEST_FOLDER_ICON_SENT,
 768                                                                                  MODEST_ICON_SIZE_SMALL));
 769
 770                 if (!sent_pixbuf_open) {
 771                         GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_exp",
 772                                                                       MODEST_ICON_SIZE_SMALL);
 773                         sent_pixbuf_open = gdk_pixbuf_copy (sent_pixbuf);
 774                         gdk_pixbuf_composite (emblem, sent_pixbuf_open, 0, 0,
 775                                               MIN (gdk_pixbuf_get_width (emblem),
 776                                                    gdk_pixbuf_get_width (sent_pixbuf_open)),
 777                                               MIN (gdk_pixbuf_get_height (emblem),
 778                                                    gdk_pixbuf_get_height (sent_pixbuf_open)),
 779                                               0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 780                         g_object_unref (emblem);
 781                 }
 782
 783                 if (!sent_pixbuf_close) {
 784                         GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_clp",
 785                                                                       MODEST_ICON_SIZE_SMALL);
 786                         sent_pixbuf_close = gdk_pixbuf_copy (sent_pixbuf);
 787                         gdk_pixbuf_composite (emblem, sent_pixbuf_close, 0, 0,
 788                                               MIN (gdk_pixbuf_get_width (emblem),
 789                                                    gdk_pixbuf_get_width (sent_pixbuf_close)),
 790                                               MIN (gdk_pixbuf_get_height (emblem),
 791                                                    gdk_pixbuf_get_height (sent_pixbuf_close)),
 792                                               0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 793                         g_object_unref (emblem);
 794                 }
 795
 796
 797             pixbuf = g_object_ref (sent_pixbuf);
 798             pixbuf_open = g_object_ref (sent_pixbuf_open);
 799             pixbuf_close = g_object_ref (sent_pixbuf_close);
 800
 801             break;
 802
 803         case TNY_FOLDER_TYPE_TRASH:
 804             if (!trash_pixbuf)
 805                     trash_pixbuf = gdk_pixbuf_copy (modest_platform_get_icon (MODEST_FOLDER_ICON_TRASH,
 806                                                                               MODEST_ICON_SIZE_SMALL));
 807             if (!trash_pixbuf_open) {
 808                     GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_exp",
 809                                                                   MODEST_ICON_SIZE_SMALL);
 810                     trash_pixbuf_open = gdk_pixbuf_copy (trash_pixbuf);
 811                     gdk_pixbuf_composite (emblem, trash_pixbuf_open, 0, 0,
 812                                           MIN (gdk_pixbuf_get_width (emblem),
 813                                                gdk_pixbuf_get_width (trash_pixbuf_open)),
 814                                           MIN (gdk_pixbuf_get_height (emblem),
 815                                                gdk_pixbuf_get_height (trash_pixbuf_open)),
 816                                           0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 817                     g_object_unref (emblem);
 818             }
 819
 820             if (!trash_pixbuf_close) {
 821                     GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_clp",
 822                                                                   MODEST_ICON_SIZE_SMALL);
 823                     trash_pixbuf_close = gdk_pixbuf_copy (trash_pixbuf);
 824                     gdk_pixbuf_composite (emblem, trash_pixbuf_close, 0, 0,
 825                                           MIN (gdk_pixbuf_get_width (emblem),
 826                                                gdk_pixbuf_get_width (trash_pixbuf_close)),
 827                                           MIN (gdk_pixbuf_get_height (emblem),
 828                                                gdk_pixbuf_get_height (trash_pixbuf_close)),
 829                                           0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 830                     g_object_unref (emblem);
 831             }
 832
 833
 834             pixbuf = g_object_ref (trash_pixbuf);
 835             pixbuf_open = g_object_ref (trash_pixbuf_open);
 836             pixbuf_close = g_object_ref (trash_pixbuf_close);
 837
 838             break;
 839         case TNY_FOLDER_TYPE_DRAFTS:
 840            if (!draft_pixbuf)
 841                    draft_pixbuf = gdk_pixbuf_copy (modest_platform_get_icon (MODEST_FOLDER_ICON_DRAFTS,
 842                                                                              MODEST_ICON_SIZE_SMALL));
 843
 844             if (!draft_pixbuf_open) {
 845                     GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_exp",
 846                                                                   MODEST_ICON_SIZE_SMALL);
 847                 draft_pixbuf_open = gdk_pixbuf_copy (draft_pixbuf);
 848                 gdk_pixbuf_composite (emblem, draft_pixbuf_open, 0, 0,
 849                                       MIN (gdk_pixbuf_get_width (emblem),
 850                                            gdk_pixbuf_get_width (draft_pixbuf_open)),
 851                                       MIN (gdk_pixbuf_get_height (emblem),
 852                                            gdk_pixbuf_get_height (draft_pixbuf_open)),
 853                                       0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 854                 g_object_unref (emblem);
 855             }
 856
 857             if (!draft_pixbuf_close) {
 858                     GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_clp",
 859                                                                   MODEST_ICON_SIZE_SMALL);
 860                 draft_pixbuf_close = gdk_pixbuf_copy (draft_pixbuf);
 861                 gdk_pixbuf_composite (emblem, draft_pixbuf_close, 0, 0,
 862                                       MIN (gdk_pixbuf_get_width (emblem),
 863                                            gdk_pixbuf_get_width (draft_pixbuf_close)),
 864                                       MIN (gdk_pixbuf_get_height (emblem),
 865                                            gdk_pixbuf_get_height (draft_pixbuf_close)),
 866                                       0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 867                 g_object_unref (emblem);
 868             }
 869
 870
 871             pixbuf = g_object_ref (draft_pixbuf);
 872             pixbuf_open = g_object_ref (draft_pixbuf_open);
 873             pixbuf_close = g_object_ref (draft_pixbuf_close);
 874
 875             break;
 876         case TNY_FOLDER_TYPE_NORMAL:
 877         default:
 878                 if (!normal_pixbuf)
 879                         normal_pixbuf = gdk_pixbuf_copy (modest_platform_get_icon (MODEST_FOLDER_ICON_NORMAL,
 880                                                                                    MODEST_ICON_SIZE_SMALL));
 881
 882                 if (!normal_pixbuf_open) {
 883                         GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_exp",
 884                                                                       MODEST_ICON_SIZE_SMALL);
 885                         normal_pixbuf_open = gdk_pixbuf_copy (normal_pixbuf);
 886                         gdk_pixbuf_composite (emblem, normal_pixbuf_open, 0, 0,
 887                                               MIN (gdk_pixbuf_get_width (emblem),
 888                                                    gdk_pixbuf_get_width (normal_pixbuf_open)),
 889                                               MIN (gdk_pixbuf_get_height (emblem),
 890                                                    gdk_pixbuf_get_height (normal_pixbuf_open)),
 891                                               0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 892                         g_object_unref (emblem);
 893                 }
 894
 895                 if (!normal_pixbuf_close) {
 896                         GdkPixbuf *emblem = modest_platform_get_icon ("qgn_list_gene_fldr_clp",
 897                                                                       MODEST_ICON_SIZE_SMALL);
 898                         normal_pixbuf_close = gdk_pixbuf_copy (normal_pixbuf);
 899                         gdk_pixbuf_composite (emblem, normal_pixbuf_close, 0, 0,
 900                                               MIN (gdk_pixbuf_get_width (emblem),
 901                                                    gdk_pixbuf_get_width (normal_pixbuf_close)),
 902                                               MIN (gdk_pixbuf_get_height (emblem),
 903                                                    gdk_pixbuf_get_height (normal_pixbuf_close)),
 904                                               0, 0, 1, 1, GDK_INTERP_NEAREST, 255);
 905                         g_object_unref (emblem);
 906                 }
 907
 908
 909             pixbuf = g_object_ref (normal_pixbuf);
 910             pixbuf_open = g_object_ref (normal_pixbuf_open);
 911             pixbuf_close = g_object_ref (normal_pixbuf_close);
 912
 913             break;
 914
 915         }
 916
 917         retval->pixbuf = pixbuf;
 918         retval->pixbuf_open = pixbuf_open;
 919         retval->pixbuf_close = pixbuf_close;
 920
 921         return retval;
 922 }
 923
 924
 925 static void
 926 free_pixbufs (ThreePixbufs *pixbufs)
 927 {
 928         g_object_unref (pixbufs->pixbuf);
 929         g_object_unref (pixbufs->pixbuf_open);
 930         g_object_unref (pixbufs->pixbuf_close);
 931         g_slice_free (ThreePixbufs, pixbufs);
 932 }
 933
 934 static void
 935 icon_cell_data  (GtkTreeViewColumn *column,
 936                  GtkCellRenderer *renderer,
 937                  GtkTreeModel *tree_model,
 938                  GtkTreeIter *iter,
 939                  gpointer data)
 940 {
 941         GObject *rendobj = NULL, *instance = NULL;
 942         TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
 943         gboolean has_children;
 944         ThreePixbufs *pixbufs;
 945
 946         rendobj = (GObject *) renderer;
 947
 948         gtk_tree_model_get (tree_model, iter,
 949                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &type,
 950                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &instance,
 951                             -1);
 952
 953         if (!instance)
 954                 return;
 955
 956         has_children = gtk_tree_model_iter_has_child (tree_model, iter);
 957         pixbufs = get_folder_icons (type, instance);
 958         g_object_unref (instance);
 959
 960         /* Set pixbuf */
 961         g_object_set (rendobj, "pixbuf", pixbufs->pixbuf, NULL);
 962
 963         if (has_children) {
 964                 g_object_set (rendobj, "pixbuf-expander-open", pixbufs->pixbuf_open, NULL);
 965                 g_object_set (rendobj, "pixbuf-expander-closed", pixbufs->pixbuf_close, NULL);
 966         }
 967
 968         free_pixbufs (pixbufs);
 969
 970         return;
 971 }
 972
 973 static void
 974 add_columns (GtkWidget *treeview)
 975 {
 976         GtkTreeViewColumn *column;
 977         GtkCellRenderer *renderer;
 978         GtkTreeSelection *sel;
 979
 980         /* Create column */
 981         column = gtk_tree_view_column_new ();
 982
 983         /* Set icon and text render function */
 984         renderer = gtk_cell_renderer_pixbuf_new();
 985         gtk_tree_view_column_pack_start (column, renderer, FALSE);
 986         gtk_tree_view_column_set_cell_data_func(column, renderer,
 987                                                 icon_cell_data, treeview, NULL);
 988
 989         renderer = gtk_cell_renderer_text_new();
 990         g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END,
 991                         "ellipsize-set", TRUE, NULL);
 992         gtk_tree_view_column_pack_start (column, renderer, TRUE);
 993         gtk_tree_view_column_set_cell_data_func(column, renderer,
 994                                                 text_cell_data, treeview, NULL);
 995
 996         /* Set selection mode */
 997         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW(treeview));
 998         gtk_tree_selection_set_mode (sel, GTK_SELECTION_SINGLE);
 999
1000         /* Set treeview appearance */
1001         gtk_tree_view_column_set_spacing (column, 2);
1002         gtk_tree_view_column_set_resizable (column, TRUE);
1003         gtk_tree_view_column_set_fixed_width (column, TRUE);
1004         gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW(treeview), FALSE);
1005         gtk_tree_view_set_enable_search (GTK_TREE_VIEW(treeview), FALSE);
1006
1007         /* Add column */
1008         gtk_tree_view_append_column (GTK_TREE_VIEW(treeview),column);
1009 }
1010
1011 static void
1012 modest_folder_view_init (ModestFolderView *obj)
1013 {
1014         ModestFolderViewPrivate *priv;
1015         ModestConf *conf;
1016
1017         priv =  MODEST_FOLDER_VIEW_GET_PRIVATE(obj);
1018
1019         priv->timer_expander = 0;
1020         priv->account_store  = NULL;
1021         priv->query          = NULL;
1022         priv->style          = MODEST_FOLDER_VIEW_STYLE_SHOW_ALL;
1023         priv->cur_folder_store   = NULL;
1024         priv->visible_account_id = NULL;
1025         priv->folder_to_select = NULL;
1026
1027         priv->reexpand = TRUE;
1028
1029         /* Initialize the local account name */
1030         conf = modest_runtime_get_conf();
1031         priv->local_account_name = modest_conf_get_string (conf, MODEST_CONF_DEVICE_NAME, NULL);
1032
1033         /* Init email clipboard */
1034         priv->clipboard = modest_runtime_get_email_clipboard ();
1035         priv->hidding_ids = NULL;
1036         priv->n_selected = 0;
1037         priv->reselect = FALSE;
1038         priv->show_non_move = TRUE;
1039
1040         /* Build treeview */
1041         add_columns (GTK_WIDGET (obj));
1042
1043         /* Setup drag and drop */
1044         setup_drag_and_drop (GTK_TREE_VIEW(obj));
1045
1046         /* Connect signals */
1047         g_signal_connect (G_OBJECT (obj),
1048                           "key-press-event",
1049                           G_CALLBACK (on_key_pressed), NULL);
1050
1051         priv->display_name_changed_signal =
1052                 g_signal_connect (modest_runtime_get_account_mgr (),
1053                                   "display_name_changed",
1054                                   G_CALLBACK (on_display_name_changed),
1055                                   obj);
1056
1057         /*
1058          * Track changes in the local account name (in the device it
1059          * will be the device name)
1060          */
1061         priv->conf_key_signal = g_signal_connect (G_OBJECT(conf),
1062                                                   "key_changed",
1063                                                   G_CALLBACK(on_configuration_key_changed),
1064                                                   obj);
1065 }
1066
1067 static void
1068 tny_account_store_view_init (gpointer g, gpointer iface_data)
1069 {
1070         TnyAccountStoreViewIface *klass = (TnyAccountStoreViewIface *)g;
1071
1072         klass->set_account_store_func = modest_folder_view_set_account_store;
1073
1074         return;
1075 }
1076
1077 static void
1078 modest_folder_view_finalize (GObject *obj)
1079 {
1080         ModestFolderViewPrivate *priv;
1081         GtkTreeSelection    *sel;
1082
1083         g_return_if_fail (obj);
1084
1085         priv =  MODEST_FOLDER_VIEW_GET_PRIVATE(obj);
1086
1087         if (priv->timer_expander != 0) {
1088                 g_source_remove (priv->timer_expander);
1089                 priv->timer_expander = 0;
1090         }
1091
1092         if (priv->account_store) {
1093                 g_signal_handler_disconnect (G_OBJECT(priv->account_store),
1094                                              priv->account_inserted_signal);
1095                 g_signal_handler_disconnect (G_OBJECT(priv->account_store),
1096                                              priv->account_removed_signal);
1097                 g_signal_handler_disconnect (G_OBJECT(priv->account_store),
1098                                              priv->account_changed_signal);
1099                 g_object_unref (G_OBJECT(priv->account_store));
1100                 priv->account_store = NULL;
1101         }
1102
1103         if (priv->query) {
1104                 g_object_unref (G_OBJECT (priv->query));
1105                 priv->query = NULL;
1106         }
1107
1108 /*      modest_folder_view_disable_next_folder_selection (MODEST_FOLDER_VIEW(obj)); */
1109         if (priv->folder_to_select) {
1110                 g_object_unref (G_OBJECT(priv->folder_to_select));
1111                 priv->folder_to_select = NULL;
1112         }
1113
1114         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW(obj));
1115         if (sel)
1116                 g_signal_handler_disconnect (G_OBJECT(sel), priv->changed_signal);
1117
1118         g_free (priv->local_account_name);
1119         g_free (priv->visible_account_id);
1120
1121         if (priv->conf_key_signal) {
1122                 g_signal_handler_disconnect (modest_runtime_get_conf (),
1123                                              priv->conf_key_signal);
1124                 priv->conf_key_signal = 0;
1125         }
1126
1127         if (priv->cur_folder_store) {
1128                 if (TNY_IS_FOLDER(priv->cur_folder_store))
1129                         tny_folder_sync (TNY_FOLDER(priv->cur_folder_store), FALSE, NULL);
1130
1131                 g_object_unref (priv->cur_folder_store);
1132                 priv->cur_folder_store = NULL;
1133         }
1134
1135         /* Clear hidding array created by cut operation */
1136         _clear_hidding_filter (MODEST_FOLDER_VIEW (obj));
1137
1138         G_OBJECT_CLASS(parent_class)->finalize (obj);
1139 }
1140
1141
1142 static void
1143 modest_folder_view_set_account_store (TnyAccountStoreView *self, TnyAccountStore *account_store)
1144 {
1145         ModestFolderViewPrivate *priv;
1146         TnyDevice *device;
1147
1148         g_return_if_fail (MODEST_IS_FOLDER_VIEW (self));
1149         g_return_if_fail (TNY_IS_ACCOUNT_STORE (account_store));
1150
1151         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (self);
1152         device = tny_account_store_get_device (account_store);
1153
1154         if (G_UNLIKELY (priv->account_store)) {
1155
1156                 if (g_signal_handler_is_connected (G_OBJECT (priv->account_store),
1157                                                    priv->account_inserted_signal))
1158                         g_signal_handler_disconnect (G_OBJECT (priv->account_store),
1159                                                      priv->account_inserted_signal);
1160                 if (g_signal_handler_is_connected (G_OBJECT (priv->account_store),
1161                                                    priv->account_removed_signal))
1162                         g_signal_handler_disconnect (G_OBJECT (priv->account_store),
1163                                                      priv->account_removed_signal);
1164                 if (g_signal_handler_is_connected (G_OBJECT (priv->account_store),
1165                                                    priv->account_changed_signal))
1166                         g_signal_handler_disconnect (G_OBJECT (priv->account_store),
1167                                                      priv->account_changed_signal);
1168                 g_object_unref (G_OBJECT (priv->account_store));
1169         }
1170
1171         priv->account_store = g_object_ref (G_OBJECT (account_store));
1172
1173         priv->account_removed_signal =
1174                 g_signal_connect (G_OBJECT(account_store), "account_removed",
1175                                   G_CALLBACK (on_account_removed), self);
1176
1177         priv->account_inserted_signal =
1178                 g_signal_connect (G_OBJECT(account_store), "account_inserted",
1179                                   G_CALLBACK (on_account_inserted), self);
1180
1181         priv->account_changed_signal =
1182                 g_signal_connect (G_OBJECT(account_store), "account_changed",
1183                                   G_CALLBACK (on_account_changed), self);
1184
1185         modest_folder_view_update_model (MODEST_FOLDER_VIEW (self), account_store);
1186
1187         g_object_unref (G_OBJECT (device));
1188 }
1189
1190 static void
1191 on_connection_status_changed (TnyAccount *self,
1192                               TnyConnectionStatus status,
1193                               gpointer user_data)
1194 {
1195         /* If the account becomes online then refresh it */
1196         if (status == TNY_CONNECTION_STATUS_CONNECTED) {
1197                 const gchar *acc_name;
1198                 GtkWidget *my_window;
1199
1200                 my_window = gtk_widget_get_ancestor (GTK_WIDGET (user_data), MODEST_TYPE_WINDOW);
1201                 acc_name = modest_tny_account_get_parent_modest_account_name_for_server_account (self);
1202                 modest_ui_actions_do_send_receive (acc_name, FALSE, MODEST_WINDOW (my_window));
1203         }
1204 }
1205
1206 static void
1207 on_account_inserted (TnyAccountStore *account_store,
1208                      TnyAccount *account,
1209                      gpointer user_data)
1210 {
1211         ModestFolderViewPrivate *priv;
1212         GtkTreeModel *sort_model, *filter_model;
1213
1214         /* Ignore transport account insertions, we're not showing them
1215            in the folder view */
1216         if (TNY_IS_TRANSPORT_ACCOUNT (account))
1217                 return;
1218
1219         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (user_data);
1220
1221         /* If we're adding a new account, and there is no previous
1222            one, we need to select the visible server account */
1223         if (priv->style == MODEST_FOLDER_VIEW_STYLE_SHOW_ONE &&
1224             !priv->visible_account_id)
1225                 modest_widget_memory_restore (modest_runtime_get_conf(),
1226                                               G_OBJECT (user_data),
1227                                               MODEST_CONF_FOLDER_VIEW_KEY);
1228
1229         /* Get the inner model */
1230         filter_model = gtk_tree_view_get_model (GTK_TREE_VIEW (user_data));
1231         sort_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (filter_model));
1232
1233         /* Insert the account in the model */
1234         tny_list_append (TNY_LIST (gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (sort_model))),
1235                          G_OBJECT (account));
1236
1237
1238         /* When the store account gets online refresh it */
1239         g_signal_connect (account, "connection_status_changed",
1240                           G_CALLBACK (on_connection_status_changed),
1241                           MODEST_FOLDER_VIEW (user_data));
1242
1243         /* Refilter the model */
1244         gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (filter_model));
1245 }
1246
1247
1248 static void
1249 on_account_changed (TnyAccountStore *account_store,
1250                     TnyAccount *tny_account,
1251                     gpointer user_data)
1252 {
1253         ModestFolderViewPrivate *priv;
1254         GtkTreeModel *sort_model, *filter_model;
1255
1256         /* Ignore transport account insertions, we're not showing them
1257            in the folder view */
1258         if (TNY_IS_TRANSPORT_ACCOUNT (tny_account))
1259                 return;
1260
1261         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (user_data);
1262
1263         /* Get the inner model */
1264         filter_model = gtk_tree_view_get_model (GTK_TREE_VIEW (user_data));
1265         sort_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (filter_model));
1266
1267         /* Remove the account from the model */
1268         tny_list_remove (TNY_LIST (gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (sort_model))),
1269                          G_OBJECT (tny_account));
1270
1271         /* Insert the account in the model */
1272         tny_list_append (TNY_LIST (gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (sort_model))),
1273                          G_OBJECT (tny_account));
1274
1275         /* Refilter the model */
1276         gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (filter_model));
1277 }
1278
1279 /**
1280  *
1281  * Selects the first inbox or the local account in an idle
1282  */
1283 static gboolean
1284 on_idle_select_first_inbox_or_local (gpointer user_data)
1285 {
1286         ModestFolderView *self = MODEST_FOLDER_VIEW (user_data);
1287
1288         modest_folder_view_select_first_inbox_or_local (self);
1289
1290         return FALSE;
1291 }
1292
1293
1294 static void
1295 on_account_removed (TnyAccountStore *account_store,
1296                     TnyAccount *account,
1297                     gpointer user_data)
1298 {
1299         ModestFolderView *self = NULL;
1300         ModestFolderViewPrivate *priv;
1301         GtkTreeModel *sort_model, *filter_model;
1302         GtkTreeSelection *sel = NULL;
1303         gboolean same_account_selected = FALSE;
1304
1305         /* Ignore transport account removals, we're not showing them
1306            in the folder view */
1307         if (TNY_IS_TRANSPORT_ACCOUNT (account))
1308                 return;
1309
1310         self = MODEST_FOLDER_VIEW (user_data);
1311         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (self);
1312
1313         /* Invalidate the cur_folder_store only if the selected folder
1314            belongs to the account that is being removed */
1315         if (priv->cur_folder_store) {
1316                 TnyAccount *selected_folder_account = NULL;
1317
1318                 if (TNY_IS_FOLDER (priv->cur_folder_store)) {
1319                         selected_folder_account =
1320                                 tny_folder_get_account (TNY_FOLDER (priv->cur_folder_store));
1321                 } else {
1322                         selected_folder_account =
1323                                 TNY_ACCOUNT (g_object_ref (priv->cur_folder_store));
1324                 }
1325
1326                 if (selected_folder_account == account) {
1327                         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
1328                         gtk_tree_selection_unselect_all (sel);
1329                         same_account_selected = TRUE;
1330                 }
1331                 g_object_unref (selected_folder_account);
1332         }
1333
1334         /* Invalidate row to select only if the folder to select
1335            belongs to the account that is being removed*/
1336         if (priv->folder_to_select) {
1337                 TnyAccount *folder_to_select_account = NULL;
1338
1339                 folder_to_select_account = tny_folder_get_account (priv->folder_to_select);
1340                 if (folder_to_select_account == account) {
1341                         modest_folder_view_disable_next_folder_selection (self);
1342                         g_object_unref (priv->folder_to_select);
1343                         priv->folder_to_select = NULL;
1344                 }
1345                 g_object_unref (folder_to_select_account);
1346         }
1347
1348         /* Remove the account from the model */
1349         filter_model = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
1350         sort_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (filter_model));
1351         tny_list_remove (TNY_LIST (gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (sort_model))),
1352                          G_OBJECT (account));
1353
1354         /* If the removed account is the currently viewed one then
1355            clear the configuration value. The new visible account will be the default account */
1356         if (priv->visible_account_id &&
1357             !strcmp (priv->visible_account_id, tny_account_get_id (account))) {
1358
1359                 /* Clear the current visible account_id */
1360                 modest_folder_view_set_account_id_of_visible_server_account (self, NULL);
1361
1362                 /* Call the restore method, this will set the new visible account */
1363                 modest_widget_memory_restore (modest_runtime_get_conf(), G_OBJECT(self),
1364                                               MODEST_CONF_FOLDER_VIEW_KEY);
1365         }
1366
1367         /* Refilter the model */
1368         gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (filter_model));
1369
1370         /* Select the first INBOX if the currently selected folder
1371            belongs to the account that is being deleted */
1372         if (same_account_selected)
1373                 g_idle_add (on_idle_select_first_inbox_or_local, self);
1374 }
1375
1376 void
1377 modest_folder_view_set_title (ModestFolderView *self, const gchar *title)
1378 {
1379         GtkTreeViewColumn *col;
1380
1381         g_return_if_fail (self && MODEST_IS_FOLDER_VIEW(self));
1382
1383         col = gtk_tree_view_get_column (GTK_TREE_VIEW(self), 0);
1384         if (!col) {
1385                 g_printerr ("modest: failed get column for title\n");
1386                 return;
1387         }
1388
1389         gtk_tree_view_column_set_title (col, title);
1390         gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(self),
1391                                            title != NULL);
1392 }
1393
1394 static gboolean
1395 modest_folder_view_on_map (ModestFolderView *self,
1396                            GdkEventExpose *event,
1397                            gpointer data)
1398 {
1399         ModestFolderViewPrivate *priv;
1400
1401         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (self);
1402
1403         /* This won't happen often */
1404         if (G_UNLIKELY (priv->reselect)) {
1405                 /* Select the first inbox or the local account if not found */
1406
1407                 /* TODO: this could cause a lock at startup, so we
1408                    comment it for the moment. We know that this will
1409                    be a bug, because the INBOX is not selected, but we
1410                    need to rewrite some parts of Modest to avoid the
1411                    deathlock situation */
1412                 /* TODO: check if this is still the case */
1413                 priv->reselect = FALSE;
1414                 modest_folder_view_select_first_inbox_or_local (self);
1415                 /* Notify the display name observers */
1416                 g_signal_emit (G_OBJECT(self),
1417                                signals[FOLDER_DISPLAY_NAME_CHANGED_SIGNAL], 0,
1418                                NULL);
1419         }
1420
1421         if (priv->reexpand) {
1422                 expand_root_items (self);
1423                 priv->reexpand = FALSE;
1424         }
1425
1426         return FALSE;
1427 }
1428
1429 GtkWidget*
1430 modest_folder_view_new (TnyFolderStoreQuery *query)
1431 {
1432         GObject *self;
1433         ModestFolderViewPrivate *priv;
1434         GtkTreeSelection *sel;
1435
1436         self = G_OBJECT (g_object_new (MODEST_TYPE_FOLDER_VIEW, NULL));
1437         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (self);
1438
1439         if (query)
1440                 priv->query = g_object_ref (query);
1441
1442         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(self));
1443         priv->changed_signal = g_signal_connect (sel, "changed",
1444                                                  G_CALLBACK (on_selection_changed), self);
1445
1446         g_signal_connect (self, "expose-event", G_CALLBACK (modest_folder_view_on_map), NULL);
1447
1448         return GTK_WIDGET(self);
1449 }
1450
1451 /* this feels dirty; any other way to expand all the root items? */
1452 static void
1453 expand_root_items (ModestFolderView *self)
1454 {
1455         GtkTreePath *path;
1456         GtkTreeModel *model;
1457         GtkTreeIter iter;
1458
1459         model = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
1460         path = gtk_tree_path_new_first ();
1461
1462         /* all folders should have child items, so.. */
1463         do {
1464                 gtk_tree_view_expand_row (GTK_TREE_VIEW(self), path, FALSE);
1465                 gtk_tree_path_next (path);
1466         } while (gtk_tree_model_get_iter (model, &iter, path));
1467
1468         gtk_tree_path_free (path);
1469 }
1470
1471 /*
1472  * We use this function to implement the
1473  * MODEST_FOLDER_VIEW_STYLE_SHOW_ONE style. We only show the default
1474  * account in this case, and the local folders.
1475  */
1476 static gboolean
1477 filter_row (GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
1478 {
1479         ModestFolderViewPrivate *priv;
1480         gboolean retval = TRUE;
1481         TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
1482         GObject *instance = NULL;
1483         const gchar *id = NULL;
1484         guint i;
1485         gboolean found = FALSE;
1486         gboolean cleared = FALSE;
1487
1488         g_return_val_if_fail (MODEST_IS_FOLDER_VIEW (data), FALSE);
1489         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (data);
1490
1491         gtk_tree_model_get (model, iter,
1492                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &type,
1493                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &instance,
1494                             -1);
1495
1496         /* Do not show if there is no instance, this could indeed
1497            happen when the model is being modified while it's being
1498            drawn. This could occur for example when moving folders
1499            using drag&drop */
1500         if (!instance)
1501                 return FALSE;
1502
1503         if (type == TNY_FOLDER_TYPE_ROOT) {
1504                 /* TNY_FOLDER_TYPE_ROOT means that the instance is an
1505                    account instead of a folder. */
1506                 if (TNY_IS_ACCOUNT (instance)) {
1507                         TnyAccount *acc = TNY_ACCOUNT (instance);
1508                         const gchar *account_id = tny_account_get_id (acc);
1509
1510                         /* If it isn't a special folder,
1511                          * don't show it unless it is the visible account: */
1512                         if (priv->style == MODEST_FOLDER_VIEW_STYLE_SHOW_ONE &&
1513                             !modest_tny_account_is_virtual_local_folders (acc) &&
1514                             strcmp (account_id, MODEST_MMC_ACCOUNT_ID)) {
1515
1516                                 /* Show only the visible account id */
1517                                 if (priv->visible_account_id) {
1518                                         if (strcmp (account_id, priv->visible_account_id))
1519                                                 retval = FALSE;
1520                                 } else {
1521                                         retval = FALSE;
1522                                 }
1523                         }
1524
1525                         /* Never show these to the user. They are merged into one folder
1526                          * in the local-folders account instead: */
1527                         if (retval && MODEST_IS_TNY_OUTBOX_ACCOUNT (acc))
1528                                 retval = FALSE;
1529                 }
1530         }
1531
1532         /* Check hiding (if necessary) */
1533         cleared = modest_email_clipboard_cleared (priv->clipboard);
1534         if ((retval) && (!cleared) && (TNY_IS_FOLDER (instance))) {
1535                 id = tny_folder_get_id (TNY_FOLDER(instance));
1536                 if (priv->hidding_ids != NULL)
1537                         for (i=0; i < priv->n_selected && !found; i++)
1538                                 if (priv->hidding_ids[i] != NULL && id != NULL)
1539                                         found = (!strcmp (priv->hidding_ids[i], id));
1540
1541                 retval = !found;
1542         }
1543
1544
1545         /* If this is a move to dialog, hide Sent, Outbox and Drafts
1546         folder as no message can be move there according to UI specs */
1547         if (!priv->show_non_move) {
1548                 switch (type) {
1549                         case TNY_FOLDER_TYPE_OUTBOX:
1550                         case TNY_FOLDER_TYPE_SENT:
1551                         case TNY_FOLDER_TYPE_DRAFTS:
1552                                 retval = FALSE;
1553                                 break;
1554                         case TNY_FOLDER_TYPE_UNKNOWN:
1555                         case TNY_FOLDER_TYPE_NORMAL:
1556                                 type = modest_tny_folder_guess_folder_type(TNY_FOLDER(instance));
1557                                 if (type == TNY_FOLDER_TYPE_INVALID)
1558                                         g_warning ("%s: BUG: TNY_FOLDER_TYPE_INVALID", __FUNCTION__);
1559
1560                                 if (type == TNY_FOLDER_TYPE_OUTBOX ||
1561                                     type == TNY_FOLDER_TYPE_SENT
1562                                     || type == TNY_FOLDER_TYPE_DRAFTS)
1563                                         retval = FALSE;
1564                                 break;
1565                         default:
1566                                 break;
1567                 }
1568         }
1569
1570         /* Free */
1571         g_object_unref (instance);
1572
1573         return retval;
1574 }
1575
1576
1577 gboolean
1578 modest_folder_view_update_model (ModestFolderView *self,
1579                                  TnyAccountStore *account_store)
1580 {
1581         ModestFolderViewPrivate *priv;
1582         GtkTreeModel *model /* , *old_model */;
1583         GtkTreeModel *filter_model = NULL, *sortable = NULL;
1584
1585         g_return_val_if_fail (self && MODEST_IS_FOLDER_VIEW (self), FALSE);
1586         g_return_val_if_fail (account_store && MODEST_IS_TNY_ACCOUNT_STORE(account_store),
1587                               FALSE);
1588
1589         priv =  MODEST_FOLDER_VIEW_GET_PRIVATE(self);
1590
1591         /* Notify that there is no folder selected */
1592         g_signal_emit (G_OBJECT(self),
1593                        signals[FOLDER_SELECTION_CHANGED_SIGNAL], 0,
1594                        NULL, FALSE);
1595         if (priv->cur_folder_store) {
1596                 g_object_unref (priv->cur_folder_store);
1597                 priv->cur_folder_store = NULL;
1598         }
1599
1600         /* FIXME: the local accounts are not shown when the query
1601            selects only the subscribed folders */
1602         model = tny_gtk_folder_store_tree_model_new (NULL);
1603
1604         /* Get the accounts: */
1605         tny_account_store_get_accounts (TNY_ACCOUNT_STORE(account_store),
1606                                         TNY_LIST (model),
1607                                         TNY_ACCOUNT_STORE_STORE_ACCOUNTS);
1608
1609         sortable = gtk_tree_model_sort_new_with_model (model);
1610         gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(sortable),
1611                                               TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN,
1612                                               GTK_SORT_ASCENDING);
1613         gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sortable),
1614                                          TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN,
1615                                          cmp_rows, NULL, NULL);
1616
1617         /* Create filter model */
1618         filter_model = gtk_tree_model_filter_new (sortable, NULL);
1619         gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter_model),
1620                                                 filter_row,
1621                                                 self,
1622                                                 NULL);
1623
1624         /* Set new model */
1625         gtk_tree_view_set_model (GTK_TREE_VIEW(self), filter_model);
1626         g_signal_connect (G_OBJECT(filter_model), "row-inserted",
1627                           (GCallback) on_row_inserted_maybe_select_folder, self);
1628
1629
1630         g_object_unref (model);
1631         g_object_unref (filter_model);
1632         g_object_unref (sortable);
1633
1634         /* Force a reselection of the INBOX next time the widget is shown */
1635         priv->reselect = TRUE;
1636
1637         return TRUE;
1638 }
1639
1640
1641 static void
1642 on_selection_changed (GtkTreeSelection *sel, gpointer user_data)
1643 {
1644         GtkTreeModel *model = NULL;
1645         TnyFolderStore *folder = NULL;
1646         GtkTreeIter iter;
1647         ModestFolderView *tree_view = NULL;
1648         ModestFolderViewPrivate *priv = NULL;
1649         gboolean selected = FALSE;
1650
1651         g_return_if_fail (sel);
1652         g_return_if_fail (user_data);
1653
1654         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(user_data);
1655
1656         selected = gtk_tree_selection_get_selected (sel, &model, &iter);
1657
1658         tree_view = MODEST_FOLDER_VIEW (user_data);
1659
1660         if (selected) {
1661                 gtk_tree_model_get (model, &iter,
1662                                     TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &folder,
1663                                     -1);
1664
1665                 /* If the folder is the same do not notify */
1666                 if (folder && priv->cur_folder_store == folder) {
1667                         g_object_unref (folder);
1668                         return;
1669                 }
1670         }
1671
1672         /* Current folder was unselected */
1673         if (priv->cur_folder_store) {
1674                 g_signal_emit (G_OBJECT(tree_view), signals[FOLDER_SELECTION_CHANGED_SIGNAL], 0,
1675                        priv->cur_folder_store, FALSE);
1676
1677                 if (TNY_IS_FOLDER(priv->cur_folder_store))
1678                         tny_folder_sync_async (TNY_FOLDER(priv->cur_folder_store),
1679                                                FALSE, NULL, NULL, NULL);
1680
1681                 /* FALSE --> don't expunge the messages */
1682
1683                 g_object_unref (priv->cur_folder_store);
1684                 priv->cur_folder_store = NULL;
1685         }
1686
1687         /* New current references */
1688         priv->cur_folder_store = folder;
1689
1690         /* New folder has been selected. Do not notify if there is
1691            nothing new selected */
1692         if (selected) {
1693                 g_signal_emit (G_OBJECT(tree_view),
1694                                signals[FOLDER_SELECTION_CHANGED_SIGNAL],
1695                                0, priv->cur_folder_store, TRUE);
1696         }
1697 }
1698
1699 TnyFolderStore *
1700 modest_folder_view_get_selected (ModestFolderView *self)
1701 {
1702         ModestFolderViewPrivate *priv;
1703
1704         g_return_val_if_fail (self && MODEST_IS_FOLDER_VIEW(self), NULL);
1705
1706         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
1707         if (priv->cur_folder_store)
1708                 g_object_ref (priv->cur_folder_store);
1709
1710         return priv->cur_folder_store;
1711 }
1712
1713 static gint
1714 get_cmp_rows_type_pos (GObject *folder)
1715 {
1716         /* Remote accounts -> Local account -> MMC account .*/
1717         /* 0, 1, 2 */
1718
1719         if (TNY_IS_ACCOUNT (folder) &&
1720                 modest_tny_account_is_virtual_local_folders (
1721                         TNY_ACCOUNT (folder))) {
1722                 return 1;
1723         } else if (TNY_IS_ACCOUNT (folder)) {
1724                 TnyAccount *account = TNY_ACCOUNT (folder);
1725                 const gchar *account_id = tny_account_get_id (account);
1726                 if (!strcmp (account_id, MODEST_MMC_ACCOUNT_ID))
1727                         return 2;
1728                 else
1729                         return 0;
1730         }
1731         else {
1732                 printf ("DEBUG: %s: unexpected type.\n", __FUNCTION__);
1733                 return -1; /* Should never happen */
1734         }
1735 }
1736
1737 static gint
1738 get_cmp_subfolder_type_pos (TnyFolderType t)
1739 {
1740         /* Inbox, Outbox, Drafts, Sent, User */
1741         /* 0, 1, 2, 3, 4 */
1742
1743         switch (t) {
1744         case TNY_FOLDER_TYPE_INBOX:
1745                 return 0;
1746                 break;
1747         case TNY_FOLDER_TYPE_OUTBOX:
1748                 return 1;
1749                 break;
1750         case TNY_FOLDER_TYPE_DRAFTS:
1751                 return 2;
1752                 break;
1753         case TNY_FOLDER_TYPE_SENT:
1754                 return 3;
1755                 break;
1756         default:
1757                 return 4;
1758         }
1759 }
1760
1761 /*
1762  * This function orders the mail accounts according to these rules:
1763  * 1st - remote accounts
1764  * 2nd - local account
1765  * 3rd - MMC account
1766  */
1767 static gint
1768 cmp_rows (GtkTreeModel *tree_model, GtkTreeIter *iter1, GtkTreeIter *iter2,
1769           gpointer user_data)
1770 {
1771         gint cmp = 0;
1772         gchar *name1 = NULL;
1773         gchar *name2 = NULL;
1774         TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
1775         TnyFolderType type2 = TNY_FOLDER_TYPE_UNKNOWN;
1776         GObject *folder1 = NULL;
1777         GObject *folder2 = NULL;
1778
1779         gtk_tree_model_get (tree_model, iter1,
1780                             TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, &name1,
1781                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &type,
1782                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &folder1,
1783                             -1);
1784         gtk_tree_model_get (tree_model, iter2,
1785                             TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, &name2,
1786                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &type2,
1787                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &folder2,
1788                             -1);
1789
1790         /* Return if we get no folder. This could happen when folder
1791            operations are happening. The model is updated after the
1792            folder copy/move actually occurs, so there could be
1793            situations where the model to be drawn is not correct */
1794         if (!folder1 || !folder2)
1795                 goto finish;
1796
1797         if (type == TNY_FOLDER_TYPE_ROOT) {
1798                 /* Compare the types, so that
1799                  * Remote accounts -> Local account -> MMC account .*/
1800                 const gint pos1 = get_cmp_rows_type_pos (folder1);
1801                 const gint pos2 = get_cmp_rows_type_pos (folder2);
1802                 /* printf ("DEBUG: %s:\n  type1=%s, pos1=%d\n  type2=%s, pos2=%d\n",
1803                         __FUNCTION__, G_OBJECT_TYPE_NAME(folder1), pos1, G_OBJECT_TYPE_NAME(folder2), pos2); */
1804                 if (pos1 <  pos2)
1805                         cmp = -1;
1806                 else if (pos1 > pos2)
1807                         cmp = 1;
1808                 else {
1809                         /* Compare items of the same type: */
1810
1811                         TnyAccount *account1 = NULL;
1812                         if (TNY_IS_ACCOUNT (folder1))
1813                                 account1 = TNY_ACCOUNT (folder1);
1814
1815                         TnyAccount *account2 = NULL;
1816                         if (TNY_IS_ACCOUNT (folder2))
1817                                 account2 = TNY_ACCOUNT (folder2);
1818
1819                         const gchar *account_id = account1 ? tny_account_get_id (account1) : NULL;
1820                         const gchar *account_id2 = account2 ? tny_account_get_id (account2) : NULL;
1821
1822                         if (!account_id && !account_id2) {
1823                                 cmp = 0;
1824                         } else if (!account_id) {
1825                                 cmp = -1;
1826                         } else if (!account_id2) {
1827                                 cmp = +1;
1828                         } else if (!strcmp (account_id, MODEST_MMC_ACCOUNT_ID)) {
1829                                 cmp = +1;
1830                         } else {
1831                                 cmp = modest_text_utils_utf8_strcmp (name1, name2, TRUE);
1832                         }
1833                 }
1834         } else {
1835                 gint cmp1 = 0, cmp2 = 0;
1836                 /* get the parent to know if it's a local folder */
1837
1838                 GtkTreeIter parent;
1839                 gboolean has_parent;
1840                 has_parent = gtk_tree_model_iter_parent (tree_model, &parent, iter1);
1841                 if (has_parent) {
1842                         GObject *parent_folder;
1843                         TnyFolderType parent_type = TNY_FOLDER_TYPE_UNKNOWN;
1844                         gtk_tree_model_get (tree_model, &parent,
1845                                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &parent_type,
1846                                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &parent_folder,
1847                                             -1);
1848                         if ((parent_type == TNY_FOLDER_TYPE_ROOT) &&
1849                             TNY_IS_ACCOUNT (parent_folder) &&
1850                             modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
1851                                 cmp1 = get_cmp_subfolder_type_pos (modest_tny_folder_get_local_or_mmc_folder_type
1852                                                                    (TNY_FOLDER (folder1)));
1853                                 cmp2 = get_cmp_subfolder_type_pos (modest_tny_folder_get_local_or_mmc_folder_type
1854                                                                    (TNY_FOLDER (folder2)));
1855                         }
1856                         g_object_unref (parent_folder);
1857                 }
1858
1859                 /* if they are not local folders */
1860                 if (cmp1 == cmp2) {
1861                         cmp1 = get_cmp_subfolder_type_pos (tny_folder_get_folder_type (TNY_FOLDER (folder1)));
1862                         cmp2 = get_cmp_subfolder_type_pos (tny_folder_get_folder_type (TNY_FOLDER (folder2)));
1863                 }
1864
1865                 if (cmp1 == cmp2)
1866                         cmp = modest_text_utils_utf8_strcmp (name1, name2, TRUE);
1867                 else
1868                         cmp = (cmp1 - cmp2);
1869         }
1870
1871 finish:
1872         if (folder1)
1873                 g_object_unref(G_OBJECT(folder1));
1874         if (folder2)
1875                 g_object_unref(G_OBJECT(folder2));
1876
1877         g_free (name1);
1878         g_free (name2);
1879
1880         return cmp;
1881 }
1882
1883 /*****************************************************************************/
1884 /*                        DRAG and DROP stuff                                */
1885 /*****************************************************************************/
1886 /*
1887  * This function fills the #GtkSelectionData with the row and the
1888  * model that has been dragged. It's called when this widget is a
1889  * source for dnd after the event drop happened
1890  */
1891 static void
1892 on_drag_data_get (GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data,
1893                   guint info, guint time, gpointer data)
1894 {
1895         GtkTreeSelection *selection;
1896         GtkTreeModel *model;
1897         GtkTreeIter iter;
1898         GtkTreePath *source_row;
1899
1900         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
1901         if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
1902
1903                 source_row = gtk_tree_model_get_path (model, &iter);
1904                 gtk_tree_set_row_drag_data (selection_data,
1905                                             model,
1906                                             source_row);
1907
1908                 gtk_tree_path_free (source_row);
1909         }
1910 }
1911
1912 typedef struct _DndHelper {
1913         ModestFolderView *folder_view;
1914         gboolean delete_source;
1915         GtkTreePath *source_row;
1916         GdkDragContext *context;
1917         guint time;
1918 } DndHelper;
1919
1920 static void
1921 dnd_helper_destroyer (DndHelper *helper)
1922 {
1923         /* Free the helper */
1924         g_object_unref (helper->folder_view);
1925         gtk_tree_path_free (helper->source_row);
1926         g_slice_free (DndHelper, helper);
1927 }
1928
1929 static void
1930 xfer_cb (ModestMailOperation *mail_op,
1931          gpointer user_data)
1932 {
1933         gboolean success;
1934         DndHelper *helper;
1935
1936         helper = (DndHelper *) user_data;
1937
1938         if (modest_mail_operation_get_status (mail_op) ==
1939             MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
1940                 success = TRUE;
1941         } else {
1942                 success = FALSE;
1943         }
1944
1945         /* Notify the drag source. Never call delete, the monitor will
1946            do the job if needed */
1947         gtk_drag_finish (helper->context, success, FALSE, helper->time);
1948
1949         /* Free the helper */
1950         dnd_helper_destroyer (helper);
1951 }
1952
1953 static void
1954 xfer_msgs_cb (ModestMailOperation *mail_op,
1955               gpointer user_data)
1956 {
1957         /* Common part */
1958         xfer_cb (mail_op, user_data);
1959 }
1960
1961 static void
1962 xfer_folder_cb (ModestMailOperation *mail_op,
1963                 TnyFolder *new_folder,
1964                 gpointer user_data)
1965 {
1966         DndHelper *helper;
1967
1968         helper = (DndHelper *) user_data;
1969
1970         /* Common part */
1971         xfer_cb (mail_op, user_data);
1972
1973         /* Select the folder */
1974         if (new_folder)
1975                 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (helper->folder_view),
1976                                                   new_folder, FALSE);
1977 }
1978
1979
1980 /* get the folder for the row the treepath refers to. */
1981 /* folder must be unref'd */
1982 static TnyFolderStore *
1983 tree_path_to_folder (GtkTreeModel *model, GtkTreePath *path)
1984 {
1985         GtkTreeIter iter;
1986         TnyFolderStore *folder = NULL;
1987
1988         if (gtk_tree_model_get_iter (model,&iter, path))
1989                 gtk_tree_model_get (model, &iter,
1990                                     TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &folder,
1991                                     -1);
1992         return folder;
1993 }
1994
1995 /*
1996  * This function is used by drag_data_received_cb to manage drag and
1997  * drop of a header, i.e, and drag from the header view to the folder
1998  * view.
1999  */
2000 static void
2001 drag_and_drop_from_header_view (GtkTreeModel *source_model,
2002                                 GtkTreeModel *dest_model,
2003                                 GtkTreePath  *dest_row,
2004                                 GtkSelectionData *selection_data,
2005                                 DndHelper    *helper)
2006 {
2007         TnyList *headers = NULL;
2008         TnyFolder *folder = NULL;
2009         TnyFolderType folder_type;
2010         ModestMailOperation *mail_op = NULL;
2011         GtkTreeIter source_iter, dest_iter;
2012         ModestWindowMgr *mgr = NULL;
2013         ModestWindow *main_win = NULL;
2014         gchar **uris, **tmp;
2015         gint response;
2016
2017         /* Build the list of headers */
2018         mgr = modest_runtime_get_window_mgr ();
2019         headers = tny_simple_list_new ();
2020         uris = modest_dnd_selection_data_get_paths (selection_data);
2021         tmp = uris;
2022
2023         while (*tmp != NULL) {
2024                 TnyHeader *header;
2025                 GtkTreePath *path;
2026
2027                 /* Get header */
2028                 path = gtk_tree_path_new_from_string (*tmp);
2029                 gtk_tree_model_get_iter (source_model, &source_iter, path);
2030                 gtk_tree_model_get (source_model, &source_iter,
2031                                     TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
2032                                     &header, -1);
2033
2034                 /* Do not enable d&d of headers already opened */
2035                 if (!modest_window_mgr_find_registered_header(mgr, header, NULL))
2036                         tny_list_append (headers, G_OBJECT (header));
2037
2038                 /* Free and go on */
2039                 gtk_tree_path_free (path);
2040                 g_object_unref (header);
2041                 tmp++;
2042         }
2043         g_strfreev (uris);
2044
2045         /* Get the target folder */
2046         gtk_tree_model_get_iter (dest_model, &dest_iter, dest_row);
2047         gtk_tree_model_get (dest_model, &dest_iter,
2048                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,
2049                             &folder, -1);
2050
2051         if (!folder || !TNY_IS_FOLDER(folder)) {
2052 /*              g_warning ("%s: not a valid target folder (%p)", __FUNCTION__, folder); */
2053                 goto cleanup;
2054         }
2055
2056         folder_type = modest_tny_folder_guess_folder_type (folder);
2057         if (folder_type == TNY_FOLDER_TYPE_INVALID) {
2058 /*              g_warning ("%s: invalid target folder", __FUNCTION__); */
2059                 goto cleanup;  /* cannot move messages there */
2060         }
2061
2062         if (modest_tny_folder_get_rules((TNY_FOLDER(folder))) & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
2063 /*              g_warning ("folder not writable"); */
2064                 goto cleanup; /* verboten! */
2065         }
2066
2067         /* Ask for confirmation to move */
2068         main_win = modest_window_mgr_get_main_window (mgr, FALSE); /* don't create */
2069         if (!main_win) {
2070                 g_warning ("%s: BUG: no main window found", __FUNCTION__);
2071                 goto cleanup;
2072         }
2073
2074         response = modest_ui_actions_msgs_move_to_confirmation (main_win, folder,
2075                                                                 TRUE, headers);
2076         if (response == GTK_RESPONSE_CANCEL)
2077                 goto cleanup;
2078
2079         /* Transfer messages */
2080         mail_op = modest_mail_operation_new_with_error_handling ((GObject *) main_win,
2081                                                                  modest_ui_actions_move_folder_error_handler,
2082                                                                  NULL, NULL);
2083
2084         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2085                                          mail_op);
2086
2087         modest_mail_operation_xfer_msgs (mail_op,
2088                                          headers,
2089                                          folder,
2090                                          helper->delete_source,
2091                                          xfer_msgs_cb, helper);
2092
2093         /* Frees */
2094 cleanup:
2095         if (G_IS_OBJECT(mail_op))
2096                 g_object_unref (G_OBJECT (mail_op));
2097         if (G_IS_OBJECT(folder))
2098                 g_object_unref (G_OBJECT (folder));
2099         if (G_IS_OBJECT(headers))
2100                 g_object_unref (headers);
2101 }
2102
2103 typedef struct {
2104         TnyFolderStore *src_folder;
2105         TnyFolderStore *dst_folder;
2106         ModestFolderView *folder_view;
2107         DndHelper *helper;
2108 } DndFolderInfo;
2109
2110 static void
2111 dnd_folder_info_destroyer (DndFolderInfo *info)
2112 {
2113         if (info->src_folder)
2114                 g_object_unref (info->src_folder);
2115         if (info->dst_folder)
2116                 g_object_unref (info->dst_folder);
2117         if (info->folder_view)
2118                 g_object_unref (info->folder_view);
2119         g_slice_free (DndFolderInfo, info);
2120 }
2121
2122 static void
2123 dnd_on_connection_failed_destroyer (DndFolderInfo *info,
2124                                     GtkWindow *parent_window,
2125                                     TnyAccount *account)
2126 {
2127         time_t dnd_time = info->helper->time;
2128         GdkDragContext *context = info->helper->context;
2129
2130         /* Show error */
2131         modest_ui_actions_on_account_connection_error (parent_window, account);
2132
2133         /* Free the helper & info */
2134         dnd_helper_destroyer (info->helper);
2135         dnd_folder_info_destroyer (info);
2136
2137         /* Notify the drag source. Never call delete, the monitor will
2138            do the job if needed */
2139         gtk_drag_finish (context, FALSE, FALSE, dnd_time);
2140         return;
2141 }
2142
2143 static void
2144 drag_and_drop_from_folder_view_src_folder_performer (gboolean canceled,
2145                                                      GError *err,
2146                                                      GtkWindow *parent_window,
2147                                                      TnyAccount *account,
2148                                                      gpointer user_data)
2149 {
2150         DndFolderInfo *info = NULL;
2151         ModestMailOperation *mail_op;
2152
2153         info = (DndFolderInfo *) user_data;
2154
2155         if (err || canceled) {
2156                 dnd_on_connection_failed_destroyer (info, parent_window, account);
2157                 return;
2158         }
2159
2160         /* Do the mail operation */
2161         mail_op = modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
2162                                                                  modest_ui_actions_move_folder_error_handler,
2163                                                                  info->src_folder, NULL);
2164
2165         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2166                                          mail_op);
2167
2168         /* Transfer the folder */
2169         modest_mail_operation_xfer_folder (mail_op,
2170                                            TNY_FOLDER (info->src_folder),
2171                                            info->dst_folder,
2172                                            info->helper->delete_source,
2173                                            xfer_folder_cb,
2174                                            info->helper);
2175
2176 /*      modest_folder_view_select_folder (MODEST_FOLDER_VIEW(info->folder_view), */
2177 /*                                        TNY_FOLDER (info->dst_folder), TRUE); */
2178
2179         g_object_unref (G_OBJECT (mail_op));
2180 }
2181
2182
2183 static void
2184 drag_and_drop_from_folder_view_dst_folder_performer (gboolean canceled,
2185                                                      GError *err,
2186                                                      GtkWindow *parent_window,
2187                                                      TnyAccount *account,
2188                                                      gpointer user_data)
2189 {
2190         DndFolderInfo *info = NULL;
2191
2192         info = (DndFolderInfo *) user_data;
2193
2194         if (err || canceled) {
2195                 dnd_on_connection_failed_destroyer (info, parent_window, account);
2196                 return;
2197         }
2198
2199         /* Connect to source folder and perform the copy/move */
2200         modest_platform_connect_if_remote_and_perform (NULL, TRUE,
2201                                                        info->src_folder,
2202                                                        drag_and_drop_from_folder_view_src_folder_performer,
2203                                                        info);
2204 }
2205
2206 /*
2207  * This function is used by drag_data_received_cb to manage drag and
2208  * drop of a folder, i.e, and drag from the folder view to the same
2209  * folder view.
2210  */
2211 static void
2212 drag_and_drop_from_folder_view (GtkTreeModel     *source_model,
2213                                 GtkTreeModel     *dest_model,
2214                                 GtkTreePath      *dest_row,
2215                                 GtkSelectionData *selection_data,
2216                                 DndHelper        *helper)
2217 {
2218         GtkTreeIter dest_iter, iter;
2219         TnyFolderStore *dest_folder = NULL;
2220         TnyFolderStore *folder = NULL;
2221         gboolean forbidden = FALSE;
2222         ModestWindow *win;
2223         DndFolderInfo *info = NULL;
2224
2225         win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(), FALSE); /* don't create */
2226         if (!win) {
2227                 g_warning ("%s: BUG: no main window", __FUNCTION__);
2228                 return;
2229         }
2230
2231         if (!forbidden) {
2232                 /* check the folder rules for the destination */
2233                 folder = tree_path_to_folder (dest_model, dest_row);
2234                 if (TNY_IS_FOLDER(folder)) {
2235                         ModestTnyFolderRules rules =
2236                                 modest_tny_folder_get_rules (TNY_FOLDER (folder));
2237                         forbidden = rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE;
2238                 } else if (TNY_IS_FOLDER_STORE(folder)) {
2239                         /* enable local root as destination for folders */
2240                         if (!MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (folder)
2241                                         && TNY_IS_ACCOUNT (folder))
2242                                 forbidden = TRUE;
2243                 }
2244                 g_object_unref (folder);
2245         }
2246         if (!forbidden) {
2247                 /* check the folder rules for the source */
2248                 folder = tree_path_to_folder (source_model, helper->source_row);
2249                 if (TNY_IS_FOLDER(folder)) {
2250                         ModestTnyFolderRules rules =
2251                                 modest_tny_folder_get_rules (TNY_FOLDER (folder));
2252                         forbidden = rules & MODEST_FOLDER_RULES_FOLDER_NON_MOVEABLE;
2253                 } else
2254                         forbidden = TRUE;
2255                 g_object_unref (folder);
2256         }
2257
2258
2259         /* Check if the drag is possible */
2260         if (forbidden || !gtk_tree_path_compare (helper->source_row, dest_row)) {
2261                 gtk_drag_finish (helper->context, FALSE, FALSE, helper->time);
2262                 gtk_tree_path_free (helper->source_row);
2263                 g_slice_free (DndHelper, helper);
2264                 return;
2265         }
2266
2267         /* Get data */
2268         gtk_tree_model_get_iter (dest_model, &dest_iter, dest_row);
2269         gtk_tree_model_get (dest_model, &dest_iter,
2270                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,
2271                             &dest_folder, -1);
2272         gtk_tree_model_get_iter (source_model, &iter, helper->source_row);
2273         gtk_tree_model_get (source_model, &iter,
2274                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,
2275                             &folder, -1);
2276
2277         /* Create the info for the performer */
2278         info = g_slice_new (DndFolderInfo);
2279         info->src_folder = g_object_ref (folder);
2280         info->dst_folder = g_object_ref (dest_folder);
2281         info->folder_view = g_object_ref (helper->folder_view);
2282         info->helper = helper;
2283
2284         /* Connect to the destination folder and perform the copy/move */
2285         modest_platform_connect_if_remote_and_perform (GTK_WINDOW (win), TRUE,
2286                                                        dest_folder,
2287                                                        drag_and_drop_from_folder_view_dst_folder_performer,
2288                                                        info);
2289
2290         /* Frees */
2291         g_object_unref (dest_folder);
2292         g_object_unref (folder);
2293 }
2294
2295 /*
2296  * This function receives the data set by the "drag-data-get" signal
2297  * handler. This information comes within the #GtkSelectionData. This
2298  * function will manage both the drags of folders of the treeview and
2299  * drags of headers of the header view widget.
2300  */
2301 static void
2302 on_drag_data_received (GtkWidget *widget,
2303                        GdkDragContext *context,
2304                        gint x,
2305                        gint y,
2306                        GtkSelectionData *selection_data,
2307                        guint target_type,
2308                        guint time,
2309                        gpointer data)
2310 {
2311         GtkWidget *source_widget;
2312         GtkTreeModel *dest_model, *source_model;
2313         GtkTreePath *source_row, *dest_row;
2314         GtkTreeViewDropPosition pos;
2315         gboolean success = FALSE, delete_source = FALSE;
2316         DndHelper *helper = NULL;
2317
2318         /* Do not allow further process */
2319         g_signal_stop_emission_by_name (widget, "drag-data-received");
2320         source_widget = gtk_drag_get_source_widget (context);
2321
2322         /* Get the action */
2323         if (context->action == GDK_ACTION_MOVE) {
2324                 delete_source = TRUE;
2325
2326                 /* Notify that there is no folder selected. We need to
2327                    do this in order to update the headers view (and
2328                    its monitors, because when moving, the old folder
2329                    won't longer exist. We can not wait for the end of
2330                    the operation, because the operation won't start if
2331                    the folder is in use */
2332                 if (source_widget == widget) {
2333                         GtkTreeSelection *sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
2334                         gtk_tree_selection_unselect_all (sel);
2335                 }
2336         }
2337
2338         /* Check if the get_data failed */
2339         if (selection_data == NULL || selection_data->length < 0)
2340                 gtk_drag_finish (context, success, FALSE, time);
2341
2342         /* Select the destination model */
2343         dest_model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
2344
2345         /* Get the path to the destination row. Can not call
2346            gtk_tree_view_get_drag_dest_row() because the source row
2347            is not selected anymore */
2348         gtk_tree_view_get_dest_row_at_pos (GTK_TREE_VIEW (widget), x, y,
2349                                            &dest_row, &pos);
2350
2351         /* Only allow drops IN other rows */
2352         if (!dest_row ||
2353             pos == GTK_TREE_VIEW_DROP_BEFORE ||
2354             pos == GTK_TREE_VIEW_DROP_AFTER)
2355                 gtk_drag_finish (context, success, FALSE, time);
2356
2357         /* Create the helper */
2358         helper = g_slice_new0 (DndHelper);
2359         helper->delete_source = delete_source;
2360         helper->context = context;
2361         helper->time = time;
2362         helper->folder_view = g_object_ref (widget);
2363
2364         /* Drags from the header view */
2365         if (source_widget != widget) {
2366                 source_model = gtk_tree_view_get_model (GTK_TREE_VIEW (source_widget));
2367
2368                 drag_and_drop_from_header_view (source_model,
2369                                                 dest_model,
2370                                                 dest_row,
2371                                                 selection_data,
2372                                                 helper);
2373         } else {
2374                 /* Get the source model and row */
2375                 gtk_tree_get_row_drag_data (selection_data,
2376                                             &source_model,
2377                                             &source_row);
2378                 helper->source_row = gtk_tree_path_copy (source_row);
2379
2380                 drag_and_drop_from_folder_view (source_model,
2381                                                 dest_model,
2382                                                 dest_row,
2383                                                 selection_data,
2384                                                 helper);
2385
2386                 gtk_tree_path_free (source_row);
2387         }
2388
2389         /* Frees */
2390         gtk_tree_path_free (dest_row);
2391 }
2392
2393 /*
2394  * We define a "drag-drop" signal handler because we do not want to
2395  * use the default one, because the default one always calls
2396  * gtk_drag_finish and we prefer to do it in the "drag-data-received"
2397  * signal handler, because there we have all the information available
2398  * to know if the dnd was a success or not.
2399  */
2400 static gboolean
2401 drag_drop_cb (GtkWidget      *widget,
2402               GdkDragContext *context,
2403               gint            x,
2404               gint            y,
2405               guint           time,
2406               gpointer        user_data)
2407 {
2408         gpointer target;
2409
2410         if (!context->targets)
2411                 return FALSE;
2412
2413         /* Check if we're dragging a folder row */
2414         target = gtk_drag_dest_find_target (widget, context, NULL);
2415
2416         /* Request the data from the source. */
2417         gtk_drag_get_data(widget, context, target, time);
2418
2419     return TRUE;
2420 }
2421
2422 /*
2423  * This function expands a node of a tree view if it's not expanded
2424  * yet. Not sure why it needs the threads stuff, but gtk+`example code
2425  * does that, so that's why they're here.
2426  */
2427 static gint
2428 expand_row_timeout (gpointer data)
2429 {
2430         GtkTreeView *tree_view = data;
2431         GtkTreePath *dest_path = NULL;
2432         GtkTreeViewDropPosition pos;
2433         gboolean result = FALSE;
2434
2435         gdk_threads_enter ();
2436
2437         gtk_tree_view_get_drag_dest_row (tree_view,
2438                                          &dest_path,
2439                                          &pos);
2440
2441         if (dest_path &&
2442             (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
2443              pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)) {
2444                 gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
2445                 gtk_tree_path_free (dest_path);
2446         }
2447         else {
2448                 if (dest_path)
2449                         gtk_tree_path_free (dest_path);
2450
2451                 result = TRUE;
2452         }
2453
2454         gdk_threads_leave ();
2455
2456         return result;
2457 }
2458
2459 /*
2460  * This function is called whenever the pointer is moved over a widget
2461  * while dragging some data. It installs a timeout that will expand a
2462  * node of the treeview if not expanded yet. This function also calls
2463  * gdk_drag_status in order to set the suggested action that will be
2464  * used by the "drag-data-received" signal handler to know if we
2465  * should do a move or just a copy of the data.
2466  */
2467 static gboolean
2468 on_drag_motion (GtkWidget      *widget,
2469                 GdkDragContext *context,
2470                 gint            x,
2471                 gint            y,
2472                 guint           time,
2473                 gpointer        user_data)
2474 {
2475         GtkTreeViewDropPosition pos;
2476         GtkTreePath *dest_row;
2477         GtkTreeModel *dest_model;
2478         ModestFolderViewPrivate *priv;
2479         GdkDragAction suggested_action;
2480         gboolean valid_location = FALSE;
2481         TnyFolderStore *folder = NULL;
2482
2483         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (widget);
2484
2485         if (priv->timer_expander != 0) {
2486                 g_source_remove (priv->timer_expander);
2487                 priv->timer_expander = 0;
2488         }
2489
2490         gtk_tree_view_get_dest_row_at_pos (GTK_TREE_VIEW (widget),
2491                                            x, y,
2492                                            &dest_row,
2493                                            &pos);
2494
2495         /* Do not allow drops between folders */
2496         if (!dest_row ||
2497             pos == GTK_TREE_VIEW_DROP_BEFORE ||
2498             pos == GTK_TREE_VIEW_DROP_AFTER) {
2499                 gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW (widget), NULL, 0);
2500                 gdk_drag_status(context, 0, time);
2501                 valid_location = FALSE;
2502                 goto out;
2503         } else {
2504                 valid_location = TRUE;
2505         }
2506
2507         /* Check that the destination folder is writable */
2508         dest_model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
2509         folder = tree_path_to_folder (dest_model, dest_row);
2510         if (folder && TNY_IS_FOLDER (folder)) {
2511                 ModestTnyFolderRules rules = modest_tny_folder_get_rules(TNY_FOLDER (folder));
2512
2513                 if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
2514                         valid_location = FALSE;
2515                         goto out;
2516                 }
2517         }
2518
2519         /* Expand the selected row after 1/2 second */
2520         if (!gtk_tree_view_row_expanded (GTK_TREE_VIEW (widget), dest_row)) {
2521                 gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget), dest_row, pos);
2522                 priv->timer_expander = g_timeout_add (500, expand_row_timeout, widget);
2523         }
2524
2525         /* Select the desired action. By default we pick MOVE */
2526         suggested_action = GDK_ACTION_MOVE;
2527
2528         if (context->actions == GDK_ACTION_COPY)
2529             gdk_drag_status(context, GDK_ACTION_COPY, time);
2530         else if (context->actions == GDK_ACTION_MOVE)
2531             gdk_drag_status(context, GDK_ACTION_MOVE, time);
2532         else if (context->actions & suggested_action)
2533             gdk_drag_status(context, suggested_action, time);
2534         else
2535             gdk_drag_status(context, GDK_ACTION_DEFAULT, time);
2536
2537  out:
2538         if (folder)
2539                 g_object_unref (folder);
2540         if (dest_row)
2541                 gtk_tree_path_free (dest_row);
2542         g_signal_stop_emission_by_name (widget, "drag-motion");
2543
2544         return valid_location;
2545 }
2546
2547 /*
2548  * This function sets the treeview as a source and a target for dnd
2549  * events. It also connects all the requirede signals.
2550  */
2551 static void
2552 setup_drag_and_drop (GtkTreeView *self)
2553 {
2554         /* Set up the folder view as a dnd destination. Set only the
2555            highlight flag, otherwise gtk will have a different
2556            behaviour */
2557         gtk_drag_dest_set (GTK_WIDGET (self),
2558                            GTK_DEST_DEFAULT_HIGHLIGHT,
2559                            folder_view_drag_types,
2560                            G_N_ELEMENTS (folder_view_drag_types),
2561                            GDK_ACTION_MOVE | GDK_ACTION_COPY);
2562
2563         g_signal_connect (G_OBJECT (self),
2564                           "drag_data_received",
2565                           G_CALLBACK (on_drag_data_received),
2566                           NULL);
2567
2568
2569         /* Set up the treeview as a dnd source */
2570         gtk_drag_source_set (GTK_WIDGET (self),
2571                              GDK_BUTTON1_MASK,
2572                              folder_view_drag_types,
2573                              G_N_ELEMENTS (folder_view_drag_types),
2574                              GDK_ACTION_MOVE | GDK_ACTION_COPY);
2575
2576         g_signal_connect (G_OBJECT (self),
2577                           "drag_motion",
2578                           G_CALLBACK (on_drag_motion),
2579                           NULL);
2580
2581         g_signal_connect (G_OBJECT (self),
2582                           "drag_data_get",
2583                           G_CALLBACK (on_drag_data_get),
2584                           NULL);
2585
2586         g_signal_connect (G_OBJECT (self),
2587                           "drag_drop",
2588                           G_CALLBACK (drag_drop_cb),
2589                           NULL);
2590 }
2591
2592 /*
2593  * This function manages the navigation through the folders using the
2594  * keyboard or the hardware keys in the device
2595  */
2596 static gboolean
2597 on_key_pressed (GtkWidget *self,
2598                 GdkEventKey *event,
2599                 gpointer user_data)
2600 {
2601         GtkTreeSelection *selection;
2602         GtkTreeIter iter;
2603         GtkTreeModel *model;
2604         gboolean retval = FALSE;
2605
2606         /* Up and Down are automatically managed by the treeview */
2607         if (event->keyval == GDK_Return) {
2608                 /* Expand/Collapse the selected row */
2609                 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
2610                 if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
2611                         GtkTreePath *path;
2612
2613                         path = gtk_tree_model_get_path (model, &iter);
2614
2615                         if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (self), path))
2616                                 gtk_tree_view_collapse_row (GTK_TREE_VIEW (self), path);
2617                         else
2618                                 gtk_tree_view_expand_row (GTK_TREE_VIEW (self), path, FALSE);
2619                         gtk_tree_path_free (path);
2620                 }
2621                 /* No further processing */
2622                 retval = TRUE;
2623         }
2624
2625         return retval;
2626 }
2627
2628 /*
2629  * We listen to the changes in the local folder account name key,
2630  * because we want to show the right name in the view. The local
2631  * folder account name corresponds to the device name in the Maemo
2632  * version. We do this because we do not want to query gconf on each
2633  * tree view refresh. It's better to cache it and change whenever
2634  * necessary.
2635  */
2636 static void
2637 on_configuration_key_changed (ModestConf* conf,
2638                               const gchar *key,
2639                               ModestConfEvent event,
2640                               ModestConfNotificationId id,
2641                               ModestFolderView *self)
2642 {
2643         ModestFolderViewPrivate *priv;
2644
2645
2646         g_return_if_fail (MODEST_IS_FOLDER_VIEW (self));
2647         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
2648
2649         if (!strcmp (key, MODEST_CONF_DEVICE_NAME)) {
2650                 g_free (priv->local_account_name);
2651
2652                 if (event == MODEST_CONF_EVENT_KEY_UNSET)
2653                         priv->local_account_name = g_strdup (MODEST_LOCAL_FOLDERS_DEFAULT_DISPLAY_NAME);
2654                 else
2655                         priv->local_account_name = modest_conf_get_string (modest_runtime_get_conf(),
2656                                                                            MODEST_CONF_DEVICE_NAME, NULL);
2657
2658                 /* Force a redraw */
2659 #if GTK_CHECK_VERSION(2, 8, 0)
2660                 GtkTreeViewColumn * tree_column;
2661
2662                 tree_column = gtk_tree_view_get_column (GTK_TREE_VIEW (self),
2663                                                         TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN);
2664                 gtk_tree_view_column_queue_resize (tree_column);
2665 #else
2666                 gtk_widget_queue_draw (GTK_WIDGET (self));
2667 #endif
2668         }
2669 }
2670
2671 void
2672 modest_folder_view_set_style (ModestFolderView *self,
2673                               ModestFolderViewStyle style)
2674 {
2675         ModestFolderViewPrivate *priv;
2676
2677         g_return_if_fail (self && MODEST_IS_FOLDER_VIEW(self));
2678         g_return_if_fail (style == MODEST_FOLDER_VIEW_STYLE_SHOW_ALL ||
2679                           style == MODEST_FOLDER_VIEW_STYLE_SHOW_ONE);
2680
2681         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
2682
2683
2684         priv->style = style;
2685 }
2686
2687 void
2688 modest_folder_view_set_account_id_of_visible_server_account (ModestFolderView *self,
2689                                                              const gchar *account_id)
2690 {
2691         ModestFolderViewPrivate *priv;
2692         GtkTreeModel *model;
2693
2694         g_return_if_fail (self && MODEST_IS_FOLDER_VIEW(self));
2695
2696         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
2697
2698         /* This will be used by the filter_row callback,
2699          * to decided which rows to show: */
2700         if (priv->visible_account_id) {
2701                 g_free (priv->visible_account_id);
2702                 priv->visible_account_id = NULL;
2703         }
2704         if (account_id)
2705                 priv->visible_account_id = g_strdup (account_id);
2706
2707         /* Refilter */
2708         model = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
2709         if (GTK_IS_TREE_MODEL_FILTER (model))
2710                 gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
2711
2712         /* Save settings to gconf */
2713         modest_widget_memory_save (modest_runtime_get_conf (), G_OBJECT(self),
2714                                    MODEST_CONF_FOLDER_VIEW_KEY);
2715 }
2716
2717 const gchar *
2718 modest_folder_view_get_account_id_of_visible_server_account (ModestFolderView *self)
2719 {
2720         ModestFolderViewPrivate *priv;
2721
2722         g_return_val_if_fail (self && MODEST_IS_FOLDER_VIEW(self), NULL);
2723
2724         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
2725
2726         return (const gchar *) priv->visible_account_id;
2727 }
2728
2729 static gboolean
2730 find_inbox_iter (GtkTreeModel *model, GtkTreeIter *iter, GtkTreeIter *inbox_iter)
2731 {
2732         do {
2733                 GtkTreeIter child;
2734                 TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
2735
2736                 gtk_tree_model_get (model, iter,
2737                                     TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN,
2738                                     &type, -1);
2739
2740                 gboolean result = FALSE;
2741                 if (type == TNY_FOLDER_TYPE_INBOX) {
2742                         result = TRUE;
2743                 }
2744                 if (result) {
2745                         *inbox_iter = *iter;
2746                         return TRUE;
2747                 }
2748
2749                 if (gtk_tree_model_iter_children (model, &child, iter)) {
2750                         if (find_inbox_iter (model, &child, inbox_iter))
2751                                 return TRUE;
2752                 }
2753
2754         } while (gtk_tree_model_iter_next (model, iter));
2755
2756         return FALSE;
2757 }
2758
2759
2760
2761
2762 void
2763 modest_folder_view_select_first_inbox_or_local (ModestFolderView *self)
2764 {
2765         GtkTreeModel *model;
2766         GtkTreeIter iter, inbox_iter;
2767         GtkTreeSelection *sel;
2768         GtkTreePath *path = NULL;
2769
2770         g_return_if_fail (self && MODEST_IS_FOLDER_VIEW(self));
2771
2772         model = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
2773         if (!model)
2774                 return;
2775
2776         expand_root_items (self);
2777         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
2778
2779         if (!gtk_tree_model_get_iter_first (model, &iter)) {
2780                 g_warning ("%s: model is empty", __FUNCTION__);
2781                 return;
2782         }
2783
2784         if (find_inbox_iter (model, &iter, &inbox_iter))
2785                 path = gtk_tree_model_get_path (model, &inbox_iter);
2786         else
2787                 path = gtk_tree_path_new_first ();
2788
2789         /* Select the row and free */
2790         gtk_tree_view_set_cursor (GTK_TREE_VIEW (self), path, NULL, FALSE);
2791         gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (self), path, NULL, FALSE, 0.0, 0.0);
2792         gtk_tree_path_free (path);
2793
2794         /* set focus */
2795         gtk_widget_grab_focus (GTK_WIDGET(self));
2796 }
2797
2798
2799 /* recursive */
2800 static gboolean
2801 find_folder_iter (GtkTreeModel *model, GtkTreeIter *iter, GtkTreeIter *folder_iter,
2802                   TnyFolder* folder)
2803 {
2804         do {
2805                 GtkTreeIter child;
2806                 TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
2807                 TnyFolder* a_folder;
2808                 gchar *name = NULL;
2809
2810                 gtk_tree_model_get (model, iter,
2811                                     TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &a_folder,
2812                                     TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, &name,
2813                                     TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &type,
2814                                     -1);
2815                 g_free (name);
2816
2817                 if (folder == a_folder) {
2818                         g_object_unref (a_folder);
2819                         *folder_iter = *iter;
2820                         return TRUE;
2821                 }
2822                 g_object_unref (a_folder);
2823
2824                 if (gtk_tree_model_iter_children (model, &child, iter)) {
2825                         if (find_folder_iter (model, &child, folder_iter, folder))
2826                                 return TRUE;
2827                 }
2828
2829         } while (gtk_tree_model_iter_next (model, iter));
2830
2831         return FALSE;
2832 }
2833
2834
2835 static void
2836 on_row_inserted_maybe_select_folder (GtkTreeModel *tree_model,
2837                                      GtkTreePath *path,
2838                                      GtkTreeIter *iter,
2839                                      ModestFolderView *self)
2840 {
2841         ModestFolderViewPrivate *priv = NULL;
2842         GtkTreeSelection *sel;
2843         TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
2844         GObject *instance = NULL;
2845
2846         if (!MODEST_IS_FOLDER_VIEW(self))
2847                 return;
2848
2849         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (self);
2850
2851         priv->reexpand = TRUE;
2852
2853         gtk_tree_model_get (tree_model, iter,
2854                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &type,
2855                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &instance,
2856                             -1);
2857         if (type == TNY_FOLDER_TYPE_INBOX && priv->folder_to_select == NULL) {
2858                 priv->folder_to_select = g_object_ref (instance);
2859         }
2860         g_object_unref (instance);
2861
2862
2863         if (priv->folder_to_select) {
2864
2865                 if (!modest_folder_view_select_folder (self, priv->folder_to_select,
2866                                                        FALSE)) {
2867                         GtkTreePath *path;
2868                         path = gtk_tree_model_get_path (tree_model, iter);
2869                         gtk_tree_view_expand_to_path (GTK_TREE_VIEW(self), path);
2870
2871                         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
2872
2873                         gtk_tree_selection_select_iter (sel, iter);
2874                         gtk_tree_view_set_cursor (GTK_TREE_VIEW(self), path, NULL, FALSE);
2875
2876                         gtk_tree_path_free (path);
2877
2878                 }
2879
2880                 /* Disable next */
2881                 modest_folder_view_disable_next_folder_selection (self);
2882
2883                 /* Refilter the model */
2884                 gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (tree_model));
2885         }
2886 }
2887
2888
2889 void
2890 modest_folder_view_disable_next_folder_selection (ModestFolderView *self)
2891 {
2892         ModestFolderViewPrivate *priv;
2893
2894         g_return_if_fail (self && MODEST_IS_FOLDER_VIEW(self));
2895
2896         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (self);
2897
2898         if (priv->folder_to_select)
2899                 g_object_unref(priv->folder_to_select);
2900
2901         priv->folder_to_select = NULL;
2902 }
2903
2904 gboolean
2905 modest_folder_view_select_folder (ModestFolderView *self, TnyFolder *folder,
2906                                   gboolean after_change)
2907 {
2908         GtkTreeModel *model;
2909         GtkTreeIter iter, folder_iter;
2910         GtkTreeSelection *sel;
2911         ModestFolderViewPrivate *priv = NULL;
2912
2913         g_return_val_if_fail (self && MODEST_IS_FOLDER_VIEW (self), FALSE);
2914         g_return_val_if_fail (folder && TNY_IS_FOLDER (folder), FALSE);
2915
2916         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (self);
2917
2918         if (after_change) {
2919                 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
2920                 gtk_tree_selection_unselect_all (sel);
2921
2922                 if (priv->folder_to_select)
2923                         g_object_unref(priv->folder_to_select);
2924                 priv->folder_to_select = TNY_FOLDER(g_object_ref(folder));
2925                 return TRUE;
2926         }
2927
2928         model = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
2929         if (!model)
2930                 return FALSE;
2931
2932
2933         /* Refilter the model, before selecting the folder */
2934         gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
2935
2936         if (!gtk_tree_model_get_iter_first (model, &iter)) {
2937                 g_warning ("%s: model is empty", __FUNCTION__);
2938                 return FALSE;
2939         }
2940
2941         if (find_folder_iter (model, &iter, &folder_iter, folder)) {
2942                 GtkTreePath *path;
2943
2944                 path = gtk_tree_model_get_path (model, &folder_iter);
2945                 gtk_tree_view_expand_to_path (GTK_TREE_VIEW(self), path);
2946
2947                 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
2948                 gtk_tree_selection_select_iter (sel, &folder_iter);
2949                 gtk_tree_view_set_cursor (GTK_TREE_VIEW(self), path, NULL, FALSE);
2950
2951                 gtk_tree_path_free (path);
2952                 return TRUE;
2953         }
2954         return FALSE;
2955 }
2956
2957
2958 void
2959 modest_folder_view_copy_selection (ModestFolderView *self)
2960 {
2961         g_return_if_fail (self && MODEST_IS_FOLDER_VIEW(self));
2962
2963         /* Copy selection */
2964         _clipboard_set_selected_data (self, FALSE);
2965 }
2966
2967 void
2968 modest_folder_view_cut_selection (ModestFolderView *folder_view)
2969 {
2970         ModestFolderViewPrivate *priv = NULL;
2971         GtkTreeModel *model = NULL;
2972         const gchar **hidding = NULL;
2973         guint i, n_selected;
2974
2975         g_return_if_fail (folder_view && MODEST_IS_FOLDER_VIEW (folder_view));
2976         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (folder_view);
2977
2978         /* Copy selection */
2979         if (!_clipboard_set_selected_data (folder_view, TRUE))
2980                 return;
2981
2982         /* Get hidding ids */
2983         hidding = modest_email_clipboard_get_hidding_ids (priv->clipboard, &n_selected);
2984
2985         /* Clear hidding array created by previous cut operation */
2986         _clear_hidding_filter (MODEST_FOLDER_VIEW (folder_view));
2987
2988         /* Copy hidding array */
2989         priv->n_selected = n_selected;
2990         priv->hidding_ids = g_malloc0(sizeof(gchar *) * n_selected);
2991         for (i=0; i < n_selected; i++)
2992                 priv->hidding_ids[i] = g_strdup(hidding[i]);
2993
2994         /* Hide cut folders */
2995         model = gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view));
2996         gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
2997 }
2998
2999 void
3000 modest_folder_view_copy_model (ModestFolderView *folder_view_src,
3001                                ModestFolderView *folder_view_dst)
3002 {
3003         GtkTreeModel *filter_model = NULL;
3004         GtkTreeModel *model = NULL;
3005         GtkTreeModel *new_filter_model = NULL;
3006
3007         g_return_if_fail (folder_view_src && MODEST_IS_FOLDER_VIEW (folder_view_src));
3008         g_return_if_fail (folder_view_dst && MODEST_IS_FOLDER_VIEW (folder_view_dst));
3009
3010         /* Get src model*/
3011         filter_model = gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view_src));
3012         model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER(filter_model));
3013
3014         /* Build new filter model */
3015         new_filter_model = gtk_tree_model_filter_new (model, NULL);
3016         gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (new_filter_model),
3017                                                 filter_row,
3018                                                 folder_view_dst,
3019                                                 NULL);
3020         /* Set copied model */
3021         gtk_tree_view_set_model (GTK_TREE_VIEW (folder_view_dst), new_filter_model);
3022         g_signal_connect (G_OBJECT(new_filter_model), "row-inserted",
3023                           (GCallback) on_row_inserted_maybe_select_folder, folder_view_dst);
3024
3025         /* Free */
3026         g_object_unref (new_filter_model);
3027 }
3028
3029 void
3030 modest_folder_view_show_non_move_folders (ModestFolderView *folder_view,
3031                                           gboolean show)
3032 {
3033         GtkTreeModel *model = NULL;
3034         ModestFolderViewPrivate* priv;
3035
3036         g_return_if_fail (folder_view && MODEST_IS_FOLDER_VIEW (folder_view));
3037
3038         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(folder_view);
3039         priv->show_non_move = show;
3040 /*      modest_folder_view_update_model(folder_view, */
3041 /*                                      TNY_ACCOUNT_STORE(modest_runtime_get_account_store())); */
3042
3043         /* Hide special folders */
3044         model = gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view));
3045         if (GTK_IS_TREE_MODEL_FILTER (model)) {
3046                 gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
3047         }
3048 }
3049
3050 /* Returns FALSE if it did not selected anything */
3051 static gboolean
3052 _clipboard_set_selected_data (ModestFolderView *folder_view,
3053                               gboolean delete)
3054 {
3055         ModestFolderViewPrivate *priv = NULL;
3056         TnyFolderStore *folder = NULL;
3057         gboolean retval = FALSE;
3058
3059         g_return_val_if_fail (MODEST_IS_FOLDER_VIEW (folder_view), FALSE);
3060         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (folder_view);
3061
3062         /* Set selected data on clipboard   */
3063         g_return_val_if_fail (MODEST_IS_EMAIL_CLIPBOARD (priv->clipboard), FALSE);
3064         folder = modest_folder_view_get_selected (folder_view);
3065
3066         /* Do not allow to select an account */
3067         if (TNY_IS_FOLDER (folder)) {
3068                 modest_email_clipboard_set_data (priv->clipboard, TNY_FOLDER(folder), NULL, delete);
3069                 retval = TRUE;
3070         }
3071
3072         /* Free */
3073         g_object_unref (folder);
3074
3075         return retval;
3076 }
3077
3078 static void
3079 _clear_hidding_filter (ModestFolderView *folder_view)
3080 {
3081         ModestFolderViewPrivate *priv;
3082         guint i;
3083
3084         g_return_if_fail (MODEST_IS_FOLDER_VIEW (folder_view));
3085         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(folder_view);
3086
3087         if (priv->hidding_ids != NULL) {
3088                 for (i=0; i < priv->n_selected; i++)
3089                         g_free (priv->hidding_ids[i]);
3090                 g_free(priv->hidding_ids);
3091         }
3092 }
3093
3094
3095 static void
3096 on_display_name_changed (ModestAccountMgr *mgr,
3097                          const gchar *account,
3098                          gpointer user_data)
3099 {
3100         ModestFolderView *self;
3101
3102         self = MODEST_FOLDER_VIEW (user_data);
3103
3104         /* Force a redraw */
3105 #if GTK_CHECK_VERSION(2, 8, 0)
3106         GtkTreeViewColumn * tree_column;
3107
3108         tree_column = gtk_tree_view_get_column (GTK_TREE_VIEW (self),
3109                                                 TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN);
3110         gtk_tree_view_column_queue_resize (tree_column);
3111 #else
3112         gtk_widget_queue_draw (GTK_WIDGET (self));
3113 #endif
3114 }