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