fastfetch-cli/fastfetch
1
0
Fork 0
mirror of https://github.com/fastfetch-cli/fastfetch.git synced 2026-09-13 02:42:09 +02:00
Code Issues Packages Projects Releases 10 Wiki Activity

better gtk detection

Browse Source
This commit is contained in:
Linus Dierheimer
2021-04-05 19:25:34 +02:00
parent af430bd405
commit de312adb52
11 changed files with 455 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
+1
View File
@@ -34,6 +34,7 @@ set(SRCS
src/common.c
src/logo.c
src/util/FFstrbuf.c
src/helpers/gtk.c
src/modules/break.c
src/modules/custom.c
src/modules/title.c
src/common.c
+17 -54
View File
@@ -357,7 +357,7 @@ void ffParseFormatStringV(FFstrbuf* buffer, FFstrbuf* formatstr, uint32_t numArg
else if(arg.type == FF_FORMAT_ARG_TYPE_STRBUF)
ffStrbufAppend(buffer, (FFstrbuf*)arg.value);
else if(arg.type == FF_FORMAT_ARG_TYPE_DOUBLE)
ffStrbufAppendF(buffer, "%.9g", *(double*)arg.value);
ffStrbufAppendF(buffer, "%g", *(double*)arg.value);
else
{
fprintf(stderr, "Error: format string \"%s\" argument is not implemented\n", formatstr->chars);
@@ -398,62 +398,25 @@ void ffPrintFormatString(FFinstance* instance, FFstrbuf* customKey, const char*
ffStrbufDestroy(&buffer);
}
static inline bool strSet(const char* str)
void ffParseFont(const char* font, FFstrbuf* name, double* size)
{
return str != NULL && str[0] != '\0';
}
ffStrbufEnsureCapacity(name, 32);
void ffFormatGtkPretty(FFstrbuf* buffer, const char* gtk2, const char* gtk3, const char* gtk4)
{
if(strSet(gtk2) && strSet(gtk3) && strSet(gtk4))
{
if((strcmp(gtk2, gtk3) == 0) && (strcmp(gtk2, gtk4) == 0))
ffStrbufSetF(buffer, "%s [GTK2/3/4]", gtk2);
else if(strcmp(gtk2, gtk3) == 0)
ffStrbufSetF(buffer, "%s [GTK2/3], %s [GTK4]", gtk2, gtk4);
else if(strcmp(gtk3, gtk4) == 0)
ffStrbufSetF(buffer, "%s [GTK2], %s [GTK3/4]", gtk2, gtk3);
else
ffStrbufSetF(buffer, "%s [GTK2], %s [GTK3], %s [GTK4]", gtk2, gtk3, gtk4);
}
else if(strSet(gtk2) && strSet(gtk3))
{
if(strcmp(gtk2, gtk3) == 0)
ffStrbufSetF(buffer, "%s [GTK2/3]", gtk2);
else
ffStrbufSetF(buffer, "%s [GTK2], %s [GTK3]", gtk2, gtk3);
}
else if(strSet(gtk3) && strSet(gtk4))
{
if(strcmp(gtk3, gtk4) == 0)
ffStrbufSetF(buffer, "%s [GTK3/4]", gtk3);
else
ffStrbufSetF(buffer, "%s [GTK3], %s [GTK4]", gtk3, gtk4);
}
else if(strSet(gtk2))
{
ffStrbufSetF(buffer, "%s [GTK2]", gtk2);
}
else if(strSet(gtk3))
{
ffStrbufSetF(buffer, "%s [GTK3]", gtk3);
}
else if(strSet(gtk4))
{
ffStrbufSetF(buffer, "%s [GTK4]", gtk4);
}
}
int scanned = sscanf(font, "%[^,], %lf", name->chars, size);
void ffParseFont(char* font, char* buffer)
{
char name[64];
char size[32];
int scanned = sscanf(font, "%[^,], %[^,]", name, size);
ffStrbufRecalculateLength(name);
if(scanned < 2)
*size = 0.0;
if(scanned == 0)
strcpy(buffer, font);
else if(scanned == 1)
strcpy(buffer, name);
else
sprintf(buffer, "%s (%spt)", name, size);
ffStrbufSetS(name, font);
}
void ffFontPretty(FFstrbuf* buffer, const FFstrbuf* name, double size)
{
ffStrbufAppend(buffer, name);
ffStrbufAppendS(buffer, " (");
ffStrbufAppendF(buffer, "%g", size);
ffStrbufAppendS(buffer, "pt)");
}
src/fastfetch.c
+23 -8
View File
@@ -324,12 +324,24 @@ static inline void printCommandHelp(const char* command)
}
else if(strcasecmp(command, "font-format") == 0)
{
constructAndPrintCommandHelpFormat("font", "{} [Plasma], {5}", 5,
"Plasma font",
"GTK2 font",
"GTK3 font",
"GTK4 font",
"Combined GTK fonts"
constructAndPrintCommandHelpFormat("font", "{4}, {17}", 17,
"Plasma as in resource file",
"Plasma name",
"Plasma size",
"Plasma name and size pretty together",
"GTK2 as in resource file",
"GTK2 name",
"GTK2 size",
"GTK2 name and size pretty together",
"GTK3 as in resource file",
"GTK3 name",
"GTK3 size",
"GTK3 name and size pretty together",
"GTK4 as in resource file",
"GTK4 name",
"GTK4 size",
"GTK4 name and size pretty together",
"GTK 2/3/4 name and size pretty together"
);
}
else if(strcasecmp(command, "terminal-format") == 0)
@@ -342,8 +354,11 @@ static inline void printCommandHelp(const char* command)
}
else if(strcasecmp(command, "terminal-font-format") == 0)
{
constructAndPrintCommandHelpFormat("terminal-font", "{}", 1,
"Terminal font name"
constructAndPrintCommandHelpFormat("terminal-font", "{4}", 4,
"Terminal font as in resource file",
"Terminal font name",
"Termianl font size",
"Terminal font name and size pretty together"
);
}
else if(strcasecmp(command, "cpu-format") == 0)
src/fastfetch.h
+10 -2
View File
@@ -142,8 +142,8 @@ void ffParsePropFileHome(FFinstance* instance, const char* relativeFile, const c
void ffParseFormatStringV(FFstrbuf* buffer, FFstrbuf* formatstr, uint32_t numArgs, va_list argp);
void ffParseFormatString(FFstrbuf* buffer, FFstrbuf* formatstr, uint32_t numArgs, ...);
void ffPrintFormatString(FFinstance* instance, FFstrbuf* customKey, const char* defKey, FFstrbuf* formatstr, uint32_t numArgs, ...);
void ffParseFont(char* font, char* buffer);
void ffFormatGtkPretty(FFstrbuf* buffer, const char* gtk2, const char* gtk3, const char* gtk4);
void ffParseFont(const char* font, FFstrbuf* name, double* size);
void ffFontPretty(FFstrbuf* buffer, const FFstrbuf* name, double size);
void ffFinish(FFinstance* instance);
//Logo functions
@@ -157,6 +157,14 @@ void ffListLogos();
void ffPrintLogos(bool color);
#endif
//Helper functions
void ffCalculateGTK2(FFinstance* instance, FFstrbuf** themeNamePtr, FFstrbuf** iconsNamePtr, FFstrbuf** fontNamePtr);
void ffCalculateGTK4(FFinstance* instance, FFstrbuf** themeNamePtr, FFstrbuf** iconsNamePtr, FFstrbuf** fontNamePtr);
void ffCalculateGTK3(FFinstance* instance, FFstrbuf** themeNamePtr, FFstrbuf** iconsNamePtr, FFstrbuf** fontNamePtr);
void ffFormatGtkPretty(FFstrbuf* buffer, FFstrbuf* gtk2, FFstrbuf* gtk3, FFstrbuf* gtk4);
//Module functions
void ffCalculateTerminal(FFinstance* instance, FFstrbuf** exeNamePtr, FFstrbuf** processNamePtr, FFstrbuf** errorPtr);
src/helpers/gtk.c
+258
View File
@@ -0,0 +1,258 @@
#include "fastfetch.h"
static void parseGTKConfigFile(FFstrbuf* fileName, FFstrbuf* themeNamePtr, FFstrbuf* iconsNamePtr, FFstrbuf* fontNamePtr)
{
FILE* file = fopen(fileName->chars, "r");
if(file == NULL)
return;
char* line = NULL;
size_t len = 0;
while(getline(&line, &len, file) != -1)
{
if(themeNamePtr->length == 0)
{
sscanf(line, "gtk-theme-name=%[^\n]", themeNamePtr->chars);
sscanf(line, "gtk-theme-name=\"%[^\"]+", themeNamePtr->chars);
}
if(iconsNamePtr->length == 0)
{
sscanf(line, "gtk-icon-theme-name=%[^\n]", iconsNamePtr->chars);
sscanf(line, "gtk-icon-theme-name=\"%[^\"]+", iconsNamePtr->chars);
}
if(fontNamePtr->length == 0)
{
sscanf(line, "gtk-font-name=%[^\n]", fontNamePtr->chars);
sscanf(line, "gtk-font-name=\"%[^\"]+", fontNamePtr->chars);
}
}
if(line != NULL)
free(line);
fclose(file);
ffStrbufRecalculateLength(themeNamePtr);
ffStrbufRecalculateLength(iconsNamePtr);
ffStrbufRecalculateLength(fontNamePtr);
}
static void calculateGTKFromConfigDir(const char* configDir, const char* version, FFstrbuf* themeNamePtr, FFstrbuf* iconsNamePtr, FFstrbuf* fontNamePtr)
{
// <configdir>/gtk-<version>.0/settings.ini
FFstrbuf file1;
ffStrbufInitA(&file1, 64);
ffStrbufAppendS(&file1, configDir);
ffStrbufAppendS(&file1, "gtk-");
ffStrbufAppendS(&file1, version);
ffStrbufAppendS(&file1, ".0/settings.ini");
parseGTKConfigFile(&file1, themeNamePtr, iconsNamePtr, fontNamePtr);
ffStrbufDestroy(&file1);
// <configdir>/gtk-<version>.0/gtkrc
FFstrbuf file2;
ffStrbufInitA(&file2, 64);
ffStrbufAppendS(&file2, configDir);
ffStrbufAppendS(&file2, "gtk-");
ffStrbufAppendS(&file2, version);
ffStrbufAppendS(&file2, ".0/gtkrc");
parseGTKConfigFile(&file2, themeNamePtr, iconsNamePtr, fontNamePtr);
ffStrbufDestroy(&file2);
// <configdir>/gtkrc-<version>.0
FFstrbuf file3;
ffStrbufInitA(&file3, 64);
ffStrbufAppendS(&file3, configDir);
ffStrbufAppendS(&file3, "gtkrc-");
ffStrbufAppendS(&file3, version);
ffStrbufAppendS(&file3, ".0");
parseGTKConfigFile(&file3, themeNamePtr, iconsNamePtr, fontNamePtr);
ffStrbufDestroy(&file3);
// <configdir>/.gtkrc-<version>.0
FFstrbuf file4;
ffStrbufInitA(&file4, 64);
ffStrbufAppendS(&file4, configDir);
ffStrbufAppendS(&file4, "gtkrc-");
ffStrbufAppendS(&file4, version);
ffStrbufAppendS(&file4, ".0");
parseGTKConfigFile(&file4, themeNamePtr, iconsNamePtr, fontNamePtr);
ffStrbufDestroy(&file4);
}
static void calculateGTK(FFinstance* instance, const char* version, FFstrbuf* themeNamePtr, FFstrbuf* iconsNamePtr, FFstrbuf* fontNamePtr)
{
static FFstrbuf configDir;
static bool configDirInit = false;
if(!configDirInit)
{
ffStrbufInitA(&configDir, 64);
ffStrbufAppendS(&configDir, instance->state.passwd->pw_dir);
ffStrbufAppendS(&configDir, "/.config/");
configDirInit = true;
}
static FFstrbuf xdgConfigDir;
static bool xdgConfigDirInit = false;
if(!xdgConfigDirInit)
{
ffStrbufInitA(&xdgConfigDir, 64);
ffStrbufAppendS(&xdgConfigDir, getenv("XDG_CONFIG_HOME"));
if(xdgConfigDir.length > 0 && xdgConfigDir.chars[xdgConfigDir.length - 1] != '/')
ffStrbufAppendC(&xdgConfigDir, '/');
xdgConfigDirInit = true;
}
static bool xdgIsDifferent;
static bool xdgIsDifferentInit = false;
if(!xdgIsDifferentInit)
{
xdgIsDifferent = ffStrbufComp(&configDir, &xdgConfigDir) != 0;
xdgConfigDirInit = true;
}
if(xdgIsDifferent)
calculateGTKFromConfigDir(xdgConfigDir.chars, version, themeNamePtr, iconsNamePtr, fontNamePtr);
calculateGTKFromConfigDir(configDir.chars, version, themeNamePtr, iconsNamePtr, fontNamePtr);
// <homedir>/gtkrc-<version>.0
FFstrbuf homeConfig1;
ffStrbufInitA(&homeConfig1, 64);
ffStrbufAppendS(&homeConfig1, instance->state.passwd->pw_dir);
ffStrbufAppendS(&homeConfig1, "/gtkrc-");
ffStrbufAppendS(&homeConfig1, version);
ffStrbufAppendS(&homeConfig1, ".0");
parseGTKConfigFile(&homeConfig1, themeNamePtr, iconsNamePtr, fontNamePtr);
ffStrbufDestroy(&homeConfig1);
// <homedir>/.gtkrc-<version>.0
FFstrbuf homeConfig2;
ffStrbufInitA(&homeConfig2, 64);
ffStrbufAppendS(&homeConfig2, instance->state.passwd->pw_dir);
ffStrbufAppendS(&homeConfig2, "/.gtkrc-");
ffStrbufAppendS(&homeConfig2, version);
ffStrbufAppendS(&homeConfig2, ".0");
parseGTKConfigFile(&homeConfig2, themeNamePtr, iconsNamePtr, fontNamePtr);
ffStrbufDestroy(&homeConfig2);
calculateGTKFromConfigDir("/etc/", version, themeNamePtr, iconsNamePtr, fontNamePtr);
}
#define FF_CALCULATE_GTK_IMPL(version) \
static FFstrbuf themeName; \
static FFstrbuf iconsName; \
static FFstrbuf fontName; \
if(themeNamePtr != NULL) *themeNamePtr = &themeName; \
if(iconsNamePtr != NULL) *iconsNamePtr = &iconsName; \
if(fontNamePtr != NULL) *fontNamePtr = &fontName; \
static bool init = false; \
if(init) return; \
init = true; \
ffStrbufInit(&themeName); \
ffStrbufInit(&iconsName); \
ffStrbufInit(&fontName); \
calculateGTK(instance, #version, &themeName, &iconsName, &fontName);
void ffCalculateGTK2(FFinstance* instance, FFstrbuf** themeNamePtr, FFstrbuf** iconsNamePtr, FFstrbuf** fontNamePtr)
{
FF_CALCULATE_GTK_IMPL(2)
}
void ffCalculateGTK3(FFinstance* instance, FFstrbuf** themeNamePtr, FFstrbuf** iconsNamePtr, FFstrbuf** fontNamePtr)
{
FF_CALCULATE_GTK_IMPL(3)
}
void ffCalculateGTK4(FFinstance* instance, FFstrbuf** themeNamePtr, FFstrbuf** iconsNamePtr, FFstrbuf** fontNamePtr)
{
FF_CALCULATE_GTK_IMPL(4)
}
#undef FF_CALCULATE_GTK_IMPL
void ffFormatGtkPretty(FFstrbuf* buffer, FFstrbuf* gtk2, FFstrbuf* gtk3, FFstrbuf* gtk4)
{
if(gtk2->length > 0 && gtk3->length > 0 && gtk4->length > 0)
{
if((ffStrbufIgnCaseComp(gtk2, gtk3) == 0) && (ffStrbufIgnCaseComp(gtk2, gtk4) == 0))
{
ffStrbufAppend(buffer, gtk4);
ffStrbufAppendS(buffer, " [GTK2/3/4]");
}
else if(ffStrbufIgnCaseComp(gtk2, gtk3) == 0)
{
ffStrbufAppend(buffer, gtk3);
ffStrbufAppendS(buffer, " [GTK2/3], ");
ffStrbufAppend(buffer, gtk4);
ffStrbufAppendS(buffer, " [GTK4]");
}
else if(ffStrbufIgnCaseComp(gtk3, gtk4) == 0)
{
ffStrbufAppend(buffer, gtk2);
ffStrbufAppendS(buffer, " [GTK2], ");
ffStrbufAppend(buffer, gtk4);
ffStrbufAppendS(buffer, " [GTK3/4]");
}
else
{
ffStrbufAppend(buffer, gtk2);
ffStrbufAppendS(buffer, " [GTK2], ");
ffStrbufAppend(buffer, gtk3);
ffStrbufAppendS(buffer, " [GTK3], ");
ffStrbufAppend(buffer, gtk4);
ffStrbufAppendS(buffer, " [GTK4]");
}
}
else if(gtk2->length > 0 && gtk3->length > 0)
{
if(ffStrbufIgnCaseComp(gtk2, gtk3) == 0)
{
ffStrbufAppend(buffer, gtk3);
ffStrbufAppendS(buffer, " [GTK2/3]");
}
else
{
ffStrbufAppend(buffer, gtk2);
ffStrbufAppendS(buffer, " [GTK2], ");
ffStrbufAppend(buffer, gtk3);
ffStrbufAppendS(buffer, " [GTK3]");
}
}
else if(gtk3->length > 0 && gtk4->length > 0)
{
if(ffStrbufIgnCaseComp(gtk3, gtk4) == 0)
{
ffStrbufAppend(buffer, gtk4);
ffStrbufAppendS(buffer, " [GTK3/4]");
}
else
{
ffStrbufAppend(buffer, gtk3);
ffStrbufAppendS(buffer, " [GTK3], ");
ffStrbufAppend(buffer, gtk4);
ffStrbufAppendS(buffer, " [GTK4]");
}
}
else if(gtk2->length > 0)
{
ffStrbufAppend(buffer, gtk2);
ffStrbufAppendS(buffer, " [GTK2]");
}
else if(gtk3->length > 0)
{
ffStrbufAppend(buffer, gtk3);
ffStrbufAppendS(buffer, " [GTK3]");
}
else if(gtk4->length > 0)
{
ffStrbufAppend(buffer, gtk4);
ffStrbufAppendS(buffer, " [GTK4]");
}
}
src/modules/font.c
+98 -37
View File
@@ -1,62 +1,123 @@
#include "fastfetch.h"
#include <unistd.h>
void ffPrintFont(FFinstance* instance)
{
FF_STRBUF_CREATE(plasmaFile);
ffStrbufAppendS(&plasmaFile, instance->state.passwd->pw_dir);
ffStrbufAppendS(&plasmaFile, "/.config/kdeglobals");
//When using Noto Sans 10, the default font in KDE Plasma, the font entry is deleted from the config file instead of set.
//So the pure existence of the file sets this font value if not set other in the file itself.
bool plasmaFileExists = access(plasmaFile.chars, F_OK) == 0;
char plasma[256];
ffParsePropFileHome(instance, ".config/kdeglobals", "font=%[^\n]", plasma);
plasma[0] = '\0';
if(plasmaFileExists)
ffParsePropFile(plasmaFile.chars, "font=%[^\n]", plasma);
char plasmaPretty[256];
if(plasma[0] == '\0')
strcpy(plasmaPretty, "Noto Sans (10pt)");
ffStrbufDestroy(&plasmaFile);
FFstrbuf* gtk2;
ffCalculateGTK2(instance, NULL, NULL, &gtk2);
FFstrbuf* gtk3;
ffCalculateGTK3(instance, NULL, NULL, &gtk3);
FFstrbuf* gtk4;
ffCalculateGTK4(instance, NULL, NULL, &gtk4);
if(plasma[0] == '\0' && !plasmaFileExists && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0)
{
ffPrintError(instance, &instance->config.fontKey, "Font", "No fonts found");
return;
}
FF_STRBUF_CREATE(plasmaName);
FF_STRBUF_CREATE(plasmaPretty);
double plasmaSize;
if(plasma[0] == '\0' && plasmaFileExists)
{
strcpy(plasma, "Noto Sans, 10");
ffStrbufSetS(&plasmaName, "Noto Sans");
plasmaSize = 10;
ffStrbufSetS(&plasmaPretty, "Noto Sans (10pt)");
}
else
ffParseFont(plasma, plasmaPretty);
{
ffParseFont(plasma, &plasmaName, &plasmaSize);
ffFontPretty(&plasmaPretty, &plasmaName, plasmaSize);
}
char gtk2[256];
ffParsePropFileHome(instance, ".gtkrc-2.0", "gtk-font-name=\"%[^\"]+", gtk2);
FF_STRBUF_CREATE(gtk2Name);
double gtk2Size;
ffParseFont(gtk2->chars, &gtk2Name, &gtk2Size);
FF_STRBUF_CREATE(gtk2Pretty);
ffFontPretty(&gtk2Pretty, &gtk2Name, gtk2Size);
char gtk2Pretty[256];
if(gtk2[0] == '\0')
gtk2Pretty[0] = '\0';
else
ffParseFont(gtk2, gtk2Pretty);
FF_STRBUF_CREATE(gtk3Name);
double gtk3Size;
ffParseFont(gtk3->chars, &gtk3Name, &gtk3Size);
FF_STRBUF_CREATE(gtk3Pretty);
ffFontPretty(&gtk3Pretty, &gtk3Name, gtk3Size);
char gtk3[256];
ffParsePropFileHome(instance, ".config/gtk-3.0/settings.ini", "gtk-font-name=%[^\n]", gtk3);
char gtk3Pretty[256];
if(gtk3[0] == '\0')
gtk3Pretty[0] = '\0';
else
ffParseFont(gtk3, gtk3Pretty);
char gtk4[256];
ffParsePropFileHome(instance, ".config/gtk-4.0/settings.ini", "gtk-font-name=%[^\n]", gtk4);
char gtk4Pretty[256];
if(gtk4Pretty[0] == '\0')
gtk4Pretty[0] = '\0';
else
ffParseFont(gtk4, gtk4Pretty);
FF_STRBUF_CREATE(gtk4Name);
double gtk4Size;
ffParseFont(gtk4->chars, &gtk4Name, &gtk4Size);
FF_STRBUF_CREATE(gtk4Pretty);
ffFontPretty(&gtk4Pretty, &gtk4Name, gtk4Size);
FF_STRBUF_CREATE(gtkPretty);
ffFormatGtkPretty(&gtkPretty, gtk2Pretty, gtk3Pretty, gtk4Pretty);
ffFormatGtkPretty(&gtkPretty, &gtk2Pretty, &gtk3Pretty, &gtk4Pretty);
if(instance->config.fontFormat.length == 0)
{
ffPrintLogoAndKey(instance, &instance->config.fontKey, "Font");
printf("%s [Plasma], ", plasmaPretty);
if(plasma[0] != '\0')
{
ffStrbufWriteTo(&plasmaPretty, stdout);
fputs(" [Plasma]", stdout);
if(gtkPretty.length > 0)
fputs(", ", stdout);
}
ffStrbufPutTo(&gtkPretty, stdout);
}
else
{
ffPrintFormatString(instance, &instance->config.fontKey, "Font", &instance->config.fontFormat, 5,
(FFformatarg){FF_FORMAT_ARG_TYPE_STRING, plasmaPretty},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRING, gtk2Pretty},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRING, gtk3Pretty},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRING, gtk4Pretty},
ffPrintFormatString(instance, &instance->config.fontKey, "Font", &instance->config.fontFormat, 17,
(FFformatarg){FF_FORMAT_ARG_TYPE_STRING, plasma},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRBUF, &plasmaName},
(FFformatarg){FF_FORMAT_ARG_TYPE_DOUBLE, &plasmaSize},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRBUF, &plasmaPretty},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRBUF, gtk2},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRBUF, &gtk2Name},
(FFformatarg){FF_FORMAT_ARG_TYPE_DOUBLE, &gtk2Size},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRBUF, &gtk2Pretty},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRBUF, gtk3},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRBUF, &gtk3Name},
(FFformatarg){FF_FORMAT_ARG_TYPE_DOUBLE, &gtk3Size},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRBUF, &gtk3Pretty},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRBUF, gtk4},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRBUF, &gtk4Name},
(FFformatarg){FF_FORMAT_ARG_TYPE_DOUBLE, &gtk4Size},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRBUF, &gtk4Pretty},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRBUF, &gtkPretty}
);
}
ffStrbufDestroy(&gtkPretty);
ffStrbufDestroy(&plasmaName);
ffStrbufDestroy(&plasmaPretty);
ffStrbufDestroy(&gtk2Name);
ffStrbufDestroy(&gtk2Pretty);
ffStrbufDestroy(&gtk3Name);
ffStrbufDestroy(&gtk3Pretty);
ffStrbufDestroy(&gtk3Name);
ffStrbufDestroy(&gtk3Pretty);
}
src/modules/icons.c
+12 -12
View File
@@ -5,20 +5,20 @@ void ffPrintIcons(FFinstance* instance)
char plasma[256];
ffParsePropFileHome(instance, ".config/kdeglobals", "Theme=%[^\n]", plasma);
char gtk2[256];
ffParsePropFileHome(instance, ".gtkrc-2.0", "gtk-icon-theme-name=\"%[^\"]+", gtk2);
if(gtk2[0] == '\0')
strcpy(gtk2, "Adwaita");
FFstrbuf* gtk2;
ffCalculateGTK2(instance, NULL, &gtk2, NULL);
char gtk3[256];
ffParsePropFileHome(instance, ".config/gtk-3.0/settings.ini", "gtk-icon-theme-name=%[^\n]", gtk3);
if(gtk3[0] == '\0')
strcpy(gtk3, "Adwaita");
FFstrbuf* gtk3;
ffCalculateGTK3(instance, NULL, &gtk3, NULL);
char gtk4[256];
ffParsePropFileHome(instance, ".config/gtk-4.0/settings.ini", "gtk-icon-theme-name=%[^\n]", gtk4);
if(gtk4[0] == '\0')
strcpy(gtk4, "Adwaita");
FFstrbuf* gtk4;
ffCalculateGTK4(instance, NULL, &gtk4, NULL);
if(plasma[0] == '\0' && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0)
{
ffPrintError(instance, &instance->config.iconsKey, "Icons", "No icons found");
return;
}
FF_STRBUF_CREATE(gtkPretty);
ffFormatGtkPretty(&gtkPretty, gtk2, gtk3, gtk4);
src/modules/terminalfont.c
+17 -8
View File
@@ -1,18 +1,30 @@
#include "fastfetch.h"
static void printTerminalFont(FFinstance* instance, char* font)
static void printTerminalFont(FFinstance* instance, const char* font)
{
FF_STRBUF_CREATE(name);
double size;
ffParseFont(font, &name, &size);
FF_STRBUF_CREATE(pretty);
ffFontPretty(&pretty, &name, size);
if(instance->config.termFontFormat.length == 0)
{
ffPrintLogoAndKey(instance, &instance->config.termFontKey, "Terminal font");
puts(font);
ffStrbufPutTo(&pretty, stdout);
}
else
{
ffPrintFormatString(instance, &instance->config.termFontKey, "Terminal font", &instance->config.termFontFormat, 1,
(FFformatarg){FF_FORMAT_ARG_TYPE_STRING, font}
ffPrintFormatString(instance, &instance->config.termFontKey, "Terminal font", &instance->config.termFontFormat, 4,
(FFformatarg){FF_FORMAT_ARG_TYPE_STRING, font},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRBUF, &name},
(FFformatarg){FF_FORMAT_ARG_TYPE_DOUBLE, &size},
(FFformatarg){FF_FORMAT_ARG_TYPE_STRBUF, &pretty}
);
}
ffStrbufDestroy(&name);
ffStrbufDestroy(&pretty);
}
static void printKonsole(FFinstance* instance)
@@ -36,10 +48,7 @@ static void printKonsole(FFinstance* instance)
return;
}
char fontPretty[128];
ffParseFont(font, fontPretty);
printTerminalFont(instance, fontPretty);
printTerminalFont(instance, font);
}
static void printTTY(FFinstance* instance)
src/modules/theme.c
+12 -12
View File
@@ -5,20 +5,20 @@ void ffPrintTheme(FFinstance* instance)
char plasma[256];
ffParsePropFileHome(instance, ".config/kdeglobals", "Name=%[^\n]", plasma);
char gtk2[256];
ffParsePropFileHome(instance, ".gtkrc-2.0", "gtk-theme-name=\"%[^\"]+", gtk2);
if(gtk2[0] == '\0')
strcpy(gtk2, "Raleigh");
FFstrbuf* gtk2;
ffCalculateGTK2(instance, &gtk2, NULL, NULL);
char gtk3[256];
ffParsePropFileHome(instance, ".config/gtk-3.0/settings.ini", "gtk-theme-name=%[^\n]", gtk3);
if(gtk3[0] == '\0')
strcpy(gtk3, "Adwaita");
FFstrbuf* gtk3;
ffCalculateGTK3(instance, &gtk3, NULL, NULL);
char gtk4[256];
ffParsePropFileHome(instance, ".config/gtk-4.0/settings.ini", "gtk-theme-name=%[^\n]", gtk4);
if(gtk4[0] == '\0')
strcpy(gtk4, "Adwaita");
FFstrbuf* gtk4;
ffCalculateGTK4(instance, &gtk4, NULL, NULL);
if(plasma[0] == '\0' && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0)
{
ffPrintError(instance, &instance->config.themeKey, "Theme", "No themes found");
return;
}
FF_STRBUF_CREATE(gtkPretty);
ffFormatGtkPretty(&gtkPretty, gtk2, gtk3, gtk4);
src/util/FFstrbuf.c
+5
View File
@@ -431,6 +431,11 @@ bool ffStrbufStartsWithNS(FFstrbuf* strbuf, uint32_t length, const char* start)
return true;
}
void ffStrbufRecalculateLength(FFstrbuf* strbuf)
{
for(strbuf->length = 0; strbuf->chars[strbuf->length] != '\0'; ++strbuf->length);
}
void ffStrbufDestroy(FFstrbuf* strbuf)
{
free(strbuf->chars);
src/util/FFstrbuf.h
+2
View File
@@ -81,6 +81,8 @@ bool ffStrbufStartsWith(FFstrbuf* strbuf, FFstrbuf* start);
bool ffStrbufStartsWithS(FFstrbuf* strbuf, const char* start);
bool ffStrbufStartsWithNS(FFstrbuf* strbuf, uint32_t length, const char* start);
void ffStrbufRecalculateLength(FFstrbuf* strbuf);
void ffStrbufDestroy(FFstrbuf* strbuf);
#endif