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