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

#define _PURPLE_BLIST_C_

#include "internal.h"

#include "blist.h"

#include "conversation.h"

#include "dbus-maybe.h"

#include "debug.h"

#include "glibcompat.h"

#include "notify.h"

#include "pounce.h"

#include "prefs.h"

#include "privacy.h"

#include "prpl.h"

#include "server.h"

#include "signals.h"

#include "util.h"

#include "value.h"

#include "xmlnode.h"

static PurpleBlistUiOps *blist_ui_ops = NULL;

static PurpleBuddyList *purplebuddylist = NULL;

/**

* A hash table used for efficient lookups of buddies by name.

* PurpleAccount* => GHashTable*, with the inner hash table being

* struct _purple_hbuddy => PurpleBuddy*

static GHashTable *buddies_cache = NULL;

/**

* A hash table used for efficient lookups of groups by name.

* UTF-8 collate-key => PurpleGroup*.

static GHashTable *groups_cache = NULL;

static guint save_timer = 0;

static gboolean blist_loaded = FALSE;

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

* Private utility functions *

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

static PurpleBlistNode *purple_blist_get_last_sibling(PurpleBlistNode *node)

{

PurpleBlistNode *n = node;

if (!n)

return NULL;

while (n->next)

n = n->next;

return n;

}

static PurpleBlistNode *purple_blist_get_last_child(PurpleBlistNode *node)

{

if (!node)

return NULL;

return purple_blist_get_last_sibling(node->child);

}

struct _list_account_buddies {

GSList *list;

PurpleAccount *account;

};

struct _purple_hbuddy {

char *name;

PurpleAccount *account;

PurpleBlistNode *group;

};

/* This function must not use purple_normalize */

static guint _purple_blist_hbuddy_hash(struct _purple_hbuddy *hb)

{

return g_str_hash(hb->name) ^ g_direct_hash(hb->group) ^ g_direct_hash(hb->account);

}

/* This function must not use purple_normalize */

static guint _purple_blist_hbuddy_equal(struct _purple_hbuddy *hb1, struct _purple_hbuddy *hb2)

{

return (hb1->group == hb2->group &&

hb1->account == hb2->account &&

purple_strequal(hb1->name, hb2->name));

}

static void _purple_blist_hbuddy_free_key(struct _purple_hbuddy *hb)

{

g_free(hb->name);

g_free(hb);

}

static void

purple_blist_buddies_cache_add_account(PurpleAccount *account)

{

GHashTable *account_buddies = g_hash_table_new_full((GHashFunc)_purple_blist_hbuddy_hash,

(GEqualFunc)_purple_blist_hbuddy_equal,

(GDestroyNotify)_purple_blist_hbuddy_free_key, NULL);

g_hash_table_insert(buddies_cache, account, account_buddies);

}

static void

purple_blist_buddies_cache_remove_account(const PurpleAccount *account)

{

g_hash_table_remove(buddies_cache, account);

}

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

* Writing to disk *

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

static void

value_to_xmlnode(gpointer key, gpointer hvalue, gpointer user_data)

