/*------------------------------------------------------------------------
* Enable the user to change their PIN.
*
* @param action The action object
*/
static void mxit_change_pin_action( PurplePluginAction* action )
{
PurpleConnection* gc = (PurpleConnection*) action->context;
PurpleRequestFields* fields = NULL;
PurpleRequestFieldGroup* group = NULL;
PurpleRequestField* field = NULL;
purple_debug_info( MXIT_PLUGIN_ID, "mxit_change_pin_action\n" );
fields = purple_request_fields_new();
group = purple_request_field_group_new( NULL );
purple_request_fields_add_group( fields, group );
/* pin */
field = purple_request_field_string_new( "pin", _( "PIN" ), purple_connection_get_password( gc ), FALSE );
purple_request_field_string_set_masked( field, TRUE );
purple_request_field_group_add_field( group, field );
/* verify pin */
field = purple_request_field_string_new( "pin2", _( "Verify PIN" ), purple_connection_get_password( gc ), FALSE );
purple_request_field_string_set_masked( field, TRUE );
purple_request_field_group_add_field( group, field );
/* (reference: "libpurple/request.h") */
purple_request_fields( gc, _( "Change PIN" ), _( "Change MXit PIN" ), NULL, fields, _( "Set" ),
G_CALLBACK( mxit_change_pin_cb ), _( "Cancel" ), NULL, purple_request_cpar_from_connection(gc), gc );
}
/* Add buddy dialog */
static void plainprpl_add_buddy(PurpleConnection *gc, PurpleBuddy *buddy, PurpleGroup *buddy_group)
{
purple_debug_info("plainprpl", "plainprpl_add_buddy_with_invite: %s\n", buddy->name);
PurpleRequestFields *request;
PurpleRequestFieldGroup *group;
PurpleRequestField *field;
group = purple_request_field_group_new(NULL);
field = purple_request_field_string_new("addr_str", _("IP Address"), "", FALSE);
purple_request_field_group_add_field(group, field);
field = purple_request_field_string_new("invite_msg", _("Invite Message"), "Please allow me to add you as a contact!", FALSE);
purple_request_field_group_add_field(group, field);
request = purple_request_fields_new();
purple_request_fields_add_group(request, group);
purple_request_fields(gc, "Add Contact", "Add a new contact.",
NULL, request,
"OK", G_CALLBACK(plainprpl_add_buddy_ok),
"Cancel", G_CALLBACK(plainprpl_add_buddy_cancel),
NULL, NULL, NULL, (void *) buddy
);
purple_prpl_got_user_status(gc->account, buddy->name, PLAIN_STATUS_OFFLINE, NULL);
}
void GeneralMenu::openRequestFieldsTest(CppConsUI::Button& /*activator*/)
{
PurpleRequestFields *fields = purple_request_fields_new();
PurpleRequestFieldGroup *g = purple_request_field_group_new("Group 0");
purple_request_fields_add_group(fields, g);
PurpleRequestField *f;
f = purple_request_field_string_new("text0", "String field 0", "def0",
FALSE);
purple_request_field_group_add_field(g, f);
f = purple_request_field_string_new("text1", "String field 1", NULL,
FALSE);
purple_request_field_group_add_field(g, f);
f = purple_request_field_int_new("int0", "Int field 0", INT_MAX);
purple_request_field_group_add_field(g, f);
f = purple_request_field_bool_new("bool0", "Bool field 0", FALSE);
purple_request_field_group_add_field(g, f);
f = purple_request_field_choice_new("choice0", "Choice field 0", 2);
purple_request_field_choice_add(f, "One");
purple_request_field_choice_add(f, "Two");
purple_request_field_choice_add(f, "Three");
purple_request_field_choice_add(f, "Four");
purple_request_field_group_add_field(g, f);
f = purple_request_field_list_new("list0", "List field 0, multiple");
purple_request_field_list_set_multi_select(f, TRUE);
purple_request_field_list_add(f, "One", this);
purple_request_field_list_add(f, "Two", this);
purple_request_field_list_add(f, "Three", this);
purple_request_field_list_add(f, "Four", this);
purple_request_field_list_add_selected(f, "Three");
purple_request_field_group_add_field(g, f);
f = purple_request_field_list_new("list1", "List field 1, single");
purple_request_field_list_set_multi_select(f, FALSE);
purple_request_field_list_add(f, "One", this);
purple_request_field_list_add(f, "Two", this);
purple_request_field_list_add(f, "Three", this);
purple_request_field_list_add(f, "Four", this);
purple_request_field_list_add_selected(f, "Three");
purple_request_field_group_add_field(g, f);
f = purple_request_field_account_new("account0", "Account field 0", NULL);
purple_request_field_account_set_show_all(f, TRUE);
purple_request_field_group_add_field(g, f);
purple_request_fields(NULL, "Title", "Primary", "Secondary", fields,
"Ok", G_CALLBACK(fields_ok_cb_),
"Cancel", NULL,
NULL, NULL, NULL, this);
close();
}
static void field_request_new(PurpleRequestFieldGroup *group, gint index, gchar **segments)
{
PurpleRequestField *field;
gchar *utf8_value;
int choice_num;
int i;
g_return_if_fail(index >=0 && segments[index] != NULL && index < QQ_INFO_LAST);
switch (field_infos[index].type) {
case QQ_FIELD_STRING:
case QQ_FIELD_MULTI:
utf8_value = qq_to_utf8(segments[index], QQ_CHARSET_DEFAULT);
if (field_infos[index].type == QQ_FIELD_STRING) {
field = purple_request_field_string_new(
field_infos[index].id, field_infos[index].text, utf8_value, FALSE);
} else {
field = purple_request_field_string_new(
field_infos[index].id, field_infos[index].text, utf8_value, TRUE);
}
purple_request_field_group_add_field(group, field);
g_free(utf8_value);
break;
case QQ_FIELD_BOOL:
field = purple_request_field_bool_new(
field_infos[index].id, field_infos[index].text,
strtol(segments[index], NULL, 10) ? TRUE : FALSE);
purple_request_field_group_add_field(group, field);
break;
case QQ_FIELD_CHOICE:
choice_num = strtol(segments[index], NULL, 10);
if (choice_num < 0 || choice_num >= field_infos[index].choice_size) choice_num = 0;
if (index == QQ_INFO_GENDER && strlen(segments[index]) != 0) {
for (i = 0; i < QQ_GENDER_SIZE; i++) {
if (strcmp(segments[index], genders_zh[i]) == 0) {
choice_num = i;
}
}
}
field = purple_request_field_choice_new(
field_infos[index].id, field_infos[index].text, choice_num);
for (i = 0; i < field_infos[index].choice_size; i++) {
purple_request_field_choice_add(field, field_infos[index].choice[i]);
}
purple_request_field_group_add_field(group, field);
break;
case QQ_FIELD_LABEL:
default:
field = purple_request_field_label_new(field_infos[index].id, segments[index]);
purple_request_field_group_add_field(group, field);
break;
}
}
//with invite message
static void plainprpl_add_buddy_by_contact_request(PurpleConnection *gc, const char *addr_str, const char *message)
{
PurpleBuddy *buddy;
/* Create the basic buddy item */
buddy = purple_buddy_new(gc->account, addr_str, NULL);
purple_blist_add_buddy(buddy, NULL, NULL, NULL);
PurpleRequestFields *request;
PurpleRequestFieldGroup *group;
PurpleRequestField *field;
group = purple_request_field_group_new(NULL);
field = purple_request_field_string_new("name", _("Name"), addr_str, FALSE);
purple_request_field_group_add_field(group, field);
request = purple_request_fields_new();
purple_request_fields_add_group(request, group);
char *msg = g_strdup_printf("Add a new contact from %s. Message: %s", addr_str, message);
purple_request_fields(gc, "Contact Request", msg,
NULL, request,
"OK", G_CALLBACK(plainprpl_add_buddy_by_contact_request_ok),
"Cancel", G_CALLBACK(plainprpl_add_buddy_by_contact_request_cancel),
NULL, NULL, NULL, (void *) buddy
);
g_free(msg);
purple_prpl_got_user_status(gc->account, buddy->name, PLAIN_STATUS_OFFLINE, NULL);
}
static void fb_login_captcha_image_cb(FacebookAccount *fba, gchar *response,
gsize len, gpointer userdata)
{
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_image_new("captcha_image", "", response, len);
purple_request_field_group_add_field(group, field);
field = purple_request_field_string_new("captcha_response", "", "", FALSE);
purple_request_field_group_add_field(group, field);
purple_request_fields(fba->pc,
_("Facebook Captcha"), _("Facebook Captcha"),
_("Enter both words below, separated by a space"),
fields,
_("OK"), G_CALLBACK(fb_login_captcha_ok_cb),
_("Logout"), G_CALLBACK(fb_login_captcha_cancel_cb),
fba->account, NULL, NULL, fba->pc
);
}
static void alias_add (GtkButton *button, gpointer data)
{
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("alias", _("Alias"),
NULL, FALSE);
purple_request_field_set_required(field, TRUE);
purple_request_field_set_type_hint(field, "alias");
purple_request_field_group_add_field(group, field);
purple_request_fields(purple_get_blist(), _("Add Alias"),
NULL,
_("Type in the alias that you use"),
fields,
_("OK"), G_CALLBACK(new_alias),
_("Cancel"), NULL,
NULL, NULL, NULL, NULL);
}
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 auth_token_captcha_input_cb(PurpleUtilFetchUrlData *url_data,
gpointer user_data, const gchar *url_text, gsize len, const gchar *error_message)
{
PurpleAccount *account;
PurpleRequestFields *fields;
PurpleRequestFieldGroup *group;
PurpleRequestField *field;
qq_buddy_opt_req *opt_req = (qq_buddy_opt_req *)user_data;
gchar *end_of_headers, *p;
guint header_len, content_len;
g_return_if_fail(opt_req && opt_req->gc && opt_req->uid>0 );
g_return_if_fail(url_text && len>0);
account = purple_connection_get_account(opt_req->gc);
end_of_headers = strstr(url_text, "\r\n\r\n");
if (end_of_headers) {
header_len = (end_of_headers + 4 - url_text);
}
p = find_header_content(url_text, header_len, "\nContent-Length: ", sizeof("\nContent-Length: ") - 1);
if (p) {
sscanf(p, "%" G_GSIZE_FORMAT, &content_len);
} else {
purple_debug_error("QQ", "can not parse http header, maybe it's chunked!");
}
p = find_header_content(url_text, header_len, "\ngetqqsession: ", sizeof("\ngetqqsession: ") - 1);
if (!p) purple_debug_error("QQ", "can not find qqsession in http header!");
opt_req->session_len = strstr(p, "\r\n")-p;
opt_req->session = g_new0(guint8, opt_req->session_len);
g_memmove(opt_req->session, p, opt_req->session_len);
fields = purple_request_fields_new();
group = purple_request_field_group_new(NULL);
purple_request_fields_add_group(fields, group);
field = purple_request_field_image_new("captcha_img",
_("Captcha Image"), url_text+header_len, content_len);
purple_request_field_group_add_field(group, field);
field = purple_request_field_string_new("captcha_code",
_("Enter code"), "", FALSE);
purple_request_field_string_set_masked(field, FALSE);
purple_request_field_group_add_field(group, field);
purple_request_fields(account,
_("QQ Captcha Verification"),
_("QQ Captcha Verification"),
_("Enter the text from the image"),
fields,
_("OK"), G_CALLBACK(auth_token_captcha_input_ok_cb),
_("Cancel"), G_CALLBACK(auth_token_captcha_input_cancel_cb),
account, NULL, NULL,
opt_req);
}
/* memo modify dialogue */
static void memo_modify_dialogue(PurpleConnection *gc, guint32 bd_uid, gchar **segments, guint32 action)
{
modify_memo_request *memo_request;
PurpleRequestField *field;
PurpleRequestFields *fields;
PurpleRequestFieldGroup *group;
int index;
gchar *utf8_title;
gchar *utf8_primary;
g_return_if_fail(NULL != gc && NULL != segments);
switch (action) {
case QQ_BUDDY_MEMO_GET:
memo_free(segments);
break;
case QQ_BUDDY_MEMO_MODIFY:
/* keep one dialog once a time */
purple_request_close_with_handle(gc);
/* show dialog */
fields = purple_request_fields_new();
group = purple_request_field_group_new(NULL);
purple_request_fields_add_group(fields, group);
for(index = 0; index < QQ_MEMO_SIZE; index++) {
/*
purple_debug_info("QQ", "id:%s txt:%s segment:%s\n",
memo_id[index], memo_txt[index], segments[index]);
*/
field = purple_request_field_string_new(memo_id[index], memo_txt[index],
segments[index], FALSE);
purple_request_field_group_add_field(group, field);
}
/* for upload cb */
memo_request = g_new0(modify_memo_request, 1);
memo_request->gc = gc;
memo_request->bd_uid = bd_uid;
memo_request->segments = segments;
/* callback */
utf8_title = g_strdup(_("Buddy Memo"));
utf8_primary = g_strdup(_("Change his/her memo as you like"));
purple_request_fields(gc, utf8_title, utf8_primary, NULL,
fields,
_("_Modify"), G_CALLBACK(memo_modify_ok_cb),
_("_Cancel"), G_CALLBACK(memo_modify_cancle_cb),
purple_connection_get_account(gc), NULL, NULL,
memo_request);
g_free(utf8_title);
g_free(utf8_primary);
break;
default:
purple_debug_info("QQ", "Error...unknown memo action, please tell us\n");
break;
}
}
static PurpleRequestFields *
request_fields_from_personal_details(YahooPersonalDetails *ypd, const char *id)
{
PurpleRequestFields *fields;
PurpleRequestFieldGroup *group;
PurpleRequestField *field;
int i;
struct {
char *id;
char *text;
char *value;
} yfields[] = {
{"fn", N_("First Name"), ypd->names.first},
{"ln", N_("Last Name"), ypd->names.last},
{"nn", N_("Nickname"), ypd->names.nick},
{"mn", N_("Middle Name"), ypd->names.middle},
{"hp", N_("Home Phone Number"), ypd->phone.home},
{"wp", N_("Work Phone Number"), ypd->phone.work},
{"mo", N_("Mobile Phone Number"), ypd->phone.mobile},
{NULL, NULL, NULL}
};
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("yname", "", id, FALSE);
purple_request_field_set_visible(field, FALSE);
purple_request_field_group_add_field(group, field);
field = purple_request_field_string_new("yid", "", ypd->id, FALSE);
purple_request_field_set_visible(field, FALSE);
purple_request_field_group_add_field(group, field);
for (i = 0; yfields[i].id; i++) {
field = purple_request_field_string_new(yfields[i].id, _(yfields[i].text),
yfields[i].value, FALSE);
purple_request_field_group_add_field(group, field);
}
return fields;
}
void ggp_pubdir_search(PurpleConnection *gc,
const ggp_pubdir_search_form *form)
{
PurpleRequestFields *fields;
PurpleRequestFieldGroup *group;
PurpleRequestField *field;
purple_debug_info("gg", "ggp_pubdir_search\n");
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("name", _("Name"),
form ? form->nick : NULL, FALSE);
purple_request_field_group_add_field(group, field);
field = purple_request_field_string_new("city", _("City"),
form ? form->city : NULL, FALSE);
purple_request_field_group_add_field(group, field);
field = purple_request_field_choice_new("gender", _("Gender"),
form ? GINT_TO_POINTER(form->gender) : NULL);
purple_request_field_choice_add(field, _("Male or female"), NULL);
purple_request_field_choice_add(field, _("Male"),
GINT_TO_POINTER(GGP_PUBDIR_GENDER_MALE));
purple_request_field_choice_add(field, _("Female"),
GINT_TO_POINTER(GGP_PUBDIR_GENDER_FEMALE));
purple_request_field_group_add_field(group, field);
purple_request_fields(gc, _("Find buddies"), _("Find buddies"),
_("Please, enter your search criteria below"), fields,
_("OK"), G_CALLBACK(ggp_pubdir_search_request),
_("Cancel"), NULL,
purple_request_cpar_from_connection(gc), gc);
}
static void plainprpl_change_address(PurpleBlistNode *node, gpointer userdata)
{
PurpleBuddy *buddy;
plain_buddy_state *bstate;
char *request_str;
const char *addr_str;
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);
buddy = (PurpleBuddy *) node;
bstate = purple_buddy_get_protocol_data(buddy);
if (bstate) {
addr_str = purple_blist_node_get_string(PURPLE_BLIST_NODE(buddy), "addr_str");
field = purple_request_field_string_new("addr_str", _("Address"), addr_str, FALSE);
purple_request_field_string_set_masked(field, FALSE);
purple_request_field_group_add_field(group, field);
request_str = g_strdup_printf("Address to reach buddy '%s'.", buddy->name);
purple_request_fields(buddy->account, "Change Address",
request_str,
NULL, fields,
_("OK"), G_CALLBACK(plainprpl_change_address_ok),
_("Cancel"), G_CALLBACK(plainprpl_change_address_cancel),
NULL, NULL, NULL, (void *) buddy
);
g_free(request_str);
} else {
purple_debug_info("plainprpl", "Buddy %s has no bstate set.\n", buddy->name);
}
}
static PurpleRequestField *
get_pref_field(Prefs *prefs)
{
PurpleRequestField *field = NULL;
if (prefs->lv == NULL)
{
switch (prefs->type)
{
case PURPLE_PREF_BOOLEAN:
field = purple_request_field_bool_new(prefs->pref, _(prefs->label),
purple_prefs_get_bool(prefs->pref));
break;
case PURPLE_PREF_INT:
field = purple_request_field_int_new(prefs->pref, _(prefs->label),
purple_prefs_get_int(prefs->pref));
break;
case PURPLE_PREF_STRING:
field = purple_request_field_string_new(prefs->pref, _(prefs->label),
purple_prefs_get_string(prefs->pref), FALSE);
break;
default:
break;
}
}
else
{
GList *list = prefs->lv(), *iter;
if (list)
field = purple_request_field_list_new(prefs->pref, _(prefs->label));
for (iter = list; iter; iter = iter->next)
{
gboolean select = FALSE;
const char *data = iter->data;
int idata;
iter = iter->next;
switch (prefs->type)
{
case PURPLE_PREF_BOOLEAN:
sscanf(iter->data, "%d", &idata);
if (purple_prefs_get_bool(prefs->pref) == idata)
select = TRUE;
break;
case PURPLE_PREF_INT:
sscanf(iter->data, "%d", &idata);
if (purple_prefs_get_int(prefs->pref) == idata)
select = TRUE;
break;
case PURPLE_PREF_STRING:
if (strcmp(purple_prefs_get_string(prefs->pref), iter->data) == 0)
select = TRUE;
break;
default:
break;
}
purple_request_field_list_add(field, data, iter->data);
if (select)
purple_request_field_list_add_selected(field, data);
}
g_list_free(list);
}
return field;
}
PurpleRequestFields* fields;
PurpleRequestFieldGroup* group;
PurpleRequestField* field;
if ( !session->profile ) {
/* we need to create a profile object here */
session->profile = g_new0( struct MXitProfile, 1 );
}
profile = session->profile;
fields = purple_request_fields_new();
group = purple_request_field_group_new( NULL );
purple_request_fields_add_group( fields, group );
/* mxit login name */
field = purple_request_field_string_new( "loginname", _( "MXit ID" ), purple_account_get_username( session->acc ), FALSE );
purple_request_field_set_sensitive( field, FALSE );
purple_request_field_group_add_field( group, field );
/* nick name (required) */
field = purple_request_field_string_new( "nickname", _( "Display Name" ), profile->nickname, FALSE );
purple_request_field_set_required( field, TRUE );
purple_request_field_group_add_field( group, field );
/* birthday (required) */
field = purple_request_field_string_new( "bday", _( "Birthday" ), profile->birthday, FALSE );
purple_request_field_string_set_default_value( field, "YYYY-MM-DD" );
purple_request_field_set_required( field, TRUE );
purple_request_field_group_add_field( group, field );
/* gender */
void BuddyList::request_add_chat(PurpleAccount *account, PurpleGroup *group,
const char *alias, const char *name)
{
if (!CheckAnyAccountConnected())
return;
if (account) {
PurpleConnection *gc = purple_account_get_connection(account);
if (!PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->join_chat) {
LOG->Message(_("This protocol does not support chat rooms."));
return;
}
}
else {
// find an account with chat capabilities
for (GList *l = purple_connections_get_all(); l; l = l->next) {
PurpleConnection *gc = reinterpret_cast<PurpleConnection*>(l->data);
if (PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->join_chat) {
account = purple_connection_get_account(gc);
break;
}
}
if (!account) {
LOG->Message(_("You are not currently signed on with any "
"protocols that have the ability to chat."));
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", _("Chat name"), NULL, FALSE);
purple_request_field_group_add_field(g, f);
f = purple_request_field_string_new("alias", _("Alias"), NULL, 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)) {
PurpleGroup *cur_group = reinterpret_cast<PurpleGroup*>(i);
const char *cur_name = purple_group_get_name(cur_group);
purple_request_field_choice_add(f, cur_name);
if (!dval_set) {
if (group == cur_group) {
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, _("Chats"));
purple_request_field_group_add_field(g, f);
f = purple_request_field_bool_new("autojoin", _("Auto-join"), FALSE);
purple_request_field_group_add_field(g, f);
purple_request_fields(NULL, _("Add chat"), NULL, NULL, fields, _("Add"),
G_CALLBACK(add_chat_ok_cb_), CANCEL_BUTTON_TEXT, NULL, NULL, NULL, NULL,
this);
}
/*------------------------------------------------------------------------
* Display and update the user's profile.
*
* @param action The action object
*/
static void mxit_profile_action( PurplePluginAction* action )
{
PurpleConnection* gc = (PurpleConnection*) action->context;
struct MXitSession* session = purple_connection_get_protocol_data( gc );
struct MXitProfile* profile = session->profile;
PurpleRequestFields* fields = NULL;
PurpleRequestField* field = NULL;
purple_debug_info( MXIT_PLUGIN_ID, "mxit_profile_action\n" );
/* ensure that we actually have the user's profile information */
if ( !profile ) {
/* no profile information yet, so we cannot update */
mxit_popup( PURPLE_NOTIFY_MSG_WARNING, _( "Profile" ), _( "Your profile information is not yet retrieved. Please try again later." ) );
return;
}
fields = purple_request_fields_new();
/* Public information - what other users can see */
{
PurpleRequestFieldGroup* public_group = purple_request_field_group_new( "Public information" );
/* display name */
field = purple_request_field_string_new( "name", _( "Display Name" ), profile->nickname, FALSE );
purple_request_field_group_add_field( public_group, field );
/* birthday */
field = purple_request_field_string_new( "bday", _( "Birthday" ), profile->birthday, FALSE );
purple_request_field_group_add_field( public_group, field );
if ( profile->flags & CP_PROF_DOBLOCKED )
purple_request_field_set_sensitive( field, FALSE );
/* gender */
field = purple_request_field_choice_new( "male", _( "Gender" ), GINT_TO_POINTER(profile->male ? 1 : 0));
purple_request_field_choice_add( field, _( "Female" ), GINT_TO_POINTER(0));
purple_request_field_choice_add( field, _( "Male" ), GINT_TO_POINTER(1));
purple_request_field_group_add_field( public_group, field );
/* first name */
field = purple_request_field_string_new( "firstname", _( "First Name" ), profile->firstname, FALSE );
purple_request_field_group_add_field( public_group, field );
/* last name */
field = purple_request_field_string_new( "lastname", _( "Last Name" ), profile->lastname, FALSE );
purple_request_field_group_add_field( public_group, field );
/* about me */
field = purple_request_field_string_new( "aboutme", _( "About Me" ), profile->aboutme, FALSE);
purple_request_field_group_add_field( public_group, field );
/* where I live */
field = purple_request_field_string_new( "whereami", _( "Where I Live" ), profile->whereami, FALSE);
purple_request_field_group_add_field( public_group, field );
/* relationship status */
field = purple_request_field_list_new( "relationship", _( "Relationship Status" ) );
purple_request_field_list_set_multi_select( field, FALSE );
purple_request_field_list_add_icon( field, mxit_relationship_to_name( MXIT_RELATIONSHIP_UNKNOWN ), NULL, g_strdup_printf( "%i", MXIT_RELATIONSHIP_UNKNOWN ) );
purple_request_field_list_add_icon( field, mxit_relationship_to_name( MXIT_RELATIONSHIP_DONTSAY ), NULL, g_strdup_printf( "%i", MXIT_RELATIONSHIP_DONTSAY ) );
purple_request_field_list_add_icon( field, mxit_relationship_to_name( MXIT_RELATIONSHIP_SINGLE ), NULL, g_strdup_printf( "%i", MXIT_RELATIONSHIP_SINGLE ) );
purple_request_field_list_add_icon( field, mxit_relationship_to_name( MXIT_RELATIONSHIP_INVOLVED ), NULL, g_strdup_printf( "%i", MXIT_RELATIONSHIP_INVOLVED ) );
purple_request_field_list_add_icon( field, mxit_relationship_to_name( MXIT_RELATIONSHIP_ENGAGED ), NULL, g_strdup_printf( "%i", MXIT_RELATIONSHIP_ENGAGED ) );
purple_request_field_list_add_icon( field, mxit_relationship_to_name( MXIT_RELATIONSHIP_MARRIED ), NULL, g_strdup_printf( "%i", MXIT_RELATIONSHIP_MARRIED ) );
purple_request_field_list_add_icon( field, mxit_relationship_to_name( MXIT_RELATIONSHIP_COMPLICATED ), NULL, g_strdup_printf( "%i", MXIT_RELATIONSHIP_COMPLICATED ) );
purple_request_field_list_add_icon( field, mxit_relationship_to_name( MXIT_RELATIONSHIP_WIDOWED ), NULL, g_strdup_printf( "%i", MXIT_RELATIONSHIP_WIDOWED ) );
purple_request_field_list_add_icon( field, mxit_relationship_to_name( MXIT_RELATIONSHIP_SEPARATED ), NULL, g_strdup_printf( "%i", MXIT_RELATIONSHIP_SEPARATED ) );
purple_request_field_list_add_icon( field, mxit_relationship_to_name( MXIT_RELATIONSHIP_DIVORCED ), NULL, g_strdup_printf( "%i", MXIT_RELATIONSHIP_DIVORCED ) );
purple_request_field_list_add_selected( field, mxit_relationship_to_name( profile->relationship ) );
purple_request_field_group_add_field( public_group, field );
purple_request_fields_add_group( fields, public_group );
}
/* Private information - what only MXit can see */
{
PurpleRequestFieldGroup* private_group = purple_request_field_group_new( "Private information" );
/* title */
field = purple_request_field_string_new( "title", _( "Title" ), profile->title, FALSE );
purple_request_field_group_add_field( private_group, field );
/* email */
field = purple_request_field_string_new( "email", _( "Email" ), profile->email, FALSE );
purple_request_field_group_add_field( private_group, field );
/* mobile number */
field = purple_request_field_string_new( "mobilenumber", _( "Mobile Number" ), profile->mobilenr, FALSE );
purple_request_field_group_add_field( private_group, field );
/* is searchable */
field = purple_request_field_bool_new( "searchable", _( "Can be searched" ), ( ( profile->flags & CP_PROF_NOT_SEARCHABLE ) == 0) );
purple_request_field_group_add_field( private_group, field );
/* is suggestable */
field = purple_request_field_bool_new( "suggestable", _( "Can be suggested" ), ( ( profile->flags & CP_PROF_NOT_SUGGESTABLE ) == 0 ) );
purple_request_field_group_add_field( private_group, field );
purple_request_fields_add_group( fields, private_group );
}
/* (reference: "libpurple/request.h") */
purple_request_fields( gc, _( "Profile" ), _( "Update your MXit Profile" ), NULL, fields, _( "Set" ),
G_CALLBACK( mxit_profile_cb ), _( "Cancel" ), NULL, purple_request_cpar_from_connection(gc), gc );
}
static GntWidget*
process_pref_frame(PurplePluginPrefFrame *frame)
{
PurpleRequestField *field;
PurpleRequestFields *fields;
PurpleRequestFieldGroup *group = NULL;
GList *prefs;
GList *stringlist = NULL;
GntWidget *ret = NULL;
fields = purple_request_fields_new();
for (prefs = purple_plugin_pref_frame_get_prefs(frame); prefs; prefs = prefs->next) {
PurplePluginPref *pref = prefs->data;
PurplePrefType type;
const char *name = purple_plugin_pref_get_name(pref);
const char *label = purple_plugin_pref_get_label(pref);
if(name == NULL) {
if(label == NULL)
continue;
if(purple_plugin_pref_get_pref_type(pref) == PURPLE_PLUGIN_PREF_INFO) {
field = purple_request_field_label_new("*", purple_plugin_pref_get_label(pref));
purple_request_field_group_add_field(group, field);
} else {
group = purple_request_field_group_new(label);
purple_request_fields_add_group(fields, group);
}
continue;
}
field = NULL;
type = purple_prefs_get_pref_type(name);
if(purple_plugin_pref_get_pref_type(pref) == PURPLE_PLUGIN_PREF_CHOICE) {
GList *list = purple_plugin_pref_get_choices(pref);
gpointer current_value = NULL;
switch(type) {
case PURPLE_PREF_BOOLEAN:
current_value = g_strdup_printf("%d", (int)purple_prefs_get_bool(name));
break;
case PURPLE_PREF_INT:
current_value = g_strdup_printf("%d", (int)purple_prefs_get_int(name));
break;
case PURPLE_PREF_STRING:
current_value = g_strdup(purple_prefs_get_string(name));
break;
default:
continue;
}
field = purple_request_field_list_new(name, label);
purple_request_field_list_set_multi_select(field, FALSE);
while (list && list->next) {
const char *label = list->data;
char *value = NULL;
switch(type) {
case PURPLE_PREF_BOOLEAN:
value = g_strdup_printf("%d", GPOINTER_TO_INT(list->next->data));
break;
case PURPLE_PREF_INT:
value = g_strdup_printf("%d", GPOINTER_TO_INT(list->next->data));
break;
case PURPLE_PREF_STRING:
value = g_strdup(list->next->data);
break;
default:
break;
}
stringlist = g_list_prepend(stringlist, value);
purple_request_field_list_add_icon(field, label, NULL, value);
if (strcmp(value, current_value) == 0)
purple_request_field_list_add_selected(field, label);
list = list->next->next;
}
g_free(current_value);
} else {
switch(type) {
case PURPLE_PREF_BOOLEAN:
field = purple_request_field_bool_new(name, label, purple_prefs_get_bool(name));
break;
case PURPLE_PREF_INT:
field = purple_request_field_int_new(name, label, purple_prefs_get_int(name), INT_MIN, INT_MAX);
break;
case PURPLE_PREF_STRING:
field = purple_request_field_string_new(name, label, purple_prefs_get_string(name),
purple_plugin_pref_get_format_type(pref) & PURPLE_STRING_FORMAT_TYPE_MULTILINE);
break;
default:
break;
}
}
if (field) {
if (group == NULL) {
group = purple_request_field_group_new(_("Preferences"));
purple_request_fields_add_group(fields, group);
}
purple_request_field_group_add_field(group, field);
}
}
ret = purple_request_fields(NULL, _("Preferences"), NULL, NULL, fields,
_("Save"), G_CALLBACK(finch_request_save_in_prefs), _("Cancel"), NULL,
NULL, NULL);
g_signal_connect_swapped(G_OBJECT(ret), "destroy", G_CALLBACK(free_stringlist), stringlist);
return ret;
}
static void ggp_pubdir_set_info_dialog(PurpleConnection *gc, int records_count,
const ggp_pubdir_record *records, int next_offset, void *user_data)
{
PurpleRequestFields *fields;
PurpleRequestFieldGroup *group;
PurpleRequestField *field;
gsize i;
const ggp_pubdir_record *record;
purple_debug_info("gg", "ggp_pubdir_set_info_dialog (record: %d)\n",
records_count);
record = (records_count == 1 ? &records[0] : NULL);
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("first_name", _("First name"),
record ? record->first_name : NULL, FALSE);
purple_request_field_group_add_field(group, field);
field = purple_request_field_string_new("last_name", _("Last name"),
record ? record->last_name : NULL, FALSE);
purple_request_field_group_add_field(group, field);
field = purple_request_field_choice_new("gender", _("Gender"),
record ? GINT_TO_POINTER(record->gender) :
GGP_PUBDIR_GENDER_UNSPECIFIED);
purple_request_field_set_required(field, TRUE);
purple_request_field_choice_add(field, _("Male"),
GINT_TO_POINTER(GGP_PUBDIR_GENDER_MALE));
purple_request_field_choice_add(field, _("Female"),
GINT_TO_POINTER(GGP_PUBDIR_GENDER_FEMALE));
purple_request_field_group_add_field(group, field);
field = purple_request_field_string_new("birth_date", _("Birth Day"),
(record && record->birth) ?
ggp_date_strftime("%Y-%m-%d", record->birth) : NULL, FALSE);
purple_request_field_set_required(field, TRUE);
purple_request_field_group_add_field(group, field);
field = purple_request_field_string_new("city", _("City"),
record ? record->city : NULL, FALSE);
purple_request_field_group_add_field(group, field);
/* Translators: This word is basically used to describe a Polish
province. Gadu-Gadu users outside of Poland might choose to enter some
equivalent value for themselves. For example, users in the USA might
use their state (e.g. New York). If there is an equivalent term for
your language, feel free to use it. Otherwise it's probably acceptable
to leave it changed or transliterate it into your alphabet. */
field = purple_request_field_choice_new("province", _("Voivodeship"), 0);
purple_request_field_group_add_field(group, field);
for (i = 0; i < ggp_pubdir_provinces_count; i++) {
purple_request_field_choice_add(field, ggp_pubdir_provinces[i],
GINT_TO_POINTER(i));
if (record && i == record->province) {
purple_request_field_choice_set_value(field, GINT_TO_POINTER(i));
purple_request_field_choice_set_default_value(field, GINT_TO_POINTER(i));
}
}
purple_request_fields(gc, _("Set User Info"), _("Set User Info"),
NULL, fields,
_("OK"), G_CALLBACK(ggp_pubdir_set_info_request),
_("Cancel"), NULL,
purple_request_cpar_from_connection(gc), gc);
}
