Refactored logo choosing logic

src/common/init.c

@@ -286,13 +286,13 @@ void ffStart(FFinstance* instance)
     if(ffDisableLinewrap)
         fputs("\033[?7l", stdout);
 
-    ffPrintLogo(instance);
+    ffLogoPrint(instance);
 }
 
 void ffFinish(FFinstance* instance)
 {
     if(instance->config.logoPrintRemaining)
-        ffPrintRemainingLogo(instance);
+        ffLogoPrintRemaining(instance);
 
     resetConsole();
 }

src/common/printing.c

@@ -2,16 +2,12 @@
 
 void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat)
 {
-    ffPrintLogoLine(instance);
+    ffLogoPrintLine(instance);
 
     if(!instance->config.pipe)
     {
         fputs(FASTFETCH_TEXT_MODIFIER_RESET FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
-
-        //If the main color is not set (e.g. none logo), this would reset in \033[m, which resets everything,
-        //including the wanted bolt from above. So we only print it, if the main color is at least one char.
-        if(instance->config.mainColor.length > 0)
-            ffPrintColor(&instance->config.mainColor);
+        ffPrintColor(&instance->config.mainColor);
     }
 
     if(customKeyFormat == NULL || customKeyFormat->length == 0)
@@ -91,6 +87,11 @@ void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t m
 
 void ffPrintColor(const FFstrbuf* colorValue)
 {
+    //If the color is not set, this would reset in \033[m, which resets everything.
+    //So we only print it, if the main color is at least one char.
+    if(colorValue->length == 0)
+        return;
+
     fputs("\033[", stdout);
     ffStrbufWriteTo(colorValue, stdout);
     fputc('m', stdout);

src/fastfetch.c

@@ -700,17 +700,17 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
     }
     else if(strcasecmp(key, "--list-logos") == 0)
     {
-        ffListBuiltinLogos();
+        ffLogoBuiltinList();
         exit(0);
     }
     else if(strcasecmp(key, "--list-logos-autocompletion") == 0)
     {
-        ffListBuiltinLogosAutocompletion();
+        ffLogoBuiltinListAutocompletion();
         exit(0);
     }
     else if(strcasecmp(key, "--print-logos") == 0)
     {
-        ffPrintBuiltinLogos(instance);
+        ffLogoBuiltinPrint(instance);
         exit(0);
     }
 

src/fastfetch.h

@@ -61,7 +61,7 @@ typedef struct FFconfig
     uint32_t logoPaddingRight;
     bool logoPrintRemaining;
 
-    FFstrbuf mainColor; //If this is empty, ffPrintLogo will set it to the main color of the logo
+    FFstrbuf mainColor; //If this is empty, ffLogoPrint will set it to the main color of the logo
     FFstrbuf separator;
 
     bool showErrors;
@@ -525,14 +525,13 @@ bool ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result);
 // Logo functions //
 ////////////////////
 
-void ffPrintLogo(FFinstance* instance);
-void ffPrintRemainingLogo(FFinstance* instance);
+void ffLogoPrint(FFinstance* instance);
+void ffLogoPrintRemaining(FFinstance* instance);
+void ffLogoPrintLine(FFinstance* instance);
 
-void ffPrintLogoLine(FFinstance* instance);
-
-void ffPrintBuiltinLogos(FFinstance* instance);
-void ffListBuiltinLogos();
-void ffListBuiltinLogosAutocompletion();
+void ffLogoBuiltinPrint(FFinstance* instance);
+void ffLogoBuiltinList();
+void ffLogoBuiltinListAutocompletion();
 
 /////////////////////////
 // Detection functions //

src/logo/builtin.c

@@ -1,24 +1,12 @@
 #include "logo.h"
 
-#include <limits.h>
-#include <string.h>
-#include <unistd.h>
-#include <ctype.h>
-
-typedef struct FFlogo
-{
-    const char* data;
-    const char** names; //Null terminated
-    const char** builtinColors; //Null terminated
-} FFlogo;
-
 #define FF_LOGO_INIT static FFlogo logo; static bool init = false; if(init) return &logo; init = true;
 #define FF_LOGO_NAMES(...) static const char* names[] = (const char*[]) { __VA_ARGS__, NULL }; logo.names = names;
 #define FF_LOGO_LINES(x) logo.data = x;
 #define FF_LOGO_COLORS(...) static const char* colors[] = (const char*[]) { __VA_ARGS__, NULL }; logo.builtinColors = colors;
 #define FF_LOGO_RETURN return &logo;
 
-static const FFlogo* getLogoUnknown()
+const FFlogo* ffLogoBuiltinGetUnknown()
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("unknown", "question mark", "?")
@@ -1441,13 +1429,11 @@ static const FFlogo* getLogoZorin()
     FF_LOGO_RETURN
 }
 
