if (ch < 10) {

return '0' + ch;

} else if (ch < 16) {

return 'a' + (ch - 10);

}

return '0';

QString result, lineBreak = "\\\n";

result.reserve(str.size() * 8);

bool writingHexEscapedCharacters = false, startOnNewLine = false;

int lastCutSize = 0;

auto utf = str.toUtf8();

for (auto ch : utf) {

if (result.size() - lastCutSize > 80) {

startOnNewLine = true;

result.append(lineBreak);

lastCutSize = result.size();

}

if (ch == '\n') {

writingHexEscapedCharacters = false;

result.append("\\n");

} else if (ch == '\t') {

writingHexEscapedCharacters = false;

result.append("\\t");

} else if (ch == '"' || ch == '\\') {

writingHexEscapedCharacters = false;

result.append('\\').append(ch);

} else if (ch < 32 || static_cast<uchar>(ch) > 127) {

writingHexEscapedCharacters = true;

result.append("\\x").append(hexFirstChar(ch)).append(hexSecondChar(ch));

} else {

if (writingHexEscapedCharacters) {

writingHexEscapedCharacters = false;

result.append("\"\"");

}

result.append(ch);

}

}

return '"' + (startOnNewLine ? lineBreak : QString()) + result + '"';

QStringList rows, chars;

chars.reserve(13);

rows.reserve(1 + (str.size() / 13));

for (uchar ch : str) {

if (chars.size() > 12) {

rows.push_back(chars.join(", "));

chars.clear();

}

chars.push_back(QString("0x") + hexFirstChar(ch) + hexSecondChar(ch));

}

if (!chars.isEmpty()) {

rows.push_back(chars.join(", "));

}

return QString("{") + ((rows.size() > 1) ? '\n' : ' ') + rows.join(",\n") + " }";

QString result = "px";

if (value < 0) {

value = -value;

result += 'm';

}

return result + QString::number(value);

auto moduleInfo = QFileInfo(module.filepath());

auto moduleIsPalette = (moduleInfo.suffix() == "palette");

return moduleIsPalette ? "palette" : "style_" + moduleInfo.baseName();

auto copy = value.copyOf();

if (!copy.isEmpty()) {

return copy.back();

}

return value.Color().fallback;

part = (part & 0x0F);

if (part >= 10) {

return QChar('a' + (part - 10));

}

return QChar('0' + part);

auto result = paletteColorComponent(value.red) + paletteColorComponent(value.green) + paletteColorComponent(value.blue);

if (value.alpha != 255) result += paletteColorComponent(value.alpha);

return result;

switch (type.tag) {

case Tag::Int:

case Tag::Double: return true;

default: return false;

}

: module_(module)

, basePath_(destBasePath)

, baseName_(QFileInfo(basePath_).baseName())

, project_(project)

