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); } } } }