{

const char *name;

PurpleValue *value;

xmlnode *node, *child;

char buf[21];

name = (const char *)key;

value = (PurpleValue *)hvalue;

node = (xmlnode *)user_data;

g_return_if_fail(value != NULL);

child = xmlnode_new_child(node, "setting");

xmlnode_set_attrib(child, "name", name);

if (purple_value_get_type(value) == PURPLE_TYPE_INT) {

xmlnode_set_attrib(child, "type", "int");

g_snprintf(buf, sizeof(buf), "%d", purple_value_get_int(value));

xmlnode_insert_data(child, buf, -1);

}

else if (purple_value_get_type(value) == PURPLE_TYPE_STRING) {

xmlnode_set_attrib(child, "type", "string");

xmlnode_insert_data(child, purple_value_get_string(value), -1);

}

else if (purple_value_get_type(value) == PURPLE_TYPE_BOOLEAN) {

xmlnode_set_attrib(child, "type", "bool");

g_snprintf(buf, sizeof(buf), "%d", purple_value_get_boolean(value));

xmlnode_insert_data(child, buf, -1);

}

static void

chat_component_to_xmlnode(gpointer key, gpointer value, gpointer user_data)

{

const char *name;

const char *data;

xmlnode *node, *child;

name = (const char *)key;

data = (const char *)value;

node = (xmlnode *)user_data;

g_return_if_fail(data != NULL);

child = xmlnode_new_child(node, "component");

xmlnode_set_attrib(child, "name", name);

xmlnode_insert_data(child, data, -1);

}

static xmlnode *

buddy_to_xmlnode(PurpleBlistNode *bnode)

{

xmlnode *node, *child;

PurpleBuddy *buddy;

buddy = (PurpleBuddy *)bnode;

node = xmlnode_new("buddy");

xmlnode_set_attrib(node, "account", purple_account_get_username(buddy->account));

xmlnode_set_attrib(node, "proto", purple_account_get_protocol_id(buddy->account));

child = xmlnode_new_child(node, "name");

xmlnode_insert_data(child, buddy->name, -1);

if (buddy->alias != NULL)

{

child = xmlnode_new_child(node, "alias");

xmlnode_insert_data(child, buddy->alias, -1);

}

/* Write buddy settings */

g_hash_table_foreach(buddy->node.settings, value_to_xmlnode, node);

return node;

}

static xmlnode *

contact_to_xmlnode(PurpleBlistNode *cnode)

{

xmlnode *node, *child;

PurpleContact *contact;

PurpleBlistNode *bnode;

contact = (PurpleContact *)cnode;

node = xmlnode_new("contact");

if (contact->alias != NULL)

{

xmlnode_set_attrib(node, "alias", contact->alias);

}

/* Write buddies */

for (bnode = cnode->child; bnode != NULL; bnode = bnode->next)

{

if (!PURPLE_BLIST_NODE_SHOULD_SAVE(bnode))

continue;

if (PURPLE_BLIST_NODE_IS_BUDDY(bnode))

{

child = buddy_to_xmlnode(bnode);

xmlnode_insert_child(node, child);

}

/* Write contact settings */

g_hash_table_foreach(cnode->settings, value_to_xmlnode, node);

return node;

}

static xmlnode *

chat_to_xmlnode(PurpleBlistNode *cnode)

{

xmlnode *node, *child;

PurpleChat *chat;

chat = (PurpleChat *)cnode;

node = xmlnode_new("chat");

xmlnode_set_attrib(node, "proto", purple_account_get_protocol_id(chat->account));

xmlnode_set_attrib(node, "account", purple_account_get_username(chat->account));

if (chat->alias != NULL)

{

child = xmlnode_new_child(node, "alias");

xmlnode_insert_data(child, chat->alias, -1);

}

/* Write chat components */

g_hash_table_foreach(chat->components, chat_component_to_xmlnode, node);

/* Write chat settings */

g_hash_table_foreach(chat->node.settings, value_to_xmlnode, node);

return node;

}

static xmlnode *

group_to_xmlnode(PurpleBlistNode *gnode)

{

xmlnode *node, *child;

PurpleGroup *group;

PurpleBlistNode *cnode;

group = (PurpleGroup *)gnode;

node = xmlnode_new("group");

if (!purple_strequal(group->name, _("Buddies")))

xmlnode_set_attrib(node, "name", group->name);

/* Write settings */

g_hash_table_foreach(group->node.settings, value_to_xmlnode, node);

/* Write contacts and chats */

for (cnode = gnode->child; cnode != NULL; cnode = cnode->next)

{

if (!PURPLE_BLIST_NODE_SHOULD_SAVE(cnode))

continue;

if (PURPLE_BLIST_NODE_IS_CONTACT(cnode))

{

child = contact_to_xmlnode(cnode);

xmlnode_insert_child(node, child);

}

else if (PURPLE_BLIST_NODE_IS_CHAT(cnode))

{

child = chat_to_xmlnode(cnode);

xmlnode_insert_child(node, child);

}

return node;

}

static xmlnode *

accountprivacy_to_xmlnode(PurpleAccount *account)

{

xmlnode *node, *child;

GSList *cur;

char buf[10];

node = xmlnode_new("account");

xmlnode_set_attrib(node, "proto", purple_account_get_protocol_id(account));

xmlnode_set_attrib(node, "name", purple_account_get_username(account));

g_snprintf(buf, sizeof(buf), "%d", account->perm_deny);

xmlnode_set_attrib(node, "mode", buf);

for (cur = account->permit; cur; cur = cur->next)

{

child = xmlnode_new_child(node, "permit");

xmlnode_insert_data(child, cur->data, -1);

}

for (cur = account->deny; cur; cur = cur->next)

{

child = xmlnode_new_child(node, "block");

xmlnode_insert_data(child, cur->data, -1);

}

return node;

}

static xmlnode *

blist_to_xmlnode(void)

{

xmlnode *node, *child, *grandchild;

PurpleBlistNode *gnode;

GList *cur;

node = xmlnode_new("purple");

xmlnode_set_attrib(node, "version", "1.0");

/* Write groups */

child = xmlnode_new_child(node, "blist");

for (gnode = purplebuddylist->root; gnode != NULL; gnode = gnode->next)

{

if (!PURPLE_BLIST_NODE_SHOULD_SAVE(gnode))

continue;

if (PURPLE_BLIST_NODE_IS_GROUP(gnode))

{

grandchild = group_to_xmlnode(gnode);

xmlnode_insert_child(child, grandchild);

}

/* Write privacy settings */

child = xmlnode_new_child(node, "privacy");

for (cur = purple_accounts_get_all(); cur != NULL; cur = cur->next)

{

grandchild = accountprivacy_to_xmlnode(cur->data);

xmlnode_insert_child(child, grandchild);

}

return node;

}

static void

purple_blist_sync(void)

{

xmlnode *node;

char *data;

if (!blist_loaded)

{

purple_debug_error("blist", "Attempted to save buddy list before it "

"was read!\n");

return;

}

node = blist_to_xmlnode();

data = xmlnode_to_formatted_str(node, NULL);

purple_util_write_data_to_file("blist.xml", data, -1);

g_free(data);

xmlnode_free(node);

}

static gboolean

save_cb(gpointer data)

{

purple_blist_sync();

save_timer = 0;

return FALSE;

}

static void

_purple_blist_schedule_save()

{

if (save_timer == 0)

save_timer = purple_timeout_add_seconds(5, save_cb, NULL);

}

static void

purple_blist_save_account(PurpleAccount *account)

{

#if 1

_purple_blist_schedule_save();

#else

if (account != NULL) {

/* Save the buddies and privacy data for this account */

} else {

/* Save all buddies and privacy data */

}

#endif

}

static void

purple_blist_save_node(PurpleBlistNode *node)

{

_purple_blist_schedule_save();

}

void purple_blist_schedule_save()

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

/* Save everything */

if (ops && ops->save_account)

ops->save_account(NULL);

}

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

* Reading from disk *

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

static void

parse_setting(PurpleBlistNode *node, xmlnode *setting)

{

const char *name = xmlnode_get_attrib(setting, "name");

const char *type = xmlnode_get_attrib(setting, "type");

char *value = xmlnode_get_data(setting);

if (!value)

return;

if (!type || purple_strequal(type, "string"))

purple_blist_node_set_string(node, name, value);

else if (purple_strequal(type, "bool"))

purple_blist_node_set_bool(node, name, atoi(value));

else if (purple_strequal(type, "int"))

purple_blist_node_set_int(node, name, atoi(value));

g_free(value);

}

static void

parse_buddy(PurpleGroup *group, PurpleContact *contact, xmlnode *bnode)

{

PurpleAccount *account;

PurpleBuddy *buddy;

char *name = NULL, *alias = NULL;

const char *acct_name, *proto, *protocol;

xmlnode *x;

acct_name = xmlnode_get_attrib(bnode, "account");

protocol = xmlnode_get_attrib(bnode, "protocol");

protocol = _purple_oscar_convert(acct_name, protocol); /* XXX: Remove */

proto = xmlnode_get_attrib(bnode, "proto");

proto = _purple_oscar_convert(acct_name, proto); /* XXX: Remove */

if (!acct_name || (!proto && !protocol))

return;

account = purple_accounts_find(acct_name, proto ? proto : protocol);

if (!account)

return;

if ((x = xmlnode_get_child(bnode, "name")))

name = xmlnode_get_data(x);

if (!name)

return;

if ((x = xmlnode_get_child(bnode, "alias")))

alias = xmlnode_get_data(x);

buddy = purple_buddy_new(account, name, alias);

purple_blist_add_buddy(buddy, contact, group,

purple_blist_get_last_child((PurpleBlistNode*)contact));

for (x = xmlnode_get_child(bnode, "setting"); x; x = xmlnode_get_next_twin(x)) {

parse_setting((PurpleBlistNode*)buddy, x);

}

g_free(name);

g_free(alias);

}

static void

parse_contact(PurpleGroup *group, xmlnode *cnode)

{

PurpleContact *contact = purple_contact_new();

xmlnode *x;

const char *alias;

purple_blist_add_contact(contact, group,

purple_blist_get_last_child((PurpleBlistNode*)group));

if ((alias = xmlnode_get_attrib(cnode, "alias"))) {

purple_blist_alias_contact(contact, alias);

}

for (x = cnode->child; x; x = x->next) {

if (x->type != XMLNODE_TYPE_TAG)

continue;

if (purple_strequal(x->name, "buddy"))

parse_buddy(group, contact, x);

else if (purple_strequal(x->name, "setting"))

parse_setting((PurpleBlistNode*)contact, x);

}

/* if the contact is empty, don't keep it around. it causes problems */

if (!((PurpleBlistNode*)contact)->child)

purple_blist_remove_contact(contact);

}

static void

parse_chat(PurpleGroup *group, xmlnode *cnode)

{

PurpleChat *chat;

PurpleAccount *account;

const char *acct_name, *proto, *protocol;

xmlnode *x;

char *alias = NULL;

GHashTable *components;

acct_name = xmlnode_get_attrib(cnode, "account");

protocol = xmlnode_get_attrib(cnode, "protocol");

proto = xmlnode_get_attrib(cnode, "proto");

if (!acct_name || (!proto && !protocol))

return;

account = purple_accounts_find(acct_name, proto ? proto : protocol);

if (!account)

return;

if ((x = xmlnode_get_child(cnode, "alias")))

alias = xmlnode_get_data(x);

components = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);

for (x = xmlnode_get_child(cnode, "component"); x; x = xmlnode_get_next_twin(x)) {

const char *name;

char *value;

name = xmlnode_get_attrib(x, "name");

value = xmlnode_get_data(x);

g_hash_table_replace(components, g_strdup(name), value);

}

chat = purple_chat_new(account, alias, components);

purple_blist_add_chat(chat, group,

purple_blist_get_last_child((PurpleBlistNode*)group));

for (x = xmlnode_get_child(cnode, "setting"); x; x = xmlnode_get_next_twin(x)) {

parse_setting((PurpleBlistNode*)chat, x);

}

g_free(alias);

}

static void

parse_group(xmlnode *groupnode)

{

const char *name = xmlnode_get_attrib(groupnode, "name");

PurpleGroup *group;

xmlnode *cnode;

if (!name)

name = _("Buddies");

group = purple_group_new(name);

purple_blist_add_group(group,

purple_blist_get_last_sibling(purplebuddylist->root));

for (cnode = groupnode->child; cnode; cnode = cnode->next) {

if (cnode->type != XMLNODE_TYPE_TAG)

continue;

if (purple_strequal(cnode->name, "setting"))

parse_setting((PurpleBlistNode*)group, cnode);

else if (purple_strequal(cnode->name, "contact") ||

purple_strequal(cnode->name, "person"))

parse_contact(group, cnode);

else if (purple_strequal(cnode->name, "chat"))

parse_chat(group, cnode);

}

/* TODO: Make static and rename to load_blist */

void

purple_blist_load()

{

xmlnode *purple, *blist, *privacy;

blist_loaded = TRUE;

purple = purple_util_read_xml_from_file("blist.xml", _("buddy list"));

if (purple == NULL)

return;

blist = xmlnode_get_child(purple, "blist");

if (blist) {

xmlnode *groupnode;

for (groupnode = xmlnode_get_child(blist, "group"); groupnode != NULL;

groupnode = xmlnode_get_next_twin(groupnode)) {

parse_group(groupnode);

}

privacy = xmlnode_get_child(purple, "privacy");

if (privacy) {

xmlnode *anode;

for (anode = privacy->child; anode; anode = anode->next) {

xmlnode *x;

PurpleAccount *account;

int imode;

const char *acct_name, *proto, *mode, *protocol;

acct_name = xmlnode_get_attrib(anode, "name");

protocol = xmlnode_get_attrib(anode, "protocol");

proto = xmlnode_get_attrib(anode, "proto");

mode = xmlnode_get_attrib(anode, "mode");

if (!acct_name || (!proto && !protocol) || !mode)

continue;

account = purple_accounts_find(acct_name, proto ? proto : protocol);

if (!account)

continue;

imode = atoi(mode);

account->perm_deny = (imode != 0 ? imode : PURPLE_PRIVACY_ALLOW_ALL);

for (x = anode->child; x; x = x->next) {

char *name;

if (x->type != XMLNODE_TYPE_TAG)

continue;

if (purple_strequal(x->name, "permit")) {

name = xmlnode_get_data(x);

purple_privacy_permit_add(account, name, TRUE);

g_free(name);

} else if (purple_strequal(x->name, "block")) {

name = xmlnode_get_data(x);

purple_privacy_deny_add(account, name, TRUE);

g_free(name);

}

xmlnode_free(purple);

/* This tells the buddy icon code to do its thing. */

_purple_buddy_icons_blist_loaded_cb();

}

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

* Stuff *

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

static void

purple_contact_compute_priority_buddy(PurpleContact *contact)

{

PurpleBlistNode *bnode;

PurpleBuddy *new_priority = NULL;

g_return_if_fail(contact != NULL);

contact->priority = NULL;

for (bnode = ((PurpleBlistNode*)contact)->child;

bnode != NULL;

bnode = bnode->next)

{

PurpleBuddy *buddy;

if (!PURPLE_BLIST_NODE_IS_BUDDY(bnode))

continue;

buddy = (PurpleBuddy*)bnode;

if (new_priority == NULL)

{

new_priority = buddy;

continue;

}

if (purple_account_is_connected(buddy->account))

{

int cmp = 1;

if (purple_account_is_connected(new_priority->account))

cmp = purple_presence_compare(purple_buddy_get_presence(new_priority),

purple_buddy_get_presence(buddy));

if (cmp > 0 || (cmp == 0 &&

purple_prefs_get_bool("/purple/contact/last_match")))

{

new_priority = buddy;

}

contact->priority = new_priority;

contact->priority_valid = TRUE;

}

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

* Public API functions *

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

PurpleBuddyList *purple_blist_new()

{

PurpleBlistUiOps *ui_ops;

GList *account;

PurpleBuddyList *gbl = g_new0(PurpleBuddyList, 1);

PURPLE_DBUS_REGISTER_POINTER(gbl, PurpleBuddyList);

ui_ops = purple_blist_get_ui_ops();

gbl->buddies = g_hash_table_new_full((GHashFunc)_purple_blist_hbuddy_hash,

(GEqualFunc)_purple_blist_hbuddy_equal,

(GDestroyNotify)_purple_blist_hbuddy_free_key, NULL);

buddies_cache = g_hash_table_new_full(g_direct_hash, g_direct_equal,

NULL, (GDestroyNotify)g_hash_table_destroy);

groups_cache = g_hash_table_new_full((GHashFunc)g_str_hash,

(GEqualFunc)g_str_equal,

(GDestroyNotify)g_free, NULL);

for (account = purple_accounts_get_all(); account != NULL; account = account->next)

{

purple_blist_buddies_cache_add_account(account->data);

}

if (ui_ops != NULL && ui_ops->new_list != NULL)

ui_ops->new_list(gbl);

return gbl;

}

void

purple_set_blist(PurpleBuddyList *list)

{

purplebuddylist = list;

}

PurpleBuddyList *

purple_get_blist()

{

return purplebuddylist;

}

PurpleBlistNode *

purple_blist_get_root()

{

return purplebuddylist ? purplebuddylist->root : NULL;

}

static void

append_buddy(gpointer key, gpointer value, gpointer user_data)

{

GSList **list = user_data;

*list = g_slist_prepend(*list, value);

}

GSList *

purple_blist_get_buddies()

{

GSList *buddies = NULL;

if (!purplebuddylist)

return NULL;

g_hash_table_foreach(purplebuddylist->buddies, append_buddy, &buddies);

return buddies;

}

void *

purple_blist_get_ui_data()

{

return purplebuddylist->ui_data;

}

void

purple_blist_set_ui_data(void *ui_data)

{

purplebuddylist->ui_data = ui_data;

}

void purple_blist_show()

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

if (ops && ops->show)

ops->show(purplebuddylist);

}

void purple_blist_destroy()

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

purple_debug(PURPLE_DEBUG_INFO, "blist", "Destroying\n");

if (ops && ops->destroy)

ops->destroy(purplebuddylist);

}

void purple_blist_set_visible(gboolean show)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

if (ops && ops->set_visible)

ops->set_visible(purplebuddylist, show);

}

static PurpleBlistNode *get_next_node(PurpleBlistNode *node, gboolean godeep)

{

if (node == NULL)

return NULL;

if (godeep && node->child)

return node->child;

if (node->next)

return node->next;

return get_next_node(node->parent, FALSE);

}

PurpleBlistNode *purple_blist_node_next(PurpleBlistNode *node, gboolean offline)

{

PurpleBlistNode *ret = node;

if (offline)

return get_next_node(ret, TRUE);

{

ret = get_next_node(ret, TRUE);

} while (ret && PURPLE_BLIST_NODE_IS_BUDDY(ret) &&

!purple_account_is_connected(purple_buddy_get_account((PurpleBuddy *)ret)));

return ret;

}

PurpleBlistNode *purple_blist_node_get_parent(PurpleBlistNode *node)

{

return node ? node->parent : NULL;

}

PurpleBlistNode *purple_blist_node_get_first_child(PurpleBlistNode *node)

{

return node ? node->child : NULL;

}

PurpleBlistNode *purple_blist_node_get_sibling_next(PurpleBlistNode *node)

{

return node? node->next : NULL;

}

PurpleBlistNode *purple_blist_node_get_sibling_prev(PurpleBlistNode *node)

{

return node? node->prev : NULL;

}

void *

purple_blist_node_get_ui_data(const PurpleBlistNode *node)

{

g_return_val_if_fail(node, NULL);

return node->ui_data;

}

void

purple_blist_node_set_ui_data(PurpleBlistNode *node, void *ui_data) {

g_return_if_fail(node);

node->ui_data = ui_data;

}

void

purple_blist_update_buddy_status(PurpleBuddy *buddy, PurpleStatus *old_status)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

PurplePresence *presence;

PurpleStatus *status;

PurpleBlistNode *cnode;

g_return_if_fail(buddy != NULL);

presence = purple_buddy_get_presence(buddy);

status = purple_presence_get_active_status(presence);

purple_debug_info("blist", "Updating buddy status for %s (%s)\n",

buddy->name, purple_account_get_protocol_name(buddy->account));

if (purple_status_is_online(status) &&

!purple_status_is_online(old_status)) {

purple_signal_emit(purple_blist_get_handle(), "buddy-signed-on", buddy);

cnode = buddy->node.parent;

if (++(PURPLE_CONTACT(cnode)->online) == 1)

PURPLE_GROUP(cnode->parent)->online++;

} else if (!purple_status_is_online(status) &&

purple_status_is_online(old_status)) {

purple_blist_node_set_int(&buddy->node, "last_seen", time(NULL));

purple_signal_emit(purple_blist_get_handle(), "buddy-signed-off", buddy);

cnode = buddy->node.parent;

if (--(PURPLE_CONTACT(cnode)->online) == 0)

PURPLE_GROUP(cnode->parent)->online--;

} else {

purple_signal_emit(purple_blist_get_handle(),

"buddy-status-changed", buddy, old_status,

status);

}

* This function used to only call the following two functions if one of

* the above signals had been triggered, but that's not good, because

* if someone's away message changes and they don't go from away to back

* to away then no signal is triggered.

* It's a safe assumption that SOMETHING called this function. PROBABLY

* because something, somewhere changed. Calling the stuff below

* certainly won't hurt anything. Unless you're on a K6-2 300.

purple_contact_invalidate_priority_buddy(purple_buddy_get_contact(buddy));

if (ops && ops->update)

ops->update(purplebuddylist, (PurpleBlistNode *)buddy);

}

void

purple_blist_update_node_icon(PurpleBlistNode *node)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

g_return_if_fail(node != NULL);

if (ops && ops->update)

ops->update(purplebuddylist, node);

}

void

purple_blist_update_buddy_icon(PurpleBuddy *buddy)

{

purple_blist_update_node_icon((PurpleBlistNode *)buddy);

}

* TODO: Maybe remove the call to this from server.c and call it

* from oscar.c and toc.c instead?

void purple_blist_rename_buddy(PurpleBuddy *buddy, const char *name)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

struct _purple_hbuddy *hb, *hb2;

GHashTable *account_buddies;

g_return_if_fail(buddy != NULL);

hb = g_new(struct _purple_hbuddy, 1);

hb->name = (gchar *)purple_normalize(buddy->account, buddy->name);

hb->account = buddy->account;

hb->group = ((PurpleBlistNode *)buddy)->parent->parent;

g_hash_table_remove(purplebuddylist->buddies, hb);

account_buddies = g_hash_table_lookup(buddies_cache, buddy->account);

g_hash_table_remove(account_buddies, hb);

hb->name = g_strdup(purple_normalize(buddy->account, name));

g_hash_table_replace(purplebuddylist->buddies, hb, buddy);

hb2 = g_new(struct _purple_hbuddy, 1);

hb2->name = g_strdup(hb->name);

hb2->account = buddy->account;

hb2->group = ((PurpleBlistNode *)buddy)->parent->parent;

g_hash_table_replace(account_buddies, hb2, buddy);

g_free(buddy->name);

buddy->name = g_strdup(name);

if (ops && ops->save_node)

ops->save_node((PurpleBlistNode *) buddy);

if (ops && ops->update)

ops->update(purplebuddylist, (PurpleBlistNode *)buddy);

}

static gboolean

purple_strings_are_different(const char *one, const char *two)

{

return !((one && two && g_utf8_collate(one, two) == 0) ||

((one == NULL || *one == '\0') && (two == NULL || *two == '\0')));

}

void purple_blist_alias_contact(PurpleContact *contact, const char *alias)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

PurpleConversation *conv;

PurpleBlistNode *bnode;

char *old_alias;

char *new_alias = NULL;

g_return_if_fail(contact != NULL);

if ((alias != NULL) && (*alias != '\0'))

new_alias = purple_utf8_strip_unprintables(alias);

if (!purple_strings_are_different(contact->alias, new_alias)) {

g_free(new_alias);

return;

}

old_alias = contact->alias;

if ((new_alias != NULL) && (*new_alias != '\0'))

contact->alias = new_alias;

else {

contact->alias = NULL;

g_free(new_alias); /* could be "\0" */

}

if (ops && ops->save_node)

ops->save_node((PurpleBlistNode*) contact);

if (ops && ops->update)

ops->update(purplebuddylist, (PurpleBlistNode *)contact);

for(bnode = ((PurpleBlistNode *)contact)->child; bnode != NULL; bnode = bnode->next)

{

PurpleBuddy *buddy = (PurpleBuddy *)bnode;

conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, buddy->name,

buddy->account);

if (conv)

purple_conversation_autoset_title(conv);

}

purple_signal_emit(purple_blist_get_handle(), "blist-node-aliased",

contact, old_alias);

g_free(old_alias);

}

void purple_blist_alias_chat(PurpleChat *chat, const char *alias)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

char *old_alias;

char *new_alias = NULL;

g_return_if_fail(chat != NULL);

if ((alias != NULL) && (*alias != '\0'))

new_alias = purple_utf8_strip_unprintables(alias);

if (!purple_strings_are_different(chat->alias, new_alias)) {

g_free(new_alias);

return;

}

old_alias = chat->alias;

if ((new_alias != NULL) && (*new_alias != '\0'))

chat->alias = new_alias;

else {

chat->alias = NULL;

g_free(new_alias); /* could be "\0" */

}

if (ops && ops->save_node)

ops->save_node((PurpleBlistNode*) chat);

if (ops && ops->update)

ops->update(purplebuddylist, (PurpleBlistNode *)chat);

purple_signal_emit(purple_blist_get_handle(), "blist-node-aliased",

chat, old_alias);

g_free(old_alias);

}

