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