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 #ifdef MODEST_TOOLKIT_HILDON2
  46 #define SMALL_ICON_SIZE MODEST_ICON_SIZE_SMALL
  47 #else
  48 #define SMALL_ICON_SIZE MODEST_ICON_SIZE_SMALL
  49 #endif
  50
  51 static const gchar *
  52 get_status_string (ModestTnySendQueueStatus status)
  53 {
  54         switch (status) {
  55         case MODEST_TNY_SEND_QUEUE_WAITING:
  56                 return _("mcen_li_outbox_waiting");
  57                 break;
  58         case MODEST_TNY_SEND_QUEUE_SENDING:
  59                 return _("mcen_li_outbox_sending");
  60                 break;
  61         case MODEST_TNY_SEND_QUEUE_SUSPENDED:
  62                 return _("mcen_li_outbox_suspended");
  63                 break;
  64         case MODEST_TNY_SEND_QUEUE_FAILED:
  65                 return _("mcen_li_outbox_failed");
  66                 break;
  67         default:
  68                 return "";
  69                 break;
  70         }
  71 }
  72
  73 static GdkPixbuf*
  74 get_pixbuf_for_flag (TnyHeaderFlags flag)
  75 {
  76         /* optimization */
  77         static GdkPixbuf *deleted_pixbuf          = NULL;
  78         static GdkPixbuf *seen_pixbuf             = NULL;
  79         static GdkPixbuf *unread_pixbuf           = NULL;
  80         static GdkPixbuf *attachments_pixbuf      = NULL;
  81         static GdkPixbuf *high_pixbuf             = NULL;
  82         static GdkPixbuf *low_pixbuf             = NULL;
  83
  84         switch (flag) {
  85         case TNY_HEADER_FLAG_DELETED:
  86                 if (G_UNLIKELY(!deleted_pixbuf))
  87                         deleted_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_DELETED,
  88                                                                    SMALL_ICON_SIZE);
  89                 return deleted_pixbuf;
  90         case TNY_HEADER_FLAG_SEEN:
  91                 if (G_UNLIKELY(!seen_pixbuf))
  92                         seen_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_READ,
  93                                                                 SMALL_ICON_SIZE);
  94                 return seen_pixbuf;
  95         case TNY_HEADER_FLAG_ATTACHMENTS:
  96                 if (G_UNLIKELY(!attachments_pixbuf))
  97                         attachments_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_ATTACH,
  98                                                                        SMALL_ICON_SIZE);
  99                 return attachments_pixbuf;
 100         case TNY_HEADER_FLAG_HIGH_PRIORITY:
 101                 if (G_UNLIKELY(!high_pixbuf))
 102                         high_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_HIGH,
 103                                                                 SMALL_ICON_SIZE);
 104                 return high_pixbuf;
 105         case TNY_HEADER_FLAG_LOW_PRIORITY:
 106                 if (G_UNLIKELY(!low_pixbuf))
 107                         low_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_LOW,
 108                                                                SMALL_ICON_SIZE);
 109                 return low_pixbuf;
 110         case TNY_HEADER_FLAG_NORMAL_PRIORITY:
 111                 return NULL;
 112         default:
 113                 if (G_UNLIKELY(!unread_pixbuf))
 114                         unread_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_UNREAD,
 115                                                                   SMALL_ICON_SIZE);
 116                 return unread_pixbuf;
 117         }
 118 }
 119
 120 static void
 121 set_common_flags (GtkCellRenderer *renderer, TnyHeaderFlags flags)
 122 {
 123         g_object_set (G_OBJECT(renderer),
 124                       "weight", (flags & TNY_HEADER_FLAG_SEEN) ? PANGO_WEIGHT_NORMAL: PANGO_WEIGHT_ULTRABOLD,
 125                       "strikethrough",  (flags & TNY_HEADER_FLAG_DELETED) ?  TRUE:FALSE,
 126                       NULL);
 127 }
 128
 129 static void
 130 set_cell_text (GtkCellRenderer *renderer,
 131                const gchar *text,
 132                TnyHeaderFlags flags)
 133 {
 134         gboolean strikethrough;
 135         gboolean bold_is_active_color;
 136         GdkColor *color = NULL;
 137         PangoWeight weight;
 138
 139         bold_is_active_color = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (renderer), BOLD_IS_ACTIVE_COLOR));
 140         if (bold_is_active_color) {
 141                 color = g_object_get_data (G_OBJECT (renderer), ACTIVE_COLOR);
 142         }
 143
 144 #ifdef MODEST_TOOLKIT_HILDON2
 145         weight =  PANGO_WEIGHT_NORMAL;
 146 #else
 147         weight =  (bold_is_active_color || (flags & TNY_HEADER_FLAG_SEEN)) ? PANGO_WEIGHT_NORMAL: PANGO_WEIGHT_ULTRABOLD;
 148 #endif
 149         strikethrough = (flags & TNY_HEADER_FLAG_DELETED) ?  TRUE:FALSE;
 150         g_object_freeze_notify (G_OBJECT (renderer));
 151         g_object_set (G_OBJECT (renderer),
 152                       "text", text,
 153                       "weight", weight,
 154                       "strikethrough", (flags &TNY_HEADER_FLAG_DELETED) ? TRUE : FALSE,
 155                       NULL);
 156         if (bold_is_active_color && color) {
 157                 if (flags & TNY_HEADER_FLAG_SEEN) {
 158                         g_object_set (G_OBJECT (renderer),
 159                                       "foreground-set", FALSE,
 160                                       NULL);
 161                 } else {
 162                         g_object_set (G_OBJECT (renderer),
 163                                       "foreground-gdk", color,
 164                                       "foreground-set", TRUE,
 165                                       NULL);
 166                 }
 167         }
 168         g_object_thaw_notify (G_OBJECT (renderer));
 169 }
 170
 171 void
 172 _modest_header_view_attach_cell_data (GtkTreeViewColumn *column, GtkCellRenderer *renderer,
 173                                       GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer user_data)
 174 {
 175         TnyHeaderFlags flags;
 176
 177         gtk_tree_model_get (tree_model, iter, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 178                             &flags, -1);
 179
 180         if (flags & TNY_HEADER_FLAG_ATTACHMENTS)
 181                 g_object_set (G_OBJECT (renderer), "pixbuf",
 182                               get_pixbuf_for_flag (TNY_HEADER_FLAG_ATTACHMENTS),
 183                               NULL);
 184 }
 185
 186 void
 187 _modest_header_view_header_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 188                   GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer user_data)
 189 {
 190         TnyHeaderFlags flags;
 191
 192         gtk_tree_model_get (tree_model, iter, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 193                             &flags, -1);
 194         set_common_flags (renderer, flags);
 195 }
 196
 197
 198 void
 199 _modest_header_view_date_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 200                                      GtkTreeModel *tree_model,  GtkTreeIter *iter,
 201                                      gpointer user_data)
 202 {
 203         TnyHeaderFlags flags;
 204         guint date, date_col;
 205         gboolean received = GPOINTER_TO_INT(user_data);
 206
 207         if (received)
 208                 date_col = TNY_GTK_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN;
 209         else
 210                 date_col = TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN;
 211
 212         gtk_tree_model_get (tree_model, iter,
 213                             TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 214                             date_col, &date,
 215                             -1);
 216
 217 #if GTK_CHECK_VERSION (2, 12, 0)
 218         ModestHeaderView *header_view;
 219         header_view = MODEST_HEADER_VIEW (gtk_tree_view_column_get_tree_view (column));
 220         set_cell_text (renderer,
 221                        _modest_header_view_get_display_date (header_view, date),
 222                        flags);
 223 #else
 224         set_cell_text (renderer, modest_text_utils_get_display_date (date),
 225                        flags);
 226 #endif
 227 }
 228
 229 void
 230 _modest_header_view_sender_receiver_cell_data  (GtkTreeViewColumn *column,
 231                                                 GtkCellRenderer *renderer,
 232                                                 GtkTreeModel *tree_model,
 233                                                 GtkTreeIter *iter,
 234                                                 gboolean is_sender)
 235 {
 236         TnyHeaderFlags flags;
 237         gchar *address;
 238         gint sender_receiver_col;
 239
 240         if (is_sender)
 241                 sender_receiver_col = TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN;
 242         else
 243                 sender_receiver_col = TNY_GTK_HEADER_LIST_MODEL_TO_COLUMN;
 244
 245         gtk_tree_model_get (tree_model, iter,
 246                             sender_receiver_col,  &address,
 247                             TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 248                             -1);
 249
 250         modest_text_utils_get_display_address (address); /* string is changed in-place */
 251
 252         set_cell_text (renderer, (address && address[0] != '\0')?address:_("mail_va_no_to"),
 253                        flags);
 254         g_free (address);
 255 }
 256 /*
 257  * this for both incoming and outgoing mail, depending on the the user_data
 258  * parameter. in the incoming case, show 'From' and 'Received date', in the
 259  * outgoing case, show 'To' and 'Sent date'
 260  */
 261 void
 262 _modest_header_view_compact_header_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 263                                                GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer user_data)
 264 {
 265         TnyHeaderFlags flags = 0;
 266         gchar *recipients = NULL, *addresses;
 267         GSList *recipient_list;
 268         gchar *subject = NULL;
 269         time_t date;
 270         GtkCellRenderer *recipient_cell, *date_or_status_cell, *subject_cell,
 271                 *attach_cell, *priority_cell,
 272                 *recipient_box, *subject_box = NULL;
 273         TnyHeader *msg_header = NULL;
 274         TnyHeaderFlags prio = 0;
 275
 276 #ifdef MAEMO_CHANGES
 277 #ifdef HAVE_GTK_TREE_VIEW_COLUMN_GET_CELL_DATA_HINT
 278         GtkTreeCellDataHint hint;
 279 #endif
 280 #endif
 281
 282         g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
 283         g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
 284         g_return_if_fail (GTK_IS_TREE_MODEL (tree_model));
 285
 286 #ifdef MAEMO_CHANGES
 287 #ifdef HAVE_GTK_TREE_VIEW_COLUMN_GET_CELL_DATA_HINT
 288         hint = gtk_tree_view_column_get_cell_data_hint (GTK_TREE_VIEW_COLUMN (column));
 289
 290         if (hint != GTK_TREE_CELL_DATA_HINT_ALL)
 291                 return;
 292 #endif
 293 #endif
 294
 295         recipient_box = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (renderer), "recpt-box-renderer"));
 296         subject_box = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (renderer), "subject-box-renderer"));
 297         priority_cell = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (subject_box), "priority-renderer"));
 298         subject_cell = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (subject_box), "subject-renderer"));
 299         attach_cell = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (recipient_box), "attach-renderer"));
 300         recipient_cell = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (recipient_box), "recipient-renderer"));
 301         date_or_status_cell = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (recipient_box), "date-renderer"));
 302
 303         ModestHeaderViewCompactHeaderMode header_mode = GPOINTER_TO_INT (user_data);
 304
 305         if (header_mode == MODEST_HEADER_VIEW_COMPACT_HEADER_MODE_IN)
 306                 gtk_tree_model_get (tree_model, iter,
 307                                     TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 308                                     TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN,  &recipients,
 309                                     TNY_GTK_HEADER_LIST_MODEL_SUBJECT_COLUMN, &subject,
 310                                     TNY_GTK_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN, &date,
 311                                     TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, &msg_header,
 312                                     -1);
 313         else
 314                 gtk_tree_model_get (tree_model, iter,
 315                                     TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 316                                     TNY_GTK_HEADER_LIST_MODEL_TO_COLUMN,  &recipients,
 317                                     TNY_GTK_HEADER_LIST_MODEL_SUBJECT_COLUMN, &subject,
 318                                     TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &date,
 319                                     TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, &msg_header,
 320                                     -1);
 321         /* flags */
 322         /* FIXME: we might gain something by doing all the g_object_set's at once */
 323         if (flags & TNY_HEADER_FLAG_ATTACHMENTS)
 324                 g_object_set (G_OBJECT (attach_cell), "pixbuf",
 325                               get_pixbuf_for_flag (TNY_HEADER_FLAG_ATTACHMENTS),
 326                               NULL);
 327         else
 328                 g_object_set (G_OBJECT (attach_cell), "pixbuf",
 329                               NULL, NULL);
 330
 331         if (msg_header)
 332                 prio = tny_header_get_priority (msg_header);
 333         g_object_set (G_OBJECT (priority_cell), "pixbuf",
 334                       get_pixbuf_for_flag (prio),
 335                       NULL);
 336
 337         set_cell_text (subject_cell, (subject && subject[0] != 0)?subject:_("mail_va_no_subject"),
 338                        flags);
 339         g_free (subject);
 340
 341         /* Show the list of senders/recipients */
 342         addresses = NULL;
 343         recipient_list = modest_text_utils_split_addresses_list (recipients);
 344         if (recipient_list) {
 345                 GString *add_string = g_string_sized_new (strlen (recipients));
 346                 GSList *iter = recipient_list;
 347                 gboolean first = TRUE;
 348
 349                 while (iter) {
 350                         /* Strings are changed in place */
 351                         modest_text_utils_get_display_address ((gchar *) iter->data);
 352                         if (G_UNLIKELY (first)) {
 353                                 g_string_append_printf (add_string, "%s", (gchar *) iter->data);
 354                                 first = FALSE;
 355                         } else {
 356                                 g_string_append_printf (add_string, ", %s", (gchar *) iter->data);
 357                         }
 358                         iter = g_slist_next (iter);
 359                 }
 360                 g_slist_foreach (recipient_list, (GFunc) g_free, NULL);
 361                 g_slist_free (recipient_list);
 362                 addresses = g_string_free (add_string, FALSE);
 363         }
 364
 365         set_cell_text (recipient_cell, (addresses) ? addresses : _("mail_va_no_to"), flags);
 366         g_free (addresses);
 367         g_free (recipients);
 368
 369         /* Show status (outbox folder) or sent date */
 370         if (header_mode == MODEST_HEADER_VIEW_COMPACT_HEADER_MODE_OUTBOX) {
 371                 ModestTnySendQueueStatus status = MODEST_TNY_SEND_QUEUE_UNKNOWN;
 372                 const gchar *status_str = "";
 373                 if (msg_header != NULL) {
 374                         status = modest_tny_all_send_queues_get_msg_status (msg_header);
 375                         if (status == MODEST_TNY_SEND_QUEUE_SUSPENDED) {
 376                                 tny_header_set_flag (msg_header, TNY_HEADER_FLAG_SUSPENDED);
 377                         }
 378                 }
 379
 380                 status_str = get_status_string (status);
 381                 set_cell_text (date_or_status_cell, status_str, flags);
 382         } else {
 383 #if GTK_CHECK_VERSION (2, 12, 0)
 384                 ModestHeaderView *header_view;
 385                 header_view = MODEST_HEADER_VIEW (gtk_tree_view_column_get_tree_view (column));
 386                 set_cell_text (date_or_status_cell,
 387                                date ? _modest_header_view_get_display_date (header_view, date) : "",
 388                                flags);
 389 #else
 390                 set_cell_text (date_or_status_cell,
 391                                date ? modest_text_utils_get_display_date (date) : "",
 392                                flags);
 393 #endif
 394         }
 395         if (msg_header != NULL)
 396                 g_object_unref (msg_header);
 397 }
 398
 399
 400 void
 401 _modest_header_view_size_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 402                                      GtkTreeModel *tree_model,  GtkTreeIter *iter,
 403                                      gpointer user_data)
 404 {
 405         TnyHeaderFlags flags;
 406         guint size;
 407         gchar *size_str;
 408
 409         gtk_tree_model_get (tree_model, iter,
 410                            TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 411                            TNY_GTK_HEADER_LIST_MODEL_MESSAGE_SIZE_COLUMN, &size,
 412                             -1);
 413
 414         size_str = modest_text_utils_get_display_size (size);
 415
 416         set_cell_text (renderer, size_str, flags);
 417
 418         g_free (size_str);
 419  }
 420
 421 void
 422 _modest_header_view_status_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 423                                        GtkTreeModel *tree_model,  GtkTreeIter *iter,
 424                                        gpointer user_data)
 425 {
 426         TnyHeaderFlags flags;
 427         //guint status;
 428         gchar *status_str;
 429
 430         gtk_tree_model_get (tree_model, iter,
 431                             TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 432                             -1);
 433
 434        if (flags & TNY_HEADER_FLAG_SUSPENDED)
 435                status_str = g_strdup(_("mcen_li_outbox_suspended"));
 436        else
 437                status_str = g_strdup(_("mcen_li_outbox_waiting"));
 438
 439         set_cell_text (renderer, status_str, flags);
 440
 441         g_free (status_str);
 442  }
 443