309 lines
8.4 KiB
C++
309 lines
8.4 KiB
C++
/*
|
|
OmniaFramework - A collection of useful functionality
|
|
Copyright (C) 2025 OmniaX-Dev
|
|
|
|
This file is part of OmniaFramework.
|
|
|
|
OmniaFramework is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
OmniaFramework is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with OmniaFramework. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "Stylesheet.hpp"
|
|
#include "FileSystem.hpp"
|
|
#include "Logger.hpp"
|
|
|
|
namespace ostd
|
|
{
|
|
Stylesheet::Stylesheet(void)
|
|
{
|
|
}
|
|
|
|
Stylesheet& Stylesheet::clear(void)
|
|
{
|
|
m_values.clear();
|
|
return *this;
|
|
}
|
|
|
|
Stylesheet& Stylesheet::loadFromFile(const ostd::String& filePath, bool clearCurrentRules)
|
|
{
|
|
ostd::String outContent = "";
|
|
ostd::FileSystem::readTextFileRaw(filePath, outContent);
|
|
return loadFromString(outContent, filePath, clearCurrentRules);
|
|
}
|
|
|
|
Stylesheet& Stylesheet::loadFromString(const ostd::String& content, const ostd::String& filePath, bool clearCurrentRules)
|
|
{
|
|
if (clearCurrentRules)
|
|
m_values.clear();
|
|
std::vector<ostd::String> lines = content.tokenize("\n", false, true).getRawData();
|
|
uint32_t lineNumber = 0;
|
|
ostd::String lineCopy = "";
|
|
std::unordered_map<ostd::String, ostd::String> variables;
|
|
auto l_warn = [&](const ostd::String& msg) -> void {
|
|
OX_WARN("%s in theme line. File: <%s:%d>:\n\t%s", msg.c_str(), filePath.c_str(), lineNumber, lineCopy.c_str());
|
|
};
|
|
auto l_parseLine = [&](ostd::String& line) -> void {
|
|
for (const auto&[var, val] : variables)
|
|
line.replaceAll(var, val);
|
|
if (!parseThemeFileLine(line))
|
|
l_warn("Error");
|
|
};
|
|
ostd::String groupSelector = "";
|
|
bool groupLines = false;
|
|
std::vector<ostd::String> group;
|
|
for (auto& line : lines)
|
|
{
|
|
lineNumber++;
|
|
lineCopy = line;
|
|
line.trim();
|
|
if (line.startsWith("%"))
|
|
continue;
|
|
if (line.contains("%"))
|
|
line.substr(0, line.indexOf("%")).trim();
|
|
if (line == "")
|
|
continue;
|
|
if (line.startsWith("$"))
|
|
{
|
|
line.substr(1);
|
|
if (line.count("=") != 1 || line.endsWith("="))
|
|
{
|
|
l_warn("Invalid variable");
|
|
continue;
|
|
}
|
|
ostd::String varName = line.new_substr(0, line.indexOf("=")).trim();
|
|
ostd::String varValue = line.new_substr(line.indexOf("=") + 1).trim();
|
|
if (!varName.regexMatches(m_validNameRegex))
|
|
{
|
|
l_warn("Invalid variable name");
|
|
continue;
|
|
}
|
|
variables["$" + varName] = varValue;
|
|
continue;
|
|
}
|
|
if (groupSelector != "")
|
|
{
|
|
if (groupLines)
|
|
{
|
|
if (line == "}")
|
|
{
|
|
groupLines = false;
|
|
auto newLines = parseGroup(groupSelector, group);
|
|
for (auto& l : newLines)
|
|
l_parseLine(l);
|
|
groupSelector = "";
|
|
group.clear();
|
|
continue;
|
|
}
|
|
group.push_back(line);
|
|
}
|
|
else
|
|
{
|
|
if (line == "{")
|
|
groupLines = true;
|
|
}
|
|
continue;
|
|
}
|
|
if (line.startsWith("("))
|
|
{
|
|
if (line.count(")") != 1 || line.indexOf(")") < 3)
|
|
{
|
|
l_warn("Invalid group selector");
|
|
continue;
|
|
}
|
|
ostd::String rawSelector = line.new_substr(1, line.indexOf(")")).trim();
|
|
groupSelector = parseGroupSelector(rawSelector);
|
|
if (line.contains("{"))
|
|
{
|
|
line.substr(line.indexOf("{")).trim();
|
|
if (line != "{")
|
|
{
|
|
l_warn("Invalid group selector");
|
|
continue;
|
|
}
|
|
groupLines = true;
|
|
}
|
|
continue;
|
|
}
|
|
l_parseLine(line);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
void Stylesheet::set(const std::string& key, TypeVariant value, const ostd::String& themeID)
|
|
{
|
|
ostd::String fullKey = "@" + themeID + "." + key;
|
|
// std::cout << "SET: " << fullKey << "\n";
|
|
setFull(fullKey, value);
|
|
}
|
|
|
|
void Stylesheet::setFull(const ostd::String& fullKey, TypeVariant value)
|
|
{
|
|
m_values[fullKey] = std::move(value);
|
|
}
|
|
|
|
const Stylesheet::TypeVariant* Stylesheet::getVariant(const ostd::String& key, const ostd::String& themeID, const QualifierList& qualifierList) const
|
|
{
|
|
for (const auto&[qualifier, state] : qualifierList)
|
|
{
|
|
const TypeVariant* v = (state ? getFull("@" + themeID + ":" + qualifier + "." + key) : nullptr);
|
|
// std::cout << "0: " << "@" + themeID + ":" + qualifier + "." + key << "\n";
|
|
if (v)
|
|
{
|
|
std::cout << "1: " << "@" + themeID + ":" + qualifier + "." + key << "\n";
|
|
return v;
|
|
}
|
|
v = (state ? getFull("@:" + qualifier + "." + key) : nullptr);
|
|
if (v)
|
|
{
|
|
std::cout << "2: " << "@:" + qualifier + "." + key << "\n";
|
|
return v;
|
|
}
|
|
}
|
|
if (auto v = getFull("@" + themeID + "." + key))
|
|
{
|
|
std::cout << "3: " << "@" + themeID + "." + key << "\n";
|
|
return v;
|
|
}
|
|
else if (auto v = getFull("@." + key))
|
|
{
|
|
std::cout << "4: " << "@." + key << "\n";
|
|
return v;
|
|
}
|
|
std::cout << "\n\n";
|
|
return nullptr;
|
|
}
|
|
|
|
const Stylesheet::TypeVariant* Stylesheet::getFull(const ostd::String& fullKey) const
|
|
{
|
|
auto it = m_values.find(fullKey);
|
|
// if (it != m_values.end())
|
|
// std::cout << " GET: " << fullKey << "\n";
|
|
return it != m_values.end() ? &it->second : nullptr;
|
|
}
|
|
|
|
bool Stylesheet::parseThemeFileLine(const ostd::String& line)
|
|
{
|
|
if (!line.contains("="))
|
|
return false;
|
|
ostd::String key = line.new_substr(0, line.indexOf("=")).trim();
|
|
ostd::String valuePreserveCase = line.new_substr(line.indexOf("=") + 1).trim();
|
|
ostd::String value = line.new_substr(line.indexOf("=") + 1).trim().toLower();
|
|
if (key == "")
|
|
return false;
|
|
ostd::String themeID = "";
|
|
if (key.startsWith("@"))
|
|
{
|
|
if (key.indexOf(" ") < 2)
|
|
return false;
|
|
themeID = key.new_substr(1, key.indexOf(" ")).trim();
|
|
key.substr(key.indexOf(" ") + 1).trim();
|
|
}
|
|
if (value.isInt())
|
|
set(key, static_cast<int32_t>(value.toInt()), themeID);
|
|
else if (value.isNumeric(true))
|
|
set(key, value.toFloat(), themeID);
|
|
else if (value == "true" || value == "false")
|
|
set(key, value == "true", themeID);
|
|
else if (value.startsWith("\"") && value.endsWith("\""))
|
|
{
|
|
valuePreserveCase.substr(1, value.len() - 1);
|
|
set(key, valuePreserveCase, themeID);
|
|
}
|
|
else if (value.startsWith("color(") && value.endsWith(")"))
|
|
{
|
|
value.substr(6, value.len() - 1).trim();
|
|
set(key, ostd::Color(value), themeID);
|
|
}
|
|
else if (value.startsWith("vec2(") && value.endsWith(")"))
|
|
{
|
|
value.substr(4, value.len() - 1).trim();
|
|
auto tokens = value.tokenize(",");
|
|
if (tokens.count() != 2)
|
|
return false;
|
|
std::vector<float> vec;
|
|
for (const auto& tok : tokens)
|
|
{
|
|
if (!tok.isNumeric(true))
|
|
return false;
|
|
vec.push_back(tok.toFloat());
|
|
}
|
|
set(key, ostd::Vec2(vec[0], vec[1]), themeID);
|
|
}
|
|
else if (value.startsWith("rect(") && value.endsWith(")"))
|
|
{
|
|
value.substr(5, value.len() - 1).trim();
|
|
auto tokens = value.tokenize(",");
|
|
if (tokens.count() != 4)
|
|
return false;
|
|
std::vector<float> vec;
|
|
for (const auto& tok : tokens)
|
|
{
|
|
if (!tok.isNumeric(true))
|
|
return false;
|
|
vec.push_back(tok.toFloat());
|
|
}
|
|
set(key, ostd::Rectangle(vec[0], vec[1], vec[2], vec[3]), themeID);
|
|
}
|
|
else
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
ostd::String Stylesheet::parseGroupSelector(const ostd::String& rawSelector) const
|
|
{
|
|
ostd::String sel = rawSelector.new_trim();
|
|
if (sel == "") return "";
|
|
ostd::String id = "";
|
|
ostd::String name = sel;
|
|
ostd::String qual = "";
|
|
if (sel.contains(" "))
|
|
{
|
|
id = sel.new_substr(0, sel.indexOf(" ")).trim();
|
|
name = sel.new_substr(sel.indexOf(" ") + 1).trim();
|
|
}
|
|
if (name.contains(":"))
|
|
{
|
|
if (name.startsWith(":") || name.endsWith(":") || name.count(":") != 1)
|
|
return "";
|
|
qual = name.new_substr(name.indexOf(":") + 1).trim();
|
|
name.substr(0, name.indexOf(":")).trim();
|
|
}
|
|
if (qual != "")
|
|
{
|
|
if (!id.startsWith("@"))
|
|
id = "@" + id;
|
|
id += ":" + qual;
|
|
}
|
|
id += " " + name;
|
|
id.trim();
|
|
return id;
|
|
}
|
|
|
|
std::vector<ostd::String> Stylesheet::parseGroup(const ostd::String& selector, const std::vector<ostd::String>& group)
|
|
{
|
|
if (selector.new_trim() == "" || group.size() == 0)
|
|
return {};
|
|
std::vector<ostd::String> newLines;
|
|
for (const auto& property : group)
|
|
newLines.push_back(selector.new_add(".").new_add(property));
|
|
return newLines;
|
|
}
|
|
|
|
void Stylesheet::debugPrint(void)
|
|
{
|
|
for (const auto&[key, value] : m_values)
|
|
{
|
|
std::cout << key << "\n";
|
|
}
|
|
}
|
|
}
|