supprt for custom / multiple config dirs

src/common/detectGTK.c

@@ -171,84 +171,22 @@ static void detectGTK(FFinstance* instance, const char* version, const char* env
         return;
     }
 
-    //From DIR: XDG_CONFIG_HOME
+    //From config dirs
 
-    const char* xdgConfigHome = getenv("XDG_CONFIG_HOME");
-    ffStrbufSetS(&buffer, xdgConfigHome);
-    detectGTKFromConfigDir(&buffer, version, result);
-    if(allPropertiesSet(result))
+    //We need to do this because we use multiple threads on configDirs
+    FFstrbuf baseDirCopy;
+    ffStrbufInitA(&baseDirCopy, 64);
+
+    for(uint32_t i = 0; i < instance->state.configDirs.length; i++)
     {
-        ffStrbufDestroy(&buffer);
-        return;
-    }
-
-    //From DIRs: XDG_CONFIG_DIRS
-
-    ffStrbufSetS(&buffer, getenv("XDG_CONFIG_DIRS"));
-    lastIndex = 0;
-    while (lastIndex < buffer.length)
-    {
-        uint32_t colonIndex = ffStrbufFirstIndexAfterC(&buffer, lastIndex, ':');
-        buffer.chars[colonIndex] = '\0';
-
-        FFstrbuf configDir;
-        ffStrbufInitA(&configDir, 64);
-        ffStrbufAppendS(&configDir, buffer.chars + lastIndex);
-
-        detectGTKFromConfigDir(&configDir, version, result);
-
-        ffStrbufDestroy(&configDir);
-
+        FFstrbuf* baseDir = (FFstrbuf*) ffListGet(&instance->state.configDirs, i);
+        ffStrbufSet(&baseDirCopy, baseDir);
+        detectGTKFromConfigDir(&baseDirCopy, version, result);
         if(allPropertiesSet(result))
-        {
-            ffStrbufDestroy(&buffer);
-            return;
-        }
-
-        lastIndex = colonIndex + 1;
+            break;
     }
 
-    //From DIR: ~/.config/
-
-    ffStrbufSetS(&buffer, instance->state.passwd->pw_dir);
-    lastIndex = buffer.length;
-
-    ffStrbufAppendS(&buffer, "/.config");
-    if(ffStrbufCompS(&buffer, xdgConfigHome) != 0)
-    {
-        detectGTKFromConfigDir(&buffer, version, result);
-        if(allPropertiesSet(result))
-        {
-            ffStrbufDestroy(&buffer);
-            return;
-        }
-    }
-
-    //From DIR: ~/
-
-    ffStrbufSubstrBefore(&buffer, lastIndex);
-    detectGTKFromConfigDir(&buffer, version, result);
-    if(allPropertiesSet(result))
-    {
-        ffStrbufDestroy(&buffer);
-        return;
-    }
-
-    //From DIR: /etc/xdg/
-
-    ffStrbufSetS(&buffer, "/etc/xdg");
-    detectGTKFromConfigDir(&buffer, version, result);
-    if(allPropertiesSet(result))
-    {
-        ffStrbufDestroy(&buffer);
-        return;
-    }
-
-    //From DIR: /etc/
-
-    ffStrbufSetS(&buffer, "/etc");
-    detectGTKFromConfigDir(&buffer, version, result);
-
+    ffStrbufDestroy(&baseDirCopy);
     ffStrbufDestroy(&buffer);
 }
 

src/common/detectPlasma.c

@@ -11,35 +11,11 @@ typedef enum PlasmaCategory
     PLASMA_CATEGORY_OTHER
 } PlasmaCategory;
 