void purple_blist_alias_buddy(PurpleBuddy *buddy, const char *alias)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

PurpleConversation *conv;

char *old_alias;

char *new_alias = NULL;

g_return_if_fail(buddy != NULL);

if ((alias != NULL) && (*alias != '\0'))

new_alias = purple_utf8_strip_unprintables(alias);

if (!purple_strings_are_different(buddy->alias, new_alias)) {

g_free(new_alias);

return;

}

old_alias = buddy->alias;

if ((new_alias != NULL) && (*new_alias != '\0'))

buddy->alias = new_alias;

else {

buddy->alias = NULL;

g_free(new_alias); /* could be "\0" */

}

if (ops && ops->save_node)

ops->save_node((PurpleBlistNode*) buddy);

if (ops && ops->update)

ops->update(purplebuddylist, (PurpleBlistNode *)buddy);

conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, buddy->name,

buddy->account);

if (conv)

purple_conversation_autoset_title(conv);

purple_signal_emit(purple_blist_get_handle(), "blist-node-aliased",

buddy, old_alias);

g_free(old_alias);

}

void purple_blist_server_alias_buddy(PurpleBuddy *buddy, const char *alias)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

PurpleConversation *conv;

char *old_alias;

char *new_alias = NULL;

g_return_if_fail(buddy != NULL);

if ((alias != NULL) && (*alias != '\0') && g_utf8_validate(alias, -1, NULL))

new_alias = purple_utf8_strip_unprintables(alias);

if (!purple_strings_are_different(buddy->server_alias, new_alias)) {

g_free(new_alias);

return;

}

old_alias = buddy->server_alias;

if ((new_alias != NULL) && (*new_alias != '\0'))

buddy->server_alias = new_alias;

else {

buddy->server_alias = NULL;

g_free(new_alias); /* could be "\0"; */

}

if (ops && ops->save_node)

ops->save_node((PurpleBlistNode*) buddy);

if (ops && ops->update)

ops->update(purplebuddylist, (PurpleBlistNode *)buddy);

conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, buddy->name,

buddy->account);

if (conv)

purple_conversation_autoset_title(conv);

purple_signal_emit(purple_blist_get_handle(), "blist-node-aliased",

buddy, old_alias);

g_free(old_alias);

}

* TODO: If merging, prompt the user if they want to merge.

void purple_blist_rename_group(PurpleGroup *source, const char *name)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

PurpleGroup *dest;

gchar *old_name;

gchar *new_name;

GList *moved_buddies = NULL;

GSList *accts;

g_return_if_fail(source != NULL);

g_return_if_fail(name != NULL);

new_name = purple_utf8_strip_unprintables(name);

if (*new_name == '\0' || purple_strequal(new_name, source->name)) {

g_free(new_name);

return;

}

dest = purple_find_group(new_name);

if (dest != NULL && purple_utf8_strcasecmp(source->name, dest->name) != 0) {

/* We're merging two groups */

PurpleBlistNode *prev, *child, *next;

prev = purple_blist_get_last_child((PurpleBlistNode*)dest);

child = ((PurpleBlistNode*)source)->child;

* TODO: This seems like a dumb way to do this... why not just

* append all children from the old group to the end of the new

* one? PRPLs might be expecting to receive an add_buddy() for

* each moved buddy...

while (child)

{

next = child->next;

if (PURPLE_BLIST_NODE_IS_CONTACT(child)) {

PurpleBlistNode *bnode;

purple_blist_add_contact((PurpleContact *)child, dest, prev);

for (bnode = child->child; bnode != NULL; bnode = bnode->next) {

purple_blist_add_buddy((PurpleBuddy *)bnode, (PurpleContact *)child,

NULL, bnode->prev);

moved_buddies = g_list_append(moved_buddies, bnode);

}

prev = child;

} else if (PURPLE_BLIST_NODE_IS_CHAT(child)) {

purple_blist_add_chat((PurpleChat *)child, dest, prev);

prev = child;

} else {

purple_debug(PURPLE_DEBUG_ERROR, "blist",

"Unknown child type in group %s\n", source->name);

}

child = next;

}

/* Make a copy of the old group name and then delete the old group */

old_name = g_strdup(source->name);

purple_blist_remove_group(source);

source = dest;

g_free(new_name);

} else {

/* A simple rename */

PurpleBlistNode *cnode, *bnode;

gchar* key;

/* Build a GList of all buddies in this group */

for (cnode = ((PurpleBlistNode *)source)->child; cnode != NULL; cnode = cnode->next) {

if (PURPLE_BLIST_NODE_IS_CONTACT(cnode))

for (bnode = cnode->child; bnode != NULL; bnode = bnode->next)

moved_buddies = g_list_append(moved_buddies, bnode);

}

old_name = source->name;

source->name = new_name;

key = g_utf8_collate_key(old_name, -1);

g_hash_table_remove(groups_cache, key);

g_free(key);

key = g_utf8_collate_key(new_name, -1);

g_hash_table_insert(groups_cache, key, source);

}

/* Save our changes */

if (ops && ops->save_node)

ops->save_node((PurpleBlistNode*) source);

/* Update the UI */

if (ops && ops->update)

ops->update(purplebuddylist, (PurpleBlistNode*)source);

/* Notify all PRPLs */

/* TODO: Is this condition needed? Seems like it would always be TRUE */

