bool PurpleIMContactList::moveContactToGroupCbk(void * dataIn)
{
Mutex::ScopedLock lock(PurpleIMContactList::_mutex);
PurpleIMContactListCallbackData* cbData = (PurpleIMContactListCallbackData*)dataIn;
PurpleAccount* gAccount = getPurpleAccount( cbData->getInstance() );
PurpleGroup* gOldGroup = purple_find_group( cbData->getOldGroupName().c_str() );
if (gOldGroup)
{
PurpleBuddy *gBuddy = purple_find_buddy_in_group(gAccount, cbData->getContactId().c_str(), gOldGroup);
if (gBuddy)
{
PurpleGroup *gNewGroup = purple_find_group( cbData->getNewGroupName().c_str() );
if (gNewGroup)
{
gNewGroup = purple_group_new(cbData->getNewGroupName().c_str());
purple_blist_add_buddy(gBuddy, NULL, gNewGroup, NULL);
}
}
}
timeoutRemove( cbData );
delete cbData;
return TRUE;
}
PurpleBuddy * qq_buddy_find_or_new( PurpleConnection *gc, guint32 uid, guint8 group_id)
{
PurpleBuddy *buddy;
qq_buddy_data *bd;
qq_data *qd;
GSList *l;
qq_group * g;
PurpleGroup * old_group;
g_return_val_if_fail(gc->account != NULL && uid != 0, NULL);
qd = (qq_data *)gc->proto_data;
buddy = qq_buddy_find(gc, uid);
/* group_id==0xFF only when add an unknown stranger */
if (group_id==0xFF) {
if (buddy) goto buddy_data_check;
else group_id=0; //add stranger to group 0
}
/* find input group_id */
for (l=qd->group_list; l; l=l->next)
{
if (((qq_group *)(l->data))->group_id == group_id) break;
}
/* if group_id found */
if (l) {
if (buddy) //if buddy already exist, we need check if he is in new group
{
old_group = purple_buddy_get_group(buddy);
g = (qq_group *)l->data;
if (old_group != purple_find_group(g->group_name))
{
qq_buddy_free(buddy);
} else goto buddy_data_check;
}
old_group = purple_find_group(((qq_group *)(l->data))->group_name);
buddy = qq_buddy_new(gc, uid, old_group);
} else {
if (group_id==0)
{
if (!buddy)
buddy = qq_buddy_new(gc, uid, NULL);
goto buddy_data_check;
}
purple_debug_error("QQ","cannot find group id: %u", group_id);
return NULL;
}
buddy_data_check:
if (purple_buddy_get_protocol_data(buddy) != NULL)
return buddy;
bd = qq_buddy_data_new(uid);
purple_buddy_set_protocol_data(buddy, bd);
return buddy;
}
gboolean AddBuddy_cb(struct fetion_account_data *sip, struct sipmsg *msg, struct transaction *tc)
{
xmlnode *root,*item;
const gchar *uri, *name ,*group_id;
struct group_attr *g_attr;
gchar *buddy_name;
PurpleBuddy *b;
PurpleGroup *g = NULL;
struct fetion_buddy *bs;
if(msg->response != 522)
{
root = xmlnode_from_str(msg->body, msg->bodylen);
item = xmlnode_get_child(root,"contacts/buddies/buddy");
g_return_val_if_fail(item!=NULL,FALSE);
uri = xmlnode_get_attrib(item, "uri");
name = xmlnode_get_attrib(item, "local-name");
group_id = xmlnode_get_attrib(item, "buddy-lists");
buddy_name = g_strdup_printf("%s", uri);
g_attr = g_hash_table_lookup(sip->group,group_id);
if(g_attr==NULL)
{
g = purple_find_group("未分组");
if(!g)
g = purple_group_new("未分组");
}
else
{
g = purple_find_group(g_attr->name);
if(!g)
g = purple_group_new(g_attr->name);
}
b = purple_find_buddy(sip->account, buddy_name);
if(!b){
b = purple_buddy_new(sip->account, buddy_name, NULL);
}
g_free(buddy_name);
purple_blist_add_buddy(b, NULL, g, NULL);
if(name!=NULL && *name!='\0')
purple_blist_alias_buddy(b, name);
bs = g_new0(struct fetion_buddy, 1);
bs->name = g_strdup(b->name);
g_hash_table_insert(sip->buddies, bs->name, bs);
fetion_subscribe_exp(sip,bs);
}
void
gevo_add_buddy(PurpleAccount *account, const char *group_name,
const char *buddy_name, const char *alias)
{
PurpleConversation *conv = NULL;
PurpleBuddy *buddy;
PurpleGroup *group;
conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, buddy_name, account);
group = purple_find_group(group_name);
if (group == NULL)
{
group = purple_group_new(group_name);
purple_blist_add_group(group, NULL);
}
buddy = purple_find_buddy_in_group(account, buddy_name, group);
if (buddy == NULL)
{
buddy = purple_buddy_new(account, buddy_name, alias);
purple_blist_add_buddy(buddy, NULL, group, NULL);
}
purple_account_add_buddy(account, buddy);
if (conv != NULL)
{
purple_buddy_icon_update(purple_conv_im_get_icon(PURPLE_CONV_IM(conv)));
purple_conversation_update(conv, PURPLE_CONV_UPDATE_ADD);
}
}
static VALUE remove_buddy(VALUE self, VALUE buddy)
{
PurpleAccount *account = NULL;
PurpleConnection *gc = NULL;
Data_Get_Struct(self, PurpleAccount, account);
gc = purple_account_get_connection( account );
PurpleBuddy* pb = purple_find_buddy(account, RSTRING_PTR(buddy));
if (NULL == pb) {
rb_raise(rb_eRuntimeError, "Failed to remove buddy for %s : %s does not exist", purple_account_get_username(account), RSTRING_PTR(buddy));
}
char* group = _("Buddies");
PurpleGroup* grp = purple_find_group(group);
if (!grp)
{
grp = purple_group_new(group);
purple_blist_add_group(grp, NULL);
}
purple_blist_remove_buddy(pb);
purple_account_remove_buddy(account, pb, grp);
serv_rem_permit( gc, RSTRING_PTR( buddy ) );
return Qtrue;
}
static PurpleGroup *flist_get_group(const gchar *name) {
PurpleGroup *g;
if(!(g = purple_find_group(name))) {
g = purple_group_new(name);
}
return g;
}
bool PurpleIMContactList::removeContactCbk(void * dataIn)
{
// Mutex::ScopedLock lock(PurpleIMContactList::_mutex);
Mutex::ScopedLock lock(PurpleIMContactList::_mutexContact); //VOXOX - JRT - 2009.07.14
PurpleIMContactListCallbackData* cbData = (PurpleIMContactListCallbackData*)dataIn;
PurpleAccount *gAccount = getPurpleAccount( cbData->getInstance() );
PurpleGroup *gGroup = NULL;
PurpleBuddy *gBuddy = NULL;
if ( !cbData->getGroupName().empty() )
{
gGroup = purple_find_group( cbData->getGroupName().c_str() );
gBuddy = purple_find_buddy_in_group(gAccount, cbData->getContactId().c_str(), gGroup );
}
else
{
gBuddy = purple_find_buddy(gAccount, cbData->getContactId().c_str() );
}
if (gBuddy)
{
purple_account_remove_buddy(gAccount, gBuddy, gGroup);
purple_blist_remove_buddy(gBuddy);
}
timeoutRemove( cbData );
delete cbData;
return TRUE;
}
bool PurpleIMContactList::addContactCbk(void * dataIn)
{
// Mutex::ScopedLock lock(PurpleIMContactList::_mutex);
Mutex::ScopedLock lock(PurpleIMContactList::_mutexContact); //VOXOX - JRT - 2009.07.14
PurpleIMContactListCallbackData* cbData = (PurpleIMContactListCallbackData*)dataIn;
PurpleAccount *gAccount = getPurpleAccount( cbData->getInstance() );
PurpleGroup *gGroup = NULL;
PurpleBuddy *gBuddy = NULL;
if ((gGroup = purple_find_group(cbData->getGroupName().c_str())) == NULL)
{
gGroup = purple_group_new(cbData->getGroupName().c_str());
purple_blist_add_group(gGroup, NULL);
}
gBuddy = purple_buddy_new(gAccount, cbData->getContactId().c_str(), cbData->getContactId().c_str() );
purple_blist_add_buddy(gBuddy, NULL, gGroup, NULL);
purple_account_add_buddy(gAccount, gBuddy);
timeoutRemove( cbData );
delete cbData;
return TRUE;
}
void QuetzalAccount::load(Config cfg)
{
cfg.beginGroup(QLatin1String("general"));
QByteArray password = cfg.value(QLatin1String("passwd"), QString(), Config::Crypted).toUtf8();
if (!password.isEmpty()) {
purple_account_set_password(m_account, password.constData());
purple_account_set_remember_password(m_account, true);
}
purple_account_set_alias(m_account, cfg.value(QLatin1String("alias"),
QString()).toUtf8().constData());
purple_account_set_user_info(m_account, cfg.value(QLatin1String("userInfo"),
QString()).toUtf8().constData());
QMapIterator<QString, QVariant> it(cfg.value(QLatin1String("quetzal_settings")).toMap());
while (it.hasNext()) {
it.next();
QByteArray key = it.key().toUtf8();
QVariant::Type type = it.value().type();
if (type == QVariant::Bool) {
purple_account_set_bool(m_account, key.constData(), it.value().toBool());
} else if (type == QVariant::Int || type == QVariant::UInt
|| type == QVariant::LongLong || type == QVariant::ULongLong) {
purple_account_set_int(m_account, key.constData(), it.value().toInt());
} else {
purple_account_set_string(m_account, key.constData(), it.value().toString().toUtf8());
}
}
cfg.endGroup();
RosterStorage::instance()->load(this);
int size = cfg.beginArray(QLatin1String("chats"));
QString name = QLatin1String("name");
QString recent = QLatin1String("recent");
QString data = QLatin1String("data");
for (int i = 0; i < size; i++) {
cfg.setArrayIndex(i);
QByteArray alias = cfg.value(name, QString()).toUtf8();
PurpleGroup *group = NULL;
if (cfg.value(recent, false)) {
group = purple_find_group("Recent");
if (!group) {
group = purple_group_new("Recent");
purple_blist_add_group(group, NULL);
}
}
GHashTable *comps = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
QMapIterator<QString, QVariant> it(cfg.value(data).toMap());
while (it.hasNext()) {
it.next();
QByteArray key = it.key().toUtf8();
QByteArray value = it.value().toString().toUtf8();
g_hash_table_insert(comps, g_strdup(key.constData()), g_strdup(value.constData()));
}
PurpleChat *pc = purple_chat_new(m_account, alias.constData(), comps);
purple_blist_add_chat(pc, NULL, NULL);
}
_purple_buddy_icons_blist_loaded_cb();
}
PurpleGroup *tgp_blist_group_init (const char *name) {
PurpleGroup *grp = purple_find_group (name);
if (grp == NULL) {
grp = purple_group_new (name);
purple_blist_add_group (grp, NULL);
}
return grp;
}
void
fb_got_groups(FacebookAccount *fba, const gchar *data, gsize data_len, gpointer user_data)
{
// look for /home.php?sk=group_ ...
gchar **splits;
gint i;
PurpleGroup *group;
splits = g_strsplit(data, "<a href=\\\"\\/home.php?sk=group_", 0);
if (!splits || !splits[0])
{
g_strfreev(splits);
return;
}
group = purple_find_group(DEFAULT_GROUP_NAME);
if (!group)
{
group = purple_group_new(DEFAULT_GROUP_NAME);
purple_blist_add_group(group, NULL);
}
for(i = 1; splits[i]; i++)
{
gchar *eos;
eos = strchr(splits[i], '\\');
if (eos != NULL)
{
*eos = '\0';
purple_debug_info("facebook", "searching for %s\n", splits[i]);
if (!purple_blist_find_chat(fba->account, splits[i]))
{
gchar *alias = NULL;
if (eos[1] == '"' && eos[2] == '>')
{
purple_debug_info("facebook", "searching for alias\n");
gchar *eoa = strchr(&eos[3], '<');
if (eoa)
{
*eoa = '\0';
alias = &eos[3];
purple_debug_info("facebook", "found chat alias %s\n", alias);
}
}
purple_debug_info("facebook", "adding chat %s to buddy list...\n", splits[i]);
// Add the group chat to the buddy list
GHashTable *components = fb_chat_info_defaults(fba->pc, splits[i]);
PurpleChat *chat = purple_chat_new(fba->account, alias, components);
purple_blist_add_chat(chat, group, NULL);
purple_debug_info("facebook", "done\n");
}
}
}
g_strfreev(splits);
}
static void
pref_size_on_change(const char *name, PurplePrefType type, gconstpointer val,
gpointer user_data)
{
g_size = purple_prefs_get_int(PREF_SIZE);
PurpleGroup * grp = purple_find_group(GROUP_NAME);
if (!grp) return;
rc_pop_contacts(grp);
}
void BuddyList::add_buddy_ok_cb(PurpleRequestFields *fields)
{
PurpleAccount *account = purple_request_fields_get_account(fields, "account");
const char *name = purple_request_fields_get_string(fields, "name");
const char *alias = purple_request_fields_get_string(fields, "alias");
int selected = purple_request_fields_get_choice(fields, "group");
GList *list = purple_request_field_choice_get_labels(
purple_request_fields_get_field(fields, "group"));
const char *group
= reinterpret_cast<const char*>(g_list_nth_data(list, selected));
bool err = false;
if (!account) {
LOG->Message(_("No account specified."));
err = true;
}
else if (!purple_account_is_connected(account)) {
LOG->Message(_("Selected account is not connected."));
err = true;
}
if (!name || !name[0]) {
LOG->Message(_("No buddy name specified."));
err = true;
}
if (!group || !group[0]) {
LOG->Message(_("No group name specified."));
err = true;
}
if (err) {
purple_blist_request_add_buddy(account, name, group, alias);
return;
}
PurpleGroup *g = purple_find_group(group);
if (!g) {
g = purple_group_new(group);
purple_blist_add_group(g, NULL);
}
PurpleBuddy *b = purple_find_buddy_in_group(account, name, g);
if (b) {
LOG->Message(_("Specified buddy is already in the list."));
return;
}
if (alias && !alias[0])
alias = NULL;
b = purple_buddy_new(account, name, alias);
purple_blist_add_buddy(b, NULL, g, NULL);
purple_account_add_buddy(account, b);
}
PurpleGroup *qq_group_find_or_new(const gchar *group_name)
{
PurpleGroup *g;
g_return_val_if_fail(group_name != NULL, NULL);
g = purple_find_group(group_name);
if (g == NULL) {
g = purple_group_new(group_name);
purple_blist_add_group(g, NULL);
purple_debug_warning("QQ", "Add new group: %s\n", group_name);
}
return g;
}
void rc_pop_contacts(PurpleGroup * grp)
{
if (!grp) return;
PurpleBlistNode * gnode = PURPLE_BLIST_NODE(grp);
PurpleBlistNode * n = NULL;
PurpleBuddy * b = NULL;
int total;
gboolean offline;
//XXX group->totalsize is unreliable!!!
for (n=gnode->child, total=0; n!=NULL; total++, n=n->next);
trace("Total Group Count %d", total);
while (total > g_size) {
n = gnode->child;
if (PURPLE_BLIST_NODE_IS_CONTACT(n)) {
trace("Child Contact : %s", (PURPLE_CONTACT(n)->priority->name));
b = PURPLE_CONTACT(n)->priority;
} else if (PURPLE_BLIST_NODE_IS_BUDDY(n)) {
trace("Child Buddy : %s", (PURPLE_BUDDY(n)->name));
b = PURPLE_BUDDY(n);
}
n = PURPLE_BLIST_NODE(b);
const char *name = purple_blist_node_get_string(n, NODE_GROUP_KEY);
if (!name) { // if cannot find orig group name, put back to Buddies
trace("ERROR!!! cannot find original group name");
name = "Buddies";
}
PurpleGroup * g = purple_find_group(name);
if (!g) {
trace("Group %s Not Found. Create one.", name);
g = purple_group_new(name);
}
trace("<<<<<<< Remove %s", b->name);
offline = purple_blist_node_get_bool(n, NODE_ORIG_OFFLINE_KEY);
purple_blist_node_set_bool(n, NODE_OFFLINE_KEY, offline);
purple_blist_add_buddy(b, NULL, g, NULL);
total--;
}
}
/* Remove the buddy referenced by the MsnAddRemData before the serverside list is changed.
* If the buddy will be added, he'll be added back; if he will be removed, he won't be. */
static void
msn_complete_sync_issue(MsnAddRemData *data)
{
PurpleBuddy *buddy;
PurpleGroup *group = NULL;
if (data->group != NULL)
group = purple_find_group(data->group);
if (group != NULL)
buddy = purple_find_buddy_in_group(purple_connection_get_account(data->gc), data->who, group);
else
buddy = purple_find_buddy(purple_connection_get_account(data->gc), data->who);
if (buddy != NULL)
purple_blist_remove_buddy(buddy);
}
static void
stress_close(PurpleConnection *pc) {
GList *l = NULL;
PurpleGroup *g = NULL;
for(l = buddies; l; l = l->next) {
StressBuddy *sb = l->data;
purple_blist_remove_buddy(sb->buddy);
}
g_list_free(buddies);
g = purple_find_group("prpl-stress");
purple_blist_remove_group(g);
buddies = NULL;
}
static void purple_add_buddy( struct im_connection *ic, char *who, char *group )
{
PurpleBuddy *pb;
PurpleGroup *pg = NULL;
if( group && !( pg = purple_find_group( group ) ) )
{
pg = purple_group_new( group );
purple_blist_add_group( pg, NULL );
}
pb = purple_buddy_new( (PurpleAccount*) ic->proto_data, who, NULL );
purple_blist_add_buddy( pb, NULL, pg, NULL );
purple_account_add_buddy( (PurpleAccount*) ic->proto_data, pb );
purple_gg_buddylist_export( ((PurpleAccount*)ic->proto_data)->gc );
}
static void
pb_got_phonebook(PushBulletAccount *pba, JsonNode *node, gpointer user_data)
{
PurpleAccount *account = pba->account;
JsonObject *rootobj = json_node_get_object(node);
JsonArray *phonebook = json_object_get_array_member(rootobj, "phonebook");
gint i;
guint len;
gchar *device = user_data;
PurpleGroup *pbgroup;
pbgroup = purple_find_group("PushBullet");
if (!pbgroup)
{
pbgroup = purple_group_new("PushBullet");
purple_blist_add_group(pbgroup, NULL);
}
for(i = 0, len = json_array_get_length(phonebook); i < len; i++)
{
JsonObject *number = json_array_get_object_element(phonebook, i);
const gchar *name = json_object_get_string_member(number, "name");
const gchar *phone = json_object_get_string_member(number, "phone");
const gchar *phone_type = json_object_get_string_member(number, "phone_type");
PurpleBuddy *pbuddy;
//Only handle the right 'type' of phone number.
//home, mobile, work, other
if (purple_account_get_bool(account, "mobile_contacts_only", FALSE) && phone_type[0] != 'm')
continue;
pbuddy = purple_find_buddy(account, phone);
if (!pbuddy)
{
pbuddy = purple_buddy_new(account, phone, name);
purple_blist_add_buddy(pbuddy, NULL, pbgroup, NULL);
purple_debug_info("pushbullet", "Added buddy %s %s\n", phone, name);
}
purple_prpl_got_user_status(account, phone, "mobile", NULL);
purple_prpl_got_user_status(account, phone, purple_primitive_get_id_from_type(PURPLE_STATUS_AVAILABLE), NULL);
}
g_free(device);
}
void Buddy::SetGroups (const QStringList& groups)
{
const auto& newGroup = groups.value (0);
PurpleGroup *group = 0;
if (!newGroup.isEmpty ())
{
const auto& utf8 = newGroup.toUtf8 ();
group = purple_find_group (utf8.constData ());
if (!group)
{
group = purple_group_new (utf8.constData ());
purple_blist_add_group (group, nullptr);
}
}
purple_blist_add_buddy (Buddy_, nullptr, group, nullptr);
}
bool PurpleIMContactList::changeGroupNameCbk(void * dataIn)
{
Mutex::ScopedLock lock(PurpleIMContactList::_mutex);
PurpleIMContactListCallbackData* cbData = (PurpleIMContactListCallbackData*)dataIn;
PurpleGroup *gGroup = purple_find_group( cbData->getOldGroupName().c_str() );
if (gGroup)
{
purple_blist_rename_group(gGroup, cbData->getNewGroupName().c_str() );
}
timeoutRemove( cbData );
delete cbData;
return TRUE;
}
static VALUE add_buddy(VALUE self, VALUE buddy)
{
PurpleAccount *account;
Data_Get_Struct(self, PurpleAccount, account);
PurpleBuddy* pb = purple_buddy_new(account, StringValueCStr(buddy), NULL);
char* group = _("Buddies");
PurpleGroup* grp = purple_find_group(group);
if (!grp)
{
grp = purple_group_new(group);
purple_blist_add_group(grp, NULL);
}
purple_blist_add_buddy(pb, NULL, grp, NULL);
purple_account_add_buddy(account, pb);
return Qtrue;
}
bool PurpleIMContactList::addGroupCbk(void * dataIn)
{
Mutex::ScopedLock lock(PurpleIMContactList::_mutex);
PurpleIMContactListCallbackData* cbData = (PurpleIMContactListCallbackData*)dataIn;
PurpleGroup *gGroup = purple_find_group( cbData->getGroupName().c_str() );
if (!gGroup)
{
gGroup = purple_group_new( cbData->getGroupName().c_str() );
purple_blist_add_group(gGroup, NULL);
}
timeoutRemove( cbData );
delete cbData;
return TRUE;
}
void rc_push_contact(PurpleAccount *acct,
const char * buddyname)
{
PurpleGroup * grp = purple_find_group(GROUP_NAME);
if (!grp) {
trace("Group %s Not Found. Create one.", GROUP_NAME);
grp = purple_group_new(GROUP_NAME);
}
PurpleBuddy * buddy;
// if we can find it in 'Recent Contacts', skip
if ((buddy = purple_find_buddy_in_group(acct, buddyname, grp)) != NULL) {
trace("Buddy %s is already in %s", buddyname, GROUP_NAME);
purple_blist_add_buddy(buddy, NULL, grp, NULL);
return;
}
buddy = purple_find_buddy(acct, buddyname);
if (!buddy) {
trace("Buddy %s Not Found. You SUCK!", buddyname);
return;
}
PurpleBlistNode * node = PURPLE_BLIST_NODE(buddy);
// back up group info
PurpleGroup * orig_grp = purple_buddy_get_group(buddy);
purple_blist_node_set_string(node, NODE_GROUP_KEY, orig_grp->name);
// back up offline info
gboolean offline = purple_blist_node_get_bool(node, NODE_OFFLINE_KEY);
purple_blist_node_set_bool(node, NODE_ORIG_OFFLINE_KEY, offline);
purple_blist_node_set_bool(node, NODE_OFFLINE_KEY, TRUE);
// Add to Recent Contacts Group
trace(">>>>>>> Add %s", buddyname);
purple_blist_add_buddy(buddy, NULL, grp, NULL);
// Clean up old group if needed
rc_pop_contacts(grp);
}
/* this should be called upon signin, even when we did not open group chat window */
void qq_room_data_initial(PurpleConnection *gc)
{
PurpleAccount *account;
PurpleChat *chat;
PurpleGroup *purple_group;
PurpleBlistNode *node;
qq_data *qd;
qq_room_data *rmd;
gint count;
account = purple_connection_get_account(gc);
qd = (qq_data *) gc->proto_data;
purple_debug_info("QQ", "Initial QQ Qun configurations\n");
purple_group = purple_find_group(PURPLE_GROUP_QQ_ROOM);
if (purple_group == NULL) {
purple_debug_info("QQ", "We have no QQ Qun\n");
return;
}
count = 0;
for (node = purple_blist_node_get_first_child((PurpleBlistNode *)purple_group);
node != NULL;
node = purple_blist_node_get_sibling_next(node))
{
if ( !PURPLE_BLIST_NODE_IS_CHAT(node)) {
continue;
}
/* got one */
chat = (PurpleChat *) node;
if (account != purple_chat_get_account(chat)) /* not qq account*/
continue;
rmd = room_data_new_by_hashtable(gc, purple_chat_get_components(chat));
rmd->my_role = QQ_ROOM_ROLE_NO; //now set all old qun data detached 'cause we don't know if we are still in
qd->rooms = g_slist_append(qd->rooms, rmd);
count++;
}
purple_debug_info("QQ", "Load %d QQ Qun configurations\n", count);
}
Contact *QuetzalContactsFactory::addContact(const QString &id, const QVariantMap &data)
{
QByteArray group = data.value(QLatin1String("group")).toString().toUtf8();
if (group.isEmpty()) {
// For compatibility with other implementations
// Looks like libpurple doesn't support multiple groups
// Or does it at some unknown way
group = data.value(QLatin1String("tags")).toStringList().value(0).toUtf8();
}
QString name = data.value(QLatin1String("name")).toString();
const char *groupName = group.isEmpty() ? "Buddies" : group.constData();
PurpleGroup *pg = purple_find_group(groupName);
if (!pg) {
pg = purple_group_new(groupName);
purple_blist_add_group(pg, quetzal_blist_get_last_sibling(purple_blist_get_root()));
}
PurpleContact *pc = purple_contact_new();
purple_blist_add_contact(pc, pg, quetzal_blist_get_last_child(PURPLE_BLIST_NODE(pg)));
PurpleBuddy *buddy = purple_buddy_new(m_account->purple(), id.toUtf8().constData(),
name.toUtf8().constData());
PurpleBlistNode *node = PURPLE_BLIST_NODE(buddy);
purple_blist_add_buddy(buddy, pc, pg, quetzal_blist_get_last_child(PURPLE_BLIST_NODE(pc)));
QMapIterator<QString, QVariant> it(data.value(QLatin1String("quetzal_settings")).toMap());
while (it.hasNext()) {
it.next();
QByteArray key = it.key().toUtf8();
QVariant::Type type = it.value().type();
if (type == QVariant::Bool) {
purple_blist_node_set_bool(node, key.constData(), it.value().toBool());
} else if (type == QVariant::Int || type == QVariant::UInt
|| type == QVariant::LongLong || type == QVariant::ULongLong) {
purple_blist_node_set_int(node, key.constData(), it.value().toInt());
} else {
purple_blist_node_set_string(node, key.constData(), it.value().toString().toUtf8());
}
}
QuetzalContact *contact = reinterpret_cast<QuetzalContact*>(node->ui_data);
contact->update(buddy);
return contact;
}
void hon_parse_notification(PurpleConnection *gc,gchar* buffer){
PurpleBuddy* buddy;
guint32 buddyid;
PurpleGroup* buddies;
hon_account* hon = gc->proto_data;
guint8 notification_type = read_byte(buffer);
gchar *title = NULL,*msg = NULL;
switch (notification_type)
{
case HON_NOTIFICATION_ADDED_AS_BUDDY:
case HON_NOTIFICATION_BUDDY_ACCEPTED:
buddies = purple_find_group(HON_BUDDIES_GROUP);
buddyid = read_guint32(buffer);
read_guint32(buffer); /* notification id */
g_hash_table_insert(hon->id2nick,GINT_TO_POINTER(buddyid),g_strdup(buffer));
buddy = purple_buddy_new(gc->account,buffer,NULL);
purple_blist_add_buddy(buddy,NULL,buddies,NULL);
title = g_strdup(_("Friendship Accepted"));
if (notification_type == HON_NOTIFICATION_ADDED_AS_BUDDY)
msg = g_strdup_printf(_("Accepted friendship request from %s"),buffer);
else
msg = g_strdup_printf(_("%s accepted your friendship request"),buffer);
break;
/*
case HON_NOTIFICATION_REMOVED_AS_BUDDY:
title = g_strdup(_("User removed you as buddy"));
break;
case HON_NOTIFICATION_BUDDY_REMOVED:
title = g_strdup(_("Buddy removed"));
break;
*/
default :
title = g_strdup_printf(_("Unknown notification type (%d)"),notification_type);
msg = g_strdup(buffer);
break;
}
purple_notify_info(NULL,title,msg,NULL);
g_free(title);
g_free(msg);
}
void on_ready (struct tgl_state *TLS) {
debug ("on_ready().\n");
telegram_conn *conn = TLS->ev_base;
purple_connection_set_state(conn->gc, PURPLE_CONNECTED);
purple_connection_set_display_name(conn->gc, purple_account_get_username(conn->pa));
purple_blist_add_account(conn->pa);
tggroup = purple_find_group("Telegram");
if (tggroup == NULL) {
debug ("PurpleGroup = NULL, creating");
tggroup = purple_group_new ("Telegram");
purple_blist_add_group (tggroup, NULL);
}
debug ("seq = %d, pts = %d\n", TLS->seq, TLS->pts);
tgl_do_get_difference (TLS, 0, 0, 0);
tgl_do_get_dialog_list (TLS, 0, 0);
tgl_do_update_contact_list (TLS, 0, 0);
conn->timer = purple_timeout_add (5000, queries_timerfunc, conn);
}
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();
}
/*add group id to User object*/
void
msn_user_add_group_id(MsnUser *user, const char* group_id)
{
MsnUserList *userlist;
PurpleAccount *account;
PurpleBuddy *b;
PurpleGroup *g;
const char *passport;
const char *group_name;
g_return_if_fail(user != NULL);
g_return_if_fail(group_id != NULL);
user->group_ids = g_list_append(user->group_ids, g_strdup(group_id));
userlist = user->userlist;
account = userlist->session->account;
passport = msn_user_get_passport(user);
group_name = msn_userlist_find_group_name(userlist, group_id);
purple_debug_info("msn", "User: group id:%s,name:%s,user:%s\n", group_id, group_name, passport);
g = purple_find_group(group_name);
if ((group_id == NULL) && (g == NULL))
{
g = purple_group_new(group_name);
purple_blist_add_group(g, NULL);
}
b = purple_find_buddy_in_group(account, passport, g);
if (b == NULL)
{
b = purple_buddy_new(account, passport, NULL);
purple_blist_add_buddy(b, NULL, g, NULL);
}
purple_buddy_set_protocol_data(b, user);
/*Update the blist Node info*/
}
