Add the files

1 files changed, 545 insertions, 0 deletions

diff --git a/src/detection/terminalfont/terminalfont_linux.c b/src/detection/terminalfont/terminalfont_linux.c
new file mode 100644
index 0000000..bfc8959
--- /dev/null
+++ b/src/detection/terminalfont/terminalfont_linux.c
@@ -0,0 +1,545 @@
+#include "common/font.h"
+#include "terminalfont.h"
+#include "common/settings.h"
+#include "common/properties.h"
+#include "common/parsing.h"
+#include "common/io.h"
+#include "common/processing.h"
+#include "common/mallocHelper.h"
+#include "common/strutil.h"
+#include "common/binary.h"
+#include "detection/terminalshell/terminalshell.h"
+#include "detection/displayserver/displayserver.h"
+
+static const char* getSystemMonospaceFont(void) {
+    const FFDisplayServerResult* wmde = ffConnectDisplayServer();
+
+    if (ffStrbufIgnCaseEqualS(&wmde->dePrettyName, "Cinnamon")) {
+        const char* systemMonospaceFont = ffSettingsGetGnome("/org/cinnamon/desktop/interface/monospace-font-name", "org.cinnamon.desktop.interface", NULL, "monospace-font-name", FF_VARIANT_TYPE_STRING).strValue;
+        if (ffStrSet(systemMonospaceFont)) {
+            return systemMonospaceFont;
+        }
+    } else if (ffStrbufIgnCaseEqualS(&wmde->dePrettyName, "Mate")) {
+        const char* systemMonospaceFont = ffSettingsGetGnome("/org/mate/interface/monospace-font-name", "org.mate.interface", NULL, "monospace-font-name", FF_VARIANT_TYPE_STRING).strValue;
+        if (ffStrSet(systemMonospaceFont)) {
+            return systemMonospaceFont;
+        }
+    }
+
+    return ffSettingsGetGnome("/org/gnome/desktop/interface/monospace-font-name", "org.gnome.desktop.interface", NULL, "monospace-font-name", FF_VARIANT_TYPE_STRING).strValue;
+}
+
+static void detectKgx(FFTerminalFontResult* terminalFont) {
+    // kgx (gnome console) doesn't support profiles
+    if (!ffSettingsGetGnome("/org/gnome/Console/use-system-font", "org.gnome.Console", NULL, "use-system-font", FF_VARIANT_TYPE_BOOL).boolValue) {
+        FF_AUTO_FREE const char* fontName = ffSettingsGetGnome("/org/gnome/Console/custom-font", "org.gnome.Console", NULL, "custom-font", FF_VARIANT_TYPE_STRING).strValue;
+        if (ffStrSet(fontName)) {
+            ffFontInitPango(&terminalFont->font, fontName);
+        } else {
+            ffStrbufAppendF(&terminalFont->error, "Couldn't get terminal font from GSettings (org.gnome.Console::custom-font)");
+        }
+    } else {
+        FF_AUTO_FREE const char* fontName = getSystemMonospaceFont();
+        if (ffStrSet(fontName)) {
+            ffFontInitPango(&terminalFont->font, fontName);
+        } else {
+            ffStrbufAppendS(&terminalFont->error, "Couldn't get system monospace font name from GSettings / DConf");
+        }
+    }
+}
+
+static void detectPtyxis(FFTerminalFontResult* terminalFont) {
+    if (!ffSettingsGetGnome("/org/gnome/Ptyxis/use-system-font", "org.gnome.Ptyxis", NULL, "use-system-font", FF_VARIANT_TYPE_BOOL).boolValue) {
+        FF_AUTO_FREE const char* fontName = ffSettingsGetGnome("/org/gnome/Ptyxis/font-name", "org.gnome.Ptyxis", NULL, "font-name", FF_VARIANT_TYPE_STRING).strValue;
+        if (ffStrSet(fontName)) {
+            ffFontInitPango(&terminalFont->font, fontName);
+        } else {
+            ffStrbufAppendF(&terminalFont->error, "Couldn't get terminal font from GSettings (org.gnome.Ptyxis::font-name)");
+        }
+    } else {
+        FF_AUTO_FREE const char* fontName = getSystemMonospaceFont();
+        if (ffStrSet(fontName)) {
+            ffFontInitPango(&terminalFont->font, fontName);
+        } else {
+            ffStrbufAppendS(&terminalFont->error, "Couldn't get system monospace font name from GSettings / DConf");
+        }
+    }
+}
+
+static void detectFromGSettings(const char* profilePath, const char* profileList, const char* profile, const char* defaultProfileKey, FFTerminalFontResult* terminalFont) {
+    FF_AUTO_FREE const char* defaultProfile = ffSettingsGetGSettings(profileList, NULL, defaultProfileKey, FF_VARIANT_TYPE_STRING).strValue;
+    if (!ffStrSet(defaultProfile)) {
+        ffStrbufAppendF(&terminalFont->error, "Could not get default profile from gsettings: %s", profileList);
+        return;
+    }
+
+    FF_STRBUF_AUTO_DESTROY path = ffStrbufCreateA(128);
+    ffStrbufAppendS(&path, profilePath);
+    ffStrbufAppendS(&path, defaultProfile);
+    ffStrbufAppendC(&path, '/');
+
+    if (!ffSettingsGetGSettings(profile, path.chars, "use-system-font", FF_VARIANT_TYPE_BOOL).boolValue) {
+        FF_AUTO_FREE const char* fontName = ffSettingsGetGSettings(profile, path.chars, "font", FF_VARIANT_TYPE_STRING).strValue;
+        if (ffStrSet(fontName)) {
+            ffFontInitPango(&terminalFont->font, fontName);
+        } else {
+            ffStrbufAppendF(&terminalFont->error, "Couldn't get terminal font from GSettings (%s::%s::font)", profile, path.chars);
+        }
+    } else {
+        FF_AUTO_FREE const char* fontName = getSystemMonospaceFont();
+        if (ffStrSet(fontName)) {
+            ffFontInitPango(&terminalFont->font, fontName);
+        } else {
+            ffStrbufAppendS(&terminalFont->error, "Couldn't get system monospace font name from GSettings / DConf");
+        }
+    }
+}
+
+static void detectFromConfigFile(const char* configFile, const char* start, FFTerminalFontResult* terminalFont) {
+    FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
+    ffParsePropFileConfig(configFile, start, &fontName);
+
+    if (fontName.length == 0) {
+        ffStrbufAppendF(&terminalFont->error, "Couldn't find %s in .config/%s", start, configFile);
+    } else {
+        ffFontInitPango(&terminalFont->font, fontName.chars);
+    }
+}
+
+static void detectKonsole(FFTerminalFontResult* terminalFont, const char* rcFile) {
+    FF_STRBUF_AUTO_DESTROY profile = ffStrbufCreate();
+    if (!ffParsePropFileConfig(rcFile, "DefaultProfile =", &profile)) {
+        ffStrbufAppendF(&terminalFont->error, "Configuration \".config/%s\" doesn't exist", rcFile);
+        return;
+    }
+
+    if (profile.length == 0) {
+        ffStrbufAppendS(&terminalFont->error, "Built-in profile is used");
+        return;
+    }
+
+    FF_STRBUF_AUTO_DESTROY profilePath = ffStrbufCreateA(32);
+    ffStrbufAppendS(&profilePath, "konsole/");
+    ffStrbufAppend(&profilePath, &profile);
+
+    FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
+    ffParsePropFileData(profilePath.chars, "Font =", &fontName);
+
+    if (fontName.length == 0) {
+        ffStrbufAppendF(&terminalFont->error, "Couldn't find \"Font=%%[^\\n]\" in \"%s\"", profilePath.chars);
+    } else {
+        ffFontInitQt(&terminalFont->font, fontName.chars);
+    }
+}
+
+static void detectXFCETerminal(FFTerminalFontResult* terminalFont) {
+    FF_STRBUF_AUTO_DESTROY useSysFont = ffStrbufCreate();
+    FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
+
+    const char* path = "xfce4/xfconf/xfce-perchannel-xml/xfce4-terminal.xml";
+    bool configFound = ffParsePropFileConfigValues(path, 2, (FFpropquery[]) { { "<property name=\"font-use-system\" type=\"bool\" value=\"", &useSysFont }, { "<property name=\"font-name\" type=\"string\" value=\"", &fontName } });
+
+    if (configFound) {
+        ffStrbufSubstrBeforeLastC(&useSysFont, '"');
+        ffStrbufSubstrBeforeLastC(&fontName, '"');
+    } else {
+        path = "xfce4/terminal/terminalrc";
+        configFound = ffParsePropFileConfigValues(path, 2, (FFpropquery[]) { { "FontUseSystem = ", &useSysFont }, { "FontName = ", &fontName } });
+    }
+
+    if (configFound && (useSysFont.length == 0 || ffStrbufIgnCaseEqualS(&useSysFont, "false"))) {
+        if (fontName.length == 0) {
+            ffStrbufAppendF(&terminalFont->error, "Couldn't find FontName in %s", path);
+        } else {
+            ffFontInitPango(&terminalFont->font, fontName.chars);
+        }
+    } else {
+        const char* systemFontName = ffSettingsGetXFConf("xsettings", "/Gtk/MonospaceFontName", FF_VARIANT_TYPE_STRING).strValue;
+        if (ffStrSet(systemFontName)) {
+            ffFontInitPango(&terminalFont->font, systemFontName);
+        } else {
+            ffStrbufAppendS(&terminalFont->error, "Couldn't find xsettings::/Gtk/MonospaceFontName in XFConf");
+        }
+    }
+}
+
+static void detectDeepinTerminal(FFTerminalFontResult* terminalFont) {
+    FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
+    FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
+
+    FF_STRBUF_AUTO_DESTROY profile = ffStrbufCreateA(64);
+    ffSearchUserConfigFile(&instance.state.platform.configDirs, "deepin/deepin-terminal/config.conf", &profile);
+    FILE* file = fopen(profile.chars, "r");
+
+    if (file) {
+        char* line = NULL;
+        size_t len = 0;
+
+        for (int count = 0; getline(&line, &len, file) != -1 && count < 2;) {
+            if (ffStrEquals(line, "[basic.interface.font]\n")) {
+                if (getline(&line, &len, file) != -1) {
+                    ffParsePropLine(line, "value=", &fontName);
+                }
+                ++count;
+            } else if (ffStrEquals(line, "[basic.interface.font_size]\n")) {
+                if (getline(&line, &len, file) != -1) {
+                    ffParsePropLine(line, "value=", &fontSize);
+                }
+                ++count;
+            }
+        }
+
+        free(line);
+        fclose(file);
+    }
+
+    if (fontName.length == 0) {
+        ffStrbufAppendS(&fontName, "Noto Sans Mono");
+    }
+    if (fontSize.length == 0) {
+        ffStrbufAppendS(&fontSize, "11");
+    }
+
+    ffFontInitValues(&terminalFont->font, fontName.chars, fontSize.chars);
+}
+
+static void detectFootTerminal(FFTerminalFontResult* terminalFont) {
+    FF_STRBUF_AUTO_DESTROY font = ffStrbufCreate();
+
+    if (!ffParsePropFileConfig("foot/foot.ini", "font=", &font) || !ffStrSet(font.chars)) {
+        ffFontInitValues(&terminalFont->font, "monospace", "8");
+        return;
+    }
+
+    // Sarasa Term SC Nerd:size=8
+    uint32_t colon = ffStrbufFirstIndexC(&font, ':');
+    if (colon == font.length) {
+        ffFontInitValues(&terminalFont->font, font.chars, "8");
+        return;
+    }
+    uint32_t equal = ffStrbufNextIndexS(&font, colon, "size=");
+    font.chars[colon] = '\0';
+    if (equal == font.length) {
+        ffFontInitValues(&terminalFont->font, font.chars, "8");
+        return;
+    }
+    uint32_t size = equal + (uint32_t) strlen("size=");
+    uint32_t comma = ffStrbufNextIndexC(&font, size, ',');
+    if (comma < font.length) {
+        font.chars[comma] = '\0';
+    }
+    ffFontInitValues(&terminalFont->font, font.chars, &font.chars[size]);
+    if (comma < font.length) {
+        ffFontInitValues(&terminalFont->fallback, &font.chars[comma + 1], NULL);
+    }
+}
+
+static void detectQTerminal(FFTerminalFontResult* terminalFont) {
+    FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
+    FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
+
+    ffParsePropFileConfigValues("qterminal.org/qterminal.ini", 2, (FFpropquery[]) {
+                                                                      { "fontFamily=", &fontName },
+                                                                      { "fontSize=", &fontSize },
+                                                                  });
+
+    if (fontName.length == 0) {
+        ffStrbufAppendS(&fontName, "monospace");
+    }
+    if (fontSize.length == 0) {
+        ffStrbufAppendS(&fontSize, "12");
+    }
+    ffFontInitValues(&terminalFont->font, fontName.chars, fontSize.chars);
+}
+
+static void detectXterm(FFTerminalFontResult* terminalFont) {
+    FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
+    FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
+
+    ffParsePropFileHomeValues(".Xresources", 2, (FFpropquery[]) {
+                                                    { "xterm*faceName:", &fontName },
+                                                    { "xterm*faceSize:", &fontSize },
+                                                });
+
+    if (fontName.length == 0) {
+        ffParsePropFileHomeValues(".Xresources", 2, (FFpropquery[]) {
+                                                        { "xterm.vt100.faceName:", &fontName },
+                                                        { "xterm.vt100.faceSize:", &fontSize },
+                                                    });
+    }
+
+    if (fontName.length == 0) {
+        ffStrbufAppendS(&fontName, "fixed");
+    }
+    if (fontSize.length == 0) {
+        ffStrbufAppendS(&fontSize, "8.0");
+    }
+    ffFontInitValues(&terminalFont->font, fontName.chars, fontSize.chars);
+}
+
+static bool extractStTermFont(const char* str, FF_A_UNUSED uint32_t len, void* userdata) {
+    if (!ffStrContains(str, "size=")) {
+        return true;
+    }
+    ffStrbufSetNS((FFstrbuf*) userdata, len, str);
+    return false;
+}
+
+static void detectSt(FFTerminalFontResult* terminalFont, const FFTerminalResult* terminal) {
+    FF_STRBUF_AUTO_DESTROY size = ffStrbufCreateF("/proc/%u/cmdline", terminal->pid);
+    FF_STRBUF_AUTO_DESTROY font = ffStrbufCreate();
+    if (!ffAppendFileBuffer(size.chars, &font)) {
+        ffStrbufAppendF(&terminalFont->error, "Failed to open %s", size.chars);
+        return;
+    }
+
+    const char* p = memmem(font.chars, font.length, "\0-f", sizeof("\0-f")); // find parameter of `-f`
+    if (p) {
+        // st was executed with `-f` parameter
+        ffStrbufSubstrAfter(&font, (uint32_t) (p + (sizeof("\0-f") - 1) - font.chars));
+        ffStrbufRecalculateLength(&font);
+    } else {
+        ffStrbufClear(&font);
+
+        const char* error = ffBinaryExtractStrings(terminal->exePath.chars, extractStTermFont, &font, (uint32_t) strlen("size=0"));
+        if (error) {
+            ffStrbufAppendS(&terminalFont->error, error);
+            return;
+        }
+        if (font.length == 0) {
+            ffStrbufAppendS(&terminalFont->error, "No font config found in st binary");
+            return;
+        }
+    }
+
+    // JetBrainsMono Nerd Font Mono:pixelsize=12:antialias=true:autohint=true
+
+    uint32_t index = ffStrbufFirstIndexC(&font, ':');
+    if (index != font.length) {
+        uint32_t sIndex = ffStrbufNextIndexS(&font, index + 1, "size=");
+        if (sIndex != font.length) {
+            sIndex += (uint32_t) strlen("size=");
+            uint32_t sIndexEnd = ffStrbufNextIndexC(&font, sIndex, ':');
+            ffStrbufSetNS(&size, sIndexEnd - sIndex, font.chars + sIndex);
+        }
+        ffStrbufSubstrBefore(&font, index);
+    } else {
+        ffStrbufClear(&size);
+    }
+    ffFontInitValues(&terminalFont->font, font.chars, size.chars);
+}
+
+static void detectWarp(FFTerminalFontResult* terminalFont) {
+    FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateA(64);
+
+    FF_LIST_FOR_EACH (FFstrbuf, dirPrefix, instance.state.platform.configDirs) {
+        // We need to copy the dir each time, because it used by multiple threads, so we can't directly write to it.
+        ffStrbufSet(&baseDir, dirPrefix);
+        ffStrbufAppendS(&baseDir, "warp-terminal/user_preferences.json");
+
+        yyjson_doc* doc = yyjson_read_file(baseDir.chars, YYJSON_READ_INSITU | YYJSON_READ_ALLOW_TRAILING_COMMAS | YYJSON_READ_ALLOW_COMMENTS, NULL, NULL);
+        if (!doc) {
+            continue;
+        }
+
+        yyjson_val* prefs = yyjson_obj_get(yyjson_doc_get_root(doc), "prefs");
+        if (yyjson_is_obj(prefs)) {
+            const char* fontName = yyjson_get_str(yyjson_obj_get(prefs, "FontName"));
+            if (!fontName) {
+                fontName = "Hack";
+            }
+            const char* fontSize = yyjson_get_str(yyjson_obj_get(prefs, "FontSize"));
+            if (!fontSize) {
+                fontSize = "13";
+            }
+
+            ffFontInitValues(&terminalFont->font, fontName, fontSize);
+        }
+        yyjson_doc_free(doc);
+        return;
+    }
+}
+
+static void detectTerminator(FFTerminalFontResult* result) {
+    FF_STRBUF_AUTO_DESTROY useSystemFont = ffStrbufCreate();
+    FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
+
+    if (!ffParsePropFileConfigValues("terminator/config", 2, (FFpropquery[]) {
+                                                                 { "use_system_font =", &useSystemFont },
+                                                                 { "font =", &fontName },
+                                                             }) ||
+        ffStrbufIgnCaseEqualS(&useSystemFont, "True")) {
+        FF_AUTO_FREE const char* fontName = getSystemMonospaceFont();
+        if (ffStrSet(fontName)) {
+            ffFontInitPango(&result->font, fontName);
+        } else {
+            ffStrbufAppendS(&result->error, "Couldn't get system monospace font name from GSettings / DConf");
+        }
+        return;
+    }
+
+    if (fontName.length == 0) {
+        ffFontInitValues(&result->font, "Mono", "10");
+    } else {
+        ffFontInitPango(&result->font, fontName.chars);
+    }
+}
+
+static void detectWestonTerminal(FFTerminalFontResult* terminalFont) {
+    FF_STRBUF_AUTO_DESTROY font = ffStrbufCreate();
+    FF_STRBUF_AUTO_DESTROY size = ffStrbufCreate();
+    ffParsePropFileConfigValues("weston.ini", 2, (FFpropquery[]) {
+                                                     { "font=", &font },
+                                                     { "font-size=", &size },
+                                                 });
+    if (!font.length) {
+        ffStrbufSetStatic(&font, "DejaVu Sans Mono");
+    }
+    if (!size.length) {
+        ffStrbufSetStatic(&size, "14");
+    }
+    ffFontInitValues(&terminalFont->font, font.chars, size.chars);
+}
+
+static void detectUrxvt(FFTerminalFontResult* terminalFont) {
+    FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
+
+    if (!(ffParsePropFileHomeValues(".Xresources", 1, (FFpropquery[]) {
+                                                          { "URxvt.font:", &buffer },
+                                                      }) ||
+            ffParsePropFileHomeValues(".Xdefaults", 1, (FFpropquery[]) {
+                                                           { "URxvt.font:", &buffer },
+                                                       }))) {
+        ffStrbufAppendS(&terminalFont->error, "Could not find URxvt.font in .Xresources or .Xdefaults");
+        return;
+    }
+
+    uint32_t index = 0;
+
+    char* line = NULL;
+    size_t len = 0;
+    while (ffStrbufGetdelim(&line, &len, ',', &buffer)) {
+        FFfont* font = index == 0 ? &terminalFont->font : &terminalFont->fallback;
+        if (line[0] == '-') {
+            ffFontInitXlfd(font, line);
+        } else if (ffStrStartsWith(line, "xft:")) {
+            ffFontInitXft(font, line + 4);
+        } else {
+            ffStrbufAppendF(&terminalFont->error, "Unknown URxvt font format: %s", line);
+            continue;
+        }
+        index++;
+        if (index > 1) {
+            break;
+        }
+    }
+}
+
+static bool detectCosmicTerm(FFTerminalFontResult* terminalFont) {
+    FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
+    FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
+
+    FF_STRBUF_AUTO_DESTROY path = ffStrbufCreateCopy(&instance.state.platform.homeDir);
+    ffStrbufAppendS(&path, ".config/cosmic/com.system76.CosmicTerm/v1/");
+    uint32_t baseLen = path.length;
+
+    ffStrbufAppendS(&path, "font_name");
+    ffReadFileBuffer(path.chars, &fontName);
+    ffStrbufTrim(&path, '"');
+    ffStrbufSubstrBefore(&path, baseLen);
+    if (fontName.length == 0) {
+        ffStrbufSetStatic(&fontName, "Noto Sans Mono");
+    }
+
+    ffStrbufAppendS(&path, "font_size");
+    if (ffReadFileBuffer(path.chars, &fontSize)) {
+        ffStrbufAppendS(&fontSize, "px");
+    }
+    ffStrbufSubstrBefore(&path, baseLen);
+    if (fontSize.length == 0) {
+        ffStrbufSetStatic(&fontSize, "14px");
+    }
+
+    ffFontInitValues(&terminalFont->font, fontName.chars, fontSize.chars);
+
+    return true;
+}
+
+#ifdef __HAIKU__
+static void detectHaikuTerminal(FFTerminalFontResult* terminalFont) {
+    FF_STRBUF_AUTO_DESTROY font = ffStrbufCreate();
+    FF_STRBUF_AUTO_DESTROY size = ffStrbufCreate();
+    ffParsePropFileConfigValues("Terminal/Default", 2, (FFpropquery[]) {
+                                                           { "\"Half Font Family\" , ", &font },
+                                                           { "\"Half Font Size\" , ", &size },
+                                                       });
+    if (!font.length) {
+        ffStrbufSetStatic(&font, "Noto Sans Mono");
+    }
+    if (!size.length) {
+        ffStrbufSetStatic(&size, "12");
+    }
+    ffFontInitValues(&terminalFont->font, font.chars, size.chars);
+}
+#endif
+
+bool
+#ifdef __ANDROID__
+ffDetectTerminalFontPlatformLinux
+#else
+ffDetectTerminalFontPlatform
+#endif
+    (const FFTerminalResult* terminal, FFTerminalFontResult* terminalFont) {
+    if (ffStrbufIgnCaseEqualS(&terminal->processName, "konsole")) {
+        detectKonsole(terminalFont, "konsolerc");
+    } else if (ffStrbufIgnCaseEqualS(&terminal->processName, "yakuake")) {
+        detectKonsole(terminalFont, "yakuakerc");
+    } else if (ffStrbufIgnCaseEqualS(&terminal->processName, "xfce4-terminal")) {
+        detectXFCETerminal(terminalFont);
+    } else if (ffStrbufIgnCaseEqualS(&terminal->processName, "lxterminal")) {
+        detectFromConfigFile("lxterminal/lxterminal.conf", "fontname =", terminalFont);
+    } else if (ffStrbufIgnCaseEqualS(&terminal->processName, "tilix")) {
+        detectFromGSettings("/com/gexperts/Tilix/profiles/", "com.gexperts.Tilix.ProfilesList", "com.gexperts.Tilix.Profile", "default", terminalFont);
+    } else if (ffStrbufStartsWithIgnCaseS(&terminal->processName, "gnome-terminal")) {
+        detectFromGSettings("/org/gnome/terminal/legacy/profiles:/:", "org.gnome.Terminal.ProfilesList", "org.gnome.Terminal.Legacy.Profile", "default", terminalFont);
+    } else if (ffStrbufStartsWithIgnCaseS(&terminal->processName, "ptyxis-agent")) {
+        detectPtyxis(terminalFont);
+    } else if (ffStrbufIgnCaseEqualS(&terminal->processName, "kgx")) {
+        detectKgx(terminalFont);
+    } else if (ffStrbufIgnCaseEqualS(&terminal->processName, "mate-terminal")) {
+        detectFromGSettings("/org/mate/terminal/profiles/", "org.mate.terminal.global", "org.mate.terminal.profile", "default-profile", terminalFont);
+    } else if (ffStrbufIgnCaseEqualS(&terminal->processName, "deepin-terminal")) {
+        detectDeepinTerminal(terminalFont);
+    } else if (ffStrbufIgnCaseEqualS(&terminal->processName, "foot")) {
+        detectFootTerminal(terminalFont);
+    } else if (ffStrbufIgnCaseEqualS(&terminal->processName, "qterminal")) {
+        detectQTerminal(terminalFont);
+    } else if (ffStrbufIgnCaseEqualS(&terminal->processName, "xterm")) {
+        detectXterm(terminalFont);
+    } else if (ffStrbufIgnCaseEqualS(&terminal->processName, "st")) {
+        detectSt(terminalFont, terminal);
+    } else if (ffStrbufIgnCaseEqualS(&terminal->processName, "warp")) {
+        detectWarp(terminalFont);
+    } else if (ffStrbufIgnCaseEqualS(&terminal->processName, "weston-terminal")) {
+        detectWestonTerminal(terminalFont);
+    } else if (ffStrbufStartsWithIgnCaseS(&terminal->processName, "terminator")) {
+        detectTerminator(terminalFont);
+    } else if (ffStrbufStartsWithIgnCaseS(&terminal->processName, "sakura")) {
+        detectFromConfigFile("sakura/sakura.conf", "font=", terminalFont);
+    } else if (ffStrbufStartsWithIgnCaseS(&terminal->processName, "cosmic-term")) {
+        detectCosmicTerm(terminalFont);
+    }
+#ifdef __HAIKU__
+    else if (ffStrbufStartsWithIgnCaseS(&terminal->processName, "Terminal")) {
+        detectHaikuTerminal(terminalFont);
+    }
+#endif
+    else if (ffStrbufStartsWithIgnCaseS(&terminal->processName, "termite")) {
+        detectFromConfigFile("termite/config", "font =", terminalFont);
+    } else if (ffStrbufIgnCaseEqualS(&terminal->processName, "rxvt") || ffStrbufIgnCaseEqualS(&terminal->processName, "urxvt") || ffStrbufIgnCaseEqualS(&terminal->processName, "urxvtd")) {
+        detectUrxvt(terminalFont);
+    } else {
+        return false;
+    }
+    return true;
+}