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