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-2008 Collabora Ltd.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  *
  19  * Authors: Dafydd Harrie <dafydd.harries@collabora.co.uk>
  20  *          Xavier Claessens <xclaesse@gmail.com>
  21  */
  22
  23 #include <config.h>
  24
  25 #include <string.h>
  26
  27 #include <libempathy/empathy-utils.h>
  28 #include "empathy-smiley-manager.h"
  29 #include "empathy-ui-utils.h"
  30
  31 typedef struct _SmileyManagerTree SmileyManagerTree;
  32
  33 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathySmileyManager)
  34 typedef struct {
  35         SmileyManagerTree *tree;
  36         GSList            *smileys;
  37 } EmpathySmileyManagerPriv;
  38
  39 struct _SmileyManagerTree {
  40         gunichar   c;
  41         GdkPixbuf *pixbuf;
  42         GSList    *childrens;
  43 };
  44
  45 G_DEFINE_TYPE (EmpathySmileyManager, empathy_smiley_manager, G_TYPE_OBJECT);
  46
  47 static SmileyManagerTree *
  48 smiley_manager_tree_new (gunichar c)
  49 {
  50         SmileyManagerTree *tree;
  51
  52         tree = g_slice_new0 (SmileyManagerTree);
  53         tree->c = c;
  54         tree->pixbuf = NULL;
  55         tree->childrens = NULL;
  56
  57         return tree;
  58 }
  59
  60 static void
  61 smiley_manager_tree_free (SmileyManagerTree *tree)
  62 {
  63         GSList *l;
  64
  65         if (!tree) {
  66                 return;
  67         }
  68
  69         for (l = tree->childrens; l; l = l->next) {
  70                 smiley_manager_tree_free (l->data);
  71         }
  72
  73         if (tree->pixbuf) {
  74                 g_object_unref (tree->pixbuf);
  75         }
  76         g_slist_free (tree->childrens);
  77         g_slice_free (SmileyManagerTree, tree);
  78 }
  79
  80 static EmpathySmiley *
  81 smiley_new (GdkPixbuf *pixbuf, const gchar *str)
  82 {
  83         EmpathySmiley *smiley;
  84
  85         smiley = g_slice_new0 (EmpathySmiley);
  86         if (pixbuf) {
  87                 smiley->pixbuf = g_object_ref (pixbuf);
  88         }
  89         smiley->str = g_strdup (str);
  90
  91         return smiley;
  92 }
  93
  94 void
  95 empathy_smiley_free (EmpathySmiley *smiley)
  96 {
  97         if (!smiley) {
  98                 return;
  99         }
 100
 101         if (smiley->pixbuf) {
 102                 g_object_unref (smiley->pixbuf);
 103         }
 104         g_free (smiley->str);
 105         g_slice_free (EmpathySmiley, smiley);
 106 }
 107
 108 static void
 109 smiley_manager_finalize (GObject *object)
 110 {
 111         EmpathySmileyManagerPriv *priv = GET_PRIV (object);
 112
 113         smiley_manager_tree_free (priv->tree);
 114         g_slist_foreach (priv->smileys, (GFunc) empathy_smiley_free, NULL);
 115         g_slist_free (priv->smileys);
 116 }
 117
 118 static void
 119 empathy_smiley_manager_class_init (EmpathySmileyManagerClass *klass)
 120 {
 121         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 122
 123         object_class->finalize = smiley_manager_finalize;
 124
 125         g_type_class_add_private (object_class, sizeof (EmpathySmileyManagerPriv));
 126 }
 127
 128 static void
 129 empathy_smiley_manager_init (EmpathySmileyManager *manager)
 130 {
 131         EmpathySmileyManagerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
 132                 EMPATHY_TYPE_SMILEY_MANAGER, EmpathySmileyManagerPriv);
 133
 134         manager->priv = priv;
 135         priv->tree = smiley_manager_tree_new ('\0');
 136         priv->smileys = NULL;
 137 }
 138
 139 EmpathySmileyManager *
 140 empathy_smiley_manager_new (void)
 141 {
 142         static EmpathySmileyManager *manager = NULL;
 143
 144         if (!manager) {
 145                 manager = g_object_new (EMPATHY_TYPE_SMILEY_MANAGER, NULL);
 146                 g_object_add_weak_pointer (G_OBJECT (manager), (gpointer) &manager);
 147                 empathy_smiley_manager_load (manager);
 148         } else {
 149                 g_object_ref (manager);
 150         }
 151
 152         return manager;
 153 }
 154
 155 static SmileyManagerTree *
 156 smiley_manager_tree_find_child (SmileyManagerTree *tree, gunichar c)
 157 {
 158         GSList *l;
 159
 160         for (l = tree->childrens; l; l = l->next) {
 161                 SmileyManagerTree *child = l->data;
 162
 163                 if (child->c == c) {
 164                         return child;
 165                 }
 166         }
 167
 168         return NULL;
 169 }
 170
 171 static SmileyManagerTree *
 172 smiley_manager_tree_find_or_insert_child (SmileyManagerTree *tree, gunichar c)
 173 {
 174         SmileyManagerTree *child;
 175
 176         child = smiley_manager_tree_find_child (tree, c);
 177
 178         if (!child) {
 179                 child = smiley_manager_tree_new (c);
 180                 tree->childrens = g_slist_prepend (tree->childrens, child);
 181         }
 182
 183         return child;
 184 }
 185
 186 static void
 187 smiley_manager_tree_insert (SmileyManagerTree *tree,
 188                             GdkPixbuf         *smiley,
 189                             const gchar       *str)
 190 {
 191         SmileyManagerTree *child;
 192
 193         child = smiley_manager_tree_find_or_insert_child (tree, g_utf8_get_char (str));
 194
 195         str = g_utf8_next_char (str);
 196         if (*str) {
 197                 smiley_manager_tree_insert (child, smiley, str);
 198                 return;
 199         }
 200
 201         child->pixbuf = g_object_ref (smiley);
 202 }
 203
 204 static void
 205 smiley_manager_add_valist (EmpathySmileyManager *manager,
 206                            GdkPixbuf            *smiley,
 207                            const gchar          *first_str,
 208                            va_list               var_args)
 209 {
 210         EmpathySmileyManagerPriv *priv = GET_PRIV (manager);
 211         const gchar              *str;
 212
 213         for (str = first_str; str; str = va_arg (var_args, gchar*)) {
 214                 smiley_manager_tree_insert (priv->tree, smiley, str);
 215         }
 216
 217         priv->smileys = g_slist_prepend (priv->smileys, smiley_new (smiley, first_str));
 218 }
 219
 220 void
 221 empathy_smiley_manager_add (EmpathySmileyManager *manager,
 222                             const gchar          *icon_name,
 223                             const gchar          *first_str,
 224                             ...)
 225 {
 226         GdkPixbuf *smiley;
 227         va_list    var_args;
 228
 229         g_return_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager));
 230         g_return_if_fail (!G_STR_EMPTY (icon_name));
 231         g_return_if_fail (!G_STR_EMPTY (first_str));
 232
 233         smiley = empathy_pixbuf_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
 234         if (smiley) {
 235                 va_start (var_args, first_str);
 236                 smiley_manager_add_valist (manager, smiley, first_str, var_args);
 237                 va_end (var_args);
 238                 g_object_unref (smiley);
 239         }
 240 }
 241
 242 void
 243 empathy_smiley_manager_add_from_pixbuf (EmpathySmileyManager *manager,
 244                                         GdkPixbuf            *smiley,
 245                                         const gchar          *first_str,
 246                                         ...)
 247 {
 248         va_list var_args;
 249
 250         g_return_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager));
 251         g_return_if_fail (GDK_IS_PIXBUF (smiley));
 252         g_return_if_fail (!G_STR_EMPTY (first_str));
 253
 254         va_start (var_args, first_str);
 255         smiley_manager_add_valist (manager, smiley, first_str, var_args);
 256         va_end (var_args);
 257 }
 258
 259 void
 260 empathy_smiley_manager_load (EmpathySmileyManager *manager)
 261 {
 262         g_return_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager));
 263
 264         /* From fd.o icon-naming spec */
 265         empathy_smiley_manager_add (manager, "face-angel",      "O:-)",  "O:)",  NULL);
 266         empathy_smiley_manager_add (manager, "face-cool",       "B-)",   "B)",   NULL);
 267         empathy_smiley_manager_add (manager, "face-crying",     ":'(", NULL);
 268         empathy_smiley_manager_add (manager, "face-devilish",   ">:-)",  ">:)",  NULL);
 269         empathy_smiley_manager_add (manager, "face-embarrassed",":-[",   ":[",   ":-$", ":$", NULL);
 270         empathy_smiley_manager_add (manager, "face-kiss",       ":-*",   ":*",   NULL);
 271         empathy_smiley_manager_add (manager, "face-monkey",     ":-(|)", ":(|)", NULL);
 272         empathy_smiley_manager_add (manager, "face-plain",      ":-|",   ":|",   NULL);
 273         empathy_smiley_manager_add (manager, "face-raspberry",  ":-P",   ":P",   ":-p", ":p", NULL);
 274         empathy_smiley_manager_add (manager, "face-sad",        ":-(",   ":(",   NULL);
 275         empathy_smiley_manager_add (manager, "face-smile",      ":-)",   ":)",   NULL);
 276         empathy_smiley_manager_add (manager, "face-smile-big",  ":-D",   ":D",   ":-d", ":d", NULL);
 277         empathy_smiley_manager_add (manager, "face-smirk",      ":-!",   ":!",   NULL);
 278         empathy_smiley_manager_add (manager, "face-surprise",   ":-O",   ":O",   NULL);
 279         empathy_smiley_manager_add (manager, "face-wink",       ";-)",   ";)",   NULL);
 280 }
 281
 282 GSList *
 283 empathy_smiley_manager_parse (EmpathySmileyManager *manager,
 284                               const gchar          *text)
 285 {
 286         EmpathySmileyManagerPriv *priv = GET_PRIV (manager);
 287         EmpathySmiley            *smiley;
 288         SmileyManagerTree        *cur_tree = priv->tree;
 289         const gchar              *t;
 290         const gchar              *cur_str = text;
 291         GSList                   *smileys = NULL;
 292
 293         g_return_val_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager), NULL);
 294         g_return_val_if_fail (text != NULL, NULL);
 295
 296         for (t = text; *t; t = g_utf8_next_char (t)) {
 297                 SmileyManagerTree *child;
 298                 gunichar           c;
 299
 300                 c = g_utf8_get_char (t);
 301                 child = smiley_manager_tree_find_child (cur_tree, c);
 302
 303                 if (cur_tree == priv->tree) {
 304                         if (child) {
 305                                 if (t > cur_str) {
 306                                         smiley = smiley_new (NULL, g_strndup (cur_str, t - cur_str));
 307                                         smileys = g_slist_prepend (smileys, smiley);
 308                                 }
 309                                 cur_str = t;
 310                                 cur_tree = child;
 311                         }
 312
 313                         continue;
 314                 }
 315
 316                 if (child) {
 317                         cur_tree = child;
 318                         continue;
 319                 }
 320
 321                 smiley = smiley_new (cur_tree->pixbuf, g_strndup (cur_str, t - cur_str));
 322                 smileys = g_slist_prepend (smileys, smiley);
 323                 if (cur_tree->pixbuf) {
 324                         cur_str = t;
 325                         cur_tree = smiley_manager_tree_find_child (priv->tree, c);
 326
 327                         if (!cur_tree) {
 328                                 cur_tree = priv->tree;
 329                         }
 330                 } else {
 331                         cur_str = t;
 332                         cur_tree = priv->tree;
 333                 }
 334         }
 335
 336         smiley = smiley_new (cur_tree->pixbuf, g_strndup (cur_str, t - cur_str));
 337         smileys = g_slist_prepend (smileys, smiley);
 338
 339         return g_slist_reverse (smileys);
 340 }
 341
 342 GSList *
 343 empathy_smiley_manager_get_all (EmpathySmileyManager *manager)
 344 {
 345         EmpathySmileyManagerPriv *priv = GET_PRIV (manager);
 346
 347         return priv->smileys;
 348 }
 349
 350 typedef struct {
 351         EmpathySmileyManager *manager;
 352         EmpathySmiley        *smiley;
 353         EmpathySmileyMenuFunc func;
 354         gpointer              user_data;
 355 } ActivateData;
 356
 357 static void
 358 smiley_menu_data_free (gpointer  user_data,
 359                        GClosure *closure)
 360 {
 361         ActivateData *data = (ActivateData*) user_data;
 362
 363         g_object_unref (data->manager);
 364         g_slice_free (ActivateData, data);
 365 }
 366
 367 static void
 368 smiley_menu_activate_cb (GtkMenuItem *menuitem,
 369                          gpointer     user_data)
 370 {
 371         ActivateData *data = (ActivateData*) user_data;
 372
 373         data->func (data->manager, data->smiley, data->user_data);
 374 }
 375
 376 GtkWidget *
 377 empathy_smiley_menu_new (EmpathySmileyManager *manager,
 378                          EmpathySmileyMenuFunc func,
 379                          gpointer              user_data)
 380 {
 381         EmpathySmileyManagerPriv *priv = GET_PRIV (manager);
 382         GSList                   *l;
 383         GtkWidget                *menu;
 384         gint                      x = 0;
 385         gint                      y = 0;
 386
 387         g_return_val_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager), NULL);
 388         g_return_val_if_fail (func != NULL, NULL);
 389
 390         menu = gtk_menu_new ();
 391
 392         for (l = priv->smileys; l; l = l->next) {
 393                 EmpathySmiley *smiley;
 394                 GtkWidget     *item;
 395                 GtkWidget     *image;
 396                 ActivateData  *data;
 397
 398                 smiley = l->data;
 399                 image = gtk_image_new_from_pixbuf (smiley->pixbuf);
 400
 401                 item = gtk_image_menu_item_new_with_label ("");
 402                 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 403
 404                 gtk_menu_attach (GTK_MENU (menu), item,
 405                                  x, x + 1, y, y + 1);
 406
 407                 gtk_widget_set_tooltip_text (item, smiley->str);
 408
 409                 data = g_slice_new (ActivateData);
 410                 data->manager = g_object_ref (manager);
 411                 data->smiley = smiley;
 412                 data->func = func;
 413                 data->user_data = user_data;
 414
 415                 g_signal_connect_data (item, "activate",
 416                                        G_CALLBACK (smiley_menu_activate_cb),
 417                                        data,
 418                                        smiley_menu_data_free,
 419                                        0);
 420
 421                 if (x > 3) {
 422                         y++;
 423                         x = 0;
 424                 } else {
 425                         x++;
 426                 }
 427         }
 428
 429         gtk_widget_show_all (menu);
 430
 431         return menu;
 432 }
 433