HGKeeper

* finch

* Finch 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 "finch.h"

#include NCURSES_HEADER

#include <account.h>

#include <action.h>

#include <buddylist.h>

#include <log.h>

#include <notify.h>

#include <request.h>

#include <plugins.h>

#include <savedstatuses.h>

#include <server.h>

#include <signal.h>

#include <status.h>

#include <util.h>

#include "debug.h"

#include "gntbox.h"

#include "gntcolors.h"

#include "gntcombobox.h"

#include "gntentry.h"

#include "gntxfer.h"

#include "gntlabel.h"

#include "gntline.h"

#include "gntlog.h"

#include "gntmenu.h"

#include "gntmenuitem.h"

#include "gntmenuitemcheck.h"

#include "gntmenuutil.h"

#include "gntpounce.h"

#include "gntstyle.h"

#include "gnttree.h"

#include "gntutils.h"

#include "gntwindow.h"

#include "gntblist.h"

#include "gntconv.h"

#include "gntstatus.h"

#include <string.h>

#define PREF_ROOT "/finch/blist"

#define TYPING_TIMEOUT_S 4

#define SHOW_EMPTY_GROUP_TIMEOUT 60

struct _FinchBuddyList {

PurpleBuddyList parent;

GntWidget *window;

GntWidget *tree;

GntWidget *tooltip;

PurpleBlistNode *tnode; /* Who is the tooltip being displayed for? */

GList *tagged; /* A list of tagged blistnodes */

GntWidget *context;

PurpleBlistNode *cnode;

/* XXX: I am KISSing */

GntWidget *status; /* Dropdown with the statuses */

GntWidget *statustext; /* Status message */

int typing;

GntWidget *menu;

/* These are the menuitems that get regenerated */

GntMenuItem *accounts;

GntMenuItem *plugins;

GntMenuItem *grouping;

/* When a new group is manually added, it is empty, but we still want to show it

* for a while (SHOW_EMPTY_GROUP_TIMEOUT seconds) even if 'show empty groups' is

* not selected.

GList *new_group;

guint new_group_timeout;

FinchBlistManager *manager;

};

typedef struct

{

gpointer row; /* the row in the GntTree */

guint signed_timer; /* used when 'recently' signed on/off */

} FinchBlistNode;

typedef enum

{

STATUS_PRIMITIVE = 0,

STATUS_SAVED_POPULAR,

STATUS_SAVED_ALL,

STATUS_SAVED_NEW

} StatusType;

typedef struct

{

StatusType type;

union

{

PurpleStatusPrimitive prim;

PurpleSavedStatus *saved;

} u;

} StatusBoxItem;

static FinchBuddyList *ggblist;

static void add_buddy(PurpleBuddy *buddy, FinchBuddyList *ggblist);

static void add_contact(PurpleContact *contact, FinchBuddyList *ggblist);

static void add_group(PurpleGroup *group, FinchBuddyList *ggblist);

static void add_chat(PurpleChat *chat, FinchBuddyList *ggblist);

static void add_node(PurpleBlistNode *node, FinchBuddyList *ggblist);

static void node_update(PurpleBuddyList *list, PurpleBlistNode *node);

static void draw_tooltip(FinchBuddyList *ggblist);

static void tooltip_for_buddy(PurpleBuddy *buddy, GString *str, gboolean full);

static gboolean remove_typing_cb(gpointer null);

static void remove_peripherals(FinchBuddyList *ggblist);

static const char * get_display_name(PurpleBlistNode *node);

static void savedstatus_changed(PurpleSavedStatus *now, PurpleSavedStatus *old);

static void blist_show(PurpleBuddyList *list);

static void update_node_display(PurpleBlistNode *buddy,

FinchBuddyList *ggblist);

static void update_buddy_display(PurpleBuddy *buddy, FinchBuddyList *ggblist);

static gboolean account_autojoin_cb(PurpleConnection *pc, gpointer null);

static void finch_request_add_buddy(PurpleBuddyList *list,

PurpleAccount *account,

const char *username, const char *grp,

const char *alias);

static void menu_group_set_cb(GntMenuItem *item, gpointer null);

/* Sort functions */

static int blist_node_compare_position(PurpleBlistNode *n1, PurpleBlistNode *n2);

static int blist_node_compare_text(PurpleBlistNode *n1, PurpleBlistNode *n2);

static int blist_node_compare_status(PurpleBlistNode *n1, PurpleBlistNode *n2);

static int blist_node_compare_log(PurpleBlistNode *n1, PurpleBlistNode *n2);

static int color_available;

static int color_away;

static int color_offline;

static int color_idle;

* Buddy List Manager functions.

static gboolean default_can_add_node(PurpleBlistNode *node)

{

gboolean offline = purple_prefs_get_bool(PREF_ROOT "/showoffline");

if (PURPLE_IS_BUDDY(node)) {

PurpleBuddy *buddy = (PurpleBuddy*)node;

FinchBlistNode *fnode = purple_blist_node_get_ui_data(node);

if (!purple_buddy_get_contact(buddy))

return FALSE; /* When a new buddy is added and show-offline is set */

if (PURPLE_BUDDY_IS_ONLINE(buddy))

return TRUE; /* The buddy is online */

if (!purple_account_is_connected(purple_buddy_get_account(buddy)))

return FALSE; /* The account is disconnected. Do not show */

if (offline)

return TRUE; /* We want to see offline buddies too */

if (fnode && fnode->signed_timer)

return TRUE; /* Show if the buddy just signed off */

if (purple_blist_node_get_bool(node, "show_offline"))

return TRUE;

} else if (PURPLE_IS_CONTACT(node)) {

PurpleBlistNode *nd;

for (nd = purple_blist_node_get_first_child(node);

nd; nd = purple_blist_node_get_sibling_next(nd)) {

if (default_can_add_node(nd))

return TRUE;

}

} else if (PURPLE_IS_CHAT(node)) {

PurpleChat *chat = (PurpleChat*)node;

if (purple_account_is_connected(purple_chat_get_account(chat)))

return TRUE; /* Show whenever the account is online */

} else if (PURPLE_IS_GROUP(node)) {

PurpleBlistNode *nd;

gboolean empty = purple_prefs_get_bool(PREF_ROOT "/emptygroups");

if (empty)

return TRUE; /* If we want to see empty groups, we can show any group */

for (nd = purple_blist_node_get_first_child(node);

nd; nd = purple_blist_node_get_sibling_next(nd)) {

if (default_can_add_node(nd))

return TRUE;

}

if (ggblist && ggblist->new_group && g_list_find(ggblist->new_group, node))

return TRUE;

}

return FALSE;

}

static gpointer default_find_parent(PurpleBlistNode *node)

{

gpointer ret = NULL;

if (PURPLE_IS_BUDDY(node) || PURPLE_IS_CONTACT(node) || PURPLE_IS_CHAT(node))

ret = purple_blist_node_get_parent(node);

if (ret)

add_node(ret, ggblist);

return ret;

}

static gboolean default_create_tooltip(gpointer selected_row, GString **body, char **tool_title)

{

GString *str;

PurpleBlistNode *node = selected_row;

int lastseen = 0;

char *title;

str = g_string_new("");

if (PURPLE_IS_CONTACT(node)) {

PurpleBuddy *pr = purple_contact_get_priority_buddy((PurpleContact*)node);

gboolean offline = !PURPLE_BUDDY_IS_ONLINE(pr);

gboolean showoffline = purple_prefs_get_bool(PREF_ROOT "/showoffline");

const char *name = purple_buddy_get_name(pr);

title = g_strdup(name);

tooltip_for_buddy(pr, str, TRUE);

for (node = purple_blist_node_get_first_child(node); node; node = purple_blist_node_get_sibling_next(node)) {

PurpleBuddy *buddy = (PurpleBuddy*)node;

if (offline) {

int value = purple_blist_node_get_int(node, "last_seen");

if (value > lastseen)

lastseen = value;

}

if (node == (PurpleBlistNode*)pr)

continue;

if (!purple_account_is_connected(purple_buddy_get_account(buddy)))

continue;

if (!showoffline && !PURPLE_BUDDY_IS_ONLINE(buddy))

continue;

str = g_string_append(str, "\n----------\n");

tooltip_for_buddy(buddy, str, FALSE);

}

} else if (PURPLE_IS_BUDDY(node)) {

PurpleBuddy *buddy = (PurpleBuddy *)node;

tooltip_for_buddy(buddy, str, TRUE);

title = g_strdup(purple_buddy_get_name(buddy));

if (!PURPLE_BUDDY_IS_ONLINE((PurpleBuddy*)node))

lastseen = purple_blist_node_get_int(node, "last_seen");

} else if (PURPLE_IS_GROUP(node)) {

PurpleGroup *group = (PurpleGroup *)node;

g_string_append_printf(str, _("Online: %d\nTotal: %d"),

purple_counting_node_get_online_count(PURPLE_COUNTING_NODE(group)),

purple_counting_node_get_current_size(PURPLE_COUNTING_NODE(group)));

title = g_strdup(purple_group_get_name(group));

} else if (PURPLE_IS_CHAT(node)) {

PurpleChat *chat = (PurpleChat *)node;

PurpleAccount *account = purple_chat_get_account(chat);

g_string_append_printf(str, _("Account: %s (%s)"),

purple_account_get_username(account),

purple_account_get_protocol_name(account));

title = g_strdup(purple_chat_get_name(chat));

} else {

g_string_free(str, TRUE);

return FALSE;

}

if (lastseen > 0) {

char *tmp = purple_str_seconds_to_string(time(NULL) - lastseen);

g_string_append_printf(str, _("\nLast Seen: %s ago"), tmp);

g_free(tmp);

}

if (tool_title)

*tool_title = title;

else

g_free(title);

if (body)

*body = str;

else

g_string_free(str, TRUE);

return TRUE;

}

static FinchBlistManager default_manager =

{

"default",

N_("Default"),

NULL,

default_can_add_node,

default_find_parent,

default_create_tooltip,

{NULL, NULL, NULL, NULL}

};

static GList *managers;

static FinchBlistNode *

create_finch_blist_node(PurpleBlistNode *node, gpointer row)

{

FinchBlistNode *fnode = purple_blist_node_get_ui_data(node);

if (!fnode) {

fnode = g_new0(FinchBlistNode, 1);

fnode->signed_timer = 0;

purple_blist_node_set_ui_data(node, fnode);

}

fnode->row = row;

return fnode;

}

static void

reset_blist_node_ui_data(PurpleBlistNode *node)

{

FinchBlistNode *fnode = purple_blist_node_get_ui_data(node);

if (fnode == NULL)

return;

if (fnode->signed_timer)

g_source_remove(fnode->signed_timer);

g_free(fnode);

purple_blist_node_set_ui_data(node, NULL);

}

static int

get_display_color(PurpleBlistNode *node)

{

PurpleBuddy *buddy;

int color = 0;

if (PURPLE_IS_CONTACT(node))

node = PURPLE_BLIST_NODE(purple_contact_get_priority_buddy(PURPLE_CONTACT(node)));

if (!PURPLE_IS_BUDDY(node))

return 0;

buddy = (PurpleBuddy*)node;

if (purple_presence_is_idle(purple_buddy_get_presence(buddy))) {

color = color_idle;

} else if (purple_presence_is_available(purple_buddy_get_presence(buddy))) {

color = color_available;

} else if (purple_presence_is_online(purple_buddy_get_presence(buddy)) &&

!purple_presence_is_available(purple_buddy_get_presence(buddy))) {

color = color_away;

} else if (!purple_presence_is_online(purple_buddy_get_presence(buddy))) {

color = color_offline;

}

return color;

}

static GntTextFormatFlags

get_blist_node_flag(FinchBuddyList *ggblist, PurpleBlistNode *node)

{

GntTextFormatFlags flag = 0;

FinchBlistNode *fnode = purple_blist_node_get_ui_data(node);

if (ggblist->tagged && g_list_find(ggblist->tagged, node))

flag |= GNT_TEXT_FLAG_BOLD;

if (fnode && fnode->signed_timer)

flag |= GNT_TEXT_FLAG_BLINK;

else if (PURPLE_IS_CONTACT(node)) {

node = PURPLE_BLIST_NODE(purple_contact_get_priority_buddy(PURPLE_CONTACT(node)));

fnode = purple_blist_node_get_ui_data(node);

if (fnode && fnode->signed_timer)

flag |= GNT_TEXT_FLAG_BLINK;

}

return flag;

}

static void

blist_update_row_flags(FinchBuddyList *ggblist, PurpleBlistNode *node)

{

gnt_tree_set_row_flags(GNT_TREE(ggblist->tree), node,

get_blist_node_flag(ggblist, node));

gnt_tree_set_row_color(GNT_TREE(ggblist->tree), node, get_display_color(node));

}

static void

new_node(PurpleBuddyList *list, PurpleBlistNode *node)

{

}

static void

add_node(PurpleBlistNode *node, FinchBuddyList *ggblist)

{

if (purple_blist_node_get_ui_data(node))

return;

if (!ggblist->manager->can_add_node(node))

return;

if (PURPLE_IS_BUDDY(node))

add_buddy((PurpleBuddy*)node, ggblist);

else if (PURPLE_IS_CONTACT(node))

add_contact((PurpleContact*)node, ggblist);

else if (PURPLE_IS_GROUP(node))

add_group((PurpleGroup*)node, ggblist);

else if (PURPLE_IS_CHAT(node))

add_chat((PurpleChat *)node, ggblist);

draw_tooltip(ggblist);

}

void finch_blist_manager_add_node(PurpleBlistNode *node)

{

add_node(node, ggblist);

}

static void

remove_tooltip(FinchBuddyList *ggblist)

{

gnt_widget_destroy(ggblist->tooltip);

ggblist->tooltip = NULL;

ggblist->tnode = NULL;

}

static void

node_remove(PurpleBuddyList *list, PurpleBlistNode *node)

