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