git.maemo.org Git - modest/blob - src/widgets/modest-header-view-render.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 <modest-header-view.h>
  31 #include <modest-header-view-priv.h>
  32 #include <modest-icon-names.h>
  33 #include <modest-text-utils.h>
  34 #include <modest-runtime.h>
  35 #include <glib/gi18n.h>
  36 #include <modest-platform.h>
  37
  38 static GdkPixbuf*
  39 get_pixbuf_for_flag (TnyHeaderFlags flag)
  40 {
  41         /* optimization */
  42         static GdkPixbuf *deleted_pixbuf          = NULL;
  43         static GdkPixbuf *seen_pixbuf             = NULL;
  44         static GdkPixbuf *unread_pixbuf           = NULL;
  45         static GdkPixbuf *attachments_pixbuf      = NULL;
  46
  47         switch (flag) {
  48         case TNY_HEADER_FLAG_DELETED:
  49                 if (G_UNLIKELY(!deleted_pixbuf))
  50                         deleted_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_DELETED);
  51                 return deleted_pixbuf;
  52         case TNY_HEADER_FLAG_SEEN:
  53                 if (G_UNLIKELY(!seen_pixbuf))
  54                         seen_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_READ);
  55                 return seen_pixbuf;
  56         case TNY_HEADER_FLAG_ATTACHMENTS:
  57                 if (G_UNLIKELY(!attachments_pixbuf))
  58                         attachments_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_ATTACH);
  59                 return attachments_pixbuf;
  60         default:
  61                 if (G_UNLIKELY(!unread_pixbuf))
  62                         unread_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_UNREAD);
  63                 return unread_pixbuf;
  64         }
  65 }
  66
  67 static GdkPixbuf*
  68 get_pixbuf_for_compact_flag (TnyHeaderFlags flags)
  69 {
  70         /* optimization */
  71         static GdkPixbuf *high_attachments_pixbuf   = NULL;
  72         static GdkPixbuf *normal_attachments_pixbuf = NULL;
  73         static GdkPixbuf *low_attachments_pixbuf    = NULL;
  74         static GdkPixbuf *high_pixbuf               = NULL;
  75         static GdkPixbuf *low_pixbuf                = NULL;
  76         TnyHeaderFlags prior;
  77
  78         prior = flags & TNY_HEADER_FLAG_HIGH_PRIORITY;
  79         switch (prior) {
  80         case TNY_HEADER_FLAG_HIGH_PRIORITY:
  81                 if (flags & TNY_HEADER_FLAG_ATTACHMENTS) {
  82                         if (G_UNLIKELY(!high_attachments_pixbuf))
  83                                 high_attachments_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_ATTACH_HIGH_PRIORITY);
  84                         return high_attachments_pixbuf;
  85                 } else {
  86                         if (G_UNLIKELY(!high_pixbuf))
  87                                 high_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_HIGH_PRIORITY);
  88                         return high_pixbuf;
  89                 }
  90                 break;
  91         case TNY_HEADER_FLAG_LOW_PRIORITY:
  92                 if (flags & TNY_HEADER_FLAG_ATTACHMENTS) {
  93                         if (G_UNLIKELY(!low_attachments_pixbuf))
  94                                 low_attachments_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_ATTACH_LOW_PRIORITY);
  95                         return low_attachments_pixbuf;
  96                 } else {
  97                         if (G_UNLIKELY(!low_pixbuf))
  98                                 low_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_LOW_PRIORITY);
  99                         return low_pixbuf;
 100                 }
 101                 break;
 102         default:
 103                 if (flags & TNY_HEADER_FLAG_ATTACHMENTS) {
 104                         if (G_UNLIKELY(!normal_attachments_pixbuf))
 105                                 normal_attachments_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_ATTACH_NORM_PRIORITY);
 106                         return normal_attachments_pixbuf;
 107                 }
 108         }
 109
 110         return NULL;
 111 }
 112
 113 static void
 114 set_common_flags (GtkCellRenderer *renderer, TnyHeaderFlags flags)
 115 {
 116         g_object_set (G_OBJECT(renderer),
 117                       "weight", (flags & TNY_HEADER_FLAG_SEEN) ? PANGO_WEIGHT_NORMAL: PANGO_WEIGHT_ULTRABOLD,
 118                       "strikethrough",  (flags & TNY_HEADER_FLAG_DELETED) ?  TRUE:FALSE,
 119                       NULL);
 120 }
 121
 122
 123 void
 124 _modest_header_view_msgtype_cell_data (GtkTreeViewColumn *column, GtkCellRenderer *renderer,
 125                    GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer user_data)
 126 {
 127         TnyHeaderFlags flags;
 128
 129         gtk_tree_model_get (tree_model, iter, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 130                             &flags, -1);
 131
 132         if (flags & TNY_HEADER_FLAG_DELETED)
 133                 g_object_set (G_OBJECT (renderer), "pixbuf",
 134                               get_pixbuf_for_flag (TNY_HEADER_FLAG_DELETED), NULL);
 135         else if (flags & TNY_HEADER_FLAG_SEEN)
 136                 g_object_set (G_OBJECT (renderer), "pixbuf",
 137                               get_pixbuf_for_flag (TNY_HEADER_FLAG_SEEN), NULL);
 138         else
 139                 g_object_set (G_OBJECT (renderer), "pixbuf",
 140                               get_pixbuf_for_flag (0), NULL); /* ughh, FIXME */
 141 }
 142
 143 void
 144 _modest_header_view_attach_cell_data (GtkTreeViewColumn *column, GtkCellRenderer *renderer,
 145                                       GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer user_data)
 146 {
 147         TnyHeaderFlags flags;
 148
 149         gtk_tree_model_get (tree_model, iter, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 150                             &flags, -1);
 151
 152         if (flags & TNY_HEADER_FLAG_ATTACHMENTS)
 153                 g_object_set (G_OBJECT (renderer), "pixbuf",
 154                               get_pixbuf_for_flag (TNY_HEADER_FLAG_ATTACHMENTS),
 155                               NULL);
 156 }
 157
 158 void
 159 _modest_header_view_compact_flag_cell_data (GtkTreeViewColumn *column, GtkCellRenderer *renderer,
 160                                             GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer user_data)
 161 {
 162         TnyHeaderFlags flags;
 163         GdkPixbuf* pixbuf = NULL;
 164
 165         gtk_tree_model_get (tree_model, iter, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 166                             &flags, -1);
 167
 168         pixbuf = get_pixbuf_for_compact_flag (flags);
 169         if (pixbuf != NULL)
 170                 g_object_set (G_OBJECT (renderer), "pixbuf", pixbuf, NULL);
 171
 172 }
 173
 174 void
 175 _modest_header_view_header_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 176                   GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer user_data)
 177 {
 178         TnyHeaderFlags flags;
 179
 180         gtk_tree_model_get (tree_model, iter, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 181                             &flags, -1);
 182         set_common_flags (renderer, flags);
 183 }
 184
 185
 186 void
 187 _modest_header_view_date_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 188                                      GtkTreeModel *tree_model,  GtkTreeIter *iter,
 189                                      gpointer user_data)
 190 {
 191         TnyHeaderFlags flags;
 192         guint date, date_col;
 193         gchar *display_date = NULL;
 194         gboolean received = GPOINTER_TO_INT(user_data);
 195
 196         if (received)
 197                 date_col = TNY_GTK_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN;
 198         else
 199                 date_col = TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN;
 200
 201         gtk_tree_model_get (tree_model, iter,
 202                             TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 203                             date_col, &date,
 204                             -1);
 205
 206         display_date = modest_text_utils_get_display_date (date);
 207         g_object_set (G_OBJECT(renderer), "text", display_date, NULL);
 208
 209         set_common_flags (renderer, flags);
 210         g_free (display_date);
 211 }
 212
 213 void
 214 _modest_header_view_compact_date_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 215                                              GtkTreeModel *tree_model,  GtkTreeIter *iter,
 216                                              gpointer user_data)
 217 {
 218         TnyHeaderFlags flags;
 219         guint date, date_col;
 220         gchar *display_date = NULL, *tmp_date = NULL;
 221         gboolean received = GPOINTER_TO_INT(user_data);
 222
 223         if (received)
 224                 date_col = TNY_GTK_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN;
 225         else
 226                 date_col = TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN;
 227
 228         gtk_tree_model_get (tree_model, iter,
 229                             TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 230                             date_col, &date,
 231                             -1);
 232
 233         tmp_date = modest_text_utils_get_display_date (date);
 234         display_date = g_strdup_printf ("\n<small>%s</small>", tmp_date);
 235         g_object_set (G_OBJECT(renderer), "markup", display_date, NULL);
 236
 237         set_common_flags (renderer, flags);
 238         g_free (tmp_date);
 239         g_free (display_date);
 240 }
 241
 242 void
 243 _modest_header_view_sender_receiver_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 244                             GtkTreeModel *tree_model,  GtkTreeIter *iter,  gboolean is_sender)
 245 {
 246         TnyHeaderFlags flags;
 247         gchar *address;
 248         gint sender_receiver_col;
 249
 250         if (is_sender)
 251                 sender_receiver_col = TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN;
 252         else
 253                 sender_receiver_col = TNY_GTK_HEADER_LIST_MODEL_TO_COLUMN;
 254
 255         gtk_tree_model_get (tree_model, iter,
 256                             sender_receiver_col,  &address,
 257                             TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 258                             -1);
 259
 260         g_object_set (G_OBJECT(renderer),
 261                       "text",
 262                       modest_text_utils_get_display_address (address),
 263                       NULL);
 264         g_free (address);
 265         set_common_flags (renderer, flags);
 266 }
 267 /*
 268  * this for both incoming and outgoing mail, depending on the the user_data
 269  * parameter. in the incoming case, show 'From' and 'Received date', in the
 270  * outgoing case, show 'To' and 'Sent date'
 271  */
 272 void
 273 _modest_header_view_compact_header_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 274                                                GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer user_data)
 275 {
 276         GObject *rendobj;
 277         TnyHeaderFlags flags;
 278         gchar *address, *subject, *header, *display_address;
 279         gchar *parsed_address, *parsed_subject;
 280         time_t date;
 281         gboolean is_incoming;
 282
 283         is_incoming = GPOINTER_TO_INT(user_data); /* GPOINTER_TO_BOOLEAN is not available
 284                                                    * in older versions of glib...*/
 285
 286         if (is_incoming)
 287                 gtk_tree_model_get (tree_model, iter,
 288                                     TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 289                                     TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN,  &address,
 290                                     TNY_GTK_HEADER_LIST_MODEL_SUBJECT_COLUMN, &subject,
 291                                     TNY_GTK_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN, &date,
 292                                     -1);
 293         else
 294                 gtk_tree_model_get (tree_model, iter,
 295                                     TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 296                                     TNY_GTK_HEADER_LIST_MODEL_TO_COLUMN,  &address,
 297                                     TNY_GTK_HEADER_LIST_MODEL_SUBJECT_COLUMN, &subject,
 298                                     TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &date,
 299                                     -1);
 300
 301         rendobj = G_OBJECT(renderer);
 302
 303         /* deal with empty subjects */
 304         if (!subject)
 305                 subject = g_strdup (_("mail_va_no_subject"));
 306
 307         /* Escape special characteres to allow pango makup`*/
 308         display_address = modest_text_utils_get_display_address (address);
 309         parsed_address = modest_text_utils_convert_to_pango (display_address);
 310         //_pango_parse_string (display_address);
 311         parsed_subject = modest_text_utils_convert_to_pango (subject);
 312         //_pango_parse_string (subject);
 313
 314         header = g_strdup_printf ("%s\n<small>%s</small>",
 315                                   parsed_subject,
 316                                   parsed_address);
 317         g_free (address);
 318         g_free (subject);
 319         g_free(parsed_subject);
 320         g_free(parsed_address);
 321
 322         g_object_set (rendobj, "markup", header, NULL);
 323         set_common_flags (renderer, flags);
 324
 325         g_free (header);
 326 }
 327
 328
 329 void
 330 _modest_header_view_size_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 331                                      GtkTreeModel *tree_model,  GtkTreeIter *iter,
 332                                      gpointer user_data)
 333 {
 334         TnyHeaderFlags flags;
 335         guint size;
 336         gchar *size_str;
 337
 338         gtk_tree_model_get (tree_model, iter,
 339                            TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 340                            TNY_GTK_HEADER_LIST_MODEL_MESSAGE_SIZE_COLUMN, &size,
 341                             -1);
 342
 343         size_str = modest_text_utils_get_display_size (size);
 344
 345         g_object_set (G_OBJECT(renderer), "text", size_str, NULL);
 346         set_common_flags (renderer, flags);
 347
 348         g_free (size_str);
 349  }
 350
 351 void
 352 _modest_header_view_status_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 353                                      GtkTreeModel *tree_model,  GtkTreeIter *iter,
 354                                      gpointer user_data)
 355 {
 356         TnyHeaderFlags flags;
 357         guint status;
 358         gchar *status_str;
 359
 360         gtk_tree_model_get (tree_model, iter,
 361                            TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 362                            TNY_GTK_HEADER_LIST_MODEL_MESSAGE_SIZE_COLUMN, &status,
 363                             -1);
 364
 365 /*      size_str = modest_text_utils_get_display_size (size); */
 366         status_str = g_strdup(_("mcen_li_outbox_waiting"));
 367
 368         g_object_set (G_OBJECT(renderer), "text", status_str, NULL);
 369         set_common_flags (renderer, flags);
 370
 371         g_free (status_str);
 372  }
 373