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

Merge pull request #432 from CarterLi/config

Browse Source 
Initial support of JSON config file, the first step to fastfetch 2.0
This commit is contained in:
Carter Li
2023-06-10 10:10:15 +08:00
committed by GitHub
parent 8b285af276 3227eee080
commit cb8dc0326c
303 changed files with 8313 additions and 4179 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.github/workflows/push.yml
+6 -6
View File
@@ -21,7 +21,7 @@ jobs:
uses: actions/checkout@v3
- name: install required packages
run: sudo apt-get update && sudo apt-get install -y libpci-dev libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libxfconf-0-dev libsqlite3-dev rpm librpm-dev libzstd-dev libegl-dev libglx-dev libosmesa6-dev ocl-icd-opencl-dev libnm-dev libpulse-dev libcjson-dev
run: sudo apt-get update && sudo apt-get install -y libpci-dev libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libxfconf-0-dev libsqlite3-dev rpm librpm-dev libzstd-dev libegl-dev libglx-dev libosmesa6-dev ocl-icd-opencl-dev libnm-dev libpulse-dev libjson-c-dev
- name: configure project
env:
@@ -53,7 +53,7 @@ jobs:
uses: actions/checkout@v3
- name: install required packages
run: sudo apt-get update && sudo apt-get install -y libpci-dev libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libxfconf-0-dev libsqlite3-dev rpm librpm-dev libzstd-dev libegl-dev libglx-dev libosmesa6-dev ocl-icd-opencl-dev libnm-dev libpulse-dev libcjson-dev
run: sudo apt-get update && sudo apt-get install -y libpci-dev libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libxfconf-0-dev libsqlite3-dev rpm librpm-dev libzstd-dev libegl-dev libglx-dev libosmesa6-dev ocl-icd-opencl-dev libnm-dev libpulse-dev libjson-c-dev
- name: Initialize CodeQL
uses: github/codeql-action/init@v2
@@ -183,7 +183,7 @@ jobs:
with:
msystem: CLANG64
update: true
install: git zip mingw-w64-clang-x86_64-cmake mingw-w64-clang-x86_64-clang mingw-w64-clang-x86_64-vulkan-loader mingw-w64-clang-x86_64-opencl-icd mingw-w64-clang-x86_64-cjson
install: git zip mingw-w64-clang-x86_64-cmake mingw-w64-clang-x86_64-clang mingw-w64-clang-x86_64-vulkan-loader mingw-w64-clang-x86_64-opencl-icd mingw-w64-clang-x86_64-json-c
- name: print msys version
run: uname -a
@@ -203,7 +203,7 @@ jobs:
uses: github/codeql-action/analyze@v2
- name: copy necessary dlls
run: cp /clang64/bin/{libcjson,OpenCL,vulkan-1}.dll .
run: cp /clang64/bin/{libjson-c*,OpenCL,vulkan-1}.dll .
- name: list features
run: ./fastfetch --list-features
@@ -244,7 +244,7 @@ jobs:
with:
msystem: CLANG32
update: true
install: git zip mingw-w64-clang-i686-cmake mingw-w64-clang-i686-clang mingw-w64-clang-i686-vulkan-loader mingw-w64-clang-i686-opencl-icd mingw-w64-clang-i686-cjson
install: git zip mingw-w64-clang-i686-cmake mingw-w64-clang-i686-clang mingw-w64-clang-i686-vulkan-loader mingw-w64-clang-i686-opencl-icd mingw-w64-clang-i686-json-c
- name: print msys version
run: uname -a
@@ -264,7 +264,7 @@ jobs:
uses: github/codeql-action/analyze@v2
- name: copy necessary dlls
run: cp /clang32/bin/{libcjson,OpenCL,vulkan-1}.dll .
run: cp /clang32/bin/{libjson-c*,OpenCL,vulkan-1}.dll .
- name: run fastfetch
run: time ./fastfetch --disable-linewrap false --hide-cursor false --show-errors true --load-config presets/all
CHANGELOG.md
+3
View File
@@ -68,6 +68,9 @@ Bugfixes:
* Don't exit if libpci is failed to init (GPU, Linux, #433)
* Names of most well-known gamepads are correctly printed instead of `Wireless Controller` on Windows
Changes:
* Use json-c to parse JSON strings for comments support, instead of using unmaintained cJSON
Logo:
* Small update for nobara logo (#435, @regulargvy13)
CMakeLists.txt
+66 -64
View File
@@ -70,7 +70,7 @@ cmake_dependent_option(ENABLE_OPENCL "Enable opencl" ON "LINUX OR BSD OR WIN32"
cmake_dependent_option(ENABLE_LIBNM "Enable libnm" ON "LINUX" OFF)
cmake_dependent_option(ENABLE_FREETYPE "Enable freetype" ON "ANDROID" OFF)
cmake_dependent_option(ENABLE_PULSE "Enable pulse" ON "LINUX OR BSD" OFF)
cmake_dependent_option(ENABLE_LIBCJSON "Enable libcjson" ON "LINUX OR WIN32" OFF)
cmake_dependent_option(ENABLE_JSONC "Enable json-c" ON "LINUX OR APPLE OR BSD OR WIN32 OR ANDROID" OFF)
cmake_dependent_option(ENABLE_THREADS "Enable multithreading" ON "Threads_FOUND" OFF)
cmake_dependent_option(ENABLE_BUFFER "Enable stdout buffer" ON "LINUX OR APPLE OR BSD OR WIN32 OR ANDROID" OFF)
@@ -231,14 +231,17 @@ set(LIBFASTFETCH_SRC
src/common/font.c
src/common/format.c
src/common/init.c
src/common/json.c
src/common/jsonconfig.c
src/common/library.c
src/common/option.c
src/common/parsing.c
src/common/printing.c
src/common/properties.c
src/common/settings.c
src/detection/bluetooth/bluetooth.c
src/detection/cpu/cpu.c
src/detection/cpuUsage/cpuUsage.c
src/detection/cpuusage/cpuusage.c
src/detection/datetime/datetime.c
src/detection/disk/disk.c
src/detection/displayserver/displayserver.c
@@ -258,62 +261,61 @@ set(LIBFASTFETCH_SRC
src/logo/image/im7.c
src/logo/image/image.c
src/logo/logo.c
src/modules/battery.c
src/modules/bios.c
src/modules/bluetooth.c
src/modules/board.c
src/modules/brightness.c
src/modules/break.c
src/modules/chassis.c
src/modules/colors.c
src/modules/cpu.c
src/modules/cpuUsage.c
src/modules/cursor.c
src/modules/custom.c
src/modules/command.c
src/modules/date.c
src/modules/datetime.c
src/modules/de.c
src/modules/disk.c
src/modules/font.c
src/modules/gpu.c
src/modules/host.c
src/modules/icons.c
src/modules/gamepad.c
src/modules/kernel.c
src/modules/locale.c
src/modules/localip.c
src/modules/memory.c
src/modules/opencl.c
src/modules/opengl.c
src/modules/os.c
src/modules/packages.c
src/modules/player.c
src/modules/poweradapter.c
src/modules/processes.c
src/modules/publicip.c
src/modules/display.c
src/modules/separator.c
src/modules/shell.c
src/modules/sound.c
src/modules/swap.c
src/modules/media.c
src/modules/terminal.c
src/modules/terminalfont.c
src/modules/theme.c
src/modules/time.c
src/modules/title.c
src/modules/uptime.c
src/modules/users.c
src/modules/vulkan.c
src/modules/wallpaper.c
src/modules/weather.c
src/modules/wifi.c
src/modules/wm.c
src/modules/wmtheme.c
src/logo/option.c
src/modules/battery/battery.c
src/modules/bios/bios.c
src/modules/bluetooth/bluetooth.c
src/modules/board/board.c
src/modules/brightness/brightness.c
src/modules/break/break.c
src/modules/chassis/chassis.c
src/modules/colors/colors.c
src/modules/cpu/cpu.c
src/modules/cpuusage/cpuusage.c
src/modules/cursor/cursor.c
src/modules/custom/custom.c
src/modules/command/command.c
src/modules/datetime/datetime.c
src/modules/de/de.c
src/modules/disk/disk.c
src/modules/font/font.c
src/modules/gpu/gpu.c
src/modules/host/host.c
src/modules/icons/icons.c
src/modules/gamepad/gamepad.c
src/modules/kernel/kernel.c
src/modules/locale/locale.c
src/modules/localip/localip.c
src/modules/memory/memory.c
src/modules/opencl/opencl.c
src/modules/opengl/opengl.c
src/modules/os/os.c
src/modules/packages/packages.c
src/modules/processes/processes.c
src/modules/player/player.c
src/modules/poweradapter/poweradapter.c
src/modules/publicip/publicip.c
src/modules/display/display.c
src/modules/separator/separator.c
src/modules/shell/shell.c
src/modules/sound/sound.c
src/modules/swap/swap.c
src/modules/media/media.c
src/modules/terminal/terminal.c
src/modules/terminalfont/terminalfont.c
src/modules/theme/theme.c
src/modules/title/title.c
src/modules/uptime/uptime.c
src/modules/users/users.c
src/modules/vulkan/vulkan.c
src/modules/wallpaper/wallpaper.c
src/modules/weather/weather.c
src/modules/wifi/wifi.c
src/modules/wm/wm.c
src/modules/wmtheme/wmtheme.c
src/modules/jsonconfig/jsonconfig.c
src/util/FFlist.c
src/util/FFstrbuf.c
src/util/FFvaluestore.c
src/util/platform/FFPlatform.c
src/util/stringUtils.c
)
@@ -330,7 +332,7 @@ if(LINUX)
src/detection/brightness/brightness_linux.c
src/detection/chassis/chassis_linux.c
src/detection/cpu/cpu_linux.c
src/detection/cpuUsage/cpuUsage_linux.c
src/detection/cpuusage/cpuusage_linux.c
src/detection/cursor/cursor_linux.c
src/detection/bluetooth/bluetooth_linux.c
src/detection/disk/disk_linux.c
@@ -380,7 +382,7 @@ elseif(ANDROID)
src/detection/chassis/chassis_nosupport.c
src/detection/cpu/cpu_linux.c
src/detection/cursor/cursor_nosupport.c
src/detection/cpuUsage/cpuUsage_linux.c
src/detection/cpuusage/cpuusage_linux.c
src/detection/disk/disk_linux.c
src/detection/displayserver/displayserver_nosupport.c
src/detection/font/font_nosupport.c
@@ -423,7 +425,7 @@ elseif(BSD)
src/detection/brightness/brightness_nosupport.c
src/detection/chassis/chassis_nosupport.c
src/detection/cpu/cpu_bsd.c
src/detection/cpuUsage/cpuUsage_bsd.c
src/detection/cpuusage/cpuusage_bsd.c
src/detection/cursor/cursor_linux.c
src/detection/disk/disk_bsd.c
src/detection/displayserver/linux/displayserver_linux.c
@@ -472,7 +474,7 @@ elseif(APPLE)
src/detection/brightness/brightness_apple.c
src/detection/chassis/chassis_nosupport.c
src/detection/cpu/cpu_apple.c
src/detection/cpuUsage/cpuUsage_apple.c
src/detection/cpuusage/cpuusage_apple.c
src/detection/cursor/cursor_apple.m
src/detection/disk/disk_apple.m
src/detection/disk/disk_bsd.c
@@ -517,7 +519,7 @@ elseif(WIN32)
src/detection/brightness/brightness_windows.cpp
src/detection/chassis/chassis_nosupport.c
src/detection/cpu/cpu_windows.c
src/detection/cpuUsage/cpuUsage_windows.c
src/detection/cpuusage/cpuusage_windows.c
src/detection/cursor/cursor_windows.c
src/detection/disk/disk_windows.c
src/detection/displayserver/displayserver_windows.c
@@ -700,9 +702,9 @@ ff_lib_enable(PULSE
"libpulse"
"Pulse"
)
ff_lib_enable(LIBCJSON
"libcjson"
"CJson"
ff_lib_enable(JSONC
"json-c"
"json-c"
)
if(ENABLE_THREADS)
README.md
+3 -3
View File
@@ -53,7 +53,7 @@ The following libraries are used if present at runtime:
* [`libXFConf`](https://gitlab.xfce.org/xfce/xfconf): Needed for XFWM theme and XFCE Terminal font.
* [`libsqlite3`](https://www.sqlite.org/index.html): Needed for pkg & rpm package count.
* [`librpm`](http://rpm.org/): Slower fallback for rpm package count. Needed on openSUSE.
* [`libcJSON`](https://github.com/DaveGamble/cJSON): Needed for Windows Terminal font ( WSL ).
* [`json-c`](https://github.com/json-c/json-c): Needed for Windows Terminal font ( WSL ).
* [`libnm`](https://networkmanager.dev/docs/libnm/latest/): Used for Wifi detection.
* [`libpulse`](https://freedesktop.org/software/pulseaudio/doxygen/): Used for Sound detection.
@@ -71,7 +71,7 @@ For the image logo, iTerm with iterm image protocol should work. Apple Terminal
### Windows
* [`wlanapi`](https://learn.microsoft.com/en-us/windows/win32/api/wlanapi/): A system dll which isn't supported by Windows Server by default. Used for Wifi info detection.
* [`libcJSON`](https://github.com/DaveGamble/cJSON): Used for Windows Terminal font detection. [`cjson`](https://github.com/msys2/MINGW-packages/tree/master/mingw-w64-cjson)
* [`json-c`](https://github.com/json-c/json-c): Used for Windows Terminal font detection. [`json-c`](https://github.com/msys2/MINGW-packages/tree/master/mingw-w64-json-c)
* [`libvulkan`](https://www.vulkan.org/): Vulkan module. Usually has been provided by GPU drivers. [`vulkan-loader`](https://github.com/msys2/MINGW-packages/tree/master/mingw-w64-vulkan-loader) [`vulkan-headers`](https://github.com/msys2/MINGW-packages/tree/master/mingw-w64-vulkan-headers)
* [`libOpenCL`](https://www.khronos.org/opencl/): OpenCL module. [`opencl-icd`](https://github.com/msys2/MINGW-packages/tree/master/mingw-w64-opencl-icd)
@@ -138,7 +138,7 @@ Currently GCC or clang is required (MSVC is not supported). MSYS2 with CLANG64 s
1. Open `MSYS2 / CLANG64` (not `MSYS2 / MSYS`, which targets cygwin C runtime)
1. Install dependencies
```bash
pacman -Syu mingw-w64-clang-x86_64-cmake mingw-w64-clang-x86_64-pkgconf mingw-w64-clang-x86_64-clang mingw-w64-clang-x86_64-cjson mingw-w64-clang-x86_64-vulkan-loader mingw-w64-clang-x86_64-opencl-icd
pacman -Syu mingw-w64-clang-x86_64-cmake mingw-w64-clang-x86_64-pkgconf mingw-w64-clang-x86_64-clang mingw-w64-clang-x86_64-json-c mingw-w64-clang-x86_64-vulkan-loader mingw-w64-clang-x86_64-opencl-icd
```
Follow the building instructions of Linux next.
src/common/font.c
+1 -1
View File
@@ -7,7 +7,7 @@ static void fontInit(FFfont* font)
{
ffStrbufInit(&font->pretty);
ffStrbufInit(&font->name);
ffStrbufInitA(&font->size, 4);
ffStrbufInitA(&font->size, 8);
ffListInitA(&font->styles, sizeof(FFstrbuf), 4);
}
src/common/format.c
+1 -18
View File
@@ -134,18 +134,14 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
continue;
}
FFstrbuf placeholderValue;
ffStrbufInit(&placeholderValue);
FF_STRBUF_AUTO_DESTROY placeholderValue = ffStrbufCreate();
while(i < formatstr->length && formatstr->chars[i] != '}')
ffStrbufAppendC(&placeholderValue, formatstr->chars[i++]);
// test if for stop, if so break the loop
if(placeholderValue.length == 1 && placeholderValue.chars[0] == '-')
{
ffStrbufDestroy(&placeholderValue);
break;
}
// test for end of an if, if so do nothing
if(placeholderValue.length == 1 && placeholderValue.chars[0] == '?')
@@ -155,7 +151,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
else
--numOpenIfs;
ffStrbufDestroy(&placeholderValue);
continue;
}
@@ -167,7 +162,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
else
--numOpenNotIfs;
ffStrbufDestroy(&placeholderValue);
continue;
}
@@ -182,7 +176,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
--numOpenColors;
}
ffStrbufDestroy(&placeholderValue);
continue;
}
@@ -197,7 +190,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
if(index > numArgs)
{
appendInvalidPlaceholder(buffer, "{?", &placeholderValue, i, formatstr->length);
ffStrbufDestroy(&placeholderValue);
continue;
}
@@ -205,13 +197,11 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
if(formatArgSet(&arguments[index - 1]))
{
++numOpenIfs;
ffStrbufDestroy(&placeholderValue);
continue;
}
// fastforward to the end of the if without printing the in between
i = ffStrbufNextIndexS(formatstr, i, "{?}") + 2; // 2 is the length of "{?}" - 1 because the loop will increament it again directly after continue
ffStrbufDestroy(&placeholderValue);
continue;
}
@@ -226,7 +216,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
if(index > numArgs)
{
appendInvalidPlaceholder(buffer, "{/", &placeholderValue, i, formatstr->length);
ffStrbufDestroy(&placeholderValue);
continue;
}
@@ -234,13 +223,11 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
if(!formatArgSet(&arguments[index - 1]))
{
++numOpenNotIfs;
ffStrbufDestroy(&placeholderValue);
continue;
}
// fastforward to the end of the if without printing the in between
i = ffStrbufNextIndexS(formatstr, i, "{/}") + 2; // 2 is the length of "{/}" - 1 because the loop will increament it again directly after continue
ffStrbufDestroy(&placeholderValue);
continue;
}
@@ -252,7 +239,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
ffStrbufAppendS(buffer, "\033[");
ffStrbufAppend(buffer, &placeholderValue);
ffStrbufAppendC(buffer, 'm');
ffStrbufDestroy(&placeholderValue);
continue;
}
@@ -262,13 +248,10 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
if(index > numArgs)
{
appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
ffStrbufDestroy(&placeholderValue);
continue;
}
ffFormatAppendFormatArg(buffer, &arguments[index - 1]);
ffStrbufDestroy(&placeholderValue);
}
ffStrbufTrimRight(buffer, ' ');
src/common/init.c
+133 -227
View File
@@ -3,6 +3,7 @@
#include "common/thread.h"
#include "detection/displayserver/displayserver.h"
#include "util/textModifier.h"
#include "logo/logo.h"
#include <stdlib.h>
#include <unistd.h>
@@ -15,47 +16,27 @@
#include <signal.h>
#endif
#include "modules/modules.h"
static void initState(FFstate* state)
{
state->logoWidth = 0;
state->logoHeight = 0;
state->keysHeight = 0;
state->titleLength = 0;
ffPlatformInit(&state->platform);
}
static void initModuleArg(FFModuleArgs* args)
{
ffStrbufInit(&args->key);
ffStrbufInit(&args->outputFormat);
ffStrbufInit(&args->errorFormat);
}
static void defaultConfig(FFinstance* instance)
{
ffStrbufInitA(&instance->config.logo.source, 0);
instance->config.logo.type = FF_LOGO_TYPE_AUTO;
for(uint8_t i = 0; i < (uint8_t) FASTFETCH_LOGO_MAX_COLORS; ++i)
ffStrbufInit(&instance->config.logo.colors[i]);
instance->config.logo.width = 0;
instance->config.logo.height = 0; //preserve aspect ratio
instance->config.logo.paddingTop = 0;
instance->config.logo.paddingLeft = 0;
instance->config.logo.paddingRight = 4;
instance->config.logo.printRemaining = true;
instance->config.logo.preserveAspectRadio = false;
instance->config.logo.chafaFgOnly = false;
ffStrbufInitS(&instance->config.logo.chafaSymbols, "block+border+space-wide-inverted"); // Chafa default
instance->config.logo.chafaCanvasMode = UINT32_MAX;
instance->config.logo.chafaColorSpace = UINT32_MAX;
instance->config.logo.chafaDitherMode = UINT32_MAX;
ffInitLogoOptions(&instance->config.logo);
ffStrbufInit(&instance->config.colorKeys);
ffStrbufInit(&instance->config.colorTitle);
ffStrbufInit(&instance->config.separator);
ffStrbufAppendS(&instance->config.separator, ": ");
ffStrbufInit(&instance->config.keyValueSeparator);
ffStrbufAppendS(&instance->config.keyValueSeparator, ": ");
instance->config.showErrors = false;
instance->config.recache = false;
@@ -64,139 +45,87 @@ static void defaultConfig(FFinstance* instance)
instance->config.hideCursor = true;
instance->config.escapeBedrock = true;
instance->config.binaryPrefixType = FF_BINARY_PREFIX_TYPE_IEC;
instance->config.glType = FF_GL_TYPE_AUTO;
instance->config.pipe = false;
instance->config.multithreading = true;
instance->config.stat = false;
initModuleArg(&instance->config.os);
initModuleArg(&instance->config.host);
initModuleArg(&instance->config.bios);
initModuleArg(&instance->config.board);
initModuleArg(&instance->config.brightness);
initModuleArg(&instance->config.chassis);
initModuleArg(&instance->config.kernel);
initModuleArg(&instance->config.uptime);
initModuleArg(&instance->config.processes);
initModuleArg(&instance->config.packages);
initModuleArg(&instance->config.shell);
initModuleArg(&instance->config.display);
initModuleArg(&instance->config.de);
initModuleArg(&instance->config.wm);
initModuleArg(&instance->config.wmTheme);
initModuleArg(&instance->config.theme);
initModuleArg(&instance->config.icons);
initModuleArg(&instance->config.font);
initModuleArg(&instance->config.cursor);
initModuleArg(&instance->config.terminal);
initModuleArg(&instance->config.terminalFont);
initModuleArg(&instance->config.cpu);
initModuleArg(&instance->config.cpuUsage);
initModuleArg(&instance->config.gpu);
initModuleArg(&instance->config.memory);
initModuleArg(&instance->config.swap);
initModuleArg(&instance->config.disk);
initModuleArg(&instance->config.battery);
initModuleArg(&instance->config.powerAdapter);
initModuleArg(&instance->config.locale);
initModuleArg(&instance->config.localIP);
initModuleArg(&instance->config.publicIP);
initModuleArg(&instance->config.weather);
initModuleArg(&instance->config.wifi);
initModuleArg(&instance->config.player);
initModuleArg(&instance->config.media);
initModuleArg(&instance->config.dateTime);
initModuleArg(&instance->config.date);
initModuleArg(&instance->config.time);
initModuleArg(&instance->config.vulkan);
initModuleArg(&instance->config.wallpaper);
initModuleArg(&instance->config.openGL);
initModuleArg(&instance->config.openCL);
initModuleArg(&instance->config.users);
initModuleArg(&instance->config.bluetooth);
initModuleArg(&instance->config.sound);
initModuleArg(&instance->config.gamepad);
ffInitTitleOptions(&instance->config.title);
ffInitOSOptions(&instance->config.os);
ffInitHostOptions(&instance->config.host);
ffInitBiosOptions(&instance->config.bios);
ffInitBoardOptions(&instance->config.board);
ffInitBrightnessOptions(&instance->config.brightness);
ffInitChassisOptions(&instance->config.chassis);
ffInitCommandOptions(&instance->config.command);
ffInitCustomOptions(&instance->config.custom);
ffInitKernelOptions(&instance->config.kernel);
ffInitUptimeOptions(&instance->config.uptime);
ffInitProcessesOptions(&instance->config.processes);
ffInitPackagesOptions(&instance->config.packages);
ffInitShellOptions(&instance->config.shell);
ffInitDisplayOptions(&instance->config.display);
ffInitDEOptions(&instance->config.de);
ffInitWMOptions(&instance->config.wm);
ffInitWMThemeOptions(&instance->config.wmTheme);
ffInitThemeOptions(&instance->config.theme);
ffInitIconsOptions(&instance->config.icons);
ffInitFontOptions(&instance->config.font);
ffInitCursorOptions(&instance->config.cursor);
ffInitTerminalOptions(&instance->config.terminal);
ffInitTerminalFontOptions(&instance->config.terminalFont);
ffInitCPUOptions(&instance->config.cpu);
ffInitCPUUsageOptions(&instance->config.cpuUsage);
ffInitGPUOptions(&instance->config.gpu);
ffInitMemoryOptions(&instance->config.memory);
ffInitSwapOptions(&instance->config.swap);
ffInitDiskOptions(&instance->config.disk);
ffInitBatteryOptions(&instance->config.battery);
ffInitPowerAdapterOptions(&instance->config.powerAdapter);
ffInitLocaleOptions(&instance->config.locale);
ffInitLocalIpOptions(&instance->config.localIP);
ffInitPublicIpOptions(&instance->config.publicIP);
ffInitWeatherOptions(&instance->config.weather);
ffInitWifiOptions(&instance->config.wifi);
ffInitPlayerOptions(&instance->config.player);
ffInitMediaOptions(&instance->config.media);
ffInitDateTimeOptions(&instance->config.dateTime);
ffInitVulkanOptions(&instance->config.vulkan);
ffInitWallpaperOptions(&instance->config.wallpaper);
ffInitOpenGLOptions(&instance->config.openGL);
ffInitOpenCLOptions(&instance->config.openCL);
ffInitUsersOptions(&instance->config.users);
ffInitBluetoothOptions(&instance->config.bluetooth);
ffInitSoundOptions(&instance->config.sound);
ffInitSeparatorOptions(&instance->config.separator);
ffInitGamepadOptions(&instance->config.gamepad);
ffStrbufInitA(&instance->config.libPCI, 0);
ffStrbufInitA(&instance->config.libVulkan, 0);
ffStrbufInitA(&instance->config.libWayland, 0);
ffStrbufInitA(&instance->config.libXcbRandr, 0);
ffStrbufInitA(&instance->config.libXcb, 0);
ffStrbufInitA(&instance->config.libXrandr, 0);
ffStrbufInitA(&instance->config.libX11, 0);
ffStrbufInitA(&instance->config.libGIO, 0);
ffStrbufInitA(&instance->config.libDConf, 0);
ffStrbufInitA(&instance->config.libDBus, 0);
ffStrbufInitA(&instance->config.libXFConf, 0);
ffStrbufInitA(&instance->config.libSQLite3, 0);
ffStrbufInitA(&instance->config.librpm, 0);
ffStrbufInitA(&instance->config.libImageMagick, 0);
ffStrbufInitA(&instance->config.libZ, 0);
ffStrbufInitA(&instance->config.libChafa, 0);
ffStrbufInitA(&instance->config.libEGL, 0);
ffStrbufInitA(&instance->config.libGLX, 0);
ffStrbufInitA(&instance->config.libOSMesa, 0);
ffStrbufInitA(&instance->config.libOpenCL, 0);
ffStrbufInitA(&instance->config.libcJSON, 0);
ffStrbufInitA(&instance->config.libfreetype, 0);
ffStrbufInit(&instance->config.libPCI);
ffStrbufInit(&instance->config.libVulkan);
ffStrbufInit(&instance->config.libWayland);
ffStrbufInit(&instance->config.libXcbRandr);
ffStrbufInit(&instance->config.libXcb);
ffStrbufInit(&instance->config.libXrandr);
ffStrbufInit(&instance->config.libX11);
ffStrbufInit(&instance->config.libGIO);
ffStrbufInit(&instance->config.libDConf);
ffStrbufInit(&instance->config.libDBus);
ffStrbufInit(&instance->config.libXFConf);
ffStrbufInit(&instance->config.libSQLite3);
ffStrbufInit(&instance->config.librpm);
ffStrbufInit(&instance->config.libImageMagick);
ffStrbufInit(&instance->config.libZ);
ffStrbufInit(&instance->config.libChafa);
ffStrbufInit(&instance->config.libEGL);
ffStrbufInit(&instance->config.libGLX);
ffStrbufInit(&instance->config.libOSMesa);
ffStrbufInit(&instance->config.libOpenCL);
ffStrbufInit(&instance->config.libJSONC);
ffStrbufInit(&instance->config.libfreetype);
ffStrbufInit(&instance->config.libPulse);
ffStrbufInit(&instance->config.libwlanapi);
ffStrbufInit(&instance->config.libnm);
instance->config.cpuTemp = false;
instance->config.gpuTemp = false;
instance->config.gpuForceVulkan = false;
instance->config.batteryTemp = false;
instance->config.gpuHideIntegrated = false;
instance->config.gpuHideDiscrete = false;
instance->config.shellVersion = true;
instance->config.terminalVersion = true;
instance->config.titleFQDN = false;
ffStrbufInitA(&instance->config.diskFolders, 0);
instance->config.diskShowTypes = FF_DISK_TYPE_REGULAR_BIT | FF_DISK_TYPE_EXTERNAL_BIT;
instance->config.displayCompactType = FF_DISPLAY_COMPACT_TYPE_NONE;
instance->config.displayDetectName = false;
instance->config.displayPreciseRefreshRate = false;
instance->config.bluetoothShowDisconnected = false;
instance->config.soundType = FF_SOUND_TYPE_MAIN;
ffStrbufInitA(&instance->config.batteryDir, 0);
ffStrbufInitA(&instance->config.separatorString, 0);
instance->config.localIpShowType = FF_LOCALIP_TYPE_IPV4_BIT;
ffStrbufInit(&instance->config.localIpNamePrefix);
instance->config.publicIpTimeout = 0;
ffStrbufInit(&instance->config.publicIpUrl);
instance->config.weatherTimeout = 0;
ffStrbufInitS(&instance->config.weatherOutputFormat, "%t+-+%C+(%l)");
ffStrbufInitA(&instance->config.osFile, 0);
ffStrbufInitA(&instance->config.playerName, 0);
instance->config.percentType = 1;
ffStrbufInitS(&instance->config.commandShell,
#ifdef _WIN32
"cmd"
#elif defined(__FreeBSD__)
"csh"
#else
"bash"
#endif
);
ffListInit(&instance->config.commandKeys, sizeof(FFstrbuf));
ffListInit(&instance->config.commandTexts, sizeof(FFstrbuf));
}
void ffInitInstance(FFinstance* instance)
@@ -316,69 +245,63 @@ void ffFinish(FFinstance* instance)
resetConsole();
}
static void destroyModuleArg(FFModuleArgs* args)
{
ffStrbufDestroy(&args->key);
ffStrbufDestroy(&args->outputFormat);
ffStrbufDestroy(&args->errorFormat);
}
static void destroyConfig(FFinstance* instance)
{
ffStrbufDestroy(&instance->config.logo.source);
ffStrbufDestroy(&instance->config.logo.chafaSymbols);
for(uint8_t i = 0; i < (uint8_t) FASTFETCH_LOGO_MAX_COLORS; ++i)
ffStrbufDestroy(&instance->config.logo.colors[i]);
ffDestroyLogoOptions(&instance->config.logo);
ffStrbufDestroy(&instance->config.colorKeys);
ffStrbufDestroy(&instance->config.colorTitle);
ffStrbufDestroy(&instance->config.separator);
ffStrbufDestroy(&instance->config.keyValueSeparator);
destroyModuleArg(&instance->config.os);
destroyModuleArg(&instance->config.host);
destroyModuleArg(&instance->config.bios);
destroyModuleArg(&instance->config.board);
destroyModuleArg(&instance->config.chassis);
destroyModuleArg(&instance->config.kernel);
destroyModuleArg(&instance->config.uptime);
destroyModuleArg(&instance->config.processes);
destroyModuleArg(&instance->config.packages);
destroyModuleArg(&instance->config.shell);
destroyModuleArg(&instance->config.display);
destroyModuleArg(&instance->config.de);
destroyModuleArg(&instance->config.wm);
destroyModuleArg(&instance->config.wmTheme);
destroyModuleArg(&instance->config.theme);
destroyModuleArg(&instance->config.icons);
destroyModuleArg(&instance->config.font);
destroyModuleArg(&instance->config.cursor);
destroyModuleArg(&instance->config.terminal);
destroyModuleArg(&instance->config.terminalFont);
destroyModuleArg(&instance->config.cpu);
destroyModuleArg(&instance->config.cpuUsage);
destroyModuleArg(&instance->config.gpu);
destroyModuleArg(&instance->config.memory);
destroyModuleArg(&instance->config.swap);
destroyModuleArg(&instance->config.disk);
destroyModuleArg(&instance->config.battery);
destroyModuleArg(&instance->config.powerAdapter);
destroyModuleArg(&instance->config.locale);
destroyModuleArg(&instance->config.localIP);
destroyModuleArg(&instance->config.publicIP);
destroyModuleArg(&instance->config.wallpaper);
destroyModuleArg(&instance->config.weather);
destroyModuleArg(&instance->config.wifi);
destroyModuleArg(&instance->config.player);
destroyModuleArg(&instance->config.media);
destroyModuleArg(&instance->config.dateTime);
destroyModuleArg(&instance->config.date);
destroyModuleArg(&instance->config.time);
destroyModuleArg(&instance->config.vulkan);
destroyModuleArg(&instance->config.openGL);
destroyModuleArg(&instance->config.openCL);
destroyModuleArg(&instance->config.users);
destroyModuleArg(&instance->config.bluetooth);
destroyModuleArg(&instance->config.sound);
destroyModuleArg(&instance->config.gamepad);
ffDestroyTitleOptions(&instance->config.title);
ffDestroyOSOptions(&instance->config.os);
ffDestroyHostOptions(&instance->config.host);
ffDestroyBiosOptions(&instance->config.bios);
ffDestroyBoardOptions(&instance->config.board);
ffDestroyBrightnessOptions(&instance->config.brightness);
ffDestroyChassisOptions(&instance->config.chassis);
ffDestroyCommandOptions(&instance->config.command);
ffDestroyCustomOptions(&instance->config.custom);
ffDestroyKernelOptions(&instance->config.kernel);
ffDestroyUptimeOptions(&instance->config.uptime);
ffDestroyProcessesOptions(&instance->config.processes);
ffDestroyPackagesOptions(&instance->config.packages);
ffDestroyShellOptions(&instance->config.shell);
ffDestroyDisplayOptions(&instance->config.display);
ffDestroyDEOptions(&instance->config.de);
ffDestroyWMOptions(&instance->config.wm);
ffDestroyWMThemeOptions(&instance->config.wmTheme);
ffDestroyThemeOptions(&instance->config.theme);
ffDestroyIconsOptions(&instance->config.icons);
ffDestroyFontOptions(&instance->config.font);
ffDestroyCursorOptions(&instance->config.cursor);
ffDestroyTerminalOptions(&instance->config.terminal);
ffDestroyTerminalFontOptions(&instance->config.terminalFont);
ffDestroyCPUOptions(&instance->config.cpu);
ffDestroyCPUUsageOptions(&instance->config.cpuUsage);
ffDestroyGPUOptions(&instance->config.gpu);
ffDestroyMemoryOptions(&instance->config.memory);
ffDestroySwapOptions(&instance->config.swap);
ffDestroyDiskOptions(&instance->config.disk);
ffDestroyBatteryOptions(&instance->config.battery);
ffDestroyPowerAdapterOptions(&instance->config.powerAdapter);
ffDestroyLocaleOptions(&instance->config.locale);
ffDestroyLocalIpOptions(&instance->config.localIP);
ffDestroyPublicIpOptions(&instance->config.publicIP);
ffDestroyWallpaperOptions(&instance->config.wallpaper);
ffDestroyWeatherOptions(&instance->config.weather);
ffDestroyWifiOptions(&instance->config.wifi);
ffDestroyPlayerOptions(&instance->config.player);
ffDestroyMediaOptions(&instance->config.media);
ffDestroyDateTimeOptions(&instance->config.dateTime);
ffDestroyVulkanOptions(&instance->config.vulkan);
ffDestroyOpenGLOptions(&instance->config.openGL);
ffDestroyOpenCLOptions(&instance->config.openCL);
ffDestroyUsersOptions(&instance->config.users);
ffDestroyBluetoothOptions(&instance->config.bluetooth);
ffDestroySeparatorOptions(&instance->config.separator);
ffDestroySoundOptions(&instance->config.sound);
ffDestroyGamepadOptions(&instance->config.gamepad);
ffStrbufDestroy(&instance->config.libPCI);
ffStrbufDestroy(&instance->config.libVulkan);
@@ -400,28 +323,11 @@ static void destroyConfig(FFinstance* instance)
ffStrbufDestroy(&instance->config.libGLX);
ffStrbufDestroy(&instance->config.libOSMesa);
ffStrbufDestroy(&instance->config.libOpenCL);
ffStrbufDestroy(&instance->config.libcJSON);
ffStrbufDestroy(&instance->config.libJSONC);
ffStrbufDestroy(&instance->config.libfreetype);
ffStrbufDestroy(&instance->config.libPulse);
ffStrbufDestroy(&instance->config.libwlanapi);
ffStrbufDestroy(&instance->config.libnm);
ffStrbufDestroy(&instance->config.diskFolders);
ffStrbufDestroy(&instance->config.batteryDir);
ffStrbufDestroy(&instance->config.separatorString);
ffStrbufDestroy(&instance->config.localIpNamePrefix);
ffStrbufDestroy(&instance->config.publicIpUrl);
ffStrbufDestroy(&instance->config.weatherOutputFormat);
ffStrbufDestroy(&instance->config.osFile);
ffStrbufDestroy(&instance->config.playerName);
ffStrbufDestroy(&instance->config.commandShell);
FF_LIST_FOR_EACH(FFstrbuf, item, instance->config.commandKeys)
ffStrbufDestroy(item);
ffListDestroy(&instance->config.commandKeys);
FF_LIST_FOR_EACH(FFstrbuf, item, instance->config.commandTexts)
ffStrbufDestroy(item);
ffListDestroy(&instance->config.commandTexts);
}
static void destroyState(FFinstance* instance)
@@ -505,8 +411,8 @@ void ffListFeatures()
#ifdef FF_HAVE_OPENCL
"opencl\n"
#endif
#ifdef FF_HAVE_LIBCJSON
"libcjson\n"
#ifdef FF_HAVE_LIBJSONC
"json-c\n"
#endif
#ifdef FF_HAVE_FREETYPE
"freetype\n"
src/common/io/io_unix.c
+2 -7
View File
@@ -8,8 +8,7 @@
static void createSubfolders(const char* fileName)
{
FFstrbuf path;
ffStrbufInit(&path);
FF_STRBUF_AUTO_DESTROY path = ffStrbufCreate();
while(*fileName != '\0')
{
@@ -18,8 +17,6 @@ static void createSubfolders(const char* fileName)
mkdir(path.chars, S_IRWXU | S_IRGRP | S_IROTH);
++fileName;
}
ffStrbufDestroy(&path);
}
bool ffWriteFileData(const char* fileName, size_t dataSize, const void* data)
@@ -218,9 +215,7 @@ void listFilesRecursively(FFstrbuf* folder, uint8_t indentation, const char* fol
void ffListFilesRecursively(const char* path)
{
FFstrbuf folder;
ffStrbufInitS(&folder, path);
FF_STRBUF_AUTO_DESTROY folder = ffStrbufCreateS(path);
ffStrbufEnsureEndsWithC(&folder, '/');
listFilesRecursively(&folder, 0, NULL);
ffStrbufDestroy(&folder);
}
src/common/io/io_windows.c
+2 -6
View File
@@ -2,9 +2,7 @@
static void createSubfolders(const char* fileName)
{
FF_STRBUF_AUTO_DESTROY path;
ffStrbufInit(&path);
FF_STRBUF_AUTO_DESTROY path = ffStrbufCreate();
while(*fileName != '\0')
{
ffStrbufAppendC(&path, *fileName);
@@ -141,9 +139,7 @@ void listFilesRecursively(FFstrbuf* folder, uint8_t indentation, const char* fol
void ffListFilesRecursively(const char* path)
{
FFstrbuf folder;
ffStrbufInitS(&folder, path);
FF_STRBUF_AUTO_DESTROY folder = ffStrbufCreateS(path);
ffStrbufEnsureEndsWithC(&folder, '/');
listFilesRecursively(&folder, 0, NULL);
ffStrbufDestroy(&folder);
}
src/common/json.c
+57
View File
@@ -0,0 +1,57 @@
#include "common/json.h"
#ifdef FF_HAVE_JSONC
#include "common/thread.h"
static const FFJsonLibrary* loadLibSymbols(const FFinstance* instance)
{
assert(instance);
static FFJsonLibrary lib;
FF_LIBRARY_LOAD(libjsonc, &instance->config.libJSONC, NULL,
#ifdef _WIN32
"libjson-c-5" FF_LIBRARY_EXTENSION, -1
#else
"libjson-c" FF_LIBRARY_EXTENSION, 5
#endif
)
FF_LIBRARY_LOAD_SYMBOL_VAR(libjsonc, lib, json_tokener_parse, NULL)
FF_LIBRARY_LOAD_SYMBOL_VAR(libjsonc, lib, json_object_is_type, NULL)
FF_LIBRARY_LOAD_SYMBOL_VAR(libjsonc, lib, json_object_get_array, NULL)
FF_LIBRARY_LOAD_SYMBOL_VAR(libjsonc, lib, json_object_get_boolean, NULL)
FF_LIBRARY_LOAD_SYMBOL_VAR(libjsonc, lib, json_object_get_double, NULL)
FF_LIBRARY_LOAD_SYMBOL_VAR(libjsonc, lib, json_object_get_int, NULL)
FF_LIBRARY_LOAD_SYMBOL_VAR(libjsonc, lib, json_object_get_string_len, NULL)
FF_LIBRARY_LOAD_SYMBOL_VAR(libjsonc, lib, json_object_get_string, NULL)
FF_LIBRARY_LOAD_SYMBOL_VAR(libjsonc, lib, json_object_get_object, NULL)
FF_LIBRARY_LOAD_SYMBOL_VAR(libjsonc, lib, json_object_object_del, NULL)
FF_LIBRARY_LOAD_SYMBOL_VAR(libjsonc, lib, json_object_object_get, NULL)
FF_LIBRARY_LOAD_SYMBOL_VAR(libjsonc, lib, json_object_object_length, NULL)
FF_LIBRARY_LOAD_SYMBOL_VAR(libjsonc, lib, json_object_put, NULL)
libjsonc = NULL; // don't dlclose automatically
return &lib;
}
const FFJsonLibrary* ffJsonLib = NULL;
bool ffJsonLoadLibrary(const FFinstance* instance)
{
static bool loaded = false;
static FFThreadMutex mutex = FF_THREAD_MUTEX_INITIALIZER;
if (!loaded)
{
ffThreadMutexLock(&mutex);
if(!loaded)
{
loaded = true;
ffJsonLib = loadLibSymbols(instance);
}
ffThreadMutexUnlock(&mutex);
}
return !!ffJsonLib;
}
#endif
src/common/json.h
+130
View File
@@ -0,0 +1,130 @@
#pragma once
#ifdef FF_HAVE_JSONC
#include "fastfetch.h"
#include "common/library.h"
#include <assert.h>
#include <json-c/json.h>
typedef struct FFJsonLibrary
{
FF_LIBRARY_SYMBOL(json_tokener_parse)
FF_LIBRARY_SYMBOL(json_object_is_type)
FF_LIBRARY_SYMBOL(json_object_get_array)
FF_LIBRARY_SYMBOL(json_object_get_boolean)
FF_LIBRARY_SYMBOL(json_object_get_double)
FF_LIBRARY_SYMBOL(json_object_get_int)
FF_LIBRARY_SYMBOL(json_object_get_string_len)
FF_LIBRARY_SYMBOL(json_object_get_string)
FF_LIBRARY_SYMBOL(json_object_get_object)
FF_LIBRARY_SYMBOL(json_object_object_del)
FF_LIBRARY_SYMBOL(json_object_object_get)
FF_LIBRARY_SYMBOL(json_object_object_length)
FF_LIBRARY_SYMBOL(json_object_put)
} FFJsonLibrary;
extern const FFJsonLibrary* ffJsonLib;
bool ffJsonLoadLibrary(const FFinstance* instance);
static inline void wrapJsoncFree(json_object** root)
{
assert(root);
if (*root)
json_object_put(*root);
}
extern inline __attribute__((__gnu_inline__, __always_inline__))
struct json_object *json_tokener_parse(const char *str)
{
assert(ffJsonLib);
return ffJsonLib->ffjson_tokener_parse(str);
}
extern inline __attribute__((__gnu_inline__, __always_inline__))
int json_object_is_type(const json_object *obj, enum json_type type)
{
assert(ffJsonLib);
return ffJsonLib->ffjson_object_is_type(obj, type);
}
extern inline __attribute__((__gnu_inline__, __always_inline__))
struct array_list *json_object_get_array(const json_object *obj)
{
assert(ffJsonLib);
return ffJsonLib->ffjson_object_get_array(obj);
}
extern inline __attribute__((__gnu_inline__, __always_inline__))
json_bool json_object_get_boolean(const json_object *obj)
{
assert(ffJsonLib);
return ffJsonLib->ffjson_object_get_boolean(obj);
}
extern inline __attribute__((__gnu_inline__, __always_inline__))
double json_object_get_double(const json_object *obj)
{
assert(ffJsonLib);
return ffJsonLib->ffjson_object_get_double(obj);
}
extern inline __attribute__((__gnu_inline__, __always_inline__))
int32_t json_object_get_int(const json_object *obj)
{
assert(ffJsonLib);
return ffJsonLib->ffjson_object_get_int(obj);
}
extern inline __attribute__((__gnu_inline__, __always_inline__))
int json_object_get_string_len(const json_object *obj)
{
assert(ffJsonLib);
return ffJsonLib->ffjson_object_get_string_len(obj);
}
extern inline __attribute__((__gnu_inline__, __always_inline__))
const char *json_object_get_string(json_object *obj)
{
assert(ffJsonLib);
return ffJsonLib->ffjson_object_get_string(obj);
}
extern inline __attribute__((__gnu_inline__, __always_inline__))
struct lh_table *json_object_get_object(const json_object *obj)
{
assert(ffJsonLib);
return ffJsonLib->ffjson_object_get_object(obj);
}
extern inline __attribute__((__gnu_inline__, __always_inline__))
void json_object_object_del(struct json_object *obj, const char *key)
{
assert(ffJsonLib);
return ffJsonLib->ffjson_object_object_del(obj, key);
}
extern inline __attribute__((__gnu_inline__, __always_inline__))
struct json_object *json_object_object_get(const json_object *obj, const char *key)
{
assert(ffJsonLib);
return ffJsonLib->ffjson_object_object_get(obj, key);
}
extern inline __attribute__((__gnu_inline__, __always_inline__))
int json_object_object_length(const json_object *obj)
{
assert(ffJsonLib);
return ffJsonLib->ffjson_object_object_length(obj);
}
extern inline __attribute__((__gnu_inline__, __always_inline__))
int json_object_put(json_object *obj)
{
assert(ffJsonLib);
return ffJsonLib->ffjson_object_put(obj);
}
#endif
src/common/jsonconfig.c
+61
View File
@@ -0,0 +1,61 @@
#include "fastfetch.h"
#include "common/jsonconfig.h"
#ifdef FF_HAVE_JSONC
bool ffJsonConfigParseModuleArgs(const char* key, json_object* val, FFModuleArgs* moduleArgs)
{
if(strcasecmp(key, "key") == 0)
{
ffStrbufSetNS(&moduleArgs->key, (uint32_t) json_object_get_string_len(val), json_object_get_string(val));
return true;
}
else if(strcasecmp(key, "format") == 0)
{
ffStrbufSetNS(&moduleArgs->outputFormat, (uint32_t) json_object_get_string_len(val), json_object_get_string(val));
return true;
}
else if(strcasecmp(key, "error") == 0)
{
ffStrbufSetNS(&moduleArgs->errorFormat, (uint32_t) json_object_get_string_len(val), json_object_get_string(val));
return true;
}
return false;
}
const char* ffJsonConfigParseEnum(json_object* val, int* result, FFKeyValuePair pairs[])
{
if (json_object_is_type(val, json_type_int))
{
int intVal = json_object_get_int(val);
for (const FFKeyValuePair* pPair = pairs; pPair->key; ++pPair)
{
if (intVal == pPair->value)
{
*result = pPair->value;
return NULL;
}
}
return "Invalid enum integer";
}
else if (json_object_is_type(val, json_type_string))
{
const char* strVal = json_object_get_string(val);
for (const FFKeyValuePair* pPair = pairs; pPair->key; ++pPair)
{
if (strcasecmp(strVal, pPair->key) == 0)
{
*result = pPair->value;
return NULL;
}
}
return "Invalid enum string";
}
else
return "Invalid enum value type; must be a string or integer";
}
#endif
src/common/jsonconfig.h
+10
View File
@@ -0,0 +1,10 @@
#pragma once
#ifdef FF_HAVE_JSONC
#include "common/json.h"
bool ffJsonConfigParseModuleArgs(const char* key, json_object* val, FFModuleArgs* moduleArgs);
const char* ffJsonConfigParseEnum(json_object* val, int* result, FFKeyValuePair pairs[]);
#endif
src/common/library.c
+1 -4
View File
@@ -32,8 +32,7 @@ static void* libraryLoad(const char* path, int maxVersion)
if(result != NULL || maxVersion < 0)
return result;
FFstrbuf pathbuf;
ffStrbufInitA(&pathbuf, 64);
FF_STRBUF_AUTO_DESTROY pathbuf = ffStrbufCreateA(64);
ffStrbufAppendS(&pathbuf, path);
ffStrbufAppendC(&pathbuf, '.');
@@ -49,8 +48,6 @@ static void* libraryLoad(const char* path, int maxVersion)
ffStrbufSubstrBefore(&pathbuf, originalLength);
}
ffStrbufDestroy(&pathbuf);
#endif
return result;
src/common/library.h
+4 -4
View File
@@ -62,16 +62,16 @@ static inline void ffLibraryUnload(void** handle)
__typeof__(&symbolName) FF_LIBRARY_LOAD_SYMBOL_ADDRESS2(library, ff ## symbolName, symbolName, alternateName, "dlsym " #symbolName " failed");
#define FF_LIBRARY_LOAD_SYMBOL_VAR(library, varName, symbolName, returnValue) \
FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, varName.ff ## symbolName, symbolName, returnValue);
FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, (varName).ff ## symbolName, symbolName, returnValue);
#define FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(library, varName, symbolName) \
FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, varName.ff ## symbolName, symbolName, "dlsym " #symbolName " failed");
FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, (varName).ff ## symbolName, symbolName, "dlsym " #symbolName " failed");
#define FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE2(library, varName, symbolName, alternateName) \
FF_LIBRARY_LOAD_SYMBOL_ADDRESS2(library, varName.ff ## symbolName, symbolName, alternateName, "dlsym " #symbolName " failed");
FF_LIBRARY_LOAD_SYMBOL_ADDRESS2(library, (varName).ff ## symbolName, symbolName, alternateName, "dlsym " #symbolName " failed");
#define FF_LIBRARY_LOAD_SYMBOL_PTR(library, varName, symbolName, returnValue) \
FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, varName->ff ## symbolName, symbolName, returnValue);
FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, (varName)->ff ## symbolName, symbolName, returnValue);
void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...);
src/common/networking_windows.c
+1 -2
View File
@@ -75,8 +75,7 @@ bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, con
}
}
FF_STRBUF_AUTO_DESTROY command;
ffStrbufInitA(&command, 64);
FF_STRBUF_AUTO_DESTROY command = ffStrbufCreateA(64);
ffStrbufAppendS(&command, "GET ");
ffStrbufAppendS(&command, path);
ffStrbufAppendS(&command, " HTTP/1.1\nHost: ");
src/common/option.c
+154
View File
@@ -0,0 +1,154 @@
#include "common/option.h"
#include "util/stringUtils.h"
// Return start position of the inner key if the argument key belongs to the module specified, NULL otherwise
const char* ffOptionTestPrefix(const char* argumentKey, const char* moduleName)
{
const char* subKey = argumentKey;
if(!(subKey[0] == '-' && subKey[1] == '-'))
return NULL;
subKey += 2;
uint32_t moduleNameLen = (uint32_t)strlen(moduleName);
if(strncasecmp(subKey, moduleName, moduleNameLen) != 0)
return NULL;
subKey += moduleNameLen;
if(subKey[0] == '\0')
return subKey;
if(subKey[0] != '-')
return NULL;
subKey += 1;
return subKey;
}
bool ffOptionParseModuleArgs(const char* argumentKey, const char* subKey, const char* value, FFModuleArgs* result)
{
if(strcasecmp(subKey, "key") == 0)
{
ffOptionParseString(argumentKey, value, &result->key);
return true;
}
else if(strcasecmp(subKey, "format") == 0)
{
ffOptionParseString(argumentKey, value, &result->outputFormat);
return true;
}
else if(strcasecmp(subKey, "error") == 0)
{
ffOptionParseString(argumentKey, value, &result->errorFormat);
return true;
}
return false;
}
void ffOptionParseString(const char* argumentKey, const char* value, FFstrbuf* buffer)
{
if(value == NULL)
{
fprintf(stderr, "Error: usage: %s <str>\n", argumentKey);
exit(477);
}
ffStrbufSetS(buffer, value);
}
uint32_t ffOptionParseUInt32(const char* argumentKey, const char* value)
{
if(value == NULL)
{
fprintf(stderr, "Error: usage: %s <num>\n", argumentKey);
exit(480);
}
char* end;
uint32_t num = (uint32_t) strtoul(value, &end, 10);
if(*end != '\0')
{
fprintf(stderr, "Error: usage: %s <num>\n", argumentKey);
exit(479);
}
return num;
}
int ffOptionParseEnum(const char* argumentKey, const char* requestedKey, FFKeyValuePair pairs[])
{
if(requestedKey == NULL)
{
fprintf(stderr, "Error: usage: %s <value>\n", argumentKey);
exit(476);
}
for (const FFKeyValuePair* pPair = pairs; pPair->key; ++pPair)
{
if(strcasecmp(requestedKey, pPair->key) == 0)
return pPair->value;
}
fprintf(stderr, "Error: unknown %s value: %s\n", argumentKey, requestedKey);
exit(478);
}
bool ffOptionParseBoolean(const char* str)
{
return (
!ffStrSet(str) ||
strcasecmp(str, "true") == 0 ||
strcasecmp(str, "yes") == 0 ||
strcasecmp(str, "on") == 0 ||
strcasecmp(str, "1") == 0
);
}
void ffOptionParseColor(const char* key, const char* value, FFstrbuf* buffer)
{
if(value == NULL)
{
fprintf(stderr, "Error: usage: %s <str>\n", key);
exit(477);
}
ffStrbufEnsureFree(buffer, 63);
while(*value != '\0')
{
#define FF_APPEND_COLOR_CODE_COND(prefix, code) \
if(strncasecmp(value, #prefix, strlen(#prefix))) { ffStrbufAppendS(buffer, code); value += strlen(#prefix); }
FF_APPEND_COLOR_CODE_COND(reset_, "0;")
else FF_APPEND_COLOR_CODE_COND(bright_, "1;")
else FF_APPEND_COLOR_CODE_COND(black, "30")
else FF_APPEND_COLOR_CODE_COND(red, "31")
else FF_APPEND_COLOR_CODE_COND(green, "32")
else FF_APPEND_COLOR_CODE_COND(yellow, "33")
else FF_APPEND_COLOR_CODE_COND(blue, "34")
else FF_APPEND_COLOR_CODE_COND(magenta, "35")
else FF_APPEND_COLOR_CODE_COND(cyan, "36")
else FF_APPEND_COLOR_CODE_COND(white, "37")
else
{
ffStrbufAppendC(buffer, *value);
++value;
}
#undef FF_APPEND_COLOR_CODE_COND
}
}
void ffOptionInitModuleArg(FFModuleArgs* args)
{
ffStrbufInit(&args->key);
ffStrbufInit(&args->outputFormat);
ffStrbufInit(&args->errorFormat);
}
void ffOptionDestroyModuleArg(FFModuleArgs* args)
{
ffStrbufDestroy(&args->key);
ffStrbufDestroy(&args->outputFormat);
ffStrbufDestroy(&args->errorFormat);
}
src/common/option.h
+26
View File
@@ -0,0 +1,26 @@
#pragma once
#include "util/FFstrbuf.h"
typedef struct FFModuleArgs
{
FFstrbuf key;
FFstrbuf outputFormat;
FFstrbuf errorFormat;
} FFModuleArgs;
typedef struct FFKeyValuePair
{
const char* key;
int value;
} FFKeyValuePair;
const char* ffOptionTestPrefix(const char* argumentKey, const char* moduleName);
bool ffOptionParseModuleArgs(const char* argumentKey, const char* pkey, const char* value, FFModuleArgs* result);
void ffOptionParseString(const char* argumentKey, const char* value, FFstrbuf* buffer);
FF_C_NODISCARD uint32_t ffOptionParseUInt32(const char* argumentKey, const char* value);
FF_C_NODISCARD int ffOptionParseEnum(const char* argumentKey, const char* requestedKey, FFKeyValuePair pairs[]);
FF_C_NODISCARD bool ffOptionParseBoolean(const char* str);
void ffOptionParseColor(const char* key, const char* value, FFstrbuf* buffer);
void ffOptionInitModuleArg(FFModuleArgs* args);
void ffOptionDestroyModuleArg(FFModuleArgs* args);
src/common/printing.c
+4 -15
View File
@@ -26,19 +26,17 @@ void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t mod
}
else
{
FFstrbuf key;
ffStrbufInit(&key);
FF_STRBUF_AUTO_DESTROY key = ffStrbufCreate();
ffParseFormatString(&key, customKeyFormat, 1, (FFformatarg[]){
{FF_FORMAT_ARG_TYPE_UINT8, &moduleIndex}
});
ffPrintUserString(key.chars);
ffStrbufDestroy(&key);
}
if(!instance->config.pipe)
fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
ffStrbufWriteTo(&instance->config.separator, stdout);
ffStrbufWriteTo(&instance->config.keyValueSeparator, stdout);
if(!instance->config.pipe)
fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
@@ -46,9 +44,7 @@ void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t mod
void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments)
{
FFstrbuf buffer;
ffStrbufInitA(&buffer, 256);
FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreateA(256);
ffParseFormatString(&buffer, format, numArgs, arguments);
if(buffer.length > 0)
@@ -57,8 +53,6 @@ void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t m
ffPrintUserString(buffer.chars);
putchar('\n');
}
ffStrbufDestroy(&buffer);
}
void ffPrintFormat(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments)
@@ -74,15 +68,10 @@ static void printError(FFinstance* instance, const char* moduleName, uint8_t mod
if(hasCustomErrorFormat)
{
FFstrbuf error;
ffStrbufInit(&error);
ffStrbufAppendVF(&error, message, arguments);
FF_STRBUF_AUTO_DESTROY error = ffStrbufCreateVF(message, arguments);
ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, customErrorFormat, 1, (FFformatarg[]) {
{FF_FORMAT_ARG_TYPE_STRBUF, &error}
});
ffStrbufDestroy(&error);
}
else
{
src/common/processing_windows.c
+1 -2
View File
@@ -28,8 +28,7 @@ const char* ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[])
BOOL success;
{
FF_STRBUF_AUTO_DESTROY cmdline;
ffStrbufInitF(&cmdline, "\"%s\"", argv[0]);
FF_STRBUF_AUTO_DESTROY cmdline = ffStrbufCreateF("\"%s\"", argv[0]);
for(char* const* parg = &argv[1]; *parg; ++parg)
{
ffStrbufAppendC(&cmdline, ' ');
src/common/properties.c
+3 -15
View File
@@ -146,25 +146,15 @@ done:
bool ffParsePropFileHomeValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
{
FFstrbuf absolutePath;
ffStrbufInitA(&absolutePath, 64);
ffStrbufAppend(&absolutePath, &instance->state.platform.homeDir);
ffStrbufAppendC(&absolutePath, '/');
ffStrbufAppendS(&absolutePath, relativeFile);
bool result = ffParsePropFileValues(absolutePath.chars, numQueries, queries);
ffStrbufDestroy(&absolutePath);
return result;
FF_STRBUF_AUTO_DESTROY absolutePath = ffStrbufCreateF("%s/%s", instance->state.platform.homeDir.chars, relativeFile);
return ffParsePropFileValues(absolutePath.chars, numQueries, queries);
}
bool ffParsePropFileListValues(const FFlist* list, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
{
bool foundAFile = false;
FFstrbuf baseDir;
ffStrbufInitA(&baseDir, 64);
FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateA(64);
FF_LIST_FOR_EACH(FFstrbuf, dirPrefix, *list)
{
@@ -189,7 +179,5 @@ bool ffParsePropFileListValues(const FFlist* list, const char* relativeFile, uin
break;
}
ffStrbufDestroy(&baseDir);
return foundAFile;
}
src/data/config_user.txt
+1 -1
View File
@@ -456,6 +456,6 @@
#--lib-glx /usr/lib/libGLX.so
#--lib-osmesa /usr/lib/libOSMesa.so
#--lib-opencl /usr/lib/libOpenCL.so
#--lib-cjson /usr/lib/libcjson.so
#--lib-jsonc /usr/lib/libjson-c.so
#--lib-freetype /data/data/com.termux/files/usr/lib
#--lib-pulse /usr/lib/libpulse.so
src/data/help.txt
+1 -1
View File
@@ -97,7 +97,7 @@ Library options: Set the path of a library to load
--lib-glx <path>
--lib-osmesa <path>
--lib-opencl <path>
--lib-cjson <path>
--lib-jsonc <path>
--lib-pulse <path>
--lib-freetype <path>
src/detection/battery/battery_android.c
+3 -4
View File
@@ -7,10 +7,9 @@
#define FF_TERMUX_API_PATH FASTFETCH_TARGET_DIR_ROOT "/libexec/termux-api"
#define FF_TERMUX_API_PARAM "BatteryStatus"
const char* ffDetectBatteryImpl(FF_MAYBE_UNUSED FFinstance* instance, FFlist* results)
const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results)
{
FF_STRBUF_AUTO_DESTROY buffer;
ffStrbufInit(&buffer);
FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
if(ffProcessAppendStdOut(&buffer, (char* const[]){
FF_TERMUX_API_PATH,
@@ -35,7 +34,7 @@ const char* ffDetectBatteryImpl(FF_MAYBE_UNUSED FFinstance* instance, FFlist* re
ffStrbufClear(&battery->status);
}
if(instance->config.batteryTemp)
if(instance->config.battery.temp)
{
if(ffParsePropLines(buffer.chars, "\"temperature\": ", &battery->status))
{
src/detection/battery/battery_apple.c
+2 -5
View File
@@ -7,8 +7,7 @@
static double detectBatteryTemp()
{
FF_LIST_AUTO_DESTROY temps;
ffListInit(&temps, sizeof(FFTempValue));
FF_LIST_AUTO_DESTROY temps = ffListCreate(sizeof(FFTempValue));
ffDetectCoreTemps(FF_TEMP_BATTERY, &temps);
@@ -30,8 +29,6 @@ static double detectBatteryTemp()
const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results)
{
FF_UNUSED(instance);
CFMutableDictionaryRef matchDict = IOServiceMatching("AppleSmartBattery");
if (matchDict == NULL)
return "IOServiceMatching(\"AppleSmartBattery\") failed";
@@ -93,7 +90,7 @@ const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results)
else
ffStrbufAppendS(&battery->status, "");
if(instance->config.batteryTemp)
if(instance->config.battery.temp)
battery->temperature = detectBatteryTemp();
else
battery->temperature = FF_BATTERY_TEMP_UNSET;
src/detection/battery/battery_linux.c
+9 -21
View File
@@ -8,8 +8,7 @@ static void parseBattery(FFstrbuf* dir, FFlist* results)
{
uint32_t dirLength = dir->length;
FFstrbuf testBatteryBuffer;
ffStrbufInit(&testBatteryBuffer);
FF_STRBUF_AUTO_DESTROY testBatteryBuffer = ffStrbufCreate();
//type must exist and be "Battery"
ffStrbufAppendS(dir, "/type");
@@ -17,10 +16,7 @@ static void parseBattery(FFstrbuf* dir, FFlist* results)
ffStrbufSubstrBefore(dir, dirLength);
if(ffStrbufIgnCaseCompS(&testBatteryBuffer, "Battery") != 0)
{
ffStrbufDestroy(&testBatteryBuffer);
return;
}
//scope may not exist or must not be "Device"
ffStrbufAppendS(dir, "/scope");
@@ -28,10 +24,7 @@ static void parseBattery(FFstrbuf* dir, FFlist* results)
ffStrbufSubstrBefore(dir, dirLength);
if(ffStrbufIgnCaseCompS(&testBatteryBuffer, "Device") == 0)
{
ffStrbufDestroy(&testBatteryBuffer);
return;
}
BatteryResult* result = ffListAdd(results);
@@ -41,7 +34,7 @@ static void parseBattery(FFstrbuf* dir, FFlist* results)
ffStrbufSubstrBefore(dir, dirLength);
if(available)
result->capacity = ffStrbufToDouble(&testBatteryBuffer);
ffStrbufDestroy(&testBatteryBuffer);
if(!available)
{
result->capacity = 0.0/0.0;
@@ -74,12 +67,13 @@ static void parseBattery(FFstrbuf* dir, FFlist* results)
result->temperature = FF_BATTERY_TEMP_UNSET;
}
const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results) {
FFstrbuf baseDir;
ffStrbufInitA(&baseDir, 64);
if(instance->config.batteryDir.length > 0)
const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results)
{
FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateA(64);
if(instance->config.battery.dir.length > 0)
{
ffStrbufAppend(&baseDir, &instance->config.batteryDir);
ffStrbufAppend(&baseDir, &instance->config.battery.dir);
ffStrbufEnsureEndsWithC(&baseDir, '/');
}
else
@@ -91,10 +85,7 @@ const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results) {
DIR* dirp = opendir(baseDir.chars);
if(dirp == NULL)
{
ffStrbufDestroy(&baseDir);
return "opendir(batteryDir) == NULL";
}
struct dirent* entry;
while((entry = readdir(dirp)) != NULL)
@@ -109,11 +100,8 @@ const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results) {
closedir(dirp);
if(results->length == 0) {
ffStrbufDestroy(&baseDir);
if(results->length == 0)
return "batteryDir doesn't contain any battery folder";
}
ffStrbufDestroy(&baseDir);
return NULL;
}
src/detection/battery/battery_windows.c
+1 -1
View File
@@ -111,7 +111,7 @@ const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results)
}
battery->temperature = 0.0/0.0;
if(instance->config.batteryTemp)
if(instance->config.battery.temp)
{
bqi.InformationLevel = BatteryTemperature;
ULONG temp;
src/detection/brightness/brightness_linux.c
+2 -4
View File
@@ -13,14 +13,12 @@ const char* ffDetectBrightness(FF_MAYBE_UNUSED FFlist* result)
if(dirp == NULL)
return "Failed to open `/sys/class/backlight/`";
FF_STRBUF_AUTO_DESTROY backlightDir;
ffStrbufInitA(&backlightDir, 64);
FF_STRBUF_AUTO_DESTROY backlightDir = ffStrbufCreateA(64);
ffStrbufAppendS(&backlightDir, backlightDirPath);
uint32_t backlightDirLength = backlightDir.length;
FF_STRBUF_AUTO_DESTROY buffer;
ffStrbufInit(&buffer);
FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
struct dirent* entry;
while((entry = readdir(dirp)) != NULL)
src/detection/cpu/cpu_apple.c
+2 -3
View File
@@ -15,8 +15,7 @@ static double getFrequency(const char* propName)
static double detectCpuTemp(const FFstrbuf* cpuName)
{
FF_LIST_AUTO_DESTROY temps;
ffListInit(&temps, sizeof(FFTempValue));
FF_LIST_AUTO_DESTROY temps = ffListCreate(sizeof(FFTempValue));
if(ffStrbufStartsWithS(cpuName, "Apple M1"))
ffDetectCoreTemps(FF_TEMP_CPU_M1X, &temps);
@@ -65,7 +64,7 @@ void ffDetectCPUImpl(const FFinstance* instance, FFCPUResult* cpu)
if(cpu->frequencyMax == 0.0)
cpu->frequencyMax = getFrequency("hw.cpufrequency");
if (instance->config.cpuTemp)
if (instance->config.cpu.temp)
cpu->temperature = detectCpuTemp(&cpu->name);
else
cpu->temperature = FF_CPU_TEMP_UNSET;
src/detection/cpu/cpu_bsd.c
+2 -3
View File
@@ -5,10 +5,9 @@ void ffDetectCPUImpl(const FFinstance* instance, FFCPUResult* cpu)
{
FF_UNUSED(instance);
if (instance->config.cpuTemp)
if (instance->config.cpu.temp)
{
FFstrbuf cpuTemp;
ffStrbufInit(&cpuTemp);
FF_STRBUF_AUTO_DESTROY cpuTemp = ffStrbufCreate();
if(ffSysctlGetString("temperature", &cpuTemp))
cpu->temperature = FF_CPU_TEMP_UNSET;
else
src/detection/cpu/cpu_linux.c
+6 -20
View File
@@ -41,12 +41,10 @@ static void parseCpuInfo(FFCPUResult* cpu, FFstrbuf* physicalCoresBuffer, FFstrb
static double getGHz(const char* file)
{
FFstrbuf content;
ffStrbufInit(&content);
FF_STRBUF_AUTO_DESTROY content = ffStrbufCreate();
if(ffAppendFileBuffer(file, &content))
{
double herz = ffStrbufToDouble(&content);
ffStrbufDestroy(&content);
//ffStrbufToDouble failed
if(herz != herz)
@@ -106,22 +104,15 @@ static void parseIsa(FFstrbuf* cpuIsa)
void ffDetectCPUImpl(const FFinstance* instance, FFCPUResult* cpu)
{
if(instance->config.cpuTemp)
if(instance->config.cpu.temp)
cpu->temperature = detectCPUTemp();
else
cpu->temperature = FF_CPU_TEMP_UNSET;
FFstrbuf physicalCoresBuffer;
ffStrbufInit(&physicalCoresBuffer);
FFstrbuf cpuMHz;
ffStrbufInit(&cpuMHz);
FFstrbuf cpuIsa;
ffStrbufInit(&cpuIsa);
FFstrbuf cpuUarch;
ffStrbufInit(&cpuUarch);
FF_STRBUF_AUTO_DESTROY physicalCoresBuffer = ffStrbufCreate();
FF_STRBUF_AUTO_DESTROY cpuMHz = ffStrbufCreate();
FF_STRBUF_AUTO_DESTROY cpuIsa = ffStrbufCreate();
FF_STRBUF_AUTO_DESTROY cpuUarch = ffStrbufCreate();
parseCpuInfo(cpu, &physicalCoresBuffer, &cpuMHz, &cpuIsa, &cpuUarch);
@@ -155,9 +146,4 @@ void ffDetectCPUImpl(const FFinstance* instance, FFCPUResult* cpu)
ffStrbufAppendC(&cpu->name, ' ');
ffStrbufAppend(&cpu->name, &cpuIsa);
}
ffStrbufDestroy(&physicalCoresBuffer);
ffStrbufDestroy(&cpuMHz);
ffStrbufDestroy(&cpuIsa);
ffStrbufDestroy(&cpuUarch);
}
src/detection/cpu/cpu_windows.c
+1 -1
View File
@@ -51,6 +51,6 @@ void ffDetectCPUImpl(const FFinstance* instance, FFCPUResult* cpu)
ffRegReadStrbuf(hKey, L"ProcessorNameString", &cpu->name, NULL);
ffRegReadStrbuf(hKey, L"VendorIdentifier", &cpu->vendor, NULL);
if(instance->config.cpuTemp)
if(instance->config.cpu.temp)
ffDetectSmbiosTemp(&cpu->temperature, NULL);
}
src/detection/cpuUsage/cpuUsage.h
-8
View File
@@ -1,8 +0,0 @@
#pragma once
#ifndef FF_INCLUDED_detection_cpu_cpuUsage
#define FF_INCLUDED_detection_cpu_cpuUsage
const char* ffGetCpuUsageResult(double* result);
#endif
src/detection/cpuUsage/cpuUsage.c → src/detection/cpuusage/cpuusage.c
+1 -2
View File
@@ -1,6 +1,5 @@
#include "fastfetch.h"
#include "cpuUsage.h"
#include "detection/cpuusage/cpuusage.h"
#include "common/time.h"
#include <stdint.h>
src/detection/cpuusage/cpuusage.h
+8
View File
@@ -0,0 +1,8 @@
#pragma once
#ifndef FF_INCLUDED_detection_cpuusage_cpuusage
#define FF_INCLUDED_detection_cpuusage_cpuusage
const char* ffGetCpuUsageResult(double* result);
#endif
src/detection/cpuUsage/cpuUsage_apple.c → src/detection/cpuusage/cpuusage_apple.c
+1 -1
View File
@@ -1,5 +1,5 @@
#include "fastfetch.h"
#include "cpuUsage.h"
#include "detection/cpuusage/cpuusage.h"
#include <mach/processor_info.h>
#include <mach/mach_host.h>
src/detection/cpuUsage/cpuUsage_bsd.c → src/detection/cpuusage/cpuusage_bsd.c
+1 -1
View File
@@ -1,4 +1,4 @@
#include "cpuUsage.h"
#include "detection/cpuusage/cpuusage.h"
#include <sys/types.h>
#include <sys/user.h>
src/detection/cpuUsage/cpuUsage_linux.c → src/detection/cpuusage/cpuusage_linux.c
+1 -1
View File
@@ -1,5 +1,5 @@
#include "fastfetch.h"
#include "cpuUsage.h"
#include "detection/cpuusage/cpuusage.h"
#include <stdio.h>
#include <inttypes.h>
src/detection/cpuUsage/cpuUsage_windows.c → src/detection/cpuusage/cpuusage_windows.c
+1 -1
View File
@@ -1,5 +1,5 @@
#include "fastfetch.h"
#include "cpuUsage.h"
#include "detection/cpuusage/cpuusage.h"
#include "util/mallocHelper.h"
src/detection/disk/disk_linux.c
+2 -4
View File
@@ -112,8 +112,7 @@ static void detectName(FFDisk* disk, const FFstrbuf* device)
if(stat(device->chars, &deviceStat) != 0)
return;
FF_STRBUF_AUTO_DESTROY basePath;
ffStrbufInit(&basePath);
FF_STRBUF_AUTO_DESTROY basePath = ffStrbufCreate();
//Try partlabel first
ffStrbufSetS(&basePath, "/dev/disk/by-partlabel/");
@@ -202,8 +201,7 @@ void ffDetectDisksImpl(FFDiskResult* disks)
return;
}
FF_LIST_AUTO_DESTROY devices;
ffListInit(&devices, sizeof(FFstrbuf));
FF_LIST_AUTO_DESTROY devices = ffListCreate(sizeof(FFstrbuf));
char* line = NULL;
size_t len = 0;
src/detection/displayserver/displayserver_apple.c
+2 -3
View File
@@ -40,8 +40,7 @@ static void detectDisplays(FFDisplayServerResult* ds, bool detectName)
}
}
FF_STRBUF_AUTO_DESTROY name;
ffStrbufInit(&name);
FF_STRBUF_AUTO_DESTROY name = ffStrbufCreate();
if(detectName && CoreDisplay_DisplayCreateInfoDictionary)
{
CFDictionaryRef FF_CFTYPE_AUTO_RELEASE displayInfo = CoreDisplay_DisplayCreateInfoDictionary(screen);
@@ -121,5 +120,5 @@ void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* ins
ffStrbufAppendS(&ds->dePrettyName, "Aqua");
ffListInitA(&ds->displays, sizeof(FFDisplayResult), 4);
detectDisplays(ds, instance->config.displayDetectName);
detectDisplays(ds, instance->config.display.detectName);
}
src/detection/displayserver/displayserver_nosupport.c
+6 -6
View File
@@ -4,11 +4,11 @@ void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* ins
{
FF_UNUSED(instance);
ffStrbufInitA(&ds->wmProcessName, 0);
ffStrbufInitA(&ds->wmPrettyName, 0);
ffStrbufInitA(&ds->wmProtocolName, 0);
ffStrbufInitA(&ds->deProcessName, 0);
ffStrbufInitA(&ds->dePrettyName, 0);
ffStrbufInitA(&ds->deVersion, 0);
ffStrbufInit(&ds->wmProcessName);
ffStrbufInit(&ds->wmPrettyName);
ffStrbufInit(&ds->wmProtocolName);
ffStrbufInit(&ds->deProcessName);
ffStrbufInit(&ds->dePrettyName);
ffStrbufInit(&ds->deVersion);
ffListInitA(&ds->displays, sizeof(FFDisplayResult), 0);
}
src/detection/displayserver/displayserver_windows.c
+2 -3
View File
@@ -42,8 +42,7 @@ static void detectDisplays(FFDisplayServerResult* ds, bool detectName)
DeleteDC(hdc);
}
FF_STRBUF_AUTO_DESTROY name;
ffStrbufInit(&name);
FF_STRBUF_AUTO_DESTROY name = ffStrbufCreate();
if (detectName)
{
@@ -113,7 +112,7 @@ void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* ins
ffStrbufInit(&ds->deVersion);
ffListInit(&ds->displays, sizeof(FFDisplayResult));
detectDisplays(ds, instance->config.displayDetectName);
detectDisplays(ds, instance->config.display.detectName);
//https://github.com/hykilpikonna/hyfetch/blob/master/neofetch#L2067
const FFOSResult* os = ffDetectOS(instance);
src/detection/displayserver/linux/displayserver_linux.c
+1 -3
View File
@@ -10,8 +10,7 @@ static void parseDRM(FFDisplayServerResult* result)
if(dirp == NULL)
return;
FFstrbuf drmDir;
ffStrbufInitA(&drmDir, 64);
FF_STRBUF_AUTO_DESTROY drmDir = ffStrbufCreateA(64);
ffStrbufAppendS(&drmDir, drmDirPath);
uint32_t drmDirLength = drmDir.length;
@@ -48,7 +47,6 @@ static void parseDRM(FFDisplayServerResult* result)
}
closedir(dirp);
ffStrbufDestroy(&drmDir);
}
void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* instance)
src/detection/displayserver/linux/wayland.c
+2 -4
View File
@@ -42,13 +42,11 @@ static void waylandDetectWM(int fd, FFDisplayServerResult* result)
if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &len) == -1)
return;
FFstrbuf procPath;
ffStrbufInit(&procPath);
FF_STRBUF_AUTO_DESTROY procPath = ffStrbufCreate();
ffStrbufAppendF(&procPath, "/proc/%d/cmdline", ucred.pid); //We check the cmdline for the process name, because it is not trimmed.
ffReadFileBuffer(procPath.chars, &result->wmProcessName);
ffStrbufSubstrBeforeFirstC(&result->wmProcessName, '\0'); //Trim the arguments
ffStrbufSubstrAfterLastC(&result->wmProcessName, '/'); //Trim the path
ffStrbufDestroy(&procPath);
}
#else
static void waylandDetectWM(int fd, FFDisplayServerResult* result)
@@ -225,7 +223,7 @@ bool detectWayland(const FFinstance* instance, FFDisplayServerResult* result)
if(data.display == NULL)
return false;
data.detectName = instance->config.displayDetectName;
data.detectName = instance->config.display.detectName;
waylandDetectWM(ffwl_display_get_fd(data.display), result);
src/detection/displayserver/linux/wmde.c
+8 -32
View File
@@ -165,14 +165,9 @@ static void getMate(const FFinstance* instance, FFDisplayServerResult* result)
ffStrbufSetS(&result->deProcessName, "mate-session");
ffStrbufSetS(&result->dePrettyName, FF_DE_PRETTY_MATE);
FFstrbuf major;
ffStrbufInit(&major);
FFstrbuf minor;
ffStrbufInit(&minor);
FFstrbuf micro;
ffStrbufInit(&micro);
FF_STRBUF_AUTO_DESTROY major = ffStrbufCreate();
FF_STRBUF_AUTO_DESTROY minor = ffStrbufCreate();
FF_STRBUF_AUTO_DESTROY micro = ffStrbufCreate();
ffParsePropFileDataValues(instance, "mate-about/mate-version.xml", 3, (FFpropquery[]) {
{"<platform>", &major},
@@ -182,10 +177,6 @@ static void getMate(const FFinstance* instance, FFDisplayServerResult* result)
ffParseSemver(&result->deVersion, &major, &minor, &micro);
ffStrbufDestroy(&major);
ffStrbufDestroy(&minor);
ffStrbufDestroy(&micro);
if(result->deVersion.length == 0 && instance->config.allowSlowOperations)
{
ffProcessAppendStdOut(&result->deVersion, (char* const[]){
@@ -244,13 +235,10 @@ static void getLXQt(const FFinstance* instance, FFDisplayServerResult* result)
ffParsePropLines(result->deVersion.chars , "liblxqt", &result->deVersion);
}
FFstrbuf wmProcessNameBuffer;
ffStrbufInit(&wmProcessNameBuffer);
FF_STRBUF_AUTO_DESTROY wmProcessNameBuffer = ffStrbufCreate();
ffParsePropFileConfig(instance, "lxqt/session.conf", "window_manager =", &wmProcessNameBuffer);
applyBetterWM(result, wmProcessNameBuffer.chars);
ffStrbufDestroy(&wmProcessNameBuffer);
}
static void getBudgie(const FFinstance* instance, FFDisplayServerResult* result)
@@ -351,21 +339,14 @@ static void getFromProcDir(const FFinstance* instance, FFDisplayServerResult* re
if(proc == NULL)
return;
FFstrbuf procPath;
ffStrbufInitA(&procPath, 64);
FF_STRBUF_AUTO_DESTROY procPath = ffStrbufCreateA(64);
ffStrbufAppendS(&procPath, "/proc/");
uint32_t procPathLength = procPath.length;
FFstrbuf userID;
ffStrbufInit(&userID);
ffStrbufAppendF(&userID, "%i", getuid());
FFstrbuf loginuid;
ffStrbufInit(&loginuid);
FFstrbuf processName;
ffStrbufInitA(&processName, 256); //Some processes have large command lines (looking at you chrome)
FF_STRBUF_AUTO_DESTROY userID = ffStrbufCreateF("%i", getuid());
FF_STRBUF_AUTO_DESTROY loginuid = ffStrbufCreate();
FF_STRBUF_AUTO_DESTROY processName = ffStrbufCreateA(256); //Some processes have large command lines (looking at you chrome)
struct dirent* dirent;
while((dirent = readdir(proc)) != NULL)
@@ -407,11 +388,6 @@ static void getFromProcDir(const FFinstance* instance, FFDisplayServerResult* re
}
closedir(proc);
ffStrbufDestroy(&processName);
ffStrbufDestroy(&loginuid);
ffStrbufDestroy(&userID);
ffStrbufDestroy(&procPath);
}
void ffdsDetectWMDE(const FFinstance* instance, FFDisplayServerResult* result)
src/detection/gamepad/gamepad_linux.c
+1 -2
View File
@@ -10,8 +10,7 @@ const char* ffDetectGamepad(FF_MAYBE_UNUSED const FFinstance* instance, FFlist*
if(dirp == NULL)
return "opendir(\"/sys/class/input/\") == NULL";
FF_STRBUF_AUTO_DESTROY path;
ffStrbufInitS(&path, "/sys/class/input/");
FF_STRBUF_AUTO_DESTROY path = ffStrbufCreateS("/sys/class/input/");
uint32_t baseLen = path.length;
struct dirent* entry;
src/detection/gpu/gpu.c
+1 -1
View File
@@ -36,7 +36,7 @@ const FFlist* ffDetectGPU(const FFinstance* instance)
{
FF_DETECTION_INTERNAL_GUARD(FFlist,
ffListInit(&result, sizeof(FFGPUResult));
if(instance->config.gpuForceVulkan || ffDetectGPUImpl(&result, instance) != NULL)
if(instance->config.gpu.forceVulkan || ffDetectGPUImpl(&result, instance) != NULL)
{
const FFVulkanResult* vulkan = ffDetectVulkan(instance);
result = vulkan->gpus;
src/detection/gpu/gpu.h
+1 -8
View File
@@ -14,13 +14,6 @@ extern const char* FF_GPU_VENDOR_NAME_AMD;
extern const char* FF_GPU_VENDOR_NAME_INTEL;
extern const char* FF_GPU_VENDOR_NAME_NVIDIA;
typedef enum FFGpuType
{
FF_GPU_TYPE_UNKNOWN,
FF_GPU_TYPE_INTEGRATED,
FF_GPU_TYPE_DISCRETE,
} FFGpuType;
typedef struct FFGPUMemory
{
uint64_t total;
@@ -29,7 +22,7 @@ typedef struct FFGPUMemory
typedef struct FFGPUResult
{
FFGpuType type;
FFGPUType type;
FFstrbuf vendor;
FFstrbuf name;
FFstrbuf driver;
src/detection/gpu/gpu_apple.c
+2 -3
View File
@@ -9,8 +9,7 @@
static double detectGpuTemp(const FFstrbuf* gpuName)
{
FF_LIST_AUTO_DESTROY temps;
ffListInit(&temps, sizeof(FFTempValue));
FF_LIST_AUTO_DESTROY temps = ffListCreate(sizeof(FFTempValue));
if(ffStrbufStartsWithS(gpuName, "Apple M1"))
ffDetectCoreTemps(FF_TEMP_GPU_M1X, &temps);
@@ -99,7 +98,7 @@ const char* ffDetectGPUImpl(FFlist* gpus, const FFinstance* instance)
if(ffCfDictGetInt(properties, CFSTR("gpu-core-count"), &gpu->coreCount))
gpu->coreCount = FF_GPU_CORE_COUNT_UNSET;
if(instance->config.gpuTemp)
if(instance->config.gpu.temp)
gpu->temperature = detectGpuTemp(&gpu->name);
else
gpu->temperature = FF_GPU_TEMP_UNSET;
src/detection/gpu/gpu_linux.c
+3 -13
View File
@@ -64,14 +64,9 @@ static void drmDetectDeviceName(const FFinstance* instance, FFGPUResult* gpu, PC
#endif
}
FFstrbuf query;
ffStrbufInit(&query);
ffStrbufAppendF(&query, "%X, %X,", device->device_id, revId);
FF_STRBUF_AUTO_DESTROY query = ffStrbufCreateF("%X, %X,", device->device_id, revId);
ffParsePropFileData(instance, "libdrm/amdgpu.ids", query.chars, &gpu->name);
ffStrbufDestroy(&query);
const char* removeStrings[] = {
"AMD ", "ATI ",
" (TM)", "(TM)",
@@ -116,10 +111,7 @@ static void pciDetectDriverName(FFGPUResult* gpu, PCIData* pci, struct pci_dev*
if(!ffStrSet(base))
return;
FFstrbuf path;
ffStrbufInitA(&path, 64);
ffStrbufAppendF(&path, "%s/devices/%04x:%02x:%02x.%d/driver", base, device->domain, device->bus, device->dev, device->func);
FF_STRBUF_AUTO_DESTROY path = ffStrbufCreateF("%s/devices/%04x:%02x:%02x.%d/driver", base, device->domain, device->bus, device->dev, device->func);
ffStrbufEnsureFree(&gpu->driver, 1023);
ssize_t resultLength = readlink(path.chars, gpu->driver.chars, gpu->driver.allocated - 1); //-1 for null terminator
if(resultLength > 0)
@@ -128,8 +120,6 @@ static void pciDetectDriverName(FFGPUResult* gpu, PCIData* pci, struct pci_dev*
gpu->driver.chars[resultLength] = '\0';
ffStrbufSubstrAfterLastC(&gpu->driver, '/');
}
ffStrbufDestroy(&path);
}
static void pciDetectTemperatur(FFGPUResult* gpu, struct pci_dev* device)
@@ -216,7 +206,7 @@ static void pciHandleDevice(const FFinstance* instance, FFlist* results, PCIData
gpu->coreCount = FF_GPU_CORE_COUNT_UNSET;
gpu->temperature = FF_GPU_TEMP_UNSET;
if(instance->config.gpuTemp)
if(instance->config.gpu.temp)
pciDetectTemperatur(gpu, device);
}
src/detection/gtk_qt/gtk.c
+1 -4
View File
@@ -162,8 +162,7 @@ static void detectGTK(const FFinstance* instance, const char* version, FFGTKResu
return;
//We need to do this because we use multiple threads on configDirs
FFstrbuf baseDir;
ffStrbufInitA(&baseDir, 64);
FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateA(64);
FF_LIST_FOR_EACH(FFstrbuf, configDir, instance->state.platform.configDirs)
{
@@ -172,8 +171,6 @@ static void detectGTK(const FFinstance* instance, const char* version, FFGTKResu
if(allPropertiesSet(result))
break;
}
ffStrbufDestroy(&baseDir);
}
#define FF_DETECT_GTK_IMPL(version) \
src/detection/gtk_qt/qt.c
+1 -6
View File
@@ -85,8 +85,7 @@ static void detectPlasma(const FFinstance* instance, FFQtResult* result)
bool foundAFile = false;
//We need to do this because we use multiple threads on configDirs
FFstrbuf baseDir;
ffStrbufInitA(&baseDir, 64);
FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateA(64);
FF_LIST_FOR_EACH(FFstrbuf, configDir, instance->state.platform.configDirs)
{
@@ -97,13 +96,9 @@ static void detectPlasma(const FFinstance* instance, FFQtResult* result)
foundAFile = true;
if(allValuesSet(result))
{
ffStrbufDestroy(&baseDir);
return;
}
}
ffStrbufDestroy(&baseDir);
if(!foundAFile)
return;
src/detection/host/host_android.c
+2 -2
View File
@@ -32,6 +32,6 @@ void ffDetectHostImpl(FFHostResult* host)
//Not implemented
ffStrbufInitA(&host->productVersion, 0);
ffStrbufInitA(&host->productSku, 0);
ffStrbufInit(&host->productVersion);
ffStrbufInit(&host->productSku);
}
src/detection/host/host_linux.c
+1 -3
View File
@@ -89,8 +89,7 @@ void ffDetectHostImpl(FFHostResult* host)
{
ffStrbufAppendS(&host->productName, "Windows Subsystem for Linux");
FFstrbuf wslVer; //Wide charactors
ffStrbufInit(&wslVer);
FF_STRBUF_AUTO_DESTROY wslVer = ffStrbufCreate(); //Wide charactors
if(!ffProcessAppendStdOut(&wslVer, (char* const[]){
"wsl.exe",
"--version",
@@ -106,7 +105,6 @@ void ffDetectHostImpl(FFHostResult* host)
}
ffStrbufAppendC(&host->productName, ')');
}
ffStrbufDestroy(&wslVer);
}
}
}
src/detection/icons/icons_linux.c
+1 -2
View File
@@ -18,8 +18,7 @@ const char* ffDetectIcons(const FFinstance* instance, FFstrbuf* result)
if(plasma->length == 0 && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0)
return "No icons could be found";
FF_STRBUF_AUTO_DESTROY gtkPretty;
ffStrbufInit(&gtkPretty);
FF_STRBUF_AUTO_DESTROY gtkPretty = ffStrbufCreate();
ffParseGTK(&gtkPretty, gtk2, gtk3, gtk4);
if(plasma->length > 0)
src/detection/localip/localip.h
+1 -1
View File
@@ -13,6 +13,6 @@ typedef struct FFLocalIpResult
FFstrbuf mac;
} FFLocalIpResult;
const char* ffDetectLocalIps(const FFinstance* instance, FFlist* results);
const char* ffDetectLocalIps(const FFLocalIpOptions* options, FFlist* results);
#endif
src/detection/localip/localip_linux.c
+7 -7
View File
@@ -46,7 +46,7 @@ static void addNewIp(FFlist* list, const char* name, const char* addr, int type)
}
}
const char* ffDetectLocalIps(const FFinstance* instance, FFlist* results)
const char* ffDetectLocalIps(const FFLocalIpOptions* options, FFlist* results)
{
struct ifaddrs* ifAddrStruct = NULL;
if(getifaddrs(&ifAddrStruct) < 0)
@@ -57,15 +57,15 @@ const char* ffDetectLocalIps(const FFinstance* instance, FFlist* results)
if (!ifa->ifa_addr || !(ifa->ifa_flags & IFF_RUNNING))
continue;
if ((ifa->ifa_flags & IFF_LOOPBACK) && !(instance->config.localIpShowType & FF_LOCALIP_TYPE_LOOP_BIT))
if ((ifa->ifa_flags & IFF_LOOPBACK) && !(options->showType & FF_LOCALIP_TYPE_LOOP_BIT))
continue;
if (instance->config.localIpNamePrefix.length && strncmp(ifa->ifa_name, instance->config.localIpNamePrefix.chars, instance->config.localIpNamePrefix.length) != 0)
if (options->namePrefix.length && strncmp(ifa->ifa_name, options->namePrefix.chars, options->namePrefix.length) != 0)
continue;
if (ifa->ifa_addr->sa_family == AF_INET)
{
if (!(instance->config.localIpShowType & FF_LOCALIP_TYPE_IPV4_BIT))
if (!(options->showType & FF_LOCALIP_TYPE_IPV4_BIT))
continue;
struct sockaddr_in* ipv4 = (struct sockaddr_in*) ifa->ifa_addr;
@@ -75,7 +75,7 @@ const char* ffDetectLocalIps(const FFinstance* instance, FFlist* results)
}
else if (ifa->ifa_addr->sa_family == AF_INET6)
{
if (!(instance->config.localIpShowType & FF_LOCALIP_TYPE_IPV6_BIT))
if (!(options->showType & FF_LOCALIP_TYPE_IPV6_BIT))
continue;
struct sockaddr_in6* ipv6 = (struct sockaddr_in6 *)ifa->ifa_addr;
@@ -86,7 +86,7 @@ const char* ffDetectLocalIps(const FFinstance* instance, FFlist* results)
#if defined(__FreeBSD__) || defined(__APPLE__)
else if (ifa->ifa_addr->sa_family == AF_LINK)
{
if (!(instance->config.localIpShowType & FF_LOCALIP_TYPE_MAC_BIT))
if (!(options->showType & FF_LOCALIP_TYPE_MAC_BIT))
continue;
char addressBuffer[32];
@@ -98,7 +98,7 @@ const char* ffDetectLocalIps(const FFinstance* instance, FFlist* results)
#else
else if (ifa->ifa_addr->sa_family == AF_PACKET)
{
if (!(instance->config.localIpShowType & FF_LOCALIP_TYPE_MAC_BIT))
if (!(options->showType & FF_LOCALIP_TYPE_MAC_BIT))
continue;
char addressBuffer[32];
src/detection/localip/localip_windows.c
+6 -6
View File
@@ -37,7 +37,7 @@ static void addNewIp(FFlist* list, const char* name, const char* value, int type
}
}
const char* ffDetectLocalIps(const FFinstance* instance, FFlist* results)
const char* ffDetectLocalIps(const FFLocalIpOptions* options, FFlist* results)
{
IP_ADAPTER_ADDRESSES* FF_AUTO_FREE adapter_addresses = NULL;
@@ -51,8 +51,8 @@ const char* ffDetectLocalIps(const FFinstance* instance, FFlist* results)
assert(adapter_addresses);
DWORD error = GetAdaptersAddresses(
instance->config.localIpShowType & FF_LOCALIP_TYPE_IPV4_BIT
? instance->config.localIpShowType & FF_LOCALIP_TYPE_IPV6_BIT ? AF_UNSPEC : AF_INET
options->showType & FF_LOCALIP_TYPE_IPV4_BIT
? options->showType & FF_LOCALIP_TYPE_IPV6_BIT ? AF_UNSPEC : AF_INET
: AF_INET6,
GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER,
NULL,
@@ -71,17 +71,17 @@ const char* ffDetectLocalIps(const FFinstance* instance, FFlist* results)
for (IP_ADAPTER_ADDRESSES* adapter = adapter_addresses; adapter; adapter = adapter->Next)
{
bool isLoop = adapter->IfType == IF_TYPE_SOFTWARE_LOOPBACK;
if (isLoop && !(instance->config.localIpShowType & FF_LOCALIP_TYPE_LOOP_BIT))
if (isLoop && !(options->showType & FF_LOCALIP_TYPE_LOOP_BIT))
continue;
bool newIp = true;
char name[128];
WideCharToMultiByte(CP_UTF8, 0, adapter->FriendlyName, -1, name, sizeof(name), NULL, NULL);
if (instance->config.localIpNamePrefix.length && strncmp(name, instance->config.localIpNamePrefix.chars, instance->config.localIpNamePrefix.length) != 0)
if (options->namePrefix.length && strncmp(name, options->namePrefix.chars, options->namePrefix.length) != 0)
continue;
if (instance->config.localIpShowType & FF_LOCALIP_TYPE_MAC_BIT && adapter->PhysicalAddressLength == 6)
if (options->showType & FF_LOCALIP_TYPE_MAC_BIT && adapter->PhysicalAddressLength == 6)
{
char addressBuffer[32];
uint8_t* ptr = adapter->PhysicalAddress;
src/detection/media/media.c
+1 -1
View File
@@ -6,7 +6,7 @@ void ffDetectMediaImpl(const FFinstance* instance, FFMediaResult* media);
const FFMediaResult* ffDetectMedia(const FFinstance* instance)
{
FF_DETECTION_INTERNAL_GUARD(FFMediaResult,
ffStrbufInitA(&result.error, 0);
ffStrbufInit(&result.error);
ffStrbufInit(&result.playerId);
ffStrbufInit(&result.player);
ffStrbufInit(&result.song);
src/detection/media/media_linux.c
+5 -8
View File
@@ -101,18 +101,15 @@ static bool getBusProperties(FFDBusData* data, const char* busName, FFMediaResul
static void getCustomBus(FFDBusData* data, const FFinstance* instance, FFMediaResult* result)
{
if(ffStrbufStartsWithS(&instance->config.playerName, FF_DBUS_MPRIS_PREFIX))
if(ffStrbufStartsWithS(&instance->config.player.name, FF_DBUS_MPRIS_PREFIX))
{
getBusProperties(data, instance->config.playerName.chars, result);
getBusProperties(data, instance->config.player.name.chars, result);
return;
}
FFstrbuf busName;
ffStrbufInit(&busName);
ffStrbufAppendS(&busName, FF_DBUS_MPRIS_PREFIX);
ffStrbufAppend(&busName, &instance->config.playerName);
FF_STRBUF_AUTO_DESTROY busName = ffStrbufCreateS(FF_DBUS_MPRIS_PREFIX);
ffStrbufAppend(&busName, &instance->config.player.name);
getBusProperties(data, busName.chars, result);
ffStrbufDestroy(&busName);
}
static void getBestBus(FFDBusData* data, FFMediaResult* result)
@@ -161,7 +158,7 @@ static const char* getMedia(const FFinstance* instance, FFMediaResult* result)
if(error != NULL)
return error;
if(instance->config.playerName.length > 0)
if(instance->config.player.name.length > 0)
getCustomBus(&data, instance, result);
else
getBestBus(&data, result);
src/detection/opengl/opengl_linux.c
+3 -3
View File
@@ -315,7 +315,7 @@ const char* ffDetectOpenGL(FFinstance* instance, FFOpenGLResult* result)
{
#if FF_HAVE_GL
if(instance->config.glType == FF_GL_TYPE_GLX)
if(instance->config.openGL.type == FF_OPENGL_TYPE_GLX)
{
#ifdef FF_HAVE_GLX
return glxPrint(instance, result);
@@ -324,7 +324,7 @@ const char* ffDetectOpenGL(FFinstance* instance, FFOpenGLResult* result)
#endif
}
if(instance->config.glType == FF_GL_TYPE_EGL)
if(instance->config.openGL.type == FF_OPENGL_TYPE_EGL)
{
#ifdef FF_HAVE_EGL
return eglPrint(instance, result);
@@ -333,7 +333,7 @@ const char* ffDetectOpenGL(FFinstance* instance, FFOpenGLResult* result)
#endif
}
if(instance->config.glType == FF_GL_TYPE_OSMESA)
if(instance->config.openGL.type == FF_OPENGL_TYPE_OSMESA)
{
#ifdef FF_HAVE_OSMESA
return osMesaPrint(instance, result);
src/detection/os/os_apple.m
+4 -4
View File
@@ -107,10 +107,10 @@ void ffDetectOSImpl(FFOSResult* os, const FFinstance* instance)
ffStrbufInit(&os->prettyName);
ffStrbufInit(&os->versionID);
ffStrbufInitA(&os->codename, 0);
ffStrbufInitA(&os->idLike, 0);
ffStrbufInitA(&os->variant, 0);
ffStrbufInitA(&os->variantID, 0);
ffStrbufInit(&os->codename);
ffStrbufInit(&os->idLike);
ffStrbufInit(&os->variant);
ffStrbufInit(&os->variantID);
parseSystemVersion(os);
src/detection/os/os_linux.c
+2 -2
View File
@@ -96,9 +96,9 @@ static void getUbuntuFlavour(FFOSResult* result)
static void detectOS(FFOSResult* os, const FFinstance* instance)
{
if(instance->config.osFile.length > 0)
if(instance->config.os.file.length > 0)
{
parseFile(instance->config.osFile.chars, os);
parseFile(instance->config.os.file.chars, os);
return;
}
src/detection/packages/packages_apple.c
+2 -4
View File
@@ -28,8 +28,7 @@ static uint32_t getNumElements(const char* dirname, unsigned char type)
static void countBrewPackages(const char* dirname, FFPackagesResult* result)
{
FF_STRBUF_AUTO_DESTROY baseDir;
ffStrbufInitS(&baseDir, dirname);
FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateS(dirname);
uint32_t baseDirLength = baseDir.length;
@@ -54,8 +53,7 @@ static void getBrewPackages(FFPackagesResult* result)
static uint32_t countMacPortsPackages(const char* dirname)
{
FF_STRBUF_AUTO_DESTROY baseDir;
ffStrbufInitS(&baseDir, dirname);
FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateS(dirname);
ffStrbufAppendS(&baseDir, "/var/macports/software");
return getNumElements(baseDir.chars, DT_DIR);
src/detection/packages/packages_linux.c
+4 -12
View File
@@ -132,12 +132,10 @@ static uint32_t getNixPackagesImpl(char* path)
if(!ffPathExists(path, FF_PATHTYPE_DIRECTORY))
return 0;
FFstrbuf output;
ffStrbufInitA(&output, 128);
FF_STRBUF_AUTO_DESTROY output = ffStrbufCreateA(128);
//https://github.com/LinusDierheimer/fastfetch/issues/195#issuecomment-1191748222
FFstrbuf command;
ffStrbufInitA(&command, 255);
FF_STRBUF_AUTO_DESTROY command = ffStrbufCreateA(255);
ffStrbufAppendS(&command, "for x in $(nix-store --query --requisites ");
ffStrbufAppendS(&command, path);
ffStrbufAppendS(&command, "); do if [ -d $x ]; then echo $x ; fi ; done | cut -d- -f2- | egrep '([0-9]{1,}\\.)+[0-9]{1,}' | egrep -v '\\-doc$|\\-man$|\\-info$|\\-dev$|\\-bin$|^nixos-system-nixos-' | uniq | wc -l");
@@ -149,12 +147,7 @@ static uint32_t getNixPackagesImpl(char* path)
NULL
});
int result = (int) strtol(output.chars, NULL, 10);
ffStrbufDestroy(&command);
ffStrbufDestroy(&output);
return (uint32_t) result;
return (uint32_t) strtol(output.chars, NULL, 10);
}
static uint32_t getNixPackages(FFstrbuf* baseDir, const char* dirname)
@@ -329,8 +322,7 @@ static void getPackageCountsBedrock(const FFinstance* instance, FFstrbuf* baseDi
void ffDetectPackagesImpl(const FFinstance* instance, FFPackagesResult* result)
{
FF_STRBUF_AUTO_DESTROY baseDir;
ffStrbufInitA(&baseDir, 512);
FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateA(512);
ffStrbufAppendS(&baseDir, FASTFETCH_TARGET_DIR_ROOT);
if(ffStrbufIgnCaseEqualS(&ffDetectOS(instance)->id, "bedrock"))
src/detection/packages/packages_windows.c
+1 -2
View File
@@ -34,8 +34,7 @@ static uint32_t getNumElements(const char* searchPath /* including `\*` suffix *
static void detectScoop(const FFinstance* instance, FFPackagesResult* result)
{
FF_STRBUF_AUTO_DESTROY scoopPath;
ffStrbufInitA(&scoopPath, MAX_PATH + 3);
FF_STRBUF_AUTO_DESTROY scoopPath = ffStrbufCreateA(MAX_PATH + 3);
const char* scoopEnv = getenv("SCOOP");
if(ffStrSet(scoopEnv))
src/detection/poweradapter/poweradapter.h
+2 -2
View File
@@ -16,7 +16,7 @@ typedef struct PowerAdapterResult
const char* ffDetectPowerAdapterImpl(FFinstance* instance, FFlist* results);
#define FF_POWER_ADAPTER_UNSET -2
#define FF_POWER_ADAPTER_NOT_CONNECTED -1
#define FF_POWERADAPTER_UNSET -2
#define FF_POWERADAPTER_NOT_CONNECTED -1
#endif
src/detection/poweradapter/poweradapter_apple.c
+2 -2
View File
@@ -32,14 +32,14 @@ const char* ffDetectPowerAdapterImpl(FFinstance* instance, FFlist* results)
ffStrbufInit(&adapter->description);
ffStrbufInit(&adapter->manufacturer);
ffStrbufInit(&adapter->modelName);
adapter->watts = FF_POWER_ADAPTER_UNSET;
adapter->watts = FF_POWERADAPTER_UNSET;
CFDictionaryRef adapterDict;
if(!ffCfDictGetDict(properties, CFSTR("AdapterDetails"), &adapterDict))
{
if (ffCfDictGetInt(adapterDict, CFSTR("Watts"), &adapter->watts))
{
adapter->watts = FF_POWER_ADAPTER_NOT_CONNECTED;
adapter->watts = FF_POWERADAPTER_NOT_CONNECTED;
continue;
}
ffCfDictGetString(adapterDict, CFSTR("Name"), &adapter->name);
src/detection/temps/temps_linux.c
+2 -6
View File
@@ -11,8 +11,7 @@ static bool parseHwmonDir(FFstrbuf* dir, FFTempValue* value)
//https://www.kernel.org/doc/Documentation/hwmon/sysfs-interface
uint32_t dirLength = dir->length;
FF_STRBUF_AUTO_DESTROY valueBuffer;
ffStrbufInit(&valueBuffer);
FF_STRBUF_AUTO_DESTROY valueBuffer = ffStrbufCreate();
ffStrbufAppendS(dir, "temp1_input");
if(!ffReadFileBuffer(dir->chars, &valueBuffer))
@@ -58,8 +57,7 @@ const FFTempsResult* ffDetectTemps()
ffListInitA(&result.values, sizeof(FFTempValue), 16);
FFstrbuf baseDir;
ffStrbufInitA(&baseDir, 64);
FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateA(64);
ffStrbufAppendS(&baseDir, "/sys/class/hwmon/");
uint32_t baseDirLength = baseDir.length;
@@ -67,7 +65,6 @@ const FFTempsResult* ffDetectTemps()
DIR* dirp = opendir(baseDir.chars);
if(dirp == NULL)
{
ffStrbufDestroy(&baseDir);
ffThreadMutexUnlock(&mutex);
return &result;
}
@@ -94,7 +91,6 @@ const FFTempsResult* ffDetectTemps()
}
closedir(dirp);
ffStrbufDestroy(&baseDir);
ffThreadMutexUnlock(&mutex);
return &result;
src/detection/terminalfont/terminalfont.c
+56 -108
View File
@@ -6,11 +6,8 @@
static void detectAlacritty(const FFinstance* instance, FFTerminalFontResult* terminalFont)
{
FFstrbuf fontName;
ffStrbufInit(&fontName);
FFstrbuf fontSize;
ffStrbufInit(&fontSize);
FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
FFpropquery fontQuery[] = {
{"family:", &fontName},
@@ -33,15 +30,11 @@ static void detectAlacritty(const FFinstance* instance, FFTerminalFontResult* te
ffStrbufAppendS(&fontSize, "11");
ffFontInitValues(&terminalFont->font, fontName.chars, fontSize.chars);
ffStrbufDestroy(&fontName);
ffStrbufDestroy(&fontSize);
}
FF_MAYBE_UNUSED static void detectTTY(FFTerminalFontResult* terminalFont)
{
FFstrbuf fontName;
ffStrbufInit(&fontName);
FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
ffParsePropFile(FASTFETCH_TARGET_DIR_ETC"/vconsole.conf", "Font =", &fontName);
@@ -61,116 +54,83 @@ FF_MAYBE_UNUSED static void detectTTY(FFTerminalFontResult* terminalFont)
ffFontInitCopy(&terminalFont->font, fontName.chars);
else
ffStrbufAppendS(&terminalFont->error, "Couldn't find Font in "FASTFETCH_TARGET_DIR_ETC"/vconsole.conf");
ffStrbufDestroy(&fontName);
}
#if defined(_WIN32) || defined(__linux__)
#ifdef FF_HAVE_LIBCJSON
#ifdef FF_HAVE_JSONC
#include "common/library.h"
#include "common/processing.h"
#include "common/json.h"
#include <cjson/cJSON.h>
#include <stdlib.h>
typedef struct CJSONData
static const char* detectWTProfile(json_object* profile, FFstrbuf* name, double* size)
{
FF_LIBRARY_SYMBOL(cJSON_Parse)
FF_LIBRARY_SYMBOL(cJSON_IsObject)
FF_LIBRARY_SYMBOL(cJSON_GetObjectItemCaseSensitive)
FF_LIBRARY_SYMBOL(cJSON_IsString)
FF_LIBRARY_SYMBOL(cJSON_GetStringValue)
FF_LIBRARY_SYMBOL(cJSON_IsNumber)
FF_LIBRARY_SYMBOL(cJSON_GetNumberValue)
FF_LIBRARY_SYMBOL(cJSON_IsArray)
FF_LIBRARY_SYMBOL(cJSON_Delete)
json_object* font = json_object_object_get(profile, "font");
if (!font)
return "json_object_object_get(profile, \"font\"); failed";
cJSON* root;
} CJSONData;
if (!json_object_is_type(font, json_type_object))
return "json_object_is_type(font, json_type_object) returns false";
static const char* detectWTProfile(CJSONData* cjsonData, cJSON* profile, FFstrbuf* name, double* size)
{
if(!cjsonData->ffcJSON_IsObject(profile))
return "cJSON_IsObject(profile) returns false";
cJSON* font = cjsonData->ffcJSON_GetObjectItemCaseSensitive(profile, "font");
if(!cjsonData->ffcJSON_IsObject(font))
return "cJSON_IsObject(font) returns false";
if(name->length == 0)
if (name->length == 0)
{
cJSON* pface = cjsonData->ffcJSON_GetObjectItemCaseSensitive(font, "face");
if(cjsonData->ffcJSON_IsString(pface))
ffStrbufAppendS(name, cjsonData->ffcJSON_GetStringValue(pface));
json_object* pface = json_object_object_get(font, "face");
if(json_object_is_type(pface, json_type_string))
ffStrbufAppendNS(name, (uint32_t) json_object_get_string_len(pface), json_object_get_string(pface));
}
if(*size < 0)
if (*size < 0)
{
cJSON* psize = cjsonData->ffcJSON_GetObjectItemCaseSensitive(font, "size");
if(cjsonData->ffcJSON_IsNumber(psize))
*size = cjsonData->ffcJSON_GetNumberValue(psize);
json_object* psize = json_object_object_get(font, "size");
if (json_object_is_type(psize, json_type_int) || json_object_is_type(psize, json_type_double))
*size = json_object_get_double(psize);
}
return NULL;
}
static inline void wrapCjsonFree(CJSONData* data)
{
assert(data);
if (data->root)
data->ffcJSON_Delete(data->root);
}
static const char* detectFromWTImpl(const FFinstance* instance, FFstrbuf* content, FFstrbuf* name, double* size)
{
FF_LIBRARY_LOAD(libcjson, &instance->config.libcJSON, "dlopen libcjson" FF_LIBRARY_EXTENSION " failed", "libcjson"FF_LIBRARY_EXTENSION, 1)
CJSONData __attribute__((__cleanup__(wrapCjsonFree))) cjsonData = {}; // Make sure cjsonData is destroyed before libcjson is dlclosed
FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE2(libcjson, cjsonData, cJSON_Parse, cJSON_Parse@4)
FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE2(libcjson, cjsonData, cJSON_IsObject, cJSON_IsObject@4)
FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE2(libcjson, cjsonData, cJSON_GetObjectItemCaseSensitive, cJSON_GetObjectItemCaseSensitive@8)
FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE2(libcjson, cjsonData, cJSON_IsString, cJSON_IsString@4)
FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE2(libcjson, cjsonData, cJSON_GetStringValue, cJSON_GetStringValue@4)
FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE2(libcjson, cjsonData, cJSON_IsNumber, cJSON_IsNumber@4)
FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE2(libcjson, cjsonData, cJSON_GetNumberValue, cJSON_GetNumberValue@4)
FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE2(libcjson, cjsonData, cJSON_IsArray, cJSON_IsArray@4)
FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE2(libcjson, cjsonData, cJSON_Delete, cJSON_Delete@4)
if (!ffJsonLoadLibrary(instance))
return "Failed to load json-c library";
cJSON* root = cjsonData.root = cjsonData.ffcJSON_Parse(content->chars);
if(!cjsonData.ffcJSON_IsObject(root))
return "cJSON_Parse() failed";
json_object* __attribute__((__cleanup__(wrapJsoncFree))) root = json_tokener_parse(content->chars);
if (!root)
return "Failed to parse WT JSON config file";
cJSON* profiles = cjsonData.ffcJSON_GetObjectItemCaseSensitive(root, "profiles");
if(!cjsonData.ffcJSON_IsObject(profiles))
return "cJSON_GetObjectItemCaseSensitive(root, \"profiles\") failed";
json_object* profiles = json_object_object_get(root, "profiles");
if (!profiles)
return "json_object_object_get(root, \"profiles\") failed";
FF_STRBUF_AUTO_DESTROY wtProfileId;
ffStrbufInitS(&wtProfileId, getenv("WT_PROFILE_ID"));
FF_STRBUF_AUTO_DESTROY wtProfileId = ffStrbufCreateS(getenv("WT_PROFILE_ID"));
ffStrbufTrim(&wtProfileId, '\'');
if(wtProfileId.length > 0)
if (wtProfileId.length > 0)
{
cJSON* list = cjsonData.ffcJSON_GetObjectItemCaseSensitive(profiles, "list");
if(cjsonData.ffcJSON_IsArray(list))
array_list* list = json_object_get_array(json_object_object_get(profiles, "list"));
if (list)
{
cJSON* profile;
cJSON_ArrayForEach(profile, list)
for (size_t idx = 0; idx < list->length; ++idx)
{
if(!cjsonData.ffcJSON_IsObject(profile))
json_object* profile = (json_object*) list->array[idx];
json_object* guid = json_object_object_get(profile, "guid");
if (!json_object_is_type(guid, json_type_string))
continue;
cJSON* guid = cjsonData.ffcJSON_GetObjectItemCaseSensitive(profile, "guid");
if(!cjsonData.ffcJSON_IsString(guid))
continue;
if(ffStrbufCompS(&wtProfileId, cjsonData.ffcJSON_GetStringValue(guid)) == 0)
if(ffStrbufEqualS(&wtProfileId, json_object_get_string(guid)))
{
detectWTProfile(&cjsonData, profile, name, size);
detectWTProfile(profile, name, size);
break;
}
}
}
}
cJSON* defaults = cjsonData.ffcJSON_GetObjectItemCaseSensitive(profiles, "defaults");
if(defaults)
detectWTProfile(&cjsonData, defaults, name, size);
json_object* defaults = json_object_object_get(profiles, "defaults");
if (defaults)
detectWTProfile(defaults, name, size);
if(name->length == 0)
ffStrbufSetS(name, "Cascadia Mono");
@@ -188,8 +148,7 @@ static const char* detectFromWTImpl(const FFinstance* instance, FFstrbuf* conten
static void detectFromWindowsTeriminal(const FFinstance* instance, const FFstrbuf* terminalExe, FFTerminalFontResult* terminalFont)
{
//https://learn.microsoft.com/en-us/windows/terminal/install#settings-json-file
FF_STRBUF_AUTO_DESTROY json;
ffStrbufInit(&json);
FF_STRBUF_AUTO_DESTROY json = ffStrbufCreate();
const char* error = NULL;
#ifdef _WIN32
@@ -258,8 +217,7 @@ static void detectFromWindowsTeriminal(const FFinstance* instance, const FFstrbu
return;
}
FF_STRBUF_AUTO_DESTROY name;
ffStrbufInit(&name);
FF_STRBUF_AUTO_DESTROY name = ffStrbufCreate();
double size = -1;
error = detectFromWTImpl(instance, &json, &name, &size);
@@ -273,25 +231,22 @@ static void detectFromWindowsTeriminal(const FFinstance* instance, const FFstrbu
}
}
#else //FF_HAVE_CJSON
#else //FF_HAVE_JSONC
static void detectFromWindowsTeriminal(const FFinstance* instance, const FFstrbuf* terminalExe, FFTerminalFontResult* terminalFont)
{
FF_UNUSED(instance, terminalExe, terminalFont);
ffStrbufAppendS(&terminalFont->error, "Fastfetch was built without libcJSON support");
ffStrbufAppendS(&terminalFont->error, "Fastfetch was built without json-c support");
}
#endif //FF_HAVE_CJSON
#endif //FF_HAVE_JSONC
#endif //defined(_WIN32) || defined(__linux__)
FF_MAYBE_UNUSED static bool detectKitty(const FFinstance* instance, FFTerminalFontResult* result)
{
FF_STRBUF_AUTO_DESTROY fontName;
ffStrbufInit(&fontName);
FF_STRBUF_AUTO_DESTROY fontSize;
ffStrbufInit(&fontSize);
FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
FFpropquery fontQuery[] = {
{"font_family ", &fontName},
@@ -313,11 +268,8 @@ FF_MAYBE_UNUSED static bool detectKitty(const FFinstance* instance, FFTerminalFo
static void detectTerminator(const FFinstance* instance, FFTerminalFontResult* result)
{
FF_STRBUF_AUTO_DESTROY useSystemFont;
ffStrbufInit(&useSystemFont);
FF_STRBUF_AUTO_DESTROY fontName;
ffStrbufInit(&fontName);
FF_STRBUF_AUTO_DESTROY useSystemFont = ffStrbufCreate();
FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
FFpropquery fontQuery[] = {
{"use_system_font =", &useSystemFont},
@@ -344,8 +296,7 @@ static void detectTerminator(const FFinstance* instance, FFTerminalFontResult* r
static bool detectWezterm(FF_MAYBE_UNUSED const FFinstance* instance, FFTerminalFontResult* result)
{
FF_STRBUF_AUTO_DESTROY fontName;
ffStrbufInit(&fontName);
FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
ffStrbufSetS(&result->error, ffProcessAppendStdOut(&fontName, (char* const[]){
"wezterm",
@@ -372,11 +323,8 @@ static bool detectWezterm(FF_MAYBE_UNUSED const FFinstance* instance, FFTerminal
static bool detectTabby(FF_MAYBE_UNUSED const FFinstance* instance, FFTerminalFontResult* result)
{
FF_STRBUF_AUTO_DESTROY fontName;
ffStrbufInit(&fontName);
FF_STRBUF_AUTO_DESTROY fontSize;
ffStrbufInit(&fontSize);
FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
FFpropquery fontQuery[] = {
{"font: ", &fontName},
@@ -434,7 +382,7 @@ static bool detectTerminalFontCommon(const FFinstance* instance, const FFTermina
const FFTerminalFontResult* ffDetectTerminalFont(const FFinstance* instance)
{
FF_DETECTION_INTERNAL_GUARD(FFTerminalFontResult,
ffStrbufInitA(&result.error, 0);
ffStrbufInit(&result.error);
const FFTerminalShellResult* terminalShell = ffDetectTerminalShell(instance);
src/detection/terminalfont/terminalfont_apple.m
+1 -2
View File
@@ -46,8 +46,7 @@ static void detectIterm2(const FFinstance* instance, FFTerminalFontResult* termi
static void detectAppleTerminal(FFTerminalFontResult* terminalFont)
{
FF_STRBUF_AUTO_DESTROY font;
ffStrbufInit(&font);
FF_STRBUF_AUTO_DESTROY font = ffStrbufCreate();
ffOsascript("tell application \"Terminal\" to font name of window frontmost & \" \" & font size of window frontmost", &font);
if(font.length == 0)
src/detection/terminalfont/terminalfont_linux.c
+11 -42
View File
@@ -35,8 +35,7 @@ static void detectFromGSettings(const FFinstance* instance, char* profilePath, c
return;
}
FFstrbuf path;
ffStrbufInitA(&path, 128);
FF_STRBUF_AUTO_DESTROY path = ffStrbufCreateA(128);
ffStrbufAppendS(&path, profilePath);
ffStrbufAppendS(&path, defaultProfile);
ffStrbufAppendC(&path, '/');
@@ -57,64 +56,47 @@ static void detectFromGSettings(const FFinstance* instance, char* profilePath, c
else
ffStrbufAppendS(&terminalFont->error, "Could't get system monospace font name from GSettings / DConf");
}
ffStrbufDestroy(&path);
}
static void detectFromConfigFile(const FFinstance* instance, const char* configFile, const char* start, FFTerminalFontResult* terminalFont)
{
FFstrbuf fontName;
ffStrbufInit(&fontName);
FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
ffParsePropFileConfig(instance, 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);
ffStrbufDestroy(&fontName);
}
static void detectKonsole(const FFinstance* instance, FFTerminalFontResult* terminalFont)
{
FFstrbuf profile;
ffStrbufInit(&profile);
FF_STRBUF_AUTO_DESTROY profile = ffStrbufCreate();
ffParsePropFileConfig(instance, "konsolerc", "DefaultProfile =", &profile);
if(profile.length == 0)
{
ffStrbufAppendS(&terminalFont->error, "Couldn't find \"DefaultProfile=%[^\\n]\" in \".config/konsolerc\"");
ffStrbufDestroy(&profile);
return;
}
FFstrbuf profilePath;
ffStrbufInitA(&profilePath, 32);
FF_STRBUF_AUTO_DESTROY profilePath = ffStrbufCreateA(32);
ffStrbufAppendS(&profilePath, "konsole/");
ffStrbufAppend(&profilePath, &profile);
ffStrbufDestroy(&profile);
FFstrbuf fontName;
ffStrbufInit(&fontName);
FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
ffParsePropFileData(instance, 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);
ffStrbufDestroy(&fontName);
ffStrbufDestroy(&profilePath);
}
static void detectXFCETerminal(const FFinstance* instance, FFTerminalFontResult* terminalFont)
{
FFstrbuf useSysFont;
ffStrbufInit(&useSysFont);
FFstrbuf fontName;
ffStrbufInit(&fontName);
FF_STRBUF_AUTO_DESTROY useSysFont = ffStrbufCreate();
FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
ffParsePropFileConfigValues(instance, "xfce4/terminal/terminalrc", 2, (FFpropquery[]) {
{"FontUseSystem = ", &useSysFont},
@@ -136,21 +118,14 @@ static void detectXFCETerminal(const FFinstance* instance, FFTerminalFontResult*
else
ffStrbufAppendS(&terminalFont->error, "Couldn't find xsettings::/Gtk/MonospaceFontName in XFConf");
}
ffStrbufDestroy(&fontName);
ffStrbufDestroy(&useSysFont);
}
static void detectDeepinTerminal(const FFinstance* instance, FFTerminalFontResult* terminalFont)
{
FFstrbuf fontName;
ffStrbufInit(&fontName);
FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
FF_STRBUF_AUTO_DESTROY profile = ffStrbufCreate();
FFstrbuf fontSize;
ffStrbufInit(&fontSize);
FFstrbuf profile;
ffStrbufInit(&profile);
ffStrbufAppend(&profile, &instance->state.platform.homeDir);
ffStrbufAppendS(&profile, ".config/deepin/deepin-terminal/config.conf"); //TODO: Use config dirs
FILE* file = fopen(profile.chars, "r");
@@ -180,23 +155,17 @@ static void detectDeepinTerminal(const FFinstance* instance, FFTerminalFontResul
fclose(file);
}
ffStrbufDestroy(&profile);
if(fontName.length == 0)
ffStrbufAppendS(&fontName, "Noto Sans Mono");
if(fontSize.length == 0)
ffStrbufAppendS(&fontSize, "11");
ffFontInitValues(&terminalFont->font, fontName.chars, fontSize.chars);
ffStrbufDestroy(&fontName);
ffStrbufDestroy(&fontSize);
}
static void detectFootTerminal(const FFinstance* instance, FFTerminalFontResult* terminalFont)
{
FF_STRBUF_AUTO_DESTROY font;
ffStrbufInit(&font);
FF_STRBUF_AUTO_DESTROY font = ffStrbufCreate();
if (!ffParsePropFileConfig(instance, "foot/foot.ini", "font=", &font) || !ffStrSet(font.chars))
{
src/detection/terminalfont/terminalfont_windows.c
+5 -17
View File
@@ -8,11 +8,8 @@
static void detectMintty(const FFinstance* instance, FFTerminalFontResult* terminalFont)
{
FF_STRBUF_AUTO_DESTROY fontName;
ffStrbufInit(&fontName);
FF_STRBUF_AUTO_DESTROY fontSize;
ffStrbufInit(&fontSize);
FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
if(!ffParsePropFileConfigValues(instance, "mintty/config", 2, (FFpropquery[]) {
{"Font=", &fontName},
@@ -54,14 +51,9 @@ static void detectConEmu(const FFinstance* instance, FFTerminalFontResult* termi
FF_UNUSED(instance)
//https://conemu.github.io/en/ConEmuXml.html#search-sequence
FFstrbuf path;
ffStrbufInit(&path);
FFstrbuf fontName;
ffStrbufInit(&fontName);
FFstrbuf fontSize;
ffStrbufInit(&fontSize);
FF_STRBUF_AUTO_DESTROY path = ffStrbufCreate();
FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
const char* paths[] = { "ConEmuDir", "ConEmuBaseDir", "APPDATA" };
for (uint32_t i = 0; i < sizeof(paths) / sizeof(paths[0]); ++i)
@@ -77,7 +69,6 @@ static void detectConEmu(const FFinstance* instance, FFTerminalFontResult* termi
break;
}
}
ffStrbufDestroy(&path);
if(fontName.length == 0 && fontSize.length == 0)
{
@@ -96,9 +87,6 @@ static void detectConEmu(const FFinstance* instance, FFTerminalFontResult* termi
ffStrbufAppendS(&fontSize, "14");
ffFontInitValues(&terminalFont->font, fontName.chars, fontSize.chars);
ffStrbufDestroy(&fontName);
ffStrbufDestroy(&fontSize);
}
void ffDetectTerminalFontPlatform(const FFinstance* instance, const FFTerminalShellResult* terminalShell, FFTerminalFontResult* terminalFont)
src/detection/terminalshell/terminalshell_linux.c
+3 -6
View File
@@ -281,8 +281,7 @@ static void getUserShellFromEnv(const FFinstance* instance, FFTerminalShellResul
static void getShellVersionGeneric(FFstrbuf* exe, const char* exeName, FFstrbuf* version)
{
FFstrbuf command;
ffStrbufInit(&command);
FF_STRBUF_AUTO_DESTROY command = ffStrbufCreate();
ffStrbufAppendS(&command, "printf \"%s\" \"$");
ffStrbufAppendTransformS(&command, exeName, toupper);
ffStrbufAppendS(&command, "_VERSION\"");
@@ -297,8 +296,6 @@ static void getShellVersionGeneric(FFstrbuf* exe, const char* exeName, FFstrbuf*
});
ffStrbufSubstrBeforeFirstC(version, '(');
ffStrbufRemoveStrings(version, 2, "-release", "release");
ffStrbufDestroy(&command);
}
bool fftsGetShellVersion(FFstrbuf* exe, const char* exeName, FFstrbuf* version);
@@ -356,7 +353,7 @@ const FFTerminalShellResult* ffDetectTerminalShell(const FFinstance* instance)
getUserShellFromEnv(instance, &result);
ffStrbufClear(&result.shellVersion);
if(instance->config.shellVersion)
if(instance->config.shell.version)
{
getShellVersion(&result.shellExe, result.shellExeName, &result.shellVersion);
@@ -393,7 +390,7 @@ const FFTerminalShellResult* ffDetectTerminalShell(const FFinstance* instance)
ffStrbufInit(&result.terminalVersion);
if(instance->config.terminalVersion)
if(instance->config.terminal.version)
fftsGetTerminalVersion(&result.terminalProcessName, &result.terminalExe, &result.terminalVersion);
ffThreadMutexUnlock(&mutex);
src/detection/terminalshell/terminalshell_windows.c
+2 -2
View File
@@ -152,7 +152,7 @@ static uint32_t getShellInfo(const FFinstance* instance, FFTerminalShellResult*
}
ffStrbufClear(&result->shellVersion);
if(instance->config.shellVersion)
if(instance->config.shell.version)
fftsGetShellVersion(&result->shellExe, result->shellPrettyName.chars, &result->shellVersion);
result->shellPid = pid;
@@ -351,7 +351,7 @@ const FFTerminalShellResult* ffDetectTerminalShell(const FFinstance* instance)
getTerminalFromEnv(&result);
ffStrbufInit(&result.terminalVersion);
if(instance->config.terminalVersion)
if(instance->config.terminal.version)
fftsGetTerminalVersion(&result.terminalProcessName, &result.terminalExe, &result.terminalVersion);
exit:
src/detection/theme/theme_linux.c
+2 -4
View File
@@ -18,8 +18,7 @@ const char* ffDetectTheme(const FFinstance* instance, FFstrbuf* result)
if(plasma->widgetStyle.length == 0 && plasma->colorScheme.length == 0 && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0)
return "No themes found";
FF_STRBUF_AUTO_DESTROY plasmaColorPretty;
ffStrbufInit(&plasmaColorPretty);
FF_STRBUF_AUTO_DESTROY plasmaColorPretty = ffStrbufCreate();
if(ffStrbufStartsWithIgnCase(&plasma->colorScheme, &plasma->widgetStyle))
ffStrbufAppendNS(&plasmaColorPretty, plasma->colorScheme.length - plasma->widgetStyle.length, &plasma->colorScheme.chars[plasma->widgetStyle.length]);
else
@@ -27,8 +26,7 @@ const char* ffDetectTheme(const FFinstance* instance, FFstrbuf* result)
ffStrbufTrim(&plasmaColorPretty, ' ');
FF_STRBUF_AUTO_DESTROY gtkPretty;
ffStrbufInit(&gtkPretty);
FF_STRBUF_AUTO_DESTROY gtkPretty = ffStrbufCreate();
ffParseGTK(&gtkPretty, gtk2, gtk3, gtk4);
if(plasma->widgetStyle.length > 0)
src/detection/uptime/uptime.h
+1 -1
View File
@@ -5,6 +5,6 @@
#include "fastfetch.h"
uint64_t ffDetectUptime();
const char* ffDetectUptime(uint64_t* result);
#endif
src/detection/uptime/uptime_bsd.c
+6 -4
View File
@@ -4,7 +4,7 @@
#include <sys/sysctl.h>
#include <sys/time.h>
uint64_t ffDetectUptime()
const char* ffDetectUptime(uint64_t* result)
{
struct timeval bootTime;
size_t bootTimeSize = sizeof(bootTime);
@@ -12,8 +12,10 @@ uint64_t ffDetectUptime()
(int[]) {CTL_KERN, KERN_BOOTTIME}, 2,
&bootTime, &bootTimeSize,
NULL, 0
) == 0)
return (uint64_t) difftime(time(NULL), bootTime.tv_sec);
) != 0)
return "sysctl({CTL_KERN, KERN_BOOTTIME}) failed";
return 0;
*result = (uint64_t) difftime(time(NULL), bootTime.tv_sec);
return NULL;
}
src/detection/uptime/uptime_linux.c
+4 -3
View File
@@ -2,10 +2,11 @@
#include <sys/sysinfo.h>
uint64_t ffDetectUptime()
const char* ffDetectUptime(uint64_t* result)
{
struct sysinfo info;
if(sysinfo(&info) != 0)
return 0;
return (uint32_t) info.uptime;
return "sysinfo() failed";
*result = (uint64_t) info.uptime;
return NULL;
}
src/detection/uptime/uptime_windows.c
+3 -2
View File
@@ -2,7 +2,8 @@
#include <sysinfoapi.h>
uint64_t ffDetectUptime()
const char* ffDetectUptime(uint64_t* result)
{
return GetTickCount64() / 1000;
*result = GetTickCount64() / 1000;
return NULL;
}
src/detection/wallpaper/wallpaper_apple.c
+1 -2
View File
@@ -8,8 +8,7 @@ const char* ffDetectWallpaper(FF_MAYBE_UNUSED const FFinstance* instance, FFstrb
#ifdef FF_HAVE_SQLITE3
FF_STRBUF_AUTO_DESTROY path;
ffStrbufInitCopy(&path, &instance->state.platform.homeDir);
FF_STRBUF_AUTO_DESTROY path = ffStrbufCreateCopy(&instance->state.platform.homeDir);
ffStrbufAppendS(&path, "Library/Application Support/Dock/desktoppicture.db");
if (ffSettingsGetSQLite3String(instance, path.chars,
"SELECT value\n"
src/detection/wifi/wifi_android.c
+1 -2
View File
@@ -8,8 +8,7 @@
const char* ffDetectWifi(FF_MAYBE_UNUSED const FFinstance* instance, FFlist* result)
{
FF_STRBUF_AUTO_DESTROY buffer;
ffStrbufInit(&buffer);
FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
if(ffProcessAppendStdOut(&buffer, (char* const[]){
FF_TERMUX_API_PATH,
src/detection/wifi/wifi_linux.c
+2 -5
View File
@@ -144,8 +144,7 @@ static const char* detectWifiWithLibnm(const FFinstance* instance, FFlist* resul
if(instance->config.allowSlowOperations)
{
FF_STRBUF_AUTO_DESTROY output;
ffStrbufInit(&output);
FF_STRBUF_AUTO_DESTROY output = ffStrbufCreate();
if(!ffProcessAppendStdOut(&output, (char* const[]){
"iw",
"dev",
@@ -216,8 +215,7 @@ static const char* detectWifiWithIoctls(FF_MAYBE_UNUSED const FFinstance* instan
if(!infs)
return "if_nameindex() failed";
FFstrbuf path;
ffStrbufInit(&path);
FF_STRBUF_AUTO_DESTROY path = ffStrbufCreate();
for(struct if_nameindex* i = infs; !(i->if_index == 0 && i->if_name == NULL); ++i)
{
@@ -307,7 +305,6 @@ static const char* detectWifiWithIoctls(FF_MAYBE_UNUSED const FFinstance* instan
close(sock);
}
if_freenameindex(infs);
ffStrbufDestroy(&path);
return NULL;
}
src/detection/wmtheme/wmtheme_linux.c
+2 -6
View File
@@ -10,7 +10,7 @@ static bool detectWMThemeFromConfigFile(FFinstance* instance, const char* config
{
if(!ffParsePropFileConfig(instance, configFile, themeRegex, themeOrError))
{
ffStrbufInitF(themeOrError, "Config file %s doesn't exist", configFile);
ffStrbufAppendF(themeOrError, "Config file %s doesn't exist", configFile);
return false;
}
@@ -131,8 +131,7 @@ static bool detectXFWM4(FFinstance* instance, FFstrbuf* themeOrError)
static bool detectOpenbox(FFinstance* instance, const FFstrbuf* dePrettyName, FFstrbuf* themeOrError)
{
FFstrbuf absolutePath;
ffStrbufInitA(&absolutePath, 64);
FF_STRBUF_AUTO_DESTROY absolutePath = ffStrbufCreateA(64);
ffStrbufAppend(&absolutePath, &instance->state.platform.homeDir);
//TODO: use config dirs
@@ -150,7 +149,6 @@ static bool detectOpenbox(FFinstance* instance, const FFstrbuf* dePrettyName, FF
if(file == NULL)
{
ffStrbufAppendF(themeOrError, "Couldn't open \"%s\"", absolutePath.chars);
ffStrbufDestroy(&absolutePath);
return false;
}
@@ -184,11 +182,9 @@ static bool detectOpenbox(FFinstance* instance, const FFstrbuf* dePrettyName, FF
if(themeOrError->length == 0)
{
ffStrbufAppendF(themeOrError, "Couldn't find theme name in \"%s\"", absolutePath.chars);
ffStrbufDestroy(&absolutePath);
return false;
}
ffStrbufDestroy(&absolutePath);
return true;
}
src/detection/wmtheme/wmtheme_windows.c
+1 -2
View File
@@ -66,8 +66,7 @@ bool ffDetectWmTheme(FF_MAYBE_UNUSED FFinstance* instance, FFstrbuf* themeOrErro
FF_HKEY_AUTO_DESTROY hKey = NULL;
if(ffRegOpenKeyForRead(HKEY_CURRENT_USER, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Themes", &hKey, NULL))
{
FF_STRBUF_AUTO_DESTROY theme;
ffStrbufInit(&theme);
FF_STRBUF_AUTO_DESTROY theme = ffStrbufCreate();
if(ffRegReadStrbuf(hKey, L"CurrentTheme", &theme, NULL))
{
ffStrbufSubstrBeforeLastC(&theme, '.');
src/fastfetch.c
+166 -468
View File
@@ -3,8 +3,8 @@
#include "common/parsing.h"
#include "common/io/io.h"
#include "common/time.h"
#include "util/FFvaluestore.h"
#include "util/stringUtils.h"
#include "logo/logo.h"
#include <stdlib.h>
#include <ctype.h>
@@ -17,6 +17,9 @@
#pragma GCC diagnostic ignored "-Wsign-conversion"
#include "common/jsonconfig.h"
#include "modules/modules.h"
typedef struct CustomValue
{
bool printKey;
@@ -26,7 +29,6 @@ typedef struct CustomValue
// Things only needed by fastfetch
typedef struct FFdata
{
FFvaluestore customValues;
FFstrbuf structure;
bool loadUserConfig;
} FFdata;
@@ -610,8 +612,7 @@ static void optionParseConfigFile(FFinstance* instance, FFdata* data, const char
//Try to load as a relative path
FFstrbuf absolutePath;
ffStrbufInitA(&absolutePath, 128);
FF_STRBUF_AUTO_DESTROY absolutePath = ffStrbufCreateA(128);
FF_LIST_FOR_EACH(FFstrbuf, path, instance->state.platform.dataDirs)
{
@@ -626,8 +627,6 @@ static void optionParseConfigFile(FFinstance* instance, FFdata* data, const char
return;
}
ffStrbufDestroy(&absolutePath);
//File not found
fprintf(stderr, "Error: couldn't find config: %s\n", value);
@@ -714,32 +713,6 @@ static uint32_t optionParseUInt32(const char* key, const char* value)
return num;
}
static void optionParseCustomValue(FFdata* data, const char* key, const char* value, bool printKey)
{
if(value == NULL)
{
fprintf(stderr, "Error: usage: %s <key=value>\n", key);
exit(411);
}
char* separator = strchr(value, '=');
if(separator == NULL)
{
fprintf(stderr, "Error: usage: %s <key=value>, '=' missing\n", key);
exit(412);
}
*separator = '\0';
bool created;
CustomValue* customValue = ffValuestoreSet(&data->customValues, value, &created);
if(created)
ffStrbufInit(&customValue->value);
ffStrbufSetS(&customValue->value, separator + 1);
customValue->printKey = printKey;
}
static void optionParseEnum(const char* argumentKey, const char* requestedKey, void* result, ...)
{
if(requestedKey == NULL)
@@ -773,40 +746,6 @@ static void optionParseEnum(const char* argumentKey, const char* requestedKey, v
exit(478);
}
static bool optionParseModuleArgs(const char* argumentKey, const char* value, const char* moduleName, struct FFModuleArgs* result)
{
const char* pkey = argumentKey;
if(!(pkey[0] == '-' && pkey[1] == '-'))
return false;
pkey += 2;
uint32_t moduleNameLen = (uint32_t)strlen(moduleName);
if(strncasecmp(pkey, moduleName, moduleNameLen) != 0)
return false;
pkey += moduleNameLen;
if(pkey[0] != '-')
return false;
pkey += 1;
if(strcasecmp(pkey, "key") == 0)
{
optionParseString(argumentKey, value, &result->key);
return true;
}
else if(strcasecmp(pkey, "format") == 0)
{
optionParseString(argumentKey, value, &result->outputFormat);
return true;
}
else if(strcasecmp(pkey, "error") == 0)
{
optionParseString(argumentKey, value, &result->errorFormat);
return true;
}
return false;
}
static void parseOption(FFinstance* instance, FFdata* data, const char* key, const char* value)
{
///////////////////////
@@ -961,132 +900,7 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
//Logo options//
////////////////
else if(strcasecmp(key, "-l") == 0 || strcasecmp(key, "--logo") == 0)
{
optionParseString(key, value, &instance->config.logo.source);
//this is usally wanted when using the none logo
if(strcasecmp(value, "none") == 0)
{
instance->config.logo.paddingTop = 0;
instance->config.logo.paddingRight = 0;
instance->config.logo.paddingLeft = 0;
instance->config.logo.type = FF_LOGO_TYPE_NONE;
}
}
else if(startsWith(key, "--logo"))
{
const char* subkey = key + strlen("--logo");
if(strcasecmp(subkey, "-type") == 0)
{
optionParseEnum(key, value, &instance->config.logo.type,
"auto", FF_LOGO_TYPE_AUTO,
"builtin", FF_LOGO_TYPE_BUILTIN,
"file", FF_LOGO_TYPE_FILE,
"file-raw", FF_LOGO_TYPE_FILE_RAW,
"data", FF_LOGO_TYPE_DATA,
"data-raw", FF_LOGO_TYPE_DATA_RAW,
"sixel", FF_LOGO_TYPE_IMAGE_SIXEL,
"kitty", FF_LOGO_TYPE_IMAGE_KITTY,
"iterm", FF_LOGO_TYPE_IMAGE_ITERM,
"chafa", FF_LOGO_TYPE_IMAGE_CHAFA,
"raw", FF_LOGO_TYPE_IMAGE_RAW,
"none", FF_LOGO_TYPE_NONE,
NULL
);
}
else if(startsWith(subkey, "-color-") && key[13] != '\0' && key[14] == '\0') // matches "--logo-color-*"
{
//Map the number to an array index, so that '1' -> 0, '2' -> 1, etc.
int index = (int)key[13] - 49;
//Match only --logo-color-[1-9]
if(index < 0 || index >= FASTFETCH_LOGO_MAX_COLORS)
{
fprintf(stderr, "Error: invalid --color-[1-9] index: %c\n", key[13]);
exit(472);
}
optionParseColor(key, value, &instance->config.logo.colors[index]);
}
else if(strcasecmp(subkey, "-width") == 0)
instance->config.logo.width = optionParseUInt32(key, value);
else if(strcasecmp(subkey, "-height") == 0)
instance->config.logo.height = optionParseUInt32(key, value);
else if(strcasecmp(subkey, "-padding") == 0)
{
uint32_t padding = optionParseUInt32(key, value);
instance->config.logo.paddingLeft = padding;
instance->config.logo.paddingRight = padding;
}
else if(strcasecmp(subkey, "-padding-top") == 0)
instance->config.logo.paddingTop = optionParseUInt32(key, value);
else if(strcasecmp(subkey, "-padding-left") == 0)
instance->config.logo.paddingLeft = optionParseUInt32(key, value);
else if(strcasecmp(subkey, "-padding-right") == 0)
instance->config.logo.paddingRight = optionParseUInt32(key, value);
else if(strcasecmp(subkey, "-print-remaining") == 0)
instance->config.logo.printRemaining = optionParseBoolean(value);
else if(strcasecmp(subkey, "-preserve-aspect-radio") == 0)
instance->config.logo.preserveAspectRadio = optionParseBoolean(value);
else
goto error;
}
else if(strcasecmp(key, "--file") == 0)
{
optionParseString(key, value, &instance->config.logo.source);
instance->config.logo.type = FF_LOGO_TYPE_FILE;
}
else if(strcasecmp(key, "--file-raw") == 0)
{
optionParseString(key, value, &instance->config.logo.source);
instance->config.logo.type = FF_LOGO_TYPE_FILE_RAW;
}
else if(strcasecmp(key, "--data") == 0)
{
optionParseString(key, value, &instance->config.logo.source);
instance->config.logo.type = FF_LOGO_TYPE_DATA;
}
else if(strcasecmp(key, "--data-raw") == 0)
{
optionParseString(key, value, &instance->config.logo.source);
instance->config.logo.type = FF_LOGO_TYPE_DATA_RAW;
}
else if(strcasecmp(key, "--sixel") == 0)
{
optionParseString(key, value, &instance->config.logo.source);
instance->config.logo.type = FF_LOGO_TYPE_IMAGE_SIXEL;
}
else if(strcasecmp(key, "--kitty") == 0)
{
optionParseString(key, value, &instance->config.logo.source);
instance->config.logo.type = FF_LOGO_TYPE_IMAGE_KITTY;
}
else if(strcasecmp(key, "--chafa") == 0)
{
optionParseString(key, value, &instance->config.logo.source);
instance->config.logo.type = FF_LOGO_TYPE_IMAGE_CHAFA;
}
else if(strcasecmp(key, "--iterm") == 0)
{
optionParseString(key, value, &instance->config.logo.source);
instance->config.logo.type = FF_LOGO_TYPE_IMAGE_ITERM;
}
else if(strcasecmp(key, "--raw") == 0)
{
optionParseString(key, value, &instance->config.logo.source);
instance->config.logo.type = FF_LOGO_TYPE_IMAGE_RAW;
}
else if(strcasecmp(key, "--chafa-fg-only") == 0)
instance->config.logo.chafaFgOnly = optionParseBoolean(value);
else if(strcasecmp(key, "--chafa-symbols") == 0)
optionParseString(key, value, &instance->config.logo.chafaSymbols);
else if(strcasecmp(key, "--chafa-canvas-mode") == 0)
instance->config.logo.chafaCanvasMode = optionParseUInt32(key, value);
else if(strcasecmp(key, "--chafa-color-space") == 0)
instance->config.logo.chafaColorSpace = optionParseUInt32(key, value);
else if(strcasecmp(key, "--chafa-dither-mode") == 0)
instance->config.logo.chafaDitherMode = optionParseUInt32(key, value);
else if(ffParseLogoCommandOptions(&instance->config.logo, key, value)) {}
///////////////////
//Display options//
@@ -1101,7 +915,7 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
else if(strcasecmp(key, "-s") == 0 || strcasecmp(key, "--structure") == 0)
optionParseString(key, value, &data->structure);
else if(strcasecmp(key, "--separator") == 0)
optionParseString(key, value, &instance->config.separator);
optionParseString(key, value, &instance->config.keyValueSeparator);
else if(strcasecmp(key, "--color-keys") == 0)
optionParseColor(key, value, &instance->config.colorKeys);
else if(strcasecmp(key, "--color-title") == 0)
@@ -1111,10 +925,6 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
optionParseColor(key, value, &instance->config.colorKeys);
ffStrbufSet(&instance->config.colorTitle, &instance->config.colorKeys);
}
else if(strcasecmp(key, "--set") == 0)
optionParseCustomValue(data, key, value, true);
else if(strcasecmp(key, "--set-keyless") == 0)
optionParseCustomValue(data, key, value, false);
else if(strcasecmp(key, "--binary-prefix") == 0)
{
optionParseEnum(key, value, &instance->config.binaryPrefixType,
@@ -1129,53 +939,55 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
//Module args options//
///////////////////////
else if(optionParseModuleArgs(key, value, "os", &instance->config.os)) {}
else if(optionParseModuleArgs(key, value, "host", &instance->config.host)) {}
else if(optionParseModuleArgs(key, value, "bios", &instance->config.bios)) {}
else if(optionParseModuleArgs(key, value, "board", &instance->config.board)) {}
else if(optionParseModuleArgs(key, value, "chassis", &instance->config.chassis)) {}
else if(optionParseModuleArgs(key, value, "kernel", &instance->config.kernel)) {}
else if(optionParseModuleArgs(key, value, "uptime", &instance->config.uptime)) {}
else if(optionParseModuleArgs(key, value, "processes", &instance->config.processes)) {}
else if(optionParseModuleArgs(key, value, "packages", &instance->config.packages)) {}
else if(optionParseModuleArgs(key, value, "shell", &instance->config.shell)) {}
else if(optionParseModuleArgs(key, value, "display", &instance->config.display)) {}
else if(optionParseModuleArgs(key, value, "brightness", &instance->config.brightness)) {}
else if(optionParseModuleArgs(key, value, "de", &instance->config.de)) {}
else if(optionParseModuleArgs(key, value, "wifi", &instance->config.wifi)) {}
else if(optionParseModuleArgs(key, value, "wm", &instance->config.wm)) {}
else if(optionParseModuleArgs(key, value, "wm-theme", &instance->config.wmTheme)) {}
else if(optionParseModuleArgs(key, value, "theme", &instance->config.theme)) {}
else if(optionParseModuleArgs(key, value, "icons", &instance->config.icons)) {}
else if(optionParseModuleArgs(key, value, "wallpaper", &instance->config.wallpaper)) {}
else if(optionParseModuleArgs(key, value, "font", &instance->config.font)) {}
else if(optionParseModuleArgs(key, value, "cursor", &instance->config.cursor)) {}
else if(optionParseModuleArgs(key, value, "terminal", &instance->config.terminal)) {}
else if(optionParseModuleArgs(key, value, "terminal-font", &instance->config.terminalFont)) {}
else if(optionParseModuleArgs(key, value, "cpu", &instance->config.cpu)) {}
else if(optionParseModuleArgs(key, value, "cpu-usage", &instance->config.cpuUsage)) {}
else if(optionParseModuleArgs(key, value, "gpu", &instance->config.gpu)) {}
else if(optionParseModuleArgs(key, value, "memory", &instance->config.memory)) {}
else if(optionParseModuleArgs(key, value, "swap", &instance->config.swap)) {}
else if(optionParseModuleArgs(key, value, "disk", &instance->config.disk)) {}
else if(optionParseModuleArgs(key, value, "battery", &instance->config.battery)) {}
else if(optionParseModuleArgs(key, value, "poweradapter", &instance->config.powerAdapter)) {}
else if(optionParseModuleArgs(key, value, "locale", &instance->config.locale)) {}
else if(optionParseModuleArgs(key, value, "localip", &instance->config.localIP)) {}
else if(optionParseModuleArgs(key, value, "publicip", &instance->config.publicIP)) {}
else if(optionParseModuleArgs(key, value, "weather", &instance->config.weather)) {}
else if(optionParseModuleArgs(key, value, "player", &instance->config.player)) {}
else if(optionParseModuleArgs(key, value, "media", &instance->config.media)) {}
else if(optionParseModuleArgs(key, value, "datetime", &instance->config.dateTime)) {}
else if(optionParseModuleArgs(key, value, "date", &instance->config.date)) {}
else if(optionParseModuleArgs(key, value, "time", &instance->config.time)) {}
else if(optionParseModuleArgs(key, value, "vulkan", &instance->config.vulkan)) {}
else if(optionParseModuleArgs(key, value, "opengl", &instance->config.openGL)) {}
else if(optionParseModuleArgs(key, value, "opencl", &instance->config.openCL)) {}
else if(optionParseModuleArgs(key, value, "users", &instance->config.users)) {}
else if(optionParseModuleArgs(key, value, "bluetooth", &instance->config.bluetooth)) {}
else if(optionParseModuleArgs(key, value, "sound", &instance->config.sound)) {}
else if(optionParseModuleArgs(key, value, "gamepad", &instance->config.gamepad)) {}
else if(ffParseOSCommandOptions(&instance->config.os, key, value)) {}
else if(ffParseHostCommandOptions(&instance->config.host, key, value)) {}
else if(ffParseOSCommandOptions(&instance->config.os, key, value)) {}
else if(ffParseBiosCommandOptions(&instance->config.bios, key, value)) {}
else if(ffParseBoardCommandOptions(&instance->config.board, key, value)) {}
else if(ffParseChassisCommandOptions(&instance->config.chassis, key, value)) {}
else if(ffParseCommandCommandOptions(&instance->config.command, key, value)) {}
else if(ffParseCustomCommandOptions(&instance->config.custom, key, value)) {}
else if(ffParseKernelCommandOptions(&instance->config.kernel, key, value)) {}
else if(ffParseUptimeCommandOptions(&instance->config.uptime, key, value)) {}
else if(ffParseProcessesCommandOptions(&instance->config.processes, key, value)) {}
else if(ffParsePackagesCommandOptions(&instance->config.packages, key, value)) {}
else if(ffParseShellCommandOptions(&instance->config.shell, key, value)) {}
else if(ffParseDisplayCommandOptions(&instance->config.display, key, value)) {}
else if(ffParseBrightnessCommandOptions(&instance->config.brightness, key, value)) {}
else if(ffParseDECommandOptions(&instance->config.de, key, value)) {}
else if(ffParseWifiCommandOptions(&instance->config.wifi, key, value)) {}
else if(ffParseWMCommandOptions(&instance->config.wm, key, value)) {}
else if(ffParseWMThemeCommandOptions(&instance->config.wmTheme, key, value)) {}
else if(ffParseThemeCommandOptions(&instance->config.theme, key, value)) {}
else if(ffParseIconsCommandOptions(&instance->config.icons, key, value)) {}
else if(ffParseWallpaperCommandOptions(&instance->config.wallpaper, key, value)) {}
else if(ffParseFontCommandOptions(&instance->config.font, key, value)) {}
else if(ffParseCursorCommandOptions(&instance->config.cursor, key, value)) {}
else if(ffParseTerminalCommandOptions(&instance->config.terminal, key, value)) {}
else if(ffParseTerminalFontCommandOptions(&instance->config.terminalFont, key, value)) {}
else if(ffParseCPUCommandOptions(&instance->config.cpu, key, value)) {}
else if(ffParseCPUUsageCommandOptions(&instance->config.cpuUsage, key, value)) {}
else if(ffParseGPUCommandOptions(&instance->config.gpu, key, value)) {}
else if(ffParseMemoryCommandOptions(&instance->config.memory, key, value)) {}
else if(ffParseSwapCommandOptions(&instance->config.swap, key, value)) {}
else if(ffParseDiskCommandOptions(&instance->config.disk, key, value)) {}
else if(ffParseBatteryCommandOptions(&instance->config.battery, key, value)) {}
else if(ffParsePowerAdapterCommandOptions(&instance->config.powerAdapter, key, value)) {}
else if(ffParseLocaleCommandOptions(&instance->config.locale, key, value)) {}
else if(ffParseLocalIpCommandOptions(&instance->config.localIP, key, value)) {}
else if(ffParsePublicIpCommandOptions(&instance->config.publicIP, key, value)) {}
else if(ffParseWeatherCommandOptions(&instance->config.weather, key, value)) {}
else if(ffParsePlayerCommandOptions(&instance->config.player, key, value)) {}
else if(ffParseMediaCommandOptions(&instance->config.media, key, value)) {}
else if(ffParseDateTimeCommandOptions(&instance->config.dateTime, key, value)) {}
else if(ffParseVulkanCommandOptions(&instance->config.vulkan, key, value)) {}
else if(ffParseOpenGLCommandOptions(&instance->config.openGL, key, value)) {}
else if(ffParseOpenCLCommandOptions(&instance->config.openCL, key, value)) {}
else if(ffParseUsersCommandOptions(&instance->config.users, key, value)) {}
else if(ffParseBluetoothCommandOptions(&instance->config.bluetooth, key, value)) {}
else if(ffParseSeparatorCommandOptions(&instance->config.separator, key, value)) {}
else if(ffParseSoundCommandOptions(&instance->config.sound, key, value)) {}
else if(ffParseGamepadCommandOptions(&instance->config.gamepad, key, value)) {}
///////////////////
//Library options//
@@ -1226,8 +1038,8 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
optionParseString(key, value, &instance->config.libOSMesa);
else if(strcasecmp(subkey, "-opencl") == 0)
optionParseString(key, value, &instance->config.libOpenCL);
else if(strcasecmp(subkey, "-cjson") == 0)
optionParseString(key, value, &instance->config.libcJSON);
else if(strcasecmp(subkey, "-jsonc") == 0)
optionParseString(key, value, &instance->config.libJSONC);
else if(strcasecmp(subkey, "-wlanapi") == 0)
optionParseString(key, value, &instance->config.libwlanapi);
else if(strcasecmp(key, "-pulse") == 0)
@@ -1242,113 +1054,8 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
//Module options//
//////////////////
else if(strcasecmp(key, "--cpu-temp") == 0)
instance->config.cpuTemp = optionParseBoolean(value);
else if(strcasecmp(key, "--gpu-temp") == 0)
instance->config.gpuTemp = optionParseBoolean(value);
else if(strcasecmp(key, "--gpu-force-vulkan") == 0)
instance->config.gpuForceVulkan = optionParseBoolean(value);
else if(strcasecmp(key, "--battery-temp") == 0)
instance->config.batteryTemp = optionParseBoolean(value);
else if(strcasecmp(key, "--gpu-hide-integrated") == 0)
instance->config.gpuHideIntegrated = optionParseBoolean(value);
else if(strcasecmp(key, "--gpu-hide-discrete") == 0)
instance->config.gpuHideDiscrete = optionParseBoolean(value);
else if(strcasecmp(key, "--title-fqdn") == 0)
instance->config.titleFQDN = optionParseBoolean(value);
else if(strcasecmp(key, "--shell-version") == 0)
instance->config.shellVersion = optionParseBoolean(value);
else if(strcasecmp(key, "--terminal-version") == 0)
instance->config.terminalVersion = optionParseBoolean(value);
else if(strcasecmp(key, "--disk-folders") == 0)
optionParseString(key, value, &instance->config.diskFolders);
else if(strcasecmp(key, "--disk-show-regular") == 0)
optionParseBoolean(value) ? (instance->config.diskShowTypes |= FF_DISK_TYPE_REGULAR_BIT) : (instance->config.diskShowTypes &= ~FF_DISK_TYPE_REGULAR_BIT);
else if(strcasecmp(key, "--disk-show-removable") == 0)
optionParseBoolean(value) ? (instance->config.diskShowTypes |= FF_DISK_TYPE_EXTERNAL_BIT) : (instance->config.diskShowTypes &= ~FF_DISK_TYPE_EXTERNAL_BIT);
else if(strcasecmp(key, "--disk-show-hidden") == 0)
optionParseBoolean(value) ? (instance->config.diskShowTypes |= FF_DISK_TYPE_HIDDEN_BIT) : (instance->config.diskShowTypes &= ~FF_DISK_TYPE_HIDDEN_BIT);
else if(strcasecmp(key, "--disk-show-subvolumes") == 0)
optionParseBoolean(value) ? (instance->config.diskShowTypes |= FF_DISK_TYPE_SUBVOLUME_BIT) : (instance->config.diskShowTypes &= ~FF_DISK_TYPE_SUBVOLUME_BIT);
else if(strcasecmp(key, "--disk-show-unknown") == 0)
optionParseBoolean(value) ? (instance->config.diskShowTypes |= FF_DISK_TYPE_UNKNOWN_BIT) : (instance->config.diskShowTypes &= ~FF_DISK_TYPE_UNKNOWN_BIT);
else if(strcasecmp(key, "--display-compact-type") == 0)
{
optionParseEnum(key, value, &instance->config.displayCompactType,
"none", FF_DISPLAY_COMPACT_TYPE_NONE,
"original", FF_DISPLAY_COMPACT_TYPE_ORIGINAL_BIT,
"scaled", FF_DISPLAY_COMPACT_TYPE_SCALED_BIT,
NULL);
}
else if(strcasecmp(key, "--display-precise-refresh-rate") == 0)
instance->config.displayPreciseRefreshRate = optionParseBoolean(value);
else if(strcasecmp(key, "--display-detect-name") == 0)
instance->config.displayDetectName = optionParseBoolean(value);
else if(strcasecmp(key, "--bluetooth-show-disconnected") == 0)
instance->config.bluetoothShowDisconnected = optionParseBoolean(value);
else if(strcasecmp(key, "--sound-type") == 0)
{
optionParseEnum(key, value, &instance->config.soundType,
"main", FF_SOUND_TYPE_MAIN,
"active", FF_SOUND_TYPE_ACTIVE,
"all", FF_SOUND_TYPE_ALL,
NULL
);
}
else if(strcasecmp(key, "--battery-dir") == 0)
optionParseString(key, value, &instance->config.batteryDir);
else if(strcasecmp(key, "--separator-string") == 0)
optionParseString(key, value, &instance->config.separatorString);
else if(strcasecmp(key, "--localip-show-ipv4") == 0)
optionParseBoolean(value) ? (instance->config.localIpShowType |= FF_LOCALIP_TYPE_IPV4_BIT) : (instance->config.localIpShowType &= ~FF_LOCALIP_TYPE_IPV4_BIT);
else if(strcasecmp(key, "--localip-show-ipv6") == 0)
optionParseBoolean(value) ? (instance->config.localIpShowType |= FF_LOCALIP_TYPE_IPV6_BIT) : (instance->config.localIpShowType &= ~FF_LOCALIP_TYPE_IPV6_BIT);
else if(strcasecmp(key, "--localip-show-mac") == 0)
optionParseBoolean(value) ? (instance->config.localIpShowType |= FF_LOCALIP_TYPE_MAC_BIT) : (instance->config.localIpShowType &= ~FF_LOCALIP_TYPE_MAC_BIT);
else if(strcasecmp(key, "--localip-show-loop") == 0)
optionParseBoolean(value) ? (instance->config.localIpShowType |= FF_LOCALIP_TYPE_LOOP_BIT) : (instance->config.localIpShowType &= ~FF_LOCALIP_TYPE_LOOP_BIT);
else if(strcasecmp(key, "--localip-compact") == 0)
optionParseBoolean(value) ? (instance->config.localIpShowType |= FF_LOCALIP_TYPE_COMPACT_BIT) : (instance->config.localIpShowType &= ~FF_LOCALIP_TYPE_COMPACT_BIT);
else if(strcasecmp(key, "--localip-name-prefix") == 0)
optionParseString(key, value, &instance->config.localIpNamePrefix);
else if(strcasecmp(key, "--os-file") == 0)
optionParseString(key, value, &instance->config.osFile);
else if(strcasecmp(key, "--player-name") == 0)
optionParseString(key, value, &instance->config.playerName);
else if(strcasecmp(key, "--publicip-url") == 0)
optionParseString(key, value, &instance->config.publicIpUrl);
else if(strcasecmp(key, "--publicip-timeout") == 0)
instance->config.publicIpTimeout = optionParseUInt32(key, value);
else if(strcasecmp(key, "--weather-output-format") == 0)
optionParseString(key, value, &instance->config.weatherOutputFormat);
else if(strcasecmp(key, "--weather-timeout") == 0)
instance->config.weatherTimeout = optionParseUInt32(key, value);
else if(strcasecmp(key, "--gl") == 0)
{
optionParseEnum(key, value, &instance->config.glType,
"auto", FF_GL_TYPE_AUTO,
"egl", FF_GL_TYPE_EGL,
"glx", FF_GL_TYPE_GLX,
"osmesa", FF_GL_TYPE_OSMESA,
NULL
);
}
else if(strcasecmp(key, "--percent-type") == 0)
instance->config.percentType = optionParseUInt32(key, value);
else if(strcasecmp(key, "--command-shell") == 0)
optionParseString(key, value, &instance->config.commandShell);
else if(strcasecmp(key, "--command-key") == 0)
{
FFstrbuf* result = (FFstrbuf*) ffListAdd(&instance->config.commandKeys);
ffStrbufInit(result);
optionParseString(key, value, result);
}
else if(strcasecmp(key, "--command-text") == 0)
{
FFstrbuf* result = (FFstrbuf*) ffListAdd(&instance->config.commandTexts);
ffStrbufInit(result);
optionParseString(key, value, result);
}
//////////////////
//Unknown option//
@@ -1399,119 +1106,112 @@ static void parseArguments(FFinstance* instance, FFdata* data, int argc, const c
}
}
static void parseStructureCommand(FFinstance* instance, FFdata* data, const char* line)
static void parseStructureCommand(FFinstance* instance, const char* line)
{
CustomValue* customValue = ffValuestoreGet(&data->customValues, line);
if(customValue != NULL)
{
ffPrintCustom(instance, customValue->printKey ? line : NULL, customValue->value.chars);
return;
}
if(strcasecmp(line, "break") == 0)
if(strcasecmp(line, FF_BREAK_MODULE_NAME) == 0)
ffPrintBreak(instance);
else if(strcasecmp(line, "title") == 0)
ffPrintTitle(instance);
else if(strcasecmp(line, "separator") == 0)
ffPrintSeparator(instance);
else if(strcasecmp(line, "os") == 0)
ffPrintOS(instance);
else if(strcasecmp(line, "host") == 0)
ffPrintHost(instance);
else if(strcasecmp(line, "bios") == 0)
ffPrintBios(instance);
else if(strcasecmp(line, "board") == 0)
ffPrintBoard(instance);
else if(strcasecmp(line, "brightness") == 0)
ffPrintBrightness(instance);
else if(strcasecmp(line, "chassis") == 0)
ffPrintChassis(instance);
else if(strcasecmp(line, "kernel") == 0)
ffPrintKernel(instance);
else if(strcasecmp(line, "uptime") == 0)
ffPrintUptime(instance);
else if(strcasecmp(line, "processes") == 0)
ffPrintProcesses(instance);
else if(strcasecmp(line, "packages") == 0)
ffPrintPackages(instance);
else if(strcasecmp(line, "shell") == 0)
ffPrintShell(instance);
else if(strcasecmp(line, "display") == 0)
ffPrintDisplay(instance);
else if(strcasecmp(line, "desktopenvironment") == 0 || strcasecmp(line, "de") == 0)
ffPrintDesktopEnvironment(instance);
else if(strcasecmp(line, "windowmanager") == 0 || strcasecmp(line, "wm") == 0)
ffPrintWM(instance);
else if(strcasecmp(line, "theme") == 0)
ffPrintTheme(instance);
else if(strcasecmp(line, "wmtheme") == 0)
ffPrintWMTheme(instance);
else if(strcasecmp(line, "icons") == 0)
ffPrintIcons(instance);
else if(strcasecmp(line, "wallpaper") == 0)
ffPrintWallpaper(instance);
else if(strcasecmp(line, "font") == 0)
ffPrintFont(instance);
else if(strcasecmp(line, "cursor") == 0)
ffPrintCursor(instance);
else if(strcasecmp(line, "terminal") == 0)
ffPrintTerminal(instance);
else if(strcasecmp(line, "terminalfont") == 0)
ffPrintTerminalFont(instance);
else if(strcasecmp(line, "cpu") == 0)
ffPrintCPU(instance);
else if(strcasecmp(line, "cpuusage") == 0)
ffPrintCPUUsage(instance);
else if(strcasecmp(line, "gpu") == 0)
ffPrintGPU(instance);
else if(strcasecmp(line, "memory") == 0)
ffPrintMemory(instance);
else if(strcasecmp(line, "swap") == 0)
ffPrintSwap(instance);
else if(strcasecmp(line, "disk") == 0)
ffPrintDisk(instance);
else if(strcasecmp(line, "battery") == 0)
ffPrintBattery(instance);
else if(strcasecmp(line, "poweradapter") == 0)
ffPrintPowerAdapter(instance);
else if(strcasecmp(line, "locale") == 0)
ffPrintLocale(instance);
else if(strcasecmp(line, FF_TITLE_MODULE_NAME) == 0)
ffPrintTitle(instance, &instance->config.title);
else if(strcasecmp(line, FF_SEPARATOR_MODULE_NAME) == 0)
ffPrintSeparator(instance, &instance->config.separator);
else if(strcasecmp(line, FF_OS_MODULE_NAME) == 0)
ffPrintOS(instance, &instance->config.os);
else if(strcasecmp(line, FF_HOST_MODULE_NAME) == 0)
ffPrintHost(instance, &instance->config.host);
else if(strcasecmp(line, FF_BIOS_MODULE_NAME) == 0)
ffPrintBios(instance, &instance->config.bios);
else if(strcasecmp(line, FF_BOARD_MODULE_NAME) == 0)
ffPrintBoard(instance, &instance->config.board);
else if(strcasecmp(line, FF_BRIGHTNESS_MODULE_NAME) == 0)
ffPrintBrightness(instance, &instance->config.brightness);
else if(strcasecmp(line, FF_CHASSIS_MODULE_NAME) == 0)
ffPrintChassis(instance, &instance->config.chassis);
else if(strcasecmp(line, FF_KERNEL_MODULE_NAME) == 0)
ffPrintKernel(instance, &instance->config.kernel);
else if(strcasecmp(line, FF_PROCESSES_MODULE_NAME) == 0)
ffPrintProcesses(instance, &instance->config.processes);
else if(strcasecmp(line, FF_UPTIME_MODULE_NAME) == 0)
ffPrintUptime(instance, &instance->config.uptime);
else if(strcasecmp(line, FF_PACKAGES_MODULE_NAME) == 0)
ffPrintPackages(instance, &instance->config.packages);
else if(strcasecmp(line, FF_SHELL_MODULE_NAME) == 0)
ffPrintShell(instance, &instance->config.shell);
else if(strcasecmp(line, FF_DISPLAY_MODULE_NAME) == 0)
ffPrintDisplay(instance, &instance->config.display);
else if(strcasecmp(line, FF_DE_MODULE_NAME) == 0)
ffPrintDE(instance, &instance->config.de);
else if(strcasecmp(line, FF_WM_MODULE_NAME) == 0)
ffPrintWM(instance, &instance->config.wm);
else if(strcasecmp(line, FF_THEME_MODULE_NAME) == 0)
ffPrintTheme(instance, &instance->config.theme);
else if(strcasecmp(line, FF_WMTHEME_MODULE_NAME) == 0)
ffPrintWMTheme(instance, &instance->config.wmTheme);
else if(strcasecmp(line, FF_ICONS_MODULE_NAME) == 0)
ffPrintIcons(instance, &instance->config.icons);
else if(strcasecmp(line, FF_WALLPAPER_MODULE_NAME) == 0)
ffPrintWallpaper(instance, &instance->config.wallpaper);
else if(strcasecmp(line, FF_FONT_MODULE_NAME) == 0)
ffPrintFont(instance, &instance->config.font);
else if(strcasecmp(line, FF_CURSOR_MODULE_NAME) == 0)
ffPrintCursor(instance, &instance->config.cursor);
else if(strcasecmp(line, FF_TERMINAL_MODULE_NAME) == 0)
ffPrintTerminal(instance, &instance->config.terminal);
else if(strcasecmp(line, FF_TERMINALFONT_MODULE_NAME) == 0)
ffPrintTerminalFont(instance, &instance->config.terminalFont);
else if(strcasecmp(line, FF_CPU_MODULE_NAME) == 0)
ffPrintCPU(instance, &instance->config.cpu);
else if(strcasecmp(line, FF_CPUUSAGE_MODULE_NAME) == 0)
ffPrintCPUUsage(instance, &instance->config.cpuUsage);
else if(strcasecmp(line, FF_CUSTOM_MODULE_NAME) == 0)
ffPrintCustom(instance, &instance->config.custom);
else if(strcasecmp(line, FF_GPU_MODULE_NAME) == 0)
ffPrintGPU(instance, &instance->config.gpu);
else if(strcasecmp(line, FF_MEMORY_MODULE_NAME) == 0)
ffPrintMemory(instance, &instance->config.memory);
else if(strcasecmp(line, FF_SWAP_MODULE_NAME) == 0)
ffPrintSwap(instance, &instance->config.swap);
else if(strcasecmp(line, FF_DISK_MODULE_NAME) == 0)
ffPrintDisk(instance, &instance->config.disk);
else if(strcasecmp(line, FF_BATTERY_MODULE_NAME) == 0)
ffPrintBattery(instance, &instance->config.battery);
else if(strcasecmp(line, FF_POWERADAPTER_MODULE_NAME) == 0)
ffPrintPowerAdapter(instance, &instance->config.powerAdapter);
else if(strcasecmp(line, FF_LOCALE_MODULE_NAME) == 0)
ffPrintLocale(instance, &instance->config.locale);
else if(strcasecmp(line, "localip") == 0)
ffPrintLocalIp(instance);
else if(strcasecmp(line, "publicip") == 0)
ffPrintPublicIp(instance);
else if(strcasecmp(line, "wifi") == 0)
ffPrintWifi(instance);
else if(strcasecmp(line, "weather") == 0)
ffPrintWeather(instance);
else if(strcasecmp(line, "player") == 0)
ffPrintPlayer(instance);
else if(strcasecmp(line, "media") == 0)
ffPrintMedia(instance);
else if(strcasecmp(line, "datetime") == 0)
ffPrintDateTime(instance);
else if(strcasecmp(line, "date") == 0)
ffPrintDate(instance);
else if(strcasecmp(line, "time") == 0)
ffPrintTime(instance);
else if(strcasecmp(line, "colors") == 0)
ffPrintLocalIp(instance, &instance->config.localIP);
else if(strcasecmp(line, FF_PUBLICIP_MODULE_NAME) == 0)
ffPrintPublicIp(instance, &instance->config.publicIP);
else if(strcasecmp(line, FF_WIFI_MODULE_NAME) == 0)
ffPrintWifi(instance, &instance->config.wifi);
else if(strcasecmp(line, FF_WEATHER_MODULE_NAME) == 0)
ffPrintWeather(instance, &instance->config.weather);
else if(strcasecmp(line, FF_PLAYER_MODULE_NAME) == 0)
ffPrintPlayer(instance, &instance->config.player);
else if(strcasecmp(line, FF_MEDIA_MODULE_NAME) == 0)
ffPrintMedia(instance, &instance->config.media);
else if(strcasecmp(line, FF_DATETIME_MODULE_NAME) == 0)
ffPrintDateTime(instance, &instance->config.dateTime);
else if(strcasecmp(line, FF_COLORS_MODULE_NAME) == 0)
ffPrintColors(instance);
else if(strcasecmp(line, "vulkan") == 0)
ffPrintVulkan(instance);
else if(strcasecmp(line, "opengl") == 0)
ffPrintOpenGL(instance);
else if(strcasecmp(line, "opencl") == 0)
ffPrintOpenCL(instance);
else if(strcasecmp(line, "users") == 0)
ffPrintUsers(instance);
else if(strcasecmp(line, "command") == 0)
ffPrintCommand(instance);
else if(strcasecmp(line, "bluetooth") == 0)
ffPrintBluetooth(instance);
else if(strcasecmp(line, "sound") == 0)
ffPrintSound(instance);
else if(strcasecmp(line, "gamepad") == 0)
ffPrintGamepad(instance);
else if(strcasecmp(line, FF_VULKAN_MODULE_NAME) == 0)
ffPrintVulkan(instance, &instance->config.vulkan);
else if(strcasecmp(line, FF_OPENGL_MODULE_NAME) == 0)
ffPrintOpenGL(instance, &instance->config.openGL);
else if(strcasecmp(line, FF_OPENCL_MODULE_NAME) == 0)
ffPrintOpenCL(instance, &instance->config.openCL);
else if(strcasecmp(line, FF_USERS_MODULE_NAME) == 0)
ffPrintUsers(instance, &instance->config.users);
else if(strcasecmp(line, FF_COMMAND_MODULE_NAME) == 0)
ffPrintCommand(instance, &instance->config.command);
else if(strcasecmp(line, FF_BLUETOOTH_MODULE_NAME) == 0)
ffPrintBluetooth(instance, &instance->config.bluetooth);
else if(strcasecmp(line, FF_SOUND_MODULE_NAME) == 0)
ffPrintSound(instance, &instance->config.sound);
else if(strcasecmp(line, FF_GAMEPAD_MODULE_NAME) == 0)
ffPrintGamepad(instance, &instance->config.gamepad);
else if(strcasecmp(line, FF_JSONCONFIG_MODULE_NAME) == 0)
ffPrintJsonConfig(instance);
else
ffPrintErrorString(instance, line, 0, NULL, NULL, "<no implementation provided>");
}
@@ -1523,7 +1223,6 @@ int main(int argc, const char** argv)
//Data stores things only needed for the configuration of fastfetch
FFdata data;
ffValuestoreInit(&data.customValues, sizeof(CustomValue));
ffStrbufInitA(&data.structure, 256);
data.loadUserConfig = true;
@@ -1535,16 +1234,16 @@ int main(int argc, const char** argv)
if(data.structure.length == 0)
ffStrbufAppendS(&data.structure, FASTFETCH_DATATEXT_STRUCTURE);
if(ffStrbufContainIgnCaseS(&data.structure, "CPUUsage"))
if(ffStrbufContainIgnCaseS(&data.structure, FF_CPUUSAGE_MODULE_NAME))
ffPrepareCPUUsage();
if(instance.config.multithreading)
{
if(ffStrbufContainIgnCaseS(&data.structure, "PublicIp"))
ffPreparePublicIp(&instance);
if(ffStrbufContainIgnCaseS(&data.structure, FF_PUBLICIP_MODULE_NAME))
ffPreparePublicIp(&instance.config.publicIP);
if(ffStrbufContainIgnCaseS(&data.structure, "Weather"))
ffPrepareWeather(&instance);
if(ffStrbufContainIgnCaseS(&data.structure, FF_WEATHER_MODULE_NAME))
ffPrepareWeather(&instance.config.weather);
}
ffStart(&instance);
@@ -1564,7 +1263,7 @@ int main(int argc, const char** argv)
if(__builtin_expect(instance.config.stat, false))
ms = ffTimeGetTick();
parseStructureCommand(&instance, &data, data.structure.chars + startIndex);
parseStructureCommand(&instance, data.structure.chars + startIndex);
if(__builtin_expect(instance.config.stat, false))
{
@@ -1586,7 +1285,6 @@ int main(int argc, const char** argv)
ffFinish(&instance);
ffStrbufDestroy(&data.structure);
ffValuestoreDestroy(&data.customValues);
ffDestroyInstance(&instance);
}
src/fastfetch.h
+56 -254
View File
@@ -16,54 +16,8 @@ static inline void ffUnused(int dummy, ...) { (void) dummy; }
#define FF_UNUSED(...) ffUnused(0, __VA_ARGS__);
#define FF_MAYBE_UNUSED __attribute__ ((__unused__))
#define FASTFETCH_LOGO_MAX_COLORS 9 //two digits would make parsing much more complicated (index 1 - 9)
typedef enum FFLogoType
{
FF_LOGO_TYPE_AUTO, //if something is given, first try builtin, then file. Otherwise detect logo
FF_LOGO_TYPE_BUILTIN, //builtin ascii art
FF_LOGO_TYPE_FILE, //text file, printed with color code replacement
FF_LOGO_TYPE_FILE_RAW, //text file, printed as is
FF_LOGO_TYPE_DATA, //text data, printed with color code replacement
FF_LOGO_TYPE_DATA_RAW, //text data, printed as is
FF_LOGO_TYPE_IMAGE_SIXEL, //image file, printed as sixel codes.
FF_LOGO_TYPE_IMAGE_KITTY, //image file, printed as kitty graphics protocol
FF_LOGO_TYPE_IMAGE_ITERM, //image file, printed as iterm graphics protocol
FF_LOGO_TYPE_IMAGE_CHAFA, //image file, printed as ascii art using libchafa
FF_LOGO_TYPE_IMAGE_RAW, //image file, printed as raw binary string
FF_LOGO_TYPE_NONE, //--logo none
} FFLogoType;
typedef enum FFSoundType
{
FF_SOUND_TYPE_MAIN,
FF_SOUND_TYPE_ACTIVE,
FF_SOUND_TYPE_ALL,
} FFSoundType;
typedef enum FFDisplayCompactType
{
FF_DISPLAY_COMPACT_TYPE_NONE = 0,
FF_DISPLAY_COMPACT_TYPE_ORIGINAL_BIT = 1 << 0,
FF_DISPLAY_COMPACT_TYPE_SCALED_BIT = 1 << 1,
} FFDisplayCompactType;
typedef enum FFLocalIpCompactType
{
FF_LOCALIP_COMPACT_TYPE_NONE,
FF_LOCALIP_COMPACT_TYPE_MULTILINE,
FF_LOCALIP_COMPACT_TYPE_ONELINE,
} FFLocalIpCompactType;
typedef enum FFDiskType
{
FF_DISK_TYPE_NONE = 0,
FF_DISK_TYPE_REGULAR_BIT = 1 << 0,
FF_DISK_TYPE_HIDDEN_BIT = 1 << 1,
FF_DISK_TYPE_EXTERNAL_BIT = 1 << 2,
FF_DISK_TYPE_SUBVOLUME_BIT = 1 << 3,
FF_DISK_TYPE_UNKNOWN_BIT = 1 << 4,
} FFDiskType;
#include "modules/options.h"
#include "logo/option.h"
typedef enum FFBinaryPrefixType
{
@@ -72,59 +26,15 @@ typedef enum FFBinaryPrefixType
FF_BINARY_PREFIX_TYPE_JEDEC, // 1024 Bytes = 1 kB, 1024 K = 1 MB, ...
} FFBinaryPrefixType;
typedef enum FFGLType
{
FF_GL_TYPE_AUTO,
FF_GL_TYPE_EGL,
FF_GL_TYPE_GLX,
FF_GL_TYPE_OSMESA
} FFGLType;
typedef struct FFModuleArgs
{
FFstrbuf key;
FFstrbuf outputFormat;
FFstrbuf errorFormat;
} FFModuleArgs;
typedef enum FFLocalIpType
{
FF_LOCALIP_TYPE_NONE,
FF_LOCALIP_TYPE_LOOP_BIT = 1 << 0,
FF_LOCALIP_TYPE_IPV4_BIT = 1 << 1,
FF_LOCALIP_TYPE_IPV6_BIT = 1 << 2,
FF_LOCALIP_TYPE_MAC_BIT = 1 << 3,
FF_LOCALIP_TYPE_COMPACT_BIT = 1 << 10,
} FFLocalIpType;
typedef struct FFconfig
{
struct
{
FFstrbuf source;
FFLogoType type;
FFstrbuf colors[FASTFETCH_LOGO_MAX_COLORS];
uint32_t width;
uint32_t height;
uint32_t paddingTop;
uint32_t paddingLeft;
uint32_t paddingRight;
bool printRemaining;
bool preserveAspectRadio;
bool chafaFgOnly;
FFstrbuf chafaSymbols;
uint32_t chafaCanvasMode;
uint32_t chafaColorSpace;
uint32_t chafaDitherMode;
} logo;
FFLogoOptions logo;
//If one of those is empty, ffLogoPrint will set them
FFstrbuf colorKeys;
FFstrbuf colorTitle;
FFstrbuf separator;
FFstrbuf keyValueSeparator;
bool showErrors;
bool recache;
@@ -133,58 +43,59 @@ typedef struct FFconfig
bool hideCursor;
bool escapeBedrock;
FFBinaryPrefixType binaryPrefixType;
FFGLType glType;
bool pipe; //disables logo and all escape sequences
bool multithreading;
bool stat;
FFModuleArgs os;
FFModuleArgs host;
FFModuleArgs bios;
FFModuleArgs board;
FFModuleArgs brightness;
FFModuleArgs chassis;
FFModuleArgs kernel;
FFModuleArgs uptime;
FFModuleArgs processes;
FFModuleArgs packages;
FFModuleArgs shell;
FFModuleArgs display;
FFModuleArgs de;
FFModuleArgs wallpaper;
FFModuleArgs wifi;
FFModuleArgs wm;
FFModuleArgs wmTheme;
FFModuleArgs theme;
FFModuleArgs icons;
FFModuleArgs font;
FFModuleArgs cursor;
FFModuleArgs terminal;
FFModuleArgs terminalFont;
FFModuleArgs cpu;
FFModuleArgs cpuUsage;
FFModuleArgs gpu;
FFModuleArgs memory;
FFModuleArgs swap;
FFModuleArgs disk;
FFModuleArgs battery;
FFModuleArgs powerAdapter;
FFModuleArgs locale;
FFModuleArgs localIP;
FFModuleArgs publicIP;
FFModuleArgs weather;
FFModuleArgs player;
FFModuleArgs media;
FFModuleArgs dateTime;
FFModuleArgs date;
FFModuleArgs time;
FFModuleArgs vulkan;
FFModuleArgs openGL;
FFModuleArgs openCL;
FFModuleArgs users;
FFModuleArgs bluetooth;
FFModuleArgs sound;
FFModuleArgs gamepad;
FFTitleOptions title;
FFOSOptions os;
FFHostOptions host;
FFBiosOptions bios;
FFBoardOptions board;
FFBrightnessOptions brightness;
FFChassisOptions chassis;
FFCommandOptions command;
FFKernelOptions kernel;
FFUptimeOptions uptime;
FFProcessesOptions processes;
FFPackagesOptions packages;
FFShellOptions shell;
FFDisplayOptions display;
FFDEOptions de;
FFWallpaperOptions wallpaper;
FFWifiOptions wifi;
FFWMOptions wm;
FFWMThemeOptions wmTheme;
FFThemeOptions theme;
FFIconsOptions icons;
FFFontOptions font;
FFCursorOptions cursor;
FFTerminalOptions terminal;
FFTerminalFontOptions terminalFont;
FFCPUOptions cpu;
FFCPUUsageOptions cpuUsage;
FFCustomOptions custom;
FFGPUOptions gpu;
FFMemoryOptions memory;
FFSwapOptions swap;
FFDiskOptions disk;
FFBatteryOptions battery;
FFPowerAdapterOptions powerAdapter;
FFLocaleOptions locale;
FFLocalIpOptions localIP;
FFPublicIpOptions publicIP;
FFWeatherOptions weather;
FFPlayerOptions player;
FFMediaOptions media;
FFDateTimeOptions dateTime;
FFVulkanOptions vulkan;
FFOpenGLOptions openGL;
FFOpenCLOptions openCL;
FFUsersOptions users;
FFBluetoothOptions bluetooth;
FFSeparatorOptions separator;
FFSoundOptions sound;
FFGamepadOptions gamepad;
FFstrbuf libPCI;
FFstrbuf libVulkan;
@@ -206,58 +117,15 @@ typedef struct FFconfig
FFstrbuf libGLX;
FFstrbuf libOSMesa;
FFstrbuf libOpenCL;
FFstrbuf libcJSON;
FFstrbuf libJSONC;
FFstrbuf libfreetype;
FFstrbuf libPulse;
FFstrbuf libwlanapi;
FFstrbuf libnm;
bool cpuTemp;
bool gpuTemp;
bool gpuForceVulkan;
bool batteryTemp;
bool gpuHideIntegrated;
bool gpuHideDiscrete;
bool titleFQDN;
bool shellVersion;
bool terminalVersion;
FFstrbuf diskFolders;
FFDiskType diskShowTypes;
FFDisplayCompactType displayCompactType;
bool displayDetectName;
bool displayPreciseRefreshRate;
bool bluetoothShowDisconnected;
FFstrbuf batteryDir;
FFstrbuf separatorString;
FFstrbuf localIpNamePrefix;
FFLocalIpType localIpShowType;
FFstrbuf publicIpUrl;
uint32_t publicIpTimeout;
FFstrbuf weatherOutputFormat;
uint32_t weatherTimeout;
FFSoundType soundType;
FFstrbuf osFile;
FFstrbuf playerName;
uint32_t percentType;
FFstrbuf commandShell;
FFlist commandKeys;
FFlist commandTexts;
bool jsonConfig;
} FFconfig;
typedef struct FFstate
@@ -265,6 +133,7 @@ typedef struct FFstate
uint32_t logoWidth;
uint32_t logoHeight;
uint32_t keysHeight;
uint32_t titleLength;
FFPlatform platform;
} FFstate;
@@ -299,71 +168,4 @@ void ffLogoBuiltinPrint(FFinstance* instance);
void ffLogoBuiltinList();
void ffLogoBuiltinListAutocompletion();
//////////////////////
// Module functions //
//////////////////////
//Common
void ffPrintDateTimeFormat(FFinstance* instance, const char* moduleName, const FFModuleArgs* moduleArgs);
void ffPrepareCPUUsage();
void ffPreparePublicIp(FFinstance* instance);
void ffPrepareWeather(FFinstance* instance);
//Printing
void ffPrintCustom(FFinstance* instance, const char* key, const char* value);
void ffPrintBreak(FFinstance* instance);
void ffPrintTitle(FFinstance* instance);
void ffPrintSeparator(FFinstance* instance);
void ffPrintOS(FFinstance* instance);
void ffPrintHost(FFinstance* instance);
void ffPrintBios(FFinstance* instance);
void ffPrintBoard(FFinstance* instance);
void ffPrintChassis(FFinstance* instance);
void ffPrintKernel(FFinstance* instance);
void ffPrintUptime(FFinstance* instance);
void ffPrintProcesses(FFinstance* instance);
void ffPrintPackages(FFinstance* instance);
void ffPrintShell(FFinstance* instance);
void ffPrintDisplay(FFinstance* instance);
void ffPrintBrightness(FFinstance* instance);
void ffPrintDesktopEnvironment(FFinstance* instance);
void ffPrintWM(FFinstance* instance);
void ffPrintWMTheme(FFinstance* instance);
void ffPrintTheme(FFinstance* instance);
void ffPrintIcons(FFinstance* instance);
void ffPrintWallpaper(FFinstance* instance);
void ffPrintFont(FFinstance* instance);
void ffPrintCursor(FFinstance* instance);
void ffPrintTerminal(FFinstance* instance);
void ffPrintTerminalFont(FFinstance* instance);
void ffPrintCPU(FFinstance* instance);
void ffPrintCPUUsage(FFinstance* instance);
void ffPrintGPU(FFinstance* instance);
void ffPrintMemory(FFinstance* instance);
void ffPrintSwap(FFinstance* instance);
void ffPrintDisk(FFinstance* instance);
void ffPrintBattery(FFinstance* instance);
void ffPrintPowerAdapter(FFinstance* instance);
void ffPrintLocale(FFinstance* instance);
void ffPrintPlayer(FFinstance* instance);
void ffPrintMedia(FFinstance* instance);
void ffPrintDateTime(FFinstance* instance);
void ffPrintDate(FFinstance* instance);
void ffPrintTime(FFinstance* instance);
void ffPrintLocalIp(FFinstance* instance);
void ffPrintPublicIp(FFinstance* instance);
void ffPrintWeather(FFinstance* instance);
void ffPrintWifi(FFinstance* instance);
void ffPrintColors(FFinstance* instance);
void ffPrintVulkan(FFinstance* instance);
void ffPrintOpenGL(FFinstance* instance);
void ffPrintOpenCL(FFinstance* instance);
void ffPrintUsers(FFinstance* instance);
void ffPrintCommand(FFinstance* instance);
void ffPrintBluetooth(FFinstance* instance);
void ffPrintSound(FFinstance* instance);
void ffPrintGamepad(FFinstance* instance);
#endif
src/flashfetch.c
+43 -41
View File
@@ -1,5 +1,7 @@
#include "fastfetch.h"
#include "modules/modules.h"
int main(int argc, char** argv)
{
//Disable compiler warnings
@@ -11,60 +13,60 @@ int main(int argc, char** argv)
//Modify instance.config here
// ffPrepareCPUUsage();
// ffPreparePublicIp(&instance);
// ffPreparePublicIp(&instance.config.publicIP);
// ffPrepareWeather(&instance);
//Does things like starting detection threads, disabling line wrap, etc
ffStart(&instance);
//Printing
ffPrintTitle(&instance);
ffPrintSeparator(&instance);
ffPrintOS(&instance);
ffPrintHost(&instance);
//ffPrintBios(&instance);
//ffPrintBoard(&instance);
//ffPrintChassis(&instance);
ffPrintKernel(&instance);
ffPrintUptime(&instance);
//ffPrintProcesses(&instance);
ffPrintPackages(&instance);
ffPrintShell(&instance);
ffPrintDisplay(&instance);
ffPrintTitle(&instance, &instance.config.title);
ffPrintSeparator(&instance, &instance.config.separator);
ffPrintOS(&instance, &instance.config.os);
ffPrintHost(&instance, &instance.config.host);
//ffPrintBios(&instance, &instance.config.bios);
//ffPrintBoard(&instance, &instance.config.board);
//ffPrintChassis(&instance, &instance.config.chassis);
ffPrintKernel(&instance, &instance.config.kernel);
//ffPrintProcesses(&instance, &instance.config.processes);
ffPrintUptime(&instance, &instance.config.uptime);
ffPrintPackages(&instance, &instance.config.packages);
ffPrintShell(&instance, &instance.config.shell);
ffPrintDisplay(&instance, &instance.config.display);
// ffPrintBrightness(&instance);
ffPrintDesktopEnvironment(&instance);
ffPrintWM(&instance);
ffPrintWMTheme(&instance);
ffPrintTheme(&instance);
ffPrintIcons(&instance);
ffPrintFont(&instance);
ffPrintCursor(&instance);
ffPrintTerminal(&instance);
ffPrintTerminalFont(&instance);
ffPrintCPU(&instance);
ffPrintGPU(&instance);
ffPrintMemory(&instance);
//ffPrintSwap(&instance);
ffPrintDisk(&instance);
ffPrintBattery(&instance);
ffPrintPowerAdapter(&instance);
//ffPrintPlayer(&instance);
//ffPrintMedia(&instance);
ffPrintDE(&instance, &instance.config.de);
ffPrintWM(&instance, &instance.config.wm);
ffPrintWMTheme(&instance, &instance.config.wmTheme);
ffPrintTheme(&instance, &instance.config.theme);
ffPrintIcons(&instance, &instance.config.icons);
ffPrintFont(&instance, &instance.config.font);
ffPrintCursor(&instance, &instance.config.cursor);
ffPrintTerminal(&instance, &instance.config.terminal);
ffPrintTerminalFont(&instance, &instance.config.terminalFont);
ffPrintCPU(&instance, &instance.config.cpu);
ffPrintGPU(&instance, &instance.config.gpu);
ffPrintMemory(&instance, &instance.config.memory);
ffPrintSwap(&instance, &instance.config.swap);
ffPrintDisk(&instance, &instance.config.disk);
ffPrintBattery(&instance, &instance.config.battery);
ffPrintPowerAdapter(&instance, &instance.config.powerAdapter);
//ffPrintPlayer(&instance, &instance.config.player);
//ffPrintMedia(&instance, &instance.config.media);
//ffPrintLocalIp(&instance);
//ffPrintPublicIp(&instance);
//ffPrintPublicIp(&instance, &instance.config.publicIp);
//ffPrintWifi(&instance);
//ffPrintCPUUsage(&instance);
ffPrintLocale(&instance);
//ffPrintCPUUsage(&instance, &instance.config.cpuUsage);
ffPrintLocale(&instance, &instance.config.locale);
//ffPrintDateTime(&instance);
//ffPrintDate(&instance);
//ffPrintTime(&instance);
//ffPrintVulkan(&instance);
//ffPrintOpenGL(&instance);
//ffPrintOpenCL(&instance);
//ffPrintUsers(&instance);
//ffPrintWeather(&instance);
//ffPrintVulkan(&instance, &instance.config.vulkan);
//ffPrintOpenGL(&instance, &instance.config.openGL);
//ffPrintOpenCL(&instance, &instance.config.openCL);
//ffPrintUsers(&instance, &instance.config.users);
//ffPrintWeather(&instance, &instance.config.weather);
//ffPrintBluetooth(&instance);
//ffPrintSound(&instance);
//ffPrintSound(&instance, &instance.config.sound);
//ffPrintGamepad(&instance);
ffPrintBreak(&instance);
ffPrintColors(&instance);
src/logo/image/image.c
+7 -21
View File
@@ -12,8 +12,7 @@ static FFstrbuf base64Encode(FFstrbuf* in)
{
const char* base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
FFstrbuf out;
ffStrbufInitA(&out, 8 * (1 + in->length / 6));
FFstrbuf out = ffStrbufCreateA(8 * (1 + in->length / 6));
unsigned val = 0;
int valb = -6;
@@ -41,8 +40,7 @@ static bool printImageIterm(FFinstance* instance)
return false;
}
FFstrbuf buf;
ffStrbufInit(&buf);
FF_STRBUF_AUTO_DESTROY buf = ffStrbufCreate();
if(!ffAppendFileBuffer(instance->config.logo.source.chars, &buf))
{
fputs("Logo: Failed to load image file\n", stderr);
@@ -51,7 +49,8 @@ static bool printImageIterm(FFinstance* instance)
ffPrintCharTimes(' ', instance->config.logo.paddingLeft);
ffPrintCharTimes('\n', instance->config.logo.paddingTop);
FFstrbuf base64 = base64Encode(&buf);
FF_STRBUF_AUTO_DESTROY base64 = base64Encode(&buf);
instance->state.logoWidth = instance->config.logo.width + instance->config.logo.paddingLeft + instance->config.logo.paddingRight;
instance->state.logoHeight = instance->config.logo.paddingTop + instance->config.logo.height;
printf("\033]1337;File=inline=1;width=%u;height=%u;preserveAspectRatio=%u:%s\a\033[9999999D\n\033[%uA",
@@ -62,9 +61,6 @@ static bool printImageIterm(FFinstance* instance)
(unsigned) instance->state.logoHeight
);
ffStrbufDestroy(&buf);
ffStrbufDestroy(&base64);
return true;
}
@@ -289,8 +285,7 @@ static bool printImageKitty(FFinstance* instance, FFLogoRequestData* requestData
if(!checkAllocationResult(chars, length))
return false;
FFstrbuf result;
ffStrbufInitA(&result, (uint32_t) (length + 1024));
FF_STRBUF_AUTO_DESTROY result = ffStrbufCreateA((uint32_t) (length + 1024));
const char* currentPos = chars;
size_t remainingLength = length;
@@ -304,7 +299,6 @@ static bool printImageKitty(FFinstance* instance, FFLogoRequestData* requestData
printImagePixels(instance, requestData, &result, isCompressed ? FF_CACHE_FILE_KITTY_COMPRESSED : FF_CACHE_FILE_KITTY_UNCOMPRESSED);
ffStrbufDestroy(&result);
free(chars);
return true;
}
@@ -532,8 +526,7 @@ static void readCachedStrbuf(FFLogoRequestData* requestData, FFstrbuf* result, c
static uint32_t readCachedUint32(FFLogoRequestData* requestData, const char* cacheFileName)
{
FFstrbuf content;
ffStrbufInit(&content);
FF_STRBUF_AUTO_DESTROY content = ffStrbufCreate();
readCachedStrbuf(requestData, &content, cacheFileName);
uint32_t result = 0;
@@ -546,27 +539,20 @@ static uint32_t readCachedUint32(FFLogoRequestData* requestData, const char* cac
memcpy(&result, content.chars, sizeof(result));
ffStrbufDestroy(&content);
return result;
}
static bool printCachedChars(FFinstance* instance, FFLogoRequestData* requestData)
{
FFstrbuf content;
ffStrbufInitA(&content, 32768);
FF_STRBUF_AUTO_DESTROY content = ffStrbufCreateA(32768);
if(requestData->type == FF_LOGO_TYPE_IMAGE_CHAFA)
readCachedStrbuf(requestData, &content, FF_CACHE_FILE_CHAFA);
if(content.length == 0)
{
ffStrbufDestroy(&content);
return false;
}
ffLogoPrintChars(instance, content.chars, false);
ffStrbufDestroy(&content);
return true;
}
src/logo/logo.c
+54 -44
View File
@@ -1,4 +1,4 @@
#include "logo.h"
#include "logo/logo.h"
#include "common/io/io.h"
#include "common/printing.h"
#include "detection/os/os.h"
@@ -10,35 +10,38 @@
static void ffLogoPrintCharsRaw(FFinstance* instance, const char* data, size_t length)
{
FFLogoOptions* options = &instance->config.logo;
fputs(FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
ffPrintCharTimes('\n', instance->config.logo.paddingTop);
ffPrintCharTimes(' ', instance->config.logo.paddingLeft);
ffPrintCharTimes('\n', options->paddingTop);
ffPrintCharTimes(' ', options->paddingLeft);
fwrite(data, length, 1, stdout);
instance->state.logoHeight = instance->config.logo.paddingTop + instance->config.logo.height;
instance->state.logoWidth = instance->config.logo.paddingLeft + instance->config.logo.width + instance->config.logo.paddingRight;
instance->state.logoHeight = options->paddingTop + options->height;
instance->state.logoWidth = options->paddingLeft + options->width + options->paddingRight;
printf("\033[9999999D\n\033[%uA", instance->state.logoHeight);
}
void ffLogoPrintChars(FFinstance* instance, const char* data, bool doColorReplacement)
{
FFLogoOptions* options = &instance->config.logo;
uint32_t currentlineLength = 0;
fputs(FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
ffPrintCharTimes('\n', instance->config.logo.paddingTop);
ffPrintCharTimes(' ', instance->config.logo.paddingLeft);
ffPrintCharTimes('\n', options->paddingTop);
ffPrintCharTimes(' ', options->paddingLeft);
instance->state.logoHeight = instance->config.logo.paddingTop;
instance->state.logoHeight = options->paddingTop;
//Use logoColor[0] as the default color
if(doColorReplacement)
ffPrintColor(&instance->config.logo.colors[0]);
ffPrintColor(&options->colors[0]);
while(*data != '\0')
{
//We are at the end of a line. Print paddings and update max line length
if(*data == '\n' || (*data == '\r' && *(data + 1) == '\n'))
{
ffPrintCharTimes(' ', instance->config.logo.paddingRight);
ffPrintCharTimes(' ', options->paddingRight);
//We have \r\n, skip the \r
if(*data == '\r')
@@ -47,7 +50,7 @@ void ffLogoPrintChars(FFinstance* instance, const char* data, bool doColorReplac
putchar('\n');
++data;
ffPrintCharTimes(' ', instance->config.logo.paddingLeft);
ffPrintCharTimes(' ', options->paddingLeft);
if(currentlineLength > instance->state.logoWidth)
instance->state.logoWidth = currentlineLength;
@@ -115,7 +118,7 @@ void ffLogoPrintChars(FFinstance* instance, const char* data, bool doColorReplac
}
else
{
ffPrintColor(&instance->config.logo.colors[index]);
ffPrintColor(&options->colors[index]);
++data;
continue;
}
@@ -148,14 +151,14 @@ void ffLogoPrintChars(FFinstance* instance, const char* data, bool doColorReplac
}
}
ffPrintCharTimes(' ', instance->config.logo.paddingRight);
ffPrintCharTimes(' ', options->paddingRight);
fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
//Happens if the last line is the longest
if(currentlineLength > instance->state.logoWidth)
instance->state.logoWidth = currentlineLength;
instance->state.logoWidth += instance->config.logo.paddingLeft + instance->config.logo.paddingRight;
instance->state.logoWidth += options->paddingLeft + options->paddingRight;
//Go to the leftmost position
fputs("\033[9999999D", stdout);
@@ -241,11 +244,13 @@ static void logoPrintStruct(FFinstance* instance, const FFlogo* logo)
{
logoApplyColors(instance, logo);
FFLogoOptions* options = &instance->config.logo;
const char** colors = logo->builtinColors;
for(int i = 0; *colors != NULL && i < FASTFETCH_LOGO_MAX_COLORS; i++, colors++)
{
if(instance->config.logo.colors[i].length == 0)
ffStrbufAppendS(&instance->config.logo.colors[i], *colors);
if(options->colors[i].length == 0)
ffStrbufAppendS(&options->colors[i], *colors);
}
ffLogoPrintChars(instance, logo->data, true);
@@ -281,47 +286,47 @@ static inline void logoPrintDetected(FFinstance* instance)
}
static bool logoPrintData(FFinstance* instance, bool doColorReplacement) {
if(instance->config.logo.source.length == 0)
FFLogoOptions* options = &instance->config.logo;
if(options->source.length == 0)
return false;
ffLogoPrintChars(instance, instance->config.logo.source.chars, doColorReplacement);
ffLogoPrintChars(instance, options->source.chars, doColorReplacement);
logoApplyColorsDetected(instance);
return true;
}
static void updateLogoPath(FFinstance* instance)
{
if(ffPathExists(instance->config.logo.source.chars, FF_PATHTYPE_FILE))
FFLogoOptions* options = &instance->config.logo;
if(ffPathExists(options->source.chars, FF_PATHTYPE_FILE))
return;
FFstrbuf fullPath;
ffStrbufInit(&fullPath);
FF_STRBUF_AUTO_DESTROY fullPath = ffStrbufCreate();
FF_LIST_FOR_EACH(FFstrbuf, dataDir, instance->state.platform.dataDirs)
{
//We need to copy it, because multiple threads might be using dataDirs at the same time
ffStrbufSet(&fullPath, dataDir);
ffStrbufAppendS(&fullPath, "fastfetch/logos/");
ffStrbufAppend(&fullPath, &instance->config.logo.source);
ffStrbufAppend(&fullPath, &options->source);
if(ffPathExists(fullPath.chars, FF_PATHTYPE_FILE))
{
ffStrbufSet(&instance->config.logo.source, &fullPath);
ffStrbufSet(&options->source, &fullPath);
break;
}
}
ffStrbufDestroy(&fullPath);
}
static bool logoPrintFileIfExists(FFinstance* instance, bool doColorReplacement, bool raw)
{
FFstrbuf content;
ffStrbufInit(&content);
FFLogoOptions* options = &instance->config.logo;
if(!ffAppendFileBuffer(instance->config.logo.source.chars, &content))
FF_STRBUF_AUTO_DESTROY content = ffStrbufCreate();
if(!ffAppendFileBuffer(options->source.chars, &content))
{
ffStrbufDestroy(&content);
fputs("Logo: Failed to load file content from logo source\n", stderr);
return false;
}
@@ -331,7 +336,7 @@ static bool logoPrintFileIfExists(FFinstance* instance, bool doColorReplacement,
ffLogoPrintCharsRaw(instance, content.chars, content.length);
else
ffLogoPrintChars(instance, content.chars, doColorReplacement);
ffStrbufDestroy(&content);
return true;
}
@@ -346,32 +351,34 @@ static bool logoPrintImageIfExists(FFinstance* instance, FFLogoType logo, bool p
static bool logoTryKnownType(FFinstance* instance)
{
if(instance->config.logo.type == FF_LOGO_TYPE_NONE)
FFLogoOptions* options = &instance->config.logo;
if(options->type == FF_LOGO_TYPE_NONE)
{
logoApplyColorsDetected(instance);
return true;
}
if(instance->config.logo.type == FF_LOGO_TYPE_BUILTIN)
return logoPrintBuiltinIfExists(instance, instance->config.logo.source.chars);
if(options->type == FF_LOGO_TYPE_BUILTIN)
return logoPrintBuiltinIfExists(instance, options->source.chars);
if(instance->config.logo.type == FF_LOGO_TYPE_DATA)
if(options->type == FF_LOGO_TYPE_DATA)
return logoPrintData(instance, true);
if(instance->config.logo.type == FF_LOGO_TYPE_DATA_RAW)
if(options->type == FF_LOGO_TYPE_DATA_RAW)
return logoPrintData(instance, false);
updateLogoPath(instance); //We sure have a file, resolve relative paths
if(instance->config.logo.type == FF_LOGO_TYPE_FILE)
if(options->type == FF_LOGO_TYPE_FILE)
return logoPrintFileIfExists(instance, true, false);
if(instance->config.logo.type == FF_LOGO_TYPE_FILE_RAW)
if(options->type == FF_LOGO_TYPE_FILE_RAW)
return logoPrintFileIfExists(instance, false, false);
if(instance->config.logo.type == FF_LOGO_TYPE_IMAGE_RAW)
if(options->type == FF_LOGO_TYPE_IMAGE_RAW)
{
if(instance->config.logo.width == 0 || instance->config.logo.height == 0)
if(options->width == 0 || options->height == 0)
{
fputs("both `--logo-width` and `--logo-height` must be specified\n", stderr);
return false;
@@ -380,7 +387,7 @@ static bool logoTryKnownType(FFinstance* instance)
return logoPrintFileIfExists(instance, false, true);
}
return logoPrintImageIfExists(instance, instance->config.logo.type, true);
return logoPrintImageIfExists(instance, options->type, true);
}
static void logoPrintKnownType(FFinstance* instance)
@@ -401,22 +408,24 @@ void ffLogoPrint(FFinstance* instance)
return;
}
const FFLogoOptions* options = &instance->config.logo;
//If the source is not set, we can directly print the detected logo.
if(instance->config.logo.source.length == 0)
if(options->source.length == 0)
{
logoPrintDetected(instance);
return;
}
//If the source and source type is set to something else than auto, always print with the set type.
if(instance->config.logo.source.length > 0 && instance->config.logo.type != FF_LOGO_TYPE_AUTO)
if(options->source.length > 0 && options->type != FF_LOGO_TYPE_AUTO)
{
logoPrintKnownType(instance);
return;
}
//If source matches the name of a builtin logo, print it and return.
if(logoPrintBuiltinIfExists(instance, instance->config.logo.source.chars))
if(logoPrintBuiltinIfExists(instance, options->source.chars))
return;
//Make sure the logo path is set correctly.
@@ -462,6 +471,7 @@ void ffLogoPrintRemaining(FFinstance* instance)
void ffLogoBuiltinPrint(FFinstance* instance)
{
GetLogoMethod* methods = ffLogoBuiltinGetAll();
FFLogoOptions* options = &instance->config.logo;
while(*methods != NULL)
{
@@ -474,7 +484,7 @@ void ffLogoBuiltinPrint(FFinstance* instance)
instance->state.logoHeight = 0;
instance->state.keysHeight = 0;
for(uint8_t i = 0; i < FASTFETCH_LOGO_MAX_COLORS; i++)
ffStrbufClear(&instance->config.logo.colors[i]);
ffStrbufClear(&options->colors[i]);
puts("\n");
++methods;
src/logo/logo.h
+5
View File
@@ -26,4 +26,9 @@ GetLogoMethod* ffLogoBuiltinGetAll();
//image/image.c
bool ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type, bool printError);
//option.c
void ffInitLogoOptions(FFLogoOptions* options);
bool ffParseLogoCommandOptions(FFLogoOptions* options, const char* key, const char* value);
void ffDestroyLogoOptions(FFLogoOptions* options);
#endif
src/logo/option.c
+183
View File
@@ -0,0 +1,183 @@
#include "logo/logo.h"
void ffInitLogoOptions(FFLogoOptions* options)
{
ffStrbufInit(&options->source);
options->type = FF_LOGO_TYPE_AUTO;
for(uint8_t i = 0; i < (uint8_t) FASTFETCH_LOGO_MAX_COLORS; ++i)
ffStrbufInit(&options->colors[i]);
options->width = 0;
options->height = 0; //preserve aspect ratio
options->paddingTop = 0;
options->paddingLeft = 0;
options->paddingRight = 4;
options->printRemaining = true;
options->preserveAspectRadio = false;
options->chafaFgOnly = false;
ffStrbufInitS(&options->chafaSymbols, "block+border+space-wide-inverted"); // Chafa default
options->chafaCanvasMode = UINT32_MAX;
options->chafaColorSpace = UINT32_MAX;
options->chafaDitherMode = UINT32_MAX;
}
bool ffParseLogoCommandOptions(FFLogoOptions* options, const char* key, const char* value)
{
if (strcasecmp(key, "-l") == 0)
goto logoType;
const char* subKey = ffOptionTestPrefix(key, "logo");
if(subKey)
{
if (subKey[0] == '\0')
{
logoType:
ffOptionParseString(key, value, &options->source);
//this is usally wanted when using the none logo
if(strcasecmp(value, "none") == 0)
{
options->paddingTop = 0;
options->paddingRight = 0;
options->paddingLeft = 0;
options->type = FF_LOGO_TYPE_NONE;
}
}
else if(strcasecmp(subKey, "type") == 0)
{
options->type = (FFLogoType) ffOptionParseEnum(key, value, (FFKeyValuePair[]) {
{ "auto", FF_LOGO_TYPE_AUTO },
{ "builtin", FF_LOGO_TYPE_BUILTIN },
{ "file", FF_LOGO_TYPE_FILE },
{ "file-raw", FF_LOGO_TYPE_FILE_RAW },
{ "data", FF_LOGO_TYPE_DATA },
{ "data-raw", FF_LOGO_TYPE_DATA_RAW },
{ "sixel", FF_LOGO_TYPE_IMAGE_SIXEL },
{ "kitty", FF_LOGO_TYPE_IMAGE_KITTY },
{ "iterm", FF_LOGO_TYPE_IMAGE_ITERM },
{ "chafa", FF_LOGO_TYPE_IMAGE_CHAFA },
{ "raw", FF_LOGO_TYPE_IMAGE_RAW },
{ "none", FF_LOGO_TYPE_NONE },
{},
});
}
else if(strncasecmp(subKey, "color-", strlen("color-")) && key[13] != '\0' && key[14] == '\0') // matches "--logo-color-*"
{
//Map the number to an array index, so that '1' -> 0, '2' -> 1, etc.
int index = (int)key[13] - 49;
//Match only --logo-color-[1-9]
if(index < 0 || index >= FASTFETCH_LOGO_MAX_COLORS)
{
fprintf(stderr, "Error: invalid --color-[1-9] index: %c\n", key[13]);
exit(472);
}
ffOptionParseColor(key, value, &options->colors[index]);
}
else if(strcasecmp(subKey, "width") == 0)
options->width = ffOptionParseUInt32(key, value);
else if(strcasecmp(subKey, "height") == 0)
options->height = ffOptionParseUInt32(key, value);
else if(strcasecmp(subKey, "padding") == 0)
{
uint32_t padding = ffOptionParseUInt32(key, value);
options->paddingLeft = padding;
options->paddingRight = padding;
}
else if(strcasecmp(subKey, "padding-top") == 0)
options->paddingTop = ffOptionParseUInt32(key, value);
else if(strcasecmp(subKey, "padding-left") == 0)
options->paddingLeft = ffOptionParseUInt32(key, value);
else if(strcasecmp(subKey, "padding-right") == 0)
options->paddingRight = ffOptionParseUInt32(key, value);
else if(strcasecmp(subKey, "print-remaining") == 0)
options->printRemaining = ffOptionParseBoolean(value);
else if(strcasecmp(subKey, "preserve-aspect-radio") == 0)
options->preserveAspectRadio = ffOptionParseBoolean(value);
else
return false;
}
else if((subKey = ffOptionTestPrefix(key, "file")))
{
if(subKey[0] == '\0')
{
ffOptionParseString(key, value, &options->source);
options->type = FF_LOGO_TYPE_FILE;
}
else if(strcasecmp(key, "raw") == 0)
{
ffOptionParseString(key, value, &options->source);
options->type = FF_LOGO_TYPE_FILE_RAW;
}
else
return false;
}
else if((subKey = ffOptionTestPrefix(key, "data")))
{
if(subKey[0] == '\0')
{
ffOptionParseString(key, value, &options->source);
options->type = FF_LOGO_TYPE_DATA;
}
else if(strcasecmp(subKey, "raw") == 0)
{
ffOptionParseString(key, value, &options->source);
options->type = FF_LOGO_TYPE_DATA_RAW;
}
else
return false;
}
else if(strcasecmp(key, "--sixel") == 0)
{
ffOptionParseString(key, value, &options->source);
options->type = FF_LOGO_TYPE_IMAGE_SIXEL;
}
else if(strcasecmp(key, "--kitty") == 0)
{
ffOptionParseString(key, value, &options->source);
options->type = FF_LOGO_TYPE_IMAGE_KITTY;
}
else if(strcasecmp(key, "--iterm") == 0)
{
ffOptionParseString(key, value, &options->source);
options->type = FF_LOGO_TYPE_IMAGE_ITERM;
}
else if(strcasecmp(key, "--raw") == 0)
{
ffOptionParseString(key, value, &options->source);
options->type = FF_LOGO_TYPE_IMAGE_RAW;
}
else if((subKey = ffOptionTestPrefix(key, "chafa")))
{
if(subKey[0] == '\0')
{
ffOptionParseString(key, value, &options->source);
options->type = FF_LOGO_TYPE_IMAGE_CHAFA;
}
else if(strcasecmp(subKey, "fg-only") == 0)
options->chafaFgOnly = ffOptionParseBoolean(value);
else if(strcasecmp(subKey, "symbols") == 0)
ffOptionParseString(key, value, &options->chafaSymbols);
else if(strcasecmp(subKey, "canvas-mode") == 0)
options->chafaCanvasMode = ffOptionParseUInt32(key, value);
else if(strcasecmp(subKey, "color-space") == 0)
options->chafaColorSpace = ffOptionParseUInt32(key, value);
else if(strcasecmp(subKey, "dither-mode") == 0)
options->chafaDitherMode = ffOptionParseUInt32(key, value);
else
return false;
}
else
return false;
return true;
}
void ffDestroyLogoOptions(FFLogoOptions* options)
{
ffStrbufDestroy(&options->source);
ffStrbufDestroy(&options->chafaSymbols);
for(uint8_t i = 0; i < (uint8_t) FASTFETCH_LOGO_MAX_COLORS; ++i)
ffStrbufDestroy(&options->colors[i]);
}
src/logo/option.h
+41
View File
@@ -0,0 +1,41 @@
#pragma once
#include "util/FFstrbuf.h"
#define FASTFETCH_LOGO_MAX_COLORS 9 //two digits would make parsing much more complicated (index 1 - 9)
typedef enum FFLogoType
{
FF_LOGO_TYPE_AUTO, //if something is given, first try builtin, then file. Otherwise detect logo
FF_LOGO_TYPE_BUILTIN, //builtin ascii art
FF_LOGO_TYPE_FILE, //text file, printed with color code replacement
FF_LOGO_TYPE_FILE_RAW, //text file, printed as is
FF_LOGO_TYPE_DATA, //text data, printed with color code replacement
FF_LOGO_TYPE_DATA_RAW, //text data, printed as is
FF_LOGO_TYPE_IMAGE_SIXEL, //image file, printed as sixel codes.
FF_LOGO_TYPE_IMAGE_KITTY, //image file, printed as kitty graphics protocol
FF_LOGO_TYPE_IMAGE_ITERM, //image file, printed as iterm graphics protocol
FF_LOGO_TYPE_IMAGE_CHAFA, //image file, printed as ascii art using libchafa
FF_LOGO_TYPE_IMAGE_RAW, //image file, printed as raw binary string
FF_LOGO_TYPE_NONE, //--logo none
} FFLogoType;
typedef struct FFLogoOptions
{
FFstrbuf source;
FFLogoType type;
FFstrbuf colors[FASTFETCH_LOGO_MAX_COLORS];
uint32_t width;
uint32_t height;
uint32_t paddingTop;
uint32_t paddingLeft;
uint32_t paddingRight;
bool printRemaining;
bool preserveAspectRadio;
bool chafaFgOnly;
FFstrbuf chafaSymbols;
uint32_t chafaCanvasMode;
uint32_t chafaColorSpace;
uint32_t chafaDitherMode;
} FFLogoOptions;
src/modules/battery.c → src/modules/battery/battery.c
+88 -12
View File
@@ -2,23 +2,22 @@
#include "common/printing.h"
#include "common/bar.h"
#include "detection/battery/battery.h"
#include "modules/battery/battery.h"
#define FF_BATTERY_MODULE_NAME "Battery"
#define FF_BATTERY_NUM_FORMAT_ARGS 5
static void printBattery(FFinstance* instance, BatteryResult* result, uint8_t index)
static void printBattery(FFinstance* instance, FFBatteryOptions* options, BatteryResult* result, uint8_t index)
{
if(instance->config.battery.outputFormat.length == 0)
if(instance->config.battery.moduleArgs.outputFormat.length == 0)
{
ffPrintLogoAndKey(instance, FF_BATTERY_MODULE_NAME, index, &instance->config.battery.key);
ffPrintLogoAndKey(instance, FF_BATTERY_MODULE_NAME, index, &options->moduleArgs.key);
bool showStatus =
!(instance->config.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT) &&
result->status.length > 0 &&
ffStrbufIgnCaseCompS(&result->status, "Unknown") != 0;
FFstrbuf str;
ffStrbufInit(&str);
FF_STRBUF_AUTO_DESTROY str = ffStrbufCreate();
if(result->capacity >= 0)
{
@@ -58,11 +57,10 @@ static void printBattery(FFinstance* instance, BatteryResult* result, uint8_t in
}
ffStrbufPutTo(&str, stdout);
ffStrbufDestroy(&str);
}
else
{
ffPrintFormat(instance, FF_BATTERY_MODULE_NAME, index, &instance->config.battery, FF_BATTERY_NUM_FORMAT_ARGS, (FFformatarg[]){
ffPrintFormat(instance, FF_BATTERY_MODULE_NAME, index, &options->moduleArgs, FF_BATTERY_NUM_FORMAT_ARGS, (FFformatarg[]){
{FF_FORMAT_ARG_TYPE_STRBUF, &result->manufacturer},
{FF_FORMAT_ARG_TYPE_STRBUF, &result->modelName},
{FF_FORMAT_ARG_TYPE_STRBUF, &result->technology},
@@ -73,7 +71,7 @@ static void printBattery(FFinstance* instance, BatteryResult* result, uint8_t in
}
}
void ffPrintBattery(FFinstance* instance)
void ffPrintBattery(FFinstance* instance, FFBatteryOptions* options)
{
FFlist results;
ffListInitA(&results, sizeof(BatteryResult), 0);
@@ -82,14 +80,14 @@ void ffPrintBattery(FFinstance* instance)
if (error)
{
ffPrintError(instance, FF_BATTERY_MODULE_NAME, 0, &instance->config.battery, "%s", error);
ffPrintError(instance, FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
}
else
{
for(uint8_t i = 0; i < (uint8_t) results.length; i++)
{
BatteryResult* result = ffListGet(&results, i);
printBattery(instance, result, i);
printBattery(instance, options, result, i);
ffStrbufDestroy(&result->manufacturer);
ffStrbufDestroy(&result->modelName);
@@ -97,8 +95,86 @@ void ffPrintBattery(FFinstance* instance)
ffStrbufDestroy(&result->status);
}
if(results.length == 0)
ffPrintError(instance, FF_BATTERY_MODULE_NAME, 0, &instance->config.battery, "No batteries found");
ffPrintError(instance, FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, "No batteries found");
}
ffListDestroy(&results);
}
void ffInitBatteryOptions(FFBatteryOptions* options)
{
options->moduleName = FF_BATTERY_MODULE_NAME;
ffOptionInitModuleArg(&options->moduleArgs);
options->temp = false;
#ifdef __linux__
ffStrbufInit(&options->dir);
#endif
}
bool ffParseBatteryCommandOptions(FFBatteryOptions* options, const char* key, const char* value)
{
const char* subKey = ffOptionTestPrefix(key, FF_BATTERY_MODULE_NAME);
if (!subKey) return false;
if (ffOptionParseModuleArgs(key, subKey, value, &options->moduleArgs))
return true;
if (strcasecmp(subKey, "temp") == 0)
{
options->temp = ffOptionParseBoolean(value);
return true;
}
#ifdef __linux__
if (strcasecmp(subKey, "dir") == 0)
{
ffOptionParseString(key, value, &options->dir);
return true;
}
#endif
return false;
}
void ffDestroyBatteryOptions(FFBatteryOptions* options)
{
ffOptionDestroyModuleArg(&options->moduleArgs);
#ifdef __linux__
ffStrbufDestroy(&options->dir);
#endif
}
#ifdef FF_HAVE_JSONC
void ffParseBatteryJsonObject(FFinstance* instance, json_object* module)
{
FFBatteryOptions __attribute__((__cleanup__(ffDestroyBatteryOptions))) options;
ffInitBatteryOptions(&options);
if (module)
{
json_object_object_foreach(module, key, val)
{
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
continue;
#ifdef __linux__
if (strcasecmp(key, "dir") == 0)
{
ffStrbufSetS(&options.dir, json_object_get_string(val));
continue;
}
#endif
if (strcasecmp(key, "temp") == 0)
{
options.temp = (bool) json_object_get_boolean(val);
continue;
}
ffPrintError(instance, FF_BATTERY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintBattery(instance, &options);
}
#endif
src/modules/battery/battery.h
+16
View File
@@ -0,0 +1,16 @@
#pragma once
#include "fastfetch.h"
#define FF_BATTERY_MODULE_NAME "Battery"
void ffPrintBattery(FFinstance* instance, FFBatteryOptions* options);
void ffInitBatteryOptions(FFBatteryOptions* options);
bool ffParseBatteryCommandOptions(FFBatteryOptions* options, const char* key, const char* value);
void ffDestroyBatteryOptions(FFBatteryOptions* options);
#ifdef FF_HAVE_JSONC
#include "common/jsonconfig.h"
void ffParseBatteryJsonObject(FFinstance* instance, json_object* module);
#endif
src/modules/battery/option.h
+17
View File
@@ -0,0 +1,17 @@
#pragma once
// This file will be included in "fastfetch.h", do NOT put unnecessary things here
#include "common/option.h"
typedef struct FFBatteryOptions
{
const char* moduleName;
FFModuleArgs moduleArgs;
bool temp;
#ifdef __linux__
FFstrbuf dir;
#endif
} FFBatteryOptions;
src/modules/bios.c
-46
View File
@@ -1,46 +0,0 @@
#include "fastfetch.h"
#include "common/printing.h"
#include "detection/bios/bios.h"
#define FF_BIOS_MODULE_NAME "Bios"
#define FF_BIOS_NUM_FORMAT_ARGS 4
void ffPrintBios(FFinstance* instance)
{
FFBiosResult result;
ffDetectBios(&result);
if(result.error.length > 0)
{
ffPrintError(instance, FF_BIOS_MODULE_NAME, 0, &instance->config.bios, "%*s", result.error.length, result.error.chars);
goto exit;
}
if(result.biosRelease.length == 0)
{
ffPrintError(instance, FF_BIOS_MODULE_NAME, 0, &instance->config.bios, "bios_release is not set.");
goto exit;
}
if(instance->config.bios.outputFormat.length == 0)
{
ffPrintLogoAndKey(instance, FF_BIOS_MODULE_NAME, 0, &instance->config.bios.key);
puts(result.biosRelease.chars);
}
else
{
ffPrintFormat(instance, FF_BIOS_MODULE_NAME, 0, &instance->config.bios, FF_BIOS_NUM_FORMAT_ARGS, (FFformatarg[]) {
{FF_FORMAT_ARG_TYPE_STRBUF, &result.biosDate},
{FF_FORMAT_ARG_TYPE_STRBUF, &result.biosRelease},
{FF_FORMAT_ARG_TYPE_STRBUF, &result.biosVendor},
{FF_FORMAT_ARG_TYPE_STRBUF, &result.biosVersion},
});
}
exit:
ffStrbufDestroy(&result.biosDate);
ffStrbufDestroy(&result.biosRelease);
ffStrbufDestroy(&result.biosVendor);
ffStrbufDestroy(&result.biosVersion);
ffStrbufDestroy(&result.error);
}
src/modules/bios/bios.c
+88
View File
@@ -0,0 +1,88 @@
#include "fastfetch.h"
#include "common/printing.h"
#include "detection/bios/bios.h"
#include "modules/bios/bios.h"
#define FF_BIOS_NUM_FORMAT_ARGS 4
void ffPrintBios(FFinstance* instance, FFBiosOptions* options)
{
FFBiosResult result;
ffDetectBios(&result);
if(result.error.length > 0)
{
ffPrintError(instance, FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, "%*s", result.error.length, result.error.chars);
goto exit;
}
if(result.biosRelease.length == 0)
{
ffPrintError(instance, FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, "bios_release is not set.");
goto exit;
}
if(options->moduleArgs.outputFormat.length == 0)
{
ffPrintLogoAndKey(instance, FF_BIOS_MODULE_NAME, 0, &options->moduleArgs.key);
puts(result.biosRelease.chars);
}
else
{
ffPrintFormat(instance, FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, FF_BIOS_NUM_FORMAT_ARGS, (FFformatarg[]) {
{FF_FORMAT_ARG_TYPE_STRBUF, &result.biosDate},
{FF_FORMAT_ARG_TYPE_STRBUF, &result.biosRelease},
{FF_FORMAT_ARG_TYPE_STRBUF, &result.biosVendor},
{FF_FORMAT_ARG_TYPE_STRBUF, &result.biosVersion},
});
}
exit:
ffStrbufDestroy(&result.biosDate);
ffStrbufDestroy(&result.biosRelease);
ffStrbufDestroy(&result.biosVendor);
ffStrbufDestroy(&result.biosVersion);
ffStrbufDestroy(&result.error);
}
void ffInitBiosOptions(FFBiosOptions* options)
{
options->moduleName = FF_BIOS_MODULE_NAME;
ffOptionInitModuleArg(&options->moduleArgs);
}
bool ffParseBiosCommandOptions(FFBiosOptions* options, const char* key, const char* value)
{
const char* subKey = ffOptionTestPrefix(key, FF_BIOS_MODULE_NAME);
if (!subKey) return false;
if (ffOptionParseModuleArgs(key, subKey, value, &options->moduleArgs))
return true;
return false;
}
void ffDestroyBiosOptions(FFBiosOptions* options)
{
ffOptionDestroyModuleArg(&options->moduleArgs);
}
#ifdef FF_HAVE_JSONC
void ffParseBiosJsonObject(FFinstance* instance, json_object* module)
{
FFBiosOptions __attribute__((__cleanup__(ffDestroyBiosOptions))) options;
ffInitBiosOptions(&options);
if (module)
{
json_object_object_foreach(module, key, val)
{
if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
continue;
ffPrintError(instance, FF_BIOS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
}
}
ffPrintBios(instance, &options);
}
#endif
src/modules/bios/bios.h
+15
View File
@@ -0,0 +1,15 @@
#pragma once
#include "fastfetch.h"
#define FF_BIOS_MODULE_NAME "Bios"
void ffPrintBios(FFinstance* instance, FFBiosOptions* options);
void ffInitBiosOptions(FFBiosOptions* options);
bool ffParseBiosCommandOptions(FFBiosOptions* options, const char* key, const char* value);
void ffDestroyBiosOptions(FFBiosOptions* options);
#ifdef FF_HAVE_JSONC
#include "common/jsonconfig.h"
void ffParseBiosJsonObject(FFinstance* instance, json_object* module);
#endif

Some files were not shown because too many files have changed in this diff Show More