if(old_name && !purple_strequal(source->name, old_name)) {

for (accts = purple_group_get_accounts(source); accts; accts = g_slist_remove(accts, accts->data)) {

PurpleAccount *account = accts->data;

PurpleConnection *gc = NULL;

PurplePlugin *prpl = NULL;

PurplePluginProtocolInfo *prpl_info = NULL;

GList *l = NULL, *buddies = NULL;

gc = purple_account_get_connection(account);

if(gc)

prpl = purple_connection_get_prpl(gc);

if(gc && prpl)

prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);

if(!prpl_info)

continue;

for(l = moved_buddies; l; l = l->next) {

PurpleBuddy *buddy = (PurpleBuddy *)l->data;

if(buddy && buddy->account == account)

buddies = g_list_append(buddies, (PurpleBlistNode *)buddy);

}

if(prpl_info->rename_group) {

prpl_info->rename_group(gc, old_name, source, buddies);

} else {

GList *cur, *groups = NULL;

/* Make a list of what the groups each buddy is in */

for(cur = buddies; cur; cur = cur->next) {

PurpleBlistNode *node = (PurpleBlistNode *)cur->data;

groups = g_list_prepend(groups, node->parent->parent);

}

purple_account_remove_buddies(account, buddies, groups);

g_list_free(groups);

purple_account_add_buddies(account, buddies);

}

g_list_free(buddies);

}

g_list_free(moved_buddies);

g_free(old_name);

}

static void purple_blist_node_initialize_settings(PurpleBlistNode *node);

PurpleChat *purple_chat_new(PurpleAccount *account, const char *alias, GHashTable *components)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

PurpleChat *chat;

g_return_val_if_fail(account != NULL, NULL);

g_return_val_if_fail(components != NULL, NULL);

chat = g_new0(PurpleChat, 1);

chat->account = account;

if ((alias != NULL) && (*alias != '\0'))

chat->alias = purple_utf8_strip_unprintables(alias);

chat->components = components;

purple_blist_node_initialize_settings((PurpleBlistNode *)chat);

((PurpleBlistNode *)chat)->type = PURPLE_BLIST_CHAT_NODE;

if (ops != NULL && ops->new_node != NULL)

ops->new_node((PurpleBlistNode *)chat);

PURPLE_DBUS_REGISTER_POINTER(chat, PurpleChat);

return chat;

}

void

purple_chat_destroy(PurpleChat *chat)

{

g_hash_table_destroy(chat->components);

g_hash_table_destroy(chat->node.settings);

g_free(chat->alias);

PURPLE_DBUS_UNREGISTER_POINTER(chat);

g_free(chat);

}

PurpleBuddy *purple_buddy_new(PurpleAccount *account, const char *name, const char *alias)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

PurpleBuddy *buddy;

g_return_val_if_fail(account != NULL, NULL);

g_return_val_if_fail(name != NULL, NULL);

buddy = g_new0(PurpleBuddy, 1);

buddy->account = account;

buddy->name = purple_utf8_strip_unprintables(name);

buddy->alias = purple_utf8_strip_unprintables(alias);

buddy->presence = purple_presence_new_for_buddy(buddy);

((PurpleBlistNode *)buddy)->type = PURPLE_BLIST_BUDDY_NODE;

purple_presence_set_status_active(buddy->presence, "offline", TRUE);

purple_blist_node_initialize_settings((PurpleBlistNode *)buddy);

if (ops && ops->new_node)

ops->new_node((PurpleBlistNode *)buddy);

PURPLE_DBUS_REGISTER_POINTER(buddy, PurpleBuddy);

return buddy;

}

void

purple_buddy_destroy(PurpleBuddy *buddy)

{

PurplePlugin *prpl;

PurplePluginProtocolInfo *prpl_info;

* Tell the owner PRPL that we're about to free the buddy so it

* can free proto_data

prpl = purple_find_prpl(purple_account_get_protocol_id(buddy->account));

if (prpl) {

prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);

if (prpl_info && prpl_info->buddy_free)

prpl_info->buddy_free(buddy);

}

/* Delete the node */

purple_buddy_icon_unref(buddy->icon);

g_hash_table_destroy(buddy->node.settings);

purple_presence_destroy(buddy->presence);

g_free(buddy->name);

g_free(buddy->alias);

g_free(buddy->server_alias);

PURPLE_DBUS_UNREGISTER_POINTER(buddy);

g_free(buddy);

/* FIXME: Once PurpleBuddy is a GObject, timeout callbacks can

* g_object_ref() it when connecting the callback and

* g_object_unref() it in the handler. That way, it won't

* get freed while the timeout is pending and this line can

* be removed. */

while (g_source_remove_by_user_data((gpointer *)buddy));

}

void

purple_buddy_set_icon(PurpleBuddy *buddy, PurpleBuddyIcon *icon)

{

g_return_if_fail(buddy != NULL);

if (buddy->icon != icon)

{

purple_buddy_icon_unref(buddy->icon);

buddy->icon = (icon != NULL ? purple_buddy_icon_ref(icon) : NULL);

}

purple_signal_emit(purple_blist_get_handle(), "buddy-icon-changed", buddy);

purple_blist_update_node_icon((PurpleBlistNode*)buddy);

}

PurpleAccount *

purple_buddy_get_account(const PurpleBuddy *buddy)

{

g_return_val_if_fail(buddy != NULL, NULL);

return buddy->account;

}

const char *

purple_buddy_get_name(const PurpleBuddy *buddy)

{

g_return_val_if_fail(buddy != NULL, NULL);

return buddy->name;

}

PurpleBuddyIcon *

purple_buddy_get_icon(const PurpleBuddy *buddy)

{

g_return_val_if_fail(buddy != NULL, NULL);

return buddy->icon;

}

gpointer

purple_buddy_get_protocol_data(const PurpleBuddy *buddy)

{

g_return_val_if_fail(buddy != NULL, NULL);

return buddy->proto_data;

}

void

purple_buddy_set_protocol_data(PurpleBuddy *buddy, gpointer data)

{

g_return_if_fail(buddy != NULL);

buddy->proto_data = data;

}

void purple_blist_add_chat(PurpleChat *chat, PurpleGroup *group, PurpleBlistNode *node)

{

PurpleBlistNode *cnode = (PurpleBlistNode*)chat;

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

g_return_if_fail(chat != NULL);

g_return_if_fail(PURPLE_BLIST_NODE_IS_CHAT((PurpleBlistNode *)chat));

if (node == NULL) {

if (group == NULL)

group = purple_group_new(_("Chats"));

/* Add group to blist if isn't already on it. Fixes #2752. */

if (!purple_find_group(group->name)) {

purple_blist_add_group(group,

purple_blist_get_last_sibling(purplebuddylist->root));

}

} else {

group = (PurpleGroup*)node->parent;

}

/* if we're moving to overtop of ourselves, do nothing */

if (cnode == node)

return;

if (cnode->parent) {

/* This chat was already in the list and is

* being moved.

((PurpleGroup *)cnode->parent)->totalsize--;

if (purple_account_is_connected(chat->account)) {

((PurpleGroup *)cnode->parent)->online--;

((PurpleGroup *)cnode->parent)->currentsize--;

}

if (cnode->next)

cnode->next->prev = cnode->prev;

if (cnode->prev)

cnode->prev->next = cnode->next;

if (cnode->parent->child == cnode)

cnode->parent->child = cnode->next;

if (ops && ops->remove)

ops->remove(purplebuddylist, cnode);

/* ops->remove() cleaned up the cnode's ui_data, so we need to

* reinitialize it */

if (ops && ops->new_node)

ops->new_node(cnode);

}

if (node != NULL) {

if (node->next)

node->next->prev = cnode;

cnode->next = node->next;

cnode->prev = node;

cnode->parent = node->parent;

node->next = cnode;

((PurpleGroup *)node->parent)->totalsize++;

if (purple_account_is_connected(chat->account)) {

((PurpleGroup *)node->parent)->online++;

((PurpleGroup *)node->parent)->currentsize++;

}

} else {

if (((PurpleBlistNode *)group)->child)

((PurpleBlistNode *)group)->child->prev = cnode;

cnode->next = ((PurpleBlistNode *)group)->child;

cnode->prev = NULL;

((PurpleBlistNode *)group)->child = cnode;

cnode->parent = (PurpleBlistNode *)group;

group->totalsize++;

if (purple_account_is_connected(chat->account)) {

group->online++;

group->currentsize++;

}

if (ops && ops->save_node)

ops->save_node(cnode);

if (ops && ops->update)

ops->update(purplebuddylist, (PurpleBlistNode *)cnode);

purple_signal_emit(purple_blist_get_handle(), "blist-node-added",

cnode);

}

void purple_blist_add_buddy(PurpleBuddy *buddy, PurpleContact *contact, PurpleGroup *group, PurpleBlistNode *node)

{

PurpleBlistNode *cnode, *bnode;

PurpleGroup *g;

PurpleContact *c;

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

struct _purple_hbuddy *hb, *hb2;

GHashTable *account_buddies;

g_return_if_fail(buddy != NULL);

g_return_if_fail(PURPLE_BLIST_NODE_IS_BUDDY((PurpleBlistNode*)buddy));

bnode = (PurpleBlistNode *)buddy;

/* if we're moving to overtop of ourselves, do nothing */

if (bnode == node || (!node && bnode->parent &&

contact && bnode->parent == (PurpleBlistNode*)contact

&& bnode == bnode->parent->child))

return;

if (node && PURPLE_BLIST_NODE_IS_BUDDY(node)) {

c = (PurpleContact*)node->parent;

g = (PurpleGroup*)node->parent->parent;

} else if (contact) {

c = contact;

g = PURPLE_GROUP(PURPLE_BLIST_NODE(c)->parent);

} else {

g = group;

if (g == NULL)

g = purple_group_new(_("Buddies"));

/* Add group to blist if isn't already on it. Fixes #2752. */

if (!purple_find_group(g->name)) {

purple_blist_add_group(g,

purple_blist_get_last_sibling(purplebuddylist->root));

}

c = purple_contact_new();

purple_blist_add_contact(c, g,

purple_blist_get_last_child((PurpleBlistNode*)g));

}

cnode = (PurpleBlistNode *)c;

if (bnode->parent) {

if (PURPLE_BUDDY_IS_ONLINE(buddy)) {

((PurpleContact*)bnode->parent)->online--;

if (((PurpleContact*)bnode->parent)->online == 0)

((PurpleGroup*)bnode->parent->parent)->online--;

}

if (purple_account_is_connected(buddy->account)) {

((PurpleContact*)bnode->parent)->currentsize--;

if (((PurpleContact*)bnode->parent)->currentsize == 0)

((PurpleGroup*)bnode->parent->parent)->currentsize--;

}

((PurpleContact*)bnode->parent)->totalsize--;

/* the group totalsize will be taken care of by remove_contact below */

if (bnode->parent->parent != (PurpleBlistNode*)g) {

purple_signal_emit(purple_blist_get_handle(), "buddy-removed-from-group", buddy);

serv_move_buddy(buddy, (PurpleGroup *)bnode->parent->parent, g);

}

if (bnode->next)

bnode->next->prev = bnode->prev;

if (bnode->prev)

bnode->prev->next = bnode->next;

if (bnode->parent->child == bnode)

bnode->parent->child = bnode->next;

if (ops && ops->remove)

ops->remove(purplebuddylist, bnode);

if (bnode->parent->parent != (PurpleBlistNode*)g) {

struct _purple_hbuddy hb;

hb.name = (gchar *)purple_normalize(buddy->account, buddy->name);

hb.account = buddy->account;

hb.group = bnode->parent->parent;

g_hash_table_remove(purplebuddylist->buddies, &hb);

account_buddies = g_hash_table_lookup(buddies_cache, buddy->account);

g_hash_table_remove(account_buddies, &hb);

}

if (!bnode->parent->child) {

purple_blist_remove_contact((PurpleContact*)bnode->parent);

} else {

purple_contact_invalidate_priority_buddy((PurpleContact*)bnode->parent);

if (ops && ops->update)

ops->update(purplebuddylist, bnode->parent);

}

if (node && PURPLE_BLIST_NODE_IS_BUDDY(node)) {

if (node->next)

node->next->prev = bnode;

bnode->next = node->next;

bnode->prev = node;

bnode->parent = node->parent;

node->next = bnode;

} else {

if (cnode->child)

cnode->child->prev = bnode;

bnode->prev = NULL;

bnode->next = cnode->child;

cnode->child = bnode;

bnode->parent = cnode;

}

if (PURPLE_BUDDY_IS_ONLINE(buddy)) {

if (++(PURPLE_CONTACT(bnode->parent)->online) == 1)

PURPLE_GROUP(bnode->parent->parent)->online++;

}

if (purple_account_is_connected(buddy->account)) {

if (++(PURPLE_CONTACT(bnode->parent)->currentsize) == 1)

PURPLE_GROUP(bnode->parent->parent)->currentsize++;

}

PURPLE_CONTACT(bnode->parent)->totalsize++;

hb = g_new(struct _purple_hbuddy, 1);

hb->name = g_strdup(purple_normalize(buddy->account, buddy->name));

hb->account = buddy->account;

hb->group = ((PurpleBlistNode*)buddy)->parent->parent;

g_hash_table_replace(purplebuddylist->buddies, hb, buddy);

account_buddies = g_hash_table_lookup(buddies_cache, buddy->account);

hb2 = g_new(struct _purple_hbuddy, 1);

hb2->name = g_strdup(hb->name);

hb2->account = buddy->account;

hb2->group = ((PurpleBlistNode*)buddy)->parent->parent;

g_hash_table_replace(account_buddies, hb2, buddy);

purple_contact_invalidate_priority_buddy(purple_buddy_get_contact(buddy));

if (ops && ops->save_node)

ops->save_node((PurpleBlistNode*) buddy);

if (ops && ops->update)

ops->update(purplebuddylist, (PurpleBlistNode*)buddy);

/* Signal that the buddy has been added */

purple_signal_emit(purple_blist_get_handle(), "buddy-added", buddy);

purple_signal_emit(purple_blist_get_handle(), "blist-node-added",

PURPLE_BLIST_NODE(buddy));

}

PurpleContact *purple_contact_new()

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

PurpleContact *contact = g_new0(PurpleContact, 1);

contact->totalsize = 0;

contact->currentsize = 0;

contact->online = 0;

purple_blist_node_initialize_settings((PurpleBlistNode *)contact);

((PurpleBlistNode *)contact)->type = PURPLE_BLIST_CONTACT_NODE;

if (ops && ops->new_node)

ops->new_node((PurpleBlistNode *)contact);

PURPLE_DBUS_REGISTER_POINTER(contact, PurpleContact);

return contact;

}

void

purple_contact_destroy(PurpleContact *contact)

{

g_hash_table_destroy(contact->node.settings);

g_free(contact->alias);

PURPLE_DBUS_UNREGISTER_POINTER(contact);

g_free(contact);

}

PurpleGroup *

purple_contact_get_group(const PurpleContact *contact)

{

g_return_val_if_fail(contact, NULL);

return (PurpleGroup *)(((PurpleBlistNode *)contact)->parent);

}

void purple_contact_set_alias(PurpleContact *contact, const char *alias)

{

purple_blist_alias_contact(contact,alias);

}

const char *purple_contact_get_alias(PurpleContact* contact)

{

g_return_val_if_fail(contact != NULL, NULL);

if (contact->alias)

return contact->alias;

return purple_buddy_get_alias(purple_contact_get_priority_buddy(contact));

}

gboolean purple_contact_on_account(PurpleContact *c, PurpleAccount *account)

{

PurpleBlistNode *bnode, *cnode = (PurpleBlistNode *) c;

g_return_val_if_fail(c != NULL, FALSE);

g_return_val_if_fail(account != NULL, FALSE);

for (bnode = cnode->child; bnode; bnode = bnode->next) {

PurpleBuddy *buddy;

if (! PURPLE_BLIST_NODE_IS_BUDDY(bnode))

continue;

buddy = (PurpleBuddy *)bnode;

if (buddy->account == account)

return TRUE;

}

return FALSE;

}

void purple_contact_invalidate_priority_buddy(PurpleContact *contact)

{

g_return_if_fail(contact != NULL);

contact->priority_valid = FALSE;

}

PurpleGroup *purple_group_new(const char *name)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

PurpleGroup *group;

g_return_val_if_fail(name != NULL, NULL);

g_return_val_if_fail(*name != '\0', NULL);

group = purple_find_group(name);

if (group != NULL)

return group;

group = g_new0(PurpleGroup, 1);

group->name = purple_utf8_strip_unprintables(name);

group->totalsize = 0;

group->currentsize = 0;

group->online = 0;

purple_blist_node_initialize_settings((PurpleBlistNode *)group);

((PurpleBlistNode *)group)->type = PURPLE_BLIST_GROUP_NODE;

if (ops && ops->new_node)

ops->new_node((PurpleBlistNode *)group);

PURPLE_DBUS_REGISTER_POINTER(group, PurpleGroup);

return group;

}