-typedef const FFlogo*(*GetLogoMethod)();
-
-static GetLogoMethod* getLogos()
+GetLogoMethod* ffLogoBuiltinGetAll()
 {
     static GetLogoMethod logoMethods[] = {
+        ffLogoBuiltinGetUnknown,
         getLogoNone,
-        getLogoUnknown,
         getLogoAndroid,
         getLogoAndroidSmall,
         getLogoArch,
@@ -1504,187 +1490,3 @@ static GetLogoMethod* getLogos()
 
     return logoMethods;
 }
-
-static bool logoHasName(const FFlogo* logo, const char* name)
-{
-    const char** logoName = logo->names;
-
-    while(*logoName != NULL)
-    {
-        if(strcasecmp(*logoName, name) == 0)
-            return true;
-        ++logoName;
-    }
-
-    return false;
-}
-
-static const FFlogo* getBuiltinLogo(const char* name)
-{
-    GetLogoMethod* methods = getLogos();
-
-    while(*methods != NULL)
-    {
-        const FFlogo* logo = (*methods)();
-        if(logoHasName(logo, name))
-            return logo;
-        ++methods;
-    }
-
-    return NULL;
-}
-
-static const FFlogo* detectBuiltinLogoWithVersion(const FFstrbuf* versionString, const FFstrbuf* name)
-{
-    if(versionString->length == 0)
-        return getBuiltinLogo(name->chars);
-
-    #define FF_PRINT_LOGO_VERSIONED_IF_EXISTS(newLogo, oldLogo, ver) \
-        if(logoHasName(newLogo, name->chars)) \
-        { \
-            long version = strtol(versionString->chars, NULL, 10); \
-            return (version == 0 || version == LONG_MAX || version == LONG_MIN || version >= ver) ? newLogo : oldLogo; \
-        }
-
-    FF_PRINT_LOGO_VERSIONED_IF_EXISTS(getLogoFedora(), getLogoFedoraOld(), 34)
-    FF_PRINT_LOGO_VERSIONED_IF_EXISTS(getLogoMint(), getLogoMintOld(), 19)
-
-    return getBuiltinLogo(name->chars);
-}
-
-static const FFlogo* detectBuiltinLogo(const FFinstance* instance)
-{
-    static const FFlogo* logo;
-    static bool detected = false;
-    if(detected)
-        return logo;
-
-    detected = true;
-
-    const FFOSResult* os = ffDetectOS(instance);
-
-    logo = detectBuiltinLogoWithVersion(&os->version, &os->name);
-    if(logo != NULL)
-        return logo;
-
-    logo = detectBuiltinLogoWithVersion(&os->version, &os->id);
-    if(logo != NULL)
-        return logo;
-
-    logo = detectBuiltinLogoWithVersion(&os->version, &os->idLike);
-    if(logo != NULL)
-        return logo;
-
-    logo = detectBuiltinLogoWithVersion(&os->version, &os->systemName);
-    if(logo != NULL)
-        return logo;
-
-    return getLogoUnknown();
-}
-
-void ffLogoSetMainColor(FFinstance* instance)
-{
-    const FFlogo* logo = NULL;
-
-    if(instance->config.logoSource.length > 0)
-       logo = getBuiltinLogo(instance->config.logoSource.chars);
-
-    if(logo == NULL)
-        logo = detectBuiltinLogo(instance);
-
-    ffStrbufAppendS(&instance->config.mainColor, logo->builtinColors[0]);
-}
-
-static void printLogoStruct(FFinstance* instance, const FFlogo* logo, bool doColorReplacement)
-{
-    if(!doColorReplacement)
-    {
-        ffLogoPrint(instance, logo->data, false);
-        return;
-    }
-
-    const char** colors = logo->builtinColors;
-    for(int i = 0; *colors != NULL && i < FASTFETCH_LOGO_MAX_COLORS; i++, colors++)
-    {
-        if(instance->config.logoColors[i].length == 0)
-            ffStrbufAppendS(&instance->config.logoColors[i], *colors);
-    }
-
-    ffLogoPrint(instance, logo->data, true);
-}
-
-void ffLogoPrintUnknown(FFinstance* instance)
-{
-    printLogoStruct(instance, getLogoUnknown(), false);
-}
-
-bool ffLogoPrintBuiltinIfExists(FFinstance* instance)
-{
-    const FFlogo* logo = getBuiltinLogo(instance->config.logoSource.chars);
-    if(logo == NULL)
-        return false;
-
-    printLogoStruct(instance, logo, true);
-    return true;
-}
-
-void ffLogoPrintBuiltinDetected(FFinstance* instance)
-{
-    printLogoStruct(instance, detectBuiltinLogo(instance), true);
-}
-
-void ffPrintBuiltinLogos(FFinstance* instance)
-{
-    GetLogoMethod* methods = getLogos();
-
-    while(*methods != NULL)
-    {
-        const FFlogo* logo = (*methods)();
-        printf("\033[%sm%s:\033[0m\n", logo->builtinColors[0], logo->names[0]);
-        printLogoStruct(instance, logo, true);
-        ffPrintRemainingLogo(instance);
-
-        instance->state.logoHeight = 0;
-        for(uint8_t i = 0; i < FASTFETCH_LOGO_MAX_COLORS; i++)
-            ffStrbufClear(&instance->config.logoColors[i]);
-
-        puts("\n");
-        ++methods;
-    }
-}
-
-void ffListBuiltinLogos()
-{
-    GetLogoMethod* methods = getLogos();
-
-    uint32_t counter = 0;
-
-    while(*methods != NULL)
-    {
-        const FFlogo* logo = (*methods)();
-        const char** names = logo->names;
-
-        printf("%u)%s ", counter, counter < 10 ? " " : "");
-        ++counter;
-
-        while(*names != NULL)
-        {
-            printf("\"%s\" ", *names);
-            ++names;
-        }
-
-        putchar('\n');
-        ++methods;
-    }
-}
-
-void ffListBuiltinLogosAutocompletion()
-{
-    GetLogoMethod* methods = getLogos();
-
-    while(*methods != NULL)
-    {
-        printf("%s\n", (*methods)()->names[0]);
-        ++methods;
-    }
-}

src/logo/image/image.c

@@ -255,7 +255,7 @@ static bool printImageChafa(FFinstance* instance, FFLogoRequestData* requestData
     result.length = (uint32_t) str->len;
     result.chars = str->str;
 
-    ffLogoPrint(instance, result.chars, false);
+    ffLogoPrintChars(instance, result.chars, false);
     writeCacheStrbuf(requestData, &result, FF_CACHE_FILE_CHAFA);
 
     ffg_string_free(str, TRUE);
@@ -412,7 +412,7 @@ static bool printCachedChars(FFinstance* instance, FFLogoRequestData* requestDat
         return false;
     }
 
-    ffLogoPrint(instance, content.chars, false);
+    ffLogoPrintChars(instance, content.chars, false);
     ffStrbufDestroy(&content);
     return true;
 }
@@ -499,12 +499,12 @@ static bool getCharacterPixelDimensions(FFLogoRequestData* requestData)
     return requestData->characterPixelWidth > 1.0 && requestData->characterPixelHeight > 1.0;
 }
 
