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

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