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