Fix parsing quoted values in config files

#217

.github/ISSUE_TEMPLATE/bug_report.md

@@ -7,6 +7,13 @@ assignees: ''
 
 ---
 
+# General description of bug:
+
+
+# Often helpful questions:
+* Does the issue occur across multiple terminal emulators? [Y/N]
+* Does the issue occur across multiple shells? (bash, zsh, fish, etc) [Y/N]
+
 Output of `fastfetch --version`:
 ```
 //paste here
@@ -18,6 +25,9 @@ Output of `fastfetch --load-config devinfo`:
 ```
 
 Output of `fastfetch --load-config devinfo-verbose`:
+<!--
+Note that this output will contain you public IP. If it is not relevant for the issue, feel free to remove it before uploading.
+-->
 ```
 //paste here
 ```
@@ -27,9 +37,7 @@ Output of `fastfetch --list-features`:
 //paste here
 ```
 
+<!--
 If you get the following error: `Error: couldn't find config: [...]`, copy the files in [presets](../../presets/) to `/usr/share/fastfetch/presets/` or `~/.local/share/fastfetch/presets/`.
-If this isn't possible (or to much work) for you, post the output of `fastfetch --show-errors --recache --multithreading false --disable-linewrap false`.
-
-Often helpful questions:
-* Does the issue occur across multiple terminal emulators?
-* Does the issue occur across multiple shells? (bash, zsh, fish, etc)
+If this isn't possible (or too much work) for you, post the output of `fastfetch --show-errors --recache --multithreading false --disable-linewrap false`. 
+-->

.github/ISSUE_TEMPLATE/logo_request.md

@@ -0,0 +1,18 @@
+---
+name: Logo request
+about: Request a new logo
+title: ''
+labels: logo request
+assignees: ''
+
+---
+
+# OS
+```
+paste content of /etc/os-release here. If this file doesn't exist, describe a way to identify the distro.
+```
+
+# Ascii
+```
+paste ascii art here. If you leave this empty, i will try to find the logo myself.
+```

.github/workflows/pull_request.yml

@@ -0,0 +1,37 @@
+name: manage pull requests
+
+on: pull_request
+
+jobs:
+  check:
+    name: manage pull request
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v2
+
+      - 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
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v1
+
+      - name: configure project
+        run: cmake -DBUILD_TESTS=On .
+
+      - name: build project
+        run: cmake --build . -j$(nproc) --target package
+
+      - name: run fastfetch
+        run: ./fastfetch --recache --disable-linewrap false --hide-cursor false --show-errors true
+
+      - name: run flashfetch
+        run: ./flashfetch
+
+      - name: run tests
+        run: ctest
+
+      - name: perform CodeQL analysis
+        uses: github/codeql-action/analyze@v1

.github/workflows/push.yml

@@ -1,101 +1,60 @@
-name: Manage pushes and pull requests
+name: manage pushes
 
 on:
   push:
     branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-env:
-  BUILD_TYPE: Release
 
 jobs:
-  check:
-    name: Build, Run and Analyze fastfetch
+  manage:
+    name: manage push
     runs-on: ubuntu-latest
     permissions:
-      actions: read
       contents: write
       security-events: write
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'cpp' ]
     steps:
-    - name: Checkout repository
-      uses: actions/checkout@v2
+      - name: checkout repository
+        uses: actions/checkout@v2
 
-    - name: Update and install 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 libxfconf-0-dev librpm-dev libzstd-dev
+      - 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
 
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
-      with:
-        languages: ${{ matrix.language }}
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v1
 
-    - name: Configure
-      run: cmake -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} .
+      - name: configure project
+        # We reuse the build binary only for the releases.
+        # We set tweak version to off, because it is wrong, as git tag will happen after this step. Releases don't have a tweak, so this is ok.
+        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr .
 
-    - name: Build
-      run: cmake --build . -j$(nproc)
+      - name: build project
+        run: cmake --build . -j$(nproc) --target package
 
-    - name: Run fastfetch
-      run: ./fastfetch --recache --disable-linewrap false --hide-cursor false --show-errors true
+      - name: run fastfetch
+        run: ./fastfetch --recache --disable-linewrap false --hide-cursor false --show-errors true
 
-    - name: Run flashfetch
-      run: ./flashfetch
+      - name: run flashfetch
+        run: ./flashfetch
 
-    - name: Run tests
-      run: ctest
+      - name: run tests
+        run: ctest
 
-    - name: Build deb package
-      run: sh packaging/deb/create.sh .
+      - name: perform CodeQL analysis
+        uses: github/codeql-action/analyze@v1
 
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
-
-    - name: Create tarball
-      if: github.event_name == 'push'
-      run: tar -cvf fastfetch.tar ./fastfetch -C packaging/deb ./fastfetch.deb
-
-    - name: Upload tarball
-      if: github.event_name == 'push'
-      uses: actions/upload-artifact@v3
-      with:
-        name: fastfetch.tar
-        path: ./fastfetch.tar
-
-  deploy:
-    name: Create GitHub release
-    runs-on: ubuntu-latest
-    needs: check
-    if: github.event_name == 'push'
-    permissions:
-      contents: write
-    steps:
-      - name: Download tarball
-        uses: actions/download-artifact@v3
-        with:
-          name: fastfetch.tar
-          path: ./fastfetch.tar
-
-      - name: Extract tarball
-        run: tar --overwrite -xvf ./fastfetch.tar/fastfetch.tar
-
-      - name: Get fastfetch version
+      - name: get fastfetch version
         id: get_version_fastfetch
         run: echo "::set-output name=release::$(./fastfetch --version-raw)"
 
-      - name: Get latest release version
+      - name: get latest release version
         id: get_version_release
         uses: pozetroninc/github-action-get-latest-release@master
         with:
           repository: ${{ github.repository }}
 
-      - name: Push release
+      - name: create release
         if: steps.get_version_fastfetch.outputs.release != steps.get_version_release.outputs.release
         uses: ncipollo/release-action@v1
         with:
           tag: ${{ steps.get_version_fastfetch.outputs.release }}
           commit: ${{ github.sha }}
-          artifacts: ./fastfetch,./fastfetch.deb
+          artifacts: ./fastfetch-*.*

.gitignore

@@ -5,5 +5,3 @@
 cscope.*
 tags
 fastfetch.kdev4
-**/*.deb
-packaging/deb/fastfetch

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "packaging/aur"]
-	path = packaging/aur
-	url = https://aur.archlinux.org/fastfetch-git.git

CHANGELOG.md

@@ -0,0 +1,61 @@
+# 1.6.5
+
+Fixes parsing quoted values in config files
+
+# 1.6.4
+
+Releasing this, so fedora can package fastfetch. Thanks to @jonathanspw for doing that!
+
+Features:
+* --set-keyless option (#215)
+* Replace `\n`, `\t`, `\e` and `\\` in user provided strings, just like c would do it (#215)
+* APK (Alpine Package Keeper) support (@mxkrsv, #216)
+
+Logos:
+* Alma Linux (@jonathanspw, #214)
+
+Bugfixes:
+* replace deprecated gethostbyname call with getaddrinfo (#217)
+
+# 1.6.3
+
+Fixes installing presets in their own directory (@ceamac, #212)
+
+# 1.6.2
+
+Releasing this, so void linux can package fastfetch.
+
+Logos:
+* Rosa linux (#206)
+* KISS linux (@draumaz, #207)
+* LangitKetujuh (@hervyqa, #208)
+
+Bugfixes:
+* Using musl as libc does work now (#210)
+* XBPS packages are once again printed (#209)
+* configured target dirs are applied to install directories too
+* empty XDG_* env vars don't cause a crash anymore
+
+# 1.6.1
+
+Fixes build on android (#205)
+
+# 1.6.0
+
+Features:
+* Detect QT on more DEs than just KDE Plasma. The [Plasma] category was therefore renamed to [QT]
+* Alacritty font detection
+* Load `/etc/fastfetch/config.conf` before user config
+* Disk: print one decimal point if size < 100GB
+* `--title-fqdn` option, to print fully qualified domain name instead of host name in title
+ 
+Logos:
+* updated old NixOS logo
+
+Bugfixes:
+* Correctly detect GTK on DEs that store their settings in dconf
+* Correctly detect NixOS packages
+* Mutter WM detected once again
+* Show full NixOS version in OS output
+* Don't segfault if an invalid structure is given
+* WSL doesn't output GPU anymore, as the name is always meaningless

CMakeLists.txt

@@ -1,15 +1,13 @@
-cmake_minimum_required(VERSION 3.1.0) # Threads::Threads
+cmake_minimum_required(VERSION 3.12.0) # target_link_libraries with OBJECT libs
 
 project(fastfetch
-    VERSION 1.2.0
+    VERSION 1.6.5
     LANGUAGES C
 )
 
-#e.g. +1
-#This allows to track builds between versions, without GitHub creating a new release
-set(PROJECT_VERSION_EXTRA "")
-
-include(GNUInstallDirs)
+#####################
+# Configure options #
+#####################
 
 OPTION(ENABLE_LIBPCI "Enable libpci" ON)
 OPTION(ENABLE_VULKAN "Enable vulkan" ON)
@@ -22,15 +20,91 @@ OPTION(ENABLE_GIO "Enable gio-2.0" ON)
 OPTION(ENABLE_DCONF "Enable dconf" ON)
 OPTION(ENABLE_DBUS "Enable dbus-1" ON)
 OPTION(ENABLE_XFCONF "Enable libxfconf-0" ON)
+OPTION(ENABLE_SQLITE3 "Enable sqlite3" ON)
 OPTION(ENABLE_RPM "Enable rpm" ON)
-OPTION(BUILD_TESTS "Build tests" ON)
+OPTION(ENABLE_IMAGEMAGICK7 "Enable imagemagick 7" ON)
+OPTION(ENABLE_IMAGEMAGICK6 "Enable imagemagick 6" ON)
+OPTION(ENABLE_ZLIB "Enable zlib" ON)
+OPTION(ENABLE_CHAFA "Enable chafa" ON)
+OPTION(ENABLE_EGL "Enable egl" ON)
+OPTION(ENABLE_GLX "Enable glx" ON)
+OPTION(ENABLE_OSMESA "Enable osmesa" ON)
+OPTION(ENABLE_OPENCL "Enable opencl" ON)
+
+OPTION(BUILD_TESTS "Build tests" OFF) # Also create test executables
+OPTION(SET_TWEAK "Add tweak to project version" ON) # This is set to off by github actions for release builds
+
+#############################
+# Compile time dependencies #
+#############################
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+
+find_package(PkgConfig REQUIRED)
+
+####################
+# Compiler options #
+####################
 
 if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Release)
 endif()
 
+set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wconversion")
-set(CMAKE_EXE_LINKER_FLAGS_RELEASE "-Wl,-O3")
+
+include(CheckIPOSupported)
+check_ipo_supported(RESULT IPO_SUPPORTED)
+if(IPO_SUPPORTED)
+    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+endif()
+
+#######################
+# Target FS structure #
+#######################
+
+if(NOT TARGET_DIR_ROOT)
+    if(NOT ANDROID)
+        set(TARGET_DIR_ROOT "")
+    else()
+        set(TARGET_DIR_ROOT "/data/data/com.termux/files/usr")
+    endif()
+endif()
+
+if(NOT TARGET_DIR_USR)
+    if(NOT ANDROID)
+        set(TARGET_DIR_USR "${TARGET_DIR_ROOT}/usr")
+    else()
+        set(TARGET_DIR_USR "${TARGET_DIR_ROOT}")
+    endif()
+endif()
+
+if(NOT TARGET_DIR_HOME)
+    if(NOT ANDROID)
+        set(TARGET_DIR_HOME "${TARGET_DIR_ROOT}/home")
+    else()
+        set(TARGET_DIR_HOME "/data/data/com.termux/files/home")
+    endif()
+endif()
+
+#################
+# Tweak version #
+#################
+
+if (SET_TWEAK AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
+    execute_process(
+        COMMAND git describe --tags
+        WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+        OUTPUT_VARIABLE PROJECT_VERSION_TWEAK
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    string(REGEX MATCH "-[0-9]+" PROJECT_VERSION_TWEAK "${PROJECT_VERSION_TWEAK}")
+endif()
+
+#############
+# Text data #
+#############
 
 function(fastfetch_load_text FILENAME OUTVAR)
     file(READ "${FILENAME}" TEMP)
@@ -41,42 +115,54 @@ function(fastfetch_load_text FILENAME OUTVAR)
 endfunction(fastfetch_load_text)
 
 fastfetch_load_text(src/data/structure.txt DATATEXT_STRUCTURE)
-fastfetch_load_text(src/data/config.txt DATATEXT_CONFIG)
+fastfetch_load_text(src/data/config_system.txt DATATEXT_CONFIG_SYSTEM)
+fastfetch_load_text(src/data/config_user.txt DATATEXT_CONFIG_USER)
 fastfetch_load_text(src/data/modules.txt DATATEXT_MODULES)
 fastfetch_load_text(src/data/help.txt DATATEXT_HELP)
 fastfetch_load_text(src/data/help_color.txt DATATEXT_HELP_COLOR)
 fastfetch_load_text(src/data/help_format.txt DATATEXT_HELP_FORMAT)
 fastfetch_load_text(src/data/help_config.txt DATATEXT_HELP_CONFIG)
 
+######################
+# Configure config.h #
+######################
+
 configure_file(src/fastfetch_config.h.in fastfetch_config.h)
 
-set(THREADS_PREFER_PTHREAD_FLAG ON)
-find_package(Threads REQUIRED)
+#######################
+# libfastfetch target #
+#######################
 
-find_package(PkgConfig REQUIRED)
-
-# Init CMake targets.
-
-add_library(libfastfetch STATIC
+add_library(libfastfetch OBJECT
     src/util/FFstrbuf.c
     src/util/FFlist.c
     src/util/FFvaluestore.c
     src/common/init.c
-    src/common/threading.c
     src/common/io.c
+    src/common/printing.c
+    src/common/caching.c
+    src/common/properties.c
+    src/common/font.c
     src/common/processing.c
-    src/common/logo.c
     src/common/format.c
     src/common/parsing.c
     src/common/settings.c
     src/common/library.c
     src/common/networking.c
+    src/logo/logo.c
+    src/logo/builtin.c
+    src/logo/image/image.c
+    src/logo/image/im7.c
+    src/logo/image/im6.c
     src/detection/os.c
-    src/detection/plasma.c
+    src/detection/qt.c
     src/detection/gtk.c
     src/detection/terminalShell.c
+    src/detection/vulkan.c
     src/detection/media.c
     src/detection/datetime.c
+    src/detection/temps.c
+    src/detection/title.c
     src/detection/displayserver/displayServer.c
     src/detection/displayserver/wayland.c
     src/detection/displayserver/xcb.c
@@ -110,6 +196,7 @@ add_library(libfastfetch STATIC
     src/modules/disk.c
     src/modules/battery.c
     src/modules/locale.c
+    src/modules/vulkan.c
     src/modules/localip.c
     src/modules/publicip.c
     src/modules/player.c
@@ -118,115 +205,222 @@ add_library(libfastfetch STATIC
     src/modules/date.c
     src/modules/time.c
     src/modules/colors.c
+    src/modules/opengl.c
+    src/modules/opencl.c
 )
 
 if(ENABLE_LIBPCI)
-    pkg_check_modules (LIBPCI libpci)
+    pkg_check_modules(LIBPCI libpci)
     if(LIBPCI_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_LIBPCI=1)
-    else(LIBPCI_FOUND)
+    else()
         message(WARNING "Package libpci not found. Building without support.")
-    endif(LIBPCI_FOUND)
-endif(ENABLE_LIBPCI)
+    endif()
+endif()
 
 if(ENABLE_VULKAN)
-    pkg_check_modules (VULKAN vulkan)
+    pkg_check_modules(VULKAN vulkan)
     if(VULKAN_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_VULKAN=1)
-    else(VULKAN_FOUND)
+    else()
         message(WARNING "Package vulkan not found. Building without support.")
-    endif(VULKAN_FOUND)
-endif(ENABLE_VULKAN)
+    endif()
+endif()
 
 if(ENABLE_WAYLAND)
     pkg_check_modules (WAYLAND wayland-client)
     if(WAYLAND_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_WAYLAND=1)
-    else(WAYLAND_FOUND)
+    else()
         message(WARNING "Package wayland-client not found. Building without support.")
-    endif(WAYLAND_FOUND)
-endif(ENABLE_WAYLAND)
+    endif()
+endif()
 
 if(ENABLE_XCB_RANDR)
-    pkg_check_modules (XCB_RANDR xcb-randr)
+    pkg_check_modules(XCB_RANDR xcb-randr)
     if(XCB_RANDR_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_XCB_RANDR=1)
-    else(XCB_RANDR_FOUND)
+    else()
         message(WARNING "Package xcb-randr not found. Building without support.")
-    endif(XCB_RANDR_FOUND)
-endif(ENABLE_XCB_RANDR)
+    endif()
+endif()
 
 if(ENABLE_XCB)
     pkg_check_modules (XCB xcb)
     if(XCB_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_XCB=1)
-    else(XCB_FOUND)
+    else()
         message(WARNING "Package xcb not found. Building without support.")
-    endif(XCB_FOUND)
-endif(ENABLE_XCB)
+    endif()
+endif()
 
 if(ENABLE_XRANDR)
-    pkg_check_modules (XRANDR xrandr)
+    pkg_check_modules(XRANDR xrandr)
     if(XRANDR_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_XRANDR=1)
-    else(XRANDR_FOUND)
+    else()
         message(WARNING "Package xrandr not found. Building without support.")
-    endif(XRANDR_FOUND)
-endif(ENABLE_XRANDR)
+    endif()
+endif()
 
 if(ENABLE_X11)
-    pkg_check_modules (X11 x11)
+    pkg_check_modules(X11 x11)
     if(X11_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_X11=1)
-    else(X11_FOUND)
+    else()
         message(WARNING "Package x11 not found. Building without support.")
-    endif(X11_FOUND)
-endif(ENABLE_X11)
+    endif()
+endif()
 
 if(ENABLE_GIO)
-    pkg_check_modules (GIO gio-2.0)
+    pkg_check_modules(GIO gio-2.0)
     if(GIO_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_GIO=1)
-    else(GIO_FOUND)
+    else()
         message(WARNING "Package gio-2.0 not found. Building without support.")
-    endif(GIO_FOUND)
-endif(ENABLE_GIO)
+    endif()
+endif()
 
 if(ENABLE_DCONF)
-    pkg_check_modules (DCONF dconf)
+    pkg_check_modules(DCONF dconf)
     if(DCONF_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_DCONF=1)
-    else(DCONF_FOUND)
+    else()
         message(WARNING "Package dconf not found. Building without support.")
-    endif(DCONF_FOUND)
-endif(ENABLE_DCONF)
+    endif()
+endif()
 
 if(ENABLE_DBUS)
-    pkg_check_modules (DBUS dbus-1)
+    pkg_check_modules(DBUS dbus-1)
     if(DBUS_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_DBUS=1)
-    else(DBUS_FOUND)
+    else()
         message(WARNING "Package dbus-1 not found. Building without support.")
-    endif(DBUS_FOUND)
-endif(ENABLE_DBUS)
+    endif()
+endif()
 
 if(ENABLE_XFCONF)
-    pkg_check_modules (XFCONF libxfconf-0)
+    pkg_check_modules(XFCONF libxfconf-0)
     if(XFCONF_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_XFCONF=1)
-    else(XFCONF_FOUND)
+    else()
         message(WARNING "Package libxfconf-0 not found. Building without support.")
-    endif(XFCONF_FOUND)
-endif(ENABLE_XFCONF)
+    endif()
+endif()
+
+if(ENABLE_SQLITE3)
+    pkg_check_modules(SQLITE3 sqlite3)
+    if(SQLITE3_FOUND)
+        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_SQLITE3=1)
+    else()
+        message(WARNING "Package sqlite3 not found. Building without support.")
+    endif()
+endif()
 
 if(ENABLE_RPM)
-    pkg_check_modules (RPM rpm)
+    pkg_check_modules(RPM rpm)
     if(RPM_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_RPM=1)
-    else(RPM_FOUND)
-        message(WARNING "Package librpm not found. Building without support.")
-    endif(RPM_FOUND)
-endif(ENABLE_RPM)
+    else()
+        message(WARNING "Package rpm not found. Building without support.")
+    endif()
+endif()
+
+if(ENABLE_IMAGEMAGICK7)
+    pkg_check_modules(IMAGEMAGICK7 MagickCore-7.Q16HDRI)
+    if(NOT IMAGEMAGICK7_FOUND)
+        pkg_check_modules(IMAGEMAGICK7 /usr/lib/imagemagick7/pkgconfig/MagickCore-7.Q16HDRI.pc)
+    endif()
+    if(NOT IMAGEMAGICK7_FOUND)
+        pkg_check_modules(IMAGEMAGICK7 MagickCore-7.Q16)
+    endif()
+    if(NOT IMAGEMAGICK7_FOUND)
+        pkg_check_modules(IMAGEMAGICK7 /usr/lib/imagemagick7/pkgconfig/MagickCore-7.Q16.pc)
+    endif()
+
+    if(IMAGEMAGICK7_FOUND)
+        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_IMAGEMAGICK7=1)
+    else()
+        message(WARNING "Package MagickCore-7.Q16HDRI or MagickCore-7.Q16 not found. Building without support.")
+    endif()
+endif()
+
+if(ENABLE_IMAGEMAGICK6)
+    pkg_check_modules(IMAGEMAGICK6 MagickCore-6.Q16HDRI)
+    if(NOT IMAGEMAGICK6_FOUND)
+        pkg_check_modules(IMAGEMAGICK6 /usr/lib/imagemagick6/pkgconfig/MagickCore-6.Q16HDRI.pc)
+    endif()
+    if(NOT IMAGEMAGICK6_FOUND)
+        pkg_check_modules(IMAGEMAGICK6 MagickCore-6.Q16)
+    endif()
+    if(NOT IMAGEMAGICK6_FOUND)
+        pkg_check_modules(IMAGEMAGICK6 /usr/lib/imagemagick6/pkgconfig/MagickCore-6.Q16.pc)
+    endif()
+
+    if(IMAGEMAGICK6_FOUND)
+        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_IMAGEMAGICK6=1)
+    else()
+        message(WARNING "Package MagickCore-6.Q16HDRI or MagickCore-6.Q16 not found. Building without support.")
+    endif()
+endif()
+
+if(ENABLE_ZLIB)
+    pkg_check_modules(ZLIB zlib)
+    if(ZLIB_FOUND)
+        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_ZLIB=1)
+    else()
+        message(WARNING "Package zlib not found. Building without support")
+    endif()
+endif()
+
+if(ENABLE_CHAFA)
+    if(IMAGEMAGICK6_FOUND OR IMAGEMAGICK7_FOUND)
+        pkg_check_modules(CHAFA chafa>=1.10)
+        if(CHAFA_FOUND)
+            target_compile_definitions(libfastfetch PRIVATE FF_HAVE_CHAFA=1)
+        else()
+            message(WARNING "Package chafa>=1.10 not found. Building without support.")
+        endif()
+    else()
+        message(WARNING "Chafa not enabled, because neither ImageMagick6 nor ImageMagick7 were found. Building without support.")
+    endif()
+endif()
+
+if(ENABLE_EGL)
+    pkg_check_modules(EGL egl)
+    if(EGL_FOUND)
+        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_EGL=1)
+    else()
+        message(WARNING "Package egl not found. Building without support.")
+    endif()
+endif()
+
+if(ENABLE_GLX)
+    pkg_check_modules(GLX glx)
+    if(GLX_FOUND)
+        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_GLX=1)
+    else()
+        message(WARNING "Package glx not found. Building without support.")
+    endif()
+endif()
+
+if(ENABLE_OSMESA)
+    pkg_check_modules(OSMESA osmesa)
+    if(OSMESA_FOUND)
+        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_OSMESA=1)
+    else()
+        message(WARNING "Package osmesa not found. Building without support.")
+    endif()
+endif()
+
+if(ENABLE_OPENCL)
+    pkg_check_modules(OPENCL OpenCL)
+    if(OPENCL_FOUND)
+        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_OPENCL=1)
+    else()
+        message(WARNING "Package opencl not found. Building without support.")
+    endif()
+endif()
 
 target_include_directories(libfastfetch
     PUBLIC ${PROJECT_BINARY_DIR}
@@ -243,7 +437,17 @@ target_include_directories(libfastfetch
     PRIVATE ${DCONF_INCLUDE_DIRS}
     PRIVATE ${DBUS_INCLUDE_DIRS}
     PRIVATE ${XFCONF_INCLUDE_DIRS}
+    PRIVATE ${SQLITE3_INCLUDE_DIRS}
     PRIVATE ${RPM_INCLUDE_DIRS}
+    PRIVATE ${IMAGEMAGICK7_INCLUDE_DIRS}
+    PRIVATE ${IMAGEMAGICK6_INCLUDE_DIRS}
+    PRIVATE ${ZLIB_INCLUDE_DIRS}
+    PRIVATE ${CHAFA_INCLUDE_DIRS}
+    PRIVATE ${VULKAN_INCLUDE_DIRS}
+    PRIVATE ${EGL_INCLUDE_DIRS}
+    PRIVATE ${GLX_INCLUDE_DIRS}
+    PRIVATE ${OSMESA_INCLUDE_DIRS}
+    PRIVATE ${OPENCL_INCLUDE_DIRS}
 )
 
 target_link_libraries(libfastfetch
@@ -251,7 +455,9 @@ target_link_libraries(libfastfetch
     PRIVATE Threads::Threads
 )
 
-set_target_properties(libfastfetch PROPERTIES OUTPUT_NAME "fastfetch")
+######################
+# Executable targets #
+######################
 
 add_executable(fastfetch
     src/fastfetch.c
@@ -267,16 +473,11 @@ target_link_libraries(flashfetch
     PRIVATE libfastfetch
 )
 
-# Testing.
+###################
+# Testing targets #
+###################
 
 if (BUILD_TESTS)
-    add_executable(fastfetch-test-performance
-        tests/performance.c
-    )
-    target_link_libraries(fastfetch-test-performance
-        PRIVATE libfastfetch
-    )
-
     add_executable(fastfetch-test-strbuf
         tests/strbuf.c
     )
@@ -288,25 +489,67 @@ if (BUILD_TESTS)
     add_test(NAME test-strbuf COMMAND fastfetch-test-strbuf)
 endif()
 
-# Installation.
+##################
+# install target #
+##################
+
+#https://cmake.org/cmake/help/latest/variable/CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT.html
+if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+    set(CMAKE_INSTALL_PREFIX "${TARGET_DIR_USR}" CACHE PATH "..." FORCE)
+endif()
+
+if(NOT CMAKE_INSTALL_SYSCONFDIR)
+    set(CMAKE_INSTALL_SYSCONFDIR "${TARGET_DIR_ROOT}/etc")
+endif()
+
+include(GNUInstallDirs)
 
 install(
-    TARGETS fastfetch
-    DESTINATION ${CMAKE_INSTALL_BINDIR}
+    TARGETS fastfetch flashfetch
+    DESTINATION "${CMAKE_INSTALL_BINDIR}"
 )
 
 install(
-    FILES completions/bash
-    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/bash-completion/completions
-    RENAME ${CMAKE_PROJECT_NAME}
+    FILES "${CMAKE_SOURCE_DIR}/src/data/config_system.txt"
+    DESTINATION "${CMAKE_INSTALL_SYSCONFDIR}/${CMAKE_PROJECT_NAME}"
+    RENAME "config.conf"
 )
 
 install(
-    DIRECTORY presets
-    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${CMAKE_PROJECT_NAME}
+    FILES "${CMAKE_SOURCE_DIR}/completions/bash"
+    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/bash-completion/completions"
+    RENAME "${CMAKE_PROJECT_NAME}"
 )
 
 install(
-    FILES ./LICENSE
-    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/licenses/${CMAKE_PROJECT_NAME}
+    DIRECTORY "${CMAKE_SOURCE_DIR}/presets"
+    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/${CMAKE_PROJECT_NAME}"
 )
+
+install(
+    FILES "${CMAKE_SOURCE_DIR}/LICENSE"
+    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/licenses/${CMAKE_PROJECT_NAME}"
+)
+
+##################
+# package target #
+##################
+
+set(CPACK_GENERATOR "DEB;RPM;TGZ;ZIP")
+set(CPACK_SET_DESTDIR ON)
+
+set(CPACK_PACKAGE_CONTACT "Linus Dierheimer <Linus@Dierheimer.de>")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Neofetch clone written in C")
+set(CPACK_PACKAGE_DESCRIPTION "\
+fastfetch is a neofetch-like tool for fetching system information and displaying them in a pretty way. \
+It is written in c to achieve much better performance.\
+")
+set(CPACK_PACKAGE_HOMEPAGE_URL "https://github.com/LinusDierheimer")
+
+set(CPACK_DEBIAN_PACKAGE_SECTION, "utils")
+set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
+set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6")
+
+set(CPACK_RPM_PACKAGE_LICENSE "MIT")
+
+include(CPack)

DEVELOPMENT.md

@@ -11,12 +11,7 @@ Here i just add things that are easy to forget.
   - `libffdetect`: contains all the detection stuff. To be used by anything that needs system information
   - `libffprint`: contains the printing functions, logos, format etc
   - `fastfetch` and `flashfetch`: Executables, that initialize the config of libffprint. Fist one at runtime, second one at compile time
-- [ ] Support for printing images as ascii art logos (using imlib2 and libcaca probably)
-- [ ] Support for printing images in terminals that support it
 - [ ] Better OS output for all possible combinations of /etc/os-release variables.
-- [ ] Expose temperatures to CPU format string
-- [ ] Expose temperatures to GPU format string
-- [ ] Fallback GPU detection using GL (multi GPU suport somehow possible?)
 - [ ] Find wayland compositor by looking at \${XDG_RUNTIME_DIR}/${WAYLAND_DISPLAY:-wayland-0}
 - [ ] Make LocalIP module more configurable
 - [ ] Automatic migrate old config files to newer versions
@@ -25,7 +20,6 @@ Here i just add things that are easy to forget.
 - [ ] Make CPU usage detection much faster and more accurate
 - [ ] Detect CPU usage in a common detection methode and expose it both to the cpuUsage module and the cpu format string
 - [ ] Per session caching
-- [ ] RPM packaging
 
 ### General
 - More presets

README.md

@@ -9,7 +9,7 @@ The output on my personal machine with default configurations looks like this:
 
 With customization and speed being two competing goals, this project actually builds two executables.  
 The main one being `fastfetch`, which can be very greatly configured via flags. These flags can be made persistent in `~/.config/fastfetch/config.conf`. To view the available options run `fastfetch --help`.  
-The second executable being buildt is called `flashfetch`, which is configured at compile time to eliminate any possible overhead. Configuration of it can be very easily done in [`src/flashfetch.c`](src/flashfetch.c).  
+The second executable being built is called `flashfetch`, which is configured at compile time to eliminate any possible overhead. Configuration of it can be very easily done in [`src/flashfetch.c`](src/flashfetch.c).  
 At the moment the performance difference is measurable, but too small to be human recognizable. But the leap will get bigger with more and more options coming, and on slow machines this might actually make a difference.  
   
 There are some presets defined for fastfech in [`presets`](presets), you can can load them with `--load-config`. They may also serve as a good example for format arguments.
@@ -19,39 +19,48 @@ There are some presets defined for fastfech in [`presets`](presets), you can can
 Fastfetch dynamically loads needed libraries if they are available. Therefore its only hard dependencies are `libc` (any implementation of the c standard library), `libdl` and `libpthread`. They are all shipped with [`glibc`](https://www.gnu.org/software/libc/), which is already installed on most linux distributions, so you probably don't have to worry about it.  
 
 The following libraries are used if present at runtime:
-*  [`libpci`](https://github.com/pciutils/pciutils): GPU output.
-*  [`libvulkan`](https://www.vulkan.org/): Fallback for GPU output.
-*  [`libxcb-randr`](https://xcb.freedesktop.org/),
-   [`libXrandr`](https://gitlab.freedesktop.org/xorg/lib/libxrandr),
-   [`libxcb`](https://xcb.freedesktop.org/),
-   [`libX11`](https://gitlab.freedesktop.org/xorg/lib/libx11): At least one of them sould be present in X11 sessions for better resolution detection and faster WM detection. The `*randr` ones provide multi monitor support. The `libxcb*` ones usually have better performance.
-*  [`libwayland-client`](https://wayland.freedesktop.org/): Better resolution performance and output in wayland sessions. Supports different refresh rates per monitor.
-*  [`libGIO`](https://developer.gnome.org/gio/unstable/): Needed for values that are only stored GSettings.
-*  [`libDConf`](https://developer.gnome.org/dconf/unstable/): Needed for values that are only stored in DConf + Fallback for GSettings.
-*  [`libDBus`](https://www.freedesktop.org/wiki/Software/dbus): Needed for detecting current media player and song.
-*  [`libXFConf`](https://gitlab.xfce.org/xfce/xfconf): Needed for XFWM theme and XFCE Terminal font.
-*  [`librpm`](http://rpm.org/): Needed for rpm package count.
+* [`libpci`](https://github.com/pciutils/pciutils): GPU output.
+* [`libvulkan`](https://www.vulkan.org/): Vulkan module & fallback for GPU output.
+* [`libxcb-randr`](https://xcb.freedesktop.org/),
+    [`libXrandr`](https://gitlab.freedesktop.org/xorg/lib/libxrandr),
+    [`libxcb`](https://xcb.freedesktop.org/),
+    [`libX11`](https://gitlab.freedesktop.org/xorg/lib/libx11): At least one of them sould be present in X11 sessions for better resolution detection and faster WM detection. The `*randr` ones provide multi monitor support The `libxcb*` ones usually have better performance.
+* [`libwayland-client`](https://wayland.freedesktop.org/): Better resolution performance and output in wayland sessions. Supports different refresh rates per monitor.
+* [`libGIO`](https://developer.gnome.org/gio/unstable/): Needed for values that are only stored GSettings.
+* [`libDConf`](https://developer.gnome.org/dconf/unstable/): Needed for values that are only stored in DConf + Fallback for GSettings.
+* [`libmagickcore` (ImageMagick)](https://www.imagemagick.org/): Images in terminal using sixel or kitty graphics protocol.
+* [`libchafa`](https://github.com/hpjansson/chafa): Image output as ascii art.
+* [`libZ`](https://www.zlib.net/): Faster image output when using kitty graphics protocol.
+* [`libDBus`](https://www.freedesktop.org/wiki/Software/dbus): Needed for detecting current media player and song.
+* [`libEGL`](https://www.khronos.org/registry/EGL/),
+    [`libGLX`](https://dri.freedesktop.org/wiki/GLX/),
+    [`libOSMesa`](https://docs.mesa3d.org/osmesa.html): At least one of them is needed by the OpenGL module for gl context creation.
+* [`libOpenCL`](https://www.khronos.org/opencl/): OpenCL module
+* [`libXFConf`](https://gitlab.xfce.org/xfce/xfconf): Needed for XFWM theme and XFCE Terminal font.
+* [`libsqlite3`](https://www.sqlite.org/index.html): Needed for rpm package count.
+* [`librpm`](http://rpm.org/): Slower fallback for rpm package count. Needed on openSUSE.
 
 ## Support status
 All categories not listed here should work without needing a specific implementation.
 
 ##### Available Modules
 ```
-Title, Separator, OS, Host, Kernel, Uptime, Processes, Packages, Shell, Resolution, DE, WM, WMTheme, Theme, Icons, Font, Cursor, Terminal, Terminal Font, CPU, CPUUsage, GPU, Memory, Disk, Battery, Player, Song, LocalIP, PublicIP, DateTime, Date, Time, Locale, Colors, Break, Custom
+Title, Separator, OS, Host, Kernel, Uptime, Processes, Packages, Shell, Resolution, DE, WM, WMTheme, Theme, Icons, Font, Cursor, Terminal, Terminal Font, CPU, CPUUsage, GPU, Memory, Disk, Battery, Player, Song, Vulkan, OpenGL, OpenCL, LocalIP, PublicIP, DateTime, Date, Time, Locale, Colors, Break, Custom
 ```
 
 ##### Logos
 ```
-Android, Arch, Arco, Artix, CachyOS, CentOS, Debian, Endeavour, Fedora, Garuda, Gentoo, KDE Neon, Linux, Manjaro, Mint, Pop!_OS, RebornOS, Ubuntu, Void, Zorin
+AlmaLinux, Alpine, Android, Arch, Arco, Artix, Bedrock, CachyOS, CentOS, Debian, Devuan, Deepin, Endeavour, Fedora, Garuda, Gentoo, KDE Neon, KISS, Kubuntu, LangitKetujuh, Linux, Manjaro, Mint, NixOS, OpenSUSE, OpenSUSE Tumbleweed, OpenSUSE LEAP, Pop!_OS, RebornOS, RedstarOS, Rocky, Rosa, Ubuntu, Void, Zorin
 ```
 * Most of the logos have a small variant. Access it by appending _small to the logo name.
 * Some logos have an old variant. Access it by appending _old to the logo name.
 * Unknown/unsupported logos will be replaced with a generic linux logo when running fastfetch.
 * Get a list of all available logos with `fastfetch --print-logos`.
+* Printing images as logo is supported using Sixel or Kitty graphics protocol.
 
 ##### Package managers
 ```
-Pacman, dpkg, rpm, emerge, xbps, Flatpak, Snap
+Pacman, dpkg, rpm, emerge, xbps, nix, Flatpak, Snap, apk
 ```
 
 ##### WM themes
@@ -66,7 +75,7 @@ KDE Plasma, Gnome, Cinnamon, Mate, XFCE4, LXQt
 
 ##### Terminal fonts
 ```
-konsole, gnome-terminal-server, tilix, xfce4-terminal, lxterminal, TTY
+konsole, gnome-terminal-server, tilix, xfce4-terminal, alacritty, lxterminal, TTY
 ```
 
 ## Building
@@ -76,20 +85,21 @@ fastfetch uses [`cmake`](https://cmake.org/) and [`pkg-config`](https://www.free
 mkdir -p build
 cd build
 cmake ..
-cmake --build . -j$(nproc) --target fastfetch --target flashfetch
+cmake --build . --target fastfetch --target flashfetch
 ```
 
 If pkg-config fails to find the headers for a library listed in [dependencies](#dependencies), fastfetch will simply build without support for that specific feature. This means, it won't look for it at runtime and just act like it isn't available.
 
 ## Packaging
 
-* [AUR](https://aur.archlinux.org/packages/fastfetch-git/): Packaged by me. Will install the fastfetch binary, bash completion and the presets. Git version
-* [Manjaro Repositories](https://gitlab.manjaro.org/packages/community/fastfetch): Packaged by a manjaro maintainer. Usually a bit outdated.
-* [Gentoo (Guru)](https://github.com/gentoo/guru/tree/master/app-misc/fastfetch): Packed by some other guy. May be out of date some times.
-* DEB: Run [`packaging/deb/create.sh`](packaging/deb/create.sh) from the root directory. You can give a custom build directory as an argument.
-* Manually:
-    * Build: Follow the [build instructions](#building).
-    * Install: `sudo cmake --install build --prefix /usr/local`
+### Repositories
+
+[![Packaging status](https://repology.org/badge/vertical-allrepos/fastfetch.svg?header=)](https://repology.org/project/fastfetch/versions)
+
+### Manual
+
+* DEB / RPM package: `cmake --build . --target package`
+* Install directly: `cmake --install . --prefix /usr/local`
 
 ## FAQ
 

completions/bash

@@ -108,7 +108,8 @@ __fastfetch_completion()
         "--list-presets"
         "--list-features"
         "--print-logos"
-        "--print-config"
+        "--print-config-system"
+        "--print-config-user"
         "--print-structure"
     )
 
@@ -122,8 +123,7 @@ __fastfetch_completion()
         "--recache"
         "--nocache"
         "--show-errors"
-        "--color-logo"
-        "--print-remaining-logo"
+        "--logo-print-remaining"
         "--multithreading"
         "--allow-slow-operations"
         "--disable-linewrap"
@@ -131,18 +131,33 @@ __fastfetch_completion()
         "--localip-show-ipv4"
         "--localip-show-ipv6"
         "--localip-show-loop"
+        "--escape-bedrock"
+        "--pipe"
+        "--title-fqdn"
     )
 
     local FF_OPTIONS_STRING=(
+        "--logo-type"
+        "--logo-padding"
+        "--logo-padding-left"
+        "--logo-padding-right"
+        "--logo-color-1"
+        "--logo-color-2"
+        "--logo-color-3"
+        "--logo-color-4"
+        "--logo-color-5"
+        "--logo-color-6"
+        "--logo-color-7"
+        "--logo-color-8"
+        "--logo-color-9"
         "-c"
         "--color"
-        "--spacing"
-        "-s"
         "--separator"
-        "-x"
-        "--offsetx"
+        "-s"
         "--structure"
         "--set"
+        "--set-keyless"
+        "--gl"
         "--os-format"
         "--os-key"
         "--host-format"
@@ -207,6 +222,47 @@ __fastfetch_completion()
         "--date-key"
         "--time-format"
         "--time-key"
+        "--vulkan-key"
+        "--vulkan-format"
+        "--opengl-key"
+        "--opengl-format"
+        "--opencl-key"
+        "--opencl-format"
+        "--os-error"
+        "--host-error"
+        "--kernel-error"
+        "--uptime-error"
+        "--processes-error"
+        "--packages-error"
+        "--shell-error"
+        "--resolution-error"
+        "--de-error"
+        "--wm-error"
+        "--wm-theme-error"
+        "--theme-error"
+        "--icons-error"
+        "--font-error"
+        "--cursor-error"
+        "--terminal-error"
+        "--terminal-font-error"
+        "--cpu-error"
+        "--cpu-usage-error"
+        "--gpu-error"
+        "--memory-error"
+        "--disk-error"
+        "--battery-error"
+        "--locale-error"
+        "--disk-error"
+        "--local-ip-error"
+        "--public-ip-error"
+        "--player-error"
+        "--song-error"
+        "--datetime-error"
+        "--date-error"
+        "--time-error"
+        "--vulkan-error"
+        "--opengl-error"
+        "--opencl-error"
     )
 
     local FF_OPTIONS_PATH=(
@@ -222,7 +278,15 @@ __fastfetch_completion()
         "--lib-DConf"
         "--lib-DBus"
         "--lib-XFConf"
-        "--lib-RPM"
+        "--lib-sqlite3"
+        "--lib-rpm"
+        "--lib-imagemagick"
+        "--lib-z"
+        "--lib-chafa"
+        "--lib-egl"
+        "--lib-glx"
+        "--lib-osmesa"
+        "--lib-opencl"
         "--battery-dir"
         "--load-config"
     )

packaging/deb/control-template

@@ -1,13 +0,0 @@
-Package: fastfetch
-Version: <VERSION>
-Section: utils
-Priority: extra
-Architecture: amd64
-Maintainer: Linus@Dierheimer.de
-Homepage: https://github.com/LinusDierheimer/fastfetch
-Installed-Size: 410K
-Description: A fast alternative to neofetch
- fastfetch is a neofetch-like tool for fetching system information and
- displaying them in a pretty way. It is written in c to achieve much better
- performance, in return only Linux and Android are supported. It also uses
- mechanisms like multithreading and caching to finish as fast as possible.

packaging/deb/create.sh

@@ -1,28 +0,0 @@
-#!/bin/sh
-
-# This script is intended to be run from the root of the repository.
-# If you don't want to use build/ as build directoy, or already build the elsewere, you can give the build directoy as argument.
-
-BUILD_DIR="${1:-build}"
-ROOT_DIR="${2:-.}"
-PACKAGE_DIR="${BUILD_DIR}/packaging/deb/fastfetch"
-
-# Create missing files
-mkdir -p "${BUILD_DIR}" || exit 1
-
-if [ ! -f "${BUILD_DIR}/cmake_install.cmake" ]; then
-    cmake -S "${ROOT_DIR}" -B "${BUILD_DIR}" || exit 2
-    rm -f "${BUILD_DIR}/fastfetch" || exit 3 # Always rebuild the project if we reconfigured it
-fi
-
-if [ ! -f "${BUILD_DIR}/fastfetch" ]; then
-    cmake --build "${BUILD_DIR}" || exit 4
-fi
-
-# Populate the files
-cmake --install "${BUILD_DIR}" --prefix "${PACKAGE_DIR}/usr" || exit 5
-mkdir -p "${PACKAGE_DIR}/DEBIAN" || exit 6
-sed "s/<VERSION>/$("${BUILD_DIR}/fastfetch" --version-raw)/g" "${ROOT_DIR}/packaging/deb/control-template" > "${PACKAGE_DIR}/DEBIAN/control" || exit 7
-
-# Create the package
-dpkg-deb --build "${PACKAGE_DIR}" || exit 8

presets/all

@@ -1 +1 @@
---structure Title:Separator:OS:Host:Kernel:Uptime:Processes:Packages:Shell:Resolution:DE:WM:WMTheme:Theme:Icons:Font:Cursor:Terminal:TerminalFont:CPU:GPU:Memory:Disk:Battery:Player:Song:PublicIP:LocalIP:DateTime:Locale:Break:Colors
+--structure Title:Separator:OS:Host:Kernel:Uptime:Processes:Packages:Shell:Resolution:DE:WM:WMTheme:Theme:Icons:Font:Cursor:Terminal:TerminalFont:CPU:GPU:Memory:Disk:Battery:Player:Song:PublicIP:LocalIP:DateTime:Locale:Vulkan:OpenGL:OpenCL:Break:Colors

presets/verbose

@@ -1,7 +1,7 @@
 --load-config all
 
 --os-format "System: {}; Name: {}; Pretty name: {}; ID: {}; ID like: {}; Variant: {}; Variant ID: {}; Version: {}; Version ID: {}; Version codename: {}; Build ID: {}; Architecture: {}"
---host-format "Family: {}; Name: {}; Version: {}"
+--host-format "Family: "product_family: {}; product_name: {}; product_version: {}; product_sku: {}; bios_date: {}; bios_release: {}; bios_vendor: {}; bios_version: {}; board_name: {}; board_vendor: {}; board_version: {}; chassis_type: {}; chassis_vendor: {}; chassis_version: {}; sys_vendor: {}"
 --kernel-format "Sysname: {}; Release: {}; Version: {}"
 --uptime-format "Days: {}; Hours: {}; Minutes: {}; Seconds: {}"
 --processes-format "Count: {}"
@@ -17,12 +17,15 @@
 --cursor-format "Theme: {}; Size: {}"
 --terminal-format "Process: {}; Path: {}; Exe: {}"
 --terminal-font-format "Raw: {}; Name: {}; Size: {}; Styles: {}; Pretty: {}"
---cpu-format "Name: {}; Pretty: {}; Vendor: {}; Logical online: {}; Logical configured: {}; Physical: {}; Cores: {}; bios: {}; scaling max: {}; scaling min: {}; info max: {}; info min: {}; cpuinfo: {}; frequency: {}"
+--cpu-format "Name: {}; Pretty: {}; Vendor: {}; Logical online: {}; Logical configured: {}; Physical: {}; Cores: {}; temperature: {}; bios: {}; scaling max: {}; scaling min: {}; info max: {}; info min: {}; cpuinfo: {}; frequency: {}"
 --cpu-usage-format "Percentage: {}"
---gpu-format "Vendor: {}; Vendor pretty: {}; Name: {}; Name pretty: {}; Driver: {}"
+--gpu-format "Vendor: {}; Vendor pretty: {}; Name: {}; Name pretty: {}; Driver: {}; Temperature: {}"
 --memory-format "Used: {}; Total: {}; Percentage: {}"
 --disk-format "Used: {}; Total: {}; Files: {}; Percentage: {}"
 --battery-format "Manufactor: {}; Model: {}; Technology: {}; Capacaty: {}; Status: {}"
 --player-format "Name: {}"
 --song-format "Song: {}; Artist: {}; Album: {}"
 --datetime-format "year: {}; yearShort: {}; month: {}; monthPretty: {}; monthName: {}; monthNameShort: {}; weekNumber: {}; weekday: {}; weekdayShort: {}; dayInYear: {}; dayInMonth: {}; dayInWeek: {}; hour: {}; hourPretty: {}; hour12: {}; hour12Pretty: {}; minute: {}; minutePretty: {}; second: {}; secondPretty: {}"
+--vulkan-format "driver: {}; Api Version: {}; Conformance Version: {}"
+--opengl-format "version: {}; renderer: {}; vendor: {}"
+--opencl-format "version: {}; device: {}; vendor: {}"

run.sh

@@ -1,4 +1,9 @@
 #!/bin/env sh
+
+# make the script exit if any of the commands fail,
+# making fastfetch not run if the build failed.
+set -e
+
 mkdir -p build/
 cd build/
 cmake ..

src/common/caching.c

@@ -0,0 +1,229 @@
+#include "fastfetch.h"
+#include "common/caching.h"
+#include "common/io.h"
+#include "common/printing.h"
+
+#include <stdlib.h>
+
+#define FF_CACHE_VALUE_EXTENSION "ffcv"
+#define FF_CACHE_SPLIT_EXTENSION "ffcs"
+
+#define FF_CACHE_EXTENSION_DATA "ffcd"
+
+static void getCacheFilePath(const FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* buffer)
+{
+    ffStrbufAppend(buffer, &instance->state.cacheDir);
+    ffStrbufAppendS(buffer, moduleName);
+
+    if(extension != NULL)
+    {
+        ffStrbufAppendC(buffer, '.');
+        ffStrbufAppendS(buffer, extension);
+    }
+}
+
+static void readCacheFile(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* buffer)
+{
+    FFstrbuf path;
+    ffStrbufInitA(&path, 64);
+    getCacheFilePath(instance, moduleName, extension, &path);
+    ffAppendFileBuffer(path.chars, buffer);
+    ffStrbufDestroy(&path);
+}
+
+static void writeCacheFile(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* content)
+{
+    FFstrbuf path;
+    ffStrbufInitA(&path, 64);
+    getCacheFilePath(instance, moduleName, extension, &path);
+    ffWriteFileBuffer(path.chars, content);
+    ffStrbufDestroy(&path);
+}
+
+void ffCacheValidate(FFinstance* instance)
+{
+    FFstrbuf content;
+    ffStrbufInit(&content);
+    readCacheFile(instance, "cacheversion", "ffv", &content);
+
+    bool isSameVersion = ffStrbufCompS(&content, FASTFETCH_PROJECT_VERSION) == 0;
+    ffStrbufDestroy(&content);
+    if(isSameVersion)
+        return;
+
+    instance->config.recache = true;
+
+    FFstrbuf version;
+    ffStrbufInitA(&version, sizeof(FASTFETCH_PROJECT_VERSION));
+    ffStrbufAppendS(&version, FASTFETCH_PROJECT_VERSION);
+    writeCacheFile(instance, "cacheversion", "ffv", &version);
+    ffStrbufDestroy(&version);
+}
+
+void ffCacheOpenWrite(FFinstance* instance, const char* moduleName, FFcache* cache)
+{
+    FFstrbuf cacheFileValue;
+    ffStrbufInitA(&cacheFileValue, 64);
+    getCacheFilePath(instance, moduleName, FF_CACHE_VALUE_EXTENSION, &cacheFileValue);
+    cache->value = fopen(cacheFileValue.chars, "w");
+    ffStrbufDestroy(&cacheFileValue);
+
+    FFstrbuf cacheFileSplit;
+    ffStrbufInitA(&cacheFileSplit, 64);
+    getCacheFilePath(instance, moduleName, FF_CACHE_SPLIT_EXTENSION, &cacheFileSplit);
+    cache->split = fopen(cacheFileSplit.chars, "w");
+    ffStrbufDestroy(&cacheFileSplit);
+}
+
+void ffCacheClose(FFcache* cache)
+{
+    if(cache->value != NULL)
+        fclose(cache->value);
+
+    if(cache->split != NULL)
+        fclose(cache->split);
+}
+
+static bool printCachedValue(FFinstance* instance, const char* moduleName, const FFModuleArgs* moduleArgs)
+{
+    FFstrbuf content;
+    ffStrbufInitA(&content, 512);
+    readCacheFile(instance, moduleName, FF_CACHE_VALUE_EXTENSION, &content);
+
+    ffStrbufTrimRight(&content, '\0'); //Strbuf always appends a '\0' at the end. We want the last null byte to be at the position of the length
+
+    if(content.length == 0)
+        return false;
+
+    uint8_t moduleCounter = 1;
+
+    uint32_t startIndex = 0;
+    while(startIndex < content.length)
+    {
+        uint32_t nullByteIndex = ffStrbufNextIndexC(&content, startIndex, '\0');
+        uint8_t moduleIndex = (moduleCounter == 1 && nullByteIndex == content.length) ? 0 : moduleCounter;
+        ffPrintLogoAndKey(instance, moduleName, moduleIndex, &moduleArgs->key);
+        puts(content.chars + startIndex);
+        startIndex = nullByteIndex + 1;
+        ++moduleCounter;
+    }
+
+    ffStrbufDestroy(&content);
+
+    return moduleCounter > 1;
+}
+
+static bool printCachedFormat(FFinstance* instance, const char* moduleName, const FFModuleArgs* moduleArgs, uint32_t numArgs)
+{
+    FFstrbuf content;
+    ffStrbufInitA(&content, 512);
+    readCacheFile(instance, moduleName, FF_CACHE_SPLIT_EXTENSION, &content);
+
+    ffStrbufTrimRight(&content, '\0'); //Strbuf always appends a '\0' at the end. We want the last null byte to be at the position of the length
+
+    if(content.length == 0)
+        return false;
+
+    uint8_t moduleCounter = 1;
+
+    FFformatarg* arguments = calloc(numArgs, sizeof(FFformatarg));
+    uint32_t argumentCounter = 0;
+
+    uint32_t startIndex = 0;
+    while(startIndex < content.length)
+    {
+        arguments[argumentCounter].type = FF_FORMAT_ARG_TYPE_STRING;
+        arguments[argumentCounter].value = &content.chars[startIndex];
+        ++argumentCounter;
+
+        uint32_t nullByteIndex = ffStrbufNextIndexC(&content, startIndex, '\0');
+
+        if(argumentCounter == numArgs)
+        {
+            uint8_t moduleIndex = (moduleCounter == 1 && nullByteIndex == content.length) ? 0 : moduleCounter;
+            ffPrintFormat(instance, moduleName, moduleIndex, moduleArgs, numArgs, arguments);
+            ++moduleCounter;
+            argumentCounter = 0;
+        }
+
+        startIndex = nullByteIndex + 1;
+    }
+
+    free(arguments);
+    ffStrbufDestroy(&content);
+
+    return moduleCounter > 1;
+}
+
+bool ffPrintFromCache(FFinstance* instance, const char* moduleName, const FFModuleArgs* moduleArgs, uint32_t numArgs)
+{
+    if(instance->config.recache)
+        return false;
+
+    if(moduleArgs->outputFormat.length == 0)
+        return printCachedValue(instance, moduleName, moduleArgs);
+    else
+        return printCachedFormat(instance, moduleName, moduleArgs, numArgs);
+}
+
+void ffPrintAndAppendToCache(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFcache* cache, const FFstrbuf* value, uint32_t numArgs, const FFformatarg* arguments)
+{
+    if(moduleArgs->outputFormat.length == 0)
+    {
+        ffPrintLogoAndKey(instance, moduleName, moduleIndex, &moduleArgs->key);
+        ffStrbufPutTo(value, stdout);
+    }
+    else
+    {
+        ffPrintFormat(instance, moduleName, moduleIndex, moduleArgs, numArgs, arguments);
+    }
+
+    if(cache->value != NULL)
+    {
+        ffStrbufWriteTo(value, cache->value);
+        fputc('\0', cache->value);
+    }
+
+    if(cache->split == NULL)
+        return;
+
+    for(uint32_t i = 0; i < numArgs; i++)
+    {
+        FFstrbuf buffer;
+        ffStrbufInitA(&buffer, 64);
+        ffFormatAppendFormatArg(&buffer, &arguments[i]);
+        ffStrbufWriteTo(&buffer, cache->split);
+        ffStrbufDestroy(&buffer);
+        fputc('\0', cache->split);
+    }
+}
+
+void ffPrintAndWriteToCache(FFinstance* instance, const char* moduleName, const FFModuleArgs* moduleArgs, const FFstrbuf* value, uint32_t numArgs, const FFformatarg* arguments)
+{
+    FFcache cache;
+    ffCacheOpenWrite(instance, moduleName, &cache);
+    ffPrintAndAppendToCache(instance, moduleName, 0, moduleArgs, &cache, value, numArgs, arguments);
+    ffCacheClose(&cache);
+}
+
+void ffCachingWriteData(const FFinstance* instance, const char* moduleName, size_t dataSize, const void* data)
+{
+    FFstrbuf path;
+    ffStrbufInitA(&path, 128);
+    getCacheFilePath(instance, moduleName, FF_CACHE_EXTENSION_DATA, &path);
+    ffWriteFileData(path.chars, dataSize, data);
+    ffStrbufDestroy(&path);
+}
+
+bool ffCachingReadData(const FFinstance* instance, const char* moduleName, size_t dataSize, void* data)
+{
+    if(instance->config.recache)
+        return false;
+
+    FFstrbuf path;
+    ffStrbufInitA(&path, 128);
+    getCacheFilePath(instance, moduleName, FF_CACHE_EXTENSION_DATA, &path);
+    ssize_t result = ffReadFileData(path.chars, dataSize, data);
+    ffStrbufDestroy(&path);
+    return result > 0 && (size_t) result == dataSize;
+}

src/common/caching.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_caching
+#define FF_INCLUDED_common_caching
+
+#include "fastfetch.h"
+#include "common/format.h"
+
+typedef struct FFcache
+{
+    FILE* value;
+    FILE* split;
+} FFcache;
+
+void ffCacheValidate(FFinstance* instance);
+
+void ffCacheOpenWrite(FFinstance* instance, const char* moduleName, FFcache* cache);
+void ffCacheClose(FFcache* cache);
+
+bool ffPrintFromCache(FFinstance* instance, const char* moduleName, const FFModuleArgs* moduleArgs, uint32_t numArgs);
+void ffPrintAndAppendToCache(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFcache* cache, const FFstrbuf* value, uint32_t numArgs, const FFformatarg* arguments);
+void ffPrintAndWriteToCache(FFinstance* instance, const char* moduleName, const FFModuleArgs* moduleArgs, const FFstrbuf* value, uint32_t numArgs, const FFformatarg* arguments);
+
+void ffCachingWriteData(const FFinstance* instance, const char* moduleName, size_t dataSize, const void* data);
+bool ffCachingReadData(const FFinstance* instance, const char* moduleName, size_t dataSize, void* data);
+
+#endif

src/common/font.c

@@ -0,0 +1,216 @@
+#include "fastfetch.h"
+#include "common/font.h"
+
+#include <string.h>
+
+static void fontInit(FFfont* font)
+{
+    ffStrbufInit(&font->pretty);
+    ffStrbufInit(&font->name);
+    ffStrbufInitA(&font->size, 4);
+    ffListInitA(&font->styles, sizeof(FFstrbuf), 4);
+}
+
+static void fontInitPretty(FFfont* font)
+{
+    ffStrbufAppend(&font->pretty, &font->name);
+
+    if(font->size.length == 0 && font->styles.length == 0)
+        return;
+    else if(font->pretty.length == 0)
+        ffStrbufAppendS(&font->pretty, "default");
+
+    ffStrbufAppendS(&font->pretty, " (");
+
+    if(font->size.length > 0)
+    {
+        ffStrbufAppend(&font->pretty, &font->size);
+        ffStrbufAppendS(&font->pretty, "pt");
+
+        if(font->styles.length > 0)
+            ffStrbufAppendS(&font->pretty, ", ");
+    }
+
+    for(uint32_t i = 0; i < font->styles.length; i++)
+    {
+        ffStrbufAppend(&font->pretty, ffListGet(&font->styles, i));
+
+        if(i < font->styles.length - 1)
+            ffStrbufAppendS(&font->pretty, ", ");
+    }
+
+    ffStrbufAppendC(&font->pretty, ')');
+}
+
+void ffFontInitQt(FFfont* font, const char* data)
+{
+    fontInit(font);
+
+    //See https://doc.qt.io/qt-5/qfont.html#toString
+
+    //Family
+    while(*data != ',' && *data != '\0')
+    {
+        ffStrbufAppendC(&font->name, *data);
+        ++data;
+    }
+    if(*data != '\0')
+        ++data;
+    ffStrbufTrim(&font->name, ' ');
+
+    //Size
+    while(*data != ',' && *data != '\0')
+    {
+        ffStrbufAppendC(&font->size, *data);
+        ++data;
+    }
+    if(*data != '\0')
+        ++data;
+    ffStrbufTrim(&font->size, ' ');
+
+    #define FF_FONT_QT_SKIP_VALUE \
+        while(*data != ',' && *data != '\0') \
+            ++data; \
+        if(*data != '\0') \
+             ++data;
+
+    FF_FONT_QT_SKIP_VALUE //Pixel size
+    FF_FONT_QT_SKIP_VALUE //Style hint
+    FF_FONT_QT_SKIP_VALUE //Font weight
+    FF_FONT_QT_SKIP_VALUE //Font style
+    FF_FONT_QT_SKIP_VALUE //Underline
+    FF_FONT_QT_SKIP_VALUE //Strike out
+    FF_FONT_QT_SKIP_VALUE //Fixed pitch
+    FF_FONT_QT_SKIP_VALUE //Always 0
+
+    #undef FF_FONT_QT_SKIP_VALUE
+
+    while(*data != '\0')
+    {
+        while(*data == ' ')
+            ++data;
+
+        if(*data == '\0')
+            break;
+
+        FFstrbuf* style = ffListAdd(&font->styles);
+        ffStrbufInit(style);
+        while(*data != ' ' && *data != '\0')
+        {
+            ffStrbufAppendC(style, *data);
+            ++data;
+        }
+    }
+
+    fontInitPretty(font);
+}
+
+static void fontPangoParseWord(const char** data, FFfont* font, FFstrbuf* alternativeBuffer)
+{
+    while(**data == ' ' || **data == '\t' || **data == ',')
+        ++(*data);
+
+    const char* wordStart = *data;
+
+    while(**data != ' ' && **data != '\t' && **data != ',' && **data != '\0' && **data != '`' && **data != '\\')
+        ++(*data);
+
+    uint32_t wordLength = (uint32_t) (*data - wordStart);
+    if(wordLength == 0)
+        return;
+
+    if(**data == '\0' || **data == '`' || **data == '\\')
+    {
+        ffStrbufAppendNS(&font->size, wordLength, wordStart);
+        if(ffStrbufEndsWithS(&font->size, "px"))
+            ffStrbufSubstrBefore(&font->size, font->size.length - 2);
+
+        double dummy;
+        if(sscanf(font->size.chars, "%lf", &dummy) == 1)
+            return;
+
+        ffStrbufClear(&font->size);
+    }
+
+    if(
+        strncasecmp(wordStart, "Ultra", 5) == 0 ||
+        strncasecmp(wordStart, "Extra", 5) == 0 ||
+        strncasecmp(wordStart, "Semi", 4) == 0 ||
+        strncasecmp(wordStart, "Demi", 4) == 0 ||
+        strncasecmp(wordStart, "Normal", wordLength) == 0 ||
+        strncasecmp(wordStart, "Roman", wordLength) == 0 ||
+        strncasecmp(wordStart, "Oblique", wordLength) == 0 ||
+        strncasecmp(wordStart, "Italic", wordLength) == 0 ||
+        strncasecmp(wordStart, "Thin", wordLength) == 0 ||
+        strncasecmp(wordStart, "Light", wordLength) == 0 ||
+        strncasecmp(wordStart, "Bold", wordLength) == 0 ||
+        strncasecmp(wordStart, "Black", wordLength) == 0 ||
+        strncasecmp(wordStart, "Condensed", wordLength) == 0 ||
+        strncasecmp(wordStart, "Expanded", wordLength) == 0
+    ) {
+        if(alternativeBuffer == NULL)
+        {
+            alternativeBuffer = ffListAdd(&font->styles);
+            ffStrbufInit(alternativeBuffer);
+        }
+
+        ffStrbufAppendNSExludingC(alternativeBuffer, wordLength, wordStart, '-');
+
+        if(
+            strncasecmp(wordStart, "Ultra ", 6) == 0 ||
+            strncasecmp(wordStart, "Extra ", 6) == 0 ||
+            strncasecmp(wordStart, "Semi ", 5) == 0 ||
+            strncasecmp(wordStart, "Demi ", 5) == 0
+        ) {
+            fontPangoParseWord(data, font, alternativeBuffer);
+        }
+
+        return;
+    }
+
+    if(alternativeBuffer != NULL)
+    {
+        ffStrbufAppendNSExludingC(alternativeBuffer, wordLength, wordStart, '-');
+        return;
+    }
+
+    if(font->name.length > 0)
+        ffStrbufAppendC(&font->name, ' ');
+    ffStrbufAppendNS(&font->name, wordLength, wordStart);
+}
+
+void ffFontInitPango(FFfont* font, const char* data)
+{
+    fontInit(font);
+
+    while(*data != '\0' && *data != '`' && *data != '\\')
+        fontPangoParseWord(&data, font, NULL);
+
+    fontInitPretty(font);
+}
+
+void ffFontInitValues(FFfont* font, const char* name, const char* size)
+{
+    fontInit(font);
+
+    ffStrbufAppendS(&font->name, name);
+    ffStrbufAppendS(&font->size, size);
+
+    fontInitPretty(font);
+}
+
+void ffFontInitCopy(FFfont* font, const char* name)
+{
+    ffFontInitValues(font, name, NULL);
+}
+
+void ffFontDestroy(FFfont* font)
+{
+    ffStrbufDestroy(&font->pretty);
+    ffStrbufDestroy(&font->name);
+    ffStrbufDestroy(&font->size);
+
+    for(uint32_t i = 0; i < font->styles.length; i++)
+        ffStrbufDestroy(ffListGet(&font->styles, i));
+    ffListDestroy(&font->styles);
+}

src/common/font.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_font
+#define FF_INCLUDED_common_font
+
+#include "util/FFstrbuf.h"
+#include "util/FFlist.h"
+
+typedef struct FFfont
+{
+    FFstrbuf pretty;
+    FFstrbuf name;
+    FFstrbuf size;
+    FFlist styles;
+} FFfont;
+
+void ffFontInitQt(FFfont* font, const char* data);
+void ffFontInitPango(FFfont* font, const char* data);
+void ffFontInitCopy(FFfont* font, const char* name);
+void ffFontInitValues(FFfont* font, const char* name, const char* size);
+void ffFontDestroy(FFfont* font);
+
+#endif

src/common/format.c

@@ -1,4 +1,5 @@
 #include "fastfetch.h"
+#include "common/format.h"
 
 void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg)
 {
@@ -32,15 +33,6 @@ void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg)
     }
 }
 
-static inline bool placeholderValueIsForError(const FFstrbuf* placeholderValue)
-{
-    return
-        ffStrbufIgnCaseCompS(placeholderValue, "e") == 0 ||
-        ffStrbufIgnCaseCompS(placeholderValue, "error") == 0 ||
-        ffStrbufIgnCaseCompS(placeholderValue, "0") == 0
-    ;
-}
-
 static inline uint32_t getArgumentIndex(const FFstrbuf* placeholderValue)
 {
     uint32_t result = UINT32_MAX;
@@ -72,6 +64,7 @@ static inline bool formatArgSet(const FFformatarg* arg)
 {
     return arg->value != NULL && (
         (arg->type == FF_FORMAT_ARG_TYPE_DOUBLE && *(double*)arg->value > 0) ||
+        (arg->type == FF_FORMAT_ARG_TYPE_DOUBLE && *(double*)arg->value == *(double*)arg->value) || //NaN
         (arg->type == FF_FORMAT_ARG_TYPE_INT && *(int*)arg->value > 0) ||
         (arg->type == FF_FORMAT_ARG_TYPE_STRBUF && ((FFstrbuf*)arg->value)->length > 0) ||
         (arg->type == FF_FORMAT_ARG_TYPE_STRING && *(const char*)arg->value != '\0') ||
@@ -81,7 +74,7 @@ static inline bool formatArgSet(const FFformatarg* arg)
     );
 }
 
-void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFstrbuf* error, uint32_t numArgs, const FFformatarg* arguments)
+void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t numArgs, const FFformatarg* arguments)
 {
     uint32_t argCounter = 0;
 
@@ -128,13 +121,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFst
         while(i < formatstr->length && formatstr->chars[i] != '}')
             ffStrbufAppendC(&placeholderValue, formatstr->chars[i++]);
 
-        // test for error, if so print it
-        if(placeholderValueIsForError(&placeholderValue)) {
-            ffStrbufAppend(buffer, error);
-            ffStrbufDestroy(&placeholderValue);
-            continue;
-        }
-
          // test if for stop, if so break the loop
         if(placeholderValue.length == 1 && placeholderValue.chars[0] == '-')
         {
@@ -173,7 +159,7 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFst
                 appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
             else
             {
-                ffStrbufAppendS(buffer, "\033[0m");
+                ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
                 --numOpenColors;
             }
 
@@ -186,14 +172,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFst
         {
             ffStrbufSubstrAfter(&placeholderValue, 0);
 
-            // continue if an error is set
-            if(placeholderValueIsForError(&placeholderValue) && error != NULL && error->length > 0)
-            {
-                ++numOpenIfs;
-                ffStrbufDestroy(&placeholderValue);
-                continue;
-            }
-
             uint32_t index = getArgumentIndex(&placeholderValue);
 
             // testing for an invalid index
@@ -223,14 +201,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFst
         {
             ffStrbufSubstrAfter(&placeholderValue, 0);
 
-            //continue if an error os not set
-            if(placeholderValueIsForError(&placeholderValue) && (error == NULL || error->length == 0))
-            {
-                ++numOpenNotIfs;
-                ffStrbufDestroy(&placeholderValue);
-                continue;
-            }
-
             uint32_t index = getArgumentIndex(&placeholderValue);
 
             // testing for an invalid index
@@ -284,6 +254,5 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFst
 
     ffStrbufTrimRight(buffer, ' ');
 
-    if(numOpenColors > 0)
-        ffStrbufAppendS(buffer, "\033[0m");
+    ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
 }

src/common/format.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_format
+#define FF_INCLUDED_common_format
+
+typedef enum FFformatargtype
+{
+    FF_FORMAT_ARG_TYPE_NULL = 0,
+    FF_FORMAT_ARG_TYPE_UINT,
+    FF_FORMAT_ARG_TYPE_UINT16,
+    FF_FORMAT_ARG_TYPE_UINT8,
+    FF_FORMAT_ARG_TYPE_INT,
+    FF_FORMAT_ARG_TYPE_STRING,
+    FF_FORMAT_ARG_TYPE_STRBUF,
+    FF_FORMAT_ARG_TYPE_DOUBLE,
+    FF_FORMAT_ARG_TYPE_LIST
+} FFformatargtype;
+
+typedef struct FFformatarg
+{
+    FFformatargtype type;
+    const void* value;
+} FFformatarg;
+
+void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg);
+void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t numArgs, const FFformatarg* arguments);
+
+#endif

src/common/init.c

@@ -1,8 +1,15 @@
 #include "fastfetch.h"
+#include "common/caching.h"
+#include "common/parsing.h"
+#include "detection/qt.h"
+#include "detection/gtk.h"
+#include "detection/displayserver.h"
 
+#include <stdlib.h>
 #include <unistd.h>
 #include <sys/stat.h>
 #include <signal.h>
+#include <pthread.h>
 
 static bool strbufEqualsAdapter(const void* first, const void* second)
 {
@@ -14,18 +21,14 @@ static void initConfigDirs(FFstate* state)
     ffListInit(&state->configDirs, sizeof(FFstrbuf));
 
     const char* xdgConfigHome = getenv("XDG_CONFIG_HOME");
-    if(xdgConfigHome != NULL)
+    if(ffStrSet(xdgConfigHome))
     {
         FFstrbuf* buffer = (FFstrbuf*) ffListAdd(&state->configDirs);
         ffStrbufInitA(buffer, 64);
         ffStrbufAppendS(buffer, xdgConfigHome);
-        ffStrbufTrimRight(buffer, '/');
+        ffStrbufEnsureEndsWithC(buffer, '/');
     }
 
-    FFstrbuf xdgConfigDirs;
-    ffStrbufInitA(&xdgConfigDirs, 64);
-    ffStrbufAppendS(&xdgConfigDirs, getenv("XDG_CONFIG_DIRS"));
-
     #define FF_ENSURE_ONLY_ONCE_IN_LIST(element) \
         if(ffListFirstIndexComp(&state->configDirs, element, strbufEqualsAdapter) < state->configDirs.length - 1) \
             --state->configDirs.length;
@@ -33,24 +36,35 @@ static void initConfigDirs(FFstate* state)
     FFstrbuf* userConfigHome = ffListAdd(&state->configDirs);
     ffStrbufInitA(userConfigHome, 64);
     ffStrbufAppendS(userConfigHome, state->passwd->pw_dir);
-    ffStrbufAppendS(userConfigHome, "/.config");
+    ffStrbufAppendS(userConfigHome, "/.config/");
     FF_ENSURE_ONLY_ONCE_IN_LIST(userConfigHome)
 
     FFstrbuf* userHome = ffListAdd(&state->configDirs);
     ffStrbufInitA(userHome, 64);
     ffStrbufAppendS(userHome, state->passwd->pw_dir);
+    ffStrbufEnsureEndsWithC(userHome, '/');
     FF_ENSURE_ONLY_ONCE_IN_LIST(userHome)
 
+    FFstrbuf xdgConfigDirs;
+    ffStrbufInitA(&xdgConfigDirs, 64);
+    ffStrbufAppendS(&xdgConfigDirs, getenv("XDG_CONFIG_DIRS"));
+
     uint32_t startIndex = 0;
     while (startIndex < xdgConfigDirs.length)
     {
         uint32_t colonIndex = ffStrbufNextIndexC(&xdgConfigDirs, startIndex, ':');
         xdgConfigDirs.chars[colonIndex] = '\0';
 
+        if(!ffStrSet(xdgConfigDirs.chars + startIndex))
+        {
+            startIndex = colonIndex + 1;
+            continue;
+        }
+
         FFstrbuf* buffer = (FFstrbuf*) ffListAdd(&state->configDirs);
         ffStrbufInitA(buffer, 64);
         ffStrbufAppendS(buffer, xdgConfigDirs.chars + startIndex);
-        ffStrbufTrimRight(buffer, '/');
+        ffStrbufEnsureEndsWithC(buffer, '/');
         FF_ENSURE_ONLY_ONCE_IN_LIST(buffer);
 
         startIndex = colonIndex + 1;
@@ -58,12 +72,12 @@ static void initConfigDirs(FFstate* state)
 
     FFstrbuf* systemConfigHome = ffListAdd(&state->configDirs);
     ffStrbufInitA(systemConfigHome, 64);
-    ffStrbufAppendS(systemConfigHome, "/etc/xdg");
+    ffStrbufAppendS(systemConfigHome, FASTFETCH_TARGET_DIR_ROOT"/etc/xdg/");
     FF_ENSURE_ONLY_ONCE_IN_LIST(systemConfigHome)
 
     FFstrbuf* systemConfig = ffListAdd(&state->configDirs);
     ffStrbufInitA(systemConfig, 64);
-    ffStrbufAppendS(systemConfig, "/etc");
+    ffStrbufAppendS(systemConfig, FASTFETCH_TARGET_DIR_ROOT"/etc/");
     FF_ENSURE_ONLY_ONCE_IN_LIST(systemConfig)
 
     #undef FF_ENSURE_ONLY_ONCE_IN_LIST
@@ -80,8 +94,8 @@ static void initCacheDir(FFstate* state)
         ffStrbufAppendS(&state->cacheDir, state->passwd->pw_dir);
         ffStrbufAppendS(&state->cacheDir, "/.cache/");
     }
-    else if(!ffStrbufEndsWithC(&state->cacheDir, '/'))
-        ffStrbufAppendC(&state->cacheDir, '/');
+    else
+        ffStrbufEnsureEndsWithC(&state->cacheDir, '/');
 
     mkdir(state->cacheDir.chars, S_IRWXU | S_IXGRP | S_IRGRP | S_IXOTH | S_IROTH); //I hope everybody has a cache folder, but who knows
 
@@ -92,6 +106,8 @@ static void initCacheDir(FFstate* state)
 static void initState(FFstate* state)
 {
     state->logoWidth = 0;
+    state->logoHeight = 0;
+    state->keysHeight = 0;
     state->passwd = getpwuid(getuid());
     uname(&state->utsname);
     sysinfo(&state->sysinfo);
@@ -100,90 +116,74 @@ static void initState(FFstate* state)
     initCacheDir(state);
 }
 
+static void initModuleArg(FFModuleArgs* args)
+{
+    ffStrbufInitA(&args->key, 0);
+    ffStrbufInitA(&args->outputFormat, 0);
+    ffStrbufInitA(&args->errorFormat, 0);
+}
+
 static void defaultConfig(FFinstance* instance)
 {
-    ffStrbufInit(&instance->config.color);
+    ffStrbufInit(&instance->config.logo.source);
+    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.paddingLeft = 0;
+    instance->config.logo.paddingRight = 4;
+    instance->config.logo.printRemaining = true;
 
+    ffStrbufInit(&instance->config.mainColor);
     ffStrbufInit(&instance->config.separator);
     ffStrbufAppendS(&instance->config.separator, ": ");
 
-    instance->config.logoKeySpacing = 4;
-    instance->config.offsetx = 0;
-    instance->config.colorLogo = true;
     instance->config.showErrors = false;
     instance->config.recache = false;
     instance->config.cacheSave = true;
-    instance->config.printRemainingLogo = true;
     instance->config.allowSlowOperations = false;
     instance->config.disableLinewrap = true;
     instance->config.hideCursor = true;
-    instance->config.userLogoIsRaw = false;
+    instance->config.escapeBedrock = true;
+    instance->config.glType = FF_GL_TYPE_AUTO;
+    instance->config.pipe = false;
+    instance->config.multithreading = true;
 
-    for(uint8_t i = 0; i < (uint8_t) FASTFETCH_LOGO_MAX_COLORS; ++i)
-        ffStrbufInit(&instance->config.logoColors[i]);
-
-    ffStrbufInitA(&instance->config.osFormat, 0);
-    ffStrbufInitA(&instance->config.osKey, 0);
-    ffStrbufInitA(&instance->config.hostFormat, 0);
-    ffStrbufInitA(&instance->config.hostKey, 0);
-    ffStrbufInitA(&instance->config.kernelFormat, 0);
-    ffStrbufInitA(&instance->config.kernelKey, 0);
-    ffStrbufInitA(&instance->config.uptimeFormat, 0);
-    ffStrbufInitA(&instance->config.uptimeKey, 0);
-    ffStrbufInitA(&instance->config.processesFormat, 0);
-    ffStrbufInitA(&instance->config.processesKey, 0);
-    ffStrbufInitA(&instance->config.packagesFormat, 0);
-    ffStrbufInitA(&instance->config.packagesKey, 0);
-    ffStrbufInitA(&instance->config.shellFormat, 0);
-    ffStrbufInitA(&instance->config.shellKey, 0);
-    ffStrbufInitA(&instance->config.resolutionFormat, 0);
-    ffStrbufInitA(&instance->config.resolutionKey, 0);
-    ffStrbufInitA(&instance->config.deFormat, 0);
-    ffStrbufInitA(&instance->config.deKey, 0);
-    ffStrbufInitA(&instance->config.wmFormat, 0);
-    ffStrbufInitA(&instance->config.wmKey, 0);
-    ffStrbufInitA(&instance->config.wmThemeFormat, 0);
-    ffStrbufInitA(&instance->config.wmThemeKey, 0);
-    ffStrbufInitA(&instance->config.themeFormat, 0);
-    ffStrbufInitA(&instance->config.themeKey, 0);
-    ffStrbufInitA(&instance->config.iconsFormat, 0);
-    ffStrbufInitA(&instance->config.iconsKey, 0);
-    ffStrbufInitA(&instance->config.fontFormat, 0);
-    ffStrbufInitA(&instance->config.fontKey, 0);
-    ffStrbufInitA(&instance->config.cursorKey, 0);
-    ffStrbufInitA(&instance->config.cursorFormat, 0);
-    ffStrbufInitA(&instance->config.terminalFormat, 0);
-    ffStrbufInitA(&instance->config.terminalKey, 0);
-    ffStrbufInitA(&instance->config.termFontFormat, 0);
-    ffStrbufInitA(&instance->config.termFontKey, 0);
-    ffStrbufInitA(&instance->config.cpuFormat, 0);
-    ffStrbufInitA(&instance->config.cpuKey, 0);
-    ffStrbufInitA(&instance->config.cpuUsageFormat, 0);
-    ffStrbufInitA(&instance->config.cpuUsageKey, 0);
-    ffStrbufInitA(&instance->config.gpuFormat, 0);
-    ffStrbufInitA(&instance->config.gpuKey, 0);
-    ffStrbufInitA(&instance->config.memoryFormat, 0);
-    ffStrbufInitA(&instance->config.memoryKey, 0);
-    ffStrbufInitA(&instance->config.diskFormat, 0);
-    ffStrbufInitA(&instance->config.diskKey, 0);
-    ffStrbufInitA(&instance->config.batteryFormat, 0);
-    ffStrbufInitA(&instance->config.batteryKey, 0);
-    ffStrbufInitA(&instance->config.localeFormat, 0);
-    ffStrbufInitA(&instance->config.localeKey, 0);
-    ffStrbufInitA(&instance->config.localIpKey, 0);
-    ffStrbufInitA(&instance->config.localIpFormat, 0);
-    ffStrbufInitA(&instance->config.publicIpKey, 0);
-    ffStrbufInitA(&instance->config.publicIpFormat, 0);
-    ffStrbufInitA(&instance->config.playerKey, 0);
-    ffStrbufInitA(&instance->config.playerFormat, 0);
-    ffStrbufInitA(&instance->config.songKey, 0);
-    ffStrbufInitA(&instance->config.songFormat, 0);
-    ffStrbufInitA(&instance->config.dateTimeKey, 0);
-    ffStrbufInitA(&instance->config.dateTimeFormat, 0);
-    ffStrbufInitA(&instance->config.dateKey, 0);
-    ffStrbufInitA(&instance->config.dateFormat, 0);
-    ffStrbufInitA(&instance->config.timeKey, 0);
-    ffStrbufInitA(&instance->config.timeFormat, 0);
+    initModuleArg(&instance->config.os);
+    initModuleArg(&instance->config.host);
+    initModuleArg(&instance->config.kernel);
+    initModuleArg(&instance->config.uptime);
+    initModuleArg(&instance->config.processes);
+    initModuleArg(&instance->config.packages);
+    initModuleArg(&instance->config.shell);
+    initModuleArg(&instance->config.resolution);
+    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.disk);
+    initModuleArg(&instance->config.battery);
+    initModuleArg(&instance->config.locale);
+    initModuleArg(&instance->config.localIP);
+    initModuleArg(&instance->config.publicIP);
+    initModuleArg(&instance->config.player);
+    initModuleArg(&instance->config.song);
+    initModuleArg(&instance->config.dateTime);
+    initModuleArg(&instance->config.date);
+    initModuleArg(&instance->config.time);
+    initModuleArg(&instance->config.vulkan);
+    initModuleArg(&instance->config.openGL);
+    initModuleArg(&instance->config.openCL);
 
     ffStrbufInitA(&instance->config.libPCI, 0);
     ffStrbufInitA(&instance->config.libVulkan, 0);
@@ -196,7 +196,17 @@ static void defaultConfig(FFinstance* instance)
     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);
+
+    instance->config.titleFQDN = false;
 
     ffStrbufInitA(&instance->config.diskFolders, 0);
 
@@ -219,32 +229,103 @@ void ffInitInstance(FFinstance* instance)
 {
     initState(&instance->state);
     defaultConfig(instance);
-    ffCacheValidate(instance);
 }
 
-static void resetConsole(bool disableLinewrap, bool hideCursor)
+static inline void* detectPlasmaThreadMain(void* instance)
 {
-    if(disableLinewrap)
-        fputs("\033[?7h", stdout);
+    ffDetectQt((FFinstance*)instance);
+    return NULL;
+}
 
-    if(hideCursor)
-        fputs("\033[?25h", stdout);
+static inline void* detectGTK2ThreadMain(void* instance)
+{
+    ffDetectGTK2((FFinstance*)instance);
+    return NULL;
+}
+
+static inline void* detectGTK3ThreadMain(void* instance)
+{
+    ffDetectGTK3((FFinstance*)instance);
+    return NULL;
+}
+
+static inline void* detectGTK4ThreadMain(void* instance)
+{
+    ffDetectGTK4((FFinstance*)instance);
+    return NULL;
+}
+
+static inline void* connectDisplayServerThreadMain(void* instance)
+{
+    ffConnectDisplayServer((FFinstance*)instance);
+    return NULL;
+}
+
+static inline void* startThreadsThreadMain(void* instance)
+{
+    pthread_t dsThread;
+    pthread_create(&dsThread, NULL, connectDisplayServerThreadMain, instance);
+    pthread_detach(dsThread);
+
+    pthread_t gtk2Thread;
+    pthread_create(&gtk2Thread, NULL, detectGTK2ThreadMain, instance);
+    pthread_detach(gtk2Thread);
+
+    pthread_t gtk3Thread;
+    pthread_create(&gtk3Thread, NULL, detectGTK3ThreadMain, instance);
+    pthread_detach(gtk3Thread);
+
+    pthread_t gtk4Thread;
+    pthread_create(&gtk4Thread, NULL, detectGTK4ThreadMain, instance);
+    pthread_detach(gtk4Thread);
+
+    pthread_t plasmaThread;
+    pthread_create(&plasmaThread, NULL, detectPlasmaThreadMain, instance);
+    pthread_detach(plasmaThread);
+
+    return NULL;
+}
+
+void startDetectionThreads(FFinstance* instance)
+{
+    //Android needs none of the things that are detected here
+    //And using gsettings sometimes hangs the program in android for some unknown reason,
+    //and since we don't need it we just never call it.
+    #ifdef __ANDROID__
+        return;
+    #endif
+
+    pthread_t startThreadsThread;
+    pthread_create(&startThreadsThread, NULL, startThreadsThreadMain, instance);
+    pthread_detach(startThreadsThread);
 }
 
 static volatile bool ffDisableLinewrap = true;
 static volatile bool ffHideCursor = true;
 
+static void resetConsole()
+{
+    if(ffDisableLinewrap)
+        fputs("\033[?7h", stdout);
+
+    if(ffHideCursor)
+        fputs("\033[?25h", stdout);
+}
+
 static void exitSignalHandler(int signal)
 {
     FF_UNUSED(signal);
-    resetConsole(ffDisableLinewrap, ffHideCursor);
+    resetConsole();
     exit(0);
 }
 
 void ffStart(FFinstance* instance)
 {
-    ffDisableLinewrap = instance->config.disableLinewrap;
-    ffHideCursor = instance->config.hideCursor;
+    if(instance->config.multithreading)
+        startDetectionThreads(instance);
+
+    ffDisableLinewrap = instance->config.disableLinewrap && !instance->config.pipe;
+    ffHideCursor = instance->config.hideCursor && !instance->config.pipe;
 
     struct sigaction action = {};
     action.sa_handler = exitSignalHandler;
@@ -253,21 +334,32 @@ void ffStart(FFinstance* instance)
     sigaction(SIGTERM, &action, NULL);
     sigaction(SIGQUIT, &action, NULL);
 
-    if(instance->config.hideCursor)
+    //We do the cache validation here, so we can skip it if --recache is given
+    if(!instance->config.recache)
+        ffCacheValidate(instance);
+
+    //reset everything to default before we start printing
+    if(!instance->config.pipe)
+        fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
+
+    if(ffHideCursor)
         fputs("\033[?25l", stdout);
 
-    if(instance->config.disableLinewrap)
+    if(ffDisableLinewrap)
         fputs("\033[?7l", stdout);
+
+    ffLogoPrint(instance);
 }
 
 void ffFinish(FFinstance* instance)
 {
-    if(instance->config.printRemainingLogo)
-        ffPrintRemainingLogo(instance);
+    if(instance->config.logo.printRemaining)
+        ffLogoPrintRemaining(instance);
 
-    resetConsole(instance->config.disableLinewrap, instance->config.hideCursor);
+    resetConsole();
 }
 
+//Must be in a file compiled with the libfastfetch target, because the FF_HAVE* macros are not defined for the executable targets
 void ffListFeatures()
 {
     fputs(
@@ -301,11 +393,38 @@ void ffListFeatures()
         #ifdef FF_HAVE_DBUS
             "dbus\n"
         #endif
+        #ifdef FF_HAVE_IMAGEMAGICK7
+            "imagemagick7\n"
+        #endif
+        #ifdef FF_HAVE_IMAGEMAGICK6
+            "imagemagick6\n"
+        #endif
+        #ifdef FF_HAVE_CHAFA
+            "chafa\n"
+        #endif
+        #ifdef FF_HAVE_ZLIB
+            "zlib\n"
+        #endif
         #ifdef FF_HAVE_XFCONF
             "xfconf\n"
         #endif
+        #ifdef FF_HAVE_SQLITE3
+            "sqlite3\n"
+        #endif
         #ifdef FF_HAVE_RPM
-            "librpm\n"
+            "rpm\n"
+        #endif
+        #ifdef FF_HAVE_EGL
+            "egl\n"
+        #endif
+        #ifdef FF_HAVE_GLX
+            "glx\n"
+        #endif
+        #ifdef FF_HAVE_OSMESA
+            "osmesa\n"
+        #endif
+        #ifdef FF_HAVE_OPENCL
+            "opencl\n"
         #endif
         ""
     , stdout);

src/common/io.c

@@ -1,424 +1,61 @@
 #include "fastfetch.h"
+#include "common/io.h"
 
-#include <malloc.h>
+#include <sys/stat.h>
 #include <unistd.h>
 #include <fcntl.h>
+#include <termios.h>
+#include <poll.h>
 
-#define FF_IO_CACHE_VALUE_EXTENSION "ffcv"
-#define FF_IO_CACHE_SPLIT_EXTENSION "ffcs"
-
-void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat)
-{
-    ffPrintLogoLine(instance);
-
-    fputs(FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
-    ffPrintColor(&instance->config.color);
-
-    if(customKeyFormat == NULL || customKeyFormat->length == 0)
-    {
-        fputs(moduleName, stdout);
-
-        if(moduleIndex > 0)
-            printf(" %hhu", moduleIndex);
-    }
-    else
-    {
-        FFstrbuf key;
-        ffStrbufInit(&key);
-        ffParseFormatString(&key, customKeyFormat, NULL, 1, (FFformatarg[]){
-            {FF_FORMAT_ARG_TYPE_UINT8, &moduleIndex}
-        });
-        ffStrbufWriteTo(&key, stdout);
-        ffStrbufDestroy(&key);
-    }
-
-    fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
-    ffStrbufWriteTo(&instance->config.separator, stdout);
-}
-
-void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numFormatArgs, const char* message, ...)
-{
-    if(!instance->config.showErrors)
-        return;
-
-    va_list arguments;
-    va_start(arguments, message);
-
-    if(formatString == NULL || formatString->length == 0)
-    {
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
-        fputs(FASTFETCH_TEXT_MODIFIER_ERROR, stdout);
-        vprintf(message, arguments);
-        puts(FASTFETCH_TEXT_MODIFIER_RESET);
-    }
-    else
-    {
-        FF_STRBUF_CREATE(error);
-        ffStrbufAppendVF(&error, message, arguments);
-
-        // calloc sets all to 0 and FF_FORMAT_ARG_TYPE_NULL also has value 0 so we don't need to explictly set it
-        FFformatarg* nullArgs = calloc(numFormatArgs, sizeof(FFformatarg));
-
-        ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, formatString, &error, numFormatArgs, nullArgs);
-
-        free(nullArgs);
-        ffStrbufDestroy(&error);
-    }
-
-    va_end(arguments);
-}
-
-void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, const FFstrbuf* error, uint32_t numArgs, const FFformatarg* arguments)
-{
-    FFstrbuf buffer;
-    ffStrbufInitA(&buffer, 256);
-
-    ffParseFormatString(&buffer, formatString, error, numArgs, arguments);
-
-    if(buffer.length > 0)
-    {
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
-        ffStrbufPutTo(&buffer, stdout);
-    }
-
-    ffStrbufDestroy(&buffer);
-}
-
-void ffGetCacheFilePath(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* buffer)
-{
-    ffStrbufAppend(buffer, &instance->state.cacheDir);
-    ffStrbufAppendS(buffer, moduleName);
-
-    if(extension != NULL)
-    {
-        ffStrbufAppendC(buffer, '.');
-        ffStrbufAppendS(buffer, extension);
-    }
-}
-
-void ffReadCacheFile(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* buffer)
+static void createSubfolders(const char* fileName)
 {
     FFstrbuf path;
-    ffStrbufInitA(&path, 64);
-    ffGetCacheFilePath(instance, moduleName, extension, &path);
-    ffAppendFileContent(path.chars, buffer);
-    ffStrbufDestroy(&path);
-}
+    ffStrbufInit(&path);
 
-void ffWriteCacheFile(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* content)
-{
-    FFstrbuf path;
-    ffStrbufInitA(&path, 64);
-    ffGetCacheFilePath(instance, moduleName, extension, &path);
-    ffWriteFileContent(path.chars, content);
-    ffStrbufDestroy(&path);
-}
-
-static bool printCachedValue(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat)
-{
-    FFstrbuf content;
-    ffStrbufInitA(&content, 512);
-    ffReadCacheFile(instance, moduleName, FF_IO_CACHE_VALUE_EXTENSION, &content);
-
-    ffStrbufTrimRight(&content, '\0'); //Strbuf always appends a '\0' at the end. We want the last null byte to be at the position of the length
-
-    if(content.length == 0)
-        return false;
-
-    uint8_t moduleCounter = 1;
-
-    uint32_t startIndex = 0;
-    while(startIndex < content.length)
+    while(*fileName != '\0')
     {
-        uint32_t nullByteIndex = ffStrbufNextIndexC(&content, startIndex, '\0');
-        uint8_t moduleIndex = (moduleCounter == 1 && nullByteIndex == content.length) ? 0 : moduleCounter;
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
-        puts(content.chars + startIndex);
-        startIndex = nullByteIndex + 1;
-        ++moduleCounter;
+        ffStrbufAppendC(&path, *fileName);
+        if(*fileName == '/')
+            mkdir(path.chars, S_IRWXU | S_IRGRP | S_IROTH);
+        ++fileName;
     }
 
-    ffStrbufDestroy(&content);
-
-    return moduleCounter > 1;
-}
-
-static bool printCachedFormat(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numArgs)
-{
-    FFstrbuf content;
-    ffStrbufInitA(&content, 512);
-    ffReadCacheFile(instance, moduleName, FF_IO_CACHE_SPLIT_EXTENSION, &content);
-
-    ffStrbufTrimRight(&content, '\0'); //Strbuf always appends a '\0' at the end. We want the last null byte to be at the position of the length
-
-    if(content.length == 0)
-        return false;
-
-    uint8_t moduleCounter = 1;
-
-    FFformatarg* arguments = calloc(numArgs, sizeof(FFformatarg));
-    uint32_t argumentCounter = 0;
-
-    uint32_t startIndex = 0;
-    while(startIndex < content.length)
-    {
-        arguments[argumentCounter].type = FF_FORMAT_ARG_TYPE_STRING;
-        arguments[argumentCounter].value = &content.chars[startIndex];
-        ++argumentCounter;
-
-        uint32_t nullByteIndex = ffStrbufNextIndexC(&content, startIndex, '\0');
-
-        if(argumentCounter == numArgs)
-        {
-            uint8_t moduleIndex = (moduleCounter == 1 && nullByteIndex == content.length) ? 0 : moduleCounter;
-            ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, formatString, NULL, numArgs, arguments);
-            ++moduleCounter;
-            argumentCounter = 0;
-        }
-
-        startIndex = nullByteIndex + 1;
-    }
-
-    free(arguments);
-    ffStrbufDestroy(&content);
-
-    return moduleCounter > 1;
-}
-
-bool ffPrintFromCache(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numArgs)
-{
-    if(instance->config.recache)
-        return false;
-
-    if(formatString == NULL || formatString->length == 0)
-        return printCachedValue(instance, moduleName, customKeyFormat);
-    else
-        return printCachedFormat(instance, moduleName, customKeyFormat, formatString, numArgs);
-}
-
-void ffPrintAndAppendToCache(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, FFcache* cache, const FFstrbuf* value, const FFstrbuf* formatString, uint32_t numArgs, const FFformatarg* arguments)
-{
-    if(formatString == NULL || formatString->length == 0)
-    {
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
-        ffStrbufPutTo(value, stdout);
-    }
-    else
-    {
-        ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, formatString, NULL, numArgs, arguments);
-    }
-
-    if(cache->value != NULL)
-    {
-        ffStrbufWriteTo(value, cache->value);
-        fputc('\0', cache->value);
-    }
-
-    if(cache->split == NULL)
-        return;
-
-    for(uint32_t i = 0; i < numArgs; i++)
-    {
-        FFstrbuf buffer;
-        ffStrbufInitA(&buffer, 64);
-        ffFormatAppendFormatArg(&buffer, &arguments[i]);
-        ffStrbufWriteTo(&buffer, cache->split);
-        ffStrbufDestroy(&buffer);
-        fputc('\0', cache->split);
-    }
-}
-
-void ffPrintAndSaveToCache(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* value, const FFstrbuf* formatString, uint32_t numArgs, const FFformatarg* arguments)
-{
-    FFcache cache;
-    ffCacheOpenWrite(instance, moduleName, &cache);
-    ffPrintAndAppendToCache(instance, moduleName, 0, customKeyFormat, &cache, value, formatString, numArgs, arguments);
-    ffCacheClose(&cache);
-}
-
-void ffCacheValidate(FFinstance* instance)
-{
-    FFstrbuf path;
-    ffStrbufInitA(&path, 64);
-    ffGetCacheFilePath(instance, "cacheversion", "ffv", &path);
-
-    FFstrbuf content;
-    ffStrbufInit(&content);
-    ffAppendFileContent(path.chars, &content);
-
-    bool isSameVersion = ffStrbufCompS(&content, FASTFETCH_PROJECT_VERSION) == 0;
-    ffStrbufDestroy(&content);
-    if(isSameVersion)
-    {
-        ffStrbufDestroy(&path);
-        return;
-    }
-
-    instance->config.recache = true;
-
-    FFstrbuf version;
-    ffStrbufInit(&version);
-    ffStrbufAppendS(&version, FASTFETCH_PROJECT_VERSION);
-    ffWriteFileContent(path.chars, &version);
-    ffStrbufDestroy(&version);
-
     ffStrbufDestroy(&path);
 }
 
-void ffCacheOpenWrite(FFinstance* instance, const char* moduleName, FFcache* cache)
-{
-    FFstrbuf cacheFileValue;
-    ffStrbufInitA(&cacheFileValue, 64);
-    ffGetCacheFilePath(instance, moduleName, FF_IO_CACHE_VALUE_EXTENSION, &cacheFileValue);
-    cache->value = fopen(cacheFileValue.chars, "w");
-    ffStrbufDestroy(&cacheFileValue);
 
-    FFstrbuf cacheFileSplit;
-    ffStrbufInitA(&cacheFileSplit, 64);
-    ffGetCacheFilePath(instance, moduleName, FF_IO_CACHE_SPLIT_EXTENSION, &cacheFileSplit);
-    cache->split = fopen(cacheFileSplit.chars, "w");
-    ffStrbufDestroy(&cacheFileSplit);
-}
-
-void ffCacheClose(FFcache* cache)
-{
-    if(cache->value != NULL)
-        fclose(cache->value);
-
-    if(cache->split != NULL)
-        fclose(cache->split);
-}
-
-bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquery* queries)
-{
-    bool* searchedValues = malloc(sizeof(bool) * numQueries);
-    bool allSet = true;
-    for(uint32_t i = 0; i < numQueries; i++)
-    {
-        if((searchedValues[i] = queries[i].buffer->length == 0))
-            allSet = false;
-    }
-
-    if(allSet)
-    {
-        free(searchedValues);
-        return true;
-    }
-
-    FILE* file = fopen(filename, "r");
-    if(file == NULL)
-        return false;
-
-    char* line = NULL;
-    size_t len = 0;
-
-    while (getline(&line, &len, file) != -1)
-    {
-        for(uint32_t i = 0; i < numQueries; i++)
-        {
-            if(!searchedValues[i])
-                continue;
-
-            uint32_t currentLength = queries[i].buffer->length;
-            queries[i].buffer->length = 0;
-            if(!ffGetPropValue(line, queries[i].start, queries[i].buffer))
-                queries[i].buffer->length = currentLength;
-        }
-    }
-
-    free(searchedValues);
-
-    if(line != NULL)
-        free(line);
-
-    fclose(file);
-
-    return true;
-}
-
-bool ffParsePropFile(const char* filename, const char* start, FFstrbuf* buffer)
-{
-    return ffParsePropFileValues(filename, 1, (FFpropquery[]){{start, buffer}});
-}
-
-bool ffParsePropFileHomeValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
-{
-    FFstrbuf absolutePath;
-    ffStrbufInitA(&absolutePath, 64);
-    ffStrbufAppendS(&absolutePath, instance->state.passwd->pw_dir);
-    ffStrbufAppendC(&absolutePath, '/');
-    ffStrbufAppendS(&absolutePath, relativeFile);
-
-    bool result = ffParsePropFileValues(absolutePath.chars, numQueries, queries);
-
-    ffStrbufDestroy(&absolutePath);
-
-    return result;
-}
-
-bool ffParsePropFileHome(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
-{
-    return ffParsePropFileHomeValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
-}
-
-bool ffParsePropFileConfigValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
-{
-    bool foundAFile = false;
-
-    for(uint32_t i = 0; i < instance->state.configDirs.length; i++)
-    {
-        FFstrbuf* baseDir = (FFstrbuf*) ffListGet(&instance->state.configDirs, i);
-        uint32_t baseDirLength = baseDir->length;
-
-        if(*relativeFile != '/')
-            ffStrbufAppendC(baseDir, '/');
-
-        ffStrbufAppendS(baseDir, relativeFile);
-
-        if(ffParsePropFileValues(baseDir->chars, numQueries, queries))
-            foundAFile = true;
-
-        ffStrbufSubstrBefore(baseDir, baseDirLength);
-
-        bool allSet = true;
-        for(uint32_t k = 0; k < numQueries; k++)
-        {
-            if(queries[k].buffer->length == 0)
-            {
-                allSet = false;
-                break;
-            }
-        }
-
-        if(allSet)
-            break;
-    }
-
-    return foundAFile;
-}
-
-bool ffParsePropFileConfig(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
-{
-    return ffParsePropFileConfigValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
-}
-
-bool ffWriteFDContent(int fd, const FFstrbuf* content)
+bool ffWriteFDBuffer(int fd, const FFstrbuf* content)
 {
     return write(fd, content->chars, content->length) != -1;
 }
 
-void ffWriteFileContent(const char* fileName, const FFstrbuf* content)
+bool ffWriteFileData(const char* fileName, size_t dataSize, const void* data)
 {
-    int fd = open(fileName, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
-    if(fd == -1)
-        return;
+    int openFlagsModes = O_WRONLY | O_CREAT | O_TRUNC;
+    int openFlagsRights = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
 
-    ffWriteFDContent(fd, content);
+    int fd = open(fileName, openFlagsModes, openFlagsRights);
+    if(fd == -1)
+    {
+        createSubfolders(fileName);
+        fd = open(fileName, openFlagsModes, openFlagsRights);
+        if(fd == -1)
+            return false;
+    }
+
+    bool ret = write(fd, data, dataSize) != -1;
 
     close(fd);
+
+    return ret;
 }
 
-void ffAppendFDContent(int fd, FFstrbuf* buffer)
+bool ffWriteFileBuffer(const char* fileName, const FFstrbuf* buffer)
+{
+    return ffWriteFileData(fileName, buffer->length, buffer->chars);
+}
+
+bool ffAppendFDBuffer(int fd, FFstrbuf* buffer)
 {
     ssize_t readed = 0;
 
@@ -430,7 +67,7 @@ void ffAppendFDContent(int fd, FFstrbuf* buffer)
         (uint32_t) readed == free
     ) {
         buffer->length += (uint32_t) readed;
-        ffStrbufEnsureCapacity(buffer, (buffer->allocated * 2) - 1); // -1 for null terminator
+        ffStrbufEnsureFree(buffer, buffer->allocated - 1); // Doubles capacity every round. -1 for the null byte.
         free = ffStrbufGetFree(buffer);
     }
 
@@ -442,24 +79,40 @@ void ffAppendFDContent(int fd, FFstrbuf* buffer)
 
     ffStrbufTrimRight(buffer, '\n');
     ffStrbufTrimRight(buffer, ' ');
+
+    return readed >= 0;
 }
 
-bool ffAppendFileContent(const char* fileName, FFstrbuf* buffer)
+ssize_t ffReadFileData(const char* fileName, size_t dataSize, void* data)
+{
+    int fd = open(fileName, O_RDONLY);
+    if(fd == -1)
+        return -1;
+
+    ssize_t readed = read(fd, data, dataSize);
+
+    close(fd);
+
+    return readed;
+}
+
+bool ffAppendFileBuffer(const char* fileName, FFstrbuf* buffer)
 {
     int fd = open(fileName, O_RDONLY);
     if(fd == -1)
         return false;
 
-    ffAppendFDContent(fd, buffer);
+    bool ret = ffAppendFDBuffer(fd, buffer);
 
     close(fd);
-    return true;
+
+    return ret;
 }
 
-bool ffGetFileContent(const char* fileName, FFstrbuf* buffer)
+bool ffReadFileBuffer(const char* fileName, FFstrbuf* buffer)
 {
     ffStrbufClear(buffer);
-    return ffAppendFileContent(fileName, buffer);
+    return ffAppendFileBuffer(fileName, buffer);
 }
 
 // Not thread safe!
@@ -491,15 +144,50 @@ void ffSuppressIO(bool suppress)
     dup2(suppress ? nullFile : origErr, STDERR_FILENO);
 }
 
-void ffPrintColor(const FFstrbuf* colorValue)
-{
-    fputs("\033[", stdout);
-    ffStrbufWriteTo(colorValue, stdout);
-    fputc('m', stdout);
-}
-
 bool ffFileExists(const char* fileName, mode_t mode)
 {
     struct stat fileStat;
     return stat(fileName, &fileStat) == 0 && ((fileStat.st_mode & S_IFMT) == mode);
 }
+
+void ffGetTerminalResponse(const char* request, const char* format, ...)
+{
+    struct termios oldTerm, newTerm;
+    if(tcgetattr(STDIN_FILENO, &oldTerm) == -1)
+        return;
+
+    newTerm = oldTerm;
+    newTerm.c_lflag &= (tcflag_t) ~(ICANON | ECHO);
+    if(tcsetattr(STDIN_FILENO, TCSANOW, &newTerm) == -1)
+        return;
+
+    fputs(request, stdout);
+    fflush(stdout);
+
+    struct pollfd pfd;
+    pfd.fd = STDIN_FILENO;
+    pfd.events = POLLIN;
+    pfd.revents = 0;
+
+    //Give the terminal 35ms to respond
+    if(poll(&pfd, 1, 35) <= 0)
+    {
+        tcsetattr(STDIN_FILENO, TCSANOW, &oldTerm);
+        return;
+    }
+
+    char buffer[512];
+    ssize_t readed = read(STDIN_FILENO, buffer, sizeof(buffer) - 1);
+
+    tcsetattr(STDIN_FILENO, TCSANOW, &oldTerm);
+
+    if(readed <= 0)
+        return;
+
+    buffer[readed] = '\0';
+
+    va_list args;
+    va_start(args, format);
+    vsscanf(buffer, format, args);
+    va_end(args);
+}

src/common/io.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_io
+#define FF_INCLUDED_common_io
+
+#include <sys/types.h> //mode_t
+
+bool ffWriteFDBuffer(int fd, const FFstrbuf* content);
+bool ffWriteFileData(const char* fileName, size_t dataSize, const void* data);
+bool ffWriteFileBuffer(const char* fileName, const FFstrbuf* buffer);
+
+bool ffAppendFDBuffer(int fd, FFstrbuf* buffer);
+ssize_t ffReadFileData(const char* fileName, size_t dataSize, void* data);
+bool ffAppendFileBuffer(const char* fileName, FFstrbuf* buffer);
+bool ffReadFileBuffer(const char* fileName, FFstrbuf* buffer);
+
+bool ffFileExists(const char* fileName, mode_t mode);
+
+// Not thread safe!
+void ffSuppressIO(bool suppress);
+
+void ffGetTerminalResponse(const char* request, const char* format, ...);
+
+#endif

src/common/library.c

@@ -1,7 +1,35 @@
 #include "fastfetch.h"
+#include "common/library.h"
 
 #include <stdarg.h>
 
+static void* libraryLoad(const char* path, int maxVersion)
+{
+    void* result = dlopen(path, RTLD_LAZY);
+    if(result != NULL)
+        return result;
+
+    FFstrbuf pathbuf;
+    ffStrbufInitA(&pathbuf, 64);
+    ffStrbufAppendS(&pathbuf, path);
+    ffStrbufAppendC(&pathbuf, '.');
+
+    for(int i = maxVersion; i >= 0; --i)
+    {
+        uint32_t originalLength = pathbuf.length;
+        ffStrbufAppendF(&pathbuf, "%i", i);
+
+        result = dlopen(pathbuf.chars, RTLD_LAZY);
+        if(result != NULL)
+            break;
+
+        ffStrbufSubstrBefore(&pathbuf, originalLength);
+    }
+
+    ffStrbufDestroy(&pathbuf);
+    return result;
+}
+
 void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...)
 {
     if(userProvidedName->length > 0)
@@ -11,12 +39,15 @@ void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...)
     va_start(defaultNames, userProvidedName);
 
     void* result = NULL;
-    const char* name = va_arg(defaultNames, const char*);
 
-    while(result == NULL && name != NULL)
+    while(result == NULL)
     {
-        result = dlopen(name, RTLD_LAZY);
-        name = va_arg(defaultNames, const char*);
+        const char* path = va_arg(defaultNames, const char*);
+        if(path == NULL)
+            break;
+
+        int maxVersion = va_arg(defaultNames, int);
+        result = libraryLoad(path, maxVersion);
     }
 
     va_end(defaultNames);

src/common/library.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_library
+#define FF_INCLUDED_common_library
+
+#include <dlfcn.h>
+
+#define FF_LIBRARY_SYMBOL(symbolName) \
+    __typeof__(&symbolName) ff ## symbolName;
+
+#define FF_LIBRARY_LOAD(libraryObjectName, userLibraryName, returnValue, ...) \
+    void* libraryObjectName =  ffLibraryLoad(&userLibraryName, __VA_ARGS__, NULL);\
+    if(libraryObjectName == NULL) \
+        return returnValue;
+
+#define FF_LIBRARY_LOAD_SYMBOL_ADRESS(library, symbolMapping, symbolName, returnValue) \
+    symbolMapping = dlsym(library, #symbolName); \
+    if(symbolMapping == NULL) \
+    { \
+        dlclose(library); \
+        return returnValue; \
+    }
+
+#define FF_LIBRARY_LOAD_SYMBOL(library, symbolName, returnValue) \
+    __typeof__(&symbolName) FF_LIBRARY_LOAD_SYMBOL_ADRESS(library, ff ## symbolName, symbolName, returnValue);
+
+void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...);
+
+#endif

src/common/networking.c

@@ -1,7 +1,8 @@
 #include "fastfetch.h"
+#include "common/networking.h"
 
-#include <sys/types.h>
 #include <unistd.h>
+#include <sys/time.h>
 #include <sys/socket.h>
 #include <netdb.h>
 
@@ -10,7 +11,6 @@ void ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, F
     struct addrinfo hints = {0};
     hints.ai_family = AF_INET;
     hints.ai_socktype = SOCK_STREAM;
-    hints.ai_protocol = 0;
 
     struct addrinfo* addr;
 

src/common/networking.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_networking
+#define FF_INCLUDED_common_networking
+
+#include "util/FFstrbuf.h"
+
+void ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, FFstrbuf* buffer);
+
+#endif

src/common/parsing.c

@@ -1,8 +1,72 @@
 #include "fastfetch.h"
+#include "common/parsing.h"
 
-#include <string.h>
+bool ffStrSet(const char* str)
+{
+    if(str == NULL)
+        return false;
 
-void ffGetGtkPretty(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, const FFstrbuf* gtk4)
+    while(*str != '\0')
+    {
+        if(*str != ' ' && *str != '\t' && *str != '\n' && *str != '\r')
+            return true;
+    }
+
+    return false;
+}
+
+void ffParseSemver(FFstrbuf* buffer, const FFstrbuf* major, const FFstrbuf* minor, const FFstrbuf* patch)
+{
+    if(major->length > 0)
+        ffStrbufAppend(buffer, major);
+    else if(minor->length > 0 || patch->length > 0)
+        ffStrbufAppendC(buffer, '1');
+
+    if(minor->length == 0 && patch->length == 0)
+        return;
+
+    ffStrbufAppendC(buffer, '.');
+
+    if(minor->length > 0)
+        ffStrbufAppend(buffer, minor);
+    else if(patch->length > 0)
+        ffStrbufAppendC(buffer, '0');
+
+    if(patch->length == 0)
+        return;
+
+    ffStrbufAppendC(buffer, '.');
+
+    ffStrbufAppend(buffer, patch);
+}
+
+int8_t ffVersionCompare(const FFVersion* version1, const FFVersion* version2)
+{
+    if(version1->major != version2->major)
+        return version1->major > version2->major ? 1 : -1;
+
+    if(version1->minor != version2->minor)
+        return version1->minor > version2->minor ? 1 : -1;
+
+    if(version1->patch != version2->patch)
+        return version1->patch > version2->patch ? 1 : -1;
+
+    return 0;
+}
+
+void ffVersionToPretty(const FFVersion* version, FFstrbuf* pretty)
+{
+    if(version->major > 0 || version->minor > 0 || version->patch > 0)
+        ffStrbufAppendF(pretty, "%u", version->major);
+
+    if(version->minor > 0 || version->patch > 0)
+        ffStrbufAppendF(pretty, ".%u", version->minor);
+
+    if(version->patch > 0)
+        ffStrbufAppendF(pretty, ".%u", version->patch);
+}
+
+void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, const FFstrbuf* gtk4)
 {
     if(gtk2->length > 0 && gtk3->length > 0 && gtk4->length > 0)
     {
@@ -81,329 +145,3 @@ void ffGetGtkPretty(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3
         ffStrbufAppendS(buffer, " [GTK4]");
     }
 }
-
-static void fontInit(FFfont* font)
-{
-    ffStrbufInit(&font->pretty);
-    ffStrbufInit(&font->name);
-    ffStrbufInitA(&font->size, 4);
-    ffListInitA(&font->styles, sizeof(FFstrbuf), 4);
-}
-
-static void fontInitPretty(FFfont* font)
-{
-    ffStrbufAppend(&font->pretty, &font->name);
-
-    if(font->size.length == 0 && font->styles.length == 0)
-        return;
-    else if(font->pretty.length == 0)
-        ffStrbufAppendS(&font->pretty, "default");
-
-    ffStrbufAppendS(&font->pretty, " (");
-
-    if(font->size.length > 0)
-    {
-        ffStrbufAppend(&font->pretty, &font->size);
-        ffStrbufAppendS(&font->pretty, "pt");
-
-        if(font->styles.length > 0)
-            ffStrbufAppendS(&font->pretty, ", ");
-    }
-
-    for(uint32_t i = 0; i < font->styles.length; i++)
-    {
-        ffStrbufAppend(&font->pretty, ffListGet(&font->styles, i));
-
-        if(i < font->styles.length - 1)
-            ffStrbufAppendS(&font->pretty, ", ");
-    }
-
-    ffStrbufAppendC(&font->pretty, ')');
-}
-
-void ffFontInitQt(FFfont* font, const char* data)
-{
-    fontInit(font);
-
-    //See https://doc.qt.io/qt-5/qfont.html#toString
-
-    //Family
-    while(*data != ',' && *data != '\0')
-    {
-        ffStrbufAppendC(&font->name, *data);
-        ++data;
-    }
-    if(*data != '\0')
-        ++data;
-    ffStrbufTrim(&font->name, ' ');
-
-    //Size
-    while(*data != ',' && *data != '\0')
-    {
-        ffStrbufAppendC(&font->size, *data);
-        ++data;
-    }
-    if(*data != '\0')
-        ++data;
-    ffStrbufTrim(&font->size, ' ');
-
-    #define FF_FONT_QT_SKIP_VALUE \
-        while(*data != ',' && *data != '\0') \
-            ++data; \
-        if(*data != '\0') \
-             ++data;
-
-    FF_FONT_QT_SKIP_VALUE //Pixel size
-    FF_FONT_QT_SKIP_VALUE //Style hint
-    FF_FONT_QT_SKIP_VALUE //Font weight
-    FF_FONT_QT_SKIP_VALUE //Font style
-    FF_FONT_QT_SKIP_VALUE //Underline
-    FF_FONT_QT_SKIP_VALUE //Strike out
-    FF_FONT_QT_SKIP_VALUE //Fixed pitch
-    FF_FONT_QT_SKIP_VALUE //Always 0
-
-    #undef FF_FONT_QT_SKIP_VALUE
-
-    while(*data != '\0')
-    {
-        while(*data == ' ')
-            ++data;
-
-        if(*data == '\0')
-            break;
-
-        FFstrbuf* style = ffListAdd(&font->styles);
-        ffStrbufInit(style);
-        while(*data != ' ' && *data != '\0')
-        {
-            ffStrbufAppendC(style, *data);
-            ++data;
-        }
-    }
-
-    fontInitPretty(font);
-}
-
-static void fontPangoParseWord(const char** data, FFfont* font, FFstrbuf* alternativeBuffer)
-{
-    while(**data == ' ' || **data == '\t' || **data == ',')
-        ++(*data);
-
-    const char* wordStart = *data;
-
-    while(**data != ' ' && **data != '\t' && **data != ',' && **data != '\0' && **data != '`' && **data != '\\')
-        ++(*data);
-
-    uint32_t wordLength = (uint32_t) (*data - wordStart);
-    if(wordLength == 0)
-        return;
-
-    if(**data == '\0' || **data == '`' || **data == '\\')
-    {
-        ffStrbufAppendNS(&font->size, wordLength, wordStart);
-        if(ffStrbufEndsWithS(&font->size, "px"))
-            ffStrbufSubstrBefore(&font->size, font->size.length - 2);
-
-        double dummy;
-        if(sscanf(font->size.chars, "%lf", &dummy) == 1)
-            return;
-
-        ffStrbufClear(&font->size);
-    }
-
-    if(
-        strncasecmp(wordStart, "Ultra", 5) == 0 ||
-        strncasecmp(wordStart, "Extra", 5) == 0 ||
-        strncasecmp(wordStart, "Semi", 4) == 0 ||
-        strncasecmp(wordStart, "Demi", 4) == 0 ||
-        strncasecmp(wordStart, "Normal", wordLength) == 0 ||
-        strncasecmp(wordStart, "Roman", wordLength) == 0 ||
-        strncasecmp(wordStart, "Oblique", wordLength) == 0 ||
-        strncasecmp(wordStart, "Italic", wordLength) == 0 ||
-        strncasecmp(wordStart, "Thin", wordLength) == 0 ||
-        strncasecmp(wordStart, "Light", wordLength) == 0 ||
-        strncasecmp(wordStart, "Bold", wordLength) == 0 ||
-        strncasecmp(wordStart, "Black", wordLength) == 0 ||
-        strncasecmp(wordStart, "Condensed", wordLength) == 0 ||
-        strncasecmp(wordStart, "Expanded", wordLength) == 0
-    ) {
-        if(alternativeBuffer == NULL)
-        {
-            alternativeBuffer = ffListAdd(&font->styles);
-            ffStrbufInit(alternativeBuffer);
-        }
-
-        ffStrbufAppendNSExludingC(alternativeBuffer, wordLength, wordStart, '-');
-
-        if(
-            strncasecmp(wordStart, "Ultra ", 6) == 0 ||
-            strncasecmp(wordStart, "Extra ", 6) == 0 ||
-            strncasecmp(wordStart, "Semi ", 5) == 0 ||
-            strncasecmp(wordStart, "Demi ", 5) == 0
-        ) {
-            fontPangoParseWord(data, font, alternativeBuffer);
-        }
-
-        return;
-    }
-
-    if(alternativeBuffer != NULL)
-    {
-        ffStrbufAppendNSExludingC(alternativeBuffer, wordLength, wordStart, '-');
-        return;
-    }
-
-    if(font->name.length > 0)
-        ffStrbufAppendC(&font->name, ' ');
-    ffStrbufAppendNS(&font->name, wordLength, wordStart);
-}
-
-void ffFontInitPango(FFfont* font, const char* data)
-{
-    fontInit(font);
-
-    while(*data != '\0' && *data != '`' && *data != '\\')
-        fontPangoParseWord(&data, font, NULL);
-
-    fontInitPretty(font);
-}
-
-void ffFontInitCopy(FFfont* font, const char* name)
-{
-    fontInit(font);
-    ffStrbufAppendS(&font->name, name);
-    fontInitPretty(font);
-}
-
-void ffFontDestroy(FFfont* font)
-{
-    ffStrbufDestroy(&font->pretty);
-    ffStrbufDestroy(&font->name);
-    ffStrbufDestroy(&font->size);
-
-    for(uint32_t i = 0; i < font->styles.length; i++)
-        ffStrbufDestroy(ffListGet(&font->styles, i));
-    ffListDestroy(&font->styles);
-}
-
-static bool getPropValueLine(const char** line, const char* start, FFstrbuf* buffer)
-{
-    if(**line == '\0')
-        return false;
-
-    //Skip any amount of whitespace at the begin of line
-    while(**line == ' ' || **line == '\t')
-        ++(*line);
-
-    while(*start != '\0')
-    {
-        // Any amount of whitespace in the format string matches any amount of whitespace in the line, even none
-        if(*start == ' ' || *start == '\t')
-        {
-            while(*start == ' ' || *start == '\t')
-                ++start;
-
-            while(**line == ' ' || **line == '\t')
-                ++(*line);
-
-            continue;
-        }
-
-        //Line doesn't match start, skip it
-        if(**line != *start || **line == '\0')
-            return false;
-
-        //Line and start match, continue testing
-        ++(*line);
-        ++start;
-    }
-
-    char valueEnd = '\n';
-
-    //Allow faster parsing of XML
-    if(*(*line - 1) == '>')
-        valueEnd = '<';
-
-    //Skip any amount of whitespace at the begin of the value
-    while(**line == ' ' || **line == '\t')
-        ++(*line);
-
-    //Allow faster parsing of quotet values
-    if(**line == '"' || **line == '\'')
-    {
-        valueEnd = **line;
-        ++(*line);
-    }
-
-    //Copy the value to the buffer
-    while(**line != valueEnd && **line != '\n' && **line != '\0')
-    {
-        ffStrbufAppendC(buffer, **line);
-        ++(*line);
-    }
-
-    ffStrbufTrimRight(buffer, ' ');
-
-    return true;
-}
-
-bool ffGetPropValue(const char* line, const char* start, FFstrbuf* buffer)
-{
-    return getPropValueLine(&line, start, buffer);
-}
-
-bool ffGetPropValueFromLines(const char* lines, const char* start, FFstrbuf* buffer)
-{
-    while(!getPropValueLine(&lines, start, buffer))
-    {
-        while(*lines != '\0' && *lines != '\n')
-            ++lines;
-
-        if(*lines == '\0')
-            return false;
-
-        //Skip '\n'
-        ++lines;
-    }
-
-    return true;
-}
-
-void ffParseSemver(FFstrbuf* buffer, const FFstrbuf* major, const FFstrbuf* minor, const FFstrbuf* patch)
-{
-    if(major->length > 0)
-        ffStrbufAppend(buffer, major);
-    else if(minor->length > 0 || patch->length > 0)
-        ffStrbufAppendC(buffer, '1');
-
-    if(minor->length == 0 && patch->length == 0)
-        return;
-
-    ffStrbufAppendC(buffer, '.');
-
-    if(minor->length > 0)
-        ffStrbufAppend(buffer, minor);
-    else if(patch->length > 0)
-        ffStrbufAppendC(buffer, '0');
-
-    if(patch->length == 0)
-        return;
-
-    ffStrbufAppendC(buffer, '.');
-
-    ffStrbufAppend(buffer, patch);
-}
-
-bool ffStrSet(const char* str)
-{
-    if(str == NULL)
-        return false;
-
-    while(*str != '\0')
-    {
-        if(*str != ' ' && *str != '\t' && *str != '\n' && *str != '\r')
-            return true;
-    }
-
-    return false;
-}

src/common/parsing.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#ifndef FF_INCLUDED_parsing_h
+#define FF_INCLUDED_parsing_h
+
+#include <stdint.h>
+
+typedef struct FFVersion
+{
+    uint32_t major;
+    uint32_t minor;
+    uint32_t patch;
+} FFVersion;
+
+#define FF_VERSION_INIT ((FFVersion) {0})
+
+bool ffStrSet(const char* str);
+void ffParseSemver(FFstrbuf* buffer, const FFstrbuf* major, const FFstrbuf* minor, const FFstrbuf* patch);
+void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, const FFstrbuf* gtk4);
+
+void ffVersionToPretty(const FFVersion* version, FFstrbuf* pretty);
+int8_t ffVersionCompare(const FFVersion* version1, const FFVersion* version2);
+
+#endif

src/common/printing.c

@@ -0,0 +1,163 @@
+#include "fastfetch.h"
+#include "common/printing.h"
+
+void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat)
+{
+    ffLogoPrintLine(instance);
+
+    //This is used by --set-keyless, in this case we wan't neither the module name nor the separator
+    if(moduleName == NULL)
+        return;
+
+    if(!instance->config.pipe)
+    {
+        fputs(FASTFETCH_TEXT_MODIFIER_RESET FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
+        ffPrintColor(&instance->config.mainColor);
+    }
+
+    //NULL check is required for modules with custom keys, e.g. disk with the folder path
+    if(customKeyFormat == NULL || customKeyFormat->length == 0)
+    {
+        fputs(moduleName, stdout);
+
+        if(moduleIndex > 0)
+            printf(" %hhu", moduleIndex);
+    }
+    else
+    {
+        FFstrbuf key;
+        ffStrbufInit(&key);
+        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);
+
+    if(!instance->config.pipe)
+        fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
+}
+
+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);
+
+    ffParseFormatString(&buffer, format, numArgs, arguments);
+
+    if(buffer.length > 0)
+    {
+        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
+        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)
+{
+    ffPrintFormatString(instance, moduleName, moduleIndex, &moduleArgs->key, &moduleArgs->outputFormat, numArgs, arguments);
+}
+
+static void printError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customErrorFormat, const char* message, va_list arguments)
+{
+    bool hasCustomErrorFormat = customErrorFormat != NULL && customErrorFormat->length > 0;
+    if(!hasCustomErrorFormat && !instance->config.showErrors)
+        return;
+
+    if(hasCustomErrorFormat)
+    {
+        FFstrbuf error;
+        ffStrbufInit(&error);
+        ffStrbufAppendVF(&error, message, arguments);
+
+        ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, customErrorFormat, 1, (FFformatarg[]) {
+            {FF_FORMAT_ARG_TYPE_STRBUF, &error}
+        });
+
+        ffStrbufDestroy(&error);
+    }
+    else
+    {
+        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
+
+        if(!instance->config.pipe)
+            fputs(FASTFETCH_TEXT_MODIFIER_ERROR, stdout);
+
+        vprintf(message, arguments);
+
+        if(!instance->config.pipe)
+            puts(FASTFETCH_TEXT_MODIFIER_RESET);
+    }
+}
+
+void ffPrintErrorString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customErrorFormat, const char* message, ...)
+{
+    va_list arguments;
+    va_start(arguments, message);
+    printError(instance, moduleName, moduleIndex, customKeyFormat, customErrorFormat, message, arguments);
+    va_end(arguments);
+}
+
+void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...)
+{
+    va_list arguments;
+    va_start(arguments, message);
+    printError(instance, moduleName, moduleIndex, &moduleArgs->key, &moduleArgs->errorFormat, message, arguments);
+    va_end(arguments);
+}
+
+void ffPrintColor(const FFstrbuf* colorValue)
+{
+    //If the color is not set, this would reset in \033[m, which resets everything.
+    //So we only print it, if the main color is at least one char.
+    if(colorValue->length == 0)
+        return;
+
+    fputs("\033[", stdout);
+    ffStrbufWriteTo(colorValue, stdout);
+    fputc('m', stdout);
+}
+
+void ffPrintCharTimes(char c, uint32_t times)
+{
+    for(uint32_t i = 0; i < times; i++)
+        putchar(c);
+}
+
+void ffPrintUserString(const char* value)
+{
+    while(*value != '\0')
+    {
+        if(*value != '\\')
+        {
+            putchar(*value);
+            ++value;
+            continue;
+        }
+
+        ++value;
+
+        if(*value == 'n')
+            putchar('\n');
+        else if(*value == 't')
+            putchar('\t');
+        else if(*value == 'e')
+            putchar('\e');
+        else if(*value == '\\')
+            putchar('\\');
+        else
+        {
+            putchar('\\');
+            putchar(*value);
+        }
+
+        ++value;
+    }
+}

src/common/printing.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_printing
+#define FF_INCLUDED_common_printing
+
+#include "fastfetch.h"
+#include "common/format.h"
+
+void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat);
+void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments);
+void ffPrintFormat(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments);
+void ffPrintErrorString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customErrorFormat, const char* message, ...);
+void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...);
+void ffPrintColor(const FFstrbuf* colorValue);
+void ffPrintCharTimes(char c, uint32_t times);
+void ffPrintUserString(const char* str);
+
+#endif

src/common/processing.c

@@ -1,6 +1,8 @@
 #include "fastfetch.h"
+#include "common/processing.h"
+#include "common/io.h"
 
-#include <sys/types.h>
+#include <stdlib.h>
 #include <unistd.h>
 #include <sys/wait.h>
 
@@ -29,6 +31,6 @@ void ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[])
     //Parent
     close(pipes[1]);
     waitpid(childPid, NULL, 0);
-    ffAppendFDContent(pipes[0], buffer);
+    ffAppendFDBuffer(pipes[0], buffer);
     close(pipes[0]);
 }

src/common/processing.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_processing
+#define FF_INCLUDED_common_processing
+
+#include "util/FFstrbuf.h"
+
+void ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[]);
+
+#endif

src/common/properties.c

@@ -0,0 +1,207 @@
+#include "fastfetch.h"
+#include "common/properties.h"
+
+#include <stdlib.h>
+
+static bool parsePropLinePointer(const char** line, const char* start, FFstrbuf* buffer)
+{
+    if(**line == '\0')
+        return false;
+
+    //Skip any amount of whitespace at the begin of line
+    while(**line == ' ' || **line == '\t')
+        ++(*line);
+
+    while(*start != '\0')
+    {
+        // Any amount of whitespace in the format string matches any amount of whitespace in the line, even none
+        if(*start == ' ' || *start == '\t')
+        {
+            while(*start == ' ' || *start == '\t')
+                ++start;
+
+            while(**line == ' ' || **line == '\t')
+                ++(*line);
+
+            continue;
+        }
+
+        //Line doesn't match start, skip it
+        if(**line != *start || **line == '\0')
+            return false;
+
+        //Line and start match, continue testing
+        ++(*line);
+        ++start;
+    }
+
+    char valueEnd = '\n';
+
+    //Allow faster parsing of XML
+    if(*(*line - 1) == '>')
+        valueEnd = '<';
+
+    //Skip any amount of whitespace at the begin of the value
+    while(**line == ' ' || **line == '\t')
+        ++(*line);
+
+    //Allow faster parsing of quotet values
+    if(**line == '"' || **line == '\'')
+    {
+        valueEnd = **line;
+        ++(*line);
+    }
+
+    //Copy the value to the buffer
+    while(**line != valueEnd && **line != '\n' && **line != '\0')
+    {
+        ffStrbufAppendC(buffer, **line);
+        ++(*line);
+    }
+
+    ffStrbufTrimRight(buffer, ' ');
+
+    return true;
+}
+
+bool ffParsePropLine(const char* line, const char* start, FFstrbuf* buffer)
+{
+    return parsePropLinePointer(&line, start, buffer);
+}
+
+bool ffParsePropLines(const char* lines, const char* start, FFstrbuf* buffer)
+{
+    while(!parsePropLinePointer(&lines, start, buffer))
+    {
+        while(*lines != '\0' && *lines != '\n')
+            ++lines;
+
+        if(*lines == '\0')
+            return false;
+
+        //Skip '\n'
+        ++lines;
+    }
+
+    return true;
+}
+
+// The following functions return true if the file was found, independently if start was found
+// Buffers which already contain content are not overwritten
+// The last occurence of start in the first file will be the one used
+
+bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquery* queries)
+{
+    FILE* file = fopen(filename, "r");
+    if(file == NULL)
+        return false;
+
+    bool valueStorage[4];
+    bool* unsetValues;
+
+    if(numQueries > sizeof(valueStorage) / sizeof(valueStorage[0]))
+        unsetValues = malloc(sizeof(bool) * numQueries);
+    else
+        unsetValues = valueStorage;
+
+    bool allSet = true;
+    for(uint32_t i = 0; i < numQueries; i++)
+    {
+        if((unsetValues[i] = queries[i].buffer->length == 0))
+            allSet = false;
+    }
+
+    if(allSet)
+        goto done;
+
+    char* line = NULL;
+    size_t len = 0;
+
+    while (getline(&line, &len, file) != -1)
+    {
+        for(uint32_t i = 0; i < numQueries; i++)
+        {
+            if(!unsetValues[i])
+                continue;
+
+            uint32_t currentLength = queries[i].buffer->length;
+            queries[i].buffer->length = 0;
+            if(!ffParsePropLine(line, queries[i].start, queries[i].buffer))
+                queries[i].buffer->length = currentLength;
+        }
+    }
+
+    if(line != NULL)
+        free(line);
+
+done:
+    fclose(file);
+    if(unsetValues != valueStorage)
+        free(unsetValues);
+    return true;
+}
+
+bool ffParsePropFile(const char* filename, const char* start, FFstrbuf* buffer)
+{
+    return ffParsePropFileValues(filename, 1, (FFpropquery[]){{start, buffer}});
+}
+
+bool ffParsePropFileHomeValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
+{
+    FFstrbuf absolutePath;
+    ffStrbufInitA(&absolutePath, 64);
+    ffStrbufAppendS(&absolutePath, instance->state.passwd->pw_dir);
+    ffStrbufAppendC(&absolutePath, '/');
+    ffStrbufAppendS(&absolutePath, relativeFile);
+
+    bool result = ffParsePropFileValues(absolutePath.chars, numQueries, queries);
+
+    ffStrbufDestroy(&absolutePath);
+
+    return result;
+}
+
+bool ffParsePropFileHome(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
+{
+    return ffParsePropFileHomeValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+}
+
+bool ffParsePropFileConfigValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
+{
+    bool foundAFile = false;
+
+    FFstrbuf baseDir;
+    ffStrbufInitA(&baseDir, 64);
+
+    for(uint32_t i = 0; i < instance->state.configDirs.length; i++)
+    {
+        //We need to copy the config dir each time, because it used by multiple threads, so we can't directly write to it.
+        ffStrbufSet(&baseDir, ffListGet(&instance->state.configDirs, i));
+        ffStrbufAppendS(&baseDir, relativeFile);
+
+        if(ffParsePropFileValues(baseDir.chars, numQueries, queries))
+            foundAFile = true;
+
+        bool allSet = true;
+        for(uint32_t k = 0; k < numQueries; k++)
+        {
+            if(queries[k].buffer->length == 0)
+            {
+                allSet = false;
+                break;
+            }
+        }
+
+        if(allSet)
+            break;
+    }
+
+    ffStrbufDestroy(&baseDir);
+
+    return foundAFile;
+}
+
+bool ffParsePropFileConfig(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
+{
+    return ffParsePropFileConfigValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+}

src/common/properties.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_properties
+#define FF_INCLUDED_common_properties
+
+#include "util/FFstrbuf.h"
+
+typedef struct FFpropquery
+{
+    const char* start;
+    FFstrbuf* buffer;
+} FFpropquery;
+
+bool ffParsePropLine(const char* line, const char* start, FFstrbuf* buffer);
+bool ffParsePropLines(const char* lines, const char* start, FFstrbuf* buffer);
+bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquery* queries);
+bool ffParsePropFile(const char* filename, const char* start, FFstrbuf* buffer);
+bool ffParsePropFileHomeValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries);
+bool ffParsePropFileHome(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer);
+bool ffParsePropFileConfigValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries);
+bool ffParsePropFileConfig(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer);
+
+#endif

src/common/settings.c

@@ -1,6 +1,17 @@
 #include "fastfetch.h"
+#include "common/settings.h"
+#include "common/library.h"
+#include "common/io.h"
 
 #include <pthread.h>
+#include <string.h>
+
+typedef enum FFInitState
+{
+    FF_INITSTATE_UNINITIALIZED = 0,
+    FF_INITSTATE_SUCCESSFUL = 1,
+    FF_INITSTATE_FAILED = 2
+} FFInitState;
 
 #define FF_LIBRARY_DATA_LOAD_INIT(dataObject, userLibraryName, ...) \
     static dataObject data; \
@@ -80,7 +91,7 @@ typedef struct GSettingsData
 
 static const GSettingsData* getGSettingsData(FFinstance* instance)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(GSettingsData, instance->config.libGIO, "libgio-2.0.so", "libgio-2.0.so.0");
+    FF_LIBRARY_DATA_LOAD_INIT(GSettingsData, instance->config.libGIO, "libgio-2.0.so", 1);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_schema_source_lookup)
     FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_schema_has_key)
@@ -152,7 +163,7 @@ typedef struct DConfData
 
 static const DConfData* getDConfData(FFinstance* instance)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(DConfData, instance->config.libDConf, "libdconf.so", "libdconf.so.1");
+    FF_LIBRARY_DATA_LOAD_INIT(DConfData, instance->config.libDConf, "libdconf.so", 2);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(dconf_client_read_full)
     FF_LIBRARY_DATA_LOAD_SYMBOL(dconf_client_new)
@@ -222,7 +233,7 @@ typedef struct XFConfData
 
 static const XFConfData* getXFConfData(FFinstance* instance)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(XFConfData, instance->config.libXFConf, "libxfconf-0.so", "libxfconf-0.so.3");
+    FF_LIBRARY_DATA_LOAD_INIT(XFConfData, instance->config.libXFConf, "libxfconf-0.so", 4);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_get)
     FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_has_property)
@@ -267,6 +278,78 @@ FFvariant ffSettingsGetXFConf(FFinstance* instance, const char* channelName, con
 }
 #endif //FF_HAVE_XFCONF
 
+#ifdef FF_HAVE_SQLITE3
+#include <sqlite3.h>
+#include <sys/stat.h>
+
+typedef struct SQLiteData
+{
+    FF_LIBRARY_SYMBOL(sqlite3_open_v2)
+    FF_LIBRARY_SYMBOL(sqlite3_prepare_v2)
+    FF_LIBRARY_SYMBOL(sqlite3_step)
+    FF_LIBRARY_SYMBOL(sqlite3_data_count)
+    FF_LIBRARY_SYMBOL(sqlite3_column_int)
+    FF_LIBRARY_SYMBOL(sqlite3_finalize)
+    FF_LIBRARY_SYMBOL(sqlite3_close)
+} SQLiteData;
+
+static const SQLiteData* getSQLiteData(const FFinstance* instance)
+{
+    FF_LIBRARY_DATA_LOAD_INIT(SQLiteData, instance->config.libSQLite3, "libsqlite3.so", 1);
+
+    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_open_v2)
+    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_prepare_v2)
+    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_step)
+    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_data_count)
+    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_column_int)
+    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_finalize)
+    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_close)
+
+    FF_LIBRARY_DATA_LOAD_RETURN
+}
+
+int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query)
+{
+    if(!ffFileExists(dbPath, S_IFREG))
+        return 0;
+
+    const SQLiteData* data = getSQLiteData(instance);
+    if(data == NULL)
+        return 0;
+
+    sqlite3* db;
+    if(data->ffsqlite3_open_v2(dbPath, &db, SQLITE_OPEN_READONLY, NULL) != SQLITE_OK)
+        return 0;
+
+    sqlite3_stmt* stmt;
+    if(data->ffsqlite3_prepare_v2(db, query, (int) strlen(query), &stmt, NULL) != SQLITE_OK)
+    {
+        data->ffsqlite3_close(db);
+        return 0;
+    }
+
+    if(data->ffsqlite3_step(stmt) != SQLITE_ROW || data->ffsqlite3_data_count(stmt) < 1)
+    {
+        data->ffsqlite3_finalize(stmt);
+        data->ffsqlite3_close(db);
+        return 0;
+    }
+
+    int result = data->ffsqlite3_column_int(stmt, 0);
+
+    data->ffsqlite3_finalize(stmt);
+    data->ffsqlite3_close(db);
+
+    return result;
+}
+#else //FF_HAVE_SQLITE3
+int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query)
+{
+    FF_UNUSED(instance, dbPath, query)
+    return 0;
+}
+#endif //FF_HAVE_SQLITE3
+
 #ifdef __ANDROID__
 #include <sys/system_properties.h>
 bool ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result) {

src/common/settings.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_settings
+#define FF_INCLUDED_common_settings
+
+#include "fastfetch.h"
+
+typedef enum FFvarianttype
+{
+    FF_VARIANT_TYPE_STRING,
+    FF_VARIANT_TYPE_BOOL,
+    FF_VARIANT_TYPE_INT
+} FFvarianttype;
+
+typedef union FFvariant
+{
+    const char* strValue;
+    int32_t intValue;
+    struct
+    {
+        bool boolValueSet;
+        bool boolValue;
+    };
+} FFvariant;
+
+#define FF_VARIANT_NULL ((FFvariant){.strValue = NULL})
+
+FFvariant ffSettingsGetDConf(FFinstance* instance, const char* key, FFvarianttype type);
+FFvariant ffSettingsGetGSettings(FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type);
+FFvariant ffSettingsGet(FFinstance* instance, const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type);
+FFvariant ffSettingsGetXFConf(FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type);
+
+int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query);
+
+#ifdef __ANDROID__
+bool ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result);
+#endif
+
+#endif

src/common/threading.c

@@ -1,72 +0,0 @@
-#include "fastfetch.h"
-
-#include <pthread.h>
-
-static inline void* detectPlasmaThreadMain(void* instance)
-{
-    ffDetectPlasma((FFinstance*)instance);
-    return NULL;
-}
-
-static inline void* detectGTK2ThreadMain(void* instance)
-{
-    ffDetectGTK2((FFinstance*)instance);
-    return NULL;
-}
-
-static inline void* detectGTK3ThreadMain(void* instance)
-{
-    ffDetectGTK3((FFinstance*)instance);
-    return NULL;
-}
-
-static inline void* detectGTK4ThreadMain(void* instance)
-{
-    ffDetectGTK4((FFinstance*)instance);
-    return NULL;
-}
-
-static inline void* connectDisplayServerThreadMain(void* instance)
-{
-    ffConnectDisplayServer((FFinstance*)instance);
-    return NULL;
-}
-
-static inline void* startThreadsThreadMain(void* instance)
-{
-    pthread_t dsThread;
-    pthread_create(&dsThread, NULL, connectDisplayServerThreadMain, instance);
-    pthread_detach(dsThread);
-
-    pthread_t gtk2Thread;
-    pthread_create(&gtk2Thread, NULL, detectGTK2ThreadMain, instance);
-    pthread_detach(gtk2Thread);
-
-    pthread_t gtk3Thread;
-    pthread_create(&gtk3Thread, NULL, detectGTK3ThreadMain, instance);
-    pthread_detach(gtk3Thread);
-
-    pthread_t gtk4Thread;
-    pthread_create(&gtk4Thread, NULL, detectGTK4ThreadMain, instance);
-    pthread_detach(gtk4Thread);
-
-    pthread_t plasmaThread;
-    pthread_create(&plasmaThread, NULL, detectPlasmaThreadMain, instance);
-    pthread_detach(plasmaThread);
-
-    return NULL;
-}
-
-void ffStartDetectionThreads(FFinstance* instance)
-{
-    //Android needs none of the things that are detected here
-    //And using gsettings sometimes hangs the program in android for some unknown reason,
-    //and since we don't need it we just never call it.
-    #ifdef __ANDROID__
-        return;
-    #endif
-
-    pthread_t startThreadsThread;
-    pthread_create(&startThreadsThread, NULL, startThreadsThreadMain, instance);
-    pthread_detach(startThreadsThread);
-}

src/data/config_system.txt

@@ -0,0 +1,16 @@
+# Fastfetch system configuration
+# This file sets the defaults for all users of the system.
+
+# For more information about configuration files work,
+# see the file ~/.config/fastfetch/config.conf, generated during first
+# All options that can be put there (or passed as argument) can be put here too.
+
+# This file was shipped with $"FASTFETCH_PROJECT_VERSION$".
+# Use fastfetch --print-config-system > /etc/fastfetch/config.conf to overwrite this file with the current defaults
+
+# User config option
+# Sets if fastfetch should load user provided configuration.
+# If this is off, fastfetch ignores the user config file and any passed arguments
+# Must be true or false
+# Default is true.
+#--load-user-config true

src/data/config_user.txt

@@ -6,7 +6,7 @@
 # Empty lines or lines starting with # are ignored.
 
 # This file was shipped with $"FASTFETCH_PROJECT_VERSION$".
-# Use fastfetch --print-config > ~/.config/fastfetch/config.conf to overwrite this with the current defaults
+# Use fastfetch --print-config-user > ~/.config/fastfetch/config.conf to overwrite this file with the current defaults
 
 # Below some often usefull options are listed. Uncomment and modify them so they take affect.
 # Note that there are a lot more options than the ones listed here, take a look at "fastfetch --help".
@@ -27,38 +27,17 @@
 # Get the default structure with "fastfetch --print-structure".
 #--structure $"FASTFETCH_DATATEXT_STRUCTURE$"
 
-# Logo option:
-# Sets the logo to use.
-# List available logos with "fastfetch --list-logos".
-# Print available logos with "fastfetch --print-logos".
-# Must be the name of an available logo or a path to a text file containing a custom logo.
-# Default is the current distribution.
-#--logo arch
+# Multithreading option:
+# Sets if fastfetch should use multiple threads to detect the values.
+# Must be true or false.
+# Default is true.
+#--multithreading true
 
-# Color option:
-# Sets the color of the keys.
-# Must be linux console color codes or the name of a color.
-# Default is the primary color of the logo.
-# Use "fastfetch --help color" to learn more and see examples.
-#--color magenta
-
-# Spacing option:
-# Sets the amount of whitespace between the logo and keys.
-# Must be an positive integer.
-# Default is 4.
-#--spacing 4
-
-# Separator option:
-# Sets the string placed between a key and its value.
-# Can be any string.
-# Default is ": ".
-#--separator ": "
-
-# Offset option:
-# Sets the amount of whitespace before the logo. Can be negative to cut the logo.
-# Must be an integer.
-# Default is 0.
-#--offsetx 0
+# Slow operations option:
+# Sets if fastfetch is allowed to use known slow operations to detect more / better values.
+# Must be true or false.
+# Default is false.
+#--allow-slow-operations false
 
 # Linewrap option:
 # Sets if fastfetch should disable linewrap during the run.
@@ -72,35 +51,31 @@
 # Default is true.
 #--hide-cursor true
 
-# Remaing logo option:
-# Sets if the remaining logo should be printed, if it is higher than the information printed.
-# Must be true or false.
-# Default is true.
-#--print-remaining-logo true
+# Logo option:
+# Sets the logo to use.
+# List available logos with "fastfetch --list-logos".
+# Print available logos with "fastfetch --print-logos".
+# Must be the name of an available logo or a path to a text file containing a custom logo.
+# Default is the current distribution.
+#--logo arch
 
-# Multithreading option:
-# Sets if fastfetch should use multiple threads to detect the values.
-# Must be true or false.
-# Default is true.
-#--multithreading true
+# Logo type option:
+# Sets the logo type to use.
+# Must be auto, builtin, file, raw, sixel, kitty or chafa.
+# Default is auto.
+#--logo-type auto
 
-# Slow operations option:
-# Sets if fastfetch is allowed to use known slow operations to detect more / better values.
-# Must be true or false.
-# Default is false.
-#--allow-slow-operations false
+# Logo width option:
+# Sets the width of the logo (in characters) if the logo is an image.
+# Must be a positive integer.
+# Default is 65.
+#--logo-width 65
 
-# Color logo option:
-# Sets if the logo should be colored.
-# Must be true or false.
-# Default is true.
-#--color-logo true
-
-# Separator string option:
-# Sets the string printed by the "separator" module (usually between title and rest of output)
-# Must be any string. It is repated / cut to fit perfectly.
-# Default is "-"
-#--separator-string -
+# Logo height option:
+# Sets the height of the logo (in characters) if the logo is an image.
+# Must be a positive integer.
+# Default is 0 (keeps aspect ration).
+#--logo-height 0
 
 # Logo color options:
 # Overwrite a color in the logo. Also works for user provided logos.
@@ -109,16 +84,59 @@
 # Default is the one specified by the logo.
 # Use "fastfetch --help color" to learn more and see examples.
 # Valid index range is [1-9].
-#--color-1 red
-#--color-2 32
+#--logo-color-1 red
+#--logo-color-2 32
 # [...]
-#--color-9 yellow
+#--logo-color-9 yellow
 
-# User logo raw option:
-# Sets if color replacements should be performed on the user provided logo.
+# Logo padding option:
+# Adds a padding to the left and the right side of the logo.
+# Must be a positive integer.
+# Default is 0.
+#--logo-padding 0
+
+# Logo padding left option:
+# Adds a padding to the left side of the logo.
+# Must be a positive integer.
+# Default is 0.
+#--logo-padding-left 0
+
+# Logo padding right option:
+# Adds a padding to the right side of the logo.
+# Must be a positive integer.
+# Default is 0.
+#--logo-padding-right 0
+
+# Logo print remaining option:
+# Sets if the remaining logo should be printed, it is has more lines than modules to show.
 # Must be true or false.
 # Default is true.
-#--color-raw true
+#--logo-print-remaining true
+
+# Color option:
+# Sets the color of the keys.
+# Must be linux console color codes or the name of a color.
+# Default is the primary color of the logo.
+# Use "fastfetch --help color" to learn more and see examples.
+#--color magenta
+
+# Title FQDN option:
+# Sets if the title should use the fully qualified domain name.
+# Must be true or false.
+# Default is false.
+#--title-fqdn false
+
+# Separator option:
+# Sets the string placed between a key and its value.
+# Can be any string.
+# Default is ": ".
+#--separator ": "
+
+# Separator string option:
+# Sets the string printed by the "separator" module (usually between title and rest of output)
+# Must be any string. It is repated / cut to fit perfectly.
+# Default is "-"
+#--separator-string -
 
 # Public IP timeout option:
 # Sets the time to wait for the public ip server to respond.
@@ -139,6 +157,18 @@
 # Default is the first match starting with org.mpris.MediaPlayer2.
 #--player-name spotify
 
+# Escape bedrock option
+# Sets if fastfetch should escape the bedrock jail, if it detectes that it is running in one
+# Must be true or false.
+# Default is true.
+#--escape-bedrock true
+
+# GL option
+# Sets with opengl context creation library to use
+# Must be either auto, egl, glx or osmesa
+# Default is auto.
+#--gl auto
+
 # Key options:
 # Sets the displayed key of a module
 # Can be any string. Some of theme take an argument like a format string. See "fastfetch --help format" for help.
@@ -171,6 +201,9 @@
 #--player-key Media Player
 #--song-key Song
 #--datetime-key Date Time
+#--vulkan-key Vulkan
+#--opengl-key OpenGL
+#--opencl-key OpenCL
 
 # Format options:
 # Sets the format string for module values.
@@ -206,6 +239,47 @@
 #--player-format
 #--song-format
 #--datetime-format
+#--vulkan-format
+#--opengl-format
+#--opencl-format
+
+# Error options:
+# Sets the format string to use if an error occured
+# For information on format strings, see "fastfetch --help format".
+# Each of them take the error as first and only argument.
+# If one of them is set, the module will appear, even if --show-errors is not given.
+#--os-error
+#--host-error
+#--kernel-error
+#--uptime-error
+#--processes-error
+#--packages-error
+#--shell-error
+#--resolution-error
+#--de-error
+#--wm-error
+#--wm-theme-error
+#--theme-error
+#--icons-error
+#--font-error
+#--cursor-error
+#--terminal-error
+#--terminal-font-error
+#--cpu-error
+#--cpu-usage-error
+#--gpu-error
+#--memory-error
+#--disk-error
+#--battery-error
+#--locale-error
+#--local-ip-error
+#--public-ip-error
+#--player-error
+#--song-error
+#--datetime-error
+#--vulkan-error
+#--opengl-error
+#--opencl-error
 
 # Library options:
 # Sets an user specific path to a library to load.
@@ -221,4 +295,12 @@
 #--lib-DConf /usr/lib/libdconf.so
 #--lib-DBus /usr/lib/libdbus-1.so
 #--lib-XFConf /usr/lib/libxfconf-0.so
+#--lib-sqlite3 /usr/lib/libsqlite3.so
 #--lib-rpm /usr/lib/librpm.so
+#--lib-imagemagick /usr/lib/libMagickCore-7.Q16HDRI.so
+#--lib-z /usr/lib/libz.so
+#--lib-chafa /usr/lib/libchafa.so
+#--lib-egl /usr/lib/libEGL.so
+#--lib-glx /usr/lib/libGLX.so
+#--lib-osmesa /usr/lib/libOSMesa.so
+#--lib-opencl /usr/lib/libOpenCL.so

src/data/help.txt

@@ -1,105 +1,64 @@
 Usage: fastfetch <options>
 
 Informative options:
-    -h,           --help:            shows this message and exits
-    -h <command>, --help <command>:  shows help for a specific command and exits
-    -v            --version:         prints the version of fastfetch and exits
-                  --list-logos:      list available logos and exits
-                  --list-modules:    lists available modules and exits
-                  --list-presets:    list presets fastfetch knows about and exits. They can be loaded with --load-config. (+)
-                  --list-features:   list the supported features fastfetch was compiled with and exits. Mainly for development.
-                  --print-logos:     show available logos and exits
-                  --print-config:    prints the default config and exits
-                  --print-structure: prints the default stucture and exits
+    -h,--help:             shows this message and exits
+    -h,--help <command>:   shows help for a specific command and exits
+    -v,--version:          prints the version of fastfetch and exits
+    --list-logos:          list available logos and exits
+    --list-modules:        lists available modules and exits
+    --list-presets:        list presets fastfetch knows about and exits. They can be loaded with --load-config. (+)
+    --list-features:       list the supported features fastfetch was compiled with and exits. Mainly for development.
+    --print-logos:         show available logos and exits
+    --print-config-system: prints the default system config and exits
+    --print-config-user:   prints the default user config and exits
+    --print-structure:     prints the default stucture and exits
 
 General options:
-                 --structure <structure>:          sets the structure of the fetch. Must be a colon separated list of keys. Use "fastfetch --list-modules" to see the ones available.
-                 --set <key=value>:                hard set the value of a key
-    -c <color>,  --color <color>:                  sets the color of the keys. Must be a linux console color code or the name of a color (+)
-                 --color-[1-9] <color>:            overwrites a color of the logo. Must be a linux console color code or the name of a color
-                 --spacing <width>:                sets the distance between logo and text
-    -s <str>,    --separator <str>:                sets the separator between key and value. Default is a colon with a space
-    -x <offset>, --offsetx <offset>:               sets the x offset. Can be negative to cut the logo, but no more than logo width.
-                 --show-errors <?value>:           print occuring errors
-    -r <?value>  --recache <?value>:               generate new cached values
-                 --nocache <?value>:               don't use cached values, but also don't overwrite existing ones
-                 --print-remaining-logo <?value>:  print the remaining logo, if it is higher than the number of lines shown
-                 --multithreading <?value>:        use multiple threads to detect values
-                 --load-config <file>:             load a config file (+)
-                 --allow-slow-operations <?value>: Allow operations that are usually very slow for more detailed output
-                 --disable-linewrap <?value>:      Disable linewrap during the run
-                 --hide-cursor <?value>:           Hide the cursor during the run
-                 --logo-raw <?value>:              Print a custom logo as is, without any color replacements
+    -r,--recache <?value>:            generate new cached values
+    --nocache <?value>:               don't use cached values, but also don't overwrite existing ones
+    --load-config <file>:             load a config file or a preset (+)
+    --multithreading <?value>:        use multiple threads to detect values
+    --allow-slow-operations <?value>: allow operations that are usually very slow for more detailed output
+    --escape-bedrock <?value>:        on bedrock linux, sets if it should escape the bedrock jail or not
+    --pipe <?value>:                  disable logo and all escape sequences
 
 Logo options:
-    -l <name>, --logo <name>:         sets the shown logo. Also changes the main color accordingly. This will also load file contents as logo if the given argument is a valid path.
-               --color-logo <?value>: if set to false, the logo will be black / white
+    -l,--logo <logo>:                set the logo to use. The type is specified by --logo-type. If default: the name of a builtin logo or a path to a file
+    --logo-type <type>:              set the type of the logo given. Must be auto, builtin, file, raw, sixel, kitty or chafa.
+    --logo-width <width>:            set the width of the logo (in characters), if it is an image
+    --logo-height <height>:          set the height of the logo (in characters), if it is an image
+    --logo-color-[1-9] <color>:      overwrite a color in the logo
+    --logo-padding <padding>:        set the padding on the left and the right of the logo
+    --logo-padding-left <padding>:   set the padding on the left of the logo
+    --logo-padding-right <padding>:  set the padding on the right of the logo
+    --logo-print-remaining <?value>: weather to print the remaining logo, if it has more lines than modules to display
+    --sixel <file>:                  short for --logo-type sixel --logo <file>
+    --kitty <file>:                  short for --logo-type kitty --logo <file>
+    --chafa <file>:                  short for --logo-type chafa --logo <file>
+    --file <file>:                   short for --logo-type file --logo <file>
+    --raw <file>:                    short for --logo-type raw --logo <file>
 
-Format options: Provide the format string for custom output. Use fastfetch --help *-format for specific help.
-    --os-format <format>
-    --host-format <format>
-    --kernel-format <format>
-    --uptime-format <format>
-    --processes-format <format>
-    --packages-format <format>
-    --shell-format <format>
-    --resolution-format <format>
-    --de-format <format>
-    --wm-format <format>
-    --wm-theme-format <format>
-    --theme-format <format>
-    --icons-format <format>
-    --font-format <format>
-    --cursor-format <format>
-    --terminal-format <format>
-    --terminal-font-format <format>
-    --cpu-format <format>
-    --cpu-usage-format <format>
-    --gpu-format <format>
-    --memory-format <format>
-    --disk-format <format>
-    --battery-format <format>
-    --locale-format <format>
-    --local-ip-format <format>
-    --public-ip-format <format>
-    --player-format <format>
-    --song-format <format>
-    --datetime-format <format>
-    --time-format <format>
-    --date-format <format>
+Display options:
+    -s,--structure <structure>:  sets the structure of the fetch. Must be a colon separated list of keys. Use "fastfetch --list-modules" to see the ones available.
+    -c,--color <color>:          sets the color of the keys. Must be a linux console color code or the name of a color (+)
+    --separator <str>:           sets the separator between key and value. Default is a colon with a space
+    --set <key=value>:           hard set the value of a key
+    --set-keyless <key=value>:   hard set the value of a key, but don't print the key or the separator
+    --show-errors <?value>:      print occuring errors
+    --disable-linewrap <?value>: weather to disable linewrap during the run
+    --hide-cursor <?value>:      weather to hide the cursor during the run
 
-Key options: Provide a custom key for an output
-    --os-key <key>
-    --host-key <key>
-    --kernel-key <key>
-    --uptime-key <key>
-    --processes-key <key>
-    --packages-key <key>
-    --shell-key <key>
-    --resolution-key <key>: takes the resolution index as argument
-    --de-key <key>
-    --wm-key <key>
-    --wm-theme-key <key>
-    --theme-key <key>
-    --icons-key <key>
-    --font-key <key>
-    --cursor-key <key>
-    --terminal-key <key>
-    --terminal-font-key <key>
-    --cpu-key <key>
-    --cpu-usage-key <key>
-    --gpu-key <key>: takes the gpu index as format argument
-    --memory-key <key>
-    --disk-key <key>: takes the mount path as format argument
-    --battery-key <key>: takes the battery index as format argument
-    --locale-key <key>
-    --local-ip-key <key>: takes the name of this network interface as format argument
-    --public-ip-key <key>
-    --player-key <key>
-    --song-key <key>
-    --datetime-key <key>
-    --time-key <key>
-    --date-key <key>
+General module options:
+    --<module>-format <format>: Sets the format string to use for each specific module.
+                                To see how a format string works, use fastfetch --help format.
+                                To see help about a specific format string, use fastfetch --help <module>-format.
+
+    --<module>-key <key>:       Sets the key to use for each specific module.
+                                For modules which print multiple lines, the string is parsed as a format string with the index as first character.
+
+    --<module>-error <format>:  Sets the error format string to use for each specific module.
+                                The error is given as the first and only argument.
+                                Setting this for a module will cause it to appear, even if --show-errors is not given.
 
 Library options: Set the path of a library to load
     --lib-PCI <path>
@@ -113,9 +72,18 @@ Library options: Set the path of a library to load
     --lib-DConf <path>
     --lib-DBus <path>
     --lib-XFConf <path>
-    --lib-RPM <path>
+    --lib-sqlite3 <path>
+    --lib-rpm <path>
+    --lib-imagemagick <path>
+    --lib-z <path>
+    --lib-chafa <path>
+    --lib-egl <path>
+    --lib-glx <path>
+    --lib-osmesa <path>
+    --lib-opencl <path>
 
 Module specific options:
+    --title-fqdn <?value>:        sets if the title should use fully qualified domain name. Default is false.
     --separator-string <str>:     Set the string printed by the separator module
     --os-file <path>:             Set the path to the file containing OS informations
     --disk-folders <folders>:     A colon separated list of folder paths for the disk output. Default is "/:/home"
@@ -125,6 +93,7 @@ Module specific options:
     --localip-show-loop <?value>: Show loop back addresses (127.0.0.1) in local ip module. Default is false
     --public-ip-timeout:          Time in milliseconds to wait for the public ip server to respond. Default is disabled (0)
     --player-name:                The name of the player to use
+    --gl <value>:                 Sets the opengl context creation library to use. Must be auto, egl, glx or osmesa. Default is auto
 
 Parsing is not case sensitive. E.g. "--lib-PCI" is equal to "--Lib-Pci"
 If a value starts with a ?, it is optional. "true" will be used if not set.

src/data/help_format.txt

@@ -19,24 +19,18 @@ If a "{?}" is found without an opener, it is printed as is.
 To only print something if a variable is not set, do the same as with if, just replace every '?' with a '!'.
 For example to print a fallback for a second value if it is not set, use "{?2}{2}{?}{/2}Second value fallback{/}"
 
-There is a special variable set if an error occured during detection. You can access it with "{e}", "{error}" o
-You can use ifs and not ifs with it like with an index. For example use "{?e}some text{?}", to print a text if an
-
 To stop formatting at any point in the format string, use "{-}".
-For example to print an error instead of the normal output if it occured, prefix the format string with "{?e}{e}{-
 
 To print something with color, start a placeholder with a '#' and then the linux terminal color encoding.
 "\\033[" at the start, and an 'm' at the end is automatically added, so don't do that.
 A "{#}" is equivalent to a "{#0}" and resets everything to normal.
 For example to print something pink and underline, use "{#4;35}...{#}".
-If not in a format string, fastfetch wraps errors with "{#1;31}error{#}", so you might want to do that to if you
 Information about what the numbers mean can be found here: https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Sele
 Which escape codes are supported and how they look is defined by your terminal.
 
 If a format string evaluates to an empty value, the whole line in the output will be discarded.
 You can therefore use --host-format " " to disable host output.
 Note that --host-format "" would evaluate as not set, and therefore use the built-in host format
-This can be used to print nothing if an error occured: prefix the format string with "{?e}{-}{?}...".
 
 Format string is also the way to go to set a fixed value - just use one without placeholders.
 For example when running in headless mode, you could use "--resolution-format "Preferred".

src/data/modules.txt

@@ -17,6 +17,8 @@ Locale
 LocalIP
 Memory
 OS
+OpenCL
+OpenGL
 Packages
 Player
 Processes
@@ -31,5 +33,6 @@ Theme
 Time
 Title
 Uptime
+Vulkan
 WM
 WMTheme

src/detection/datetime.c

@@ -1,7 +1,7 @@
 #include "fastfetch.h"
+#include "detection/datetime.h"
 
 #include <time.h>
-
 #include <pthread.h>
 
 const FFDateTimeResult* ffDetectDateTime(const FFinstance* instance)

src/detection/datetime.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_datetime
+#define FF_INCLUDED_detection_datetime
+
+#include "fastfetch.h"
+
+typedef struct FFDateTimeResult
+{
+    //Examples for 21.02.2022 - 15:18:37
+    uint16_t year; //2022
+    uint8_t yearShort; //22
+    uint8_t month; //2
+    FFstrbuf monthPretty; //02
+    FFstrbuf monthName; //February
+    FFstrbuf monthNameShort; //Feb
+    uint8_t week; //8
+    FFstrbuf weekday; //Monday
+    FFstrbuf weekdayShort; //Mon
+    uint16_t dayInYear; //52
+    uint8_t dayInMonth; //21
+    uint8_t dayInWeek; //1
+    uint8_t hour; //15
+    FFstrbuf hourPretty; //15
+    uint8_t hour12; //3
+    FFstrbuf hour12Pretty; //03
+    uint8_t minute; //18
+    FFstrbuf minutePretty; //18
+    uint8_t second; //37
+    FFstrbuf secondPretty; //37
+} FFDateTimeResult;
+
+const FFDateTimeResult* ffDetectDateTime(const FFinstance* instance);
+
+#endif

src/detection/displayserver.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_displayserver
+#define FF_INCLUDED_detection_displayserver
+
+#include "fastfetch.h"
+
+typedef struct FFResolutionResult
+{
+    uint32_t width;
+    uint32_t height;
+    uint32_t refreshRate;
+} FFResolutionResult;
+
+typedef struct FFDisplayServerResult
+{
+    FFstrbuf wmProcessName;
+    FFstrbuf wmPrettyName;
+    FFstrbuf wmProtocolName;
+    FFstrbuf deProcessName;
+    FFstrbuf dePrettyName;
+    FFstrbuf deVersion;
+    FFlist resolutions; //List of FFResolutionResult
+} FFDisplayServerResult;
+
+const FFDisplayServerResult* ffConnectDisplayServer(const FFinstance* instance);
+
+#endif
+

src/detection/displayserver/displayServer.c

@@ -1,4 +1,5 @@
 #include "displayServer.h"
+
 #include <pthread.h>
 #include <dirent.h>
 

src/detection/displayserver/displayServer.h

@@ -4,6 +4,7 @@
 #define FASTFETCH_INCLUDED_DISPLAYSERVER
 
 #include "fastfetch.h"
+#include "detection/displayserver.h"
 
 #define FF_DISPLAYSERVER_PROTOCOL_WAYLAND "Wayland"
 #define FF_DISPLAYSERVER_PROTOCOL_X11 "X11"

src/detection/displayserver/wayland.c

@@ -1,50 +1,53 @@
+#define _GNU_SOURCE //required for struct ucred
+
 #include "displayServer.h"
+
+#include <stdlib.h>
 #include <string.h>
 
 #ifdef FF_HAVE_WAYLAND
-#include <wayland-client.h>
+#include "common/library.h"
+#include "common/io.h"
 #include <pthread.h>
+#include <wayland-client.h>
+#include <sys/socket.h>
 
 typedef struct WaylandData
 {
-    const FFinstance* instance;
     FFlist* results;
     FF_LIBRARY_SYMBOL(wl_proxy_marshal_constructor_versioned)
     FF_LIBRARY_SYMBOL(wl_proxy_add_listener)
-    FF_LIBRARY_SYMBOL(wl_proxy_destroy)
     const struct wl_interface* ffwl_output_interface;
-    struct wl_output_listener output_listener;
 } WaylandData;
 
-static void waylandGlobalRemoveListener(void* data, struct wl_registry* wl_registry, uint32_t name){
-    FF_UNUSED(data, wl_registry, name);
+static void waylandDetectWM(int fd, FFDisplayServerResult* result)
+{
+    struct ucred ucred;
+    socklen_t len = sizeof(struct ucred);
+    if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &len) == -1)
+        return;
+
+    FFstrbuf procPath;
+    ffStrbufInit(&procPath);
+    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);
 }
 
-static void waylandOutputGeometryListener(void* data, struct wl_output* wl_output, int32_t x, int32_t y, int32_t physical_width, int32_t physical_height, int32_t subpixel, const char* make, const char* model, int32_t transform)
+static void stubListener(void* data, ...)
 {
-    FF_UNUSED(data, wl_output, x, y, physical_width, physical_height, subpixel, make, model, transform);
-}
-
-static void waylandOutputDoneListener(void* data, struct wl_output* wl_output)
-{
-    FF_UNUSED(data, wl_output);
-}
-
-static void waylandOutputScaleListener(void* data, struct wl_output* wl_output, int32_t factor)
-{
-    FF_UNUSED(data, wl_output, factor);
+    (void) data;
 }
 
 static void waylandOutputModeListener(void* data, struct wl_output* output, uint32_t flags, int32_t width, int32_t height, int32_t refreshRate)
 {
-    if(!(flags & WL_OUTPUT_MODE_CURRENT))
-        return;
+    FF_UNUSED(output);
 
-    WaylandData* wldata = (WaylandData*) data;
+    WaylandData* wldata = data;
 
-    wldata->ffwl_proxy_destroy((struct wl_proxy*) output);
-
-    if(width <= 0 || height <= 0)
+    if(!(flags & WL_OUTPUT_MODE_CURRENT) || width <= 0 || height <= 0)
         return;
 
     static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
@@ -61,92 +64,106 @@ static void waylandOutputModeListener(void* data, struct wl_output* output, uint
 
 static void waylandGlobalAddListener(void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t version)
 {
-    if(strcmp(interface, "wl_output") == 0)
-    {
-        WaylandData* wldata = (WaylandData*) data;
+    WaylandData* wldata = data;
 
-        struct wl_output* output = (struct wl_output*) wldata->ffwl_proxy_marshal_constructor_versioned((struct wl_proxy *) registry, WL_REGISTRY_BIND, wldata->ffwl_output_interface, version, name, wldata->ffwl_output_interface->name, version, NULL);
+    if(strcmp(interface, wldata->ffwl_output_interface->name) == 0)
+    {
+        struct wl_proxy* output = wldata->ffwl_proxy_marshal_constructor_versioned((struct wl_proxy*) registry, WL_REGISTRY_BIND, wldata->ffwl_output_interface, version, name, wldata->ffwl_output_interface->name, version, NULL);
         if(output == NULL)
             return;
 
-        wldata->ffwl_proxy_add_listener((struct wl_proxy*) output, (void(**)(void)) &wldata->output_listener, data);
+        //Needs to be static, because the scope of the function will already be lost when calling the listener
+        static struct wl_output_listener outputListener = {
+            .mode = waylandOutputModeListener,
+            .geometry = (void*) stubListener,
+
+            //https://lists.freedesktop.org/archives/wayland-devel/2013-July/010278.html
+            #if WAYLAND_VERSION_MINOR >= 2
+                .done = (void*) stubListener,
+                .scale = (void*) stubListener,
+            #endif
+
+            //https://lists.freedesktop.org/archives/wayland-devel/2021-December/042064.html
+            #if WAYLAND_VERSION_MINOR >= 20
+                .name = (void*) stubListener,
+                .description = (void*) stubListener,
+            #endif
+        };
+
+        wldata->ffwl_proxy_add_listener(output, (void(**)(void)) &outputListener, data);
     }
 }
 
-void ffdsConnectWayland(const FFinstance* instance, FFDisplayServerResult* result)
+bool detectWayland(const FFinstance* instance, FFDisplayServerResult* result)
 {
-    if(getenv("XDG_RUNTIME_DIR") == NULL)
-        return;
+    FF_LIBRARY_LOAD(wayland, instance->config.libWayland, false, "libwayland-client.so", 1)
 
-    FF_LIBRARY_LOAD(wayland, instance->config.libWayland, , "libwayland-client.so", "libwayland-client.so.0")
-
-    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_connect,)
-    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_dispatch,)
-    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_roundtrip,)
-    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_proxy_marshal_constructor,)
-    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_disconnect,)
-    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_registry_interface,)
+    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_connect, false)
+    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_get_fd, false)
+    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_dispatch, false)
+    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_roundtrip, false)
+    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_proxy_marshal_constructor, false)
+    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_disconnect, false)
+    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_registry_interface, false)
 
     WaylandData data;
 
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(wayland, data.ffwl_proxy_marshal_constructor_versioned, wl_proxy_marshal_constructor_versioned,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(wayland, data.ffwl_proxy_add_listener, wl_proxy_add_listener,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(wayland, data.ffwl_output_interface, wl_output_interface,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(wayland, data.ffwl_proxy_destroy, wl_proxy_destroy,)
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(wayland, data.ffwl_proxy_marshal_constructor_versioned, wl_proxy_marshal_constructor_versioned, false)
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(wayland, data.ffwl_proxy_add_listener, wl_proxy_add_listener, false)
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(wayland, data.ffwl_output_interface, wl_output_interface, false)
 
     struct wl_display* display = ffwl_display_connect(NULL);
     if(display == NULL)
     {
         dlclose(wayland);
-        return;
+        return false;
     }
 
-    struct wl_registry* registry = (struct wl_registry*) ffwl_proxy_marshal_constructor((struct wl_proxy*) display, WL_DISPLAY_GET_REGISTRY, ffwl_registry_interface, NULL);
+    waylandDetectWM(ffwl_display_get_fd(display), result);
+
+    struct wl_proxy* registry = ffwl_proxy_marshal_constructor((struct wl_proxy*) display, WL_DISPLAY_GET_REGISTRY, ffwl_registry_interface, NULL);
     if(registry == NULL)
     {
         ffwl_display_disconnect(display);
         dlclose(wayland);
-        return;
+        return false;
     }
 
-    data.instance = instance;
     data.results = &result->resolutions;
 
-    struct wl_registry_listener regestry_listener;
-    regestry_listener.global = waylandGlobalAddListener;
-    regestry_listener.global_remove = waylandGlobalRemoveListener;
+    struct wl_registry_listener registry_listener = {
+        .global = waylandGlobalAddListener,
+        .global_remove = (void*) stubListener
+    };
 
-    data.output_listener.geometry = waylandOutputGeometryListener;
-    data.output_listener.mode = waylandOutputModeListener;
-    data.output_listener.done = waylandOutputDoneListener;
-    data.output_listener.scale = waylandOutputScaleListener;
-
-    data.ffwl_proxy_add_listener((struct wl_proxy*) registry, (void(**)(void)) &regestry_listener, &data);
+    data.ffwl_proxy_add_listener(registry, (void(**)(void)) &registry_listener, &data);
     ffwl_display_dispatch(display);
     ffwl_display_roundtrip(display);
 
-    data.ffwl_proxy_destroy((struct wl_proxy*) registry);
-    ffwl_display_disconnect(display);
+    ffwl_display_disconnect(display); //This will also destroy our wl_registry and wl_output proxies
     dlclose(wayland);
 
     //We successfully connected to wayland and detected the resolution.
     //So we can set set the session type to wayland.
     //This is used as an indicator that we are running wayland by the x11 backends.
     ffStrbufSetS(&result->wmProtocolName, FF_DISPLAYSERVER_PROTOCOL_WAYLAND);
+    return true;
 }
-
-#else
+#endif
 
 void ffdsConnectWayland(const FFinstance* instance, FFDisplayServerResult* result)
 {
-    FF_UNUSED(instance);
-
-    //We try to detect wayland already here, so the x11 methods only to resolution detection.
-
     //Wayland requires this to be set
     if(getenv("XDG_RUNTIME_DIR") == NULL)
         return;
 
+    #ifdef FF_HAVE_WAYLAND
+        if(detectWayland(instance, result))
+            return;
+    #else
+        FF_UNUSED(instance);
+    #endif
+
     const char* xdgSessionType = getenv("XDG_SESSION_TYPE");
 
     //If XDG_SESSION_TYPE is set, and doesn't contain "wayland", we are probably not running in a wayland session.
@@ -158,9 +175,7 @@ void ffdsConnectWayland(const FFinstance* instance, FFDisplayServerResult* resul
     if(xdgSessionType == NULL && getenv("WAYLAND_DISPLAY") == NULL && getenv("WAYLAND_SOCKET") == NULL)
         return;
 
-    //We are probably running a wayland compositor at this point, but fastfetch was compiled without the required library.
-    //Set the protocol name and use DRM for resolution detection.
+    //We are probably running a wayland compositor at this point,
+    //but fastfetch was compiled without the required library, or loading the library failed.
     ffStrbufSetS(&result->wmProtocolName, FF_DISPLAYSERVER_PROTOCOL_WAYLAND);
 }
-
-#endif

src/detection/displayserver/wmde.c

@@ -1,8 +1,15 @@
 #include "displayServer.h"
-#include <dirent.h>
+#include "common/io.h"
+#include "common/properties.h"
+#include "common/parsing.h"
+#include "common/processing.h"
+
+#include <stdlib.h>
+#include <ctype.h>
 #include <string.h>
 #include <unistd.h>
-#include <ctype.h>
+#include <dirent.h>
+#include <sys/stat.h>
 
 static const char* parseEnv()
 {
@@ -40,6 +47,11 @@ static const char* parseEnv()
     if(getenv("TDE_FULL_SESSION") != NULL)
         return "Trinity";
 
+    if(
+        getenv("WAYLAND_DISPLAY") != NULL &&
+        ffFileExists("/mnt/wslg/", S_IFDIR)
+    ) return "WSLg";
+
     return NULL;
 }
 
@@ -48,8 +60,23 @@ static void applyPrettyNameIfWM(FFDisplayServerResult* result, const char* proce
     if(!ffStrSet(processName))
         return;
 
-    if(strcasecmp(processName, "kwin_wayland") == 0 || strcasecmp(processName, "kwin_x11") == 0 || strcasecmp(processName, "kwin") == 0)
-        ffStrbufSetS(&result->wmPrettyName, "KWin");
+    if(
+        strcasecmp(processName, "kwin_wayland") == 0 ||
+        strcasecmp(processName, "kwin_wayland_wrapper") == 0 ||
+        strcasecmp(processName, "kwin_x11") == 0 ||
+        strcasecmp(processName, "kwin_x11_wrapper") == 0 ||
+        strcasecmp(processName, "kwin") == 0
+    ) ffStrbufSetS(&result->wmPrettyName, "KWin");
+    else if(
+        strcasecmp(processName, "gnome-shell") == 0 ||
+        strcasecmp(processName, "gnome shell") == 0 ||
+        strcasecmp(processName, "gnome-session-binary") == 0 ||
+        strcasecmp(processName, "Mutter") == 0
+    ) ffStrbufSetS(&result->wmPrettyName, "Mutter");
+    else if(
+        strcasecmp(processName, "cinnamon-session") == 0 ||
+        strcasecmp(processName, "Muffin") == 0
+    ) ffStrbufSetS(&result->wmPrettyName, "Muffin");
     else if(strcasecmp(processName, "sway") == 0)
         ffStrbufSetS(&result->wmPrettyName, "Sway");
     else if(strcasecmp(processName, "weston") == 0)
@@ -64,10 +91,6 @@ static void applyPrettyNameIfWM(FFDisplayServerResult* result, const char* proce
         ffStrbufSetS(&result->wmPrettyName, "Marco");
     else if(strcasecmp(processName, "xmonad") == 0)
         ffStrbufSetS(&result->wmPrettyName, "XMonad");
-    else if(strcasecmp(processName, "gnome-session-binary") == 0 || strcasecmp(processName, "Mutter") == 0)
-        ffStrbufSetS(&result->wmPrettyName, "Mutter");
-    else if(strcasecmp(processName, "cinnamon-session") == 0 || strcasecmp(processName, "Muffin") == 0)
-        ffStrbufSetS(&result->wmPrettyName, "Muffin");
     else if( // WMs where the pretty name matches the process name
         strcasecmp(processName, "dwm") == 0 ||
         strcasecmp(processName, "bspwm") == 0 ||
@@ -98,7 +121,15 @@ static void getKDE(FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "plasmashell");
     ffStrbufSetS(&result->dePrettyName, "KDE Plasma");
-    ffParsePropFile("/usr/share/xsessions/plasma.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
+
+    ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/xsessions/plasma.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
+    if(result->deVersion.length == 0)
+        ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/xsessions/plasma5.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
+    if(result->deVersion.length == 0)
+        ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/wayland-sessions/plasmawayland.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
+    if(result->deVersion.length == 0)
+        ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/wayland-sessions/plasmawayland5.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
+
     applyBetterWM(result, getenv("KDEWM"));
 }
 
@@ -106,14 +137,14 @@ static void getGnome(FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "gnome-shell");
     ffStrbufSetS(&result->dePrettyName, "GNOME");
-    ffParsePropFile("/usr/share/gnome-shell/org.gnome.Extensions", "version :", &result->deVersion);
+    ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/gnome-shell/org.gnome.Extensions", "version :", &result->deVersion);
 }
 
 static void getCinnamon(FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "cinnamon");
     ffStrbufSetS(&result->dePrettyName, "Cinnamon");
-    ffParsePropFile("/usr/share/applications/cinnamon.desktop", "X-GNOME-Bugzilla-Version =", &result->deVersion);
+    ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/applications/cinnamon.desktop", "X-GNOME-Bugzilla-Version =", &result->deVersion);
 }
 
 static void getMate(const FFinstance* instance, FFDisplayServerResult* result)
@@ -130,7 +161,7 @@ static void getMate(const FFinstance* instance, FFDisplayServerResult* result)
     FFstrbuf micro;
     ffStrbufInit(&micro);
 
-    ffParsePropFileValues("/usr/share/mate-about/mate-version.xml", 3, (FFpropquery[]) {
+    ffParsePropFileValues(FASTFETCH_TARGET_DIR_USR"/share/mate-about/mate-version.xml", 3, (FFpropquery[]) {
         {"<platform>", &major},
         {"<minor>", &minor},
         {"<micro>", &micro}
@@ -159,7 +190,7 @@ static void getXFCE4(const FFinstance* instance, FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "xfce4-session");
     ffStrbufSetS(&result->dePrettyName, "Xfce4");
-    ffParsePropFile("/usr/share/gtk-doc/html/libxfce4ui/index.html", "<div><p class=\"releaseinfo\">Version", &result->deVersion);
+    ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/gtk-doc/html/libxfce4ui/index.html", "<div><p class=\"releaseinfo\">Version", &result->deVersion);
 
     if(result->deVersion.length == 0 && instance->config.allowSlowOperations)
     {
@@ -180,12 +211,12 @@ static void getLXQt(const FFinstance* instance, FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "lxqt-session");
     ffStrbufSetS(&result->dePrettyName, "LXQt");
-    ffParsePropFile("/usr/lib/pkgconfig/lxqt.pc", "Version:", &result->deVersion);
+    ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/lib/pkgconfig/lxqt.pc", "Version:", &result->deVersion);
 
     if(result->deVersion.length == 0)
-        ffParsePropFile("/usr/share/cmake/lxqt/lxqt-config.cmake", "set ( LXQT_VERSION", &result->deVersion);
+        ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/cmake/lxqt/lxqt-config.cmake", "set ( LXQT_VERSION", &result->deVersion);
     if(result->deVersion.length == 0)
-        ffParsePropFile("/usr/share/cmake/lxqt/lxqt-config-version.cmake", "set ( PACKAGE_VERSION", &result->deVersion);
+        ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/cmake/lxqt/lxqt-config-version.cmake", "set ( PACKAGE_VERSION", &result->deVersion);
 
     if(result->deVersion.length == 0 && instance->config.allowSlowOperations)
     {
@@ -197,7 +228,7 @@ static void getLXQt(const FFinstance* instance, FFDisplayServerResult* result)
         });
 
         result->deVersion.length = 0; //don't set '\0' byte
-        ffGetPropValueFromLines(result->deVersion.chars , "liblxqt", &result->deVersion);
+        ffParsePropLines(result->deVersion.chars , "liblxqt", &result->deVersion);
     }
 
     FFstrbuf wmProcessNameBuffer;
@@ -321,7 +352,7 @@ static void getFromProcDir(const FFinstance* instance, FFDisplayServerResult* re
 
         //Don't check for processes not owend by the current user.
         ffStrbufAppendS(&procPath, "/loginuid");
-        ffGetFileContent(procPath.chars, &loginuid);
+        ffReadFileBuffer(procPath.chars, &loginuid);
         if(ffStrbufComp(&userID, &loginuid) != 0)
         {
             ffStrbufSubstrBefore(&procPath, procPathLength);
@@ -332,7 +363,7 @@ static void getFromProcDir(const FFinstance* instance, FFDisplayServerResult* re
 
         //We check the cmdline for the process name, because it is not trimmed.
         ffStrbufAppendS(&procPath, "/cmdline");
-        ffGetFileContent(procPath.chars, &processName);
+        ffReadFileBuffer(procPath.chars, &processName);
         ffStrbufSubstrBeforeFirstC(&processName, '\0'); //Trim the arguments
         ffStrbufSubstrAfterLastC(&processName, '/');
 
@@ -363,7 +394,7 @@ void ffdsDetectWMDE(const FFinstance* instance, FFDisplayServerResult* result)
         getWMProtocolNameFromEnv(result);
 
     //We don't want to detect anything in TTY
-    //This can't happen if a X11 connection succeeded, so we don't need to clear wmProcessName
+    //This can't happen if a connection succeeded, so we don't need to clear wmProcessName
     if(ffStrbufIgnCaseCompS(&result->wmProtocolName, FF_DISPLAYSERVER_PROTOCOL_TTY) == 0)
         return;
 

src/detection/displayserver/xcb.c

@@ -1,8 +1,10 @@
 #include "displayServer.h"
 
 #ifdef FF_HAVE_XCB
-#include <xcb/xcb.h>
+#include "common/library.h"
+#include <stdlib.h>
 #include <string.h>
+#include <xcb/xcb.h>
 
 typedef struct XcbPropertyData
 {
@@ -60,7 +62,7 @@ static void* xcbGetProperty(XcbPropertyData* data, xcb_connection_t* connection,
 
 static void xcbDetectWMfromEWMH(XcbPropertyData* data, xcb_connection_t* connection, xcb_window_t rootWindow, FFDisplayServerResult* result)
 {
-    if(result->wmProcessName.length > 0)
+    if(result->wmProcessName.length > 0 || ffStrbufCompS(&result->wmProtocolName, FF_DISPLAYSERVER_PROTOCOL_WAYLAND) == 0)
         return;
 
     xcb_window_t* wmWindow = (xcb_window_t*) xcbGetProperty(data, connection, rootWindow, "_NET_SUPPORTING_WM_CHECK");
@@ -89,7 +91,7 @@ static void xcbDetectWMfromEWMH(XcbPropertyData* data, xcb_connection_t* connect
 
 void ffdsConnectXcb(const FFinstance* instance, FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(xcb, instance->config.libXcb, , "libxcb.so", "libxcb.so.1")
+    FF_LIBRARY_LOAD(xcb, instance->config.libXcb, , "libxcb.so", 2)
     FF_LIBRARY_LOAD_SYMBOL(xcb, xcb_connect,)
     FF_LIBRARY_LOAD_SYMBOL(xcb, xcb_get_setup,)
     FF_LIBRARY_LOAD_SYMBOL(xcb, xcb_setup_roots_iterator,)
@@ -213,15 +215,15 @@ static bool xcbRandrHandleCrtc(XcbRandrData* data, xcb_randr_crtc_t crtc)
         return false;
 
     bool res = xcbRandrHandleMode(data, crtcInfoReply->mode);
-
-    free(crtcInfoReply);
-
-    return res ? true : ffdsAppendResolution(
+    res = res ? true : ffdsAppendResolution(
         data->result,
         (uint32_t) crtcInfoReply->width,
         (uint32_t) crtcInfoReply->height,
         data->defaultRefreshRate
     );
+
+    free(crtcInfoReply);
+    return res;
 }
 
 static bool xcbRandrHandleOutput(XcbRandrData* data, xcb_randr_output_t output)
@@ -324,7 +326,7 @@ static void xcbRandrHandleScreen(XcbRandrData* data, xcb_screen_t* screen)
 
 void ffdsConnectXcbRandr(const FFinstance* instance, FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(xcbRandr, instance->config.libXcbRandr, , "libxcb-randr.so", "libxcb-randr.so.0")
+    FF_LIBRARY_LOAD(xcbRandr, instance->config.libXcbRandr, , "libxcb-randr.so", 1)
     FF_LIBRARY_LOAD_SYMBOL(xcbRandr, xcb_connect,)
     FF_LIBRARY_LOAD_SYMBOL(xcbRandr, xcb_get_setup,)
     FF_LIBRARY_LOAD_SYMBOL(xcbRandr, xcb_setup_roots_iterator,)

src/detection/displayserver/xlib.c

@@ -1,6 +1,8 @@
 #include "displayServer.h"
 
 #ifdef FF_HAVE_X11
+#include "common/library.h"
+#include "common/parsing.h"
 #include <X11/Xlib.h>
 
 typedef struct X11PropertyData
@@ -34,7 +36,7 @@ static unsigned char* x11GetProperty(X11PropertyData* data, Display* display, Wi
 
 static void x11DetectWMFromEWMH(X11PropertyData* data, Display* display, FFDisplayServerResult* result)
 {
-    if(result->wmProcessName.length > 0)
+    if(result->wmProcessName.length > 0 || ffStrbufCompS(&result->wmProtocolName, FF_DISPLAYSERVER_PROTOCOL_WAYLAND) == 0)
         return;
 
     Window* wmWindow = (Window*) x11GetProperty(data, display, DefaultRootWindow(display), "_NET_SUPPORTING_WM_CHECK");
@@ -53,7 +55,7 @@ static void x11DetectWMFromEWMH(X11PropertyData* data, Display* display, FFDispl
 
 void ffdsConnectXlib(const FFinstance* instance, FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(x11, instance->config.libX11, , "libX11.so", "libX11.so.6", "libX11-xcb.so", "libX11-xcb.so.1")
+    FF_LIBRARY_LOAD(x11, instance->config.libX11, , "libX11.so", 7, "libX11-xcb.so", 2)
     FF_LIBRARY_LOAD_SYMBOL(x11, XOpenDisplay,)
     FF_LIBRARY_LOAD_SYMBOL(x11, XCloseDisplay,)
 
@@ -161,15 +163,15 @@ static bool xrandrHandleCrtc(XrandrData* data, RRCrtc crtc)
         return false;
 
     bool res = xrandrHandleMode(data, crtcInfo->mode);
-
-    data->ffXRRFreeCrtcInfo(crtcInfo);
-
-    return res ? true : ffdsAppendResolution(
+    res = res ? true : ffdsAppendResolution(
         data->result,
         (uint32_t) crtcInfo->width,
         (uint32_t) crtcInfo->height,
         data->defaultRefreshRate
     );
+
+    data->ffXRRFreeCrtcInfo(crtcInfo);
+    return res;
 }
 
 static bool xrandrHandleOutput(XrandrData* data, RROutput output)
@@ -257,7 +259,7 @@ static void xrandrHandleScreen(XrandrData* data, Screen* screen)
 
 void ffdsConnectXrandr(const FFinstance* instance, FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(xrandr, instance->config.libXrandr, , "libXrandr.so", "libXrandr.so.2")
+    FF_LIBRARY_LOAD(xrandr, instance->config.libXrandr, , "libXrandr.so", 3)
 
     FF_LIBRARY_LOAD_SYMBOL(xrandr, XOpenDisplay,)
     FF_LIBRARY_LOAD_SYMBOL(xrandr, XCloseDisplay,)

src/detection/gtk.c

@@ -1,4 +1,8 @@
 #include "fastfetch.h"
+#include "detection/gtk.h"
+#include "common/properties.h"
+#include "common/settings.h"
+#include "detection/displayserver.h"
 
 #include <pthread.h>
 
@@ -10,7 +14,7 @@ static inline bool allPropertiesSet(FFGTKResult* result)
         result->font.length > 0;
 }
 
-static inline void applyGTKDConfSettings(FFGTKResult* result, const char* themeName, const char* iconsName, const char* fontName, const char* cursorTheme, int cursorSize)
+static inline void applyGTKSettings(FFGTKResult* result, const char* themeName, const char* iconsName, const char* fontName, const char* cursorTheme, int cursorSize)
 {
     if(result->theme.length == 0)
         ffStrbufAppendS(&result->theme, themeName);
@@ -28,7 +32,7 @@ static inline void applyGTKDConfSettings(FFGTKResult* result, const char* themeN
         ffStrbufAppendF(&result->cursorSize, "%i", cursorSize);
 }
 
-static void detectGTKFromDConf(FFinstance* instance, FFGTKResult* result)
+static void detectGTKFromSettings(FFinstance* instance, FFGTKResult* result)
 {
     static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 
@@ -45,7 +49,7 @@ static void detectGTKFromDConf(FFinstance* instance, FFGTKResult* result)
     if(init)
     {
         pthread_mutex_unlock(&mutex);
-        applyGTKDConfSettings(result, themeName, iconsName, fontName, cursorTheme, cursorSize);
+        applyGTKSettings(result, themeName, iconsName, fontName, cursorTheme, cursorSize);
         return;
     }
 
@@ -53,7 +57,15 @@ static void detectGTKFromDConf(FFinstance* instance, FFGTKResult* result)
 
     const FFDisplayServerResult* wmde = ffConnectDisplayServer(instance);
 
-    if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Cinnamon") == 0)
+    if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Xfce") == 0 || ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Xfce4") == 0)
+    {
+        themeName = ffSettingsGetXFConf(instance, "xsettings", "/Net/ThemeName", FF_VARIANT_TYPE_STRING).strValue;
+        iconsName = ffSettingsGetXFConf(instance, "xsettings", "/Net/IconThemeName", FF_VARIANT_TYPE_STRING).strValue;
+        fontName = ffSettingsGetXFConf(instance, "xsettings", "/Gtk/FontName", FF_VARIANT_TYPE_STRING).strValue;
+        cursorTheme = ffSettingsGetXFConf(instance, "xsettings", "/Gtk/CursorThemeName", FF_VARIANT_TYPE_STRING).strValue;
+        cursorSize = ffSettingsGetXFConf(instance, "xsettings", "/Gtk/CursorThemeSize", FF_VARIANT_TYPE_INT).intValue;
+    }
+    else if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Cinnamon") == 0)
     {
         themeName = ffSettingsGet(instance, "/org/cinnamon/desktop/interface/gtk-theme", "org.cinnamon.desktop.interface", NULL, "gtk-theme", FF_VARIANT_TYPE_STRING).strValue;
         iconsName = ffSettingsGet(instance, "/org/cinnamon/desktop/interface/icon-theme", "org.cinnamon.desktop.interface", NULL, "icon-theme", FF_VARIANT_TYPE_STRING).strValue;
@@ -69,26 +81,17 @@ static void detectGTKFromDConf(FFinstance* instance, FFGTKResult* result)
         cursorTheme = ffSettingsGet(instance, "/org/mate/peripherals-mouse/cursor-theme", "org.mate.peripherals-mouse", NULL, "cursor-theme", FF_VARIANT_TYPE_STRING).strValue;
         cursorSize = ffSettingsGet(instance, "/org/mate/peripherals-mouse/cursor-size", "org.mate.peripherals-mouse", NULL, "cursor-size", FF_VARIANT_TYPE_INT).intValue;
     }
-
-    //Fallback + Gnome impl
-
-    if(themeName == NULL)
+    else if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Gnome") == 0 || ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Unity") == 0 || ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Budgie") == 0)
+    {
         themeName = ffSettingsGet(instance, "/org/gnome/desktop/interface/gtk-theme", "org.gnome.desktop.interface", NULL, "gtk-theme", FF_VARIANT_TYPE_STRING).strValue;
-
-    if(iconsName == NULL)
         iconsName = ffSettingsGet(instance, "/org/gnome/desktop/interface/icon-theme", "org.gnome.desktop.interface", NULL, "icon-theme", FF_VARIANT_TYPE_STRING).strValue;
-
-    if(fontName == NULL)
         fontName = ffSettingsGet(instance, "/org/gnome/desktop/interface/font-name", "org.gnome.desktop.interface", NULL, "font-name", FF_VARIANT_TYPE_STRING).strValue;
-
-    if(cursorTheme == NULL)
         cursorTheme = ffSettingsGet(instance, "/org/gnome/desktop/interface/cursor-theme", "org.gnome.desktop.interface", NULL, "cursor-theme", FF_VARIANT_TYPE_STRING).strValue;
-
-    if(cursorSize <= 0)
         cursorSize = ffSettingsGet(instance, "/org/gnome/desktop/interface/cursor-size", "org.gnome.desktop.interface", NULL, "cursor-size", FF_VARIANT_TYPE_INT).intValue;
+    }
 
     pthread_mutex_unlock(&mutex);
-    applyGTKDConfSettings(result, themeName, iconsName, fontName, cursorTheme, cursorSize);
+    applyGTKSettings(result, themeName, iconsName, fontName, cursorTheme, cursorSize);
 }
 
 static void detectGTKFromConfigFile(const char* filename, FFGTKResult* result)
@@ -104,15 +107,10 @@ static void detectGTKFromConfigFile(const char* filename, FFGTKResult* result)
 
 static void detectGTKFromConfigDir(FFstrbuf* configDir, const char* version, FFGTKResult* result)
 {
-    //In case of an empty env variable
-    ffStrbufTrim(configDir, ' ');
-    if(configDir->length == 0)
-        return;
-
     uint32_t configDirLength = configDir->length;
 
     // <configdir>/gtk-<version>.0/settings.ini
-    ffStrbufAppendS(configDir, "/gtk-");
+    ffStrbufAppendS(configDir, "gtk-");
     ffStrbufAppendS(configDir, version);
     ffStrbufAppendS(configDir, ".0/settings.ini");
     detectGTKFromConfigFile(configDir->chars, result);
@@ -121,7 +119,7 @@ static void detectGTKFromConfigDir(FFstrbuf* configDir, const char* version, FFG
         return;
 
     // <configdir>/gtk-<version>.0/gtkrc
-    ffStrbufAppendS(configDir, "/gtk-");
+    ffStrbufAppendS(configDir, "gtk-");
     ffStrbufAppendS(configDir, version);
     ffStrbufAppendS(configDir, ".0/gtkrc");
     detectGTKFromConfigFile(configDir->chars, result);
@@ -130,7 +128,7 @@ static void detectGTKFromConfigDir(FFstrbuf* configDir, const char* version, FFG
         return;
 
     // <configdir>/gtkrc-<version>.0
-    ffStrbufAppendS(configDir, "/gtkrc-");
+    ffStrbufAppendS(configDir, "gtkrc-");
     ffStrbufAppendS(configDir, version);
     ffStrbufAppendS(configDir, ".0");
     detectGTKFromConfigFile(configDir->chars, result);
@@ -139,66 +137,37 @@ static void detectGTKFromConfigDir(FFstrbuf* configDir, const char* version, FFG
         return;
 
     // <configdir>/.gtkrc-<version>.0
-    ffStrbufAppendS(configDir, "/.gtkrc-");
+    ffStrbufAppendS(configDir, ".gtkrc-");
     ffStrbufAppendS(configDir, version);
     ffStrbufAppendS(configDir, ".0");
     detectGTKFromConfigFile(configDir->chars, result);
     ffStrbufSubstrBefore(configDir, configDirLength);
 }
 
-static void detectGTK(FFinstance* instance, const char* version, const char* envVariable, FFGTKResult* result)
+static void detectGTK(FFinstance* instance, const char* version, FFGTKResult* result)
 {
-    FFstrbuf buffer;
-    ffStrbufInitA(&buffer, 128);
-
-    // From ENV: GTK*_RC_FILES
-
-    ffStrbufSetS(&buffer, getenv(envVariable));
-    uint32_t startIndex = 0;
-    while (startIndex < buffer.length)
-    {
-        uint32_t colonIndex = ffStrbufNextIndexC(&buffer, startIndex, ':');
-        buffer.chars[colonIndex] = '\0';
-
-        detectGTKFromConfigFile(buffer.chars + startIndex, result);
-        if(allPropertiesSet(result))
-        {
-            ffStrbufDestroy(&buffer);
-            return;
-        }
-
-        startIndex = colonIndex + 1;
-    }
-
-    //From DConf / GSettings
-
-    detectGTKFromDConf(instance, result);
+    //Mate, Cinnamon and Gnome use dconf to save theme config
+    //On other DEs, this will do nothing
+    detectGTKFromSettings(instance, result);
     if(allPropertiesSet(result))
-    {
-        ffStrbufDestroy(&buffer);
         return;
-    }
-
-    //From config dirs
 
     //We need to do this because we use multiple threads on configDirs
-    FFstrbuf baseDirCopy;
-    ffStrbufInitA(&baseDirCopy, 64);
+    FFstrbuf baseDir;
+    ffStrbufInitA(&baseDir, 64);
 
     for(uint32_t i = 0; i < instance->state.configDirs.length; i++)
     {
-        FFstrbuf* baseDir = (FFstrbuf*) ffListGet(&instance->state.configDirs, i);
-        ffStrbufSet(&baseDirCopy, baseDir);
-        detectGTKFromConfigDir(&baseDirCopy, version, result);
+        ffStrbufSet(&baseDir, ffListGet(&instance->state.configDirs, i));
+        detectGTKFromConfigDir(&baseDir, version, result);
         if(allPropertiesSet(result))
             break;
     }
 
-    ffStrbufDestroy(&baseDirCopy);
-    ffStrbufDestroy(&buffer);
+    ffStrbufDestroy(&baseDir);
 }
 
-#define FF_CALCULATE_GTK_IMPL(version) \
+#define FF_DETECT_GTK_IMPL(version) \
     static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; \
     static FFGTKResult result; \
     static bool init = false; \
@@ -213,23 +182,23 @@ static void detectGTK(FFinstance* instance, const char* version, const char* env
     ffStrbufInit(&result.font); \
     ffStrbufInit(&result.cursor); \
     ffStrbufInit(&result.cursorSize); \
-    detectGTK(instance, #version, "GTK"#version"_RC_FILES", &result); \
+    detectGTK(instance, #version, &result); \
     pthread_mutex_unlock(&mutex); \
     return &result;
 
 const FFGTKResult* ffDetectGTK2(FFinstance* instance)
 {
-    FF_CALCULATE_GTK_IMPL(2)
+    FF_DETECT_GTK_IMPL(2)
 }
 
 const FFGTKResult* ffDetectGTK3(FFinstance* instance)
 {
-    FF_CALCULATE_GTK_IMPL(3)
+    FF_DETECT_GTK_IMPL(3)
 }
 
 const FFGTKResult* ffDetectGTK4(FFinstance* instance)
 {
-    FF_CALCULATE_GTK_IMPL(4)
+    FF_DETECT_GTK_IMPL(4)
 }
 
 #undef FF_CALCULATE_GTK_IMPL

src/detection/gtk.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_gtk
+#define FF_INCLUDED_detection_gtk
+
+#include "fastfetch.h"
+
+typedef struct FFGTKResult
+{
+    FFstrbuf theme;
+    FFstrbuf icons;
+    FFstrbuf font;
+    FFstrbuf cursor;
+    FFstrbuf cursorSize;
+} FFGTKResult;
+
+const FFGTKResult* ffDetectGTK2(FFinstance* instance);
+const FFGTKResult* ffDetectGTK4(FFinstance* instance);
+const FFGTKResult* ffDetectGTK3(FFinstance* instance);
+
+#endif

src/detection/media.c

@@ -1,11 +1,15 @@
 #include "fastfetch.h"
+#include "detection/media.h"
 
 #include <string.h>
 #include <pthread.h>
 
 #define FF_DBUS_MPRIS_PREFIX "org.mpris.MediaPlayer2."
+#define FF_DBUS_TIMEOUT_MILLISECONDS 35
 
 #ifdef FF_HAVE_DBUS
+#include "common/library.h"
+#include "common/parsing.h"
 #include <dbus/dbus.h>
 
 #define FF_DBUS_ITER_CONTINUE(iterator) \
@@ -68,8 +72,11 @@ static bool getValue(DBusMessageIter* iter, FFstrbuf* result, DBusData* data)
 
     while(true)
     {
-        if((foundAValue = getValue(&subIter, result, data)))
+        if(getValue(&subIter, result, data))
+        {
+            foundAValue = true;
             ffStrbufAppendS(result, ", ");
+        }
 
         FF_DBUS_ITER_CONTINUE(subIter);
     }
@@ -83,7 +90,7 @@ static bool getValue(DBusMessageIter* iter, FFstrbuf* result, DBusData* data)
 static DBusMessage* getReply(DBusMessage* request, DBusData* data)
 {
     DBusPendingCall* pendingCall = NULL;
-    dbus_bool_t succesfull = data->ffdbus_connection_send_with_reply(data->connection, request, &pendingCall, DBUS_TIMEOUT_USE_DEFAULT);
+    dbus_bool_t succesfull = data->ffdbus_connection_send_with_reply(data->connection, request, &pendingCall, FF_DBUS_TIMEOUT_MILLISECONDS);
     data->ffdbus_message_unref(request);
     if(!succesfull || pendingCall == NULL)
         return NULL;
@@ -208,6 +215,7 @@ static bool getBusProperties(const char* busName, FFMediaResult* result, DBusDat
     {
         ffStrbufClear(&result->artist);
         ffStrbufClear(&result->album);
+        ffStrbufClear(&result->url);
         return false;
     }
 
@@ -284,7 +292,7 @@ static void getMedia(FFinstance* instance, FFMediaResult* result)
 {
     DBusData data;
 
-    FF_LIBRARY_LOAD(dbus, instance->config.libDBus, , "libdbus-1.so", "libdbus-1.so.3");
+    FF_LIBRARY_LOAD(dbus, instance->config.libDBus, , "libdbus-1.so", 4);
     FF_LIBRARY_LOAD_SYMBOL(dbus, dbus_bus_get,)
     FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_message_new_method_call, dbus_message_new_method_call,)
     FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_message_iter_init, dbus_message_iter_init,)

src/detection/media.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_media
+#define FF_INCLUDED_detection_media
+
+#include "fastfetch.h"
+
+typedef struct FFMediaResult
+{
+    FFstrbuf busNameShort; //e.g. plasma-browser-integration
+    FFstrbuf player; // e.g. Google Chrome
+    FFstrbuf song;
+    FFstrbuf artist;
+    FFstrbuf album;
+    FFstrbuf url;
+} FFMediaResult;
+
+const FFMediaResult* ffDetectMedia(FFinstance* instance);
+
+#endif

src/detection/os.c

@@ -1,15 +1,22 @@
 #include "fastfetch.h"
+#include "detection/os.h"
+#include "common/properties.h"
+#include "common/parsing.h"
 
+#include <string.h>
+#include <stdlib.h>
 #include <pthread.h>
 
-#if !defined(__ANDROID__)
+#if __ANDROID__
+    #include "common/settings.h"
+#else
 
-static void parseFile(const char* fileName, FFOSResult* result)
+static bool parseFile(const char* fileName, FFOSResult* result)
 {
-    if(result->name.length > 0 && result->prettyName.length > 0)
-        return;
+    if(result->id.length > 0 && result->name.length > 0 && result->prettyName.length > 0)
+        return true;
 
-    ffParsePropFileValues(fileName, 13, (FFpropquery[]) {
+    return ffParsePropFileValues(fileName, 13, (FFpropquery[]) {
         {"NAME =", &result->name},
         {"DISTRIB_DESCRIPTION =", &result->prettyName},
         {"PRETTY_NAME =", &result->prettyName},
@@ -26,9 +33,70 @@ static void parseFile(const char* fileName, FFOSResult* result)
     });
 }
 
+static void getUbuntuFlavour(FFOSResult* result)
+{
+    const char* xdgConfigDirs = getenv("XDG_CONFIG_DIRS");
+    if(!ffStrSet(xdgConfigDirs))
+        return;
+
+    if(strstr(xdgConfigDirs, "kde") != NULL || strstr(xdgConfigDirs, "plasma") != NULL)
+    {
+        ffStrbufSetS(&result->name, "Kubuntu");
+        ffStrbufSetS(&result->prettyName, "Kubuntu");
+        ffStrbufSetS(&result->id, "kubuntu");
+        ffStrbufSetS(&result->idLike, "ubuntu");
+        return;
+    }
+
+    if(strstr(xdgConfigDirs, "xfce") != NULL || strstr(xdgConfigDirs, "xubuntu") != NULL)
+    {
+        ffStrbufSetS(&result->name, "Xubuntu");
+        ffStrbufSetS(&result->prettyName, "Xubuntu");
+        ffStrbufSetS(&result->id, "xubuntu");
+        ffStrbufSetS(&result->idLike, "ubuntu");
+        return;
+    }
+
+    if(strstr(xdgConfigDirs, "lxde") != NULL || strstr(xdgConfigDirs, "lubuntu") != NULL)
+    {
+        ffStrbufSetS(&result->name, "Lubuntu");
+        ffStrbufSetS(&result->prettyName, "Lubuntu");
+        ffStrbufSetS(&result->id, "lubuntu");
+        ffStrbufSetS(&result->idLike, "ubuntu");
+        return;
+    }
+
+    if(strstr(xdgConfigDirs, "budgie") != NULL)
+    {
+        ffStrbufSetS(&result->name, "Ubuntu Budgie");
+        ffStrbufSetS(&result->prettyName, "Ubuntu Budgie");
+        ffStrbufSetS(&result->id, "ubuntu-budgie");
+        ffStrbufSetS(&result->idLike, "ubuntu");
+        return;
+    }
+
+    if(strstr(xdgConfigDirs, "mate") != NULL)
+    {
+        ffStrbufSetS(&result->name, "Ubuntu MATE");
+        ffStrbufSetS(&result->prettyName, "Ubuntu MATE");
+        ffStrbufSetS(&result->id, "ubuntu-mate");
+        ffStrbufSetS(&result->idLike, "ubuntu");
+        return;
+    }
+
+    if(strstr(xdgConfigDirs, "studio") != NULL)
+    {
+        ffStrbufSetS(&result->name, "Ubuntu Studio");
+        ffStrbufSetS(&result->prettyName, "Ubuntu Studio");
+        ffStrbufSetS(&result->id, "ubuntu-studio");
+        ffStrbufSetS(&result->idLike, "ubuntu");
+        return;
+    }
+}
+
 #endif
 
-const FFOSResult* ffDetectOS(FFinstance* instance)
+const FFOSResult* ffDetectOS(const FFinstance* instance)
 {
     static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
     static FFOSResult result;
@@ -62,12 +130,27 @@ const FFOSResult* ffDetectOS(FFinstance* instance)
     {
         parseFile(instance->config.osFile.chars, &result);
     }
+    else if(instance->config.escapeBedrock && parseFile(FASTFETCH_TARGET_DIR_ROOT"/bedrock/etc/bedrock-release", &result))
+    {
+        if(result.id.length == 0)
+            ffStrbufAppendS(&result.id, "bedrock");
+
+        if(result.name.length == 0)
+            ffStrbufAppendS(&result.name, "Bedrock");
+
+        if(result.prettyName.length == 0)
+            ffStrbufAppendS(&result.prettyName, "Bedrock Linux");
+    }
     else
     {
-        parseFile("/etc/os-release", &result);
-        parseFile("/usr/lib/os-release", &result);
-        parseFile("/etc/lsb-release", &result);
+        parseFile(FASTFETCH_TARGET_DIR_ROOT"/etc/os-release", &result);
+        parseFile(FASTFETCH_TARGET_DIR_USR"/lib/os-release", &result);
+        parseFile(FASTFETCH_TARGET_DIR_ROOT"/etc/lsb-release", &result);
     }
+
+    if(ffStrbufIgnCaseCompS(&result.id, "ubuntu") == 0)
+        getUbuntuFlavour(&result);
+
 #else
     ffStrbufSetS(&result.name, "Android");
     ffStrbufSetS(&result.id, "android");

src/detection/os.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_os
+#define FF_INCLUDED_detection_os
+
+#include "fastfetch.h"
+
+typedef struct FFOSResult
+{
+    FFstrbuf systemName;
+    FFstrbuf name;
+    FFstrbuf prettyName;
+    FFstrbuf id;
+    FFstrbuf idLike;
+    FFstrbuf variant;
+    FFstrbuf variantID;
+    FFstrbuf version;
+    FFstrbuf versionID;
+    FFstrbuf codename;
+    FFstrbuf buildID;
+    FFstrbuf architecture;
+} FFOSResult;
+
+const FFOSResult* ffDetectOS(const FFinstance* instance);
+
+#endif

src/detection/qt.c

@@ -1,8 +1,21 @@
 #include "fastfetch.h"
+#include "detection/qt.h"
+#include "common/properties.h"
+#include "detection/displayserver.h"
 
+#include <stdlib.h>
 #include <string.h>
 #include <pthread.h>
 
+static inline bool allValuesSet(const FFQtResult* result)
+{
+    return
+        result->widgetStyle.length > 0 &&
+        result->colorScheme.length > 0 &&
+        result->icons.length > 0 &&
+        result->font.length > 0;
+}
+
 typedef enum PlasmaCategory
 {
     PLASMA_CATEGORY_GENERAL,
@@ -11,9 +24,9 @@ typedef enum PlasmaCategory
     PLASMA_CATEGORY_OTHER
 } PlasmaCategory;
 
-static bool detectFromConfigFile(const FFstrbuf* filename, FFPlasmaResult* result)
+static bool detectPlasmaFromFile(const char* filename, FFQtResult* result)
 {
-    FILE* kdeglobals = fopen(filename->chars, "r");
+    FILE* kdeglobals = fopen(filename, "r");
     if(kdeglobals == NULL)
         return false;
 
@@ -42,20 +55,20 @@ static bool detectFromConfigFile(const FFstrbuf* filename, FFPlasmaResult* resul
         }
 
         if(category == PLASMA_CATEGORY_KDE && result->widgetStyle.length == 0)
-            ffGetPropValue(line, "widgetStyle =", &result->widgetStyle);
+            ffParsePropLine(line, "widgetStyle =", &result->widgetStyle);
         else if(category == PLASMA_CATEGORY_ICONS && result->icons.length == 0)
-            ffGetPropValue(line, "Theme =", &result->icons);
+            ffParsePropLine(line, "Theme =", &result->icons);
         else if(category == PLASMA_CATEGORY_GENERAL)
         {
             if(result->colorScheme.length == 0)
-                ffGetPropValue(line, "ColorScheme =", &result->colorScheme);
+                ffParsePropLine(line, "ColorScheme =", &result->colorScheme);
 
             if(result->font.length == 0)
-                ffGetPropValue(line, "font =", &result->font);
+                ffParsePropLine(line, "font =", &result->font);
 
             //Before plasma 5.23, "Font" was the key instead of "font". Since a lot of distros ship older versions, we test for both.
             if(result->font.length == 0)
-                ffGetPropValue(line, "Font =", &result->font);
+                ffParsePropLine(line, "Font =", &result->font);
         }
     }
 
@@ -67,10 +80,62 @@ static bool detectFromConfigFile(const FFstrbuf* filename, FFPlasmaResult* resul
     return true;
 }
 
-const FFPlasmaResult* ffDetectPlasma(FFinstance* instance)
+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);
+
+    for(uint32_t i = 0; i < instance->state.configDirs.length; i++)
+    {
+        ffStrbufSet(&baseDir, ffListGet(&instance->state.configDirs, i));
+        ffStrbufAppendS(&baseDir, "kdeglobals");
+
+        if(detectPlasmaFromFile(baseDir.chars, result))
+            foundAFile = true;
+
+        if(allValuesSet(result))
+        {
+            ffStrbufDestroy(&baseDir);
+            return;
+        }
+    }
+
+    ffStrbufDestroy(&baseDir);
+    if(!foundAFile)
+        return;
+
+    //In Plasma the default value is never set in the config file, but the whole key-value is discarded.
+    ///We must set these values by our self if the file exists (it always does here)
+    if(result->widgetStyle.length == 0)
+        ffStrbufAppendS(&result->widgetStyle, "Breeze");
+
+    if(result->colorScheme.length == 0)
+        ffStrbufAppendS(&result->colorScheme, "BreezeLight");
+
+    if(result->icons.length == 0)
+        ffStrbufAppendS(&result->icons, "Breeze");
+
+    if(result->font.length == 0)
+        ffStrbufAppendS(&result->font, "Noto Sans, 10");
+}
+
+static void detectLXQt(const FFinstance* instance, FFQtResult* result)
+{
+    ffParsePropFileConfigValues(instance, "lxqt/lxqt.conf", 3, (FFpropquery[]) {
+        {"style = ", &result->widgetStyle},
+        {"icon_theme = ", &result->icons},
+        {"font = ", &result->font}
+    });
+}
+
+const FFQtResult* ffDetectQt(FFinstance* instance)
+{
+    static FFQtResult result;
+
     static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-    static FFPlasmaResult result;
     static bool init = false;
     pthread_mutex_lock(&mutex);
     if(init)
@@ -86,57 +151,11 @@ const FFPlasmaResult* ffDetectPlasma(FFinstance* instance)
     ffStrbufInit(&result.font);
 
     const FFDisplayServerResult* wmde = ffConnectDisplayServer(instance);
-    if(ffStrbufIgnCaseCompS(&wmde->deProcessName, "plasmashell") != 0)
-    {
-        pthread_mutex_unlock(&mutex);
-        return &result;
-    }
 
-    bool foundAFile = false;
-
-    //We need to do this because we use multiple threads on configDirs
-    FFstrbuf baseDirCopy;
-    ffStrbufInitA(&baseDirCopy, 64);
-
-    for(uint32_t i = 0; i < instance->state.configDirs.length; i++)
-    {
-        FFstrbuf* baseDir = (FFstrbuf*) ffListGet(&instance->state.configDirs, i);
-
-        ffStrbufSet(&baseDirCopy, baseDir);
-        ffStrbufAppendS(&baseDirCopy, "/kdeglobals");
-
-        if(detectFromConfigFile(&baseDirCopy, &result))
-            foundAFile = true;
-
-        if(
-            result.widgetStyle.length > 0 &&
-            result.colorScheme.length > 0 &&
-            result.icons.length > 0 &&
-            result.font.length > 0
-        ) break;
-    }
-
-    ffStrbufDestroy(&baseDirCopy);
-
-    if(!foundAFile)
-    {
-        pthread_mutex_unlock(&mutex);
-        return &result;
-    }
-
-    //In Plasma the default value is never set in the config file, but the whole key-value is discarded.
-    ///We must set these values by our self if the file exists (it always does here)
-    if(result.widgetStyle.length == 0)
-        ffStrbufAppendS(&result.widgetStyle, "Breeze");
-
-    if(result.colorScheme.length == 0)
-        ffStrbufAppendS(&result.colorScheme, "BreezeLight");
-
-    if(result.icons.length == 0)
-        ffStrbufAppendS(&result.icons, "Breeze");
-
-    if(result.font.length == 0)
-        ffStrbufAppendS(&result.font, "Noto Sans, 10");
+    if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, "KDE Plasma") == 0)
+        detectPlasma(instance, &result);
+    else if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, "LXQt") == 0)
+        detectLXQt(instance, &result);
 
     pthread_mutex_unlock(&mutex);
     return &result;

src/detection/qt.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_qt
+#define FF_INCLUDED_detection_qt
+
+#include "fastfetch.h"
+
+typedef struct FFQtResult
+{
+    FFstrbuf widgetStyle;
+    FFstrbuf colorScheme;
+    FFstrbuf icons;
+    FFstrbuf font;
+} FFQtResult;
+
+const FFQtResult* ffDetectQt(FFinstance* instance);
+
+#endif

src/detection/temps.c

@@ -1,16 +1,15 @@
 #include "fastfetch.h"
+#include "detection/temps.h"
+#include "common/io.h"
 
+#include <string.h>
 #include <pthread.h>
 #include <dirent.h>
-#include <string.h>
 
 static bool isTempFile(const char* name)
 {
     return
-        name[0] == 't' &&
-        name[1] == 'e' &&
-        name[2] == 'm' &&
-        name[3] == 'p' &&
+        strncmp(name, "temp", 4) == 0 &&
         name[4] >= '0' &&
         name[4] <= '9' &&
         strncmp(name + 5, "_input", 6) == 0;
@@ -23,30 +22,42 @@ static bool parseHwmonDir(FFstrbuf* dir, FFTempValue* value)
         return false;
 
     uint32_t dirLength = dir->length;
+    value->value = 0.0 / 0.0; //use NaN as error value
+
+    FFstrbuf valueString;
+    ffStrbufInit(&valueString);
 
     struct dirent* dirent;
     while((dirent = readdir(dirp)) != NULL)
     {
-        if(isTempFile(dirent->d_name))
-        {
-            ffStrbufAppendS(dir, dirent->d_name);
-            ffGetFileContent(dir->chars, &value->value);
-            ffStrbufSubstrBefore(dir, dirLength);
-            break;
-        }
+        if(!isTempFile(dirent->d_name))
+            continue;
+
+        ffStrbufAppendS(dir, dirent->d_name);
+        ffReadFileBuffer(dir->chars, &valueString);
+        ffStrbufSubstrBefore(dir, dirLength);
+
+        //ffStrbufToDouble() returns NaN if the string couldn't be parsed
+        value->value = ffStrbufToDouble(&valueString);
+        if(value->value != value->value)
+            continue;
+
+        value->value /= 1000.0; //millidegrees to degrees
+        break;
     }
 
     closedir(dirp);
+    ffStrbufDestroy(&valueString);
 
-    if(value->value.length == 0)
+    if(value->value != value->value)
         return false;
 
     ffStrbufAppendS(dir, "name");
-    ffGetFileContent(dir->chars, &value->name);
+    ffReadFileBuffer(dir->chars, &value->name);
     ffStrbufSubstrBefore(dir, dirLength);
 
     ffStrbufAppendS(dir, "device/class");
-    ffGetFileContent(dir->chars, &value->deviceClass);
+    ffReadFileBuffer(dir->chars, &value->deviceClass);
     ffStrbufSubstrBefore(dir, dirLength);
 
     return value->name.length > 0 || value->deviceClass.length > 0;
@@ -95,12 +106,10 @@ const FFTempsResult* ffDetectTemps(const FFinstance* instance)
         FFTempValue* temp = ffListAdd(&result.values);
         ffStrbufInit(&temp->name);
         ffStrbufInit(&temp->deviceClass);
-        ffStrbufInit(&temp->value);
         if(!parseHwmonDir(&baseDir, temp))
         {
             ffStrbufDestroy(&temp->name);
             ffStrbufDestroy(&temp->deviceClass);
-            ffStrbufDestroy(&temp->value);
             --result.values.length;
         }
 

src/detection/temps.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_temps
+#define FF_INCLUDED_detection_temps
+
+#include "fastfetch.h"
+
+typedef struct FFTempValue
+{
+    FFstrbuf name;
+    FFstrbuf deviceClass;
+    double value;
+} FFTempValue;
+
+typedef struct FFTempsResult
+{
+    FFlist values; //List of FFTempValue
+} FFTempsResult;
+
+const FFTempsResult* ffDetectTemps(const FFinstance* instance);
+
+#endif

src/detection/terminalShell.c

@@ -1,7 +1,12 @@
 #include "fastfetch.h"
+#include "detection/terminalshell.h"
+#include "common/io.h"
+#include "common/parsing.h"
+#include "common/processing.h"
 
 #include <ctype.h>
 #include <string.h>
+#include <stdlib.h>
 #include <unistd.h>
 #include <pthread.h>
 
@@ -20,7 +25,7 @@ static void getProcessInformation(const char* pid, FFstrbuf* processName, FFstrb
     ffStrbufAppendS(&cmdlineFilePath, pid);
     ffStrbufAppendS(&cmdlineFilePath, "/cmdline");
 
-    ffGetFileContent(cmdlineFilePath.chars, exe);
+    ffReadFileBuffer(cmdlineFilePath.chars, exe);
     ffStrbufSubstrBeforeFirstC(exe, '\0'); //Trim the arguments
     ffStrbufTrimLeft(exe, '-'); //Happens in TTY
 
@@ -68,12 +73,13 @@ static void getTerminalShell(FFTerminalShellResult* result, const char* pid)
 
     //Common programs that are between terminal and own process, but are not the shell
     if(
-        strcasecmp(name, "sudo")   == 0 ||
-        strcasecmp(name, "su")     == 0 ||
-        strcasecmp(name, "doas")   == 0 ||
-        strcasecmp(name, "strace") == 0 ||
-        strcasecmp(name, "sshd")   == 0 ||
-        strcasecmp(name, "gdb")    == 0
+        strcasecmp(name, "sudo")          == 0 ||
+        strcasecmp(name, "su")            == 0 ||
+        strcasecmp(name, "doas")          == 0 ||
+        strcasecmp(name, "strace")        == 0 ||
+        strcasecmp(name, "sshd")          == 0 ||
+        strcasecmp(name, "gdb")           == 0 ||
+        strcasecmp(name, "guake-wrapped") == 0
     ) {
         getTerminalShell(result, ppid);
         return;
@@ -119,8 +125,17 @@ static void getTerminalFromEnv(FFTerminalShellResult* result)
         term = getenv("SSH_TTY");
 
     //Windows Terminal
-    if(!ffStrSet(term) && getenv("WT_SESSION") != NULL)
-        term = "Windows Terminal";
+    if(!ffStrSet(term) && (
+        getenv("WT_SESSION") != NULL ||
+        getenv("WT_PROFILE_ID") != NULL
+    )) term = "Windows Terminal";
+
+    //Termux
+    if(!ffStrSet(term) && (
+        getenv("TERMUX_VERSION") != NULL ||
+        getenv("TERMUX_MAIN_PACKAGE_FORMAT") != NULL ||
+        getenv("TMUX_TMPDIR") != NULL
+    )) term = "Termux";
 
     //Normal Terminal
     if(!ffStrSet(term))

src/detection/terminalshell.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_terminalshell
+#define FF_INCLUDED_detection_terminalshell
+
+#include "fastfetch.h"
+
+typedef struct FFTerminalShellResult
+{
+    FFstrbuf shellProcessName;
+    FFstrbuf shellExe;
+    const char* shellExeName; //pointer to a char in shellExe
+    FFstrbuf shellVersion;
+
+    FFstrbuf terminalProcessName;
+    FFstrbuf terminalExe;
+    const char* terminalExeName; //pointer to a char in terminalExe
+
+    FFstrbuf userShellExe;
+    const char* userShellExeName; //pointer to a char in userShellExe
+    FFstrbuf userShellVersion;
+} FFTerminalShellResult;
+
+const FFTerminalShellResult* ffDetectTerminalShell(FFinstance* instance);
+
+#endif

src/detection/title.c

@@ -0,0 +1,54 @@
+#include "fastfetch.h"
+#include "detection/title.h"
+
+#include <limits.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <netdb.h>
+
+const FFTitleResult* ffDetectTitle(const FFinstance* instance)
+{
+    static FFTitleResult result;
+
+    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+    static bool init = false;
+    pthread_mutex_lock(&mutex);
+    if(init)
+    {
+        pthread_mutex_unlock(&mutex);
+        return &result;
+    }
+    init = true;
+
+    ffStrbufInit(&result.userName);
+    ffStrbufAppendS(&result.userName, instance->state.passwd->pw_name);
+
+    ffStrbufInitA(&result.hostname, HOST_NAME_MAX);
+    ffStrbufAppendS(&result.hostname, instance->state.utsname.nodename);
+
+    ffStrbufInitA(&result.fqdn, HOST_NAME_MAX);
+
+    struct addrinfo hints = {0};
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_flags = AI_CANONNAME;
+
+    struct addrinfo* info = NULL;
+
+    if(getaddrinfo(result.hostname.chars, "80", &hints, &info) == 0)
+    {
+        struct addrinfo* current = info;
+        while(result.fqdn.length == 0 && current != NULL)
+        {
+            ffStrbufAppendS(&result.fqdn, current->ai_canonname);
+            current = current->ai_next;
+        }
+
+        freeaddrinfo(info);
+    }
+
+    if(result.fqdn.length == 0)
+        ffStrbufAppend(&result.fqdn, &result.hostname);
+
+    pthread_mutex_unlock(&mutex);
+    return &result;
+}

src/detection/title.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_title
+#define FF_INCLUDED_detection_title
+
+#include "fastfetch.h"
+
+typedef struct FFTitleResult
+{
+    FFstrbuf userName;
+    FFstrbuf hostname;
+    FFstrbuf fqdn; //Fully qualified domain name
+} FFTitleResult;
+
+const FFTitleResult* ffDetectTitle(const FFinstance* instance);
+
+#endif

src/detection/vulkan.c

@@ -0,0 +1,231 @@
+#include "fastfetch.h"
+#include "detection/vulkan.h"
+
+#include <pthread.h>
+
+#ifdef FF_HAVE_VULKAN
+#include "common/library.h"
+#include "common/io.h"
+#include "common/parsing.h"
+#include <stdlib.h>
+#include <vulkan/vulkan.h>
+
+static inline void applyVulkanVersion(uint32_t vulkanVersion, FFVersion* ffVersion)
+{
+    ffVersion->major = VK_VERSION_MAJOR(vulkanVersion);
+    ffVersion->minor = VK_VERSION_MINOR(vulkanVersion);
+    ffVersion->patch = VK_VERSION_PATCH(vulkanVersion);
+}
+
+static void applyDriverName(VkPhysicalDeviceDriverProperties* properties, FFstrbuf* result)
+{
+    if(!ffStrSet(properties->driverName))
+        return;
+
+    ffStrbufAppendS(result, properties->driverName);
+
+    if(!ffStrSet(properties->driverInfo))
+        return;
+
+    ffStrbufAppendS(result, " [");
+    ffStrbufAppendS(result, properties->driverInfo);
+    ffStrbufAppendC(result, ']');
+}
+
+static void detectVulkan(const FFinstance* instance, FFVulkanResult* result)
+{
+    FF_LIBRARY_LOAD(vulkan, instance->config.libVulkan, , "libvulkan.so", 2)
+    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkGetInstanceProcAddr,)
+    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkCreateInstance,)
+    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkDestroyInstance,)
+    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkEnumeratePhysicalDevices,)
+    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkGetPhysicalDeviceProperties,)
+
+    //Some drivers (nvdc) print messages to stdout
+    //and thats the best way i found to disable that
+    ffSuppressIO(true);
+
+    FFVersion instanceVersion = FF_VERSION_INIT;
+
+    //We need to get the function pointer this way, because it is only provided by vulkan 1.1 and higher.
+    //a dlsym would fail on 1.0 implementations
+    PFN_vkEnumerateInstanceVersion ffvkEnumerateInstanceVersion = (PFN_vkEnumerateInstanceVersion) ffvkGetInstanceProcAddr(NULL, "vkEnumerateInstanceVersion");
+    if(ffvkEnumerateInstanceVersion != NULL)
+    {
+        uint32_t version;
+        if(ffvkEnumerateInstanceVersion(&version) == VK_SUCCESS)
+            applyVulkanVersion(version, &instanceVersion);
+    }
+
+    const uint32_t projectVersion = VK_MAKE_VERSION(
+        FASTFETCH_PROJECT_VERSION_MAJOR,
+        FASTFETCH_PROJECT_VERSION_MINOR,
+        FASTFETCH_PROJECT_VERSION_PATCH
+    );
+
+    //We need to request 1.2 to get physicalDeviceDriverProperties
+    uint32_t requestedVkVersion = VK_API_VERSION_1_0;
+    if(instanceVersion.minor >= 2)
+        requestedVkVersion = VK_API_VERSION_1_2;
+
+    const VkApplicationInfo applicationInfo = {
+        .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+        .pNext = NULL,
+        .pApplicationName = FASTFETCH_PROJECT_NAME,
+        .applicationVersion = projectVersion,
+        .pEngineName = "vulkanPrintGPUs",
+        .engineVersion = projectVersion,
+        .apiVersion = requestedVkVersion
+    };
+
+    const VkInstanceCreateInfo instanceCreateInfo = {
+        .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+        .pNext = NULL,
+        .pApplicationInfo = &applicationInfo,
+        .enabledLayerCount = 0,
+        .ppEnabledLayerNames = NULL,
+        .enabledExtensionCount = 0,
+        .ppEnabledExtensionNames = NULL,
+        .flags = 0
+    };
+
+    VkInstance vkInstance;
+    if(ffvkCreateInstance(&instanceCreateInfo, NULL, &vkInstance) != VK_SUCCESS)
+    {
+        dlclose(vulkan);
+        ffSuppressIO(false);
+        return;
+    }
+
+
+    //if instance creation succeeded, but vkEnumerateInstanceVersion didn't, this means we are running against a vulkan 1.0 implementation
+    //explicitly set this version, if no device is found, so we still have at least this info
+    if(instanceVersion.major == 0 && instanceVersion.minor == 0 && instanceVersion.patch == 0)
+        instanceVersion.major = 1;
+
+    uint32_t physicalDeviceCount;
+    if(ffvkEnumeratePhysicalDevices(vkInstance, &physicalDeviceCount, NULL) != VK_SUCCESS)
+    {
+        ffvkDestroyInstance(vkInstance, NULL);
+        dlclose(vulkan);
+        ffSuppressIO(false);
+        return;
+    }
+
+    VkPhysicalDevice* physicalDevices = malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount);
+    if(ffvkEnumeratePhysicalDevices(vkInstance, &physicalDeviceCount, physicalDevices) != VK_SUCCESS)
+    {
+        free(physicalDevices);
+        ffvkDestroyInstance(vkInstance, NULL);
+        dlclose(vulkan);
+        ffSuppressIO(false);
+        return;
+    }
+
+    PFN_vkGetPhysicalDeviceProperties2 ffvkGetPhysicalDeviceProperties2 = (PFN_vkGetPhysicalDeviceProperties2) ffvkGetInstanceProcAddr(vkInstance, "vkGetPhysicalDeviceProperties2");
+
+    FFVersion maxDeviceApiVersion = FF_VERSION_INIT;
+    FFVersion maxDeviceConformanceVersion = FF_VERSION_INIT;
+
+    for(uint32_t i = 0; i < physicalDeviceCount; i++)
+    {
+        //Get device properties.
+        //On VK 1.2 and up, we use vkGetPhysicalDeviceProperties2, so we can put VkPhysicalDeviceDriverProperties in the pNext chain.
+        //This is required to get the driver name and conformance version.
+
+        VkPhysicalDeviceDriverProperties driverProperties;
+        driverProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
+        driverProperties.pNext = NULL;
+        driverProperties.driverName[0] = '\0';
+        driverProperties.conformanceVersion = (VkConformanceVersion) {0, 0, 0, 0};
+
+        VkPhysicalDeviceProperties2 physicalDeviceProperties;
+        physicalDeviceProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
+        physicalDeviceProperties.pNext = &driverProperties;
+
+        if(ffvkGetPhysicalDeviceProperties2 != NULL)
+            ffvkGetPhysicalDeviceProperties2(physicalDevices[i], &physicalDeviceProperties);
+        else
+            ffvkGetPhysicalDeviceProperties(physicalDevices[i], &physicalDeviceProperties.properties);
+
+        //If the device api version is higher than the current highest device api version, overwrite it
+        //In this case, also use the current device driver name as the shown driver name
+
+        FFVersion deviceAPIVersion = FF_VERSION_INIT;
+        applyVulkanVersion(physicalDeviceProperties.properties.apiVersion, &deviceAPIVersion);
+        if(ffVersionCompare(&deviceAPIVersion, &maxDeviceApiVersion) > 0)
+        {
+            maxDeviceApiVersion = deviceAPIVersion;
+            applyDriverName(&driverProperties, &result->driver);
+        }
+
+        //If the device conformance version is higher than the current highest device conformance version, overwrite it
+
+        FFVersion deviceConformanceVersion = FF_VERSION_INIT;
+        deviceConformanceVersion.major = driverProperties.conformanceVersion.major;
+        deviceConformanceVersion.minor = driverProperties.conformanceVersion.minor;
+        deviceConformanceVersion.patch = driverProperties.conformanceVersion.patch;
+
+        if(ffVersionCompare(&deviceConformanceVersion, &maxDeviceConformanceVersion) > 0)
+            maxDeviceConformanceVersion = deviceConformanceVersion;
+
+        //Add the device to the list of devices shown by the GPU module
+
+        //We don't want softare rasterizers to show up as physical gpu
+        if(physicalDeviceProperties.properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU)
+            continue;
+
+        FFGPUResult* gpu = ffListAdd(&result->devices);
+        ffStrbufInit(&gpu->vendor);
+        ffStrbufInit(&gpu->name);
+        ffStrbufInit(&gpu->driver);
+        gpu->temperature = 0.0 / 0.0; //NaN, no way to detect temperature using vulkan
+        ffStrbufAppendS(&gpu->name, physicalDeviceProperties.properties.deviceName);
+    }
+
+    //If the highest device version is lower than the instance version, use it as our vulkan version
+    //otherwise the instance version is the vulkan version
+    if(ffVersionCompare(&instanceVersion, &maxDeviceApiVersion) > 0)
+        ffVersionToPretty(&maxDeviceApiVersion, &result->apiVersion);
+    else
+        ffVersionToPretty(&instanceVersion, &result->apiVersion);
+
+    //Use the highest device conformace version as our conformance version
+    ffVersionToPretty(&maxDeviceConformanceVersion, &result->conformanceVersion);
+
+    free(physicalDevices);
+    ffvkDestroyInstance(vkInstance, NULL);
+    dlclose(vulkan);
+    ffSuppressIO(false);
+}
+
+#endif
+
+const FFVulkanResult* ffDetectVulkan(const FFinstance* instance)
+{
+    static FFVulkanResult result;
+    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+    static bool init = false;
+
+    pthread_mutex_lock(&mutex);
+    if(init)
+    {
+        pthread_mutex_unlock(&mutex);
+        return &result;
+    }
+    init = true;
+
+    ffStrbufInit(&result.driver);
+    ffStrbufInit(&result.apiVersion);
+    ffStrbufInit(&result.conformanceVersion);
+    ffListInit(&result.devices, sizeof(FFGPUResult));
+
+    #ifdef FF_HAVE_VULKAN
+        detectVulkan(instance, &result);
+    #else
+        FF_UNUSED(instance);
+    #endif
+
+    pthread_mutex_unlock(&mutex);
+    return &result;
+}

src/detection/vulkan.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_vulkan
+#define FF_INCLUDED_detection_vulkan
+
+#include "fastfetch.h"
+
+typedef struct FFGPUResult
+{
+    FFstrbuf vendor;
+    FFstrbuf name;
+    FFstrbuf driver;
+    double temperature;
+} FFGPUResult;
+
+typedef struct FFVulkanResult
+{
+    FFstrbuf driver;
+    FFstrbuf apiVersion;
+    FFstrbuf conformanceVersion;
+    FFlist devices; //List of FFGPUResult
+} FFVulkanResult;
+
+const FFVulkanResult* ffDetectVulkan(const FFinstance* instance);
+
+#endif

src/fastfetch.h

@@ -3,24 +3,17 @@
 #ifndef FASTFETCH_INCLUDED
 #define FASTFETCH_INCLUDED
 
-#include <stddef.h>
+#include "fastfetch_config.h"
+
 #include <stdint.h>
 #include <stdbool.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
+
 #include <pwd.h>
-#include <sys/types.h>
 #include <sys/utsname.h>
 #include <sys/sysinfo.h>
-#include <sys/stat.h>
-#include <dlfcn.h>
-
-#include "fastfetch_config.h"
 
 #include "util/FFstrbuf.h"
 #include "util/FFlist.h"
-#include "util/FFvaluestore.h"
 
 static inline void ffUnused(int dummy, ...) { (void) dummy; }
 #define FF_UNUSED(...) ffUnused(0, __VA_ARGS__);
@@ -31,95 +24,94 @@ static inline void ffUnused(int dummy, ...) { (void) dummy; }
 
 #define FASTFETCH_LOGO_MAX_COLORS 9 //two digits would make parsing much more complicated (index 1 - 9)
 
-typedef struct FFlogo
+typedef enum FFLogoType
 {
-    const char** names; //Null terminated
-    char* lines;
-    bool isFromUser;
-    const char** builtinColors; // [0] is used as key color, if not user specified
-} FFlogo;
+    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,    //Raw text file, printed as is.
+    FF_LOGO_TYPE_RAW,     //Raw text file, printed with color codes replacement.
+    FF_LOGO_TYPE_SIXEL,   //Image file, printed as sixel codes.
+    FF_LOGO_TYPE_KITTY,   //Image file, printed as kitty graphics protocol
+    FF_LOGO_TYPE_CHAFA    //Image file, printed as ascii art using libchafa
+} FFLogoType;
+
+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 struct FFconfig
 {
-    const FFlogo* logo;
-    FFstrbuf logoColors[FASTFETCH_LOGO_MAX_COLORS];
+    struct
+    {
+        FFstrbuf source;
+        FFLogoType type;
+        FFstrbuf colors[FASTFETCH_LOGO_MAX_COLORS];
+        uint32_t width;
+        uint32_t height;
+        uint32_t paddingLeft;
+        uint32_t paddingRight;
+        bool printRemaining;
+    } logo;
 
-    uint16_t logoKeySpacing;
+    FFstrbuf mainColor; //If this is empty, ffLogoPrint will set it to the main color of the logo
     FFstrbuf separator;
-    int16_t offsetx;
-    FFstrbuf color;
-    bool colorLogo;
+
     bool showErrors;
     bool recache;
     bool cacheSave;
-    bool printRemainingLogo;
     bool allowSlowOperations;
     bool disableLinewrap;
     bool hideCursor;
-    bool userLogoIsRaw;
+    bool escapeBedrock;
+    FFGLType glType;
+    bool pipe; //disables logo and all escape sequences
+    bool multithreading;
 
-    FFstrbuf osFormat;
-    FFstrbuf osKey;
-    FFstrbuf hostFormat;
-    FFstrbuf hostKey;
-    FFstrbuf kernelFormat;
-    FFstrbuf kernelKey;
-    FFstrbuf uptimeFormat;
-    FFstrbuf uptimeKey;
-    FFstrbuf processesFormat;
-    FFstrbuf processesKey;
-    FFstrbuf packagesFormat;
-    FFstrbuf packagesKey;
-    FFstrbuf shellFormat;
-    FFstrbuf shellKey;
-    FFstrbuf resolutionFormat;
-    FFstrbuf resolutionKey;
-    FFstrbuf deFormat;
-    FFstrbuf deKey;
-    FFstrbuf wmFormat;
-    FFstrbuf wmKey;
-    FFstrbuf wmThemeFormat;
-    FFstrbuf wmThemeKey;
-    FFstrbuf themeFormat;
-    FFstrbuf themeKey;
-    FFstrbuf iconsFormat;
-    FFstrbuf iconsKey;
-    FFstrbuf fontFormat;
-    FFstrbuf fontKey;
-    FFstrbuf cursorFormat;
-    FFstrbuf cursorKey;
-    FFstrbuf terminalFormat;
-    FFstrbuf terminalKey;
-    FFstrbuf termFontFormat;
-    FFstrbuf termFontKey;
-    FFstrbuf cpuFormat;
-    FFstrbuf cpuKey;
-    FFstrbuf cpuUsageFormat;
-    FFstrbuf cpuUsageKey;
-    FFstrbuf gpuFormat;
-    FFstrbuf gpuKey;
-    FFstrbuf memoryFormat;
-    FFstrbuf memoryKey;
-    FFstrbuf diskFormat;
-    FFstrbuf diskKey;
-    FFstrbuf batteryFormat;
-    FFstrbuf batteryKey;
-    FFstrbuf localeFormat;
-    FFstrbuf localeKey;
-    FFstrbuf localIpKey;
-    FFstrbuf localIpFormat;
-    FFstrbuf publicIpKey;
-    FFstrbuf publicIpFormat;
-    FFstrbuf playerKey;
-    FFstrbuf playerFormat;
-    FFstrbuf songKey;
-    FFstrbuf songFormat;
-    FFstrbuf dateTimeKey;
-    FFstrbuf dateTimeFormat;
-    FFstrbuf dateKey;
-    FFstrbuf dateFormat;
-    FFstrbuf timeKey;
-    FFstrbuf timeFormat;
+    FFModuleArgs os;
+    FFModuleArgs host;
+    FFModuleArgs kernel;
+    FFModuleArgs uptime;
+    FFModuleArgs processes;
+    FFModuleArgs packages;
+    FFModuleArgs shell;
+    FFModuleArgs resolution;
+    FFModuleArgs de;
+    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 disk;
+    FFModuleArgs battery;
+    FFModuleArgs locale;
+    FFModuleArgs localIP;
+    FFModuleArgs publicIP;
+    FFModuleArgs player;
+    FFModuleArgs song;
+    FFModuleArgs dateTime;
+    FFModuleArgs date;
+    FFModuleArgs time;
+    FFModuleArgs vulkan;
+    FFModuleArgs openGL;
+    FFModuleArgs openCL;
 
     FFstrbuf libPCI;
     FFstrbuf libVulkan;
@@ -132,7 +124,17 @@ typedef struct FFconfig
     FFstrbuf libDConf;
     FFstrbuf libDBus;
     FFstrbuf libXFConf;
+    FFstrbuf libSQLite3;
     FFstrbuf librpm;
+    FFstrbuf libImageMagick;
+    FFstrbuf libZ;
+    FFstrbuf libChafa;
+    FFstrbuf libEGL;
+    FFstrbuf libGLX;
+    FFstrbuf libOSMesa;
+    FFstrbuf libOpenCL;
+
+    bool titleFQDN;
 
     FFstrbuf diskFolders;
 
@@ -154,7 +156,8 @@ typedef struct FFconfig
 typedef struct FFstate
 {
     uint32_t logoWidth;
-    char* logoLinesIndex;
+    uint32_t logoHeight;
+    uint32_t keysHeight;
 
     struct passwd* passwd;
     struct utsname utsname;
@@ -170,214 +173,9 @@ typedef struct FFinstance
     FFstate state;
 } FFinstance;
 
-typedef struct FFTitleResult
-{
-    FFstrbuf userName;
-    FFstrbuf hostname;
-} FFTitleResult;
-
-typedef struct FFOSResult
-{
-    FFstrbuf systemName;
-    FFstrbuf name;
-    FFstrbuf prettyName;
-    FFstrbuf id;
-    FFstrbuf idLike;
-    FFstrbuf variant;
-    FFstrbuf variantID;
-    FFstrbuf version;
-    FFstrbuf versionID;
-    FFstrbuf codename;
-    FFstrbuf buildID;
-    FFstrbuf architecture;
-} FFOSResult;
-
-typedef struct FFPlasmaResult
-{
-    FFstrbuf widgetStyle;
-    FFstrbuf colorScheme;
-    FFstrbuf icons;
-    FFstrbuf font;
-} FFPlasmaResult;
-
-typedef struct FFGTKResult
-{
-    FFstrbuf theme;
-    FFstrbuf icons;
-    FFstrbuf font;
-    FFstrbuf cursor;
-    FFstrbuf cursorSize;
-} FFGTKResult;
-
-typedef struct FFTerminalShellResult
-{
-    FFstrbuf shellProcessName;
-    FFstrbuf shellExe;
-    const char* shellExeName; //pointer to a char in shellExe
-    FFstrbuf shellVersion;
-
-    FFstrbuf terminalProcessName;
-    FFstrbuf terminalExe;
-    const char* terminalExeName; //pointer to a char in terminalExe
-
-    FFstrbuf userShellExe;
-    const char* userShellExeName; //pointer to a char in userShellExe
-    FFstrbuf userShellVersion;
-} FFTerminalShellResult;
-
-typedef struct FFResolutionResult
-{
-    uint32_t width;
-    uint32_t height;
-    uint32_t refreshRate;
-} FFResolutionResult;
-
-typedef struct FFDisplayServerResult
-{
-    FFstrbuf wmProcessName;
-    FFstrbuf wmPrettyName;
-    FFstrbuf wmProtocolName;
-    FFstrbuf deProcessName;
-    FFstrbuf dePrettyName;
-    FFstrbuf deVersion;
-    FFlist resolutions; //List of FFResolutionResult
-} FFDisplayServerResult;
-
-typedef struct FFTempValue
-{
-    FFstrbuf name;
-    FFstrbuf value;
-    FFstrbuf deviceClass;
-} FFTempValue;
-
-typedef struct FFTempsResult
-{
-    FFlist values; //List of FFTempValue
-} FFTempsResult;
-
-typedef struct FFMediaResult
-{
-    FFstrbuf busNameShort; //e.g. plasma-browser-integration
-    FFstrbuf player; // e.g. Google Chrome
-    FFstrbuf song;
-    FFstrbuf artist;
-    FFstrbuf album;
-    FFstrbuf url;
-} FFMediaResult;
-
-typedef struct FFDateTimeResult
-{
-    //Examples for 21.02.2022 - 15:18:37
-    uint16_t year; //2022
-    uint8_t yearShort; //22
-    uint8_t month; //2
-    FFstrbuf monthPretty; //02
-    FFstrbuf monthName; //February
-    FFstrbuf monthNameShort; //Feb
-    uint8_t week; //8
-    FFstrbuf weekday; //Monday
-    FFstrbuf weekdayShort; //Mon
-    uint16_t dayInYear; //52
-    uint8_t dayInMonth; //21
-    uint8_t dayInWeek; //1
-    uint8_t hour; //15
-    FFstrbuf hourPretty; //15
-    uint8_t hour12; //3
-    FFstrbuf hour12Pretty; //03
-    uint8_t minute; //18
-    FFstrbuf minutePretty; //18
-    uint8_t second; //37
-    FFstrbuf secondPretty; //37
-} FFDateTimeResult;
-
-typedef enum FFformatargtype
-{
-    FF_FORMAT_ARG_TYPE_NULL = 0,
-    FF_FORMAT_ARG_TYPE_UINT,
-    FF_FORMAT_ARG_TYPE_UINT16,
-    FF_FORMAT_ARG_TYPE_UINT8,
-    FF_FORMAT_ARG_TYPE_INT,
-    FF_FORMAT_ARG_TYPE_STRING,
-    FF_FORMAT_ARG_TYPE_STRBUF,
-    FF_FORMAT_ARG_TYPE_DOUBLE,
-    FF_FORMAT_ARG_TYPE_LIST
-} FFformatargtype;
-
-typedef struct FFformatarg
-{
-    FFformatargtype type;
-    const void* value;
-} FFformatarg;
-
-typedef struct FFcache
-{
-    FILE* value;
-    FILE* split;
-} FFcache;
-
-typedef enum FFvarianttype
-{
-    FF_VARIANT_TYPE_STRING,
-    FF_VARIANT_TYPE_BOOL,
-    FF_VARIANT_TYPE_INT
-} FFvarianttype;
-
-typedef union FFvariant
-{
-    const char* strValue;
-    int32_t intValue;
-    struct
-    {
-        bool boolValueSet;
-        bool boolValue;
-    };
-} FFvariant;
-
-#define FF_VARIANT_NULL ((FFvariant){.strValue = NULL})
-
-typedef struct FFfont
-{
-    FFstrbuf pretty;
-    FFstrbuf name;
-    FFstrbuf size;
-    FFlist styles;
-} FFfont;
-
-typedef struct FFpropquery
-{
-    const char* start;
-    FFstrbuf* buffer;
-} FFpropquery;
-
-typedef enum FFInitState
-{
-    FF_INITSTATE_UNINITIALIZED = 0,
-    FF_INITSTATE_SUCCESSFUL = 1,
-    FF_INITSTATE_FAILED = 2
-} FFInitState;
-
-#define FF_LIBRARY_SYMBOL(symbolName) \
-    __typeof__(&symbolName) ff ## symbolName;
-
-#define FF_LIBRARY_LOAD(libraryObjectName, userLibraryName, returnValue, ...) \
-    void* libraryObjectName =  ffLibraryLoad(&userLibraryName, __VA_ARGS__, NULL);\
-    if(libraryObjectName == NULL) \
-        return returnValue;
-
-#define FF_LIBRARY_LOAD_SYMBOL_ADRESS(library, symbolMapping, symbolName, returnValue) \
-    symbolMapping = dlsym(library, #symbolName); \
-    if(symbolMapping == NULL) \
-    { \
-        dlclose(library); \
-        return returnValue; \
-    }
-
-#define FF_LIBRARY_LOAD_SYMBOL(library, symbolName, returnValue) \
-    __typeof__(&symbolName) FF_LIBRARY_LOAD_SYMBOL_ADRESS(library, ff ## symbolName, symbolName, returnValue);
-
-/*************************/
-/* Common util functions */
-/*************************/
+//////////////////////
+// Init functions //
+//////////////////////
 
 //common/init.c
 void ffInitInstance(FFinstance* instance);
@@ -386,130 +184,25 @@ void ffFinish(FFinstance* instance);
 
 void ffListFeatures();
 
-//common/threading.c
-void ffStartDetectionThreads(FFinstance* instance);
+////////////////////
+// Logo functions //
+////////////////////
 
-//common/io.c
-void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat);
-void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numFormatArgs, const char* message, ...);
-void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, const FFstrbuf* error, uint32_t numArgs, const FFformatarg* arguments);
-void ffGetCacheFilePath(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* buffer);
-void ffReadCacheFile(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* buffer);
-void ffWriteCacheFile(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* content);
-bool ffPrintFromCache(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numArgs);
-void ffPrintAndSaveToCache(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* value, const FFstrbuf* formatString, uint32_t numArgs, const FFformatarg* arguments);
-void ffPrintAndAppendToCache(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, FFcache* cache, const FFstrbuf* value, const FFstrbuf* formatString, uint32_t numArgs, const FFformatarg* arguments);
+void ffLogoPrint(FFinstance* instance);
+void ffLogoPrintRemaining(FFinstance* instance);
+void ffLogoPrintLine(FFinstance* instance);
 
-void ffCacheValidate(FFinstance* instance);
-void ffCacheOpenWrite(FFinstance* instance, const char* moduleName, FFcache* cache);
-void ffCacheClose(FFcache* cache);
+void ffLogoBuiltinPrint(FFinstance* instance);
+void ffLogoBuiltinList();
+void ffLogoBuiltinListAutocompletion();
 
-void ffAppendFDContent(int fd, FFstrbuf* buffer);
-bool ffAppendFileContent(const char* fileName, FFstrbuf* buffer); //returns true if open() succeeds. This is used to differentiate between <file not found> and <empty file>
-bool ffGetFileContent(const char* fileName, FFstrbuf* buffer);
-bool ffWriteFDContent(int fd, const FFstrbuf* content);
-void ffWriteFileContent(const char* fileName, const FFstrbuf* buffer);
-
-bool ffFileExists(const char* fileName, mode_t mode);
-
-// Not thread safe!
-void ffSuppressIO(bool suppress);
-
-void ffPrintColor(const FFstrbuf* colorValue);
-
-// They return true if the file was found, independently if start was found
-// Buffers which already contain content are not overwritten
-// The last occurence of start in the first file will be the one used
-// The *Values methods always return true, if all properties were already found before, without testing if the file exists
-bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquery* queries);
-bool ffParsePropFile(const char* filename, const char* start, FFstrbuf* buffer);
-bool ffParsePropFileHomeValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries);
-bool ffParsePropFileHome(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer);
-bool ffParsePropFileConfigValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries);
-bool ffParsePropFileConfig(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer);
-
-//common/processing.c
-void ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[]);
-
-//common/libraries.c
-void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...);
-
-//common/networking.c
-void ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, FFstrbuf* buffer);
-
-//common/logo.c
-void ffLoadLogoSet(FFinstance* instance, const char* logo);
-void ffLoadLogo(FFinstance* instance);
-void ffPrintLogoLine(FFinstance* instance);
-void ffPrintRemainingLogo(FFinstance* instance);
-
-void ffPrintLogos(FFinstance* instance);
-void ffListLogos();
-void ffListLogosForAutocompletion();
-
-//common/format.c
-void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg);
-void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFstrbuf* error, uint32_t numArgs, const FFformatarg* arguments);
-
-//common/parsing.c
-void ffGetGtkPretty(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, const FFstrbuf* gtk4);
-
-void ffFontInitQt(FFfont* font, const char* data);
-void ffFontInitPango(FFfont* font, const char* data);
-void ffFontInitCopy(FFfont* font, const char* name);
-void ffFontDestroy(FFfont* font);
-
-bool ffGetPropValue(const char* line, const char* start, FFstrbuf* buffer);
-bool ffGetPropValueFromLines(const char* lines, const char* start, FFstrbuf* buffer);
-
-void ffParseSemver(FFstrbuf* buffer, const FFstrbuf* major, const FFstrbuf* minor, const FFstrbuf* patch);
-
-bool ffStrSet(const char* str);
-
-//common/settings.c
-FFvariant ffSettingsGetDConf(FFinstance* instance, const char* key, FFvarianttype type);
-FFvariant ffSettingsGetGSettings(FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type);
-FFvariant ffSettingsGet(FFinstance* instance, const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type);
-FFvariant ffSettingsGetXFConf(FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type);
-
-#ifdef __ANDROID__
-bool ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result);
-#endif
-
-//detection/os.c
-const FFOSResult* ffDetectOS(FFinstance* instance);
-
-//detection/plasma.c
-const FFPlasmaResult* ffDetectPlasma(FFinstance* instance);
-
-//detection/gtk.c
-const FFGTKResult* ffDetectGTK2(FFinstance* instance);
-const FFGTKResult* ffDetectGTK4(FFinstance* instance);
-const FFGTKResult* ffDetectGTK3(FFinstance* instance);
-
-//detection/displayServer.c
-const FFDisplayServerResult* ffConnectDisplayServer(const FFinstance* instance);
-
-//detection/terminalShell.c
-const FFTerminalShellResult* ffDetectTerminalShell(FFinstance* instance);
-
-//detection/temps.c (currently unused)
-const FFTempsResult* ffDetectTemps(const FFinstance* instance);
-
-//detection/media.c
-const FFMediaResult* ffDetectMedia(FFinstance* instance);
-
-//detection/dateTime.c
-const FFDateTimeResult* ffDetectDateTime(const FFinstance* instance);
-
-/********************/
-/* Module functions */
-/********************/
+//////////////////////
+// Module functions //
+//////////////////////
 
 //Common
-const FFTitleResult* ffDetectTitle(FFinstance* instance);
 
-void ffPrintDateTimeFormat(FFinstance* instance, const char* moduleName, const FFstrbuf* key, const FFstrbuf* format);
+void ffPrintDateTimeFormat(FFinstance* instance, const char* moduleName, const FFModuleArgs* moduleArgs);
 
 //Printing
 
@@ -549,5 +242,8 @@ void ffPrintTime(FFinstance* instance);
 void ffPrintLocalIp(FFinstance* instance);
 void ffPrintPublicIp(FFinstance* instance);
 void ffPrintColors(FFinstance* instance);
+void ffPrintVulkan(FFinstance* instance);
+void ffPrintOpenGL(FFinstance* instance);
+void ffPrintOpenCL(FFinstance* instance);
 
 #endif

src/fastfetch_config.h.in

@@ -4,10 +4,17 @@
 #define FASTFETCH_PROJECT_NAME "@PROJECT_NAME@"
 #define FASTFETCH_PROJECT_VERSION "@PROJECT_VERSION@"
 #define FASTFETCH_PROJECT_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
-#define FASTFETCH_PROJECT_VERSION_EXTRA "@PROJECT_VERSION_EXTRA@"
+#define FASTFETCH_PROJECT_VERSION_MINOR @PROJECT_VERSION_MINOR@
+#define FASTFETCH_PROJECT_VERSION_PATCH @PROJECT_VERSION_PATCH@
+#define FASTFETCH_PROJECT_VERSION_TWEAK "@PROJECT_VERSION_TWEAK@"
+
+#define FASTFETCH_TARGET_DIR_ROOT "@TARGET_DIR_ROOT@"
+#define FASTFETCH_TARGET_DIR_USR "@TARGET_DIR_USR@"
+#define FASTFETCH_TARGET_DIR_HOME "@TARGET_DIR_HOME@"
 
 #define FASTFETCH_DATATEXT_STRUCTURE "@DATATEXT_STRUCTURE@"
-#define FASTFETCH_DATATEXT_CONFIG "@DATATEXT_CONFIG@" //Requires FASTFETCH_PROJECT_VERSION and FASTFETCH_DATATEXT_STRUCTURE to be set
+#define FASTFETCH_DATATEXT_CONFIG_SYSTEM "@DATATEXT_CONFIG_SYSTEM@" //Requires FASTFETCH_PROJECT_VERSION to be set
+#define FASTFETCH_DATATEXT_CONFIG_USER "@DATATEXT_CONFIG_USER@" //Requires FASTFETCH_PROJECT_VERSION and FASTFETCH_DATATEXT_STRUCTURE to be set
 #define FASTFETCH_DATATEXT_MODULES "@DATATEXT_MODULES@"
 #define FASTFETCH_DATATEXT_HELP "@DATATEXT_HELP@"
 #define FASTFETCH_DATATEXT_HELP_COLOR "@DATATEXT_HELP_COLOR@"

src/flashfetch.c

@@ -10,13 +10,7 @@ int main(int argc, char** argv)
 
     //Modify instance.config here
 
-    ffLoadLogo(&instance); //ffLoadLogoSet(&instance, "my custom logo");
-    ffStrbufSet(&instance.config.color, &instance.config.logoColors[0]); //Use the primary color of the logo as key color
-
-    //Multithreading --> better performance
-    ffStartDetectionThreads(&instance);
-
-    //Does things like disabling line wrap
+    //Does things like starting detection threads, disabling line wrap, etc
     ffStart(&instance);
 
     //Printing
@@ -53,6 +47,8 @@ int main(int argc, char** argv)
     //ffPrintDateTime(&instance);
     //ffPrintDate(&instance);
     //ffPrintTime(&instance);
+    //ffPrintVulkan(&instance);
+    //ffPrintOpenGL(&instance);
     ffPrintBreak(&instance);
     ffPrintColors(&instance);
 

src/logo/image/im6.c

@@ -0,0 +1,31 @@
+#ifdef FF_HAVE_IMAGEMAGICK6
+
+#include "image.h"
+#include "common/library.h"
+
+#include <magick/MagickCore.h>
+
+static FF_LIBRARY_SYMBOL(ResizeImage);
+
+static void* logoResize(const void* image, size_t width, size_t height, void* exceptionInfo)
+{
+    return ffResizeImage(image, width, height, UndefinedFilter, 1.0, exceptionInfo);
+}
+
+FFLogoImageResult ffLogoPrintImageIM6(FFinstance* instance, FFLogoRequestData* requestData)
+{
+    FF_LIBRARY_LOAD(imageMagick, instance->config.libImageMagick, FF_LOGO_IMAGE_RESULT_INIT_ERROR, "libMagickCore-6.Q16HDRI.so", 8, "libMagickCore-6.Q16.so", 8)
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(imageMagick, ffResizeImage, ResizeImage, FF_LOGO_IMAGE_RESULT_INIT_ERROR);
+
+    FFIMData imData;
+    imData.resizeFunc = logoResize;
+    imData.library = imageMagick;
+
+    FFLogoImageResult result = ffLogoPrintImageImpl(instance, requestData, &imData);
+
+    dlclose(imageMagick);
+
+    return result;
+}
+
+#endif

src/logo/image/im7.c

@@ -0,0 +1,31 @@
+#ifdef FF_HAVE_IMAGEMAGICK7
+
+#include "image.h"
+#include "common/library.h"
+
+#include <MagickCore/MagickCore.h>
+
+static FF_LIBRARY_SYMBOL(ResizeImage);
+
+static void* logoResize(const void* image, size_t width, size_t height, void* exceptionInfo)
+{
+    return ffResizeImage(image, width, height, UndefinedFilter, exceptionInfo);
+}
+
+FFLogoImageResult ffLogoPrintImageIM7(FFinstance* instance, FFLogoRequestData* requestData)
+{
+    FF_LIBRARY_LOAD(imageMagick, instance->config.libImageMagick, FF_LOGO_IMAGE_RESULT_INIT_ERROR, "libMagickCore-7.Q16HDRI.so", 11, "libMagickCore-7.Q16.so", 11)
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(imageMagick, ffResizeImage, ResizeImage, FF_LOGO_IMAGE_RESULT_INIT_ERROR);
+
+    FFIMData imData;
+    imData.resizeFunc = logoResize;
+    imData.library = imageMagick;
+
+    FFLogoImageResult result = ffLogoPrintImageImpl(instance, requestData, &imData);
+
+    dlclose(imageMagick);
+
+    return result;
+}
+
+#endif

src/logo/image/image.c

@@ -0,0 +1,574 @@
+#include "image.h"
+#include "common/io.h"
+#include "common/printing.h"
+
+#if defined(FF_HAVE_IMAGEMAGICK7) || defined(FF_HAVE_IMAGEMAGICK6)
+
+#define FF_KITTY_MAX_CHUNK_SIZE 4096
+
+#define FF_CACHE_FILE_HEIGHT "height"
+#define FF_CACHE_FILE_WIDTH "width"
+#define FF_CACHE_FILE_SIXEL "sixel"
+#define FF_CACHE_FILE_KITTY_COMPRESSED "kittyc"
+#define FF_CACHE_FILE_KITTY_UNCOMPRESSED "kittyu"
+#define FF_CACHE_FILE_CHAFA "chafa"
+
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+#ifdef FF_HAVE_ZLIB
+#include "common/library.h"
+#include <stdlib.h>
+#include <zlib.h>
+
+static bool compressBlob(const FFinstance* instance, void** blob, size_t* length)
+{
+    FF_LIBRARY_LOAD(zlib, instance->config.libZ, false, "libz.so", 2)
+    FF_LIBRARY_LOAD_SYMBOL(zlib, compressBound, false)
+    FF_LIBRARY_LOAD_SYMBOL(zlib, compress2, false)
+
+    uLong compressedLength = ffcompressBound(*length);
+    void* compressed = malloc(compressedLength);
+    if(compressed == NULL)
+    {
+        dlclose(zlib);
+        return false;
+    }
+
+    int compressResult = ffcompress2(compressed, &compressedLength, *blob, *length, Z_BEST_COMPRESSION);
+    dlclose(zlib);
+    if(compressResult != Z_OK)
+    {
+        free(compressed);
+        return false;
+    }
+
+    free(*blob);
+
+    *length = (size_t) compressedLength;
+    *blob = compressed;
+    return true;
+}
+
+#endif // FF_HAVE_ZLIB
+
+//We use only the defines from here, that are exactly the same in both versions
+#ifdef FF_HAVE_IMAGEMAGICK7
+    #include <MagickCore/MagickCore.h>
+#else
+    #include <magick/MagickCore.h>
+#endif
+
+typedef struct ImageData
+{
+    FF_LIBRARY_SYMBOL(CopyMagickString)
+    FF_LIBRARY_SYMBOL(ImageToBlob)
+    FF_LIBRARY_SYMBOL(Base64Encode)
+
+    ImageInfo* imageInfo;
+    Image* image;
+    ExceptionInfo* exceptionInfo;
+} ImageData;
+
+static inline bool checkAllocationResult(void* data, size_t length)
+{
+    if(data == NULL)
+        return false;
+
+    if(length == 0)
+    {
+        free(data);
+        return false;
+    }
+
+    return true;
+}
+
+static inline uint32_t simpleCeil(double value)
+{
+    uint32_t result = (uint32_t) value;
+    return value == (double) result ? result : result + 1;
+}
+
+static void writeCacheStrbuf(FFLogoRequestData* requestData, const FFstrbuf* value, const char* cacheFileName)
+{
+    uint32_t cacheDirLength = requestData->cacheDir.length;
+    ffStrbufAppendS(&requestData->cacheDir, cacheFileName);
+    ffWriteFileBuffer(requestData->cacheDir.chars, value);
+    ffStrbufSubstrBefore(&requestData->cacheDir, cacheDirLength);
+}
+
+static void writeCacheUint32(FFLogoRequestData* requestData, uint32_t value, const char* cacheFileName)
+{
+    FFstrbuf content;
+    content.chars = (char*) &value;
+    content.length = sizeof(value);
+    writeCacheStrbuf(requestData, &content, cacheFileName);
+}
+
+static void printImagePixels(FFinstance* instance, FFLogoRequestData* requestData, const FFstrbuf* result, const char* cacheFileName)
+{
+    //Calculate character dimensions
+    instance->state.logoWidth = requestData->logoCharacterWidth + instance->config.logo.paddingLeft + instance->config.logo.paddingRight;
+
+    instance->state.logoHeight = requestData->logoCharacterHeight;
+    if(requestData->type == FF_LOGO_TYPE_KITTY)
+        instance->state.logoHeight -= 1;
+
+    //Write cache files
+    writeCacheStrbuf(requestData, result, cacheFileName);
+
+    if(instance->config.logo.width == 0)
+        writeCacheUint32(requestData, instance->state.logoWidth, FF_CACHE_FILE_WIDTH);
+
+    if(instance->config.logo.height == 0)
+        writeCacheUint32(requestData, instance->state.logoHeight, FF_CACHE_FILE_HEIGHT);
+
+    //Write result to stdout
+    ffPrintCharTimes(' ', instance->config.logo.paddingLeft);
+    fflush(stdout);
+    ffWriteFDBuffer(STDOUT_FILENO, result);
+
+    //Go to upper left corner
+    fputs("\033[9999999D", stdout);
+    printf("\033[%uA", instance->state.logoHeight);
+}
+
+static bool printImageSixel(FFinstance* instance, FFLogoRequestData* requestData, const ImageData* imageData)
+{
+    imageData->ffCopyMagickString(imageData->imageInfo->magick, "SIXEL", 6);
+
+    size_t length;
+    void* blob = imageData->ffImageToBlob(imageData->imageInfo, imageData->image, &length, imageData->exceptionInfo);
+    if(!checkAllocationResult(blob, length))
+        return false;
+
+    FFstrbuf result;
+    result.chars = (char*) blob;
+    result.length = (uint32_t) length;
+
+    printImagePixels(instance, requestData, &result, FF_CACHE_FILE_SIXEL);
+
+    free(blob);
+    return true;
+}
+
+static void appendKittyChunk(FFstrbuf* result, const char** blob, size_t* length, bool printEscapeCode)
+{
+    uint32_t chunkSize = *length > FF_KITTY_MAX_CHUNK_SIZE ? FF_KITTY_MAX_CHUNK_SIZE : (uint32_t) *length;
+
+    if(printEscapeCode)
+        ffStrbufAppendS(result, "\033_G");
+    else
+        ffStrbufAppendC(result, ',');
+
+    ffStrbufAppendS(result, chunkSize != *length ? "m=1" : "m=0");
+    ffStrbufAppendC(result, ';');
+    ffStrbufAppendNS(result, chunkSize, *blob);
+    ffStrbufAppendS(result, "\033\\");
+    *length -= chunkSize;
+    *blob += chunkSize;
+}
+
+static bool printImageKitty(FFinstance* instance, FFLogoRequestData* requestData, const ImageData* imageData)
+{
+    imageData->ffCopyMagickString(imageData->imageInfo->magick, "RGBA", 5);
+
+    size_t length;
+    void* blob = imageData->ffImageToBlob(imageData->imageInfo, imageData->image, &length, imageData->exceptionInfo);
+    if(!checkAllocationResult(blob, length))
+        return false;
+
+    #ifdef FF_HAVE_ZLIB
+        bool isCompressed = compressBlob(instance, &blob, &length);
+    #else
+        bool isCompressed = false;
+    #endif
+
+    char* chars = imageData->ffBase64Encode(blob, length, &length);
+    free(blob);
+    if(!checkAllocationResult(chars, length))
+        return false;
+
+    FFstrbuf result;
+    ffStrbufInitA(&result, (uint32_t) (length + 1024));
+
+    const char* currentPos = chars;
+    size_t remainingLength = length;
+
+    ffStrbufAppendF(&result, "\033_Ga=T,f=32,s=%u,v=%u", requestData->logoPixelWidth, requestData->logoPixelHeight);
+    if(isCompressed)
+        ffStrbufAppendS(&result, ",o=z");
+    appendKittyChunk(&result, &currentPos, &remainingLength, false);
+    while(remainingLength > 0)
+        appendKittyChunk(&result, &currentPos, &remainingLength, true);
+
+    printImagePixels(instance, requestData, &result, isCompressed ? FF_CACHE_FILE_KITTY_COMPRESSED : FF_CACHE_FILE_KITTY_UNCOMPRESSED);
+
+    ffStrbufDestroy(&result);
+    free(chars);
+    return true;
+}
+
+#ifdef FF_HAVE_CHAFA
+#include <chafa/chafa.h>
+static bool printImageChafa(FFinstance* instance, FFLogoRequestData* requestData, const ImageData* imageData)
+{
+    FF_LIBRARY_LOAD(chafa, instance->config.libChafa, false, "libchafa.so", 1)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_symbol_map_new, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_symbol_map_add_by_tags, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_canvas_config_new, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_canvas_config_set_geometry, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_canvas_config_set_symbol_map, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_canvas_new, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_canvas_draw_all_pixels, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_canvas_print, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_canvas_unref, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_canvas_config_unref, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_symbol_map_unref, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, g_string_free, false)
+
+    imageData->ffCopyMagickString(imageData->imageInfo->magick, "RGBA", 5);
+    size_t length;
+    void* blob = imageData->ffImageToBlob(imageData->imageInfo, imageData->image, &length, imageData->exceptionInfo);
+    if(!checkAllocationResult(blob, length))
+        return false;
+
+    ChafaSymbolMap* symbolMap = ffchafa_symbol_map_new();
+    ffchafa_symbol_map_add_by_tags(symbolMap, CHAFA_SYMBOL_TAG_ALL);
+
+    ChafaCanvasConfig* canvasConfig = ffchafa_canvas_config_new();
+    ffchafa_canvas_config_set_geometry(canvasConfig, (gint) requestData->logoCharacterWidth, (gint) requestData->logoCharacterHeight);
+    ffchafa_canvas_config_set_symbol_map(canvasConfig, symbolMap);
+
+    ChafaCanvas* canvas = ffchafa_canvas_new(canvasConfig);
+    ffchafa_canvas_draw_all_pixels(
+        canvas,
+        CHAFA_PIXEL_RGBA8_UNASSOCIATED,
+        blob,
+        (gint) imageData->image->columns,
+        (gint) imageData->image->rows,
+        (gint) imageData->image->columns * 4
+    );
+
+    GString* str = ffchafa_canvas_print(canvas, NULL);
+    FFstrbuf result;
+    result.allocated = (uint32_t) str->allocated_len;
+    result.length = (uint32_t) str->len;
+    result.chars = str->str;
+
+    ffLogoPrintChars(instance, result.chars, false);
+    writeCacheStrbuf(requestData, &result, FF_CACHE_FILE_CHAFA);
+
+    ffg_string_free(str, TRUE);
+    ffchafa_canvas_unref(canvas);
+    ffchafa_canvas_config_unref(canvasConfig);
+    ffchafa_symbol_map_unref(symbolMap);
+
+    return true;
+}
+#endif
+
+FFLogoImageResult ffLogoPrintImageImpl(FFinstance* instance, FFLogoRequestData* requestData, const FFIMData* imData)
+{
+    FF_LIBRARY_LOAD_SYMBOL(imData->library, AcquireExceptionInfo, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+    FF_LIBRARY_LOAD_SYMBOL(imData->library, DestroyExceptionInfo, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+    FF_LIBRARY_LOAD_SYMBOL(imData->library, AcquireImageInfo, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+    FF_LIBRARY_LOAD_SYMBOL(imData->library, DestroyImageInfo, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+    FF_LIBRARY_LOAD_SYMBOL(imData->library, ReadImage, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+    FF_LIBRARY_LOAD_SYMBOL(imData->library, DestroyImage, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+
+    ImageData imageData;
+
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(imData->library, imageData.ffCopyMagickString, CopyMagickString, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(imData->library, imageData.ffImageToBlob, ImageToBlob, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(imData->library, imageData.ffBase64Encode, Base64Encode, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+
+    imageData.exceptionInfo = ffAcquireExceptionInfo();
+    if(imageData.exceptionInfo == NULL)
+        return FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+
+    ImageInfo* imageInfoIn = ffAcquireImageInfo();
+    if(imageInfoIn == NULL)
+    {
+        ffDestroyExceptionInfo(imageData.exceptionInfo);
+        return FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+    }
+
+    //+1, because we need to copy the null byte too
+    imageData.ffCopyMagickString(imageInfoIn->filename, instance->config.logo.source.chars, instance->config.logo.source.length + 1);
+
+    imageData.image = ffReadImage(imageInfoIn, imageData.exceptionInfo);
+    ffDestroyImageInfo(imageInfoIn);
+    if(imageData.image == NULL)
+    {
+        ffDestroyExceptionInfo(imageData.exceptionInfo);
+        return FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+    }
+
+    if(requestData->logoPixelWidth == 0 && requestData->logoPixelHeight == 0)
+    {
+        requestData->logoPixelWidth = (uint32_t) imageData.image->columns;
+        requestData->logoPixelHeight = (uint32_t) imageData.image->rows;
+    }
+    else if(requestData->logoPixelWidth == 0)
+        requestData->logoPixelWidth = (uint32_t) ((double) imageData.image->columns / (double) imageData.image->rows * requestData->logoPixelHeight);
+    else if(requestData->logoPixelHeight == 0)
+        requestData->logoPixelHeight = (uint32_t) ((double) imageData.image->rows / (double) imageData.image->columns * requestData->logoPixelWidth);
+
+    requestData->logoCharacterWidth = simpleCeil((double) requestData->logoPixelWidth / requestData->characterPixelWidth);
+    requestData->logoCharacterHeight = simpleCeil((double) requestData->logoPixelHeight / requestData->characterPixelHeight);
+
+    if(requestData->logoPixelWidth == 0 || requestData->logoPixelHeight == 0 || requestData->logoCharacterWidth == 0 || requestData->logoCharacterHeight == 0)
+    {
+        ffDestroyImage(imageData.image);
+        ffDestroyExceptionInfo(imageData.exceptionInfo);
+        return FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+    }
+
+    Image* resized = imData->resizeFunc(imageData.image, requestData->logoPixelWidth, requestData->logoPixelHeight, imageData.exceptionInfo);
+    ffDestroyImage(imageData.image);
+    if(resized == NULL)
+    {
+        ffDestroyExceptionInfo(imageData.exceptionInfo);
+        return FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+    }
+    imageData.image = resized;
+
+    imageData.imageInfo = ffAcquireImageInfo();
+    if(imageData.imageInfo == NULL)
+    {
+        ffDestroyImage(imageData.image);
+        ffDestroyExceptionInfo(imageData.exceptionInfo);
+        return FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+    }
+
+    bool printSuccessful = false;
+    if(requestData->type == FF_LOGO_TYPE_CHAFA)
+    {
+        #ifdef FF_HAVE_CHAFA
+            printSuccessful = printImageChafa(instance, requestData, &imageData);
+        #endif
+    }
+    else if(requestData->type == FF_LOGO_TYPE_KITTY)
+        printSuccessful = printImageKitty(instance, requestData, &imageData);
+    else if(requestData->type == FF_LOGO_TYPE_SIXEL)
+        printSuccessful = printImageSixel(instance, requestData, &imageData);
+
+    ffDestroyImageInfo(imageData.imageInfo);
+    ffDestroyImage(imageData.image);
+    ffDestroyExceptionInfo(imageData.exceptionInfo);
+
+    return printSuccessful ? FF_LOGO_IMAGE_RESULT_SUCCESS : FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+}
+
+static int getCacheFD(FFLogoRequestData* requestData, const char* fileName)
+{
+    uint32_t cacheDirLength = requestData->cacheDir.length;
+    ffStrbufAppendS(&requestData->cacheDir, fileName);
+    int fd = open(requestData->cacheDir.chars, O_RDONLY);
+    ffStrbufSubstrBefore(&requestData->cacheDir, cacheDirLength);
+    return fd;
+}
+
+static void readCachedStrbuf(FFLogoRequestData* requestData, FFstrbuf* result, const char* cacheFileName)
+{
+    uint32_t cacheDirLength = requestData->cacheDir.length;
+    ffStrbufAppendS(&requestData->cacheDir, cacheFileName);
+    ffAppendFileBuffer(requestData->cacheDir.chars, result);
+    ffStrbufSubstrBefore(&requestData->cacheDir, cacheDirLength);
+}
+
+static uint32_t readCachedUint32(FFLogoRequestData* requestData, const char* cacheFileName)
+{
+    FFstrbuf content;
+    ffStrbufInit(&content);
+    readCachedStrbuf(requestData, &content, cacheFileName);
+
+    uint32_t result = 0;
+
+    if(content.length != sizeof(result))
+    {
+        ffStrbufDestroy(&content);
+        return 0;
+    }
+
+    memcpy(&result, content.chars, sizeof(result));
+
+    ffStrbufDestroy(&content);
+
+    return result;
+}
+
+static bool printCachedChars(FFinstance* instance, FFLogoRequestData* requestData)
+{
+    FFstrbuf content;
+    ffStrbufInitA(&content, 32768);
+
+    if(requestData->type == FF_LOGO_TYPE_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;
+}
+
+static bool printCachedPixel(FFinstance* instance, FFLogoRequestData* requestData)
+{
+    requestData->logoCharacterWidth = instance->config.logo.width;
+    if(requestData->logoCharacterWidth == 0)
+    {
+        requestData->logoCharacterWidth = readCachedUint32(requestData, FF_CACHE_FILE_WIDTH);
+        if(requestData->logoCharacterWidth == 0)
+            return false;
+    }
+
+    requestData->logoCharacterHeight = instance->config.logo.height;
+    if(requestData->logoCharacterHeight == 0)
+    {
+        requestData->logoCharacterHeight = readCachedUint32(requestData, FF_CACHE_FILE_HEIGHT);
+        if(requestData->logoCharacterHeight == 0)
+            return false;
+    }
+
+    int fd = -1;
+    if(requestData->type == FF_LOGO_TYPE_KITTY)
+    {
+        fd = getCacheFD(requestData, FF_CACHE_FILE_KITTY_COMPRESSED);
+        if(fd == -1)
+            fd = getCacheFD(requestData, FF_CACHE_FILE_KITTY_UNCOMPRESSED);
+    }
+    else if(requestData->type == FF_LOGO_TYPE_SIXEL)
+        fd = getCacheFD(requestData, FF_CACHE_FILE_SIXEL);
+
+    if(fd == -1)
+        return false;
+
+    ffPrintCharTimes(' ', instance->config.logo.paddingLeft);
+    fflush(stdout);
+
+    char buffer[32768];
+    ssize_t readBytes;
+    while((readBytes = read(fd, buffer, sizeof(buffer))) > 0)
+        FF_UNUSED(write(STDOUT_FILENO, buffer, (size_t) readBytes));
+
+    close(fd);
+
+    instance->state.logoWidth = requestData->logoCharacterWidth + instance->config.logo.paddingLeft + instance->config.logo.paddingRight;
+    instance->state.logoHeight = requestData->logoCharacterHeight;
+
+    //Go to upper left corner
+    fputs("\033[9999999D", stdout);
+    printf("\033[%uA", instance->state.logoHeight);
+    return true;
+}
+
+static bool printCached(FFinstance* instance, FFLogoRequestData* requestData)
+{
+    if(requestData->type == FF_LOGO_TYPE_CHAFA)
+        return printCachedChars(instance, requestData);
+    else
+        return printCachedPixel(instance, requestData);
+}
+
+static bool getCharacterPixelDimensions(FFLogoRequestData* requestData)
+{
+    struct winsize winsize;
+
+    //Initialize every member to 0, because it isn't guaranteed that every terminal sets them all
+    memset(&winsize, 0, sizeof(struct winsize));
+
+    ioctl(STDOUT_FILENO, TIOCGWINSZ, &winsize);
+
+    if(winsize.ws_row == 0 || winsize.ws_col == 0)
+        ffGetTerminalResponse("\033[18t", "\033[8;%hu;%hut", &winsize.ws_row, &winsize.ws_col);
+
+    if(winsize.ws_row == 0 || winsize.ws_col == 0)
+        return false;
+
+    if(winsize.ws_ypixel == 0 || winsize.ws_xpixel == 0)
+        ffGetTerminalResponse("\033[14t", "\033[4;%hu;%hut", &winsize.ws_ypixel, &winsize.ws_xpixel);
+
+    requestData->characterPixelWidth = winsize.ws_xpixel / (double) winsize.ws_col;
+    requestData->characterPixelHeight = winsize.ws_ypixel / (double) winsize.ws_row;
+
+    return requestData->characterPixelWidth > 1.0 && requestData->characterPixelHeight > 1.0;
+}
+
+bool ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type)
+{
+    //Performance optimisation
+    #ifndef FF_HAVE_CHAFA
+        if(type == FF_LOGO_TYPE_CHAFA)
+            return false;
+    #endif
+
+    FFLogoRequestData requestData;
+    requestData.type = type;
+    requestData.characterPixelWidth = 1;
+    requestData.characterPixelHeight = 1;
+
+    if(
+        (type != FF_LOGO_TYPE_CHAFA || instance->config.logo.width == 0 || instance->config.logo.height == 0) &&
+        !getCharacterPixelDimensions(&requestData)
+    )
+        return false;
+
+    requestData.logoPixelWidth = simpleCeil((double) instance->config.logo.width * requestData.characterPixelWidth);
+    requestData.logoPixelHeight = simpleCeil((double) instance->config.logo.height * requestData.characterPixelHeight);
+
+    ffStrbufInitA(&requestData.cacheDir, PATH_MAX * 2);
+    ffStrbufAppend(&requestData.cacheDir, &instance->state.cacheDir);
+    ffStrbufAppendS(&requestData.cacheDir, "images");
+
+    ffStrbufEnsureFree(&requestData.cacheDir, PATH_MAX);
+    if(realpath(instance->config.logo.source.chars, requestData.cacheDir.chars + requestData.cacheDir.length) == NULL)
+    {
+        //We can safely return here, because if realpath failed, we surely won't be able to read the file
+        ffStrbufDestroy(&requestData.cacheDir);
+        return false;
+    }
+    ffStrbufRecalculateLength(&requestData.cacheDir);
+    ffStrbufEnsureEndsWithC(&requestData.cacheDir, '/');
+
+    ffStrbufAppendF(&requestData.cacheDir, "%u", requestData.logoPixelWidth);
+    ffStrbufAppendC(&requestData.cacheDir, '*');
+    ffStrbufAppendF(&requestData.cacheDir, "%u", requestData.logoPixelHeight);
+    ffStrbufAppendC(&requestData.cacheDir, '/');
+
+    if(!instance->config.recache && printCached(instance, &requestData))
+    {
+        ffStrbufDestroy(&requestData.cacheDir);
+        return true;
+    }
+
+    FFLogoImageResult result = FF_LOGO_IMAGE_RESULT_INIT_ERROR;
+
+    #ifdef FF_HAVE_IMAGEMAGICK7
+        result = ffLogoPrintImageIM7(instance, &requestData);
+    #endif
+
+    #ifdef FF_HAVE_IMAGEMAGICK6
+        if(result == FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+            result = ffLogoPrintImageIM6(instance, &requestData);
+    #endif
+
+    ffStrbufDestroy(&requestData.cacheDir);
+    return result == FF_LOGO_IMAGE_RESULT_SUCCESS;
+}
+
+#else //FF_HAVE_IMAGEMAGICK{6, 7}
+bool ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type)
+{
+    FF_UNUSED(instance, type);
+    return false;
+}
+#endif //FF_HAVE_IMAGEMAGICK{6, 7}

src/logo/image/image.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#ifndef FF_INCLUDED_LOGO_SIXEL_sixel
+#define FF_INCLUDED_LOGO_SIXEL_sixel
+
+#include "../logo.h"
+
+#if defined(FF_HAVE_IMAGEMAGICK7) || defined(FF_HAVE_IMAGEMAGICK6)
+
+#define MAGICKCORE_HDRI_ENABLE 1
+#define MAGICKCORE_QUANTUM_DEPTH 16
+
+typedef enum FFLogoImageResult
+{
+    FF_LOGO_IMAGE_RESULT_SUCCESS,    //Logo printed
+    FF_LOGO_IMAGE_RESULT_INIT_ERROR, //Failed to load library, try again with next IM version
+    FF_LOGO_IMAGE_RESULT_RUN_ERROR   //Failed to load / convert image, cancle whole sixel code
+} FFLogoImageResult;
+
+typedef struct FFLogoRequestData
+{
+    FFLogoType type;
+    FFstrbuf cacheDir;
+
+    double characterPixelWidth;
+    double characterPixelHeight;
+
+    uint32_t logoPixelWidth;
+    uint32_t logoPixelHeight;
+
+    uint32_t logoCharacterHeight;
+    uint32_t logoCharacterWidth;
+} FFLogoRequestData;
+
+typedef struct FFIMData
+{
+    void* library;
+    void*(*resizeFunc)(const void* image, size_t width, size_t height, void* exceptionInfo);
+} FFIMData;
+
+FFLogoImageResult ffLogoPrintImageImpl(FFinstance* instance, FFLogoRequestData* requestData, const FFIMData* imData);
+
+#endif
+
+#ifdef FF_HAVE_IMAGEMAGICK7
+FFLogoImageResult ffLogoPrintImageIM7(FFinstance* instance, FFLogoRequestData* requestData);
+#endif
+
+#ifdef FF_HAVE_IMAGEMAGICK6
+#include <math.h>
+FFLogoImageResult ffLogoPrintImageIM6(FFinstance* instance, FFLogoRequestData* requestData);
+#endif
+
+#endif

src/logo/logo.c

@@ -0,0 +1,417 @@
+#include "logo.h"
+#include "common/io.h"
+#include "common/printing.h"
+#include "detection/os.h"
+#include "detection/terminalshell.h"
+
+#include <ctype.h>
+#include <string.h>
+
+void ffLogoPrintChars(FFinstance* instance, const char* data, bool doColorReplacement)
+{
+    uint32_t currentlineLength = 0;
+
+    fputs(FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
+    ffPrintCharTimes(' ', instance->config.logo.paddingLeft);
+
+    //Use logoColor[0] as the default color
+    if(doColorReplacement)
+        ffPrintColor(&instance->config.logo.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);
+
+            //We have \r\n, skip the \r
+            if(*data == '\r')
+                ++data;
+
+            putchar('\n');
+            ++data;
+
+            ffPrintCharTimes(' ', instance->config.logo.paddingLeft);
+
+            if(currentlineLength > instance->state.logoWidth)
+                instance->state.logoWidth = currentlineLength;
+
+            currentlineLength = 0;
+            ++instance->state.logoHeight;
+            continue;
+        }
+
+        //Always print tabs as 4 spaces, to have consistent spacing
+        if(*data == '\t')
+        {
+            ffPrintCharTimes(' ', 4);
+            ++data;
+            continue;
+        }
+
+        //We have an escape sequence direclty as bytes. We print it, but don't increase the line length
+        if(*data == '\033' && *(data + 1) == '[')
+        {
+            const char* start = data;
+
+            fputs("\033[", stdout);
+            data += 2;
+
+            while(isdigit(*data) || *data == ';')
+                putchar(*data++); // number
+
+            //We have a valid control sequence, print it and continue with next char
+            if(isascii(*data))
+            {
+                putchar(*data++); // single letter, end of control sequence
+                continue;
+            }
+
+            //Invalid control sequence, try to get most accurate length
+            currentlineLength += (uint32_t) (data - start - 1); //-1 for \033 which for sure doesn't take any space
+
+            //Don't continue here, print the char after the letters with the unicode printing
+        }
+
+        //We have a fastfetch color placeholder. Replace it with the esacape sequence, don't increase the line length
+        if(doColorReplacement && *data == '$')
+        {
+            ++data;
+
+            //If we have $$, or $\0, print it as single $
+            if(*data == '$' || *data == '\0')
+            {
+                putchar('$');
+                ++currentlineLength;
+                ++data;
+                continue;
+            }
+
+            //Map the number to an array index, so that '1' -> 0, '2' -> 1, etc.
+            int index = ((int) *data) - 49;
+
+            //If the index is valid, print the color. Otherwise continue as normal
+            if(index < 0 || index >= FASTFETCH_LOGO_MAX_COLORS)
+            {
+                putchar('$');
+                ++currentlineLength;
+                //Don't continue here, we want to print the current char as unicode
+            }
+            else
+            {
+                ffPrintColor(&instance->config.logo.colors[index]);
+                ++data;
+                continue;
+            }
+        }
+
+        //Do the printing, respecting unicode
+
+        ++currentlineLength;
+
+        int codepoint = (unsigned char) *data;
+        uint8_t bytes;
+
+        if(codepoint <= 127)
+            bytes = 1;
+        else if((codepoint & 0xE0) == 0xC0)
+            bytes = 2;
+        else if((codepoint & 0xF0) == 0xE0)
+            bytes = 3;
+        else if((codepoint & 0xF8) == 0xF0)
+            bytes = 4;
+        else
+            bytes = 1; //Invalid utf8, print it as is, byte by byte
+
+        for(uint8_t i = 0; i < bytes; ++i)
+        {
+            if(*data == '\0')
+                break;
+
+            putchar(*data++);
+        }
+    }
+
+    ffPrintCharTimes(' ', instance->config.logo.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;
+
+    //Go to the leftmost position
+    fputs("\033[9999999D", stdout);
+
+    //If the logo height is > 1, go up the height
+    if(instance->state.logoHeight > 0)
+        printf("\033[%uA", instance->state.logoHeight);
+}
+
+static void logoApplyMainColor(FFinstance* instance, const FFlogo* logo)
+{
+    if(instance->config.mainColor.length == 0)
+        ffStrbufAppendS(&instance->config.mainColor, logo->builtinColors[0]);
+}
+
+static bool logoHasName(const FFlogo* logo, const char* name)
+{
+    const char** logoName = logo->names;
+
+    while(*logoName != NULL)
+    {
+        if(strcasecmp(*logoName, name) == 0)
+            return true;
+        ++logoName;
+    }
+
+    return false;
+}
+
+static const FFlogo* logoGetBuiltin(const char* name)
+{
+    GetLogoMethod* methods = ffLogoBuiltinGetAll();
+
+    while(*methods != NULL)
+    {
+        const FFlogo* logo = (*methods)();
+
+        if(logoHasName(logo, name))
+            return logo;
+
+        ++methods;
+    }
+
+    return NULL;
+}
+
+static const FFlogo* logoGetBuiltinDetected(FFinstance* instance)
+{
+    const FFOSResult* os = ffDetectOS(instance);
+
+    const FFlogo* logo = logoGetBuiltin(os->id.chars);
+    if(logo != NULL)
+        return logo;
+
+    logo = logoGetBuiltin(os->name.chars);
+    if(logo != NULL)
+        return logo;
+
+    logo = logoGetBuiltin(os->prettyName.chars);
+    if(logo != NULL)
+        return logo;
+
+    logo = logoGetBuiltin(os->idLike.chars);
+    if(logo != NULL)
+        return logo;
+
+    logo = logoGetBuiltin(os->systemName.chars);
+    if(logo != NULL)
+        return logo;
+
+    return ffLogoBuiltinGetUnknown();
+}
+
+static inline void logoApplyMainColorDetected(FFinstance* instance)
+{
+    logoApplyMainColor(instance, logoGetBuiltinDetected(instance));
+}
+
+static void logoPrintStruct(FFinstance* instance, const FFlogo* logo)
+{
+    logoApplyMainColor(instance, 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);
+    }
+
+    ffLogoPrintChars(instance, logo->data, true);
+}
+
+static bool logoPrintBuiltinIfExists(FFinstance* instance, const char* name)
+{
+    const FFlogo* logo = logoGetBuiltin(name);
+    if(logo == NULL)
+        return false;
+
+    logoPrintStruct(instance, logo);
+    return true;
+}
+
+static inline void logoPrintDetected(FFinstance* instance)
+{
+    logoPrintStruct(instance, logoGetBuiltinDetected(instance));
+}
+
+static bool logoPrintFileIfExists(FFinstance* instance, bool doColorReplacement)
+{
+    FFstrbuf content;
+    ffStrbufInitA(&content, 2047);
+
+    if(!ffAppendFileBuffer(instance->config.logo.source.chars, &content))
+    {
+        ffStrbufDestroy(&content);
+        return false;
+    }
+
+    logoApplyMainColorDetected(instance);
+    ffLogoPrintChars(instance, content.chars, doColorReplacement);
+    ffStrbufDestroy(&content);
+    return true;
+}
+
+static bool logoPrintImageIfExists(FFinstance* instance, FFLogoType logo)
+{
+    if(!ffLogoPrintImageIfExists(instance, logo))
+        return false;
+
+    logoApplyMainColorDetected(instance);
+    return true;
+}
+
+static void logoPrintKnownType(FFinstance* instance)
+{
+    bool successfull;
+
+    if(instance->config.logo.type == FF_LOGO_TYPE_BUILTIN)
+        successfull = logoPrintBuiltinIfExists(instance, instance->config.logo.source.chars);
+    else if(instance->config.logo.type == FF_LOGO_TYPE_FILE)
+        successfull = logoPrintFileIfExists(instance, true);
+    else if(instance->config.logo.type == FF_LOGO_TYPE_RAW)
+        successfull = logoPrintFileIfExists(instance, false);
+    else //image
+        successfull = logoPrintImageIfExists(instance, instance->config.logo.type);
+
+    if(!successfull)
+        logoPrintDetected(instance);
+}
+
+void ffLogoPrint(FFinstance* instance)
+{
+    //In pipe mode, we don't have a logo or padding.
+    //We also don't need to set main color, because it won't be printed anyway.
+    //So we can return quickly here.
+    if(instance->config.pipe)
+    {
+        instance->state.logoHeight = 0;
+        instance->state.logoWidth = 0;
+        return;
+    }
+
+    //If the source is not set, we can directly print the detected logo.
+    if(instance->config.logo.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)
+    {
+        logoPrintKnownType(instance);
+        return;
+    }
+
+    //If source matches the name of a builtin logo, print it and return.
+    if(logoPrintBuiltinIfExists(instance, instance->config.logo.source.chars))
+        return;
+
+    const FFTerminalShellResult* terminalShell = ffDetectTerminalShell(instance);
+
+    //Terminal emulators that support kitty graphics protocol.
+    bool supportsKitty =
+        ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "kitty") == 0 ||
+        ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "konsole") == 0 ||
+        ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "wezterm") == 0 ||
+        ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "wayst") == 0;
+
+    //Try to load the logo as an image. If it succeeds, print it and return.
+    if(logoPrintImageIfExists(instance, supportsKitty ? FF_LOGO_TYPE_KITTY : FF_LOGO_TYPE_CHAFA))
+        return;
+
+    //Try to load the logo as a file. If it succeeds, print it and return.
+    if(logoPrintFileIfExists(instance, true))
+        return;
+
+    logoPrintDetected(instance);
+}
+
+void ffLogoPrintLine(FFinstance* instance)
+{
+    if(instance->state.logoWidth > 0)
+        printf("\033[%uC", instance->state.logoWidth);
+
+    ++instance->state.keysHeight;
+}
+
+void ffLogoPrintRemaining(FFinstance* instance)
+{
+    while(instance->state.keysHeight <= instance->state.logoHeight)
+    {
+        ffLogoPrintLine(instance);
+        putchar('\n');
+    }
+}
+
+void ffLogoBuiltinPrint(FFinstance* instance)
+{
+    GetLogoMethod* methods = ffLogoBuiltinGetAll();
+
+    while(*methods != NULL)
+    {
+        const FFlogo* logo = (*methods)();
+        printf("\033[%sm%s:\033[0m\n", logo->builtinColors[0], logo->names[0]);
+        logoPrintStruct(instance, logo);
+        ffLogoPrintRemaining(instance);
+
+        //reset everything
+        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]);
+
+        puts("\n");
+        ++methods;
+    }
+}
+
+void ffLogoBuiltinList()
+{
+    GetLogoMethod* methods = ffLogoBuiltinGetAll();
+
+    uint32_t counter = 0;
+
+    while(*methods != NULL)
+    {
+        const FFlogo* logo = (*methods)();
+        const char** names = logo->names;
+
+        printf("%u)%s ", counter, counter < 10 ? " " : "");
+        ++counter;
+
+        while(*names != NULL)
+        {
+            printf("\"%s\" ", *names);
+            ++names;
+        }
+
+        putchar('\n');
+        ++methods;
+    }
+}
+
+void ffLogoBuiltinListAutocompletion()
+{
+    GetLogoMethod* methods = ffLogoBuiltinGetAll();
+
+    while(*methods != NULL)
+    {
+        printf("%s\n", (*methods)()->names[0]);
+        ++methods;
+    }
+}

src/logo/logo.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#ifndef FASTFETCH_INCLUDED_LOGO_logo
+#define FASTFETCH_INCLUDED_LOGO_logo
+
+#include "fastfetch.h"
+
+typedef struct FFlogo
+{
+    const char* data;
+    const char** names; //Null terminated
+    const char** builtinColors; //Null terminated
+} FFlogo;
+
+typedef const FFlogo*(*GetLogoMethod)();
+
+//logo.c
+void ffLogoPrintChars(FFinstance* instance, const char* data, bool doColorReplacement);
+
+//builtin.c
+const FFlogo* ffLogoBuiltinGetUnknown();
+GetLogoMethod* ffLogoBuiltinGetAll();
+
+//image/image.c
+bool ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type);
+
+#endif

src/modules/battery.c

@@ -1,6 +1,7 @@
 #include "fastfetch.h"
+#include "common/io.h"
+#include "common/printing.h"
 
-#include <unistd.h>
 #include <dirent.h>
 
 #define FF_BATTERY_MODULE_NAME "Battery"
@@ -24,7 +25,7 @@ static void parseBattery(FFstrbuf* dir, FFlist* results)
 
     //type must exist and be "Battery"
     ffStrbufAppendS(dir, "/type");
-    ffGetFileContent(dir->chars, &testBatteryBuffer);
+    ffReadFileBuffer(dir->chars, &testBatteryBuffer);
     ffStrbufSubstrBefore(dir, dirLength);
 
     if(ffStrbufIgnCaseCompS(&testBatteryBuffer, "Battery") != 0)
@@ -35,7 +36,7 @@ static void parseBattery(FFstrbuf* dir, FFlist* results)
 
     //scope may not exist or must not be "Device"
     ffStrbufAppendS(dir, "/scope");
-    ffGetFileContent(dir->chars, &testBatteryBuffer);
+    ffReadFileBuffer(dir->chars, &testBatteryBuffer);
     ffStrbufSubstrBefore(dir, dirLength);
 
     if(ffStrbufIgnCaseCompS(&testBatteryBuffer, "Device") == 0)
@@ -50,7 +51,7 @@ static void parseBattery(FFstrbuf* dir, FFlist* results)
     //capacity must exist and be not empty
     ffStrbufInit(&result->capacity);
     ffStrbufAppendS(dir, "/capacity");
-    ffGetFileContent(dir->chars, &result->capacity);
+    ffReadFileBuffer(dir->chars, &result->capacity);
     ffStrbufSubstrBefore(dir, dirLength);
 
     if(result->capacity.length == 0)
@@ -64,30 +65,30 @@ static void parseBattery(FFstrbuf* dir, FFlist* results)
 
     ffStrbufInit(&result->manufacturer);
     ffStrbufAppendS(dir, "/manufacturer");
-    ffGetFileContent(dir->chars, &result->manufacturer);
+    ffReadFileBuffer(dir->chars, &result->manufacturer);
     ffStrbufSubstrBefore(dir, dirLength);
 
     ffStrbufInit(&result->modelName);
     ffStrbufAppendS(dir, "/model_name");
-    ffGetFileContent(dir->chars, &result->modelName);
+    ffReadFileBuffer(dir->chars, &result->modelName);
     ffStrbufSubstrBefore(dir, dirLength);
 
     ffStrbufInit(&result->technology);
     ffStrbufAppendS(dir, "/technology");
-    ffGetFileContent(dir->chars, &result->technology);
+    ffReadFileBuffer(dir->chars, &result->technology);
     ffStrbufSubstrBefore(dir, dirLength);
 
     ffStrbufInit(&result->status);
     ffStrbufAppendS(dir, "/status");
-    ffGetFileContent(dir->chars, &result->status);
+    ffReadFileBuffer(dir->chars, &result->status);
     ffStrbufSubstrBefore(dir, dirLength);
 }
 
 static void printBattery(FFinstance* instance, const BatteryResult* result, uint8_t index)
 {
-    if(instance->config.batteryFormat.length == 0)
+    if(instance->config.battery.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_BATTERY_MODULE_NAME, index, &instance->config.batteryKey);
+        ffPrintLogoAndKey(instance, FF_BATTERY_MODULE_NAME, index, &instance->config.battery.key);
 
         bool showStatus =
             result->status.length > 0 &&
@@ -114,7 +115,7 @@ static void printBattery(FFinstance* instance, const BatteryResult* result, uint
     }
     else
     {
-        ffPrintFormatString(instance, FF_BATTERY_MODULE_NAME, index, &instance->config.batteryKey, &instance->config.batteryFormat, NULL, FF_BATTERY_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(instance, FF_BATTERY_MODULE_NAME, index, &instance->config.battery, 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},
@@ -131,8 +132,7 @@ void ffPrintBattery(FFinstance* instance)
     if(instance->config.batteryDir.length > 0)
     {
         ffStrbufAppend(&baseDir, &instance->config.batteryDir);
-        if(!ffStrbufEndsWithC(&baseDir, '/'))
-            ffStrbufAppendC(&baseDir, '/');
+        ffStrbufEndsWithC(&baseDir, '/');
     }
     else
     {
@@ -144,7 +144,7 @@ void ffPrintBattery(FFinstance* instance)
     DIR* dirp = opendir(baseDir.chars);
     if(dirp == NULL)
     {
-        ffPrintError(instance, FF_BATTERY_MODULE_NAME, 0, &instance->config.batteryKey, &instance->config.batteryFormat, FF_BATTERY_NUM_FORMAT_ARGS, "opendir(\"%s\") == NULL", baseDir.chars);
+        ffPrintError(instance, FF_BATTERY_MODULE_NAME, 0, &instance->config.battery, "opendir(\"%s\") == NULL", baseDir.chars);
         ffStrbufDestroy(&baseDir);
         return;
     }
@@ -175,7 +175,7 @@ void ffPrintBattery(FFinstance* instance)
     }
 
     if(results.length == 0)
-        ffPrintError(instance, FF_BATTERY_MODULE_NAME, 0, &instance->config.batteryKey, &instance->config.batteryFormat, FF_BATTERY_NUM_FORMAT_ARGS, "%s doesn't contain any battery folder", baseDir.chars);
+        ffPrintError(instance, FF_BATTERY_MODULE_NAME, 0, &instance->config.battery, "%s doesn't contain any battery folder", baseDir.chars);
 
     ffListDestroy(&results);
     ffStrbufDestroy(&baseDir);

src/modules/break.c

@@ -1,7 +1,8 @@
 #include "fastfetch.h"
+#include "common/printing.h"
 
 void ffPrintBreak(FFinstance* instance)
 {
-    ffPrintLogoLine(instance);
+    ffLogoPrintLine(instance);
     putchar('\n');
 }

src/modules/colors.c

@@ -1,8 +1,18 @@
 #include "fastfetch.h"
+#include "common/printing.h"
 
 void ffPrintColors(FFinstance* instance)
 {
-    ffPrintLogoLine(instance);
+    if(instance->config.pipe)
+    {
+        ffLogoPrintLine(instance);
+        puts("████████████████████████");
+        ffLogoPrintLine(instance);
+        puts("████████████████████████");
+        return;
+    }
+
+    ffLogoPrintLine(instance);
 
     // 4%d: Set the background color
     // 3%d: Set the foreground color
@@ -11,7 +21,7 @@ void ffPrintColors(FFinstance* instance)
 
     puts(FASTFETCH_TEXT_MODIFIER_RESET);
 
-    ffPrintLogoLine(instance);
+    ffLogoPrintLine(instance);
 
     // 1: Set everything to bolt. This causes normal colors on some systems to be bright.
     // 4%d: Set the backgound to the not bright color

src/modules/cpu.c

@@ -1,48 +1,63 @@
 #include "fastfetch.h"
+#include "common/io.h"
+#include "common/properties.h"
+#include "common/printing.h"
+#include "common/caching.h"
+#include "detection/temps.h"
 
-#include <string.h>
+#include <stdlib.h>
 
 #define FF_CPU_MODULE_NAME "CPU"
-#define FF_CPU_NUM_FORMAT_ARGS 14
-
-static double parseHz(FFstrbuf* content)
-{
-    if(content->length == 0)
-        return 0;
-
-    double herz;
-    if(sscanf(content->chars, "%lf", &herz) != 1)
-        return 0;
-
-    return herz;
-}
+#define FF_CPU_NUM_FORMAT_ARGS 15
 
 static double getGhz(const char* policyFile, const char* cpuFile)
 {
     FFstrbuf content;
     ffStrbufInit(&content);
 
-    ffGetFileContent(policyFile, &content);
+    ffReadFileBuffer(policyFile, &content);
     if(content.length == 0)
-        ffGetFileContent(cpuFile, &content);
+        ffReadFileBuffer(cpuFile, &content);
 
-    double herz = parseHz(&content);
+    double herz = ffStrbufToDouble(&content);
 
     ffStrbufDestroy(&content);
 
+    //ffStrbufToDouble failed
+    if(herz != herz)
+        return 0;
+
     herz /= 1000.0; //to MHz
     return herz / 1000.0; //to GHz
 }
 
+static double detectCPUTemp(const FFinstance* instance)
+{
+    const FFTempsResult *temps = ffDetectTemps(instance);
+
+    for(uint32_t i = 0; i < temps->values.length; i++)
+    {
+        FFTempValue* value = ffListGet(&temps->values, i);
+
+        if(
+            ffStrbufFirstIndexS(&value->name, "cpu") < value->name.length ||
+            ffStrbufCompS(&value->name, "k10temp") == 0 ||
+            ffStrbufCompS(&value->name, "coretemp") == 0
+        ) return value->value;
+    }
+
+    return 0.0 / 0.0; //NaN
+}
+
 void ffPrintCPU(FFinstance* instance)
 {
-    if(ffPrintFromCache(instance, FF_CPU_MODULE_NAME, &instance->config.cpuKey, &instance->config.cpuFormat, FF_CPU_NUM_FORMAT_ARGS))
+    if(ffPrintFromCache(instance, FF_CPU_MODULE_NAME, &instance->config.cpu, FF_CPU_NUM_FORMAT_ARGS))
         return;
 
     FILE* cpuinfo = fopen("/proc/cpuinfo", "r");
     if(cpuinfo == NULL)
     {
-        ffPrintError(instance, FF_CPU_MODULE_NAME, 0, &instance->config.cpuKey, &instance->config.cpuFormat, FF_CPU_NUM_FORMAT_ARGS, "fopen(\"/proc/cpuinfo\", \"r\") == NULL");
+        ffPrintError(instance, FF_CPU_MODULE_NAME, 0, &instance->config.cpu, "fopen(\"""/proc/cpuinfo\", \"r\") == NULL");
         return;
     }
 
@@ -68,11 +83,11 @@ void ffPrintCPU(FFinstance* instance)
             break;
 
         (void)(
-            ffGetPropValue(line, "model name :", &name) ||
-            ffGetPropValue(line, "vendor_id :", &vendor) ||
-            ffGetPropValue(line, "cpu cores :", &physicalCoresString) ||
-            ffGetPropValue(line, "cpu MHz :", &procGhzString) ||
-            (name.length == 0 && ffGetPropValue(line, "Hardware :", &name)) //For Android devices
+            ffParsePropLine(line, "model name :", &name) ||
+            ffParsePropLine(line, "vendor_id :", &vendor) ||
+            ffParsePropLine(line, "cpu cores :", &physicalCoresString) ||
+            ffParsePropLine(line, "cpu MHz :", &procGhzString) ||
+            (name.length == 0 && ffParsePropLine(line, "Hardware :", &name)) //For Android devices
         );
     }
 
@@ -81,7 +96,12 @@ void ffPrintCPU(FFinstance* instance)
 
     fclose(cpuinfo);
 
-    double procGhz = parseHz(&procGhzString) / 1000.0; //to GHz
+    double procGhz = ffStrbufToDouble(&procGhzString);
+    if(procGhz != procGhz)
+        procGhz = 0; //NaN
+    else
+        procGhz /= 1000.0; //To GHz
+
     ffStrbufDestroy(&procGhzString);
 
     double biosLimit      = getGhz("/sys/devices/system/cpu/cpufreq/policy0/bios_limit",       "/sys/devices/system/cpu/cpu0/cpufreq/bios_limit");
@@ -124,7 +144,7 @@ void ffPrintCPU(FFinstance* instance)
     ) {
         ffStrbufDestroy(&name);
         ffStrbufDestroy(&vendor);
-        ffPrintError(instance, FF_CPU_MODULE_NAME, 0, &instance->config.cpuKey, &instance->config.cpuFormat, FF_CPU_NUM_FORMAT_ARGS, "No CPU info found in /proc/cpuinfo");
+        ffPrintError(instance, FF_CPU_MODULE_NAME, 0, &instance->config.cpu, "No CPU info found in /proc/cpuinfo");
         return;
     }
 
@@ -143,6 +163,10 @@ void ffPrintCPU(FFinstance* instance)
     ffStrbufSubstrBeforeFirstC(&namePretty, '@'); //Cut the speed output in the name as we append our own
     ffStrbufTrimRight(&namePretty, ' '); //If we removed the @ in previous step there was most likely a space before it
 
+    double cpuTemp;
+    if(instance->config.cpu.outputFormat.length > 0)
+        cpuTemp = detectCPUTemp(instance);
+
     FFstrbuf cpu;
     ffStrbufInitA(&cpu, 128);
 
@@ -164,7 +188,7 @@ void ffPrintCPU(FFinstance* instance)
     if(ghz > 0)
         ffStrbufAppendF(&cpu, " @ %.9gGHz", ghz);
 
-    ffPrintAndSaveToCache(instance, FF_CPU_MODULE_NAME, &instance->config.cpuKey, &cpu, &instance->config.cpuFormat, FF_CPU_NUM_FORMAT_ARGS, (FFformatarg[]){
+    ffPrintAndWriteToCache(instance, FF_CPU_MODULE_NAME, &instance->config.cpu, &cpu, FF_CPU_NUM_FORMAT_ARGS, (FFformatarg[]){
         {FF_FORMAT_ARG_TYPE_STRBUF, &name},
         {FF_FORMAT_ARG_TYPE_STRBUF, &namePretty},
         {FF_FORMAT_ARG_TYPE_STRBUF, &vendor},
@@ -172,6 +196,7 @@ void ffPrintCPU(FFinstance* instance)
         {FF_FORMAT_ARG_TYPE_INT, &numProcsAvailable},
         {FF_FORMAT_ARG_TYPE_INT, &physicalCores},
         {FF_FORMAT_ARG_TYPE_INT, &numProcs},
+        {FF_FORMAT_ARG_TYPE_DOUBLE, &cpuTemp},
         {FF_FORMAT_ARG_TYPE_DOUBLE, &biosLimit},
         {FF_FORMAT_ARG_TYPE_DOUBLE, &scalingMaxFreq},
         {FF_FORMAT_ARG_TYPE_DOUBLE, &scalingMinFreq},

src/modules/cpuUsage.c

@@ -1,6 +1,6 @@
 #include "fastfetch.h"
+#include "common/printing.h"
 
-#include <stdio.h>
 #include <unistd.h>
 
 #define FF_CPU_USAGE_MODULE_NAME "CPU Usage"
@@ -12,7 +12,7 @@ void ffPrintCPUUsage(FFinstance* instance)
     FILE* procStat = fopen("/proc/stat", "r");
     if(procStat == NULL)
     {
-        ffPrintError(instance, FF_CPU_USAGE_MODULE_NAME, 0, &instance->config.cpuUsageKey, &instance->config.cpuUsageFormat, FF_CPU_USAGE_NUM_FORMAT_ARGS, "fopen(\"/proc/stat\", \"r\") == NULL");
+        ffPrintError(instance, FF_CPU_USAGE_MODULE_NAME, 0, &instance->config.cpu, "fopen(\"""/proc/stat\", \"r\") == NULL");
         return;
     }
     if (fscanf(procStat, "cpu%ld%ld%ld%ld%ld%ld%ld", &user, &nice, &system, &idle, &iowait, &irq, &softirq) < 0) goto exit;
@@ -31,15 +31,15 @@ void ffPrintCPUUsage(FFinstance* instance)
     long totalOverPeriod = totalJiffies2 - totalJiffies1;
     double cpuPercent = (double)workOverPeriod / (double)totalOverPeriod * 100;
 
-    if(instance->config.cpuUsageFormat.length == 0)
+    if(instance->config.cpuUsage.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_CPU_USAGE_MODULE_NAME, 0, &instance->config.cpuUsageKey);
+        ffPrintLogoAndKey(instance, FF_CPU_USAGE_MODULE_NAME, 0, &instance->config.cpuUsage.key);
 
         printf("%.2lf%%\n", cpuPercent);
     }
     else
     {
-        ffPrintFormatString(instance, FF_CPU_USAGE_MODULE_NAME, 0, &instance->config.cpuUsageKey, &instance->config.cpuUsageFormat, NULL, FF_CPU_USAGE_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(instance, FF_CPU_USAGE_MODULE_NAME, 0, &instance->config.cpuUsage, FF_CPU_USAGE_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_DOUBLE, &cpuPercent}
         });
     }

src/modules/cursor.c

@@ -1,4 +1,12 @@
 #include "fastfetch.h"
+#include "common/properties.h"
+#include "common/printing.h"
+#include "common/parsing.h"
+#include "common/settings.h"
+#include "detection/gtk.h"
+#include "detection/displayserver.h"
+
+#include <stdlib.h>
 
 #define FF_CURSOR_MODULE_NAME "Cursor"
 #define FF_CURSOR_NUM_FORMAT_ARGS 2
@@ -12,9 +20,9 @@ static void printCursor(FFinstance* instance, FFstrbuf* cursorTheme, const FFstr
     if(cursorTheme->length == 0)
         ffStrbufAppendS(cursorTheme, "default");
 
-    if(instance->config.cursorFormat.length == 0)
+    if(instance->config.cursor.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_CURSOR_MODULE_NAME, 0, &instance->config.cursorKey);
+        ffPrintLogoAndKey(instance, FF_CURSOR_MODULE_NAME, 0, &instance->config.cursor.key);
         ffStrbufWriteTo(cursorTheme, stdout);
 
         if(cursorSize != NULL && cursorSize->length > 0)
@@ -28,7 +36,7 @@ static void printCursor(FFinstance* instance, FFstrbuf* cursorTheme, const FFstr
     }
     else
     {
-        ffPrintFormatString(instance, FF_CURSOR_MODULE_NAME, 0, &instance->config.cursorKey, &instance->config.cursorFormat, NULL, FF_CURSOR_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(instance, FF_CURSOR_MODULE_NAME, 0, &instance->config.cursor, FF_CURSOR_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, cursorTheme},
             {FF_FORMAT_ARG_TYPE_STRBUF, cursorSize}
         });
@@ -47,7 +55,7 @@ static void printCursorGTK(FFinstance* instance)
 
     if(gtk->cursor.length == 0)
     {
-        ffPrintError(instance, FF_CURSOR_MODULE_NAME, 0, &instance->config.cursorKey, &instance->config.cursorFormat, FF_CURSOR_NUM_FORMAT_ARGS, "Couldn't detect GTK Cursor");
+        ffPrintError(instance, FF_CURSOR_MODULE_NAME, 0, &instance->config.cursor, "Couldn't detect GTK Cursor");
         return;
     }
 
@@ -69,7 +77,7 @@ static void printCursorXFCE(FFinstance* instance)
 
     if(cursorTheme.length == 0)
     {
-        ffPrintError(instance, FF_CURSOR_MODULE_NAME, 0, &instance->config.cursorKey, &instance->config.cursorFormat, FF_CURSOR_NUM_FORMAT_ARGS, "Couldn't find xfce cursor in xfconf (xsettings::/Gtk/CursorThemeName)");
+        ffPrintError(instance, FF_CURSOR_MODULE_NAME, 0, &instance->config.cursor, "Couldn't find xfce cursor in xfconf (xsettings::/Gtk/CursorThemeName)");
         return;
     }
 
@@ -105,7 +113,7 @@ static void printCursorFromConfigFile(FFinstance* instance, const char* relative
     }
 
     if(cursorTheme.length == 0)
-        ffPrintError(instance, FF_CURSOR_MODULE_NAME, 0, &instance->config.cursorKey, &instance->config.cursorFormat, FF_CURSOR_NUM_FORMAT_ARGS, "Couldn't find cursor in %s", relativeFilePath);
+        ffPrintError(instance, FF_CURSOR_MODULE_NAME, 0, &instance->config.cursor, "Couldn't find cursor in %s", relativeFilePath);
     else
         printCursor(instance, &cursorTheme, &cursorSize);
 
@@ -147,7 +155,7 @@ static bool printCursorFromXDG(FFinstance* instance, bool user)
     if(user)
         ffParsePropFileHome(instance, ".icons/default/index.theme", "Inherits =", &theme);
     else
-        ffParsePropFile("/usr/share/icons/default/index.theme", "Inherits =", &theme);
+        ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/icons/default/index.theme", "Inherits =", &theme);
 
     if(theme.length == 0)
     {
@@ -185,15 +193,21 @@ static bool printCursorFromEnv(FFinstance* instance)
 void ffPrintCursor(FFinstance* instance)
 {
     #ifdef __ANDROID__
-        ffPrintError(instance, FF_CURSOR_MODULE_NAME, 0, &instance->config.cursorKey, &instance->config.cursorFormat, FF_CURSOR_NUM_FORMAT_ARGS, "Cursor detection is not supported on Android");
+        ffPrintError(instance, FF_CURSOR_MODULE_NAME, 0, &instance->config.cursor, "Cursor detection is not supported on Android");
         return;
     #endif
 
     const FFDisplayServerResult* wmde = ffConnectDisplayServer(instance);
 
+    if(ffStrbufCompS(&wmde->wmPrettyName, "WSLg") == 0)
+    {
+        ffPrintError(instance, FF_CURSOR_MODULE_NAME, 0, &instance->config.cursor, "WSLg uses native windows cursor");
+        return;
+    }
+
     if(ffStrbufIgnCaseCompS(&wmde->wmProtocolName, "TTY") == 0)
     {
-        ffPrintError(instance, FF_CURSOR_MODULE_NAME, 0, &instance->config.cursorKey, &instance->config.cursorFormat, FF_CURSOR_NUM_FORMAT_ARGS, "Cursor isn't supported in TTY");
+        ffPrintError(instance, FF_CURSOR_MODULE_NAME, 0, &instance->config.cursor, "Cursor isn't supported in TTY");
         return;
     }
 

src/modules/custom.c

@@ -1,7 +1,9 @@
 #include "fastfetch.h"
+#include "common/printing.h"
 
 void ffPrintCustom(FFinstance* instance, const char* key, const char* value)
 {
     ffPrintLogoAndKey(instance, key, 0, NULL);
-    puts(value);
+    ffPrintUserString(value);
+    puts(FASTFETCH_TEXT_MODIFIER_RESET);
 }

src/modules/date.c

@@ -1,17 +1,19 @@
 #include "fastfetch.h"
+#include "common/printing.h"
+#include "detection/datetime.h"
 
 #define FF_DATE_MODULE_NAME "Date"
 
 void ffPrintDate(FFinstance* instance)
 {
-    if(instance->config.dateFormat.length > 0)
+    if(instance->config.date.outputFormat.length > 0)
     {
-        ffPrintDateTimeFormat(instance, FF_DATE_MODULE_NAME, &instance->config.dateKey, &instance->config.dateFormat);
+        ffPrintDateTimeFormat(instance, FF_DATE_MODULE_NAME, &instance->config.date);
         return;
     }
 
     const FFDateTimeResult* datetime = ffDetectDateTime(instance);
-    ffPrintLogoAndKey(instance, FF_DATE_MODULE_NAME, 0, &instance->config.dateKey);
+    ffPrintLogoAndKey(instance, FF_DATE_MODULE_NAME, 0, &instance->config.date.key);
 
     //yyyy-mm-dd
     printf("%u-%s-%u\n", datetime->year, datetime->monthPretty.chars, datetime->dayInMonth);

src/modules/datetime.c

@@ -1,12 +1,14 @@
 #include "fastfetch.h"
+#include "common/printing.h"
+#include "detection/datetime.h"
 
 #define FF_DATETIME_MODULE_NAME "Date & Time"
 #define FF_DATETIME_NUM_FORMAT_ARGS 20
 
-void ffPrintDateTimeFormat(FFinstance* instance, const char* moduleName, const FFstrbuf* key, const FFstrbuf* format)
+void ffPrintDateTimeFormat(FFinstance* instance, const char* moduleName, const FFModuleArgs* moduleArgs)
 {
     const FFDateTimeResult* result = ffDetectDateTime(instance);
-    ffPrintFormatString(instance, moduleName, 0, key, format, NULL, FF_DATETIME_NUM_FORMAT_ARGS, (FFformatarg[]) {
+    ffPrintFormat(instance, moduleName, 0, moduleArgs, FF_DATETIME_NUM_FORMAT_ARGS, (FFformatarg[]) {
         {FF_FORMAT_ARG_TYPE_UINT16, &result->year},
         {FF_FORMAT_ARG_TYPE_UINT8, &result->yearShort},
         {FF_FORMAT_ARG_TYPE_UINT8, &result->month},
@@ -32,14 +34,14 @@ void ffPrintDateTimeFormat(FFinstance* instance, const char* moduleName, const F
 
 void ffPrintDateTime(FFinstance* instance)
 {
-    if(instance->config.dateTimeFormat.length > 0)
+    if(instance->config.dateTime.outputFormat.length > 0)
     {
-        ffPrintDateTimeFormat(instance, FF_DATETIME_MODULE_NAME, &instance->config.dateTimeKey, &instance->config.dateTimeFormat);
+        ffPrintDateTimeFormat(instance, FF_DATETIME_MODULE_NAME, &instance->config.dateTime);
         return;
     }
 
     const FFDateTimeResult* datetime = ffDetectDateTime(instance);
-    ffPrintLogoAndKey(instance, FF_DATETIME_MODULE_NAME, 0, &instance->config.dateTimeKey);
+    ffPrintLogoAndKey(instance, FF_DATETIME_MODULE_NAME, 0, &instance->config.dateTime.key);
 
     //yyyy-mm-dd hh:mm:ss
     printf("%u-%s-%u %s:%s:%s\n", datetime->year, datetime->monthPretty.chars, datetime->dayInMonth, datetime->hourPretty.chars, datetime->minutePretty.chars, datetime->secondPretty.chars);

src/modules/de.c

@@ -1,6 +1,6 @@
 #include "fastfetch.h"
-
-#include <string.h>
+#include "common/printing.h"
+#include "detection/displayserver.h"
 
 #define FF_DE_MODULE_NAME "DE"
 #define FF_DE_NUM_FORMAT_ARGS 3
@@ -8,7 +8,7 @@
 void ffPrintDesktopEnvironment(FFinstance* instance)
 {
     #ifdef __ANDROID__
-        ffPrintError(instance, FF_DE_MODULE_NAME, 0, &instance->config.deKey, &instance->config.deFormat, FF_DE_NUM_FORMAT_ARGS, "DE detection is not supported on Android");
+        ffPrintError(instance, FF_DE_MODULE_NAME, 0, &instance->config.de, "DE detection is not supported on Android");
         return;
     #endif
 
@@ -16,13 +16,13 @@ void ffPrintDesktopEnvironment(FFinstance* instance)
 
     if(result->dePrettyName.length == 0)
     {
-        ffPrintError(instance, FF_DE_MODULE_NAME, 0, &instance->config.deKey, &instance->config.deFormat, FF_DE_NUM_FORMAT_ARGS, "No DE found");
+        ffPrintError(instance, FF_DE_MODULE_NAME, 0, &instance->config.de, "No DE found");
         return;
     }
 
-    if(instance->config.deFormat.length == 0)
+    if(instance->config.de.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_DE_MODULE_NAME, 0, &instance->config.deKey);
+        ffPrintLogoAndKey(instance, FF_DE_MODULE_NAME, 0, &instance->config.de.key);
 
         ffStrbufWriteTo(&result->dePrettyName, stdout);
 
@@ -36,7 +36,7 @@ void ffPrintDesktopEnvironment(FFinstance* instance)
     }
     else
     {
-        ffPrintFormatString(instance, FF_DE_MODULE_NAME, 0, &instance->config.deKey, &instance->config.deFormat, NULL, FF_DE_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(instance, FF_DE_MODULE_NAME, 0, &instance->config.de, FF_DE_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->deProcessName},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->dePrettyName},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->deVersion}

src/modules/disk.c

@@ -1,4 +1,5 @@
 #include "fastfetch.h"
+#include "common/printing.h"
 
 #include <sys/statvfs.h>
 
@@ -7,7 +8,7 @@
 
 static void getKey(FFinstance* instance, FFstrbuf* key, const char* folderPath, bool showFolderPath)
 {
-    if(instance->config.diskKey.length == 0)
+    if(instance->config.disk.key.length == 0)
     {
         if(showFolderPath)
             ffStrbufAppendF(key, FF_DISK_MODULE_NAME" (%s)", folderPath);
@@ -16,7 +17,7 @@ static void getKey(FFinstance* instance, FFstrbuf* key, const char* folderPath,
     }
     else
     {
-        ffParseFormatString(key, &instance->config.diskKey, NULL, 1, (FFformatarg[]){
+        ffParseFormatString(key, &instance->config.disk.key, 1, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRING, folderPath}
         });
     }
@@ -24,26 +25,39 @@ static void getKey(FFinstance* instance, FFstrbuf* key, const char* folderPath,
 
 static void printStatvfs(FFinstance* instance, FFstrbuf* key, struct statvfs* fs)
 {
-    const uint32_t GB = 1024 * 1024 * 1024;
+    const double GB = 1024 * 1024 * 1024;
 
-    uint32_t total     = (uint32_t) ((fs->f_blocks * fs->f_frsize) / GB);
-    uint32_t available = (uint32_t) ((fs->f_bfree  * fs->f_frsize) / GB);
-    uint32_t used      = total - available;
-    uint8_t percentage = (uint8_t) ((used / (double) total) * 100.0);
+    double total     = ((double) (fs->f_blocks * fs->f_frsize)) / GB;
+    double available = ((double) (fs->f_bfree  * fs->f_frsize)) / GB;
+    double used      = total - available;
+    uint8_t percentage = (uint8_t) ((used / total) * 100.0);
 
     uint32_t files = (uint32_t) (fs->f_files - fs->f_ffree);
 
-    if(instance->config.diskFormat.length == 0)
+    if(instance->config.disk.outputFormat.length == 0)
     {
         ffPrintLogoAndKey(instance, key->chars, 0, NULL);
-        printf("%uGB / %uGB (%u%%)\n", used, total, percentage);
+
+        if(used >= 100.0)
+            printf("%.0f", used);
+        else
+            printf("%.1f", used);
+
+        fputs(" GB / ", stdout);
+
+        if(total >= 100.0)
+            printf("%.0f", total);
+        else
+            printf("%.1f", total);
+
+        printf("GiB (%u%%)\n", percentage);
     }
     else
     {
-        ffPrintFormatString(instance, key->chars, 0, NULL, &instance->config.diskFormat, NULL, FF_DISK_NUM_FORMAT_ARGS, (FFformatarg[]){
-            {FF_FORMAT_ARG_TYPE_UINT, &used},
-            {FF_FORMAT_ARG_TYPE_UINT, &total},
-            {FF_FORMAT_ARG_TYPE_UINT, &files},
+        ffPrintFormatString(instance, key->chars, 0, NULL, &instance->config.disk.outputFormat, FF_DISK_NUM_FORMAT_ARGS, (FFformatarg[]){
+            {FF_FORMAT_ARG_TYPE_DOUBLE, &used},
+            {FF_FORMAT_ARG_TYPE_DOUBLE, &total},
+            {FF_FORMAT_ARG_TYPE_DOUBLE, &files},
             {FF_FORMAT_ARG_TYPE_UINT8, &percentage}
         });
     }
@@ -64,9 +78,9 @@ static void printFolder(FFinstance* instance, const char* folderPath)
 
     struct statvfs fs;
     int ret = statvfs(folderPath, &fs);
-    if(ret != 0 && instance->config.diskFormat.length == 0)
+    if(ret != 0 && instance->config.disk.outputFormat.length == 0)
     {
-        ffPrintError(instance, key.chars, 0, NULL, &instance->config.diskFormat, FF_DISK_NUM_FORMAT_ARGS, "statvfs(\"%s\", &fs) != 0 (%i)", folderPath, ret);
+        ffPrintErrorString(instance, key.chars, 0, NULL, &instance->config.disk.errorFormat, "statvfs(\"%s\", &fs) != 0 (%i)", folderPath, ret);
         ffStrbufDestroy(&key);
         return;
     }
@@ -79,18 +93,17 @@ void ffPrintDisk(FFinstance* instance)
 {
     if(instance->config.diskFolders.length == 0)
     {
-
         struct statvfs fsRoot;
         int rootRet = statvfs("/", &fsRoot);
 
         struct statvfs fsHome;
-        int homeRet = statvfs("/home", &fsHome);
+        int homeRet = statvfs(FASTFETCH_TARGET_DIR_HOME, &fsHome);
 
         if(rootRet != 0 && homeRet != 0)
         {
             FF_STRBUF_CREATE(key);
             getKey(instance, &key, "", false);
-            ffPrintError(instance, key.chars, 0, NULL, &instance->config.diskFormat, FF_DISK_NUM_FORMAT_ARGS, "statvfs failed for both / and /home");
+            ffPrintErrorString(instance, key.chars, 0, NULL, &instance->config.disk.errorFormat, "statvfs failed for both / and " FASTFETCH_TARGET_DIR_HOME);
             ffStrbufDestroy(&key);
             return;
         }
@@ -99,7 +112,7 @@ void ffPrintDisk(FFinstance* instance)
             printStatvfsCreateKey(instance, "/", &fsRoot);
 
         if(homeRet == 0 && (rootRet != 0 || fsRoot.f_fsid != fsHome.f_fsid))
-            printStatvfsCreateKey(instance, "/home", &fsHome);
+            printStatvfsCreateKey(instance, FASTFETCH_TARGET_DIR_HOME, &fsHome);
     }
     else
     {
@@ -109,7 +122,7 @@ void ffPrintDisk(FFinstance* instance)
         {
             FF_STRBUF_CREATE(key);
             getKey(instance, &key, "", false);
-            ffPrintError(instance, key.chars, 0, NULL, &instance->config.diskFormat, FF_DISK_NUM_FORMAT_ARGS, "Custom disk folders string doesn't contain any folders");
+            ffPrintErrorString(instance, key.chars, 0, NULL, &instance->config.disk.errorFormat, "Custom disk folders string doesn't contain any folders");
             ffStrbufDestroy(&key);
             return;
         }

src/modules/font.c

@@ -1,4 +1,10 @@
 #include "fastfetch.h"
+#include "common/font.h"
+#include "common/printing.h"
+#include "common/parsing.h"
+#include "detection/qt.h"
+#include "detection/gtk.h"
+#include "detection/displayserver.h"
 
 #define FF_FONT_MODULE_NAME "Font"
 #define FF_FONT_NUM_FORMAT_ARGS 21
@@ -6,7 +12,7 @@
 void ffPrintFont(FFinstance* instance)
 {
     #ifdef __ANDROID__
-        ffPrintError(instance, FF_FONT_MODULE_NAME, 0, &instance->config.fontKey, &instance->config.fontFormat, FF_FONT_NUM_FORMAT_ARGS, "Font detection is not supported on Android");
+        ffPrintError(instance, FF_FONT_MODULE_NAME, 0, &instance->config.font, "Font detection is not supported on Android");
         return;
     #endif
 
@@ -14,18 +20,18 @@ void ffPrintFont(FFinstance* instance)
 
     if(ffStrbufIgnCaseCompS(&wmde->wmProtocolName, "TTY") == 0)
     {
-        ffPrintError(instance, FF_FONT_MODULE_NAME, 0, &instance->config.fontKey, &instance->config.fontFormat, FF_FONT_NUM_FORMAT_ARGS, "Font isn't supported in TTY");
+        ffPrintError(instance, FF_FONT_MODULE_NAME, 0, &instance->config.font, "Font isn't supported in TTY");
         return;
     }
 
-    const FFstrbuf* plasmaRaw = &ffDetectPlasma(instance)->font;
+    const FFstrbuf* plasmaRaw = &ffDetectQt(instance)->font;
     const FFstrbuf* gtk2Raw = &ffDetectGTK2(instance)->font;
     const FFstrbuf* gtk3Raw = &ffDetectGTK3(instance)->font;
     const FFstrbuf* gtk4Raw = &ffDetectGTK4(instance)->font;
 
     if(plasmaRaw->length == 0 && gtk2Raw->length == 0 && gtk3Raw->length == 0 && gtk4Raw->length == 0)
     {
-        ffPrintError(instance, FF_FONT_MODULE_NAME, 0, &instance->config.fontKey, &instance->config.fontFormat, FF_FONT_NUM_FORMAT_ARGS, "No fonts found");
+        ffPrintError(instance, FF_FONT_MODULE_NAME, 0, &instance->config.font, "No fonts found");
         return;
     }
 
@@ -43,15 +49,15 @@ void ffPrintFont(FFinstance* instance)
 
     FFstrbuf gtk;
     ffStrbufInitA(&gtk, 64);
-    ffGetGtkPretty(&gtk, &gtk2.pretty, &gtk3.pretty, &gtk4.pretty);
+    ffParseGTK(&gtk, &gtk2.pretty, &gtk3.pretty, &gtk4.pretty);
 
-    if(instance->config.fontFormat.length == 0)
+    if(instance->config.font.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_FONT_MODULE_NAME, 0, &instance->config.fontKey);
+        ffPrintLogoAndKey(instance, FF_FONT_MODULE_NAME, 0, &instance->config.font.key);
         if(plasma.pretty.length > 0)
         {
             ffStrbufWriteTo(&plasma.pretty, stdout);
-            fputs(" [Plasma]", stdout);
+            fputs(" [QT]", stdout);
 
             if(gtk.length > 0)
                 fputs(", ", stdout);
@@ -60,7 +66,7 @@ void ffPrintFont(FFinstance* instance)
     }
     else
     {
-        ffPrintFormatString(instance, FF_FONT_MODULE_NAME, 0, &instance->config.fontKey, &instance->config.fontFormat, NULL, FF_FONT_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(instance, FF_FONT_MODULE_NAME, 0, &instance->config.font, FF_FONT_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, plasmaRaw},
             {FF_FORMAT_ARG_TYPE_STRBUF, &plasma.name},
             {FF_FORMAT_ARG_TYPE_STRBUF, &plasma.size},

src/modules/gpu.c

@@ -1,185 +1,16 @@
 #include "fastfetch.h"
+#include "common/printing.h"
+#include "common/caching.h"
+#include "common/parsing.h"
+#include "detection/temps.h"
+#include "detection/vulkan.h"
 
-#include <string.h>
+#include <stdlib.h>
 
 #define FF_GPU_MODULE_NAME "GPU"
-#define FF_GPU_NUM_FORMAT_ARGS 5
+#define FF_GPU_NUM_FORMAT_ARGS 6
 
-typedef struct GPUResult
-{
-    FFstrbuf vendor;
-    FFstrbuf name;
-    FFstrbuf driver;
-} GPUResult;
-
-#ifdef FF_HAVE_VULKAN
-#include <vulkan/vulkan.h>
-
-static void vulkanFillGPUs(FFinstance* instance, FFlist* results)
-{
-    FF_LIBRARY_LOAD(vulkan, instance->config.libVulkan, , "libvulkan.so", "libvulkan.so.1")
-    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkCreateInstance,)
-    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkDestroyInstance,)
-    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkEnumeratePhysicalDevices,)
-    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkGetPhysicalDeviceProperties,)
-
-    //Some drivers (nvdc) print messages to stdout
-    //and thats the best way i found to disable that
-    ffSuppressIO(true);
-
-    const VkApplicationInfo applicationInfo = {
-        .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
-        .pNext = NULL,
-        .pApplicationName = FASTFETCH_PROJECT_NAME,
-        .applicationVersion = VK_MAKE_VERSION(FASTFETCH_PROJECT_VERSION_MAJOR, 0, 0),
-        .pEngineName = "vulkanPrintGPUs",
-        .engineVersion = VK_MAKE_VERSION(FASTFETCH_PROJECT_VERSION_MAJOR, 0, 0),
-        .apiVersion = VK_API_VERSION_1_0,
-    };
-
-    const VkInstanceCreateInfo instanceCreateInfo = {
-        .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
-        .pNext = NULL,
-        .pApplicationInfo = &applicationInfo,
-        .enabledLayerCount = 0,
-        .ppEnabledLayerNames = NULL,
-        .enabledExtensionCount = 0,
-        .ppEnabledExtensionNames = NULL,
-        .flags = 0
-    };
-
-    VkInstance vkInstance;
-    if(ffvkCreateInstance(&instanceCreateInfo, NULL, &vkInstance) != VK_SUCCESS)
-    {
-        dlclose(vulkan);
-        ffSuppressIO(false);
-        return;
-    }
-
-    uint32_t physicalDeviceCount;
-    if(ffvkEnumeratePhysicalDevices(vkInstance, &physicalDeviceCount, NULL) != VK_SUCCESS)
-    {
-        ffvkDestroyInstance(vkInstance, NULL);
-        dlclose(vulkan);
-        ffSuppressIO(false);
-        return;
-    }
-
-    VkPhysicalDevice* physicalDevices = malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount);
-    if(ffvkEnumeratePhysicalDevices(vkInstance, &physicalDeviceCount, physicalDevices) != VK_SUCCESS)
-    {
-        free(physicalDevices);
-        ffvkDestroyInstance(vkInstance, NULL);
-        dlclose(vulkan);
-        ffSuppressIO(false);
-        return;
-    }
-
-    for(uint32_t i = 0; i < physicalDeviceCount; i++)
-    {
-        VkPhysicalDeviceProperties physicalDeviceProperties;
-        ffvkGetPhysicalDeviceProperties(physicalDevices[i], &physicalDeviceProperties);
-
-        //We don't want softare rasterizers
-        if(physicalDeviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU)
-            continue;
-
-        GPUResult* result = ffListAdd(results);
-        ffStrbufInit(&result->vendor);
-        ffStrbufInit(&result->name);
-        ffStrbufInit(&result->driver);
-
-        ffStrbufAppendS(&result->name, physicalDeviceProperties.deviceName);
-    }
-
-    free(physicalDevices);
-    ffvkDestroyInstance(vkInstance, NULL);
-    dlclose(vulkan);
-    ffSuppressIO(false);
-    return;
-}
-
-#endif
-
-#ifdef FF_HAVE_LIBPCI
-#include <pci/pci.h>
-#include <unistd.h>
-
-//see https://github.com/pciutils/pciutils/blob/5bdf63b6b1bc35b59c4b3f47f7ca83ca1868155b/ls-kernel.c#L220
-static void pciGetDriver(struct pci_dev* dev, FFstrbuf* driver, char*(*ffpci_get_param)(struct pci_access*, char*))
-{
-    if(dev->access->method != PCI_ACCESS_SYS_BUS_PCI)
-        return;
-
-    const char* base = ffpci_get_param(dev->access, "sysfs.path");
-    if(!ffStrSet(base))
-        return;
-
-    FFstrbuf path;
-    ffStrbufInitA(&path, 64);
-    ffStrbufAppendF(&path, "%s/devices/%04x:%02x:%02x.%d/driver", base, dev->domain, dev->bus, dev->dev, dev->func);
-
-    ffStrbufEnsureFree(driver, 1023);
-    ssize_t resultLength = readlink(path.chars, driver->chars, driver->allocated - 1); //-1 for null terminator
-    if(resultLength > 0)
-    {
-        driver->length = (uint32_t) resultLength;
-        driver->chars[resultLength] = '\0';
-        ffStrbufSubstrAfterLastC(driver, '/');
-    }
-
-    ffStrbufDestroy(&path);
-}
-
-static void pciFillGPUs(FFinstance* instance, FFlist* results)
-{
-    FF_LIBRARY_LOAD(pci, instance->config.libPCI, , "libpci.so", "libpci.so.3")
-    FF_LIBRARY_LOAD_SYMBOL(pci, pci_alloc,)
-    FF_LIBRARY_LOAD_SYMBOL(pci, pci_init,)
-    FF_LIBRARY_LOAD_SYMBOL(pci, pci_scan_bus,)
-    FF_LIBRARY_LOAD_SYMBOL(pci, pci_fill_info,)
-    FF_LIBRARY_LOAD_SYMBOL(pci, pci_lookup_name,)
-    FF_LIBRARY_LOAD_SYMBOL(pci, pci_get_param,)
-    FF_LIBRARY_LOAD_SYMBOL(pci, pci_cleanup,)
-
-    struct pci_access *pacc = ffpci_alloc();
-    ffpci_init(pacc);
-    ffpci_scan_bus(pacc);
-
-    struct pci_dev* dev;
-    for (dev=pacc->devices; dev; dev=dev->next)
-    {
-        ffpci_fill_info(dev, PCI_FILL_IDENT | PCI_FILL_CLASS);
-        char class[1024];
-        ffpci_lookup_name(pacc, class, sizeof(class), PCI_LOOKUP_CLASS, dev->device_class);
-        if(
-            strcasecmp("VGA compatible controller", class) == 0 ||
-            strcasecmp("3D controller", class)             == 0 ||
-            strcasecmp("Display controller", class)        == 0
-        ) {
-            GPUResult* result = ffListAdd(results);
-
-            ffStrbufInitA(&result->vendor, 256);
-            ffpci_lookup_name(pacc, result->vendor.chars, (int) result->vendor.allocated -1, PCI_LOOKUP_VENDOR, dev->vendor_id, dev->device_id);
-            ffStrbufRecalculateLength(&result->vendor);
-
-            ffStrbufInitA(&result->name, 256);
-            ffpci_lookup_name(pacc, result->name.chars, (int) result->name.allocated - 1, PCI_LOOKUP_DEVICE, dev->vendor_id, dev->device_id);
-            ffStrbufRecalculateLength(&result->name);
-
-            ffStrbufInit(&result->driver);
-            if(instance->config.gpuFormat.length > 0) //We only need it for the format string, so don't detect it if it isn't needed
-                pciGetDriver(dev, &result->driver, ffpci_get_param);
-        };
-    }
-
-    ffpci_cleanup(pacc);
-    dlclose(pci);
-}
-
-#endif
-
-static void printGPUResult(FFinstance* instance, uint8_t index, FFcache* cache, GPUResult* result)
+static void printGPUResult(FFinstance* instance, uint8_t index, FFcache* cache, FFGPUResult* result)
 {
     const char* vendorPretty;
     if(ffStrbufIgnCaseCompS(&result->vendor, "Advanced Micro Devices, Inc. [AMD/ATI]") == 0)
@@ -207,12 +38,13 @@ static void printGPUResult(FFinstance* instance, uint8_t index, FFcache* cache,
 
     ffStrbufAppend(&gpu, &namePretty);
 
-    ffPrintAndAppendToCache(instance, FF_GPU_MODULE_NAME, index, &instance->config.gpuKey, cache, &gpu, &instance->config.gpuFormat, FF_GPU_NUM_FORMAT_ARGS, (FFformatarg[]){
+    ffPrintAndAppendToCache(instance, FF_GPU_MODULE_NAME, index, &instance->config.gpu, cache, &gpu, FF_GPU_NUM_FORMAT_ARGS, (FFformatarg[]){
         {FF_FORMAT_ARG_TYPE_STRBUF, &result->vendor},
         {FF_FORMAT_ARG_TYPE_STRING, vendorPretty},
         {FF_FORMAT_ARG_TYPE_STRBUF, &result->name},
         {FF_FORMAT_ARG_TYPE_STRBUF, &namePretty},
         {FF_FORMAT_ARG_TYPE_STRBUF, &result->driver},
+        {FF_FORMAT_ARG_TYPE_DOUBLE, &result->temperature}
     });
 
     ffStrbufDestroy(&result->vendor);
@@ -222,32 +54,168 @@ static void printGPUResult(FFinstance* instance, uint8_t index, FFcache* cache,
     ffStrbufDestroy(&namePretty);
 }
 
-void ffPrintGPU(FFinstance* instance)
+static void printGPUList(FFinstance* instance, const FFlist* list)
 {
-    if(ffPrintFromCache(instance, FF_GPU_MODULE_NAME, &instance->config.gpuKey, &instance->config.gpuFormat, FF_GPU_NUM_FORMAT_ARGS))
-        return;
-
-    FFlist gpus;
-    ffListInitA(&gpus, sizeof(GPUResult), 4);
-
     FFcache cache;
     ffCacheOpenWrite(instance, FF_GPU_MODULE_NAME, &cache);
 
-    #ifdef FF_HAVE_LIBPCI
-        pciFillGPUs(instance, &gpus);
-    #endif
-
-    #ifdef FF_HAVE_VULKAN
-        if(gpus.length == 0)
-            vulkanFillGPUs(instance, &gpus);
-    #endif
-
-    for(uint8_t i = 0; i < (uint8_t) gpus.length; i++)
-        printGPUResult(instance, gpus.length == 1 ? 0 : (uint8_t) (i + 1), &cache, ffListGet(&gpus, i));
-
-    if(gpus.length == 0)
-        ffPrintError(instance, FF_GPU_MODULE_NAME, 0, &instance->config.gpuKey, &instance->config.gpuFormat, FF_GPU_NUM_FORMAT_ARGS, "No GPUs found.");
+    for(uint8_t i = 0; i < (uint8_t) list->length; i++)
+        printGPUResult(instance, list->length == 1 ? 0 : (uint8_t) (i + 1), &cache, ffListGet(list, i));
 
     ffCacheClose(&cache);
-    ffListDestroy(&gpus);
+}
+
+#ifdef FF_HAVE_LIBPCI
+#include "common/library.h"
+#include <string.h>
+#include <unistd.h>
+#include <pci/pci.h>
+
+//see https://github.com/pciutils/pciutils/blob/5bdf63b6b1bc35b59c4b3f47f7ca83ca1868155b/ls-kernel.c#L220
+static void pciGetDriver(struct pci_dev* dev, FFstrbuf* driver, char*(*ffpci_get_param)(struct pci_access*, char*))
+{
+    if(dev->access->method != PCI_ACCESS_SYS_BUS_PCI)
+        return;
+
+    const char* base = ffpci_get_param(dev->access, "sysfs.path");
+    if(!ffStrSet(base))
+        return;
+
+    FFstrbuf path;
+    ffStrbufInitA(&path, 64);
+    ffStrbufAppendF(&path, "%s/devices/%04x:%02x:%02x.%d/driver", base, dev->domain, dev->bus, dev->dev, dev->func);
+
+    ffStrbufEnsureFree(driver, 1023);
+    ssize_t resultLength = readlink(path.chars, driver->chars, driver->allocated - 1); //-1 for null terminator
+    if(resultLength > 0)
+    {
+        driver->length = (uint32_t) resultLength;
+        driver->chars[resultLength] = '\0';
+        ffStrbufSubstrAfterLastC(driver, '/');
+    }
+
+    ffStrbufDestroy(&path);
+}
+
+static double pciGetTemperatur(const FFinstance* instance, uint16_t deviceClass)
+{
+    const FFTempsResult* tempsResult = ffDetectTemps(instance);
+
+    for(uint32_t i = 0; i < tempsResult->values.length; i++)
+    {
+        FFTempValue* tempValue = ffListGet(&tempsResult->values, i);
+
+        uint32_t tempClass;
+        if(sscanf(tempValue->deviceClass.chars, "%x", &tempClass) != 1)
+            continue;
+
+        //The kernel exposes the device class multiplied by 256 for some reason
+        if(tempClass == deviceClass * 256)
+            return tempValue->value;
+    }
+
+    return 0.0 / 0.0; //NaN
+}
+
+static bool pciPrintGPUs(FFinstance* instance)
+{
+    FF_LIBRARY_LOAD(pci, instance->config.libPCI, false, "libpci.so", 4)
+    FF_LIBRARY_LOAD_SYMBOL(pci, pci_alloc, false)
+    FF_LIBRARY_LOAD_SYMBOL(pci, pci_init, false)
+    FF_LIBRARY_LOAD_SYMBOL(pci, pci_scan_bus, false)
+    FF_LIBRARY_LOAD_SYMBOL(pci, pci_fill_info, false)
+    FF_LIBRARY_LOAD_SYMBOL(pci, pci_lookup_name, false)
+    FF_LIBRARY_LOAD_SYMBOL(pci, pci_get_param, false)
+    FF_LIBRARY_LOAD_SYMBOL(pci, pci_cleanup, false)
+
+    FFlist results;
+    ffListInit(&results, sizeof(FFGPUResult));
+
+    struct pci_access *pacc = ffpci_alloc();
+    ffpci_init(pacc);
+    ffpci_scan_bus(pacc);
+
+    struct pci_dev* dev;
+    for (dev=pacc->devices; dev; dev=dev->next)
+    {
+        ffpci_fill_info(dev, PCI_FILL_IDENT | PCI_FILL_CLASS);
+        char class[1024];
+        ffpci_lookup_name(pacc, class, sizeof(class), PCI_LOOKUP_CLASS, dev->device_class);
+        if(
+            strcasecmp("VGA compatible controller", class) == 0 ||
+            strcasecmp("3D controller", class)             == 0 ||
+            strcasecmp("Display controller", class)        == 0
+        ) {
+            FFGPUResult* result = ffListAdd(&results);
+
+            ffStrbufInitA(&result->vendor, 256);
+            ffpci_lookup_name(pacc, result->vendor.chars, (int) ffStrbufGetFree(&result->vendor), PCI_LOOKUP_VENDOR, dev->vendor_id, dev->device_id);
+            ffStrbufRecalculateLength(&result->vendor);
+
+            ffStrbufInitA(&result->name, 256);
+            ffpci_lookup_name(pacc, result->name.chars, (int) ffStrbufGetFree(&result->name), PCI_LOOKUP_DEVICE, dev->vendor_id, dev->device_id);
+            ffStrbufRecalculateLength(&result->name);
+
+            ffStrbufInit(&result->driver);
+            result->temperature = 0;
+
+            //We only need it for the format string, so don't detect it if it isn't needed
+            if(instance->config.gpu.outputFormat.length > 0)
+            {
+                pciGetDriver(dev, &result->driver, ffpci_get_param);
+                result->temperature = pciGetTemperatur(instance, dev->device_class);
+            }
+        };
+    }
+
+    ffpci_cleanup(pacc);
+    dlclose(pci);
+
+    if(results.length == 0)
+    {
+        ffListDestroy(&results);
+        return false;
+    }
+
+    printGPUList(instance, &results);
+
+    ffListDestroy(&results);
+    return true;
+}
+
+#endif
+
+static bool vulkanPrintGPUs(FFinstance* instance)
+{
+    const FFVulkanResult* result = ffDetectVulkan(instance);
+    if(result->devices.length == 0)
+        return false;
+
+    printGPUList(instance, &result->devices);
+    return true;
+}
+
+void ffPrintGPU(FFinstance* instance)
+{
+    if(ffPrintFromCache(instance, FF_GPU_MODULE_NAME, &instance->config.gpu, FF_GPU_NUM_FORMAT_ARGS))
+        return;
+
+    if(
+        getenv("WSLENV") != NULL ||
+        getenv("WSL_DISTRO") != NULL ||
+        getenv("WSL_INTEROP") != NULL
+    ) {
+        ffPrintError(instance, FF_GPU_MODULE_NAME, 0, &instance->config.gpu, "WSL doesn't expose senseful GPU names");
+        return;
+    }
+
+    #ifdef FF_HAVE_LIBPCI
+        if(pciPrintGPUs(instance))
+            return;
+    #endif
+
+    if(vulkanPrintGPUs(instance))
+        return;
+
+    ffPrintError(instance, FF_GPU_MODULE_NAME, 0, &instance->config.gpu, "No GPUs found.");
 }

src/modules/host.c

@@ -1,10 +1,19 @@
 #include "fastfetch.h"
+#include "common/printing.h"
+#include "common/caching.h"
 
-#include <ctype.h>
+#include <stdlib.h>
 
 #define FF_HOST_MODULE_NAME "Host"
-#define FF_HOST_NUM_FORMAT_ARGS 3
+#define FF_HOST_NUM_FORMAT_ARGS 15
 
+#ifndef __ANDROID__
+    #include "common/io.h"
+#else
+    #include <ctype.h>
+#endif
+
+#ifndef __ANDROID__
 static bool hostValueSet(FFstrbuf* value)
 {
     ffStrbufTrimRight(value, '\n');
@@ -32,100 +41,156 @@ static bool hostValueSet(FFstrbuf* value)
     ;
 }
 
-#ifndef __ANDROID__
 static void getHostValue(const char* devicesPath, const char* classPath, FFstrbuf* buffer)
 {
-    ffGetFileContent(devicesPath, buffer);
+    ffReadFileBuffer(devicesPath, buffer);
 
     if(buffer->length == 0)
-        ffGetFileContent(classPath, buffer);
+        ffReadFileBuffer(classPath, buffer);
 }
 #endif
 
 void ffPrintHost(FFinstance* instance)
 {
-    if(ffPrintFromCache(instance, FF_HOST_MODULE_NAME, &instance->config.hostKey, &instance->config.hostFormat, FF_HOST_NUM_FORMAT_ARGS))
+    if(ffPrintFromCache(instance, FF_HOST_MODULE_NAME, &instance->config.host, FF_HOST_NUM_FORMAT_ARGS))
         return;
 
-    FFstrbuf family;
-    ffStrbufInit(&family);
+    FFstrbuf product_family;
+    ffStrbufInit(&product_family);
     #ifndef __ANDROID__
-        getHostValue("/sys/devices/virtual/dmi/id/product_family", "/sys/class/dmi/id/product_family", &family);
+        getHostValue("/sys/devices/virtual/dmi/id/product_family", "/sys/class/dmi/id/product_family", &product_family);
+        if(!hostValueSet(&product_family))
+            ffStrbufClear(&product_family);
     #else
-        ffSettingsGetAndroidProperty("ro.product.device", &family);
+        ffSettingsGetAndroidProperty("ro.product.device", &product_family);
     #endif
-    bool familySet = hostValueSet(&family);
 
-    FFstrbuf name;
-    ffStrbufInit(&name);
+    FFstrbuf product_name;
+    ffStrbufInit(&product_name);
     #ifndef __ANDROID__
-        getHostValue("/sys/devices/virtual/dmi/id/product_name", "/sys/class/dmi/id/product_name", &name);
+        getHostValue("/sys/devices/virtual/dmi/id/product_name", "/sys/class/dmi/id/product_name", &product_name);
 
-        if(name.length == 0)
-            ffGetFileContent("/sys/firmware/devicetree/base/model", &name);
+        if(product_name.length == 0)
+            ffReadFileBuffer("/sys/firmware/devicetree/base/model", &product_name);
 
-        if(name.length == 0)
-            ffGetFileContent("/tmp/sysinfo/model", &name);
+        if(product_name.length == 0)
+            ffReadFileBuffer("/tmp/sysinfo/model", &product_name);
 
-        if(ffStrbufStartsWithS(&name, "Standard PC"))
+        if(ffStrbufStartsWithS(&product_name, "Standard PC"))
         {
             FFstrbuf copy;
-            ffStrbufInitCopy(&copy, &name);
-            ffStrbufSetS(&name, "KVM/QEMU ");
-            ffStrbufAppend(&name, &copy);
+            ffStrbufInitCopy(&copy, &product_name);
+            ffStrbufSetS(&product_name, "KVM/QEMU ");
+            ffStrbufAppend(&product_name, &copy);
             ffStrbufDestroy(&copy);
         }
+
+        if(!hostValueSet(&product_name))
+            ffStrbufClear(&product_name);
+
+        //On WSL, the real host can't be detected. Instead use WSL as host.
+        if(product_name.length == 0 && product_family.length == 0 && (
+            getenv("WSLENV") != NULL ||
+            getenv("WSL_DISTRO") != NULL ||
+            getenv("WSL_INTEROP") != NULL
+        )) ffStrbufAppendS(&product_name, "Windows Subsystem for Linux");
     #else
-        ffSettingsGetAndroidProperty("ro.product.brand", &name);
-        if(name.length > 0){
-            name.chars[0] = (char) toupper(name.chars[0]);
-            ffStrbufAppendC(&name, ' ');
+        ffSettingsGetAndroidProperty("ro.product.brand", &product_name);
+        if(product_name.length > 0){
+            product_name.chars[0] = (char) toupper(product_name.chars[0]);
+            ffStrbufAppendC(&product_name, ' ');
         }
 
-        if(!ffSettingsGetAndroidProperty("ro.product.model", &name))
-            ffSettingsGetAndroidProperty("ro.product.name", &name);
+        if(!ffSettingsGetAndroidProperty("ro.product.model", &product_name))
+            ffSettingsGetAndroidProperty("ro.product.name", &product_name);
 
-        ffStrbufTrimRight(&name, ' ');
+        ffStrbufTrimRight(&product_name, ' ');
     #endif
-    bool nameSet = hostValueSet(&name);
 
-    FFstrbuf version;
-    ffStrbufInit(&version);
-    #ifndef __ANDROID__
-        getHostValue("/sys/devices/virtual/dmi/id/product_version", "/sys/class/dmi/id/product_version", &version);
-    #endif
-    bool versionSet = hostValueSet(&version);
-
-    if(!familySet && !nameSet)
+    if(product_family.length == 0 && product_name.length == 0)
     {
-        ffStrbufDestroy(&family);
-        ffStrbufDestroy(&name);
-        ffStrbufDestroy(&version);
-        ffPrintError(instance, FF_HOST_MODULE_NAME, 0, &instance->config.hostKey, &instance->config.hostFormat, FF_HOST_NUM_FORMAT_ARGS, "neither family nor name is set by O.E.M.");
+        ffStrbufDestroy(&product_family);
+        ffStrbufDestroy(&product_name);
+        ffPrintError(instance, FF_HOST_MODULE_NAME, 0, &instance->config.host, "neither product_family nor product_name is set by O.E.M.");
         return;
     }
 
+    #ifdef __ANDROID__
+        #define FF_HOST_DATA(name) \
+            FFstrbuf name; \
+            ffStrbufInitA(&name, 0);
+    #else
+        #define FF_HOST_DATA(name) \
+            FFstrbuf name; \
+            ffStrbufInit(&name); \
+            getHostValue("/sys/devices/virtual/dmi/id/"#name, "/sys/class/dmi/id/"#name, &name); \
+            if(!hostValueSet(&name)) \
+                ffStrbufClear(&name);
+    #endif
+
+    FF_HOST_DATA(product_version)
+    FF_HOST_DATA(product_sku)
+    FF_HOST_DATA(bios_date)
+    FF_HOST_DATA(bios_release)
+    FF_HOST_DATA(bios_vendor)
+    FF_HOST_DATA(bios_version)
+    FF_HOST_DATA(board_name)
+    FF_HOST_DATA(board_vendor)
+    FF_HOST_DATA(board_version)
+    FF_HOST_DATA(chassis_type)
+    FF_HOST_DATA(chassis_vendor)
+    FF_HOST_DATA(chassis_version)
+    FF_HOST_DATA(sys_vendor)
+
     FFstrbuf host;
     ffStrbufInit(&host);
 
-    if(nameSet)
-        ffStrbufAppend(&host, &name);
+    if(product_name.length > 0)
+        ffStrbufAppend(&host, &product_name);
     else
-        ffStrbufAppend(&host, &family);
+        ffStrbufAppend(&host, &product_family);
 
-    if(versionSet)
+    if(product_version.length > 0)
     {
         ffStrbufAppendC(&host, ' ');
-        ffStrbufAppend(&host, &version);
+        ffStrbufAppend(&host, &product_version);
     }
 
-    ffPrintAndSaveToCache(instance, FF_HOST_MODULE_NAME, &instance->config.hostKey, &host, &instance->config.hostFormat, FF_HOST_NUM_FORMAT_ARGS, (FFformatarg[]) {
-        {FF_FORMAT_ARG_TYPE_STRBUF, &family},
-        {FF_FORMAT_ARG_TYPE_STRBUF, &name},
-        {FF_FORMAT_ARG_TYPE_STRBUF, &version}
+    ffPrintAndWriteToCache(instance, FF_HOST_MODULE_NAME, &instance->config.host, &host, FF_HOST_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        {FF_FORMAT_ARG_TYPE_STRBUF, &product_family},
+        {FF_FORMAT_ARG_TYPE_STRBUF, &product_name},
+        {FF_FORMAT_ARG_TYPE_STRBUF, &product_version},
+        {FF_FORMAT_ARG_TYPE_STRBUF, &product_sku},
+        {FF_FORMAT_ARG_TYPE_STRBUF, &bios_date},
+        {FF_FORMAT_ARG_TYPE_STRBUF, &bios_release},
+        {FF_FORMAT_ARG_TYPE_STRBUF, &bios_vendor},
+        {FF_FORMAT_ARG_TYPE_STRBUF, &bios_version},
+        {FF_FORMAT_ARG_TYPE_STRBUF, &board_name},
+        {FF_FORMAT_ARG_TYPE_STRBUF, &board_vendor},
+        {FF_FORMAT_ARG_TYPE_STRBUF, &board_version},
+        {FF_FORMAT_ARG_TYPE_STRBUF, &chassis_type},
+        {FF_FORMAT_ARG_TYPE_STRBUF, &chassis_vendor},
+        {FF_FORMAT_ARG_TYPE_STRBUF, &chassis_version},
+        {FF_FORMAT_ARG_TYPE_STRBUF, &sys_vendor}
     });
 
-    ffStrbufDestroy(&family);
-    ffStrbufDestroy(&name);
-    ffStrbufDestroy(&version);
+    ffStrbufDestroy(&product_family);
+    ffStrbufDestroy(&product_name);
+
+    //On Android, all of them get initialized without heap, so no need to destroy them.
+    #ifndef __ANDROID__
+        ffStrbufDestroy(&product_version);
+        ffStrbufDestroy(&product_sku);
+        ffStrbufDestroy(&bios_date);
+        ffStrbufDestroy(&bios_release);
+        ffStrbufDestroy(&bios_vendor);
+        ffStrbufDestroy(&bios_version);
+        ffStrbufDestroy(&board_name);
+        ffStrbufDestroy(&board_vendor);
+        ffStrbufDestroy(&board_version);
+        ffStrbufDestroy(&chassis_type);
+        ffStrbufDestroy(&chassis_vendor);
+        ffStrbufDestroy(&chassis_version);
+        ffStrbufDestroy(&sys_vendor);
+    #endif
 }

src/modules/icons.c

@@ -1,4 +1,9 @@
 #include "fastfetch.h"
+#include "common/printing.h"
+#include "common/parsing.h"
+#include "detection/qt.h"
+#include "detection/gtk.h"
+#include "detection/displayserver.h"
 
 #define FF_ICONS_MODULE_NAME "Icons"
 #define FF_ICONS_NUM_FORMAT_ARGS 5
@@ -6,7 +11,7 @@
 void ffPrintIcons(FFinstance* instance)
 {
     #ifdef __ANDROID__
-        ffPrintError(instance, FF_ICONS_MODULE_NAME, 0, &instance->config.iconsKey, &instance->config.iconsFormat, FF_ICONS_NUM_FORMAT_ARGS, "Icons detection is not supported on Android");
+        ffPrintError(instance, FF_ICONS_MODULE_NAME, 0, &instance->config.icons, "Icons detection is not supported on Android");
         return;
     #endif
 
@@ -14,32 +19,32 @@ void ffPrintIcons(FFinstance* instance)
 
     if(ffStrbufIgnCaseCompS(&wmde->wmProtocolName, "TTY") == 0)
     {
-        ffPrintError(instance, FF_ICONS_MODULE_NAME, 0, &instance->config.fontKey, &instance->config.fontFormat, FF_ICONS_NUM_FORMAT_ARGS, "Icons aren't supported in TTY");
+        ffPrintError(instance, FF_ICONS_MODULE_NAME, 0, &instance->config.icons, "Icons aren't supported in TTY");
         return;
     }
 
-    const FFstrbuf* plasma = &ffDetectPlasma(instance)->icons;
+    const FFstrbuf* plasma = &ffDetectQt(instance)->icons;
     const FFstrbuf* gtk2 = &ffDetectGTK2(instance)->icons;
     const FFstrbuf* gtk3 = &ffDetectGTK3(instance)->icons;
     const FFstrbuf* gtk4 = &ffDetectGTK4(instance)->icons;
 
     if(plasma->length == 0 && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0)
     {
-        ffPrintError(instance, FF_ICONS_MODULE_NAME, 0, &instance->config.iconsKey, &instance->config.iconsFormat, FF_ICONS_NUM_FORMAT_ARGS, "No icons could be found");
+        ffPrintError(instance, FF_ICONS_MODULE_NAME, 0, &instance->config.icons, "No icons could be found");
         return;
     }
 
     FF_STRBUF_CREATE(gtkPretty);
-    ffGetGtkPretty(&gtkPretty, gtk2, gtk3, gtk4);
+    ffParseGTK(&gtkPretty, gtk2, gtk3, gtk4);
 
-    if(instance->config.iconsFormat.length == 0)
+    if(instance->config.icons.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_ICONS_MODULE_NAME, 0, &instance->config.iconsKey);
+        ffPrintLogoAndKey(instance, FF_ICONS_MODULE_NAME, 0, &instance->config.icons.key);
 
         if(plasma->length > 0)
         {
             ffStrbufWriteTo(plasma, stdout);
-            fputs(" [Plasma]", stdout);
+            fputs(" [QT]", stdout);
 
             if(gtkPretty.length > 0)
                 fputs(", ", stdout);
@@ -49,7 +54,7 @@ void ffPrintIcons(FFinstance* instance)
     }
     else
     {
-        ffPrintFormatString(instance, FF_ICONS_MODULE_NAME, 0, &instance->config.iconsKey, &instance->config.iconsFormat, NULL, FF_ICONS_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(instance, FF_ICONS_MODULE_NAME, 0, &instance->config.icons, FF_ICONS_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, plasma},
             {FF_FORMAT_ARG_TYPE_STRBUF, gtk2},
             {FF_FORMAT_ARG_TYPE_STRBUF, gtk3},

src/modules/kernel.c

@@ -1,18 +1,19 @@
 #include "fastfetch.h"
+#include "common/printing.h"
 
 #define FF_KERNEL_MODULE_NAME "Kernel"
 #define FF_KERNEL_NUM_FORMAT_ARGS 3
 
 void ffPrintKernel(FFinstance* instance)
 {
-    if(instance->config.kernelFormat.length == 0)
+    if(instance->config.kernel.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_KERNEL_MODULE_NAME, 0, &instance->config.kernelKey);
+        ffPrintLogoAndKey(instance, FF_KERNEL_MODULE_NAME, 0, &instance->config.kernel.key);
         puts(instance->state.utsname.release);
     }
     else
     {
-        ffPrintFormatString(instance, FF_KERNEL_MODULE_NAME, 0, &instance->config.kernelKey, &instance->config.kernelFormat, NULL, FF_KERNEL_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(instance, FF_KERNEL_MODULE_NAME, 0, &instance->config.kernel, FF_KERNEL_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRING, instance->state.utsname.sysname},
             {FF_FORMAT_ARG_TYPE_STRING, instance->state.utsname.release},
             {FF_FORMAT_ARG_TYPE_STRING, instance->state.utsname.version}

src/modules/locale.c

@@ -1,4 +1,9 @@
 #include "fastfetch.h"
+#include "common/properties.h"
+#include "common/printing.h"
+#include "common/caching.h"
+
+#include <stdlib.h>
 
 #define FF_LOCALE_MODULE_NAME "Locale"
 #define FF_LOCALE_NUM_FORMAT_ARGS 1
@@ -22,24 +27,34 @@ static void getLocaleFromEnv(FFstrbuf* locale)
 
 void ffPrintLocale(FFinstance* instance)
 {
-	if(ffPrintFromCache(instance, FF_LOCALE_MODULE_NAME, &instance->config.localeKey, &instance->config.localeFormat, FF_LOCALE_NUM_FORMAT_ARGS))
+	if(ffPrintFromCache(instance, FF_LOCALE_MODULE_NAME, &instance->config.locale, FF_LOCALE_NUM_FORMAT_ARGS))
         return;
 
 	FFstrbuf locale;
     ffStrbufInit(&locale);
 
-    ffParsePropFile("/etc/locale.conf", "LANG =", &locale);
-
-	if (locale.length == 0)
-        getLocaleFromEnv(&locale);
+    //Ubuntu (and deriviates) use a non standard locale file.
+    //Parse it first, because on distributions where it exists, it takes precedence.
+    //Otherwise use the standard /etc/locale.conf file.
+    ffParsePropFile(FASTFETCH_TARGET_DIR_ROOT"/etc/default/locale", "LANG =", &locale);
 
     if(locale.length == 0)
     {
-        ffPrintError(instance, FF_LOCALE_MODULE_NAME, 0, &instance->config.localeKey, &instance->config.localeFormat, FF_LOCALE_NUM_FORMAT_ARGS, "No locale found");
+        ffParsePropFile(FASTFETCH_TARGET_DIR_ROOT"/etc/locale.conf", "LANG =", &locale);
+    }
+
+	if(locale.length == 0)
+    {
+        getLocaleFromEnv(&locale);
+    }
+
+    if(locale.length == 0)
+    {
+        ffPrintError(instance, FF_LOCALE_MODULE_NAME, 0, &instance->config.locale, "No locale found");
         return;
     }
 
-    ffPrintAndSaveToCache(instance, FF_LOCALE_MODULE_NAME, &instance->config.localeKey, &locale, &instance->config.localeFormat, FF_LOCALE_NUM_FORMAT_ARGS, (FFformatarg[]){
+    ffPrintAndWriteToCache(instance, FF_LOCALE_MODULE_NAME, &instance->config.locale, &locale, FF_LOCALE_NUM_FORMAT_ARGS, (FFformatarg[]){
         {FF_FORMAT_ARG_TYPE_STRBUF, &locale}
     });