291 lines
7.1 KiB
C++
291 lines
7.1 KiB
C++
#include <scene/gui/control.h>
|
|
#include <scene/gui/box_container.h>
|
|
#include <scene/gui/panel_container.h>
|
|
#include <scene/gui/tab_container.h>
|
|
#include <scene/gui/scroll_container.h>
|
|
#include <scene/gui/label.h>
|
|
#include <scene/gui/line_edit.h>
|
|
#include <scene/gui/button.h>
|
|
#include <scene/gui/option_button.h>
|
|
#include <scene/gui/item_list.h>
|
|
#include <scene/gui/menu_button.h>
|
|
#include <scene/gui/spin_box.h>
|
|
#include <scene/gui/separator.h>
|
|
#include "base_data.h"
|
|
#include "world_editor.h"
|
|
#include "handle_cmd_button.h"
|
|
#include "handle_event_button.h"
|
|
#include "handle_building_type.h"
|
|
#include "handle_buildings_editor_mode.h"
|
|
#include "ui_field_builder.h"
|
|
|
|
Vector<Object *> ui_field::c_handlers;
|
|
void ui_field::ui_field_builder(Node *owner, Node *parent, const String format,
|
|
const Variant *args, int args_size,
|
|
HashMap<String, Object *> *saved_nodes)
|
|
{
|
|
int argp = 0, i;
|
|
List<Node *> stack;
|
|
int fmt_size = (int)format.length();
|
|
Control *last_created = nullptr;
|
|
flecs::world ecs = BaseData::get_singleton()->get();
|
|
flecs::entity world_editor_e = ecs.lookup("world_editor");
|
|
WorldEditor *we =
|
|
world_editor_e
|
|
.get<WorldEditor::components::world_editor_node>()
|
|
->node;
|
|
BuildingsEditor *be =
|
|
world_editor_e
|
|
.get<WorldEditor::components::buildings_editor_node>()
|
|
->node;
|
|
assert(owner->is_inside_tree());
|
|
for (i = 0; i < format.length(); i++) {
|
|
const char *fmt = format.ascii().ptr();
|
|
int c = fmt[i];
|
|
printf("character: %c : argp: %d\n", (char)c, argp);
|
|
switch (c) {
|
|
case '{':
|
|
stack.push_front(parent);
|
|
parent = last_created;
|
|
break;
|
|
case '}':
|
|
parent = stack.front()->get();
|
|
stack.pop_front();
|
|
break;
|
|
case '#': {
|
|
assert(argp < args_size);
|
|
String name = args[argp++];
|
|
assert(name.length() > 0);
|
|
last_created->set_name(name);
|
|
printf("set name: %s\n", name.ascii().ptr());
|
|
} break;
|
|
case '$': {
|
|
if (saved_nodes)
|
|
(*saved_nodes)[last_created->get_name()] =
|
|
last_created;
|
|
} break;
|
|
case '.':
|
|
assert(argp < args_size);
|
|
last_created->set_custom_minimum_size(args[argp++]);
|
|
break;
|
|
case '!':
|
|
last_created->set_unique_name_in_owner(true);
|
|
break;
|
|
case '+':
|
|
assert(argp < args_size);
|
|
last_created->set_h_size_flags(args[argp++]);
|
|
break;
|
|
case '=':
|
|
assert(argp < args_size);
|
|
last_created->set_v_size_flags(args[argp++]);
|
|
break;
|
|
case '*': {
|
|
assert(argp + 1 < args_size);
|
|
assert(args[argp].get_type() == Variant::INT);
|
|
assert(args[argp + 1].get_type() == Variant::REAL);
|
|
Margin m = args[argp++];
|
|
float value = args[argp++];
|
|
last_created->set_anchor(m, value);
|
|
} break;
|
|
case 'v':
|
|
case 'h':
|
|
if (c == 'v') {
|
|
VBoxContainer *vb = memnew(VBoxContainer);
|
|
parent->add_child(vb);
|
|
vb->set_owner(owner);
|
|
last_created = vb;
|
|
} else {
|
|
HBoxContainer *hb = memnew(HBoxContainer);
|
|
parent->add_child(hb);
|
|
hb->set_owner(owner);
|
|
last_created = hb;
|
|
}
|
|
break;
|
|
case 'p': {
|
|
PanelContainer *p = memnew(PanelContainer);
|
|
parent->add_child(p);
|
|
p->set_owner(owner);
|
|
last_created = p;
|
|
} break;
|
|
case 't': {
|
|
TabContainer *t = memnew(TabContainer);
|
|
parent->add_child(t);
|
|
t->set_owner(owner);
|
|
last_created = t;
|
|
} break;
|
|
case 's': {
|
|
ScrollContainer *sc = memnew(ScrollContainer);
|
|
parent->add_child(sc);
|
|
sc->set_owner(owner);
|
|
last_created = sc;
|
|
} break;
|
|
case 'l':
|
|
case 'L':
|
|
assert(i < fmt_size - 1);
|
|
assert(argp < args_size);
|
|
{
|
|
Label *l = memnew(Label);
|
|
l->set_text(args[argp++]);
|
|
parent->add_child(l);
|
|
l->set_owner(owner);
|
|
last_created = l;
|
|
}
|
|
break;
|
|
case 'e':
|
|
case 'E':
|
|
assert(i < fmt_size);
|
|
assert(argp < args_size);
|
|
{
|
|
LineEdit *l = memnew(LineEdit);
|
|
assert(argp < args_size);
|
|
l->set_text(args[argp++]);
|
|
parent->add_child(l);
|
|
l->set_owner(owner);
|
|
last_created = l;
|
|
}
|
|
break;
|
|
case 'b':
|
|
case 'B':
|
|
assert(argp < args_size);
|
|
{
|
|
Button *b = memnew(Button);
|
|
assert(argp < args_size);
|
|
b->set_text(args[argp++]);
|
|
parent->add_child(b);
|
|
b->set_owner(owner);
|
|
last_created = b;
|
|
}
|
|
break;
|
|
case 'o':
|
|
assert(argp < args_size);
|
|
{
|
|
int j, count;
|
|
OptionButton *b = memnew(OptionButton);
|
|
assert(argp < args_size);
|
|
b->set_text(args[argp++]);
|
|
parent->add_child(b);
|
|
b->set_owner(owner);
|
|
assert(argp < args_size);
|
|
count = args[argp++];
|
|
for (j = 0; j < count; j++) {
|
|
assert(argp < args_size);
|
|
int id = args[argp++];
|
|
assert(argp < args_size);
|
|
String text = args[argp++];
|
|
b->add_item(text, id);
|
|
}
|
|
last_created = b;
|
|
}
|
|
break;
|
|
case 'i':
|
|
assert(argp < args_size);
|
|
{
|
|
int j, count;
|
|
ItemList *l = memnew(ItemList);
|
|
assert(argp < args_size);
|
|
parent->add_child(l);
|
|
l->set_owner(owner);
|
|
assert(argp < args_size);
|
|
count = args[argp++];
|
|
for (j = 0; j < count; j++) {
|
|
assert(argp < args_size);
|
|
String text = args[argp++];
|
|
l->add_item(text);
|
|
}
|
|
last_created = l;
|
|
}
|
|
break;
|
|
case 'm':
|
|
assert(argp < args_size);
|
|
{
|
|
int j, count;
|
|
MenuButton *b = memnew(MenuButton);
|
|
assert(argp < args_size);
|
|
b->set_text(args[argp++]);
|
|
parent->add_child(b);
|
|
b->set_owner(owner);
|
|
assert(argp < args_size);
|
|
count = args[argp++];
|
|
for (j = 0; j < count; j++) {
|
|
assert(argp < args_size);
|
|
int id = args[argp++];
|
|
assert(argp < args_size);
|
|
String text = args[argp++];
|
|
assert(argp < args_size);
|
|
bool checkable = args[argp++];
|
|
if (id == -1)
|
|
b->get_popup()->add_separator(
|
|
text, id);
|
|
else {
|
|
if (checkable)
|
|
b->get_popup()
|
|
->add_check_item(
|
|
text,
|
|
id);
|
|
else
|
|
b->get_popup()->add_item(
|
|
text, id);
|
|
}
|
|
}
|
|
b->set_switch_on_hover(true);
|
|
last_created = b;
|
|
}
|
|
break;
|
|
case 'x': {
|
|
SpinBox *sp = memnew(SpinBox);
|
|
parent->add_child(sp);
|
|
sp->set_owner(owner);
|
|
last_created = sp;
|
|
} break;
|
|
case '_': {
|
|
HSeparator *hs = memnew(HSeparator);
|
|
parent->add_child(hs);
|
|
hs->set_owner(owner);
|
|
last_created = hs;
|
|
} break;
|
|
case '|': {
|
|
VSeparator *vs = memnew(VSeparator);
|
|
parent->add_child(vs);
|
|
vs->set_owner(owner);
|
|
last_created = vs;
|
|
} break;
|
|
case 'q': {
|
|
assert(argp + 1 < args_size);
|
|
Button *b = Object::cast_to<Button>(last_created);
|
|
assert(b);
|
|
HandleCmdButton *cmd = memnew(HandleCmdButton(
|
|
b, we, args[argp++], args[argp++]));
|
|
c_handlers.push_back(cmd);
|
|
} break;
|
|
case 'Q': {
|
|
assert(argp + 1 < args_size);
|
|
Button *b = Object::cast_to<Button>(last_created);
|
|
assert(b);
|
|
HandleEventButton *cmd = memnew(HandleEventButton(
|
|
b, be, args[argp++], args[argp++]));
|
|
c_handlers.push_back(cmd);
|
|
} break;
|
|
case 'T': {
|
|
assert(argp < args_size);
|
|
OptionButton *b =
|
|
Object::cast_to<OptionButton>(last_created);
|
|
assert(b);
|
|
HandleBuildingType *cmd =
|
|
memnew(HandleBuildingType(b, be));
|
|
c_handlers.push_back(cmd);
|
|
} break;
|
|
case 'M': {
|
|
assert(argp < args_size);
|
|
OptionButton *b =
|
|
Object::cast_to<OptionButton>(last_created);
|
|
assert(b);
|
|
HandleBuildingsEditorMode *cmd =
|
|
memnew(HandleBuildingsEditorMode(b, be));
|
|
c_handlers.push_back(cmd);
|
|
} break;
|
|
default:
|
|
printf("bad character %c\n", (char)c);
|
|
assert(false);
|
|
}
|
|
}
|
|
} |