mirror of
https://github.com/fastfetch-cli/fastfetch.git
synced 2026-11-05 04:34:19 +01:00
李通洲
e0eba8ce21
```bash find . -type f \( -name "*.c" -o -name "*.h" -o -name "*.cpp" -o -name "*.hpp" \) ! -path "src/3rdparty/*" -print0 | xargs -0 clang-format -i ```
547 lines
27 KiB
C
547 lines
27 KiB
C
#include "logo/logo.h"
|
|
|
|
#include "common/jsonconfig.h"
|
|
#include "common/stringUtils.h"
|
|
|
|
void ffOptionsInitLogo(FFOptionsLogo* options) {
|
|
ffStrbufInit(&options->source);
|
|
options->type = FF_LOGO_TYPE_AUTO;
|
|
for (uint8_t i = 0; i < (uint8_t) FASTFETCH_LOGO_MAX_COLORS; ++i) {
|
|
ffStrbufInit(&options->colors[i]);
|
|
}
|
|
options->width = 0;
|
|
options->height = 0; // preserve aspect ratio
|
|
options->paddingTop = 0;
|
|
options->paddingLeft = 0;
|
|
options->paddingRight = 4;
|
|
options->printRemaining = true;
|
|
options->preserveAspectRatio = false;
|
|
options->recache = false;
|
|
options->position = FF_LOGO_POSITION_LEFT;
|
|
|
|
options->chafaFgOnly = false;
|
|
ffStrbufInitStatic(&options->chafaSymbols, "block+border+space-wide-inverted"); // Chafa default
|
|
options->chafaCanvasMode = UINT32_MAX;
|
|
options->chafaColorSpace = UINT32_MAX;
|
|
options->chafaDitherMode = UINT32_MAX;
|
|
}
|
|
|
|
bool ffOptionsParseLogoCommandLine(FFOptionsLogo* options, const char* key, const char* value) {
|
|
if (ffStrEqualsIgnCase(key, "-l")) {
|
|
goto logoType;
|
|
}
|
|
|
|
const char* subKey = ffOptionTestPrefix(key, "logo");
|
|
if (subKey) {
|
|
if (subKey[0] == '\0') {
|
|
logoType:
|
|
if (value == NULL) {
|
|
fprintf(stderr, "Error: usage: %s <none|small|logo-source>\n", key);
|
|
exit(477);
|
|
}
|
|
// this is usually wanted when disabling logo
|
|
if (ffStrEqualsIgnCase(value, "none")) {
|
|
options->type = FF_LOGO_TYPE_NONE;
|
|
} else if (ffStrEqualsIgnCase(value, "small")) {
|
|
options->type = FF_LOGO_TYPE_SMALL;
|
|
} else {
|
|
ffOptionParseString(key, value, &options->source);
|
|
}
|
|
} else if (ffStrEqualsIgnCase(subKey, "type")) {
|
|
options->type = (FFLogoType) ffOptionParseEnum(key, value, (FFKeyValuePair[]) {
|
|
{"auto", FF_LOGO_TYPE_AUTO},
|
|
{"builtin", FF_LOGO_TYPE_BUILTIN},
|
|
{"small", FF_LOGO_TYPE_SMALL},
|
|
{"file", FF_LOGO_TYPE_FILE},
|
|
{"file-raw", FF_LOGO_TYPE_FILE_RAW},
|
|
{"data", FF_LOGO_TYPE_DATA},
|
|
{"data-raw", FF_LOGO_TYPE_DATA_RAW},
|
|
{"command-raw", FF_LOGO_TYPE_COMMAND_RAW},
|
|
{"sixel", FF_LOGO_TYPE_IMAGE_SIXEL},
|
|
{"kitty", FF_LOGO_TYPE_IMAGE_KITTY},
|
|
{"kitty-direct", FF_LOGO_TYPE_IMAGE_KITTY_DIRECT},
|
|
{"kitty-icat", FF_LOGO_TYPE_IMAGE_KITTY_ICAT},
|
|
{"iterm", FF_LOGO_TYPE_IMAGE_ITERM},
|
|
{"chafa", FF_LOGO_TYPE_IMAGE_CHAFA},
|
|
{"raw", FF_LOGO_TYPE_IMAGE_RAW},
|
|
{"none", FF_LOGO_TYPE_NONE},
|
|
{},
|
|
});
|
|
} else if (ffStrStartsWithIgnCase(subKey, "color-") && subKey[6] != '\0' && subKey[7] == '\0') // matches "--logo-color-*"
|
|
{
|
|
// Map the number to an array index, so that '1' -> 0, '2' -> 1, etc.
|
|
int index = (int) subKey[6] - '0' - 1;
|
|
|
|
// Match only --logo-color-[1-9]
|
|
if (index < 0 || index >= FASTFETCH_LOGO_MAX_COLORS) {
|
|
fprintf(stderr, "Error: invalid --color-[1-9] index: %c\n", key[13]);
|
|
exit(472);
|
|
}
|
|
if (value == NULL) {
|
|
fprintf(stderr, "Error: usage: %s <str>\n", key);
|
|
exit(477);
|
|
}
|
|
ffOptionParseColor(value, &options->colors[index]);
|
|
} else if (ffStrEqualsIgnCase(subKey, "width")) {
|
|
options->width = ffOptionParseUInt32(key, value);
|
|
} else if (ffStrEqualsIgnCase(subKey, "height")) {
|
|
options->height = ffOptionParseUInt32(key, value);
|
|
} else if (ffStrEqualsIgnCase(subKey, "padding")) {
|
|
uint32_t padding = ffOptionParseUInt32(key, value);
|
|
options->paddingLeft = padding;
|
|
options->paddingRight = padding;
|
|
} else if (ffStrEqualsIgnCase(subKey, "padding-top")) {
|
|
options->paddingTop = ffOptionParseUInt32(key, value);
|
|
} else if (ffStrEqualsIgnCase(subKey, "padding-left")) {
|
|
options->paddingLeft = ffOptionParseUInt32(key, value);
|
|
} else if (ffStrEqualsIgnCase(subKey, "padding-right")) {
|
|
options->paddingRight = ffOptionParseUInt32(key, value);
|
|
} else if (ffStrEqualsIgnCase(subKey, "print-remaining")) {
|
|
options->printRemaining = ffOptionParseBoolean(value);
|
|
} else if (ffStrEqualsIgnCase(subKey, "preserve-aspect-ratio")) {
|
|
options->preserveAspectRatio = ffOptionParseBoolean(value);
|
|
} else if (ffStrEqualsIgnCase(subKey, "recache")) {
|
|
options->recache = ffOptionParseBoolean(value);
|
|
} else if (ffStrEqualsIgnCase(subKey, "separate")) {
|
|
fputs("--logo-separate has been renamed to --logo-position\n", stderr);
|
|
exit(477);
|
|
} else if (ffStrEqualsIgnCase(subKey, "position")) {
|
|
options->position = (FFLogoPosition) ffOptionParseEnum(key, value, (FFKeyValuePair[]) {
|
|
{"left", FF_LOGO_POSITION_LEFT},
|
|
{"right", FF_LOGO_POSITION_RIGHT},
|
|
{"top", FF_LOGO_POSITION_TOP},
|
|
{},
|
|
});
|
|
} else {
|
|
return false;
|
|
}
|
|
} else if ((subKey = ffOptionTestPrefix(key, "file"))) {
|
|
if (subKey[0] == '\0') {
|
|
ffOptionParseString(key, value, &options->source);
|
|
options->type = FF_LOGO_TYPE_FILE;
|
|
} else if (ffStrEqualsIgnCase(subKey, "raw")) {
|
|
ffOptionParseString(key, value, &options->source);
|
|
options->type = FF_LOGO_TYPE_FILE_RAW;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else if ((subKey = ffOptionTestPrefix(key, "data"))) {
|
|
if (subKey[0] == '\0') {
|
|
ffOptionParseString(key, value, &options->source);
|
|
options->type = FF_LOGO_TYPE_DATA;
|
|
} else if (ffStrEqualsIgnCase(subKey, "raw")) {
|
|
ffOptionParseString(key, value, &options->source);
|
|
options->type = FF_LOGO_TYPE_DATA_RAW;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else if (ffStrEqualsIgnCase(key, "--sixel")) {
|
|
ffOptionParseString(key, value, &options->source);
|
|
options->type = FF_LOGO_TYPE_IMAGE_SIXEL;
|
|
} else if (ffStrEqualsIgnCase(key, "--kitty")) {
|
|
ffOptionParseString(key, value, &options->source);
|
|
options->type = FF_LOGO_TYPE_IMAGE_KITTY;
|
|
} else if (ffStrEqualsIgnCase(key, "--kitty-direct")) {
|
|
ffOptionParseString(key, value, &options->source);
|
|
options->type = FF_LOGO_TYPE_IMAGE_KITTY_DIRECT;
|
|
} else if (ffStrEqualsIgnCase(key, "--kitty-icat")) {
|
|
ffOptionParseString(key, value, &options->source);
|
|
options->type = FF_LOGO_TYPE_IMAGE_KITTY_ICAT;
|
|
} else if (ffStrEqualsIgnCase(key, "--iterm")) {
|
|
ffOptionParseString(key, value, &options->source);
|
|
options->type = FF_LOGO_TYPE_IMAGE_ITERM;
|
|
} else if (ffStrEqualsIgnCase(key, "--raw")) {
|
|
ffOptionParseString(key, value, &options->source);
|
|
options->type = FF_LOGO_TYPE_IMAGE_RAW;
|
|
} else if ((subKey = ffOptionTestPrefix(key, "chafa"))) {
|
|
if (subKey[0] == '\0') {
|
|
ffOptionParseString(key, value, &options->source);
|
|
options->type = FF_LOGO_TYPE_IMAGE_CHAFA;
|
|
} else if (ffStrEqualsIgnCase(subKey, "fg-only")) {
|
|
options->chafaFgOnly = ffOptionParseBoolean(value);
|
|
} else if (ffStrEqualsIgnCase(subKey, "symbols")) {
|
|
ffOptionParseString(key, value, &options->chafaSymbols);
|
|
} else if (ffStrEqualsIgnCase(subKey, "canvas-mode")) {
|
|
options->chafaCanvasMode = (uint32_t) ffOptionParseEnum(key, value, (FFKeyValuePair[]) {
|
|
{"TRUECOLOR", 0},
|
|
{"INDEXED_256", 1},
|
|
{"INDEXED_240", 2},
|
|
{"INDEXED_16", 3},
|
|
{"FGBG_BGFG", 4},
|
|
{"FGBG", 5},
|
|
{"INDEXED_8", 6},
|
|
{"INDEXED_16_8", 7},
|
|
{},
|
|
});
|
|
} else if (ffStrEqualsIgnCase(subKey, "color-space")) {
|
|
options->chafaColorSpace = (uint32_t) ffOptionParseEnum(key, value, (FFKeyValuePair[]) {
|
|
{"RGB", 0},
|
|
{"DIN99D", 1},
|
|
{},
|
|
});
|
|
} else if (ffStrEqualsIgnCase(subKey, "dither-mode")) {
|
|
options->chafaDitherMode = (uint32_t) ffOptionParseEnum(key, value, (FFKeyValuePair[]) {
|
|
{"NONE", 0},
|
|
{"ORDERED", 1},
|
|
{"DIFFUSION", 2},
|
|
{},
|
|
});
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void ffOptionsDestroyLogo(FFOptionsLogo* options) {
|
|
ffStrbufDestroy(&options->source);
|
|
ffStrbufDestroy(&options->chafaSymbols);
|
|
for (uint8_t i = 0; i < (uint8_t) FASTFETCH_LOGO_MAX_COLORS; ++i) {
|
|
ffStrbufDestroy(&options->colors[i]);
|
|
}
|
|
}
|
|
|
|
const char* ffOptionsParseLogoJsonConfig(FFOptionsLogo* options, yyjson_val* root) {
|
|
yyjson_val* object = yyjson_obj_get(root, "logo");
|
|
if (!object) {
|
|
return NULL;
|
|
}
|
|
if (yyjson_is_null(object)) {
|
|
options->type = FF_LOGO_TYPE_NONE;
|
|
options->paddingTop = 0;
|
|
options->paddingRight = 0;
|
|
options->paddingLeft = 0;
|
|
return NULL;
|
|
}
|
|
|
|
if (yyjson_is_str(object)) {
|
|
ffStrbufSetJsonVal(&options->source, object);
|
|
return NULL;
|
|
}
|
|
|
|
if (!yyjson_is_obj(object)) {
|
|
return "Property 'logo' must be an object";
|
|
}
|
|
|
|
yyjson_val *key, *val;
|
|
size_t idx, max;
|
|
yyjson_obj_foreach (object, idx, max, key, val) {
|
|
if (unsafe_yyjson_equals_str(key, "type")) {
|
|
int value;
|
|
const char* error = ffJsonConfigParseEnum(val, &value, (FFKeyValuePair[]) {
|
|
{"auto", FF_LOGO_TYPE_AUTO},
|
|
{"builtin", FF_LOGO_TYPE_BUILTIN},
|
|
{"small", FF_LOGO_TYPE_SMALL},
|
|
{"file", FF_LOGO_TYPE_FILE},
|
|
{"file-raw", FF_LOGO_TYPE_FILE_RAW},
|
|
{"data", FF_LOGO_TYPE_DATA},
|
|
{"data-raw", FF_LOGO_TYPE_DATA_RAW},
|
|
{"command-raw", FF_LOGO_TYPE_COMMAND_RAW},
|
|
{"sixel", FF_LOGO_TYPE_IMAGE_SIXEL},
|
|
{"kitty", FF_LOGO_TYPE_IMAGE_KITTY},
|
|
{"kitty-direct", FF_LOGO_TYPE_IMAGE_KITTY_DIRECT},
|
|
{"kitty-icat", FF_LOGO_TYPE_IMAGE_KITTY_ICAT},
|
|
{"iterm", FF_LOGO_TYPE_IMAGE_ITERM},
|
|
{"chafa", FF_LOGO_TYPE_IMAGE_CHAFA},
|
|
{"raw", FF_LOGO_TYPE_IMAGE_RAW},
|
|
{"none", FF_LOGO_TYPE_NONE},
|
|
{},
|
|
});
|
|
|
|
if (error) {
|
|
return error;
|
|
}
|
|
options->type = (FFLogoType) value;
|
|
continue;
|
|
} else if (unsafe_yyjson_equals_str(key, "source")) {
|
|
ffStrbufSetJsonVal(&options->source, val);
|
|
continue;
|
|
} else if (unsafe_yyjson_equals_str(key, "color")) {
|
|
if (!yyjson_is_obj(val)) {
|
|
return "Property 'color' must be an object";
|
|
}
|
|
|
|
yyjson_val *keyc, *valc;
|
|
size_t idxc, maxc;
|
|
yyjson_obj_foreach (val, idxc, maxc, keyc, valc) {
|
|
uint32_t index = (uint32_t) strtoul(unsafe_yyjson_get_str(keyc), NULL, 10);
|
|
if (index < 1 || index > FASTFETCH_LOGO_MAX_COLORS) {
|
|
return "Keys of property 'color' must be a number between 1 to 9";
|
|
}
|
|
|
|
ffOptionParseColor(yyjson_get_str(valc), &options->colors[index - 1]);
|
|
}
|
|
continue;
|
|
} else if (unsafe_yyjson_equals_str(key, "width")) {
|
|
if (yyjson_is_null(val)) {
|
|
options->width = 0;
|
|
} else {
|
|
uint32_t value = (uint32_t) yyjson_get_uint(val);
|
|
if (value == 0) {
|
|
return "Logo width must be a positive integer";
|
|
}
|
|
options->width = value;
|
|
}
|
|
continue;
|
|
} else if (unsafe_yyjson_equals_str(key, "height")) {
|
|
if (yyjson_is_null(val)) {
|
|
options->height = 0;
|
|
} else {
|
|
uint32_t value = (uint32_t) yyjson_get_uint(val);
|
|
if (value == 0) {
|
|
return "Logo height must be a positive integer";
|
|
}
|
|
options->height = value;
|
|
}
|
|
continue;
|
|
} else if (unsafe_yyjson_equals_str(key, "padding")) {
|
|
if (!yyjson_is_obj(val)) {
|
|
return "Logo padding must be an object";
|
|
}
|
|
|
|
#define FF_PARSE_PADDING_POSITON(pos, paddingPos) \
|
|
yyjson_val* pos = yyjson_obj_get(val, #pos); \
|
|
if (pos) { \
|
|
if (!yyjson_is_uint(pos)) \
|
|
return "Logo padding values must be positive integers"; \
|
|
options->paddingPos = (uint32_t) yyjson_get_uint(pos); \
|
|
}
|
|
FF_PARSE_PADDING_POSITON(left, paddingLeft);
|
|
FF_PARSE_PADDING_POSITON(top, paddingTop);
|
|
FF_PARSE_PADDING_POSITON(right, paddingRight);
|
|
#undef FF_PARSE_PADDING_POSITON
|
|
continue;
|
|
} else if (unsafe_yyjson_equals_str(key, "printRemaining")) {
|
|
options->printRemaining = yyjson_get_bool(val);
|
|
continue;
|
|
} else if (unsafe_yyjson_equals_str(key, "preserveAspectRatio")) {
|
|
options->preserveAspectRatio = yyjson_get_bool(val);
|
|
continue;
|
|
} else if (unsafe_yyjson_equals_str(key, "recache")) {
|
|
options->recache = yyjson_get_bool(val);
|
|
continue;
|
|
} else if (unsafe_yyjson_equals_str(key, "position")) {
|
|
int value;
|
|
const char* error = ffJsonConfigParseEnum(val, &value, (FFKeyValuePair[]) {
|
|
{"left", FF_LOGO_POSITION_LEFT},
|
|
{"top", FF_LOGO_POSITION_TOP},
|
|
{"right", FF_LOGO_POSITION_RIGHT},
|
|
{},
|
|
});
|
|
|
|
if (error) {
|
|
return error;
|
|
}
|
|
options->position = (FFLogoPosition) value;
|
|
continue;
|
|
} else if (unsafe_yyjson_equals_str(key, "chafa")) {
|
|
if (!yyjson_is_obj(val)) {
|
|
return "Chafa config must be an object";
|
|
}
|
|
|
|
yyjson_val* fgOnly = yyjson_obj_get(val, "fgOnly");
|
|
if (fgOnly) {
|
|
options->chafaFgOnly = yyjson_get_bool(fgOnly);
|
|
}
|
|
|
|
yyjson_val* symbols = yyjson_obj_get(val, "symbols");
|
|
if (symbols) {
|
|
ffStrbufSetJsonVal(&options->chafaSymbols, symbols);
|
|
}
|
|
|
|
yyjson_val* canvasMode = yyjson_obj_get(val, "canvasMode");
|
|
if (canvasMode) {
|
|
int value;
|
|
const char* error = ffJsonConfigParseEnum(canvasMode, &value, (FFKeyValuePair[]) {
|
|
{"TRUECOLOR", 0},
|
|
{"INDEXED_256", 1},
|
|
{"INDEXED_240", 2},
|
|
{"INDEXED_16", 3},
|
|
{"FGBG_BGFG", 4},
|
|
{"FGBG", 5},
|
|
{"INDEXED_8", 6},
|
|
{"INDEXED_16_8", 7},
|
|
{},
|
|
});
|
|
|
|
if (error) {
|
|
return error;
|
|
}
|
|
options->chafaCanvasMode = (uint32_t) value;
|
|
}
|
|
|
|
yyjson_val* colorSpace = yyjson_obj_get(val, "colorSpace");
|
|
if (colorSpace) {
|
|
int value;
|
|
const char* error = ffJsonConfigParseEnum(colorSpace, &value, (FFKeyValuePair[]) {
|
|
{"RGB", 0},
|
|
{"DIN99D", 1},
|
|
{},
|
|
});
|
|
|
|
if (error) {
|
|
return error;
|
|
}
|
|
options->chafaColorSpace = (uint32_t) value;
|
|
}
|
|
|
|
yyjson_val* ditherMode = yyjson_obj_get(val, "ditherMode");
|
|
if (ditherMode) {
|
|
int value;
|
|
const char* error = ffJsonConfigParseEnum(ditherMode, &value, (FFKeyValuePair[]) {
|
|
{"NONE", 0},
|
|
{"ORDERED", 1},
|
|
{"DIFFUSION", 2},
|
|
{},
|
|
});
|
|
|
|
if (error) {
|
|
return error;
|
|
}
|
|
options->chafaDitherMode = (uint32_t) value;
|
|
}
|
|
continue;
|
|
} else {
|
|
return "Unknown logo key";
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void ffOptionsGenerateLogoJsonConfig(FFdata* data, FFOptionsLogo* options) {
|
|
yyjson_mut_doc* doc = data->resultDoc;
|
|
yyjson_mut_val* obj = yyjson_mut_obj(doc);
|
|
|
|
switch (options->type) {
|
|
case FF_LOGO_TYPE_NONE:
|
|
yyjson_mut_obj_add_null(doc, doc->root, "logo");
|
|
return;
|
|
case FF_LOGO_TYPE_BUILTIN:
|
|
yyjson_mut_obj_add_str(doc, obj, "type", "builtin");
|
|
break;
|
|
case FF_LOGO_TYPE_SMALL:
|
|
yyjson_mut_obj_add_str(doc, obj, "type", "small");
|
|
break;
|
|
case FF_LOGO_TYPE_FILE:
|
|
yyjson_mut_obj_add_str(doc, obj, "type", "file");
|
|
break;
|
|
case FF_LOGO_TYPE_FILE_RAW:
|
|
yyjson_mut_obj_add_str(doc, obj, "type", "file-raw");
|
|
break;
|
|
case FF_LOGO_TYPE_DATA:
|
|
yyjson_mut_obj_add_str(doc, obj, "type", "data");
|
|
break;
|
|
case FF_LOGO_TYPE_DATA_RAW:
|
|
yyjson_mut_obj_add_str(doc, obj, "type", "data-raw");
|
|
break;
|
|
case FF_LOGO_TYPE_COMMAND_RAW:
|
|
yyjson_mut_obj_add_str(doc, obj, "type", "command-raw");
|
|
break;
|
|
case FF_LOGO_TYPE_IMAGE_SIXEL:
|
|
yyjson_mut_obj_add_str(doc, obj, "type", "sixel");
|
|
break;
|
|
case FF_LOGO_TYPE_IMAGE_KITTY:
|
|
yyjson_mut_obj_add_str(doc, obj, "type", "kitty");
|
|
break;
|
|
case FF_LOGO_TYPE_IMAGE_KITTY_DIRECT:
|
|
yyjson_mut_obj_add_str(doc, obj, "type", "kitty-direct");
|
|
break;
|
|
case FF_LOGO_TYPE_IMAGE_KITTY_ICAT:
|
|
yyjson_mut_obj_add_str(doc, obj, "type", "kitty-icat");
|
|
break;
|
|
case FF_LOGO_TYPE_IMAGE_ITERM:
|
|
yyjson_mut_obj_add_str(doc, obj, "type", "iterm");
|
|
break;
|
|
case FF_LOGO_TYPE_IMAGE_CHAFA:
|
|
yyjson_mut_obj_add_str(doc, obj, "type", "chafa");
|
|
break;
|
|
case FF_LOGO_TYPE_IMAGE_RAW:
|
|
yyjson_mut_obj_add_str(doc, obj, "type", "raw");
|
|
break;
|
|
default:
|
|
yyjson_mut_obj_add_str(doc, obj, "type", "auto");
|
|
break;
|
|
}
|
|
|
|
yyjson_mut_obj_add_str(doc, obj, "source", options->source.chars);
|
|
|
|
{
|
|
yyjson_mut_val* color = yyjson_mut_obj(doc);
|
|
for (int i = 0; i < FASTFETCH_LOGO_MAX_COLORS; i++) {
|
|
char c = (char) ('1' + i);
|
|
yyjson_mut_obj_add(color, yyjson_mut_strncpy(doc, &c, 1), yyjson_mut_strbuf(doc, &options->colors[i]));
|
|
}
|
|
yyjson_mut_obj_add_val(doc, obj, "color", color);
|
|
}
|
|
|
|
if (options->width == 0) {
|
|
yyjson_mut_obj_add_null(doc, obj, "width");
|
|
} else {
|
|
yyjson_mut_obj_add_uint(doc, obj, "width", options->width);
|
|
}
|
|
|
|
if (options->height == 0) {
|
|
yyjson_mut_obj_add_null(doc, obj, "height");
|
|
} else {
|
|
yyjson_mut_obj_add_uint(doc, obj, "height", options->height);
|
|
}
|
|
|
|
{
|
|
yyjson_mut_val* padding = yyjson_mut_obj_add_obj(doc, obj, "padding");
|
|
yyjson_mut_obj_add_uint(doc, padding, "top", options->paddingTop);
|
|
yyjson_mut_obj_add_uint(doc, padding, "left", options->paddingLeft);
|
|
yyjson_mut_obj_add_uint(doc, padding, "right", options->paddingRight);
|
|
}
|
|
|
|
yyjson_mut_obj_add_bool(doc, obj, "printRemaining", options->printRemaining);
|
|
|
|
yyjson_mut_obj_add_bool(doc, obj, "preserveAspectRatio", options->preserveAspectRatio);
|
|
|
|
yyjson_mut_obj_add_bool(doc, obj, "recache", options->recache);
|
|
|
|
yyjson_mut_obj_add_str(doc, obj, "position", ((const char*[]) {
|
|
"left",
|
|
"top",
|
|
"right",
|
|
})[options->position]);
|
|
|
|
{
|
|
yyjson_mut_val* chafa = yyjson_mut_obj(doc);
|
|
yyjson_mut_obj_add_bool(doc, chafa, "fgOnly", options->chafaFgOnly);
|
|
yyjson_mut_obj_add_strbuf(doc, chafa, "symbols", &options->chafaSymbols);
|
|
if (options->chafaCanvasMode <= 7) {
|
|
yyjson_mut_obj_add_str(doc, chafa, "canvasMode", ((const char*[]) {
|
|
"TRUECOLOR",
|
|
"INDEXED_256",
|
|
"INDEXED_240",
|
|
"INDEXED_16",
|
|
"FGBG_BGFG",
|
|
"FGBG",
|
|
"INDEXED_8",
|
|
"INDEXED_16_8",
|
|
})[options->chafaCanvasMode]);
|
|
}
|
|
if (options->chafaColorSpace <= 1) {
|
|
yyjson_mut_obj_add_str(doc, chafa, "colorSpace", ((const char*[]) {
|
|
"RGB",
|
|
"DIN99D",
|
|
})[options->chafaColorSpace]);
|
|
}
|
|
if (options->chafaDitherMode <= 2) {
|
|
yyjson_mut_obj_add_str(doc, chafa, "ditherMode", ((const char*[]) {
|
|
"NONE",
|
|
"ORDERED",
|
|
"DIFFUSION",
|
|
})[options->chafaDitherMode]);
|
|
}
|
|
|
|
yyjson_mut_obj_add_val(doc, obj, "chafa", chafa);
|
|
}
|
|
|
|
yyjson_mut_obj_add_val(doc, doc->root, "logo", obj);
|
|
}
|