-FFLogoImageResult ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type)
+bool ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type)
 {
     //Performance optimisation
     #ifndef FF_HAVE_CHAFA
         if(type == FF_LOGO_TYPE_CHAFA)
-            return FF_LOGO_IMAGE_RESULT_INIT_ERROR;
+            return false;
     #endif
 
     FFLogoRequestData requestData;
@@ -516,7 +516,7 @@ FFLogoImageResult ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type
         (type != FF_LOGO_TYPE_CHAFA || instance->config.logoWidth == 0 || instance->config.logoHeight == 0) &&
         !getCharacterPixelDimensions(&requestData)
     )
-        return FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+        return false;
 
     requestData.logoPixelWidth = simpleCeil((double) instance->config.logoWidth * requestData.characterPixelWidth);
     requestData.logoPixelHeight = simpleCeil((double) instance->config.logoHeight * requestData.characterPixelHeight);
@@ -530,7 +530,7 @@ FFLogoImageResult ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type
     {
         //We can safely return here, because if realpath failed, we surely won't be able to read the file
         ffStrbufDestroy(&requestData.cacheDir);
-        return FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+        return false;
     }
     ffStrbufRecalculateLength(&requestData.cacheDir);
     if(!ffStrbufEndsWithC(&requestData.cacheDir, '/'))
