HGKeeper

/* purple

* Purple is the legal property of its developers, whose names are too numerous

* to list here. Please refer to the COPYRIGHT file distributed with this

* source distribution.

* This program is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2 of the License, or

* (at your option) any later version.

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA

#include "smiley-list.h"

#include "dbus-maybe.h"

#include "debug.h"

#include "smiley-parser.h"

#include "trie.h"

#define PURPLE_SMILEY_LIST_GET_PRIVATE(obj) \

(G_TYPE_INSTANCE_GET_PRIVATE((obj), PURPLE_TYPE_SMILEY_LIST, \

PurpleSmileyListPrivate))

typedef struct {

GList *smileys;

GList *smileys_end;

PurpleTrie *trie;

GHashTable *path_map;

GHashTable *shortcut_map;

gboolean drop_failed_remotes;

} PurpleSmileyListPrivate;

enum

{

PROP_0,

PROP_DROP_FAILED_REMOTES,

PROP_LAST

};

static GObjectClass *parent_class;

static GParamSpec *properties[PROP_LAST];

static void

_list_append2(GList **head_p, GList **tail_p, gpointer data)

{

GList *head = *head_p;

GList *tail = *tail_p;

GList *elem;

g_return_if_fail((head == NULL) == (tail == NULL));

g_return_if_fail((tail == NULL) || (tail->next == NULL));

elem = g_list_alloc();

elem->data = data;

elem->prev = tail;

elem->next = NULL;

if (head) {

tail->next = elem;

*tail_p = elem;

} else

*head_p = *tail_p = elem;

}

static void

_list_delete_link2(GList **head_p, GList **tail_p, GList *link)

{

GList *head = *head_p;

GList *tail = *tail_p;

g_return_if_fail(head != NULL);

g_return_if_fail(tail != NULL);

if (link == tail)

*tail_p = tail->prev;

*head_p = g_list_delete_link(head, link);

}

static const gchar *

smiley_get_uniqid(PurpleSmiley *smiley)

{

return purple_image_get_path(purple_smiley_get_image(smiley));

}

/*******************************************************************************

* API implementation

******************************************************************************/

PurpleSmileyList *

purple_smiley_list_new(void)

{

return g_object_new(PURPLE_TYPE_SMILEY_LIST, NULL);

}

static void

remote_smiley_failed(PurpleImage *smiley_img, gpointer _list)

{

PurpleSmileyList *list = _list;

PurpleSmiley *smiley;

smiley = g_object_get_data(G_OBJECT(smiley_img),

"purple-smiley-list-smiley");

purple_debug_info("smiley-list", "remote smiley '%s' has failed, "

"removing it from the list...",

purple_smiley_get_shortcut(smiley));

purple_smiley_list_remove(list, smiley);

}

gboolean

purple_smiley_list_add(PurpleSmileyList *list, PurpleSmiley *smiley)

{

PurpleSmileyListPrivate *priv = PURPLE_SMILEY_LIST_GET_PRIVATE(list);

PurpleImage *smiley_img;

const gchar *smiley_path;

gboolean succ;

gchar *shortcut_escaped;

const gchar *shortcut;

g_return_val_if_fail(priv != NULL, FALSE);

g_return_val_if_fail(PURPLE_IS_SMILEY(smiley), FALSE);

if (g_object_get_data(G_OBJECT(smiley), "purple-smiley-list") != NULL) {

purple_debug_warning("smiley-list",

"smiley is already associated with some list");

return FALSE;

}

shortcut = purple_smiley_get_shortcut(smiley);

if (g_hash_table_lookup(priv->shortcut_map, shortcut) != NULL)

return FALSE;

shortcut_escaped = g_markup_escape_text(shortcut, -1);

succ = purple_trie_add(priv->trie, shortcut_escaped, smiley);

/* A special-case for WebKit, which unescapes apos entity.

* Please, don't trust this hack - it may be removed in future releases.

if (succ && strstr(shortcut_escaped, "'") != NULL) {

gchar *tmp = shortcut_escaped;

shortcut_escaped = purple_strreplace(shortcut_escaped,

"'", "'");

g_free(tmp);

succ = purple_trie_add(priv->trie, shortcut_escaped, smiley);

}

g_free(shortcut_escaped);

if (!succ)

return FALSE;

g_object_ref(smiley);

_list_append2(&priv->smileys, &priv->smileys_end, smiley);

g_object_set_data(G_OBJECT(smiley), "purple-smiley-list", list);

g_object_set_data(G_OBJECT(smiley), "purple-smiley-list-elem",

priv->smileys_end);

g_hash_table_insert(priv->shortcut_map, g_strdup(shortcut), smiley);

smiley_img = purple_smiley_get_image(smiley);

if (priv->drop_failed_remotes && !purple_image_is_ready(smiley_img)) {

g_object_set_data(G_OBJECT(smiley_img),

"purple-smiley-list-smiley", smiley);

g_signal_connect_object(smiley_img, "failed",

G_CALLBACK(remote_smiley_failed), list, 0);

}

smiley_path = smiley_get_uniqid(smiley);

/* TODO: add to the table, when the smiley sets the path */

if (!smiley_path)

return TRUE;

if (g_hash_table_lookup(priv->path_map, smiley_path) == NULL) {

g_hash_table_insert(priv->path_map,

g_strdup(smiley_path), smiley);

}

return TRUE;

}

