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 <tny-simple-list.h>
  31 #include <modest-header-view.h>
  32 #include <modest-header-view-priv.h>
  33 #include <modest-icon-names.h>
  34 #include <modest-text-utils.h>
  35 #include <modest-tny-account-store.h>
  36 #include <modest-tny-send-queue.h>
  37 #include <modest-tny-folder.h>
  38 #include <modest-tny-account.h>
  39 #include <modest-runtime.h>
  40 #include <glib/gi18n.h>
  41 #include <modest-platform.h>
  42 #include <string.h>
  43
  44
  45 static const gchar *
  46 get_status_string (ModestTnySendQueueStatus status)
  47 {
  48         switch (status) {
  49         case MODEST_TNY_SEND_QUEUE_WAITING:
  50                 return _("mcen_li_outbox_waiting");
  51                 break;
  52         case MODEST_TNY_SEND_QUEUE_SENDING:
  53                 return _("mcen_li_outbox_sending");
  54                 break;
  55         case MODEST_TNY_SEND_QUEUE_SUSPENDED:
  56                 return _("mcen_li_outbox_suspended");
  57                 break;
  58         case MODEST_TNY_SEND_QUEUE_FAILED:
  59                 return _("mcen_li_outbox_failed");
  60                 break;
  61         default:
  62                 return "";
  63                 break;
  64         }
  65 }
  66
  67 static GdkPixbuf*
  68 get_pixbuf_for_flag (TnyHeaderFlags flag)
  69 {
  70         /* optimization */
  71         static GdkPixbuf *deleted_pixbuf          = NULL;
  72         static GdkPixbuf *seen_pixbuf             = NULL;
  73         static GdkPixbuf *unread_pixbuf           = NULL;
  74         static GdkPixbuf *attachments_pixbuf      = NULL;
  75         static GdkPixbuf *high_pixbuf             = NULL;
  76         static GdkPixbuf *low_pixbuf             = NULL;
  77
  78         switch (flag) {
  79         case TNY_HEADER_FLAG_DELETED:
  80                 if (G_UNLIKELY(!deleted_pixbuf))
  81                         deleted_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_DELETED);
  82                 return deleted_pixbuf;
  83         case TNY_HEADER_FLAG_SEEN:
  84                 if (G_UNLIKELY(!seen_pixbuf))
  85                         seen_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_READ);
  86                 return seen_pixbuf;
  87         case TNY_HEADER_FLAG_ATTACHMENTS:
  88                 if (G_UNLIKELY(!attachments_pixbuf))
  89                         attachments_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_ATTACH);
  90                 return attachments_pixbuf;
  91         case TNY_HEADER_FLAG_HIGH_PRIORITY:
  92                 if (G_UNLIKELY(!high_pixbuf))
  93                         high_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_HIGH);
  94                 return high_pixbuf;
  95         case TNY_HEADER_FLAG_LOW_PRIORITY:
  96                 if (G_UNLIKELY(!low_pixbuf))
  97                         low_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_LOW);
  98                 return low_pixbuf;
  99         case TNY_HEADER_FLAG_NORMAL_PRIORITY:
 100                 return NULL;
 101         default:
 102                 if (G_UNLIKELY(!unread_pixbuf))
 103                         unread_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_UNREAD);
 104                 return unread_pixbuf;
 105         }
 106 }
 107
 108 static void
 109 set_common_flags (GtkCellRenderer *renderer, TnyHeaderFlags flags)
 110 {
 111         g_object_set (G_OBJECT(renderer),
 112                       "weight", (flags & TNY_HEADER_FLAG_SEEN) ? PANGO_WEIGHT_NORMAL: PANGO_WEIGHT_ULTRABOLD,
 113                       "strikethrough",  (flags & TNY_HEADER_FLAG_DELETED) ?  TRUE:FALSE,
 114                       NULL);
 115 }
 116
 117
 118 void
 119 _modest_header_view_msgtype_cell_data (GtkTreeViewColumn *column, GtkCellRenderer *renderer,
 120                    GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer user_data)
 121 {
 122         TnyHeaderFlags flags;
 123
 124         gtk_tree_model_get (tree_model, iter, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 125                             &flags, -1);
 126
 127         if (flags & TNY_HEADER_FLAG_DELETED)
 128                 g_object_set (G_OBJECT (renderer), "pixbuf",
 129                               get_pixbuf_for_flag (TNY_HEADER_FLAG_DELETED), NULL);
 130         else if (flags & TNY_HEADER_FLAG_SEEN)
 131                 g_object_set (G_OBJECT (renderer), "pixbuf",
 132                               get_pixbuf_for_flag (TNY_HEADER_FLAG_SEEN), NULL);
 133         else
 134                 g_object_set (G_OBJECT (renderer), "pixbuf",
 135                               get_pixbuf_for_flag (0), NULL); /* ughh, FIXME */
 136 }
 137
 138 void
 139 _modest_header_view_attach_cell_data (GtkTreeViewColumn *column, GtkCellRenderer *renderer,
 140                                       GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer user_data)
 141 {
 142         TnyHeaderFlags flags;
 143
 144         gtk_tree_model_get (tree_model, iter, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 145                             &flags, -1);
 146
 147         if (flags & TNY_HEADER_FLAG_ATTACHMENTS)
 148                 g_object_set (G_OBJECT (renderer), "pixbuf",
 149                               get_pixbuf_for_flag (TNY_HEADER_FLAG_ATTACHMENTS),
 150                               NULL);
 151 }
 152
 153 void
 154 _modest_header_view_header_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 155                   GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer user_data)
 156 {
 157         TnyHeaderFlags flags;
 158
 159         gtk_tree_model_get (tree_model, iter, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 160                             &flags, -1);
 161         set_common_flags (renderer, flags);
 162 }
 163
 164
 165 void
 166 _modest_header_view_date_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 167                                      GtkTreeModel *tree_model,  GtkTreeIter *iter,
 168                                      gpointer user_data)
 169 {
 170         TnyHeaderFlags flags;
 171         guint date, date_col;
 172         gboolean received = GPOINTER_TO_INT(user_data);
 173
 174         if (received)
 175                 date_col = TNY_GTK_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN;
 176         else
 177                 date_col = TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN;
 178
 179         gtk_tree_model_get (tree_model, iter,
 180                             TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 181                             date_col, &date,
 182                             -1);
 183
 184         g_object_set (G_OBJECT(renderer), "text", modest_text_utils_get_display_date (date),
 185                       NULL);
 186
 187         set_common_flags (renderer, flags);
 188 }
 189
 190 void
 191 _modest_header_view_sender_receiver_cell_data  (GtkTreeViewColumn *column,
 192                                                 GtkCellRenderer *renderer,
 193                                                 GtkTreeModel *tree_model,
 194                                                 GtkTreeIter *iter,
 195                                                 gboolean is_sender)
 196 {
 197         TnyHeaderFlags flags;
 198         gchar *address;
 199         gint sender_receiver_col;
 200
 201         if (is_sender)
 202                 sender_receiver_col = TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN;
 203         else
 204                 sender_receiver_col = TNY_GTK_HEADER_LIST_MODEL_TO_COLUMN;
 205
 206         gtk_tree_model_get (tree_model, iter,
 207                             sender_receiver_col,  &address,
 208                             TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 209                             -1);
 210
 211         modest_text_utils_get_display_address (address); /* string is changed in-place */
 212         g_object_set (G_OBJECT(renderer),
 213                       "text",
 214                       address,
 215                       NULL);
 216         g_free (address);
 217
 218         set_common_flags (renderer, flags);
 219 }
 220 /*
 221  * this for both incoming and outgoing mail, depending on the the user_data
 222  * parameter. in the incoming case, show 'From' and 'Received date', in the
 223  * outgoing case, show 'To' and 'Sent date'
 224  */
 225 void
 226 _modest_header_view_compact_header_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 227                                                GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer user_data)
 228 {
 229         /* Note that GtkTreeModel is a GtkTreeModelFilter. */
 230
 231         /* printf ("DEBUG: %s: tree_model gtype=%s\n", __FUNCTION__, G_OBJECT_TYPE_NAME (tree_model)); */
 232
 233         TnyHeaderFlags flags = 0;
 234         gchar *address = NULL;
 235         gchar *subject = NULL;
 236         gchar *header = NULL;
 237         time_t date;
 238
 239         GtkCellRenderer *recipient_cell, *date_or_status_cell, *subject_cell,
 240                 *attach_cell, *priority_cell,
 241                 *recipient_box, *subject_box = NULL;
 242         TnyHeader *msg_header = NULL;
 243         gchar *display_date = NULL, *tmp_date = NULL;
 244         TnyHeaderFlags prio = 0;
 245
 246
 247         g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
 248         g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
 249         g_return_if_fail (GTK_IS_TREE_MODEL (tree_model));
 250
 251         recipient_box = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (renderer), "recpt-box-renderer"));
 252         subject_box = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (renderer), "subject-box-renderer"));
 253         priority_cell = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (subject_box), "priority-renderer"));
 254         subject_cell = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (subject_box), "subject-renderer"));
 255         attach_cell = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (recipient_box), "attach-renderer"));
 256         recipient_cell = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (recipient_box), "recipient-renderer"));
 257         date_or_status_cell = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (recipient_box), "date-renderer"));
 258
 259         ModestHeaderViewCompactHeaderMode header_mode = GPOINTER_TO_INT (user_data);
 260
 261         if (header_mode == MODEST_HEADER_VIEW_COMPACT_HEADER_MODE_IN)
 262                 gtk_tree_model_get (tree_model, iter,
 263                                     TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 264                                     TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN,  &address,
 265                                     TNY_GTK_HEADER_LIST_MODEL_SUBJECT_COLUMN, &subject,
 266                                     TNY_GTK_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN, &date,
 267                                     TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, &msg_header,
 268                                     -1);
 269         else
 270                 gtk_tree_model_get (tree_model, iter,
 271                                     TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 272                                     TNY_GTK_HEADER_LIST_MODEL_TO_COLUMN,  &address,
 273                                     TNY_GTK_HEADER_LIST_MODEL_SUBJECT_COLUMN, &subject,
 274                                     TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &date,
 275                                     TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, &msg_header,
 276                                     -1);
 277         /* flags */
 278         /* FIXME: we might gain something by doing all the g_object_set's at once */
 279         if (flags & TNY_HEADER_FLAG_ATTACHMENTS)
 280                 g_object_set (G_OBJECT (attach_cell), "pixbuf",
 281                               get_pixbuf_for_flag (TNY_HEADER_FLAG_ATTACHMENTS),
 282                               NULL);
 283         else
 284                 g_object_set (G_OBJECT (attach_cell), "pixbuf",
 285                               NULL, NULL);
 286
 287         if (msg_header)
 288                 prio = tny_header_get_priority (msg_header);
 289         g_object_set (G_OBJECT (priority_cell), "pixbuf",
 290                       get_pixbuf_for_flag (prio),
 291                       NULL);
 292
 293         if (subject && strlen (subject)) {
 294                 gchar* escaped_subject = g_markup_escape_text (subject, -1);
 295                 g_object_set (G_OBJECT (subject_cell), "markup",
 296                               escaped_subject, NULL);
 297                 g_free (escaped_subject);
 298         } else {
 299                 g_object_set (G_OBJECT (subject_cell), "markup",
 300                               _("mail_va_no_subject"), NULL);
 301         }
 302
 303         g_free (subject);
 304         set_common_flags (subject_cell, flags);
 305
 306         /* FIXME: we hardcode the color to #666666; instead we should use SecondaryTextColour from the
 307          * theme (gtkrc file) */
 308         modest_text_utils_get_display_address (address); /* changed in-place */
 309         header = g_markup_printf_escaped ("<span size='small' foreground='#666666'>%s</span>",
 310                                           address);
 311         g_free (address);
 312         g_object_set (G_OBJECT (recipient_cell),
 313                       "markup", header,
 314                       NULL);
 315         g_free (header);
 316         header = NULL;
 317         set_common_flags (recipient_cell, flags);
 318
 319         if (header_mode == MODEST_HEADER_VIEW_COMPACT_HEADER_MODE_OUTBOX) {
 320                 ModestTnySendQueueStatus status = MODEST_TNY_SEND_QUEUE_UNKNOWN;
 321                 const gchar *status_str = "";
 322                 if (msg_header != NULL) {
 323                         status = modest_tny_all_send_queues_get_msg_status (msg_header);
 324                         if (status == MODEST_TNY_SEND_QUEUE_SUSPENDED) {
 325                                 tny_header_set_flag (msg_header, TNY_HEADER_FLAG_SUSPENDED);
 326                         }
 327                 }
 328
 329                 status_str = get_status_string (status);
 330                 display_date = g_strdup_printf("<span size='small' foreground='#666666'>%s</span>", status_str);
 331                 g_object_set (G_OBJECT (date_or_status_cell),
 332                               "markup", display_date,
 333                               NULL);
 334                 g_free (display_date);
 335                 display_date = NULL;
 336         } else {
 337                 display_date = g_strdup_printf ("<span size='small' foreground='#666666'>%s</span>",
 338                                                 date ? modest_text_utils_get_display_date (date) : "");
 339                 g_object_set (G_OBJECT (date_or_status_cell),
 340                               "markup", display_date,
 341                               NULL);
 342                 g_free (tmp_date);
 343                 tmp_date = NULL;
 344                 g_free (display_date);
 345                 display_date = NULL;
 346         }
 347
 348         if (msg_header != NULL)
 349                 g_object_unref (msg_header);
 350
 351         set_common_flags (date_or_status_cell, flags);
 352 }
 353
 354
 355 void
 356 _modest_header_view_size_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 357                                      GtkTreeModel *tree_model,  GtkTreeIter *iter,
 358                                      gpointer user_data)
 359 {
 360         TnyHeaderFlags flags;
 361         guint size;
 362         gchar *size_str;
 363
 364         gtk_tree_model_get (tree_model, iter,
 365                            TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 366                            TNY_GTK_HEADER_LIST_MODEL_MESSAGE_SIZE_COLUMN, &size,
 367                             -1);
 368
 369         size_str = modest_text_utils_get_display_size (size);
 370
 371         g_object_set (G_OBJECT(renderer), "text", size_str, NULL);
 372         set_common_flags (renderer, flags);
 373
 374         g_free (size_str);
 375  }
 376
 377 void
 378 _modest_header_view_status_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 379                                        GtkTreeModel *tree_model,  GtkTreeIter *iter,
 380                                        gpointer user_data)
 381 {
 382         TnyHeaderFlags flags;
 383         //guint status;
 384         gchar *status_str;
 385
 386         gtk_tree_model_get (tree_model, iter,
 387                             TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 388                             -1);
 389
 390        if (flags & TNY_HEADER_FLAG_SUSPENDED)
 391                status_str = g_strdup(_("mcen_li_outbox_suspended"));
 392        else
 393                status_str = g_strdup(_("mcen_li_outbox_waiting"));
 394
 395         g_object_set (G_OBJECT(renderer), "text", status_str, NULL);
 396         set_common_flags (renderer, flags);
 397
 398         g_free (status_str);
 399  }
 400