@@ -544,7 +544,7 @@ FFLogoImageResult ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type
     if(!instance->config.recache && printCached(instance, &requestData))
     {
         ffStrbufDestroy(&requestData.cacheDir);
-        return FF_LOGO_IMAGE_RESULT_SUCCESS;
+        return true;
     }
 
     FFLogoImageResult result = FF_LOGO_IMAGE_RESULT_INIT_ERROR;
@@ -559,13 +559,13 @@ FFLogoImageResult ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type
     #endif
 
     ffStrbufDestroy(&requestData.cacheDir);
-    return result;
+    return result == FF_LOGO_IMAGE_RESULT_SUCCESS;
 }
 
 #else //FF_HAVE_IMAGEMAGICK{6, 7}
 FFLogoImageResult ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type)
 {
     FF_UNUSED(instance, type);
-    return FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+    return false;
 }
 #endif //FF_HAVE_IMAGEMAGICK{6, 7}

src/logo/image/image.h

@@ -10,6 +10,13 @@
 #define MAGICKCORE_HDRI_ENABLE 1
 #define MAGICKCORE_QUANTUM_DEPTH 16
 
+typedef enum FFLogoImageResult
+{
+    FF_LOGO_IMAGE_RESULT_SUCCESS,    //Logo printed
+    FF_LOGO_IMAGE_RESULT_INIT_ERROR, //Failed to load library, try again with next IM version
+    FF_LOGO_IMAGE_RESULT_RUN_ERROR   //Failed to load / convert image, cancle whole sixel code
+} FFLogoImageResult;
+
 typedef struct FFLogoRequestData
 {
     FFLogoType type;
@@ -44,5 +51,4 @@ FFLogoImageResult ffLogoPrintImageIM7(FFinstance* instance, FFLogoRequestData* r
 FFLogoImageResult ffLogoPrintImageIM6(FFinstance* instance, FFLogoRequestData* requestData);
 #endif
 
-
 #endif

src/logo/logo.c

@@ -1,8 +1,9 @@
 #include "logo.h"
 
 #include <ctype.h>
+#include <string.h>
 
-void ffLogoPrint(FFinstance* instance, const char* data, bool doColorReplacement)
+void ffLogoPrintChars(FFinstance* instance, const char* data, bool doColorReplacement)
 {
     uint32_t currentlineLength = 0;
 
@@ -145,60 +146,152 @@ void ffLogoPrint(FFinstance* instance, const char* data, bool doColorReplacement
         printf("\033[%uA", instance->state.logoHeight);
 }
 
-static void logoPrintFile(FFinstance* instance, bool doColorReplacement)
+static void logoApplyMainColor(FFinstance* instance, const FFlogo* logo)
+{
+    if(instance->config.mainColor.length == 0)
+        ffStrbufAppendS(&instance->config.mainColor, logo->builtinColors[0]);
+}
+
+static bool logoHasName(const FFlogo* logo, const char* name)
+{
+    const char** logoName = logo->names;
+
+    while(*logoName != NULL)
+    {
+        if(strcasecmp(*logoName, name) == 0)
+            return true;
+        ++logoName;
+    }
+
+    return false;
+}
+
+static const FFlogo* logoGetBuiltin(const char* name)
+{
+    GetLogoMethod* methods = ffLogoBuiltinGetAll();
+
+    while(*methods != NULL)
+    {
+        const FFlogo* logo = (*methods)();
+
+        if(logoHasName(logo, name))
+            return logo;
+
+        ++methods;
+    }
+
+    return NULL;
+}
+
+static const FFlogo* logoGetBuiltinDetected(FFinstance* instance)
+{
+    const FFOSResult* os = ffDetectOS(instance);
+
+    const FFlogo* logo = logoGetBuiltin(os->id.chars);
+    if(logo != NULL)
+        return logo;
+
+    logo = logoGetBuiltin(os->name.chars);
+    if(logo != NULL)
+        return logo;
+
+    logo = logoGetBuiltin(os->prettyName.chars);
+    if(logo != NULL)
+        return logo;
+
+    logo = logoGetBuiltin(os->idLike.chars);
+    if(logo != NULL)
+        return logo;
+
+    logo = logoGetBuiltin(os->systemName.chars);
+    if(logo != NULL)
+        return logo;
+
+    return ffLogoBuiltinGetUnknown();
+}
+
+static inline void logoApplyMainColorDetected(FFinstance* instance)
+{
+    logoApplyMainColor(instance, logoGetBuiltinDetected(instance));
+}
+
+static void logoPrintStruct(FFinstance* instance, const FFlogo* logo)
+{
+    logoApplyMainColor(instance, logo);
+
+    const char** colors = logo->builtinColors;
+    for(int i = 0; *colors != NULL && i < FASTFETCH_LOGO_MAX_COLORS; i++, colors++)
+    {
+        if(instance->config.logoColors[i].length == 0)
+            ffStrbufAppendS(&instance->config.logoColors[i], *colors);
+    }
+
+    ffLogoPrintChars(instance, logo->data, true);
+}
+
+static bool logoPrintBuiltinIfExists(FFinstance* instance, const char* name)
+{
+    const FFlogo* logo = logoGetBuiltin(name);
+    if(logo == NULL)
+        return false;
+
+    logoPrintStruct(instance, logo);
+    return true;
+}
+
+static inline void logoPrintDetected(FFinstance* instance)
+{
+    logoPrintStruct(instance, logoGetBuiltinDetected(instance));
+}
+
+static bool logoPrintFileIfExists(FFinstance* instance, bool doColorReplacement)
 {
     FFstrbuf content;
     ffStrbufInitA(&content, 2047);
 
-    if(ffAppendFileContent(instance->config.logoSource.chars, &content))
-        ffLogoPrint(instance, content.chars, doColorReplacement);
-    else
-        ffLogoPrintUnknown(instance);
-}
-
-static void logoPrintDetected(FFinstance* instance)
-{
-    //If no logo source is given, detect the logo from OS and print the right builtin one
-    if(instance->config.logoSource.length == 0)
+    if(!ffAppendFileContent(instance->config.logoSource.chars, &content))
     {
-        ffLogoPrintBuiltinDetected(instance);
-        return;
+        ffStrbufDestroy(&content);
+        return false;
     }
 
-    //If a logo source is given, first look if it is the name of a builtin logo
-    if(ffLogoPrintBuiltinIfExists(instance))
-        return;
-
-    const FFTerminalShellResult* terminalShell = ffDetectTerminalShell(instance);
-
-    FFLogoImageResult imageResult = FF_LOGO_IMAGE_RESULT_INIT_ERROR;
-
-    //Terminals that are known to support kitty graphics protocol
-    //Try to load the logo as image.
-    if(
-        ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "kitty") == 0 ||
-        ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "konsole") == 0 ||
-        ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "wezterm") == 0 ||
-        ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "wayst") == 0
-    ) {
-        imageResult = ffLogoPrintImageIfExists(instance, FF_LOGO_TYPE_KITTY);
-        if(imageResult == FF_LOGO_IMAGE_RESULT_SUCCESS)
-            return;
-    }
-
-    //If the logo can be loaded as an image, convert it to ascii art.
-    //This happens in all terminals, that don't support kitty graphics protocol
-    if(
-        imageResult != FF_LOGO_IMAGE_RESULT_RUN_ERROR &&
-        ffLogoPrintImageIfExists(instance, FF_LOGO_TYPE_CHAFA) == FF_LOGO_IMAGE_RESULT_SUCCESS
-    ) return;
-
-    //Print the content of the file as logo
-    logoPrintFile(instance, true);
+    logoApplyMainColorDetected(instance);
+    ffLogoPrintChars(instance, content.chars, doColorReplacement);
+    ffStrbufDestroy(&content);
+    return true;
 }
 
