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

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