PulseStudio/VoxelEngine
PulseStudio/VoxelEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

refactor & optimize xml parser

Browse Source
This commit is contained in:
MihailRis 2024-12-05 20:12:02 +03:00
parent 04b6b6b546
commit 84b3b82dba
6 changed files with 384 additions and 376 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/coders/json.cpp
View File

@ -11,15 +11,17 @@
using namespace json;
class Parser : BasicParser {
dv::value parseList();
dv::value parseObject();
dv::value parseValue();
public:
Parser(std::string_view filename, std::string_view source);
namespace {
class Parser : BasicParser {
dv::value parseList();
dv::value parseObject();
dv::value parseValue();
public:
Parser(std::string_view filename, std::string_view source);
dv::value parse();
};
dv::value parse();
};
}
inline void newline(
std::stringstream& ss, bool nice, uint indent, const std::string& indentstr

342
src/coders/xml.cpp
View File

@ -107,8 +107,8 @@ glm::vec4 Attribute::asColor() const {
Node::Node(std::string tag) : tag(std::move(tag)) {
}
void Node::add(const xmlelement& element) {
elements.push_back(element);
void Node::add(std::unique_ptr<Node> element) {
elements.push_back(std::move(element));
}
void Node::set(const std::string& name, const std::string& text) {
@ -119,7 +119,7 @@ const std::string& Node::getTag() const {
return tag;
}
const xmlattribute& Node::attr(const std::string& name) const {
const Attribute& Node::attr(const std::string& name) const {
auto found = attrs.find(name);
if (found == attrs.end()) {
throw std::runtime_error(
@ -129,7 +129,7 @@ const xmlattribute& Node::attr(const std::string& name) const {
return found->second;
}
xmlattribute Node::attr(const std::string& name, const std::string& def) const {
Attribute Node::attr(const std::string& name, const std::string& def) const {
auto found = attrs.find(name);
if (found == attrs.end()) {
return Attribute(name, def);
@ -142,19 +142,23 @@ bool Node::has(const std::string& name) const {
return found != attrs.end();
}
xmlelement Node::sub(size_t index) {
return elements.at(index);
Node& Node::sub(size_t index) {
return *elements.at(index);
}
const Node& Node::sub(size_t index) const {
return *elements.at(index);
}
size_t Node::size() const {
return elements.size();
}
const std::vector<xmlelement>& Node::getElements() const {
const std::vector<std::unique_ptr<Node>>& Node::getElements() const {
return elements;
}
const xmlelements_map& Node::getAttributes() const {
const std::unordered_map<std::string, Attribute>& Node::getAttributes() const {
return attrs;
}
@ -162,12 +166,12 @@ Document::Document(std::string version, std::string encoding)
: version(std::move(version)), encoding(std::move(encoding)) {
}
void Document::setRoot(const xmlelement& element) {
this->root = element;
void Document::setRoot(std::unique_ptr<Node> element) {
root = std::move(element);
}
xmlelement Document::getRoot() const {
return root;
const Node* Document::getRoot() const {
return root.get();
}
const std::string& Document::getVersion() const {
@ -178,82 +182,6 @@ const std::string& Document::getEncoding() const {
return encoding;
}
Parser::Parser(std::string_view filename, std::string_view source)
: BasicParser(filename, source) {
}
xmlelement Parser::parseOpenTag() {
std::string tag = parseXMLName();
auto node = std::make_shared<Node>(tag);
char c;
while (true) {
skipWhitespace();
c = peek();
if (c == '/' || c == '>' || c == '?') break;
std::string attrname = parseXMLName();
std::string attrtext = "";
skipWhitespace();
if (peek() == '=') {
nextChar();
skipWhitespace();
char quote = peek();
if (quote != '\'' && quote != '"') {
throw error("string literal expected");
}
skip(1);
attrtext = parseString(quote);
}
node->set(attrname, attrtext);
}
return node;
}
void Parser::parseDeclaration() {
std::string version = "1.0";
std::string encoding = "UTF-8";
expect('<');
if (peek() == '?') {
nextChar();
xmlelement node = parseOpenTag();
expect("?>");
if (node->getTag() != "xml") {
throw error("invalid declaration");
}
version = node->attr("version", version).getText();
encoding = node->attr("encoding", encoding).getText();
if (encoding != "utf-8" && encoding != "UTF-8") {
throw error("UTF-8 encoding is only supported");
}
} else {
goBack();
}
document = std::make_shared<Document>(version, encoding);
}
void Parser::parseComment() {
expect("!--");
if (skipTo("-->")) {
skip(3);
} else {
throw error("comment close missing");
}
}
std::string Parser::parseText() {
size_t start = pos;
while (hasNext()) {
char c = peek();
if (c == '<') {
break;
}
nextChar();
}
return Parser("[string]", std::string(source.substr(start, pos - start)))
.parseString('\0', false);
}
inline bool is_xml_identifier_start(char c) {
return is_identifier_start(c) || c == ':';
}
@ -262,82 +190,166 @@ inline bool is_xml_identifier_part(char c) {
return is_identifier_part(c) || c == '-' || c == '.' || c == ':';
}
std::string Parser::parseXMLName() {
char c = peek();
if (!is_xml_identifier_start(c)) {
throw error("identifier expected");
}
int start = pos;
while (hasNext() && is_xml_identifier_part(source[pos])) {
pos++;
}
return std::string(source.substr(start, pos - start));
}
namespace {
class Parser : BasicParser {
std::unique_ptr<Document> document;
xmlelement Parser::parseElement() {
// text element
if (peek() != '<') {
auto element = std::make_shared<Node>("#");
auto text = parseText();
util::replaceAll(text, "&quot;", "\"");
util::replaceAll(text, "&apos;", "'");
util::replaceAll(text, "&lt;", "<");
util::replaceAll(text, "&gt;", ">");
util::replaceAll(text, "&amp;", "&");
element->set("#", text);
std::unique_ptr<Node> parseOpenTag() {
std::string tag = parseXMLName();
auto node = std::make_unique<Node>(tag);
char c;
while (true) {
skipWhitespace();
c = peek();
if (c == '/' || c == '>' || c == '?') break;
std::string attrname = parseXMLName();
std::string attrtext = "";
skipWhitespace();
if (peek() == '=') {
nextChar();
skipWhitespace();
char quote = peek();
if (quote != '\'' && quote != '"') {
throw error("string literal expected");
}
skip(1);
attrtext = parseString(quote);
}
node->set(attrname, attrtext);
}
return node;
}
std::unique_ptr<Node> parseElement() {
// text element
if (peek() != '<') {
auto element = std::make_unique<Node>("#");
auto text = parseText();
util::replaceAll(text, "&quot;", "\"");
util::replaceAll(text, "&apos;", "'");
util::replaceAll(text, "&lt;", "<");
util::replaceAll(text, "&gt;", ">");
util::replaceAll(text, "&amp;", "&");
element->set("#", text);
return element;
}
nextChar();
// <!--element-->
if (peek() == '!') {
if (isNext("!DOCTYPE ")) {
throw error("XML DTD is not supported yet");
}
parseComment();
return nullptr;
}
auto element = parseOpenTag();
char c = nextChar();
// <element/>
if (c == '/') {
expect('>');
}
// <element>...</element>
else if (c == '>') {
skipWhitespace();
while (!isNext("</")) {
auto sub = parseElement();
if (sub) {
element->add(std::move(sub));
}
skipWhitespace();
}
skip(2);
expect(element->getTag());
expect('>');
}
// <element?>
else {
throw error("invalid syntax");
}
return element;
}
nextChar();
// <!--element-->
if (peek() == '!') {
if (isNext("!DOCTYPE ")) {
throw error("XML DTD is not supported yet");
}
parseComment();
return nullptr;
}
auto element = parseOpenTag();
char c = nextChar();
// <element/>
if (c == '/') {
expect('>');
}
// <element>...</element>
else if (c == '>') {
skipWhitespace();
while (!isNext("</")) {
auto sub = parseElement();
if (sub) {
element->add(sub);
void parseDeclaration() {
std::string version = "1.0";
std::string encoding = "UTF-8";
expect('<');
if (peek() == '?') {
nextChar();
auto node = parseOpenTag();
expect("?>");
if (node->getTag() != "xml") {
throw error("invalid declaration");
}
skipWhitespace();
version = node->attr("version", version).getText();
encoding = node->attr("encoding", encoding).getText();
if (encoding != "utf-8" && encoding != "UTF-8") {
throw error("UTF-8 encoding is only supported");
}
} else {
goBack();
}
skip(2);
expect(element->getTag());
expect('>');
document = std::make_unique<Document>(version, encoding);
}
// <element?>
else {
throw error("invalid syntax");
void parseComment() {
expect("!--");
if (skipTo("-->")) {
skip(3);
} else {
throw error("comment close missing");
}
}
return element;
std::string parseText() {
size_t start = pos;
while (hasNext()) {
char c = peek();
if (c == '<') {
break;
}
nextChar();
}
return Parser("[string]", std::string(source.substr(start, pos - start)))
.parseString('\0', false);
}
std::string parseXMLName() {
char c = peek();
if (!is_xml_identifier_start(c)) {
throw error("identifier expected");
}
int start = pos;
while (hasNext() && is_xml_identifier_part(source[pos])) {
pos++;
}
return std::string(source.substr(start, pos - start));
}
public:
Parser(std::string_view filename, std::string_view source)
: BasicParser(filename, source) {
}
std::unique_ptr<Document> parse() {
parseDeclaration();
std::unique_ptr<Node> root;
while (root == nullptr) {
root = parseElement();
}
document->setRoot(std::move(root));
return std::move(document);
}
};
}
xmldocument Parser::parse() {
parseDeclaration();
xmlelement root = nullptr;
while (root == nullptr) {
root = parseElement();
}
document->setRoot(root);
return document;
}
xmldocument xml::parse(std::string_view filename, std::string_view source) {
std::unique_ptr<Document> xml::parse(
std::string_view filename, std::string_view source
) {
Parser parser(filename, source);
return parser.parse();
}
@ -354,13 +366,13 @@ inline void newline(
static void stringifyElement(
std::stringstream& ss,
const xmlelement& element,
const Node& element,
bool nice,
const std::string& indentStr,
int indent
) {
if (element->isText()) {
std::string text = element->attr("#").getText();
if (element.isText()) {
std::string text = element.attr("#").getText();
util::replaceAll(text, "&", "&amp;");
util::replaceAll(text, "\"", "&quot;");
util::replaceAll(text, "'", "&apos;");
@ -369,10 +381,10 @@ static void stringifyElement(
ss << text;
return;
}
const std::string& tag = element->getTag();
const std::string& tag = element.getTag();
ss << '<' << tag;
auto& attrs = element->getAttributes();
auto& attrs = element.getAttributes();
if (!attrs.empty()) {
ss << ' ';
int count = 0;
@ -388,10 +400,10 @@ static void stringifyElement(
count++;
}
}
auto& elements = element->getElements();
auto& elements = element.getElements();
if (elements.size() == 1 && elements[0]->isText()) {
ss << ">";
stringifyElement(ss, elements[0], nice, indentStr, indent + 1);
stringifyElement(ss, *elements[0], nice, indentStr, indent + 1);
ss << "</" << tag << ">";
return;
}
@ -399,7 +411,7 @@ static void stringifyElement(
ss << '>';
for (auto& sub : elements) {
newline(ss, nice, indentStr, indent + 1);
stringifyElement(ss, sub, nice, indentStr, indent + 1);
stringifyElement(ss, *sub, nice, indentStr, indent + 1);
}
newline(ss, nice, indentStr, indent);
ss << "</" << tag << ">";
@ -410,16 +422,16 @@ static void stringifyElement(
}
std::string xml::stringify(
const xmldocument& document, bool nice, const std::string& indentStr
const Document& document, bool nice, const std::string& indentStr
) {
std::stringstream ss;
// XML declaration
ss << "<?xml version=\"" << document->getVersion();
ss << "<?xml version=\"" << document.getVersion();
ss << "\" encoding=\"UTF-8\" ?>";
newline(ss, nice, indentStr, 0);
stringifyElement(ss, document->getRoot(), nice, indentStr, 0);
stringifyElement(ss, *document.getRoot(), nice, indentStr, 0);
return ss.str();
}

57
src/coders/xml.hpp
View File

@ -13,11 +13,6 @@ namespace xml {
class Attribute;
class Document;
using xmlattribute = Attribute;
using xmlelement = std::shared_ptr<Node>;
using xmldocument = std::shared_ptr<Document>;
using xmlelements_map = std::unordered_map<std::string, xmlattribute>;
class Attribute {
std::string name;
std::string text;
@ -40,13 +35,15 @@ namespace xml {
/// 'text'
class Node {
std::string tag;
std::unordered_map<std::string, xmlattribute> attrs;
std::vector<xmlelement> elements;
std::unordered_map<std::string, Attribute> attrs;
std::vector<std::unique_ptr<Node>> elements;
public:
Node(std::string tag);
Node(const Node&) = delete;
/// @brief Add sub-element
void add(const xmlelement& element);
void add(std::unique_ptr<Node> element);
/// @brief Set attribute value. Creates attribute if does not exists
/// @param name attribute name
@ -67,15 +64,15 @@ namespace xml {
/// @brief Get attribute by name
/// @param name attribute name
/// @throws std::runtime_error if element has no attribute
/// @return xmlattribute - {name, value}
const xmlattribute& attr(const std::string& name) const;
/// @return xml attribute - {name, value}
const Attribute& attr(const std::string& name) const;
/// @brief Get attribute by name
/// @param name attribute name
/// @param def default value will be returned wrapped in xmlattribute
/// if element has no attribute
/// @return xmlattribute - {name, value} or {name, def} if not found*/
xmlattribute attr(const std::string& name, const std::string& def)
/// @return xml attribute - {name, value} or {name, def} if not found
Attribute attr(const std::string& name, const std::string& def)
const;
/// @brief Check if element has attribute
@ -86,51 +83,37 @@ namespace xml {
/// @param index sub-element index
/// @throws std::out_of_range if an invalid index given
/// @return sub-element
xmlelement sub(size_t index);
Node& sub(size_t index);
const Node& sub(size_t index) const;
/// @brief Get number of sub-elements
size_t size() const;
const std::vector<xmlelement>& getElements() const;
const xmlelements_map& getAttributes() const;
const std::vector<std::unique_ptr<Node>>& getElements() const;
const std::unordered_map<std::string, Attribute>& getAttributes() const;
};
class Document {
xmlelement root = nullptr;
std::unique_ptr<Node> root = nullptr;
std::string version;
std::string encoding;
public:
Document(std::string version, std::string encoding);
void setRoot(const xmlelement& element);
xmlelement getRoot() const;
void setRoot(std::unique_ptr<Node> element);
const Node* getRoot() const;
const std::string& getVersion() const;
const std::string& getEncoding() const;
};
class Parser : BasicParser {
xmldocument document;
xmlelement parseOpenTag();
xmlelement parseElement();
void parseDeclaration();
void parseComment();
std::string parseText();
std::string parseXMLName();
public:
Parser(std::string_view filename, std::string_view source);
xmldocument parse();
};
/// @brief Serialize XML Document to string
/// @param document serializing document
/// @param nice use human readable format (with indents and line-separators)
/// @param indentStr indentation characters sequence (default - 4 spaces)
/// @return XML string
extern std::string stringify(
const xmldocument& document,
std::string stringify(
const Document& document,
bool nice = true,
const std::string& indentStr = " "
);
@ -139,7 +122,9 @@ namespace xml {
/// @param filename file name will be shown in error messages
/// @param source xml source code string
/// @return xml document
extern xmldocument parse(
std::unique_ptr<Document> parse(
std::string_view filename, std::string_view source
);
using xmlelement = Node;
}

4
src/frontend/UiDocument.cpp
View File

@ -67,9 +67,7 @@ std::unique_ptr<UiDocument> UiDocument::read(
: scripting::create_doc_environment(penv, name);
gui::UiXmlReader reader(env);
auto view = reader.readXML(
file.u8string(), xmldoc->getRoot()
);
auto view = reader.readXML(file.u8string(), *xmldoc->getRoot());
view->setId("root");
uidocscript script {};
auto scriptFile = fs::path(file.u8string()+".lua");

336
src/graphics/ui/gui_xml.cpp
View File

@ -56,8 +56,8 @@ static runnable create_runnable(
const xml::xmlelement& element,
const std::string& name
) {
if (element->has(name)) {
std::string text = element->attr(name).getText();
if (element.has(name)) {
std::string text = element.attr(name).getText();
if (!text.empty()) {
return scripting::create_runnable(
reader.getEnvironment(), text, reader.getFilename()
@ -83,78 +83,78 @@ static onaction create_action(
static void _readUINode(
const UiXmlReader& reader, const xml::xmlelement& element, UINode& node
) {
if (element->has("id")) {
node.setId(element->attr("id").getText());
if (element.has("id")) {
node.setId(element.attr("id").getText());
}
if (element->has("pos")) {
node.setPos(element->attr("pos").asVec2());
if (element.has("pos")) {
node.setPos(element.attr("pos").asVec2());
}
if (element->has("size")) {
node.setSize(element->attr("size").asVec2());
if (element.has("size")) {
node.setSize(element.attr("size").asVec2());
}
if (element->has("color")) {
glm::vec4 color = element->attr("color").asColor();
if (element.has("color")) {
glm::vec4 color = element.attr("color").asColor();
glm::vec4 hoverColor = color;
glm::vec4 pressedColor = color;
if (element->has("hover-color")) {
if (element.has("hover-color")) {
hoverColor = node.getHoverColor();
}
if (element->has("pressed-color")) {
if (element.has("pressed-color")) {
pressedColor = node.getPressedColor();
}
node.setColor(color);
node.setHoverColor(hoverColor);
node.setPressedColor(pressedColor);
}
if (element->has("margin")) {
node.setMargin(element->attr("margin").asVec4());
if (element.has("margin")) {
node.setMargin(element.attr("margin").asVec4());
}
if (element->has("z-index")) {
node.setZIndex(element->attr("z-index").asInt());
if (element.has("z-index")) {
node.setZIndex(element.attr("z-index").asInt());
}
if (element->has("interactive")) {
node.setInteractive(element->attr("interactive").asBool());
if (element.has("interactive")) {
node.setInteractive(element.attr("interactive").asBool());
}
if (element->has("visible")) {
node.setVisible(element->attr("visible").asBool());
if (element.has("visible")) {
node.setVisible(element.attr("visible").asBool());
}
if (element->has("enabled")) {
node.setEnabled(element->attr("enabled").asBool());
if (element.has("enabled")) {
node.setEnabled(element.attr("enabled").asBool());
}
if (element->has("position-func")) {
if (element.has("position-func")) {
node.setPositionFunc(scripting::create_vec2_supplier(
reader.getEnvironment(),
element->attr("position-func").getText(),
element.attr("position-func").getText(),
reader.getFilename()
));
}
if (element->has("size-func")) {
if (element.has("size-func")) {
node.setSizeFunc(scripting::create_vec2_supplier(
reader.getEnvironment(),
element->attr("size-func").getText(),
element.attr("size-func").getText(),
reader.getFilename()
));
}
if (element->has("hover-color")) {
node.setHoverColor(element->attr("hover-color").asColor());
if (element.has("hover-color")) {
node.setHoverColor(element.attr("hover-color").asColor());
}
if (element->has("pressed-color")) {
node.setPressedColor(element->attr("pressed-color").asColor());
if (element.has("pressed-color")) {
node.setPressedColor(element.attr("pressed-color").asColor());
}
std::string alignName = element->attr("align", "").getText();
std::string alignName = element.attr("align", "").getText();
node.setAlign(align_from_string(alignName, node.getAlign()));
if (element->has("gravity")) {
if (element.has("gravity")) {
node.setGravity(gravity_from_string(
element->attr("gravity").getText()
element.attr("gravity").getText()
));
}
if (element->has("tooltip")) {
node.setTooltip(util::str2wstr_utf8(element->attr("tooltip").getText()));
if (element.has("tooltip")) {
node.setTooltip(util::str2wstr_utf8(element.attr("tooltip").getText()));
}
if (element->has("tooltip-delay")) {
node.setTooltipDelay(element->attr("tooltip-delay").asFloat());
if (element.has("tooltip-delay")) {
node.setTooltipDelay(element.attr("tooltip-delay").asFloat());
}
if (auto onclick = create_action(reader, element, "onclick")) {
@ -169,16 +169,16 @@ static void _readUINode(
static void _readContainer(UiXmlReader& reader, const xml::xmlelement& element, Container& container) {
_readUINode(reader, element, container);
if (element->has("scrollable")) {
container.setScrollable(element->attr("scrollable").asBool());
if (element.has("scrollable")) {
container.setScrollable(element.attr("scrollable").asBool());
}
if (element->has("scroll-step")) {
container.setScrollStep(element->attr("scroll-step").asInt());
if (element.has("scroll-step")) {
container.setScrollStep(element.attr("scroll-step").asInt());
}
for (auto& sub : element->getElements()) {
for (auto& sub : element.getElements()) {
if (sub->isText())
continue;
auto subnode = reader.readUINode(sub);
auto subnode = reader.readUINode(*sub);
if (subnode) {
container.add(subnode);
}
@ -196,8 +196,8 @@ void UiXmlReader::readUINode(UiXmlReader& reader, const xml::xmlelement& element
static void _readPanel(UiXmlReader& reader, const xml::xmlelement& element, Panel& panel, bool subnodes=true) {
_readUINode(reader, element, panel);
if (element->has("padding")) {
glm::vec4 padding = element->attr("padding").asVec4();
if (element.has("padding")) {
glm::vec4 padding = element.attr("padding").asVec4();
panel.setPadding(padding);
glm::vec2 size = panel.getSize();
panel.setSize(glm::vec2(
@ -205,23 +205,23 @@ static void _readPanel(UiXmlReader& reader, const xml::xmlelement& element, Pane
size.y + padding.y + padding.w
));
}
if (element->has("size")) {
if (element.has("size")) {
panel.setResizing(false);
}
if (element->has("max-length")) {
panel.setMaxLength(element->attr("max-length").asInt());
if (element.has("max-length")) {
panel.setMaxLength(element.attr("max-length").asInt());
}
if (element->has("orientation")) {
auto &oname = element->attr("orientation").getText();
if (element.has("orientation")) {
auto &oname = element.attr("orientation").getText();
if (oname == "horizontal") {
panel.setOrientation(Orientation::horizontal);
}
}
if (subnodes) {
for (auto& sub : element->getElements()) {
for (auto& sub : element.getElements()) {
if (sub->isText())
continue;
auto subnode = reader.readUINode(sub);
auto subnode = reader.readUINode(*sub);
if (subnode) {
panel.add(subnode);
}
@ -231,8 +231,8 @@ static void _readPanel(UiXmlReader& reader, const xml::xmlelement& element, Pane
static std::wstring readAndProcessInnerText(const xml::xmlelement& element, const std::string& context) {
std::wstring text = L"";
if (element->size() == 1) {
std::string source = element->sub(0)->attr("#").getText();
if (element.size() == 1) {
std::string source = element.sub(0).attr("#").getText();
util::trim(source);
text = util::str2wstr_utf8(source);
if (text[0] == '@') {
@ -250,29 +250,29 @@ static std::shared_ptr<UINode> readLabel(UiXmlReader& reader, const xml::xmlelem
std::wstring text = readAndProcessInnerText(element, reader.getContext());
auto label = std::make_shared<Label>(text);
_readUINode(reader, element, *label);
if (element->has("valign")) {
if (element.has("valign")) {
label->setVerticalAlign(
align_from_string(element->attr("valign").getText(), label->getVerticalAlign())
align_from_string(element.attr("valign").getText(), label->getVerticalAlign())
);
}
if (element->has("supplier")) {
if (element.has("supplier")) {
label->textSupplier(scripting::create_wstring_supplier(
reader.getEnvironment(),
element->attr("supplier").getText(),
element.attr("supplier").getText(),
reader.getFilename()
));
}
if (element->has("autoresize")) {
label->setAutoResize(element->attr("autoresize").asBool());
if (element.has("autoresize")) {
label->setAutoResize(element.attr("autoresize").asBool());
}
if (element->has("multiline")) {
label->setMultiline(element->attr("multiline").asBool());
if (!element->has("valign")) {
if (element.has("multiline")) {
label->setMultiline(element.attr("multiline").asBool());
if (!element.has("valign")) {
label->setVerticalAlign(Align::top);
}
}
if (element->has("text-wrap")) {
label->setTextWrapping(element->attr("text-wrap").asBool());
if (element.has("text-wrap")) {
label->setTextWrapping(element.attr("text-wrap").asBool());
}
return label;
}
@ -284,19 +284,19 @@ static std::shared_ptr<UINode> readContainer(UiXmlReader& reader, const xml::xml
}
static std::shared_ptr<UINode> readPanel(UiXmlReader& reader, const xml::xmlelement& element) {
float interval = element->attr("interval", "2").asFloat();
float interval = element.attr("interval", "2").asFloat();
auto panel = std::make_shared<Panel>(glm::vec2(), glm::vec4(), interval);
_readPanel(reader, element, *panel);
return panel;
}
static std::shared_ptr<UINode> readButton(UiXmlReader& reader, const xml::xmlelement& element) {
glm::vec4 padding = element->attr("padding", "10").asVec4();
glm::vec4 padding = element.attr("padding", "10").asVec4();
std::shared_ptr<Button> button;
auto& elements = element->getElements();
auto& elements = element.getElements();
if (!elements.empty() && elements[0]->getTag() != "#") {
auto inner = reader.readUINode(element->getElements().at(0));
auto inner = reader.readUINode(*elements.at(0));
if (inner != nullptr) {
button = std::make_shared<Button>(inner, padding);
} else {
@ -308,30 +308,32 @@ static std::shared_ptr<UINode> readButton(UiXmlReader& reader, const xml::xmlele
button = std::make_shared<Button>(text, padding, nullptr);
_readPanel(reader, element, *button, true);
}
if (element->has("text-align")) {
button->setTextAlign(align_from_string(element->attr("text-align").getText(), button->getTextAlign()));
if (element.has("text-align")) {
button->setTextAlign(align_from_string(
element.attr("text-align").getText(), button->getTextAlign()
));
}
return button;
}
static std::shared_ptr<UINode> readCheckBox(UiXmlReader& reader, const xml::xmlelement& element) {
auto text = readAndProcessInnerText(element, reader.getContext());
bool checked = element->attr("checked", "false").asBool();
bool checked = element.attr("checked", "false").asBool();
auto checkbox = std::make_shared<FullCheckBox>(text, glm::vec2(32), checked);
_readPanel(reader, element, *checkbox);
if (element->has("consumer")) {
if (element.has("consumer")) {
checkbox->setConsumer(scripting::create_bool_consumer(
reader.getEnvironment(),
element->attr("consumer").getText(),
element.attr("consumer").getText(),
reader.getFilename()
));
}
if (element->has("supplier")) {
if (element.has("supplier")) {
checkbox->setSupplier(scripting::create_bool_supplier(
reader.getEnvironment(),
element->attr("supplier").getText(),
element.attr("supplier").getText(),
reader.getFilename()
));
}
@ -339,15 +341,15 @@ static std::shared_ptr<UINode> readCheckBox(UiXmlReader& reader, const xml::xmle
}
static std::shared_ptr<UINode> readTextBox(UiXmlReader& reader, const xml::xmlelement& element) {
auto placeholder = util::str2wstr_utf8(element->attr("placeholder", "").getText());
auto hint = util::str2wstr_utf8(element->attr("hint", "").getText());
auto placeholder = util::str2wstr_utf8(element.attr("placeholder", "").getText());
auto hint = util::str2wstr_utf8(element.attr("hint", "").getText());
auto text = readAndProcessInnerText(element, reader.getContext());
auto textbox = std::make_shared<TextBox>(placeholder, glm::vec4(0.0f));
textbox->setHint(hint);
_readContainer(reader, element, *textbox);
if (element->has("padding")) {
glm::vec4 padding = element->attr("padding").asVec4();
if (element.has("padding")) {
glm::vec4 padding = element.attr("padding").asVec4();
textbox->setPadding(padding);
glm::vec2 size = textbox->getSize();
textbox->setSize(glm::vec2(
@ -357,58 +359,58 @@ static std::shared_ptr<UINode> readTextBox(UiXmlReader& reader, const xml::xmlel
}
textbox->setText(text);
if (element->has("syntax")) {
textbox->setSyntax(element->attr("syntax").getText());
if (element.has("syntax")) {
textbox->setSyntax(element.attr("syntax").getText());
}
if (element->has("multiline")) {
textbox->setMultiline(element->attr("multiline").asBool());
if (element.has("multiline")) {
textbox->setMultiline(element.attr("multiline").asBool());
}
if (element->has("text-wrap")) {
textbox->setTextWrapping(element->attr("text-wrap").asBool());
if (element.has("text-wrap")) {
textbox->setTextWrapping(element.attr("text-wrap").asBool());
}
if (element->has("editable")) {
textbox->setEditable(element->attr("editable").asBool());
if (element.has("editable")) {
textbox->setEditable(element.attr("editable").asBool());
}
if (element->has("autoresize")) {
textbox->setAutoResize(element->attr("autoresize").asBool());
if (element.has("autoresize")) {
textbox->setAutoResize(element.attr("autoresize").asBool());
}
if (element->has("line-numbers")) {
textbox->setShowLineNumbers(element->attr("line-numbers").asBool());
if (element.has("line-numbers")) {
textbox->setShowLineNumbers(element.attr("line-numbers").asBool());
}
if (element->has("consumer")) {
if (element.has("consumer")) {
textbox->setTextConsumer(scripting::create_wstring_consumer(
reader.getEnvironment(),
element->attr("consumer").getText(),
element.attr("consumer").getText(),
reader.getFilename()
));
}
if (element->has("sub-consumer")) {
if (element.has("sub-consumer")) {
textbox->setTextSubConsumer(scripting::create_wstring_consumer(
reader.getEnvironment(),
element->attr("sub-consumer").getText(),
element.attr("sub-consumer").getText(),
reader.getFilename()
));
}
if (element->has("supplier")) {
if (element.has("supplier")) {
textbox->setTextSupplier(scripting::create_wstring_supplier(
reader.getEnvironment(),
element->attr("supplier").getText(),
element.attr("supplier").getText(),
reader.getFilename()
));
}
if (element->has("focused-color")) {
textbox->setFocusedColor(element->attr("focused-color").asColor());
if (element.has("focused-color")) {
textbox->setFocusedColor(element.attr("focused-color").asColor());
}
if (element->has("error-color")) {
textbox->setErrorColor(element->attr("error-color").asColor());
if (element.has("error-color")) {
textbox->setErrorColor(element.attr("error-color").asColor());
}
if (element->has("text-color")) {
textbox->setTextColor(element->attr("text-color").asColor());
if (element.has("text-color")) {
textbox->setTextColor(element.attr("text-color").asColor());
}
if (element->has("validator")) {
if (element.has("validator")) {
textbox->setTextValidator(scripting::create_wstring_validator(
reader.getEnvironment(),
element->attr("validator").getText(),
element.attr("validator").getText(),
reader.getFilename()
));
}
@ -422,7 +424,7 @@ static std::shared_ptr<UINode> readTextBox(UiXmlReader& reader, const xml::xmlel
}
static std::shared_ptr<UINode> readImage(UiXmlReader& reader, const xml::xmlelement& element) {
std::string src = element->attr("src", "").getText();
std::string src = element.attr("src", "").getText();
auto image = std::make_shared<Image>(src);
_readUINode(reader, element, *image);
return image;
@ -431,51 +433,56 @@ static std::shared_ptr<UINode> readImage(UiXmlReader& reader, const xml::xmlelem
static std::shared_ptr<UINode> readTrackBar(UiXmlReader& reader, const xml::xmlelement& element) {
const auto& env = reader.getEnvironment();
const auto& file = reader.getFilename();
float minv = element->attr("min", "0.0").asFloat();
float maxv = element->attr("max", "1.0").asFloat();
float def = element->attr("value", "0.0").asFloat();
float step = element->attr("step", "1.0").asFloat();
int trackWidth = element->attr("track-width", "12").asInt();
float minv = element.attr("min", "0.0").asFloat();
float maxv = element.attr("max", "1.0").asFloat();
float def = element.attr("value", "0.0").asFloat();
float step = element.attr("step", "1.0").asFloat();
int trackWidth = element.attr("track-width", "12").asInt();
auto bar = std::make_shared<TrackBar>(minv, maxv, def, step, trackWidth);
_readUINode(reader, element, *bar);
if (element->has("consumer")) {
if (element.has("consumer")) {
bar->setConsumer(scripting::create_number_consumer(
env, element->attr("consumer").getText(), file));
env, element.attr("consumer").getText(), file));
}
if (element->has("sub-consumer")) {
if (element.has("sub-consumer")) {
bar->setSubConsumer(scripting::create_number_consumer(
env, element->attr("sub-consumer").getText(), file));
env, element.attr("sub-consumer").getText(), file));
}
if (element->has("supplier")) {
if (element.has("supplier")) {
bar->setSupplier(scripting::create_number_supplier(
env, element->attr("supplier").getText(), file));
env, element.attr("supplier").getText(), file));
}
if (element->has("track-color")) {
bar->setTrackColor(element->attr("track-color").asColor());
if (element.has("track-color")) {
bar->setTrackColor(element.attr("track-color").asColor());
}
if (element->has("change-on-release")) {
bar->setChangeOnRelease(element->attr("change-on-release").asBool());
if (element.has("change-on-release")) {
bar->setChangeOnRelease(element.attr("change-on-release").asBool());
}
return bar;
}
static std::shared_ptr<UINode> readInputBindBox(UiXmlReader& reader, const xml::xmlelement& element) {
auto bindname = element->attr("binding").getText();
auto bindname = element.attr("binding").getText();
auto found = Events::bindings.find(bindname);
if (found == Events::bindings.end()) {
throw std::runtime_error("binding does not exists "+util::quote(bindname));
}
glm::vec4 padding = element->attr("padding", "6").asVec4();
glm::vec4 padding = element.attr("padding", "6").asVec4();
auto bindbox = std::make_shared<InputBindBox>(found->second, padding);
_readPanel(reader, element, *bindbox);
return bindbox;
}
static slotcallback readSlotFunc(InventoryView* view, UiXmlReader& reader, xml::xmlelement& element, const std::string& attr) {
static slotcallback readSlotFunc(
InventoryView* view,
const UiXmlReader& reader,
const xml::xmlelement& element,
const std::string& attr
) {
auto consumer = scripting::create_int_array_consumer(
reader.getEnvironment(),
element->attr(attr).getText()
element.attr(attr).getText()
);
return [=](uint slot, ItemStack&) {
int args[] {int(view->getInventory()->getId()), int(slot)};
@ -483,22 +490,24 @@ static slotcallback readSlotFunc(InventoryView* view, UiXmlReader& reader, xml::
};
}
static void readSlot(InventoryView* view, UiXmlReader& reader, xml::xmlelement element) {
int index = element->attr("index", "0").asInt();
bool itemSource = element->attr("item-source", "false").asBool();
bool taking = element->attr("taking", "true").asBool();
bool placing = element->attr("placing", "true").asBool();
static void readSlot(
InventoryView* view, UiXmlReader& reader, const xml::xmlelement& element
) {
int index = element.attr("index", "0").asInt();
bool itemSource = element.attr("item-source", "false").asBool();
bool taking = element.attr("taking", "true").asBool();
bool placing = element.attr("placing", "true").asBool();
SlotLayout layout(index, glm::vec2(), true, itemSource, nullptr, nullptr, nullptr);
if (element->has("pos")) {
layout.position = element->attr("pos").asVec2();
if (element.has("pos")) {
layout.position = element.attr("pos").asVec2();
}
if (element->has("updatefunc")) {
if (element.has("updatefunc")) {
layout.updateFunc = readSlotFunc(view, reader, element, "updatefunc");
}
if (element->has("sharefunc")) {
if (element.has("sharefunc")) {
layout.shareFunc = readSlotFunc(view, reader, element, "sharefunc");
}
if (element->has("onrightclick")) {
if (element.has("onrightclick")) {
layout.rightClick = readSlotFunc(view, reader, element, "onrightclick");
}
layout.taking = taking;
@ -508,19 +517,21 @@ static void readSlot(InventoryView* view, UiXmlReader& reader, xml::xmlelement e
view->add(slot);
}
static void readSlotsGrid(InventoryView* view, UiXmlReader& reader, xml::xmlelement element) {
int startIndex = element->attr("start-index", "0").asInt();
int rows = element->attr("rows", "0").asInt();
int cols = element->attr("cols", "0").asInt();
int count = element->attr("count", "0").asInt();
static void readSlotsGrid(
InventoryView* view, const UiXmlReader& reader, const xml::xmlelement& element
) {
int startIndex = element.attr("start-index", "0").asInt();
int rows = element.attr("rows", "0").asInt();
int cols = element.attr("cols", "0").asInt();
int count = element.attr("count", "0").asInt();
const int slotSize = InventoryView::SLOT_SIZE;
bool taking = element->attr("taking", "true").asBool();
bool placing = element->attr("placing", "true").asBool();
int interval = element->attr("interval", "-1").asInt();
bool taking = element.attr("taking", "true").asBool();
bool placing = element.attr("placing", "true").asBool();
int interval = element.attr("interval", "-1").asInt();
if (interval < 0) {
interval = InventoryView::SLOT_INTERVAL;
}
int padding = element->attr("padding", "-1").asInt();
int padding = element.attr("padding", "-1").asInt();
if (padding < 0) {
padding = interval;
}
@ -531,18 +542,18 @@ static void readSlotsGrid(InventoryView* view, UiXmlReader& reader, xml::xmlelem
} else if (count == 0) {
count = rows * cols;
}
bool itemSource = element->attr("item-source", "false").asBool();
bool itemSource = element.attr("item-source", "false").asBool();
SlotLayout layout(-1, glm::vec2(), true, itemSource, nullptr, nullptr, nullptr);
if (element->has("pos")) {
layout.position = element->attr("pos").asVec2();
if (element.has("pos")) {
layout.position = element.attr("pos").asVec2();
}
if (element->has("updatefunc")) {
if (element.has("updatefunc")) {
layout.updateFunc = readSlotFunc(view, reader, element, "updatefunc");
}
if (element->has("sharefunc")) {
if (element.has("sharefunc")) {
layout.shareFunc = readSlotFunc(view, reader, element, "sharefunc");
}
if (element->has("onrightclick")) {
if (element.has("onrightclick")) {
layout.rightClick = readSlotFunc(view, reader, element, "onrightclick");
}
layout.padding = padding;
@ -574,11 +585,11 @@ static std::shared_ptr<UINode> readInventory(UiXmlReader& reader, const xml::xml
reader.addIgnore("slots-grid");
reader.readUINode(reader, element, *view);
for (auto& sub : element->getElements()) {
for (auto& sub : element.getElements()) {
if (sub->getTag() == "slot") {
readSlot(view.get(), reader, sub);
readSlot(view.get(), reader, *sub);
} else if (sub->getTag() == "slots-grid") {
readSlotsGrid(view.get(), reader, sub);
readSlotsGrid(view.get(), reader, *sub);
}
}
return view;
@ -621,18 +632,18 @@ void UiXmlReader::addIgnore(const std::string& tag) {
}
std::shared_ptr<UINode> UiXmlReader::readUINode(const xml::xmlelement& element) {
if (element->has("if")) {
const auto& cond = element->attr("if").getText();
if (element.has("if")) {
const auto& cond = element.attr("if").getText();
if (cond.empty() || cond == "false" || cond == "nil")
return nullptr;
}
if (element->has("ifnot")) {
const auto& cond = element->attr("ifnot").getText();
if (element.has("ifnot")) {
const auto& cond = element.attr("ifnot").getText();
if (!(cond.empty() || cond == "false" || cond == "nil"))
return nullptr;
}
const std::string& tag = element->getTag();
const std::string& tag = element.getTag();
auto found = readers.find(tag);
if (found == readers.end()) {
if (ignored.find(tag) != ignored.end()) {
@ -641,9 +652,9 @@ std::shared_ptr<UINode> UiXmlReader::readUINode(const xml::xmlelement& element)
throw std::runtime_error("unsupported element '"+tag+"'");
}
bool hascontext = element->has("context");
bool hascontext = element.has("context");
if (hascontext) {
contextStack.push(element->attr("context").getText());
contextStack.push(element.attr("context").getText());
}
auto node = found->second(*this, element);
if (hascontext) {
@ -658,8 +669,7 @@ std::shared_ptr<UINode> UiXmlReader::readXML(
) {
this->filename = filename;
auto document = xml::parse(filename, source);
auto root = document->getRoot();
return readUINode(root);
return readUINode(*document->getRoot());
}
std::shared_ptr<UINode> UiXmlReader::readXML(

3
src/graphics/ui/gui_xml.hpp
View File

@ -11,7 +11,8 @@
namespace gui {
class UiXmlReader;
using uinode_reader = std::function<std::shared_ptr<UINode>(UiXmlReader&, xml::xmlelement)>;
using uinode_reader = std::function<
std::shared_ptr<UINode>(UiXmlReader&, const xml::xmlelement&)>;
class UiXmlReader {
std::unordered_map<std::string, uinode_reader> readers;