-void ffPrintLogo(FFinstance* instance)
+static bool logoPrintImageIfExists(FFinstance* instance, FFLogoType logoType)
 {
+    if(!ffLogoPrintImageIfExists(instance, logoType))
+        return false;
+
+    logoApplyMainColorDetected(instance);
+    return true;
+}
+
+static void logoPrintKnownType(FFinstance* instance)
+{
+    bool successfull;
+
+    if(instance->config.logoType == FF_LOGO_TYPE_BUILTIN)
+        successfull = logoPrintBuiltinIfExists(instance, instance->config.logoSource.chars);
+    else if(instance->config.logoType == FF_LOGO_TYPE_FILE)
+        successfull = logoPrintFileIfExists(instance, true);
+    else if(instance->config.logoType == FF_LOGO_TYPE_RAW)
+        successfull = logoPrintFileIfExists(instance, false);
+    else //image
+        successfull = logoPrintImageIfExists(instance, instance->config.logoType);
+
+    if(!successfull)
+        logoPrintDetected(instance);
+}
+
+void ffLogoPrint(FFinstance* instance)
+{
+    //In pipe mode, we don't have a logo or padding.
+    //We also don't need to set main color, because it won't be printed anyway.
+    //So we can return quickly here.
     if(instance->config.pipe)
     {
         instance->state.logoHeight = 0;
@@ -206,34 +299,45 @@ void ffPrintLogo(FFinstance* instance)
         return;
     }
 
-    if(instance->config.mainColor.length == 0)
-        ffLogoSetMainColor(instance);
-
-    if( //Logo type needs set logo name, but nothing was given. Print question mark
-        instance->config.logoType != FF_LOGO_TYPE_AUTO &&
-        instance->config.logoSource.length == 0
-    )
-        ffLogoPrintUnknown(instance);
-    else if(instance->config.logoType == FF_LOGO_TYPE_BUILTIN)
+    //If the source is not set, we can directly print the detected logo.
+    if(instance->config.logoSource.length == 0)
     {
-        if(!ffLogoPrintBuiltinIfExists(instance))
-            ffLogoPrintUnknown(instance);
-    }
-    else if(instance->config.logoType == FF_LOGO_TYPE_FILE)
-        logoPrintFile(instance, true);
-    else if(instance->config.logoType == FF_LOGO_TYPE_RAW)
-        logoPrintFile(instance, false);
-    else if(instance->config.logoType == FF_LOGO_TYPE_SIXEL || instance->config.logoType == FF_LOGO_TYPE_KITTY || instance->config.logoType == FF_LOGO_TYPE_CHAFA)
-    {
-        if(ffLogoPrintImageIfExists(instance, instance->config.logoType) != FF_LOGO_IMAGE_RESULT_SUCCESS)
-            ffLogoPrintBuiltinDetected(instance);
-    }
-    else
         logoPrintDetected(instance);
+        return;
+    }
+
+    //If the source and source type is set to something else than auto, always print with the set type.
+    if(instance->config.logoSource.length > 0 && instance->config.logoType != FF_LOGO_TYPE_AUTO)
+    {
+        logoPrintKnownType(instance);
+        return;
+    }
+
+    //If source matches the name of a builtin logo, print it and return.
+    if(logoPrintBuiltinIfExists(instance, instance->config.logoSource.chars))
+        return;
+
+    const FFTerminalShellResult* terminalShell = ffDetectTerminalShell(instance);
+
+    //Terminal emulators that support kitty graphics protocol.
+    bool supportsKitty =
+        ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "kitty") == 0 ||
+        ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "konsole") == 0 ||
+        ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "wezterm") == 0 ||
+        ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "wayst") == 0;
+
+    //Try to load the logo as an image. If it succeeds, print it and return.
+    if(logoPrintImageIfExists(instance, supportsKitty ? FF_LOGO_TYPE_KITTY : FF_LOGO_TYPE_CHAFA))
+        return;
+
+    //Try to load the logo as a file. If it succeeds, print it and return.
+    if(logoPrintFileIfExists(instance, true))
+        return;
+
+    logoPrintDetected(instance);
 }
 
