From 7b653164837dba618d88306835f7d39e01d15ea5 Mon Sep 17 00:00:00 2001 From: Linus Dierheimer Date: Fri, 16 Apr 2021 20:22:38 +0200 Subject: [PATCH] global results are now stored in state --- src/common/calculateGtk.c | 161 ++++++++++++++------------------- src/common/calculatePlasma.c | 67 +++++--------- src/common/calculateTerminal.c | 39 +++----- src/common/calculateWM.c | 40 +++----- src/common/init.c | 8 ++ src/common/threading.c | 12 +-- src/fastfetch.h | 49 ++++++++-- src/modules/font.c | 32 +++---- src/modules/icons.c | 28 ++---- src/modules/terminal.c | 26 +++--- src/modules/terminalfont.c | 11 +-- src/modules/theme.c | 47 ++++------ src/modules/wm.c | 25 +++-- src/modules/wmtheme.c | 9 +- 14 files changed, 255 insertions(+), 299 deletions(-) diff --git a/src/common/calculateGtk.c b/src/common/calculateGtk.c index cde0b7977..a20744c42 100644 --- a/src/common/calculateGtk.c +++ b/src/common/calculateGtk.c @@ -4,28 +4,34 @@ #include #include -static inline bool allPropertiesSet(FFstrbuf* themeNamePtr, FFstrbuf* iconsNamePtr, FFstrbuf* fontNamePtr) +static inline bool allPropertiesSet(FFgtkval* gtkval) { return - themeNamePtr->length > 0 && - iconsNamePtr->length > 0 && - fontNamePtr->length > 0; + gtkval->theme.length > 0 && + gtkval->icons.length > 0 && + gtkval->font.length > 0; } - -static inline void applyGTKDConfSettings(const gchar* themeName, FFstrbuf* themeNamePtr, const gchar* iconsName, FFstrbuf* iconsNamePtr, const gchar* fontName, FFstrbuf* fontNamePtr) +static inline void initGtkval(FFgtkval* gtkval) { - if(themeNamePtr->length == 0) - ffStrbufAppendS(themeNamePtr, themeName); - - if(iconsNamePtr->length == 0) - ffStrbufAppendS(iconsNamePtr, iconsName); - - if(fontNamePtr->length == 0) - ffStrbufAppendS(fontNamePtr, fontName); + ffStrbufInit(>kval->theme); + ffStrbufInit(>kval->icons); + ffStrbufInit(>kval->font); } -static void parseGTKDConfSettings(FFinstance* instance, FFstrbuf* themeNamePtr, FFstrbuf* iconsNamePtr, FFstrbuf* fontNamePtr) +static inline void applyGTKDConfSettings(FFgtkval* gtkval, const gchar* themeName, const gchar* iconsName, const gchar* fontName) +{ + if(gtkval->theme.length == 0) + ffStrbufAppendS(>kval->theme, themeName); + + if(gtkval->icons.length == 0) + ffStrbufAppendS(>kval->icons, iconsName); + + if(gtkval->font.length == 0) + ffStrbufAppendS(>kval->font, fontName); +} + +static void parseGTKDConfSettings(FFinstance* instance, FFgtkval* gtkval) { static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; @@ -39,7 +45,7 @@ static void parseGTKDConfSettings(FFinstance* instance, FFstrbuf* themeNamePtr, if(init) { - applyGTKDConfSettings(themeName, themeNamePtr, iconsName, iconsNamePtr, fontName, fontNamePtr); + applyGTKDConfSettings(gtkval, themeName, iconsName, fontName); pthread_mutex_unlock(&mutex); return; } @@ -96,11 +102,11 @@ static void parseGTKDConfSettings(FFinstance* instance, FFstrbuf* themeNamePtr, dlclose(dconf); - applyGTKDConfSettings(themeName, themeNamePtr, iconsName, iconsNamePtr, fontName, fontNamePtr); + applyGTKDConfSettings(gtkval, themeName, iconsName, fontName); pthread_mutex_unlock(&mutex); } -static void parseGTKConfigFile(FFstrbuf* fileName, FFstrbuf* themeNamePtr, FFstrbuf* iconsNamePtr, FFstrbuf* fontNamePtr) +static void parseGTKConfigFile(FFstrbuf* fileName, FFgtkval* gtkval) { FILE* file = fopen(fileName->chars, "r"); if(file == NULL) @@ -111,22 +117,22 @@ static void parseGTKConfigFile(FFstrbuf* fileName, FFstrbuf* themeNamePtr, FFstr while(getline(&line, &len, file) != -1) { - if(themeNamePtr->length == 0) + if(gtkval->theme.length == 0) { - sscanf(line, "gtk-theme-name=%[^\n]", themeNamePtr->chars); - sscanf(line, "gtk-theme-name=\"%[^\"]+", themeNamePtr->chars); + sscanf(line, "gtk-theme-name=%[^\n]", gtkval->theme.chars); + sscanf(line, "gtk-theme-name=\"%[^\"]+", gtkval->theme.chars); } - if(iconsNamePtr->length == 0) + if(gtkval->icons.length == 0) { - sscanf(line, "gtk-icon-theme-name=%[^\n]", iconsNamePtr->chars); - sscanf(line, "gtk-icon-theme-name=\"%[^\"]+", iconsNamePtr->chars); + sscanf(line, "gtk-icon-theme-name=%[^\n]", gtkval->icons.chars); + sscanf(line, "gtk-icon-theme-name=\"%[^\"]+", gtkval->icons.chars); } - if(fontNamePtr->length == 0) + if(gtkval->font.length == 0) { - sscanf(line, "gtk-font-name=%[^\n]", fontNamePtr->chars); - sscanf(line, "gtk-font-name=\"%[^\"]+", fontNamePtr->chars); + sscanf(line, "gtk-font-name=%[^\n]", gtkval->font.chars); + sscanf(line, "gtk-font-name=\"%[^\"]+", gtkval->font.chars); } } @@ -135,61 +141,61 @@ static void parseGTKConfigFile(FFstrbuf* fileName, FFstrbuf* themeNamePtr, FFstr fclose(file); - ffStrbufRecalculateLength(themeNamePtr); - ffStrbufRecalculateLength(iconsNamePtr); - ffStrbufRecalculateLength(fontNamePtr); + ffStrbufRecalculateLength(>kval->theme); + ffStrbufRecalculateLength(>kval->icons); + ffStrbufRecalculateLength(>kval->font); } -static void calculateGTKFromConfigDir(const char* configDir, const char* version, FFstrbuf* themeNamePtr, FFstrbuf* iconsNamePtr, FFstrbuf* fontNamePtr) +static void calculateGTKFromConfigDir(const char* configDir, const char* version, FFgtkval* gtkval) { // /gtk-.0/settings.ini FFstrbuf file1; ffStrbufInitA(&file1, 64); ffStrbufAppendS(&file1, configDir); - ffStrbufAppendS(&file1, "gtk-"); + ffStrbufAppendS(&file1, "/gtk-"); ffStrbufAppendS(&file1, version); ffStrbufAppendS(&file1, ".0/settings.ini"); - parseGTKConfigFile(&file1, themeNamePtr, iconsNamePtr, fontNamePtr); + parseGTKConfigFile(&file1, gtkval); ffStrbufDestroy(&file1); - if(allPropertiesSet(themeNamePtr, iconsNamePtr, fontNamePtr)) + if(allPropertiesSet(gtkval)) return; // /gtk-.0/gtkrc FFstrbuf file2; ffStrbufInitA(&file2, 64); ffStrbufAppendS(&file2, configDir); - ffStrbufAppendS(&file2, "gtk-"); + ffStrbufAppendS(&file2, "/gtk-"); ffStrbufAppendS(&file2, version); ffStrbufAppendS(&file2, ".0/gtkrc"); - parseGTKConfigFile(&file2, themeNamePtr, iconsNamePtr, fontNamePtr); + parseGTKConfigFile(&file2, gtkval); ffStrbufDestroy(&file2); - if(allPropertiesSet(themeNamePtr, iconsNamePtr, fontNamePtr)) + if(allPropertiesSet(gtkval)) return; // /gtkrc-.0 FFstrbuf file3; ffStrbufInitA(&file3, 64); ffStrbufAppendS(&file3, configDir); - ffStrbufAppendS(&file3, "gtkrc-"); + ffStrbufAppendS(&file3, "/gtkrc-"); ffStrbufAppendS(&file3, version); ffStrbufAppendS(&file3, ".0"); - parseGTKConfigFile(&file3, themeNamePtr, iconsNamePtr, fontNamePtr); + parseGTKConfigFile(&file3, gtkval); ffStrbufDestroy(&file3); - if(allPropertiesSet(themeNamePtr, iconsNamePtr, fontNamePtr)) + if(allPropertiesSet(gtkval)) return; // /.gtkrc-.0 FFstrbuf file4; ffStrbufInitA(&file4, 64); ffStrbufAppendS(&file4, configDir); - ffStrbufAppendS(&file4, ".gtkrc-"); + ffStrbufAppendS(&file4, "/.gtkrc-"); ffStrbufAppendS(&file4, version); ffStrbufAppendS(&file4, ".0"); - parseGTKConfigFile(&file4, themeNamePtr, iconsNamePtr, fontNamePtr); + parseGTKConfigFile(&file4, gtkval); ffStrbufDestroy(&file4); } -static void calculateGTK(FFinstance* instance, const char* version, FFstrbuf* themeNamePtr, FFstrbuf* iconsNamePtr, FFstrbuf* fontNamePtr) +static void calculateGTK(FFinstance* instance, const char* version, FFgtkval* gtkval) { static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; @@ -198,18 +204,19 @@ static void calculateGTK(FFinstance* instance, const char* version, FFstrbuf* th static bool xdgIsDifferent; static bool init = false; + initGtkval(gtkval); + pthread_mutex_lock(&mutex); if(!init) { ffStrbufInitA(&configDir, 64); ffStrbufAppendS(&configDir, instance->state.passwd->pw_dir); - ffStrbufAppendS(&configDir, "/.config/"); + ffStrbufAppendS(&configDir, "/.config"); ffStrbufInitA(&xdgConfigDir, 64); ffStrbufAppendS(&xdgConfigDir, getenv("XDG_CONFIG_HOME")); - if(xdgConfigDir.length > 0 && xdgConfigDir.chars[xdgConfigDir.length - 1] != '/') - ffStrbufAppendC(&xdgConfigDir, '/'); + ffStrbufTrimRight(&xdgConfigDir, '/'); xdgIsDifferent = ffStrbufComp(&configDir, &xdgConfigDir) != 0; @@ -220,81 +227,53 @@ static void calculateGTK(FFinstance* instance, const char* version, FFstrbuf* th if(xdgIsDifferent) { - calculateGTKFromConfigDir(xdgConfigDir.chars, version, themeNamePtr, iconsNamePtr, fontNamePtr); - if(allPropertiesSet(themeNamePtr, iconsNamePtr, fontNamePtr)) + // $XDG_CONFIG_HOME + calculateGTKFromConfigDir(xdgConfigDir.chars, version, gtkval); + if(allPropertiesSet(gtkval)) return; } - calculateGTKFromConfigDir(configDir.chars, version, themeNamePtr, iconsNamePtr, fontNamePtr); - if(allPropertiesSet(themeNamePtr, iconsNamePtr, fontNamePtr)) + // /home//.config + calculateGTKFromConfigDir(configDir.chars, version, gtkval); + if(allPropertiesSet(gtkval)) return; - // /gtkrc-.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); - if(allPropertiesSet(themeNamePtr, iconsNamePtr, fontNamePtr)) + // /home/ + calculateGTKFromConfigDir(instance->state.passwd->pw_dir, version, gtkval); + if(allPropertiesSet(gtkval)) return; - // /.gtkrc-.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); - if(allPropertiesSet(themeNamePtr, iconsNamePtr, fontNamePtr)) - return; - - parseGTKDConfSettings(instance, themeNamePtr, iconsNamePtr, fontNamePtr); - if(allPropertiesSet(themeNamePtr, iconsNamePtr, fontNamePtr)) + parseGTKDConfSettings(instance, gtkval); + if(allPropertiesSet(gtkval)) return; - calculateGTKFromConfigDir("/etc/", version, themeNamePtr, iconsNamePtr, fontNamePtr); + // /etc + calculateGTKFromConfigDir("/etc/", version, gtkval); } #define FF_CALCULATE_GTK_IMPL(version) \ static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; \ - static FFstrbuf themeName; \ - static FFstrbuf iconsName; \ - static FFstrbuf fontName; \ static bool init = false; \ - if(themeNamePtr != NULL) \ - *themeNamePtr = &themeName; \ - if(iconsNamePtr != NULL) \ - *iconsNamePtr = &iconsName; \ - if(fontNamePtr != NULL) \ - *fontNamePtr = &fontName; \ pthread_mutex_lock(&mutex); \ if(init){ \ pthread_mutex_unlock(&mutex);\ return; \ } \ init = true; \ - ffStrbufInit(&themeName); \ - ffStrbufInit(&iconsName); \ - ffStrbufInit(&fontName); \ - calculateGTK(instance, #version, &themeName, &iconsName, &fontName); \ + calculateGTK(instance, #version, &instance->state.gtk##version); \ pthread_mutex_unlock(&mutex); -void ffCalculateGTK2(FFinstance* instance, FFstrbuf** themeNamePtr, FFstrbuf** iconsNamePtr, FFstrbuf** fontNamePtr) +void ffCalculateGTK2(FFinstance* instance) { FF_CALCULATE_GTK_IMPL(2) } -void ffCalculateGTK3(FFinstance* instance, FFstrbuf** themeNamePtr, FFstrbuf** iconsNamePtr, FFstrbuf** fontNamePtr) +void ffCalculateGTK3(FFinstance* instance) { FF_CALCULATE_GTK_IMPL(3) } -void ffCalculateGTK4(FFinstance* instance, FFstrbuf** themeNamePtr, FFstrbuf** iconsNamePtr, FFstrbuf** fontNamePtr) +void ffCalculateGTK4(FFinstance* instance) { FF_CALCULATE_GTK_IMPL(4) } diff --git a/src/common/calculatePlasma.c b/src/common/calculatePlasma.c index 39da467e6..0050e8b7e 100644 --- a/src/common/calculatePlasma.c +++ b/src/common/calculatePlasma.c @@ -11,28 +11,11 @@ typedef enum PlasmaCategory PLASMA_CATEGORY_OTHER } PlasmaCategory; -void ffCalculatePlasma(FFinstance* instance, FFstrbuf** themeNamePtr, FFstrbuf** colorNamePtr, FFstrbuf** iconsNamePtr, FFstrbuf** fontNamePtr) +void ffCalculatePlasma(FFinstance* instance) { static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; - - static FFstrbuf themeName; - static FFstrbuf colorName; - static FFstrbuf iconsName; - static FFstrbuf fontName; static bool init = false; - if(themeNamePtr != NULL) - *themeNamePtr = &themeName; - - if(colorNamePtr != NULL) - *colorNamePtr = &colorName; - - if(iconsNamePtr != NULL) - *iconsNamePtr = &iconsName; - - if(fontNamePtr != NULL) - *fontNamePtr = &fontName; - pthread_mutex_lock(&mutex); if(init) @@ -43,10 +26,10 @@ void ffCalculatePlasma(FFinstance* instance, FFstrbuf** themeNamePtr, FFstrbuf** init = true; - ffStrbufInit(&themeName); - ffStrbufInit(&colorName); - ffStrbufInit(&iconsName); - ffStrbufInit(&fontName); + ffStrbufInit(&instance->state.plasma.widgetStyle); + ffStrbufInit(&instance->state.plasma.colorScheme); + ffStrbufInit(&instance->state.plasma.icons); + ffStrbufInit(&instance->state.plasma.font); FF_STRBUF_CREATE(kdeglobalsFile); ffStrbufAppendS(&kdeglobalsFile, instance->state.passwd->pw_dir); @@ -86,28 +69,28 @@ void ffCalculatePlasma(FFinstance* instance, FFstrbuf** themeNamePtr, FFstrbuf** if(category == PLASMA_CATEGORY_KDE) { - sscanf(line, "widgetStyle=%[^\n]", themeName.chars); - sscanf(line, "widgetStyle=\"%[^\"]+", themeName.chars); + sscanf(line, "widgetStyle=%[^\n]", instance->state.plasma.widgetStyle.chars); + sscanf(line, "widgetStyle=\"%[^\"]+", instance->state.plasma.widgetStyle.chars); } else if(category == PLASMA_CATEGORY_GENERAL) { - sscanf(line, "ColorScheme=%[^\n]", colorName.chars); - sscanf(line, "ColorScheme=\"%[^\"]+", colorName.chars); + sscanf(line, "ColorScheme=%[^\n]", instance->state.plasma.colorScheme.chars); + sscanf(line, "ColorScheme=\"%[^\"]+", instance->state.plasma.colorScheme.chars); - sscanf(line, "font=%[^\n]", fontName.chars); - sscanf(line, "font=\"%[^\"]+", fontName.chars); + sscanf(line, "font=%[^\n]", instance->state.plasma.font.chars); + sscanf(line, "font=\"%[^\"]+", instance->state.plasma.font.chars); } else if(category == PLASMA_CATEGORY_ICONS) { - sscanf(line, "Theme=%[^\n]", iconsName.chars); - sscanf(line, "Theme=\"%[^\"]+", iconsName.chars); + sscanf(line, "Theme=%[^\n]", instance->state.plasma.icons.chars); + sscanf(line, "Theme=\"%[^\"]+", instance->state.plasma.icons.chars); } } - ffStrbufRecalculateLength(&themeName); - ffStrbufRecalculateLength(&colorName); - ffStrbufRecalculateLength(&iconsName); - ffStrbufRecalculateLength(&fontName); + ffStrbufRecalculateLength(&instance->state.plasma.widgetStyle); + ffStrbufRecalculateLength(&instance->state.plasma.colorScheme); + ffStrbufRecalculateLength(&instance->state.plasma.icons); + ffStrbufRecalculateLength(&instance->state.plasma.font); if(line != NULL) free(line); @@ -117,17 +100,17 @@ void ffCalculatePlasma(FFinstance* instance, FFstrbuf** themeNamePtr, FFstrbuf** //In Plasma the default value is never set in the config file, but the whole key-value is discarded. ///We must set these values by our self if the file exists (it always does here) - if(themeName.length == 0) - ffStrbufAppendS(&themeName, "Breeze"); + if(instance->state.plasma.widgetStyle.length == 0) + ffStrbufAppendS(&instance->state.plasma.widgetStyle, "Breeze"); - if(colorName.length == 0) - ffStrbufAppendS(&colorName, "BreezeLight"); + if(instance->state.plasma.colorScheme.length == 0) + ffStrbufAppendS(&instance->state.plasma.colorScheme, "BreezeLight"); - if(iconsName.length == 0) - ffStrbufAppendS(&iconsName, "Breeze"); + if(instance->state.plasma.icons.length == 0) + ffStrbufAppendS(&instance->state.plasma.icons, "Breeze"); - if(fontName.length == 0) - ffStrbufAppendS(&fontName, "Noto Sans, 10"); + if(instance->state.plasma.font.length == 0) + ffStrbufAppendS(&instance->state.plasma.font, "Noto Sans, 10"); pthread_mutex_unlock(&mutex); } diff --git a/src/common/calculateTerminal.c b/src/common/calculateTerminal.c index 95fadcc53..87b934640 100644 --- a/src/common/calculateTerminal.c +++ b/src/common/calculateTerminal.c @@ -4,7 +4,7 @@ #include #include -static void getTerminalName(FFinstance* instance, const char* pid, FFstrbuf* exeName, FFstrbuf* processName, FFstrbuf* error) +static void getTerminalName(FFinstance* instance, const char* pid) { char statFile[234]; sprintf(statFile, "/proc/%s/stat", pid); @@ -12,7 +12,7 @@ static void getTerminalName(FFinstance* instance, const char* pid, FFstrbuf* exe FILE* stat = fopen(statFile, "r"); if(stat == NULL) { - ffStrbufSetF(error, "fopen(\"%s\", \"r\") == NULL", statFile); + ffStrbufSetF(&instance->state.terminal.error, "fopen(\"%s\", \"r\") == NULL", statFile); return; } @@ -20,7 +20,7 @@ static void getTerminalName(FFinstance* instance, const char* pid, FFstrbuf* exe char ppid[256]; if(fscanf(stat, "%*s (%[^)])%*s%s", name, ppid) != 2) { - ffStrbufSetS(error, "fscanf(stat, \"%*s (%[^)])%*s%s\", name, ppid) != 2"); + ffStrbufSetS(&instance->state.terminal.error, "fscanf(stat, \"%*s (%[^)])%*s%s\", name, ppid) != 2"); return; } @@ -37,38 +37,25 @@ static void getTerminalName(FFinstance* instance, const char* pid, FFstrbuf* exe strcasecmp(name, "doas") == 0 || strcasecmp(name, "strace") == 0 ) { - getTerminalName(instance, ppid, exeName, processName, error); + getTerminalName(instance, ppid); return; } char cmdlineFile[234]; sprintf(cmdlineFile, "/proc/%s/cmdline", pid); - ffGetFileContent(cmdlineFile, exeName); - ffStrbufSubstrBeforeFirstC(exeName, '\0'); - ffStrbufSubstrAfterLastC(exeName, '/'); + ffGetFileContent(cmdlineFile, &instance->state.terminal.exeName); + ffStrbufSubstrBeforeFirstC(&instance->state.terminal.exeName, '\0'); + ffStrbufSubstrAfterLastC(&instance->state.terminal.exeName, '/'); - ffStrbufSetS(processName, name); + ffStrbufSetS(&instance->state.terminal.processName, name); } -void ffCalculateTerminal(FFinstance* instance, FFstrbuf** exeNamePtr, FFstrbuf** processNamePtr, FFstrbuf** errorPtr) +void ffCalculateTerminal(FFinstance* instance) { static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; - - static FFstrbuf exeName; - static FFstrbuf processName; - static FFstrbuf error; static bool init = false; - if(exeNamePtr != NULL) - *exeNamePtr = &exeName; - - if(processNamePtr != NULL) - *processNamePtr = &processName; - - if(errorPtr != NULL) - *errorPtr = &error; - pthread_mutex_lock(&mutex); if(init) @@ -78,14 +65,14 @@ void ffCalculateTerminal(FFinstance* instance, FFstrbuf** exeNamePtr, FFstrbuf** } init = true; - ffStrbufInit(&exeName); - ffStrbufInit(&processName); - ffStrbufInit(&error); + ffStrbufInit(&instance->state.terminal.exeName); + ffStrbufInit(&instance->state.terminal.processName); + ffStrbufInit(&instance->state.terminal.error); char ppid[256]; sprintf(ppid, "%i", getppid()); - getTerminalName(instance, ppid, &exeName, &processName, &error); + getTerminalName(instance, ppid); pthread_mutex_unlock(&mutex); } diff --git a/src/common/calculateWM.c b/src/common/calculateWM.c index 49d12cce4..a8283a833 100644 --- a/src/common/calculateWM.c +++ b/src/common/calculateWM.c @@ -3,26 +3,11 @@ #include #include -void ffCalculateWM(FFinstance* instance, FFstrbuf** prettyNamePtr, FFstrbuf** processNamePtr, FFstrbuf** errorPtr) +void ffCalculateWM(FFinstance* instance) { - UNUSED(instance); - static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; - - static FFstrbuf prettyName; - static FFstrbuf processName; - static FFstrbuf error; static bool init = false; - if(prettyNamePtr != NULL) - *prettyNamePtr = &prettyName; - - if(processNamePtr != NULL) - *processNamePtr = &processName; - - if(errorPtr != NULL) - *errorPtr = &error; - pthread_mutex_lock(&mutex); if(init) @@ -33,14 +18,14 @@ void ffCalculateWM(FFinstance* instance, FFstrbuf** prettyNamePtr, FFstrbuf** pr init = true; - ffStrbufInit(&prettyName); - ffStrbufInit(&processName); - ffStrbufInit(&error); + ffStrbufInit(&instance->state.wm.processName); + ffStrbufInit(&instance->state.wm.prettyName); + ffStrbufInit(&instance->state.wm.error); DIR* proc = opendir("/proc/"); if(proc == NULL) { - ffStrbufSetS(&error, "opendir(\"/proc/\") == NULL"); + ffStrbufSetS(&instance->state.wm.error, "opendir(\"/proc/\") == NULL"); pthread_mutex_unlock(&mutex); return; } @@ -55,19 +40,22 @@ void ffCalculateWM(FFinstance* instance, FFstrbuf** prettyNamePtr, FFstrbuf** pr char path[20]; sprintf(path, "/proc/%.8s/comm", dirent->d_name); - ffGetFileContent(path, &processName); + ffGetFileContent(path, &instance->state.wm.processName); - if(ffStrbufIgnCaseCompS(&processName, "kwin_wayland") == 0 || ffStrbufIgnCaseCompS(&processName, "kwin_x11") == 0) - ffStrbufSetS(&prettyName, "KWin"); + if(ffStrbufIgnCaseCompS(&instance->state.wm.processName, "kwin_wayland") == 0 || ffStrbufIgnCaseCompS(&instance->state.wm.processName, "kwin_x11") == 0) + ffStrbufSetS(&instance->state.wm.prettyName, "KWin"); - if(prettyName.length > 0) + if(instance->state.wm.prettyName.length > 0) break; } closedir(proc); - if(prettyName.length == 0) - ffStrbufSetS(&error, "No process name matches the name of known display managers"); + if(instance->state.wm.prettyName.length == 0) + { + ffStrbufSetS(&instance->state.wm.error, "No process name matches the name of known display managers"); + ffStrbufClear(&instance->state.wm.processName); + } pthread_mutex_unlock(&mutex); } diff --git a/src/common/init.c b/src/common/init.c index 67fc42b49..a057cd1f5 100644 --- a/src/common/init.c +++ b/src/common/init.c @@ -83,6 +83,14 @@ void ffInitInstance(FFinstance* instance) ffCacheValidate(instance); } +void ffCalculatePlasmaAndGtk(FFinstance* instance) +{ + ffCalculatePlasma(instance); + ffCalculateGTK2(instance); + ffCalculateGTK3(instance); + ffCalculateGTK3(instance); +} + static void ffCleanup(FFinstance* instance) { UNUSED(instance); diff --git a/src/common/threading.c b/src/common/threading.c index 4f0694a9f..e75115de0 100644 --- a/src/common/threading.c +++ b/src/common/threading.c @@ -4,37 +4,37 @@ static inline void* calculatePlasmaThreadMain(void* instance) { - ffCalculatePlasma((FFinstance*)instance, NULL, NULL, NULL, NULL); + ffCalculatePlasma((FFinstance*)instance); return NULL; } static inline void* calculateGTK2ThreadMain(void* instance) { - ffCalculateGTK2((FFinstance*)instance, NULL, NULL, NULL); + ffCalculateGTK2((FFinstance*)instance); return NULL; } static inline void* calculateGTK3ThreadMain(void* instance) { - ffCalculateGTK3((FFinstance*)instance, NULL, NULL, NULL); + ffCalculateGTK3((FFinstance*)instance); return NULL; } static inline void* calculateGTK4ThreadMain(void* instance) { - ffCalculateGTK4((FFinstance*)instance, NULL, NULL, NULL); + ffCalculateGTK4((FFinstance*)instance); return NULL; } static inline void* calculateWMThreadMain(void* instance) { - ffCalculateWM((FFinstance*)instance, NULL, NULL, NULL); + ffCalculateWM((FFinstance*)instance); return NULL; } static inline void* calculateTerminalThreadMain(void* instance) { - ffCalculateTerminal((FFinstance*)instance, NULL, NULL, NULL); + ffCalculateTerminal((FFinstance*)instance); return NULL; } diff --git a/src/fastfetch.h b/src/fastfetch.h index 11437fb84..097f59ef3 100644 --- a/src/fastfetch.h +++ b/src/fastfetch.h @@ -99,12 +99,48 @@ typedef struct FFconfig } FFconfig; +typedef struct FFgtkval +{ + FFstrbuf theme; + FFstrbuf icons; + FFstrbuf font; +} FFgtkval; + typedef struct FFstate { uint8_t current_row; struct passwd* passwd; struct utsname utsname; struct sysinfo sysinfo; + + //Values needed in more than one module / calculated together / calculated in extra threads + + struct + { + FFstrbuf widgetStyle; + FFstrbuf colorScheme; + FFstrbuf icons; + FFstrbuf font; + } plasma; + + FFgtkval gtk2; + FFgtkval gtk3; + FFgtkval gtk4; + + struct + { + FFstrbuf exeName; + FFstrbuf processName; + FFstrbuf error; + } terminal; + + struct + { + FFstrbuf processName; + FFstrbuf prettyName; + FFstrbuf error; + } wm; + } FFstate; typedef struct FFinstance @@ -143,6 +179,7 @@ typedef struct FFcache //common/init.c void ffInitInstance(FFinstance* instance); void ffFinish(FFinstance* instance); +void ffCalculatePlasmaAndGtk(FFinstance* instance); //common/threading.c void ffStartCalculationThreads(FFinstance* instance); @@ -186,18 +223,18 @@ void ffGetFont(const char* font, FFstrbuf* name, double* size); void ffGetFontPretty(FFstrbuf* buffer, const FFstrbuf* name, double size); //common/calculatePlasma.c -void ffCalculatePlasma(FFinstance* instance, FFstrbuf** themeNamePtr, FFstrbuf** colorNamePtr, FFstrbuf** iconsNamePtr, FFstrbuf** fontNamePtr); +void ffCalculatePlasma(FFinstance* instance); //common/calculateGTK.c -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 ffCalculateGTK2(FFinstance* instance); +void ffCalculateGTK4(FFinstance* instance); +void ffCalculateGTK3(FFinstance* instance); //common/calculateWM.c -void ffCalculateWM(FFinstance* instance, FFstrbuf** prettyNamePtr, FFstrbuf** processNamePtr, FFstrbuf** errorPtr); +void ffCalculateWM(FFinstance* instance); //common/calculateTerminal.c -void ffCalculateTerminal(FFinstance* instance, FFstrbuf** exeNamePtr, FFstrbuf** processNamePtr, FFstrbuf** errorPtr); +void ffCalculateTerminal(FFinstance* instance); /********************/ /* Module functions */ diff --git a/src/modules/font.c b/src/modules/font.c index e5fa60b6b..c3537fa7f 100644 --- a/src/modules/font.c +++ b/src/modules/font.c @@ -5,19 +5,9 @@ void ffPrintFont(FFinstance* instance) { - FFstrbuf* plasma; - ffCalculatePlasma(instance, NULL, NULL, NULL, &plasma); + ffCalculatePlasmaAndGtk(instance); - FFstrbuf* gtk2; - ffCalculateGTK2(instance, NULL, NULL, >k2); - - FFstrbuf* gtk3; - ffCalculateGTK3(instance, NULL, NULL, >k3); - - FFstrbuf* gtk4; - ffCalculateGTK4(instance, NULL, NULL, >k4); - - if(plasma->length == 0 && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0) + if(instance->state.plasma.font.length == 0 && instance->state.gtk2.font.length == 0 && instance->state.gtk3.font.length == 0 && instance->state.gtk4.font.length == 0) { ffPrintError(instance, FF_FONT_MODULE_NAME, 0, &instance->config.fontKey, &instance->config.fontFormat, FF_FONT_NUM_FORMAT_ARGS, "No fonts found"); return; @@ -25,25 +15,25 @@ void ffPrintFont(FFinstance* instance) FF_STRBUF_CREATE(plasmaName); double plasmaSize; - ffGetFont(plasma->chars, &plasmaName, &plasmaSize); + ffGetFont(instance->state.plasma.font.chars, &plasmaName, &plasmaSize); FF_STRBUF_CREATE(plasmaPretty); ffGetFontPretty(&plasmaPretty, &plasmaName, plasmaSize); FF_STRBUF_CREATE(gtk2Name); double gtk2Size; - ffGetFont(gtk2->chars, >k2Name, >k2Size); + ffGetFont(instance->state.gtk2.font.chars, >k2Name, >k2Size); FF_STRBUF_CREATE(gtk2Pretty); ffGetFontPretty(>k2Pretty, >k2Name, gtk2Size); FF_STRBUF_CREATE(gtk3Name); double gtk3Size; - ffGetFont(gtk3->chars, >k3Name, >k3Size); + ffGetFont(instance->state.gtk3.font.chars, >k3Name, >k3Size); FF_STRBUF_CREATE(gtk3Pretty); ffGetFontPretty(>k3Pretty, >k3Name, gtk3Size); FF_STRBUF_CREATE(gtk4Name); double gtk4Size; - ffGetFont(gtk4->chars, >k4Name, >k4Size); + ffGetFont(instance->state.gtk4.font.chars, >k4Name, >k4Size); FF_STRBUF_CREATE(gtk4Pretty); ffGetFontPretty(>k4Pretty, >k4Name, gtk4Size); @@ -53,7 +43,7 @@ void ffPrintFont(FFinstance* instance) if(instance->config.fontFormat.length == 0) { ffPrintLogoAndKey(instance, FF_FONT_MODULE_NAME, 0, &instance->config.fontKey); - if(plasma->length > 0) + if(instance->state.plasma.font.length > 0) { ffStrbufWriteTo(&plasmaPretty, stdout); fputs(" [Plasma]", stdout); @@ -66,19 +56,19 @@ void ffPrintFont(FFinstance* instance) else { ffPrintFormatString(instance, FF_FONT_MODULE_NAME, 0, &instance->config.fontKey, &instance->config.fontFormat, NULL, FF_FONT_NUM_FORMAT_ARGS, (FFformatarg[]){ - {FF_FORMAT_ARG_TYPE_STRBUF, plasma}, + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.plasma.font}, {FF_FORMAT_ARG_TYPE_STRBUF, &plasmaName}, {FF_FORMAT_ARG_TYPE_DOUBLE, &plasmaSize}, {FF_FORMAT_ARG_TYPE_STRBUF, &plasmaPretty}, - {FF_FORMAT_ARG_TYPE_STRBUF, gtk2}, + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.gtk2.font}, {FF_FORMAT_ARG_TYPE_STRBUF, >k2Name}, {FF_FORMAT_ARG_TYPE_DOUBLE, >k2Size}, {FF_FORMAT_ARG_TYPE_STRBUF, >k2Pretty}, - {FF_FORMAT_ARG_TYPE_STRBUF, gtk3}, + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.gtk3.font}, {FF_FORMAT_ARG_TYPE_STRBUF, >k3Name}, {FF_FORMAT_ARG_TYPE_DOUBLE, >k3Size}, {FF_FORMAT_ARG_TYPE_STRBUF, >k3Pretty}, - {FF_FORMAT_ARG_TYPE_STRBUF, gtk4}, + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.gtk4.font}, {FF_FORMAT_ARG_TYPE_STRBUF, >k4Name}, {FF_FORMAT_ARG_TYPE_DOUBLE, >k4Size}, {FF_FORMAT_ARG_TYPE_STRBUF, >k4Pretty}, diff --git a/src/modules/icons.c b/src/modules/icons.c index 6eeb2bda6..564bd02f9 100644 --- a/src/modules/icons.c +++ b/src/modules/icons.c @@ -5,34 +5,24 @@ void ffPrintIcons(FFinstance* instance) { - FFstrbuf* plasma; - ffCalculatePlasma(instance, NULL, NULL, &plasma, NULL); + ffCalculatePlasmaAndGtk(instance); - FFstrbuf* gtk2; - ffCalculateGTK2(instance, NULL, >k2, NULL); - - FFstrbuf* gtk3; - ffCalculateGTK3(instance, NULL, >k3, NULL); - - FFstrbuf* gtk4; - ffCalculateGTK4(instance, NULL, >k4, NULL); - - if(plasma->length == 0 && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0) + if(instance->state.plasma.icons.length == 0 && instance->state.gtk2.icons.length == 0 && instance->state.gtk3.icons.length == 0 && instance->state.gtk4.icons.length == 0) { ffPrintError(instance, FF_ICONS_MODULE_NAME, 0, &instance->config.iconsKey, &instance->config.iconsFormat, FF_ICONS_NUM_FORMAT_ARGS, "No icons could be found"); return; } FF_STRBUF_CREATE(gtkPretty); - ffGetGtkPretty(>kPretty, gtk2, gtk3, gtk4); + ffGetGtkPretty(>kPretty, &instance->state.gtk2.icons, &instance->state.gtk3.icons, &instance->state.gtk4.icons); if(instance->config.iconsFormat.length == 0) { ffPrintLogoAndKey(instance, FF_ICONS_MODULE_NAME, 0, &instance->config.iconsKey); - if(plasma->length > 0) + if(instance->state.plasma.icons.length > 0) { - ffStrbufWriteTo(plasma, stdout); + ffStrbufWriteTo(&instance->state.plasma.icons, stdout); fputs(" [Plasma]", stdout); if(gtkPretty.length > 0) @@ -44,10 +34,10 @@ void ffPrintIcons(FFinstance* instance) else { ffPrintFormatString(instance, FF_ICONS_MODULE_NAME, 0, &instance->config.iconsKey, &instance->config.iconsFormat, NULL, FF_ICONS_NUM_FORMAT_ARGS, (FFformatarg[]){ - {FF_FORMAT_ARG_TYPE_STRBUF, plasma}, - {FF_FORMAT_ARG_TYPE_STRBUF, gtk2}, - {FF_FORMAT_ARG_TYPE_STRBUF, gtk3}, - {FF_FORMAT_ARG_TYPE_STRBUF, gtk4}, + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.plasma.icons}, + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.gtk2.icons}, + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.gtk3.icons}, + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.gtk4.icons}, {FF_FORMAT_ARG_TYPE_STRBUF, >kPretty} }); } diff --git a/src/modules/terminal.c b/src/modules/terminal.c index 30d590601..0a89bc30d 100644 --- a/src/modules/terminal.c +++ b/src/modules/terminal.c @@ -5,24 +5,26 @@ void ffPrintTerminal(FFinstance* instance) { - FFstrbuf* exeName; - FFstrbuf* processName; - FFstrbuf* error; + ffCalculateTerminal(instance); - ffCalculateTerminal(instance, &exeName, &processName, &error); - - if(error->length > 0) + if(instance->state.terminal.error.length > 0) { - ffPrintError(instance, FF_TERMINAL_MODULE_NAME, 0, &instance->config.terminalKey, &instance->config.terminalFormat, FF_TERMINAL_NUM_FORMAT_ARGS, error->chars); + ffPrintError(instance, FF_TERMINAL_MODULE_NAME, 0, &instance->config.terminalKey, &instance->config.terminalFormat, FF_TERMINAL_NUM_FORMAT_ARGS, instance->state.terminal.error.chars); + return; + } + + if(instance->state.terminal.exeName.length == 0 && instance->state.terminal.processName.length == 0) + { + ffPrintError(instance, FF_TERMINAL_MODULE_NAME, 0, &instance->config.terminalKey, &instance->config.terminalFormat, FF_TERMINAL_NUM_FORMAT_ARGS, "Terminal names not set"); return; } FFstrbuf* name; - if(ffStrbufStartsWith(exeName, processName)) - name = exeName; + if(ffStrbufStartsWith(&instance->state.terminal.exeName, &instance->state.terminal.processName)) + name = &instance->state.terminal.exeName; else - name = processName; + name = &instance->state.terminal.processName; if(instance->config.terminalFormat.length == 0) { @@ -32,8 +34,8 @@ void ffPrintTerminal(FFinstance* instance) else { ffPrintFormatString(instance, FF_TERMINAL_MODULE_NAME, 0, &instance->config.terminalKey, &instance->config.terminalFormat, NULL, FF_TERMINAL_NUM_FORMAT_ARGS, (FFformatarg[]){ - {FF_FORMAT_ARG_TYPE_STRBUF, exeName}, - {FF_FORMAT_ARG_TYPE_STRBUF, processName}, + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.terminal.exeName}, + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.terminal.processName}, {FF_FORMAT_ARG_TYPE_STRBUF, name} }); } diff --git a/src/modules/terminalfont.c b/src/modules/terminalfont.c index 3fd5ab415..8d680ca73 100644 --- a/src/modules/terminalfont.c +++ b/src/modules/terminalfont.c @@ -68,19 +68,18 @@ static void printTTY(FFinstance* instance) void ffPrintTerminalFont(FFinstance* instance) { - FFstrbuf* terminalExeName; - ffCalculateTerminal(instance, &terminalExeName, NULL, NULL); + ffCalculateTerminal(instance); - if(terminalExeName->length == 0) + if(instance->state.terminal.exeName.length == 0) { ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.termFontKey, &instance->config.termFontFormat, FF_TERMFONT_NUM_FORMAT_ARGS, "Terminal font needs successfull terminal detection"); return; } - if(ffStrbufIgnCaseCompS(terminalExeName, "konsole") == 0) + if(ffStrbufIgnCaseCompS(&instance->state.terminal.exeName, "konsole") == 0) printKonsole(instance); - else if(ffStrbufIgnCaseCompS(terminalExeName, "login") == 0) + else if(ffStrbufStartsWithIgnCaseS(&instance->state.terminal.exeName, "login") == 0) printTTY(instance); else - ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.termFontKey, &instance->config.termFontFormat, FF_TERMFONT_NUM_FORMAT_ARGS, "Terminal Font", "Unknown terminal: %s", terminalExeName->chars); + ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.termFontKey, &instance->config.termFontFormat, FF_TERMFONT_NUM_FORMAT_ARGS, "Terminal Font", "Unknown terminal: %s", instance->state.terminal.exeName.chars); } diff --git a/src/modules/theme.c b/src/modules/theme.c index 6ce0a675c..8bb11f51d 100644 --- a/src/modules/theme.c +++ b/src/modules/theme.c @@ -5,65 +5,54 @@ void ffPrintTheme(FFinstance* instance) { - FFstrbuf* plasmaTheme; - FFstrbuf* plasmaColor; - ffCalculatePlasma(instance, &plasmaTheme, &plasmaColor, NULL, NULL); + ffCalculatePlasmaAndGtk(instance); - FFstrbuf* gtk2; - ffCalculateGTK2(instance, >k2, NULL, NULL); - - FFstrbuf* gtk3; - ffCalculateGTK3(instance, >k3, NULL, NULL); - - FFstrbuf* gtk4; - ffCalculateGTK4(instance, >k4, NULL, NULL); - - if(plasmaTheme->length == 0 && plasmaColor->length == 0 && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0) + if(instance->state.plasma.widgetStyle.length == 0 && instance->state.plasma.colorScheme.length == 0 && instance->state.gtk2.theme.length == 0 && instance->state.gtk3.theme.length == 0 && instance->state.gtk4.theme.length == 0) { ffPrintError(instance, FF_THEME_MODULE_NAME, 0, &instance->config.themeKey, &instance->config.themeFormat, FF_THEME_NUM_FORMAT_ARGS, "No themes found"); return; } FF_STRBUF_CREATE(plasmaColorPretty); - if(ffStrbufStartsWithIgnCase(plasmaColor, plasmaTheme)) - ffStrbufAppendNS(&plasmaColorPretty, plasmaColor->length - plasmaTheme->length, &plasmaColor->chars[plasmaTheme->length]); + if(ffStrbufStartsWithIgnCase(&instance->state.plasma.colorScheme, &instance->state.plasma.widgetStyle)) + ffStrbufAppendNS(&plasmaColorPretty, instance->state.plasma.colorScheme.length - instance->state.plasma.widgetStyle.length, &instance->state.plasma.colorScheme.chars[instance->state.plasma.widgetStyle.length]); else - ffStrbufAppend(&plasmaColorPretty, plasmaColor); + ffStrbufAppend(&plasmaColorPretty, &instance->state.plasma.colorScheme); ffStrbufTrim(&plasmaColorPretty, ' '); FF_STRBUF_CREATE(gtkPretty); - ffGetGtkPretty(>kPretty, gtk2, gtk3, gtk4); + ffGetGtkPretty(>kPretty, &instance->state.gtk2.theme, &instance->state.gtk3.theme, &instance->state.gtk4.theme); if(instance->config.themeFormat.length == 0) { ffPrintLogoAndKey(instance, FF_THEME_MODULE_NAME, 0, &instance->config.themeKey); - if(plasmaTheme->length > 0) + if(instance->state.plasma.widgetStyle.length > 0) { - ffStrbufWriteTo(plasmaTheme, stdout); + ffStrbufWriteTo(&instance->state.plasma.widgetStyle, stdout); - if(plasmaColor->length > 0) + if(instance->state.plasma.colorScheme.length > 0) { fputs(" (", stdout); if(plasmaColorPretty.length > 0) ffStrbufWriteTo(&plasmaColorPretty, stdout); else - ffStrbufWriteTo(plasmaColor, stdout); + ffStrbufWriteTo(&instance->state.plasma.colorScheme, stdout); putchar(')'); } } - else if(plasmaColor->length > 0) + else if(instance->state.plasma.colorScheme.length > 0) { if(plasmaColorPretty.length > 0) ffStrbufWriteTo(&plasmaColorPretty, stdout); else - ffStrbufWriteTo(plasmaColor, stdout); + ffStrbufWriteTo(&instance->state.plasma.colorScheme, stdout); } - if(plasmaTheme->length > 0 || plasmaColor->length > 0) + if(instance->state.plasma.widgetStyle.length > 0 || instance->state.plasma.colorScheme.length > 0) { fputs(" [Plasma]", stdout); @@ -76,12 +65,12 @@ void ffPrintTheme(FFinstance* instance) else { ffPrintFormatString(instance, FF_THEME_MODULE_NAME, 0, &instance->config.themeKey, &instance->config.themeFormat, NULL, FF_THEME_NUM_FORMAT_ARGS, (FFformatarg[]){ - {FF_FORMAT_ARG_TYPE_STRBUF, plasmaTheme}, - {FF_FORMAT_ARG_TYPE_STRBUF, plasmaColor}, + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.plasma.widgetStyle}, + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.plasma.colorScheme}, {FF_FORMAT_ARG_TYPE_STRBUF, &plasmaColorPretty}, - {FF_FORMAT_ARG_TYPE_STRBUF, gtk2}, - {FF_FORMAT_ARG_TYPE_STRBUF, gtk3}, - {FF_FORMAT_ARG_TYPE_STRBUF, gtk4}, + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.gtk2.theme}, + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.gtk3.theme}, + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.gtk4.theme}, {FF_FORMAT_ARG_TYPE_STRBUF, >kPretty} }); } diff --git a/src/modules/wm.c b/src/modules/wm.c index 6942f4c12..6e8b0dad7 100644 --- a/src/modules/wm.c +++ b/src/modules/wm.c @@ -5,28 +5,33 @@ void ffPrintWM(FFinstance* instance) { - FFstrbuf* prettyName; - FFstrbuf* processName; - FFstrbuf* error; + ffCalculateWM(instance); - ffCalculateWM(instance, &prettyName, &processName, &error); - - if(error->length > 0) + if(instance->state.wm.error.length > 0) { - ffPrintError(instance, FF_WM_MODULE_NAME, 0, &instance->config.wmKey, &instance->config.wmFormat, FF_WM_NUM_FORMAT_ARGS, error->chars); + ffPrintError(instance, FF_WM_MODULE_NAME, 0, &instance->config.wmKey, &instance->config.wmFormat, FF_WM_NUM_FORMAT_ARGS, instance->state.wm.error.chars); + return; + } + + if(instance->state.wm.prettyName.length == 0 && instance->state.wm.processName.length == 0) + { + ffPrintError(instance, FF_WM_MODULE_NAME, 0, &instance->config.wmKey, &instance->config.wmFormat, FF_WM_NUM_FORMAT_ARGS, "No wm name provided"); return; } if(instance->config.wmFormat.length == 0) { ffPrintLogoAndKey(instance, "WM", 0, &instance->config.wmKey); - ffStrbufPutTo(prettyName, stdout); + if(instance->state.wm.prettyName.length > 0) + ffStrbufPutTo(&instance->state.wm.prettyName, stdout); + else + ffStrbufPutTo(&instance->state.wm.processName, stdout); } else { ffPrintFormatString(instance, FF_WM_MODULE_NAME, 0, &instance->config.wmKey, &instance->config.wmFormat, NULL, FF_WM_NUM_FORMAT_ARGS, (FFformatarg[]){ - {FF_FORMAT_ARG_TYPE_STRBUF, processName}, - {FF_FORMAT_ARG_TYPE_STRBUF, prettyName} + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.wm.processName}, + {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.wm.prettyName} }); } } diff --git a/src/modules/wmtheme.c b/src/modules/wmtheme.c index 31165d615..158da7739 100644 --- a/src/modules/wmtheme.c +++ b/src/modules/wmtheme.c @@ -35,17 +35,16 @@ static void printKWin(FFinstance* instance) void ffPrintWMTheme(FFinstance* instance) { - FFstrbuf* wmName; - ffCalculateWM(instance, &wmName, NULL, NULL); + ffCalculateWM(instance); - if(wmName->length == 0) + if(instance->state.wm.prettyName.length == 0) { ffPrintError(instance, FF_WMTHEME_MODULE_NAME, 0, &instance->config.wmThemeKey, &instance->config.wmThemeFormat, FF_WMTHEME_NUM_FORMAT_ARGS, "WM Theme needs sucessfull WM detection"); return; } - if(ffStrbufIgnCaseCompS(wmName, "KWin") == 0) + if(ffStrbufIgnCaseCompS(&instance->state.wm.prettyName, "KWin") == 0) printKWin(instance); else - ffPrintError(instance, FF_WMTHEME_MODULE_NAME, 0, &instance->config.wmThemeKey, &instance->config.wmThemeFormat, FF_WMTHEME_NUM_FORMAT_ARGS, "Unknown WM: %s", wmName->chars); + ffPrintError(instance, FF_WMTHEME_MODULE_NAME, 0, &instance->config.wmThemeKey, &instance->config.wmThemeFormat, FF_WMTHEME_NUM_FORMAT_ARGS, "Unknown WM: %s", instance->state.wm.prettyName.chars); }