{

FinchBuddyList *ggblist = FINCH_BUDDY_LIST(list);

PurpleBlistNode *parent;

if (ggblist == NULL || purple_blist_node_get_ui_data(node) == NULL)

return;

if (PURPLE_IS_GROUP(node) && ggblist->new_group) {

ggblist->new_group = g_list_remove(ggblist->new_group, node);

}

gnt_tree_remove(GNT_TREE(ggblist->tree), node);

reset_blist_node_ui_data(node);

if (ggblist->tagged)

ggblist->tagged = g_list_remove(ggblist->tagged, node);

parent = purple_blist_node_get_parent(node);

for (node = purple_blist_node_get_first_child(node); node;

node = purple_blist_node_get_sibling_next(node))

node_remove(list, node);

if (parent) {

if (!ggblist->manager->can_add_node(parent))

node_remove(list, parent);

else

node_update(list, parent);

}

draw_tooltip(ggblist);

}

static void

node_update(PurpleBuddyList *list, PurpleBlistNode *node)

{

FinchBuddyList *ggblist;

g_return_if_fail(FINCH_IS_BUDDY_LIST(list));

/* It really looks like this should never happen ... but it does.

This will at least emit a warning to the log when it

happens, so maybe someone will figure it out. */

g_return_if_fail(node != NULL);

ggblist = FINCH_BUDDY_LIST(list);

if (ggblist->window == NULL)

return;

if (purple_blist_node_get_ui_data(node)!= NULL) {

gnt_tree_change_text(GNT_TREE(ggblist->tree), node,

0, get_display_name(node));

gnt_tree_sort_row(GNT_TREE(ggblist->tree), node);

blist_update_row_flags(ggblist, node);

if (gnt_tree_get_parent_key(GNT_TREE(ggblist->tree), node) !=

ggblist->manager->find_parent(node))

node_remove(list, node);

}

if (PURPLE_IS_BUDDY(node)) {

PurpleBuddy *buddy = (PurpleBuddy*)node;

add_node((PurpleBlistNode *)buddy, FINCH_BUDDY_LIST(list));

node_update(list, purple_blist_node_get_parent(node));

} else if (PURPLE_IS_CHAT(node)) {

add_node(node, FINCH_BUDDY_LIST(list));

} else if (PURPLE_IS_CONTACT(node)) {

if (purple_blist_node_get_ui_data(node)== NULL) {

/* The core seems to expect the UI to add the buddies. */

for (node = purple_blist_node_get_first_child(node); node; node = purple_blist_node_get_sibling_next(node))

add_node(node, FINCH_BUDDY_LIST(list));

}

} else if (PURPLE_IS_GROUP(node)) {

if (!ggblist->manager->can_add_node(node))

node_remove(list, node);

else

add_node(node, FINCH_BUDDY_LIST(list));

}

if (ggblist->tnode == node) {

draw_tooltip(ggblist);

}

static gboolean

remove_new_empty_group(gpointer data)

{

PurpleBuddyList *list;

FinchBuddyList *ggblist;

list = purple_blist_get_default();

g_return_val_if_fail(list, FALSE);

ggblist = FINCH_BUDDY_LIST(list);

ggblist->new_group_timeout = 0;

while (ggblist->new_group) {

PurpleBlistNode *group = ggblist->new_group->data;

ggblist->new_group = g_list_delete_link(ggblist->new_group, ggblist->new_group);

node_update(list, group);

}

return FALSE;

}

static void

add_buddy_cb(void *data, PurpleRequestFields *allfields)

{

const char *username = purple_request_fields_get_string(allfields, "screenname");

const char *alias = purple_request_fields_get_string(allfields, "alias");

const char *group = purple_request_fields_get_string(allfields, "group");

const char *invite = purple_request_fields_get_string(allfields, "invite");

PurpleAccount *account = purple_request_fields_get_account(allfields, "account");

const char *error = NULL;

PurpleGroup *grp;

PurpleBuddy *buddy;

if (!username)

error = _("You must provide a username for the buddy.");

else if (!group)

error = _("You must provide a group.");

else if (!account)

error = _("You must select an account.");

else if (!purple_account_is_connected(account))

error = _("The selected account is not online.");

if (error)

{

finch_request_add_buddy(purple_blist_get_default(), account,

username, group, alias);

purple_notify_error(NULL, _("Error"), _("Error adding buddy"),

error, purple_request_cpar_from_account(account));

return;

}

grp = purple_blist_find_group(group);

if (!grp)

{

grp = purple_group_new(group);

purple_blist_add_group(grp, NULL);

}

/* XXX: Ask to merge if there's already a buddy with the same alias in the same group (#4553) */

if ((buddy = purple_blist_find_buddy_in_group(account, username, grp)) == NULL)

{

buddy = purple_buddy_new(account, username, alias);

purple_blist_add_buddy(buddy, NULL, grp, NULL);

}

purple_account_add_buddy(account, buddy, invite);

}

static void

finch_request_add_buddy(PurpleBuddyList *list, PurpleAccount *account,

const char *username, const char *grp,

const char *alias)

{

PurpleRequestFields *fields = purple_request_fields_new();

PurpleRequestFieldGroup *group = purple_request_field_group_new(NULL);

PurpleRequestField *field;

purple_request_fields_add_group(fields, group);

field = purple_request_field_string_new("screenname", _("Username"), username, FALSE);

purple_request_field_group_add_field(group, field);

field = purple_request_field_string_new("alias", _("Alias (optional)"), alias, FALSE);

purple_request_field_group_add_field(group, field);

field = purple_request_field_string_new("invite", _("Invite message (optional)"), NULL, FALSE);

purple_request_field_group_add_field(group, field);

field = purple_request_field_string_new("group", _("Add in group"), grp, FALSE);

purple_request_field_group_add_field(group, field);

purple_request_field_set_type_hint(field, "group");

field = purple_request_field_account_new("account", _("Account"), NULL);

purple_request_field_account_set_show_all(field, FALSE);

if (account)

purple_request_field_account_set_value(field, account);

purple_request_field_group_add_field(group, field);

purple_request_fields(NULL, _("Add Buddy"), NULL, _("Please enter buddy information."),

fields,

_("Add"), G_CALLBACK(add_buddy_cb),

_("Cancel"), NULL,

purple_request_cpar_from_account(account),

NULL);

}

static void

join_chat(PurpleChat *chat)

{

PurpleAccount *account = purple_chat_get_account(chat);

const char *name;

PurpleChatConversation *conv;

name = purple_chat_get_name_only(chat);

conv = purple_conversations_find_chat_with_account(name, account);

if (!conv || purple_chat_conversation_has_left(conv)) {

purple_serv_join_chat(purple_account_get_connection(account),

purple_chat_get_components(chat));

} else if (conv) {

purple_conversation_present(PURPLE_CONVERSATION(conv));

}

static void

add_chat_cb(void *data, PurpleRequestFields *allfields)

{

PurpleAccount *account;

const char *alias, *name, *group;

PurpleChat *chat;

PurpleGroup *grp;

GHashTable *hash = NULL;

PurpleConnection *gc;

gboolean autojoin;

PurpleProtocol *protocol;

account = purple_request_fields_get_account(allfields, "account");

name = purple_request_fields_get_string(allfields, "name");

alias = purple_request_fields_get_string(allfields, "alias");

group = purple_request_fields_get_string(allfields, "group");

autojoin = purple_request_fields_get_bool(allfields, "autojoin");

if (!purple_account_is_connected(account) || !name || !*name)

return;

if (!group || !*group)

group = _("Chats");

gc = purple_account_get_connection(account);

protocol = purple_connection_get_protocol(gc);

hash = purple_protocol_chat_iface_info_defaults(protocol, gc, name);

chat = purple_chat_new(account, name, hash);

if (chat != NULL) {

if ((grp = purple_blist_find_group(group)) == NULL) {

grp = purple_group_new(group);

purple_blist_add_group(grp, NULL);

}

purple_blist_add_chat(chat, grp, NULL);

purple_chat_set_alias(chat, alias);

purple_blist_node_set_bool((PurpleBlistNode*)chat, "gnt-autojoin", autojoin);

if (autojoin) {

join_chat(chat);

}

static void

finch_request_add_chat(PurpleBuddyList *list, PurpleAccount *account,

PurpleGroup *grp, const char *alias, const char *name)

{

PurpleRequestFields *fields = purple_request_fields_new();

PurpleRequestFieldGroup *group = purple_request_field_group_new(NULL);

PurpleRequestField *field;

purple_request_fields_add_group(fields, group);

field = purple_request_field_account_new("account", _("Account"), NULL);

purple_request_field_account_set_show_all(field, FALSE);

if (account)

purple_request_field_account_set_value(field, account);

purple_request_field_group_add_field(group, field);

field = purple_request_field_string_new("name", _("Name"), name, FALSE);

purple_request_field_group_add_field(group, field);

field = purple_request_field_string_new("alias", _("Alias"), alias, FALSE);

purple_request_field_group_add_field(group, field);

field = purple_request_field_string_new("group", _("Group"), grp ? purple_group_get_name(grp) : NULL, FALSE);

purple_request_field_group_add_field(group, field);

purple_request_field_set_type_hint(field, "group");

field = purple_request_field_bool_new("autojoin", _("Auto-join"), FALSE);

purple_request_field_group_add_field(group, field);

purple_request_fields(NULL, _("Add Chat"), NULL,

_("You can edit more information from the context menu later."),

fields, _("Add"), G_CALLBACK(add_chat_cb), _("Cancel"), NULL,

NULL, NULL);

}

static void

add_group_cb(FinchBuddyList *ggblist, const char *group)

{

PurpleGroup *grp;

if (!group || !*group) {

purple_notify_error(NULL, _("Error"), _("Error adding group"),

_("You must give a name for the group to add."), NULL);

g_object_unref(ggblist);

return;

}

grp = purple_blist_find_group(group);

if (!grp) {

grp = purple_group_new(group);

purple_blist_add_group(grp, NULL);

}

/* Treat the group as a new group even if it had existed before. This should

* make things easier to add buddies to empty groups (new or old) without having

* to turn on 'show empty groups' setting */

ggblist->new_group = g_list_prepend(ggblist->new_group, grp);

if (ggblist->new_group_timeout)

g_source_remove(ggblist->new_group_timeout);

ggblist->new_group_timeout = g_timeout_add_seconds(SHOW_EMPTY_GROUP_TIMEOUT,

remove_new_empty_group, NULL);

/* Select the group */

if (ggblist->tree) {

FinchBlistNode *fnode = purple_blist_node_get_ui_data((PurpleBlistNode*)grp);

if (!fnode)

add_node((PurpleBlistNode*)grp, ggblist);

gnt_tree_set_selected(GNT_TREE(ggblist->tree), grp);

}

g_object_unref(ggblist);

}

static void

finch_request_add_group(PurpleBuddyList *list)

{

purple_request_input(NULL, _("Add Group"), NULL,

_("Enter the name of the group"), NULL, FALSE,

FALSE, NULL, _("Add"), G_CALLBACK(add_group_cb),

_("Cancel"), G_CALLBACK(g_object_unref), NULL,

g_object_ref(list));

}

static gpointer

finch_blist_get_handle(void)

{

static int handle;

return &handle;

}

static void

add_group(PurpleGroup *group, FinchBuddyList *ggblist)

{

gpointer parent;

PurpleBlistNode *node = (PurpleBlistNode *)group;

if (purple_blist_node_get_ui_data(node))

return;

parent = ggblist->manager->find_parent((PurpleBlistNode*)group);

create_finch_blist_node(node, gnt_tree_add_row_after(GNT_TREE(ggblist->tree), group,

gnt_tree_create_row(GNT_TREE(ggblist->tree), get_display_name(node)),

parent, NULL));

gnt_tree_set_expanded(GNT_TREE(ggblist->tree), node,

!purple_blist_node_get_bool(node, "collapsed"));

}

static const char *

get_display_name(PurpleBlistNode *node)

{

static char text[2096];

char status[8] = " ";

const char *name = NULL;

if (PURPLE_IS_CONTACT(node))

node = PURPLE_BLIST_NODE(purple_contact_get_priority_buddy(PURPLE_CONTACT(node))); /* XXX: this can return NULL?! */

if (node == NULL)

return NULL;

if (PURPLE_IS_BUDDY(node))

{

PurpleBuddy *buddy = (PurpleBuddy *)node;

PurpleStatusPrimitive prim;

PurplePresence *presence;

PurpleStatus *now;

gboolean ascii = gnt_ascii_only();

presence = purple_buddy_get_presence(buddy);

if (purple_presence_is_status_primitive_active(presence, PURPLE_STATUS_MOBILE))

strncpy(status, ascii ? ":" : "☎", sizeof(status) - 1);

else {

now = purple_presence_get_active_status(presence);

prim = purple_status_type_get_primitive(purple_status_get_status_type(now));

switch(prim) {

case PURPLE_STATUS_OFFLINE:

strncpy(status, ascii ? "x" : "⊗", sizeof(status) - 1);

break;

case PURPLE_STATUS_AVAILABLE:

strncpy(status, ascii ? "o" : "◯", sizeof(status) - 1);

break;

default:

strncpy(status, ascii ? "." : "⊖", sizeof(status) - 1);

break;

}

name = purple_buddy_get_alias(buddy);

}

else if (PURPLE_IS_CHAT(node))

{

PurpleChat *chat = (PurpleChat*)node;

name = purple_chat_get_name(chat);

strncpy(status, "~", sizeof(status) - 1);

}

else if (PURPLE_IS_GROUP(node))

return purple_group_get_name((PurpleGroup*)node);

g_snprintf(text, sizeof(text) - 1, "%s %s", status, name);

return text;

}

static void

add_chat(PurpleChat *chat, FinchBuddyList *ggblist)

{

gpointer parent;

PurpleBlistNode *node = (PurpleBlistNode *)chat;

if (purple_blist_node_get_ui_data(node))

return;

if (!purple_account_is_connected(purple_chat_get_account(chat)))

return;

parent = ggblist->manager->find_parent((PurpleBlistNode*)chat);

create_finch_blist_node(node, gnt_tree_add_row_after(GNT_TREE(ggblist->tree), chat,

gnt_tree_create_row(GNT_TREE(ggblist->tree), get_display_name(node)),

parent, NULL));

}

static void

add_contact(PurpleContact *contact, FinchBuddyList *ggblist)

{

gpointer parent;

PurpleBlistNode *node = (PurpleBlistNode*)contact;

const char *name;

if (purple_blist_node_get_ui_data(node))

return;

name = get_display_name(node);

if (name == NULL)

return;

parent = ggblist->manager->find_parent((PurpleBlistNode*)contact);

create_finch_blist_node(node, gnt_tree_add_row_after(GNT_TREE(ggblist->tree), contact,

gnt_tree_create_row(GNT_TREE(ggblist->tree), name),

parent, NULL));

gnt_tree_set_expanded(GNT_TREE(ggblist->tree), contact, FALSE);

}

static void

add_buddy(PurpleBuddy *buddy, FinchBuddyList *ggblist)

{

gpointer parent;

PurpleBlistNode *node = (PurpleBlistNode *)buddy;

PurpleContact *contact;

if (purple_blist_node_get_ui_data(node))

return;

contact = purple_buddy_get_contact(buddy);

parent = ggblist->manager->find_parent((PurpleBlistNode*)buddy);

create_finch_blist_node(node, gnt_tree_add_row_after(GNT_TREE(ggblist->tree), buddy,

gnt_tree_create_row(GNT_TREE(ggblist->tree), get_display_name(node)),

parent, NULL));

blist_update_row_flags(ggblist, (PurpleBlistNode *)buddy);

if (buddy == purple_contact_get_priority_buddy(contact)) {

blist_update_row_flags(ggblist, (PurpleBlistNode *)contact);

}

static void

selection_activate(GntWidget *widget, FinchBuddyList *ggblist)

{

GntTree *tree = GNT_TREE(ggblist->tree);

PurpleBlistNode *node = gnt_tree_get_selection_data(tree);

if (!node)

return;

if (PURPLE_IS_CONTACT(node))

node = PURPLE_BLIST_NODE(purple_contact_get_priority_buddy(PURPLE_CONTACT(node)));

if (PURPLE_IS_BUDDY(node))

{

PurpleBuddy *buddy = (PurpleBuddy *)node;

PurpleIMConversation *im;

im = purple_conversations_find_im_with_account(purple_buddy_get_name(buddy),

purple_buddy_get_account(buddy));

if (!im) {

im = purple_im_conversation_new(purple_buddy_get_account(buddy),

purple_buddy_get_name(buddy));

} else {

FinchConv *ggconv = FINCH_CONV(PURPLE_CONVERSATION(im));

gnt_window_present(ggconv->window);

}

finch_conversation_set_active(PURPLE_CONVERSATION(im));

}

else if (PURPLE_IS_CHAT(node))

{

join_chat((PurpleChat*)node);

}

static void

append_proto_menu(GntMenu *menu, PurpleConnection *gc, PurpleBlistNode *node)

{

GList *list;

PurpleProtocol *protocol = purple_connection_get_protocol(gc);

if (!PURPLE_PROTOCOL_IMPLEMENTS(protocol, CLIENT, blist_node_menu)) {

return;

}

for(list = purple_protocol_client_iface_blist_node_menu(protocol, node); list;

list = g_list_delete_link(list, list))

{

PurpleActionMenu *act = (PurpleActionMenu *) list->data;

if (!act)

continue;

purple_action_menu_set_data(act, node);

finch_append_menu_action(menu, act, node);

}

static void

add_custom_action(GntMenu *menu, const char *label, PurpleCallback callback,

gpointer data)

{

PurpleActionMenu *action = purple_action_menu_new(label, callback, data, NULL);

finch_append_menu_action(menu, action, NULL);

}

static void

chat_components_edit_ok(PurpleChat *chat, PurpleRequestFields *allfields)

{

GList *groups, *fields;

for (groups = purple_request_fields_get_groups(allfields); groups; groups = groups->next) {

fields = purple_request_field_group_get_fields(groups->data);

for (; fields; fields = fields->next) {

PurpleRequestField *field = fields->data;

const char *id;

char *val;

id = purple_request_field_get_id(field);

if (purple_request_field_get_field_type(field) == PURPLE_REQUEST_FIELD_INTEGER)

val = g_strdup_printf("%d", purple_request_field_int_get_value(field));

else

val = g_strdup(purple_request_field_string_get_value(field));

if (!val) {

g_hash_table_remove(purple_chat_get_components(chat), id);

} else {

g_hash_table_replace(purple_chat_get_components(chat), g_strdup(id), val); /* val should not be free'd */

}

static void

chat_components_edit(PurpleBlistNode *selected, PurpleChat *chat)

{

PurpleRequestFields *fields = purple_request_fields_new();

PurpleRequestFieldGroup *group = purple_request_field_group_new(NULL);

PurpleRequestField *field;

GList *parts, *iter;

PurpleProtocolChatEntry *pce;

PurpleConnection *gc;

purple_request_fields_add_group(fields, group);

gc = purple_account_get_connection(purple_chat_get_account(chat));

parts = purple_protocol_chat_iface_info(purple_connection_get_protocol(gc), gc);

for (iter = parts; iter; iter = iter->next) {

pce = iter->data;

if (pce->is_int) {

int val;

const char *str = g_hash_table_lookup(purple_chat_get_components(chat), pce->identifier);

if (!str || sscanf(str, "%d", &val) != 1)

val = pce->min;

field = purple_request_field_int_new(pce->identifier, pce->label, val, INT_MIN, INT_MAX);

} else {

field = purple_request_field_string_new(pce->identifier, pce->label,

g_hash_table_lookup(purple_chat_get_components(chat), pce->identifier), FALSE);

if (pce->secret)

purple_request_field_string_set_masked(field, TRUE);

}

if (pce->required)

purple_request_field_set_required(field, TRUE);

purple_request_field_group_add_field(group, field);

g_free(pce);

}

g_list_free(parts);

purple_request_fields(NULL, _("Edit Chat"), NULL, _("Please Update the necessary fields."),

fields, _("Edit"), G_CALLBACK(chat_components_edit_ok), _("Cancel"), NULL,

NULL, chat);

}

static void

autojoin_toggled(GntMenuItem *item, gpointer data)

{

PurpleActionMenu *action = data;

purple_blist_node_set_bool(purple_action_menu_get_data(action), "gnt-autojoin",

gnt_menuitem_check_get_checked(GNT_MENU_ITEM_CHECK(item)));

}

static void

create_chat_menu(GntMenu *menu, PurpleChat *chat)

{

PurpleActionMenu *action = purple_action_menu_new(_("Auto-join"), NULL, chat, NULL);

GntMenuItem *check = gnt_menuitem_check_new(

purple_action_menu_get_label(action));

gnt_menuitem_check_set_checked(GNT_MENU_ITEM_CHECK(check),

purple_blist_node_get_bool((PurpleBlistNode*)chat, "gnt-autojoin"));

gnt_menu_add_item(menu, check);

gnt_menuitem_set_callback(check, autojoin_toggled, action);

g_signal_connect_swapped(G_OBJECT(menu), "destroy",

G_CALLBACK(purple_action_menu_free), action);

/* Protocol actions */

append_proto_menu(menu,

purple_account_get_connection(purple_chat_get_account(chat)),

(PurpleBlistNode*)chat);

add_custom_action(menu, _("Edit Settings"), (PurpleCallback)chat_components_edit, chat);

}

static void

finch_add_buddy(PurpleBlistNode *selected, PurpleGroup *grp)

{

purple_blist_request_add_buddy(NULL, NULL, grp ? purple_group_get_name(grp) : NULL, NULL);

}

static void

finch_add_group(PurpleBlistNode *selected, PurpleGroup *grp)

{

purple_blist_request_add_group();

}

static void

finch_add_chat(PurpleBlistNode *selected, PurpleGroup *grp)

{

purple_blist_request_add_chat(NULL, grp, NULL, NULL);

}

static void

create_group_menu(GntMenu *menu, PurpleGroup *group)

{

add_custom_action(menu, _("Add Buddy"),

PURPLE_CALLBACK(finch_add_buddy), group);

add_custom_action(menu, _("Add Chat"),

PURPLE_CALLBACK(finch_add_chat), group);

add_custom_action(menu, _("Add Group"),

PURPLE_CALLBACK(finch_add_group), group);

}

gpointer finch_retrieve_user_info(PurpleConnection *conn, const char *name)

{

PurpleNotifyUserInfo *info = purple_notify_user_info_new();

gpointer uihandle;

purple_notify_user_info_add_pair_plaintext(info, _("Information"), _("Retrieving..."));

uihandle = purple_notify_userinfo(conn, name, info, NULL, NULL);

purple_notify_user_info_destroy(info);

purple_serv_get_info(conn, name);

return uihandle;

}

static void

finch_blist_get_buddy_info_cb(PurpleBlistNode *selected, PurpleBuddy *buddy)

{

finch_retrieve_user_info(purple_account_get_connection(purple_buddy_get_account(buddy)), purple_buddy_get_name(buddy));

}

static void

finch_blist_menu_send_file_cb(PurpleBlistNode *selected, PurpleBuddy *buddy)

{

purple_serv_send_file(purple_account_get_connection(purple_buddy_get_account(buddy)), purple_buddy_get_name(buddy), NULL);

}

static void

finch_blist_pounce_node_cb(PurpleBlistNode *selected, PurpleBlistNode *node)

{

PurpleBuddy *b;

if (PURPLE_IS_CONTACT(node))

b = purple_contact_get_priority_buddy((PurpleContact *)node);

else

b = (PurpleBuddy *)node;

finch_pounce_editor_show(purple_buddy_get_account(b), purple_buddy_get_name(b), NULL);

}

static void

toggle_block_buddy(GntMenuItem *item, gpointer buddy)

{

gboolean block = gnt_menuitem_check_get_checked(GNT_MENU_ITEM_CHECK(item));

PurpleAccount *account = purple_buddy_get_account(buddy);

const char *name = purple_buddy_get_name(buddy);

block ? purple_account_privacy_deny(account, name) :

purple_account_privacy_allow(account, name);

}

static void

toggle_show_offline(GntMenuItem *item, gpointer buddy)

{

purple_blist_node_set_bool(buddy, "show_offline",

!purple_blist_node_get_bool(buddy, "show_offline"));

if (!ggblist->manager->can_add_node(buddy))

node_remove(purple_blist_get_default(), buddy);

else

node_update(purple_blist_get_default(), buddy);

}

static void

create_buddy_menu(GntMenu *menu, PurpleBuddy *buddy)

{

PurpleAccount *account;

gboolean permitted;

GntMenuItem *item;

PurpleProtocol *protocol;

PurpleConnection *gc = purple_account_get_connection(purple_buddy_get_account(buddy));

protocol = purple_connection_get_protocol(gc);

if (protocol && PURPLE_PROTOCOL_IMPLEMENTS(protocol, SERVER, get_info))

{

add_custom_action(menu, _("Get Info"),

PURPLE_CALLBACK(finch_blist_get_buddy_info_cb), buddy);

}

add_custom_action(menu, _("Add Buddy Pounce"),

PURPLE_CALLBACK(finch_blist_pounce_node_cb), buddy);

if (PURPLE_IS_PROTOCOL_XFER(protocol))

{

if (purple_protocol_xfer_can_receive(

PURPLE_PROTOCOL_XFER(protocol),

gc,

purple_buddy_get_name(buddy))

) {

add_custom_action(menu, _("Send File"),

PURPLE_CALLBACK(finch_blist_menu_send_file_cb), buddy);

}

account = purple_buddy_get_account(buddy);

permitted = purple_account_privacy_check(account, purple_buddy_get_name(buddy));

item = gnt_menuitem_check_new(_("Blocked"));

gnt_menuitem_check_set_checked(GNT_MENU_ITEM_CHECK(item), !permitted);

gnt_menuitem_set_callback(item, toggle_block_buddy, buddy);

gnt_menu_add_item(menu, item);

item = gnt_menuitem_check_new(_("Show when offline"));

gnt_menuitem_check_set_checked(GNT_MENU_ITEM_CHECK(item), purple_blist_node_get_bool((PurpleBlistNode*)buddy, "show_offline"));

gnt_menuitem_set_callback(item, toggle_show_offline, buddy);

gnt_menu_add_item(menu, item);

/* Protocol actions */

append_proto_menu(menu,

purple_account_get_connection(purple_buddy_get_account(buddy)),

(PurpleBlistNode*)buddy);

}

static void

append_extended_menu(GntMenu *menu, PurpleBlistNode *node)

{

GList *iter;

for (iter = purple_blist_node_get_extended_menu(node);

iter; iter = g_list_delete_link(iter, iter))

{

finch_append_menu_action(menu, iter->data, node);

}

/* Xerox'd from gtkdialogs.c:purple_gtkdialogs_remove_contact_cb */

static void

remove_contact(PurpleContact *contact)

{

PurpleBlistNode *bnode, *cnode;

PurpleGroup *group;

cnode = (PurpleBlistNode *)contact;

group = (PurpleGroup*)purple_blist_node_get_parent(cnode);

for (bnode = purple_blist_node_get_first_child(cnode); bnode; bnode = purple_blist_node_get_sibling_next(bnode)) {

PurpleBuddy *buddy = (PurpleBuddy*)bnode;

PurpleAccount *account = purple_buddy_get_account(buddy);

if (purple_account_is_connected(account))

purple_account_remove_buddy(account, buddy, group);

}

purple_blist_remove_contact(contact);

}

static void

rename_blist_node(PurpleBlistNode *node, const char *newname)

{

const char *name = newname;

if (name && !*name)

name = NULL;

if (PURPLE_IS_CONTACT(node)) {

PurpleContact *contact = (PurpleContact*)node;

PurpleBuddy *buddy = purple_contact_get_priority_buddy(contact);

purple_contact_set_alias(contact, name);

purple_buddy_set_local_alias(buddy, name);

purple_serv_alias_buddy(buddy);

} else if (PURPLE_IS_BUDDY(node)) {

purple_buddy_set_local_alias((PurpleBuddy*)node, name);

purple_serv_alias_buddy((PurpleBuddy*)node);

} else if (PURPLE_IS_CHAT(node))

purple_chat_set_alias((PurpleChat*)node, name);

else if (PURPLE_IS_GROUP(node) && (name != NULL))

purple_group_set_name((PurpleGroup*)node, name);

else

g_return_if_reached();

}

static void

finch_blist_rename_node_cb(PurpleBlistNode *selected, PurpleBlistNode *node)

{

const char *name = NULL;

char *prompt;

const char *text;

if (PURPLE_IS_CONTACT(node))

name = purple_contact_get_alias((PurpleContact*)node);

else if (PURPLE_IS_BUDDY(node))

name = purple_buddy_get_contact_alias((PurpleBuddy*)node);

else if (PURPLE_IS_CHAT(node))

name = purple_chat_get_name((PurpleChat*)node);

else if (PURPLE_IS_GROUP(node))

name = purple_group_get_name((PurpleGroup*)node);

else

g_return_if_reached();

prompt = g_strdup_printf(_("Please enter the new name for %s"), name);

text = PURPLE_IS_GROUP(node) ? _("Rename") : _("Set Alias");

purple_request_input(node, text, prompt, _("Enter empty string to reset the name."),

name, FALSE, FALSE, NULL, text, G_CALLBACK(rename_blist_node),

_("Cancel"), NULL,

NULL, node);

g_free(prompt);

}

static void showlog_cb(PurpleBlistNode *sel, PurpleBlistNode *node)

{

PurpleLogType type;

PurpleAccount *account;

char *name = NULL;

if (PURPLE_IS_BUDDY(node)) {

PurpleBuddy *b = (PurpleBuddy*) node;

type = PURPLE_LOG_IM;

name = g_strdup(purple_buddy_get_name(b));

account = purple_buddy_get_account(b);

} else if (PURPLE_IS_CHAT(node)) {

PurpleChat *c = (PurpleChat*) node;

PurpleProtocol *protocol = NULL;

type = PURPLE_LOG_CHAT;

account = purple_chat_get_account(c);

protocol = purple_protocols_find(purple_account_get_protocol_id(account));

if (protocol) {

name = purple_protocol_chat_iface_get_name(protocol, purple_chat_get_components(c));

}

} else if (PURPLE_IS_CONTACT(node)) {

finch_log_show_contact((PurpleContact *)node);

return;

} else {

/* This callback should not have been registered for a node

* that doesn't match the type of one of the blocks above. */

g_return_if_reached();

}

if (name && account) {

finch_log_show(type, name, account);

g_free(name);

}

/* Xeroxed from gtkdialogs.c:purple_gtkdialogs_remove_group_cb*/

static void

remove_group(PurpleGroup *group)

{

PurpleBlistNode *cnode, *bnode;

cnode = purple_blist_node_get_first_child(((PurpleBlistNode*)group));

while (cnode) {

if (PURPLE_IS_CONTACT(cnode)) {

bnode = purple_blist_node_get_first_child(cnode);

cnode = purple_blist_node_get_sibling_next(cnode);

while (bnode) {

PurpleBuddy *buddy;

if (PURPLE_IS_BUDDY(bnode)) {

PurpleAccount *account;

buddy = (PurpleBuddy*)bnode;

bnode = purple_blist_node_get_sibling_next(bnode);

account = purple_buddy_get_account(buddy);

if (purple_account_is_connected(account)) {

purple_account_remove_buddy(account, buddy, group);

purple_blist_remove_buddy(buddy);

}

} else {

bnode = purple_blist_node_get_sibling_next(bnode);

}

} else if (PURPLE_IS_CHAT(cnode)) {

PurpleChat *chat = (PurpleChat *)cnode;

cnode = purple_blist_node_get_sibling_next(cnode);

if (purple_account_is_connected(purple_chat_get_account(chat)))

purple_blist_remove_chat(chat);

} else {

cnode = purple_blist_node_get_sibling_next(cnode);

}

purple_blist_remove_group(group);

}

static void

finch_blist_remove_node(PurpleBlistNode *node)

{

if (PURPLE_IS_CONTACT(node)) {

remove_contact((PurpleContact*)node);

} else if (PURPLE_IS_BUDDY(node)) {

PurpleBuddy *buddy = (PurpleBuddy*)node;

PurpleGroup *group = purple_buddy_get_group(buddy);

purple_account_remove_buddy(purple_buddy_get_account(buddy), buddy, group);

purple_blist_remove_buddy(buddy);

} else if (PURPLE_IS_CHAT(node)) {

purple_blist_remove_chat((PurpleChat*)node);

} else if (PURPLE_IS_GROUP(node)) {

remove_group((PurpleGroup*)node);

}

static void

finch_blist_remove_node_cb(PurpleBlistNode *selected, PurpleBlistNode *node)

{

PurpleAccount *account = NULL;

char *primary;

const char *name, *sec = NULL;

if (PURPLE_IS_CONTACT(node)) {

PurpleContact *c = (PurpleContact*)node;

name = purple_contact_get_alias(c);

if (purple_counting_node_get_total_size(PURPLE_COUNTING_NODE(c)) > 1)

sec = _("Removing this contact will also remove all the buddies in the contact");

} else if (PURPLE_IS_BUDDY(node)) {

name = purple_buddy_get_name((PurpleBuddy*)node);

account = purple_buddy_get_account((PurpleBuddy*)node);

} else if (PURPLE_IS_CHAT(node)) {

name = purple_chat_get_name((PurpleChat*)node);

} else if (PURPLE_IS_GROUP(node)) {

name = purple_group_get_name((PurpleGroup*)node);

sec = _("Removing this group will also remove all the buddies in the group");

}

else

return;

primary = g_strdup_printf(_("Are you sure you want to remove %s?"), name);

/* XXX: anything to do with the returned ui-handle? */

purple_request_action(node, _("Confirm Remove"),

primary, sec,

purple_request_cpar_from_account(account),

node, 2,

_("Remove"), finch_blist_remove_node,

_("Cancel"), NULL);

g_free(primary);

}

static void

finch_blist_toggle_tag_buddy(PurpleBlistNode *node)

{

GList *iter;

if (node == NULL)

return;

if (ggblist->tagged && (iter = g_list_find(ggblist->tagged, node)) != NULL) {

ggblist->tagged = g_list_delete_link(ggblist->tagged, iter);

} else {

ggblist->tagged = g_list_prepend(ggblist->tagged, node);

}

if (PURPLE_IS_CONTACT(node))

update_buddy_display(purple_contact_get_priority_buddy(PURPLE_CONTACT(node)), ggblist);

else if (PURPLE_IS_BUDDY(node))

update_buddy_display((PurpleBuddy*)node, ggblist);

else

update_node_display(node, ggblist);

}

static void

finch_blist_place_tagged(PurpleBlistNode *target)

{

PurpleGroup *tg = NULL;

PurpleContact *tc = NULL;

if (PURPLE_IS_GROUP(target))

tg = (PurpleGroup*)target;

else if (PURPLE_IS_BUDDY(target)) {

tc = (PurpleContact*)purple_blist_node_get_parent(target);

tg = (PurpleGroup*)purple_blist_node_get_parent((PurpleBlistNode*)tc);

} else if (PURPLE_IS_CONTACT(target)) {

tc = (PurpleContact *)target;

tg = (PurpleGroup *)purple_blist_node_get_parent(target);

} else if (PURPLE_IS_CHAT(target)) {

tg = (PurpleGroup*)purple_blist_node_get_parent(target);

} else {

return;

}

if (ggblist->tagged) {

GList *list = ggblist->tagged;

ggblist->tagged = NULL;

while (list) {

PurpleBlistNode *node = list->data;

list = g_list_delete_link(list, list);

if (PURPLE_IS_GROUP(node)) {

update_node_display(node, ggblist);

/* Add the group after the current group */

purple_blist_add_group((PurpleGroup*)node, (PurpleBlistNode*)tg);

} else if (PURPLE_IS_CONTACT(node)) {

update_buddy_display(purple_contact_get_priority_buddy((PurpleContact*)node), ggblist);

if (PURPLE_BLIST_NODE(tg) == target) {

/* The target is a group, just add the contact to the group. */

purple_blist_add_contact((PurpleContact*)node, tg, NULL);

} else if (tc) {

/* The target is either a buddy, or a contact. Merge with that contact. */

purple_contact_merge((PurpleContact*)node, (PurpleBlistNode*)tc);

} else {

/* The target is a chat. Add the contact to the group after this chat. */

purple_blist_add_contact((PurpleContact*)node, NULL, target);

}

} else if (PURPLE_IS_BUDDY(node)) {

update_buddy_display((PurpleBuddy*)node, ggblist);

if (PURPLE_BLIST_NODE(tg) == target) {

/* The target is a group. Add this buddy in a new contact under this group. */

purple_blist_add_buddy((PurpleBuddy*)node, NULL, tg, NULL);

} else if (PURPLE_IS_CONTACT(target)) {

/* Add to the contact. */

purple_blist_add_buddy((PurpleBuddy*)node, tc, NULL, NULL);

} else if (PURPLE_IS_BUDDY(target)) {

/* Add to the contact after the selected buddy. */

purple_blist_add_buddy((PurpleBuddy*)node, NULL, NULL, target);

} else if (PURPLE_IS_CHAT(target)) {

/* Add to the selected chat's group. */

purple_blist_add_buddy((PurpleBuddy*)node, NULL, tg, NULL);

}

} else if (PURPLE_IS_CHAT(node)) {

update_node_display(node, ggblist);

if (PURPLE_BLIST_NODE(tg) == target)

purple_blist_add_chat((PurpleChat*)node, tg, NULL);

else

purple_blist_add_chat((PurpleChat*)node, NULL, target);

}

static void

context_menu_destroyed(GntWidget *widget, FinchBuddyList *ggblist)

{

ggblist->context = NULL;

}

static void

draw_context_menu(FinchBuddyList *ggblist)

{

PurpleBlistNode *node = NULL;

GntWidget *context = NULL;

GntTree *tree = NULL;

int x, y, top, width;

char *title = NULL;

if (ggblist->context)

return;

tree = GNT_TREE(ggblist->tree);

node = gnt_tree_get_selection_data(tree);

if (node && !(PURPLE_IS_BUDDY(node) || PURPLE_IS_CONTACT(node) ||

PURPLE_IS_GROUP(node) || PURPLE_IS_CHAT(node)))

return;

if (ggblist->tooltip)

remove_tooltip(ggblist);

ggblist->cnode = node;

ggblist->context = context = gnt_menu_new(GNT_MENU_POPUP);

g_signal_connect(G_OBJECT(context), "destroy", G_CALLBACK(context_menu_destroyed), ggblist);

g_signal_connect(G_OBJECT(context), "hide", G_CALLBACK(gnt_widget_destroy), NULL);

if (!node) {

create_group_menu(GNT_MENU(context), NULL);

title = g_strdup(_("Buddy List"));

} else if (PURPLE_IS_CONTACT(node)) {

ggblist->cnode = PURPLE_BLIST_NODE(purple_contact_get_priority_buddy(PURPLE_CONTACT(node)));

create_buddy_menu(GNT_MENU(context), (PurpleBuddy*)ggblist->cnode);

title = g_strdup(purple_contact_get_alias((PurpleContact*)node));

} else if (PURPLE_IS_BUDDY(node)) {

PurpleBuddy *buddy = (PurpleBuddy *)node;

create_buddy_menu(GNT_MENU(context), buddy);

title = g_strdup(purple_buddy_get_name(buddy));

} else if (PURPLE_IS_CHAT(node)) {

PurpleChat *chat = (PurpleChat*)node;

create_chat_menu(GNT_MENU(context), chat);

title = g_strdup(purple_chat_get_name(chat));

} else if (PURPLE_IS_GROUP(node)) {

PurpleGroup *group = (PurpleGroup *)node;

create_group_menu(GNT_MENU(context), group);

title = g_strdup(purple_group_get_name(group));

}

append_extended_menu(GNT_MENU(context), node);

/* These are common for everything */

if (node) {

add_custom_action(GNT_MENU(context),

PURPLE_IS_GROUP(node) ? _("Rename") : _("Alias"),

PURPLE_CALLBACK(finch_blist_rename_node_cb), node);

add_custom_action(GNT_MENU(context), _("Remove"),

PURPLE_CALLBACK(finch_blist_remove_node_cb), node);

if (ggblist->tagged && (PURPLE_IS_CONTACT(node)

|| PURPLE_IS_GROUP(node))) {

add_custom_action(GNT_MENU(context), _("Place tagged"),

PURPLE_CALLBACK(finch_blist_place_tagged), node);

}

if (PURPLE_IS_BUDDY(node) || PURPLE_IS_CONTACT(node)) {

add_custom_action(GNT_MENU(context), _("Toggle Tag"),

PURPLE_CALLBACK(finch_blist_toggle_tag_buddy), node);

}

if (!PURPLE_IS_GROUP(node)) {

add_custom_action(GNT_MENU(context), _("View Log"),

PURPLE_CALLBACK(showlog_cb), node);

}

/* Set the position for the popup */

gnt_widget_get_position(GNT_WIDGET(tree), &x, &y);

gnt_widget_get_size(GNT_WIDGET(tree), &width, NULL);

top = gnt_tree_get_selection_visible_line(tree);

x += width;

y += top - 1;

gnt_widget_set_position(context, x, y);

gnt_screen_menu_show(GNT_MENU(context));

g_free(title);

}

static void

tooltip_for_buddy(PurpleBuddy *buddy, GString *str, gboolean full)

{

PurpleProtocol *protocol;

PurpleAccount *account;

PurpleNotifyUserInfo *user_info;

PurplePresence *presence;

const char *alias = purple_buddy_get_alias(buddy);

char *tmp, *strip;

user_info = purple_notify_user_info_new();

account = purple_buddy_get_account(buddy);

presence = purple_buddy_get_presence(buddy);

if (!full || g_utf8_collate(purple_buddy_get_name(buddy), alias)) {

purple_notify_user_info_add_pair_plaintext(user_info, _("Nickname"), alias);

}

tmp = g_strdup_printf("%s (%s)",

purple_account_get_username(account),

purple_account_get_protocol_name(account));

purple_notify_user_info_add_pair_plaintext(user_info, _("Account"), tmp);

g_free(tmp);

protocol = purple_protocols_find(purple_account_get_protocol_id(account));

if (protocol) {

purple_protocol_client_iface_tooltip_text(protocol, buddy, user_info, full);

}

if (purple_prefs_get_bool("/finch/blist/idletime")) {

PurplePresence *pre = purple_buddy_get_presence(buddy);

if (purple_presence_is_idle(pre)) {

time_t idle = purple_presence_get_idle_time(pre);

if (idle > 0) {

char *st = purple_str_seconds_to_string(time(NULL) - idle);

purple_notify_user_info_add_pair_plaintext(user_info, _("Idle"), st);

g_free(st);

}

tmp = purple_notify_user_info_get_text_with_newline(user_info, "<BR>");

purple_notify_user_info_destroy(user_info);

strip = purple_markup_strip_html(tmp);

g_string_append(str, strip);

if (purple_presence_is_status_primitive_active(presence, PURPLE_STATUS_MOBILE)) {

g_string_append(str, "\n");

g_string_append(str, _("On Mobile"));

}

g_free(strip);

g_free(tmp);

}

static GString*

make_sure_text_fits(GString *string)

{

int maxw = getmaxx(stdscr) - 3;

char *str = gnt_util_onscreen_fit_string(string->str, maxw);

string = g_string_assign(string, str);

g_free(str);

return string;

}

static gboolean

draw_tooltip_real(FinchBuddyList *ggblist)

{

PurpleBlistNode *node;

int x, y, top, width, w, h;

GString *str = NULL;

GntTree *tree;

GntWidget *widget, *box, *tv;

char *title = NULL;

widget = ggblist->tree;

tree = GNT_TREE(widget);

if (!gnt_widget_has_focus(ggblist->tree) ||

(ggblist->context && gnt_widget_get_visible(ggblist->context)))

return FALSE;

if (ggblist->tooltip)

{

/* XXX: Once we can properly redraw on expose events, this can be removed at the end

* to avoid the blinking*/

remove_tooltip(ggblist);

}

node = gnt_tree_get_selection_data(tree);

if (!node)

return FALSE;

if (!ggblist->manager->create_tooltip(node, &str, &title))

return FALSE;

gnt_widget_get_position(widget, &x, &y);

gnt_widget_get_size(widget, &width, NULL);

top = gnt_tree_get_selection_visible_line(tree);

x += width;

y += top - 1;

box = gnt_box_new(FALSE, FALSE);

gnt_box_set_toplevel(GNT_BOX(box), TRUE);

gnt_widget_set_has_shadow(box, FALSE);

gnt_box_set_title(GNT_BOX(box), title);

str = make_sure_text_fits(str);

gnt_util_get_text_bound(str->str, &w, &h);

h = MAX(1, h);

tv = gnt_text_view_new();

gnt_widget_set_size(tv, w + 1, h);

gnt_text_view_set_flag(GNT_TEXT_VIEW(tv), GNT_TEXT_VIEW_NO_SCROLL);

gnt_box_add_widget(GNT_BOX(box), tv);

if (x + w >= getmaxx(stdscr))

x -= w + width + 2;

gnt_widget_set_position(box, x, y);

gnt_widget_set_take_focus(box, FALSE);

gnt_widget_set_transient(box, TRUE);

gnt_widget_draw(box);

gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(tv), str->str, GNT_TEXT_FLAG_NORMAL);

gnt_text_view_scroll(GNT_TEXT_VIEW(tv), 0);

g_free(title);

g_string_free(str, TRUE);

ggblist->tooltip = box;

ggblist->tnode = node;

gnt_widget_set_name(ggblist->tooltip, "tooltip");

return FALSE;

}

static void

draw_tooltip(FinchBuddyList *ggblist)

{

/* When an account has signed off, it removes one buddy at a time.

* Drawing the tooltip after removing each buddy is expensive. On

* top of that, if the selected buddy belongs to the disconnected

* account, then retreiving the tooltip for that causes crash. So

* let's make sure we wait for all the buddies to be removed first.*/

int id = g_timeout_add(0, (GSourceFunc)draw_tooltip_real, ggblist);

g_object_set_data_full(G_OBJECT(ggblist->window), "draw_tooltip_calback",

GINT_TO_POINTER(id), (GDestroyNotify)g_source_remove);

}

static void

selection_changed(GntWidget *widget, gpointer old, gpointer current,

FinchBuddyList *ggblist)

{

remove_peripherals(ggblist);

draw_tooltip(ggblist);

}

static gboolean

context_menu(GntWidget *widget, FinchBuddyList *ggblist)

{

draw_context_menu(ggblist);

return TRUE;

}

static gboolean

key_pressed(GntWidget *widget, const char *text, FinchBuddyList *ggblist)

{

if (text[0] == 27 && text[1] == 0) {

/* Escape was pressed */

if (gnt_tree_is_searching(GNT_TREE(ggblist->tree)))

gnt_bindable_perform_action_named(GNT_BINDABLE(ggblist->tree), "end-search", NULL);

remove_peripherals(ggblist);

} else if (purple_strequal(text, GNT_KEY_INS)) {

PurpleBlistNode *node = gnt_tree_get_selection_data(GNT_TREE(ggblist->tree));

purple_blist_request_add_buddy(NULL, NULL,

node && PURPLE_IS_GROUP(node) ? purple_group_get_name(PURPLE_GROUP(node)) : NULL,

NULL);

} else if (!gnt_tree_is_searching(GNT_TREE(ggblist->tree))) {

if (purple_strequal(text, "t")) {

finch_blist_toggle_tag_buddy(gnt_tree_get_selection_data(GNT_TREE(ggblist->tree)));

gnt_bindable_perform_action_named(GNT_BINDABLE(ggblist->tree), "move-down", NULL);

} else if (purple_strequal(text, "a")) {

finch_blist_place_tagged(gnt_tree_get_selection_data(GNT_TREE(ggblist->tree)));

} else

return FALSE;

} else

return FALSE;

return TRUE;

}

static void

update_node_display(PurpleBlistNode *node, FinchBuddyList *ggblist)

{

GntTextFormatFlags flag = get_blist_node_flag(ggblist, node);

gnt_tree_set_row_flags(GNT_TREE(ggblist->tree), node, flag);

}

static void

update_buddy_display(PurpleBuddy *buddy, FinchBuddyList *ggblist)

{

PurpleContact *contact;

contact = purple_buddy_get_contact(buddy);

gnt_tree_change_text(GNT_TREE(ggblist->tree), buddy, 0, get_display_name((PurpleBlistNode*)buddy));

gnt_tree_change_text(GNT_TREE(ggblist->tree), contact, 0, get_display_name((PurpleBlistNode*)contact));

blist_update_row_flags(ggblist, (PurpleBlistNode *)buddy);

if (buddy == purple_contact_get_priority_buddy(contact))

blist_update_row_flags(ggblist, (PurpleBlistNode *)contact);

if (ggblist->tnode == (PurpleBlistNode *)buddy) {

draw_tooltip(ggblist);

}

static void

buddy_status_changed(PurpleBuddy *buddy, PurpleStatus *old, PurpleStatus *now,

FinchBuddyList *ggblist)

{

update_buddy_display(buddy, ggblist);

}

static void

buddy_idle_changed(PurpleBuddy *buddy, int old, int new,

FinchBuddyList *ggblist)

{

update_buddy_display(buddy, ggblist);

}

static void

remove_peripherals(FinchBuddyList *ggblist)

{

if (ggblist->tooltip)

remove_tooltip(ggblist);

else if (ggblist->context)

gnt_widget_destroy(ggblist->context);

}

static void

size_changed_cb(GntWidget *w, int wi, int h)

{

int width, height;

gnt_widget_get_size(w, &width, &height);

purple_prefs_set_int(PREF_ROOT "/size/width", width);

purple_prefs_set_int(PREF_ROOT "/size/height", height);

}

static void

save_position_cb(GntWidget *w, int x, int y)

{

purple_prefs_set_int(PREF_ROOT "/position/x", x);

purple_prefs_set_int(PREF_ROOT "/position/y", y);

}

static void

reset_blist_window(GntWidget *window, gpointer null)

{

PurpleBlistNode *node;

purple_signals_disconnect_by_handle(finch_blist_get_handle());

node = purple_blist_get_default_root();

while (node) {

reset_blist_node_ui_data(node);

node = purple_blist_node_next(node, TRUE);

}

if (ggblist->typing)

g_source_remove(ggblist->typing);

remove_peripherals(ggblist);

if (ggblist->tagged)

g_list_free(ggblist->tagged);

if (ggblist->new_group_timeout)

g_source_remove(ggblist->new_group_timeout);

if (ggblist->new_group)

g_list_free(ggblist->new_group);

ggblist = NULL;

}

static void

populate_buddylist(void)

{

PurpleBlistNode *node;

PurpleBuddyList *list;

if (ggblist->manager->init)

ggblist->manager->init();

if (purple_strequal(purple_prefs_get_string(PREF_ROOT "/sort_type"), "text")) {

gnt_tree_set_compare_func(GNT_TREE(ggblist->tree),

(GCompareFunc)blist_node_compare_text);

} else if (purple_strequal(purple_prefs_get_string(PREF_ROOT "/sort_type"), "status")) {

gnt_tree_set_compare_func(GNT_TREE(ggblist->tree),

(GCompareFunc)blist_node_compare_status);

} else if (purple_strequal(purple_prefs_get_string(PREF_ROOT "/sort_type"), "log")) {

gnt_tree_set_compare_func(GNT_TREE(ggblist->tree),

(GCompareFunc)blist_node_compare_log);

}

list = purple_blist_get_default();

node = purple_blist_get_root(list);

while (node)

{

node_update(list, node);

node = purple_blist_node_next(node, FALSE);

}

static void

destroy_status_list(GList *list)

{

g_list_free_full(list, g_free);

}

static void

populate_status_dropdown(void)

{

int i;

GList *iter;

GList *items = NULL;

StatusBoxItem *item = NULL;

/* First the primitives */

PurpleStatusPrimitive prims[] = {PURPLE_STATUS_AVAILABLE, PURPLE_STATUS_AWAY,

PURPLE_STATUS_INVISIBLE, PURPLE_STATUS_OFFLINE, PURPLE_STATUS_UNSET};

gnt_combo_box_remove_all(GNT_COMBO_BOX(ggblist->status));

for (i = 0; prims[i] != PURPLE_STATUS_UNSET; i++)

{

item = g_new0(StatusBoxItem, 1);

item->type = STATUS_PRIMITIVE;

item->u.prim = prims[i];

items = g_list_prepend(items, item);

gnt_combo_box_add_data(GNT_COMBO_BOX(ggblist->status), item,

purple_primitive_get_name_from_type(prims[i]));

}

/* Now the popular statuses */

for (iter = purple_savedstatuses_get_popular(6); iter; iter = g_list_delete_link(iter, iter))

{

item = g_new0(StatusBoxItem, 1);

item->type = STATUS_SAVED_POPULAR;

item->u.saved = iter->data;

items = g_list_prepend(items, item);

gnt_combo_box_add_data(GNT_COMBO_BOX(ggblist->status), item,

purple_savedstatus_get_title(iter->data));

}

/* New savedstatus */

item = g_new0(StatusBoxItem, 1);

item->type = STATUS_SAVED_NEW;

items = g_list_prepend(items, item);

gnt_combo_box_add_data(GNT_COMBO_BOX(ggblist->status), item,

_("New..."));

/* More savedstatuses */

item = g_new0(StatusBoxItem, 1);

item->type = STATUS_SAVED_ALL;

items = g_list_prepend(items, item);

gnt_combo_box_add_data(GNT_COMBO_BOX(ggblist->status), item,

_("Saved..."));

/* The keys for the combobox are created here, and never used

* anywhere else. So make sure the keys are freed when the widget

* is destroyed. */

g_object_set_data_full(G_OBJECT(ggblist->status), "list of statuses",

items, (GDestroyNotify)destroy_status_list);

}

static void

redraw_blist(const char *name, PurplePrefType type, gconstpointer val, gpointer data)

{

PurpleBlistNode *node, *sel;

FinchBlistManager *manager;

if (ggblist == NULL)

return;

manager = finch_blist_manager_find(purple_prefs_get_string(PREF_ROOT "/grouping"));

if (manager == NULL)

manager = &default_manager;

if (ggblist->manager != manager) {

if (ggblist->manager->uninit)

ggblist->manager->uninit();

ggblist->manager = manager;

if (manager->can_add_node == NULL)

manager->can_add_node = default_can_add_node;

if (manager->find_parent == NULL)

manager->find_parent = default_find_parent;

if (manager->create_tooltip == NULL)

manager->create_tooltip = default_create_tooltip;

}

if (ggblist->window == NULL)

return;

sel = gnt_tree_get_selection_data(GNT_TREE(ggblist->tree));

gnt_tree_remove_all(GNT_TREE(ggblist->tree));

for (node = purple_blist_get_default_root(); node;

node = purple_blist_node_next(node, TRUE)) {

reset_blist_node_ui_data(node);

}

populate_buddylist();

gnt_tree_set_selected(GNT_TREE(ggblist->tree), sel);

draw_tooltip(ggblist);

}

void finch_blist_init()

{

color_available = gnt_style_get_color(NULL, "color-available");

if (!color_available)

color_available = gnt_color_add_pair(COLOR_GREEN, -1);

color_away = gnt_style_get_color(NULL, "color-away");

if (!color_away)

color_away = gnt_color_add_pair(COLOR_BLUE, -1);

color_idle = gnt_style_get_color(NULL, "color-idle");

if (!color_idle)

color_idle = gnt_color_add_pair(COLOR_CYAN, -1);

color_offline = gnt_style_get_color(NULL, "color-offline");

if (!color_offline)

color_offline = gnt_color_add_pair(COLOR_RED, -1);

purple_prefs_add_none(PREF_ROOT);

purple_prefs_add_none(PREF_ROOT "/size");

purple_prefs_add_int(PREF_ROOT "/size/width", 20);

purple_prefs_add_int(PREF_ROOT "/size/height", 17);

purple_prefs_add_none(PREF_ROOT "/position");

purple_prefs_add_int(PREF_ROOT "/position/x", 0);

purple_prefs_add_int(PREF_ROOT "/position/y", 0);

purple_prefs_add_bool(PREF_ROOT "/idletime", TRUE);

purple_prefs_add_bool(PREF_ROOT "/showoffline", FALSE);

purple_prefs_add_bool(PREF_ROOT "/emptygroups", FALSE);

purple_prefs_add_string(PREF_ROOT "/sort_type", "text");

purple_prefs_add_string(PREF_ROOT "/grouping", "default");

purple_prefs_connect_callback(finch_blist_get_handle(),

PREF_ROOT "/emptygroups", redraw_blist, NULL);

purple_prefs_connect_callback(finch_blist_get_handle(),

PREF_ROOT "/showoffline", redraw_blist, NULL);

purple_prefs_connect_callback(finch_blist_get_handle(),

PREF_ROOT "/sort_type", redraw_blist, NULL);

purple_prefs_connect_callback(finch_blist_get_handle(),

PREF_ROOT "/grouping", redraw_blist, NULL);

purple_signal_connect_priority(purple_connections_get_handle(),

"autojoin", purple_blist_get_handle(),

G_CALLBACK(account_autojoin_cb), NULL,

PURPLE_SIGNAL_PRIORITY_HIGHEST);

finch_blist_install_manager(&default_manager);

return;

}

static gboolean

remove_typing_cb(gpointer null)

{

PurpleSavedStatus *current;

const char *message, *newmessage;

char *escnewmessage;

PurpleStatusPrimitive prim, newprim;

StatusBoxItem *item;

current = purple_savedstatus_get_current();

message = purple_savedstatus_get_message(current);

prim = purple_savedstatus_get_primitive_type(current);

newmessage = gnt_entry_get_text(GNT_ENTRY(ggblist->statustext));

item = gnt_combo_box_get_selected_data(GNT_COMBO_BOX(ggblist->status));

escnewmessage = newmessage ? g_markup_escape_text(newmessage, -1) : NULL;

switch (item->type) {

case STATUS_PRIMITIVE:

newprim = item->u.prim;

break;

case STATUS_SAVED_POPULAR:

newprim = purple_savedstatus_get_primitive_type(item->u.saved);

break;

default:

goto end; /* 'New' or 'Saved' is selected, but this should never happen. */

}

if (newprim != prim || ((message && !escnewmessage) ||

(!message && escnewmessage) ||

(message && escnewmessage && g_utf8_collate(message, escnewmessage) != 0)))

{

PurpleSavedStatus *status = purple_savedstatus_find_transient_by_type_and_message(newprim, escnewmessage);

/* Holy Crap! That's a LAWNG function name */

if (status == NULL)

{

status = purple_savedstatus_new(NULL, newprim);

purple_savedstatus_set_message(status, escnewmessage);

}

purple_savedstatus_activate(status);

}

gnt_box_give_focus_to_child(GNT_BOX(ggblist->window), ggblist->tree);

end:

g_free(escnewmessage);

if (ggblist->typing)

g_source_remove(ggblist->typing);

ggblist->typing = 0;

return FALSE;

}

static void

status_selection_changed(GntComboBox *box, StatusBoxItem *old, StatusBoxItem *now, gpointer null)

{

gnt_entry_set_text(GNT_ENTRY(ggblist->statustext), NULL);

if (now->type == STATUS_SAVED_POPULAR)

{

/* Set the status immediately */

purple_savedstatus_activate(now->u.saved);

}

else if (now->type == STATUS_PRIMITIVE)

{

/* Move the focus to the entry box */

/* XXX: Make sure the selected status can have a message */

gnt_box_move_focus(GNT_BOX(ggblist->window), 1);

ggblist->typing = g_timeout_add_seconds(TYPING_TIMEOUT_S, (GSourceFunc)remove_typing_cb, NULL);

}

else if (now->type == STATUS_SAVED_ALL)

{

/* Restore the selection to reflect current status. */

savedstatus_changed(purple_savedstatus_get_current(), NULL);

gnt_box_give_focus_to_child(GNT_BOX(ggblist->window), ggblist->tree);

finch_savedstatus_show_all();

}

else if (now->type == STATUS_SAVED_NEW)

{

savedstatus_changed(purple_savedstatus_get_current(), NULL);

gnt_box_give_focus_to_child(GNT_BOX(ggblist->window), ggblist->tree);

finch_savedstatus_edit(NULL);

}

else

g_return_if_reached();

}

static gboolean

status_text_changed(GntEntry *entry, const char *text, gpointer null)

{

if ((text[0] == 27 || (text[0] == '\t' && text[1] == '\0')) && ggblist->typing == 0)

return FALSE;

if (ggblist->typing)

g_source_remove(ggblist->typing);

ggblist->typing = 0;

if (text[0] == '\r' && text[1] == 0)

{

/* Set the status only after you press 'Enter' */

remove_typing_cb(NULL);

return TRUE;

}

ggblist->typing = g_timeout_add_seconds(TYPING_TIMEOUT_S, (GSourceFunc)remove_typing_cb, NULL);

return FALSE;

}

static void

savedstatus_changed(PurpleSavedStatus *now, PurpleSavedStatus *old)

{

GList *list;

PurpleStatusPrimitive prim;

const char *message;

gboolean found = FALSE, saved = TRUE;

if (!ggblist)

return;

/* Block the signals we don't want to emit */

g_signal_handlers_block_matched(ggblist->status, G_SIGNAL_MATCH_FUNC,

0, 0, NULL, status_selection_changed, NULL);

g_signal_handlers_block_matched(ggblist->statustext, G_SIGNAL_MATCH_FUNC,

0, 0, NULL, status_text_changed, NULL);

prim = purple_savedstatus_get_primitive_type(now);

message = purple_savedstatus_get_message(now);

/* Rebuild the status dropdown */

populate_status_dropdown();

while (!found) {

list = g_object_get_data(G_OBJECT(ggblist->status), "list of statuses");

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

{

StatusBoxItem *item = list->data;

if ((saved && item->type != STATUS_PRIMITIVE && item->u.saved == now) ||

(!saved && item->type == STATUS_PRIMITIVE && item->u.prim == prim))

{

char *mess = purple_unescape_html(message);

gnt_combo_box_set_selected(GNT_COMBO_BOX(ggblist->status), item);

gnt_entry_set_text(GNT_ENTRY(ggblist->statustext), mess);

gnt_widget_draw(ggblist->status);

g_free(mess);

found = TRUE;

break;

}

if (!saved)

break;

saved = FALSE;

}

g_signal_handlers_unblock_matched(ggblist->status, G_SIGNAL_MATCH_FUNC,

0, 0, NULL, status_selection_changed, NULL);

g_signal_handlers_unblock_matched(ggblist->statustext, G_SIGNAL_MATCH_FUNC,

0, 0, NULL, status_text_changed, NULL);

}

static int

blist_node_compare_position(PurpleBlistNode *n1, PurpleBlistNode *n2)

{

while ((n1 = purple_blist_node_get_sibling_prev(n1)) != NULL)

if (n1 == n2)

return 1;

return -1;

}

static int

blist_node_compare_text(PurpleBlistNode *n1, PurpleBlistNode *n2)

{

const char *s1, *s2;

char *us1, *us2;

int ret;

if (G_OBJECT_TYPE(n1) != G_OBJECT_TYPE(n2))

return blist_node_compare_position(n1, n2);

if (PURPLE_IS_CHAT(n1)) {

s1 = purple_chat_get_name((PurpleChat*)n1);

s2 = purple_chat_get_name((PurpleChat*)n2);

} else if (PURPLE_IS_BUDDY(n1)) {

return purple_buddy_presence_compare(

PURPLE_BUDDY_PRESENCE(purple_buddy_get_presence(PURPLE_BUDDY(n1))),

PURPLE_BUDDY_PRESENCE(purple_buddy_get_presence(PURPLE_BUDDY(n2))));

} else if (PURPLE_IS_CONTACT(n1)) {

s1 = purple_contact_get_alias((PurpleContact*)n1);

s2 = purple_contact_get_alias((PurpleContact*)n2);

} else {

return blist_node_compare_position(n1, n2);

}

us1 = g_utf8_strup(s1, -1);

us2 = g_utf8_strup(s2, -1);

ret = g_utf8_collate(us1, us2);

g_free(us1);

g_free(us2);

return ret;

}

static int

blist_node_compare_status(PurpleBlistNode *n1, PurpleBlistNode *n2)

{

int ret;

if (G_OBJECT_TYPE(n1) != G_OBJECT_TYPE(n2))

return blist_node_compare_position(n1, n2);

if (PURPLE_IS_CONTACT(n1))

n1 = PURPLE_BLIST_NODE(purple_contact_get_priority_buddy(PURPLE_CONTACT(n1)));

if (PURPLE_IS_CONTACT(n2))

n2 = PURPLE_BLIST_NODE(purple_contact_get_priority_buddy(PURPLE_CONTACT(n2)));

if (PURPLE_IS_BUDDY(n1) && PURPLE_IS_BUDDY(n2)) {

ret = purple_buddy_presence_compare(

PURPLE_BUDDY_PRESENCE(purple_buddy_get_presence(PURPLE_BUDDY(n1))),

PURPLE_BUDDY_PRESENCE(purple_buddy_get_presence(PURPLE_BUDDY(n2))));

if (ret != 0)

return ret;

} else {

return blist_node_compare_position(n1, n2);

}

/* Sort alphabetically if presence is not comparable */

ret = blist_node_compare_text(n1, n2);

return ret;

}

static int

get_contact_log_size(PurpleBlistNode *c)

{

int log = 0;

PurpleBlistNode *node;

for (node = purple_blist_node_get_first_child(c); node; node = purple_blist_node_get_sibling_next(node)) {

PurpleBuddy *b = (PurpleBuddy*)node;

log += purple_log_get_total_size(PURPLE_LOG_IM, purple_buddy_get_name(b),

purple_buddy_get_account(b));

}

return log;

}

static int

blist_node_compare_log(PurpleBlistNode *n1, PurpleBlistNode *n2)

{

int ret;

PurpleBuddy *b1, *b2;

if (G_OBJECT_TYPE(n1) != G_OBJECT_TYPE(n2))

return blist_node_compare_position(n1, n2);

if (PURPLE_IS_BUDDY(n1)) {

b1 = (PurpleBuddy*)n1;

b2 = (PurpleBuddy*)n2;

ret = purple_log_get_total_size(PURPLE_LOG_IM, purple_buddy_get_name(b2), purple_buddy_get_account(b2)) -

purple_log_get_total_size(PURPLE_LOG_IM, purple_buddy_get_name(b1), purple_buddy_get_account(b1));

if (ret != 0)

return ret;

} else if (PURPLE_IS_CONTACT(n1)) {

ret = get_contact_log_size(n2) - get_contact_log_size(n1);

if (ret != 0)

return ret;

} else {

return blist_node_compare_position(n1, n2);

}

ret = blist_node_compare_text(n1, n2);

return ret;

}

static void

plugin_action(GntMenuItem *item, gpointer data)

{

PurplePluginAction *action = data;

if (action && action->callback)

action->callback(action);

}

static void

build_plugin_actions(GntMenuItem *item, PurplePlugin *plugin)

{

GntWidget *sub = gnt_menu_new(GNT_MENU_POPUP);

PurplePluginActionsCb actions_cb;

GList *actions;

GntMenuItem *menuitem;

actions_cb =

purple_plugin_info_get_actions_cb(purple_plugin_get_info(plugin));

gnt_menuitem_set_submenu(item, GNT_MENU(sub));

for (actions = actions_cb(plugin); actions;

actions = g_list_delete_link(actions, actions)) {

if (actions->data) {

PurplePluginAction *action = actions->data;

action->plugin = plugin;

menuitem = gnt_menuitem_new(action->label);

gnt_menu_add_item(GNT_MENU(sub), menuitem);

gnt_menuitem_set_callback(menuitem, plugin_action, action);

g_object_set_data_full(G_OBJECT(menuitem), "plugin_action",

action, (GDestroyNotify)purple_plugin_action_free);

}

static void

protocol_action(GntMenuItem *item, gpointer data)

{

PurpleProtocolAction *action = data;

if (action && action->callback)

action->callback(action);

}

static void

build_protocol_actions(GntMenuItem *item, PurpleProtocol *protocol,

PurpleConnection *gc)

{

GntWidget *sub = gnt_menu_new(GNT_MENU_POPUP);

GList *actions;

GntMenuItem *menuitem;

gnt_menuitem_set_submenu(item, GNT_MENU(sub));

for (actions = purple_protocol_client_iface_get_actions(protocol, gc); actions;

actions = g_list_delete_link(actions, actions)) {

if (actions->data) {

PurpleProtocolAction *action = actions->data;

action->connection = gc;

menuitem = gnt_menuitem_new(action->label);

gnt_menu_add_item(GNT_MENU(sub), menuitem);

gnt_menuitem_set_callback(menuitem, protocol_action, action);

g_object_set_data_full(G_OBJECT(menuitem), "protocol_action",

action, (GDestroyNotify)purple_protocol_action_free);

}

static gboolean

buddy_recent_signed_on_off(gpointer data)

{

PurpleBlistNode *node = data;

FinchBlistNode *fnode = purple_blist_node_get_ui_data(node);

g_source_remove(fnode->signed_timer);

fnode->signed_timer = 0;

if (!ggblist->manager->can_add_node(node)) {

node_remove(purple_blist_get_default(), node);

} else {

update_node_display(node, ggblist);

if (purple_blist_node_get_parent(node) && PURPLE_IS_CONTACT(purple_blist_node_get_parent(node)))

update_node_display(purple_blist_node_get_parent(node), ggblist);

}

g_object_unref(node);

return FALSE;

}

static gboolean

buddy_signed_on_off_cb(gpointer data)

{

PurpleBlistNode *node = data;

FinchBlistNode *fnode = purple_blist_node_get_ui_data(node);

if (!ggblist || !fnode)

return FALSE;

if (fnode->signed_timer)

g_source_remove(fnode->signed_timer);

g_object_ref(node);

fnode->signed_timer = g_timeout_add_seconds(6, (GSourceFunc)buddy_recent_signed_on_off, data);

update_node_display(node, ggblist);

if (purple_blist_node_get_parent(node) && PURPLE_IS_CONTACT(purple_blist_node_get_parent(node)))

update_node_display(purple_blist_node_get_parent(node), ggblist);

return FALSE;

}

static void

buddy_signed_on_off(PurpleBuddy* buddy, gpointer null)

{

g_idle_add(buddy_signed_on_off_cb, buddy);

}

static void

reconstruct_plugins_menu(void)

{

GntWidget *sub;

GntMenuItem *plg;

GList *iter;

if (!ggblist)

return;

if (ggblist->plugins == NULL)

ggblist->plugins = gnt_menuitem_new(_("Plugins"));

plg = ggblist->plugins;

sub = gnt_menu_new(GNT_MENU_POPUP);

gnt_menuitem_set_submenu(plg, GNT_MENU(sub));

for (iter = purple_plugins_get_loaded(); iter; iter = iter->next) {

PurplePlugin *plugin = iter->data;

PurplePluginInfo *info = purple_plugin_get_info(plugin);

GntMenuItem *item;

if (!purple_plugin_info_get_actions_cb(info))

continue;

item = gnt_menuitem_new(_(gplugin_plugin_info_get_name(

GPLUGIN_PLUGIN_INFO(info))));

gnt_menu_add_item(GNT_MENU(sub), item);

build_plugin_actions(item, plugin);

}

static void

reconstruct_accounts_menu(void)

{

GntWidget *sub;

GntMenuItem *acc, *item;

GList *iter;

if (!ggblist)

return;

if (ggblist->accounts == NULL)

ggblist->accounts = gnt_menuitem_new(_("Accounts"));

acc = ggblist->accounts;

sub = gnt_menu_new(GNT_MENU_POPUP);

gnt_menuitem_set_submenu(acc, GNT_MENU(sub));

for (iter = purple_accounts_get_all_active(); iter;

iter = g_list_delete_link(iter, iter)) {

PurpleAccount *account = iter->data;

PurpleConnection *gc = purple_account_get_connection(account);

PurpleProtocol *protocol;

if (!gc || !PURPLE_CONNECTION_IS_CONNECTED(gc))

continue;

protocol = purple_connection_get_protocol(gc);

if (PURPLE_PROTOCOL_IMPLEMENTS(protocol, CLIENT, get_actions)) {

item = gnt_menuitem_new(purple_account_get_username(account));

gnt_menu_add_item(GNT_MENU(sub), item);

build_protocol_actions(item, protocol, gc);

}

static void

reconstruct_grouping_menu(void)

{

GList *iter;

GntWidget *subsub;

if (!ggblist || !ggblist->grouping)

return;

subsub = gnt_menu_new(GNT_MENU_POPUP);

gnt_menuitem_set_submenu(ggblist->grouping, GNT_MENU(subsub));

for (iter = managers; iter; iter = iter->next) {

char menuid[128];

FinchBlistManager *manager = iter->data;

GntMenuItem *item = gnt_menuitem_new(_(manager->name));

g_snprintf(menuid, sizeof(menuid), "grouping-%s", manager->id);

gnt_menuitem_set_id(GNT_MENU_ITEM(item), menuid);

gnt_menu_add_item(GNT_MENU(subsub), item);

g_object_set_data_full(G_OBJECT(item), "grouping-id", g_strdup(manager->id), g_free);

gnt_menuitem_set_callback(item, menu_group_set_cb, NULL);

}

static gboolean

auto_join_chats(gpointer data)

{

PurpleBlistNode *node;

PurpleConnection *pc = data;

PurpleAccount *account = purple_connection_get_account(pc);

for (node = purple_blist_get_default_root(); node;

node = purple_blist_node_next(node, FALSE)) {

if (PURPLE_IS_CHAT(node)) {

PurpleChat *chat = (PurpleChat*)node;

if (purple_chat_get_account(chat) == account &&

purple_blist_node_get_bool(node, "gnt-autojoin"))

purple_serv_join_chat(purple_account_get_connection(account), purple_chat_get_components(chat));

}

return FALSE;

}

static gboolean

account_autojoin_cb(PurpleConnection *gc, gpointer null)

{

g_idle_add(auto_join_chats, gc);

return TRUE;

}

static void toggle_pref_cb(GntMenuItem *item, gpointer n)

{

purple_prefs_set_bool(n, !purple_prefs_get_bool(n));

}

static void sort_blist_change_cb(GntMenuItem *item, gpointer n)

{

purple_prefs_set_string(PREF_ROOT "/sort_type", n);

}

static void

block_select_cb(gpointer data, PurpleRequestFields *fields)

{

PurpleAccount *account = purple_request_fields_get_account(fields, "account");

const char *name = purple_request_fields_get_string(fields, "screenname");

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

if (GPOINTER_TO_INT(purple_request_fields_get_choice(fields, "block")) == 1) {

purple_account_privacy_deny(account, name);

} else {

purple_account_privacy_allow(account, name);

}

static void

block_select(GntMenuItem *item, gpointer n)

{

PurpleRequestFields *fields;

PurpleRequestFieldGroup *group;

PurpleRequestField *field;

fields = purple_request_fields_new();

group = purple_request_field_group_new(NULL);

purple_request_fields_add_group(fields, group);

field = purple_request_field_string_new("screenname", _("Name"), NULL, FALSE);

purple_request_field_set_type_hint(field, "screenname");

purple_request_field_set_required(field, TRUE);

purple_request_field_group_add_field(group, field);

field = purple_request_field_account_new("account", _("Account"), NULL);

purple_request_field_set_type_hint(field, "account");

purple_request_field_set_visible(field,

(purple_connections_get_all() != NULL &&

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

purple_request_field_set_required(field, TRUE);

purple_request_field_group_add_field(group, field);

field = purple_request_field_choice_new("block", _("Block/Unblock"), GINT_TO_POINTER(1));

purple_request_field_choice_add(field, _("Block"), GINT_TO_POINTER(1));

purple_request_field_choice_add(field, _("Unblock"), GINT_TO_POINTER(2));

purple_request_field_group_add_field(group, field);

purple_request_fields(

purple_blist_get_default(), _("Block/Unblock"), NULL,

_("Please enter the username or alias of the person "

"you would like to Block/Unblock."),

fields, _("OK"), G_CALLBACK(block_select_cb), _("Cancel"), NULL,

NULL, NULL);

}

/* send_im_select* -- Xerox */

static void

send_im_select_cb(gpointer data, PurpleRequestFields *fields)

{

PurpleAccount *account;

const char *username;

PurpleIMConversation *im;

account = purple_request_fields_get_account(fields, "account");

username = purple_request_fields_get_string(fields, "screenname");

im = purple_im_conversation_new(account, username);

purple_conversation_present(PURPLE_CONVERSATION(im));

}

static void

send_im_select(GntMenuItem *item, gpointer n)

{

PurpleRequestFields *fields;

PurpleRequestFieldGroup *group;

PurpleRequestField *field;

fields = purple_request_fields_new();

group = purple_request_field_group_new(NULL);

purple_request_fields_add_group(fields, group);

field = purple_request_field_string_new("screenname", _("Name"), NULL, FALSE);

purple_request_field_set_type_hint(field, "screenname");

purple_request_field_set_required(field, TRUE);

purple_request_field_group_add_field(group, field);

field = purple_request_field_account_new("account", _("Account"), NULL);

purple_request_field_set_type_hint(field, "account");

purple_request_field_set_visible(field,

(purple_connections_get_all() != NULL &&

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

purple_request_field_set_required(field, TRUE);

purple_request_field_group_add_field(group, field);

purple_request_fields(

purple_blist_get_default(), _("New Instant Message"), NULL,

_("Please enter the username or alias of the person "

"you would like to IM."),

fields, _("OK"), G_CALLBACK(send_im_select_cb), _("Cancel"),

NULL, NULL, NULL);

}

static void

join_chat_select_cb(gpointer data, PurpleRequestFields *fields)

{

PurpleAccount *account;

const char *name;

PurpleConnection *gc;

PurpleChat *chat;

GHashTable *hash = NULL;

PurpleChatConversation *conv;

account = purple_request_fields_get_account(fields, "account");

name = purple_request_fields_get_string(fields, "chat");

if (!purple_account_is_connected(account))

return;

gc = purple_account_get_connection(account);

/* Create a new conversation now. This will give focus to the new window.

* But it's necessary to pretend that we left the chat, because otherwise

* a new conversation window will pop up when we finally join the chat. */

if (!(conv = purple_conversations_find_chat_with_account(name, account))) {

conv = purple_chat_conversation_new(account, name);

purple_chat_conversation_leave(conv);

} else {

purple_conversation_present(PURPLE_CONVERSATION(conv));

}

chat = purple_blist_find_chat(account, name);

if (chat == NULL) {

PurpleProtocol *protocol = purple_connection_get_protocol(gc);

hash = purple_protocol_chat_iface_info_defaults(protocol, gc, name);

} else {

hash = purple_chat_get_components(chat);

}

purple_serv_join_chat(gc, hash);

if (chat == NULL && hash != NULL)

g_hash_table_destroy(hash);

}

static void

join_chat_select(GntMenuItem *item, gpointer n)

{

PurpleRequestFields *fields;

PurpleRequestFieldGroup *group;

PurpleRequestField *field;

fields = purple_request_fields_new();

group = purple_request_field_group_new(NULL);

purple_request_fields_add_group(fields, group);

field = purple_request_field_string_new("chat", _("Channel"), NULL, FALSE);

purple_request_field_set_required(field, TRUE);

purple_request_field_group_add_field(group, field);

field = purple_request_field_account_new("account", _("Account"), NULL);

purple_request_field_set_type_hint(field, "account");

purple_request_field_set_visible(field,

(purple_connections_get_all() != NULL &&

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

purple_request_field_set_required(field, TRUE);

purple_request_field_group_add_field(group, field);

purple_request_fields(

purple_blist_get_default(), _("Join a Chat"), NULL,

_("Please enter the name of the chat you want to join."),

fields, _("Join"), G_CALLBACK(join_chat_select_cb), _("Cancel"),

NULL, NULL, NULL);

}

static void

view_log_select_cb(gpointer data, PurpleRequestFields *fields)

{

PurpleAccount *account;

const char *name;

PurpleBuddy *buddy;

PurpleContact *contact;

account = purple_request_fields_get_account(fields, "account");

name = purple_request_fields_get_string(fields, "screenname");

buddy = purple_blist_find_buddy(account, name);

if (buddy) {

contact = purple_buddy_get_contact(buddy);

} else {

contact = NULL;

}

if (contact) {

finch_log_show_contact(contact);

} else {

finch_log_show(PURPLE_LOG_IM, name, account);

}

static void

view_log_cb(GntMenuItem *item, gpointer n)

{

PurpleRequestFields *fields;

PurpleRequestFieldGroup *group;

PurpleRequestField *field;

fields = purple_request_fields_new();

group = purple_request_field_group_new(NULL);

purple_request_fields_add_group(fields, group);

field = purple_request_field_string_new("screenname", _("Name"), NULL, FALSE);

purple_request_field_set_type_hint(field, "screenname-all");

purple_request_field_set_required(field, TRUE);

purple_request_field_group_add_field(group, field);

field = purple_request_field_account_new("account", _("Account"), NULL);

purple_request_field_set_type_hint(field, "account");

purple_request_field_set_visible(field,

(purple_accounts_get_all() != NULL &&

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

purple_request_field_set_required(field, TRUE);

purple_request_field_group_add_field(group, field);

purple_request_field_account_set_show_all(field, TRUE);

purple_request_fields(

purple_blist_get_default(), _("View Log"), NULL,

_("Please enter the username or alias of the person "

"whose log you would like to view."),

fields, _("OK"), G_CALLBACK(view_log_select_cb), _("Cancel"),

NULL, NULL, NULL);

}

static void

view_all_logs_cb(GntMenuItem *item, gpointer n)

{

finch_log_show(PURPLE_LOG_IM, NULL, NULL);

}

static void

menu_add_buddy_cb(GntMenuItem *item, gpointer null)

{

purple_blist_request_add_buddy(NULL, NULL, NULL, NULL);

}

static void

menu_add_chat_cb(GntMenuItem *item, gpointer null)

{

purple_blist_request_add_chat(NULL, NULL, NULL, NULL);

}

static void

menu_add_group_cb(GntMenuItem *item, gpointer null)

{

purple_blist_request_add_group();

}

static void

menu_group_set_cb(GntMenuItem *item, gpointer null)

{

const char *id = g_object_get_data(G_OBJECT(item), "grouping-id");

purple_prefs_set_string(PREF_ROOT "/grouping", id);

}

static void

create_menu(void)

{

GntWidget *menu, *sub, *subsub;

GntMenuItem *item;

GntWindow *window;

if (!ggblist)

return;

window = GNT_WINDOW(ggblist->window);

ggblist->menu = menu = gnt_menu_new(GNT_MENU_TOPLEVEL);

gnt_window_set_menu(window, GNT_MENU(menu));

item = gnt_menuitem_new(_("Options"));

gnt_menu_add_item(GNT_MENU(menu), item);

sub = gnt_menu_new(GNT_MENU_POPUP);

gnt_menuitem_set_submenu(item, GNT_MENU(sub));

item = gnt_menuitem_new(_("Send IM..."));

gnt_menuitem_set_id(GNT_MENU_ITEM(item), "send-im");

gnt_menu_add_item(GNT_MENU(sub), item);

gnt_menuitem_set_callback(GNT_MENU_ITEM(item), send_im_select, NULL);

item = gnt_menuitem_new(_("Block/Unblock..."));

gnt_menuitem_set_id(GNT_MENU_ITEM(item), "block-unblock");

gnt_menu_add_item(GNT_MENU(sub), item);

gnt_menuitem_set_callback(GNT_MENU_ITEM(item), block_select, NULL);

item = gnt_menuitem_new(_("Join Chat..."));

gnt_menuitem_set_id(GNT_MENU_ITEM(item), "join-chat");

gnt_menu_add_item(GNT_MENU(sub), item);

gnt_menuitem_set_callback(GNT_MENU_ITEM(item), join_chat_select, NULL);

item = gnt_menuitem_new(_("View Log..."));

gnt_menuitem_set_id(GNT_MENU_ITEM(item), "view-log");

gnt_menu_add_item(GNT_MENU(sub), item);

gnt_menuitem_set_callback(GNT_MENU_ITEM(item), view_log_cb, NULL);

item = gnt_menuitem_new(_("View All Logs"));

gnt_menuitem_set_id(GNT_MENU_ITEM(item), "view-all-logs");

gnt_menu_add_item(GNT_MENU(sub), item);

gnt_menuitem_set_callback(GNT_MENU_ITEM(item), view_all_logs_cb, NULL);

item = gnt_menuitem_new(_("Show"));

gnt_menu_add_item(GNT_MENU(sub), item);

subsub = gnt_menu_new(GNT_MENU_POPUP);

gnt_menuitem_set_submenu(item, GNT_MENU(subsub));

item = gnt_menuitem_check_new(_("Empty groups"));

gnt_menuitem_set_id(GNT_MENU_ITEM(item), "show-empty-groups");

gnt_menuitem_check_set_checked(GNT_MENU_ITEM_CHECK(item),

purple_prefs_get_bool(PREF_ROOT "/emptygroups"));

gnt_menu_add_item(GNT_MENU(subsub), item);

gnt_menuitem_set_callback(GNT_MENU_ITEM(item), toggle_pref_cb, PREF_ROOT "/emptygroups");

item = gnt_menuitem_check_new(_("Offline buddies"));

gnt_menuitem_set_id(GNT_MENU_ITEM(item), "show-offline-buddies");

gnt_menuitem_check_set_checked(GNT_MENU_ITEM_CHECK(item),

purple_prefs_get_bool(PREF_ROOT "/showoffline"));

gnt_menu_add_item(GNT_MENU(subsub), item);

gnt_menuitem_set_callback(GNT_MENU_ITEM(item), toggle_pref_cb, PREF_ROOT "/showoffline");

item = gnt_menuitem_new(_("Sort"));

gnt_menu_add_item(GNT_MENU(sub), item);

subsub = gnt_menu_new(GNT_MENU_POPUP);

gnt_menuitem_set_submenu(item, GNT_MENU(subsub));

item = gnt_menuitem_new(_("By Status"));

gnt_menuitem_set_id(GNT_MENU_ITEM(item), "sort-status");

gnt_menu_add_item(GNT_MENU(subsub), item);

gnt_menuitem_set_callback(GNT_MENU_ITEM(item), sort_blist_change_cb, "status");

item = gnt_menuitem_new(_("Alphabetically"));

gnt_menuitem_set_id(GNT_MENU_ITEM(item), "sort-alpha");

gnt_menu_add_item(GNT_MENU(subsub), item);

gnt_menuitem_set_callback(GNT_MENU_ITEM(item), sort_blist_change_cb, "text");

item = gnt_menuitem_new(_("By Log Size"));

gnt_menuitem_set_id(GNT_MENU_ITEM(item), "sort-log");

gnt_menu_add_item(GNT_MENU(subsub), item);

gnt_menuitem_set_callback(GNT_MENU_ITEM(item), sort_blist_change_cb, "log");

item = gnt_menuitem_new(_("Add"));

gnt_menu_add_item(GNT_MENU(sub), item);

subsub = gnt_menu_new(GNT_MENU_POPUP);

gnt_menuitem_set_submenu(item, GNT_MENU(subsub));

item = gnt_menuitem_new(_("Buddy"));

gnt_menuitem_set_id(GNT_MENU_ITEM(item), "add-buddy");

gnt_menu_add_item(GNT_MENU(subsub), item);

gnt_menuitem_set_callback(item, menu_add_buddy_cb, NULL);

item = gnt_menuitem_new(_("Chat"));

gnt_menuitem_set_id(GNT_MENU_ITEM(item), "add-chat");

gnt_menu_add_item(GNT_MENU(subsub), item);

gnt_menuitem_set_callback(item, menu_add_chat_cb, NULL);

item = gnt_menuitem_new(_("Group"));

gnt_menuitem_set_id(GNT_MENU_ITEM(item), "add-group");

gnt_menu_add_item(GNT_MENU(subsub), item);

gnt_menuitem_set_callback(item, menu_add_group_cb, NULL);

ggblist->grouping = item = gnt_menuitem_new(_("Grouping"));

gnt_menu_add_item(GNT_MENU(sub), item);

reconstruct_grouping_menu();

reconstruct_accounts_menu();

gnt_menu_add_item(GNT_MENU(menu), ggblist->accounts);

reconstruct_plugins_menu();

gnt_menu_add_item(GNT_MENU(menu), ggblist->plugins);

}

void finch_blist_show()

{

blist_show(purple_blist_get_default());

}

static void

group_collapsed(GntWidget *widget, PurpleBlistNode *node, gboolean collapsed, gpointer null)

{

if (PURPLE_IS_GROUP(node))

purple_blist_node_set_bool(node, "collapsed", collapsed);

}

static void

blist_show(PurpleBuddyList *list)

{

if (ggblist->window) {

gnt_window_present(ggblist->window);

return;

}

ggblist->window = gnt_vwindow_new(FALSE);

gnt_widget_set_name(ggblist->window, "buddylist");

gnt_box_set_toplevel(GNT_BOX(ggblist->window), TRUE);

gnt_box_set_title(GNT_BOX(ggblist->window), _("Buddy List"));

gnt_box_set_pad(GNT_BOX(ggblist->window), 0);

ggblist->tree = gnt_tree_new();

gnt_widget_set_has_border(ggblist->tree, FALSE);

gnt_widget_set_size(ggblist->tree, purple_prefs_get_int(PREF_ROOT "/size/width"),

purple_prefs_get_int(PREF_ROOT "/size/height"));

gnt_widget_set_position(ggblist->window, purple_prefs_get_int(PREF_ROOT "/position/x"),

purple_prefs_get_int(PREF_ROOT "/position/y"));

gnt_box_add_widget(GNT_BOX(ggblist->window), ggblist->tree);

ggblist->status = gnt_combo_box_new();

gnt_box_add_widget(GNT_BOX(ggblist->window), ggblist->status);

ggblist->statustext = gnt_entry_new(NULL);

gnt_box_add_widget(GNT_BOX(ggblist->window), ggblist->statustext);

gnt_widget_show(ggblist->window);

purple_signal_connect(purple_connections_get_handle(), "signed-on", finch_blist_get_handle(),

PURPLE_CALLBACK(reconstruct_accounts_menu), NULL);

purple_signal_connect(purple_connections_get_handle(), "signed-off", finch_blist_get_handle(),

PURPLE_CALLBACK(reconstruct_accounts_menu), NULL);

purple_signal_connect(purple_accounts_get_handle(), "account-actions-changed", finch_blist_get_handle(),

PURPLE_CALLBACK(reconstruct_accounts_menu), NULL);

purple_signal_connect(purple_blist_get_handle(), "buddy-status-changed", finch_blist_get_handle(),

PURPLE_CALLBACK(buddy_status_changed), ggblist);

purple_signal_connect(purple_blist_get_handle(), "buddy-idle-changed", finch_blist_get_handle(),

PURPLE_CALLBACK(buddy_idle_changed), ggblist);

purple_signal_connect(purple_plugins_get_handle(), "plugin-load", finch_blist_get_handle(),

PURPLE_CALLBACK(reconstruct_plugins_menu), NULL);

purple_signal_connect(purple_plugins_get_handle(), "plugin-unload", finch_blist_get_handle(),

PURPLE_CALLBACK(reconstruct_plugins_menu), NULL);

purple_signal_connect(purple_blist_get_handle(), "buddy-signed-on", finch_blist_get_handle(),

PURPLE_CALLBACK(buddy_signed_on_off), ggblist);

purple_signal_connect(purple_blist_get_handle(), "buddy-signed-off", finch_blist_get_handle(),

PURPLE_CALLBACK(buddy_signed_on_off), ggblist);

g_signal_connect(G_OBJECT(ggblist->tree), "selection_changed", G_CALLBACK(selection_changed), ggblist);

g_signal_connect(G_OBJECT(ggblist->tree), "key_pressed", G_CALLBACK(key_pressed), ggblist);

g_signal_connect(G_OBJECT(ggblist->tree), "context-menu", G_CALLBACK(context_menu), ggblist);

g_signal_connect(G_OBJECT(ggblist->tree), "collapse-toggled", G_CALLBACK(group_collapsed), NULL);

g_signal_connect(G_OBJECT(ggblist->tree), "activate", G_CALLBACK(selection_activate), ggblist);

g_signal_connect_data(G_OBJECT(ggblist->tree), "gained-focus", G_CALLBACK(draw_tooltip),

ggblist, 0, G_CONNECT_AFTER | G_CONNECT_SWAPPED);

g_signal_connect_data(G_OBJECT(ggblist->tree), "lost-focus", G_CALLBACK(remove_peripherals),

ggblist, 0, G_CONNECT_AFTER | G_CONNECT_SWAPPED);

g_signal_connect_data(G_OBJECT(ggblist->window), "workspace-hidden", G_CALLBACK(remove_peripherals),

ggblist, 0, G_CONNECT_AFTER | G_CONNECT_SWAPPED);

g_signal_connect(G_OBJECT(ggblist->tree), "size_changed", G_CALLBACK(size_changed_cb), NULL);

g_signal_connect(G_OBJECT(ggblist->window), "position_set", G_CALLBACK(save_position_cb), NULL);

g_signal_connect(G_OBJECT(ggblist->window), "destroy", G_CALLBACK(reset_blist_window), NULL);

/* Status signals */

purple_signal_connect(purple_savedstatuses_get_handle(), "savedstatus-changed", finch_blist_get_handle(),

PURPLE_CALLBACK(savedstatus_changed), NULL);

g_signal_connect(G_OBJECT(ggblist->status), "selection_changed",

G_CALLBACK(status_selection_changed), NULL);

g_signal_connect(G_OBJECT(ggblist->statustext), "key_pressed",

G_CALLBACK(status_text_changed), NULL);

create_menu();

populate_buddylist();

savedstatus_changed(purple_savedstatus_get_current(), NULL);

}

void finch_blist_uninit()

{

}

gboolean finch_blist_get_position(int *x, int *y)

{

if (!ggblist || !ggblist->window)

return FALSE;

gnt_widget_get_position(ggblist->window, x, y);

return TRUE;

}

void finch_blist_set_position(int x, int y)

{

gnt_widget_set_position(ggblist->window, x, y);

}

gboolean finch_blist_get_size(int *width, int *height)

{

if (!ggblist || !ggblist->window)

return FALSE;

gnt_widget_get_size(ggblist->window, width, height);

return TRUE;

}

void finch_blist_set_size(int width, int height)

{

gnt_widget_set_size(ggblist->window, width, height);

}

void finch_blist_install_manager(const FinchBlistManager *manager)

{

if (!g_list_find(managers, manager)) {

managers = g_list_append(managers, (gpointer)manager);

reconstruct_grouping_menu();

if (purple_strequal(manager->id, purple_prefs_get_string(PREF_ROOT "/grouping")))

purple_prefs_trigger_callback(PREF_ROOT "/grouping");

}

void finch_blist_uninstall_manager(const FinchBlistManager *manager)

{

if (g_list_find(managers, manager)) {

managers = g_list_remove(managers, manager);

reconstruct_grouping_menu();

if (purple_strequal(manager->id, purple_prefs_get_string(PREF_ROOT "/grouping")))

purple_prefs_trigger_callback(PREF_ROOT "/grouping");

}

FinchBlistManager * finch_blist_manager_find(const char *id)

{

GList *iter = managers;

if (!id)

return NULL;

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

FinchBlistManager *m = iter->data;

if (purple_strequal(id, m->id))

return m;

}

return NULL;

}

GntTree * finch_blist_get_tree(void)

{

return ggblist ? GNT_TREE(ggblist->tree) : NULL;

}

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

* GObject code

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

G_DEFINE_TYPE(FinchBuddyList, finch_buddy_list, PURPLE_TYPE_BUDDY_LIST)

static void

finch_buddy_list_init(FinchBuddyList *self)

{

if (!ggblist) {

/* The first buddy list object becomes the default. */

ggblist = self;

}

self->manager = finch_blist_manager_find(

purple_prefs_get_string(PREF_ROOT "/grouping"));

if (!self->manager) {

self->manager = &default_manager;

}

static void

finch_buddy_list_finalize(GObject *obj)

{

FinchBuddyList *ggblist = FINCH_BUDDY_LIST(obj);

gnt_widget_destroy(ggblist->window);

G_OBJECT_CLASS(finch_buddy_list_parent_class)->finalize(obj);

}

static void

finch_buddy_list_class_init(FinchBuddyListClass *klass)

{

GObjectClass *obj_class = G_OBJECT_CLASS(klass);

PurpleBuddyListClass *purple_blist_class;

obj_class->finalize = finch_buddy_list_finalize;

purple_blist_class = PURPLE_BUDDY_LIST_CLASS(klass);

purple_blist_class->new_node = new_node;

purple_blist_class->show = blist_show;

purple_blist_class->update = node_update;

purple_blist_class->remove = node_remove;

purple_blist_class->request_add_buddy = finch_request_add_buddy;

purple_blist_class->request_add_chat = finch_request_add_chat;

purple_blist_class->request_add_group = finch_request_add_group;

}

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

* GBoxed code

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

static FinchBlistManager *

finch_blist_manager_copy(FinchBlistManager *manager)

{

FinchBlistManager *manager_new;

g_return_val_if_fail(manager != NULL, NULL);

manager_new = g_new(FinchBlistManager, 1);

*manager_new = *manager;

return manager_new;

}

static void

finch_blist_manager_free(FinchBlistManager *manager)

{

g_return_if_fail(manager != NULL);

g_free(manager);

}

GType

finch_blist_manager_get_type(void)

{

static GType type = 0;

if (type == 0) {

type = g_boxed_type_register_static("FinchBlistManager",

(GBoxedCopyFunc)finch_blist_manager_copy,

(GBoxedFreeFunc)finch_blist_manager_free);

}

return type;

}

pidgin/pidgin