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
  31 /* modest-tny-header-tree-view.c */
  32
  33 #include <glib/gi18n.h>
  34 #include "modest-header-view.h"
  35 #include <tny-list-iface.h>
  36 #include <string.h>
  37 #include <modest-marshal.h>
  38
  39 #include <modest-icon-names.h>
  40 #include "modest-icon-factory.h"
  41
  42 static void modest_header_view_class_init  (ModestHeaderViewClass *klass);
  43 static void modest_header_view_init        (ModestHeaderView *obj);
  44 static void modest_header_view_finalize    (GObject *obj);
  45
  46 static void     on_selection_changed (GtkTreeSelection *sel, gpointer user_data);
  47
  48 enum {
  49         MESSAGE_SELECTED_SIGNAL,
  50         STATUS_UPDATE_SIGNAL,
  51         LAST_SIGNAL
  52 };
  53
  54
  55 typedef struct _ModestHeaderViewPrivate ModestHeaderViewPrivate;
  56 struct _ModestHeaderViewPrivate {
  57
  58         TnyMsgFolderIface *tny_msg_folder;
  59         TnyListIface      *headers;
  60         GSList            *columns;
  61         GMutex            *lock;
  62         ModestHeaderViewStyle style;
  63
  64         gulong            sig1;
  65
  66 };
  67 #define MODEST_HEADER_VIEW_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  68                                                 MODEST_TYPE_HEADER_VIEW, \
  69                                                 ModestHeaderViewPrivate))
  70 /* globals */
  71 static GObjectClass *parent_class = NULL;
  72
  73 /* uncomment the following if you have defined any signals */
  74 static guint signals[LAST_SIGNAL] = {0};
  75
  76 GType
  77 modest_header_view_get_type (void)
  78 {
  79         static GType my_type = 0;
  80         if (!my_type) {
  81                 static const GTypeInfo my_info = {
  82                         sizeof(ModestHeaderViewClass),
  83                         NULL,           /* base init */
  84                         NULL,           /* base finalize */
  85                         (GClassInitFunc) modest_header_view_class_init,
  86                         NULL,           /* class finalize */
  87                         NULL,           /* class data */
  88                         sizeof(ModestHeaderView),
  89                         1,              /* n_preallocs */
  90                         (GInstanceInitFunc) modest_header_view_init,
  91                 };
  92                 my_type = g_type_register_static (GTK_TYPE_TREE_VIEW,
  93                                                   "ModestHeaderView",
  94                                                   &my_info, 0);
  95         }
  96         return my_type;
  97 }
  98
  99 static void
 100 modest_header_view_class_init (ModestHeaderViewClass *klass)
 101 {
 102         GObjectClass *gobject_class;
 103         gobject_class = (GObjectClass*) klass;
 104
 105         parent_class            = g_type_class_peek_parent (klass);
 106         gobject_class->finalize = modest_header_view_finalize;
 107
 108         g_type_class_add_private (gobject_class, sizeof(ModestHeaderViewPrivate));
 109
 110         signals[MESSAGE_SELECTED_SIGNAL] =
 111                 g_signal_new ("message_selected",
 112                               G_TYPE_FROM_CLASS (gobject_class),
 113                               G_SIGNAL_RUN_FIRST,
 114                               G_STRUCT_OFFSET (ModestHeaderViewClass,message_selected),
 115                               NULL, NULL,
 116                               g_cclosure_marshal_VOID__POINTER,
 117                               G_TYPE_NONE, 1, G_TYPE_POINTER);
 118
 119         signals[STATUS_UPDATE_SIGNAL] =
 120                 g_signal_new ("status_update",
 121                               G_TYPE_FROM_CLASS (gobject_class),
 122                               G_SIGNAL_RUN_FIRST,
 123                               G_STRUCT_OFFSET (ModestHeaderViewClass,message_selected),
 124                               NULL, NULL,
 125                               modest_marshal_VOID__STRING_INT,
 126                               G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_INT);
 127 }
 128
 129
 130
 131
 132
 133 static void
 134 msgtype_cell_data (GtkTreeViewColumn *column, GtkCellRenderer *renderer,
 135                    GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer user_data)
 136 {
 137         TnyMsgHeaderFlags flags;
 138         GdkPixbuf *pixbuf = NULL;
 139
 140         gtk_tree_model_get (tree_model, iter, TNY_MSG_HEADER_LIST_MODEL_FLAGS_COLUMN,
 141                             &flags, -1);
 142
 143         if (flags & TNY_MSG_HEADER_FLAG_DELETED)
 144                 pixbuf = modest_icon_factory_get_icon (MODEST_HEADER_ICON_DELETED);
 145         else if (flags & TNY_MSG_HEADER_FLAG_SEEN)
 146                 pixbuf = modest_icon_factory_get_icon (MODEST_HEADER_ICON_READ);
 147         else
 148                 pixbuf = modest_icon_factory_get_icon (MODEST_HEADER_ICON_UNREAD);
 149
 150         g_object_set (G_OBJECT (renderer), "pixbuf", pixbuf, NULL);
 151 }
 152
 153 static void
 154 attach_cell_data (GtkTreeViewColumn *column, GtkCellRenderer *renderer,
 155                   GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer user_data)
 156 {
 157         TnyMsgHeaderFlags flags;
 158         GdkPixbuf *pixbuf = NULL;
 159
 160         gtk_tree_model_get (tree_model, iter, TNY_MSG_HEADER_LIST_MODEL_FLAGS_COLUMN,
 161                             &flags, -1);
 162
 163         if (flags & TNY_MSG_HEADER_FLAG_ATTACHMENTS)
 164                 pixbuf = modest_icon_factory_get_icon (MODEST_HEADER_ICON_ATTACH);
 165
 166         g_object_set (G_OBJECT (renderer), "pixbuf", pixbuf, NULL);
 167 }
 168
 169
 170 static void
 171 header_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 172                   GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer user_data)
 173 {
 174         TnyMsgHeaderFlags flags;
 175
 176         gtk_tree_model_get (tree_model, iter, TNY_MSG_HEADER_LIST_MODEL_FLAGS_COLUMN,
 177                             &flags, -1);
 178
 179         g_object_set (G_OBJECT(renderer),
 180                       "weight", (flags & TNY_MSG_HEADER_FLAG_SEEN) ? 400: 800,
 181                       "style",  (flags & TNY_MSG_HEADER_FLAG_DELETED) ?
 182                                  PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL,
 183                       NULL);
 184 }
 185
 186
 187
 188 /* try to make a shorter display address; changes it arg in-place */
 189 static gchar*
 190 display_address (gchar *address)
 191 {
 192         gchar *cursor;
 193
 194         if (!address)
 195                 return NULL;
 196
 197         /* simplistic --> remove <email@address> from display name */
 198         cursor = g_strstr_len (address, strlen(address), "<");
 199         if (cursor)
 200                 cursor[0]='\0';
 201
 202         /* simplistic --> remove (bla bla) from display name */
 203         cursor = g_strstr_len (address, strlen(address), "(");
 204         if (cursor)
 205                 cursor[0]='\0';
 206
 207         /* FIXME */
 208         if (!g_utf8_validate (address, -1, NULL))
 209                 g_printerr ("modest: invalid: '%s'", address);
 210
 211         return address;
 212 }
 213
 214
 215
 216 static void
 217 sender_receiver_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 218                             GtkTreeModel *tree_model,  GtkTreeIter *iter,  gboolean is_sender)
 219 {
 220         TnyMsgHeaderFlags flags;
 221         gchar *address;
 222         gint sender_receiver_col;
 223
 224         if (is_sender)
 225                 sender_receiver_col = TNY_MSG_HEADER_LIST_MODEL_FROM_COLUMN;
 226         else
 227                 sender_receiver_col = TNY_MSG_HEADER_LIST_MODEL_TO_COLUMN;
 228
 229         gtk_tree_model_get (tree_model, iter,
 230                             sender_receiver_col,  &address,
 231                             TNY_MSG_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 232                             -1);
 233
 234         g_object_set (G_OBJECT(renderer),
 235                       "text",
 236                       display_address (address),
 237                       "weight",
 238                       (flags & TNY_MSG_HEADER_FLAG_SEEN) ? 400 : 800,
 239                       "style",
 240                       (flags & TNY_MSG_HEADER_FLAG_DELETED)?PANGO_STYLE_ITALIC:PANGO_STYLE_NORMAL,
 241                       NULL);
 242
 243         g_free (address);
 244 }
 245
 246
 247
 248 /* just to prevent warnings:
 249  * warning: `%x' yields only last 2 digits of year in some locales
 250  */
 251 static size_t
 252 my_strftime(char *s, size_t max, const char  *fmt,  const
 253             struct tm *tm) {
 254         return strftime(s, max, fmt, tm);
 255 }
 256
 257
 258
 259 /* not reentrant/thread-safe */
 260 const gchar*
 261 display_date (time_t date)
 262 {
 263         struct tm date_tm, now_tm;
 264         time_t now;
 265
 266         const gint buf_size = 64;
 267         static gchar date_buf[64]; /* buf_size is not ... */
 268         static gchar now_buf[64];  /* ...const enough... */
 269
 270         now = time (NULL);
 271
 272         localtime_r(&now, &now_tm);
 273         localtime_r(&date, &date_tm);
 274
 275         /* get today's date */
 276         my_strftime (date_buf, buf_size, "%x", &date_tm);
 277         my_strftime (now_buf,  buf_size, "%x",  &now_tm);  /* today */
 278
 279         /* if this is today, get the time instead of the date */
 280         if (strcmp (date_buf, now_buf) == 0)
 281                 strftime (date_buf, buf_size, _("%X"), &date_tm);
 282
 283         return date_buf;
 284 }
 285
 286
 287 static void
 288 compact_header_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 289                            GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer user_data)
 290 {
 291         GObject *rendobj;
 292         TnyMsgHeaderFlags flags;
 293         gchar *from, *subject;
 294         gchar *header;
 295         time_t date;
 296
 297         gtk_tree_model_get (tree_model, iter,
 298                             TNY_MSG_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 299                             TNY_MSG_HEADER_LIST_MODEL_FROM_COLUMN,  &from,
 300                             TNY_MSG_HEADER_LIST_MODEL_SUBJECT_COLUMN, &subject,
 301                             TNY_MSG_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN, &date,
 302                             -1);
 303         rendobj = G_OBJECT(renderer);
 304
 305         header = g_strdup_printf ("%s %s\n%s",
 306                                   display_address (from),
 307                                   display_date(date),
 308                                   subject);
 309
 310         g_object_set (G_OBJECT(renderer),
 311                       "text",  header,
 312                       "weight", (flags & TNY_MSG_HEADER_FLAG_SEEN) ? 400: 800,
 313                       "style",  (flags & TNY_MSG_HEADER_FLAG_DELETED) ?
 314                                  PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL,
 315                       NULL);
 316         g_free (header);
 317         g_free (from);
 318         g_free (subject);
 319 }
 320
 321
 322 static GtkTreeViewColumn*
 323 get_new_column (const gchar *name, GtkCellRenderer *renderer,
 324                 gboolean resizable, gint sort_col_id, gboolean show_as_text,
 325                 GtkTreeCellDataFunc cell_data_func, gpointer user_data)
 326 {
 327         GtkTreeViewColumn *column;
 328
 329         column =  gtk_tree_view_column_new_with_attributes(name, renderer, NULL);
 330         gtk_tree_view_column_set_resizable (column, resizable);
 331         gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
 332
 333         if (show_as_text)
 334                 gtk_tree_view_column_add_attribute (column, renderer, "text",
 335                                                     sort_col_id);
 336         if (sort_col_id >= 0)
 337                 gtk_tree_view_column_set_sort_column_id (column, sort_col_id);
 338
 339         gtk_tree_view_column_set_sort_indicator (column, FALSE);
 340         gtk_tree_view_column_set_reorderable (column, TRUE);
 341
 342         if (cell_data_func)
 343                 gtk_tree_view_column_set_cell_data_func(column, renderer, cell_data_func,
 344                                                         user_data, NULL);
 345
 346         return column;
 347 }
 348
 349
 350
 351
 352 static void
 353 remove_all_columns (ModestHeaderView *obj)
 354 {
 355         GList *columns, *cursor;
 356
 357         columns = gtk_tree_view_get_columns (GTK_TREE_VIEW(obj));
 358
 359         for (cursor = columns; cursor; cursor = cursor->next)
 360                 gtk_tree_view_remove_column (GTK_TREE_VIEW(obj),
 361                                              GTK_TREE_VIEW_COLUMN(cursor->data));
 362         g_list_free (columns);
 363 }
 364
 365
 366
 367
 368 static void
 369 init_columns (ModestHeaderView *obj)
 370 {
 371         GtkTreeViewColumn *column=NULL;
 372         GtkCellRenderer *renderer_msgtype,
 373                 *renderer_header,
 374                 *renderer_attach;
 375
 376         ModestHeaderViewPrivate *priv;
 377         GSList *cursor;
 378
 379         priv = MODEST_HEADER_VIEW_GET_PRIVATE(obj);
 380
 381         renderer_msgtype = gtk_cell_renderer_pixbuf_new ();
 382         renderer_attach  = gtk_cell_renderer_pixbuf_new ();
 383         renderer_header = gtk_cell_renderer_text_new ();
 384
 385         remove_all_columns (obj);
 386
 387         for (cursor = priv->columns; cursor; cursor = cursor->next) {
 388                 ModestHeaderViewColumn col =
 389                         (ModestHeaderViewColumn) GPOINTER_TO_INT(cursor->data);
 390
 391                 switch (col) {
 392
 393                 case MODEST_HEADER_VIEW_COLUMN_MSGTYPE:
 394
 395                         column = get_new_column (_("M"), renderer_msgtype, FALSE,
 396                                                  TNY_MSG_HEADER_LIST_MODEL_FLAGS_COLUMN,
 397                                                  FALSE, (GtkTreeCellDataFunc)msgtype_cell_data,
 398                                                  NULL);
 399                         break;
 400
 401                 case MODEST_HEADER_VIEW_COLUMN_ATTACH:
 402
 403                         column = get_new_column (_("A"), renderer_attach, FALSE,
 404                                                  TNY_MSG_HEADER_LIST_MODEL_FLAGS_COLUMN,
 405                                                  FALSE, (GtkTreeCellDataFunc)attach_cell_data,
 406                                                  NULL);
 407                         break;
 408
 409                 case MODEST_HEADER_VIEW_COLUMN_RECEIVED_DATE:
 410                         column = get_new_column (_("Received"), renderer_header, TRUE,
 411                                                  TNY_MSG_HEADER_LIST_MODEL_DATE_RECEIVED_COLUMN,
 412                                                  TRUE, (GtkTreeCellDataFunc)header_cell_data,
 413                                                  NULL);
 414                         break;
 415
 416                 case MODEST_HEADER_VIEW_COLUMN_FROM:
 417                         column = get_new_column (_("From"), renderer_header, TRUE,
 418                                                  TNY_MSG_HEADER_LIST_MODEL_FROM_COLUMN,
 419                                                  TRUE, (GtkTreeCellDataFunc)sender_receiver_cell_data,
 420                                                  GINT_TO_POINTER(TRUE));
 421                         break;
 422
 423                 case MODEST_HEADER_VIEW_COLUMN_TO:
 424                         column = get_new_column (_("To"), renderer_header, TRUE,
 425                                                  TNY_MSG_HEADER_LIST_MODEL_TO_COLUMN,
 426                                                  TRUE, (GtkTreeCellDataFunc)sender_receiver_cell_data,
 427                                                  GINT_TO_POINTER(FALSE));
 428                         break;
 429
 430                 case MODEST_HEADER_VIEW_COLUMN_COMPACT_HEADER:
 431                         column = get_new_column (_("Header"), renderer_header, TRUE,
 432                                                  TNY_MSG_HEADER_LIST_MODEL_FROM_COLUMN,
 433                                                  TRUE, (GtkTreeCellDataFunc)compact_header_cell_data,
 434                                                  NULL);
 435                         break;
 436
 437                 case MODEST_HEADER_VIEW_COLUMN_SUBJECT:
 438                         column = get_new_column (_("Subject"), renderer_header, TRUE,
 439                                                  TNY_MSG_HEADER_LIST_MODEL_SUBJECT_COLUMN,
 440                                                  TRUE, (GtkTreeCellDataFunc)header_cell_data,
 441                                                  NULL);
 442                         break;
 443
 444
 445                 case MODEST_HEADER_VIEW_COLUMN_SENT_DATE:
 446                         column = get_new_column (_("Sent"), renderer_header, TRUE,
 447                                                  TNY_MSG_HEADER_LIST_MODEL_DATE_SENT_COLUMN,
 448                                                  TRUE, (GtkTreeCellDataFunc)header_cell_data,
 449                                                  NULL);
 450                         break;
 451
 452                 default:
 453                         g_assert_not_reached ();
 454                 }
 455
 456                 gtk_tree_view_column_set_visible (column, TRUE);
 457                 gtk_tree_view_column_set_min_width (column, 36);
 458                 gtk_tree_view_column_set_resizable (column, TRUE);
 459
 460                 gtk_tree_view_append_column (GTK_TREE_VIEW(obj), column);
 461         }
 462 }
 463
 464
 465
 466 static void
 467 modest_header_view_init (ModestHeaderView *obj)
 468 {
 469         ModestHeaderViewPrivate *priv;
 470         priv = MODEST_HEADER_VIEW_GET_PRIVATE(obj);
 471
 472         priv->lock = g_mutex_new ();
 473 }
 474
 475 static void
 476 modest_header_view_finalize (GObject *obj)
 477 {
 478         ModestHeaderView        *self;
 479         ModestHeaderViewPrivate *priv;
 480         GtkTreeSelection        *sel;
 481
 482         self = MODEST_HEADER_VIEW(obj);
 483         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 484
 485         if (priv->headers)
 486                 g_object_unref (G_OBJECT(priv->headers));
 487
 488         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(self));
 489         g_signal_handler_disconnect (G_OBJECT(sel), priv->sig1);
 490
 491         if (priv->lock) {
 492                 g_mutex_free (priv->lock);
 493                 priv->lock = NULL;
 494         }
 495
 496         priv->headers = NULL;
 497         priv->tny_msg_folder    = NULL;
 498
 499         G_OBJECT_CLASS(parent_class)->finalize (obj);
 500 }
 501
 502 GtkWidget*
 503 modest_header_view_new (TnyMsgFolderIface *folder,
 504                         GSList *columns,
 505                         ModestHeaderViewStyle style)
 506 {
 507         GObject *obj;
 508         GtkTreeSelection *sel;
 509         ModestHeaderView *self;
 510         ModestHeaderViewPrivate *priv;
 511
 512         obj  = G_OBJECT(g_object_new(MODEST_TYPE_HEADER_VIEW, NULL));
 513         self = MODEST_HEADER_VIEW(obj);
 514         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 515
 516         if (!modest_header_view_set_folder (self, NULL)) {
 517                 g_warning ("could not set the folder");
 518                 g_object_unref (obj);
 519                 return NULL;
 520         }
 521
 522         modest_header_view_set_style   (self, style);
 523         modest_header_view_set_columns (self, columns);
 524
 525         /* all cols */
 526         gtk_tree_view_set_headers_visible   (GTK_TREE_VIEW(obj), TRUE);
 527         gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW(obj), TRUE);
 528         gtk_tree_view_columns_autosize (GTK_TREE_VIEW(obj));
 529
 530         gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(obj),
 531                                       TRUE); /* alternating row colors */
 532
 533         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(self));
 534
 535         priv->sig1 = g_signal_connect (sel, "changed",
 536                                        G_CALLBACK(on_selection_changed), self);
 537
 538
 539         return GTK_WIDGET(self);
 540 }
 541
 542 gboolean
 543 modest_header_view_set_columns (ModestHeaderView *self, GSList *columns)
 544 {
 545         ModestHeaderViewPrivate *priv;
 546         GSList *cursor;
 547
 548         g_return_val_if_fail (self, FALSE);
 549
 550         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 551
 552         g_slist_free (priv->columns);
 553
 554         for (cursor = columns; cursor; cursor = cursor->next) {
 555                 ModestHeaderViewColumn col =
 556                         (ModestHeaderViewColumn) GPOINTER_TO_INT(cursor->data);
 557                 if (0 > col || col >= MODEST_HEADER_VIEW_COLUMN_NUM)
 558                         g_printerr ("modest: invalid column %d in column list\n", col);
 559                 else
 560                         priv->columns = g_slist_append (priv->columns, cursor->data);
 561         }
 562
 563         init_columns (self); /* redraw them */
 564         return TRUE;
 565 }
 566
 567
 568
 569 const GSList*
 570 modest_header_view_get_columns (ModestHeaderView *self)
 571 {
 572         ModestHeaderViewPrivate *priv;
 573
 574         g_return_val_if_fail (self, FALSE);
 575
 576         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 577         return priv->columns;
 578 }
 579
 580
 581
 582
 583 gboolean
 584 modest_header_view_set_style (ModestHeaderView *self,
 585                                        ModestHeaderViewStyle style)
 586 {
 587         g_return_val_if_fail (self, FALSE);
 588         g_return_val_if_fail (style >= 0 && style < MODEST_HEADER_VIEW_STYLE_NUM,
 589                               FALSE);
 590
 591         MODEST_HEADER_VIEW_GET_PRIVATE(self)->style = style;
 592
 593         return TRUE;
 594 }
 595
 596 ModestHeaderViewStyle
 597 modest_header_view_get_style (ModestHeaderView *self)
 598 {
 599         g_return_val_if_fail (self, FALSE);
 600
 601         return MODEST_HEADER_VIEW_GET_PRIVATE(self)->style;
 602 }
 603
 604
 605
 606 /* get the length of any prefix that should be ignored for sorting */
 607 static inline int
 608 get_prefix_len (const gchar *sub)
 609 {
 610         gint i = 0;
 611         const static gchar* prefix[] = {"Re:", "RE:", "Fwd:", "FWD:", "FW:", "AW:", NULL};
 612
 613         if (sub[0] != 'R' && sub[0] != 'F') /* optimization */
 614                 return 0;
 615
 616         while (prefix[i]) {
 617                 if (g_str_has_prefix(sub, prefix[i])) {
 618                         int prefix_len = strlen(prefix[i]);
 619                         if (sub[prefix_len] == ' ')
 620                                 ++prefix_len; /* ignore space after prefix as well */
 621                         return prefix_len;
 622                 }
 623                 ++i;
 624         }
 625         return 0;
 626 }
 627
 628
 629 static inline gint
 630 cmp_normalized_subject (const gchar* s1, const gchar *s2)
 631 {
 632         gint result = 0;
 633         register gchar *n1, *n2;
 634
 635         n1 = g_utf8_collate_key (s1 + get_prefix_len(s1), -1);
 636         n2 = g_utf8_collate_key (s2 + get_prefix_len(s2), -1);
 637
 638         result = strcmp (n1, n2);
 639         g_free (n1);
 640         g_free (n2);
 641
 642         return result;
 643 }
 644
 645
 646 static gint
 647 cmp_rows (GtkTreeModel *tree_model, GtkTreeIter *iter1, GtkTreeIter *iter2,
 648           gpointer user_data)
 649 {
 650         gint col_id = GPOINTER_TO_INT (user_data);
 651         gint t1, t2;
 652         gint val1, val2;
 653         gchar *s1, *s2;
 654         gint cmp;
 655
 656         g_return_val_if_fail (GTK_IS_TREE_MODEL(tree_model), -1);
 657
 658         switch (col_id) {
 659
 660                 /* first one, we decide based on the time */
 661         case MODEST_HEADER_VIEW_COLUMN_COMPACT_HEADER:
 662         case MODEST_HEADER_VIEW_COLUMN_RECEIVED_DATE:
 663                 gtk_tree_model_get (tree_model, iter1,
 664                                     TNY_MSG_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN,
 665                                     &t1,-1);
 666                 gtk_tree_model_get (tree_model, iter2,
 667                                     TNY_MSG_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN,
 668                                     &t2,-1);
 669                 return t1 - t2;
 670
 671         case MODEST_HEADER_VIEW_COLUMN_SENT_DATE:
 672                 gtk_tree_model_get (tree_model, iter1,
 673                                     TNY_MSG_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN,
 674                                     &t1,-1);
 675                 gtk_tree_model_get (tree_model, iter2,
 676                                     TNY_MSG_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN,
 677                                     &t2,-1);
 678                 return t1 - t2;
 679
 680
 681                 /* next ones, we try the search criteria first, if they're the same, then we use 'sent date' */
 682         case MODEST_HEADER_VIEW_COLUMN_SUBJECT: {
 683
 684                 gtk_tree_model_get (tree_model, iter1,
 685                                     TNY_MSG_HEADER_LIST_MODEL_SUBJECT_COLUMN, &s1,
 686                                     TNY_MSG_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &t1,
 687                                     -1);
 688                 gtk_tree_model_get (tree_model, iter2,
 689                                     TNY_MSG_HEADER_LIST_MODEL_SUBJECT_COLUMN, &s2,
 690                                     TNY_MSG_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &t2,
 691                                     -1);
 692
 693                 cmp = cmp_normalized_subject(s1, s2);
 694
 695                 g_free (s1);
 696                 g_free (s2);
 697
 698                 return cmp ? cmp : t1 - t2;
 699         }
 700
 701         case MODEST_HEADER_VIEW_COLUMN_FROM:
 702
 703                 gtk_tree_model_get (tree_model, iter1,
 704                                     TNY_MSG_HEADER_LIST_MODEL_FROM_COLUMN, &s1,
 705                                     TNY_MSG_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &t1,
 706                                     -1);
 707                 gtk_tree_model_get (tree_model, iter2,
 708                                     TNY_MSG_HEADER_LIST_MODEL_FROM_COLUMN, &s2,
 709                                     TNY_MSG_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &t2,
 710                                     -1);
 711                 cmp = strcmp (s1, s2);
 712                 g_free (s1);
 713                 g_free (s2);
 714
 715                 return cmp ? cmp : t1 - t2;
 716
 717         case MODEST_HEADER_VIEW_COLUMN_TO:
 718
 719                 gtk_tree_model_get (tree_model, iter1,
 720                                     TNY_MSG_HEADER_LIST_MODEL_TO_COLUMN, &s1,
 721                                     TNY_MSG_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &t1,
 722                                     -1);
 723                 gtk_tree_model_get (tree_model, iter2,
 724                                     TNY_MSG_HEADER_LIST_MODEL_TO_COLUMN, &s2,
 725                                     TNY_MSG_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &t2,
 726                                     -1);
 727                 cmp = strcmp (s1, s2);
 728                 g_free (s1);
 729                 g_free (s2);
 730
 731                 return cmp ? cmp : t1 - t2;
 732
 733         case MODEST_HEADER_VIEW_COLUMN_ATTACH:
 734
 735                 gtk_tree_model_get (tree_model, iter1, TNY_MSG_HEADER_LIST_MODEL_FLAGS_COLUMN, &val1,
 736                                     TNY_MSG_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &t1, -1);
 737                 gtk_tree_model_get (tree_model, iter2, TNY_MSG_HEADER_LIST_MODEL_FLAGS_COLUMN, &val2,
 738                                     TNY_MSG_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &t2, -1);
 739
 740                 cmp = (val1 & TNY_MSG_HEADER_FLAG_ATTACHMENTS) -
 741                         (val2 & TNY_MSG_HEADER_FLAG_ATTACHMENTS);
 742
 743                 return cmp ? cmp : t1 - t2;
 744
 745         case MODEST_HEADER_VIEW_COLUMN_MSGTYPE:
 746                 gtk_tree_model_get (tree_model, iter1, TNY_MSG_HEADER_LIST_MODEL_FLAGS_COLUMN, &val1,
 747                                     TNY_MSG_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &t1,-1);
 748                 gtk_tree_model_get (tree_model, iter2, TNY_MSG_HEADER_LIST_MODEL_FLAGS_COLUMN, &val2,
 749                                     TNY_MSG_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &t2,-1);
 750                 cmp =  (val1 & TNY_MSG_HEADER_FLAG_SEEN) - (val2 & TNY_MSG_HEADER_FLAG_SEEN);
 751
 752                 return cmp ? cmp : t1 - t2;
 753
 754         default:
 755                 return &iter1 - &iter2; /* oughhhh  */
 756         }
 757 }
 758
 759
 760 static void
 761 on_refresh_folder (TnyMsgFolderIface *folder, gboolean cancelled, gpointer user_data)
 762 {
 763         GtkTreeModel *oldsortable, *sortable;
 764         ModestHeaderView *self;
 765         ModestHeaderViewPrivate *priv;
 766
 767         if (cancelled)
 768                 return;
 769
 770         self = MODEST_HEADER_VIEW(user_data);
 771         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 772
 773
 774         g_mutex_lock (priv->lock);
 775
 776         if (!folder)  /* when there is no folder */
 777                 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(self), FALSE);
 778
 779         else { /* it's a new one or a refresh */
 780                 GSList *col;
 781
 782                 priv->headers = TNY_LIST_IFACE(tny_msg_header_list_model_new ());
 783
 784                 tny_msg_folder_iface_get_headers (folder, priv->headers, FALSE);
 785                 tny_msg_header_list_model_set_folder (TNY_MSG_HEADER_LIST_MODEL(priv->headers),
 786                                                       folder, TRUE); /* async */
 787
 788                 oldsortable = gtk_tree_view_get_model(GTK_TREE_VIEW (self));
 789                 if (oldsortable && GTK_IS_TREE_MODEL_SORT(oldsortable)) {
 790                         GtkTreeModel *oldmodel = gtk_tree_model_sort_get_model
 791                                 (GTK_TREE_MODEL_SORT(oldsortable));
 792                         if (oldmodel)
 793                                 g_object_unref (G_OBJECT(oldmodel));
 794                         g_object_unref (oldsortable);
 795                 }
 796
 797                 sortable = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL(priv->headers));
 798
 799                 /* install our special sorting functions */
 800                 col = priv->columns;
 801                 while (col) {
 802                         gint col_id = GPOINTER_TO_INT (col->data);
 803                         gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE(sortable), col_id,
 804                                                          (GtkTreeIterCompareFunc)cmp_rows,
 805                                                          GINT_TO_POINTER(col_id), NULL);
 806                         col = col->next;
 807                 }
 808
 809                 gtk_tree_view_set_model (GTK_TREE_VIEW (self), sortable);
 810                 gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW(self), TRUE);
 811                 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(self), TRUE);
 812                 /* no need to unref sortable */
 813         }
 814         g_mutex_unlock (priv->lock);
 815 }
 816
 817
 818 static void
 819 on_refresh_folder_status_update (TnyMsgFolderIface *folder, const gchar *msg,
 820                                  gint status_id,  gpointer user_data)
 821 {
 822         ModestHeaderView *self;
 823         ModestHeaderViewPrivate *priv;
 824
 825         self = MODEST_HEADER_VIEW(user_data);
 826         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 827
 828         g_signal_emit (G_OBJECT(self), signals[STATUS_UPDATE_SIGNAL],
 829                        0, msg, status_id);
 830 }
 831
 832
 833
 834 gboolean
 835 modest_header_view_set_folder (ModestHeaderView *self,
 836                                TnyMsgFolderIface *folder)
 837 {
 838         ModestHeaderViewPrivate *priv;
 839         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 840
 841         g_mutex_lock (priv->lock);
 842
 843         if (!folder)  {/* when there is no folder */
 844                 GtkTreeModel *model;
 845                 model = gtk_tree_view_get_model (GTK_TREE_VIEW(self));
 846                 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(self), FALSE);
 847                 gtk_tree_view_set_model (GTK_TREE_VIEW (self), NULL);
 848                 if (model)
 849                         g_object_unref (model);
 850         } else { /* it's a new one or a refresh */
 851                 tny_msg_folder_iface_refresh_async (folder,
 852                                                     on_refresh_folder,
 853                                                     on_refresh_folder_status_update,
 854                                                     self);
 855         }
 856
 857         /* no message selected */
 858         g_signal_emit (G_OBJECT(self), signals[MESSAGE_SELECTED_SIGNAL], 0,
 859                        NULL);
 860
 861         g_mutex_unlock (priv->lock);
 862
 863         return TRUE;
 864 }
 865
 866
 867
 868 static void
 869 on_selection_changed (GtkTreeSelection *sel, gpointer user_data)
 870 {
 871         GtkTreeModel                   *model;
 872         TnyMsgHeaderIface              *header;
 873         GtkTreeIter                    iter;
 874         ModestHeaderView        *self;
 875         ModestHeaderViewPrivate *priv;
 876
 877         g_return_if_fail (sel);
 878         g_return_if_fail (user_data);
 879
 880         self = MODEST_HEADER_VIEW (user_data);
 881         priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
 882
 883
 884         if (!gtk_tree_selection_get_selected (sel, &model, &iter))
 885                 return; /* msg was _un_selected */
 886
 887         gtk_tree_model_get (model, &iter,
 888                             TNY_MSG_HEADER_LIST_MODEL_INSTANCE_COLUMN,
 889                             &header, -1);
 890
 891         if (header) {
 892                 const TnyMsgIface *msg = NULL;
 893                 const TnyMsgFolderIface *folder;
 894
 895                 folder = tny_msg_header_iface_get_folder (TNY_MSG_HEADER_IFACE(header));
 896                 if (!folder)
 897                         g_printerr ("modest: cannot find folder\n");
 898                 else {
 899                         msg = tny_msg_folder_iface_get_message (TNY_MSG_FOLDER_IFACE(folder),
 900                                                                 header);
 901                         if (!msg) {
 902                                 g_printerr ("modest: cannot find msg\n");
 903                                 gtk_tree_store_remove (GTK_TREE_STORE(model),
 904                                                        &iter);
 905                         }
 906                 }
 907
 908                 g_signal_emit (G_OBJECT(self), signals[MESSAGE_SELECTED_SIGNAL], 0,
 909                                msg);
 910
 911                 /* mark message as seen; _set_flags crashes, bug in tinymail? */
 912                 //flags = tny_msg_header_iface_get_flags (TNY_MSG_HEADER_IFACE(header));
 913                 //tny_msg_header_iface_set_flags (header, TNY_MSG_HEADER_FLAG_SEEN);
 914         }
 915 }