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
  37 static GdkPixbuf*
  38 get_cached_icon (const gchar *name)
  39 {
  40         GError *err = NULL;
  41         gpointer pixbuf;
  42         gpointer orig_key;
  43         static GHashTable *icon_cache = NULL;
  44
  45         g_return_val_if_fail (name, NULL);
  46
  47         if (G_UNLIKELY(!icon_cache))
  48                 icon_cache = modest_cache_mgr_get_cache (modest_runtime_get_cache_mgr(),
  49                                                          MODEST_CACHE_MGR_CACHE_TYPE_PIXBUF);
  50
  51         if (!icon_cache || !g_hash_table_lookup_extended (icon_cache, name, &orig_key,&pixbuf)) {
  52                 pixbuf = (gpointer)gdk_pixbuf_new_from_file (name, &err);
  53                 if (!pixbuf) {
  54                         g_printerr ("modest: error while loading '%s': %s\n",
  55                                     name, err->message);
  56                         g_error_free (err);
  57                 }
  58                 /* if we cannot find it, we still insert (if we have a cache), so we get the error
  59                  * only once */
  60                 if (icon_cache)
  61                         g_hash_table_insert (icon_cache, g_strdup(name),(gpointer)pixbuf);
  62         }
  63         return GDK_PIXBUF(pixbuf);
  64 }
  65
  66
  67
  68 /*
  69  * optimization
  70  */
  71 static GdkPixbuf*
  72 get_pixbuf_for_flag (TnyHeaderFlags flag)
  73 {
  74         /* optimization */
  75         static GdkPixbuf *deleted_pixbuf       = NULL;
  76         static GdkPixbuf *seen_pixbuf          = NULL;
  77         static GdkPixbuf *unread_pixbuf        = NULL;
  78         static GdkPixbuf *attachments_pixbuf   = NULL;
  79
  80         switch (flag) {
  81         case TNY_HEADER_FLAG_DELETED:
  82                 if (G_UNLIKELY(!deleted_pixbuf))
  83                         deleted_pixbuf = get_cached_icon (MODEST_HEADER_ICON_DELETED);
  84                 return deleted_pixbuf;
  85         case TNY_HEADER_FLAG_SEEN:
  86                 if (G_UNLIKELY(!seen_pixbuf))
  87                         seen_pixbuf = get_cached_icon (MODEST_HEADER_ICON_READ);
  88                 return seen_pixbuf;
  89         case TNY_HEADER_FLAG_ATTACHMENTS:
  90                 if (G_UNLIKELY(!attachments_pixbuf))
  91                         attachments_pixbuf = get_cached_icon (MODEST_HEADER_ICON_ATTACH);
  92                 return attachments_pixbuf;
  93         default:
  94                 if (G_UNLIKELY(!unread_pixbuf))
  95                         unread_pixbuf = get_cached_icon (MODEST_HEADER_ICON_UNREAD);
  96                 return unread_pixbuf;
  97         }
  98 }
  99
 100
 101 void
 102 _modest_header_view_msgtype_cell_data (GtkTreeViewColumn *column, GtkCellRenderer *renderer,
 103                    GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer user_data)
 104 {
 105         TnyHeaderFlags flags;
 106
 107         gtk_tree_model_get (tree_model, iter, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 108                             &flags, -1);
 109
 110         if (flags & TNY_HEADER_FLAG_DELETED)
 111                 g_object_set (G_OBJECT (renderer), "pixbuf",
 112                               get_pixbuf_for_flag (TNY_HEADER_FLAG_DELETED), NULL);
 113         else if (flags & TNY_HEADER_FLAG_SEEN)
 114                 g_object_set (G_OBJECT (renderer), "pixbuf",
 115                               get_pixbuf_for_flag (TNY_HEADER_FLAG_SEEN), NULL);
 116         else
 117                 g_object_set (G_OBJECT (renderer), "pixbuf",
 118                               get_pixbuf_for_flag (0), NULL); /* ughh, FIXME */
 119 }
 120
 121 void
 122 _modest_header_view_attach_cell_data (GtkTreeViewColumn *column, GtkCellRenderer *renderer,
 123                                       GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer user_data)
 124 {
 125         TnyHeaderFlags flags;
 126
 127         gtk_tree_model_get (tree_model, iter, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 128                             &flags, -1);
 129
 130         if (flags & TNY_HEADER_FLAG_ATTACHMENTS)
 131                 g_object_set (G_OBJECT (renderer), "pixbuf",
 132                               get_pixbuf_for_flag (TNY_HEADER_FLAG_ATTACHMENTS),
 133                               NULL);
 134 }
 135
 136 void
 137 _modest_header_view_header_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 138                   GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer user_data)
 139 {
 140         TnyHeaderFlags flags;
 141
 142         gtk_tree_model_get (tree_model, iter, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 143                             &flags, -1);
 144
 145         g_object_set (G_OBJECT(renderer),
 146                       "weight", (flags & TNY_HEADER_FLAG_SEEN) ? 400: 800,
 147                       "strikethrough",  (flags & TNY_HEADER_FLAG_DELETED) ?  TRUE:FALSE,
 148                       NULL);
 149 }
 150
 151
 152 void
 153 _modest_header_view_date_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 154                                      GtkTreeModel *tree_model,  GtkTreeIter *iter,
 155                                      gpointer user_data)
 156 {
 157         TnyHeaderFlags flags;
 158         guint date, date_col;
 159         gchar *display_date;
 160         gboolean received = GPOINTER_TO_INT(user_data);
 161
 162         if (received)
 163                 date_col = TNY_GTK_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN;
 164         else
 165                 date_col = TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN;
 166
 167         gtk_tree_model_get (tree_model, iter,
 168                             TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 169                             date_col, &date,
 170                             -1);
 171
 172         display_date = modest_text_utils_get_display_date (date);
 173         g_object_set (G_OBJECT(renderer),
 174                       "weight", (flags & TNY_HEADER_FLAG_SEEN) ? 400: 800,
 175                       "strikethrough",  (flags & TNY_HEADER_FLAG_DELETED) ? TRUE:FALSE,
 176                       "text",    display_date,
 177                       NULL);
 178         g_free (display_date);
 179 }
 180
 181
 182 void
 183 _modest_header_view_sender_receiver_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 184                             GtkTreeModel *tree_model,  GtkTreeIter *iter,  gboolean is_sender)
 185 {
 186         TnyHeaderFlags flags;
 187         gchar *address;
 188         gint sender_receiver_col;
 189
 190         if (is_sender)
 191                 sender_receiver_col = TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN;
 192         else
 193                 sender_receiver_col = TNY_GTK_HEADER_LIST_MODEL_TO_COLUMN;
 194
 195         gtk_tree_model_get (tree_model, iter,
 196                             sender_receiver_col,  &address,
 197                             TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 198                             -1);
 199
 200         g_object_set (G_OBJECT(renderer),
 201                       "text",
 202                       modest_text_utils_get_display_address (address),
 203                       "weight",
 204                       (flags & TNY_HEADER_FLAG_SEEN) ? 400 : 800,
 205                       "striketrough",
 206                       (flags & TNY_HEADER_FLAG_DELETED)?TRUE:FALSE,
 207                       NULL);
 208
 209         g_free (address);
 210 }
 211 /*
 212  * this for both incoming and outgoing mail, depending on the the user_data
 213  * parameter. in the incoming case, show 'From' and 'Received date', in the
 214  * outgoing case, show 'To' and 'Sent date'
 215  */
 216 void
 217 _modest_header_view_compact_header_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 218                                                GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer user_data)
 219 {
 220         GObject *rendobj;
 221         TnyHeaderFlags flags;
 222         gchar *address, *subject, *header, *display_date;
 223         time_t date;
 224         gboolean is_incoming;
 225
 226         is_incoming = GPOINTER_TO_INT(user_data); /* GPOINTER_TO_BOOLEAN is not available
 227                                                    * in older versions of glib...*/
 228
 229         if (is_incoming)
 230                 gtk_tree_model_get (tree_model, iter,
 231                                     TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 232                                     TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN,  &address,
 233                                     TNY_GTK_HEADER_LIST_MODEL_SUBJECT_COLUMN, &subject,
 234                                     TNY_GTK_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN, &date,
 235                                     -1);
 236         else
 237                 gtk_tree_model_get (tree_model, iter,
 238                                     TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 239                                     TNY_GTK_HEADER_LIST_MODEL_TO_COLUMN,  &address,
 240                                     TNY_GTK_HEADER_LIST_MODEL_SUBJECT_COLUMN, &subject,
 241                                     TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &date,
 242                                     -1);
 243
 244         rendobj = G_OBJECT(renderer);
 245         display_date = modest_text_utils_get_display_date (date);
 246         header = g_strdup_printf ("%s %s\n%s",
 247                                   modest_text_utils_get_display_address (address),
 248                                   display_date, subject);
 249         g_free (address);
 250         g_free (subject);
 251         g_free (display_date);
 252
 253         g_object_set (G_OBJECT(renderer),
 254                       "text",  header,
 255                       "weight", (flags & TNY_HEADER_FLAG_SEEN) ? 400: 800,
 256                       "strikethrough",  (flags & TNY_HEADER_FLAG_DELETED) ? TRUE: FALSE,
 257                       NULL);
 258         g_free (header);
 259 }
 260
 261
 262 void
 263 _modest_header_view_size_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 264                                      GtkTreeModel *tree_model,  GtkTreeIter *iter,
 265                                      gpointer user_data)
 266 {
 267         TnyHeaderFlags flags;
 268         guint size;
 269         gchar *size_str;
 270
 271         gtk_tree_model_get (tree_model, iter,
 272                            TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 273                            TNY_GTK_HEADER_LIST_MODEL_MESSAGE_SIZE_COLUMN, &size,
 274                             -1);
 275
 276         size_str = modest_text_utils_get_display_size (size);
 277
 278         g_object_set (G_OBJECT(renderer),
 279                       "weight", (flags & TNY_HEADER_FLAG_SEEN) ? 400: 800,
 280                       "striketrough",  (flags & TNY_HEADER_FLAG_DELETED) ? TRUE:FALSE,
 281                       "text",    size_str,
 282                       NULL);
 283        g_free (size_str);
 284
 285  }