void

purple_smiley_list_remove(PurpleSmileyList *list, PurpleSmiley *smiley)

{

PurpleSmileyListPrivate *priv = PURPLE_SMILEY_LIST_GET_PRIVATE(list);

GList *list_elem, *it;

const gchar *shortcut, *path;

gchar *shortcut_escaped;

g_return_if_fail(priv != NULL);

g_return_if_fail(PURPLE_IS_SMILEY(smiley));

if (g_object_get_data(G_OBJECT(smiley), "purple-smiley-list") != list) {

purple_debug_warning("smiley-list", "remove: invalid list");

return;

}

list_elem = g_object_get_data(G_OBJECT(smiley),

"purple-smiley-list-elem");

shortcut = purple_smiley_get_shortcut(smiley);

path = smiley_get_uniqid(smiley);

g_hash_table_remove(priv->shortcut_map, shortcut);

if (path)

g_hash_table_remove(priv->path_map, path);

shortcut_escaped = g_markup_escape_text(shortcut, -1);

purple_trie_remove(priv->trie, shortcut);

g_free(shortcut_escaped);

_list_delete_link2(&priv->smileys, &priv->smileys_end, list_elem);

/* re-add entry to path_map if smiley was not unique */

for (it = priv->smileys; it && path; it = g_list_next(it)) {

PurpleSmiley *smiley = it->data;

if (g_strcmp0(smiley_get_uniqid(smiley), path) == 0) {

g_hash_table_insert(priv->path_map,

g_strdup(path), smiley);

break;

}

g_object_set_data(G_OBJECT(smiley), "purple-smiley-list", NULL);

g_object_set_data(G_OBJECT(smiley), "purple-smiley-list-elem", NULL);

g_object_unref(smiley);

}

gboolean

purple_smiley_list_is_empty(PurpleSmileyList *list)

{

PurpleSmileyListPrivate *priv = PURPLE_SMILEY_LIST_GET_PRIVATE(list);

g_return_val_if_fail(priv != NULL, TRUE);

return (priv->smileys == NULL);

}

PurpleSmiley *

purple_smiley_list_get_by_shortcut(PurpleSmileyList *list,

const gchar *shortcut)

{

PurpleSmileyListPrivate *priv = PURPLE_SMILEY_LIST_GET_PRIVATE(list);

g_return_val_if_fail(priv != NULL, NULL);

return g_hash_table_lookup(priv->shortcut_map, shortcut);

}

PurpleTrie *

purple_smiley_list_get_trie(PurpleSmileyList *list)

{

PurpleSmileyListPrivate *priv = PURPLE_SMILEY_LIST_GET_PRIVATE(list);

g_return_val_if_fail(priv != NULL, NULL);

return priv->trie;

}

GList *

purple_smiley_list_get_unique(PurpleSmileyList *list)

{

GList *unique = NULL, *it;

GHashTable *unique_map;

PurpleSmileyListPrivate *priv = PURPLE_SMILEY_LIST_GET_PRIVATE(list);

g_return_val_if_fail(priv != NULL, NULL);

/* We could just return g_hash_table_get_values(priv->path_map) here,

* but it won't be in order. */

unique_map = g_hash_table_new(g_str_hash, g_str_equal);

for (it = priv->smileys; it; it = g_list_next(it)) {

PurpleSmiley *smiley = it->data;

const gchar *path = smiley_get_uniqid(smiley);

if (g_hash_table_lookup(unique_map, path))

continue;

unique = g_list_prepend(unique, smiley);

g_hash_table_insert(unique_map, (gpointer)path, smiley);

}

g_hash_table_destroy(unique_map);

return g_list_reverse(unique);

}

GList *

purple_smiley_list_get_all(PurpleSmileyList *list)

{

PurpleSmileyListPrivate *priv = PURPLE_SMILEY_LIST_GET_PRIVATE(list);

g_return_val_if_fail(priv != NULL, NULL);

return g_hash_table_get_values(priv->shortcut_map);

}

/*******************************************************************************

* Object stuff

******************************************************************************/

static void

purple_smiley_list_init(GTypeInstance *instance, gpointer klass)

{

PurpleSmileyList *sl = PURPLE_SMILEY_LIST(instance);

PurpleSmileyListPrivate *priv = PURPLE_SMILEY_LIST_GET_PRIVATE(sl);

priv->trie = purple_trie_new();

priv->path_map = g_hash_table_new_full(g_str_hash, g_str_equal,

g_free, NULL);

priv->shortcut_map = g_hash_table_new_full(g_str_hash, g_str_equal,

g_free, NULL);

PURPLE_DBUS_REGISTER_POINTER(sl, PurpleSmileyList);

}

static void

purple_smiley_list_finalize(GObject *obj)

{

PurpleSmileyList *sl = PURPLE_SMILEY_LIST(obj);

PurpleSmileyListPrivate *priv = PURPLE_SMILEY_LIST_GET_PRIVATE(sl);

GList *it;

g_object_unref(priv->trie);

g_hash_table_destroy(priv->path_map);

g_hash_table_destroy(priv->shortcut_map);

for (it = priv->smileys; it; it = g_list_next(it)) {

PurpleSmiley *smiley = it->data;

g_object_set_data(G_OBJECT(smiley), "purple-smiley-list", NULL);

g_object_set_data(G_OBJECT(smiley), "purple-smiley-list-elem", NULL);

g_object_unref(smiley);

}

g_list_free(priv->smileys);

PURPLE_DBUS_UNREGISTER_POINTER(sl);

G_OBJECT_CLASS(parent_class)->finalize(obj);

}

static void

purple_smiley_list_get_property(GObject *object, guint par_id, GValue *value,

GParamSpec *pspec)

{

PurpleSmileyList *sl = PURPLE_SMILEY_LIST(object);

PurpleSmileyListPrivate *priv = PURPLE_SMILEY_LIST_GET_PRIVATE(sl);

switch (par_id) {

case PROP_DROP_FAILED_REMOTES:

g_value_set_boolean(value, priv->drop_failed_remotes);

break;

default:

G_OBJECT_WARN_INVALID_PROPERTY_ID(object, par_id, pspec);

break;

}

static void

purple_smiley_list_set_property(GObject *object, guint par_id, const GValue *value,

GParamSpec *pspec)

{

PurpleSmileyList *sl = PURPLE_SMILEY_LIST(object);

PurpleSmileyListPrivate *priv = PURPLE_SMILEY_LIST_GET_PRIVATE(sl);

switch (par_id) {

case PROP_DROP_FAILED_REMOTES:

priv->drop_failed_remotes = g_value_get_boolean(value);

/* XXX: we could scan for remote smiley's on our list

* and change the setting, but we don't care that much.

break;

default:

G_OBJECT_WARN_INVALID_PROPERTY_ID(object, par_id, pspec);

break;

}

static void

purple_smiley_list_class_init(PurpleSmileyListClass *klass)

{

GObjectClass *gobj_class = G_OBJECT_CLASS(klass);

parent_class = g_type_class_peek_parent(klass);

g_type_class_add_private(klass, sizeof(PurpleSmileyListPrivate));

gobj_class->get_property = purple_smiley_list_get_property;

gobj_class->set_property = purple_smiley_list_set_property;

gobj_class->finalize = purple_smiley_list_finalize;

properties[PROP_DROP_FAILED_REMOTES] = g_param_spec_boolean(

"drop-failed-remotes", "Drop failed PurpleRemoteSmileys",

"Watch added remote smileys and remove them from the list, "

"if they change their state to failed", FALSE,

G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS);

g_object_class_install_properties(gobj_class, PROP_LAST, properties);

}

GType

purple_smiley_list_get_type(void)

{

static GType type = 0;

if (G_UNLIKELY(type == 0)) {

static const GTypeInfo info = {

.class_size = sizeof(PurpleSmileyListClass),

.class_init = (GClassInitFunc)purple_smiley_list_class_init,

.instance_size = sizeof(PurpleSmileyList),

.instance_init = purple_smiley_list_init,

};

type = g_type_register_static(G_TYPE_OBJECT,

"PurpleSmileyList", &info, 0);

}

return type;

}

pidgin/pidgin