, isPalette_(isPalette) {

header_ = std::make_unique<common::CppFile>(basePath_ + ".h", project_);

header_->include("ui/style/style_core.h").newline();

if (!writeHeaderRequiredIncludes()) {

return false;

}

if (!writeHeaderStyleNamespace()) {

return false;

}

if (!writeRefsDeclarations()) {

return false;

}

return header_->finalize();

source_ = std::make_unique<common::CppFile>(basePath_ + ".cpp", project_);

writeIncludesInSource();

if (module_.hasVariables()) {

source_->pushNamespace().newline();

source_->stream() << "\

class Module_" << baseName_ << " : public style::internal::ModuleBase {\n\

Module_" << baseName_ << "() { style::internal::registerModule(this); }\n\

style::internal::init_" << baseName_ << "(scale);\n\

Module_" << baseName_ << " registrator;\n";

if (isPalette_) {

source_->newline();

source_->stream() << "style::palette _palette;\n";

} else {

if (!writeVariableDefinitions()) {

return false;

}

}

source_->newline().popNamespace();

source_->newline().pushNamespace("st");

if (!writeRefsDefinition()) {

return false;

}

source_->popNamespace().newline().pushNamespace("style");

if (isPalette_) {

writeSetPaletteColor();

}

source_->pushNamespace("internal").newline();

if (!writeVariableInit()) {

return false;

}

}

return source_->finalize();

switch (type.tag) {

case Tag::Invalid: return QString();

case Tag::Int: return "int";

case Tag::Bool: return "bool";

case Tag::Double: return "double";

case Tag::Pixels: return "int";

case Tag::String: return "QString";

case Tag::Color: return "style::color";

case Tag::Point: return "style::point";

case Tag::Size: return "style::size";

case Tag::Align: return "style::align";

case Tag::Margins: return "style::margins";

case Tag::Font: return "style::font";

case Tag::Icon: return "style::icon";

case Tag::Struct: return "style::" + type.name.back();

}

return QString();

switch (type.tag) {

case Tag::Invalid: return QString();

case Tag::Int: return "0";

case Tag::Bool: return "false";

case Tag::Double: return "0.";

case Tag::Pixels: return "0";

case Tag::String: return "QString()";

case Tag::Color: return "{ Qt::Uninitialized }";

case Tag::Point: return "{ 0, 0 }";

case Tag::Size: return "{ 0, 0 }";

case Tag::Align: return "style::al_topleft";

case Tag::Margins: return "{ 0, 0, 0, 0 }";

case Tag::Font: return "{ Qt::Uninitialized }";

case Tag::Icon: return "{ Qt::Uninitialized }";

case Tag::Struct: {

if (auto realType = module_.findStruct(type.name)) {

QStringList fields;

for (const auto &field : realType->fields) {

fields.push_back(typeToDefaultValue(field.type));

}

return "{ " + fields.join(", ") + " }";

}

return QString();

} break;

}

return QString();

structure::Value value,

bool ignoreCopy,

const QString& name) const {

auto copy = value.copyOf();

if (!ignoreCopy && !copy.isEmpty()) {

return "st::" + copy.join('.');

}

switch (value.type().tag) {

case Tag::Invalid: return QString();

case Tag::Int: return QString("%1").arg(value.Int());

case Tag::Bool: return QString(value.Bool() ? "true" : "false");

case Tag::Double: return QString("%1").arg(value.Double());

case Tag::Pixels: {

if (kWideMultiplicable.contains(name)) {

return QString("AyuUiSettings::getWideMultiplied(%1, %2)").arg(pxValueName(value.Int())).arg(kWideMultiplicable.at(name));

}

return pxValueName(value.Int());

} break;

case Tag::String: return QString("QString::fromUtf8(%1)").arg(stringToEncodedString(value.String()));

case Tag::Color: {

auto v(value.Color());

if (v.red == v.green && v.red == v.blue && v.red == 0 && v.alpha == 255) {

return QString("st::windowFg");

} else if (v.red == v.green && v.red == v.blue && v.red == 255 && v.alpha == 0) {

return QString("st::transparent");

} else {

common::logError(common::kErrorInternal, "") << "bad color value";

return QString();

}

} break;

case Tag::Point: {

auto v(value.Point());

return QString("{ %1, %2 }").arg(pxValueName(v.x), pxValueName(v.y));

} break;

case Tag::Size: {

auto v(value.Size());

if (kWideMultiplicable.contains(name)) {

return QString("{ AyuUiSettings::getWideMultiplied(%1, %3), AyuUiSettings::getWideMultiplied(%2, %3) }").arg(pxValueName(v.width), pxValueName(v.height)).arg(kWideMultiplicable.at(name));

}

return QString("{ %1, %2 }").arg(pxValueName(v.width), pxValueName(v.height));

} break;

case Tag::Align: return QString("style::al_%1").arg(value.String().c_str());

case Tag::Margins: {

auto v(value.Margins());

return QString("{ %1, %2, %3, %4 }").arg(pxValueName(v.left), pxValueName(v.top), pxValueName(v.right), pxValueName(v.bottom));

} break;

case Tag::Font: {

auto v(value.Font());

QString family = "0";

if (!v.family.empty()) {

auto familyIndex = fontFamilies_.value(v.family, -1);

if (familyIndex < 0) {

return QString();

}

family = QString("font%1index").arg(familyIndex);

}

return QString("{ %1, FontFlags::from_raw(%2), %3 }").arg(pxValueName(v.size)).arg(v.flags).arg(family);

} break;

case Tag::Icon: {

auto v(value.Icon());

QStringList parts = { "std::in_place" };

for (const auto &part : v.parts) {

auto maskIndex = iconMasks_.value(part.filename, -1);

if (maskIndex < 0) {

return QString();

}

auto color = valueAssignmentCode(part.color);

auto padding = valueAssignmentCode(part.padding);

parts.push_back(QString("MonoIcon{ &iconMask%1, %2, %3 }").arg(

QString::number(maskIndex),

color,

padding));

}

return QString("{ %1 }").arg(parts.join(", "));

} break;

case Tag::Struct: {

if (!value.Fields()) return QString();

QStringList fields;

for (const auto &field : *value.Fields()) {

fields.push_back(valueAssignmentCode(field.variable.value));

}

return "{ " + fields.join(", ") + " }";

} break;

}

return QString();

std::function<QString(const Module&, structure::FullName)> findInIncludes = [&](const Module &module, const structure::FullName &name) {

auto result = QString();

module.enumIncludes([&](const Module &included) {

if (Module::findStructInModule(name, included)) {

result = moduleBaseName(included);

return false;

}

result = findInIncludes(included, name);

return true;

});

return result;

};

auto includes = QStringList();

const auto written = module_.enumStructs([&](const Struct &value) -> bool {

for (const auto &field : value.fields) {

if (field.type.tag == structure::TypeTag::Struct) {

const auto name = field.type.name;

if (!module_.findStructInModule(name, module_)) {

const auto base = findInIncludes(module_, name);

if (base.isEmpty()) {

return false;

}

if (!includes.contains(base)) {

includes.push_back(base);

}

}

}

}

return true;

});

if (!written) {

return false;

} else if (includes.isEmpty()) {

return true;

}

for (const auto &base : includes) {

header_->include("styles/" + base + ".h");

}

header_->newline();

return true;

if (!module_.hasStructs() && !module_.hasVariables()) {

return true;

}

header_->pushNamespace("style");

if (module_.hasVariables()) {

header_->pushNamespace("internal").newline();

header_->stream() << "void init_" << baseName_ << "(int scale);\n\n";

header_->popNamespace();

}

bool wroteForwardDeclarations = writeStructsForwardDeclarations();

if (module_.hasStructs()) {

if (!wroteForwardDeclarations) {

header_->newline();

}

if (!writeStructsDefinitions()) {

return false;

}

} else if (isPalette_) {

if (!wroteForwardDeclarations) {

header_->newline();

}

if (!writePaletteDefinition()) {

return false;

}

}

header_->popNamespace().newline();

return true;

header_->stream() << "\

static constexpr auto kCount = " << (2 + module_.variablesCount()) << ";\n\

inline constexpr const color &white() const { return _colors[1]; }; // special color\n";

auto indexInPalette = 2;

if (!module_.enumVariables([&](const Variable &variable) -> bool {

auto name = variable.name.back();

if (variable.value.type().tag != structure::TypeTag::Color) {

return false;

}

auto index = (indexInPalette++);

header_->stream() << "\tinline constexpr const color &" << name << "() const { return _colors[" << index << "]; };\n";

return true;

})) return false;

const auto count = indexInPalette;

header_->stream() << "\

color _colors[kCount] = {\n";

for (int i = 0; i != count; ++i) {

header_->stream() << "\t\tdata(" << i << "),\n";

}

header_->stream() << "\

} // namespace internal\n";

return true;

bool hasNoExternalStructs = module_.enumVariables([&](const Variable &value) -> bool {

if (value.value.type().tag == structure::TypeTag::Struct) {

if (!module_.findStructInModule(value.value.type().name, module_)) {

return false;

}

}

return true;

});

if (hasNoExternalStructs) {

return false;

}

header_->newline();

std::set<QString> alreadyDeclaredTypes;

bool result = module_.enumVariables([&](const Variable &value) -> bool {

if (value.value.type().tag == structure::TypeTag::Struct) {

if (!module_.findStructInModule(value.value.type().name, module_)) {

if (alreadyDeclaredTypes.find(value.value.type().name.back()) == alreadyDeclaredTypes.end()) {

header_->stream() << "struct " << value.value.type().name.back() << ";\n";

alreadyDeclaredTypes.emplace(value.value.type().name.back());

}

}

}

return true;

});

header_->newline();

return result;

if (!module_.hasStructs()) {

return true;

}

bool result = module_.enumStructs([&](const Struct &value) -> bool {

header_->stream() << "\

struct " << value.name.back() << " {\n";

for (auto &field : value.fields) {

auto type = typeToString(field.type);

if (type.isEmpty()) {

return false;

}

header_->stream() << "\t" << type << " " << field.name.back() << ";\n";

}

header_->stream() << "\

};\n\n";

return true;

});

return result;

if (!module_.hasVariables()) {

return true;

}

header_->pushNamespace("st");

if (isPalette_) {

header_->stream() << "extern const style::color &transparent; // special color\n";

header_->stream() << "extern const style::color &white; // special color\n";

}

bool result = module_.enumVariables([&](const Variable &value) -> bool {

auto name = value.name.back();

auto type = typeToString(value.value.type());

if (type.isEmpty()) {

return false;

}

if (IsValueInHeader(value.value.type())) {

header_->stream()

<< "constexpr "

<< type

<< " "

<< name

<< " = "

<< valueAssignmentCode(

value.value,

IsValueInHeader(value.value.type()))

<< ";\n";

} else {

header_->stream()

<< "extern const "

<< type

<< " &"

<< name

<< ";\n";

}

return true;

});

header_->popNamespace();

return result;

if (isPalette_) {

source_->include("ui/style/style_core_palette.h");

source_->newline();

}

if (!module_.hasIncludes()) {

return true;

}

auto includes = QStringList();

std::function<bool(const Module&)> collector = [&](const Module &module) {

module.enumIncludes(collector);

auto base = moduleBaseName(module);

if (!includes.contains(base)) {

includes.push_back(base);

}

return true;

};

auto result = module_.enumIncludes(collector);

for (const auto &base : includes) {

source_->include("styles/" + base + ".h");

}

const auto ayuIncluded = !module_.enumVariables([=](const Variable &value) -> bool

{

for (const auto &name : value.name) {

if (kWideMultiplicable.contains(name)) {

return false;

}

}

return true;

});

if (ayuIncluded) {

source_->include("ayu/ayu_ui_settings.h");

}

source_->newline();

return result;

if (!module_.hasVariables()) {

return true;

}

source_->newline();

bool result = module_.enumVariables([&](const Variable &variable) -> bool {

auto name = variable.name.back();

auto type = typeToString(variable.value.type());

if (type.isEmpty()) {

return false;

}

if (!IsValueInHeader(variable.value.type())) {

source_->stream()

<< type

<< " _"

<< name

<< " = "

<< typeToDefaultValue(variable.value.type())

<< ";\n";

}

return true;

});

return result;

if (!module_.hasVariables()) {

return true;

}

if (isPalette_) {

source_->stream() << "const style::color &transparent(_palette.transparent()); // special color\n";

source_->stream() << "const style::color &white(_palette.white()); // special color\n";

}

bool result = module_.enumVariables([&](const Variable &variable) -> bool {

auto name = variable.name.back();

auto type = typeToString(variable.value.type());

if (type.isEmpty()) {

return false;

}

if (IsValueInHeader(variable.value.type())) {

return true;

}

source_->stream() << "const " << type << " &" << name << "(";

if (isPalette_) {

source_->stream() << "_palette." << name << "()";

} else {

source_->stream() << "_" << name;

}

source_->stream() << ");\n";

return true;

});

return result;

source_->stream() << "\n\

that.compute(1, -1, { 255, 255, 255, 255}); // special color white\n";

QList<structure::FullName> names;

module_.enumVariables([&](const Variable &variable) -> bool {

names.push_back(variable.name);

return true;

});

QString dataRows;

int indexInPalette = 2;

QByteArray checksumString;

checksumString.append("&transparent:{ 255, 255, 255, 0 }");

checksumString.append("&white:{ 255, 255, 255, 255 }");

auto result = module_.enumVariables([&](const Variable &variable) -> bool {

auto name = variable.name.back();

auto index = indexInPalette++;

paletteIndices_.emplace(name, index);

if (variable.value.type().tag != structure::TypeTag::Color) {

return false;

}

auto color = variable.value.Color();

auto fallbackIterator = paletteIndices_.find(colorFallbackName(variable.value));

auto fallbackIndex = (fallbackIterator == paletteIndices_.end()) ? -1 : fallbackIterator->second;

auto assignment = QString("{ %1, %2, %3, %4 }").arg(color.red).arg(color.green).arg(color.blue).arg(color.alpha);

source_->stream() << "\tthat.compute(" << index << ", " << fallbackIndex << ", " << assignment << ");\n";

checksumString.append(('&' + name + ':' + assignment).toUtf8());

auto isCopy = !variable.value.copyOf().isEmpty();

auto colorString = paletteColorValue(color);

auto fallbackName = QString();

if (fallbackIndex > 1) {

auto fallbackVariable = module_.findVariableInModule(names[fallbackIndex - 2], module_);

if (fallbackVariable && fallbackVariable->value.type().tag == structure::TypeTag::Color) {

fallbackName = fallbackVariable->name.back();

}

}

auto value = isCopy ? fallbackName : '#' + colorString;

if (value.isEmpty()) {

return false;

}

dataRows.append("\tresult.push_back({ qstr(\"" + name + "\"), qstr(\"" + value + "\"), qstr(\"" + (isCopy ? QString() : fallbackName) + "\"), qstr(" + stringToEncodedString(variable.description) + ") });\n");

return true;

});

if (!result) {

return false;

}

auto count = indexInPalette;

auto checksum = base::crc32(checksumString.constData(), checksumString.size());

source_->stream() << "\n\n";

for (const auto &[over, under] : kMustBeContrast) {

const auto overIndex = paletteIndices_.find(over);

const auto underIndex = paletteIndices_.find(under);

if (overIndex == paletteIndices_.end() || underIndex == paletteIndices_.end()) {

return false;

}

source_->stream() << "\tinternal::EnsureContrast(*data(" << overIndex->second << "), *data(" << underIndex->second << "));\n";

}

source_->stream() << "\

return " << checksum << ";\n\

}\n";

source_->newline().pushNamespace("internal").newline();

source_->stream() << "\

auto data = name.data();\n";

auto tabs = [](int size) {

return QString(size, '\t');

};

enum class UsedCheckType {

Switch,

If,

UpcomingIf,

};

auto checkTypes = QVector<UsedCheckType>();

auto checkLengthHistory = QVector<int>(1, 0);

auto chars = QString();

auto tabsUsed = 1;

// Returns true if at least one check was finished.

auto finishChecksTillKey = [&](const QString &key) {

auto result = false;

while (!chars.isEmpty() && !key.startsWith(chars)) {

result = true;

auto wasType = checkTypes.back();

chars.resize(chars.size() - 1);

checkTypes.pop_back();

checkLengthHistory.pop_back();

if (wasType == UsedCheckType::Switch || wasType == UsedCheckType::If) {

--tabsUsed;

if (wasType == UsedCheckType::Switch) {

source_->stream() << tabs(tabsUsed) << "break;\n";

}

if ((!chars.isEmpty() && !key.startsWith(chars)) || key == chars) {

source_->stream() << tabs(tabsUsed) << "}\n";

}

}

}

return result;

};

// Check if we can use "if" for a check on "charIndex" in "it" (otherwise only "switch")

auto canUseIfForCheck = [](auto it, auto end, int charIndex) {

auto key = it->first;

auto i = it;

auto keyStart = key.mid(0, charIndex);

for (++i; i != end; ++i) {

auto nextKey = i->first;

if (nextKey.mid(0, charIndex) != keyStart) {

return true;

} else if (nextKey.size() > charIndex && nextKey[charIndex] != key[charIndex]) {

return false;

}

}

return true;

};

auto countMinimalLength = [](auto it, auto end, int charIndex) {

auto key = it->first;

auto i = it;

auto keyStart = key.mid(0, charIndex);

auto result = key.size();

for (++i; i != end; ++i) {

auto nextKey = i->first;

if (nextKey.mid(0, charIndex) != keyStart) {

break;

} else if (nextKey.size() > charIndex && result > nextKey.size()) {

result = nextKey.size();

}

}

return result;

};

for (auto i = paletteIndices_.begin(), e = paletteIndices_.end(); i != e; ++i) {

auto name = i->first;

auto index = i->second;

auto weContinueOldSwitch = finishChecksTillKey(name);

while (chars.size() != name.size()) {

auto checking = chars.size();

auto keyChar = name[checking];

auto usedIfForCheckCount = 0;

auto minimalLengthCheck = int(countMinimalLength(i, e, checking));

for (; checking + usedIfForCheckCount != name.size(); ++usedIfForCheckCount) {

if (!canUseIfForCheck(i, e, checking + usedIfForCheckCount)

|| countMinimalLength(i, e, checking + usedIfForCheckCount) != minimalLengthCheck) {

break;

}

}

auto usedIfForCheck = !weContinueOldSwitch && (usedIfForCheckCount > 0);

auto checkLengthCondition = QString();

if (weContinueOldSwitch) {

weContinueOldSwitch = false;

} else {

checkLengthCondition = (minimalLengthCheck > checkLengthHistory.back()) ? ("size >= " + QString::number(minimalLengthCheck)) : QString();

if (!usedIfForCheck) {

source_->stream() << tabs(tabsUsed) << (checkLengthCondition.isEmpty() ? QString() : ("if (" + checkLengthCondition + ") ")) << "switch (data[" << checking << "]) {\n";

}

}

if (usedIfForCheck) {

auto conditions = QStringList();

if (usedIfForCheckCount > 1) {

conditions.push_back("!memcmp(data + " + QString::number(checking) + ", \"" + name.mid(checking, usedIfForCheckCount) + "\", " + QString::number(usedIfForCheckCount) + ")");

} else {

conditions.push_back("data[" + QString::number(checking) + "] == '" + keyChar + "'");

}

if (!checkLengthCondition.isEmpty()) {

conditions.push_front(checkLengthCondition);

}

source_->stream() << tabs(tabsUsed) << "if (" << conditions.join(" && ") << ") {\n";

checkTypes.push_back(UsedCheckType::If);

for (auto i = 1; i != usedIfForCheckCount; ++i) {

checkTypes.push_back(UsedCheckType::UpcomingIf);

chars.push_back(keyChar);

checkLengthHistory.push_back(std::max(

minimalLengthCheck,

checkLengthHistory.back()));

keyChar = name[checking + i];

}

} else {

source_->stream() << tabs(tabsUsed) << "case '" << keyChar << "':\n";

checkTypes.push_back(UsedCheckType::Switch);

}

++tabsUsed;

chars.push_back(keyChar);

checkLengthHistory.push_back(std::max(

minimalLengthCheck,

checkLengthHistory.back()));

}

source_->stream() << tabs(tabsUsed) << "return (size == " << chars.size() << ") ? " << index << " : -1;\n";

}

finishChecksTillKey(QString());

source_->stream() << "\

}\n";

source_->newline().popNamespace().newline();

source_->stream() << "\

result.reserve(" << count << ");\n\

" << dataRows << "\n\

\n";

return result;

if (!module_.hasVariables()) {

return true;

}

if (!collectUniqueValues()) {

return false;

}

bool hasUniqueValues = (!fontFamilies_.isEmpty() || !iconMasks_.isEmpty());

if (hasUniqueValues) {

source_->pushNamespace();

if (!writeFontFamiliesInit()) {

return false;

}

if (!writeIconValues()) {

return false;

}

source_->popNamespace().newline();

}

source_->stream() << "\

void init_" << baseName_ << "(int scale) {\n\

inited = true;\n\n";

if (module_.hasIncludes()) {

bool writtenAtLeastOne = false;

bool result = module_.enumIncludes([&](const Module &module) -> bool {

if (module.hasVariables()) {