void

purple_group_destroy(PurpleGroup *group)

{

g_hash_table_destroy(group->node.settings);

g_free(group->name);

PURPLE_DBUS_UNREGISTER_POINTER(group);

g_free(group);

}

void purple_blist_add_contact(PurpleContact *contact, PurpleGroup *group, PurpleBlistNode *node)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

PurpleGroup *g;

PurpleBlistNode *gnode, *cnode, *bnode;

g_return_if_fail(contact != NULL);

g_return_if_fail(PURPLE_BLIST_NODE_IS_CONTACT((PurpleBlistNode*)contact));

if (PURPLE_BLIST_NODE(contact) == node)

return;

if (node && (PURPLE_BLIST_NODE_IS_CONTACT(node) ||

PURPLE_BLIST_NODE_IS_CHAT(node)))

g = (PurpleGroup*)node->parent;

else if (group)

g = group;

else {

g = purple_find_group(_("Buddies"));

if (g == NULL) {

g = purple_group_new(_("Buddies"));

purple_blist_add_group(g,

purple_blist_get_last_sibling(purplebuddylist->root));

}

gnode = (PurpleBlistNode*)g;

cnode = (PurpleBlistNode*)contact;

if (cnode->parent) {

if (cnode->parent->child == cnode)

cnode->parent->child = cnode->next;

if (cnode->prev)

cnode->prev->next = cnode->next;

if (cnode->next)

cnode->next->prev = cnode->prev;

if (cnode->parent != gnode) {

bnode = cnode->child;

while (bnode) {

PurpleBlistNode *next_bnode = bnode->next;

PurpleBuddy *b = (PurpleBuddy*)bnode;

GHashTable *account_buddies;

struct _purple_hbuddy *hb, *hb2;

hb = g_new(struct _purple_hbuddy, 1);

hb->name = g_strdup(purple_normalize(b->account, b->name));

hb->account = b->account;

hb->group = cnode->parent;

g_hash_table_remove(purplebuddylist->buddies, hb);

account_buddies = g_hash_table_lookup(buddies_cache, b->account);

g_hash_table_remove(account_buddies, hb);

if (!purple_find_buddy_in_group(b->account, b->name, g)) {

hb->group = gnode;

g_hash_table_replace(purplebuddylist->buddies, hb, b);

hb2 = g_new(struct _purple_hbuddy, 1);

hb2->name = g_strdup(hb->name);

hb2->account = b->account;

hb2->group = gnode;

g_hash_table_replace(account_buddies, hb2, b);

if (purple_account_get_connection(b->account))

serv_move_buddy(b, (PurpleGroup *)cnode->parent, g);

} else {

gboolean empty_contact = FALSE;

/* this buddy already exists in the group, so we're

* gonna delete it instead */

g_free(hb->name);

g_free(hb);

if (purple_account_get_connection(b->account))

purple_account_remove_buddy(b->account, b, (PurpleGroup *)cnode->parent);

if (!cnode->child->next)

empty_contact = TRUE;

purple_blist_remove_buddy(b);

/** in purple_blist_remove_buddy(), if the last buddy in a

* contact is removed, the contact is cleaned up and

* g_free'd, so we mustn't try to reference bnode->next */

if (empty_contact)

return;

}

bnode = next_bnode;

}

if (contact->online > 0)

((PurpleGroup*)cnode->parent)->online--;

if (contact->currentsize > 0)

((PurpleGroup*)cnode->parent)->currentsize--;

((PurpleGroup*)cnode->parent)->totalsize--;

if (ops && ops->remove)

ops->remove(purplebuddylist, cnode);

if (ops && ops->remove_node)

ops->remove_node(cnode);

}

if (node && (PURPLE_BLIST_NODE_IS_CONTACT(node) ||

PURPLE_BLIST_NODE_IS_CHAT(node))) {

if (node->next)

node->next->prev = cnode;

cnode->next = node->next;

cnode->prev = node;

cnode->parent = node->parent;

node->next = cnode;

} else {

if (gnode->child)

gnode->child->prev = cnode;

cnode->prev = NULL;

cnode->next = gnode->child;

gnode->child = cnode;

cnode->parent = gnode;

}

if (contact->online > 0)

g->online++;

if (contact->currentsize > 0)

g->currentsize++;

g->totalsize++;

if (ops && ops->save_node)

{

if (cnode->child)

ops->save_node(cnode);

for (bnode = cnode->child; bnode; bnode = bnode->next)

ops->save_node(bnode);

}

if (ops && ops->update)

{

if (cnode->child)

ops->update(purplebuddylist, cnode);

for (bnode = cnode->child; bnode; bnode = bnode->next)

ops->update(purplebuddylist, bnode);

}

void purple_blist_merge_contact(PurpleContact *source, PurpleBlistNode *node)

{

PurpleBlistNode *sourcenode = (PurpleBlistNode*)source;

PurpleBlistNode *prev, *cur, *next;

PurpleContact *target;

g_return_if_fail(source != NULL);

g_return_if_fail(node != NULL);

if (PURPLE_BLIST_NODE_IS_CONTACT(node)) {

target = (PurpleContact *)node;

prev = purple_blist_get_last_child(node);

} else if (PURPLE_BLIST_NODE_IS_BUDDY(node)) {

target = (PurpleContact *)node->parent;

prev = node;

} else {

return;

}

if (source == target || !target)

return;

next = sourcenode->child;

while (next) {

cur = next;

next = cur->next;

if (PURPLE_BLIST_NODE_IS_BUDDY(cur)) {

purple_blist_add_buddy((PurpleBuddy *)cur, target, NULL, prev);

prev = cur;

}

void purple_blist_add_group(PurpleGroup *group, PurpleBlistNode *node)

{

PurpleBlistUiOps *ops;

PurpleBlistNode *gnode = (PurpleBlistNode*)group;

gchar* key;

g_return_if_fail(group != NULL);

g_return_if_fail(PURPLE_BLIST_NODE_IS_GROUP((PurpleBlistNode *)group));

ops = purple_blist_get_ui_ops();

/* if we're moving to overtop of ourselves, do nothing */

if (gnode == node) {

if (!purplebuddylist->root)

node = NULL;

else

return;

}

if (purple_find_group(group->name)) {

/* This is just being moved */

if (ops && ops->remove)

ops->remove(purplebuddylist, (PurpleBlistNode *)group);

if (gnode == purplebuddylist->root)

purplebuddylist->root = gnode->next;

if (gnode->prev)

gnode->prev->next = gnode->next;

if (gnode->next)

gnode->next->prev = gnode->prev;

} else {

key = g_utf8_collate_key(group->name, -1);

g_hash_table_insert(groups_cache, key, group);

}

if (node && PURPLE_BLIST_NODE_IS_GROUP(node)) {

gnode->next = node->next;

gnode->prev = node;

if (node->next)

node->next->prev = gnode;

node->next = gnode;

} else {

if (purplebuddylist->root)

purplebuddylist->root->prev = gnode;

gnode->next = purplebuddylist->root;

gnode->prev = NULL;

purplebuddylist->root = gnode;

}

if (ops && ops->save_node) {

ops->save_node(gnode);

for (node = gnode->child; node; node = node->next)

ops->save_node(node);

}

if (ops && ops->update) {

ops->update(purplebuddylist, gnode);

for (node = gnode->child; node; node = node->next)

ops->update(purplebuddylist, node);

}

purple_signal_emit(purple_blist_get_handle(), "blist-node-added",

gnode);

}

void purple_blist_remove_contact(PurpleContact *contact)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

PurpleBlistNode *node, *gnode;

g_return_if_fail(contact != NULL);

node = (PurpleBlistNode *)contact;

gnode = node->parent;

if (node->child) {

* If this contact has children then remove them. When the last

* buddy is removed from the contact, the contact is automatically

* deleted.

while (node->child->next) {

purple_blist_remove_buddy((PurpleBuddy*)node->child);

}

* Remove the last buddy and trigger the deletion of the contact.

* It would probably be cleaner if contact-deletion was done after

* a timeout? Or if it had to be done manually, like below?

purple_blist_remove_buddy((PurpleBuddy*)node->child);

} else {

/* Remove the node from its parent */

if (gnode->child == node)

gnode->child = node->next;

if (node->prev)

node->prev->next = node->next;

if (node->next)

node->next->prev = node->prev;

/* Update the UI */

if (ops && ops->remove)

ops->remove(purplebuddylist, node);

if (ops && ops->remove_node)

ops->remove_node(node);

purple_signal_emit(purple_blist_get_handle(), "blist-node-removed",

PURPLE_BLIST_NODE(contact));

/* Delete the node */

purple_contact_destroy(contact);

}

void purple_blist_remove_buddy(PurpleBuddy *buddy)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

PurpleBlistNode *node, *cnode, *gnode;

PurpleContact *contact;

PurpleGroup *group;

struct _purple_hbuddy hb;

GHashTable *account_buddies;

g_return_if_fail(buddy != NULL);

node = (PurpleBlistNode *)buddy;

cnode = node->parent;

gnode = (cnode != NULL) ? cnode->parent : NULL;

contact = (PurpleContact *)cnode;

group = (PurpleGroup *)gnode;

/* Remove the node from its parent */

if (node->prev)

node->prev->next = node->next;

if (node->next)

node->next->prev = node->prev;

if ((cnode != NULL) && (cnode->child == node))

cnode->child = node->next;

/* Adjust size counts */

if (contact != NULL) {

if (PURPLE_BUDDY_IS_ONLINE(buddy)) {

contact->online--;

if (contact->online == 0)

group->online--;

}

if (purple_account_is_connected(buddy->account)) {

contact->currentsize--;

if (contact->currentsize == 0)

group->currentsize--;

}

contact->totalsize--;

/* Re-sort the contact */

if (cnode->child && contact->priority == buddy) {

purple_contact_invalidate_priority_buddy(contact);

if (ops && ops->update)

ops->update(purplebuddylist, cnode);

}

/* Remove this buddy from the buddies hash table */

hb.name = (gchar *)purple_normalize(buddy->account, buddy->name);

hb.account = buddy->account;

hb.group = gnode;

g_hash_table_remove(purplebuddylist->buddies, &hb);

account_buddies = g_hash_table_lookup(buddies_cache, buddy->account);

g_hash_table_remove(account_buddies, &hb);

/* Update the UI */

if (ops && ops->remove)

ops->remove(purplebuddylist, node);

if (ops && ops->remove_node)

ops->remove_node(node);

/* Remove this buddy's pounces */

purple_pounce_destroy_all_by_buddy(buddy);

/* Signal that the buddy has been removed before freeing the memory for it */

purple_signal_emit(purple_blist_get_handle(), "buddy-removed", buddy);

purple_signal_emit(purple_blist_get_handle(), "blist-node-removed",

PURPLE_BLIST_NODE(buddy));

purple_buddy_destroy(buddy);

/* If the contact is empty then remove it */

if ((contact != NULL) && !cnode->child)

purple_blist_remove_contact(contact);

}

void purple_blist_remove_chat(PurpleChat *chat)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

PurpleBlistNode *node, *gnode;

PurpleGroup *group;

g_return_if_fail(chat != NULL);

node = (PurpleBlistNode *)chat;

gnode = node->parent;

group = (PurpleGroup *)gnode;

if (gnode != NULL)

{

/* Remove the node from its parent */

if (gnode->child == node)

gnode->child = node->next;

if (node->prev)

node->prev->next = node->next;

if (node->next)

node->next->prev = node->prev;

/* Adjust size counts */

if (purple_account_is_connected(chat->account)) {

group->online--;

group->currentsize--;

}

group->totalsize--;

}

/* Update the UI */

if (ops && ops->remove)

ops->remove(purplebuddylist, node);

if (ops && ops->remove_node)

ops->remove_node(node);

purple_signal_emit(purple_blist_get_handle(), "blist-node-removed",

PURPLE_BLIST_NODE(chat));

/* Delete the node */

purple_chat_destroy(chat);

}

void purple_blist_remove_group(PurpleGroup *group)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

PurpleBlistNode *node;

GList *l;

gchar* key;

g_return_if_fail(group != NULL);

node = (PurpleBlistNode *)group;

/* Make sure the group is empty */

if (node->child)

return;

/* Remove the node from its parent */

if (purplebuddylist->root == node)

purplebuddylist->root = node->next;

if (node->prev)

node->prev->next = node->next;

if (node->next)

node->next->prev = node->prev;

key = g_utf8_collate_key(group->name, -1);

g_hash_table_remove(groups_cache, key);

g_free(key);

/* Update the UI */

if (ops && ops->remove)

ops->remove(purplebuddylist, node);

if (ops && ops->remove_node)

ops->remove_node(node);

purple_signal_emit(purple_blist_get_handle(), "blist-node-removed",

PURPLE_BLIST_NODE(group));

/* Remove the group from all accounts that are online */

for (l = purple_connections_get_all(); l != NULL; l = l->next)

{

PurpleConnection *gc = (PurpleConnection *)l->data;

if (purple_connection_get_state(gc) == PURPLE_CONNECTED)

purple_account_remove_group(purple_connection_get_account(gc), group);

}

/* Delete the node */

purple_group_destroy(group);

}

PurpleBuddy *purple_contact_get_priority_buddy(PurpleContact *contact)

{

g_return_val_if_fail(contact != NULL, NULL);

if (!contact->priority_valid)

purple_contact_compute_priority_buddy(contact);

return contact->priority;

}

const char *purple_buddy_get_alias_only(PurpleBuddy *buddy)

{

g_return_val_if_fail(buddy != NULL, NULL);

if ((buddy->alias != NULL) && (*buddy->alias != '\0')) {

return buddy->alias;

} else if ((buddy->server_alias != NULL) &&

(*buddy->server_alias != '\0')) {

return buddy->server_alias;

}

return NULL;

}

const char *purple_buddy_get_contact_alias(PurpleBuddy *buddy)

{

PurpleContact *c;

g_return_val_if_fail(buddy != NULL, NULL);

/* Search for an alias for the buddy. In order of precedence: */

/* The buddy alias */

if (buddy->alias != NULL)

return buddy->alias;

/* The contact alias */

c = purple_buddy_get_contact(buddy);

if ((c != NULL) && (c->alias != NULL))

return c->alias;

/* The server alias */

if ((buddy->server_alias) && (*buddy->server_alias))

return buddy->server_alias;

/* The buddy's user name (i.e. no alias) */

return buddy->name;

}

const char *purple_buddy_get_alias(PurpleBuddy *buddy)

{

g_return_val_if_fail(buddy != NULL, NULL);

/* Search for an alias for the buddy. In order of precedence: */

/* The buddy alias */

if (buddy->alias != NULL)

return buddy->alias;

/* The server alias */

if ((buddy->server_alias) && (*buddy->server_alias))

return buddy->server_alias;

/* The buddy's user name (i.e. no alias) */

return buddy->name;

}

const char *purple_buddy_get_local_buddy_alias(PurpleBuddy *buddy)

{

g_return_val_if_fail(buddy, NULL);

return buddy->alias;

}

const char *purple_buddy_get_server_alias(PurpleBuddy *buddy)

{

g_return_val_if_fail(buddy != NULL, NULL);

if ((buddy->server_alias) && (*buddy->server_alias))

return buddy->server_alias;

return NULL;

}

const char *purple_buddy_get_local_alias(PurpleBuddy *buddy)

{

PurpleContact *c;

g_return_val_if_fail(buddy != NULL, NULL);

/* Search for an alias for the buddy. In order of precedence: */

/* The buddy alias */

if (buddy->alias != NULL)

return buddy->alias;

/* The contact alias */

c = purple_buddy_get_contact(buddy);

if ((c != NULL) && (c->alias != NULL))

return c->alias;

/* The buddy's user name (i.e. no alias) */

return buddy->name;

}

const char *purple_chat_get_name(PurpleChat *chat)

{

char *ret = NULL;

PurplePlugin *prpl;

PurplePluginProtocolInfo *prpl_info = NULL;

g_return_val_if_fail(chat != NULL, NULL);

if ((chat->alias != NULL) && (*chat->alias != '\0'))

return chat->alias;

prpl = purple_find_prpl(purple_account_get_protocol_id(chat->account));

prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);

if (prpl_info->chat_info) {

struct proto_chat_entry *pce;

GList *parts = prpl_info->chat_info(purple_account_get_connection(chat->account));

pce = parts->data;

ret = g_hash_table_lookup(chat->components, pce->identifier);

g_list_free_full(parts, (GDestroyNotify)g_free);

}

return ret;

}

PurpleBuddy *purple_find_buddy(PurpleAccount *account, const char *name)

{

PurpleBuddy *buddy, *fallback_buddy = NULL;

struct _purple_hbuddy hb;

PurpleBlistNode *group;

g_return_val_if_fail(purplebuddylist != NULL, NULL);

g_return_val_if_fail(account != NULL, NULL);

g_return_val_if_fail((name != NULL) && (*name != '\0'), NULL);

hb.account = account;

hb.name = (gchar *)purple_normalize(account, name);

for (group = purplebuddylist->root; group; group = group->next) {

if (!group->child)

continue;

hb.group = group;

if ((buddy = g_hash_table_lookup(purplebuddylist->buddies, &hb))) {

if (PURPLE_BLIST_NODE_IS_VISIBLE(buddy))

return buddy;

/* Only return invisible buddies if there are no visible ones */

fallback_buddy = buddy;

}

return fallback_buddy;

}

PurpleBuddy *purple_find_buddy_in_group(PurpleAccount *account, const char *name,

PurpleGroup *group)

{

struct _purple_hbuddy hb;

g_return_val_if_fail(purplebuddylist != NULL, NULL);

g_return_val_if_fail(account != NULL, NULL);

g_return_val_if_fail((name != NULL) && (*name != '\0'), NULL);

hb.name = (gchar *)purple_normalize(account, name);

hb.account = account;

hb.group = (PurpleBlistNode*)group;

return g_hash_table_lookup(purplebuddylist->buddies, &hb);

}

static void find_acct_buddies(gpointer key, gpointer value, gpointer data)

{

PurpleBuddy *buddy = value;

GSList **list = data;

*list = g_slist_prepend(*list, buddy);

}

GSList *purple_find_buddies(PurpleAccount *account, const char *name)

{

PurpleBuddy *buddy;

PurpleBlistNode *node;

GSList *ret = NULL;

g_return_val_if_fail(purplebuddylist != NULL, NULL);

g_return_val_if_fail(account != NULL, NULL);

if ((name != NULL) && (*name != '\0')) {

struct _purple_hbuddy hb;

hb.name = (gchar *)purple_normalize(account, name);

hb.account = account;

for (node = purplebuddylist->root; node != NULL; node = node->next) {

if (!node->child)

continue;

hb.group = node;

if ((buddy = g_hash_table_lookup(purplebuddylist->buddies, &hb)) != NULL)

ret = g_slist_prepend(ret, buddy);

}

} else {

GSList *list = NULL;

GHashTable *buddies = g_hash_table_lookup(buddies_cache, account);

g_hash_table_foreach(buddies, find_acct_buddies, &list);

ret = list;

}

return ret;

}

PurpleGroup *purple_find_group(const char *name)

{

gchar* key;

PurpleGroup *group;

g_return_val_if_fail(purplebuddylist != NULL, NULL);

g_return_val_if_fail((name != NULL) && (*name != '\0'), NULL);

key = g_utf8_collate_key(name, -1);

group = g_hash_table_lookup(groups_cache, key);

g_free(key);

return group;

}

PurpleChat *

purple_blist_find_chat(PurpleAccount *account, const char *name)

{

char *chat_name;

PurpleChat *chat;

PurplePlugin *prpl;

PurplePluginProtocolInfo *prpl_info = NULL;

struct proto_chat_entry *pce;

PurpleBlistNode *node, *group;

GList *parts;

char *normname;

g_return_val_if_fail(purplebuddylist != NULL, NULL);

g_return_val_if_fail((name != NULL) && (*name != '\0'), NULL);

if (!purple_account_is_connected(account))

return NULL;

prpl = purple_find_prpl(purple_account_get_protocol_id(account));

prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);

if (prpl_info->find_blist_chat != NULL)

return prpl_info->find_blist_chat(account, name);

normname = g_strdup(purple_normalize(account, name));

for (group = purplebuddylist->root; group != NULL; group = group->next) {

for (node = group->child; node != NULL; node = node->next) {

if (PURPLE_BLIST_NODE_IS_CHAT(node)) {

chat = (PurpleChat*)node;

if (account != chat->account)

continue;

parts = prpl_info->chat_info(

purple_account_get_connection(chat->account));

pce = parts->data;

chat_name = g_hash_table_lookup(chat->components,

pce->identifier);

g_list_free_full(parts, (GDestroyNotify)g_free);

if (chat->account == account && chat_name != NULL &&

purple_strequal(purple_normalize(account, chat_name), normname)) {

g_free(normname);

return chat;

}

g_free(normname);

return NULL;

}

PurpleGroup *

purple_chat_get_group(PurpleChat *chat)

{

g_return_val_if_fail(chat != NULL, NULL);

return (PurpleGroup *)(((PurpleBlistNode *)chat)->parent);

}

PurpleAccount *

purple_chat_get_account(PurpleChat *chat)

{

g_return_val_if_fail(chat != NULL, NULL);

return chat->account;

}

GHashTable *

purple_chat_get_components(PurpleChat *chat)

{

g_return_val_if_fail(chat != NULL, NULL);

return chat->components;

}

PurpleContact *purple_buddy_get_contact(PurpleBuddy *buddy)

{

g_return_val_if_fail(buddy != NULL, NULL);

return PURPLE_CONTACT(PURPLE_BLIST_NODE(buddy)->parent);

}

PurplePresence *purple_buddy_get_presence(const PurpleBuddy *buddy)

{

g_return_val_if_fail(buddy != NULL, NULL);

return buddy->presence;

}

PurpleMediaCaps purple_buddy_get_media_caps(const PurpleBuddy *buddy)

{

g_return_val_if_fail(buddy != NULL, 0);

return buddy->media_caps;

}

void purple_buddy_set_media_caps(PurpleBuddy *buddy, PurpleMediaCaps media_caps)

{

g_return_if_fail(buddy != NULL);

buddy->media_caps = media_caps;

}

PurpleGroup *purple_buddy_get_group(PurpleBuddy *buddy)

{

g_return_val_if_fail(buddy != NULL, NULL);

if (((PurpleBlistNode *)buddy)->parent == NULL)

return NULL;

return (PurpleGroup *)(((PurpleBlistNode*)buddy)->parent->parent);

}

GSList *purple_group_get_accounts(PurpleGroup *group)

{

GSList *l = NULL;

PurpleBlistNode *gnode, *cnode, *bnode;

gnode = (PurpleBlistNode *)group;

for (cnode = gnode->child; cnode; cnode = cnode->next) {

if (PURPLE_BLIST_NODE_IS_CHAT(cnode)) {

if (!g_slist_find(l, ((PurpleChat *)cnode)->account))

l = g_slist_append(l, ((PurpleChat *)cnode)->account);

} else if (PURPLE_BLIST_NODE_IS_CONTACT(cnode)) {

for (bnode = cnode->child; bnode; bnode = bnode->next) {

if (PURPLE_BLIST_NODE_IS_BUDDY(bnode)) {

if (!g_slist_find(l, ((PurpleBuddy *)bnode)->account))

l = g_slist_append(l, ((PurpleBuddy *)bnode)->account);

}

return l;

}

void purple_blist_add_account(PurpleAccount *account)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

PurpleBlistNode *gnode, *cnode, *bnode;

g_return_if_fail(purplebuddylist != NULL);

if (!ops || !ops->update)

return;

for (gnode = purplebuddylist->root; gnode; gnode = gnode->next) {

if (!PURPLE_BLIST_NODE_IS_GROUP(gnode))

continue;

for (cnode = gnode->child; cnode; cnode = cnode->next) {

if (PURPLE_BLIST_NODE_IS_CONTACT(cnode)) {

gboolean recompute = FALSE;

for (bnode = cnode->child; bnode; bnode = bnode->next) {

if (PURPLE_BLIST_NODE_IS_BUDDY(bnode) &&

((PurpleBuddy*)bnode)->account == account) {

recompute = TRUE;

((PurpleContact*)cnode)->currentsize++;

if (((PurpleContact*)cnode)->currentsize == 1)

((PurpleGroup*)gnode)->currentsize++;

ops->update(purplebuddylist, bnode);

}

if (recompute ||

purple_blist_node_get_bool(cnode, "show_offline")) {

purple_contact_invalidate_priority_buddy((PurpleContact*)cnode);

ops->update(purplebuddylist, cnode);

}

} else if (PURPLE_BLIST_NODE_IS_CHAT(cnode) &&

((PurpleChat*)cnode)->account == account) {

((PurpleGroup *)gnode)->online++;

((PurpleGroup *)gnode)->currentsize++;

ops->update(purplebuddylist, cnode);

}

ops->update(purplebuddylist, gnode);

}

void purple_blist_remove_account(PurpleAccount *account)

{

PurpleBlistUiOps *ops = purple_blist_get_ui_ops();

PurpleBlistNode *gnode, *cnode, *bnode;

PurpleBuddy *buddy;

PurpleChat *chat;

PurpleContact *contact;

PurpleGroup *group;

GList *list = NULL, *iter = NULL;

g_return_if_fail(purplebuddylist != NULL);

for (gnode = purplebuddylist->root; gnode; gnode = gnode->next) {

if (!PURPLE_BLIST_NODE_IS_GROUP(gnode))

continue;

group = (PurpleGroup *)gnode;

for (cnode = gnode->child; cnode; cnode = cnode->next) {

if (PURPLE_BLIST_NODE_IS_CONTACT(cnode)) {

gboolean recompute = FALSE;

contact = (PurpleContact *)cnode;

for (bnode = cnode->child; bnode; bnode = bnode->next) {

if (!PURPLE_BLIST_NODE_IS_BUDDY(bnode))

continue;

buddy = (PurpleBuddy *)bnode;

if (account == buddy->account) {

PurplePresence *presence;

presence = purple_buddy_get_presence(buddy);

if(purple_presence_is_online(presence)) {

contact->online--;

if (contact->online == 0)

group->online--;

purple_blist_node_set_int(&buddy->node,

"last_seen", time(NULL));

}

contact->currentsize--;

if (contact->currentsize == 0)

group->currentsize--;

if (!g_list_find(list, presence))

list = g_list_prepend(list, presence);

if (contact->priority == buddy)

purple_contact_invalidate_priority_buddy(contact);

else

recompute = TRUE;

if (ops && ops->remove) {

ops->remove(purplebuddylist, bnode);

}

if (recompute) {

purple_contact_invalidate_priority_buddy(contact);

if (ops && ops->update)

ops->update(purplebuddylist, cnode);

}

} else if (PURPLE_BLIST_NODE_IS_CHAT(cnode)) {

chat = (PurpleChat *)cnode;

if(chat->account == account) {

group->currentsize--;

group->online--;

if (ops && ops->remove)

ops->remove(purplebuddylist, cnode);

}

for (iter = list; iter; iter = iter->next)

{

purple_presence_set_status_active(iter->data, "offline", TRUE);

}

g_list_free(list);

}

gboolean purple_group_on_account(PurpleGroup *g, PurpleAccount *account)

{

PurpleBlistNode *cnode;

for (cnode = ((PurpleBlistNode *)g)->child; cnode; cnode = cnode->next) {

if (PURPLE_BLIST_NODE_IS_CONTACT(cnode)) {

if(purple_contact_on_account((PurpleContact *) cnode, account))

return TRUE;

} else if (PURPLE_BLIST_NODE_IS_CHAT(cnode)) {

PurpleChat *chat = (PurpleChat *)cnode;

if ((!account && purple_account_is_connected(chat->account))

|| chat->account == account)

return TRUE;

}

return FALSE;

}

const char *purple_group_get_name(PurpleGroup *group)

{

g_return_val_if_fail(group != NULL, NULL);

return group->name;

}

void

purple_blist_request_add_buddy(PurpleAccount *account, const char *username,

const char *group, const char *alias)

{

PurpleBlistUiOps *ui_ops;

ui_ops = purple_blist_get_ui_ops();

if (ui_ops != NULL && ui_ops->request_add_buddy != NULL)

ui_ops->request_add_buddy(account, username, group, alias);

}

void

purple_blist_request_add_chat(PurpleAccount *account, PurpleGroup *group,

const char *alias, const char *name)

{

PurpleBlistUiOps *ui_ops;

ui_ops = purple_blist_get_ui_ops();

if (ui_ops != NULL && ui_ops->request_add_chat != NULL)

ui_ops->request_add_chat(account, group, alias, name);

}

void

purple_blist_request_add_group(void)

{

PurpleBlistUiOps *ui_ops;

ui_ops = purple_blist_get_ui_ops();

if (ui_ops != NULL && ui_ops->request_add_group != NULL)

ui_ops->request_add_group();

}

static void

purple_blist_node_destroy(PurpleBlistNode *node)

{

PurpleBlistUiOps *ui_ops;

PurpleBlistNode *child, *next_child;

ui_ops = purple_blist_get_ui_ops();

child = node->child;

while (child) {

next_child = child->next;

purple_blist_node_destroy(child);

child = next_child;

}

/* Allow the UI to free data */

node->parent = NULL;

node->child = NULL;

node->next = NULL;

node->prev = NULL;

if (ui_ops && ui_ops->remove)

ui_ops->remove(purplebuddylist, node);

if (PURPLE_BLIST_NODE_IS_BUDDY(node))

purple_buddy_destroy((PurpleBuddy*)node);

else if (PURPLE_BLIST_NODE_IS_CHAT(node))

purple_chat_destroy((PurpleChat*)node);

else if (PURPLE_BLIST_NODE_IS_CONTACT(node))

purple_contact_destroy((PurpleContact*)node);

else if (PURPLE_BLIST_NODE_IS_GROUP(node))

purple_group_destroy((PurpleGroup*)node);

}

static void

purple_blist_node_setting_free(gpointer data)

{

PurpleValue *value;

value = (PurpleValue *)data;

purple_value_destroy(value);

}

static void purple_blist_node_initialize_settings(PurpleBlistNode *node)

{

if (node->settings)

return;

node->settings = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,

(GDestroyNotify)purple_blist_node_setting_free);

}

void purple_blist_node_remove_setting(PurpleBlistNode *node, const char *key)

{

PurpleBlistUiOps *ops;

g_return_if_fail(node != NULL);

g_return_if_fail(node->settings != NULL);

g_return_if_fail(key != NULL);

g_hash_table_remove(node->settings, key);

ops = purple_blist_get_ui_ops();

if (ops && ops->save_node)

ops->save_node(node);

}

void

purple_blist_node_set_flags(PurpleBlistNode *node, PurpleBlistNodeFlags flags)

{

g_return_if_fail(node != NULL);

node->flags = flags;

}

PurpleBlistNodeFlags

purple_blist_node_get_flags(PurpleBlistNode *node)

{

g_return_val_if_fail(node != NULL, 0);

return node->flags;

}

PurpleBlistNodeType

purple_blist_node_get_type(PurpleBlistNode *node)

{

g_return_val_if_fail(node != NULL, PURPLE_BLIST_OTHER_NODE);

return node->type;

}

void

purple_blist_node_set_bool(PurpleBlistNode* node, const char *key, gboolean data)

{

PurpleValue *value;

PurpleBlistUiOps *ops;

g_return_if_fail(node != NULL);

g_return_if_fail(node->settings != NULL);

g_return_if_fail(key != NULL);

value = purple_value_new(PURPLE_TYPE_BOOLEAN);

purple_value_set_boolean(value, data);

g_hash_table_replace(node->settings, g_strdup(key), value);

ops = purple_blist_get_ui_ops();

if (ops && ops->save_node)

ops->save_node(node);

}

gboolean

purple_blist_node_get_bool(PurpleBlistNode* node, const char *key)

{

PurpleValue *value;

g_return_val_if_fail(node != NULL, FALSE);

g_return_val_if_fail(node->settings != NULL, FALSE);

g_return_val_if_fail(key != NULL, FALSE);

value = g_hash_table_lookup(node->settings, key);

if (value == NULL)

return FALSE;

g_return_val_if_fail(purple_value_get_type(value) == PURPLE_TYPE_BOOLEAN, FALSE);

return purple_value_get_boolean(value);

}

void

purple_blist_node_set_int(PurpleBlistNode* node, const char *key, int data)

{

PurpleValue *value;

PurpleBlistUiOps *ops;

g_return_if_fail(node != NULL);

g_return_if_fail(node->settings != NULL);

g_return_if_fail(key != NULL);

value = purple_value_new(PURPLE_TYPE_INT);

purple_value_set_int(value, data);

g_hash_table_replace(node->settings, g_strdup(key), value);

ops = purple_blist_get_ui_ops();

if (ops && ops->save_node)

ops->save_node(node);

}

int

purple_blist_node_get_int(PurpleBlistNode* node, const char *key)

{

PurpleValue *value;

g_return_val_if_fail(node != NULL, 0);

g_return_val_if_fail(node->settings != NULL, 0);

g_return_val_if_fail(key != NULL, 0);

value = g_hash_table_lookup(node->settings, key);

if (value == NULL)

return 0;

g_return_val_if_fail(purple_value_get_type(value) == PURPLE_TYPE_INT, 0);

return purple_value_get_int(value);

}

void

purple_blist_node_set_string(PurpleBlistNode* node, const char *key, const char *data)

{

PurpleValue *value;

PurpleBlistUiOps *ops;

g_return_if_fail(node != NULL);

g_return_if_fail(node->settings != NULL);

g_return_if_fail(key != NULL);

value = purple_value_new(PURPLE_TYPE_STRING);

purple_value_set_string(value, data);

g_hash_table_replace(node->settings, g_strdup(key), value);

ops = purple_blist_get_ui_ops();

if (ops && ops->save_node)

ops->save_node(node);

}

const char *

purple_blist_node_get_string(PurpleBlistNode* node, const char *key)

{

PurpleValue *value;

g_return_val_if_fail(node != NULL, NULL);

g_return_val_if_fail(node->settings != NULL, NULL);

g_return_val_if_fail(key != NULL, NULL);

value = g_hash_table_lookup(node->settings, key);

if (value == NULL)

return NULL;

g_return_val_if_fail(purple_value_get_type(value) == PURPLE_TYPE_STRING, NULL);

return purple_value_get_string(value);

}

GList *

purple_blist_node_get_extended_menu(PurpleBlistNode *n)

{

GList *menu = NULL;

g_return_val_if_fail(n != NULL, NULL);

purple_signal_emit(purple_blist_get_handle(),

"blist-node-extended-menu",

n, &menu);

return menu;

}

int purple_blist_get_group_size(PurpleGroup *group, gboolean offline)

{

if (!group)

return 0;

return offline ? group->totalsize : group->currentsize;

}

int purple_blist_get_group_online_count(PurpleGroup *group)

{

if (!group)

return 0;

return group->online;

}

void

purple_blist_set_ui_ops(PurpleBlistUiOps *ops)

{

gboolean overrode = FALSE;

blist_ui_ops = ops;

if (!ops)

return;

if (!ops->save_node) {

ops->save_node = purple_blist_save_node;

overrode = TRUE;

}

if (!ops->remove_node) {

ops->remove_node = purple_blist_save_node;

overrode = TRUE;

}

if (!ops->save_account) {

ops->save_account = purple_blist_save_account;

overrode = TRUE;

}

if (overrode && (ops->save_node != purple_blist_save_node ||

ops->remove_node != purple_blist_save_node ||

ops->save_account != purple_blist_save_account)) {

purple_debug_warning("blist", "Only some of the blist saving UI ops "

"were overridden. This probably is not what you want!\n");

}

PurpleBlistUiOps *

purple_blist_get_ui_ops(void)

{

return blist_ui_ops;

}

void *

purple_blist_get_handle(void)

{

static int handle;

return &handle;

}

void

purple_blist_init(void)

{

void *handle = purple_blist_get_handle();

purple_signal_register(handle, "buddy-status-changed",

purple_marshal_VOID__POINTER_POINTER_POINTER, NULL,

purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_BLIST_BUDDY),

purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_STATUS),

purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_STATUS));

purple_signal_register(handle, "buddy-privacy-changed",

purple_marshal_VOID__POINTER, NULL,

purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_BLIST_BUDDY));

purple_signal_register(handle, "buddy-idle-changed",

purple_marshal_VOID__POINTER_INT_INT, NULL,

purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_BLIST_BUDDY),

purple_value_new(PURPLE_TYPE_INT),

purple_value_new(PURPLE_TYPE_INT));

purple_signal_register(handle, "buddy-signed-on",

purple_marshal_VOID__POINTER, NULL, 1,

purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_BLIST_BUDDY));

purple_signal_register(handle, "buddy-signed-off",

purple_marshal_VOID__POINTER, NULL, 1,

purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_BLIST_BUDDY));

purple_signal_register(handle, "buddy-got-login-time",

purple_marshal_VOID__POINTER, NULL, 1,

purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_BLIST_BUDDY));

purple_signal_register(handle, "blist-node-added",

purple_marshal_VOID__POINTER, NULL, 1,

purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_BLIST_NODE));

purple_signal_register(handle, "blist-node-removed",

purple_marshal_VOID__POINTER, NULL, 1,

purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_BLIST_NODE));

purple_signal_register(handle, "buddy-added",

purple_marshal_VOID__POINTER, NULL, 1,

purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_BLIST_BUDDY));

purple_signal_register(handle, "buddy-removed",

purple_marshal_VOID__POINTER, NULL, 1,

purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_BLIST_BUDDY));

purple_signal_register(handle, "buddy-removed-from-group",

purple_marshal_VOID__POINTER, NULL, 1,

purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_BLIST_BUDDY));

purple_signal_register(handle, "buddy-icon-changed",

purple_marshal_VOID__POINTER, NULL, 1,

purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_BLIST_BUDDY));

purple_signal_register(handle, "update-idle", purple_marshal_VOID, NULL, 0);

purple_signal_register(handle, "blist-node-extended-menu",

purple_marshal_VOID__POINTER_POINTER, NULL, 2,

purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_BLIST_NODE),

purple_value_new(PURPLE_TYPE_BOXED, "GList **"));

purple_signal_register(handle, "blist-node-aliased",

purple_marshal_VOID__POINTER_POINTER, NULL, 2,

purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_BLIST_NODE),

purple_value_new(PURPLE_TYPE_STRING));

