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