-const FFPlasmaResult* ffDetectPlasma(FFinstance* instance)
+static bool detectFromConfigFile(const FFstrbuf* filename, FFPlasmaResult* result)
 {
-    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-    static FFPlasmaResult result;
-    static bool init = false;
-    pthread_mutex_lock(&mutex);
-    if(init)
-    {
-        pthread_mutex_unlock(&mutex);
-        return &result;
-    }
-    init = true;
-
-    ffStrbufInit(&result.widgetStyle);
-    ffStrbufInit(&result.colorScheme);
-    ffStrbufInit(&result.icons);
-    ffStrbufInit(&result.font);
-
-    FF_STRBUF_CREATE(kdeglobalsFile);
-    ffStrbufAppendS(&kdeglobalsFile, instance->state.passwd->pw_dir);
-    ffStrbufAppendS(&kdeglobalsFile, "/.config/kdeglobals");
-
-    FILE* kdeglobals = fopen(kdeglobalsFile.chars, "r");
+    FILE* kdeglobals = fopen(filename->chars, "r");
     if(kdeglobals == NULL)
-    {
-        ffStrbufDestroy(&kdeglobalsFile);
-        pthread_mutex_unlock(&mutex);
-        return &result;
-    }
+        return false;
 
     char* line = NULL;
     size_t len = 0;
@@ -67,34 +43,86 @@ const FFPlasmaResult* ffDetectPlasma(FFinstance* instance)
 
         if(category == PLASMA_CATEGORY_KDE)
         {
-            sscanf(line, "widgetStyle=%[^\n]", result.widgetStyle.chars);
-            sscanf(line, "widgetStyle=\"%[^\"]+", result.widgetStyle.chars);
+            sscanf(line, "widgetStyle=%[^\n]", result->widgetStyle.chars);
+            sscanf(line, "widgetStyle=\"%[^\"]+", result->widgetStyle.chars);
         }
         else if(category == PLASMA_CATEGORY_GENERAL)
         {
-            sscanf(line, "ColorScheme=%[^\n]", result.colorScheme.chars);
-            sscanf(line, "ColorScheme=\"%[^\"]+", result.colorScheme.chars);
+            sscanf(line, "ColorScheme=%[^\n]", result->colorScheme.chars);
+            sscanf(line, "ColorScheme=\"%[^\"]+", result->colorScheme.chars);
 
-            sscanf(line, "font=%[^\n]", result.font.chars);
-            sscanf(line, "font=\"%[^\"]+", result.font.chars);
+            sscanf(line, "font=%[^\n]", result->font.chars);
+            sscanf(line, "font=\"%[^\"]+", result->font.chars);
         }
         else if(category == PLASMA_CATEGORY_ICONS)
         {
-            sscanf(line, "Theme=%[^\n]", result.icons.chars);
-            sscanf(line, "Theme=\"%[^\"]+", result.icons.chars);
+            sscanf(line, "Theme=%[^\n]", result->icons.chars);
+            sscanf(line, "Theme=\"%[^\"]+", result->icons.chars);
         }
     }
 
-    ffStrbufRecalculateLength(&result.widgetStyle);
-    ffStrbufRecalculateLength(&result.colorScheme);
-    ffStrbufRecalculateLength(&result.icons);
-    ffStrbufRecalculateLength(&result.font);
+    ffStrbufRecalculateLength(&result->widgetStyle);
+    ffStrbufRecalculateLength(&result->colorScheme);
+    ffStrbufRecalculateLength(&result->icons);
+    ffStrbufRecalculateLength(&result->font);
 
     if(line != NULL)
         free(line);
 
     fclose(kdeglobals);
-    ffStrbufDestroy(&kdeglobalsFile);
+
+    return true;
+}
+
+const FFPlasmaResult* ffDetectPlasma(FFinstance* instance)
+{
+    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+    static FFPlasmaResult result;
+    static bool init = false;
+    pthread_mutex_lock(&mutex);
+    if(init)
+    {
+        pthread_mutex_unlock(&mutex);
+        return &result;
+    }
+    init = true;
+
+    ffStrbufInit(&result.widgetStyle);
+    ffStrbufInit(&result.colorScheme);
+    ffStrbufInit(&result.icons);
+    ffStrbufInit(&result.font);
+
+    bool foundAFile = false;
+
+    //We need to do this because we use multiple threads on configDirs
+    FFstrbuf baseDirCopy;
+    ffStrbufInitA(&baseDirCopy, 64);
+
+    for(uint32_t i = 0; i < instance->state.configDirs.length; i++)
+    {
+        FFstrbuf* baseDir = (FFstrbuf*) ffListGet(&instance->state.configDirs, i);
+
+        ffStrbufSet(&baseDirCopy, baseDir);
+        ffStrbufAppendS(&baseDirCopy, "/kdeglobals");
+
+        if(detectFromConfigFile(&baseDirCopy, &result))
+            foundAFile = true;
+
+        if(
+            result.widgetStyle.length > 0 &&
+            result.colorScheme.length > 0 &&
+            result.icons.length > 0 &&
+            result.font.length > 0
+        ) break;
+    }
+
+    ffStrbufDestroy(&baseDirCopy);
+
+    if(!foundAFile)
+    {
+        pthread_mutex_unlock(&mutex);
+        return &result;
+    }
 
     //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)
@@ -111,6 +139,5 @@ const FFPlasmaResult* ffDetectPlasma(FFinstance* instance)
         ffStrbufAppendS(&result.font, "Noto Sans, 10");
 
     pthread_mutex_unlock(&mutex);
-
     return &result;
 }

src/common/init.c

@@ -2,12 +2,76 @@
 
 #include <unistd.h>
 
