pidgin/pidgin

closing merged branch
port-changes-from-branch-2.x.y-to-default
12 months ago, Gary Kramlich
2f836435c33c
closing merged branch
/* 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 "internal.h"
#include "conversation.h"
#include "debug.h"
#include "pounce.h"
#include "debug.h"
#include "pounce.h"
#include "util.h"
/*
* A buddy pounce structure.
*
* Buddy pounces are actions triggered by a buddy-related event. For
* example, a sound can be played or an IM window opened when a buddy
* signs on or returns from away. Such responses are handled in the
* UI. The events themselves are done in the core.
*/
struct _PurplePounce
{
char *ui_type; /* The type of UI. */
PurplePounceEvent events; /* The event(s) to pounce on. */
PurplePounceOption options; /* The pounce options */
PurpleAccount *pouncer; /* The user who is pouncing. */
char *pouncee; /* The buddy to pounce on. */
GHashTable *actions; /* The registered actions. */
gboolean save; /* Whether or not the pounce should
be saved after activation. */
void *data; /* Pounce-specific data. */
};
typedef struct
{
GString *buffer;
PurplePounce *pounce;
PurplePounceEvent events;
PurplePounceOption options;
char *ui_name;
char *pouncee;
char *protocol_id;
char *event_type;
char *option_type;
char *action_name;
char *param_name;
char *account_name;
} PounceParserData;
typedef struct
{
char *name;
gboolean enabled;
GHashTable *atts;
} PurplePounceActionData;
typedef struct
{
char *ui;
PurplePounceCb cb;
void (*new_pounce)(PurplePounce *);
void (*free_pounce)(PurplePounce *);
} PurplePounceHandler;
static GHashTable *pounce_handlers = NULL;
static GList *pounces = NULL;
static guint save_timer = 0;
static gboolean pounces_loaded = FALSE;
/*********************************************************************
* Private utility functions *
*********************************************************************/
static PurplePounceActionData *
find_action_data(const PurplePounce *pounce, const char *name)
{
PurplePounceActionData *action;
g_return_val_if_fail(pounce != NULL, NULL);
g_return_val_if_fail(name != NULL, NULL);
action = g_hash_table_lookup(pounce->actions, name);
return action;
}
static void
free_action_data(gpointer data)
{
PurplePounceActionData *action_data = data;
g_free(action_data->name);
g_hash_table_destroy(action_data->atts);
g_free(action_data);
}
/*********************************************************************
* Writing to disk *
*********************************************************************/
static void
action_parameter_to_xmlnode(gpointer key, gpointer value, gpointer user_data)
{
const char *name, *param_value;
PurpleXmlNode *node, *child;
name = (const char *)key;
param_value = (const char *)value;
node = (PurpleXmlNode *)user_data;
child = purple_xmlnode_new_child(node, "param");
purple_xmlnode_set_attrib(child, "name", name);
purple_xmlnode_insert_data(child, param_value, -1);
}
static void
action_parameter_list_to_xmlnode(gpointer key, gpointer value, gpointer user_data)
{
const char *action;
PurplePounceActionData *action_data;
PurpleXmlNode *node, *child;
action = (const char *)key;
action_data = (PurplePounceActionData *)value;
node = (PurpleXmlNode *)user_data;
if (!action_data->enabled)
return;
child = purple_xmlnode_new_child(node, "action");
purple_xmlnode_set_attrib(child, "type", action);
g_hash_table_foreach(action_data->atts, action_parameter_to_xmlnode, child);
}
static void
add_event_to_xmlnode(PurpleXmlNode *node, const char *type)
{
PurpleXmlNode *child;
child = purple_xmlnode_new_child(node, "event");
purple_xmlnode_set_attrib(child, "type", type);
}
static void
add_option_to_xmlnode(PurpleXmlNode *node, const char *type)
{
PurpleXmlNode *child;
child = purple_xmlnode_new_child(node, "option");
purple_xmlnode_set_attrib(child, "type", type);
}
static PurpleXmlNode *
pounce_to_xmlnode(PurplePounce *pounce)
{
PurpleXmlNode *node, *child;
PurpleAccount *pouncer;
PurplePounceEvent events;
PurplePounceOption options;
pouncer = purple_pounce_get_pouncer(pounce);
events = purple_pounce_get_events(pounce);
options = purple_pounce_get_options(pounce);
node = purple_xmlnode_new("pounce");
purple_xmlnode_set_attrib(node, "ui", pounce->ui_type);
child = purple_xmlnode_new_child(node, "account");
purple_xmlnode_set_attrib(child, "protocol", purple_account_get_protocol_id(pouncer));
purple_xmlnode_insert_data(child,
purple_normalize(pouncer, purple_account_get_username(pouncer)), -1);
child = purple_xmlnode_new_child(node, "pouncee");
purple_xmlnode_insert_data(child, purple_pounce_get_pouncee(pounce), -1);
/* Write pounce options */
child = purple_xmlnode_new_child(node, "options");
if (options & PURPLE_POUNCE_OPTION_AWAY)
add_option_to_xmlnode(child, "on-away");
/* Write pounce events */
child = purple_xmlnode_new_child(node, "events");
if (events & PURPLE_POUNCE_SIGNON)
add_event_to_xmlnode(child, "sign-on");
if (events & PURPLE_POUNCE_SIGNOFF)
add_event_to_xmlnode(child, "sign-off");
if (events & PURPLE_POUNCE_AWAY)
add_event_to_xmlnode(child, "away");
if (events & PURPLE_POUNCE_AWAY_RETURN)
add_event_to_xmlnode(child, "return-from-away");
if (events & PURPLE_POUNCE_IDLE)
add_event_to_xmlnode(child, "idle");
if (events & PURPLE_POUNCE_IDLE_RETURN)
add_event_to_xmlnode(child, "return-from-idle");
if (events & PURPLE_POUNCE_TYPING)
add_event_to_xmlnode(child, "start-typing");
if (events & PURPLE_POUNCE_TYPED)
add_event_to_xmlnode(child, "typed");
if (events & PURPLE_POUNCE_TYPING_STOPPED)
add_event_to_xmlnode(child, "stop-typing");
if (events & PURPLE_POUNCE_MESSAGE_RECEIVED)
add_event_to_xmlnode(child, "message-received");
/* Write pounce actions */
child = purple_xmlnode_new_child(node, "actions");
g_hash_table_foreach(pounce->actions, action_parameter_list_to_xmlnode, child);
if (purple_pounce_get_save(pounce))
purple_xmlnode_new_child(node, "save");
return node;
}
static PurpleXmlNode *
pounces_to_xmlnode(void)
{
PurpleXmlNode *node, *child;
GList *cur;
node = purple_xmlnode_new("pounces");
purple_xmlnode_set_attrib(node, "version", "1.0");
for (cur = purple_pounces_get_all(); cur != NULL; cur = cur->next)
{
child = pounce_to_xmlnode(cur->data);
purple_xmlnode_insert_child(node, child);
}
return node;
}
static void
sync_pounces(void)
{
PurpleXmlNode *node;
char *data;
if (!pounces_loaded)
{
purple_debug_error("pounce", "Attempted to save buddy pounces before "
"they were read!\n");
return;
}
node = pounces_to_xmlnode();
data = purple_xmlnode_to_formatted_str(node, NULL);
purple_util_write_data_to_config_file("pounces.xml", data, -1);
g_free(data);
purple_xmlnode_free(node);
}
static gboolean
save_cb(gpointer data)
{
sync_pounces();
save_timer = 0;
return FALSE;
}
static void
schedule_pounces_save(void)
{
if (save_timer == 0)
save_timer = g_timeout_add_seconds(5, save_cb, NULL);
}
/*********************************************************************
* Reading from disk *
*********************************************************************/
static void
free_parser_data(gpointer user_data)
{
PounceParserData *data = user_data;
if (data->buffer != NULL)
g_string_free(data->buffer, TRUE);
g_free(data->ui_name);
g_free(data->pouncee);
g_free(data->protocol_id);
g_free(data->event_type);
g_free(data->option_type);
g_free(data->action_name);
g_free(data->param_name);
g_free(data->account_name);
g_free(data);
}
static void
start_element_handler(GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
gpointer user_data, GError **error)
{
PounceParserData *data = user_data;
GHashTable *atts;
int i;
atts = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
for (i = 0; attribute_names[i] != NULL; i++) {
g_hash_table_insert(atts, g_strdup(attribute_names[i]),
g_strdup(attribute_values[i]));
}
if (data->buffer != NULL) {
g_string_free(data->buffer, TRUE);
data->buffer = NULL;
}
if (purple_strequal(element_name, "pounce")) {
const char *ui = g_hash_table_lookup(atts, "ui");
if (ui == NULL) {
purple_debug(PURPLE_DEBUG_ERROR, "pounce",
"Unset 'ui' parameter for pounce!\n");
}
else
data->ui_name = g_strdup(ui);
data->events = 0;
}
else if (purple_strequal(element_name, "account")) {
const char *protocol_id = g_hash_table_lookup(atts, "protocol");
if (protocol_id == NULL) {
purple_debug(PURPLE_DEBUG_ERROR, "pounce",
"Unset 'protocol' parameter for account!\n");
}
else
data->protocol_id = g_strdup(protocol_id);
}
else if (purple_strequal(element_name, "option")) {
const char *type = g_hash_table_lookup(atts, "type");
if (type == NULL) {
purple_debug(PURPLE_DEBUG_ERROR, "pounce",
"Unset 'type' parameter for option!\n");
}
else
data->option_type = g_strdup(type);
}
else if (purple_strequal(element_name, "event")) {
const char *type = g_hash_table_lookup(atts, "type");
if (type == NULL) {
purple_debug(PURPLE_DEBUG_ERROR, "pounce",
"Unset 'type' parameter for event!\n");
}
else
data->event_type = g_strdup(type);
}
else if (purple_strequal(element_name, "action")) {
const char *type = g_hash_table_lookup(atts, "type");
if (type == NULL) {
purple_debug(PURPLE_DEBUG_ERROR, "pounce",
"Unset 'type' parameter for action!\n");
}
else
data->action_name = g_strdup(type);
}
else if (purple_strequal(element_name, "param")) {
const char *param_name = g_hash_table_lookup(atts, "name");
if (param_name == NULL) {
purple_debug(PURPLE_DEBUG_ERROR, "pounce",
"Unset 'name' parameter for param!\n");
}
else
data->param_name = g_strdup(param_name);
}
g_hash_table_destroy(atts);
}
static void
end_element_handler(GMarkupParseContext *context, const gchar *element_name,
gpointer user_data, GError **error)
{
PounceParserData *data = user_data;
gchar *buffer = NULL;
if (data->buffer != NULL) {
buffer = g_string_free(data->buffer, FALSE);
data->buffer = NULL;
}
if (purple_strequal(element_name, "account")) {
g_free(data->account_name);
data->account_name = g_strdup(buffer);
}
else if (purple_strequal(element_name, "pouncee")) {
g_free(data->pouncee);
data->pouncee = g_strdup(buffer);
}
else if (purple_strequal(element_name, "option")) {
if (purple_strequal(data->option_type, "on-away"))
data->options |= PURPLE_POUNCE_OPTION_AWAY;
g_free(data->option_type);
data->option_type = NULL;
}
else if (purple_strequal(element_name, "event")) {
if (purple_strequal(data->event_type, "sign-on"))
data->events |= PURPLE_POUNCE_SIGNON;
else if (purple_strequal(data->event_type, "sign-off"))
data->events |= PURPLE_POUNCE_SIGNOFF;
else if (purple_strequal(data->event_type, "away"))
data->events |= PURPLE_POUNCE_AWAY;
else if (purple_strequal(data->event_type, "return-from-away"))
data->events |= PURPLE_POUNCE_AWAY_RETURN;
else if (purple_strequal(data->event_type, "idle"))
data->events |= PURPLE_POUNCE_IDLE;
else if (purple_strequal(data->event_type, "return-from-idle"))
data->events |= PURPLE_POUNCE_IDLE_RETURN;
else if (purple_strequal(data->event_type, "start-typing"))
data->events |= PURPLE_POUNCE_TYPING;
else if (purple_strequal(data->event_type, "typed"))
data->events |= PURPLE_POUNCE_TYPED;
else if (purple_strequal(data->event_type, "stop-typing"))
data->events |= PURPLE_POUNCE_TYPING_STOPPED;
else if (purple_strequal(data->event_type, "message-received"))
data->events |= PURPLE_POUNCE_MESSAGE_RECEIVED;
g_free(data->event_type);
data->event_type = NULL;
}
else if (purple_strequal(element_name, "action")) {
if (data->pounce != NULL) {
purple_pounce_action_register(data->pounce, data->action_name);
purple_pounce_action_set_enabled(data->pounce, data->action_name, TRUE);
}
g_free(data->action_name);
data->action_name = NULL;
}
else if (purple_strequal(element_name, "param")) {
if (data->pounce != NULL) {
purple_pounce_action_set_attribute(data->pounce, data->action_name,
data->param_name, buffer);
}
g_free(data->param_name);
data->param_name = NULL;
}
else if (purple_strequal(element_name, "events")) {
PurpleAccount *account;
account = purple_accounts_find(data->account_name, data->protocol_id);
g_free(data->account_name);
g_free(data->protocol_id);
data->account_name = NULL;
data->protocol_id = NULL;
if (account == NULL) {
purple_debug(PURPLE_DEBUG_ERROR, "pounce",
"Account for pounce not found!\n");
/*
* This pounce has effectively been removed, so make
* sure that we save the changes to pounces.xml
*/
schedule_pounces_save();
}
else {
purple_debug(PURPLE_DEBUG_INFO, "pounce",
"Creating pounce: %s, %s\n", data->ui_name,
data->pouncee);
data->pounce = purple_pounce_new(data->ui_name, account,
data->pouncee, data->events,
data->options);
}
g_free(data->pouncee);
data->pouncee = NULL;
}
else if (purple_strequal(element_name, "save")) {
if (data->pounce != NULL)
purple_pounce_set_save(data->pounce, TRUE);
}
else if (purple_strequal(element_name, "pounce")) {
data->pounce = NULL;
data->events = 0;
data->options = 0;
g_free(data->ui_name);
g_free(data->pouncee);
g_free(data->protocol_id);
g_free(data->event_type);
g_free(data->option_type);
g_free(data->action_name);
g_free(data->param_name);
g_free(data->account_name);
data->ui_name = NULL;
data->pouncee = NULL;
data->protocol_id = NULL;
data->event_type = NULL;
data->option_type = NULL;
data->action_name = NULL;
data->param_name = NULL;
data->account_name = NULL;
}
g_free(buffer);
}
static void
text_handler(GMarkupParseContext *context, const gchar *text,
gsize text_len, gpointer user_data, GError **error)
{
PounceParserData *data = user_data;
if (data->buffer == NULL)
data->buffer = g_string_new_len(text, text_len);
else
g_string_append_len(data->buffer, text, text_len);
}
static GMarkupParser pounces_parser =
{
start_element_handler,
end_element_handler,
text_handler,
NULL,
NULL
};
static gboolean
purple_pounces_load(void)
{
gchar *filename = g_build_filename(purple_config_dir(), "pounces.xml", NULL);
gchar *contents = NULL;
gsize length;
GMarkupParseContext *context;
GError *error = NULL;
PounceParserData *parser_data;
if (filename == NULL) {
pounces_loaded = TRUE;
return FALSE;
}
if (!g_file_get_contents(filename, &contents, &length, &error)) {
purple_debug(PURPLE_DEBUG_ERROR, "pounce",
"Error reading pounces: %s\n", error->message);
g_free(filename);
g_error_free(error);
pounces_loaded = TRUE;
return FALSE;
}
parser_data = g_new0(PounceParserData, 1);
context = g_markup_parse_context_new(&pounces_parser, 0,
parser_data, free_parser_data);
if (!g_markup_parse_context_parse(context, contents, length, NULL)) {
g_markup_parse_context_free(context);
g_free(contents);
g_free(filename);
pounces_loaded = TRUE;
return FALSE;
}
if (!g_markup_parse_context_end_parse(context, NULL)) {
purple_debug(PURPLE_DEBUG_ERROR, "pounce", "Error parsing %s\n",
filename);
g_markup_parse_context_free(context);
g_free(contents);
g_free(filename);
pounces_loaded = TRUE;
return FALSE;
}
g_markup_parse_context_free(context);
g_free(contents);
g_free(filename);
pounces_loaded = TRUE;
return TRUE;
}
PurplePounce *
purple_pounce_new(const char *ui_type, PurpleAccount *pouncer,
const char *pouncee, PurplePounceEvent event,
PurplePounceOption option)
{
PurplePounce *pounce;
PurplePounceHandler *handler;
g_return_val_if_fail(ui_type != NULL, NULL);
g_return_val_if_fail(pouncer != NULL, NULL);
g_return_val_if_fail(pouncee != NULL, NULL);
g_return_val_if_fail(event != 0, NULL);
pounce = g_new0(PurplePounce, 1);
pounce->ui_type = g_strdup(ui_type);
pounce->pouncer = pouncer;
pounce->pouncee = g_strdup(pouncee);
pounce->events = event;
pounce->options = option;
pounce->actions = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, free_action_data);
handler = g_hash_table_lookup(pounce_handlers, pounce->ui_type);
if (handler != NULL && handler->new_pounce != NULL)
handler->new_pounce(pounce);
pounces = g_list_append(pounces, pounce);
schedule_pounces_save();
return pounce;
}
void
purple_pounce_destroy(PurplePounce *pounce)
{
PurplePounceHandler *handler;
g_return_if_fail(pounce != NULL);
handler = g_hash_table_lookup(pounce_handlers, pounce->ui_type);
pounces = g_list_remove(pounces, pounce);
g_free(pounce->ui_type);
g_free(pounce->pouncee);
g_hash_table_destroy(pounce->actions);
if (handler != NULL && handler->free_pounce != NULL)
handler->free_pounce(pounce);
g_free(pounce);
schedule_pounces_save();
}
void
purple_pounce_destroy_all_by_account(PurpleAccount *account)
{
PurpleAccount *pouncer;
PurplePounce *pounce;
GList *l, *l_next;
g_return_if_fail(account != NULL);
for (l = purple_pounces_get_all(); l != NULL; l = l_next)
{
pounce = (PurplePounce *)l->data;
l_next = l->next;
pouncer = purple_pounce_get_pouncer(pounce);
if (pouncer == account)
purple_pounce_destroy(pounce);
}
}
void
purple_pounce_destroy_all_by_buddy(PurpleBuddy *buddy)
{
const char *pouncee, *bname;
PurpleAccount *pouncer, *bacct;
PurplePounce *pounce;
GList *l, *l_next;
g_return_if_fail(buddy != NULL);
bacct = purple_buddy_get_account(buddy);
bname = purple_buddy_get_name(buddy);
for (l = purple_pounces_get_all(); l != NULL; l = l_next) {
pounce = (PurplePounce *)l->data;
l_next = l->next;
pouncer = purple_pounce_get_pouncer(pounce);
pouncee = purple_pounce_get_pouncee(pounce);
if ( (pouncer == bacct) && (purple_strequal(pouncee, bname)) )
purple_pounce_destroy(pounce);
}
}
void
purple_pounce_set_events(PurplePounce *pounce, PurplePounceEvent events)
{
g_return_if_fail(pounce != NULL);
g_return_if_fail(events != PURPLE_POUNCE_NONE);
pounce->events = events;
schedule_pounces_save();
}
void
purple_pounce_set_options(PurplePounce *pounce, PurplePounceOption options)
{
g_return_if_fail(pounce != NULL);
pounce->options = options;
schedule_pounces_save();
}
void
purple_pounce_set_pouncer(PurplePounce *pounce, PurpleAccount *pouncer)
{
g_return_if_fail(pounce != NULL);
g_return_if_fail(pouncer != NULL);
pounce->pouncer = pouncer;
schedule_pounces_save();
}
void
purple_pounce_set_pouncee(PurplePounce *pounce, const char *pouncee)
{
g_return_if_fail(pounce != NULL);
g_return_if_fail(pouncee != NULL);
g_free(pounce->pouncee);
pounce->pouncee = g_strdup(pouncee);
schedule_pounces_save();
}
void
purple_pounce_set_save(PurplePounce *pounce, gboolean save)
{
g_return_if_fail(pounce != NULL);
pounce->save = save;
schedule_pounces_save();
}
void
purple_pounce_action_register(PurplePounce *pounce, const char *name)
{
PurplePounceActionData *action_data;
g_return_if_fail(pounce != NULL);
g_return_if_fail(name != NULL);
if (g_hash_table_lookup(pounce->actions, name) != NULL)
return;
action_data = g_new0(PurplePounceActionData, 1);
action_data->name = g_strdup(name);
action_data->enabled = FALSE;
action_data->atts = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, g_free);
g_hash_table_insert(pounce->actions, g_strdup(name), action_data);
schedule_pounces_save();
}
void
purple_pounce_action_set_enabled(PurplePounce *pounce, const char *action,
gboolean enabled)
{
PurplePounceActionData *action_data;
g_return_if_fail(pounce != NULL);
g_return_if_fail(action != NULL);
action_data = find_action_data(pounce, action);
g_return_if_fail(action_data != NULL);
action_data->enabled = enabled;
schedule_pounces_save();
}
void
purple_pounce_action_set_attribute(PurplePounce *pounce, const char *action,
const char *attr, const char *value)
{
PurplePounceActionData *action_data;
g_return_if_fail(pounce != NULL);
g_return_if_fail(action != NULL);
g_return_if_fail(attr != NULL);
action_data = find_action_data(pounce, action);
g_return_if_fail(action_data != NULL);
if (value == NULL)
g_hash_table_remove(action_data->atts, attr);
else
g_hash_table_insert(action_data->atts, g_strdup(attr),
g_strdup(value));
schedule_pounces_save();
}
void
purple_pounce_set_data(PurplePounce *pounce, void *data)
{
g_return_if_fail(pounce != NULL);
pounce->data = data;
schedule_pounces_save();
}
PurplePounceEvent
purple_pounce_get_events(const PurplePounce *pounce)
{
g_return_val_if_fail(pounce != NULL, PURPLE_POUNCE_NONE);
return pounce->events;
}
PurplePounceOption
purple_pounce_get_options(const PurplePounce *pounce)
{
g_return_val_if_fail(pounce != NULL, PURPLE_POUNCE_OPTION_NONE);
return pounce->options;
}
PurpleAccount *
purple_pounce_get_pouncer(const PurplePounce *pounce)
{
g_return_val_if_fail(pounce != NULL, NULL);
return pounce->pouncer;
}
const char *
purple_pounce_get_pouncee(const PurplePounce *pounce)
{
g_return_val_if_fail(pounce != NULL, NULL);
return pounce->pouncee;
}
gboolean
purple_pounce_get_save(const PurplePounce *pounce)
{
g_return_val_if_fail(pounce != NULL, FALSE);
return pounce->save;
}
gboolean
purple_pounce_action_is_enabled(const PurplePounce *pounce, const char *action)
{
PurplePounceActionData *action_data;
g_return_val_if_fail(pounce != NULL, FALSE);
g_return_val_if_fail(action != NULL, FALSE);
action_data = find_action_data(pounce, action);
g_return_val_if_fail(action_data != NULL, FALSE);
return action_data->enabled;
}
const char *
purple_pounce_action_get_attribute(const PurplePounce *pounce,
const char *action, const char *attr)
{
PurplePounceActionData *action_data;
g_return_val_if_fail(pounce != NULL, NULL);
g_return_val_if_fail(action != NULL, NULL);
g_return_val_if_fail(attr != NULL, NULL);
action_data = find_action_data(pounce, action);
g_return_val_if_fail(action_data != NULL, NULL);
return g_hash_table_lookup(action_data->atts, attr);
}
void *
purple_pounce_get_data(const PurplePounce *pounce)
{
g_return_val_if_fail(pounce != NULL, NULL);
return pounce->data;
}
void
purple_pounce_execute(PurpleAccount *pouncer, const char *pouncee,
PurplePounceEvent events)
{
PurplePounce *pounce;
PurplePounceHandler *handler;
PurplePresence *presence;
GList *l, *l_next;
char *norm_pouncee;
g_return_if_fail(pouncer != NULL);
g_return_if_fail(pouncee != NULL);
g_return_if_fail(events != PURPLE_POUNCE_NONE);
norm_pouncee = g_strdup(purple_normalize(pouncer, pouncee));
for (l = purple_pounces_get_all(); l != NULL; l = l_next)
{
pounce = (PurplePounce *)l->data;
l_next = l->next;
presence = purple_account_get_presence(pouncer);
if ((purple_pounce_get_events(pounce) & events) &&
(purple_pounce_get_pouncer(pounce) == pouncer) &&
!purple_utf8_strcasecmp(purple_normalize(pouncer, purple_pounce_get_pouncee(pounce)),
norm_pouncee) &&
(pounce->options == PURPLE_POUNCE_OPTION_NONE ||
(pounce->options & PURPLE_POUNCE_OPTION_AWAY &&
!purple_presence_is_available(presence))))
{
handler = g_hash_table_lookup(pounce_handlers, pounce->ui_type);
if (handler != NULL && handler->cb != NULL)
{
handler->cb(pounce, events, purple_pounce_get_data(pounce));
if (!purple_pounce_get_save(pounce))
purple_pounce_destroy(pounce);
}
}
}
g_free(norm_pouncee);
}
PurplePounce *
purple_find_pounce(PurpleAccount *pouncer, const char *pouncee,
PurplePounceEvent events)
{
PurplePounce *pounce = NULL;
GList *l;
char *norm_pouncee;
g_return_val_if_fail(pouncer != NULL, NULL);
g_return_val_if_fail(pouncee != NULL, NULL);
g_return_val_if_fail(events != PURPLE_POUNCE_NONE, NULL);
norm_pouncee = g_strdup(purple_normalize(pouncer, pouncee));
for (l = purple_pounces_get_all(); l != NULL; l = l->next)
{
pounce = (PurplePounce *)l->data;
if ((purple_pounce_get_events(pounce) & events) &&
(purple_pounce_get_pouncer(pounce) == pouncer) &&
!purple_utf8_strcasecmp(purple_normalize(pouncer, purple_pounce_get_pouncee(pounce)),
norm_pouncee))
{
break;
}
pounce = NULL;
}
g_free(norm_pouncee);
return pounce;
}
void
purple_pounces_register_handler(const char *ui, PurplePounceCb cb,
void (*new_pounce)(PurplePounce *pounce),
void (*free_pounce)(PurplePounce *pounce))
{
PurplePounceHandler *handler;
g_return_if_fail(ui != NULL);
g_return_if_fail(cb != NULL);
handler = g_new0(PurplePounceHandler, 1);
handler->ui = g_strdup(ui);
handler->cb = cb;
handler->new_pounce = new_pounce;
handler->free_pounce = free_pounce;
g_hash_table_insert(pounce_handlers, g_strdup(ui), handler);
}
void
purple_pounces_unregister_handler(const char *ui)
{
g_return_if_fail(ui != NULL);
g_hash_table_remove(pounce_handlers, ui);
}
GList *
purple_pounces_get_all(void)
{
return pounces;
}
GList *purple_pounces_get_all_for_ui(const char *ui)
{
GList *list = NULL, *iter;
g_return_val_if_fail(ui != NULL, NULL);
for (iter = pounces; iter; iter = iter->next) {
PurplePounce *pounce = iter->data;
if (purple_strequal(pounce->ui_type, ui))
list = g_list_prepend(list, pounce);
}
list = g_list_reverse(list);
return list;
}
static void
free_pounce_handler(gpointer user_data)
{
PurplePounceHandler *handler = (PurplePounceHandler *)user_data;
g_free(handler->ui);
g_free(handler);
}
static void
buddy_state_cb(PurpleBuddy *buddy, PurplePounceEvent event)
{
PurpleAccount *account = purple_buddy_get_account(buddy);
const gchar *name = purple_buddy_get_name(buddy);
purple_pounce_execute(account, name, event);
}
static void
buddy_status_changed_cb(PurpleBuddy *buddy, PurpleStatus *old_status,
PurpleStatus *status)
{
PurpleAccount *account = purple_buddy_get_account(buddy);
const gchar *name = purple_buddy_get_name(buddy);
gboolean old_available, available;
available = purple_status_is_available(status);
old_available = purple_status_is_available(old_status);
if (available && !old_available)
purple_pounce_execute(account, name, PURPLE_POUNCE_AWAY_RETURN);
else if (!available && old_available)
purple_pounce_execute(account, name, PURPLE_POUNCE_AWAY);
}
static void
buddy_idle_changed_cb(PurpleBuddy *buddy, gboolean old_idle, gboolean idle)
{
PurpleAccount *account = purple_buddy_get_account(buddy);
const gchar *name = purple_buddy_get_name(buddy);
if (idle && !old_idle)
purple_pounce_execute(account, name, PURPLE_POUNCE_IDLE);
else if (!idle && old_idle)
purple_pounce_execute(account, name, PURPLE_POUNCE_IDLE_RETURN);
}
static void
buddy_typing_cb(PurpleAccount *account, const char *name, void *data)
{
PurpleIMConversation *im;
im = purple_conversations_find_im_with_account(name, account);
if (im != NULL)
{
PurpleIMTypingState state;
PurplePounceEvent event;
state = purple_im_conversation_get_typing_state(im);
if (state == PURPLE_IM_TYPED)
event = PURPLE_POUNCE_TYPED;
else if (state == PURPLE_IM_NOT_TYPING)
event = PURPLE_POUNCE_TYPING_STOPPED;
else
event = PURPLE_POUNCE_TYPING;
purple_pounce_execute(account, name, event);
}
}
static void
received_message_cb(PurpleAccount *account, const char *name, void *data)
{
purple_pounce_execute(account, name, PURPLE_POUNCE_MESSAGE_RECEIVED);
}
void *
purple_pounces_get_handle(void)
{
static int pounce_handle;
return &pounce_handle;
}
void
purple_pounces_init(void)
{
void *handle = purple_pounces_get_handle();
void *blist_handle = purple_blist_get_handle();
void *conv_handle = purple_conversations_get_handle();
pounce_handlers = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, free_pounce_handler);
purple_signal_connect(blist_handle, "buddy-idle-changed",
handle, PURPLE_CALLBACK(buddy_idle_changed_cb), NULL);
purple_signal_connect(blist_handle, "buddy-status-changed",
handle, PURPLE_CALLBACK(buddy_status_changed_cb), NULL);
purple_signal_connect(blist_handle, "buddy-signed-on",
handle, PURPLE_CALLBACK(buddy_state_cb),
GINT_TO_POINTER(PURPLE_POUNCE_SIGNON));
purple_signal_connect(blist_handle, "buddy-signed-off",
handle, PURPLE_CALLBACK(buddy_state_cb),
GINT_TO_POINTER(PURPLE_POUNCE_SIGNOFF));
purple_signal_connect(conv_handle, "buddy-typing",
handle, PURPLE_CALLBACK(buddy_typing_cb), NULL);
purple_signal_connect(conv_handle, "buddy-typed",
handle, PURPLE_CALLBACK(buddy_typing_cb), NULL);
purple_signal_connect(conv_handle, "buddy-typing-stopped",
handle, PURPLE_CALLBACK(buddy_typing_cb), NULL);
purple_signal_connect(conv_handle, "received-im-msg",
handle, PURPLE_CALLBACK(received_message_cb), NULL);
purple_pounces_load();
}
void
purple_pounces_uninit()
{
if (save_timer != 0)
{
g_source_remove(save_timer);
save_timer = 0;
sync_pounces();
}
purple_signals_disconnect_by_handle(purple_pounces_get_handle());
g_hash_table_destroy(pounce_handlers);
pounce_handlers = NULL;
}