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

Moved terminal font detection logic to detection folder

Browse Source
This commit is contained in:
Linus Dierheimer
2022-09-18 15:53:51 +02:00
parent 051a043a4b
commit 87c3459f5d
16 changed files with 350 additions and 359 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/modules/terminalfont.c
+14 -94
View File
@@ -1,112 +1,32 @@
#include "fastfetch.h"
#include "common/properties.h"
#include "common/printing.h"
#include "common/font.h"
#include "common/processing.h"
#include "terminalfont.h"
#include "detection/terminalfont/terminalfont.h"
void ffPrintTerminalFontResult(FFinstance* instance, const char* raw, FFfont* font)
#define FF_TERMFONT_MODULE_NAME "Terminal Font"
#define FF_TERMFONT_NUM_FORMAT_ARGS 4
void ffPrintTerminalFont(FFinstance* instance)
{
if(font->pretty.length == 0)
const FFTerminalFontResult* terminalFont = ffDetectTerminalFont(instance);
if(terminalFont->error.length > 0)
{
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, "Terminal font is an empty value");
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, terminalFont->error.chars);
return;
}
if(instance->config.terminalFont.outputFormat.length == 0)
{
ffPrintLogoAndKey(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont.key);
ffStrbufPutTo(&font->pretty, stdout);
ffStrbufPutTo(&terminalFont->font.pretty, stdout);
}
else
{
ffPrintFormat(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, FF_TERMFONT_NUM_FORMAT_ARGS, (FFformatarg[]){
{FF_FORMAT_ARG_TYPE_STRING, raw},
{FF_FORMAT_ARG_TYPE_STRBUF, &font->name},
{FF_FORMAT_ARG_TYPE_STRBUF, &font->size},
{FF_FORMAT_ARG_TYPE_LIST, &font->styles},
{FF_FORMAT_ARG_TYPE_STRBUF, &font->pretty}
{FF_FORMAT_ARG_TYPE_STRBUF, &terminalFont->font.pretty},
{FF_FORMAT_ARG_TYPE_STRBUF, &terminalFont->font.name},
{FF_FORMAT_ARG_TYPE_STRBUF, &terminalFont->font.size},
{FF_FORMAT_ARG_TYPE_LIST, &terminalFont->font.styles}
});
}
}
static void printAlacritty(FFinstance* instance) {
FFstrbuf fontName;
FFstrbuf fontSize;
ffStrbufInit(&fontName);
ffStrbufInit(&fontSize);
FFpropquery fontQuery[] = {
{"family:", &fontName},
{"size:", &fontSize},
};
// alacritty parses config files in this order
ffParsePropFileConfigValues(instance, "alacritty/alacritty.yml", 2, fontQuery);
if(fontName.length == 0 || fontSize.length == 0)
ffParsePropFileConfigValues(instance, "alacritty.yml", 2, fontQuery);
if(fontName.length == 0 || fontSize.length == 0)
ffParsePropFileConfigValues(instance, ".alacritty.yml", 2, fontQuery);
//by default alacritty uses its own font called alacritty
if(fontName.length == 0)
ffStrbufAppendS(&fontName, "alacritty");
// the default font size is 11
if(fontSize.length == 0)
ffStrbufAppendS(&fontSize, "11");
FFfont font;
ffFontInitValues(&font, fontName.chars, fontSize.chars);
ffPrintTerminalFontResult(instance, fontName.chars, &font);
ffFontDestroy(&font);
ffStrbufDestroy(&fontName);
ffStrbufDestroy(&fontSize);
}
static void printTTY(FFinstance* instance)
{
FFstrbuf fontName;
ffStrbufInit(&fontName);
ffParsePropFile(FASTFETCH_TARGET_DIR_ROOT"/etc/vconsole.conf", "Font =", &fontName);
if(fontName.length == 0)
{
ffStrbufAppendS(&fontName, "VGA default kernel font ");
ffProcessAppendStdOut(&fontName, (char* const[]){
"showconsolefont",
"--info",
NULL
});
}
ffStrbufTrimRight(&fontName, ' ');
FFfont font;
ffFontInitCopy(&font, fontName.chars);
ffPrintTerminalFontResult(instance, fontName.chars, &font);
ffFontDestroy(&font);
ffStrbufDestroy(&fontName);
}
void ffPrintTerminalFont(FFinstance* instance)
{
const FFTerminalShellResult* result = ffDetectTerminalShell(instance);
if(result->terminalProcessName.length == 0)
{
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, "Terminal font needs successfull terminal detection");
return;
}
if(ffPrintTerminalFontPlatform(instance, result))
return;
if(ffStrbufStartsWithIgnCaseS(&result->terminalExe, "/dev/tty"))
printTTY(instance);
else if(ffStrbufIgnCaseCompS(&result->terminalProcessName, "alacritty") == 0)
printAlacritty(instance);
else
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, "Unknown terminal: %s", result->terminalProcessName.chars);
}
src/modules/terminalfont.h
-15
View File
@@ -1,15 +0,0 @@
#pragma once
#ifndef FF_INCLUDED_modules_terminalfont
#define FF_INCLUDED_modules_terminalfont
#include "fastfetch.h"
#include "detection/terminalshell.h"
#define FF_TERMFONT_MODULE_NAME "Terminal Font"
#define FF_TERMFONT_NUM_FORMAT_ARGS 5
void ffPrintTerminalFontResult(FFinstance* instance, const char* raw, FFfont* font);
bool ffPrintTerminalFontPlatform(FFinstance* instance, const FFTerminalShellResult* shellInfo);
#endif
src/modules/terminalfont_apple.c
-143
View File
@@ -1,143 +0,0 @@
#include "fastfetch.h"
#include "common/printing.h"
#include "common/font.h"
#include "common/io.h"
#include "common/library.h"
#include "util/apple/osascript.h"
#include "terminalfont.h"
#include <stdlib.h>
#include <string.h>
#ifdef FF_HAVE_LIBPLIST
#include <plist/plist.h>
static char* printIterm2Impl(FFinstance* instance, const char* profile, FFstrbuf* content)
{
FF_LIBRARY_LOAD(libplist, instance->config.libplist, "dlopen libplist failed", "libplist-2.0"FF_LIBRARY_EXTENSION, 2);
FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libplist, plist_is_binary);
FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libplist, plist_from_bin);
FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libplist, plist_from_xml);
FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libplist, plist_array_new_iter);
FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libplist, plist_access_path);
FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libplist, plist_array_next_item);
FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libplist, plist_string_val_compare);
FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libplist, plist_dict_get_item);
FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libplist, plist_get_string_ptr);
FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libplist, plist_free);
plist_t root_node = NULL;
if (ffplist_is_binary(content->chars, content->length))
ffplist_from_bin(content->chars, content->length, &root_node);
else
ffplist_from_xml(content->chars, content->length, &root_node);
if(root_node == NULL)
return "parsing iTerm preference file failed";
plist_t bookmarks = ffplist_access_path(root_node, 1, "New Bookmarks");
plist_array_iter iter = NULL;
ffplist_array_new_iter(bookmarks, &iter);
plist_t item = NULL;
do
{
ffplist_array_next_item(bookmarks, iter, &item);
if(ffplist_string_val_compare(ffplist_dict_get_item(item, "Name"), profile) == 0)
break;
} while(item != NULL);
free(iter);
if(item == NULL)
{
ffplist_free(root_node);
return "find profile bookmark failed";
}
item = ffplist_dict_get_item(item, "Normal Font");
if (item == NULL)
{
ffplist_free(root_node);
return "find Normal Font key failed";
}
FFfont font;
ffFontInitWithSpace(&font, ffplist_get_string_ptr(item, NULL));
ffPrintTerminalFontResult(instance, font.name.chars, &font);
ffFontDestroy(&font);
ffplist_free(root_node);
return NULL;
}
#endif //FF_HAVE_LIBPLIST
static void printIterm2(FFinstance* instance)
{
#ifdef FF_HAVE_LIBPLIST
const char* profile = getenv("ITERM_PROFILE");
if (profile == NULL)
{
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, "Unknown iTerm profile");
return;
}
FFstrbuf fileName;
ffStrbufInit(&fileName);
ffStrbufAppendS(&fileName, instance->state.passwd->pw_dir);
ffStrbufAppendS(&fileName, "/Library/Preferences/com.googlecode.iterm2.plist");
FFstrbuf content;
ffStrbufInit(&content);
bool success = ffAppendFileBuffer(fileName.chars, &content);
ffStrbufDestroy(&fileName);
if(success)
{
const char* error = printIterm2Impl(instance, profile, &content);
if (error)
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, "%s", error);
}
else
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, "Read iTerm preference file failed");
ffStrbufDestroy(&content);
#else
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, "Parse iTerm preferences requires libplist to be installed");
#endif
}
static void printAppleTerminal(FFinstance* instance)
{
FFstrbuf fontName;
ffStrbufInit(&fontName);
if(!ffOsascript("tell application \"Terminal\" to font name of window frontmost", &fontName))
{
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, "osascript failed");
return;
}
FFstrbuf fontSize;
ffStrbufInit(&fontSize);
ffOsascript("tell application \"Terminal\" to font size of window frontmost", &fontSize);
FFfont font;
ffFontInitValues(&font, fontName.chars, fontSize.chars);
ffPrintTerminalFontResult(instance, fontName.chars, &font);
ffFontDestroy(&font);
ffStrbufDestroy(&fontName);
ffStrbufDestroy(&fontSize);
}
bool ffPrintTerminalFontPlatform(FFinstance* instance, const FFTerminalShellResult* shellInfo)
{
bool success = true;
if(ffStrbufIgnCaseCompS(&shellInfo->terminalProcessName, "iterm.app") == 0)
printIterm2(instance);
else if(ffStrbufIgnCaseCompS(&shellInfo->terminalProcessName, "Apple_Terminal") == 0)
printAppleTerminal(instance);
else
success = false;
return success;
}
src/modules/terminalfont_linux.c
-177
View File
@@ -1,177 +0,0 @@
#include "fastfetch.h"
#include "common/properties.h"
#include "common/printing.h"
#include "common/font.h"
#include "common/settings.h"
#include "detection/displayserver/displayserver.h"
#include "detection/terminalshell.h"
#include "terminalfont.h"
static const char* getSystemMonospaceFont(FFinstance* instance)
{
const FFDisplayServerResult* wmde = ffConnectDisplayServer(instance);
if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Cinnamon") == 0)
{
const char* systemMonospaceFont = ffSettingsGet(instance, "/org/cinnamon/desktop/interface/monospace-font-name", "org.cinnamon.desktop.interface", NULL, "monospace-font-name", FF_VARIANT_TYPE_STRING).strValue;
if(systemMonospaceFont != NULL)
return systemMonospaceFont;
}
else if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Mate") == 0)
{
const char* systemMonospaceFont = ffSettingsGet(instance, "/org/mate/interface/monospace-font-name", "org.mate.interface", NULL, "monospace-font-name", FF_VARIANT_TYPE_STRING).strValue;
if(systemMonospaceFont != NULL)
return systemMonospaceFont;
}
return ffSettingsGet(instance, "/org/gnome/desktop/interface/monospace-font-name", "org.gnome.desktop.interface", NULL, "monospace-font-name", FF_VARIANT_TYPE_STRING).strValue;
}
static void printTerminalFontFromConfigFile(FFinstance* instance, const char* configFile, const char* start)
{
FFstrbuf fontName;
ffStrbufInit(&fontName);
ffParsePropFileConfig(instance, configFile, start, &fontName);
if(fontName.length == 0)
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, "Couldn't find terminal font in \"$XDG_CONFIG_HOME/%s\"", configFile);
else
{
FFfont font;
ffFontInitPango(&font, fontName.chars);
ffPrintTerminalFontResult(instance, fontName.chars, &font);
ffFontDestroy(&font);
}
ffStrbufDestroy(&fontName);
}
static void printTerminalFontFromGSettings(FFinstance* instance, char* profilePath, char* profileList, char* profile)
{
const char* defaultProfile = ffSettingsGetGSettings(instance, profileList, NULL, "default", FF_VARIANT_TYPE_STRING).strValue;
if(defaultProfile == NULL)
{
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, "Couldn't get \"default\" profile from gsettings");
return;
}
FFstrbuf path;
ffStrbufInitA(&path, 128);
ffStrbufAppendS(&path, profilePath);
ffStrbufAppendS(&path, defaultProfile);
ffStrbufAppendC(&path, '/');
const char* fontName;
if(!ffSettingsGetGSettings(instance, profile, path.chars, "use-system-font", FF_VARIANT_TYPE_BOOL).boolValue) // custom font
{
fontName = ffSettingsGetGSettings(instance, profile, path.chars, "font", FF_VARIANT_TYPE_STRING).strValue;
if(fontName == NULL)
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, "Couldn't get terminal font from GSettings (%s::%s::font)", profile, path.chars);
}
else // system font
{
fontName = getSystemMonospaceFont(instance);
if(fontName == NULL)
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, "Could't get system monospace font name from GSettings / DConf");
}
ffStrbufDestroy(&path);
if(fontName == NULL)
return;
FFfont font;
ffFontInitPango(&font, fontName);
ffPrintTerminalFontResult(instance, fontName, &font);
ffFontDestroy(&font);
}
static void printKonsole(FFinstance* instance)
{
FFstrbuf profile;
ffStrbufInit(&profile);
ffParsePropFileConfig(instance, "konsolerc", "DefaultProfile =", &profile);
if(profile.length == 0)
{
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, "%s", "Couldn't find \"DefaultProfile=%[^\\n]\" in \".config/konsolerc\"");
ffStrbufDestroy(&profile);
return;
}
FFstrbuf profilePath;
ffStrbufInitA(&profilePath, 64);
ffStrbufAppendS(&profilePath, ".local/share/konsole/");
ffStrbufAppend(&profilePath, &profile);
FFstrbuf fontName;
ffStrbufInit(&fontName);
ffParsePropFileHome(instance, profilePath.chars, "Font =", &fontName);
if(fontName.length == 0)
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, "Couldn't find \"Font=%%[^\\n]\" in \"%s\"", profilePath.chars);
else
{
FFfont font;
ffFontInitQt(&font, fontName.chars);
ffPrintTerminalFontResult(instance, fontName.chars, &font);
ffFontDestroy(&font);
}
ffStrbufDestroy(&fontName);
ffStrbufDestroy(&profilePath);
ffStrbufDestroy(&profile);
}
static void printXCFETerminal(FFinstance* instance)
{
FFstrbuf useSysFont;
ffStrbufInit(&useSysFont);
if(!ffParsePropFileConfig(instance, "xfce4/terminal/terminalrc", "FontUseSystem =", &useSysFont))
{
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, "Couldn't open \"$XDG_CONFIG_HOME/xfce4/terminal/terminalrc\"");
ffStrbufDestroy(&useSysFont);
return;
}
if(useSysFont.length == 0 || ffStrbufIgnCaseCompS(&useSysFont, "FALSE") == 0)
{
printTerminalFontFromConfigFile(instance, "xfce4/terminal/terminalrc", "FontName =");
ffStrbufDestroy(&useSysFont);
return;
}
ffStrbufDestroy(&useSysFont);
const char* fontName = ffSettingsGetXFConf(instance, "xsettings", "/Gtk/MonospaceFontName", FF_VARIANT_TYPE_STRING).strValue;
if(fontName == NULL)
ffPrintError(instance, FF_TERMFONT_MODULE_NAME, 0, &instance->config.terminalFont, "Couldn't find \"xsettings::/Gtk/MonospaceFontName\" in XFConf");
else
{
FFfont font;
ffFontInitPango(&font, fontName);
ffPrintTerminalFontResult(instance, fontName, &font);
ffFontDestroy(&font);
}
}
bool ffPrintTerminalFontPlatform(FFinstance* instance, const FFTerminalShellResult* shellInfo)
{
bool success = true;
if(ffStrbufIgnCaseCompS(&shellInfo->terminalProcessName, "konsole") == 0)
printKonsole(instance);
else if(ffStrbufIgnCaseCompS(&shellInfo->terminalProcessName, "xfce4-terminal") == 0)
printXCFETerminal(instance);
else if(ffStrbufIgnCaseCompS(&shellInfo->terminalProcessName, "lxterminal") == 0)
printTerminalFontFromConfigFile(instance, "lxterminal/lxterminal.conf", "fontname =");
else if(ffStrbufIgnCaseCompS(&shellInfo->terminalProcessName, "tilix") == 0)
printTerminalFontFromGSettings(instance, "/com/gexperts/Tilix/profiles/", "com.gexperts.Tilix.ProfilesList", "com.gexperts.Tilix.Profile");
else if(ffStrbufIgnCaseCompS(&shellInfo->terminalProcessName, "gnome-terminal-") == 0)
printTerminalFontFromGSettings(instance, "/org/gnome/terminal/legacy/profiles:/:", "org.gnome.Terminal.ProfilesList", "org.gnome.Terminal.Legacy.Profile");
else
success = false;
return success;
}