libempathy-gtk/empathy-smiley-manager.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2007 Collabora Ltd.
   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: Xavier Claessens <xclaesse@gmail.com>
  21  */
  22
  23 #include <config.h>
  24
  25 #include <string.h>
  26
  27 #include <libempathy/empathy-debug.h>
  28
  29 #include "empathy-smiley-manager.h"
  30 #include "empathy-ui-utils.h"
  31
  32 #define GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \
  33                        EMPATHY_TYPE_SMILEY_MANAGER, EmpathySmileyManagerPriv))
  34
  35 #define DEBUG_DOMAIN "SmileyManager"
  36
  37 typedef struct {
  38         gunichar   c;
  39         GdkPixbuf *pixbuf;
  40         GSList    *childrens;
  41 } SmileyManagerTree;
  42
  43 struct _EmpathySmileyManagerPriv {
  44         SmileyManagerTree *tree;
  45         GSList            *smileys;
  46 };
  47
  48 static void empathy_smiley_manager_class_init (EmpathySmileyManagerClass *klass);
  49 static void empathy_smiley_manager_init       (EmpathySmileyManager      *manager);
  50
  51 G_DEFINE_TYPE (EmpathySmileyManager, empathy_smiley_manager, G_TYPE_OBJECT);
  52
  53 static SmileyManagerTree *
  54 smiley_manager_tree_new (gunichar c)
  55 {
  56         SmileyManagerTree *tree;
  57
  58         tree = g_slice_new0 (SmileyManagerTree);
  59         tree->c = c;
  60         tree->pixbuf = NULL;
  61         tree->childrens = NULL;
  62
  63         return tree;
  64 }
  65
  66 static void
  67 smiley_manager_tree_free (SmileyManagerTree *tree)
  68 {
  69         GSList *l;
  70
  71         if (!tree) {
  72                 return;
  73         }
  74
  75         for (l = tree->childrens; l; l = l->next) {
  76                 smiley_manager_tree_free (l->data);
  77         }
  78
  79         if (tree->pixbuf) {
  80                 g_object_unref (tree->pixbuf);
  81         }
  82         g_slist_free (tree->childrens);
  83         g_slice_free (SmileyManagerTree, tree);
  84 }
  85
  86 static EmpathySmiley *
  87 smiley_new (GdkPixbuf *pixbuf, const gchar *str)
  88 {
  89         EmpathySmiley *smiley;
  90
  91         smiley = g_slice_new0 (EmpathySmiley);
  92         if (pixbuf) {
  93                 smiley->pixbuf = g_object_ref (pixbuf);
  94         }
  95         smiley->str = g_strdup (str);
  96
  97         return smiley;
  98 }
  99
 100 void
 101 empathy_smiley_free (EmpathySmiley *smiley)
 102 {
 103         if (!smiley) {
 104                 return;
 105         }
 106
 107         if (smiley->pixbuf) {
 108                 g_object_unref (smiley->pixbuf);
 109         }
 110         g_free (smiley->str);
 111 }
 112
 113 static void
 114 smiley_manager_finalize (GObject *object)
 115 {
 116         EmpathySmileyManagerPriv *priv = GET_PRIV (object);
 117
 118         smiley_manager_tree_free (priv->tree);
 119         g_slist_foreach (priv->smileys, (GFunc) empathy_smiley_free, NULL);
 120         g_slist_free (priv->smileys);
 121 }
 122
 123 static void
 124 empathy_smiley_manager_class_init (EmpathySmileyManagerClass *klass)
 125 {
 126         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 127
 128         object_class->finalize = smiley_manager_finalize;
 129
 130         g_type_class_add_private (object_class, sizeof (EmpathySmileyManagerPriv));
 131 }
 132
 133 static void
 134 empathy_smiley_manager_init (EmpathySmileyManager *manager)
 135 {
 136         EmpathySmileyManagerPriv *priv = GET_PRIV (manager);
 137
 138         priv->tree = smiley_manager_tree_new ('\0');
 139         priv->smileys = NULL;
 140 }
 141
 142 EmpathySmileyManager *
 143 empathy_smiley_manager_new (void)
 144 {
 145         static EmpathySmileyManager *manager = NULL;
 146
 147         if (!manager) {
 148                 manager = g_object_new (EMPATHY_TYPE_SMILEY_MANAGER, NULL);
 149                 g_object_add_weak_pointer (G_OBJECT (manager), (gpointer) &manager);
 150                 empathy_smiley_manager_load (manager);
 151         } else {
 152                 g_object_ref (manager);
 153         }
 154
 155         return manager;
 156 }
 157
 158 static SmileyManagerTree *
 159 smiley_manager_tree_find_child (SmileyManagerTree *tree, gunichar c)
 160 {
 161         GSList *l;
 162
 163         for (l = tree->childrens; l; l = l->next) {
 164                 SmileyManagerTree *child = l->data;
 165
 166                 if (child->c == c) {
 167                         return child;
 168                 }
 169         }
 170
 171         return NULL;
 172 }
 173
 174 static SmileyManagerTree *
 175 smiley_manager_tree_find_or_insert_child (SmileyManagerTree *tree, gunichar c)
 176 {
 177         SmileyManagerTree *child;
 178
 179         child = smiley_manager_tree_find_child (tree, c);
 180
 181         if (!child) {
 182                 child = smiley_manager_tree_new (c);
 183                 tree->childrens = g_slist_prepend (tree->childrens, child);
 184         }
 185
 186         return child;
 187 }
 188
 189 static void
 190 smiley_manager_tree_insert (SmileyManagerTree *tree,
 191                             GdkPixbuf         *smiley,
 192                             const gchar       *str)
 193 {
 194         SmileyManagerTree *child;
 195
 196         child = smiley_manager_tree_find_or_insert_child (tree, g_utf8_get_char (str));
 197
 198         str = g_utf8_next_char (str);
 199         if (*str) {
 200                 smiley_manager_tree_insert (child, smiley, str);
 201                 return;
 202         }
 203
 204         child->pixbuf = g_object_ref (smiley);
 205 }
 206
 207 static void
 208 smiley_manager_add_valist (EmpathySmileyManager *manager,
 209                            GdkPixbuf            *smiley,
 210                            const gchar          *first_str,
 211                            va_list               var_args)
 212 {
 213         EmpathySmileyManagerPriv *priv = GET_PRIV (manager);
 214         const gchar *str;
 215
 216         for (str = first_str; str; str = va_arg (var_args, gchar*)) {
 217                 smiley_manager_tree_insert (priv->tree, smiley, str);
 218         }
 219
 220         priv->smileys = g_slist_prepend (priv->smileys, smiley_new (smiley, first_str));
 221 }
 222
 223 void
 224 empathy_smiley_manager_add (EmpathySmileyManager *manager,
 225                             const gchar          *icon_name,
 226                             const gchar          *first_str,
 227                             ...)
 228 {
 229         GdkPixbuf *smiley;
 230         va_list    var_args;
 231
 232         g_return_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager));
 233         g_return_if_fail (!G_STR_EMPTY (icon_name));
 234         g_return_if_fail (!G_STR_EMPTY (first_str));
 235
 236         smiley = empathy_pixbuf_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
 237         if (smiley) {
 238                 va_start (var_args, first_str);
 239                 smiley_manager_add_valist (manager, smiley, first_str, var_args);
 240                 va_end (var_args);
 241                 g_object_unref (smiley);
 242         }
 243 }
 244
 245 void
 246 empathy_smiley_manager_add_from_pixbuf (EmpathySmileyManager *manager,
 247                                         GdkPixbuf            *smiley,
 248                                         const gchar          *first_str,
 249                                         ...)
 250 {
 251         va_list var_args;
 252
 253         g_return_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager));
 254         g_return_if_fail (GDK_IS_PIXBUF (smiley));
 255         g_return_if_fail (!G_STR_EMPTY (first_str));
 256
 257         va_start (var_args, first_str);
 258         smiley_manager_add_valist (manager, smiley, first_str, var_args);
 259         va_end (var_args);
 260 }
 261
 262 void
 263 empathy_smiley_manager_load (EmpathySmileyManager *manager)
 264 {
 265         g_return_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager));
 266
 267         /* From fd.o icon-naming spec */
 268         empathy_smiley_manager_add (manager, "face-angel",      "0:-)",  "0:)",  NULL);
 269         empathy_smiley_manager_add (manager, "face-crying",     ":'(", NULL);
 270         empathy_smiley_manager_add (manager, "face-devil-grin", ">:-)",  ">:)",  NULL);
 271         empathy_smiley_manager_add (manager, "face-devil-sad",  ">:-(",  ">:(",  NULL);
 272         empathy_smiley_manager_add (manager, "face-glasses",    "B-)",   "B)",   NULL);
 273         empathy_smiley_manager_add (manager, "face-kiss",       ":-*",   ":*",   NULL);
 274         empathy_smiley_manager_add (manager, "face-monkey",     ":-(|)", ":(|)", NULL);
 275         empathy_smiley_manager_add (manager, "face-plain",      ":-|",   ":|",   NULL);
 276         empathy_smiley_manager_add (manager, "face-sad",        ":-(",   ":(",   NULL);
 277         empathy_smiley_manager_add (manager, "face-smile",      ":-)",   ":)",   NULL);
 278         empathy_smiley_manager_add (manager, "face-smile-big",  ":-D",   ":D",   NULL);
 279         empathy_smiley_manager_add (manager, "face-smirk",      ":-!",   ":!",   NULL);
 280         empathy_smiley_manager_add (manager, "face-surprise",   ":-0",   ":0",   NULL);
 281         empathy_smiley_manager_add (manager, "face-wink",       ";-)",   ";)",   NULL);
 282 }
 283
 284 GSList *
 285 empathy_smiley_manager_parse (EmpathySmileyManager *manager,
 286                               const gchar          *text)
 287 {
 288         EmpathySmileyManagerPriv *priv = GET_PRIV (manager);
 289         EmpathySmiley            *smiley;
 290         SmileyManagerTree        *cur_tree = priv->tree;
 291         const gchar              *t;
 292         const gchar              *cur_str = text;
 293         GSList                   *smileys = NULL;
 294
 295         g_return_val_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager), NULL);
 296         g_return_val_if_fail (text != NULL, NULL);
 297
 298         for (t = text; *t; t = g_utf8_next_char (t)) {
 299                 SmileyManagerTree *child;
 300                 gunichar           c;
 301
 302                 c = g_utf8_get_char (t);
 303                 child = smiley_manager_tree_find_child (cur_tree, c);
 304
 305                 if (cur_tree == priv->tree) {
 306                         if (child) {
 307                                 if (t > cur_str) {
 308                                         smiley = smiley_new (NULL, g_strndup (cur_str, t - cur_str));
 309                                         smileys = g_slist_prepend (smileys, smiley);
 310                                 }
 311                                 cur_str = t;
 312                                 cur_tree = child;
 313                         }
 314
 315                         continue;
 316                 }
 317
 318                 if (child) {
 319                         cur_tree = child;
 320                         continue;
 321                 }
 322
 323                 smiley = smiley_new (cur_tree->pixbuf, g_strndup (cur_str, t - cur_str));
 324                 smileys = g_slist_prepend (smileys, smiley);
 325                 if (cur_tree->pixbuf) {
 326                         cur_str = t;
 327                         cur_tree = smiley_manager_tree_find_child (priv->tree, c);
 328
 329                         if (!cur_tree) {
 330                                 cur_tree = priv->tree;
 331                         }
 332                 } else {
 333                         cur_str = t;
 334                         cur_tree = priv->tree;
 335                 }
 336         }
 337
 338         smiley = smiley_new (cur_tree->pixbuf, g_strndup (cur_str, t - cur_str));
 339         smileys = g_slist_prepend (smileys, smiley);
 340
 341         return g_slist_reverse (smileys);
 342 }
 343
 344 GSList *
 345 empathy_smiley_manager_get_all (EmpathySmileyManager *manager)
 346 {
 347         EmpathySmileyManagerPriv *priv = GET_PRIV (manager);
 348
 349         return priv->smileys;
 350 }
 351