cc6482ee86be4c63c919510b428a10184eaf5d10
[empathy.git] / libempathy-gtk / gossip-chat-view.c
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
2 /*
3  * Copyright (C) 2002-2007 Imendio AB
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation; either version 2 of the
8  * License, or (at your option) any later version.
9  *
10  * This program 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  * General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public
16  * License along with this program; if not, write to the
17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18  * Boston, MA 02111-1307, USA.
19  * 
20  * Authors: Mikael Hallendal <micke@imendio.com>
21  *          Richard Hult <richard@imendio.com>
22  *          Martyn Russell <martyn@imendio.com>
23  */
24
25 #include "config.h"
26
27 #include <sys/types.h>
28 #include <string.h>
29 #include <time.h>
30
31 #include <glib/gi18n.h>
32 #include <gtk/gtkbutton.h>
33 #include <gtk/gtkimage.h>
34 #include <gtk/gtkmenu.h>
35 #include <gtk/gtkmenuitem.h>
36 #include <gtk/gtkimagemenuitem.h>
37 #include <gtk/gtkstock.h>
38 #include <gtk/gtkscrolledwindow.h>
39 #include <gtk/gtksizegroup.h>
40 #include <glade/glade.h>
41
42 #include <libmissioncontrol/mc-account.h>
43
44 #include <libempathy/gossip-utils.h>
45 #include <libempathy/gossip-debug.h>
46 #include <libempathy/gossip-conf.h>
47
48 #include "gossip-chat-view.h"
49 #include "gossip-chat.h"
50 #include "gossip-preferences.h"
51 #include "gossip-theme-manager.h"
52 #include "gossip-ui-utils.h"
53
54 #define DEBUG_DOMAIN "ChatView"
55
56 /* Number of seconds between timestamps when using normal mode, 5 minutes. */
57 #define TIMESTAMP_INTERVAL 300
58
59 #define MAX_LINES 800
60
61 #define GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GOSSIP_TYPE_CHAT_VIEW, GossipChatViewPriv))
62
63 typedef enum {
64         BLOCK_TYPE_NONE,
65         BLOCK_TYPE_SELF,
66         BLOCK_TYPE_OTHER,
67         BLOCK_TYPE_EVENT,
68         BLOCK_TYPE_TIME,
69         BLOCK_TYPE_INVITE
70 } BlockType;
71
72 struct _GossipChatViewPriv {
73         GtkTextBuffer *buffer;
74
75         gboolean       irc_style;
76         time_t         last_timestamp;
77         BlockType      last_block_type;
78
79         gboolean       allow_scrolling;
80         gboolean       is_group_chat;
81
82         GtkTextMark   *find_mark_previous;
83         GtkTextMark   *find_mark_next;
84         gboolean       find_wrapped;
85         gboolean       find_last_direction;
86
87         /* This is for the group chat so we know if the "other" last contact
88          * changed, so we know whether to insert a header or not.
89          */
90         GossipContact *last_contact;
91
92         guint          notify_system_fonts_id;
93         guint          notify_show_avatars_id;
94 };
95
96 typedef struct {
97         GossipSmiley  smiley;
98         const gchar  *pattern;
99 } GossipSmileyPattern;
100
101 static const GossipSmileyPattern smileys[] = {
102         /* Forward smileys. */
103         { GOSSIP_SMILEY_NORMAL,       ":)"  },
104         { GOSSIP_SMILEY_WINK,         ";)"  },
105         { GOSSIP_SMILEY_WINK,         ";-)" },
106         { GOSSIP_SMILEY_BIGEYE,       "=)"  },
107         { GOSSIP_SMILEY_NOSE,         ":-)" },
108         { GOSSIP_SMILEY_CRY,          ":'(" },
109         { GOSSIP_SMILEY_SAD,          ":("  },
110         { GOSSIP_SMILEY_SAD,          ":-(" },
111         { GOSSIP_SMILEY_SCEPTICAL,    ":/"  },
112         { GOSSIP_SMILEY_SCEPTICAL,    ":\\" },
113         { GOSSIP_SMILEY_BIGSMILE,     ":D"  },
114         { GOSSIP_SMILEY_BIGSMILE,     ":-D" },
115         { GOSSIP_SMILEY_INDIFFERENT,  ":|"  },
116         { GOSSIP_SMILEY_TOUNGE,       ":p"  },
117         { GOSSIP_SMILEY_TOUNGE,       ":-p" },
118         { GOSSIP_SMILEY_TOUNGE,       ":P"  },
119         { GOSSIP_SMILEY_TOUNGE,       ":-P" },
120         { GOSSIP_SMILEY_TOUNGE,       ";p"  },
121         { GOSSIP_SMILEY_TOUNGE,       ";-p" },
122         { GOSSIP_SMILEY_TOUNGE,       ";P"  },
123         { GOSSIP_SMILEY_TOUNGE,       ";-P" },
124         { GOSSIP_SMILEY_SHOCKED,      ":o"  },
125         { GOSSIP_SMILEY_SHOCKED,      ":-o" },
126         { GOSSIP_SMILEY_SHOCKED,      ":O"  },
127         { GOSSIP_SMILEY_SHOCKED,      ":-O" },
128         { GOSSIP_SMILEY_COOL,         "8)"  },
129         { GOSSIP_SMILEY_COOL,         "B)"  },
130         { GOSSIP_SMILEY_SORRY,        "*|"  },
131         { GOSSIP_SMILEY_KISS,         ":*"  },
132         { GOSSIP_SMILEY_SHUTUP,       ":#"  },
133         { GOSSIP_SMILEY_SHUTUP,       ":-#" },
134         { GOSSIP_SMILEY_YAWN,         "|O"  },
135         { GOSSIP_SMILEY_CONFUSED,     ":S"  },
136         { GOSSIP_SMILEY_CONFUSED,     ":s"  },
137         { GOSSIP_SMILEY_ANGEL,        "<)"  },
138         { GOSSIP_SMILEY_OOOH,         ":x"  },
139         { GOSSIP_SMILEY_LOOKAWAY,     "*)"  },
140         { GOSSIP_SMILEY_LOOKAWAY,     "*-)" },
141         { GOSSIP_SMILEY_BLUSH,        "*S"  },
142         { GOSSIP_SMILEY_BLUSH,        "*s"  },
143         { GOSSIP_SMILEY_BLUSH,        "*$"  },
144         { GOSSIP_SMILEY_COOLBIGSMILE, "8D"  },
145         { GOSSIP_SMILEY_ANGRY,        ":@"  },
146         { GOSSIP_SMILEY_BOSS,         "@)"  },
147         { GOSSIP_SMILEY_MONKEY,       "#)"  },
148         { GOSSIP_SMILEY_SILLY,        "O)"  },
149         { GOSSIP_SMILEY_SICK,         "+o(" },
150
151         /* Backward smileys. */
152         { GOSSIP_SMILEY_NORMAL,       "(:"  },
153         { GOSSIP_SMILEY_WINK,         "(;"  },
154         { GOSSIP_SMILEY_WINK,         "(-;" },
155         { GOSSIP_SMILEY_BIGEYE,       "(="  },
156         { GOSSIP_SMILEY_NOSE,         "(-:" },
157         { GOSSIP_SMILEY_CRY,          ")':" },
158         { GOSSIP_SMILEY_SAD,          "):"  },
159         { GOSSIP_SMILEY_SAD,          ")-:" },
160         { GOSSIP_SMILEY_SCEPTICAL,    "/:"  },
161         { GOSSIP_SMILEY_SCEPTICAL,    "//:" },
162         { GOSSIP_SMILEY_INDIFFERENT,  "|:"  },
163         { GOSSIP_SMILEY_TOUNGE,       "d:"  },
164         { GOSSIP_SMILEY_TOUNGE,       "d-:" },
165         { GOSSIP_SMILEY_TOUNGE,       "d;"  },
166         { GOSSIP_SMILEY_TOUNGE,       "d-;" },
167         { GOSSIP_SMILEY_SHOCKED,      "o:"  },
168         { GOSSIP_SMILEY_SHOCKED,      "O:"  },
169         { GOSSIP_SMILEY_COOL,         "(8"  },
170         { GOSSIP_SMILEY_COOL,         "(B"  },
171         { GOSSIP_SMILEY_SORRY,        "|*"  },
172         { GOSSIP_SMILEY_KISS,         "*:"  },
173         { GOSSIP_SMILEY_SHUTUP,       "#:"  },
174         { GOSSIP_SMILEY_SHUTUP,       "#-:" },
175         { GOSSIP_SMILEY_YAWN,         "O|"  },
176         { GOSSIP_SMILEY_CONFUSED,     "S:"  },
177         { GOSSIP_SMILEY_CONFUSED,     "s:"  },
178         { GOSSIP_SMILEY_ANGEL,        "(>"  },
179         { GOSSIP_SMILEY_OOOH,         "x:"  },
180         { GOSSIP_SMILEY_LOOKAWAY,     "(*"  },
181         { GOSSIP_SMILEY_LOOKAWAY,     "(-*" },
182         { GOSSIP_SMILEY_BLUSH,        "S*"  },
183         { GOSSIP_SMILEY_BLUSH,        "s*"  },
184         { GOSSIP_SMILEY_BLUSH,        "$*"  },
185         { GOSSIP_SMILEY_ANGRY,        "@:"  },
186         { GOSSIP_SMILEY_BOSS,         "(@"  },
187         { GOSSIP_SMILEY_MONKEY,       "#)"  },
188         { GOSSIP_SMILEY_SILLY,        "(O"  },
189         { GOSSIP_SMILEY_SICK,         ")o+" }
190 };
191
192 static void     gossip_chat_view_class_init          (GossipChatViewClass      *klass);
193 static void     gossip_chat_view_init                (GossipChatView           *view);
194 static void     chat_view_finalize                   (GObject                  *object);
195 static gboolean chat_view_drag_motion                (GtkWidget                *widget,
196                                                       GdkDragContext           *context,
197                                                       gint                      x,
198                                                       gint                      y,
199                                                       guint                     time);
200 static void     chat_view_size_allocate              (GtkWidget                *widget,
201                                                       GtkAllocation            *alloc);
202 static void     chat_view_setup_tags                 (GossipChatView           *view);
203 static void     chat_view_system_font_update         (GossipChatView           *view);
204 static void     chat_view_notify_system_font_cb      (GossipConf               *conf,
205                                                       const gchar              *key,
206                                                       gpointer                  user_data);
207 static void     chat_view_notify_show_avatars_cb     (GossipConf               *conf,
208                                                       const gchar              *key,
209                                                       gpointer                  user_data);
210 static void     chat_view_populate_popup             (GossipChatView           *view,
211                                                       GtkMenu                  *menu,
212                                                       gpointer                  user_data);
213 static gboolean chat_view_event_cb                   (GossipChatView           *view,
214                                                       GdkEventMotion           *event,
215                                                       GtkTextTag               *tag);
216 static gboolean chat_view_url_event_cb               (GtkTextTag               *tag,
217                                                       GObject                  *object,
218                                                       GdkEvent                 *event,
219                                                       GtkTextIter              *iter,
220                                                       GtkTextBuffer            *buffer);
221 static void     chat_view_open_address_cb            (GtkMenuItem              *menuitem,
222                                                       const gchar              *url);
223 static void     chat_view_copy_address_cb            (GtkMenuItem              *menuitem,
224                                                       const gchar              *url);
225 static void     chat_view_clear_view_cb              (GtkMenuItem              *menuitem,
226                                                       GossipChatView           *view);
227 static void     chat_view_insert_text_with_emoticons (GtkTextBuffer            *buf,
228                                                       GtkTextIter              *iter,
229                                                       const gchar              *str);
230 static gboolean chat_view_is_scrolled_down           (GossipChatView           *view);
231 static void     chat_view_theme_changed_cb           (GossipThemeManager       *manager,
232                                                       GossipChatView           *view);
233 static void     chat_view_maybe_append_date_and_time (GossipChatView           *view,
234                                                       GossipMessage            *msg);
235 static void     chat_view_append_spacing             (GossipChatView           *view);
236 static void     chat_view_append_text                (GossipChatView           *view,
237                                                       const gchar              *body,
238                                                       const gchar              *tag);
239 static void     chat_view_maybe_append_fancy_header  (GossipChatView           *view,
240                                                       GossipMessage            *msg);
241 static void     chat_view_append_irc_action          (GossipChatView           *view,
242                                                       GossipMessage            *msg);
243 static void     chat_view_append_fancy_action        (GossipChatView           *view,
244                                                       GossipMessage            *msg);
245 static void     chat_view_append_irc_message         (GossipChatView           *view,
246                                                       GossipMessage            *msg);
247 static void     chat_view_append_fancy_message       (GossipChatView           *view,
248                                                       GossipMessage            *msg);
249
250 G_DEFINE_TYPE (GossipChatView, gossip_chat_view, GTK_TYPE_TEXT_VIEW);
251
252 static void
253 gossip_chat_view_class_init (GossipChatViewClass *klass)
254 {
255         GObjectClass   *object_class = G_OBJECT_CLASS (klass);
256         GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
257
258         object_class->finalize = chat_view_finalize;
259         widget_class->size_allocate = chat_view_size_allocate;
260         widget_class->drag_motion = chat_view_drag_motion; 
261
262         g_type_class_add_private (object_class, sizeof (GossipChatViewPriv));
263 }
264
265 static void
266 gossip_chat_view_init (GossipChatView *view)
267 {
268         GossipChatViewPriv *priv;
269         gboolean            show_avatars;
270
271         priv = GET_PRIV (view);
272
273         priv->buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
274
275         priv->last_block_type = BLOCK_TYPE_NONE;
276         priv->last_timestamp = 0;
277
278         priv->allow_scrolling = TRUE;
279
280         priv->is_group_chat = FALSE;
281
282         g_object_set (view,
283                       "wrap-mode", GTK_WRAP_WORD_CHAR,
284                       "editable", FALSE,
285                       "cursor-visible", FALSE,
286                       NULL);
287
288         priv->notify_system_fonts_id =
289                 gossip_conf_notify_add (gossip_conf_get (),
290                                          "/desktop/gnome/interface/document_font_name",
291                                          chat_view_notify_system_font_cb,
292                                          view);
293         chat_view_system_font_update (view);
294
295         priv->notify_show_avatars_id =
296                 gossip_conf_notify_add (gossip_conf_get (),
297                                          GOSSIP_PREFS_UI_SHOW_AVATARS,
298                                          chat_view_notify_show_avatars_cb,
299                                          view);
300
301         chat_view_setup_tags (view);
302
303         gossip_theme_manager_apply_saved (gossip_theme_manager_get (), view);
304
305         show_avatars = FALSE;
306         gossip_conf_get_bool (gossip_conf_get (),
307                                GOSSIP_PREFS_UI_SHOW_AVATARS,
308                                &show_avatars);
309
310         gossip_theme_manager_update_show_avatars (gossip_theme_manager_get (),
311                                                   view, show_avatars);
312
313         g_signal_connect (view,
314                           "populate-popup",
315                           G_CALLBACK (chat_view_populate_popup),
316                           NULL);
317
318         g_signal_connect_object (gossip_theme_manager_get (),
319                                  "theme-changed",
320                                  G_CALLBACK (chat_view_theme_changed_cb),
321                                  view,
322                                  0);
323 }
324
325 static void
326 chat_view_finalize (GObject *object)
327 {
328         GossipChatView     *view;
329         GossipChatViewPriv *priv;
330
331         view = GOSSIP_CHAT_VIEW (object);
332         priv = GET_PRIV (view);
333
334         gossip_debug (DEBUG_DOMAIN, "finalize: %p", object);
335
336         gossip_conf_notify_remove (gossip_conf_get (), priv->notify_system_fonts_id);
337         gossip_conf_notify_remove (gossip_conf_get (), priv->notify_show_avatars_id);
338
339         if (priv->last_contact) {
340                 g_object_unref (priv->last_contact);
341         }
342
343         G_OBJECT_CLASS (gossip_chat_view_parent_class)->finalize (object);
344 }
345
346 static gboolean
347 chat_view_drag_motion (GtkWidget        *widget,
348                        GdkDragContext   *context,
349                        gint              x,
350                        gint              y,
351                        guint             time)
352 {
353         /* Don't handle drag motion, since we don't want the view to scroll as
354          * the result of dragging something across it.
355          */
356
357         return FALSE;
358 }
359
360 static void
361 chat_view_size_allocate (GtkWidget     *widget,
362                          GtkAllocation *alloc)
363 {
364         gboolean down;
365
366         down = chat_view_is_scrolled_down (GOSSIP_CHAT_VIEW (widget));
367
368         GTK_WIDGET_CLASS (gossip_chat_view_parent_class)->size_allocate (widget, alloc);
369
370         if (down) {
371                 gossip_chat_view_scroll_down (GOSSIP_CHAT_VIEW (widget));
372         }
373 }
374
375 static void
376 chat_view_setup_tags (GossipChatView *view)
377 {
378         GossipChatViewPriv *priv;
379         GtkTextTag         *tag;
380
381         priv = GET_PRIV (view);
382
383         gtk_text_buffer_create_tag (priv->buffer,
384                                     "cut",
385                                     NULL);
386
387         /* FIXME: Move to the theme and come up with something that looks a bit
388          * nicer.
389          */
390         gtk_text_buffer_create_tag (priv->buffer,
391                                     "highlight",
392                                     "background", "yellow",
393                                     NULL);
394
395         tag = gtk_text_buffer_create_tag (priv->buffer,
396                                           "link",
397                                           NULL);
398
399         g_signal_connect (tag,
400                           "event",
401                           G_CALLBACK (chat_view_url_event_cb),
402                           priv->buffer);
403
404         g_signal_connect (view,
405                           "motion-notify-event",
406                           G_CALLBACK (chat_view_event_cb),
407                           tag);
408 }
409
410 static void
411 chat_view_system_font_update (GossipChatView *view)
412 {
413         PangoFontDescription *font_description = NULL;
414         gchar                *font_name;
415
416         if (gossip_conf_get_string (gossip_conf_get (),
417                                      "/desktop/gnome/interface/document_font_name",
418                                      &font_name) && font_name) {
419                 font_description = pango_font_description_from_string (font_name);
420                 g_free (font_name);
421         } else {
422                 font_description = NULL;
423         }
424
425         gtk_widget_modify_font (GTK_WIDGET (view), font_description);
426
427         if (font_description) {
428                 pango_font_description_free (font_description);
429         }
430 }
431
432 static void
433 chat_view_notify_system_font_cb (GossipConf  *conf,
434                                  const gchar *key,
435                                  gpointer     user_data)
436 {
437         GossipChatView *view;
438         gboolean        show_avatars = FALSE;
439
440         view = user_data;
441
442         chat_view_system_font_update (view);
443
444         /* Ugly, again, to adjust the vertical position of the nick... Will fix
445          * this when reworking the theme manager so that view register
446          * themselves with it instead of the other way around.
447          */
448         gossip_conf_get_bool (conf,
449                                GOSSIP_PREFS_UI_SHOW_AVATARS,
450                                &show_avatars);
451
452         gossip_theme_manager_update_show_avatars (gossip_theme_manager_get (),
453                                                   view, show_avatars);
454 }
455
456 static void
457 chat_view_notify_show_avatars_cb (GossipConf  *conf,
458                                   const gchar *key,
459                                   gpointer     user_data)
460 {
461         GossipChatView     *view;
462         GossipChatViewPriv *priv;
463         gboolean            show_avatars = FALSE;
464
465         view = user_data;
466         priv = GET_PRIV (view);
467
468         gossip_conf_get_bool (conf, key, &show_avatars);
469
470         gossip_theme_manager_update_show_avatars (gossip_theme_manager_get (),
471                                                   view, show_avatars);
472 }
473
474 static void
475 chat_view_populate_popup (GossipChatView *view,
476                           GtkMenu        *menu,
477                           gpointer        user_data)
478 {
479         GossipChatViewPriv *priv;
480         GtkTextTagTable    *table;
481         GtkTextTag         *tag;
482         gint                x, y;
483         GtkTextIter         iter, start, end;
484         GtkWidget          *item;
485         gchar              *str = NULL;
486
487         priv = GET_PRIV (view);
488
489         /* Clear menu item */
490         if (gtk_text_buffer_get_char_count (priv->buffer) > 0) {
491                 item = gtk_menu_item_new ();
492                 gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
493                 gtk_widget_show (item);
494
495                 item = gtk_image_menu_item_new_from_stock (GTK_STOCK_CLEAR, NULL);
496                 gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
497                 gtk_widget_show (item);
498
499                 g_signal_connect (item,
500                                   "activate",
501                                   G_CALLBACK (chat_view_clear_view_cb),
502                                   view);
503         }
504
505         /* Link context menu items */
506         table = gtk_text_buffer_get_tag_table (priv->buffer);
507         tag = gtk_text_tag_table_lookup (table, "link");
508
509         gtk_widget_get_pointer (GTK_WIDGET (view), &x, &y);
510
511         gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (view),
512                                                GTK_TEXT_WINDOW_WIDGET,
513                                                x, y,
514                                                &x, &y);
515
516         gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (view), &iter, x, y);
517
518         start = end = iter;
519
520         if (gtk_text_iter_backward_to_tag_toggle (&start, tag) &&
521             gtk_text_iter_forward_to_tag_toggle (&end, tag)) {
522                 str = gtk_text_buffer_get_text (priv->buffer,
523                                                 &start, &end, FALSE);
524         }
525
526         if (G_STR_EMPTY (str)) {
527                 g_free (str);
528                 return;
529         }
530
531         /* NOTE: Set data just to get the string freed when not needed. */
532         g_object_set_data_full (G_OBJECT (menu),
533                                 "url", str,
534                                 (GDestroyNotify) g_free);
535
536         item = gtk_menu_item_new ();
537         gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
538         gtk_widget_show (item);
539
540         item = gtk_menu_item_new_with_mnemonic (_("_Copy Link Address"));
541         g_signal_connect (item,
542                           "activate",
543                           G_CALLBACK (chat_view_copy_address_cb),
544                           str);
545         gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
546         gtk_widget_show (item);
547
548         item = gtk_menu_item_new_with_mnemonic (_("_Open Link"));
549         g_signal_connect (item,
550                           "activate",
551                           G_CALLBACK (chat_view_open_address_cb),
552                           str);
553         gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
554         gtk_widget_show (item);
555 }
556
557 static gboolean
558 chat_view_event_cb (GossipChatView *view,
559                     GdkEventMotion *event,
560                     GtkTextTag     *tag)
561 {
562         static GdkCursor  *hand = NULL;
563         static GdkCursor  *beam = NULL;
564         GtkTextWindowType  type;
565         GtkTextIter        iter;
566         GdkWindow         *win;
567         gint               x, y, buf_x, buf_y;
568
569         type = gtk_text_view_get_window_type (GTK_TEXT_VIEW (view),
570                                               event->window);
571
572         if (type != GTK_TEXT_WINDOW_TEXT) {
573                 return FALSE;
574         }
575
576         /* Get where the pointer really is. */
577         win = gtk_text_view_get_window (GTK_TEXT_VIEW (view), type);
578         if (!win) {
579                 return FALSE;
580         }
581
582         gdk_window_get_pointer (win, &x, &y, NULL);
583
584         /* Get the iter where the cursor is at */
585         gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (view), type,
586                                                x, y,
587                                                &buf_x, &buf_y);
588
589         gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (view),
590                                             &iter,
591                                             buf_x, buf_y);
592
593         if (gtk_text_iter_has_tag (&iter, tag)) {
594                 if (!hand) {
595                         hand = gdk_cursor_new (GDK_HAND2);
596                         beam = gdk_cursor_new (GDK_XTERM);
597                 }
598                 gdk_window_set_cursor (win, hand);
599         } else {
600                 if (!beam) {
601                         beam = gdk_cursor_new (GDK_XTERM);
602                 }
603                 gdk_window_set_cursor (win, beam);
604         }
605
606         return FALSE;
607 }
608
609 static gboolean
610 chat_view_url_event_cb (GtkTextTag    *tag,
611                         GObject       *object,
612                         GdkEvent      *event,
613                         GtkTextIter   *iter,
614                         GtkTextBuffer *buffer)
615 {
616         GtkTextIter  start, end;
617         gchar       *str;
618
619         /* If the link is being selected, don't do anything. */
620         gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
621         if (gtk_text_iter_get_offset (&start) != gtk_text_iter_get_offset (&end)) {
622                 return FALSE;
623         }
624
625         if (event->type == GDK_BUTTON_RELEASE && event->button.button == 1) {
626                 start = end = *iter;
627
628                 if (gtk_text_iter_backward_to_tag_toggle (&start, tag) &&
629                     gtk_text_iter_forward_to_tag_toggle (&end, tag)) {
630                         str = gtk_text_buffer_get_text (buffer,
631                                                         &start,
632                                                         &end,
633                                                         FALSE);
634
635                         gossip_url_show (str);
636                         g_free (str);
637                 }
638         }
639
640         return FALSE;
641 }
642
643 static void
644 chat_view_open_address_cb (GtkMenuItem *menuitem, const gchar *url)
645 {
646         gossip_url_show (url);
647 }
648
649 static void
650 chat_view_copy_address_cb (GtkMenuItem *menuitem, const gchar *url)
651 {
652         GtkClipboard *clipboard;
653
654         clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
655         gtk_clipboard_set_text (clipboard, url, -1);
656
657         clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
658         gtk_clipboard_set_text (clipboard, url, -1);
659 }
660
661 static void
662 chat_view_clear_view_cb (GtkMenuItem *menuitem, GossipChatView *view)
663 {
664         gossip_chat_view_clear (view);
665 }
666
667 static void
668 chat_view_insert_text_with_emoticons (GtkTextBuffer *buf,
669                                       GtkTextIter   *iter,
670                                       const gchar   *str)
671 {
672         const gchar *p;
673         gunichar     c, prev_c;
674         gint         i;
675         gint         match;
676         gint         submatch;
677         gboolean     use_smileys = FALSE;
678
679         gossip_conf_get_bool (gossip_conf_get (),
680                                GOSSIP_PREFS_CHAT_SHOW_SMILEYS,
681                                &use_smileys);
682
683         if (!use_smileys) {
684                 gtk_text_buffer_insert (buf, iter, str, -1);
685                 return;
686         }
687
688         while (*str) {
689                 gint         smileys_index[G_N_ELEMENTS (smileys)];
690                 GdkPixbuf   *pixbuf;
691                 gint         len;
692                 const gchar *start;
693
694                 memset (smileys_index, 0, sizeof (smileys_index));
695
696                 match = -1;
697                 submatch = -1;
698                 p = str;
699                 prev_c = 0;
700
701                 while (*p) {
702                         c = g_utf8_get_char (p);
703
704                         if (match != -1 && g_unichar_isspace (c)) {
705                                 break;
706                         } else {
707                                 match = -1;
708                         }
709
710                         if (submatch != -1 || prev_c == 0 || g_unichar_isspace (prev_c)) {
711                                 submatch = -1;
712
713                                 for (i = 0; i < G_N_ELEMENTS (smileys); i++) {
714                                         /* Only try to match if we already have
715                                          * a beginning match for the pattern, or
716                                          * if it's the first character in the
717                                          * pattern, if it's not in the middle of
718                                          * a word.
719                                          */
720                                         if (((smileys_index[i] == 0 && (prev_c == 0 || g_unichar_isspace (prev_c))) ||
721                                              smileys_index[i] > 0) &&
722                                             smileys[i].pattern[smileys_index[i]] == c) {
723                                                 submatch = i;
724
725                                                 smileys_index[i]++;
726                                                 if (!smileys[i].pattern[smileys_index[i]]) {
727                                                         match = i;
728                                                 }
729                                         } else {
730                                                 smileys_index[i] = 0;
731                                         }
732                                 }
733                         }
734
735                         prev_c = c;
736                         p = g_utf8_next_char (p);
737                 }
738
739                 if (match == -1) {
740                         gtk_text_buffer_insert (buf, iter, str, -1);
741                         return;
742                 }
743
744                 start = p - strlen (smileys[match].pattern);
745
746                 if (start > str) {
747                         len = start - str;
748                         gtk_text_buffer_insert (buf, iter, str, len);
749                 }
750
751                 pixbuf = gossip_chat_view_get_smiley_image (smileys[match].smiley);
752                 gtk_text_buffer_insert_pixbuf (buf, iter, pixbuf);
753
754                 gtk_text_buffer_insert (buf, iter, " ", 1);
755
756                 str = g_utf8_find_next_char (p, NULL);
757         }
758 }
759
760 static gboolean
761 chat_view_is_scrolled_down (GossipChatView *view)
762 {
763         GtkWidget *sw;
764
765         sw = gtk_widget_get_parent (GTK_WIDGET (view));
766         if (GTK_IS_SCROLLED_WINDOW (sw)) {
767                 GtkAdjustment *vadj;
768
769                 vadj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (sw));
770
771                 if (vadj->value + vadj->page_size / 2 < vadj->upper - vadj->page_size) {
772                         return FALSE;
773                 }
774         }
775
776         return TRUE;
777 }
778
779 static void
780 chat_view_maybe_trim_buffer (GossipChatView *view)
781 {
782         GossipChatViewPriv *priv;
783         GtkTextIter         top, bottom;
784         gint                line;
785         gint                remove;
786         GtkTextTagTable    *table;
787         GtkTextTag         *tag;
788
789         priv = GET_PRIV (view);
790
791         gtk_text_buffer_get_end_iter (priv->buffer, &bottom);
792         line = gtk_text_iter_get_line (&bottom);
793         if (line < MAX_LINES) {
794                 return;
795         }
796
797         remove = line - MAX_LINES;
798         gtk_text_buffer_get_start_iter (priv->buffer, &top);
799
800         bottom = top;
801         if (!gtk_text_iter_forward_lines (&bottom, remove)) {
802                 return;
803         }
804
805         /* Track backwords to a place where we can safely cut, we don't do it in
806          * the middle of a tag.
807          */
808         table = gtk_text_buffer_get_tag_table (priv->buffer);
809         tag = gtk_text_tag_table_lookup (table, "cut");
810         if (!tag) {
811                 return;
812         }
813
814         if (!gtk_text_iter_forward_to_tag_toggle (&bottom, tag)) {
815                 return;
816         }
817
818         if (!gtk_text_iter_equal (&top, &bottom)) {
819                 gtk_text_buffer_delete (priv->buffer, &top, &bottom);
820         }
821 }
822
823 static void
824 chat_view_maybe_append_date_and_time (GossipChatView *view,
825                                       GossipMessage  *msg)
826 {
827         GossipChatViewPriv *priv;
828         const gchar        *tag;
829         time_t              timestamp;
830         GDate              *date, *last_date;
831         GtkTextIter         iter;
832         gboolean            append_date, append_time;
833         GString            *str;
834
835         priv = GET_PRIV (view);
836
837         if (priv->irc_style) {
838                 tag = "irc-time";
839         } else {
840                 tag = "fancy-time";
841         }
842
843         if (priv->last_block_type == BLOCK_TYPE_TIME) {
844                 return;
845         }
846
847         str = g_string_new (NULL);
848
849         timestamp = 0;
850         if (msg) {
851                 timestamp = gossip_message_get_timestamp (msg);
852         }
853
854         if (timestamp <= 0) {
855                 timestamp = gossip_time_get_current ();
856         }
857
858         date = g_date_new ();
859         g_date_set_time (date, timestamp);
860
861         last_date = g_date_new ();
862         g_date_set_time (last_date, priv->last_timestamp);
863
864         append_date = FALSE;
865         append_time = FALSE;
866
867         if (g_date_compare (date, last_date) > 0) {
868                 append_date = TRUE;
869                 append_time = TRUE;
870         }
871
872         if (priv->last_timestamp + TIMESTAMP_INTERVAL < timestamp) {
873                 append_time = TRUE;
874         }
875
876         if (append_time || append_date) {
877                 chat_view_append_spacing (view);
878
879                 g_string_append (str, "- ");
880         }
881
882         if (append_date) {
883                 gchar buf[256];
884
885                 g_date_strftime (buf, 256, _("%A %d %B %Y"), date);
886                 g_string_append (str, buf);
887
888                 if (append_time) {
889                         g_string_append (str, ", ");
890                 }
891         }
892
893         g_date_free (date);
894         g_date_free (last_date);
895
896         if (append_time) {
897                 gchar *tmp;
898
899                 tmp = gossip_time_to_string_local (timestamp, GOSSIP_TIME_FORMAT_DISPLAY_SHORT);
900                 g_string_append (str, tmp);
901                 g_free (tmp);
902         }
903
904         if (append_time || append_date) {
905                 g_string_append (str, " -\n");
906
907                 gtk_text_buffer_get_end_iter (priv->buffer, &iter);
908                 gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
909                                                           &iter,
910                                                           str->str, -1,
911                                                           tag,
912                                                           NULL);
913
914                 priv->last_block_type = BLOCK_TYPE_TIME;
915                 priv->last_timestamp = timestamp;
916         }
917
918         g_string_free (str, TRUE);
919 }
920
921 static void
922 chat_view_append_spacing (GossipChatView *view)
923 {
924         GossipChatViewPriv *priv;
925         const gchar        *tag;
926         GtkTextIter         iter;
927
928         priv = GET_PRIV (view);
929
930         if (priv->irc_style) {
931                 tag = "irc-spacing";
932         } else {
933                 tag = "fancy-spacing";
934         }
935
936         gtk_text_buffer_get_end_iter (priv->buffer, &iter);
937         gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
938                                                   &iter,
939                                                   "\n",
940                                                   -1,
941                                                   "cut",
942                                                   tag,
943                                                   NULL);
944 }
945
946 static void
947 chat_view_append_text (GossipChatView *view,
948                        const gchar    *body,
949                        const gchar    *tag)
950 {
951         GossipChatViewPriv *priv;
952         GtkTextIter         start_iter, end_iter;
953         GtkTextMark        *mark;
954         GtkTextIter         iter;
955         gint                num_matches, i;
956         GArray             *start, *end;
957         const gchar        *link_tag;
958
959         priv = GET_PRIV (view);
960
961         if (priv->irc_style) {
962                 link_tag = "irc-link";
963         } else {
964                 link_tag = "fancy-link";
965         }
966
967         gtk_text_buffer_get_end_iter (priv->buffer, &start_iter);
968         mark = gtk_text_buffer_create_mark (priv->buffer, NULL, &start_iter, TRUE);
969
970         start = g_array_new (FALSE, FALSE, sizeof (gint));
971         end = g_array_new (FALSE, FALSE, sizeof (gint));
972
973         num_matches = gossip_regex_match (GOSSIP_REGEX_ALL, body, start, end);
974
975         if (num_matches == 0) {
976                 gtk_text_buffer_get_end_iter (priv->buffer, &iter);
977                 chat_view_insert_text_with_emoticons (priv->buffer, &iter, body);
978         } else {
979                 gint   last = 0;
980                 gint   s = 0, e = 0;
981                 gchar *tmp;
982
983                 for (i = 0; i < num_matches; i++) {
984                         s = g_array_index (start, gint, i);
985                         e = g_array_index (end, gint, i);
986
987                         if (s > last) {
988                                 tmp = gossip_substring (body, last, s);
989
990                                 gtk_text_buffer_get_end_iter (priv->buffer, &iter);
991                                 chat_view_insert_text_with_emoticons (priv->buffer,
992                                                                       &iter,
993                                                                       tmp);
994                                 g_free (tmp);
995                         }
996
997                         tmp = gossip_substring (body, s, e);
998
999                         gtk_text_buffer_get_end_iter (priv->buffer, &iter);
1000                         gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
1001                                                                   &iter,
1002                                                                   tmp,
1003                                                                   -1,
1004                                                                   link_tag,
1005                                                                   "link",
1006                                                                   NULL);
1007
1008                         g_free (tmp);
1009
1010                         last = e;
1011                 }
1012
1013                 if (e < strlen (body)) {
1014                         tmp = gossip_substring (body, e, strlen (body));
1015
1016                         gtk_text_buffer_get_end_iter (priv->buffer, &iter);
1017                         chat_view_insert_text_with_emoticons (priv->buffer,
1018                                                               &iter,
1019                                                               tmp);
1020                         g_free (tmp);
1021                 }
1022         }
1023
1024         g_array_free (start, TRUE);
1025         g_array_free (end, TRUE);
1026
1027         gtk_text_buffer_get_end_iter (priv->buffer, &iter);
1028         gtk_text_buffer_insert (priv->buffer, &iter, "\n", 1);
1029
1030         /* Apply the style to the inserted text. */
1031         gtk_text_buffer_get_iter_at_mark (priv->buffer, &start_iter, mark);
1032         gtk_text_buffer_get_end_iter (priv->buffer, &end_iter);
1033
1034         gtk_text_buffer_apply_tag_by_name (priv->buffer,
1035                                            tag,
1036                                            &start_iter,
1037                                            &end_iter);
1038
1039         gtk_text_buffer_delete_mark (priv->buffer, mark);
1040 }
1041
1042 static void
1043 chat_view_maybe_append_fancy_header (GossipChatView *view,
1044                                      GossipMessage  *msg)
1045 {
1046         GossipChatViewPriv *priv;
1047         GossipContact      *sender;
1048         GossipContact      *my_contact;
1049         const gchar        *name;
1050         gboolean            header;
1051         GtkTextIter         iter;
1052         gchar              *tmp;
1053         const gchar        *tag;
1054         const gchar        *avatar_tag;
1055         const gchar        *line_top_tag;
1056         const gchar        *line_bottom_tag;
1057         gboolean            from_self;
1058         GdkPixbuf          *avatar;
1059
1060         priv = GET_PRIV (view);
1061
1062         sender = gossip_message_get_sender (msg);
1063         my_contact = gossip_get_own_contact_from_contact (sender);
1064         name = gossip_contact_get_name (sender);
1065         from_self = gossip_contact_equal (sender, my_contact);
1066
1067         gossip_debug (DEBUG_DOMAIN, "Maybe add fancy header");
1068
1069         if (from_self) {
1070                 tag = "fancy-header-self";
1071                 line_top_tag = "fancy-line-top-self";
1072                 line_bottom_tag = "fancy-line-bottom-self";
1073         } else {
1074                 tag = "fancy-header-other";
1075                 line_top_tag = "fancy-line-top-other";
1076                 line_bottom_tag = "fancy-line-bottom-other";
1077         }
1078
1079         header = FALSE;
1080
1081         /* Only insert a header if the previously inserted block is not the same
1082          * as this one. This catches all the different cases:
1083          */
1084         if (priv->last_block_type != BLOCK_TYPE_SELF &&
1085             priv->last_block_type != BLOCK_TYPE_OTHER) {
1086                 header = TRUE;
1087         }
1088         else if (from_self && priv->last_block_type == BLOCK_TYPE_OTHER) {
1089                 header = TRUE;
1090         }
1091         else if (!from_self && priv->last_block_type == BLOCK_TYPE_SELF) {
1092                 header = TRUE;
1093         }
1094         else if (!from_self &&
1095                  (!priv->last_contact ||
1096                   !gossip_contact_equal (sender, priv->last_contact))) {
1097                 header = TRUE;
1098         }
1099
1100         if (!header) {
1101                 return;
1102         }
1103
1104         chat_view_append_spacing (view);
1105
1106         gtk_text_buffer_get_end_iter (priv->buffer, &iter);
1107         gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
1108                                                   &iter,
1109                                                   "\n",
1110                                                   -1,
1111                                                   line_top_tag,
1112                                                   NULL);
1113
1114         avatar = gossip_pixbuf_avatar_from_contact_scaled (sender, 32, 32);
1115
1116         if (avatar) {
1117                 GtkTextIter start;
1118
1119                 gtk_text_buffer_get_end_iter (priv->buffer, &iter);
1120                 gtk_text_buffer_insert_pixbuf (priv->buffer, &iter, avatar);
1121
1122                 gtk_text_buffer_get_end_iter (priv->buffer, &iter);
1123                 start = iter;
1124                 gtk_text_iter_backward_char (&start);
1125
1126                 if (from_self) {
1127                         gtk_text_buffer_apply_tag_by_name (priv->buffer,
1128                                                            "fancy-avatar-self",
1129                                                            &start, &iter);
1130                         avatar_tag = "fancy-header-self-avatar";
1131                 } else {
1132                         gtk_text_buffer_apply_tag_by_name (priv->buffer,
1133                                                            "fancy-avatar-other",
1134                                                            &start, &iter);
1135                         avatar_tag = "fancy-header-other-avatar";
1136                 }
1137
1138                 g_object_unref (avatar);
1139         } else {
1140                 avatar_tag = NULL;
1141         }
1142
1143         tmp = g_strdup_printf ("%s\n", name);
1144
1145         gtk_text_buffer_get_end_iter (priv->buffer, &iter);
1146         gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
1147                                                   &iter,
1148                                                   tmp,
1149                                                   -1,
1150                                                   tag,
1151                                                   avatar_tag,
1152                                                   NULL);
1153         g_free (tmp);
1154
1155         gtk_text_buffer_get_end_iter (priv->buffer, &iter);
1156         gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
1157                                                   &iter,
1158                                                   "\n",
1159                                                   -1,
1160                                                   line_bottom_tag,
1161                                                   NULL);
1162 }
1163
1164 static void
1165 chat_view_append_irc_action (GossipChatView *view,
1166                              GossipMessage  *msg)
1167 {
1168         GossipChatViewPriv *priv;
1169         GossipContact      *my_contact;
1170         GossipContact      *sender;
1171         const gchar        *name;
1172         GtkTextIter         iter;
1173         const gchar        *body;
1174         gchar              *tmp;
1175         const gchar        *tag;
1176
1177         priv = GET_PRIV (view);
1178
1179         gossip_debug (DEBUG_DOMAIN, "Add IRC action");
1180
1181         sender = gossip_message_get_sender (msg);
1182         my_contact = gossip_get_own_contact_from_contact (sender);
1183         name = gossip_contact_get_name (sender);
1184
1185         /* Skip the "/me ". */
1186         if (gossip_contact_equal (sender, my_contact)) {
1187                 tag = "irc-action-self";
1188         } else {
1189                 tag = "irc-action-other";
1190         }
1191
1192         if (priv->last_block_type != BLOCK_TYPE_SELF &&
1193             priv->last_block_type != BLOCK_TYPE_OTHER) {
1194                 chat_view_append_spacing (view);
1195         }
1196
1197         gtk_text_buffer_get_end_iter (priv->buffer, &iter);
1198
1199         tmp = g_strdup_printf (" * %s ", name);
1200         gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
1201                                                   &iter,
1202                                                   tmp,
1203                                                   -1,
1204                                                   "cut",
1205                                                   tag,
1206                                                   NULL);
1207         g_free (tmp);
1208
1209         body = gossip_message_get_body (msg);
1210         chat_view_append_text (view, body, tag);
1211 }
1212
1213 static void
1214 chat_view_append_fancy_action (GossipChatView *view,
1215                                GossipMessage  *msg)
1216 {
1217         GossipChatViewPriv *priv;
1218         GossipContact      *sender;
1219         GossipContact      *my_contact;
1220         const gchar        *name;
1221         const gchar        *body;
1222         GtkTextIter         iter;
1223         gchar              *tmp;
1224         const gchar        *tag;
1225         const gchar        *line_tag;
1226
1227         priv = GET_PRIV (view);
1228
1229         gossip_debug (DEBUG_DOMAIN, "Add fancy action");
1230
1231         sender = gossip_message_get_sender (msg);
1232         my_contact = gossip_get_own_contact_from_contact (sender);
1233         name = gossip_contact_get_name (sender);
1234
1235         if (gossip_contact_equal (sender, my_contact)) {
1236                 tag = "fancy-action-self";
1237                 line_tag = "fancy-line-self";
1238         } else {
1239                 tag = "fancy-action-other";
1240                 line_tag = "fancy-line-other";
1241         }
1242
1243         tmp = g_strdup_printf (" * %s ", name);
1244         gtk_text_buffer_get_end_iter (priv->buffer, &iter);
1245         gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
1246                                                   &iter,
1247                                                   tmp,
1248                                                   -1,
1249                                                   tag,
1250                                                   NULL);
1251         g_free (tmp);
1252
1253         body = gossip_message_get_body (msg);
1254         chat_view_append_text (view, body, tag);
1255 }
1256
1257 static void
1258 chat_view_append_irc_message (GossipChatView *view,
1259                               GossipMessage  *msg)
1260 {
1261         GossipChatViewPriv *priv;
1262         GossipContact      *sender;
1263         GossipContact      *my_contact;
1264         const gchar        *name;
1265         const gchar        *body;
1266         const gchar        *nick_tag;
1267         const gchar        *body_tag;
1268         GtkTextIter         iter;
1269         gchar              *tmp;
1270
1271         priv = GET_PRIV (view);
1272
1273         gossip_debug (DEBUG_DOMAIN, "Add IRC message");
1274
1275         body = gossip_message_get_body (msg);
1276         sender = gossip_message_get_sender (msg);
1277         my_contact = gossip_get_own_contact_from_contact (sender);
1278         name = gossip_contact_get_name (sender);
1279
1280         if (gossip_contact_equal (sender, my_contact)) {
1281                 nick_tag = "irc-nick-self";
1282                 body_tag = "irc-body-self";
1283         } else {
1284                 if (gossip_chat_should_highlight_nick (msg)) {
1285                         nick_tag = "irc-nick-highlight";
1286                 } else {
1287                         nick_tag = "irc-nick-other";
1288                 }
1289
1290                 body_tag = "irc-body-other";
1291         }
1292
1293         if (priv->last_block_type != BLOCK_TYPE_SELF &&
1294             priv->last_block_type != BLOCK_TYPE_OTHER) {
1295                 chat_view_append_spacing (view);
1296         }
1297
1298         gtk_text_buffer_get_end_iter (priv->buffer, &iter);
1299
1300         /* The nickname. */
1301         tmp = g_strdup_printf ("%s: ", name);
1302         gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
1303                                                   &iter,
1304                                                   tmp,
1305                                                   -1,
1306                                                   "cut",
1307                                                   nick_tag,
1308                                                   NULL);
1309         g_free (tmp);
1310
1311         /* The text body. */
1312         chat_view_append_text (view, body, body_tag);
1313 }
1314
1315 static void
1316 chat_view_append_fancy_message (GossipChatView *view,
1317                                 GossipMessage  *msg)
1318 {
1319         GossipChatViewPriv *priv;
1320         GossipContact      *sender;
1321         GossipContact      *my_contact;
1322         const gchar        *body;
1323         const gchar        *tag;
1324
1325         priv = GET_PRIV (view);
1326
1327         sender = gossip_message_get_sender (msg);
1328         my_contact = gossip_get_own_contact_from_contact (sender);
1329
1330         if (gossip_contact_equal (sender, my_contact)) {
1331                 tag = "fancy-body-self";
1332         } else {
1333                 tag = "fancy-body-other";
1334
1335                 /* FIXME: Might want to support nick highlighting here... */
1336         }
1337
1338         body = gossip_message_get_body (msg);
1339         chat_view_append_text (view, body, tag);
1340 }
1341
1342 static void
1343 chat_view_theme_changed_cb (GossipThemeManager *manager,
1344                             GossipChatView     *view)
1345 {
1346         GossipChatViewPriv *priv;
1347         gboolean            show_avatars = FALSE;
1348         gboolean            theme_rooms = FALSE;
1349
1350         priv = GET_PRIV (view);
1351
1352         priv->last_block_type = BLOCK_TYPE_NONE;
1353
1354         gossip_conf_get_bool (gossip_conf_get (),
1355                               GOSSIP_PREFS_CHAT_THEME_CHAT_ROOM,
1356                               &theme_rooms);
1357         if (!theme_rooms && priv->is_group_chat) {
1358                 gossip_theme_manager_apply (manager, view, NULL);
1359         } else {
1360                 gossip_theme_manager_apply_saved (manager, view);
1361         }
1362
1363         /* Needed for now to update the "rise" property of the names to get it
1364          * vertically centered.
1365          */
1366         gossip_conf_get_bool (gossip_conf_get (),
1367                                GOSSIP_PREFS_UI_SHOW_AVATARS,
1368                                &show_avatars);
1369         gossip_theme_manager_update_show_avatars (manager, view, show_avatars);
1370 }
1371
1372 GossipChatView *
1373 gossip_chat_view_new (void)
1374 {
1375         return g_object_new (GOSSIP_TYPE_CHAT_VIEW, NULL);
1376 }
1377
1378 /* The name is optional, if NULL, the sender for msg is used. */
1379 void
1380 gossip_chat_view_append_message (GossipChatView *view,
1381                                  GossipMessage  *msg)
1382 {
1383         GossipChatViewPriv *priv;
1384         GossipContact      *sender;
1385         const gchar        *body;
1386         gboolean            scroll_down;
1387
1388         g_return_if_fail (GOSSIP_IS_CHAT_VIEW (view));
1389         g_return_if_fail (GOSSIP_IS_MESSAGE (msg));
1390
1391         priv = GET_PRIV (view);
1392
1393         body = gossip_message_get_body (msg);
1394         if (!body) {
1395                 return;
1396         }
1397
1398         scroll_down = chat_view_is_scrolled_down (view);
1399
1400         chat_view_maybe_trim_buffer (view);
1401         chat_view_maybe_append_date_and_time (view, msg);
1402
1403         sender = gossip_message_get_sender (msg);
1404
1405         if (!priv->irc_style) {
1406                 chat_view_maybe_append_fancy_header (view, msg);
1407         }
1408
1409         if (gossip_message_get_type (msg) == GOSSIP_MESSAGE_TYPE_ACTION) {
1410                 if (priv->irc_style) {
1411                         chat_view_append_irc_action (view, msg);
1412                 } else {
1413                         chat_view_append_fancy_action (view, msg);
1414                 }
1415         } else {
1416                 if (priv->irc_style) {
1417                         chat_view_append_irc_message (view, msg);
1418                 } else {
1419                         chat_view_append_fancy_message (view, msg);
1420                 }
1421         }
1422
1423         priv->last_block_type = BLOCK_TYPE_SELF;
1424
1425         /* Reset the last inserted contact, since it was from self. */
1426         if (priv->last_contact) {
1427                 g_object_unref (priv->last_contact);
1428                 priv->last_contact = NULL;
1429         }
1430
1431         if (scroll_down) {
1432                 gossip_chat_view_scroll_down (view);
1433         }
1434 }
1435
1436 void
1437 gossip_chat_view_append_event (GossipChatView *view,
1438                                const gchar    *str)
1439 {
1440         GossipChatViewPriv *priv;
1441         gboolean            bottom;
1442         GtkTextIter         iter;
1443         gchar              *msg;
1444         const gchar        *tag;
1445
1446         g_return_if_fail (GOSSIP_IS_CHAT_VIEW (view));
1447         g_return_if_fail (!G_STR_EMPTY (str));
1448
1449         priv = GET_PRIV (view);
1450
1451         bottom = chat_view_is_scrolled_down (view);
1452
1453         chat_view_maybe_trim_buffer (view);
1454
1455         if (priv->irc_style) {
1456                 tag = "irc-event";
1457                 msg = g_strdup_printf (" - %s\n", str);
1458         } else {
1459                 tag = "fancy-event";
1460                 msg = g_strdup_printf (" - %s\n", str);
1461         }
1462
1463         if (priv->last_block_type != BLOCK_TYPE_EVENT) {
1464                 /* Comment out for now. */
1465                 /*chat_view_append_spacing (view);*/
1466         }
1467
1468         chat_view_maybe_append_date_and_time (view, NULL);
1469
1470         gtk_text_buffer_get_end_iter (priv->buffer, &iter);
1471
1472         gtk_text_buffer_insert_with_tags_by_name (priv->buffer, &iter,
1473                                                   msg, -1,
1474                                                   tag,
1475                                                   NULL);
1476         g_free (msg);
1477
1478         if (bottom) {
1479                 gossip_chat_view_scroll_down (view);
1480         }
1481
1482         priv->last_block_type = BLOCK_TYPE_EVENT;
1483 }
1484
1485 void
1486 gossip_chat_view_append_button (GossipChatView *view,
1487                                 const gchar    *message,
1488                                 GtkWidget      *button1,
1489                                 GtkWidget      *button2)
1490 {
1491         GossipChatViewPriv   *priv;
1492         GtkTextChildAnchor   *anchor;
1493         GtkTextIter           iter;
1494         gboolean              bottom;
1495         const gchar          *tag;
1496
1497         g_return_if_fail (GOSSIP_IS_CHAT_VIEW (view));
1498         g_return_if_fail (button1 != NULL);
1499
1500         priv = GET_PRIV (view);
1501
1502         if (priv->irc_style) {
1503                 tag = "irc-invite";
1504         } else {
1505                 tag = "fancy-invite";
1506         }
1507
1508         bottom = chat_view_is_scrolled_down (view);
1509
1510         chat_view_maybe_append_date_and_time (view, NULL);
1511
1512         if (message) {
1513                 chat_view_append_text (view, message, tag);
1514         }
1515
1516         gtk_text_buffer_get_end_iter (priv->buffer, &iter);
1517
1518         anchor = gtk_text_buffer_create_child_anchor (priv->buffer, &iter);
1519         gtk_text_view_add_child_at_anchor (GTK_TEXT_VIEW (view), button1, anchor);
1520         gtk_widget_show (button1);
1521
1522         gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
1523                                                   &iter,
1524                                                   " ",
1525                                                   1,
1526                                                   tag,
1527                                                   NULL);
1528
1529         if (button2) {
1530                 gtk_text_buffer_get_end_iter (priv->buffer, &iter);
1531                 
1532                 anchor = gtk_text_buffer_create_child_anchor (priv->buffer, &iter);
1533                 gtk_text_view_add_child_at_anchor (GTK_TEXT_VIEW (view), button2, anchor);
1534                 gtk_widget_show (button2);
1535                 
1536                 gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
1537                                                           &iter,
1538                                                           " ",
1539                                                           1,
1540                                                           tag,
1541                                                           NULL);
1542         }
1543
1544         gtk_text_buffer_get_end_iter (priv->buffer, &iter);
1545         gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
1546                                                   &iter,
1547                                                   "\n\n",
1548                                                   2,
1549                                                   tag,
1550                                                   NULL);
1551
1552         if (bottom) {
1553                 gossip_chat_view_scroll_down (view);
1554         }
1555
1556         priv->last_block_type = BLOCK_TYPE_INVITE;
1557 }
1558
1559 void
1560 gossip_chat_view_scroll (GossipChatView *view,
1561                          gboolean        allow_scrolling)
1562 {
1563         GossipChatViewPriv *priv;
1564
1565         g_return_if_fail (GOSSIP_IS_CHAT_VIEW (view));
1566
1567         priv = GET_PRIV (view);
1568
1569         priv->allow_scrolling = allow_scrolling;
1570
1571         gossip_debug (DEBUG_DOMAIN, "Scrolling %s",
1572                       allow_scrolling ? "enabled" : "disabled");
1573 }
1574
1575 void
1576 gossip_chat_view_scroll_down (GossipChatView *view)
1577 {
1578         GossipChatViewPriv *priv;
1579         GtkTextBuffer      *buffer;
1580         GtkTextIter         iter;
1581         GtkTextMark        *mark;
1582
1583         g_return_if_fail (GOSSIP_IS_CHAT_VIEW (view));
1584
1585         priv = GET_PRIV (view);
1586
1587         if (!priv->allow_scrolling) {
1588                 return;
1589         }
1590
1591         gossip_debug (DEBUG_DOMAIN, "Scrolling down");
1592
1593         buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
1594
1595         gtk_text_buffer_get_end_iter (buffer, &iter);
1596         mark = gtk_text_buffer_create_mark (buffer,
1597                                             NULL,
1598                                             &iter,
1599                                             FALSE);
1600
1601         gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),
1602                                       mark,
1603                                       0.0,
1604                                       FALSE,
1605                                       0,
1606                                       0);
1607
1608         gtk_text_buffer_delete_mark (buffer, mark);
1609 }
1610
1611 gboolean
1612 gossip_chat_view_get_selection_bounds (GossipChatView *view,
1613                                        GtkTextIter    *start,
1614                                        GtkTextIter    *end)
1615 {
1616         GtkTextBuffer *buffer;
1617
1618         g_return_val_if_fail (GOSSIP_IS_CHAT_VIEW (view), FALSE);
1619
1620         buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
1621
1622         return gtk_text_buffer_get_selection_bounds (buffer, start, end);
1623 }
1624
1625 void
1626 gossip_chat_view_clear (GossipChatView *view)
1627 {
1628         GtkTextBuffer      *buffer;
1629         GossipChatViewPriv *priv;
1630
1631         g_return_if_fail (GOSSIP_IS_CHAT_VIEW (view));
1632
1633         buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
1634         gtk_text_buffer_set_text (buffer, "", -1);
1635
1636         /* We set these back to the initial values so we get
1637          * timestamps when clearing the window to know when
1638          * conversations start.
1639          */
1640         priv = GET_PRIV (view);
1641
1642         priv->last_block_type = BLOCK_TYPE_NONE;
1643         priv->last_timestamp = 0;
1644 }
1645
1646 gboolean
1647 gossip_chat_view_find_previous (GossipChatView *view,
1648                                 const gchar    *search_criteria,
1649                                 gboolean        new_search)
1650 {
1651         GossipChatViewPriv *priv;
1652         GtkTextBuffer      *buffer;
1653         GtkTextIter         iter_at_mark;
1654         GtkTextIter         iter_match_start;
1655         GtkTextIter         iter_match_end;
1656         gboolean            found;
1657         gboolean            from_start = FALSE;
1658
1659         g_return_val_if_fail (GOSSIP_IS_CHAT_VIEW (view), FALSE);
1660         g_return_val_if_fail (search_criteria != NULL, FALSE);
1661
1662         priv = GET_PRIV (view);
1663
1664         buffer = priv->buffer;
1665
1666         if (G_STR_EMPTY (search_criteria)) {
1667                 if (priv->find_mark_previous) {
1668                         gtk_text_buffer_get_start_iter (buffer, &iter_at_mark);
1669
1670                         gtk_text_buffer_move_mark (buffer,
1671                                                    priv->find_mark_previous,
1672                                                    &iter_at_mark);
1673                         gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),
1674                                                       priv->find_mark_previous,
1675                                                       0.0,
1676                                                       TRUE,
1677                                                       0.0,
1678                                                       0.0);
1679                         gtk_text_buffer_select_range (buffer,
1680                                                       &iter_at_mark,
1681                                                       &iter_at_mark);
1682                 }
1683
1684                 return FALSE;
1685         }
1686
1687         if (new_search) {
1688                 from_start = TRUE;
1689         }
1690
1691         if (priv->find_mark_previous) {
1692                 gtk_text_buffer_get_iter_at_mark (buffer,
1693                                                   &iter_at_mark,
1694                                                   priv->find_mark_previous);
1695         } else {
1696                 gtk_text_buffer_get_end_iter (buffer, &iter_at_mark);
1697                 from_start = TRUE;
1698         }
1699
1700         priv->find_last_direction = FALSE;
1701
1702         found = gossip_text_iter_backward_search (&iter_at_mark,
1703                                                   search_criteria,
1704                                                   &iter_match_start,
1705                                                   &iter_match_end,
1706                                                   NULL);
1707
1708         if (!found) {
1709                 gboolean result = FALSE;
1710
1711                 if (from_start) {
1712                         return result;
1713                 }
1714
1715                 /* Here we wrap around. */
1716                 if (!new_search && !priv->find_wrapped) {
1717                         priv->find_wrapped = TRUE;
1718                         result = gossip_chat_view_find_previous (view, 
1719                                                                  search_criteria, 
1720                                                                  FALSE);
1721                         priv->find_wrapped = FALSE;
1722                 }
1723
1724                 return result;
1725         }
1726
1727         /* Set new mark and show on screen */
1728         if (!priv->find_mark_previous) {
1729                 priv->find_mark_previous = gtk_text_buffer_create_mark (buffer, NULL,
1730                                                                         &iter_match_start,
1731                                                                         TRUE);
1732         } else {
1733                 gtk_text_buffer_move_mark (buffer,
1734                                            priv->find_mark_previous,
1735                                            &iter_match_start);
1736         }
1737
1738         if (!priv->find_mark_next) {
1739                 priv->find_mark_next = gtk_text_buffer_create_mark (buffer, NULL,
1740                                                                     &iter_match_end,
1741                                                                     TRUE);
1742         } else {
1743                 gtk_text_buffer_move_mark (buffer,
1744                                            priv->find_mark_next,
1745                                            &iter_match_end);
1746         }
1747
1748         gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),
1749                                       priv->find_mark_previous,
1750                                       0.0,
1751                                       TRUE,
1752                                       0.5,
1753                                       0.5);
1754
1755         gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &iter_match_start);
1756         gtk_text_buffer_move_mark_by_name (buffer, "insert", &iter_match_end);
1757
1758         return TRUE;
1759 }
1760
1761 gboolean
1762 gossip_chat_view_find_next (GossipChatView *view,
1763                             const gchar    *search_criteria,
1764                             gboolean        new_search)
1765 {
1766         GossipChatViewPriv *priv;
1767         GtkTextBuffer      *buffer;
1768         GtkTextIter         iter_at_mark;
1769         GtkTextIter         iter_match_start;
1770         GtkTextIter         iter_match_end;
1771         gboolean            found;
1772         gboolean            from_start = FALSE;
1773
1774         g_return_val_if_fail (GOSSIP_IS_CHAT_VIEW (view), FALSE);
1775         g_return_val_if_fail (search_criteria != NULL, FALSE);
1776
1777         priv = GET_PRIV (view);
1778
1779         buffer = priv->buffer;
1780
1781         if (G_STR_EMPTY (search_criteria)) {
1782                 if (priv->find_mark_next) {
1783                         gtk_text_buffer_get_start_iter (buffer, &iter_at_mark);
1784
1785                         gtk_text_buffer_move_mark (buffer,
1786                                                    priv->find_mark_next,
1787                                                    &iter_at_mark);
1788                         gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),
1789                                                       priv->find_mark_next,
1790                                                       0.0,
1791                                                       TRUE,
1792                                                       0.0,
1793                                                       0.0);
1794                         gtk_text_buffer_select_range (buffer,
1795                                                       &iter_at_mark,
1796                                                       &iter_at_mark);
1797                 }
1798
1799                 return FALSE;
1800         }
1801
1802         if (new_search) {
1803                 from_start = TRUE;
1804         }
1805
1806         if (priv->find_mark_next) {
1807                 gtk_text_buffer_get_iter_at_mark (buffer,
1808                                                   &iter_at_mark,
1809                                                   priv->find_mark_next);
1810         } else {
1811                 gtk_text_buffer_get_start_iter (buffer, &iter_at_mark);
1812                 from_start = TRUE;
1813         }
1814
1815         priv->find_last_direction = TRUE;
1816
1817         found = gossip_text_iter_forward_search (&iter_at_mark,
1818                                                  search_criteria,
1819                                                  &iter_match_start,
1820                                                  &iter_match_end,
1821                                                  NULL);
1822
1823         if (!found) {
1824                 gboolean result = FALSE;
1825
1826                 if (from_start) {
1827                         return result;
1828                 }
1829
1830                 /* Here we wrap around. */
1831                 if (!new_search && !priv->find_wrapped) {
1832                         priv->find_wrapped = TRUE;
1833                         result = gossip_chat_view_find_next (view, 
1834                                                              search_criteria, 
1835                                                              FALSE);
1836                         priv->find_wrapped = FALSE;
1837                 }
1838
1839                 return result;
1840         }
1841
1842         /* Set new mark and show on screen */
1843         if (!priv->find_mark_next) {
1844                 priv->find_mark_next = gtk_text_buffer_create_mark (buffer, NULL,
1845                                                                &iter_match_end,
1846                                                                TRUE);
1847         } else {
1848                 gtk_text_buffer_move_mark (buffer,
1849                                            priv->find_mark_next,
1850                                            &iter_match_end);
1851         }
1852
1853         if (!priv->find_mark_previous) {
1854                 priv->find_mark_previous = gtk_text_buffer_create_mark (buffer, NULL,
1855                                                                         &iter_match_start,
1856                                                                         TRUE);
1857         } else {
1858                 gtk_text_buffer_move_mark (buffer,
1859                                            priv->find_mark_previous,
1860                                            &iter_match_start);
1861         }
1862
1863         gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),
1864                                       priv->find_mark_next,
1865                                       0.0,
1866                                       TRUE,
1867                                       0.5,
1868                                       0.5);
1869
1870         gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &iter_match_start);
1871         gtk_text_buffer_move_mark_by_name (buffer, "insert", &iter_match_end);
1872
1873         return TRUE;
1874 }
1875
1876
1877 void
1878 gossip_chat_view_find_abilities (GossipChatView *view,
1879                                  const gchar    *search_criteria,
1880                                  gboolean       *can_do_previous,
1881                                  gboolean       *can_do_next)
1882 {
1883         GossipChatViewPriv *priv;
1884         GtkTextBuffer      *buffer;
1885         GtkTextIter         iter_at_mark;
1886         GtkTextIter         iter_match_start;
1887         GtkTextIter         iter_match_end;
1888
1889         g_return_if_fail (GOSSIP_IS_CHAT_VIEW (view));
1890         g_return_if_fail (search_criteria != NULL);
1891         g_return_if_fail (can_do_previous != NULL && can_do_next != NULL);
1892
1893         priv = GET_PRIV (view);
1894
1895         buffer = priv->buffer;
1896
1897         if (can_do_previous) {
1898                 if (priv->find_mark_previous) {
1899                         gtk_text_buffer_get_iter_at_mark (buffer,
1900                                                           &iter_at_mark,
1901                                                           priv->find_mark_previous);
1902                 } else {
1903                         gtk_text_buffer_get_start_iter (buffer, &iter_at_mark);
1904                 }
1905                 
1906                 *can_do_previous = gossip_text_iter_backward_search (&iter_at_mark,
1907                                                                      search_criteria,
1908                                                                      &iter_match_start,
1909                                                                      &iter_match_end,
1910                                                                      NULL);
1911         }
1912
1913         if (can_do_next) {
1914                 if (priv->find_mark_next) {
1915                         gtk_text_buffer_get_iter_at_mark (buffer,
1916                                                           &iter_at_mark,
1917                                                           priv->find_mark_next);
1918                 } else {
1919                         gtk_text_buffer_get_start_iter (buffer, &iter_at_mark);
1920                 }
1921                 
1922                 *can_do_next = gossip_text_iter_forward_search (&iter_at_mark,
1923                                                                 search_criteria,
1924                                                                 &iter_match_start,
1925                                                                 &iter_match_end,
1926                                                                 NULL);
1927         }
1928 }
1929
1930 void
1931 gossip_chat_view_highlight (GossipChatView *view,
1932                             const gchar    *text)
1933 {
1934         GtkTextBuffer *buffer;
1935         GtkTextIter    iter;
1936         GtkTextIter    iter_start;
1937         GtkTextIter    iter_end;
1938         GtkTextIter    iter_match_start;
1939         GtkTextIter    iter_match_end;
1940         gboolean       found;
1941
1942         g_return_if_fail (GOSSIP_IS_CHAT_VIEW (view));
1943
1944         buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
1945
1946         gtk_text_buffer_get_start_iter (buffer, &iter);
1947
1948         gtk_text_buffer_get_bounds (buffer, &iter_start, &iter_end);
1949         gtk_text_buffer_remove_tag_by_name (buffer, "highlight",
1950                                             &iter_start,
1951                                             &iter_end);
1952
1953         if (G_STR_EMPTY (text)) {
1954                 return;
1955         }
1956
1957         while (1) {
1958                 found = gossip_text_iter_forward_search (&iter,
1959                                                          text,
1960                                                          &iter_match_start,
1961                                                          &iter_match_end,
1962                                                          NULL);
1963
1964                 if (!found) {
1965                         break;
1966                 }
1967
1968                 gtk_text_buffer_apply_tag_by_name (buffer, "highlight",
1969                                                    &iter_match_start,
1970                                                    &iter_match_end);
1971
1972                 iter = iter_match_end;
1973                 gtk_text_iter_forward_char (&iter);
1974         }
1975 }
1976
1977 void
1978 gossip_chat_view_copy_clipboard (GossipChatView *view)
1979 {
1980         GtkTextBuffer *buffer;
1981         GtkClipboard  *clipboard;
1982
1983         g_return_if_fail (GOSSIP_IS_CHAT_VIEW (view));
1984
1985         buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
1986         clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
1987
1988         gtk_text_buffer_copy_clipboard (buffer, clipboard);
1989 }
1990
1991 gboolean
1992 gossip_chat_view_get_irc_style (GossipChatView *view)
1993 {
1994         GossipChatViewPriv *priv;
1995
1996         g_return_val_if_fail (GOSSIP_IS_CHAT_VIEW (view), FALSE);
1997
1998         priv = GET_PRIV (view);
1999
2000         return priv->irc_style;
2001 }
2002
2003 void
2004 gossip_chat_view_set_irc_style (GossipChatView *view,
2005                                 gboolean        irc_style)
2006 {
2007         GossipChatViewPriv *priv;
2008
2009         g_return_if_fail (GOSSIP_IS_CHAT_VIEW (view));
2010
2011         priv = GET_PRIV (view);
2012
2013         priv->irc_style = irc_style;
2014 }
2015
2016 void
2017 gossip_chat_view_set_margin (GossipChatView *view,
2018                              gint            margin)
2019 {
2020         GossipChatViewPriv *priv;
2021
2022         g_return_if_fail (GOSSIP_IS_CHAT_VIEW (view));
2023
2024         priv = GET_PRIV (view);
2025
2026         g_object_set (view,
2027                       "left-margin", margin,
2028                       "right-margin", margin,
2029                       NULL);
2030 }
2031
2032 GdkPixbuf *
2033 gossip_chat_view_get_smiley_image (GossipSmiley smiley)
2034 {
2035         static GdkPixbuf *pixbufs[GOSSIP_SMILEY_COUNT];
2036         static gboolean   inited = FALSE;
2037
2038         if (!inited) {
2039                 gint i;
2040
2041                 for (i = 0; i < GOSSIP_SMILEY_COUNT; i++) {
2042                         pixbufs[i] = gossip_pixbuf_from_smiley (i, GTK_ICON_SIZE_MENU);
2043                 }
2044
2045                 inited = TRUE;
2046         }
2047
2048         return pixbufs[smiley];
2049 }
2050
2051 const gchar *
2052 gossip_chat_view_get_smiley_text (GossipSmiley smiley)
2053 {
2054         gint i;
2055
2056         for (i = 0; i < G_N_ELEMENTS (smileys); i++) {
2057                 if (smileys[i].smiley != smiley) {
2058                         continue;
2059                 }
2060
2061                 return smileys[i].pattern;
2062         }
2063
2064         return NULL;
2065 }
2066
2067 GtkWidget *
2068 gossip_chat_view_get_smiley_menu (GCallback    callback,
2069                                   gpointer     user_data,
2070                                   GtkTooltips *tooltips)
2071 {
2072         GtkWidget *menu;
2073         gint       x;
2074         gint       y;
2075         gint       i;
2076
2077         g_return_val_if_fail (callback != NULL, NULL);
2078
2079         menu = gtk_menu_new ();
2080
2081         for (i = 0, x = 0, y = 0; i < GOSSIP_SMILEY_COUNT; i++) {
2082                 GtkWidget   *item;
2083                 GtkWidget   *image;
2084                 GdkPixbuf   *pixbuf;
2085                 const gchar *smiley_text;
2086
2087                 pixbuf = gossip_chat_view_get_smiley_image (i);
2088                 if (!pixbuf) {
2089                         continue;
2090                 }
2091
2092                 image = gtk_image_new_from_pixbuf (pixbuf);
2093
2094                 item = gtk_image_menu_item_new_with_label ("");
2095                 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
2096
2097                 gtk_menu_attach (GTK_MENU (menu), item,
2098                                  x, x + 1, y, y + 1);
2099
2100                 smiley_text = gossip_chat_view_get_smiley_text (i);
2101
2102                 gtk_tooltips_set_tip (tooltips,
2103                                       item,
2104                                       smiley_text,
2105                                       NULL);
2106
2107                 g_object_set_data  (G_OBJECT (item), "smiley_text", (gpointer) smiley_text);
2108                 g_signal_connect (item, "activate", callback, user_data);
2109
2110                 if (x > 3) {
2111                         y++;
2112                         x = 0;
2113                 } else {
2114                         x++;
2115                 }
2116         }
2117
2118         gtk_widget_show_all (menu);
2119
2120         return menu;
2121 }
2122
2123 /* FIXME: Do we really need this? Better to do it internally only at setup time,
2124  * we will never change it on the fly.
2125  */
2126 void
2127 gossip_chat_view_set_is_group_chat (GossipChatView *view,
2128                                     gboolean        is_group_chat)
2129 {
2130         GossipChatViewPriv *priv;
2131         gboolean            theme_rooms = FALSE;
2132
2133         g_return_if_fail (GOSSIP_IS_CHAT_VIEW (view));
2134
2135         priv = GET_PRIV (view);
2136
2137         priv->is_group_chat = is_group_chat;
2138
2139         gossip_conf_get_bool (gossip_conf_get (),
2140                               GOSSIP_PREFS_CHAT_THEME_CHAT_ROOM,
2141                               &theme_rooms);
2142
2143         if (!theme_rooms && is_group_chat) {
2144                 gossip_theme_manager_apply (gossip_theme_manager_get (),
2145                                             view,
2146                                             NULL);
2147         } else {
2148                 gossip_theme_manager_apply_saved (gossip_theme_manager_get (),
2149                                                   view);
2150         }
2151 }