libempathy-gtk/empathy-theme-adium.c

   1 /*
   2  * Copyright (C) 2008-2012 Collabora Ltd.
   3  * Copyright (C) 2012 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  *
  19  * Authors: Xavier Claessens <xclaesse@gmail.com>
  20  */
  21
  22 #include "config.h"
  23 #include "empathy-theme-adium.h"
  24
  25 #include <glib/gi18n-lib.h>
  26 #include <tp-account-widgets/tpaw-images.h>
  27 #include <tp-account-widgets/tpaw-time.h>
  28 #include <tp-account-widgets/tpaw-pixbuf-utils.h>
  29 #include <tp-account-widgets/tpaw-utils.h>
  30
  31 #include "empathy-gsettings.h"
  32 #include "empathy-images.h"
  33 #include "empathy-plist.h"
  34 #include "empathy-smiley-manager.h"
  35 #include "empathy-ui-utils.h"
  36 #include "empathy-utils.h"
  37 #include "empathy-webkit-utils.h"
  38
  39 #define DEBUG_FLAG EMPATHY_DEBUG_CHAT
  40 #include "empathy-debug.h"
  41
  42 #define BORING_DPI_DEFAULT 96
  43
  44 /* "Join" consecutive messages with timestamps within five minutes */
  45 #define MESSAGE_JOIN_PERIOD 5*60
  46
  47 struct _EmpathyThemeAdiumPriv
  48 {
  49   EmpathyAdiumData *data;
  50   EmpathySmileyManager *smiley_manager;
  51   EmpathyContact *first_contact;
  52   EmpathyContact *last_contact;
  53   gint64 first_timestamp;
  54   gint64 last_timestamp;
  55   gboolean first_is_backlog;
  56   gboolean last_is_backlog;
  57   guint pages_loading;
  58   /* Queue of QueuedItem*s containing an EmpathyMessage or string */
  59   GQueue message_queue;
  60   /* Queue of guint32 of pending message id to remove unread
  61    * marker for when we lose focus. */
  62   GQueue acked_messages;
  63   GtkWidget *inspector_window;
  64
  65   GSettings *gsettings_chat;
  66   GSettings *gsettings_desktop;
  67
  68   gboolean has_focus;
  69   gboolean has_unread_message;
  70   gboolean allow_scrolling;
  71   gchar *variant;
  72   gboolean in_construction;
  73   gboolean show_avatars;
  74 };
  75
  76 struct _EmpathyAdiumData
  77 {
  78   gint ref_count;
  79   gchar *path;
  80   gchar *basedir;
  81   gchar *default_avatar_filename;
  82   gchar *default_incoming_avatar_filename;
  83   gchar *default_outgoing_avatar_filename;
  84   GHashTable *info;
  85   guint version;
  86   gboolean custom_template;
  87   /* gchar* -> gchar* both owned */
  88   GHashTable *date_format_cache;
  89
  90   /* HTML bits */
  91   const gchar *template_html;
  92   const gchar *content_html;
  93   const gchar *in_content_html;
  94   const gchar *in_context_html;
  95   const gchar *in_nextcontent_html;
  96   const gchar *in_nextcontext_html;
  97   const gchar *out_content_html;
  98   const gchar *out_context_html;
  99   const gchar *out_nextcontent_html;
 100   const gchar *out_nextcontext_html;
 101   const gchar *status_html;
 102
 103   /* Above html strings are pointers to strings stored in this array.
 104    * We do this because of fallbacks, some htmls could be pointing the
 105    * same string. */
 106   GPtrArray *strings_to_free;
 107 };
 108
 109 static gchar * adium_info_dup_path_for_variant (GHashTable *info,
 110     const gchar *variant);
 111
 112 enum
 113 {
 114   PROP_0,
 115   PROP_ADIUM_DATA,
 116   PROP_VARIANT,
 117 };
 118
 119 G_DEFINE_TYPE (EmpathyThemeAdium, empathy_theme_adium,
 120        WEBKIT_TYPE_WEB_VIEW)
 121
 122 enum
 123 {
 124   QUEUED_EVENT,
 125   QUEUED_MESSAGE,
 126   QUEUED_EDIT
 127 };
 128
 129 typedef struct
 130 {
 131   guint type;
 132   EmpathyMessage *msg;
 133   char *str;
 134   gboolean should_highlight;
 135 } QueuedItem;
 136
 137 static QueuedItem *
 138 queue_item (GQueue *queue,
 139     guint type,
 140     EmpathyMessage *msg,
 141     const char *str,
 142     gboolean should_highlight,
 143     gboolean prepend)
 144 {
 145   QueuedItem *item = g_slice_new0 (QueuedItem);
 146
 147   item->type = type;
 148   if (msg != NULL)
 149     item->msg = g_object_ref (msg);
 150   item->str = g_strdup (str);
 151   item->should_highlight = should_highlight;
 152
 153   if (prepend)
 154     g_queue_push_head (queue, item);
 155   else
 156     g_queue_push_tail (queue, item);
 157
 158   return item;
 159 }
 160
 161 static void
 162 free_queued_item (QueuedItem *item)
 163 {
 164   tp_clear_object (&item->msg);
 165   g_free (item->str);
 166
 167   g_slice_free (QueuedItem, item);
 168 }
 169
 170 static gboolean
 171 theme_adium_navigation_policy_decision_requested_cb (WebKitWebView *view,
 172     WebKitWebFrame *web_frame,
 173     WebKitNetworkRequest *request,
 174     WebKitWebNavigationAction *action,
 175     WebKitWebPolicyDecision *decision,
 176     gpointer data)
 177 {
 178   const gchar *uri;
 179
 180   /* Only call url_show on clicks */
 181   if (webkit_web_navigation_action_get_reason (action) !=
 182       WEBKIT_WEB_NAVIGATION_REASON_LINK_CLICKED)
 183     {
 184       webkit_web_policy_decision_use (decision);
 185       return TRUE;
 186     }
 187
 188   uri = webkit_network_request_get_uri (request);
 189   empathy_url_show (GTK_WIDGET (view), uri);
 190
 191   webkit_web_policy_decision_ignore (decision);
 192   return TRUE;
 193 }
 194
 195 /* Replace each %@ in format with string passed in args */
 196 static gchar *
 197 string_with_format (const gchar *format,
 198     const gchar *first_string,
 199     ...)
 200 {
 201   va_list args;
 202   const gchar *str;
 203   GString *result;
 204
 205   va_start (args, first_string);
 206   result = g_string_sized_new (strlen (format));
 207   for (str = first_string; str != NULL; str = va_arg (args, const gchar *))
 208     {
 209       const gchar *next;
 210
 211       next = strstr (format, "%@");
 212       if (next == NULL)
 213         break;
 214
 215       g_string_append_len (result, format, next - format);
 216       g_string_append (result, str);
 217       format = next + 2;
 218     }
 219   g_string_append (result, format);
 220   va_end (args);
 221
 222   return g_string_free (result, FALSE);
 223 }
 224
 225 static void
 226 theme_adium_load_template (EmpathyThemeAdium *self)
 227 {
 228   gchar *basedir_uri;
 229   gchar *variant_path;
 230   gchar *template;
 231
 232   self->priv->pages_loading++;
 233   basedir_uri = g_strconcat ("file://", self->priv->data->basedir, NULL);
 234
 235   variant_path = adium_info_dup_path_for_variant (self->priv->data->info,
 236       self->priv->variant);
 237
 238   template = string_with_format (self->priv->data->template_html,
 239     variant_path, NULL);
 240
 241   webkit_web_view_load_html_string (WEBKIT_WEB_VIEW (self),
 242       template, basedir_uri);
 243
 244   g_free (basedir_uri);
 245   g_free (variant_path);
 246   g_free (template);
 247 }
 248
 249 static gchar *
 250 theme_adium_parse_body (EmpathyThemeAdium *self,
 251   const gchar *text,
 252   const gchar *token)
 253 {
 254   TpawStringParser *parsers;
 255   GString *string;
 256
 257   /* Check if we have to parse smileys */
 258   parsers = empathy_webkit_get_string_parser (
 259     g_settings_get_boolean (self->priv->gsettings_chat,
 260       EMPATHY_PREFS_CHAT_SHOW_SMILEYS));
 261
 262   /* Parse text and construct string with links and smileys replaced
 263    * by html tags. Also escape text to make sure html code is
 264    * displayed verbatim. */
 265   string = g_string_sized_new (strlen (text));
 266
 267   /* wrap this in HTML that allows us to find the message for later
 268    * editing */
 269   if (!tp_str_empty (token))
 270     g_string_append_printf (string,
 271       "<span id=\"message-token-%s\">",
 272       token);
 273
 274   tpaw_string_parser_substr (text, -1, parsers, string);
 275
 276   if (!tp_str_empty (token))
 277     g_string_append (string, "</span>");
 278
 279   /* Wrap body in order to make tabs and multiple spaces displayed
 280    * properly. See bug #625745. */
 281   g_string_prepend (string, "<div style=\"display: inline; "
 282                  "white-space: pre-wrap\"'>");
 283   g_string_append (string, "</div>");
 284
 285   return g_string_free (string, FALSE);
 286 }
 287
 288 static void
 289 escape_and_append_len (GString *string, const gchar *str, gint len)
 290 {
 291   while (str != NULL && *str != '\0' && len != 0)
 292     {
 293       switch (*str)
 294         {
 295           case '\\':
 296             /* \ becomes \\ */
 297             g_string_append (string, "\\\\");
 298             break;
 299           case '\"':
 300             /* " becomes \" */
 301             g_string_append (string, "\\\"");
 302             break;
 303           case '\n':
 304             /* Remove end of lines */
 305             break;
 306           default:
 307             g_string_append_c (string, *str);
 308         }
 309
 310       str++;
 311       len--;
 312     }
 313 }
 314
 315 /* If *str starts with match, returns TRUE and move pointer to the end */
 316 static gboolean
 317 theme_adium_match (const gchar **str,
 318     const gchar *match)
 319 {
 320   gint len;
 321
 322   len = strlen (match);
 323   if (strncmp (*str, match, len) == 0)
 324     {
 325       *str += len - 1;
 326       return TRUE;
 327     }
 328
 329   return FALSE;
 330 }
 331
 332 /* Like theme_adium_match() but also return the X part if match is
 333  * like %foo{X}% */
 334 static gboolean
 335 theme_adium_match_with_format (const gchar **str,
 336     const gchar *match,
 337     gchar **format)
 338 {
 339   const gchar *cur = *str;
 340   const gchar *end;
 341
 342   if (!theme_adium_match (&cur, match))
 343     return FALSE;
 344
 345   cur++;
 346
 347   end = strstr (cur, "}%");
 348   if (!end)
 349     return FALSE;
 350
 351   *format = g_strndup (cur , end - cur);
 352   *str = end + 1;
 353   return TRUE;
 354 }
 355
 356 /* List of colors used by %senderColor%. Copied from
 357  * adium/Frameworks/AIUtilities\ Framework/Source/AIColorAdditions.m
 358  */
 359 static gchar *colors[] = {
 360   "aqua", "aquamarine", "blue", "blueviolet", "brown", "burlywood", "cadetblue",
 361   "chartreuse", "chocolate", "coral", "cornflowerblue", "crimson", "cyan",
 362   "darkblue", "darkcyan", "darkgoldenrod", "darkgreen", "darkgrey", "darkkhaki",
 363   "darkmagenta", "darkolivegreen", "darkorange", "darkorchid", "darkred",
 364   "darksalmon", "darkseagreen", "darkslateblue", "darkslategrey",
 365   "darkturquoise", "darkviolet", "deeppink", "deepskyblue", "dimgrey",
 366   "dodgerblue", "firebrick", "forestgreen", "fuchsia", "gold", "goldenrod",
 367   "green", "greenyellow", "grey", "hotpink", "indianred", "indigo", "lawngreen",
 368   "lightblue", "lightcoral",
 369   "lightgreen", "lightgrey", "lightpink", "lightsalmon", "lightseagreen",
 370   "lightskyblue", "lightslategrey", "lightsteelblue", "lime", "limegreen",
 371   "magenta", "maroon", "mediumaquamarine", "mediumblue", "mediumorchid",
 372   "mediumpurple", "mediumseagreen", "mediumslateblue", "mediumspringgreen",
 373   "mediumturquoise", "mediumvioletred", "midnightblue", "navy", "olive",
 374   "olivedrab", "orange", "orangered", "orchid", "palegreen", "paleturquoise",
 375   "palevioletred", "peru", "pink", "plum", "powderblue", "purple", "red",
 376   "rosybrown", "royalblue", "saddlebrown", "salmon", "sandybrown", "seagreen",
 377   "sienna", "silver", "skyblue", "slateblue", "slategrey", "springgreen",
 378   "steelblue", "tan", "teal", "thistle", "tomato", "turquoise", "violet",
 379   "yellowgreen",
 380 };
 381
 382 static const gchar *
 383 nsdate_to_strftime (EmpathyAdiumData *data, const gchar *nsdate)
 384 {
 385   /* Convert from NSDateFormatter
 386    * (http://www.stepcase.com/blog/2008/12/02/format-string-for-the-iphone-nsdateformatter/)
 387    * to strftime supported by g_date_time_format.
 388    * FIXME: table is incomplete, doc of g_date_time_format has a table of
 389    *        supported tags.
 390    * FIXME: g_date_time_format in GLib 2.28 does 0 padding by default, but
 391    *        in 2.29.x we have to explictely request padding with %0x */
 392   static const gchar *convert_table[] = {
 393     "a", "%p", // AM/PM
 394     "A", NULL, // 0~86399999 (Millisecond of Day)
 395
 396     "cccc", "%A", // Sunday/Monday/Tuesday/Wednesday/Thursday/Friday/Saturday
 397     "ccc", "%a", // Sun/Mon/Tue/Wed/Thu/Fri/Sat
 398     "cc", "%u", // 1~7 (Day of Week)
 399     "c", "%u", // 1~7 (Day of Week)
 400
 401     "dd", "%d", // 1~31 (0 padded Day of Month)
 402     "d", "%d", // 1~31 (0 padded Day of Month)
 403     "D", "%j", // 1~366 (0 padded Day of Year)
 404
 405     "e", "%u", // 1~7 (0 padded Day of Week)
 406     "EEEE", "%A", // Sunday/Monday/Tuesday/Wednesday/Thursday/Friday/Saturday
 407     "EEE", "%a", // Sun/Mon/Tue/Wed/Thu/Fri/Sat
 408     "EE", "%a", // Sun/Mon/Tue/Wed/Thu/Fri/Sat
 409     "E", "%a", // Sun/Mon/Tue/Wed/Thu/Fri/Sat
 410
 411     "F", NULL, // 1~5 (0 padded Week of Month, first day of week = Monday)
 412
 413     "g", NULL, // Julian Day Number (number of days since 4713 BC January 1)
 414     "GGGG", NULL, // Before Christ/Anno Domini
 415     "GGG", NULL, // BC/AD (Era Designator Abbreviated)
 416     "GG", NULL, // BC/AD (Era Designator Abbreviated)
 417     "G", NULL, // BC/AD (Era Designator Abbreviated)
 418
 419     "h", "%I", // 1~12 (0 padded Hour (12hr))
 420     "H", "%H", // 0~23 (0 padded Hour (24hr))
 421
 422     "k", NULL, // 1~24 (0 padded Hour (24hr)
 423     "K", NULL, // 0~11 (0 padded Hour (12hr))
 424
 425     "LLLL", "%B", // January/February/March/April/May/June/July/August/September/October/November/December
 426     "LLL", "%b", // Jan/Feb/Mar/Apr/May/Jun/Jul/Aug/Sep/Oct/Nov/Dec
 427     "LL", "%m", // 1~12 (0 padded Month)
 428     "L", "%m", // 1~12 (0 padded Month)
 429
 430     "m", "%M", // 0~59 (0 padded Minute)
 431     "MMMM", "%B", // January/February/March/April/May/June/July/August/September/October/November/December
 432     "MMM", "%b", // Jan/Feb/Mar/Apr/May/Jun/Jul/Aug/Sep/Oct/Nov/Dec
 433     "MM", "%m", // 1~12 (0 padded Month)
 434     "M", "%m", // 1~12 (0 padded Month)
 435
 436     "qqqq", NULL, // 1st quarter/2nd quarter/3rd quarter/4th quarter
 437     "qqq", NULL, // Q1/Q2/Q3/Q4
 438     "qq", NULL, // 1~4 (0 padded Quarter)
 439     "q", NULL, // 1~4 (0 padded Quarter)
 440     "QQQQ", NULL, // 1st quarter/2nd quarter/3rd quarter/4th quarter
 441     "QQQ", NULL, // Q1/Q2/Q3/Q4
 442     "QQ", NULL, // 1~4 (0 padded Quarter)
 443     "Q", NULL, // 1~4 (0 padded Quarter)
 444
 445     "s", "%S", // 0~59 (0 padded Second)
 446     "S", NULL, // (rounded Sub-Second)
 447
 448     "u", "%Y", // (0 padded Year)
 449
 450     "vvvv", "%Z", // (General GMT Timezone Name)
 451     "vvv", "%Z", // (General GMT Timezone Abbreviation)
 452     "vv", "%Z", // (General GMT Timezone Abbreviation)
 453     "v", "%Z", // (General GMT Timezone Abbreviation)
 454
 455     "w", "%W", // 1~53 (0 padded Week of Year, 1st day of week = Sunday, NB, 1st week of year starts from the last Sunday of last year)
 456     "W", NULL, // 1~5 (0 padded Week of Month, 1st day of week = Sunday)
 457
 458     "yyyy", "%Y", // (Full Year)
 459     "yyy", "%y", // (2 Digits Year)
 460     "yy", "%y", // (2 Digits Year)
 461     "y", "%Y", // (Full Year)
 462     "YYYY", NULL, // (Full Year, starting from the Sunday of the 1st week of year)
 463     "YYY", NULL, // (2 Digits Year, starting from the Sunday of the 1st week of year)
 464     "YY", NULL, // (2 Digits Year, starting from the Sunday of the 1st week of year)
 465     "Y", NULL, // (Full Year, starting from the Sunday of the 1st week of year)
 466
 467     "zzzz", NULL, // (Specific GMT Timezone Name)
 468     "zzz", NULL, // (Specific GMT Timezone Abbreviation)
 469     "zz", NULL, // (Specific GMT Timezone Abbreviation)
 470     "z", NULL, // (Specific GMT Timezone Abbreviation)
 471     "Z", "%z", // +0000 (RFC 822 Timezone)
 472   };
 473   const gchar *str;
 474   GString *string;
 475   guint i, j;
 476
 477   if (nsdate == NULL)
 478     return NULL;
 479
 480   str = g_hash_table_lookup (data->date_format_cache, nsdate);
 481   if (str != NULL) {
 482     return str;
 483   }
 484
 485   /* Copy nsdate into string, replacing occurences of NSDateFormatter tags
 486    * by corresponding strftime tag. */
 487   string = g_string_sized_new (strlen (nsdate));
 488   for (i = 0; nsdate[i] != '\0'; i++)
 489     {
 490       gboolean found = FALSE;
 491
 492       /* even indexes are NSDateFormatter tag, odd indexes are the
 493        * corresponding strftime tag */
 494       for (j = 0; j < G_N_ELEMENTS (convert_table); j += 2)
 495         {
 496           if (g_str_has_prefix (nsdate + i, convert_table[j]))
 497             {
 498               found = TRUE;
 499               break;
 500             }
 501         }
 502
 503       if (found)
 504         {
 505           /* If we don't have a replacement, just ignore that tag */
 506           if (convert_table[j + 1] != NULL)
 507             g_string_append (string, convert_table[j + 1]);
 508
 509           i += strlen (convert_table[j]) - 1;
 510         }
 511       else
 512         {
 513           g_string_append_c (string, nsdate[i]);
 514         }
 515     }
 516
 517   DEBUG ("Date format converted '%s' → '%s'", nsdate, string->str);
 518
 519   /* The cache takes ownership of string->str */
 520   g_hash_table_insert (data->date_format_cache, g_strdup (nsdate), string->str);
 521   return g_string_free (string, FALSE);
 522 }
 523
 524 static void
 525 theme_adium_add_html (EmpathyThemeAdium *self,
 526     const gchar *func,
 527     const gchar *html,
 528     const gchar *message,
 529     const gchar *avatar_filename,
 530     const gchar *name,
 531     const gchar *contact_id,
 532     const gchar *service_name,
 533     const gchar *message_classes,
 534     gint64 timestamp,
 535     gboolean is_backlog,
 536     gboolean outgoing,
 537     PangoDirection direction)
 538 {
 539   GBytes *bytes;
 540   GString *string;
 541   const gchar *cur = NULL;
 542   const gchar *js;
 543   gchar *script;
 544
 545   /* Make some search-and-replace in the html code */
 546   string = g_string_sized_new (strlen (html) + strlen (message));
 547   g_string_append_printf (string, "%s(\"", func);
 548
 549   for (cur = html; *cur != '\0'; cur++)
 550     {
 551       const gchar *replace = NULL;
 552       gchar *dup_replace = NULL;
 553       gchar *format = NULL;
 554
 555       /* Those are all well known keywords that needs replacement in
 556        * html files. Please keep them in the same order than the adium
 557        * spec. See http://trac.adium.im/wiki/CreatingMessageStyles */
 558       if (theme_adium_match (&cur, "%userIconPath%"))
 559         {
 560           replace = avatar_filename;
 561         }
 562       else if (theme_adium_match (&cur, "%senderScreenName%"))
 563         {
 564           replace = contact_id;
 565         }
 566       else if (theme_adium_match (&cur, "%sender%"))
 567         {
 568           replace = name;
 569         }
 570       else if (theme_adium_match (&cur, "%senderColor%"))
 571         {
 572           /* A color derived from the user's name.
 573            * FIXME: If a colon separated list of HTML colors is at
 574            * Incoming/SenderColors.txt it will be used instead of
 575            * the default colors.
 576            */
 577
 578           /* Ensure we always use the same color when sending messages
 579            * (bgo #658821) */
 580           if (outgoing)
 581             {
 582               replace = "inherit";
 583             }
 584           else if (contact_id != NULL)
 585             {
 586               guint hash = g_str_hash (contact_id);
 587               replace = colors[hash % G_N_ELEMENTS (colors)];
 588             }
 589         }
 590       else if (theme_adium_match (&cur, "%senderStatusIcon%"))
 591         {
 592           /* FIXME: The path to the status icon of the sender
 593            * (available, away, etc...)
 594            */
 595         }
 596       else if (theme_adium_match (&cur, "%messageDirection%"))
 597         {
 598           switch (direction)
 599             {
 600               case PANGO_DIRECTION_LTR:
 601               case PANGO_DIRECTION_TTB_LTR:
 602               case PANGO_DIRECTION_WEAK_LTR:
 603                 replace = "ltr";
 604                 break;
 605               case PANGO_DIRECTION_RTL:
 606               case PANGO_DIRECTION_TTB_RTL:
 607               case PANGO_DIRECTION_WEAK_RTL:
 608                 replace = "rtl";
 609                 break;
 610               case PANGO_DIRECTION_NEUTRAL:
 611               default:
 612                 break;
 613             }
 614         }
 615       else if (theme_adium_match (&cur, "%senderDisplayName%"))
 616         {
 617           /* FIXME: The serverside (remotely set) name of the
 618            * sender, such as an MSN display name.
 619            *
 620            *  We don't have access to that yet so we use
 621            * local alias instead.
 622            */
 623           replace = name;
 624         }
 625       else if (theme_adium_match (&cur, "%senderPrefix%"))
 626         {
 627           /* FIXME: If we supported IRC user mode flags, this
 628            * would be replaced with @ if the user is an op, + if
 629            * the user has voice, etc. as per
 630            * http://hg.adium.im/adium/rev/b586b027de42. But we
 631            * don't, so for now we just strip it. */
 632         }
 633       else if (theme_adium_match_with_format (&cur, "%textbackgroundcolor{",
 634             &format))
 635         {
 636           /* FIXME: This keyword is used to represent the
 637            * highlight background color. "X" is the opacity of the
 638            * background, ranges from 0 to 1 and can be any decimal
 639            * between.
 640            */
 641         }
 642       else if (theme_adium_match (&cur, "%message%"))
 643         {
 644           replace = message;
 645         }
 646       else if (theme_adium_match (&cur, "%time%") ||
 647            theme_adium_match_with_format (&cur, "%time{", &format))
 648         {
 649           const gchar *strftime_format;
 650
 651           strftime_format = nsdate_to_strftime (self->priv->data, format);
 652           if (is_backlog)
 653             dup_replace = tpaw_time_to_string_local (timestamp,
 654               strftime_format ? strftime_format :
 655               TPAW_TIME_DATE_FORMAT_DISPLAY_SHORT);
 656           else
 657             dup_replace = tpaw_time_to_string_local (timestamp,
 658               strftime_format ? strftime_format :
 659               TPAW_TIME_FORMAT_DISPLAY_SHORT);
 660
 661           replace = dup_replace;
 662         }
 663       else if (theme_adium_match (&cur, "%shortTime%"))
 664         {
 665           dup_replace = tpaw_time_to_string_local (timestamp,
 666             TPAW_TIME_FORMAT_DISPLAY_SHORT);
 667           replace = dup_replace;
 668         }
 669       else if (theme_adium_match (&cur, "%service%"))
 670         {
 671           replace = service_name;
 672         }
 673       else if (theme_adium_match (&cur, "%variant%"))
 674         {
 675           /* FIXME: The name of the active message style variant,
 676            * with all spaces replaced with an underscore.
 677            * A variant named "Alternating Messages - Blue Red"
 678            * will become "Alternating_Messages_-_Blue_Red".
 679            */
 680         }
 681       else if (theme_adium_match (&cur, "%userIcons%"))
 682         {
 683           replace = self->priv->show_avatars ? "showIcons" : "hideIcons";
 684         }
 685       else if (theme_adium_match (&cur, "%messageClasses%"))
 686         {
 687           replace = message_classes;
 688         }
 689       else if (theme_adium_match (&cur, "%status%"))
 690         {
 691           /* FIXME: A description of the status event. This is
 692            * neither in the user's local language nor expected to
 693            * be displayed; it may be useful to use a different div
 694            * class to present different types of status messages.
 695            * The following is a list of some of the more important
 696            * status messages; your message style should be able to
 697            * handle being shown a status message not in this list,
 698            * as even at present the list is incomplete and is
 699            * certain to become out of date in the future:
 700            *  online
 701            *  offline
 702            *  away
 703            *  away_message
 704            *  return_away
 705            *  idle
 706            *  return_idle
 707            *  date_separator
 708            *  contact_joined (group chats)
 709            *  contact_left
 710            *  error
 711            *  timed_out
 712            *  encryption (all OTR messages use this status)
 713            *  purple (all IRC topic and join/part messages use this status)
 714            *  fileTransferStarted
 715            *  fileTransferCompleted
 716            */
 717         }
 718       else
 719         {
 720           escape_and_append_len (string, cur, 1);
 721           continue;
 722         }
 723
 724       /* Here we have a replacement to make */
 725       escape_and_append_len (string, replace, -1);
 726
 727       g_free (dup_replace);
 728       g_free (format);
 729     }
 730   g_string_append (string, "\")");
 731
 732   bytes = g_resources_lookup_data ("/org/gnome/Empathy/Chat/empathy-chat.js",
 733       G_RESOURCE_LOOKUP_FLAGS_NONE,
 734       NULL);
 735
 736   if (bytes != NULL)
 737     {
 738       js = (const gchar *) g_bytes_get_data (bytes, NULL);
 739       g_string_prepend (string, js);
 740       g_bytes_unref (bytes);
 741     }
 742
 743   script = g_string_free (string, FALSE);
 744   webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self), script);
 745   g_free (script);
 746 }
 747
 748 static void
 749 theme_adium_append_event_escaped (EmpathyThemeAdium *self,
 750     const gchar *escaped,
 751     PangoDirection direction)
 752 {
 753   theme_adium_add_html (self, "appendMessage",
 754       self->priv->data->status_html, escaped, NULL, NULL, NULL,
 755       NULL, "event", tpaw_time_get_current (), FALSE, FALSE, direction);
 756
 757   /* There is no last contact */
 758   if (self->priv->last_contact)
 759     {
 760       g_object_unref (self->priv->last_contact);
 761       self->priv->last_contact = NULL;
 762     }
 763 }
 764
 765 static void
 766 theme_adium_remove_focus_marks (EmpathyThemeAdium *self,
 767     WebKitDOMNodeList *nodes)
 768 {
 769   guint i;
 770
 771   /* Remove focus and firstFocus class */
 772   for (i = 0; i < webkit_dom_node_list_get_length (nodes); i++)
 773     {
 774       WebKitDOMNode *node = webkit_dom_node_list_item (nodes, i);
 775       WebKitDOMHTMLElement *element = WEBKIT_DOM_HTML_ELEMENT (node);
 776       gchar *class_name;
 777       gchar **classes, **iter;
 778       GString *new_class_name;
 779       gboolean first = TRUE;
 780
 781       if (element == NULL)
 782         continue;
 783
 784       class_name = webkit_dom_html_element_get_class_name (element);
 785       classes = g_strsplit (class_name, " ", -1);
 786       new_class_name = g_string_sized_new (strlen (class_name));
 787
 788       for (iter = classes; *iter != NULL; iter++)
 789         {
 790           if (tp_strdiff (*iter, "focus") &&
 791               tp_strdiff (*iter, "firstFocus"))
 792             {
 793               if (!first)
 794                 g_string_append_c (new_class_name, ' ');
 795
 796               g_string_append (new_class_name, *iter);
 797               first = FALSE;
 798             }
 799         }
 800
 801       webkit_dom_html_element_set_class_name (element, new_class_name->str);
 802
 803       g_free (class_name);
 804       g_strfreev (classes);
 805       g_string_free (new_class_name, TRUE);
 806     }
 807 }
 808
 809 static void
 810 theme_adium_remove_all_focus_marks (EmpathyThemeAdium *self)
 811 {
 812   WebKitDOMDocument *dom;
 813   WebKitDOMNodeList *nodes;
 814   GError *error = NULL;
 815
 816   if (!self->priv->has_unread_message)
 817     return;
 818
 819   self->priv->has_unread_message = FALSE;
 820
 821   dom = webkit_web_view_get_dom_document (WEBKIT_WEB_VIEW (self));
 822   if (dom == NULL)
 823     return;
 824
 825   /* Get all nodes with focus class */
 826   nodes = webkit_dom_document_query_selector_all (dom, ".focus", &error);
 827
 828   if (nodes == NULL)
 829     {
 830       DEBUG ("Error getting focus nodes: %s",
 831         error ? error->message : "No error");
 832       g_clear_error (&error);
 833       return;
 834     }
 835
 836   theme_adium_remove_focus_marks (self, nodes);
 837 }
 838
 839 enum
 840 {
 841   ADD_CONSECUTIVE_MSG_SCROLL = 0,
 842   ADD_CONSECUTIVE_MSG_NO_SCROLL = 1,
 843   ADD_MSG_SCROLL = 2,
 844   ADD_MSG_NO_SCROLL = 3
 845 };
 846
 847 /*
 848  * theme_adium_add_message:
 849  * @self: The #EmpathyThemeAdium used by the view.
 850  * @msg: An #EmpathyMessage that is to be added to the view.
 851  * @prev_contact: (out): The #EmpathyContact that sent the previous message.
 852  * @prev_timestamp: (out): Timestamp of the previous message.
 853  * @prev_is_backlog: (out): Whether the previous message was fetched
 854  * from the logs.
 855  * @should_highlight: Whether the message should be highlighted. eg.,
 856  * if it matches the user's username in multi-user chat.
 857  * @js_funcs: An array of JavaScript function names
 858  *
 859  * Shows @msg in the chat view by adding to @self. Addition is defined
 860  * by the JavaScript functions listed in @js_funcs. Common examples
 861  * are appending new incoming messages or prepending old messages from
 862  * the logs.
 863  *
 864  * @js_funcs should be an array with exactly 4 entries. The entries
 865  * should be the names of JavaScript functions that take the raw HTML
 866  * that is to be added to the view as an argument and take the following
 867  * actions, in this order:
 868  * - add a new consecutive message and scroll to it if needed,
 869  * - add a new consecutive message and do not scroll,
 870  * - add a new non-consecutive message and scroll to it if needed, and
 871  * - add a new non-consecutive message and do not scroll
 872  *
 873  * A message is considered to be consecutive with the previous one if
 874  * all the following conditions are met:
 875  * - senders are the same contact,
 876  * - last message was recieved recently,
 877  * - last message and this message both are/aren't backlog, and
 878  * - DisableCombineConsecutive is not set in theme's settings
 879  */
 880 static void
 881 theme_adium_add_message (EmpathyThemeAdium *self,
 882     EmpathyMessage *msg,
 883     EmpathyContact **prev_contact,
 884     gint64 *prev_timestamp,
 885     gboolean *prev_is_backlog,
 886     gboolean should_highlight,
 887     const gchar *js_funcs[])
 888 {
 889   EmpathyContact *sender;
 890   TpMessage *tp_msg;
 891   TpAccount *account;
 892   gchar *body_escaped, *name_escaped;
 893   const gchar *name;
 894   const gchar *contact_id;
 895   EmpathyAvatar *avatar;
 896   const gchar *avatar_filename = NULL;
 897   gint64 timestamp;
 898   const gchar *html = NULL;
 899   const gchar *func;
 900   const gchar *service_name;
 901   GString *message_classes = NULL;
 902   gboolean is_backlog;
 903   gboolean consecutive;
 904   gboolean action;
 905   PangoDirection direction;
 906
 907
 908   /* Get information */
 909   sender = empathy_message_get_sender (msg);
 910   account = empathy_contact_get_account (sender);
 911   service_name = tpaw_protocol_name_to_display_name
 912     (tp_account_get_protocol_name (account));
 913   if (service_name == NULL)
 914     service_name = tp_account_get_protocol_name (account);
 915   timestamp = empathy_message_get_timestamp (msg);
 916   body_escaped = theme_adium_parse_body (self,
 917     empathy_message_get_body (msg),
 918     empathy_message_get_token (msg));
 919   name = empathy_contact_get_logged_alias (sender);
 920   contact_id = empathy_contact_get_id (sender);
 921   action = (empathy_message_get_tptype (msg) ==
 922       TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION);
 923
 924   name_escaped = g_markup_escape_text (name, -1);
 925
 926   /* If this is a /me probably */
 927   if (action)
 928     {
 929       gchar *str;
 930
 931       if (self->priv->data->version >= 4 || !self->priv->data->custom_template)
 932         {
 933           str = g_strdup_printf ("<span class='actionMessageUserName'>%s</span>"
 934                      "<span class='actionMessageBody'>%s</span>",
 935                      name_escaped, body_escaped);
 936         }
 937       else
 938         {
 939           str = g_strdup_printf ("*%s*", body_escaped);
 940         }
 941
 942       g_free (body_escaped);
 943       body_escaped = str;
 944     }
 945
 946   /* Get the avatar filename, or a fallback */
 947   avatar = empathy_contact_get_avatar (sender);
 948   if (avatar)
 949     avatar_filename = avatar->filename;
 950
 951   if (!avatar_filename)
 952     {
 953       if (empathy_contact_is_user (sender))
 954         avatar_filename = self->priv->data->default_outgoing_avatar_filename;
 955       else
 956         avatar_filename = self->priv->data->default_incoming_avatar_filename;
 957
 958       if (!avatar_filename)
 959         {
 960           if (!self->priv->data->default_avatar_filename)
 961             self->priv->data->default_avatar_filename =
 962               tpaw_filename_from_icon_name (TPAW_IMAGE_AVATAR_DEFAULT,
 963                        GTK_ICON_SIZE_DIALOG);
 964
 965           avatar_filename = self->priv->data->default_avatar_filename;
 966         }
 967     }
 968
 969   is_backlog = empathy_message_is_backlog (msg);
 970   consecutive = empathy_contact_equal (*prev_contact, sender) &&
 971     (ABS (timestamp - *prev_timestamp) < MESSAGE_JOIN_PERIOD) &&
 972     (is_backlog == *prev_is_backlog) &&
 973     !tp_asv_get_boolean (self->priv->data->info,
 974              "DisableCombineConsecutive", NULL);
 975
 976   /* Define message classes */
 977   message_classes = g_string_new ("message");
 978   if (!self->priv->has_focus && !is_backlog)
 979     {
 980       if (!self->priv->has_unread_message)
 981         {
 982           g_string_append (message_classes, " firstFocus");
 983           self->priv->has_unread_message = TRUE;
 984         }
 985       g_string_append (message_classes, " focus");
 986     }
 987
 988   if (is_backlog)
 989     g_string_append (message_classes, " history");
 990
 991   if (consecutive)
 992     g_string_append (message_classes, " consecutive");
 993
 994   if (empathy_contact_is_user (sender))
 995     g_string_append (message_classes, " outgoing");
 996   else
 997     g_string_append (message_classes, " incoming");
 998
 999   if (should_highlight)
1000     g_string_append (message_classes, " mention");
1001
1002   if (empathy_message_get_tptype (msg) ==
1003       TP_CHANNEL_TEXT_MESSAGE_TYPE_AUTO_REPLY)
1004     g_string_append (message_classes, " autoreply");
1005
1006   if (action)
1007     g_string_append (message_classes, " action");
1008
1009   /* FIXME: other classes:
1010    * status - the message is a status change
1011    * event - the message is a notification of something happening
1012    *         (for example, encryption being turned on)
1013    * %status% - See %status% in theme_adium_add_html ()
1014    */
1015
1016   /* This is slightly a hack, but it's the only way to add
1017    * arbitrary data to messages in the HTML. We add another
1018    * class called "x-empathy-message-id-*" to the message. This
1019    * way, we can remove the unread marker for this specific
1020    * message later. */
1021   tp_msg = empathy_message_get_tp_message (msg);
1022   if (tp_msg != NULL)
1023     {
1024       guint32 id;
1025       gboolean valid;
1026
1027       id = tp_message_get_pending_message_id (tp_msg, &valid);
1028       if (valid)
1029         g_string_append_printf (message_classes,
1030             " x-empathy-message-id-%u", id);
1031     }
1032
1033   /* Define javascript function to use */
1034   if (consecutive)
1035     func = self->priv->allow_scrolling ? js_funcs[ADD_CONSECUTIVE_MSG_SCROLL] :
1036       js_funcs[ADD_CONSECUTIVE_MSG_NO_SCROLL];
1037   else
1038     func = self->priv->allow_scrolling ? js_funcs[ADD_MSG_SCROLL] :
1039       js_funcs[ADD_MSG_NO_SCROLL];
1040
1041   if (empathy_contact_is_user (sender))
1042     {
1043       /* out */
1044       if (is_backlog)
1045         /* context */
1046         html = consecutive ? self->priv->data->out_nextcontext_html :
1047           self->priv->data->out_context_html;
1048       else
1049         /* content */
1050         html = consecutive ? self->priv->data->out_nextcontent_html :
1051           self->priv->data->out_content_html;
1052
1053       /* remove all the unread marks when we are sending a message */
1054       theme_adium_remove_all_focus_marks (self);
1055     }
1056   else
1057     {
1058       /* in */
1059       if (is_backlog)
1060         /* context */
1061         html = consecutive ? self->priv->data->in_nextcontext_html :
1062           self->priv->data->in_context_html;
1063       else
1064         /* content */
1065         html = consecutive ? self->priv->data->in_nextcontent_html :
1066           self->priv->data->in_content_html;
1067     }
1068
1069   direction = pango_find_base_dir (empathy_message_get_body (msg), -1);
1070
1071   theme_adium_add_html (self, func, html, body_escaped,
1072       avatar_filename, name_escaped, contact_id,
1073       service_name, message_classes->str,
1074       timestamp, is_backlog, empathy_contact_is_user (sender), direction);
1075
1076   /* Keep the sender of the last displayed message */
1077   if (*prev_contact)
1078     g_object_unref (*prev_contact);
1079
1080   *prev_contact = g_object_ref (sender);
1081   *prev_timestamp = timestamp;
1082   *prev_is_backlog = is_backlog;
1083
1084   g_free (body_escaped);
1085   g_free (name_escaped);
1086   g_string_free (message_classes, TRUE);
1087 }
1088
1089 void
1090 empathy_theme_adium_append_message (EmpathyThemeAdium *self,
1091     EmpathyMessage *msg,
1092     gboolean should_highlight)
1093 {
1094   const gchar *js_funcs[] = { "appendNextMessage",
1095       "appendNextMessageNoScroll",
1096       "appendMessage",
1097       "appendMessageNoScroll" };
1098
1099   if (self->priv->pages_loading != 0)
1100     {
1101       queue_item (&self->priv->message_queue, QUEUED_MESSAGE, msg, NULL,
1102           should_highlight, FALSE);
1103       return;
1104     }
1105
1106   theme_adium_add_message (self, msg, &self->priv->last_contact,
1107       &self->priv->last_timestamp, &self->priv->last_is_backlog,
1108       should_highlight, js_funcs);
1109 }
1110
1111 void
1112 empathy_theme_adium_append_event (EmpathyThemeAdium *self,
1113     const gchar *str)
1114 {
1115   gchar *str_escaped;
1116   PangoDirection direction;
1117
1118   if (self->priv->pages_loading != 0)
1119     {
1120       queue_item (&self->priv->message_queue, QUEUED_EVENT, NULL, str, FALSE, FALSE);
1121       return;
1122     }
1123
1124   direction = pango_find_base_dir (str, -1);
1125   str_escaped = g_markup_escape_text (str, -1);
1126   theme_adium_append_event_escaped (self, str_escaped, direction);
1127   g_free (str_escaped);
1128 }
1129
1130 void
1131 empathy_theme_adium_append_event_markup (EmpathyThemeAdium *self,
1132     const gchar *markup_text,
1133     const gchar *fallback_text)
1134 {
1135   PangoDirection direction;
1136
1137   direction = pango_find_base_dir (fallback_text, -1);
1138   theme_adium_append_event_escaped (self, markup_text, direction);
1139 }
1140
1141 void
1142 empathy_theme_adium_prepend_message (EmpathyThemeAdium *self,
1143     EmpathyMessage *msg,
1144     gboolean should_highlight)
1145 {
1146   const gchar *js_funcs[] = { "prependPrev",
1147       "prependPrev",
1148       "prepend",
1149       "prepend" };
1150
1151   if (self->priv->pages_loading != 0)
1152     {
1153       queue_item (&self->priv->message_queue, QUEUED_MESSAGE, msg, NULL,
1154           should_highlight, TRUE);
1155       return;
1156     }
1157
1158   theme_adium_add_message (self, msg, &self->priv->first_contact,
1159       &self->priv->first_timestamp, &self->priv->first_is_backlog,
1160       should_highlight, js_funcs);
1161 }
1162
1163 void
1164 empathy_theme_adium_edit_message (EmpathyThemeAdium *self,
1165     EmpathyMessage *message)
1166 {
1167   WebKitDOMDocument *doc;
1168   WebKitDOMElement *span;
1169   gchar *id, *parsed_body;
1170   gchar *tooltip, *timestamp;
1171   GtkIconInfo *icon_info;
1172   GError *error = NULL;
1173
1174   if (self->priv->pages_loading != 0)
1175     {
1176       queue_item (&self->priv->message_queue, QUEUED_EDIT, message, NULL, FALSE, FALSE);
1177       return;
1178     }
1179
1180   id = g_strdup_printf ("message-token-%s",
1181     empathy_message_get_supersedes (message));
1182   /* we don't pass a token here, because doing so will return another
1183    * <span> element, and we don't want nested <span> elements */
1184   parsed_body = theme_adium_parse_body (self,
1185     empathy_message_get_body (message), NULL);
1186
1187   /* find the element */
1188   doc = webkit_web_view_get_dom_document (WEBKIT_WEB_VIEW (self));
1189   span = webkit_dom_document_get_element_by_id (doc, id);
1190
1191   if (span == NULL)
1192     {
1193       DEBUG ("Failed to find id '%s'", id);
1194       goto except;
1195     }
1196
1197   if (!WEBKIT_DOM_IS_HTML_ELEMENT (span))
1198     {
1199       DEBUG ("Not a HTML element");
1200       goto except;
1201     }
1202
1203   /* update the HTML */
1204   webkit_dom_html_element_set_inner_html (WEBKIT_DOM_HTML_ELEMENT (span),
1205     parsed_body, &error);
1206
1207   if (error != NULL)
1208     {
1209       DEBUG ("Error setting new inner-HTML: %s", error->message);
1210       g_error_free (error);
1211       goto except;
1212     }
1213
1214   /* set a tooltip */
1215   timestamp = tpaw_time_to_string_local (
1216     empathy_message_get_timestamp (message),
1217     "%H:%M:%S");
1218   tooltip = g_strdup_printf (_("Message edited at %s"), timestamp);
1219
1220   webkit_dom_html_element_set_title (WEBKIT_DOM_HTML_ELEMENT (span),
1221     tooltip);
1222
1223   g_free (tooltip);
1224   g_free (timestamp);
1225
1226   /* mark this message as edited */
1227   icon_info = gtk_icon_theme_lookup_icon (gtk_icon_theme_get_default (),
1228     EMPATHY_IMAGE_EDIT_MESSAGE, 16, 0);
1229
1230   if (icon_info != NULL)
1231     {
1232       /* set the icon as a background image using CSS
1233        * FIXME: the icon won't update in response to theme changes */
1234       gchar *style = g_strdup_printf (
1235         "background-image:url('%s');"
1236         "background-repeat:no-repeat;"
1237         "background-position:left center;"
1238         "padding-left:19px;", /* 16px icon + 3px padding */
1239         gtk_icon_info_get_filename (icon_info));
1240
1241       webkit_dom_element_set_attribute (span, "style", style, &error);
1242
1243       if (error != NULL)
1244         {
1245           DEBUG ("Error setting element style: %s",
1246             error->message);
1247           g_clear_error (&error);
1248           /* not fatal */
1249         }
1250
1251       g_free (style);
1252       g_object_unref (icon_info);
1253     }
1254
1255   goto finally;
1256
1257 except:
1258   DEBUG ("Could not find message to edit with: %s",
1259     empathy_message_get_body (message));
1260
1261 finally:
1262   g_free (id);
1263   g_free (parsed_body);
1264 }
1265
1266 void
1267 empathy_theme_adium_scroll (EmpathyThemeAdium *self,
1268     gboolean allow_scrolling)
1269 {
1270   self->priv->allow_scrolling = allow_scrolling;
1271
1272   if (allow_scrolling)
1273     empathy_theme_adium_scroll_down (self);
1274 }
1275
1276 void
1277 empathy_theme_adium_scroll_down (EmpathyThemeAdium *self)
1278 {
1279   webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self), "alignChat(true);");
1280 }
1281
1282 gboolean
1283 empathy_theme_adium_get_has_selection (EmpathyThemeAdium *self)
1284 {
1285   return webkit_web_view_has_selection (WEBKIT_WEB_VIEW (self));
1286 }
1287
1288 void
1289 empathy_theme_adium_clear (EmpathyThemeAdium *self)
1290 {
1291   theme_adium_load_template (self);
1292
1293   /* Clear last contact to avoid trying to add a 'joined'
1294    * message when we don't have an insertion point. */
1295   if (self->priv->last_contact)
1296     {
1297       g_object_unref (self->priv->last_contact);
1298       self->priv->last_contact = NULL;
1299     }
1300 }
1301
1302 gboolean
1303 empathy_theme_adium_find_previous (EmpathyThemeAdium *self,
1304     const gchar *search_criteria,
1305     gboolean new_search,
1306     gboolean match_case)
1307 {
1308   /* FIXME: Doesn't respect new_search */
1309   return webkit_web_view_search_text (WEBKIT_WEB_VIEW (self),
1310       search_criteria, match_case, FALSE, TRUE);
1311 }
1312
1313 gboolean
1314 empathy_theme_adium_find_next (EmpathyThemeAdium *self,
1315     const gchar *search_criteria,
1316     gboolean new_search,
1317     gboolean match_case)
1318 {
1319   /* FIXME: Doesn't respect new_search */
1320   return webkit_web_view_search_text (WEBKIT_WEB_VIEW (self),
1321       search_criteria, match_case, TRUE, TRUE);
1322 }
1323
1324 void
1325 empathy_theme_adium_find_abilities (EmpathyThemeAdium *self,
1326     const gchar *search_criteria,
1327     gboolean match_case,
1328     gboolean *can_do_previous,
1329     gboolean *can_do_next)
1330 {
1331   /* FIXME: Does webkit provide an API for that? We have wrap=true in
1332    * find_next and find_previous to work around this problem. */
1333   if (can_do_previous)
1334     *can_do_previous = TRUE;
1335   if (can_do_next)
1336     *can_do_next = TRUE;
1337 }
1338
1339 void
1340 empathy_theme_adium_highlight (EmpathyThemeAdium *self,
1341     const gchar *text,
1342     gboolean match_case)
1343 {
1344   webkit_web_view_unmark_text_matches (WEBKIT_WEB_VIEW (self));
1345   webkit_web_view_mark_text_matches (WEBKIT_WEB_VIEW (self),
1346       text, match_case, 0);
1347   webkit_web_view_set_highlight_text_matches (WEBKIT_WEB_VIEW (self),
1348       TRUE);
1349 }
1350
1351 void
1352 empathy_theme_adium_copy_clipboard (EmpathyThemeAdium *self)
1353 {
1354   webkit_web_view_copy_clipboard (WEBKIT_WEB_VIEW (self));
1355 }
1356
1357 static void
1358 theme_adium_remove_mark_from_message (EmpathyThemeAdium *self,
1359     guint32 id)
1360 {
1361   WebKitDOMDocument *dom;
1362   WebKitDOMNodeList *nodes;
1363   gchar *class;
1364   GError *error = NULL;
1365
1366   dom = webkit_web_view_get_dom_document (WEBKIT_WEB_VIEW (self));
1367   if (dom == NULL)
1368     return;
1369
1370   class = g_strdup_printf (".x-empathy-message-id-%u", id);
1371
1372   /* Get all nodes with focus class */
1373   nodes = webkit_dom_document_query_selector_all (dom, class, &error);
1374   g_free (class);
1375
1376   if (nodes == NULL)
1377     {
1378       DEBUG ("Error getting focus nodes: %s",
1379         error ? error->message : "No error");
1380       g_clear_error (&error);
1381       return;
1382     }
1383
1384   theme_adium_remove_focus_marks (self, nodes);
1385 }
1386
1387 static void
1388 theme_adium_remove_acked_message_unread_mark_foreach (gpointer data,
1389     gpointer user_data)
1390 {
1391   EmpathyThemeAdium *self = user_data;
1392   guint32 id = GPOINTER_TO_UINT (data);
1393
1394   theme_adium_remove_mark_from_message (self, id);
1395 }
1396
1397 void
1398 empathy_theme_adium_focus_toggled (EmpathyThemeAdium *self,
1399     gboolean has_focus)
1400 {
1401   self->priv->has_focus = has_focus;
1402   if (!self->priv->has_focus)
1403     {
1404       /* We've lost focus, so let's make sure all the acked
1405        * messages have lost their unread marker. */
1406       g_queue_foreach (&self->priv->acked_messages,
1407           theme_adium_remove_acked_message_unread_mark_foreach, self);
1408       g_queue_clear (&self->priv->acked_messages);
1409
1410       self->priv->has_unread_message = FALSE;
1411     }
1412 }
1413
1414 void
1415 empathy_theme_adium_message_acknowledged (EmpathyThemeAdium *self,
1416     EmpathyMessage *message)
1417 {
1418   TpMessage *tp_msg;
1419   guint32 id;
1420   gboolean valid;
1421
1422   tp_msg = empathy_message_get_tp_message (message);
1423
1424   if (tp_msg == NULL)
1425     return;
1426
1427   id = tp_message_get_pending_message_id (tp_msg, &valid);
1428   if (!valid)
1429     {
1430       g_warning ("Acknoledged message doesn't have a pending ID");
1431       return;
1432     }
1433
1434   /* We only want to actually remove the unread marker if the
1435    * view doesn't have focus. If we did it all the time we would
1436    * never see the unread markers, ever! So, we'll queue these
1437    * up, and when we lose focus, we'll remove the markers. */
1438   if (self->priv->has_focus)
1439     {
1440       g_queue_push_tail (&self->priv->acked_messages,
1441              GUINT_TO_POINTER (id));
1442       return;
1443     }
1444
1445   theme_adium_remove_mark_from_message (self, id);
1446 }
1447
1448 static gboolean
1449 theme_adium_context_menu_cb (EmpathyThemeAdium *self,
1450     GtkWidget *default_menu,
1451     WebKitHitTestResult *hit_test_result,
1452     gboolean triggered_with_keyboard,
1453     gpointer user_data)
1454 {
1455   GtkWidget *menu;
1456   EmpathyWebKitMenuFlags flags = EMPATHY_WEBKIT_MENU_CLEAR;
1457
1458   if (g_settings_get_boolean (self->priv->gsettings_chat,
1459         EMPATHY_PREFS_CHAT_WEBKIT_DEVELOPER_TOOLS))
1460     flags |= EMPATHY_WEBKIT_MENU_INSPECT;
1461
1462   menu = empathy_webkit_create_context_menu (
1463     WEBKIT_WEB_VIEW (self), hit_test_result, flags);
1464
1465   gtk_widget_show_all (menu);
1466
1467   gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 3,
1468       gtk_get_current_event_time ());
1469
1470   return TRUE;
1471 }
1472
1473 void
1474 empathy_theme_adium_set_show_avatars (EmpathyThemeAdium *self,
1475     gboolean show_avatars)
1476 {
1477   self->priv->show_avatars = show_avatars;
1478 }
1479
1480 static void
1481 theme_adium_load_finished_cb (WebKitWebView *view,
1482     WebKitWebFrame *frame,
1483     gpointer user_data)
1484 {
1485   EmpathyThemeAdium *self = EMPATHY_THEME_ADIUM (view);
1486   GList *l;
1487
1488   DEBUG ("Page loaded");
1489   self->priv->pages_loading--;
1490
1491   if (self->priv->pages_loading != 0)
1492     return;
1493
1494   /* Display queued messages */
1495   for (l = self->priv->message_queue.head; l != NULL; l = l->next)
1496     {
1497       QueuedItem *item = l->data;
1498
1499       switch (item->type)
1500         {
1501           case QUEUED_MESSAGE:
1502             empathy_theme_adium_append_message (self, item->msg,
1503               item->should_highlight);
1504             break;
1505
1506           case QUEUED_EDIT:
1507             empathy_theme_adium_edit_message (self, item->msg);
1508             break;
1509
1510           case QUEUED_EVENT:
1511             empathy_theme_adium_append_event (self, item->str);
1512             break;
1513         }
1514
1515       free_queued_item (item);
1516     }
1517
1518   g_queue_clear (&self->priv->message_queue);
1519 }
1520
1521 static void
1522 theme_adium_finalize (GObject *object)
1523 {
1524   EmpathyThemeAdium *self = EMPATHY_THEME_ADIUM (object);
1525
1526   empathy_adium_data_unref (self->priv->data);
1527
1528   g_object_unref (self->priv->gsettings_chat);
1529   g_object_unref (self->priv->gsettings_desktop);
1530
1531   g_free (self->priv->variant);
1532
1533   G_OBJECT_CLASS (empathy_theme_adium_parent_class)->finalize (object);
1534 }
1535
1536 static void
1537 theme_adium_dispose (GObject *object)
1538 {
1539   EmpathyThemeAdium *self = EMPATHY_THEME_ADIUM (object);
1540
1541   if (self->priv->smiley_manager)
1542     {
1543       g_object_unref (self->priv->smiley_manager);
1544       self->priv->smiley_manager = NULL;
1545     }
1546
1547   g_clear_object (&self->priv->first_contact);
1548
1549   if (self->priv->last_contact)
1550     {
1551       g_object_unref (self->priv->last_contact);
1552       self->priv->last_contact = NULL;
1553     }
1554
1555   if (self->priv->inspector_window)
1556     {
1557       gtk_widget_destroy (self->priv->inspector_window);
1558       self->priv->inspector_window = NULL;
1559     }
1560
1561   if (self->priv->acked_messages.length > 0)
1562     {
1563       g_queue_clear (&self->priv->acked_messages);
1564     }
1565
1566   G_OBJECT_CLASS (empathy_theme_adium_parent_class)->dispose (object);
1567 }
1568
1569 static gboolean
1570 theme_adium_inspector_show_window_cb (WebKitWebInspector *inspector,
1571     EmpathyThemeAdium *self)
1572 {
1573   if (self->priv->inspector_window)
1574     {
1575       gtk_widget_show_all (self->priv->inspector_window);
1576     }
1577
1578   return TRUE;
1579 }
1580
1581 static gboolean
1582 theme_adium_inspector_close_window_cb (WebKitWebInspector *inspector,
1583     EmpathyThemeAdium *self)
1584 {
1585   if (self->priv->inspector_window)
1586     {
1587       gtk_widget_hide (self->priv->inspector_window);
1588     }
1589
1590   return TRUE;
1591 }
1592
1593 static WebKitWebView *
1594 theme_adium_inspect_web_view_cb (WebKitWebInspector *inspector,
1595     WebKitWebView *web_view,
1596     EmpathyThemeAdium *self)
1597 {
1598   GtkWidget *scrolled_window;
1599   GtkWidget *inspector_web_view;
1600
1601   if (!self->priv->inspector_window)
1602     {
1603       /* Create main window */
1604       self->priv->inspector_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1605
1606       gtk_window_set_default_size (GTK_WINDOW (self->priv->inspector_window),
1607                  800, 600);
1608
1609       g_signal_connect (self->priv->inspector_window, "delete-event",
1610             G_CALLBACK (gtk_widget_hide_on_delete), NULL);
1611
1612       /* Pack a scrolled window */
1613       scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1614
1615       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
1616               GTK_POLICY_AUTOMATIC,
1617               GTK_POLICY_AUTOMATIC);
1618       gtk_container_add (GTK_CONTAINER (self->priv->inspector_window),
1619              scrolled_window);
1620       gtk_widget_show (scrolled_window);
1621
1622       /* Pack a webview in the scrolled window. That webview will be
1623        * used to render the inspector tool. */
1624       inspector_web_view = webkit_web_view_new ();
1625       gtk_container_add (GTK_CONTAINER (scrolled_window),
1626              inspector_web_view);
1627       gtk_widget_show (scrolled_window);
1628
1629       return WEBKIT_WEB_VIEW (inspector_web_view);
1630     }
1631
1632   return NULL;
1633 }
1634
1635 static void
1636 theme_adium_constructed (GObject *object)
1637 {
1638   EmpathyThemeAdium *self = EMPATHY_THEME_ADIUM (object);
1639   const gchar *font_family = NULL;
1640   gint font_size = 0;
1641   WebKitWebView *webkit_view = WEBKIT_WEB_VIEW (object);
1642   WebKitWebInspector *webkit_inspector;
1643
1644   /* Set default settings */
1645   font_family = tp_asv_get_string (self->priv->data->info, "DefaultFontFamily");
1646   font_size = tp_asv_get_int32 (self->priv->data->info, "DefaultFontSize", NULL);
1647
1648   if (font_family && font_size)
1649     {
1650       g_object_set (webkit_web_view_get_settings (webkit_view),
1651         "default-font-family", font_family,
1652         "default-font-size", font_size,
1653         NULL);
1654     }
1655   else
1656     {
1657       empathy_webkit_bind_font_setting (webkit_view,
1658         self->priv->gsettings_desktop,
1659         EMPATHY_PREFS_DESKTOP_INTERFACE_DOCUMENT_FONT_NAME);
1660     }
1661
1662   /* Setup webkit inspector */
1663   webkit_inspector = webkit_web_view_get_inspector (webkit_view);
1664   g_signal_connect (webkit_inspector, "inspect-web-view",
1665       G_CALLBACK (theme_adium_inspect_web_view_cb), object);
1666   g_signal_connect (webkit_inspector, "show-window",
1667       G_CALLBACK (theme_adium_inspector_show_window_cb), object);
1668   g_signal_connect (webkit_inspector, "close-window",
1669       G_CALLBACK (theme_adium_inspector_close_window_cb), object);
1670
1671   /* Load template */
1672   theme_adium_load_template (EMPATHY_THEME_ADIUM (object));
1673
1674   self->priv->in_construction = FALSE;
1675 }
1676
1677 static void
1678 theme_adium_get_property (GObject *object,
1679     guint param_id,
1680     GValue *value,
1681     GParamSpec *pspec)
1682 {
1683   EmpathyThemeAdium *self = EMPATHY_THEME_ADIUM (object);
1684
1685   switch (param_id)
1686     {
1687       case PROP_ADIUM_DATA:
1688         g_value_set_boxed (value, self->priv->data);
1689         break;
1690       case PROP_VARIANT:
1691         g_value_set_string (value, self->priv->variant);
1692         break;
1693       default:
1694         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
1695         break;
1696     };
1697 }
1698
1699 static void
1700 theme_adium_set_property (GObject *object,
1701     guint param_id,
1702     const GValue *value,
1703     GParamSpec *pspec)
1704 {
1705   EmpathyThemeAdium *self = EMPATHY_THEME_ADIUM (object);
1706
1707   switch (param_id)
1708     {
1709       case PROP_ADIUM_DATA:
1710         g_assert (self->priv->data == NULL);
1711         self->priv->data = g_value_dup_boxed (value);
1712         break;
1713       case PROP_VARIANT:
1714         empathy_theme_adium_set_variant (self, g_value_get_string (value));
1715         break;
1716       default:
1717         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
1718         break;
1719     };
1720 }
1721
1722 static void
1723 empathy_theme_adium_class_init (EmpathyThemeAdiumClass *klass)
1724 {
1725   GObjectClass *object_class = G_OBJECT_CLASS (klass);
1726
1727   object_class->finalize = theme_adium_finalize;
1728   object_class->dispose = theme_adium_dispose;
1729   object_class->constructed = theme_adium_constructed;
1730   object_class->get_property = theme_adium_get_property;
1731   object_class->set_property = theme_adium_set_property;
1732
1733   g_object_class_install_property (object_class, PROP_ADIUM_DATA,
1734       g_param_spec_boxed ("adium-data",
1735         "The theme data",
1736         "Data for the adium theme",
1737         EMPATHY_TYPE_ADIUM_DATA,
1738         G_PARAM_CONSTRUCT_ONLY |
1739         G_PARAM_READWRITE |
1740         G_PARAM_STATIC_STRINGS));
1741
1742   g_object_class_install_property (object_class, PROP_VARIANT,
1743       g_param_spec_string ("variant",
1744         "The theme variant",
1745         "Variant name for the theme",
1746         NULL,
1747         G_PARAM_CONSTRUCT |
1748         G_PARAM_READWRITE |
1749         G_PARAM_STATIC_STRINGS));
1750
1751   g_type_class_add_private (object_class, sizeof (EmpathyThemeAdiumPriv));
1752 }
1753
1754 static void
1755 empathy_theme_adium_init (EmpathyThemeAdium *self)
1756 {
1757   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
1758     EMPATHY_TYPE_THEME_ADIUM, EmpathyThemeAdiumPriv);
1759
1760   self->priv->in_construction = TRUE;
1761   g_queue_init (&self->priv->message_queue);
1762   self->priv->allow_scrolling = TRUE;
1763   self->priv->smiley_manager = empathy_smiley_manager_dup_singleton ();
1764
1765   /* Show avatars by default. */
1766   self->priv->show_avatars = TRUE;
1767
1768   g_signal_connect (self, "load-finished",
1769       G_CALLBACK (theme_adium_load_finished_cb), NULL);
1770   g_signal_connect (self, "navigation-policy-decision-requested",
1771         G_CALLBACK (theme_adium_navigation_policy_decision_requested_cb), NULL);
1772   g_signal_connect (self, "context-menu",
1773       G_CALLBACK (theme_adium_context_menu_cb), NULL);
1774
1775   self->priv->gsettings_chat = g_settings_new (EMPATHY_PREFS_CHAT_SCHEMA);
1776   self->priv->gsettings_desktop = g_settings_new (
1777     EMPATHY_PREFS_DESKTOP_INTERFACE_SCHEMA);
1778 }
1779
1780 EmpathyThemeAdium *
1781 empathy_theme_adium_new (EmpathyAdiumData *data,
1782     const gchar *variant)
1783 {
1784   g_return_val_if_fail (data != NULL, NULL);
1785
1786   return g_object_new (EMPATHY_TYPE_THEME_ADIUM,
1787       "adium-data", data,
1788       "variant", variant,
1789       NULL);
1790 }
1791
1792 void
1793 empathy_theme_adium_set_variant (EmpathyThemeAdium *self,
1794     const gchar *variant)
1795 {
1796   gchar *variant_path;
1797   gchar *script;
1798
1799   if (!tp_strdiff (self->priv->variant, variant))
1800     return;
1801
1802   g_free (self->priv->variant);
1803   self->priv->variant = g_strdup (variant);
1804
1805   if (self->priv->in_construction)
1806     return;
1807
1808   DEBUG ("Update view with variant: '%s'", variant);
1809   variant_path = adium_info_dup_path_for_variant (self->priv->data->info,
1810     self->priv->variant);
1811   script = g_strdup_printf ("setStylesheet(\"mainStyle\",\"%s\");",
1812       variant_path);
1813
1814   webkit_web_view_execute_script (WEBKIT_WEB_VIEW (self), script);
1815
1816   g_free (variant_path);
1817   g_free (script);
1818
1819   g_object_notify (G_OBJECT (self), "variant");
1820 }
1821
1822 void
1823 empathy_theme_adium_show_inspector (EmpathyThemeAdium *self)
1824 {
1825   WebKitWebView *web_view = WEBKIT_WEB_VIEW (self);
1826
1827   empathy_webkit_show_inspector (web_view);
1828 }
1829
1830 gboolean
1831 empathy_adium_path_is_valid (const gchar *path)
1832 {
1833   gboolean ret;
1834   gchar *file;
1835   gchar **tmp;
1836   const gchar *dir;
1837
1838   if (path[0] != '/')
1839     return FALSE;
1840
1841   /* The directory has to be *.AdiumMessageStyle per the Adium spec */
1842   tmp = g_strsplit (path, "/", 0);
1843   if (tmp == NULL)
1844     return FALSE;
1845
1846   dir = tmp[g_strv_length (tmp) - 1];
1847
1848   if (!g_str_has_suffix (dir, ".AdiumMessageStyle"))
1849     {
1850       g_strfreev (tmp);
1851       return FALSE;
1852     }
1853
1854   g_strfreev (tmp);
1855
1856   /* The theme is not valid if there is no Info.plist */
1857   file = g_build_filename (path, "Contents", "Info.plist",
1858          NULL);
1859   ret = g_file_test (file, G_FILE_TEST_EXISTS);
1860   g_free (file);
1861
1862   if (!ret)
1863     return FALSE;
1864
1865   /* We ship a default Template.html as fallback if there is any problem
1866    * with the one inside the theme. The only other required file is
1867    * Content.html OR Incoming/Content.html*/
1868   file = g_build_filename (path, "Contents", "Resources", "Content.html",
1869       NULL);
1870   ret = g_file_test (file, G_FILE_TEST_EXISTS);
1871   g_free (file);
1872
1873   if (!ret)
1874     {
1875       file = g_build_filename (path, "Contents", "Resources", "Incoming",
1876              "Content.html", NULL);
1877       ret = g_file_test (file, G_FILE_TEST_EXISTS);
1878       g_free (file);
1879     }
1880
1881   return ret;
1882 }
1883
1884 GHashTable *
1885 empathy_adium_info_new (const gchar *path)
1886 {
1887   gchar *file;
1888   GValue *value;
1889   GHashTable *info = NULL;
1890
1891   g_return_val_if_fail (empathy_adium_path_is_valid (path), NULL);
1892
1893   file = g_build_filename (path, "Contents", "Info.plist", NULL);
1894   value = empathy_plist_parse_from_file (file);
1895   g_free (file);
1896
1897   if (value == NULL)
1898     return NULL;
1899
1900   info = g_value_dup_boxed (value);
1901   tp_g_value_slice_free (value);
1902
1903   /* Insert the theme's path into the hash table,
1904    * keys have to be dupped */
1905   tp_asv_set_string (info, g_strdup ("path"), path);
1906
1907   return info;
1908 }
1909
1910 static guint
1911 adium_info_get_version (GHashTable *info)
1912 {
1913   return tp_asv_get_int32 (info, "MessageViewVersion", NULL);
1914 }
1915
1916 static const gchar *
1917 adium_info_get_no_variant_name (GHashTable *info)
1918 {
1919   const gchar *name = tp_asv_get_string (info, "DisplayNameForNoVariant");
1920   return name ? name : _("Normal");
1921 }
1922
1923 static gchar *
1924 adium_info_dup_path_for_variant (GHashTable *info,
1925     const gchar *variant)
1926 {
1927   guint version = adium_info_get_version (info);
1928   const gchar *no_variant = adium_info_get_no_variant_name (info);
1929   GPtrArray *variants;
1930   guint i;
1931
1932   if (version <= 2 && !tp_strdiff (variant, no_variant))
1933     return g_strdup ("main.css");
1934
1935   variants = empathy_adium_info_get_available_variants (info);
1936   if (variants->len == 0)
1937     return g_strdup ("main.css");
1938
1939   /* Verify the variant exists, fallback to the first one */
1940   for (i = 0; i < variants->len; i++)
1941     {
1942       if (!tp_strdiff (variant, g_ptr_array_index (variants, i)))
1943         break;
1944     }
1945
1946   if (i == variants->len)
1947     {
1948       DEBUG ("Variant %s does not exist", variant);
1949       variant = g_ptr_array_index (variants, 0);
1950     }
1951
1952   return g_strdup_printf ("Variants/%s.css", variant);
1953
1954 }
1955
1956 const gchar *
1957 empathy_adium_info_get_default_variant (GHashTable *info)
1958 {
1959   if (adium_info_get_version (info) <= 2)
1960     return adium_info_get_no_variant_name (info);
1961
1962   return tp_asv_get_string (info, "DefaultVariant");
1963 }
1964
1965 GPtrArray *
1966 empathy_adium_info_get_available_variants (GHashTable *info)
1967 {
1968   GPtrArray *variants;
1969   const gchar *path;
1970   gchar *dirpath;
1971   GDir *dir;
1972
1973   variants = tp_asv_get_boxed (info, "AvailableVariants", G_TYPE_PTR_ARRAY);
1974   if (variants != NULL)
1975     return variants;
1976
1977   variants = g_ptr_array_new_with_free_func (g_free);
1978   tp_asv_take_boxed (info, g_strdup ("AvailableVariants"),
1979     G_TYPE_PTR_ARRAY, variants);
1980
1981   path = tp_asv_get_string (info, "path");
1982   dirpath = g_build_filename (path, "Contents", "Resources", "Variants", NULL);
1983   dir = g_dir_open (dirpath, 0, NULL);
1984   if (dir != NULL)
1985     {
1986       const gchar *name;
1987
1988       for (name = g_dir_read_name (dir);
1989            name != NULL;
1990            name = g_dir_read_name (dir))
1991         {
1992           gchar *display_name;
1993
1994           if (!g_str_has_suffix (name, ".css"))
1995             continue;
1996
1997           display_name = g_strdup (name);
1998           strstr (display_name, ".css")[0] = '\0';
1999           g_ptr_array_add (variants, display_name);
2000         }
2001
2002       g_dir_close (dir);
2003     }
2004   g_free (dirpath);
2005
2006   if (adium_info_get_version (info) <= 2)
2007     g_ptr_array_add (variants,
2008       g_strdup (adium_info_get_no_variant_name (info)));
2009
2010   return variants;
2011 }
2012
2013 GType
2014 empathy_adium_data_get_type (void)
2015 {
2016   static GType type_id = 0;
2017
2018   if (!type_id)
2019     {
2020       type_id = g_boxed_type_register_static ("EmpathyAdiumData",
2021           (GBoxedCopyFunc) empathy_adium_data_ref,
2022           (GBoxedFreeFunc) empathy_adium_data_unref);
2023     }
2024
2025   return type_id;
2026 }
2027
2028 EmpathyAdiumData *
2029 empathy_adium_data_new_with_info (const gchar *path,
2030     GHashTable *info)
2031 {
2032   EmpathyAdiumData *data;
2033   gchar *template_html = NULL;
2034   gchar *footer_html = NULL;
2035   gchar *tmp;
2036
2037   g_return_val_if_fail (empathy_adium_path_is_valid (path), NULL);
2038
2039   data = g_slice_new0 (EmpathyAdiumData);
2040   data->ref_count = 1;
2041   data->path = g_strdup (path);
2042   data->basedir = g_strconcat (path, G_DIR_SEPARATOR_S "Contents"
2043     G_DIR_SEPARATOR_S "Resources" G_DIR_SEPARATOR_S, NULL);
2044   data->info = g_hash_table_ref (info);
2045   data->version = adium_info_get_version (info);
2046   data->strings_to_free = g_ptr_array_new_with_free_func (g_free);
2047   data->date_format_cache = g_hash_table_new_full (g_str_hash,
2048     g_str_equal, g_free, g_free);
2049
2050   DEBUG ("Loading theme at %s", path);
2051
2052 #define LOAD(path, var) \
2053     tmp = g_build_filename (data->basedir, path, NULL); \
2054     g_file_get_contents (tmp, &var, NULL, NULL); \
2055     g_free (tmp); \
2056
2057 #define LOAD_CONST(path, var) \
2058   { \
2059     gchar *content; \
2060     LOAD (path, content); \
2061     if (content != NULL) { \
2062       g_ptr_array_add (data->strings_to_free, content); \
2063     } \
2064     var = content; \
2065   }
2066
2067   /* Load html files */
2068   LOAD_CONST ("Content.html", data->content_html);
2069   LOAD_CONST ("Incoming/Content.html", data->in_content_html);
2070   LOAD_CONST ("Incoming/NextContent.html", data->in_nextcontent_html);
2071   LOAD_CONST ("Incoming/Context.html", data->in_context_html);
2072   LOAD_CONST ("Incoming/NextContext.html", data->in_nextcontext_html);
2073   LOAD_CONST ("Outgoing/Content.html", data->out_content_html);
2074   LOAD_CONST ("Outgoing/NextContent.html", data->out_nextcontent_html);
2075   LOAD_CONST ("Outgoing/Context.html", data->out_context_html);
2076   LOAD_CONST ("Outgoing/NextContext.html", data->out_nextcontext_html);
2077   LOAD_CONST ("Status.html", data->status_html);
2078   LOAD ("Template.html", template_html);
2079   LOAD ("Footer.html", footer_html);
2080
2081 #undef LOAD_CONST
2082 #undef LOAD
2083
2084   /* HTML fallbacks: If we have at least content OR in_content, then
2085    * everything else gets a fallback */
2086
2087 #define FALLBACK(html, fallback) \
2088   if (html == NULL) { \
2089     html = fallback; \
2090   }
2091
2092   /* in_nextcontent -> in_content -> content */
2093   FALLBACK (data->in_content_html,      data->content_html);
2094   FALLBACK (data->in_nextcontent_html,  data->in_content_html);
2095
2096   /* context -> content */
2097   FALLBACK (data->in_context_html,      data->in_content_html);
2098   FALLBACK (data->in_nextcontext_html,  data->in_nextcontent_html);
2099   FALLBACK (data->out_context_html,     data->out_content_html);
2100   FALLBACK (data->out_nextcontext_html, data->out_nextcontent_html);
2101
2102   /* out -> in */
2103   FALLBACK (data->out_content_html,     data->in_content_html);
2104   FALLBACK (data->out_nextcontent_html, data->in_nextcontent_html);
2105   FALLBACK (data->out_context_html,     data->in_context_html);
2106   FALLBACK (data->out_nextcontext_html, data->in_nextcontext_html);
2107
2108   /* status -> in_content */
2109   FALLBACK (data->status_html,          data->in_content_html);
2110
2111 #undef FALLBACK
2112
2113   /* template -> empathy's template */
2114   data->custom_template = (template_html != NULL);
2115   if (template_html == NULL)
2116     {
2117       GError *error = NULL;
2118
2119       tmp = empathy_file_lookup ("Template.html", "data");
2120
2121       if (!g_file_get_contents (tmp, &template_html, NULL, &error)) {
2122         g_warning ("couldn't load Empathy's default theme "
2123           "template: %s", error->message);
2124         g_return_val_if_reached (data);
2125       }
2126
2127       g_free (tmp);
2128     }
2129
2130   /* Default avatar */
2131   tmp = g_build_filename (data->basedir, "Incoming", "buddy_icon.png", NULL);
2132   if (g_file_test (tmp, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR))
2133     {
2134       data->default_incoming_avatar_filename = tmp;
2135     }
2136   else
2137     {
2138       g_free (tmp);
2139     }
2140
2141   tmp = g_build_filename (data->basedir, "Outgoing", "buddy_icon.png", NULL);
2142   if (g_file_test (tmp, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR))
2143     {
2144       data->default_outgoing_avatar_filename = tmp;
2145     }
2146   else
2147     {
2148       g_free (tmp);
2149     }
2150
2151   /* Old custom templates had only 4 parameters.
2152    * New templates have 5 parameters */
2153   if (data->version <= 2 && data->custom_template)
2154     {
2155       tmp = string_with_format (template_html,
2156         data->basedir,
2157         "%@", /* Leave variant unset */
2158         "", /* The header */
2159         footer_html ? footer_html : "",
2160         NULL);
2161     }
2162   else
2163     {
2164       tmp = string_with_format (template_html,
2165         data->basedir,
2166         data->version <= 2 ? "" : "@import url( \"main.css\" );",
2167         "%@", /* Leave variant unset */
2168         "", /* The header */
2169         footer_html ? footer_html : "",
2170         NULL);
2171     }
2172   g_ptr_array_add (data->strings_to_free, tmp);
2173   data->template_html = tmp;
2174
2175   g_free (template_html);
2176   g_free (footer_html);
2177
2178   return data;
2179 }
2180
2181 EmpathyAdiumData *
2182 empathy_adium_data_new (const gchar *path)
2183 {
2184   EmpathyAdiumData *data;
2185   GHashTable *info;
2186
2187   info = empathy_adium_info_new (path);
2188   data = empathy_adium_data_new_with_info (path, info);
2189   g_hash_table_unref (info);
2190
2191   return data;
2192 }
2193
2194 EmpathyAdiumData *
2195 empathy_adium_data_ref (EmpathyAdiumData *data)
2196 {
2197   g_return_val_if_fail (data != NULL, NULL);
2198
2199   g_atomic_int_inc (&data->ref_count);
2200
2201   return data;
2202 }
2203
2204 void
2205 empathy_adium_data_unref (EmpathyAdiumData *data)
2206 {
2207   g_return_if_fail (data != NULL);
2208
2209   if (g_atomic_int_dec_and_test (&data->ref_count)) {
2210     g_free (data->path);
2211     g_free (data->basedir);
2212     g_free (data->default_avatar_filename);
2213     g_free (data->default_incoming_avatar_filename);
2214     g_free (data->default_outgoing_avatar_filename);
2215     g_hash_table_unref (data->info);
2216     g_ptr_array_unref (data->strings_to_free);
2217     tp_clear_pointer (&data->date_format_cache, g_hash_table_unref);
2218
2219     g_slice_free (EmpathyAdiumData, data);
2220   }
2221 }
2222
2223 GHashTable *
2224 empathy_adium_data_get_info (EmpathyAdiumData *data)
2225 {
2226   g_return_val_if_fail (data != NULL, NULL);
2227
2228   return data->info;
2229 }
2230
2231 const gchar *
2232 empathy_adium_data_get_path (EmpathyAdiumData *data)
2233 {
2234   g_return_val_if_fail (data != NULL, NULL);
2235
2236   return data->path;
2237 }