-
-void ffPrintLogoLine(FFinstance* instance)
+void ffLogoPrintLine(FFinstance* instance)
 {
     if(instance->state.logoWidth > 0)
         printf("\033[%uC", instance->state.logoWidth);
@@ -241,11 +345,67 @@ void ffPrintLogoLine(FFinstance* instance)
     ++instance->state.keysHeight;
 }
 
-void ffPrintRemainingLogo(FFinstance* instance)
+void ffLogoPrintRemaining(FFinstance* instance)
 {
     while(instance->state.keysHeight < instance->state.logoHeight)
     {
-        ffPrintLogoLine(instance);
+        ffLogoPrintLine(instance);
         putchar('\n');
     }
 }
+
+void ffLogoBuiltinPrint(FFinstance* instance)
+{
+    GetLogoMethod* methods = ffLogoBuiltinGetAll();
+
+    while(*methods != NULL)
+    {
+        const FFlogo* logo = (*methods)();
+        printf("\033[%sm%s:\033[0m\n", logo->builtinColors[0], logo->names[0]);
+        logoPrintStruct(instance, logo);
+        ffLogoPrintRemaining(instance);
+
+        instance->state.logoHeight = 0;
+        for(uint8_t i = 0; i < FASTFETCH_LOGO_MAX_COLORS; i++)
+            ffStrbufClear(&instance->config.logoColors[i]);
+
+        puts("\n");
+        ++methods;
+    }
+}
+
+void ffLogoBuiltinList()
+{
+    GetLogoMethod* methods = ffLogoBuiltinGetAll();
+
+    uint32_t counter = 0;
+
+    while(*methods != NULL)
+    {
+        const FFlogo* logo = (*methods)();
+        const char** names = logo->names;
+
+        printf("%u)%s ", counter, counter < 10 ? " " : "");
+        ++counter;
+
+        while(*names != NULL)
+        {
+            printf("\"%s\" ", *names);
+            ++names;
+        }
+
+        putchar('\n');
+        ++methods;
+    }
+}
+
+void ffLogoBuiltinListAutocompletion()
+{
+    GetLogoMethod* methods = ffLogoBuiltinGetAll();
+
+    while(*methods != NULL)
+    {
+        printf("%s\n", (*methods)()->names[0]);
+        ++methods;
+    }
+}

