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 void
  46 fill_list_of_caches (gpointer key, gpointer value, gpointer userdata)
  47 {
  48         GSList **send_queues = (GSList **) userdata;
  49         *send_queues = g_slist_prepend (*send_queues, value);
  50 }
  51
  52 static ModestTnySendQueueStatus
  53 get_status_of_uid (TnyHeader *header)
  54 {
  55         ModestCacheMgr *cache_mgr = NULL;
  56         GHashTable     *send_queue_cache = NULL;
  57         ModestTnyAccountStore *accounts_store = NULL;
  58         TnyList *accounts = NULL;
  59         TnyIterator *iter = NULL;
  60         TnyTransportAccount *account = NULL;
  61         GSList *send_queues = NULL, *node;
  62         /* get_msg_status returns suspended by default, so we want to detect changes */
  63         ModestTnySendQueueStatus status = MODEST_TNY_SEND_QUEUE_UNKNOWN;
  64         ModestTnySendQueueStatus queue_status = MODEST_TNY_SEND_QUEUE_UNKNOWN;
  65         gchar *msg_uid = NULL;
  66         ModestTnySendQueue *send_queue = NULL;
  67
  68         msg_uid = modest_tny_send_queue_get_msg_id (header);
  69         cache_mgr = modest_runtime_get_cache_mgr ();
  70         send_queue_cache = modest_cache_mgr_get_cache (cache_mgr,
  71                                                        MODEST_CACHE_MGR_CACHE_TYPE_SEND_QUEUE);
  72
  73         g_hash_table_foreach (send_queue_cache, (GHFunc) fill_list_of_caches, &send_queues);
  74         if (send_queues == NULL) {
  75                 accounts = tny_simple_list_new ();
  76                 accounts_store = modest_runtime_get_account_store ();
  77                 tny_account_store_get_accounts (TNY_ACCOUNT_STORE(accounts_store),
  78                                                 accounts,
  79                                                 TNY_ACCOUNT_STORE_TRANSPORT_ACCOUNTS);
  80
  81                 iter = tny_list_create_iterator (accounts);
  82                 while (!tny_iterator_is_done (iter)) {
  83                         account = TNY_TRANSPORT_ACCOUNT(tny_iterator_get_current (iter));
  84                         send_queue = modest_runtime_get_send_queue(TNY_TRANSPORT_ACCOUNT(account));
  85                         g_object_unref(account);
  86
  87                         queue_status = modest_tny_send_queue_get_msg_status (send_queue, msg_uid);
  88                         if (queue_status != MODEST_TNY_SEND_QUEUE_UNKNOWN) {
  89                                 status = queue_status;
  90                                 break;
  91                         }
  92                         tny_iterator_next (iter);
  93                 }
  94                 g_object_unref (iter);
  95                 g_object_unref (accounts);
  96         }
  97         else {
  98                 for (node = send_queues; node != NULL; node = g_slist_next (node)) {
  99                         send_queue = MODEST_TNY_SEND_QUEUE (node->data);
 100
 101                         queue_status = modest_tny_send_queue_get_msg_status (send_queue, msg_uid);
 102                         if (queue_status != MODEST_TNY_SEND_QUEUE_UNKNOWN) {
 103                                 status = queue_status;
 104                                 break;
 105                         }
 106                 }
 107         }
 108
 109         g_free(msg_uid);
 110         g_slist_free (send_queues);
 111         return status;
 112 }
 113
 114 static const gchar *
 115 get_status_string (ModestTnySendQueueStatus status)
 116 {
 117         switch (status) {
 118         case MODEST_TNY_SEND_QUEUE_WAITING:
 119                 return _("mcen_li_outbox_waiting");
 120                 break;
 121         case MODEST_TNY_SEND_QUEUE_SENDING:
 122                 return _("mcen_li_outbox_sending");
 123                 break;
 124         case MODEST_TNY_SEND_QUEUE_SUSPENDED:
 125                 return _("mcen_li_outbox_suspended");
 126                 break;
 127         case MODEST_TNY_SEND_QUEUE_FAILED:
 128                 return _("mcen_li_outbox_failed");
 129                 break;
 130         default:
 131                 return "";
 132                 break;
 133         }
 134 }
 135
 136 static GdkPixbuf*
 137 get_pixbuf_for_flag (TnyHeaderFlags flag)
 138 {
 139         /* optimization */
 140         static GdkPixbuf *deleted_pixbuf          = NULL;
 141         static GdkPixbuf *seen_pixbuf             = NULL;
 142         static GdkPixbuf *unread_pixbuf           = NULL;
 143         static GdkPixbuf *attachments_pixbuf      = NULL;
 144         static GdkPixbuf *high_pixbuf             = NULL;
 145         static GdkPixbuf *low_pixbuf             = NULL;
 146
 147         switch (flag) {
 148         case TNY_HEADER_FLAG_DELETED:
 149                 if (G_UNLIKELY(!deleted_pixbuf))
 150                         deleted_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_DELETED);
 151                 return deleted_pixbuf;
 152         case TNY_HEADER_FLAG_SEEN:
 153                 if (G_UNLIKELY(!seen_pixbuf))
 154                         seen_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_READ);
 155                 return seen_pixbuf;
 156         case TNY_HEADER_FLAG_ATTACHMENTS:
 157                 if (G_UNLIKELY(!attachments_pixbuf))
 158                         attachments_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_ATTACH);
 159                 return attachments_pixbuf;
 160         case TNY_HEADER_FLAG_HIGH_PRIORITY:
 161                 if (G_UNLIKELY(!high_pixbuf))
 162                         high_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_HIGH);
 163                 return high_pixbuf;
 164         case TNY_HEADER_FLAG_LOW_PRIORITY:
 165                 if (G_UNLIKELY(!low_pixbuf))
 166                         low_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_LOW);
 167                 return low_pixbuf;
 168         default:
 169                 if (G_UNLIKELY(!unread_pixbuf))
 170                         unread_pixbuf = modest_platform_get_icon (MODEST_HEADER_ICON_UNREAD);
 171                 return unread_pixbuf;
 172         }
 173 }
 174
 175 static void
 176 set_common_flags (GtkCellRenderer *renderer, TnyHeaderFlags flags)
 177 {
 178         g_object_set (G_OBJECT(renderer),
 179                       "weight", (flags & TNY_HEADER_FLAG_SEEN) ? PANGO_WEIGHT_NORMAL: PANGO_WEIGHT_ULTRABOLD,
 180                       "strikethrough",  (flags & TNY_HEADER_FLAG_DELETED) ?  TRUE:FALSE,
 181                       NULL);
 182 }
 183
 184
 185 void
 186 _modest_header_view_msgtype_cell_data (GtkTreeViewColumn *column, GtkCellRenderer *renderer,
 187                    GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer user_data)
 188 {
 189         TnyHeaderFlags flags;
 190
 191         gtk_tree_model_get (tree_model, iter, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 192                             &flags, -1);
 193
 194         if (flags & TNY_HEADER_FLAG_DELETED)
 195                 g_object_set (G_OBJECT (renderer), "pixbuf",
 196                               get_pixbuf_for_flag (TNY_HEADER_FLAG_DELETED), NULL);
 197         else if (flags & TNY_HEADER_FLAG_SEEN)
 198                 g_object_set (G_OBJECT (renderer), "pixbuf",
 199                               get_pixbuf_for_flag (TNY_HEADER_FLAG_SEEN), NULL);
 200         else
 201                 g_object_set (G_OBJECT (renderer), "pixbuf",
 202                               get_pixbuf_for_flag (0), NULL); /* ughh, FIXME */
 203 }
 204
 205 void
 206 _modest_header_view_attach_cell_data (GtkTreeViewColumn *column, GtkCellRenderer *renderer,
 207                                       GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer user_data)
 208 {
 209         TnyHeaderFlags flags;
 210
 211         gtk_tree_model_get (tree_model, iter, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 212                             &flags, -1);
 213
 214         if (flags & TNY_HEADER_FLAG_ATTACHMENTS)
 215                 g_object_set (G_OBJECT (renderer), "pixbuf",
 216                               get_pixbuf_for_flag (TNY_HEADER_FLAG_ATTACHMENTS),
 217                               NULL);
 218 }
 219
 220 void
 221 _modest_header_view_header_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 222                   GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer user_data)
 223 {
 224         TnyHeaderFlags flags;
 225
 226         gtk_tree_model_get (tree_model, iter, TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
 227                             &flags, -1);
 228         set_common_flags (renderer, flags);
 229 }
 230
 231
 232 void
 233 _modest_header_view_date_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 234                                      GtkTreeModel *tree_model,  GtkTreeIter *iter,
 235                                      gpointer user_data)
 236 {
 237         TnyHeaderFlags flags;
 238         guint date, date_col;
 239         gchar *display_date = NULL;
 240         gboolean received = GPOINTER_TO_INT(user_data);
 241
 242         if (received)
 243                 date_col = TNY_GTK_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN;
 244         else
 245                 date_col = TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN;
 246
 247         gtk_tree_model_get (tree_model, iter,
 248                             TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 249                             date_col, &date,
 250                             -1);
 251
 252         display_date = modest_text_utils_get_display_date (date);
 253         g_object_set (G_OBJECT(renderer), "text", display_date, NULL);
 254
 255         set_common_flags (renderer, flags);
 256         g_free (display_date);
 257 }
 258
 259 void
 260 _modest_header_view_sender_receiver_cell_data  (GtkTreeViewColumn *column,
 261                                                 GtkCellRenderer *renderer,
 262                                                 GtkTreeModel *tree_model,
 263                                                 GtkTreeIter *iter,
 264                                                 gboolean is_sender)
 265 {
 266         TnyHeaderFlags flags;
 267         gchar *address;
 268         gint sender_receiver_col;
 269
 270         if (is_sender)
 271                 sender_receiver_col = TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN;
 272         else
 273                 sender_receiver_col = TNY_GTK_HEADER_LIST_MODEL_TO_COLUMN;
 274
 275         gtk_tree_model_get (tree_model, iter,
 276                             sender_receiver_col,  &address,
 277                             TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 278                             -1);
 279
 280         modest_text_utils_get_display_address (address); /* string is changed in-place */
 281         g_object_set (G_OBJECT(renderer),
 282                       "text",
 283                       address,
 284                       NULL);
 285         g_free (address);
 286
 287         set_common_flags (renderer, flags);
 288 }
 289 /*
 290  * this for both incoming and outgoing mail, depending on the the user_data
 291  * parameter. in the incoming case, show 'From' and 'Received date', in the
 292  * outgoing case, show 'To' and 'Sent date'
 293  */
 294 void
 295 _modest_header_view_compact_header_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 296                                                GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer user_data)
 297 {
 298         g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
 299         g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
 300         g_return_if_fail (GTK_IS_TREE_MODEL (tree_model));
 301
 302         /* Note that GtkTreeModel is a GtkTreeModelFilter. */
 303
 304         /* printf ("DEBUG: %s: tree_model gtype=%s\n", __FUNCTION__, G_OBJECT_TYPE_NAME (tree_model)); */
 305
 306         TnyHeaderFlags flags = 0;
 307         TnyHeaderFlags prior_flags = 0;
 308         gchar *address = NULL;
 309         gchar *subject = NULL;
 310         gchar *header = NULL;
 311         time_t date = 0;
 312
 313         GtkCellRenderer *recipient_cell, *date_or_status_cell, *subject_cell,
 314                 *attach_cell, *priority_cell,
 315                 *recipient_box, *subject_box = NULL;
 316         TnyHeader *msg_header = NULL;
 317         gchar *display_date = NULL, *tmp_date = NULL;
 318
 319         recipient_box = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (renderer), "recpt-box-renderer"));
 320         subject_box = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (renderer), "subject-box-renderer"));
 321         priority_cell = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (subject_box), "priority-renderer"));
 322         subject_cell = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (subject_box), "subject-renderer"));
 323         attach_cell = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (recipient_box), "attach-renderer"));
 324         recipient_cell = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (recipient_box), "recipient-renderer"));
 325         date_or_status_cell = GTK_CELL_RENDERER (g_object_get_data (G_OBJECT (recipient_box), "date-renderer"));
 326
 327         ModestHeaderViewCompactHeaderMode header_mode = GPOINTER_TO_INT (user_data);
 328
 329         if (header_mode == MODEST_HEADER_VIEW_COMPACT_HEADER_MODE_IN)
 330                 gtk_tree_model_get (tree_model, iter,
 331                                     TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 332                                     TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN,  &address,
 333                                     TNY_GTK_HEADER_LIST_MODEL_SUBJECT_COLUMN, &subject,
 334                                     TNY_GTK_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN, &date,
 335                                     -1);
 336         else
 337                 gtk_tree_model_get (tree_model, iter,
 338                                     TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 339                                     TNY_GTK_HEADER_LIST_MODEL_TO_COLUMN,  &address,
 340                                     TNY_GTK_HEADER_LIST_MODEL_SUBJECT_COLUMN, &subject,
 341                                     TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN, &date,
 342                                     TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, &msg_header,
 343                                     -1);
 344         /* flags */
 345         /* FIXME: we might gain something by doing all the g_object_set's at once */
 346         prior_flags = flags & TNY_HEADER_FLAG_PRIORITY;
 347         if (flags & TNY_HEADER_FLAG_ATTACHMENTS)
 348                 g_object_set (G_OBJECT (attach_cell), "pixbuf",
 349                               get_pixbuf_for_flag (TNY_HEADER_FLAG_ATTACHMENTS),
 350                               NULL);
 351         else
 352                 g_object_set (G_OBJECT (attach_cell), "pixbuf",
 353                               NULL, NULL);
 354         if (flags & TNY_HEADER_FLAG_PRIORITY)
 355                 g_object_set (G_OBJECT (priority_cell), "pixbuf",
 356                               get_pixbuf_for_flag (prior_flags),
 357 /*                            get_pixbuf_for_flag (flags & TNY_HEADER_FLAG_PRIORITY), */
 358                               NULL);
 359         else
 360                 g_object_set (G_OBJECT (priority_cell), "pixbuf",
 361                               NULL, NULL);
 362
 363
 364         if (subject && strlen (subject)) {
 365                 gchar* escaped_subject = g_markup_escape_text (subject, -1);
 366                 g_object_set (G_OBJECT (subject_cell), "markup",
 367                               escaped_subject, NULL);
 368                 g_free (escaped_subject);
 369         } else {
 370                 g_object_set (G_OBJECT (subject_cell), "markup",
 371                               _("mail_va_no_subject"), NULL);
 372         }
 373
 374         g_free (subject);
 375         set_common_flags (subject_cell, flags);
 376
 377         /* FIXME: we hardcode the color to #666666; instead we should use SecondaryTextColour from the
 378          * theme (gtkrc file) */
 379         modest_text_utils_get_display_address (address); /* changed in-place */
 380         header = g_markup_printf_escaped ("<span size='small' foreground='#666666'>%s</span>",
 381                                           address);
 382         g_free (address);
 383         g_object_set (G_OBJECT (recipient_cell),
 384                       "markup", header,
 385                       NULL);
 386         g_free (header);
 387         header = NULL;
 388         set_common_flags (recipient_cell, flags);
 389
 390         if (header_mode == MODEST_HEADER_VIEW_COMPACT_HEADER_MODE_OUTBOX) {
 391                 ModestTnySendQueueStatus status = MODEST_TNY_SEND_QUEUE_UNKNOWN;
 392                 const gchar *status_str = "";
 393                 if (msg_header != NULL) {
 394                         status = get_status_of_uid (msg_header);
 395                         if (status == MODEST_TNY_SEND_QUEUE_SUSPENDED) {
 396                                 tny_header_unset_flags (msg_header, TNY_HEADER_FLAG_PRIORITY);
 397                                 tny_header_set_flags (msg_header, TNY_HEADER_FLAG_SUSPENDED_PRIORITY);
 398                         }
 399                 }
 400
 401                 status_str = get_status_string (status);
 402                 display_date = g_strdup_printf("<span size='small' foreground='#666666'>%s</span>", status_str);
 403                 g_object_set (G_OBJECT (date_or_status_cell),
 404                               "markup", display_date,
 405                               NULL);
 406                 g_free (display_date);
 407                 display_date = NULL;
 408         } else {
 409                 /* in some rare cases, mail might have no Date: field. it case,
 410                  * don't show the date, instead of bogus 1/1/1970
 411                  */
 412                 if (date)
 413                         tmp_date = modest_text_utils_get_display_date (date);
 414                 else
 415                         tmp_date = g_strdup ("");
 416
 417                 display_date = g_strdup_printf ("<span size='small' foreground='#666666'>%s</span>", tmp_date);
 418                 g_object_set (G_OBJECT (date_or_status_cell),
 419                               "markup", display_date,
 420                               NULL);
 421                 g_free (tmp_date);
 422                 tmp_date = NULL;
 423                 g_free (display_date);
 424                 display_date = NULL;
 425         }
 426
 427         if (msg_header != NULL)
 428                 g_object_unref (msg_header);
 429
 430         set_common_flags (date_or_status_cell, flags);
 431 }
 432
 433
 434 void
 435 _modest_header_view_size_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 436                                      GtkTreeModel *tree_model,  GtkTreeIter *iter,
 437                                      gpointer user_data)
 438 {
 439         TnyHeaderFlags flags;
 440         guint size;
 441         gchar *size_str;
 442
 443         gtk_tree_model_get (tree_model, iter,
 444                            TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 445                            TNY_GTK_HEADER_LIST_MODEL_MESSAGE_SIZE_COLUMN, &size,
 446                             -1);
 447
 448         size_str = modest_text_utils_get_display_size (size);
 449
 450         g_object_set (G_OBJECT(renderer), "text", size_str, NULL);
 451         set_common_flags (renderer, flags);
 452
 453         g_free (size_str);
 454  }
 455
 456 void
 457 _modest_header_view_status_cell_data  (GtkTreeViewColumn *column,  GtkCellRenderer *renderer,
 458                                        GtkTreeModel *tree_model,  GtkTreeIter *iter,
 459                                        gpointer user_data)
 460 {
 461         TnyHeaderFlags flags, prior_flags;
 462         //guint status;
 463         gchar *status_str;
 464
 465         gtk_tree_model_get (tree_model, iter,
 466                             TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN, &flags,
 467                             -1);
 468
 469        prior_flags = flags & TNY_HEADER_FLAG_PRIORITY;
 470        if (prior_flags == TNY_HEADER_FLAG_SUSPENDED_PRIORITY)
 471                status_str = g_strdup(_("mcen_li_outbox_suspended"));
 472        else
 473                status_str = g_strdup(_("mcen_li_outbox_waiting"));
 474
 475         g_object_set (G_OBJECT(renderer), "text", status_str, NULL);
 476         set_common_flags (renderer, flags);
 477
 478         g_free (status_str);
 479  }
 480