mirror of
https://github.com/fastfetch-cli/fastfetch.git
synced 2026-10-27 23:30:47 +01:00
Carter Li
864 lines
29 KiB
C
864 lines
29 KiB
C
#include "logo/logo.h"
|
|
#include "common/io.h"
|
|
#include "common/printing.h"
|
|
#include "common/processing.h"
|
|
#include "common/textModifier.h"
|
|
#include "common/strutil.h"
|
|
#include "detection/media/media.h"
|
|
#include "detection/os/os.h"
|
|
#include "detection/terminalshell/terminalshell.h"
|
|
#include "detection/terminalsize/terminalsize.h"
|
|
|
|
#include <ctype.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
typedef struct FFLogoCachedLine {
|
|
FFstrbuf chars;
|
|
uint32_t width;
|
|
} FFLogoCachedLine;
|
|
|
|
FFLogoPosition ffLogoSelectPosition(FFLogoPosition configured, uint32_t terminalColumns, uint32_t logoWidth) {
|
|
if (configured != FF_LOGO_POSITION_AUTO) {
|
|
return configured;
|
|
}
|
|
|
|
if (terminalColumns == 0) {
|
|
return FF_LOGO_POSITION_LEFT;
|
|
}
|
|
|
|
return logoWidth <= terminalColumns && terminalColumns - logoWidth >= FF_LOGO_AUTO_MIN_INFO_WIDTH
|
|
? FF_LOGO_POSITION_LEFT
|
|
: FF_LOGO_POSITION_TOP;
|
|
}
|
|
|
|
void ffLogoResolveAutoPosition(uint32_t logoWidth) {
|
|
FFOptionsLogo* options = &instance.config.logo;
|
|
if (options->position != FF_LOGO_POSITION_AUTO) {
|
|
return;
|
|
}
|
|
|
|
uint32_t terminalColumns = 0;
|
|
if (ffIsTerminal(STDOUT_FILENO)) {
|
|
FFTerminalSizeResult size = {};
|
|
if (ffDetectTerminalSize(&size, true)) {
|
|
terminalColumns = size.columns;
|
|
}
|
|
}
|
|
|
|
options->position = ffLogoSelectPosition(FF_LOGO_POSITION_AUTO, terminalColumns, logoWidth);
|
|
}
|
|
|
|
static void logoLineCacheClear(FFLogoLineCacheState* cache) {
|
|
FF_LIST_FOR_EACH (FFLogoCachedLine, line, cache->lines) {
|
|
ffStrbufDestroy(&line->chars);
|
|
}
|
|
ffListDestroy(&cache->lines);
|
|
cache->nextLine = 0;
|
|
cache->rightOffset = 0;
|
|
}
|
|
|
|
static void logoLineCachePush(const FFstrbuf* chars, uint32_t width, FFLogoLineCacheState* cache) {
|
|
FFLogoCachedLine* line = FF_LIST_ADD(FFLogoCachedLine, cache->lines);
|
|
if (width > 0) {
|
|
ffStrbufInitCopy(&line->chars, chars);
|
|
if (!instance.config.display.pipe) {
|
|
ffStrbufAppendS(&line->chars, FASTFETCH_TEXT_MODIFIER_RESET);
|
|
}
|
|
} else {
|
|
ffStrbufInit(&line->chars);
|
|
}
|
|
line->width = width;
|
|
}
|
|
|
|
static void logoLineCacheBuild(FFLogoLineCacheState* cache, const char* data, bool doColorReplacement) {
|
|
FFOptionsLogo* options = &instance.config.logo;
|
|
bool keepCarryColor = options->type != FF_LOGO_TYPE_IMAGE_CHAFA;
|
|
|
|
logoLineCacheClear(cache);
|
|
|
|
// Overrides the auto detected max-width with the configured width, if set.
|
|
// In case we fail to get the actual width of the logo, as we don't use `wcwidth`
|
|
uint32_t maxLineWidth = options->width;
|
|
uint32_t parsedHeight = 0;
|
|
|
|
FF_STRBUF_AUTO_DESTROY carryColor = ffStrbufCreate();
|
|
if (keepCarryColor && doColorReplacement && !instance.config.display.pipe) {
|
|
ffStrbufSetF(&carryColor, "\e[%sm", options->colors[0].chars);
|
|
}
|
|
|
|
for (uint32_t i = 0; i < options->paddingTop; ++i) {
|
|
logoLineCachePush(nullptr, 0, cache);
|
|
}
|
|
|
|
if (*data != '\0') {
|
|
while (true) {
|
|
FF_STRBUF_AUTO_DESTROY line = ffStrbufCreateA(256);
|
|
uint32_t lineWidth = 0;
|
|
|
|
if (!instance.config.display.pipe && instance.config.display.brightColor) {
|
|
ffStrbufAppendS(&line, FASTFETCH_TEXT_MODIFIER_BOLT);
|
|
}
|
|
|
|
if (keepCarryColor && carryColor.length > 0) {
|
|
ffStrbufAppend(&line, &carryColor);
|
|
}
|
|
|
|
if ((options->position != FF_LOGO_POSITION_RIGHT) && options->paddingLeft > 0) {
|
|
ffStrbufAppendNC(&line, options->paddingLeft, ' ');
|
|
lineWidth += options->paddingLeft;
|
|
}
|
|
|
|
while (*data != '\0' && *data != '\n' && !(*data == '\r' && *(data + 1) == '\n')) {
|
|
if (*data == '\t') {
|
|
ffStrbufAppendNC(&line, 4, ' ');
|
|
lineWidth += 4;
|
|
++data;
|
|
continue;
|
|
}
|
|
|
|
if (*data == '\e' && *(data + 1) == '[') {
|
|
const char* start = data;
|
|
data += 2;
|
|
|
|
while (ffCharIsDigit(*data) || *data == ';') {
|
|
++data;
|
|
}
|
|
|
|
if (isascii(*data)) {
|
|
++data;
|
|
|
|
uint32_t escLen = (uint32_t) (data - start);
|
|
ffStrbufAppendNS(&line, escLen, start);
|
|
|
|
if (keepCarryColor && start[escLen - 1] == 'm') {
|
|
ffStrbufSetNS(&carryColor, escLen, start);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
lineWidth += (uint32_t) (data - start - 1);
|
|
}
|
|
|
|
if (doColorReplacement && *data == '$') {
|
|
++data;
|
|
|
|
if (*data == '$' || *data == '\0') {
|
|
ffStrbufAppendC(&line, '$');
|
|
++lineWidth;
|
|
++data;
|
|
continue;
|
|
}
|
|
|
|
if (!instance.config.display.pipe) {
|
|
int index = *data - '1';
|
|
if (index >= 0 && index < FASTFETCH_LOGO_MAX_COLORS) {
|
|
if (keepCarryColor) {
|
|
ffStrbufSetF(&carryColor, "\e[%sm", options->colors[index].chars);
|
|
ffStrbufAppend(&line, &carryColor);
|
|
} else {
|
|
ffStrbufAppendF(&line, "\e[%sm", options->colors[index].chars);
|
|
}
|
|
++data;
|
|
continue;
|
|
}
|
|
|
|
ffStrbufAppendC(&line, '$');
|
|
++lineWidth;
|
|
} else {
|
|
++data;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
uint8_t charWidth;
|
|
uint8_t bytes = ffUtf8CharLenWidth(data, UINT32_MAX, &charWidth);
|
|
lineWidth += charWidth;
|
|
|
|
for (uint8_t i = 0; i < bytes; ++i) {
|
|
if (*data == '\0') {
|
|
break;
|
|
}
|
|
|
|
ffStrbufAppendC(&line, *data);
|
|
++data;
|
|
}
|
|
}
|
|
|
|
logoLineCachePush(&line, lineWidth, cache);
|
|
if (lineWidth > maxLineWidth) {
|
|
maxLineWidth = lineWidth;
|
|
}
|
|
|
|
if (*data == '\n' || (*data == '\r' && *(data + 1) == '\n')) {
|
|
if (*data == '\r') {
|
|
++data;
|
|
}
|
|
++data;
|
|
++parsedHeight;
|
|
continue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (options->type != FF_LOGO_TYPE_IMAGE_CHAFA && options->height > parsedHeight) {
|
|
parsedHeight = options->height;
|
|
}
|
|
|
|
ffLogoResolveAutoPosition(maxLineWidth + options->paddingRight);
|
|
|
|
instance.state.logoHeight = options->paddingTop + parsedHeight;
|
|
if (options->position == FF_LOGO_POSITION_LEFT) {
|
|
instance.state.logoWidth = maxLineWidth + options->paddingRight;
|
|
} else {
|
|
instance.state.logoWidth = 0;
|
|
}
|
|
|
|
uint32_t totalLines = instance.state.logoHeight + 1;
|
|
while (cache->lines.length < totalLines) {
|
|
logoLineCachePush(nullptr, 0, cache);
|
|
}
|
|
|
|
cache->nextLine = 0;
|
|
cache->rightOffset = maxLineWidth + options->paddingRight - 1;
|
|
}
|
|
|
|
static bool ffLogoPrintCharsRaw(const char* data, size_t length, bool printError) {
|
|
FFOptionsLogo* options = &instance.config.logo;
|
|
FF_STRBUF_AUTO_DESTROY buf = ffStrbufCreate();
|
|
|
|
ffLogoResolveAutoPosition(options->width + options->paddingLeft + options->paddingRight);
|
|
|
|
if (!options->width || !options->height) {
|
|
if (options->position == FF_LOGO_POSITION_LEFT) {
|
|
ffStrbufAppendF(&buf, "\e[2J\e[3J\e[%u;%uH", (unsigned) options->paddingTop + 1, (unsigned) options->paddingLeft + 1);
|
|
} else if (options->position == FF_LOGO_POSITION_TOP) {
|
|
ffStrbufAppendNC(&buf, options->paddingTop, '\n');
|
|
ffStrbufAppendNC(&buf, options->paddingLeft, ' ');
|
|
} else if (options->position == FF_LOGO_POSITION_RIGHT) {
|
|
if (!options->width) {
|
|
if (printError) {
|
|
fputs("Logo (image-raw): Must set logo width when using position right\n", stderr);
|
|
}
|
|
return false;
|
|
}
|
|
ffStrbufAppendF(&buf, "\e[2J\e[3J\e[%u;9999999H\e[%uD", (unsigned) options->paddingTop + 1, (unsigned) options->paddingRight + options->width);
|
|
}
|
|
ffStrbufAppendNS(&buf, (uint32_t) length, data);
|
|
ffWriteFDBuffer(FFUnixFD2NativeFD(STDOUT_FILENO), &buf);
|
|
|
|
if (options->position == FF_LOGO_POSITION_LEFT || options->position == FF_LOGO_POSITION_RIGHT) {
|
|
uint16_t X = 0, Y = 0;
|
|
// Windows Terminal doesn't report `\e` for some reason
|
|
const char* error = ffGetTerminalResponse("\e[6n", 2, "%*[^0-9]%hu;%huR", &Y, &X); // %*[^0-9]: ignore optional \e[
|
|
if (error) {
|
|
if (printError) {
|
|
fprintf(stderr, "\nLogo (image-raw): fail to query cursor position: %s\n", error);
|
|
}
|
|
return true;
|
|
}
|
|
if (options->position == FF_LOGO_POSITION_LEFT) {
|
|
if (options->width + options->paddingLeft > X) {
|
|
X = (uint16_t) (options->width + options->paddingLeft);
|
|
}
|
|
instance.state.logoWidth = X + instance.config.logo.paddingRight - 1;
|
|
}
|
|
instance.state.logoHeight = Y;
|
|
fputs("\e[H", stdout);
|
|
} else if (options->position == FF_LOGO_POSITION_TOP) {
|
|
instance.state.logoWidth = instance.state.logoHeight = 0;
|
|
ffPrintCharTimes('\n', options->paddingRight);
|
|
}
|
|
} else {
|
|
ffStrbufAppendNC(&buf, options->paddingTop, '\n');
|
|
|
|
if (options->position == FF_LOGO_POSITION_RIGHT) {
|
|
ffStrbufAppendF(&buf, "\e[9999999C\e[%uD", (unsigned) options->paddingRight + options->width);
|
|
} else if (options->paddingLeft) {
|
|
ffStrbufAppendF(&buf, "\e[%uC", (unsigned) options->paddingLeft);
|
|
}
|
|
|
|
ffStrbufAppendNS(&buf, (uint32_t) length, data);
|
|
ffStrbufAppendC(&buf, '\n');
|
|
|
|
if (options->position == FF_LOGO_POSITION_LEFT) {
|
|
instance.state.logoWidth = options->width + options->paddingLeft + options->paddingRight;
|
|
instance.state.logoHeight = options->paddingTop + options->height;
|
|
ffStrbufAppendF(&buf, "\e[%uA", (unsigned) instance.state.logoHeight);
|
|
} else if (options->position == FF_LOGO_POSITION_TOP) {
|
|
instance.state.logoWidth = instance.state.logoHeight = 0;
|
|
ffStrbufAppendNC(&buf, options->paddingRight, '\n');
|
|
} else if (options->position == FF_LOGO_POSITION_RIGHT) {
|
|
instance.state.logoWidth = instance.state.logoHeight = 0;
|
|
ffStrbufAppendF(&buf, "\e[%uA", (unsigned) options->height);
|
|
}
|
|
ffWriteFDBuffer(FFUnixFD2NativeFD(STDOUT_FILENO), &buf);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void ffLogoPrintChars(const char* data, bool doColorReplacement) {
|
|
FFOptionsLogo* options = &instance.config.logo;
|
|
FFLogoLineCacheState* cache = &instance.state.logoLineCache;
|
|
|
|
logoLineCacheBuild(cache, data, doColorReplacement);
|
|
|
|
if (options->position != FF_LOGO_POSITION_TOP) {
|
|
return;
|
|
}
|
|
|
|
FF_STRBUF_AUTO_DESTROY result = ffStrbufCreateA(4096);
|
|
FF_LIST_FOR_EACH (FFLogoCachedLine, line, cache->lines) {
|
|
ffStrbufAppend(&result, &line->chars);
|
|
ffStrbufAppendC(&result, '\n');
|
|
}
|
|
ffStrbufAppendNC(&result, options->paddingBottom, '\n');
|
|
ffWriteFDBuffer(FFUnixFD2NativeFD(STDOUT_FILENO), &result);
|
|
instance.state.logoWidth = instance.state.logoHeight = 0;
|
|
logoLineCacheClear(cache);
|
|
}
|
|
|
|
static void logoApplyColors(const FFlogo* logo, bool replacement) {
|
|
if (instance.config.display.colorTitle.length == 0) {
|
|
ffStrbufSetStatic(&instance.config.display.colorTitle, logo->colorTitle ?: logo->colors[0]);
|
|
}
|
|
|
|
if (instance.config.display.colorKeys.length == 0) {
|
|
ffStrbufSetStatic(&instance.config.display.colorKeys, logo->colorKeys ?: logo->colors[1]);
|
|
}
|
|
|
|
if (replacement) {
|
|
FFOptionsLogo* options = &instance.config.logo;
|
|
|
|
const char* const* colors = logo->colors;
|
|
for (int i = 0; *colors != nullptr && i < FASTFETCH_LOGO_MAX_COLORS; i++, colors++) {
|
|
if (options->colors[i].length == 0) {
|
|
ffStrbufSetStatic(&options->colors[i], *colors);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool logoHasName(const FFlogo* logo, const FFstrbuf* name, bool small) {
|
|
for (
|
|
const char* const* logoName = logo->names;
|
|
*logoName != nullptr && logoName <= &logo->names[FASTFETCH_LOGO_MAX_NAMES];
|
|
++logoName) {
|
|
if (small) {
|
|
uint32_t logoNameLength = (uint32_t) (strlen(*logoName) - strlen("_small"));
|
|
if (name->length == logoNameLength && strncasecmp(*logoName, name->chars, logoNameLength) == 0) {
|
|
return true;
|
|
}
|
|
}
|
|
if (ffStrbufIgnCaseEqualS(name, *logoName)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static const FFlogo* logoGetBuiltin(const FFstrbuf* name, FFLogoSize size) {
|
|
if (name->length == 0 || !isalpha(name->chars[0])) {
|
|
return nullptr;
|
|
}
|
|
|
|
for (const FFlogo* logo = ffLogoBuiltins[toupper(name->chars[0]) - 'A']; *logo->names; ++logo) {
|
|
switch (size) {
|
|
// Never use alternate logos
|
|
case FF_LOGO_SIZE_NORMAL:
|
|
if (logo->type != FF_LOGO_LINE_TYPE_NORMAL) {
|
|
continue;
|
|
}
|
|
break;
|
|
case FF_LOGO_SIZE_SMALL:
|
|
if (logo->type != FF_LOGO_LINE_TYPE_SMALL_BIT) {
|
|
continue;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (logoHasName(logo, name, size == FF_LOGO_SIZE_SMALL)) {
|
|
return logo;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
static const FFlogo* logoGetBuiltinDetected(FFLogoSize size) {
|
|
const FFOSResult* os = ffDetectOS();
|
|
|
|
const FFlogo* logo = logoGetBuiltin(&os->id, size);
|
|
if (logo != nullptr) {
|
|
return logo;
|
|
}
|
|
|
|
logo = logoGetBuiltin(&os->name, size);
|
|
if (logo != nullptr) {
|
|
return logo;
|
|
}
|
|
|
|
if (ffStrbufContainC(&os->idLike, ' ')) {
|
|
FF_STRBUF_AUTO_DESTROY buf = ffStrbufCreate();
|
|
for (
|
|
uint32_t start = 0, end = ffStrbufFirstIndexC(&os->idLike, ' ');
|
|
true;
|
|
start = end + 1, end = ffStrbufNextIndexC(&os->idLike, start, ' ')) {
|
|
ffStrbufSetNS(&buf, end - start, os->idLike.chars + start);
|
|
logo = logoGetBuiltin(&buf, size);
|
|
if (logo != nullptr) {
|
|
return logo;
|
|
}
|
|
|
|
if (end >= os->idLike.length) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
logo = logoGetBuiltin(&os->idLike, size);
|
|
if (logo != nullptr) {
|
|
return logo;
|
|
}
|
|
}
|
|
|
|
logo = logoGetBuiltin(&instance.state.platform.sysinfo.name, size);
|
|
if (logo != nullptr) {
|
|
return logo;
|
|
}
|
|
|
|
return &ffLogoUnknown;
|
|
}
|
|
|
|
static void logoPrintStruct(const FFlogo* logo) {
|
|
logoApplyColors(logo, true);
|
|
|
|
ffLogoPrintChars(logo->lines, true);
|
|
}
|
|
|
|
static void logoPrintNone(void) {
|
|
if (!instance.config.display.pipe) {
|
|
logoApplyColors(logoGetBuiltinDetected(FF_LOGO_SIZE_NORMAL), false);
|
|
}
|
|
instance.state.logoHeight = 0;
|
|
instance.state.logoWidth = 0;
|
|
}
|
|
|
|
static bool logoPrintBuiltinIfExists(const FFstrbuf* name, FFLogoSize size) {
|
|
if (name->chars[0] == '~' || name->chars[0] == '.' || name->chars[0] == '/'
|
|
#if _WIN32
|
|
|| (ffCharIsEnglishAlphabet(name->chars[0]) && name->chars[1] == ':') // Windows drive letter
|
|
#endif
|
|
)
|
|
return false; // Paths
|
|
|
|
if (ffStrbufIgnCaseEqualS(name, "none")) {
|
|
logoPrintNone();
|
|
return true;
|
|
}
|
|
|
|
const FFlogo* logo = ffLogoGetBuiltinForName(name, size);
|
|
if (logo == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
logoPrintStruct(logo);
|
|
|
|
return true;
|
|
}
|
|
|
|
void ffLogoPrintDetected(FFLogoSize size) {
|
|
logoPrintStruct(logoGetBuiltinDetected(size));
|
|
}
|
|
|
|
static bool logoPrintData(bool doColorReplacement, FFstrbuf* source) {
|
|
if (source->length == 0) {
|
|
return false;
|
|
}
|
|
|
|
logoApplyColors(logoGetBuiltinDetected(FF_LOGO_SIZE_NORMAL), doColorReplacement);
|
|
ffLogoPrintChars(source->chars, doColorReplacement);
|
|
return true;
|
|
}
|
|
|
|
static bool updateLogoPath(void) {
|
|
FFOptionsLogo* options = &instance.config.logo;
|
|
|
|
if (ffPathExists(options->source.chars, FF_PATHTYPE_FILE)) {
|
|
return true;
|
|
}
|
|
|
|
if (ffStrbufEqualS(&options->source, "-")) { // stdin
|
|
return true;
|
|
}
|
|
|
|
#if !FF_MODULE_DISABLE_MEDIA
|
|
if (ffStrbufIgnCaseEqualS(&options->source, "media-cover")) {
|
|
const FFMediaResult* media = ffDetectMedia(true);
|
|
if (media->cover.length == 0) {
|
|
return false;
|
|
}
|
|
ffStrbufSet(&options->source, &media->cover);
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
FF_STRBUF_AUTO_DESTROY fullPath = ffStrbufCreateA(128);
|
|
if (ffPathExpandEnv(options->source.chars, &fullPath) && ffPathExists(fullPath.chars, FF_PATHTYPE_FILE)) {
|
|
ffStrbufDestroy(&options->source);
|
|
ffStrbufInitMove(&options->source, &fullPath);
|
|
return true;
|
|
}
|
|
|
|
FF_LIST_FOR_EACH (FFstrbuf, dataDir, instance.state.platform.dataDirs) {
|
|
// We need to copy it, because multiple threads might be using dataDirs at the same time
|
|
ffStrbufSet(&fullPath, dataDir);
|
|
ffStrbufAppendS(&fullPath, "fastfetch/logos/");
|
|
ffStrbufAppend(&fullPath, &options->source);
|
|
|
|
if (ffPathExists(fullPath.chars, FF_PATHTYPE_FILE)) {
|
|
ffStrbufDestroy(&options->source);
|
|
ffStrbufInitMove(&options->source, &fullPath);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static bool logoPrintFileIfExists(bool doColorReplacement, bool raw) {
|
|
FFOptionsLogo* options = &instance.config.logo;
|
|
|
|
FF_STRBUF_AUTO_DESTROY content = ffStrbufCreate();
|
|
|
|
if (ffStrbufEqualS(&options->source, "-")
|
|
? !ffAppendFDBuffer(FFUnixFD2NativeFD(STDIN_FILENO), &content)
|
|
: !ffAppendFileBuffer(options->source.chars, &content)) {
|
|
if (instance.config.display.showErrors) {
|
|
fprintf(stderr, "Logo: Failed to load file content from logo source: %s\n", options->source.chars);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
logoApplyColors(logoGetBuiltinDetected(FF_LOGO_SIZE_NORMAL), doColorReplacement);
|
|
if (raw) {
|
|
return ffLogoPrintCharsRaw(content.chars, content.length, instance.config.display.showErrors);
|
|
}
|
|
|
|
ffLogoPrintChars(content.chars, doColorReplacement);
|
|
return true;
|
|
}
|
|
|
|
#if FF_HAVE_IMAGE_LOGO
|
|
static bool logoPrintImageIfExists(FFLogoType logo, bool printError) {
|
|
if (!ffLogoPrintImageIfExists(logo, printError)) {
|
|
return false;
|
|
}
|
|
|
|
logoApplyColors(logoGetBuiltinDetected(FF_LOGO_SIZE_NORMAL), false);
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
static bool logoTryKnownType(void) {
|
|
FFOptionsLogo* options = &instance.config.logo;
|
|
|
|
if (options->type == FF_LOGO_TYPE_NONE) {
|
|
logoPrintNone();
|
|
return true;
|
|
}
|
|
|
|
if (options->type == FF_LOGO_TYPE_BUILTIN) {
|
|
return logoPrintBuiltinIfExists(&options->source, FF_LOGO_SIZE_UNKNOWN);
|
|
}
|
|
|
|
if (options->type == FF_LOGO_TYPE_SMALL) {
|
|
return logoPrintBuiltinIfExists(&options->source, FF_LOGO_SIZE_SMALL);
|
|
}
|
|
|
|
if (options->type == FF_LOGO_TYPE_DATA) {
|
|
return logoPrintData(true, &options->source);
|
|
}
|
|
|
|
if (options->type == FF_LOGO_TYPE_DATA_RAW) {
|
|
return logoPrintData(false, &options->source);
|
|
}
|
|
|
|
if (options->type == FF_LOGO_TYPE_COMMAND_RAW) {
|
|
FF_STRBUF_AUTO_DESTROY source = ffStrbufCreate();
|
|
|
|
const char* error = ffProcessAppendStdOut(&source, (char* const[]){
|
|
#ifdef _WIN32
|
|
"cmd.exe", "/c",
|
|
#else
|
|
"/bin/sh", "-c",
|
|
#endif
|
|
options->source.chars,
|
|
nullptr });
|
|
|
|
if (error) {
|
|
if (instance.config.display.showErrors) {
|
|
fprintf(stderr, "Logo: failed to execute command `%s`: %s\n", options->source.chars, error);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return logoPrintData(false, &source);
|
|
}
|
|
|
|
// We sure have a file, resolve relative paths
|
|
if (!updateLogoPath()) {
|
|
if (instance.config.display.showErrors) {
|
|
fprintf(stderr, "Logo: Failed to resolve logo source: %s\n", options->source.chars);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if (options->type == FF_LOGO_TYPE_FILE) {
|
|
return logoPrintFileIfExists(true, false);
|
|
}
|
|
|
|
if (options->type == FF_LOGO_TYPE_FILE_RAW) {
|
|
return logoPrintFileIfExists(false, false);
|
|
}
|
|
|
|
if (options->type == FF_LOGO_TYPE_IMAGE_RAW) {
|
|
return logoPrintFileIfExists(false, true);
|
|
}
|
|
|
|
#if FF_HAVE_IMAGE_LOGO
|
|
return logoPrintImageIfExists(options->type, instance.config.display.showErrors);
|
|
#else
|
|
// No image logo type can be selected in this build (see ffOptionsParseLogoCommandLine), and
|
|
// FF_LOGO_TYPE_IMAGE_RAW was handled above, so nothing printable is left for this source.
|
|
if (instance.config.display.showErrors) {
|
|
fprintf(stderr, "Logo: Unsupported logo type for source: %s\n", options->source.chars);
|
|
}
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
void ffLogoPrint(void) {
|
|
const FFOptionsLogo* options = &instance.config.logo;
|
|
|
|
if (options->type == FF_LOGO_TYPE_NONE) {
|
|
logoPrintNone();
|
|
return;
|
|
}
|
|
|
|
// If the source is not set, we can directly print the detected logo.
|
|
if (options->source.length == 0) {
|
|
ffLogoPrintDetected(options->type == FF_LOGO_TYPE_SMALL ? FF_LOGO_SIZE_SMALL : FF_LOGO_SIZE_NORMAL);
|
|
return;
|
|
}
|
|
|
|
// If the source and source type is set to something else than auto, always print with the set type.
|
|
if (options->source.length > 0 && options->type != FF_LOGO_TYPE_AUTO) {
|
|
if (!logoTryKnownType()) {
|
|
if (instance.config.display.showErrors) {
|
|
// Image logo should have been handled
|
|
if (options->type == FF_LOGO_TYPE_BUILTIN || options->type == FF_LOGO_TYPE_SMALL) {
|
|
fprintf(stderr, "Logo: Failed to load %s logo: %s\n", options->type == FF_LOGO_TYPE_BUILTIN ? "builtin" : "builtin small", options->source.chars);
|
|
}
|
|
}
|
|
|
|
ffLogoPrintDetected(FF_LOGO_SIZE_UNKNOWN);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// If source matches the name of a builtin logo, print it and return.
|
|
if (logoPrintBuiltinIfExists(&options->source, FF_LOGO_SIZE_UNKNOWN)) {
|
|
return;
|
|
}
|
|
|
|
// Make sure the logo path is set correctly.
|
|
if (updateLogoPath()) {
|
|
if (ffStrbufEndsWithIgnCaseS(&options->source, ".raw")) {
|
|
if (logoPrintFileIfExists(false, true)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
#if FF_HAVE_IMAGE_LOGO
|
|
// Try to load the logo as an image.
|
|
if (!ffStrbufEndsWithIgnCaseS(&options->source, ".txt")) {
|
|
#if !FF_MODULE_DISABLE_TERMINAL
|
|
const FFTerminalResult* terminal = ffDetectTerminal();
|
|
|
|
bool supportsIterm2 = ffStrbufEqualS(&terminal->prettyName, "iTerm");
|
|
|
|
if (supportsIterm2 && logoPrintImageIfExists(FF_LOGO_TYPE_IMAGE_ITERM, false)) {
|
|
return;
|
|
}
|
|
|
|
// Terminal emulators that support kitty graphics protocol.
|
|
bool supportsKitty =
|
|
ffStrbufIgnCaseEqualS(&terminal->processName, "kitty") ||
|
|
ffStrbufIgnCaseEqualS(&terminal->processName, "konsole") ||
|
|
ffStrbufIgnCaseEqualS(&terminal->processName, "wezterm") ||
|
|
ffStrbufIgnCaseEqualS(&terminal->processName, "wayst") ||
|
|
ffStrbufIgnCaseEqualS(&terminal->processName, "ghostty") ||
|
|
#ifdef __APPLE__
|
|
ffStrbufIgnCaseEqualS(&terminal->processName, "WarpTerminal") ||
|
|
#else
|
|
ffStrbufIgnCaseEqualS(&terminal->processName, "warp") ||
|
|
#endif
|
|
false;
|
|
#else
|
|
bool supportsKitty = false;
|
|
#endif
|
|
|
|
// Try to load the logo as an image. If it succeeds, print it and return.
|
|
if (logoPrintImageIfExists(supportsKitty ? FF_LOGO_TYPE_IMAGE_KITTY : FF_LOGO_TYPE_IMAGE_CHAFA, false)) {
|
|
return;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Try to load the logo as a file. If it succeeds, print it and return.
|
|
if (logoPrintFileIfExists(true, false)) {
|
|
return;
|
|
}
|
|
} else {
|
|
if (instance.config.display.showErrors) {
|
|
fprintf(stderr, "Logo: Failed to resolve logo source: %s\n", options->source.chars);
|
|
}
|
|
}
|
|
|
|
ffLogoPrintDetected(FF_LOGO_SIZE_UNKNOWN);
|
|
}
|
|
|
|
void ffLogoPrintLine(void) {
|
|
FFLogoLineCacheState* cache = &instance.state.logoLineCache;
|
|
FFOptionsLogo* logo = &instance.config.logo;
|
|
|
|
if (cache->lines.length > 0) {
|
|
// Line cache is enabled. Always move cursor with whitespaces to make lolcat happy
|
|
if (cache->nextLine < cache->lines.length) {
|
|
// Print logo line and move cursor
|
|
FFLogoCachedLine* line = FF_LIST_GET(FFLogoCachedLine, cache->lines, cache->nextLine);
|
|
|
|
if (logo->position == FF_LOGO_POSITION_RIGHT) {
|
|
printf("\033[9999999C\033[%uD", cache->rightOffset);
|
|
ffStrbufWriteTo(&line->chars, stdout);
|
|
|
|
fputs("\033[G", stdout);
|
|
} else {
|
|
ffStrbufWriteTo(&line->chars, stdout);
|
|
|
|
uint32_t remaining = instance.state.logoWidth;
|
|
remaining = line->width < remaining ? remaining - line->width : 0;
|
|
ffPrintCharTimes(' ', remaining);
|
|
}
|
|
++cache->nextLine;
|
|
} else if (logo->position == FF_LOGO_POSITION_LEFT) {
|
|
// Move cursor to the start position
|
|
ffPrintCharTimes(' ', instance.state.logoWidth);
|
|
}
|
|
} else if (instance.state.logoWidth > 0) {
|
|
printf("\033[%uC", instance.state.logoWidth);
|
|
}
|
|
|
|
if (instance.state.dynamicInterval > 0 && logo->position == FF_LOGO_POSITION_LEFT) {
|
|
fputs("\033[K", stdout); // Clear to the end of the line
|
|
// Note that we don't clear the line when the logo is on the right, as it will also clear the logo itself
|
|
}
|
|
|
|
++instance.state.keysHeight;
|
|
}
|
|
|
|
void ffLogoPrintRemaining(void) {
|
|
FFLogoLineCacheState* cache = &instance.state.logoLineCache;
|
|
FFOptionsLogo* logo = &instance.config.logo;
|
|
|
|
if (cache->lines.length > 0 && (logo->position == FF_LOGO_POSITION_LEFT || logo->position == FF_LOGO_POSITION_RIGHT)) {
|
|
while (cache->nextLine < cache->lines.length) {
|
|
FFLogoCachedLine* line = FF_LIST_GET(FFLogoCachedLine, cache->lines, cache->nextLine);
|
|
|
|
if (logo->position == FF_LOGO_POSITION_RIGHT) {
|
|
printf("\033[9999999C\033[%uD", cache->rightOffset);
|
|
}
|
|
ffStrbufPutTo(&line->chars, stdout);
|
|
|
|
++cache->nextLine;
|
|
}
|
|
|
|
if (!instance.config.display.pipe) {
|
|
fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
|
|
}
|
|
|
|
instance.state.keysHeight = instance.state.logoHeight + 1;
|
|
logoLineCacheClear(cache);
|
|
return;
|
|
}
|
|
|
|
if (instance.state.keysHeight <= instance.state.logoHeight) {
|
|
ffPrintCharTimes('\n', instance.state.logoHeight - instance.state.keysHeight + 1);
|
|
}
|
|
instance.state.keysHeight = instance.state.logoHeight + 1;
|
|
}
|
|
|
|
void ffLogoBuiltinPrint(void) {
|
|
FFOptionsLogo* options = &instance.config.logo;
|
|
options->position = FF_LOGO_POSITION_TOP;
|
|
options->paddingRight = 2; // empty line after logo printing
|
|
FF_STRBUF_AUTO_DESTROY buf = ffStrbufCreate();
|
|
|
|
for (uint8_t ch = 0; ch < 26; ++ch) {
|
|
for (const FFlogo* logo = ffLogoBuiltins[ch]; *logo->names; ++logo) {
|
|
if (instance.config.display.pipe) {
|
|
ffStrbufSetF(&buf, "%s:\n", logo->names[0]);
|
|
} else {
|
|
ffStrbufSetF(&buf, "\e[%sm%s:\e[0m\n", logo->colors[0], logo->names[0]);
|
|
}
|
|
ffWriteFDBuffer(FFUnixFD2NativeFD(STDOUT_FILENO), &buf);
|
|
logoPrintStruct(logo);
|
|
|
|
for (uint8_t i = 0; i < FASTFETCH_LOGO_MAX_COLORS; i++) {
|
|
ffStrbufClear(&options->colors[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ffLogoBuiltinList(void) {
|
|
uint32_t counter = 0;
|
|
for (uint8_t ch = 0; ch < 26; ++ch) {
|
|
for (const FFlogo* logo = ffLogoBuiltins[ch]; *logo->names; ++logo) {
|
|
++counter;
|
|
printf("%u)%s ", counter, counter < 10 ? " " : "");
|
|
|
|
for (
|
|
const char* const* names = logo->names;
|
|
*names != nullptr && names <= &logo->names[FASTFETCH_LOGO_MAX_NAMES];
|
|
++names) {
|
|
printf("\"%s\" ", *names);
|
|
}
|
|
|
|
putchar('\n');
|
|
}
|
|
}
|
|
}
|
|
|
|
void ffLogoBuiltinListAutocompletion(void) {
|
|
for (uint8_t ch = 0; ch < 26; ++ch) {
|
|
for (const FFlogo* logo = ffLogoBuiltins[ch]; *logo->names; ++logo) {
|
|
printf("%s\n", logo->names[0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
const FFlogo* ffLogoGetBuiltinForName(const FFstrbuf* name, FFLogoSize size) {
|
|
return ffStrbufEqualS(name, "?") ? &ffLogoUnknown : logoGetBuiltin(name, size);
|
|
}
|
|
|
|
const FFlogo* ffLogoGetBuiltinDetected(FFLogoSize size) {
|
|
return logoGetBuiltinDetected(size);
|
|
}
|