git.maemo.org Git - modest/blob - src/widgets/modest-header-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 <tny-list.h>
  32 #include <tny-simple-list.h>
  33 #include <tny-folder-monitor.h>
  34 #include <string.h>
  35
  36 #include <modest-header-view.h>
  37 #include <modest-header-view-priv.h>
  38 #include <modest-dnd.h>
  39 #include <modest-tny-folder.h>
  40
  41 #include <modest-main-window.h>
  42
  43 #include <modest-marshal.h>
  44 #include <modest-text-utils.h>
  45 #include <modest-icon-names.h>
  46 #include <modest-runtime.h>
  47 #include "modest-platform.h"
  48 #include <modest-hbox-cell-renderer.h>
  49 #include <modest-vbox-cell-renderer.h>
  50
  51 static void modest_header_view_class_init  (ModestHeaderViewClass *klass);
  52 static void modest_header_view_init        (ModestHeaderView *obj);
  53 static void modest_header_view_finalize    (GObject *obj);
  54
  55 static void          on_header_row_activated (GtkTreeView *treeview, GtkTreePath *path,
  56                                               GtkTreeViewColumn *column, gpointer userdata);
  57
  58 static gint          cmp_rows               (GtkTreeModel *tree_model,
  59                                              GtkTreeIter *iter1,
  60                                              GtkTreeIter *iter2,
  61                                              gpointer user_data);
  62
  63 static void          on_selection_changed   (GtkTreeSelection *sel,
  64                                              gpointer user_data);
  65
  66 static void          setup_drag_and_drop    (GtkTreeView *self);
  67
  68 static GtkTreePath * get_selected_row       (GtkTreeView *self, GtkTreeModel **model);
  69
  70 static gboolean      on_focus_in            (GtkWidget     *sef,
  71                                              GdkEventFocus *event,
  72                                              gpointer       user_data);
  73
  74 static void          folder_monitor_update  (TnyFolderObserver *self,
  75                                              TnyFolderChange *change);
  76
  77 static void          tny_folder_observer_init (TnyFolderObserverIface *klass);
  78
  79
  80 typedef struct _ModestHeaderViewPrivate ModestHeaderViewPrivate;
  81 struct _ModestHeaderViewPrivate {
  82         TnyFolder            *folder;
  83         ModestHeaderViewStyle style;
  84
  85         TnyFolderMonitor     *monitor;
  86         GMutex               *observers_lock;
  87
  88         gint                  sort_colid[2][TNY_FOLDER_TYPE_NUM];
  89         gint                  sort_type[2][TNY_FOLDER_TYPE_NUM];
  90
  91
  92 };
  93
  94 typedef struct _HeadersCountChangedHelper HeadersCountChangedHelper;
  95 struct _HeadersCountChangedHelper {
  96         ModestHeaderView *self;
  97         TnyFolderChange  *change;
  98 };
  99
 100
 101 #define MODEST_HEADER_VIEW_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
 102                                                 MODEST_TYPE_HEADER_VIEW, \
 103                                                 ModestHeaderViewPrivate))
 104
 105
 106
 107 #define MODEST_HEADER_VIEW_PTR "modest-header-view"
 108
 109 enum {
 110         HEADER_SELECTED_SIGNAL,
 111         HEADER_ACTIVATED_SIGNAL,
 112         ITEM_NOT_FOUND_SIGNAL,
 113         MSG_COUNT_CHANGED_SIGNAL,
 114         LAST_SIGNAL
 115 };
 116
 117 /* globals */
 118 static GObjectClass *parent_class = NULL;
 119
 120 /* uncomment the following if you have defined any signals */
 121 static guint signals[LAST_SIGNAL] = {0};
 122
 123 GType
 124 modest_header_view_get_type (void)
 125 {
 126         static GType my_type = 0;
 127         if (!my_type) {
 128                 static const GTypeInfo my_info = {
 129                         sizeof(ModestHeaderViewClass),
 130                         NULL,           /* base init */
 131                         NULL,           /* base finalize */
 132                         (GClassInitFunc) modest_header_view_class_init,
 133                         NULL,           /* class finalize */
 134                         NULL,           /* class data */
 135                         sizeof(ModestHeaderView),
 136                         1,              /* n_preallocs */
 137                         (GInstanceInitFunc) modest_header_view_init,
 138                         NULL
 139                 };
 140
 141                 static const GInterfaceInfo tny_folder_observer_info =
 142                 {
 143                         (GInterfaceInitFunc) tny_folder_observer_init, /* interface_init */
 144                         NULL,         /* interface_finalize */
 145                         NULL          /* interface_data */
 146                 };
 147                 my_type = g_type_register_static (GTK_TYPE_TREE_VIEW,
 148                                                   "ModestHeaderView",
 149                                                   &my_info, 0);
 150
 151                 g_type_add_interface_static (my_type, TNY_TYPE_FOLDER_OBSERVER,
 152                                              &tny_folder_observer_info);
 153
 154
 155         }
 156         return my_type;
 157 }
 158
 159 static void
 160 modest_header_view_class_init (ModestHeaderViewClass *klass)
 161 {
 162         GObjectClass *gobject_class;
 163         gobject_class = (GObjectClass*) klass;
 164
 165         parent_class            = g_type_class_peek_parent (klass);
 166         gobject_class->finalize = modest_header_view_finalize;
 167
 168         g_type_class_add_private (gobject_class, sizeof(ModestHeaderViewPrivate));
 169
 170         signals[HEADER_SELECTED_SIGNAL] =
 171                 g_signal_new ("header_selected",
 172                               G_TYPE_FROM_CLASS (gobject_class),
 173                               G_SIGNAL_RUN_FIRST,
 174                               G_STRUCT_OFFSET (ModestHeaderViewClass,header_selected),
 175                               NULL, NULL,
 176                               g_cclosure_marshal_VOID__POINTER,
 177                               G_TYPE_NONE, 1, G_TYPE_POINTER);
 178
 179         signals[HEADER_ACTIVATED_SIGNAL] =
 180                 g_signal_new ("header_activated",
 181                               G_TYPE_FROM_CLASS (gobject_class),
 182                               G_SIGNAL_RUN_FIRST,
 183                               G_STRUCT_OFFSET (ModestHeaderViewClass,header_activated),
 184                               NULL, NULL,
 185                               g_cclosure_marshal_VOID__POINTER,
 186                               G_TYPE_NONE, 1, G_TYPE_POINTER);
 187
 188
 189         signals[ITEM_NOT_FOUND_SIGNAL] =
 190                 g_signal_new ("item_not_found",
 191                               G_TYPE_FROM_CLASS (gobject_class),
 192                               G_SIGNAL_RUN_FIRST,
 193                               G_STRUCT_OFFSET (ModestHeaderViewClass,item_not_found),
 194                               NULL, NULL,
 195                               g_cclosure_marshal_VOID__INT,
 196                               G_TYPE_NONE, 1, G_TYPE_INT);
 197
 198         signals[MSG_COUNT_CHANGED_SIGNAL] =
 199                 g_signal_new ("msg_count_changed",
 200                               G_TYPE_FROM_CLASS (gobject_class),
 201                               G_SIGNAL_RUN_FIRST,
 202                               G_STRUCT_OFFSET (ModestHeaderViewClass, msg_count_changed),
 203                               NULL, NULL,
 204                               modest_marshal_VOID__POINTER_POINTER,
 205                               G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_POINTER);
 206 }
 207
 208 static void
 209 tny_folder_observer_init (TnyFolderObserverIface *klass)
 210 {
 211         klass->update_func = folder_monitor_update;
 212 }
 213
 214 static GtkTreeViewColumn*
 215 get_new_column (const gchar *name, GtkCellRenderer *renderer,
 216                 gboolean resizable, gint sort_col_id, gboolean show_as_text,
 217                 GtkTreeCellDataFunc cell_data_func, gpointer user_data)
 218 {
 219         GtkTreeViewColumn *column;
 220
 221         column =  gtk_tree_view_column_new_with_attributes(name, renderer, NULL);
 222         gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
 223
 224         gtk_tree_view_column_set_resizable (column, resizable);
 225         if (resizable)
 226                 gtk_tree_view_column_set_expand (column, TRUE);
 227
 228         if (show_as_text)
 229                 gtk_tree_view_column_add_attribute (column, renderer, "text",
 230                                                     sort_col_id);
 231         if (sort_col_id >= 0)
 232                 gtk_tree_view_column_set_sort_column_id (column, sort_col_id);
 233
 234         gtk_tree_view_column_set_sort_indicator (column, FALSE);
 235         gtk_tree_view_column_set_reorderable (column, TRUE);
 236
 237         if (cell_data_func)
 238                 gtk_tree_view_column_set_cell_data_func(column, renderer, cell_data_func,
 239                                                         user_data, NULL);
 240         return column;
 241 }
 242
 243
 244 static void
 245 remove_all_columns (ModestHeaderView *obj)
 246 {
 247         GList *columns, *cursor;
 248
 249         columns = gtk_tree_view_get_columns (GTK_TREE_VIEW(obj));
 250
 251         for (cursor = columns; cursor; cursor = cursor->next)
 252                 gtk_tree_view_remove_column (GTK_TREE_VIEW(obj),
 253                                              GTK_TREE_VIEW_COLUMN(cursor->data));
 254         g_list_free (columns);
 255 }
 256
 257 gboolean
 258 modest_header_view_set_columns (ModestHeaderView *self, const GList *columns, TnyFolderType type)
 259 {
 260         GtkTreeModel *sortable;
 261         GtkTreeViewColumn *column=NULL;
 262         GtkTreeSelection *selection = NULL;
 263         GtkCellRenderer *renderer_msgtype,*renderer_header,
 264                 *renderer_attach, *renderer_compact_date;
 265         GtkCellRenderer *renderer_compact_header, *renderer_recpt_box,
 266                 *renderer_subject, *renderer_subject_box, *renderer_recpt,
 267                 *renderer_priority;
 268         ModestHeaderViewPrivate *priv;
 269         GtkTreeViewColumn *compact_column = NULL;
 270         const GList *cursor;
 271
 272         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 273
 274         /* FIXME: check whether these renderers need to be freed */
 275         renderer_msgtype = gtk_cell_renderer_pixbuf_new ();
 276         renderer_attach  = gtk_cell_renderer_pixbuf_new ();
 277         renderer_priority  = gtk_cell_renderer_pixbuf_new ();
 278         renderer_header  = gtk_cell_renderer_text_new ();
 279
 280         renderer_compact_header = modest_vbox_cell_renderer_new ();
 281         renderer_recpt_box = modest_hbox_cell_renderer_new ();
 282         renderer_subject_box = modest_hbox_cell_renderer_new ();
 283         renderer_recpt = gtk_cell_renderer_text_new ();
 284         renderer_subject = gtk_cell_renderer_text_new ();
 285         renderer_compact_date  = gtk_cell_renderer_text_new ();
 286
 287         modest_vbox_cell_renderer_append (MODEST_VBOX_CELL_RENDERER (renderer_compact_header), renderer_subject_box, FALSE);
 288         g_object_set_data (G_OBJECT (renderer_compact_header), "subject-box-renderer", renderer_subject_box);
 289         modest_vbox_cell_renderer_append (MODEST_VBOX_CELL_RENDERER (renderer_compact_header), renderer_recpt_box, FALSE);
 290         g_object_set_data (G_OBJECT (renderer_compact_header), "recpt-box-renderer", renderer_recpt_box);
 291         modest_hbox_cell_renderer_append (MODEST_HBOX_CELL_RENDERER (renderer_subject_box), renderer_priority, FALSE);
 292         g_object_set_data (G_OBJECT (renderer_subject_box), "priority-renderer", renderer_priority);
 293         modest_hbox_cell_renderer_append (MODEST_HBOX_CELL_RENDERER (renderer_subject_box), renderer_subject, TRUE);
 294         g_object_set_data (G_OBJECT (renderer_subject_box), "subject-renderer", renderer_subject);
 295         modest_hbox_cell_renderer_append (MODEST_HBOX_CELL_RENDERER (renderer_recpt_box), renderer_attach, FALSE);
 296         g_object_set_data (G_OBJECT (renderer_recpt_box), "attach-renderer", renderer_attach);
 297         modest_hbox_cell_renderer_append (MODEST_HBOX_CELL_RENDERER (renderer_recpt_box), renderer_recpt, TRUE);
 298         g_object_set_data (G_OBJECT (renderer_recpt_box), "recipient-renderer", renderer_recpt);
 299         modest_hbox_cell_renderer_append (MODEST_HBOX_CELL_RENDERER (renderer_recpt_box), renderer_compact_date, FALSE);
 300         g_object_set_data (G_OBJECT (renderer_recpt_box), "date-renderer", renderer_compact_date);
 301
 302         g_object_set(G_OBJECT(renderer_header),
 303                      "ellipsize", PANGO_ELLIPSIZE_END,
 304                      NULL);
 305         g_object_set (G_OBJECT (renderer_subject),
 306                       "ellipsize", PANGO_ELLIPSIZE_END,
 307                       NULL);
 308         g_object_set (G_OBJECT (renderer_recpt),
 309                       "ellipsize", PANGO_ELLIPSIZE_END,
 310                       NULL);
 311         g_object_set(G_OBJECT(renderer_compact_date),
 312                      "xalign", 1.0,
 313                      NULL);
 314
 315         gtk_cell_renderer_set_fixed_size (renderer_attach, 32, 32);
 316         gtk_cell_renderer_set_fixed_size (renderer_priority, 32, 32);
 317
 318         remove_all_columns (self);
 319
 320         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self));
 321         gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
 322         sortable = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
 323
 324         /* Add new columns */
 325         for (cursor = columns; cursor; cursor = g_list_next(cursor)) {
 326                 ModestHeaderViewColumn col =
 327                         (ModestHeaderViewColumn) GPOINTER_TO_INT(cursor->data);
 328
 329                 if (0> col || col >= MODEST_HEADER_VIEW_COLUMN_NUM) {
 330                         g_printerr ("modest: invalid column %d in column list\n", col);
 331                         continue;
 332                 }
 333
 334                 switch (col) {
 335
 336                 case MODEST_HEADER_VIEW_COLUMN_MSGTYPE:
 337                         column = get_new_column (_("M"), renderer_msgtype, FALSE,
 338                                                  TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 339                                                  FALSE,
 340                                                  (GtkTreeCellDataFunc)_modest_header_view_msgtype_cell_data,
 341                                                  NULL);
 342                         gtk_tree_view_column_set_fixed_width (column, 45);
 343                         break;
 344
 345                 case MODEST_HEADER_VIEW_COLUMN_ATTACH:
 346                         column = get_new_column (_("A"), renderer_attach, FALSE,
 347                                                  TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 348                                                  FALSE,
 349                                                  (GtkTreeCellDataFunc)_modest_header_view_attach_cell_data,
 350                                                  NULL);
 351                         gtk_tree_view_column_set_fixed_width (column, 45);
 352                         break;
 353
 354
 355                 case MODEST_HEADER_VIEW_COLUMN_FROM:
 356                         column = get_new_column (_("From"), renderer_header, TRUE,
 357                                                  TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN,
 358                                                  TRUE,
 359                                                  (GtkTreeCellDataFunc)_modest_header_view_sender_receiver_cell_data,
 360                                                  GINT_TO_POINTER(TRUE));
 361                         break;
 362
 363                 case MODEST_HEADER_VIEW_COLUMN_TO:
 364                         column = get_new_column (_("To"), renderer_header, TRUE,
 365                                                  TNY_GTK_HEADER_LIST_MODEL_TO_COLUMN,
 366                                                  TRUE,
 367                                                  (GtkTreeCellDataFunc)_modest_header_view_sender_receiver_cell_data,
 368                                                  GINT_TO_POINTER(FALSE));
 369                         break;
 370
 371                 case MODEST_HEADER_VIEW_COLUMN_COMPACT_HEADER_IN:
 372                         column = get_new_column (_("Header"), renderer_compact_header, TRUE,
 373                                                      TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN,
 374                                                      FALSE,
 375                                                      (GtkTreeCellDataFunc)_modest_header_view_compact_header_cell_data,
 376                                                      GINT_TO_POINTER(TRUE));
 377                         compact_column = column;
 378                         break;
 379
 380                 case MODEST_HEADER_VIEW_COLUMN_COMPACT_HEADER_OUT:
 381                         column = get_new_column (_("Header"), renderer_compact_header, TRUE,
 382                                                      TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN,
 383                                                      FALSE,
 384                                                      (GtkTreeCellDataFunc)_modest_header_view_compact_header_cell_data,
 385                                                      GINT_TO_POINTER(FALSE));
 386                         compact_column = column;
 387                         break;
 388
 389
 390                 case MODEST_HEADER_VIEW_COLUMN_SUBJECT:
 391                         column = get_new_column (_("Subject"), renderer_header, TRUE,
 392                                                  TNY_GTK_HEADER_LIST_MODEL_SUBJECT_COLUMN,
 393                                                  TRUE,
 394                                                  (GtkTreeCellDataFunc)_modest_header_view_header_cell_data,
 395                                                  NULL);
 396                         break;
 397
 398                 case MODEST_HEADER_VIEW_COLUMN_RECEIVED_DATE:
 399                         column = get_new_column (_("Received"), renderer_header, TRUE,
 400                                                  TNY_GTK_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN,
 401                                                  TRUE,
 402                                                  (GtkTreeCellDataFunc)_modest_header_view_date_cell_data,
 403                                                  GINT_TO_POINTER(TRUE));
 404                         break;
 405
 406                 case MODEST_HEADER_VIEW_COLUMN_SENT_DATE:
 407                         column = get_new_column (_("Sent"), renderer_header, TRUE,
 408                                                  TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN,
 409                                                  TRUE,
 410                                                  (GtkTreeCellDataFunc)_modest_header_view_date_cell_data,
 411                                                  GINT_TO_POINTER(FALSE));
 412                         break;
 413
 414                 case MODEST_HEADER_VIEW_COLUMN_SIZE:
 415                         column = get_new_column (_("Size"), renderer_header, TRUE,
 416                                                  TNY_GTK_HEADER_LIST_MODEL_MESSAGE_SIZE_COLUMN,
 417                                                  FALSE,
 418                                                  (GtkTreeCellDataFunc)_modest_header_view_size_cell_data,
 419                                                  NULL);
 420                         break;
 421                 case MODEST_HEADER_VIEW_COLUMN_STATUS:
 422                         column = get_new_column (_("Status"), renderer_compact_date, TRUE,
 423                                                  TNY_GTK_HEADER_LIST_MODEL_MESSAGE_SIZE_COLUMN,
 424                                                  FALSE,
 425                                                  (GtkTreeCellDataFunc)_modest_header_view_status_cell_data,
 426                                                  NULL);
 427                         break;
 428
 429                 default:
 430                         g_return_val_if_reached(FALSE);
 431                 }
 432
 433                 /* we keep the column id around */
 434                 g_object_set_data (G_OBJECT(column), MODEST_HEADER_VIEW_COLUMN,
 435                                    GINT_TO_POINTER(col));
 436
 437                 /* we need this ptr when sorting the rows */
 438                 g_object_set_data (G_OBJECT(column), MODEST_HEADER_VIEW_PTR,
 439                                    self);
 440                 gtk_tree_view_append_column (GTK_TREE_VIEW(self), column);
 441         }
 442
 443         if (sortable) {
 444                 gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE(sortable),
 445                                                  TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 446                                                  (GtkTreeIterCompareFunc) cmp_rows,
 447                                                  compact_column, NULL);
 448         }
 449
 450
 451         return TRUE;
 452 }
 453
 454 static void
 455 modest_header_view_init (ModestHeaderView *obj)
 456 {
 457         ModestHeaderViewPrivate *priv;
 458         guint i, j;
 459
 460         priv = MODEST_HEADER_VIEW_GET_PRIVATE(obj);
 461
 462         priv->folder  = NULL;
 463
 464         priv->monitor        = NULL;
 465         priv->observers_lock = g_mutex_new ();
 466
 467         /* Sort parameters */
 468         for (j=0; j < 2; j++) {
 469                 for (i=0; i < TNY_FOLDER_TYPE_NUM; i++) {
 470                         priv->sort_colid[j][i] = -1;
 471                         priv->sort_type[j][i] = GTK_SORT_DESCENDING;
 472                 }
 473         }
 474
 475         setup_drag_and_drop (GTK_TREE_VIEW (obj));
 476 }
 477
 478 static void
 479 modest_header_view_finalize (GObject *obj)
 480 {
 481         ModestHeaderView        *self;
 482         ModestHeaderViewPrivate *priv;
 483
 484         self = MODEST_HEADER_VIEW(obj);
 485         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 486
 487         g_mutex_lock (priv->observers_lock);
 488         if (priv->monitor) {
 489                 tny_folder_monitor_stop (priv->monitor);
 490                 g_object_unref (G_OBJECT (priv->monitor));
 491         }
 492         g_mutex_unlock (priv->observers_lock);
 493         g_mutex_free (priv->observers_lock);
 494
 495         if (priv->folder) {
 496                 tny_folder_remove_observer (priv->folder, TNY_FOLDER_OBSERVER (obj));
 497                 g_object_unref (G_OBJECT (priv->folder));
 498                 priv->folder   = NULL;
 499         }
 500
 501         G_OBJECT_CLASS(parent_class)->finalize (obj);
 502 }
 503
 504
 505 GtkWidget*
 506 modest_header_view_new (TnyFolder *folder, ModestHeaderViewStyle style)
 507 {
 508         GObject *obj;
 509         GtkTreeSelection *sel;
 510         ModestHeaderView *self;
 511         ModestHeaderViewPrivate *priv;
 512
 513         g_return_val_if_fail (style >= 0 && style < MODEST_HEADER_VIEW_STYLE_NUM,
 514                               NULL);
 515
 516         obj  = G_OBJECT(g_object_new(MODEST_TYPE_HEADER_VIEW, NULL));
 517         self = MODEST_HEADER_VIEW(obj);
 518         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 519
 520         modest_header_view_set_style   (self, style);
 521         modest_header_view_set_folder (self, NULL, NULL, NULL);
 522
 523         gtk_tree_view_columns_autosize (GTK_TREE_VIEW(obj));
 524         gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW(obj),TRUE);
 525         gtk_tree_view_set_enable_search (GTK_TREE_VIEW(obj), TRUE);
 526
 527         gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(obj),
 528                                       TRUE); /* alternating row colors */
 529         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(self));
 530
 531         g_signal_connect (sel, "changed",
 532                           G_CALLBACK(on_selection_changed), self);
 533
 534         g_signal_connect (self, "row-activated",
 535                           G_CALLBACK (on_header_row_activated), NULL);
 536
 537         g_signal_connect (self, "focus-in-event",
 538                           G_CALLBACK(on_focus_in), NULL);
 539
 540         return GTK_WIDGET(self);
 541 }
 542
 543
 544 TnyList *
 545 modest_header_view_get_selected_headers (ModestHeaderView *self)
 546 {
 547         GtkTreeSelection *sel;
 548         ModestHeaderViewPrivate *priv;
 549         TnyList *header_list = NULL;
 550         TnyHeader *header;
 551         GList *list, *tmp = NULL;
 552         GtkTreeModel *tree_model = NULL;
 553         GtkTreeIter iter;
 554
 555         g_return_val_if_fail (self, NULL);
 556
 557         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 558
 559         /* Get selected rows */
 560         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(self));
 561         list = gtk_tree_selection_get_selected_rows (sel, &tree_model);
 562
 563         if (list) {
 564                 header_list = tny_simple_list_new();
 565
 566                 list = g_list_reverse (list);
 567                 tmp = list;
 568                 while (tmp) {
 569                         /* get header from selection */
 570                         gtk_tree_model_get_iter (tree_model, &iter, (GtkTreePath *) (tmp->data));
 571                         gtk_tree_model_get (tree_model, &iter,
 572                                             TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
 573                                             &header, -1);
 574                         /* Prepend to list */
 575                         tny_list_prepend (header_list, G_OBJECT (header));
 576                         g_object_unref (G_OBJECT (header));
 577
 578                         tmp = g_list_next (tmp);
 579                 }
 580                 /* Clean up*/
 581                 g_list_foreach (list, (GFunc) gtk_tree_path_free, NULL);
 582                 g_list_free (list);
 583         }
 584         return header_list;
 585 }
 586
 587
 588 /* scroll our list view so the selected item is visible */
 589 static void
 590 scroll_to_selected (ModestHeaderView *self, GtkTreeIter *iter, gboolean up)
 591 {
 592 #ifdef MODEST_PLATFORM_GNOME
 593
 594         GtkTreePath *selected_path;
 595         GtkTreePath *start, *end;
 596
 597         GtkTreeModel *model;
 598
 599         model         = gtk_tree_view_get_model (GTK_TREE_VIEW(self));
 600         selected_path = gtk_tree_model_get_path (model, iter);
 601
 602         start = gtk_tree_path_new ();
 603         end   = gtk_tree_path_new ();
 604
 605         gtk_tree_view_get_visible_range (GTK_TREE_VIEW(self), &start, &end);
 606
 607         if (gtk_tree_path_compare (selected_path, start) < 0 ||
 608             gtk_tree_path_compare (end, selected_path) < 0)
 609                 gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW(self),
 610                                               selected_path, NULL, TRUE,
 611                                               up ? 0.0 : 1.0,
 612                                               up ? 0.0 : 1.0);
 613         gtk_tree_path_free (selected_path);
 614         gtk_tree_path_free (start);
 615         gtk_tree_path_free (end);
 616
 617 #endif /* MODEST_PLATFORM_GNOME */
 618 }
 619
 620
 621 void
 622 modest_header_view_select_next (ModestHeaderView *self)
 623 {
 624         GtkTreeSelection *sel;
 625         GtkTreeIter iter;
 626         GtkTreeModel *model;
 627         GtkTreePath *path;
 628
 629         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
 630         path = get_selected_row (GTK_TREE_VIEW(self), &model);
 631         if ((path != NULL) && (gtk_tree_model_get_iter(model, &iter, path))) {
 632                 /* Unselect previous path */
 633                 gtk_tree_selection_unselect_path (sel, path);
 634
 635                 /* Move path down and selects new one  */
 636                 if (gtk_tree_model_iter_next (model, &iter)) {
 637                         gtk_tree_selection_select_iter (sel, &iter);
 638                         scroll_to_selected (self, &iter, FALSE);
 639                 }
 640                 gtk_tree_path_free(path);
 641         }
 642
 643 }
 644
 645 void
 646 modest_header_view_select_prev (ModestHeaderView *self)
 647 {
 648         GtkTreeSelection *sel;
 649         GtkTreeIter iter;
 650         GtkTreeModel *model;
 651         GtkTreePath *path;
 652
 653         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
 654         path = get_selected_row (GTK_TREE_VIEW(self), &model);
 655         if ((path != NULL) && (gtk_tree_model_get_iter(model, &iter, path))) {
 656                 /* Unselect previous path */
 657                 gtk_tree_selection_unselect_path (sel, path);
 658
 659                 /* Move path up */
 660                 if (gtk_tree_path_prev (path)) {
 661                         gtk_tree_model_get_iter (model, &iter, path);
 662
 663                         /* Select the new one */
 664                         gtk_tree_selection_select_iter (sel, &iter);
 665                         scroll_to_selected (self, &iter, TRUE);
 666
 667                 }
 668                 gtk_tree_path_free (path);
 669         }
 670 }
 671
 672 GList*
 673 modest_header_view_get_columns (ModestHeaderView *self)
 674 {
 675         g_return_val_if_fail (self, FALSE);
 676         return gtk_tree_view_get_columns (GTK_TREE_VIEW(self));
 677 }
 678
 679
 680 gboolean
 681 modest_header_view_is_empty (ModestHeaderView *self)
 682 {
 683         g_return_val_if_fail (self, FALSE);
 684         return FALSE; /* FIXME */
 685 }
 686
 687
 688 gboolean
 689 modest_header_view_set_style (ModestHeaderView *self,
 690                               ModestHeaderViewStyle style)
 691 {
 692         ModestHeaderViewPrivate *priv;
 693         gboolean show_col_headers = FALSE;
 694         ModestHeaderViewStyle old_style;
 695
 696         g_return_val_if_fail (self, FALSE);
 697         g_return_val_if_fail (style >= 0 && MODEST_HEADER_VIEW_STYLE_NUM,
 698                               FALSE);
 699
 700         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 701         if (priv->style == style)
 702                 return TRUE; /* nothing to do */
 703
 704         switch (style) {
 705         case MODEST_HEADER_VIEW_STYLE_DETAILS:
 706                 show_col_headers = TRUE;
 707                 break;
 708         case MODEST_HEADER_VIEW_STYLE_TWOLINES:
 709                 break;
 710         default:
 711                 g_return_val_if_reached (FALSE);
 712         }
 713         gtk_tree_view_set_headers_visible   (GTK_TREE_VIEW(self), show_col_headers);
 714         gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW(self), show_col_headers);
 715
 716         old_style   = priv->style;
 717         priv->style = style;
 718
 719         return TRUE;
 720 }
 721
 722
 723 ModestHeaderViewStyle
 724 modest_header_view_get_style (ModestHeaderView *self)
 725 {
 726         g_return_val_if_fail (self, FALSE);
 727         return MODEST_HEADER_VIEW_GET_PRIVATE(self)->style;
 728 }
 729
 730 /*
 731  * This function sets a sortable model in the header view. It's just
 732  * used for developing purposes, because it only does a
 733  * gtk_tree_view_set_model
 734  */
 735 static void
 736 modest_header_view_set_model (GtkTreeView *header_view, GtkTreeModel *model)
 737 {
 738         GtkTreeModel *old_model_sort = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
 739
 740         if (old_model_sort && GTK_IS_TREE_MODEL_SORT (old_model_sort)) {
 741                 GtkTreeModel *old_model;
 742                 ModestHeaderViewPrivate *priv;
 743
 744                 priv = MODEST_HEADER_VIEW_GET_PRIVATE (header_view);
 745                 old_model = gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (old_model_sort));
 746
 747                 /* Set new model */
 748                 gtk_tree_view_set_model (header_view, model);
 749         } else
 750                 gtk_tree_view_set_model (header_view, model);
 751
 752         return;
 753 }
 754
 755 TnyFolder*
 756 modest_header_view_get_folder (ModestHeaderView *self)
 757 {
 758         ModestHeaderViewPrivate *priv;
 759         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 760
 761         if (priv->folder)
 762                 g_object_ref (priv->folder);
 763
 764         return priv->folder;
 765 }
 766
 767 static void
 768 modest_header_view_set_folder_intern (ModestHeaderView *self, TnyFolder *folder)
 769 {
 770         TnyFolderType type;
 771         TnyList *headers;
 772         ModestHeaderViewPrivate *priv;
 773         GList *cols, *cursor;
 774         GtkTreeModel *sortable;
 775         guint sort_colid;
 776         GtkSortType sort_type;
 777
 778         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 779
 780         headers = TNY_LIST (tny_gtk_header_list_model_new ());
 781
 782         tny_gtk_header_list_model_set_folder (TNY_GTK_HEADER_LIST_MODEL(headers),
 783                                               folder, FALSE);
 784
 785         /* Add IDLE observer (monitor) and another folder observer for
 786            new messages (self) */
 787         g_mutex_lock (priv->observers_lock);
 788         if (priv->monitor) {
 789                 tny_folder_monitor_stop (priv->monitor);
 790                 g_object_unref (G_OBJECT (priv->monitor));
 791         }
 792         priv->monitor = TNY_FOLDER_MONITOR (tny_folder_monitor_new (folder));
 793         tny_folder_monitor_add_list (priv->monitor, TNY_LIST (headers));
 794         tny_folder_monitor_start (priv->monitor);
 795         tny_folder_add_observer (folder, TNY_FOLDER_OBSERVER (self));
 796         g_mutex_unlock (priv->observers_lock);
 797
 798         sortable = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL(headers));
 799         g_object_unref (G_OBJECT (headers));
 800
 801         /* install our special sorting functions */
 802         cursor = cols = gtk_tree_view_get_columns (GTK_TREE_VIEW(self));
 803
 804         /* Restore sort column id */
 805         if (cols) {
 806                 type  = modest_tny_folder_guess_folder_type (folder);
 807                 sort_colid = modest_header_view_get_sort_column_id (self, type);
 808                 sort_type = modest_header_view_get_sort_type (self, type);
 809                 gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(sortable),
 810                                                       sort_colid,
 811                                                       sort_type);
 812                 gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE(sortable),
 813                                                  TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 814                                                  (GtkTreeIterCompareFunc) cmp_rows,
 815                                                  cols->data, NULL);
 816         }
 817
 818         /* Set new model */
 819         modest_header_view_set_model (GTK_TREE_VIEW (self), sortable);
 820         g_object_unref (G_OBJECT (sortable));
 821
 822         /* Free */
 823         g_list_free (cols);
 824 }
 825
 826 void
 827 modest_header_view_sort_by_column_id (ModestHeaderView *self,
 828                                       guint sort_colid,
 829                                       GtkSortType sort_type)
 830 {
 831         ModestHeaderViewPrivate *priv = NULL;
 832         GtkTreeModel *sortable = NULL;
 833         TnyFolderType type;
 834
 835         /* Get model and private data */
 836         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 837         sortable = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
 838
 839         /* Sort tree model */
 840         type  = modest_tny_folder_guess_folder_type (priv->folder);
 841         gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(sortable),
 842                                               sort_colid,
 843                                               sort_type);
 844         /* Store new sort parameters */
 845         modest_header_view_set_sort_params (self, sort_colid, sort_type, type);
 846
 847         /* Save GConf parameters */
 848 /*      modest_widget_memory_save (modest_runtime_get_conf(), */
 849 /*                                 G_OBJECT(self), "header-view"); */
 850
 851 }
 852
 853 void
 854 modest_header_view_set_sort_params (ModestHeaderView *self,
 855                                     guint sort_colid,
 856                                     GtkSortType sort_type,
 857                                     TnyFolderType type)
 858 {
 859         ModestHeaderViewPrivate *priv;
 860         ModestHeaderViewStyle style;
 861
 862         style = modest_header_view_get_style   (self);
 863         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 864
 865         priv->sort_colid[style][type] = sort_colid;
 866         priv->sort_type[style][type] = sort_type;
 867 }
 868
 869 gint
 870 modest_header_view_get_sort_column_id (ModestHeaderView *self,
 871                                        TnyFolderType type)
 872 {
 873         ModestHeaderViewPrivate *priv;
 874         ModestHeaderViewStyle style;
 875
 876         style = modest_header_view_get_style   (self);
 877         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 878
 879         return priv->sort_colid[style][type];
 880 }
 881
 882 GtkSortType
 883 modest_header_view_get_sort_type (ModestHeaderView *self,
 884                                   TnyFolderType type)
 885 {
 886         ModestHeaderViewPrivate *priv;
 887         ModestHeaderViewStyle style;
 888
 889         style = modest_header_view_get_style   (self);
 890         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 891
 892         return priv->sort_type[style][type];
 893 }
 894
 895 void
 896 modest_header_view_set_folder (ModestHeaderView *self,
 897                                TnyFolder *folder,
 898                                RefreshAsyncUserCallback callback,
 899                                gpointer user_data)
 900 {
 901         ModestHeaderViewPrivate *priv;
 902         ModestMailOperation *mail_op = NULL;
 903         ModestWindowMgr *mgr = NULL;
 904         GObject *source = NULL;
 905
 906         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 907
 908         if (priv->folder) {
 909                 g_mutex_lock (priv->observers_lock);
 910                 tny_folder_remove_observer (priv->folder, TNY_FOLDER_OBSERVER (self));
 911                 g_object_unref (priv->folder);
 912                 priv->folder = NULL;
 913                 g_mutex_unlock (priv->observers_lock);
 914         }
 915
 916         if (folder) {
 917
 918                 /* Get main window to use it as source of mail operation */
 919                 mgr = modest_runtime_get_window_mgr ();
 920                 source = G_OBJECT (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
 921
 922                 /* Set folder in the model */
 923                 modest_header_view_set_folder_intern (self, folder);
 924
 925                 /* Pick my reference. Nothing to do with the mail operation */
 926                 priv->folder = g_object_ref (folder);
 927
 928                 /* no message selected */
 929                 g_signal_emit (G_OBJECT(self), signals[HEADER_SELECTED_SIGNAL], 0, NULL);
 930
 931                 /* Create the mail operation (source will be the parent widget) */
 932                 mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_TYPE_RECEIVE, source);
 933                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
 934                                                  mail_op);
 935
 936                 /* Refresh the folder asynchronously */
 937                 modest_mail_operation_refresh_folder (mail_op, folder,
 938                                                       callback,
 939                                                       user_data);
 940
 941                 /* Free */
 942                 g_object_unref (mail_op);
 943
 944         } else {
 945                 g_mutex_lock (priv->observers_lock);
 946
 947                 if (priv->monitor) {
 948                         tny_folder_monitor_stop (priv->monitor);
 949                         g_object_unref (G_OBJECT (priv->monitor));
 950                         priv->monitor = NULL;
 951                 }
 952                 modest_header_view_set_model (GTK_TREE_VIEW (self), NULL);
 953
 954                 g_mutex_unlock (priv->observers_lock);
 955         }
 956 }
 957
 958 static void
 959 on_header_row_activated (GtkTreeView *treeview, GtkTreePath *path,
 960                          GtkTreeViewColumn *column, gpointer userdata)
 961 {
 962         ModestHeaderView *self = NULL;
 963         ModestHeaderViewPrivate *priv = NULL;
 964         GtkTreeIter iter;
 965         GtkTreeModel *model = NULL;
 966         TnyHeader *header;
 967
 968         self = MODEST_HEADER_VIEW (treeview);
 969         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 970
 971         model = gtk_tree_view_get_model (treeview);
 972
 973         if ((path == NULL) || (!gtk_tree_model_get_iter(model, &iter, path)))
 974                 return;
 975
 976         /* get the first selected item */
 977         gtk_tree_model_get (model, &iter,
 978                             TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
 979                             &header, -1);
 980         /* Emit signal */
 981         g_signal_emit (G_OBJECT(self),
 982                        signals[HEADER_ACTIVATED_SIGNAL],
 983                        0, header);
 984
 985         /* Free */
 986         g_object_unref (G_OBJECT (header));
 987
 988 }
 989
 990 static void
 991 on_selection_changed (GtkTreeSelection *sel, gpointer user_data)
 992 {
 993         GtkTreeModel *model;
 994         TnyHeader *header;
 995         GtkTreePath *path = NULL;
 996         GtkTreeIter iter;
 997         ModestHeaderView *self;
 998         ModestHeaderViewPrivate *priv;
 999         GList *selected = NULL;
1000
1001         g_return_if_fail (sel);
1002         g_return_if_fail (user_data);
1003
1004         self = MODEST_HEADER_VIEW (user_data);
1005         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
1006
1007         selected = gtk_tree_selection_get_selected_rows (sel, &model);
1008         if (selected != NULL)
1009                 path = (GtkTreePath *) selected->data;
1010         if ((path == NULL) || (!gtk_tree_model_get_iter(model, &iter, path)))
1011                 return; /* msg was _un_selected */
1012
1013         gtk_tree_model_get (model, &iter,
1014                             TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
1015                             &header, -1);
1016
1017         /* Emit signal */
1018         g_signal_emit (G_OBJECT(self),
1019                        signals[HEADER_SELECTED_SIGNAL],
1020                        0, header);
1021
1022         g_object_unref (G_OBJECT (header));
1023         gtk_tree_path_free(path);
1024 }
1025
1026
1027 /* PROTECTED method. It's useful when we want to force a given
1028    selection to reload a msg. For example if we have selected a header
1029    in offline mode, when Modest become online, we want to reload the
1030    message automatically without an user click over the header */
1031 void
1032 _modest_header_view_change_selection (GtkTreeSelection *selection,
1033                                       gpointer user_data)
1034 {
1035         g_return_if_fail (GTK_IS_TREE_SELECTION (selection));
1036         g_return_if_fail (MODEST_IS_HEADER_VIEW (user_data));
1037
1038         on_selection_changed (selection, user_data);
1039 }
1040
1041
1042 static gint
1043 cmp_rows (GtkTreeModel *tree_model, GtkTreeIter *iter1, GtkTreeIter *iter2,
1044           gpointer user_data)
1045 {
1046         gint col_id;
1047         gint t1, t2;
1048         gint val1, val2;
1049         gint cmp;
1050 /*      static int counter = 0; */
1051
1052         g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN(user_data), 0);
1053 /*      col_id = gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (tree_model)); */
1054         col_id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(user_data), MODEST_HEADER_VIEW_FLAG_SORT));
1055
1056 /*      if (!(++counter % 100)) { */
1057 /*              GObject *header_view = g_object_get_data(G_OBJECT(user_data), */
1058 /*                                                       MODEST_HEADER_VIEW_PTR); */
1059 /*              g_signal_emit (header_view, */
1060 /*                             signals[STATUS_UPDATE_SIGNAL], */
1061 /*                             0, _("Sorting..."), 0, 0); */
1062 /*      } */
1063         switch (col_id) {
1064         case TNY_HEADER_FLAG_ATTACHMENTS:
1065
1066                 gtk_tree_model_get (tree_model, iter1, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &val1,
1067                                     TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &t1, -1);
1068                 gtk_tree_model_get (tree_model, iter2, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &val2,
1069                                     TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &t2, -1);
1070
1071                 cmp = (val1 & TNY_HEADER_FLAG_ATTACHMENTS) -
1072                         (val2 & TNY_HEADER_FLAG_ATTACHMENTS);
1073
1074                 return cmp ? cmp : t1 - t2;
1075
1076         case TNY_HEADER_FLAG_PRIORITY:
1077                 gtk_tree_model_get (tree_model, iter1, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &val1,
1078                                     TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &t1,-1);
1079                 gtk_tree_model_get (tree_model, iter2, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &val2,
1080                                     TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &t2,-1);
1081
1082                 /* This is for making priority values respect the intuitive sort relationship
1083                  * as HIGH is 11, LOW is 01, and we put NORMAL AS 10 (2) */
1084                 if (val1 == 0) val1 = 2;
1085                 if (val2 == 0) val2 = 2;
1086
1087                 cmp =  (val1 & TNY_HEADER_FLAG_PRIORITY) - (val2 & TNY_HEADER_FLAG_PRIORITY);
1088
1089                 return cmp ? cmp : t1 - t2;
1090
1091         default:
1092                 return &iter1 - &iter2; /* oughhhh  */
1093         }
1094 }
1095
1096 /* Drag and drop stuff */
1097 static void
1098 drag_data_get_cb (GtkWidget *widget, GdkDragContext *context,
1099                   GtkSelectionData *selection_data,
1100                   guint info,  guint time, gpointer data)
1101 {
1102         GtkTreeModel *model = NULL;
1103         GtkTreeIter iter;
1104         GtkTreePath *source_row = NULL;
1105
1106         source_row = get_selected_row (GTK_TREE_VIEW (widget), &model);
1107         if ((source_row == NULL) || (!gtk_tree_model_get_iter(model, &iter, source_row))) return;
1108
1109         switch (info) {
1110         case MODEST_HEADER_ROW:
1111                 gtk_tree_set_row_drag_data (selection_data, model, source_row);
1112                 break;
1113         case MODEST_MSG: {
1114                 TnyHeader *hdr;
1115                 gtk_tree_model_get (model, &iter,
1116                                     TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, &hdr,
1117                                     -1);
1118                 if (hdr) {
1119                         g_object_unref (G_OBJECT(hdr));
1120                 }
1121                 break;
1122         }
1123         default:
1124                 g_message ("%s: default switch case.", __FUNCTION__);
1125         }
1126
1127         gtk_tree_path_free (source_row);
1128 }
1129
1130 /* Header view drag types */
1131 const GtkTargetEntry header_view_drag_types[] = {
1132         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP, MODEST_HEADER_ROW },
1133         { "text/uri-list",      0,                   MODEST_MSG },
1134 };
1135
1136 static void
1137 setup_drag_and_drop (GtkTreeView *self)
1138 {
1139         gtk_drag_source_set (GTK_WIDGET (self),
1140                              GDK_BUTTON1_MASK,
1141                              header_view_drag_types,
1142                              G_N_ELEMENTS (header_view_drag_types),
1143                              GDK_ACTION_MOVE | GDK_ACTION_COPY);
1144
1145         g_signal_connect(G_OBJECT (self), "drag_data_get",
1146                          G_CALLBACK(drag_data_get_cb), NULL);
1147 }
1148
1149 static GtkTreePath *
1150 get_selected_row (GtkTreeView *self, GtkTreeModel **model)
1151 {
1152         GtkTreePath *path = NULL;
1153         GtkTreeSelection *sel = NULL;
1154         GList *rows = NULL;
1155
1156         sel   = gtk_tree_view_get_selection(self);
1157         rows = gtk_tree_selection_get_selected_rows (sel, model);
1158
1159         if ((rows == NULL) || (g_list_length(rows) != 1))
1160                 goto frees;
1161
1162         path = gtk_tree_path_copy(g_list_nth_data (rows, 0));
1163
1164
1165         /* Free */
1166  frees:
1167         g_list_foreach(rows,(GFunc) gtk_tree_path_free, NULL);
1168         g_list_free(rows);
1169
1170         return path;
1171 }
1172
1173 /*
1174  * This function moves the tree view scroll to the current selected
1175  * row when the widget grabs the focus
1176  */
1177 static gboolean
1178 on_focus_in (GtkWidget     *self,
1179              GdkEventFocus *event,
1180              gpointer       user_data)
1181 {
1182         GtkTreeSelection *selection;
1183         GtkTreeModel *model;
1184         GList *selected = NULL;
1185         GtkTreePath *selected_path = NULL;
1186
1187         model = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
1188         if (!model)
1189                 return FALSE;
1190
1191         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
1192         /* If none selected yet, pick the first one */
1193         if (gtk_tree_selection_count_selected_rows (selection) == 0) {
1194                 GtkTreeIter iter;
1195                 GtkTreePath *path;
1196
1197                 /* Return if the model is empty */
1198                 if (!gtk_tree_model_get_iter_first (model, &iter))
1199                         return FALSE;
1200
1201                 path = gtk_tree_model_get_path (model, &iter);
1202                 gtk_tree_selection_select_path (selection, path);
1203                 gtk_tree_path_free (path);
1204         }
1205
1206         /* Need to get the all the rows because is selection multiple */
1207         selected = gtk_tree_selection_get_selected_rows (selection, &model);
1208         if (selected == NULL) return FALSE;
1209         selected_path = (GtkTreePath *) selected->data;
1210
1211         /* Check if we need to scroll */
1212         #if GTK_CHECK_VERSION(2, 8, 0) /* TODO: gtk_tree_view_get_visible_range() is only available in GTK+ 2.8 */
1213         GtkTreePath *start_path = NULL;
1214         GtkTreePath *end_path = NULL;
1215         if (gtk_tree_view_get_visible_range (GTK_TREE_VIEW (self),
1216                                              &start_path,
1217                                              &end_path)) {
1218
1219                 if ((gtk_tree_path_compare (start_path, selected_path) != -1) ||
1220                     (gtk_tree_path_compare (end_path, selected_path) != 1)) {
1221
1222                         /* Scroll to first path */
1223                         gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (self),
1224                                                       selected_path,
1225                                                       NULL,
1226                                                       TRUE,
1227                                                       0.5,
1228                                                       0.0);
1229                 }
1230         }
1231         #endif /* GTK_CHECK_VERSION */
1232
1233         /* Frees */
1234         g_list_foreach (selected, (GFunc) gtk_tree_path_free, NULL);
1235         g_list_free (selected);
1236
1237         return FALSE;
1238 }
1239
1240 static gboolean
1241 idle_notify_added_headers (gpointer data)
1242 {
1243         modest_platform_on_new_msg ();
1244
1245         return FALSE;
1246 }
1247
1248 static void
1249 idle_notify_headers_count_changed_destroy (gpointer data)
1250 {
1251         HeadersCountChangedHelper *helper = NULL;
1252
1253         g_return_if_fail (data != NULL);
1254         helper = (HeadersCountChangedHelper *) data;
1255
1256         g_object_unref (helper->change);
1257         g_slice_free (HeadersCountChangedHelper, helper);
1258 }
1259
1260 static gboolean
1261 idle_notify_headers_count_changed (gpointer data)
1262 {
1263         TnyFolder *folder = NULL;
1264         ModestHeaderViewPrivate *priv = NULL;
1265         HeadersCountChangedHelper *helper = NULL;
1266
1267         g_return_val_if_fail (data != NULL, FALSE);
1268         helper = (HeadersCountChangedHelper *) data;
1269         g_return_val_if_fail (MODEST_IS_HEADER_VIEW(helper->self), FALSE);
1270         g_return_val_if_fail (TNY_FOLDER_CHANGE(helper->change), FALSE);
1271
1272         folder = tny_folder_change_get_folder (helper->change);
1273
1274         priv = MODEST_HEADER_VIEW_GET_PRIVATE (helper->self);
1275         g_mutex_lock (priv->observers_lock);
1276
1277         g_signal_emit (G_OBJECT(helper->self), signals[MSG_COUNT_CHANGED_SIGNAL], 0, folder, helper->change);
1278
1279         g_mutex_unlock (priv->observers_lock);
1280
1281         return FALSE;
1282 }
1283
1284 static void
1285 folder_monitor_update (TnyFolderObserver *self,
1286                        TnyFolderChange *change)
1287 {
1288         TnyFolderChangeChanged changed;
1289         HeadersCountChangedHelper *helper = NULL;
1290
1291         changed = tny_folder_change_get_changed (change);
1292
1293         /* We need an idle because this function is called from within
1294            a thread, so it could cause problems if the modest platform
1295            code calls dbus for example */
1296         if (changed & TNY_FOLDER_CHANGE_CHANGED_ADDED_HEADERS)
1297                 g_idle_add (idle_notify_added_headers, NULL);
1298
1299         /* Check folder count */
1300         if ((changed & TNY_FOLDER_CHANGE_CHANGED_ADDED_HEADERS) ||
1301             (changed & TNY_FOLDER_CHANGE_CHANGED_REMOVED_HEADERS)) {
1302                 helper = g_slice_new0 (HeadersCountChangedHelper);
1303                 helper->self = MODEST_HEADER_VIEW(self);
1304                 helper->change = g_object_ref(change);
1305
1306                 g_idle_add_full (G_PRIORITY_DEFAULT,
1307                                  idle_notify_headers_count_changed,
1308                                  helper,
1309                                  idle_notify_headers_count_changed_destroy);
1310         }
1311 }
1312
1313 void
1314 modest_header_view_clear (ModestHeaderView *self)
1315 {
1316         modest_header_view_set_folder (self, NULL, NULL, NULL);
1317 }