void
purple_request_fields_add_group(PurpleRequestFields *fields,
PurpleRequestFieldGroup *group)
{
GList *l;
PurpleRequestField *field;
g_return_if_fail(fields != NULL);
g_return_if_fail(group != NULL);
fields->groups = g_list_append(fields->groups, group);
group->fields_list = fields;
for (l = purple_request_field_group_get_fields(group);
l != NULL;
l = l->next) {
field = l->data;
g_hash_table_insert(fields->fields,
g_strdup(purple_request_field_get_id(field)), field);
if (purple_request_field_is_required(field)) {
fields->required_fields =
g_list_append(fields->required_fields, field);
}
}
}
void finch_request_save_in_prefs(gpointer null, PurpleRequestFields *allfields)
{
GList *list;
for (list = purple_request_fields_get_groups(allfields); list; list = list->next) {
PurpleRequestFieldGroup *group = list->data;
GList *fields = purple_request_field_group_get_fields(group);
for (; fields ; fields = fields->next) {
PurpleRequestField *field = fields->data;
PurpleRequestFieldType type = purple_request_field_get_type(field);
PurplePrefType pt;
gpointer val = NULL;
const char *id = purple_request_field_get_id(field);
switch (type) {
case PURPLE_REQUEST_FIELD_LIST:
val = purple_request_field_list_get_selected(field)->data;
break;
case PURPLE_REQUEST_FIELD_BOOLEAN:
val = GINT_TO_POINTER(purple_request_field_bool_get_value(field));
break;
case PURPLE_REQUEST_FIELD_INTEGER:
val = GINT_TO_POINTER(purple_request_field_int_get_value(field));
break;
case PURPLE_REQUEST_FIELD_STRING:
val = (gpointer)purple_request_field_string_get_value(field);
break;
default:
break;
}
pt = purple_prefs_get_type(id);
switch (pt) {
case PURPLE_PREF_INT:
{
long int tmp = GPOINTER_TO_INT(val);
if (type == PURPLE_REQUEST_FIELD_LIST) /* Lists always return string */
sscanf(val, "%ld", &tmp);
purple_prefs_set_int(id, (gint)tmp);
break;
}
case PURPLE_PREF_BOOLEAN:
purple_prefs_set_bool(id, GPOINTER_TO_INT(val));
break;
case PURPLE_PREF_STRING:
purple_prefs_set_string(id, val);
break;
default:
break;
}
}
}
}
static void *
finch_request_fields(const char *title, const char *primary,
const char *secondary, PurpleRequestFields *allfields,
const char *ok, GCallback ok_cb,
const char *cancel, GCallback cancel_cb,
PurpleAccount *account, const char *who, PurpleConversation *conv,
void *userdata)
{
GntWidget *window, *box;
GList *grlist;
GntWidget *screenname = NULL, *accountlist = NULL;
window = setup_request_window(title, primary, secondary, PURPLE_REQUEST_FIELDS);
/* This is how it's going to work: the request-groups are going to be
* stacked vertically one after the other. A GntLine will be separating
* the groups. */
box = gnt_vbox_new(FALSE);
gnt_box_set_pad(GNT_BOX(box), 0);
gnt_box_set_fill(GNT_BOX(box), TRUE);
for (grlist = purple_request_fields_get_groups(allfields); grlist; grlist = grlist->next)
{
PurpleRequestFieldGroup *group = grlist->data;
GList *fields = purple_request_field_group_get_fields(group);
GntWidget *hbox;
const char *title = purple_request_field_group_get_title(group);
if (title)
gnt_box_add_widget(GNT_BOX(box),
gnt_label_new_with_format(title, GNT_TEXT_FLAG_BOLD));
for (; fields ; fields = fields->next)
{
/* XXX: Break each of the fields into a separate function? */
PurpleRequestField *field = fields->data;
PurpleRequestFieldType type = purple_request_field_get_type(field);
const char *label = purple_request_field_get_label(field);
hbox = gnt_hbox_new(TRUE); /* hrm */
gnt_box_add_widget(GNT_BOX(box), hbox);
if (type != PURPLE_REQUEST_FIELD_BOOLEAN && label)
{
GntWidget *l;
if (purple_request_field_is_required(field))
l = gnt_label_new_with_format(label, GNT_TEXT_FLAG_UNDERLINE);
else
l = gnt_label_new(label);
gnt_widget_set_size(l, 0, 1);
gnt_box_add_widget(GNT_BOX(hbox), l);
}
if (type == PURPLE_REQUEST_FIELD_BOOLEAN)
{
FINCH_SET_DATA(field, create_boolean_field(field));
}
else if (type == PURPLE_REQUEST_FIELD_STRING)
{
FINCH_SET_DATA(field, create_string_field(field, &screenname));
}
else if (type == PURPLE_REQUEST_FIELD_INTEGER)
{
FINCH_SET_DATA(field, create_integer_field(field));
}
else if (type == PURPLE_REQUEST_FIELD_CHOICE)
{
FINCH_SET_DATA(field, create_choice_field(field));
}
else if (type == PURPLE_REQUEST_FIELD_LIST)
{
FINCH_SET_DATA(field, create_list_field(field));
}
else if (type == PURPLE_REQUEST_FIELD_ACCOUNT)
{
accountlist = FINCH_SET_DATA(field, create_account_field(field));
}
else
{
FINCH_SET_DATA(field, gnt_label_new_with_format(_("Not implemented yet."),
GNT_TEXT_FLAG_BOLD));
}
gnt_box_set_alignment(GNT_BOX(hbox), GNT_ALIGN_MID);
gnt_box_add_widget(GNT_BOX(hbox), GNT_WIDGET(FINCH_GET_DATA(field)));
}
if (grlist->next)
gnt_box_add_widget(GNT_BOX(box), gnt_hline_new());
}
gnt_box_add_widget(GNT_BOX(window), box);
box = setup_button_box(window, userdata, request_fields_cb, allfields,
ok, ok_cb, cancel, cancel_cb, NULL);
gnt_box_add_widget(GNT_BOX(window), box);
setup_default_callback(window, cancel_cb, userdata);
gnt_widget_show(window);
if (screenname && accountlist) {
g_signal_connect(screenname, "completion", G_CALLBACK(update_selected_account), accountlist);
}
g_object_set_data(G_OBJECT(window), "fields", allfields);
return window;
}
static void
request_fields_cb(GntWidget *button, PurpleRequestFields *fields)
{
PurpleRequestFieldsCb callback = g_object_get_data(G_OBJECT(button), "activate-callback");
gpointer data = g_object_get_data(G_OBJECT(button), "activate-userdata");
GList *list;
/* Update the data of the fields. Pidgin does this differently. Instead of
* updating the fields at the end like here, it updates the appropriate field
* instantly whenever a change is made. That allows it to make sure the
* 'required' fields are entered before the user can hit OK. It's not the case
* here, althought it can be done. */
for (list = purple_request_fields_get_groups(fields); list; list = list->next)
{
PurpleRequestFieldGroup *group = list->data;
GList *fields = purple_request_field_group_get_fields(group);
for (; fields ; fields = fields->next)
{
PurpleRequestField *field = fields->data;
PurpleRequestFieldType type = purple_request_field_get_type(field);
if (type == PURPLE_REQUEST_FIELD_BOOLEAN)
{
GntWidget *check = FINCH_GET_DATA(field);
gboolean value = gnt_check_box_get_checked(GNT_CHECK_BOX(check));
purple_request_field_bool_set_value(field, value);
}
else if (type == PURPLE_REQUEST_FIELD_STRING)
{
GntWidget *entry = FINCH_GET_DATA(field);
const char *text = gnt_entry_get_text(GNT_ENTRY(entry));
purple_request_field_string_set_value(field, (text && *text) ? text : NULL);
}
else if (type == PURPLE_REQUEST_FIELD_INTEGER)
{
GntWidget *entry = FINCH_GET_DATA(field);
const char *text = gnt_entry_get_text(GNT_ENTRY(entry));
int value = (text && *text) ? atoi(text) : 0;
purple_request_field_int_set_value(field, value);
}
else if (type == PURPLE_REQUEST_FIELD_CHOICE)
{
GntWidget *combo = FINCH_GET_DATA(field);
int id;
id = GPOINTER_TO_INT(gnt_combo_box_get_selected_data(GNT_COMBO_BOX(combo)));
purple_request_field_choice_set_value(field, id);
}
else if (type == PURPLE_REQUEST_FIELD_LIST)
{
GList *list = NULL;
if (purple_request_field_list_get_multi_select(field))
{
GList *iter;
GntWidget *tree = FINCH_GET_DATA(field);
iter = purple_request_field_list_get_items(field);
for (; iter; iter = iter->next)
{
const char *text = iter->data;
gpointer key = purple_request_field_list_get_data(field, text);
if (gnt_tree_get_choice(GNT_TREE(tree), key))
list = g_list_prepend(list, key);
}
}
else
{
GntWidget *combo = FINCH_GET_DATA(field);
gpointer data = gnt_combo_box_get_selected_data(GNT_COMBO_BOX(combo));
list = g_list_append(list, data);
}
purple_request_field_list_set_selected(field, list);
g_list_free(list);
}
else if (type == PURPLE_REQUEST_FIELD_ACCOUNT)
{
GntWidget *combo = FINCH_GET_DATA(field);
PurpleAccount *acc = gnt_combo_box_get_selected_data(GNT_COMBO_BOX(combo));
purple_request_field_account_set_value(field, acc);
}
}
}
purple_notify_close_with_handle(button);
if (!g_object_get_data(G_OBJECT(button), "cancellation-function") &&
!purple_request_fields_all_required_filled(fields)) {
purple_notify_error(button, _("Error"),
_("You must fill all the required fields."),
_("The required fields are underlined."));
return;
}
if (callback)
callback(data, fields);
while (button->parent)
button = button->parent;
purple_request_close(PURPLE_REQUEST_FIELDS, button);
}
QuetzalFieldsDialog::QuetzalFieldsDialog(const char *title, const char *primary,
const char *secondary, PurpleRequestFields *fields,
const char *ok_text, GCallback ok_cb,
const char *cancel_text, GCallback cancel_cb,
void *user_data, QWidget *parent)
: QuetzalRequestDialog(PURPLE_REQUEST_FIELDS, user_data, parent)
{
m_ok_cb = (PurpleRequestFieldsCb) ok_cb;
m_cancel_cb = (PurpleRequestFieldsCb) cancel_cb;
m_fields = fields;
DataItem root = createItem(title, primary, secondary);
GList *group_it = purple_request_fields_get_groups(m_fields);
bool useGroupBox = group_it->next;
debug() << "useGroupBox" << useGroupBox;
for (; group_it; group_it = group_it->next) {
PurpleRequestFieldGroup *group = reinterpret_cast<PurpleRequestFieldGroup*>(group_it->data);
DataItem groupItem;
if (useGroupBox)
groupItem = DataItem(purple_request_field_group_get_title(group));
GList *field_it = purple_request_field_group_get_fields(group);
for (; field_it; field_it = field_it->next) {
PurpleRequestField *field = reinterpret_cast<PurpleRequestField*>(field_it->data);
debug() << field->id << purple_request_field_is_visible(field)
<< purple_request_field_get_type(field);
if (!purple_request_field_is_visible(field))
continue;
DataItem item(purple_request_field_get_id(field),
purple_request_field_get_label(field),
QVariant());
switch (purple_request_field_get_type(field)) {
case PURPLE_REQUEST_FIELD_STRING:
item.setData(QString::fromUtf8(purple_request_field_string_get_default_value(field)));
item.setProperty("multiline", purple_request_field_string_is_multiline(field));
item.setProperty("password", bool(purple_request_field_string_is_masked(field)));
item.setReadOnly(!purple_request_field_string_is_editable(field));
debug() << item.name() << item.data() << item.property("password") << item.isReadOnly();
break;
case PURPLE_REQUEST_FIELD_INTEGER:
item.setData(purple_request_field_int_get_default_value(field));
item.setProperty("minValue", G_MININT);
item.setProperty("maxValue", G_MAXINT);
break;
case PURPLE_REQUEST_FIELD_BOOLEAN:
item.setData(bool(purple_request_field_bool_get_default_value(field)));
break;
case PURPLE_REQUEST_FIELD_CHOICE:
{
GList *labels = purple_request_field_choice_get_labels(field);
QStringList alternatives;
for (; labels; labels = labels->next)
alternatives << QString::fromUtf8(reinterpret_cast<char*>(labels->data));
item.setData(alternatives.value(purple_request_field_choice_get_default_value(field)));
item.setProperty("alternatives", alternatives);
}
break;
case PURPLE_REQUEST_FIELD_LIST:
break;
case PURPLE_REQUEST_FIELD_LABEL:
item.setData(purple_request_field_get_label(field));
item.setReadOnly(true);
item.setProperty("hideTitle", true);
break;
case PURPLE_REQUEST_FIELD_IMAGE:
{
QImageReader reader;
QByteArray data = QByteArray::fromRawData(purple_request_field_image_get_buffer(field),
purple_request_field_image_get_size(field));
QBuffer buffer(&data);
reader.setDevice(&buffer);
QSize imageSize = reader.size();
if (imageSize.isValid()) {
imageSize.setWidth(imageSize.width() * purple_request_field_image_get_scale_x(field));
imageSize.setHeight(imageSize.height() * purple_request_field_image_get_scale_y(field));
reader.setScaledSize(imageSize);
}
item.setData(qVariantFromValue(reader.read()));
item.setProperty("imageSize", qVariantFromValue(imageSize));
item.setReadOnly(true);
}
break;
case PURPLE_REQUEST_FIELD_ACCOUNT:
break;
case PURPLE_REQUEST_FIELD_NONE:
default:
continue;
}
item.setProperty("mandatory", purple_request_field_is_required(field));
if (useGroupBox)
groupItem.addSubitem(item);
else
root.addSubitem(item);
}
if (useGroupBox)
root.addSubitem(groupItem);
}
createItem(root, ok_text, cancel_text);
return;
}
Request::FieldsDialog::FieldsDialog(const char *title, const char *primary,
const char *secondary, PurpleRequestFields *request_fields,
const char *ok_text, GCallback ok_cb, const char *cancel_text,
GCallback cancel_cb, void *user_data)
: RequestDialog(title, primary, secondary, ok_text, ok_cb, cancel_text,
cancel_cb, user_data), fields(request_fields)
{
tree = new CppConsUI::TreeView(AUTOSIZE, AUTOSIZE);
lbox->AppendWidget(*tree);
bool grouping = true;
GList *groups = purple_request_fields_get_groups(fields);
if (!groups)
return;
if (!purple_request_field_group_get_title(
reinterpret_cast<PurpleRequestFieldGroup*>(groups->data))
&& !groups->next)
grouping = false;
for (; groups; groups = groups->next) {
PurpleRequestFieldGroup *group
= reinterpret_cast<PurpleRequestFieldGroup*>(groups->data);
CppConsUI::TreeView::NodeReference parent = tree->GetRootNode();
if (grouping) {
const char *title = purple_request_field_group_get_title(group);
if (!title)
title = _("Settings group");
CppConsUI::TreeView::ToggleCollapseButton *button
= new CppConsUI::TreeView::ToggleCollapseButton(title);
parent = tree->AppendNode(tree->GetRootNode(), *button);
}
for (GList *gfields = purple_request_field_group_get_fields(group);
gfields; gfields = gfields->next) {
PurpleRequestField *field
= reinterpret_cast<PurpleRequestField*>(gfields->data);
if (!purple_request_field_is_visible(field))
continue;
PurpleRequestFieldType type = purple_request_field_get_type(field);
switch (type) {
case PURPLE_REQUEST_FIELD_STRING:
tree->AppendNode(parent, *(new StringField(field)));
break;
case PURPLE_REQUEST_FIELD_INTEGER:
tree->AppendNode(parent, *(new IntegerField(field)));
break;
case PURPLE_REQUEST_FIELD_BOOLEAN:
tree->AppendNode(parent, *(new BooleanField(field)));
break;
case PURPLE_REQUEST_FIELD_CHOICE:
tree->AppendNode(parent, *(new ChoiceField(field)));
break;
case PURPLE_REQUEST_FIELD_LIST:
if (purple_request_field_list_get_multi_select(field))
tree->AppendNode(parent, *(new ListFieldMultiple(field)));
else
tree->AppendNode(parent, *(new ListFieldSingle(field)));
break;
case PURPLE_REQUEST_FIELD_LABEL:
tree->AppendNode(parent, *(new LabelField(field)));
break;
case PURPLE_REQUEST_FIELD_IMAGE:
tree->AppendNode(parent, *(new ImageField(field)));
break;
case PURPLE_REQUEST_FIELD_ACCOUNT:
tree->AppendNode(parent, *(new AccountField(field)));
break;
default:
LOG->Error(_("Unimplemented Request field type."));
break;
}
}
}
}