purple_signal_register(handle, "buddy-caps-changed",

purple_marshal_VOID__POINTER_INT_INT, NULL,

3, purple_value_new(PURPLE_TYPE_SUBTYPE,

PURPLE_SUBTYPE_BLIST_BUDDY),

purple_value_new(PURPLE_TYPE_INT),

purple_value_new(PURPLE_TYPE_INT));

purple_signal_connect(purple_accounts_get_handle(), "account-created",

handle,

PURPLE_CALLBACK(purple_blist_buddies_cache_add_account),

NULL);

purple_signal_connect(purple_accounts_get_handle(), "account-destroying",

handle,

PURPLE_CALLBACK(purple_blist_buddies_cache_remove_account),

NULL);

}

void

purple_blist_uninit(void)

{

PurpleBlistNode *node, *next_node;

/* This happens if we quit before purple_set_blist is called. */

if (purplebuddylist == NULL)

return;

if (save_timer != 0) {

purple_timeout_remove(save_timer);

save_timer = 0;

purple_blist_sync();

}

purple_blist_destroy();

node = purple_blist_get_root();

while (node) {

next_node = node->next;

purple_blist_node_destroy(node);

node = next_node;

}

purplebuddylist->root = NULL;

g_hash_table_destroy(purplebuddylist->buddies);

g_hash_table_destroy(buddies_cache);

g_hash_table_destroy(groups_cache);

buddies_cache = NULL;

groups_cache = NULL;

PURPLE_DBUS_UNREGISTER_POINTER(purplebuddylist);

g_free(purplebuddylist);

purplebuddylist = NULL;

purple_signals_disconnect_by_handle(purple_blist_get_handle());

purple_signals_unregister_by_instance(purple_blist_get_handle());

}

pidgin/pidgin