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 EmpathySmileyManager *manager_singleton = NULL;
  48
  49 static SmileyManagerTree *
  50 smiley_manager_tree_new (gunichar c)
  51 {
  52         SmileyManagerTree *tree;
  53
  54         tree = g_slice_new0 (SmileyManagerTree);
  55         tree->c = c;
  56         tree->pixbuf = NULL;
  57         tree->childrens = NULL;
  58
  59         return tree;
  60 }
  61
  62 static void
  63 smiley_manager_tree_free (SmileyManagerTree *tree)
  64 {
  65         GSList *l;
  66
  67         if (!tree) {
  68                 return;
  69         }
  70
  71         for (l = tree->childrens; l; l = l->next) {
  72                 smiley_manager_tree_free (l->data);
  73         }
  74
  75         if (tree->pixbuf) {
  76                 g_object_unref (tree->pixbuf);
  77         }
  78         g_slist_free (tree->childrens);
  79         g_slice_free (SmileyManagerTree, tree);
  80 }
  81
  82 static EmpathySmiley *
  83 smiley_new (GdkPixbuf *pixbuf, const gchar *str)
  84 {
  85         EmpathySmiley *smiley;
  86
  87         smiley = g_slice_new0 (EmpathySmiley);
  88         if (pixbuf) {
  89                 smiley->pixbuf = g_object_ref (pixbuf);
  90         }
  91         smiley->str = g_strdup (str);
  92
  93         return smiley;
  94 }
  95
  96 void
  97 empathy_smiley_free (EmpathySmiley *smiley)
  98 {
  99         if (!smiley) {
 100                 return;
 101         }
 102
 103         if (smiley->pixbuf) {
 104                 g_object_unref (smiley->pixbuf);
 105         }
 106         g_free (smiley->str);
 107         g_slice_free (EmpathySmiley, smiley);
 108 }
 109
 110 static void
 111 smiley_manager_finalize (GObject *object)
 112 {
 113         EmpathySmileyManagerPriv *priv = GET_PRIV (object);
 114
 115         smiley_manager_tree_free (priv->tree);
 116         g_slist_foreach (priv->smileys, (GFunc) empathy_smiley_free, NULL);
 117         g_slist_free (priv->smileys);
 118 }
 119
 120 static GObject *
 121 smiley_manager_constructor (GType type,
 122                             guint n_props,
 123                             GObjectConstructParam *props)
 124 {
 125         GObject *retval;
 126
 127         if (manager_singleton) {
 128                 retval = g_object_ref (manager_singleton);
 129         } else {
 130                 retval = G_OBJECT_CLASS (empathy_smiley_manager_parent_class)->constructor
 131                         (type, n_props, props);
 132
 133                 manager_singleton = EMPATHY_SMILEY_MANAGER (retval);
 134                 g_object_add_weak_pointer (retval, (gpointer *) &manager_singleton);
 135         }
 136
 137         return retval;
 138 }
 139
 140 static void
 141 empathy_smiley_manager_class_init (EmpathySmileyManagerClass *klass)
 142 {
 143         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 144
 145         object_class->finalize = smiley_manager_finalize;
 146         object_class->constructor = smiley_manager_constructor;
 147
 148         g_type_class_add_private (object_class, sizeof (EmpathySmileyManagerPriv));
 149 }
 150
 151 static void
 152 empathy_smiley_manager_init (EmpathySmileyManager *manager)
 153 {
 154         EmpathySmileyManagerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
 155                 EMPATHY_TYPE_SMILEY_MANAGER, EmpathySmileyManagerPriv);
 156
 157         manager->priv = priv;
 158         priv->tree = smiley_manager_tree_new ('\0');
 159         priv->smileys = NULL;
 160
 161         empathy_smiley_manager_load (manager);
 162 }
 163
 164 EmpathySmileyManager *
 165 empathy_smiley_manager_dup_singleton (void)
 166 {
 167         return g_object_new (EMPATHY_TYPE_SMILEY_MANAGER, NULL);
 168 }
 169
 170 static SmileyManagerTree *
 171 smiley_manager_tree_find_child (SmileyManagerTree *tree, gunichar c)
 172 {
 173         GSList *l;
 174
 175         for (l = tree->childrens; l; l = l->next) {
 176                 SmileyManagerTree *child = l->data;
 177
 178                 if (child->c == c) {
 179                         return child;
 180                 }
 181         }
 182
 183         return NULL;
 184 }
 185
 186 static SmileyManagerTree *
 187 smiley_manager_tree_find_or_insert_child (SmileyManagerTree *tree, gunichar c)
 188 {
 189         SmileyManagerTree *child;
 190
 191         child = smiley_manager_tree_find_child (tree, c);
 192
 193         if (!child) {
 194                 child = smiley_manager_tree_new (c);
 195                 tree->childrens = g_slist_prepend (tree->childrens, child);
 196         }
 197
 198         return child;
 199 }
 200
 201 static void
 202 smiley_manager_tree_insert (SmileyManagerTree *tree,
 203                             GdkPixbuf         *smiley,
 204                             const gchar       *str)
 205 {
 206         SmileyManagerTree *child;
 207
 208         child = smiley_manager_tree_find_or_insert_child (tree, g_utf8_get_char (str));
 209
 210         str = g_utf8_next_char (str);
 211         if (*str) {
 212                 smiley_manager_tree_insert (child, smiley, str);
 213                 return;
 214         }
 215
 216         child->pixbuf = g_object_ref (smiley);
 217 }
 218
 219 static void
 220 smiley_manager_add_valist (EmpathySmileyManager *manager,
 221                            GdkPixbuf            *smiley,
 222                            const gchar          *first_str,
 223                            va_list               var_args)
 224 {
 225         EmpathySmileyManagerPriv *priv = GET_PRIV (manager);
 226         const gchar              *str;
 227
 228         for (str = first_str; str; str = va_arg (var_args, gchar*)) {
 229                 smiley_manager_tree_insert (priv->tree, smiley, str);
 230         }
 231
 232         priv->smileys = g_slist_prepend (priv->smileys, smiley_new (smiley, first_str));
 233 }
 234
 235 void
 236 empathy_smiley_manager_add (EmpathySmileyManager *manager,
 237                             const gchar          *icon_name,
 238                             const gchar          *first_str,
 239                             ...)
 240 {
 241         GdkPixbuf *smiley;
 242         va_list    var_args;
 243
 244         g_return_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager));
 245         g_return_if_fail (!EMP_STR_EMPTY (icon_name));
 246         g_return_if_fail (!EMP_STR_EMPTY (first_str));
 247
 248         smiley = empathy_pixbuf_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
 249         if (smiley) {
 250                 va_start (var_args, first_str);
 251                 smiley_manager_add_valist (manager, smiley, first_str, var_args);
 252                 va_end (var_args);
 253                 g_object_unref (smiley);
 254         }
 255 }
 256
 257 void
 258 empathy_smiley_manager_add_from_pixbuf (EmpathySmileyManager *manager,
 259                                         GdkPixbuf            *smiley,
 260                                         const gchar          *first_str,
 261                                         ...)
 262 {
 263         va_list var_args;
 264
 265         g_return_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager));
 266         g_return_if_fail (GDK_IS_PIXBUF (smiley));
 267         g_return_if_fail (!EMP_STR_EMPTY (first_str));
 268
 269         va_start (var_args, first_str);
 270         smiley_manager_add_valist (manager, smiley, first_str, var_args);
 271         va_end (var_args);
 272 }
 273
 274 void
 275 empathy_smiley_manager_load (EmpathySmileyManager *manager)
 276 {
 277         g_return_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager));
 278
 279         /* From fd.o icon-naming spec */
 280         empathy_smiley_manager_add (manager, "face-angel",      "O:-)",  "O:)",  NULL);
 281         empathy_smiley_manager_add (manager, "face-cool",       "B-)",   "B)",   NULL);
 282         empathy_smiley_manager_add (manager, "face-crying",     ":'(", NULL);
 283         empathy_smiley_manager_add (manager, "face-devilish",   ">:-)",  ">:)",  NULL);
 284         empathy_smiley_manager_add (manager, "face-embarrassed",":-[",   ":[",   ":-$", ":$", NULL);
 285         empathy_smiley_manager_add (manager, "face-kiss",       ":-*",   ":*",   NULL);
 286         empathy_smiley_manager_add (manager, "face-monkey",     ":-(|)", ":(|)", NULL);
 287         empathy_smiley_manager_add (manager, "face-plain",      ":-|",   ":|",   NULL);
 288         empathy_smiley_manager_add (manager, "face-raspberry",  ":-P",   ":P",   ":-p", ":p", NULL);
 289         empathy_smiley_manager_add (manager, "face-sad",        ":-(",   ":(",   NULL);
 290         empathy_smiley_manager_add (manager, "face-smile",      ":-)",   ":)",   NULL);
 291         empathy_smiley_manager_add (manager, "face-smile-big",  ":-D",   ":D",   ":-d", ":d", NULL);
 292         empathy_smiley_manager_add (manager, "face-smirk",      ":-!",   ":!",   NULL);
 293         empathy_smiley_manager_add (manager, "face-surprise",   ":-O",   ":O",   NULL);
 294         empathy_smiley_manager_add (manager, "face-wink",       ";-)",   ";)",   NULL);
 295 }
 296
 297 GSList *
 298 empathy_smiley_manager_parse (EmpathySmileyManager *manager,
 299                               const gchar          *text)
 300 {
 301         EmpathySmileyManagerPriv *priv = GET_PRIV (manager);
 302         EmpathySmiley            *smiley;
 303         SmileyManagerTree        *cur_tree = priv->tree;
 304         const gchar              *t;
 305         const gchar              *cur_str = text;
 306         GSList                   *smileys = NULL;
 307
 308         g_return_val_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager), NULL);
 309         g_return_val_if_fail (text != NULL, NULL);
 310
 311         for (t = text; *t; t = g_utf8_next_char (t)) {
 312                 SmileyManagerTree *child;
 313                 gunichar           c;
 314
 315                 c = g_utf8_get_char (t);
 316                 child = smiley_manager_tree_find_child (cur_tree, c);
 317
 318                 if (cur_tree == priv->tree) {
 319                         if (child) {
 320                                 if (t > cur_str) {
 321                                         smiley = smiley_new (NULL, g_strndup (cur_str, t - cur_str));
 322                                         smileys = g_slist_prepend (smileys, smiley);
 323                                 }
 324                                 cur_str = t;
 325                                 cur_tree = child;
 326                         }
 327
 328                         continue;
 329                 }
 330
 331                 if (child) {
 332                         cur_tree = child;
 333                         continue;
 334                 }
 335
 336                 smiley = smiley_new (cur_tree->pixbuf, g_strndup (cur_str, t - cur_str));
 337                 smileys = g_slist_prepend (smileys, smiley);
 338                 if (cur_tree->pixbuf) {
 339                         cur_str = t;
 340                         cur_tree = smiley_manager_tree_find_child (priv->tree, c);
 341
 342                         if (!cur_tree) {
 343                                 cur_tree = priv->tree;
 344                         }
 345                 } else {
 346                         cur_str = t;
 347                         cur_tree = priv->tree;
 348                 }
 349         }
 350
 351         smiley = smiley_new (cur_tree->pixbuf, g_strndup (cur_str, t - cur_str));
 352         smileys = g_slist_prepend (smileys, smiley);
 353
 354         return g_slist_reverse (smileys);
 355 }
 356
 357 GSList *
 358 empathy_smiley_manager_get_all (EmpathySmileyManager *manager)
 359 {
 360         EmpathySmileyManagerPriv *priv = GET_PRIV (manager);
 361
 362         return priv->smileys;
 363 }
 364
 365 typedef struct {
 366         EmpathySmileyManager *manager;
 367         EmpathySmiley        *smiley;
 368         EmpathySmileyMenuFunc func;
 369         gpointer              user_data;
 370 } ActivateData;
 371
 372 static void
 373 smiley_menu_data_free (gpointer  user_data,
 374                        GClosure *closure)
 375 {
 376         ActivateData *data = (ActivateData*) user_data;
 377
 378         g_object_unref (data->manager);
 379         g_slice_free (ActivateData, data);
 380 }
 381
 382 static void
 383 smiley_menu_activate_cb (GtkMenuItem *menuitem,
 384                          gpointer     user_data)
 385 {
 386         ActivateData *data = (ActivateData*) user_data;
 387
 388         data->func (data->manager, data->smiley, data->user_data);
 389 }
 390
 391 GtkWidget *
 392 empathy_smiley_menu_new (EmpathySmileyManager *manager,
 393                          EmpathySmileyMenuFunc func,
 394                          gpointer              user_data)
 395 {
 396         EmpathySmileyManagerPriv *priv = GET_PRIV (manager);
 397         GSList                   *l;
 398         GtkWidget                *menu;
 399         gint                      x = 0;
 400         gint                      y = 0;
 401
 402         g_return_val_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager), NULL);
 403         g_return_val_if_fail (func != NULL, NULL);
 404
 405         menu = gtk_menu_new ();
 406
 407         for (l = priv->smileys; l; l = l->next) {
 408                 EmpathySmiley *smiley;
 409                 GtkWidget     *item;
 410                 GtkWidget     *image;
 411                 ActivateData  *data;
 412
 413                 smiley = l->data;
 414                 image = gtk_image_new_from_pixbuf (smiley->pixbuf);
 415
 416                 item = gtk_image_menu_item_new_with_label ("");
 417                 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 418
 419                 gtk_menu_attach (GTK_MENU (menu), item,
 420                                  x, x + 1, y, y + 1);
 421
 422                 gtk_widget_set_tooltip_text (item, smiley->str);
 423
 424                 data = g_slice_new (ActivateData);
 425                 data->manager = g_object_ref (manager);
 426                 data->smiley = smiley;
 427                 data->func = func;
 428                 data->user_data = user_data;
 429
 430                 g_signal_connect_data (item, "activate",
 431                                        G_CALLBACK (smiley_menu_activate_cb),
 432                                        data,
 433                                        smiley_menu_data_free,
 434                                        0);
 435
 436                 if (x > 3) {
 437                         y++;
 438                         x = 0;
 439                 } else {
 440                         x++;
 441                 }
 442         }
 443
 444         gtk_widget_show_all (menu);
 445
 446         return menu;
 447 }
 448