src/logo/logo.h

@@ -5,24 +5,23 @@
 
 #include "fastfetch.h"
 
+typedef struct FFlogo
+{
+    const char* data;
+    const char** names; //Null terminated
+    const char** builtinColors; //Null terminated
+} FFlogo;
+
+typedef const FFlogo*(*GetLogoMethod)();
+
 //logo.c
-void ffLogoPrint(FFinstance* instance, const char* data, bool doColorReplacement);
+void ffLogoPrintChars(FFinstance* instance, const char* data, bool doColorReplacement);
 
 //builtin.c
-void ffLogoSetMainColor(FFinstance* instance);
-
-void ffLogoPrintUnknown(FFinstance* instance);
-bool ffLogoPrintBuiltinIfExists(FFinstance* instance);
-void ffLogoPrintBuiltinDetected(FFinstance* instance);
-
-typedef enum FFLogoImageResult
-{
-    FF_LOGO_IMAGE_RESULT_SUCCESS,    //Logo printed
-    FF_LOGO_IMAGE_RESULT_INIT_ERROR, //Failed to load library, try again with next IM version
-    FF_LOGO_IMAGE_RESULT_RUN_ERROR   //Failed to load / convert image, cancle whole sixel code
-} FFLogoImageResult;
+const FFlogo* ffLogoBuiltinGetUnknown();
+GetLogoMethod* ffLogoBuiltinGetAll();
 
 //image/image.c