+static bool strbufEqualsAdapter(const void* first, const void* second)
+{
+    return ffStrbufComp(second, first) == 0;
+}
+
+static void initConfigDirs(FFstate* state)
+{
+    ffListInit(&state->configDirs, sizeof(FFstrbuf));
+
+    const char* xdgConfigHome = getenv("XDG_CONFIG_HOME");
+    if(xdgConfigHome != NULL)
+    {
+        FFstrbuf* buffer = (FFstrbuf*) ffListAdd(&state->configDirs);
+        ffStrbufInitA(buffer, 64);
+        ffStrbufAppendS(buffer, xdgConfigHome);
+        ffStrbufTrimRight(buffer, '/');
+    }
+
+    FFstrbuf xdgConfigDirs;
+    ffStrbufInitAS(&xdgConfigDirs, 64, getenv("XDG_CONFIG_DIRS"));
+    uint32_t lastIndex = 0;
+    while (lastIndex < xdgConfigDirs.length)
+    {
+        uint32_t colonIndex = ffStrbufFirstIndexAfterC(&xdgConfigDirs, lastIndex, ':');
+        xdgConfigDirs.chars[colonIndex] = '\0';
+
+        FFstrbuf* buffer = (FFstrbuf*) ffListAdd(&state->configDirs);
+        ffStrbufInitA(buffer, 64);
+        ffStrbufAppendS(buffer, xdgConfigDirs.chars + lastIndex);
+        ffStrbufTrimRight(buffer, '/');
+
+        lastIndex = colonIndex + 1;
+    }
+
+    #define FF_ENSURE_ONLY_ONCE_IN_LIST(element) \
+        if(ffListFirstIndexComp(&state->configDirs, element, strbufEqualsAdapter) < state->configDirs.length - 1) \
+            --state->configDirs.length;
+
+    FFstrbuf* userConfigHome = ffListAdd(&state->configDirs);
+    ffStrbufInitA(userConfigHome, 64);
+    ffStrbufAppendS(userConfigHome, state->passwd->pw_dir);
+    ffStrbufAppendS(userConfigHome, "/.config");
+    FF_ENSURE_ONLY_ONCE_IN_LIST(userConfigHome)
+
+    FFstrbuf* userHome = ffListAdd(&state->configDirs);
+    ffStrbufInitA(userHome, 64);
+    ffStrbufAppendS(userHome, state->passwd->pw_dir);
+    FF_ENSURE_ONLY_ONCE_IN_LIST(userHome)
+
+    FFstrbuf* systemConfigHome = ffListAdd(&state->configDirs);
+    ffStrbufInitA(systemConfigHome, 64);
+    ffStrbufAppendS(systemConfigHome, "/etc/xdg");
+    FF_ENSURE_ONLY_ONCE_IN_LIST(systemConfigHome)
+
+    FFstrbuf* systemConfig = ffListAdd(&state->configDirs);
+    ffStrbufInitA(systemConfig, 64);
+    ffStrbufAppendS(systemConfig, "/etc");
+    FF_ENSURE_ONLY_ONCE_IN_LIST(systemConfig)
+
+    #undef FF_ENSURE_ONLY_ONCE_IN_LIST
+}
+
 static void initState(FFstate* state)
 {
     state->current_row = 0;
     state->passwd = getpwuid(getuid());
     uname(&state->utsname);
     sysinfo(&state->sysinfo);
+
+    initConfigDirs(state);
 }
 
 static void defaultConfig(FFconfig* config)

src/common/io.c

@@ -364,6 +364,32 @@ bool ffParsePropFileHome(FFinstance* instance, const char* relativeFile, const c
     return result;
 }
 
+bool ffParsePropFileConfig(FFinstance* instance, const char* relativeFile, const char* regex, char* buffer)
+{
+    bool foundAFile = false;
+
+    for(uint32_t i = 0; i < instance->state.configDirs.length; i++)
+    {
+        FFstrbuf* baseDir = (FFstrbuf*) ffListGet(&instance->state.configDirs, i);
+        uint32_t baseDirLength = baseDir->length;
+
+        if(*relativeFile != '/')
+            ffStrbufAppendC(baseDir, '/');
+
+        ffStrbufAppendS(baseDir, relativeFile);
+
+        if(ffParsePropFile(baseDir->chars, regex, buffer))
+            foundAFile = true;
+
+        ffStrbufSubstrBefore(baseDir, baseDirLength);
+
+        if(*buffer != '\0')
+            return foundAFile;
+    }
+
+    return foundAFile;
+}
+
 bool ffWriteFDContent(int fd, const FFstrbuf* content)
 {
     return write(fd, content->chars, content->length) != -1;