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, 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         /* Notify the display name observers */
1659         /* TODO: this is redundant, and it's only required because we sometimes lose the focus of the folder
1660            view */
1661         g_signal_emit (G_OBJECT(user_data),
1662                        signals[FOLDER_DISPLAY_NAME_CHANGED_SIGNAL], 0,
1663                        NULL);
1664
1665         tree_view = MODEST_FOLDER_VIEW (user_data);
1666
1667         if (selected) {
1668                 gtk_tree_model_get (model, &iter,
1669                                     TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &folder,
1670                                     -1);
1671
1672                 /* If the folder is the same do not notify */
1673                 if (folder && priv->cur_folder_store == folder) {
1674                         g_object_unref (folder);
1675                         return;
1676                 }
1677         }
1678
1679         /* Current folder was unselected */
1680         if (priv->cur_folder_store) {
1681                 g_signal_emit (G_OBJECT(tree_view), signals[FOLDER_SELECTION_CHANGED_SIGNAL], 0,
1682                        priv->cur_folder_store, FALSE);
1683
1684                 if (TNY_IS_FOLDER(priv->cur_folder_store))
1685                         tny_folder_sync_async (TNY_FOLDER(priv->cur_folder_store),
1686                                                FALSE, NULL, NULL, NULL);
1687
1688                 /* FALSE --> don't expunge the messages */
1689
1690                 g_object_unref (priv->cur_folder_store);
1691                 priv->cur_folder_store = NULL;
1692         }
1693
1694         /* New current references */
1695         priv->cur_folder_store = folder;
1696
1697         /* New folder has been selected. Do not notify if there is
1698            nothing new selected */
1699         if (selected) {
1700                 g_signal_emit (G_OBJECT(tree_view),
1701                                signals[FOLDER_SELECTION_CHANGED_SIGNAL],
1702                                0, priv->cur_folder_store, TRUE);
1703         }
1704 }
1705
1706 TnyFolderStore *
1707 modest_folder_view_get_selected (ModestFolderView *self)
1708 {
1709         ModestFolderViewPrivate *priv;
1710
1711         g_return_val_if_fail (self && MODEST_IS_FOLDER_VIEW(self), NULL);
1712
1713         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
1714         if (priv->cur_folder_store)
1715                 g_object_ref (priv->cur_folder_store);
1716
1717         return priv->cur_folder_store;
1718 }
1719
1720 static gint
1721 get_cmp_rows_type_pos (GObject *folder)
1722 {
1723         /* Remote accounts -> Local account -> MMC account .*/
1724         /* 0, 1, 2 */
1725
1726         if (TNY_IS_ACCOUNT (folder) &&
1727                 modest_tny_account_is_virtual_local_folders (
1728                         TNY_ACCOUNT (folder))) {
1729                 return 1;
1730         } else if (TNY_IS_ACCOUNT (folder)) {
1731                 TnyAccount *account = TNY_ACCOUNT (folder);
1732                 const gchar *account_id = tny_account_get_id (account);
1733                 if (!strcmp (account_id, MODEST_MMC_ACCOUNT_ID))
1734                         return 2;
1735                 else
1736                         return 0;
1737         }
1738         else {
1739                 printf ("DEBUG: %s: unexpected type.\n", __FUNCTION__);
1740                 return -1; /* Should never happen */
1741         }
1742 }
1743
1744 static gint
1745 get_cmp_subfolder_type_pos (TnyFolderType t)
1746 {
1747         /* Inbox, Outbox, Drafts, Sent, User */
1748         /* 0, 1, 2, 3, 4 */
1749
1750         switch (t) {
1751         case TNY_FOLDER_TYPE_INBOX:
1752                 return 0;
1753                 break;
1754         case TNY_FOLDER_TYPE_OUTBOX:
1755                 return 1;
1756                 break;
1757         case TNY_FOLDER_TYPE_DRAFTS:
1758                 return 2;
1759                 break;
1760         case TNY_FOLDER_TYPE_SENT:
1761                 return 3;
1762                 break;
1763         default:
1764                 return 4;
1765         }
1766 }
1767
1768 /*
1769  * This function orders the mail accounts according to these rules:
1770  * 1st - remote accounts
1771  * 2nd - local account
1772  * 3rd - MMC account
1773  */
1774 static gint
1775 cmp_rows (GtkTreeModel *tree_model, GtkTreeIter *iter1, GtkTreeIter *iter2,
1776           gpointer user_data)
1777 {
1778         gint cmp = 0;
1779         gchar *name1 = NULL;
1780         gchar *name2 = NULL;
1781         TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
1782         TnyFolderType type2 = TNY_FOLDER_TYPE_UNKNOWN;
1783         GObject *folder1 = NULL;
1784         GObject *folder2 = NULL;
1785
1786         gtk_tree_model_get (tree_model, iter1,
1787                             TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, &name1,
1788                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &type,
1789                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &folder1,
1790                             -1);
1791         gtk_tree_model_get (tree_model, iter2,
1792                             TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, &name2,
1793                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &type2,
1794                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &folder2,
1795                             -1);
1796
1797         /* Return if we get no folder. This could happen when folder
1798            operations are happening. The model is updated after the
1799            folder copy/move actually occurs, so there could be
1800            situations where the model to be drawn is not correct */
1801         if (!folder1 || !folder2)
1802                 goto finish;
1803
1804         if (type == TNY_FOLDER_TYPE_ROOT) {
1805                 /* Compare the types, so that
1806                  * Remote accounts -> Local account -> MMC account .*/
1807                 const gint pos1 = get_cmp_rows_type_pos (folder1);
1808                 const gint pos2 = get_cmp_rows_type_pos (folder2);
1809                 /* printf ("DEBUG: %s:\n  type1=%s, pos1=%d\n  type2=%s, pos2=%d\n",
1810                         __FUNCTION__, G_OBJECT_TYPE_NAME(folder1), pos1, G_OBJECT_TYPE_NAME(folder2), pos2); */
1811                 if (pos1 <  pos2)
1812                         cmp = -1;
1813                 else if (pos1 > pos2)
1814                         cmp = 1;
1815                 else {
1816                         /* Compare items of the same type: */
1817
1818                         TnyAccount *account1 = NULL;
1819                         if (TNY_IS_ACCOUNT (folder1))
1820                                 account1 = TNY_ACCOUNT (folder1);
1821
1822                         TnyAccount *account2 = NULL;
1823                         if (TNY_IS_ACCOUNT (folder2))
1824                                 account2 = TNY_ACCOUNT (folder2);
1825
1826                         const gchar *account_id = account1 ? tny_account_get_id (account1) : NULL;
1827                         const gchar *account_id2 = account2 ? tny_account_get_id (account2) : NULL;
1828
1829                         if (!account_id && !account_id2) {
1830                                 cmp = 0;
1831                         } else if (!account_id) {
1832                                 cmp = -1;
1833                         } else if (!account_id2) {
1834                                 cmp = +1;
1835                         } else if (!strcmp (account_id, MODEST_MMC_ACCOUNT_ID)) {
1836                                 cmp = +1;
1837                         } else {
1838                                 cmp = modest_text_utils_utf8_strcmp (name1, name2, TRUE);
1839                         }
1840                 }
1841         } else {
1842                 gint cmp1 = 0, cmp2 = 0;
1843                 /* get the parent to know if it's a local folder */
1844
1845                 GtkTreeIter parent;
1846                 gboolean has_parent;
1847                 has_parent = gtk_tree_model_iter_parent (tree_model, &parent, iter1);
1848                 if (has_parent) {
1849                         GObject *parent_folder;
1850                         TnyFolderType parent_type = TNY_FOLDER_TYPE_UNKNOWN;
1851                         gtk_tree_model_get (tree_model, &parent,
1852                                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &parent_type,
1853                                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &parent_folder,
1854                                             -1);
1855                         if ((parent_type == TNY_FOLDER_TYPE_ROOT) &&
1856                             TNY_IS_ACCOUNT (parent_folder) &&
1857                             modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
1858                                 cmp1 = get_cmp_subfolder_type_pos (modest_tny_folder_get_local_or_mmc_folder_type
1859                                                                    (TNY_FOLDER (folder1)));
1860                                 cmp2 = get_cmp_subfolder_type_pos (modest_tny_folder_get_local_or_mmc_folder_type
1861                                                                    (TNY_FOLDER (folder2)));
1862                         }
1863                         g_object_unref (parent_folder);
1864                 }
1865
1866                 /* if they are not local folders */
1867                 if (cmp1 == cmp2) {
1868                         cmp1 = get_cmp_subfolder_type_pos (tny_folder_get_folder_type (TNY_FOLDER (folder1)));
1869                         cmp2 = get_cmp_subfolder_type_pos (tny_folder_get_folder_type (TNY_FOLDER (folder2)));
1870                 }
1871
1872                 if (cmp1 == cmp2)
1873                         cmp = modest_text_utils_utf8_strcmp (name1, name2, TRUE);
1874                 else
1875                         cmp = (cmp1 - cmp2);
1876         }
1877
1878 finish:
1879         if (folder1)
1880                 g_object_unref(G_OBJECT(folder1));
1881         if (folder2)
1882                 g_object_unref(G_OBJECT(folder2));
1883
1884         g_free (name1);
1885         g_free (name2);
1886
1887         return cmp;
1888 }
1889
1890 /*****************************************************************************/
1891 /*                        DRAG and DROP stuff                                */
1892 /*****************************************************************************/
1893 /*
1894  * This function fills the #GtkSelectionData with the row and the
1895  * model that has been dragged. It's called when this widget is a
1896  * source for dnd after the event drop happened
1897  */
1898 static void
1899 on_drag_data_get (GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data,
1900                   guint info, guint time, gpointer data)
1901 {
1902         GtkTreeSelection *selection;
1903         GtkTreeModel *model;
1904         GtkTreeIter iter;
1905         GtkTreePath *source_row;
1906
1907         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
1908         if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
1909
1910                 source_row = gtk_tree_model_get_path (model, &iter);
1911                 gtk_tree_set_row_drag_data (selection_data,
1912                                             model,
1913                                             source_row);
1914
1915                 gtk_tree_path_free (source_row);
1916         }
1917 }
1918
1919 typedef struct _DndHelper {
1920         ModestFolderView *folder_view;
1921         gboolean delete_source;
1922         GtkTreePath *source_row;
1923         GdkDragContext *context;
1924         guint time;
1925 } DndHelper;
1926
1927 static void
1928 dnd_helper_destroyer (DndHelper *helper)
1929 {
1930         /* Free the helper */
1931         g_object_unref (helper->folder_view);
1932         gtk_tree_path_free (helper->source_row);
1933         g_slice_free (DndHelper, helper);
1934 }
1935
1936 static void
1937 xfer_cb (ModestMailOperation *mail_op,
1938          gpointer user_data)
1939 {
1940         gboolean success;
1941         DndHelper *helper;
1942
1943         helper = (DndHelper *) user_data;
1944
1945         if (modest_mail_operation_get_status (mail_op) ==
1946             MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
1947                 success = TRUE;
1948         } else {
1949                 success = FALSE;
1950         }
1951
1952         /* Notify the drag source. Never call delete, the monitor will
1953            do the job if needed */
1954         gtk_drag_finish (helper->context, success, FALSE, helper->time);
1955
1956         /* Free the helper */
1957         dnd_helper_destroyer (helper);
1958 }
1959
1960 static void
1961 xfer_msgs_cb (ModestMailOperation *mail_op,
1962               gpointer user_data)
1963 {
1964         /* Common part */
1965         xfer_cb (mail_op, user_data);
1966 }
1967
1968 static void
1969 xfer_folder_cb (ModestMailOperation *mail_op,
1970                 TnyFolder *new_folder,
1971                 gpointer user_data)
1972 {
1973         DndHelper *helper;
1974
1975         helper = (DndHelper *) user_data;
1976
1977         /* Common part */
1978         xfer_cb (mail_op, user_data);
1979
1980         /* Select the folder */
1981         if (new_folder)
1982                 modest_folder_view_select_folder (MODEST_FOLDER_VIEW (helper->folder_view),
1983                                                   new_folder, FALSE);
1984 }
1985
1986
1987 /* get the folder for the row the treepath refers to. */
1988 /* folder must be unref'd */
1989 static TnyFolderStore *
1990 tree_path_to_folder (GtkTreeModel *model, GtkTreePath *path)
1991 {
1992         GtkTreeIter iter;
1993         TnyFolderStore *folder = NULL;
1994
1995         if (gtk_tree_model_get_iter (model,&iter, path))
1996                 gtk_tree_model_get (model, &iter,
1997                                     TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &folder,
1998                                     -1);
1999         return folder;
2000 }
2001
2002 /*
2003  * This function is used by drag_data_received_cb to manage drag and
2004  * drop of a header, i.e, and drag from the header view to the folder
2005  * view.
2006  */
2007 static void
2008 drag_and_drop_from_header_view (GtkTreeModel *source_model,
2009                                 GtkTreeModel *dest_model,
2010                                 GtkTreePath  *dest_row,
2011                                 GtkSelectionData *selection_data,
2012                                 DndHelper    *helper)
2013 {
2014         TnyList *headers = NULL;
2015         TnyFolder *folder = NULL;
2016         TnyFolderType folder_type;
2017         ModestMailOperation *mail_op = NULL;
2018         GtkTreeIter source_iter, dest_iter;
2019         ModestWindowMgr *mgr = NULL;
2020         ModestWindow *main_win = NULL;
2021         gchar **uris, **tmp;
2022         gint response;
2023
2024         /* Build the list of headers */
2025         mgr = modest_runtime_get_window_mgr ();
2026         headers = tny_simple_list_new ();
2027         uris = modest_dnd_selection_data_get_paths (selection_data);
2028         tmp = uris;
2029
2030         while (*tmp != NULL) {
2031                 TnyHeader *header;
2032                 GtkTreePath *path;
2033
2034                 /* Get header */
2035                 path = gtk_tree_path_new_from_string (*tmp);
2036                 gtk_tree_model_get_iter (source_model, &source_iter, path);
2037                 gtk_tree_model_get (source_model, &source_iter,
2038                                     TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
2039                                     &header, -1);
2040
2041                 /* Do not enable d&d of headers already opened */
2042                 if (!modest_window_mgr_find_registered_header(mgr, header, NULL))
2043                         tny_list_append (headers, G_OBJECT (header));
2044
2045                 /* Free and go on */
2046                 gtk_tree_path_free (path);
2047                 g_object_unref (header);
2048                 tmp++;
2049         }
2050         g_strfreev (uris);
2051
2052         /* Get the target folder */
2053         gtk_tree_model_get_iter (dest_model, &dest_iter, dest_row);
2054         gtk_tree_model_get (dest_model, &dest_iter,
2055                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,
2056                             &folder, -1);
2057
2058         if (!folder || !TNY_IS_FOLDER(folder)) {
2059 /*              g_warning ("%s: not a valid target folder (%p)", __FUNCTION__, folder); */
2060                 goto cleanup;
2061         }
2062
2063         folder_type = modest_tny_folder_guess_folder_type (folder);
2064         if (folder_type == TNY_FOLDER_TYPE_INVALID) {
2065 /*              g_warning ("%s: invalid target folder", __FUNCTION__); */
2066                 goto cleanup;  /* cannot move messages there */
2067         }
2068
2069         if (modest_tny_folder_get_rules((TNY_FOLDER(folder))) & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
2070 /*              g_warning ("folder not writable"); */
2071                 goto cleanup; /* verboten! */
2072         }
2073
2074         /* Ask for confirmation to move */
2075         main_win = modest_window_mgr_get_main_window (mgr, FALSE); /* don't create */
2076         if (!main_win) {
2077                 g_warning ("%s: BUG: no main window found", __FUNCTION__);
2078                 goto cleanup;
2079         }
2080
2081         response = modest_ui_actions_msgs_move_to_confirmation (main_win, folder,
2082                                                                 TRUE, headers);
2083         if (response == GTK_RESPONSE_CANCEL)
2084                 goto cleanup;
2085
2086         /* Transfer messages */
2087         mail_op = modest_mail_operation_new_with_error_handling ((GObject *) main_win,
2088                                                                  modest_ui_actions_move_folder_error_handler,
2089                                                                  NULL, NULL);
2090
2091         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2092                                          mail_op);
2093
2094         modest_mail_operation_xfer_msgs (mail_op,
2095                                          headers,
2096                                          folder,
2097                                          helper->delete_source,
2098                                          xfer_msgs_cb, helper);
2099
2100         /* Frees */
2101 cleanup:
2102         if (G_IS_OBJECT(mail_op))
2103                 g_object_unref (G_OBJECT (mail_op));
2104         if (G_IS_OBJECT(folder))
2105                 g_object_unref (G_OBJECT (folder));
2106         if (G_IS_OBJECT(headers))
2107                 g_object_unref (headers);
2108 }
2109
2110 typedef struct {
2111         TnyFolderStore *src_folder;
2112         TnyFolderStore *dst_folder;
2113         ModestFolderView *folder_view;
2114         DndHelper *helper;
2115 } DndFolderInfo;
2116
2117 static void
2118 dnd_folder_info_destroyer (DndFolderInfo *info)
2119 {
2120         if (info->src_folder)
2121                 g_object_unref (info->src_folder);
2122         if (info->dst_folder)
2123                 g_object_unref (info->dst_folder);
2124         if (info->folder_view)
2125                 g_object_unref (info->folder_view);
2126         g_slice_free (DndFolderInfo, info);
2127 }
2128
2129 static void
2130 dnd_on_connection_failed_destroyer (DndFolderInfo *info,
2131                                     GtkWindow *parent_window,
2132                                     TnyAccount *account)
2133 {
2134         time_t dnd_time = info->helper->time;
2135         GdkDragContext *context = info->helper->context;
2136
2137         /* Show error */
2138         modest_ui_actions_on_account_connection_error (parent_window, account);
2139
2140         /* Free the helper & info */
2141         dnd_helper_destroyer (info->helper);
2142         dnd_folder_info_destroyer (info);
2143
2144         /* Notify the drag source. Never call delete, the monitor will
2145            do the job if needed */
2146         gtk_drag_finish (context, FALSE, FALSE, dnd_time);
2147         return;
2148 }
2149
2150 static void
2151 drag_and_drop_from_folder_view_src_folder_performer (gboolean canceled,
2152                                                      GError *err,
2153                                                      GtkWindow *parent_window,
2154                                                      TnyAccount *account,
2155                                                      gpointer user_data)
2156 {
2157         DndFolderInfo *info = NULL;
2158         ModestMailOperation *mail_op;
2159
2160         info = (DndFolderInfo *) user_data;
2161
2162         if (err || canceled) {
2163                 dnd_on_connection_failed_destroyer (info, parent_window, account);
2164                 return;
2165         }
2166
2167         /* Do the mail operation */
2168         mail_op = modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
2169                                                                  modest_ui_actions_move_folder_error_handler,
2170                                                                  info->src_folder, NULL);
2171
2172         modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
2173                                          mail_op);
2174
2175         /* Transfer the folder */
2176         modest_mail_operation_xfer_folder (mail_op,
2177                                            TNY_FOLDER (info->src_folder),
2178                                            info->dst_folder,
2179                                            info->helper->delete_source,
2180                                            xfer_folder_cb,
2181                                            info->helper);
2182
2183 /*      modest_folder_view_select_folder (MODEST_FOLDER_VIEW(info->folder_view), */
2184 /*                                        TNY_FOLDER (info->dst_folder), TRUE); */
2185
2186         g_object_unref (G_OBJECT (mail_op));
2187 }
2188
2189
2190 static void
2191 drag_and_drop_from_folder_view_dst_folder_performer (gboolean canceled,
2192                                                      GError *err,
2193                                                      GtkWindow *parent_window,
2194                                                      TnyAccount *account,
2195                                                      gpointer user_data)
2196 {
2197         DndFolderInfo *info = NULL;
2198
2199         info = (DndFolderInfo *) user_data;
2200
2201         if (err || canceled) {
2202                 dnd_on_connection_failed_destroyer (info, parent_window, account);
2203                 return;
2204         }
2205
2206         /* Connect to source folder and perform the copy/move */
2207         modest_platform_connect_if_remote_and_perform (NULL, TRUE,
2208                                                        info->src_folder,
2209                                                        drag_and_drop_from_folder_view_src_folder_performer,
2210                                                        info);
2211 }
2212
2213 /*
2214  * This function is used by drag_data_received_cb to manage drag and
2215  * drop of a folder, i.e, and drag from the folder view to the same
2216  * folder view.
2217  */
2218 static void
2219 drag_and_drop_from_folder_view (GtkTreeModel     *source_model,
2220                                 GtkTreeModel     *dest_model,
2221                                 GtkTreePath      *dest_row,
2222                                 GtkSelectionData *selection_data,
2223                                 DndHelper        *helper)
2224 {
2225         GtkTreeIter dest_iter, iter;
2226         TnyFolderStore *dest_folder = NULL;
2227         TnyFolderStore *folder = NULL;
2228         gboolean forbidden = FALSE;
2229         ModestWindow *win;
2230         DndFolderInfo *info = NULL;
2231
2232         win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(), FALSE); /* don't create */
2233         if (!win) {
2234                 g_warning ("%s: BUG: no main window", __FUNCTION__);
2235                 return;
2236         }
2237
2238         if (!forbidden) {
2239                 /* check the folder rules for the destination */
2240                 folder = tree_path_to_folder (dest_model, dest_row);
2241                 if (TNY_IS_FOLDER(folder)) {
2242                         ModestTnyFolderRules rules =
2243                                 modest_tny_folder_get_rules (TNY_FOLDER (folder));
2244                         forbidden = rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE;
2245                 } else if (TNY_IS_FOLDER_STORE(folder)) {
2246                         /* enable local root as destination for folders */
2247                         if (!MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (folder)
2248                                         && TNY_IS_ACCOUNT (folder))
2249                                 forbidden = TRUE;
2250                 }
2251                 g_object_unref (folder);
2252         }
2253         if (!forbidden) {
2254                 /* check the folder rules for the source */
2255                 folder = tree_path_to_folder (source_model, helper->source_row);
2256                 if (TNY_IS_FOLDER(folder)) {
2257                         ModestTnyFolderRules rules =
2258                                 modest_tny_folder_get_rules (TNY_FOLDER (folder));
2259                         forbidden = rules & MODEST_FOLDER_RULES_FOLDER_NON_MOVEABLE;
2260                 } else
2261                         forbidden = TRUE;
2262                 g_object_unref (folder);
2263         }
2264
2265
2266         /* Check if the drag is possible */
2267         if (forbidden || !gtk_tree_path_compare (helper->source_row, dest_row)) {
2268                 gtk_drag_finish (helper->context, FALSE, FALSE, helper->time);
2269                 gtk_tree_path_free (helper->source_row);
2270                 g_slice_free (DndHelper, helper);
2271                 return;
2272         }
2273
2274         /* Get data */
2275         gtk_tree_model_get_iter (dest_model, &dest_iter, dest_row);
2276         gtk_tree_model_get (dest_model, &dest_iter,
2277                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,
2278                             &dest_folder, -1);
2279         gtk_tree_model_get_iter (source_model, &iter, helper->source_row);
2280         gtk_tree_model_get (source_model, &iter,
2281                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,
2282                             &folder, -1);
2283
2284         /* Create the info for the performer */
2285         info = g_slice_new (DndFolderInfo);
2286         info->src_folder = g_object_ref (folder);
2287         info->dst_folder = g_object_ref (dest_folder);
2288         info->folder_view = g_object_ref (helper->folder_view);
2289         info->helper = helper;
2290
2291         /* Connect to the destination folder and perform the copy/move */
2292         modest_platform_connect_if_remote_and_perform (GTK_WINDOW (win), TRUE,
2293                                                        dest_folder,
2294                                                        drag_and_drop_from_folder_view_dst_folder_performer,
2295                                                        info);
2296
2297         /* Frees */
2298         g_object_unref (dest_folder);
2299         g_object_unref (folder);
2300 }
2301
2302 /*
2303  * This function receives the data set by the "drag-data-get" signal
2304  * handler. This information comes within the #GtkSelectionData. This
2305  * function will manage both the drags of folders of the treeview and
2306  * drags of headers of the header view widget.
2307  */
2308 static void
2309 on_drag_data_received (GtkWidget *widget,
2310                        GdkDragContext *context,
2311                        gint x,
2312                        gint y,
2313                        GtkSelectionData *selection_data,
2314                        guint target_type,
2315                        guint time,
2316                        gpointer data)
2317 {
2318         GtkWidget *source_widget;
2319         GtkTreeModel *dest_model, *source_model;
2320         GtkTreePath *source_row, *dest_row;
2321         GtkTreeViewDropPosition pos;
2322         gboolean success = FALSE, delete_source = FALSE;
2323         DndHelper *helper = NULL;
2324
2325         /* Do not allow further process */
2326         g_signal_stop_emission_by_name (widget, "drag-data-received");
2327         source_widget = gtk_drag_get_source_widget (context);
2328
2329         /* Get the action */
2330         if (context->action == GDK_ACTION_MOVE) {
2331                 delete_source = TRUE;
2332
2333                 /* Notify that there is no folder selected. We need to
2334                    do this in order to update the headers view (and
2335                    its monitors, because when moving, the old folder
2336                    won't longer exist. We can not wait for the end of
2337                    the operation, because the operation won't start if
2338                    the folder is in use */
2339                 if (source_widget == widget) {
2340                         GtkTreeSelection *sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
2341                         gtk_tree_selection_unselect_all (sel);
2342                 }
2343         }
2344
2345         /* Check if the get_data failed */
2346         if (selection_data == NULL || selection_data->length < 0)
2347                 gtk_drag_finish (context, success, FALSE, time);
2348
2349         /* Select the destination model */
2350         dest_model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
2351
2352         /* Get the path to the destination row. Can not call
2353            gtk_tree_view_get_drag_dest_row() because the source row
2354            is not selected anymore */
2355         gtk_tree_view_get_dest_row_at_pos (GTK_TREE_VIEW (widget), x, y,
2356                                            &dest_row, &pos);
2357
2358         /* Only allow drops IN other rows */
2359         if (!dest_row ||
2360             pos == GTK_TREE_VIEW_DROP_BEFORE ||
2361             pos == GTK_TREE_VIEW_DROP_AFTER)
2362                 gtk_drag_finish (context, success, FALSE, time);
2363
2364         /* Create the helper */
2365         helper = g_slice_new0 (DndHelper);
2366         helper->delete_source = delete_source;
2367         helper->context = context;
2368         helper->time = time;
2369         helper->folder_view = g_object_ref (widget);
2370
2371         /* Drags from the header view */
2372         if (source_widget != widget) {
2373                 source_model = gtk_tree_view_get_model (GTK_TREE_VIEW (source_widget));
2374
2375                 drag_and_drop_from_header_view (source_model,
2376                                                 dest_model,
2377                                                 dest_row,
2378                                                 selection_data,
2379                                                 helper);
2380         } else {
2381                 /* Get the source model and row */
2382                 gtk_tree_get_row_drag_data (selection_data,
2383                                             &source_model,
2384                                             &source_row);
2385                 helper->source_row = gtk_tree_path_copy (source_row);
2386
2387                 drag_and_drop_from_folder_view (source_model,
2388                                                 dest_model,
2389                                                 dest_row,
2390                                                 selection_data,
2391                                                 helper);
2392
2393                 gtk_tree_path_free (source_row);
2394         }
2395
2396         /* Frees */
2397         gtk_tree_path_free (dest_row);
2398 }
2399
2400 /*
2401  * We define a "drag-drop" signal handler because we do not want to
2402  * use the default one, because the default one always calls
2403  * gtk_drag_finish and we prefer to do it in the "drag-data-received"
2404  * signal handler, because there we have all the information available
2405  * to know if the dnd was a success or not.
2406  */
2407 static gboolean
2408 drag_drop_cb (GtkWidget      *widget,
2409               GdkDragContext *context,
2410               gint            x,
2411               gint            y,
2412               guint           time,
2413               gpointer        user_data)
2414 {
2415         gpointer target;
2416
2417         if (!context->targets)
2418                 return FALSE;
2419
2420         /* Check if we're dragging a folder row */
2421         target = gtk_drag_dest_find_target (widget, context, NULL);
2422
2423         /* Request the data from the source. */
2424         gtk_drag_get_data(widget, context, target, time);
2425
2426     return TRUE;
2427 }
2428
2429 /*
2430  * This function expands a node of a tree view if it's not expanded
2431  * yet. Not sure why it needs the threads stuff, but gtk+`example code
2432  * does that, so that's why they're here.
2433  */
2434 static gint
2435 expand_row_timeout (gpointer data)
2436 {
2437         GtkTreeView *tree_view = data;
2438         GtkTreePath *dest_path = NULL;
2439         GtkTreeViewDropPosition pos;
2440         gboolean result = FALSE;
2441
2442         gdk_threads_enter ();
2443
2444         gtk_tree_view_get_drag_dest_row (tree_view,
2445                                          &dest_path,
2446                                          &pos);
2447
2448         if (dest_path &&
2449             (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
2450              pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)) {
2451                 gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
2452                 gtk_tree_path_free (dest_path);
2453         }
2454         else {
2455                 if (dest_path)
2456                         gtk_tree_path_free (dest_path);
2457
2458                 result = TRUE;
2459         }
2460
2461         gdk_threads_leave ();
2462
2463         return result;
2464 }
2465
2466 /*
2467  * This function is called whenever the pointer is moved over a widget
2468  * while dragging some data. It installs a timeout that will expand a
2469  * node of the treeview if not expanded yet. This function also calls
2470  * gdk_drag_status in order to set the suggested action that will be
2471  * used by the "drag-data-received" signal handler to know if we
2472  * should do a move or just a copy of the data.
2473  */
2474 static gboolean
2475 on_drag_motion (GtkWidget      *widget,
2476                 GdkDragContext *context,
2477                 gint            x,
2478                 gint            y,
2479                 guint           time,
2480                 gpointer        user_data)
2481 {
2482         GtkTreeViewDropPosition pos;
2483         GtkTreePath *dest_row;
2484         GtkTreeModel *dest_model;
2485         ModestFolderViewPrivate *priv;
2486         GdkDragAction suggested_action;
2487         gboolean valid_location = FALSE;
2488         TnyFolderStore *folder = NULL;
2489
2490         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (widget);
2491
2492         if (priv->timer_expander != 0) {
2493                 g_source_remove (priv->timer_expander);
2494                 priv->timer_expander = 0;
2495         }
2496
2497         gtk_tree_view_get_dest_row_at_pos (GTK_TREE_VIEW (widget),
2498                                            x, y,
2499                                            &dest_row,
2500                                            &pos);
2501
2502         /* Do not allow drops between folders */
2503         if (!dest_row ||
2504             pos == GTK_TREE_VIEW_DROP_BEFORE ||
2505             pos == GTK_TREE_VIEW_DROP_AFTER) {
2506                 gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW (widget), NULL, 0);
2507                 gdk_drag_status(context, 0, time);
2508                 valid_location = FALSE;
2509                 goto out;
2510         } else {
2511                 valid_location = TRUE;
2512         }
2513
2514         /* Check that the destination folder is writable */
2515         dest_model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
2516         folder = tree_path_to_folder (dest_model, dest_row);
2517         if (folder && TNY_IS_FOLDER (folder)) {
2518                 ModestTnyFolderRules rules = modest_tny_folder_get_rules(TNY_FOLDER (folder));
2519
2520                 if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
2521                         valid_location = FALSE;
2522                         goto out;
2523                 }
2524         }
2525
2526         /* Expand the selected row after 1/2 second */
2527         if (!gtk_tree_view_row_expanded (GTK_TREE_VIEW (widget), dest_row)) {
2528                 gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget), dest_row, pos);
2529                 priv->timer_expander = g_timeout_add (500, expand_row_timeout, widget);
2530         }
2531
2532         /* Select the desired action. By default we pick MOVE */
2533         suggested_action = GDK_ACTION_MOVE;
2534
2535         if (context->actions == GDK_ACTION_COPY)
2536             gdk_drag_status(context, GDK_ACTION_COPY, time);
2537         else if (context->actions == GDK_ACTION_MOVE)
2538             gdk_drag_status(context, GDK_ACTION_MOVE, time);
2539         else if (context->actions & suggested_action)
2540             gdk_drag_status(context, suggested_action, time);
2541         else
2542             gdk_drag_status(context, GDK_ACTION_DEFAULT, time);
2543
2544  out:
2545         if (folder)
2546                 g_object_unref (folder);
2547         if (dest_row)
2548                 gtk_tree_path_free (dest_row);
2549         g_signal_stop_emission_by_name (widget, "drag-motion");
2550
2551         return valid_location;
2552 }
2553
2554 /*
2555  * This function sets the treeview as a source and a target for dnd
2556  * events. It also connects all the requirede signals.
2557  */
2558 static void
2559 setup_drag_and_drop (GtkTreeView *self)
2560 {
2561         /* Set up the folder view as a dnd destination. Set only the
2562            highlight flag, otherwise gtk will have a different
2563            behaviour */
2564         gtk_drag_dest_set (GTK_WIDGET (self),
2565                            GTK_DEST_DEFAULT_HIGHLIGHT,
2566                            folder_view_drag_types,
2567                            G_N_ELEMENTS (folder_view_drag_types),
2568                            GDK_ACTION_MOVE | GDK_ACTION_COPY);
2569
2570         g_signal_connect (G_OBJECT (self),
2571                           "drag_data_received",
2572                           G_CALLBACK (on_drag_data_received),
2573                           NULL);
2574
2575
2576         /* Set up the treeview as a dnd source */
2577         gtk_drag_source_set (GTK_WIDGET (self),
2578                              GDK_BUTTON1_MASK,
2579                              folder_view_drag_types,
2580                              G_N_ELEMENTS (folder_view_drag_types),
2581                              GDK_ACTION_MOVE | GDK_ACTION_COPY);
2582
2583         g_signal_connect (G_OBJECT (self),
2584                           "drag_motion",
2585                           G_CALLBACK (on_drag_motion),
2586                           NULL);
2587
2588         g_signal_connect (G_OBJECT (self),
2589                           "drag_data_get",
2590                           G_CALLBACK (on_drag_data_get),
2591                           NULL);
2592
2593         g_signal_connect (G_OBJECT (self),
2594                           "drag_drop",
2595                           G_CALLBACK (drag_drop_cb),
2596                           NULL);
2597 }
2598
2599 /*
2600  * This function manages the navigation through the folders using the
2601  * keyboard or the hardware keys in the device
2602  */
2603 static gboolean
2604 on_key_pressed (GtkWidget *self,
2605                 GdkEventKey *event,
2606                 gpointer user_data)
2607 {
2608         GtkTreeSelection *selection;
2609         GtkTreeIter iter;
2610         GtkTreeModel *model;
2611         gboolean retval = FALSE;
2612
2613         /* Up and Down are automatically managed by the treeview */
2614         if (event->keyval == GDK_Return) {
2615                 /* Expand/Collapse the selected row */
2616                 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
2617                 if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
2618                         GtkTreePath *path;
2619
2620                         path = gtk_tree_model_get_path (model, &iter);
2621
2622                         if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (self), path))
2623                                 gtk_tree_view_collapse_row (GTK_TREE_VIEW (self), path);
2624                         else
2625                                 gtk_tree_view_expand_row (GTK_TREE_VIEW (self), path, FALSE);
2626                         gtk_tree_path_free (path);
2627                 }
2628                 /* No further processing */
2629                 retval = TRUE;
2630         }
2631
2632         return retval;
2633 }
2634
2635 /*
2636  * We listen to the changes in the local folder account name key,
2637  * because we want to show the right name in the view. The local
2638  * folder account name corresponds to the device name in the Maemo
2639  * version. We do this because we do not want to query gconf on each
2640  * tree view refresh. It's better to cache it and change whenever
2641  * necessary.
2642  */
2643 static void
2644 on_configuration_key_changed (ModestConf* conf,
2645                               const gchar *key,
2646                               ModestConfEvent event,
2647                               ModestConfNotificationId id,
2648                               ModestFolderView *self)
2649 {
2650         ModestFolderViewPrivate *priv;
2651
2652
2653         g_return_if_fail (MODEST_IS_FOLDER_VIEW (self));
2654         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
2655
2656         if (!strcmp (key, MODEST_CONF_DEVICE_NAME)) {
2657                 g_free (priv->local_account_name);
2658
2659                 if (event == MODEST_CONF_EVENT_KEY_UNSET)
2660                         priv->local_account_name = g_strdup (MODEST_LOCAL_FOLDERS_DEFAULT_DISPLAY_NAME);
2661                 else
2662                         priv->local_account_name = modest_conf_get_string (modest_runtime_get_conf(),
2663                                                                            MODEST_CONF_DEVICE_NAME, NULL);
2664
2665                 /* Force a redraw */
2666 #if GTK_CHECK_VERSION(2, 8, 0)
2667                 GtkTreeViewColumn * tree_column;
2668
2669                 tree_column = gtk_tree_view_get_column (GTK_TREE_VIEW (self),
2670                                                         TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN);
2671                 gtk_tree_view_column_queue_resize (tree_column);
2672 #else
2673                 gtk_widget_queue_draw (GTK_WIDGET (self));
2674 #endif
2675         }
2676 }
2677
2678 void
2679 modest_folder_view_set_style (ModestFolderView *self,
2680                               ModestFolderViewStyle style)
2681 {
2682         ModestFolderViewPrivate *priv;
2683
2684         g_return_if_fail (self && MODEST_IS_FOLDER_VIEW(self));
2685         g_return_if_fail (style == MODEST_FOLDER_VIEW_STYLE_SHOW_ALL ||
2686                           style == MODEST_FOLDER_VIEW_STYLE_SHOW_ONE);
2687
2688         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
2689
2690
2691         priv->style = style;
2692 }
2693
2694 void
2695 modest_folder_view_set_account_id_of_visible_server_account (ModestFolderView *self,
2696                                                              const gchar *account_id)
2697 {
2698         ModestFolderViewPrivate *priv;
2699         GtkTreeModel *model;
2700
2701         g_return_if_fail (self && MODEST_IS_FOLDER_VIEW(self));
2702
2703         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
2704
2705         /* This will be used by the filter_row callback,
2706          * to decided which rows to show: */
2707         if (priv->visible_account_id) {
2708                 g_free (priv->visible_account_id);
2709                 priv->visible_account_id = NULL;
2710         }
2711         if (account_id)
2712                 priv->visible_account_id = g_strdup (account_id);
2713
2714         /* Refilter */
2715         model = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
2716         if (GTK_IS_TREE_MODEL_FILTER (model))
2717                 gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
2718
2719         /* Save settings to gconf */
2720         modest_widget_memory_save (modest_runtime_get_conf (), G_OBJECT(self),
2721                                    MODEST_CONF_FOLDER_VIEW_KEY);
2722 }
2723
2724 const gchar *
2725 modest_folder_view_get_account_id_of_visible_server_account (ModestFolderView *self)
2726 {
2727         ModestFolderViewPrivate *priv;
2728
2729         g_return_val_if_fail (self && MODEST_IS_FOLDER_VIEW(self), NULL);
2730
2731         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
2732
2733         return (const gchar *) priv->visible_account_id;
2734 }
2735
2736 static gboolean
2737 find_inbox_iter (GtkTreeModel *model, GtkTreeIter *iter, GtkTreeIter *inbox_iter)
2738 {
2739         do {
2740                 GtkTreeIter child;
2741                 TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
2742
2743                 gtk_tree_model_get (model, iter,
2744                                     TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN,
2745                                     &type, -1);
2746
2747                 gboolean result = FALSE;
2748                 if (type == TNY_FOLDER_TYPE_INBOX) {
2749                         result = TRUE;
2750                 }
2751                 if (result) {
2752                         *inbox_iter = *iter;
2753                         return TRUE;
2754                 }
2755
2756                 if (gtk_tree_model_iter_children (model, &child, iter)) {
2757                         if (find_inbox_iter (model, &child, inbox_iter))
2758                                 return TRUE;
2759                 }
2760
2761         } while (gtk_tree_model_iter_next (model, iter));
2762
2763         return FALSE;
2764 }
2765
2766
2767
2768
2769 void
2770 modest_folder_view_select_first_inbox_or_local (ModestFolderView *self)
2771 {
2772         GtkTreeModel *model;
2773         GtkTreeIter iter, inbox_iter;
2774         GtkTreeSelection *sel;
2775         GtkTreePath *path = NULL;
2776
2777         g_return_if_fail (self && MODEST_IS_FOLDER_VIEW(self));
2778
2779         model = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
2780         if (!model)
2781                 return;
2782
2783         expand_root_items (self);
2784         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
2785
2786         if (!gtk_tree_model_get_iter_first (model, &iter)) {
2787                 g_warning ("%s: model is empty", __FUNCTION__);
2788                 return;
2789         }
2790
2791         if (find_inbox_iter (model, &iter, &inbox_iter))
2792                 path = gtk_tree_model_get_path (model, &inbox_iter);
2793         else
2794                 path = gtk_tree_path_new_first ();
2795
2796         /* Select the row and free */
2797         gtk_tree_view_set_cursor (GTK_TREE_VIEW (self), path, NULL, FALSE);
2798         gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (self), path, NULL, FALSE, 0.0, 0.0);
2799         gtk_tree_path_free (path);
2800
2801         /* set focus */
2802         gtk_widget_grab_focus (GTK_WIDGET(self));
2803 }
2804
2805
2806 /* recursive */
2807 static gboolean
2808 find_folder_iter (GtkTreeModel *model, GtkTreeIter *iter, GtkTreeIter *folder_iter,
2809                   TnyFolder* folder)
2810 {
2811         do {
2812                 GtkTreeIter child;
2813                 TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
2814                 TnyFolder* a_folder;
2815                 gchar *name = NULL;
2816
2817                 gtk_tree_model_get (model, iter,
2818                                     TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &a_folder,
2819                                     TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, &name,
2820                                     TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &type,
2821                                     -1);
2822                 g_free (name);
2823
2824                 if (folder == a_folder) {
2825                         g_object_unref (a_folder);
2826                         *folder_iter = *iter;
2827                         return TRUE;
2828                 }
2829                 g_object_unref (a_folder);
2830
2831                 if (gtk_tree_model_iter_children (model, &child, iter)) {
2832                         if (find_folder_iter (model, &child, folder_iter, folder))
2833                                 return TRUE;
2834                 }
2835
2836         } while (gtk_tree_model_iter_next (model, iter));
2837
2838         return FALSE;
2839 }
2840
2841
2842 static void
2843 on_row_inserted_maybe_select_folder (GtkTreeModel *tree_model,
2844                                      GtkTreePath *path,
2845                                      GtkTreeIter *iter,
2846                                      ModestFolderView *self)
2847 {
2848         ModestFolderViewPrivate *priv = NULL;
2849         GtkTreeSelection *sel;
2850         TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN;
2851         GObject *instance = NULL;
2852
2853         if (!MODEST_IS_FOLDER_VIEW(self))
2854                 return;
2855
2856         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (self);
2857
2858         priv->reexpand = TRUE;
2859
2860         gtk_tree_model_get (tree_model, iter,
2861                             TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, &type,
2862                             TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, &instance,
2863                             -1);
2864         if (type == TNY_FOLDER_TYPE_INBOX && priv->folder_to_select == NULL) {
2865                 priv->folder_to_select = g_object_ref (instance);
2866         }
2867         g_object_unref (instance);
2868
2869
2870         if (priv->folder_to_select) {
2871
2872                 if (!modest_folder_view_select_folder (self, priv->folder_to_select,
2873                                                        FALSE)) {
2874                         GtkTreePath *path;
2875                         path = gtk_tree_model_get_path (tree_model, iter);
2876                         gtk_tree_view_expand_to_path (GTK_TREE_VIEW(self), path);
2877
2878                         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
2879
2880                         gtk_tree_selection_select_iter (sel, iter);
2881                         gtk_tree_view_set_cursor (GTK_TREE_VIEW(self), path, NULL, FALSE);
2882
2883                         gtk_tree_path_free (path);
2884
2885                 }
2886
2887                 /* Disable next */
2888                 modest_folder_view_disable_next_folder_selection (self);
2889
2890                 /* Refilter the model */
2891                 gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (tree_model));
2892         }
2893 }
2894
2895
2896 void
2897 modest_folder_view_disable_next_folder_selection (ModestFolderView *self)
2898 {
2899         ModestFolderViewPrivate *priv;
2900
2901         g_return_if_fail (self && MODEST_IS_FOLDER_VIEW(self));
2902
2903         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (self);
2904
2905         if (priv->folder_to_select)
2906                 g_object_unref(priv->folder_to_select);
2907
2908         priv->folder_to_select = NULL;
2909 }
2910
2911 gboolean
2912 modest_folder_view_select_folder (ModestFolderView *self, TnyFolder *folder,
2913                                   gboolean after_change)
2914 {
2915         GtkTreeModel *model;
2916         GtkTreeIter iter, folder_iter;
2917         GtkTreeSelection *sel;
2918         ModestFolderViewPrivate *priv = NULL;
2919
2920         g_return_val_if_fail (self && MODEST_IS_FOLDER_VIEW (self), FALSE);
2921         g_return_val_if_fail (folder && TNY_IS_FOLDER (folder), FALSE);
2922
2923         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (self);
2924
2925         if (after_change) {
2926                 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
2927                 gtk_tree_selection_unselect_all (sel);
2928
2929                 if (priv->folder_to_select)
2930                         g_object_unref(priv->folder_to_select);
2931                 priv->folder_to_select = TNY_FOLDER(g_object_ref(folder));
2932                 return TRUE;
2933         }
2934
2935         model = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
2936         if (!model)
2937                 return FALSE;
2938
2939
2940         /* Refilter the model, before selecting the folder */
2941         gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
2942
2943         if (!gtk_tree_model_get_iter_first (model, &iter)) {
2944                 g_warning ("%s: model is empty", __FUNCTION__);
2945                 return FALSE;
2946         }
2947
2948         if (find_folder_iter (model, &iter, &folder_iter, folder)) {
2949                 GtkTreePath *path;
2950
2951                 path = gtk_tree_model_get_path (model, &folder_iter);
2952                 gtk_tree_view_expand_to_path (GTK_TREE_VIEW(self), path);
2953
2954                 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
2955                 gtk_tree_selection_select_iter (sel, &folder_iter);
2956                 gtk_tree_view_set_cursor (GTK_TREE_VIEW(self), path, NULL, FALSE);
2957
2958                 gtk_tree_path_free (path);
2959                 return TRUE;
2960         }
2961         return FALSE;
2962 }
2963
2964
2965 void
2966 modest_folder_view_copy_selection (ModestFolderView *self)
2967 {
2968         g_return_if_fail (self && MODEST_IS_FOLDER_VIEW(self));
2969
2970         /* Copy selection */
2971         _clipboard_set_selected_data (self, FALSE);
2972 }
2973
2974 void
2975 modest_folder_view_cut_selection (ModestFolderView *folder_view)
2976 {
2977         ModestFolderViewPrivate *priv = NULL;
2978         GtkTreeModel *model = NULL;
2979         const gchar **hidding = NULL;
2980         guint i, n_selected;
2981
2982         g_return_if_fail (folder_view && MODEST_IS_FOLDER_VIEW (folder_view));
2983         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (folder_view);
2984
2985         /* Copy selection */
2986         if (!_clipboard_set_selected_data (folder_view, TRUE))
2987                 return;
2988
2989         /* Get hidding ids */
2990         hidding = modest_email_clipboard_get_hidding_ids (priv->clipboard, &n_selected);
2991
2992         /* Clear hidding array created by previous cut operation */
2993         _clear_hidding_filter (MODEST_FOLDER_VIEW (folder_view));
2994
2995         /* Copy hidding array */
2996         priv->n_selected = n_selected;
2997         priv->hidding_ids = g_malloc0(sizeof(gchar *) * n_selected);
2998         for (i=0; i < n_selected; i++)
2999                 priv->hidding_ids[i] = g_strdup(hidding[i]);
3000
3001         /* Hide cut folders */
3002         model = gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view));
3003         gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
3004 }
3005
3006 void
3007 modest_folder_view_copy_model (ModestFolderView *folder_view_src,
3008                                ModestFolderView *folder_view_dst)
3009 {
3010         GtkTreeModel *filter_model = NULL;
3011         GtkTreeModel *model = NULL;
3012         GtkTreeModel *new_filter_model = NULL;
3013
3014         g_return_if_fail (folder_view_src && MODEST_IS_FOLDER_VIEW (folder_view_src));
3015         g_return_if_fail (folder_view_dst && MODEST_IS_FOLDER_VIEW (folder_view_dst));
3016
3017         /* Get src model*/
3018         filter_model = gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view_src));
3019         model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER(filter_model));
3020
3021         /* Build new filter model */
3022         new_filter_model = gtk_tree_model_filter_new (model, NULL);
3023         gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (new_filter_model),
3024                                                 filter_row,
3025                                                 folder_view_dst,
3026                                                 NULL);
3027         /* Set copied model */
3028         gtk_tree_view_set_model (GTK_TREE_VIEW (folder_view_dst), new_filter_model);
3029         g_signal_connect (G_OBJECT(new_filter_model), "row-inserted",
3030                           (GCallback) on_row_inserted_maybe_select_folder, folder_view_dst);
3031
3032         /* Free */
3033         g_object_unref (new_filter_model);
3034 }
3035
3036 void
3037 modest_folder_view_show_non_move_folders (ModestFolderView *folder_view,
3038                                           gboolean show)
3039 {
3040         GtkTreeModel *model = NULL;
3041         ModestFolderViewPrivate* priv;
3042
3043         g_return_if_fail (folder_view && MODEST_IS_FOLDER_VIEW (folder_view));
3044
3045         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(folder_view);
3046         priv->show_non_move = show;
3047 /*      modest_folder_view_update_model(folder_view, */
3048 /*                                      TNY_ACCOUNT_STORE(modest_runtime_get_account_store())); */
3049
3050         /* Hide special folders */
3051         model = gtk_tree_view_get_model (GTK_TREE_VIEW (folder_view));
3052         if (GTK_IS_TREE_MODEL_FILTER (model)) {
3053                 gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
3054         }
3055 }
3056
3057 /* Returns FALSE if it did not selected anything */
3058 static gboolean
3059 _clipboard_set_selected_data (ModestFolderView *folder_view,
3060                               gboolean delete)
3061 {
3062         ModestFolderViewPrivate *priv = NULL;
3063         TnyFolderStore *folder = NULL;
3064         gboolean retval = FALSE;
3065
3066         g_return_val_if_fail (MODEST_IS_FOLDER_VIEW (folder_view), FALSE);
3067         priv = MODEST_FOLDER_VIEW_GET_PRIVATE (folder_view);
3068
3069         /* Set selected data on clipboard   */
3070         g_return_val_if_fail (MODEST_IS_EMAIL_CLIPBOARD (priv->clipboard), FALSE);
3071         folder = modest_folder_view_get_selected (folder_view);
3072
3073         /* Do not allow to select an account */
3074         if (TNY_IS_FOLDER (folder)) {
3075                 modest_email_clipboard_set_data (priv->clipboard, TNY_FOLDER(folder), NULL, delete);
3076                 retval = TRUE;
3077         }
3078
3079         /* Free */
3080         g_object_unref (folder);
3081
3082         return retval;
3083 }
3084
3085 static void
3086 _clear_hidding_filter (ModestFolderView *folder_view)
3087 {
3088         ModestFolderViewPrivate *priv;
3089         guint i;
3090
3091         g_return_if_fail (MODEST_IS_FOLDER_VIEW (folder_view));
3092         priv = MODEST_FOLDER_VIEW_GET_PRIVATE(folder_view);
3093
3094         if (priv->hidding_ids != NULL) {
3095                 for (i=0; i < priv->n_selected; i++)
3096                         g_free (priv->hidding_ids[i]);
3097                 g_free(priv->hidding_ids);
3098         }
3099 }
3100
3101
3102 static void
3103 on_display_name_changed (ModestAccountMgr *mgr,
3104                          const gchar *account,
3105                          gpointer user_data)
3106 {
3107         ModestFolderView *self;
3108
3109         self = MODEST_FOLDER_VIEW (user_data);
3110
3111         /* Force a redraw */
3112 #if GTK_CHECK_VERSION(2, 8, 0)
3113         GtkTreeViewColumn * tree_column;
3114
3115         tree_column = gtk_tree_view_get_column (GTK_TREE_VIEW (self),
3116                                                 TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN);
3117         gtk_tree_view_column_queue_resize (tree_column);
3118 #else
3119         gtk_widget_queue_draw (GTK_WIDGET (self));
3120 #endif
3121 }