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