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

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