-FFLogoImageResult ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type);
+bool ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type);
 
 #endif

src/modules/break.c

@@ -2,6 +2,6 @@
 
 void ffPrintBreak(FFinstance* instance)
 {
-    ffPrintLogoLine(instance);
+    ffLogoPrintLine(instance);
     putchar('\n');
 }

src/modules/colors.c

@@ -4,14 +4,14 @@ void ffPrintColors(FFinstance* instance)
 {
     if(instance->config.pipe)
     {
-        ffPrintLogoLine(instance);
+        ffLogoPrintLine(instance);
         puts("████████████████████████");
-        ffPrintLogoLine(instance);
+        ffLogoPrintLine(instance);
         puts("████████████████████████");
         return;
     }
 
-    ffPrintLogoLine(instance);
+    ffLogoPrintLine(instance);
 
     // 4%d: Set the background color
     // 3%d: Set the foreground color
@@ -20,7 +20,7 @@ void ffPrintColors(FFinstance* instance)
 
     puts(FASTFETCH_TEXT_MODIFIER_RESET);
 
-    ffPrintLogoLine(instance);
+    ffLogoPrintLine(instance);
 
     // 1: Set everything to bolt. This causes normal colors on some systems to be bright.
     // 4%d: Set the backgound to the not bright color

src/modules/separator.c

@@ -5,7 +5,7 @@ void ffPrintSeparator(FFinstance* instance)
     const FFTitleResult* result = ffDetectTitle(instance);
     uint32_t titleLength = result->userName.length + 1 + result->hostname.length;
 
-    ffPrintLogoLine(instance);
+    ffLogoPrintLine(instance);
 
     if(instance->config.separatorString.length == 0)
     {

src/modules/title.c

@@ -46,7 +46,7 @@ void ffPrintTitle(FFinstance* instance)
 {
     const FFTitleResult* result = ffDetectTitle(instance);
 
-    ffPrintLogoLine(instance);
+    ffLogoPrintLine(instance);
 
     printTitlePart(instance, &result->userName);
     putchar('@');