bool BuddyListGroup::lessOrEqual(const BuddyListNode& other) const
{
/* If the groups aren't sorted but ordered manually then this method isn't
* used. */
const BuddyListGroup *o = dynamic_cast<const BuddyListGroup*>(&other);
if (o)
return g_utf8_collate(purple_group_get_name(group),
purple_group_get_name(o->group)) <= 0;
return lessOrEqualByType(other);
}
static void
extended_menu_cb(PurpleBlistNode *node, GList **menu, gpointer data)
{
GList *submenu = NULL, *submenu_1 = NULL, *submenu_2 = NULL;
PurpleMenuAction *action = NULL;
PurpleBlistNode *group;
PurpleMenuAction *action_submenu = NULL, *action_submenu_1 = NULL, *action_submenu_2 = NULL;
const gchar *group_name = NULL;
if (!PURPLE_IS_BUDDY(node))
return;
for (group = purple_blist_get_root(); group; group = purple_blist_node_get_sibling_next(group)) {
if (!PURPLE_IS_GROUP(group))
continue;
group_name = purple_group_get_name((PurpleGroup *)group);
action_submenu_1 = purple_menu_action_new(group_name,
PURPLE_CALLBACK(send_buddy_list_cb),
group, NULL);
submenu_1 = g_list_append (submenu_1, action_submenu_1);
}
for (group = purple_blist_get_root(); group; group = purple_blist_node_get_sibling_next(group)) {
if (!PURPLE_IS_GROUP(group))
continue;
group_name = purple_group_get_name((PurpleGroup *)group);
action_submenu_2 = purple_menu_action_new(group_name,
PURPLE_CALLBACK(send_online_buddy_cb),
group, NULL);
submenu_2 = g_list_append (submenu_2, action_submenu_2);
}
action_submenu = purple_menu_action_new(_("Group list"),
PURPLE_CALLBACK(send_group_list_cb), NULL, NULL);
submenu = g_list_append (submenu, action_submenu);
action_submenu = purple_menu_action_new(_("Buddy List for"),
NULL, NULL, submenu_1);
submenu = g_list_append (submenu, action_submenu);
action_submenu = purple_menu_action_new(_("Online Buddies for"),
NULL, NULL, submenu_2);
submenu = g_list_append (submenu, action_submenu);
action = purple_menu_action_new(_("Send"),
NULL, NULL, submenu);
*menu = g_list_append (*menu, action);
}
BuddyListGroup::GroupContextMenu::GroupContextMenu(
BuddyListGroup& parent_group_)
: ContextMenu(parent_group_), parent_group(&parent_group_)
{
appendExtendedMenu();
appendItem(_("Rename..."), sigc::mem_fun(this,
&GroupContextMenu::onRename));
appendItem(_("Delete..."), sigc::mem_fun(this,
&GroupContextMenu::onRemove));
if (BUDDYLIST->getGroupSortMode() == BuddyList::GROUP_SORT_BY_USER) {
/* If the manual sorting is enabled then show a menu item and a submenu
* for group moving. */
CppConsUI::MenuWindow *groups = new CppConsUI::MenuWindow(*this, AUTOSIZE,
AUTOSIZE);
groups->appendItem(_("-Top-"), sigc::bind(
sigc::mem_fun(this, &GroupContextMenu::onMoveAfter),
static_cast<PurpleGroup*>(NULL)));
for (PurpleBlistNode *node = purple_blist_get_root(); node;
node = purple_blist_node_get_sibling_next(node)) {
if (!PURPLE_BLIST_NODE_IS_GROUP(node))
continue;
PurpleGroup *group = PURPLE_GROUP(node);
groups->appendItem(purple_group_get_name(group), sigc::bind(
sigc::mem_fun(this, &GroupContextMenu::onMoveAfter), group));
}
appendSubMenu(_("Move after..."), *groups);
}
}
static GntWidget*
create_string_field(PurpleRequestField *field, GntWidget **screenname)
{
const char *hint = purple_request_field_get_type_hint(field);
GntWidget *entry = gnt_entry_new(
purple_request_field_string_get_default_value(field));
gnt_entry_set_masked(GNT_ENTRY(entry),
purple_request_field_string_is_masked(field));
if (hint && purple_str_has_prefix(hint, "screenname")) {
PurpleBlistNode *node = purple_blist_get_root();
gboolean offline = purple_str_has_suffix(hint, "all");
for (; node; node = purple_blist_node_next(node, offline)) {
if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
continue;
gnt_entry_add_suggest(GNT_ENTRY(entry), purple_buddy_get_name((PurpleBuddy*)node));
}
gnt_entry_set_always_suggest(GNT_ENTRY(entry), TRUE);
if (screenname)
*screenname = entry;
} else if (hint && !strcmp(hint, "group")) {
PurpleBlistNode *node;
for (node = purple_blist_get_root(); node;
node = purple_blist_node_get_sibling_next(node)) {
if (PURPLE_BLIST_NODE_IS_GROUP(node))
gnt_entry_add_suggest(GNT_ENTRY(entry), purple_group_get_name((PurpleGroup *)node));
}
}
return entry;
}
/* create purple buddy without data and display with no-auth icon */
PurpleBuddy * qq_buddy_new( PurpleConnection *gc, guint32 uid, PurpleGroup * group )
{
PurpleBuddy *buddy;
gchar *who;
gchar * group_name;
g_return_val_if_fail(gc->account != NULL && uid != 0, NULL);
/* deprecated when fix qq_process_add_buddy_touch */
if (!group)
{
group_name = g_strdup_printf(PURPLE_GROUP_QQ_FORMAT,
purple_account_get_username(gc->account));
group = qq_group_find_or_new(group_name);
g_free(group_name);
if (group == NULL) {
purple_debug_error("QQ", "Failed creating group\n");
return NULL;
}
}
group_name = purple_group_get_name(group);
purple_debug_info("QQ", "Add new purple buddy: [%u], at Group [%s]\n", uid, group_name);
who = uid_to_purple_name(uid);
buddy = purple_buddy_new(gc->account, who, NULL); /* alias is NULL */
purple_buddy_set_protocol_data(buddy, NULL);
g_free(who);
purple_blist_add_buddy(buddy, NULL, group, NULL);
return buddy;
}
/* char *ggp_buddylist_dump(PurpleAccount *account) {{{ */
char *ggp_buddylist_dump(PurpleAccount *account)
{
GSList *buddies;
GString *buddylist = g_string_sized_new(1024);
char *ptr;
for (buddies = purple_blist_find_buddies(account, NULL); buddies;
buddies = g_slist_delete_link(buddies, buddies))
{
PurpleBuddy *buddy = buddies->data;
PurpleGroup *group = purple_buddy_get_group(buddy);
const char *bname = purple_buddy_get_name(buddy);
const char *gname = purple_group_get_name(group);
const char *alias = purple_buddy_get_alias(buddy);
if (alias == NULL)
alias = bname;
g_string_append_printf(buddylist,
"%s;%s;%s;%s;%s;%s;%s;%s%s\r\n",
alias, alias, alias, alias,
"", gname, bname, "", "");
}
ptr = ggp_convert_to_cp1250(buddylist->str);
g_string_free(buddylist, TRUE);
return ptr;
}
void jabber_roster_group_change(PurpleConnection *gc, const char *name,
const char *old_group, const char *new_group)
{
GSList *buddies, *groups = NULL;
PurpleBuddy *b;
PurpleGroup *g;
const char *gname;
if(!old_group || !new_group || !strcmp(old_group, new_group))
return;
buddies = purple_find_buddies(gc->account, name);
while(buddies) {
b = buddies->data;
g = purple_buddy_get_group(b);
gname = purple_group_get_name(g);
if(!strcmp(gname, old_group))
groups = g_slist_append(groups, (char*)new_group); /* ick */
else
groups = g_slist_append(groups, (char*)gname);
buddies = g_slist_remove(buddies, b);
}
purple_debug_info("jabber", "jabber_roster_group_change(): Moving %s from %s to %s\n",
name, old_group, new_group);
jabber_roster_update(gc->proto_data, name, groups);
}
void fb_buddy_remove(PurpleConnection *pc, PurpleBuddy *buddy,
PurpleGroup *group)
{
// This method should only remove a buddy from a friend list.
// Nothing more. It should not defriend a user ever. See issue
// #185 for a good explaination of why this is a bad idea.
//
// Moreover, defriending is such a rare operation that we should
// never make it easy. Facebook intentionally hides such a action
// behind multiple layers of links and dialogs.
//
// If the plugin is ever to perform an actual defriending, it needs
// to provide a dialog and user prompt at the absolute bare minimum.
FacebookAccount *fba;
if (!purple_account_get_bool(pc->account, "facebook_use_groups", TRUE))
{
//Dont do anything if we're ignoring groups
return;
}
purple_debug_info("facebook", "handing removal of buddy %s\n",
buddy->name);
fba = pc->proto_data;
fb_group_buddy_move(pc, buddy->name, purple_group_get_name(group),
DEFAULT_GROUP_NAME);
}
void fb_group_rename(PurpleConnection *pc, const char *old_name,
PurpleGroup *group, GList *moved_buddies)
{
if (!purple_account_get_bool(pc->account, "facebook_use_groups", TRUE))
{
//Dont do anything if we're ignoring groups
return;
}
purple_debug_info("facebook",
"handling group rename of %s to %s\n",
old_name, purple_group_get_name(group));
// We don't do anything here. Facebook's AJAX API for renaming groups
// is horribly, horribly overcomplicated. There is no simple rename
// call, instead you must also pass in all the current data about the
// friend list and port it over. While it is possible to implement
// this, it is risky and could potentially destroy a friend list if
// the API changes. That's a Bad Thing(tm). Given the risk involved
// with this operation and how rare it is, it's not worth it.
//
// The problem is compounded by the fact that renaming groups triggers
// all sorts of weird behaviors in Pidgin. Renaming to a new name is
// simple. Renaming to an existing group name (hence a merge)
// triggers completely different behavior with calls to group_buddy
// before the call to rename. This completely defeats the purpose of
// having a rename function because group_buddy is called instead.
//
// Thus, the final decision is to use the buddy_move call.
// TODO: warn users that renaming has no effect here.
}
static void prplcb_blist_update( PurpleBuddyList *list, PurpleBlistNode *node )
{
if( node->type == PURPLE_BLIST_BUDDY_NODE )
{
PurpleBuddy *bud = (PurpleBuddy*) node;
PurpleGroup *group = purple_buddy_get_group( bud );
struct im_connection *ic = purple_ic_by_pa( bud->account );
PurpleStatus *as;
int flags = 0;
if( ic == NULL )
return;
if( bud->server_alias )
imcb_rename_buddy( ic, bud->name, bud->server_alias );
else if( bud->alias )
imcb_rename_buddy( ic, bud->name, bud->alias );
if( group )
imcb_add_buddy( ic, bud->name, purple_group_get_name( group ) );
flags |= purple_presence_is_online( bud->presence ) ? OPT_LOGGED_IN : 0;
flags |= purple_presence_is_available( bud->presence ) ? 0 : OPT_AWAY;
as = purple_presence_get_active_status( bud->presence );
imcb_buddy_status( ic, bud->name, flags, purple_status_get_name( as ),
purple_status_get_attr_string( as, "message" ) );
imcb_buddy_times( ic, bud->name,
purple_presence_get_login_time( bud->presence ),
purple_presence_get_idle_time( bud->presence ) );
}
}
static void fx_remove_group(PurpleConnection *gc, PurpleGroup *group)
{
const gchar *name = purple_group_get_name(group);
fetion_account *ac = purple_connection_get_protocol_data(gc);
Group *blist = fetion_group_list_find_by_name(ac->user->groupList, name);
if(!blist) return;
fetion_buddylist_delete(ac, blist->groupid);
}
void BuddyListGroup::GroupContextMenu::onRename(Button& /*activator*/)
{
PurpleGroup *group = parent_group->getPurpleGroup();
CppConsUI::InputDialog *dialog = new CppConsUI::InputDialog(
_("Rename"), purple_group_get_name(group));
dialog->signal_response.connect(sigc::mem_fun(this,
&GroupContextMenu::renameResponseHandler));
dialog->show();
}
static void fx_rename_group(PurpleConnection *gc,
const gchar *old_name, PurpleGroup *group, GList *UNUSED(moved_buddies))
{
fetion_account *ac = purple_connection_get_protocol_data(gc);
Group *blist = fetion_group_list_find_by_name(ac->user->groupList, old_name);
const gchar *name = purple_group_get_name(group);
fetion_buddylist_edit(ac, blist->groupid, name);
}
void jabber_roster_group_rename(PurpleConnection *gc, const char *old_name,
PurpleGroup *group, GList *moved_buddies)
{
GList *l;
const char *gname = purple_group_get_name(group);
for(l = moved_buddies; l; l = l->next) {
PurpleBuddy *buddy = l->data;
jabber_roster_group_change(gc, purple_buddy_get_name(buddy), old_name, gname);
}
}
Data IMInvoker::buddyToData(PurpleBuddy *buddy) {
Data data;
std::string buddyName = purple_buddy_get_name(buddy);
if (purple_buddy_get_name(buddy)) data.compound["name"] = Data(purple_buddy_get_name(buddy), Data::VERBATIM);
if (purple_buddy_get_alias(buddy)) data.compound["alias"] = Data(purple_buddy_get_alias(buddy), Data::VERBATIM);
if (purple_buddy_get_alias_only(buddy)) data.compound["aliasOnly"] = Data(purple_buddy_get_alias_only(buddy), Data::VERBATIM);
if (purple_buddy_get_server_alias(buddy)) data.compound["server"] = Data(purple_buddy_get_server_alias(buddy), Data::VERBATIM);
PurpleGroup* group = purple_buddy_get_group(buddy);
if (group) {
if (purple_group_get_name(group)) data.compound["group"] = Data(purple_group_get_name(group), Data::VERBATIM);
}
PurpleBuddyIcon* icon = purple_buddy_get_icon(buddy);
if (icon) {
size_t iconSize = 0;
gconstpointer iconData = purple_buddy_icon_get_data(icon, &iconSize);
data.compound["icon"] = Data((char*)iconData, iconSize, "application/octet-stream", false);
}
PurplePresence* presence = purple_buddy_get_presence(buddy);
if (presence) {
GList *statusElem;
GList *statusList = purple_presence_get_statuses(presence);
PurpleStatus* status;
for(statusElem = statusList; statusElem; statusElem = statusElem->next) {
status = (PurpleStatus*)statusElem->data;
const char* statusId = purple_status_get_id(status);
PurpleStatusPrimitive statusPrimitive = purple_primitive_get_type_from_id(statusId);
// only include active states
if(statusPrimitive == PURPLE_STATUS_UNSET || !purple_presence_is_status_primitive_active(presence, statusPrimitive))
continue;
data.compound["status"].compound[statusId] = statusToData(status);
}
}
return data;
}
/* add a buddy and send packet to QQ server
* note that when purple load local cached buddy list into its blist
* it also calls this funtion, so we have to
* define qd->is_login=TRUE AFTER LOGIN */
void qq_add_buddy(PurpleConnection *gc, PurpleBuddy *buddy, PurpleGroup *group)
{
qq_data *qd;
gchar * group_name;
qq_buddy_opt_req *opt_req;
g_return_if_fail(NULL != gc && NULL != gc->proto_data);
g_return_if_fail(buddy != NULL);
qd = (qq_data *) gc->proto_data;
if (!qd->is_login)
return; /* IMPORTANT ! */
if (purple_buddy_get_protocol_data(buddy))
{
purple_notify_error(gc, _("QQ Buddy"), _("Add buddy"), _("Buddy exists"));
return;
}
/* free it in qq_request_add_buddy_touch */
opt_req = g_new0(qq_buddy_opt_req, 1);
opt_req->gc = gc;
opt_req->uid = purple_name_to_uid(purple_buddy_get_name(buddy));
if (group)
{
group_name = purple_group_get_name(group);
if (!group_name)
{
purple_notify_error(gc, _("QQ Buddy"), _("Add buddy"), _("Group not exists"));
goto free;
}
opt_req->group_id = group_name_to_id(gc, group_name);
if (opt_req->group_id == 0xFF)
{
purple_notify_error(gc, _("QQ Buddy"), _("Add buddy"), _("Chosen Group not associated with this account"));
goto free;
}
} else opt_req->group_id = 0;
if (opt_req->uid > 0) {
qq_request_add_buddy_touch(gc, opt_req);
return;
}
purple_notify_error(gc, _("QQ Buddy"), _("Add buddy"), _("Invalid QQ Number"));
free:
if (buddy == NULL)
return;
qq_buddy_free(buddy);
}
static void
msn_session_sync_users(MsnSession *session)
{
PurpleConnection *gc = purple_account_get_connection(session->account);
GList *to_remove = NULL;
GSList *buddies;
g_return_if_fail(gc != NULL);
/* The core used to use msn_add_buddy to add all buddies before
* being logged in. This no longer happens, so we manually iterate
* over the whole buddy list to identify sync issues.
*/
for (buddies = purple_blist_find_buddies(session->account, NULL); buddies;
buddies = g_slist_delete_link(buddies, buddies)) {
PurpleBuddy *buddy = buddies->data;
const gchar *buddy_name = purple_buddy_get_name(buddy);
const gchar *group_name = purple_group_get_name(purple_buddy_get_group(buddy));
MsnUser *remote_user;
gboolean found = FALSE;
remote_user = msn_userlist_find_user(session->userlist, buddy_name);
if (remote_user && remote_user->list_op & MSN_LIST_FL_OP) {
GList *l;
for (l = remote_user->group_ids; l; l = l->next) {
const char *name = msn_userlist_find_group_name(remote_user->userlist, l->data);
if (name && !g_ascii_strcasecmp(group_name, name)) {
found = TRUE;
break;
}
}
/* We don't care if they're in a different group, as long as they're on the
* list somewhere. If we check for the group, we cause pain, agony and
* suffering for people who decide to re-arrange their buddy list elsewhere.
*/
if (!found) {
if ((remote_user == NULL) || !(remote_user->list_op & MSN_LIST_FL_OP)) {
/* The user is not on the server list */
msn_error_sync_issue(session, buddy_name, group_name);
} else {
/* The user is not in that group on the server list */
to_remove = g_list_prepend(to_remove, buddy);
}
}
}
}
if (to_remove != NULL) {
g_list_foreach(to_remove, (GFunc)purple_blist_remove_buddy, NULL);
g_list_free(to_remove);
}
}
static const gchar * ggp_roster_send_update_group_add(
ggp_roster_content *content, PurpleGroup *group)
{
gchar *id_dyn;
const char *id_existing, *group_name;
static gchar id[40];
PurpleXmlNode *group_node;
gboolean succ = TRUE;
if (group) {
group_name = purple_group_get_name(group);
id_existing =
g_hash_table_lookup(content->group_ids, group_name);
} else
id_existing = GGP_ROSTER_GROUPID_DEFAULT;
if (id_existing)
return id_existing;
purple_debug_info("gg", "ggp_roster_send_update_group_add: adding %s\n",
purple_group_get_name(group));
id_dyn = purple_uuid_random();
g_snprintf(id, sizeof(id), "%s", id_dyn);
g_free(id_dyn);
group_node = purple_xmlnode_new_child(content->groups_node, "Group");
succ &= ggp_xml_set_string(group_node, "Id", id);
succ &= ggp_xml_set_string(group_node, "Name", group_name);
succ &= ggp_xml_set_string(group_node, "IsExpanded", "true");
succ &= ggp_xml_set_string(group_node, "IsRemovable", "true");
content->needs_update = TRUE;
g_hash_table_insert(content->group_ids, g_strdup(group_name),
g_strdup(id));
g_hash_table_insert(content->group_nodes, g_strdup(id), group_node);
g_return_val_if_fail(succ, NULL);
return id;
}
void BuddyListGroup::GroupContextMenu::onRemove(Button& /*activator*/)
{
PurpleGroup *group = parent_group->getPurpleGroup();
char *msg = g_strdup_printf(
_("Are you sure you want to delete group %s from the list?"),
purple_group_get_name(group));
CppConsUI::MessageDialog *dialog
= new CppConsUI::MessageDialog(_("Group deletion"), msg);
g_free(msg);
dialog->signal_response.connect(sigc::mem_fun(this,
&GroupContextMenu::removeResponseHandler));
dialog->show();
}
void jabber_roster_remove_buddy(PurpleConnection *gc, PurpleBuddy *buddy,
PurpleGroup *group) {
const char *name = purple_buddy_get_name(buddy);
GSList *buddies = purple_find_buddies(purple_connection_get_account(gc), name);
buddies = g_slist_remove(buddies, buddy);
if(buddies != NULL) {
PurpleBuddy *tmpbuddy;
PurpleGroup *tmpgroup;
GSList *groups = NULL;
while(buddies) {
tmpbuddy = buddies->data;
tmpgroup = purple_buddy_get_group(tmpbuddy);
groups = g_slist_append(groups, (char *)purple_group_get_name(tmpgroup));
buddies = g_slist_remove(buddies, tmpbuddy);
}
purple_debug_info("jabber", "jabber_roster_remove_buddy(): Removing %s from %s\n",
purple_buddy_get_name(buddy), purple_group_get_name(group));
jabber_roster_update(gc->proto_data, name, groups);
} else {
JabberIq *iq = jabber_iq_new_query(gc->proto_data, JABBER_IQ_SET,
"jabber:iq:roster");
xmlnode *query = xmlnode_get_child(iq->node, "query");
xmlnode *item = xmlnode_new_child(query, "item");
xmlnode_set_attrib(item, "jid", name);
xmlnode_set_attrib(item, "subscription", "remove");
purple_debug_info("jabber", "jabber_roster_remove_buddy(): Removing %s\n",
purple_buddy_get_name(buddy));
jabber_iq_send(iq);
}
}
void BuddyListGroup::update()
{
BuddyListNode::update();
setText(purple_group_get_name(group));
// sort in the group
BuddyList::GroupSortMode mode = BUDDYLIST->getGroupSortMode();
switch (mode) {
case BuddyList::GROUP_SORT_BY_USER:
{
/* Note that the sorting below works even if there was
* a contact/chat/buddy node that is attached at the root level of the
* blist treeview. This happens when such a node was just created (the
* new_node() callback was called) but the node doesn't have any
* parent yet. */
PurpleBlistNode *prev = purple_blist_node_get_sibling_prev(
blist_node);
if (prev) {
// it better be a group node
g_assert(PURPLE_BLIST_NODE_IS_GROUP(prev));
BuddyListNode *bnode = reinterpret_cast<BuddyListNode*>(
purple_blist_node_get_ui_data(prev));
// there has to be ui_data set for all group nodes!
g_assert(bnode);
treeview->moveNodeAfter(ref, bnode->getRefNode());
}
else {
// the group is the first one in the list
CppConsUI::TreeView::NodeReference parent_ref
= treeview->getRootNode();
treeview->moveNodeBefore(ref, parent_ref.begin());
}
}
break;
case BuddyList::GROUP_SORT_BY_NAME:
sortIn();
break;
}
bool vis = true;
if (!BUDDYLIST->getShowEmptyGroupsPref())
vis = purple_blist_get_group_size(group, FALSE);
setVisibility(vis);
}
void ggp_roster_rename_group(PurpleConnection *gc, const char *old_name,
PurpleGroup *group, GList *moved_buddies)
{
ggp_roster_session_data *rdata = ggp_roster_get_rdata(gc);
ggp_roster_change *change = g_new0(ggp_roster_change, 1);
if (!ggp_roster_enabled())
return;
change->type = GGP_ROSTER_CHANGE_GROUP_RENAME;
change->data.group_rename.old_name = g_strdup(old_name);
change->data.group_rename.new_name =
g_strdup(purple_group_get_name(group));
rdata->pending_updates = g_list_append(rdata->pending_updates, change);
}
static gboolean
nested_group_can_add_node(PurpleBlistNode *node)
{
PurpleBlistNode *group;
int len;
if (!PURPLE_IS_GROUP(node))
return default_manager->can_add_node(node);
if (default_manager->can_add_node(node))
return TRUE;
len = strlen(purple_group_get_name(PURPLE_GROUP(node)));
group = purple_blist_get_root();
for (; group; group = purple_blist_node_get_sibling_next(group)) {
if (group == node)
continue;
if (strncmp(purple_group_get_name(PURPLE_GROUP(node)),
purple_group_get_name(PURPLE_GROUP(group)), len) == 0 &&
default_manager->can_add_node(group))
return TRUE;
}
return FALSE;
}
void BuddyList::request_add_buddy(PurpleAccount *account,
const char *username, const char *group, const char *alias)
{
if (!CheckAnyAccountConnected())
return;
PurpleRequestFields *fields = purple_request_fields_new();
PurpleRequestFieldGroup *g = purple_request_field_group_new(NULL);
purple_request_fields_add_group(fields, g);
PurpleRequestField *f;
f = purple_request_field_account_new("account", _("Account"), account);
purple_request_field_group_add_field(g, f);
f = purple_request_field_string_new("name", _("Buddy name"), username,
FALSE);
purple_request_field_group_add_field(g, f);
f = purple_request_field_string_new("alias", _("Alias"), alias, FALSE);
purple_request_field_group_add_field(g, f);
f = purple_request_field_choice_new("group", _("Group"), 0);
bool add_default_group = true;
int dval = 0;
bool dval_set = false;
for (PurpleBlistNode *i = purple_blist_get_root(); i; i = i->next)
if (PURPLE_BLIST_NODE_IS_GROUP(i)) {
const char *cur_name = purple_group_get_name(
reinterpret_cast<PurpleGroup*>(i));
purple_request_field_choice_add(f, cur_name);
if (!dval_set) {
if (group && !strcmp(group, cur_name)) {
purple_request_field_choice_set_default_value(f, dval);
dval_set = true;
}
dval++;
}
add_default_group = false;
}
if (add_default_group)
purple_request_field_choice_add(f, _("Buddies"));
purple_request_field_group_add_field(g, f);
purple_request_fields(NULL, _("Add buddy"), NULL, NULL, fields, _("Add"),
G_CALLBACK(add_buddy_ok_cb_), CANCEL_BUTTON_TEXT, NULL, NULL, NULL,
NULL, this);
}
void fb_group_remove(PurpleConnection *pc, PurpleGroup *group)
{
if (!purple_account_get_bool(pc->account, "facebook_use_groups", TRUE))
{
//Dont do anything if we're ignoring groups
return;
}
purple_debug_info("facebook", "got group removal of %s\n",
purple_group_get_name(group));
// We don't do anything here. This is because a group rename also
// fires a group removal event. This assumes that the new group is
// equivalent to the old group, but Facebook friend lists are much more
// than simple groups- they are privacy control lists too. There is
// no easy way to port the settings between groups. Better off not
// deleting, and the user can do the cleanup with their browser.
}
void
oscar_user_info_append_extra_info(PurpleConnection *gc, PurpleNotifyUserInfo *user_info, PurpleBuddy *b, aim_userinfo_t *userinfo)
{
OscarData *od;
PurpleAccount *account;
PurplePresence *presence = NULL;
PurpleStatus *status = NULL;
PurpleGroup *g = NULL;
struct buddyinfo *bi = NULL;
char *tmp;
const char *bname = NULL, *gname = NULL;
od = purple_connection_get_protocol_data(gc);
account = purple_connection_get_account(gc);
if ((user_info == NULL) || ((b == NULL) && (userinfo == NULL)))
return;
if (userinfo == NULL)
userinfo = aim_locate_finduserinfo(od, purple_buddy_get_name(b));
if (b == NULL)
b = purple_find_buddy(account, userinfo->bn);
if (b != NULL) {
bname = purple_buddy_get_name(b);
g = purple_buddy_get_group(b);
gname = purple_group_get_name(g);
presence = purple_buddy_get_presence(b);
status = purple_presence_get_active_status(presence);
}
if (userinfo != NULL)
bi = g_hash_table_lookup(od->buddyinfo, purple_normalize(account, userinfo->bn));
if ((bi != NULL) && (bi->ipaddr != 0)) {
tmp = g_strdup_printf("%hhu.%hhu.%hhu.%hhu",
(bi->ipaddr & 0xff000000) >> 24,
(bi->ipaddr & 0x00ff0000) >> 16,
(bi->ipaddr & 0x0000ff00) >> 8,
(bi->ipaddr & 0x000000ff));
oscar_user_info_add_pair(user_info, _("IP Address"), tmp);
g_free(tmp);
}
static gpointer
nested_group_find_parent(PurpleBlistNode *node)
{
char *name;
PurpleGroup *group;
char *sep;
PurpleBlistNode *ret, *parent;
GntTree *tree;
if (!PURPLE_IS_GROUP(node))
return default_manager->find_parent(node);
group = PURPLE_GROUP(node);
name = g_strdup(purple_group_get_name(group));
if (!(sep = strchr(name, '/'))) {
g_free(name);
return default_manager->find_parent(node);
}
tree = finch_blist_get_tree();
parent = NULL;
while (sep) {
*sep = 0;
if (*(sep + 1) && (ret = PURPLE_BLIST_NODE(purple_blist_find_group(name)))) {
finch_blist_manager_add_node(ret);
parent = ret;
} else if (!(ret = g_hash_table_lookup(groups, name))) {
ret = g_object_new(FINCH_TYPE_GROUPING_NODE, NULL);
g_hash_table_insert(groups, g_strdup(name), ret);
gnt_tree_add_row_last(tree, ret,
gnt_tree_create_row(tree, name), parent);
parent = ret;
}
*sep = '/';
sep = strchr(sep + 1, '/');
}
g_free(name);
return ret;
}
void BuddyListGroup::GroupContextMenu::renameResponseHandler(
CppConsUI::InputDialog& activator,
CppConsUI::AbstractDialog::ResponseType response)
{
if (response != CppConsUI::AbstractDialog::RESPONSE_OK)
return;
const char *name = activator.getText();
PurpleGroup *group = parent_group->getPurpleGroup();
PurpleGroup *other = purple_find_group(name);
if (other && !purple_utf8_strcasecmp(name, purple_group_get_name(group))) {
LOG->message(_("Specified group is already in the list."));
/* TODO Add group merging. Note that purple_blist_rename_group() can do
* the merging. */
}
else
purple_blist_rename_group(group, name);
// close context menu
close();
}
/* stupid libpurple's local contact list, we don't need you! */
static void
sync_users (MsnSession *session)
{
PurpleAccount *account;
GSList *buddies;
GList *to_remove = NULL;
account = msn_session_get_user_data(session);
for (buddies = purple_find_buddies(account, NULL); buddies;
buddies = g_slist_delete_link(buddies, buddies))
{
PurpleBuddy *buddy = buddies->data;
const gchar *buddy_name = purple_buddy_get_name(buddy);
const gchar *group_name = purple_group_get_name(purple_buddy_get_group(buddy));
struct pn_contact *contact;
gboolean found = FALSE;
contact = pn_contactlist_find_contact(session->contactlist, buddy_name);
if (contact && contact->list_op & MSN_LIST_FL_OP) {
struct pn_group *group;
group = pn_contactlist_find_group_with_name(session->contactlist,
group_name);
found = pn_contact_is_in_group(contact, group);
}
if (!found) {
pn_warning("synchronization issue; buddy %s not found in group %s: removing",
purple_buddy_get_name(buddy), group_name);
to_remove = g_list_prepend(to_remove, buddy);
}
}
if (to_remove) {
g_list_foreach(to_remove, (GFunc) purple_blist_remove_buddy, NULL);
g_list_free(to_remove);
}
}
/* When you ask other people for authorization */
void
oscar_auth_sendrequest(PurpleConnection *gc, const char *bname, const char *msg)
{
OscarData *od;
PurpleAccount *account;
PurpleBuddy *buddy;
PurpleGroup *group;
const char *gname;
od = purple_connection_get_protocol_data(gc);
account = purple_connection_get_account(gc);
buddy = purple_find_buddy(account, bname);
if (buddy != NULL)
group = purple_buddy_get_group(buddy);
else
group = NULL;
if (group != NULL)
{
gname = purple_group_get_name(group);
purple_debug_info("oscar", "ssi: adding buddy %s to group %s\n",
bname, gname);
aim_ssi_sendauthrequest(od, bname, msg ? msg : _("Please authorize me so I can add you to my buddy list."));
if (!aim_ssi_itemlist_finditem(od->ssi.local, gname, bname, AIM_SSI_TYPE_BUDDY))
{
aim_ssi_addbuddy(od, bname, gname, NULL, purple_buddy_get_alias_only(buddy), NULL, NULL, TRUE);
/* Mobile users should always be online */
if (bname[0] == '+') {
purple_prpl_got_user_status(account,
purple_buddy_get_name(buddy),
OSCAR_STATUS_ID_AVAILABLE, NULL);
purple_prpl_got_user_status(account,
purple_buddy_get_name(buddy),
OSCAR_STATUS_ID_MOBILE, NULL);
}
}
}
}
