git.maemo.org Git - modest/blob - src/widgets/modest-folder-view.c

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