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

global results are now stored in state

Browse Source
This commit is contained in:
Linus Dierheimer
2021-04-16 20:22:38 +02:00
parent 86abc05cd4
commit 7b65316483
14 changed files with 255 additions and 299 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/common/calculateGtk.c
+70 -91
View File
@@ -4,28 +4,34 @@
#include <pthread.h>
#include <dconf/client/dconf-client.h>
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(&gtkval->theme);
ffStrbufInit(&gtkval->icons);
ffStrbufInit(&gtkval->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(&gtkval->theme, themeName);
if(gtkval->icons.length == 0)
ffStrbufAppendS(&gtkval->icons, iconsName);
if(gtkval->font.length == 0)
ffStrbufAppendS(&gtkval->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(&gtkval->theme);
ffStrbufRecalculateLength(&gtkval->icons);
ffStrbufRecalculateLength(&gtkval->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)
{
// <configdir>/gtk-<version>.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;
// <configdir>/gtk-<version>.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;
// <configdir>/gtkrc-<version>.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;
// <configdir>/.gtkrc-<version>.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/<user>/.config
calculateGTKFromConfigDir(configDir.chars, version, gtkval);
if(allPropertiesSet(gtkval))
return;
// <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);
if(allPropertiesSet(themeNamePtr, iconsNamePtr, fontNamePtr))
// /home/<user>
calculateGTKFromConfigDir(instance->state.passwd->pw_dir, version, gtkval);
if(allPropertiesSet(gtkval))
return;
// <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);
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)
}
src/common/calculatePlasma.c
+25 -42
View File
@@ -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);
}
src/common/calculateTerminal.c
+13 -26
View File
@@ -4,7 +4,7 @@
#include <unistd.h>
#include <pthread.h>
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);
}
src/common/calculateWM.c
+14 -26
View File
@@ -3,26 +3,11 @@
#include <dirent.h>
#include <pthread.h>
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);
}
src/common/init.c
+8
View File
@@ -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);
src/common/threading.c
+6 -6
View File
@@ -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;
}
src/fastfetch.h
+43 -6
View File
@@ -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 */
src/modules/font.c
+11 -21
View File
@@ -5,19 +5,9 @@
void ffPrintFont(FFinstance* instance)
{
FFstrbuf* plasma;
ffCalculatePlasma(instance, NULL, NULL, NULL, &plasma);
ffCalculatePlasmaAndGtk(instance);
FFstrbuf* gtk2;
ffCalculateGTK2(instance, NULL, NULL, &gtk2);
FFstrbuf* gtk3;
ffCalculateGTK3(instance, NULL, NULL, &gtk3);
FFstrbuf* gtk4;
ffCalculateGTK4(instance, NULL, NULL, &gtk4);
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, &gtk2Name, &gtk2Size);
ffGetFont(instance->state.gtk2.font.chars, &gtk2Name, &gtk2Size);
FF_STRBUF_CREATE(gtk2Pretty);
ffGetFontPretty(&gtk2Pretty, &gtk2Name, gtk2Size);
FF_STRBUF_CREATE(gtk3Name);
double gtk3Size;
ffGetFont(gtk3->chars, &gtk3Name, &gtk3Size);
ffGetFont(instance->state.gtk3.font.chars, &gtk3Name, &gtk3Size);
FF_STRBUF_CREATE(gtk3Pretty);
ffGetFontPretty(&gtk3Pretty, &gtk3Name, gtk3Size);
FF_STRBUF_CREATE(gtk4Name);
double gtk4Size;
ffGetFont(gtk4->chars, &gtk4Name, &gtk4Size);
ffGetFont(instance->state.gtk4.font.chars, &gtk4Name, &gtk4Size);
FF_STRBUF_CREATE(gtk4Pretty);
ffGetFontPretty(&gtk4Pretty, &gtk4Name, 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, &gtk2Name},
{FF_FORMAT_ARG_TYPE_DOUBLE, &gtk2Size},
{FF_FORMAT_ARG_TYPE_STRBUF, &gtk2Pretty},
{FF_FORMAT_ARG_TYPE_STRBUF, gtk3},
{FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.gtk3.font},
{FF_FORMAT_ARG_TYPE_STRBUF, &gtk3Name},
{FF_FORMAT_ARG_TYPE_DOUBLE, &gtk3Size},
{FF_FORMAT_ARG_TYPE_STRBUF, &gtk3Pretty},
{FF_FORMAT_ARG_TYPE_STRBUF, gtk4},
{FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.gtk4.font},
{FF_FORMAT_ARG_TYPE_STRBUF, &gtk4Name},
{FF_FORMAT_ARG_TYPE_DOUBLE, &gtk4Size},
{FF_FORMAT_ARG_TYPE_STRBUF, &gtk4Pretty},
src/modules/icons.c
+9 -19
View File
@@ -5,34 +5,24 @@
void ffPrintIcons(FFinstance* instance)
{
FFstrbuf* plasma;
ffCalculatePlasma(instance, NULL, NULL, &plasma, NULL);
ffCalculatePlasmaAndGtk(instance);
FFstrbuf* gtk2;
ffCalculateGTK2(instance, NULL, &gtk2, NULL);
FFstrbuf* gtk3;
ffCalculateGTK3(instance, NULL, &gtk3, NULL);
FFstrbuf* gtk4;
ffCalculateGTK4(instance, NULL, &gtk4, 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(&gtkPretty, gtk2, gtk3, gtk4);
ffGetGtkPretty(&gtkPretty, &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, &gtkPretty}
});
}
src/modules/terminal.c
+14 -12
View File
@@ -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}
});
}
src/modules/terminalfont.c
+5 -6
View File
@@ -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);
}
src/modules/theme.c
+18 -29
View File
@@ -5,65 +5,54 @@
void ffPrintTheme(FFinstance* instance)
{
FFstrbuf* plasmaTheme;
FFstrbuf* plasmaColor;
ffCalculatePlasma(instance, &plasmaTheme, &plasmaColor, NULL, NULL);
ffCalculatePlasmaAndGtk(instance);
FFstrbuf* gtk2;
ffCalculateGTK2(instance, &gtk2, NULL, NULL);
FFstrbuf* gtk3;
ffCalculateGTK3(instance, &gtk3, NULL, NULL);
FFstrbuf* gtk4;
ffCalculateGTK4(instance, &gtk4, 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(&gtkPretty, gtk2, gtk3, gtk4);
ffGetGtkPretty(&gtkPretty, &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, &gtkPretty}
});
}
src/modules/wm.c
+15 -10
View File
@@ -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}
});
}
}
src/modules/wmtheme.c
+4 -5
View File
@@ -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);
}