src/config/ConfigWatcher.cpp: watch both symlinks and canonical paths

* config: make fd use CFileDescriptor

make use of the new hyprutils CFileDescriptor instead of manual FD
handling.

* hyprctl: make fd use CFileDescriptor

make use of the new hyprutils CFileDescriptor instead of manual FD
handling.

* ikeyboard: make fd use CFileDescriptor

make use of the new CFileDescriptor instead of manual FD handling, also
in sendKeymap remove dead code, it already early returns if keyboard
isnt valid, and dont try to close the FD that ikeyboard owns.

* core: make SHMFile functions use CFileDescriptor

make SHMFile misc functions use CFileDescriptor and its associated usage
in dmabuf and keyboard.

* core: make explicit sync use CFileDescriptor

begin using CFileDescriptor in explicit sync and its timelines and
eglsync usage in opengl, there is still a bit left with manual handling
that requires future aquamarine change aswell.

* eventmgr: make fd and sockets use CFileDescriptor

make use of the hyprutils CFileDescriptor instead of manual FD and
socket handling and closing.

* eventloopmgr: make timerfd use CFileDescriptor

make the timerfd use CFileDescriptor instead of manual fd handling

* opengl: make gbm fd use CFileDescriptor

make the gbm rendernode fd use CFileDescriptor instead of manual fd
handling

* core: make selection source/offer use CFileDescriptor

make data selection source and offers use CFileDescriptor and its
associated use in xwm and protocols

* protocols: convert protocols fd to CFileDescriptor

make most fd handling use CFileDescriptor in protocols

* shm: make SHMPool use CfileDescriptor

make SHMPool use CFileDescriptor instead of manual fd handling.

* opengl: duplicate fd with CFileDescriptor

duplicate fenceFD with CFileDescriptor duplicate instead.

* xwayland: make sockets and fds use CFileDescriptor

instead of manual opening/closing make sockets and fds use
CFileDescriptor

* keybindmgr: make sockets and fds use CFileDescriptor

make sockets and fds use CFileDescriptor instead of manual handling.

.clang-tidy

@@ -0,0 +1,101 @@
+WarningsAsErrors: '*'
+HeaderFilterRegex: '.*\.hpp'
+FormatStyle: file
+Checks: >
+  -*,
+  bugprone-*,
+  -bugprone-easily-swappable-parameters,
+  -bugprone-forward-declararion-namespace,
+  -bugprone-forward-declararion-namespace,
+  -bugprone-macro-parentheses,
+  -bugprone-narrowing-conversions,
+  -bugprone-branch-clone,
+  -bugprone-assignment-in-if-condition,
+  concurrency-*,
+  -concurrency-mt-unsafe,
+  cppcoreguidelines-*,
+  -cppcoreguidelines-owning-memory,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -cppcoreguidelines-pro-bounds-constant-array-index,
+  -cppcoreguidelines-avoid-const-or-ref-data-members,
+  -cppcoreguidelines-non-private-member-variables-in-classes,
+  -cppcoreguidelines-avoid-goto,
+  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+  -cppcoreguidelines-avoid-do-while,
+  -cppcoreguidelines-avoid-non-const-global-variables,
+  -cppcoreguidelines-special-member-functions,
+  -cppcoreguidelines-explicit-virtual-functions,
+  -cppcoreguidelines-avoid-c-arrays,
+  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
+  -cppcoreguidelines-narrowing-conversions,
+  -cppcoreguidelines-pro-type-union-access,
+  -cppcoreguidelines-pro-type-member-init,
+  -cppcoreguidelines-macro-usage,
+  -cppcoreguidelines-macro-to-enum,
+  -cppcoreguidelines-init-variables,
+  -cppcoreguidelines-pro-type-cstyle-cast,
+  -cppcoreguidelines-pro-type-vararg,
+  -cppcoreguidelines-pro-type-reinterpret-cast,
+  google-global-names-in-headers,
+  -google-readability-casting,
+  google-runtime-operator,
+  misc-*,
+  -misc-unused-parameters,
+  -misc-no-recursion,
+  -misc-non-private-member-variables-in-classes,
+  -misc-include-cleaner,
+  -misc-use-anonymous-namespace,
+  -misc-const-correctness,
+  modernize-*,
+  -modernize-return-braced-init-list,
+  -modernize-use-trailing-return-type,
+  -modernize-use-using,
+  -modernize-use-override,
+  -modernize-avoid-c-arrays,
+  -modernize-macro-to-enum,
+  -modernize-loop-convert,
+  -modernize-use-nodiscard,
+  -modernize-pass-by-value,
+  -modernize-use-auto,
+  performance-*,
+  -performance-avoid-endl,
+  -performance-unnecessary-value-param,
+  portability-std-allocator-const,
+  readability-*,
+  -readability-function-cognitive-complexity,
+  -readability-function-size,
+  -readability-identifier-length,
+  -readability-magic-numbers,
+  -readability-uppercase-literal-suffix,
+  -readability-braces-around-statements,
+  -readability-redundant-access-specifiers,
+  -readability-else-after-return,
+  -readability-container-data-pointer,
+  -readability-implicit-bool-conversion,
+  -readability-avoid-nested-conditional-operator,
+  -readability-redundant-member-init,
+  -readability-redundant-string-init,
+  -readability-avoid-const-params-in-decls,
+  -readability-named-parameter,
+  -readability-convert-member-functions-to-static,
+  -readability-qualified-auto,
+  -readability-make-member-function-const,
+  -readability-isolate-declaration,
+  -readability-inconsistent-declaration-parameter-name,
+  -clang-diagnostic-error,
+
+CheckOptions:
+  performance-for-range-copy.WarnOnAllAutoCopies: true
+  performance-inefficient-string-concatenation.StrictMode: true
+  readability-braces-around-statements.ShortStatementLines: 0
+  readability-identifier-naming.ClassCase: CamelCase
+  readability-identifier-naming.ClassIgnoredRegexp: I.*
+  readability-identifier-naming.ClassPrefix: C # We can't use regex here?!?!?!?
+  readability-identifier-naming.EnumCase: CamelCase
+  readability-identifier-naming.EnumPrefix: e
+  readability-identifier-naming.EnumConstantCase: UPPER_CASE
+  readability-identifier-naming.FunctionCase: camelBack
+  readability-identifier-naming.NamespaceCase: CamelCase
+  readability-identifier-naming.NamespacePrefix: N
+  readability-identifier-naming.StructPrefix: S
+  readability-identifier-naming.StructCase: CamelCase

.github/ISSUE_TEMPLATE/bug.yml

@@ -5,10 +5,10 @@ body:
   - type: checkboxes
     attributes:
       label: Already reported ? *
-      description: Before opening a new bug report, please take a moment to search through the current open and closed issues to check if it already exists.
+      description: Before opening a new bug report, please take a moment to search through the current open issues. If the same bug is already reported, don't open new issue - instead go upvote/comment on an existing one.
       options:
-      - label: I have searched the existing open and closed issues.
-        required: true
+        - label: I have searched the existing open and closed issues.
+          required: true
 
   - type: dropdown
     id: type
@@ -19,27 +19,28 @@ body:
         **BEFORE CONTINUING**, please check if this bug is a regression or not, and if it is, we need you to bisect with the help of the wiki: https://wiki.hyprland.org/Crashes-and-Bugs/#bisecting-an-issue
       multiple: true
       options:
-        - "Yes"
-        - "No"
+        - "Definitely a regression - something broke after update (requires bisect)"
+        - "Probably not a regression / I don't remember it happening before"
+        - "Not a regression - it's bug regarding new feature"
+        - "Not a regression - it's an old bug"
+        - "I don't know, I started using Hyprland only recently"
     validations:
       required: true
 
   - type: textarea
     id: ver
     attributes:
-      label: System Info and Version
+      label: System Info and Hyprland Version
       description: |
-        Paste the output of `hyprctl systeminfo -c` here. If you can't
+        Paste the output of `hyprctl systeminfo` here. If you can't
         launch Hyprland, paste the output of `Hyprland --systeminfo`.
-        If `Hyprland --systeminfo` errors out (added in 0.44.0), find
-        and paste the Hyprland version manually.
       value: "<details>
         <summary>System/Version info</summary>
 
 
-        ```sh
-        
-        <Paste the output of the command here>
+        ```
+
+        <Paste the output of the command here, without removing any formatting around this>
 
         ```
 
@@ -61,15 +62,56 @@ body:
     attributes:
       label: How to reproduce
       description: "How can someone else reproduce the issue?"
+      placeholder: |
+        1. ...
+        2. ...
+        3. ...
+
     validations:
       required: true
 
+  - type: markdown
+    attributes:
+      value: |
+        ## Additional info section
+
+        In the section below you will be asked to upload some files.
+
+        When including text files (such as logs or config), please **always ATTACH** them, and not paste them directly.
+
+        This is important to avoid clutter, spam, and make the issues more readable.
+        Thanks for your understanding.
+
+  # The main reason to disallow pasting directly or in a dropdown, is to not clutter
+  # the issue with unnecessary keywords, making the github issue search useless.
+  - type: checkboxes
+    attributes:
+      label: Attach not paste
+      options:
+        - label: I understand that all text files must be *attached*, and not pasted directly. If not respected, this issue will likely get closed as spam
+          required: true
+
+  - type: markdown
+    attributes:
+      value: >-
+        Please be sure to upload the following files below if they are relevant to the issue:
+
+          - Logs can be found in $XDG_RUNTIME_DIR/hypr (sort by date to grab the latest)
+          - Crash reports are stored in ~/.cache/hyprland or $XDG_CACHE_HOME/hyprland
+          - Hyprland config files - `hyprctl systeminfo -c > /tmp/hyprland_config_dump.txt` use this command to dump full configuration to a single file.
+
+  - type: checkboxes
+    attributes:
+      label: Checklist of files to include below
+      options:
+        - label: Hyprland config - `hyprctl systeminfo -c` (always include)
+        - label: Crash report (always include in case of crash)
+        - label: Video (always include in case of a visual bug)
+        - label: Logs (might contain useful info such as errors)
+
   - type: textarea
     id: logs
     attributes:
-      label: Crash reports, logs, images, videos
+      label: Additional info & File uploads
       description: |
-        Anything that can help. Please always ATTACH and not paste them.
-        Logs can be found in $XDG_RUNTIME_DIR/hypr
-        Crash reports are stored in ~/.cache/hyprland or $XDG_CACHE_HOME/hyprland
-
+        Tip: You can attach files by clicking this area to highlight it and then dragging files in.

.github/actions/setup_base/action.yml

@@ -33,7 +33,10 @@ runs:
           libfontenc \
           libglvnd \
           libinput \
+          libjxl \
           libliftoff \
+          libspng \
+          libwebp \
           libxcursor \
           libxcvt \
           libxfont2 \
@@ -58,7 +61,17 @@ runs:
           xcb-util \
           xcb-util-image \
           libzip \
-          librsvg
+          librsvg \
+          re2
+
+    - name: Get glaze
+      shell: bash
+      run: |
+        git clone https://github.com/stephenberry/glaze.git
+        cd glaze
+        cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:PATH=/usr -S . -B ./build
+        cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
+        cmake --install build
 
     - name: Get hyprwayland-scanner-git
       shell: bash
@@ -69,6 +82,11 @@ runs:
         cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
         cmake --install build
 
+    - name: Get hyprgraphics-git
+      shell: bash
+      run: |
+        git clone https://github.com/hyprwm/hyprgraphics && cd hyprgraphics && cmake -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:PATH=/usr -B build && cmake --build build --target hyprgraphics && cmake --install build
+
     - name: Get hyprutils-git
       shell: bash
       run: |

.github/pull_request_template.md

@@ -1,3 +1,9 @@
+<!--
+BEFORE you submit your PR, please check out the PR guidelines
+on our wiki: https://wiki.hyprland.org/Contributing-and-Debugging/PR-Guidelines/
+-->
+
+
 #### Describe your PR, what does it fix/add?
 
 

.github/workflows/ci.yaml

@@ -39,7 +39,7 @@ jobs:
           tar -cvf Hyprland.tar.xz hyprland
 
       - name: Release
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: Build archive
           path: Hyprland.tar.xz
@@ -107,6 +107,7 @@ jobs:
         run: make release
 
   clang-format:
+    permissions: read-all
     if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork
     name: "Code Style (Arch)"
     runs-on: ubuntu-latest

.github/workflows/clang-format.yml

@@ -0,0 +1,48 @@
+name: clang-format
+on: pull_request_target
+jobs:
+  clang-format:
+    permissions: write-all
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork
+    name: "Code Style (Arch)"
+    runs-on: ubuntu-latest
+    container:
+      image: archlinux
+    steps:
+      - name: Checkout repository actions
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: .github/actions
+
+      - name: Setup base
+        uses: ./.github/actions/setup_base
+
+      - name: Configure
+        run: meson setup build -Ddefault_library=static
+
+      - name: clang-format check
+        run: ninja -C build clang-format-check
+
+      - name: clang-format apply
+        if: ${{ failure() && github.event_name == 'pull_request' }}
+        run: ninja -C build clang-format
+
+      - name: Create patch
+        if: ${{ failure() && github.event_name == 'pull_request' }}
+        run: |
+          echo 'Please fix the formatting issues by running [`clang-format`](https://wiki.hyprland.org/Contributing-and-Debugging/PR-Guidelines/#code-style), or directly apply this patch:' > clang-format.patch
+          echo '<details>' >> clang-format.patch
+          echo '<summary>clang-format.patch</summary>' >> clang-format.patch
+          echo >> clang-format.patch
+          echo '```diff' >> clang-format.patch
+          git diff >> clang-format.patch
+          echo '```' >> clang-format.patch
+          echo >> clang-format.patch
+          echo '</details>' >> clang-format.patch
+
+      - name: Comment patch
+        if: ${{ failure() && github.event_name == 'pull_request' }}
+        uses: mshick/add-pr-comment@v2
+        with:
+          message-path: |
+            clang-format.patch

.github/workflows/man-update.yaml

@@ -17,14 +17,14 @@ jobs:
       run: sudo apt install pandoc
 
     - name: Clone repository
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         token: ${{ secrets.PAT }}
 
     - name: Build man pages
       run: make man
 
-    - uses: stefanzweifel/git-auto-commit-action@v4
+    - uses: stefanzweifel/git-auto-commit-action@v5
       name: Commit
       with:
         commit_message: "[gha] build man pages"

.github/workflows/nix-build.yml

@@ -12,7 +12,8 @@ jobs:
       matrix:
         package:
           - hyprland
-          - hyprland-cross
+          # - hyprland-cross # cross compiling fails due to qt
+          # failure chain: hyprland-qtutils -> qt6.qtsvg -> qt6.qtbase -> psqlodbc & qt6.qttranslations
           - xdg-desktop-portal-hyprland
 
     runs-on: ubuntu-latest

.github/workflows/nix-update-inputs.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           token: ${{ secrets.PAT }}
 
@@ -22,6 +22,6 @@ jobs:
         run: nix/update-inputs.sh
 
       - name: Commit
-        uses: stefanzweifel/git-auto-commit-action@v4
+        uses: stefanzweifel/git-auto-commit-action@v5
         with:
           commit_message: "[gha] Nix: update inputs"

.github/workflows/release.yaml

@@ -11,7 +11,7 @@ jobs:
     steps:
       - name: Checkout Hyprland
         id: checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           submodules: recursive
 
@@ -20,7 +20,6 @@ jobs:
         run: |
           git fetch --unshallow || echo "failed unshallowing"
           bash -c scripts/generateVersion.sh
-          mv scripts/generateVersion.sh scripts/generateVersion.sh.bak
 
       - name: Create tarball with submodules
         id: tar

.github/workflows/security-checks.yml

@@ -13,7 +13,7 @@ jobs:
       security-events: write
     steps:
       - name: Checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Scan with Flawfinder
         uses: david-a-wheeler/flawfinder@8e4a779ad59dbfaee5da586aa9210853b701959c

.github/workflows/stale.yml

@@ -19,7 +19,7 @@ jobs:
       pull-requests: write
 
     steps:
-      - uses: actions/stale@v5
+      - uses: actions/stale@v9
         with:
           repo-token: ${{ secrets.STALEBOT_PAT }}
           stale-issue-label: "stale"

.gitignore

@@ -14,6 +14,7 @@ _deps
 
 build/
 result*
+/.pre-commit-config.yaml
 /.vscode/
 /.idea/
 .envrc
@@ -39,3 +40,6 @@ PKGBUILD
 src/version.h
 hyprpm/Makefile
 hyprctl/Makefile
+
+**/.#*.*
+**/#*.*#

CMakeLists.txt

@@ -15,6 +15,7 @@ include(GNUInstallDirs)
 set(HYPRLAND_VERSION ${VER})
 set(PREFIX ${CMAKE_INSTALL_PREFIX})
 set(INCLUDEDIR ${CMAKE_INSTALL_INCLUDEDIR})
+set(BINDIR ${CMAKE_INSTALL_BINDIR})
 configure_file(hyprland.pc.in hyprland.pc @ONLY)
 
 set(CMAKE_MESSAGE_LOG_LEVEL "STATUS")
@@ -71,6 +72,8 @@ else()
   message(STATUS "Configuring Hyprland in Release with CMake")
 endif()
 
+add_compile_definitions(HYPRLAND_VERSION="${HYPRLAND_VERSION}")
+
 include_directories(. "src/" "protocols/")
 
 set(CMAKE_CXX_STANDARD 26)
@@ -98,11 +101,17 @@ else()
 endif()
 find_package(OpenGL REQUIRED COMPONENTS ${GLES_VERSION})
 
-pkg_check_modules(hyprctl_deps REQUIRED IMPORTED_TARGET hyprutils>=0.2.1)
-
-pkg_check_modules(aquamarine_dep REQUIRED IMPORTED_TARGET aquamarine)
+pkg_check_modules(aquamarine_dep REQUIRED IMPORTED_TARGET aquamarine>=0.4.5)
+pkg_check_modules(hyprlang_dep REQUIRED IMPORTED_TARGET hyprlang>=0.3.2)
+pkg_check_modules(hyprcursor_dep REQUIRED IMPORTED_TARGET hyprcursor>=0.1.7)
+pkg_check_modules(hyprutils_dep REQUIRED IMPORTED_TARGET hyprutils>=0.4.0)
+pkg_check_modules(hyprgraphics_dep REQUIRED IMPORTED_TARGET hyprgraphics>=0.1.1)
 
 add_compile_definitions(AQUAMARINE_VERSION="${aquamarine_dep_VERSION}")
+add_compile_definitions(HYPRLANG_VERSION="${hyprlang_dep_VERSION}")
+add_compile_definitions(HYPRUTILS_VERSION="${hyprutils_dep_VERSION}")
+add_compile_definitions(HYPRCURSOR_VERSION="${hyprcursor_dep_VERSION}")
+add_compile_definitions(HYPRGRAPHICS_VERSION="${hyprgraphics_dep_VERSION}")
 
 pkg_check_modules(
   deps
@@ -121,9 +130,7 @@ pkg_check_modules(
   libinput
   gbm
   gio-2.0
-  hyprlang>=0.3.2
-  hyprcursor>=0.1.7
-  hyprutils>=0.2.3)
+  re2)
 
 find_package(hyprwayland-scanner 0.3.10 REQUIRED)
 
@@ -190,6 +197,12 @@ if(NOT HAS_TIMERFD AND epoll_FOUND)
   target_link_libraries(Hyprland PkgConfig::epoll)
 endif()
 
+check_include_file("sys/inotify.h" HAS_INOTIFY)
+pkg_check_modules(inotify IMPORTED_TARGET libinotify)
+if(NOT HAS_INOTIFY AND inotify_FOUND)
+  target_link_libraries(Hyprland PkgConfig::inotify)
+endif()
+
 if(LEGACY_RENDERER)
   message(STATUS "Using the legacy GLES2 renderer!")
   add_compile_definitions(LEGACY_RENDERER)
@@ -219,6 +232,15 @@ if(NO_SYSTEMD)
 else()
   message(STATUS "SYSTEMD support is requested (NO_SYSTEMD not defined)...")
   add_compile_definitions(USES_SYSTEMD)
+
+  # session file -uwsm
+  if(NO_UWSM)
+    message(STATUS "UWSM support is disabled...")
+  else()
+    message(STATUS "UWSM support is enabled (NO_UWSM not defined)...")
+    install(FILES ${CMAKE_SOURCE_DIR}/systemd/hyprland-uwsm.desktop
+            DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/wayland-sessions)
+  endif()
 endif()
 
 set(CPACK_PROJECT_NAME ${PROJECT_NAME})
@@ -232,7 +254,15 @@ target_precompile_headers(Hyprland PRIVATE
 
 message(STATUS "Setting link libraries")
 
-target_link_libraries(Hyprland rt PkgConfig::aquamarine_dep PkgConfig::deps)
+target_link_libraries(
+  Hyprland
+  rt
+  PkgConfig::aquamarine_dep
+  PkgConfig::hyprlang_dep
+  PkgConfig::hyprutils_dep
+  PkgConfig::hyprcursor_dep
+  PkgConfig::hyprgraphics_dep
+  PkgConfig::deps)
 if(udis_dep_FOUND)
   target_link_libraries(Hyprland PkgConfig::udis_dep)
 else()
@@ -274,7 +304,7 @@ endfunction()
 
 target_link_libraries(Hyprland OpenGL::EGL OpenGL::GL Threads::Threads)
 
-pkg_check_modules(hyprland_protocols_dep hyprland-protocols>=0.2.0)
+pkg_check_modules(hyprland_protocols_dep hyprland-protocols>=0.6.0)
 if(hyprland_protocols_dep_FOUND)
   pkg_get_variable(HYPRLAND_PROTOCOLS hyprland-protocols pkgdatadir)
   message(STATUS "hyprland-protocols dependency set to ${HYPRLAND_PROTOCOLS}")
@@ -300,7 +330,13 @@ protocolnew("protocols" "kde-server-decoration" true)
 protocolnew("protocols" "wlr-data-control-unstable-v1" true)
 protocolnew("${HYPRLAND_PROTOCOLS}/protocols" "hyprland-focus-grab-v1" true)
 protocolnew("protocols" "wlr-layer-shell-unstable-v1" true)
+protocolnew("protocols" "xx-color-management-v4" true)
+protocolnew("protocols" "frog-color-management-v1" true)
 protocolnew("protocols" "wayland-drm" true)
+protocolnew("${HYPRLAND_PROTOCOLS}/protocols" "hyprland-ctm-control-v1" true)
+protocolnew("${HYPRLAND_PROTOCOLS}/protocols" "hyprland-surface-v1" true)
+protocolnew("${HYPRLAND_PROTOCOLS}/protocols" "hyprland-lock-notify-v1" true)
+
 protocolnew("staging/tearing-control" "tearing-control-v1" false)
 protocolnew("staging/fractional-scale" "fractional-scale-v1" false)
 protocolnew("unstable/xdg-output" "xdg-output-unstable-v1" false)
@@ -331,12 +367,19 @@ protocolnew("staging/drm-lease" "drm-lease-v1" false)
 protocolnew("staging/linux-drm-syncobj" "linux-drm-syncobj-v1" false)
 protocolnew("staging/xdg-dialog" "xdg-dialog-v1" false)
 protocolnew("staging/single-pixel-buffer" "single-pixel-buffer-v1" false)
+protocolnew("staging/security-context" "security-context-v1" false)
 
 protocolwayland()
 
 # tools
 add_subdirectory(hyprctl)
-add_subdirectory(hyprpm)
+
+if(NO_HYPRPM)
+  message(STATUS "hyprpm is disabled")
+else()
+  add_subdirectory(hyprpm)
+  message(STATUS "hyprpm is enabled (NO_HYPRPM not defined)")
+endif()
 
 # binary and symlink
 install(TARGETS Hyprland)
@@ -347,7 +390,6 @@ install(
         ${CMAKE_INSTALL_FULL_BINDIR}/Hyprland \
         \"\$ENV{DESTDIR}${CMAKE_INSTALL_FULL_BINDIR}/hyprland\" \
         )")
-
 # session file
 install(FILES ${CMAKE_SOURCE_DIR}/example/hyprland.desktop
         DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/wayland-sessions)

Makefile

@@ -1,12 +1,15 @@
 PREFIX = /usr/local
 
+stub:
+	@echo "Do not run $(MAKE) directly without any arguments. Please refer to the wiki on how to compile Hyprland."
+
 legacyrenderer:
-	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:STRING=${PREFIX} -DLEGACY_RENDERER:BOOL=true -S . -B ./buildZ
+	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:STRING=${PREFIX} -DLEGACY_RENDERER:BOOL=true -S . -B ./build
 	cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
 
 legacyrendererdebug:
 	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Debug -DCMAKE_INSTALL_PREFIX:STRING=${PREFIX} -DLEGACY_RENDERER:BOOL=true -S . -B ./build
-	cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
+	cmake --build ./build --config Debug --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
 
 release:
 	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:STRING=${PREFIX} -S . -B ./build

README.md

@@ -100,7 +100,7 @@ easy IPC, much more QoL stuff than other compositors and more...
 
 <!----------------------------------------------------------------------------->
 
-[Configure]: https://wiki.hyprland.org/Configuring/Configuring-Hyprland/
+[Configure]: https://wiki.hyprland.org/Configuring/
 [Stars]: https://starchart.cc/hyprwm/Hyprland
 [Hypr]: https://github.com/hyprwm/Hypr
 

VERSION

@@ -1 +1 @@
-0.44.0
+0.47.0

docs/ISSUE_GUIDELINES.md

@@ -3,7 +3,7 @@
 First of all, please remember to:
 - Check that your issue is not a duplicate
 - Read the [FAQ](https://wiki.hyprland.org/FAQ/)
-- Read the [Configuring Page](https://wiki.hyprland.org/Configuring/Configuring-Hyprland)
+- Read the [Configuring Page](https://wiki.hyprland.org/Configuring/)
 
 <br/>
 

example/hyprland-session.service

@@ -1,14 +0,0 @@
-[Unit]
-Description=Hyprland - Tiling compositor with the looks
-Documentation=man:Hyprland(1)
-BindsTo=graphical-session.target
-Before=graphical-session.target
-Wants=graphical-session-pre.target
-After=graphical-session-pre.target
-
-[Service]
-Type=notify
-ExecStart=/usr/bin/Hyprland
-ExecStop=/usr/bin/hyprctl dispatch exit
-Restart=on-failure
-Slice=session.slice

example/hyprland.conf

@@ -1,6 +1,6 @@
 # This is an example Hyprland config file.
 # Refer to the wiki for more information.
-# https://wiki.hyprland.org/Configuring/Configuring-Hyprland/
+# https://wiki.hyprland.org/Configuring/
 
 # Please note not all available settings / options are set here.
 # For a full list, see the wiki
@@ -81,15 +81,18 @@ general {
 # https://wiki.hyprland.org/Configuring/Variables/#decoration
 decoration {
     rounding = 10
+    rounding_power = 2
 
     # Change transparency of focused and unfocused windows
     active_opacity = 1.0
     inactive_opacity = 1.0
 
-    drop_shadow = true
-    shadow_range = 4
-    shadow_render_power = 3
-    col.shadow = rgba(1a1a1aee)
+    shadow {
+        enabled = true
+        range = 4
+        render_power = 3
+        color = rgba(1a1a1aee)
+    }
 
     # https://wiki.hyprland.org/Configuring/Variables/#blur
     blur {
@@ -103,20 +106,44 @@ decoration {
 
 # https://wiki.hyprland.org/Configuring/Variables/#animations
 animations {
-    enabled = true
+    enabled = yes, please :)
 
     # Default animations, see https://wiki.hyprland.org/Configuring/Animations/ for more
 
-    bezier = myBezier, 0.05, 0.9, 0.1, 1.05
+    bezier = easeOutQuint,0.23,1,0.32,1
+    bezier = easeInOutCubic,0.65,0.05,0.36,1
+    bezier = linear,0,0,1,1
+    bezier = almostLinear,0.5,0.5,0.75,1.0
+    bezier = quick,0.15,0,0.1,1
 
-    animation = windows, 1, 7, myBezier
-    animation = windowsOut, 1, 7, default, popin 80%
-    animation = border, 1, 10, default
-    animation = borderangle, 1, 8, default
-    animation = fade, 1, 7, default
-    animation = workspaces, 1, 6, default
+    animation = global, 1, 10, default
+    animation = border, 1, 5.39, easeOutQuint
+    animation = windows, 1, 4.79, easeOutQuint
+    animation = windowsIn, 1, 4.1, easeOutQuint, popin 87%
+    animation = windowsOut, 1, 1.49, linear, popin 87%
+    animation = fadeIn, 1, 1.73, almostLinear
+    animation = fadeOut, 1, 1.46, almostLinear
+    animation = fade, 1, 3.03, quick
+    animation = layers, 1, 3.81, easeOutQuint
+    animation = layersIn, 1, 4, easeOutQuint, fade
+    animation = layersOut, 1, 1.5, linear, fade
+    animation = fadeLayersIn, 1, 1.79, almostLinear
+    animation = fadeLayersOut, 1, 1.39, almostLinear
+    animation = workspaces, 1, 1.94, almostLinear, fade
+    animation = workspacesIn, 1, 1.21, almostLinear, fade
+    animation = workspacesOut, 1, 1.94, almostLinear, fade
 }
 
+# Ref https://wiki.hyprland.org/Configuring/Workspace-Rules/
+# "Smart gaps" / "No gaps when only"
+# uncomment all if you wish to use that.
+# workspace = w[tv1], gapsout:0, gapsin:0
+# workspace = f[1], gapsout:0, gapsin:0
+# windowrulev2 = bordersize 0, floating:0, onworkspace:w[tv1]
+# windowrulev2 = rounding 0, floating:0, onworkspace:w[tv1]
+# windowrulev2 = bordersize 0, floating:0, onworkspace:f[1]
+# windowrulev2 = rounding 0, floating:0, onworkspace:f[1]
+
 # See https://wiki.hyprland.org/Configuring/Dwindle-Layout/ for more
 dwindle {
     pseudotile = true # Master switch for pseudotiling. Enabling is bound to mainMod + P in the keybinds section below
@@ -255,4 +282,8 @@ bindl = , XF86AudioPrev, exec, playerctl previous
 # Example windowrule v2
 # windowrulev2 = float,class:^(kitty)$,title:^(kitty)$
 
-windowrulev2 = suppressevent maximize, class:.* # You'll probably like this.
+# Ignore maximize requests from apps. You'll probably like this.
+windowrulev2 = suppressevent maximize, class:.*
+
+# Fix some dragging issues with XWayland
+windowrulev2 = nofocus,class:^$,title:^$,xwayland:1,floating:1,fullscreen:0,pinned:0

example/hyprland.desktop

@@ -2,4 +2,6 @@
 Name=Hyprland
 Comment=An intelligent dynamic tiling Wayland compositor
 Exec=Hyprland
-Type=Application
+Type=Application
+DesktopNames=Hyprland
+Keywords=tiling;wayland;compositor;

example/launch.json

@@ -22,5 +22,6 @@
                 }
             ]
         },
+        
     ]
 }

flake.lock

@@ -16,11 +16,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1727261104,
-        "narHash": "sha256-rxDI7WrxIRV9it9mDCHcLa7xQykf1JloXnoXr5xQ8zI=",
+        "lastModified": 1738183445,
+        "narHash": "sha256-C1He3N1SA8D2u+TSlldbA9wiYwDvXI4GxX3zKaeD7qU=",
         "owner": "hyprwm",
         "repo": "aquamarine",
-        "rev": "b82fdaff917582a9d568969e15e61b398c71e990",
+        "rev": "48a000cf35dd10bfeb231152735aebbe875f4b74",
         "type": "github"
       },
       "original": {
@@ -29,6 +29,43 @@
         "type": "github"
       }
     },
+    "flake-compat": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1696426674,
+        "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=",
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
+    "gitignore": {
+      "inputs": {
+        "nixpkgs": [
+          "pre-commit-hooks",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1709087332,
+        "narHash": "sha256-HG2cCnktfHsKV0s4XW83gU3F57gaTljL9KNSuG6bnQs=",
+        "owner": "hercules-ci",
+        "repo": "gitignore.nix",
+        "rev": "637db329424fd7e46cf4185293b9cc8c88c95394",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "gitignore.nix",
+        "type": "github"
+      }
+    },
     "hyprcursor": {
       "inputs": {
         "hyprlang": [
@@ -42,11 +79,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1727532803,
-        "narHash": "sha256-ZaZ7h7PY8mQc4vtGmVqWLAq9CAO02gHMyNR5yY8zDmM=",
+        "lastModified": 1738178255,
+        "narHash": "sha256-+D6Nu2ewXbMTFzx/Q4jDOo+LAOUPr0cxQJg5k33daIE=",
         "owner": "hyprwm",
         "repo": "hyprcursor",
-        "rev": "b98726e431d4d3ed58bd58bee1047cdb81cec69f",
+        "rev": "dcadd3398abe146d60c67e0d9ee6e27b301cae82",
         "type": "github"
       },
       "original": {
@@ -55,6 +92,32 @@
         "type": "github"
       }
     },
+    "hyprgraphics": {
+      "inputs": {
+        "hyprutils": [
+          "hyprutils"
+        ],
+        "nixpkgs": [
+          "nixpkgs"
+        ],
+        "systems": [
+          "systems"
+        ]
+      },
+      "locked": {
+        "lastModified": 1738018829,
+        "narHash": "sha256-5Ol5iahMlELx3lWuChyZsqqLk6sP6aqaJCJFw92OZGo=",
+        "owner": "hyprwm",
+        "repo": "hyprgraphics",
+        "rev": "12cd7034e441a5ebfdef1a090c0788413b4a635b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hyprwm",
+        "repo": "hyprgraphics",
+        "type": "github"
+      }
+    },
     "hyprland-protocols": {
       "inputs": {
         "nixpkgs": [
@@ -65,11 +128,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1727451107,
-        "narHash": "sha256-qV9savtHwmZUa0eJE294WYJjKPGB2+bJhwByFShsVyo=",
+        "lastModified": 1737556638,
+        "narHash": "sha256-laKgI3mr2qz6tas/q3tuGPxMdsGhBi/w+HO+hO2f1AY=",
         "owner": "hyprwm",
         "repo": "hyprland-protocols",
-        "rev": "6b3261ee13a6d2b99de79a31d352f6996e35bde3",
+        "rev": "4c75dd5c015c8a0e5a34c6d02a018a650f57feb5",
         "type": "github"
       },
       "original": {
@@ -78,28 +141,64 @@
         "type": "github"
       }
     },
-    "hyprland-protocols_2": {
+    "hyprland-qt-support": {
       "inputs": {
+        "hyprlang": [
+          "hyprland-qtutils",
+          "hyprlang"
+        ],
         "nixpkgs": [
-          "xdph",
+          "hyprland-qtutils",
           "nixpkgs"
         ],
         "systems": [
-          "xdph",
+          "hyprland-qtutils",
           "systems"
         ]
       },
       "locked": {
-        "lastModified": 1721326555,
-        "narHash": "sha256-zCu4R0CSHEactW9JqYki26gy8h9f6rHmSwj4XJmlHgg=",
+        "lastModified": 1737634706,
+        "narHash": "sha256-nGCibkfsXz7ARx5R+SnisRtMq21IQIhazp6viBU8I/A=",
         "owner": "hyprwm",
-        "repo": "hyprland-protocols",
-        "rev": "5a11232266bf1a1f5952d5b179c3f4b2facaaa84",
+        "repo": "hyprland-qt-support",
+        "rev": "8810df502cdee755993cb803eba7b23f189db795",
         "type": "github"
       },
       "original": {
         "owner": "hyprwm",
-        "repo": "hyprland-protocols",
+        "repo": "hyprland-qt-support",
+        "type": "github"
+      }
+    },
+    "hyprland-qtutils": {
+      "inputs": {
+        "hyprland-qt-support": "hyprland-qt-support",
+        "hyprlang": [
+          "hyprlang"
+        ],
+        "hyprutils": [
+          "hyprland-qtutils",
+          "hyprlang",
+          "hyprutils"
+        ],
+        "nixpkgs": [
+          "nixpkgs"
+        ],
+        "systems": [
+          "systems"
+        ]
+      },
+      "locked": {
+        "lastModified": 1737981711,
+        "narHash": "sha256-lh6cL5D8nPplB3WovCQjLUZ7k7MViiBrMlpkfm4R7/c=",
+        "owner": "hyprwm",
+        "repo": "hyprland-qtutils",
+        "rev": "96bf0677fa9cd13508294e3d4559dfbbc8beff73",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hyprwm",
+        "repo": "hyprland-qtutils",
         "type": "github"
       }
     },
@@ -116,11 +215,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1725997860,
-        "narHash": "sha256-d/rZ/fHR5l1n7PeyLw0StWMNLXVU9c4HFyfskw568so=",
+        "lastModified": 1737634606,
+        "narHash": "sha256-W7W87Cv6wqZ9PHegI6rH1+ve3zJPiyevMFf0/HwdbCQ=",
         "owner": "hyprwm",
         "repo": "hyprlang",
-        "rev": "dfeb5811dd6485490cce18d6cc1e38a055eea876",
+        "rev": "f41271d35cc0f370d300413d756c2677f386af9d",
         "type": "github"
       },
       "original": {
@@ -139,11 +238,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1727300645,
-        "narHash": "sha256-OvAtVLaSRPnbXzOwlR1fVqCXR7i+ICRX3aPMCdIiv+c=",
+        "lastModified": 1737978343,
+        "narHash": "sha256-TfFS0HCEJh63Kahrkp1h9hVDMdLU8a37Zz+IFucxyfA=",
         "owner": "hyprwm",
         "repo": "hyprutils",
-        "rev": "3f5293432b6dc6a99f26aca2eba3876d2660665c",
+        "rev": "6a8bc9d2a4451df12f5179dc0b1d2d46518a90ab",
         "type": "github"
       },
       "original": {
@@ -162,11 +261,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1726874836,
-        "narHash": "sha256-VKR0sf0PSNCB0wPHVKSAn41mCNVCnegWmgkrneKDhHM=",
+        "lastModified": 1735493474,
+        "narHash": "sha256-fktzv4NaqKm94VAkAoVqO/nqQlw+X0/tJJNAeCSfzK4=",
         "owner": "hyprwm",
         "repo": "hyprwayland-scanner",
-        "rev": "500c81a9e1a76760371049a8d99e008ea77aa59e",
+        "rev": "de913476b59ee88685fdc018e77b8f6637a2ae0b",
         "type": "github"
       },
       "original": {
@@ -177,11 +276,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1727348695,
-        "narHash": "sha256-J+PeFKSDV+pHL7ukkfpVzCOO7mBSrrpJ3svwBFABbhI=",
+        "lastModified": 1737885589,
+        "narHash": "sha256-Zf0hSrtzaM1DEz8//+Xs51k/wdSajticVrATqDrfQjg=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "1925c603f17fc89f4c8f6bf6f631a802ad85d784",
+        "rev": "852ff1d9e153d8875a83602e03fdef8a63f0ecf8",
         "type": "github"
       },
       "original": {
@@ -191,15 +290,40 @@
         "type": "github"
       }
     },
+    "pre-commit-hooks": {
+      "inputs": {
+        "flake-compat": "flake-compat",
+        "gitignore": "gitignore",
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1737465171,
+        "narHash": "sha256-R10v2hoJRLq8jcL4syVFag7nIGE7m13qO48wRIukWNg=",
+        "owner": "cachix",
+        "repo": "git-hooks.nix",
+        "rev": "9364dc02281ce2d37a1f55b6e51f7c0f65a75f17",
+        "type": "github"
+      },
+      "original": {
+        "owner": "cachix",
+        "repo": "git-hooks.nix",
+        "type": "github"
+      }
+    },
     "root": {
       "inputs": {
         "aquamarine": "aquamarine",
         "hyprcursor": "hyprcursor",
+        "hyprgraphics": "hyprgraphics",
         "hyprland-protocols": "hyprland-protocols",
+        "hyprland-qtutils": "hyprland-qtutils",
         "hyprlang": "hyprlang",
         "hyprutils": "hyprutils",
         "hyprwayland-scanner": "hyprwayland-scanner",
         "nixpkgs": "nixpkgs",
+        "pre-commit-hooks": "pre-commit-hooks",
         "systems": "systems",
         "xdph": "xdph"
       }
@@ -221,7 +345,9 @@
     },
     "xdph": {
       "inputs": {
-        "hyprland-protocols": "hyprland-protocols_2",
+        "hyprland-protocols": [
+          "hyprland-protocols"
+        ],
         "hyprlang": [
           "hyprlang"
         ],
@@ -239,11 +365,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1727524473,
-        "narHash": "sha256-1DGktDtSWIJpnDbVoj/qpvJSH5zg6JbOfuh6xqZMap0=",
+        "lastModified": 1737634991,
+        "narHash": "sha256-dBAnb7Kbnier30cA7AgxVSxxARmxKZ1vHZT33THSIr8=",
         "owner": "hyprwm",
         "repo": "xdg-desktop-portal-hyprland",
-        "rev": "7e500e679ede40e79cf2d89b5f5fa3e34923bd26",
+        "rev": "e09dfe2726c8008f983e45a0aa1a3b7416aaeb8a",
         "type": "github"
       },
       "original": {

flake.nix

@@ -22,12 +22,26 @@
       inputs.hyprlang.follows = "hyprlang";
     };
 
+    hyprgraphics = {
+      url = "github:hyprwm/hyprgraphics";
+      inputs.nixpkgs.follows = "nixpkgs";
+      inputs.systems.follows = "systems";
+      inputs.hyprutils.follows = "hyprutils";
+    };
+
     hyprland-protocols = {
       url = "github:hyprwm/hyprland-protocols";
       inputs.nixpkgs.follows = "nixpkgs";
       inputs.systems.follows = "systems";
     };
 
+    hyprland-qtutils = {
+      url = "github:hyprwm/hyprland-qtutils";
+      inputs.nixpkgs.follows = "nixpkgs";
+      inputs.systems.follows = "systems";
+      inputs.hyprlang.follows = "hyprlang";
+    };
+
     hyprlang = {
       url = "github:hyprwm/hyprlang";
       inputs.nixpkgs.follows = "nixpkgs";
@@ -51,10 +65,16 @@
       url = "github:hyprwm/xdg-desktop-portal-hyprland";
       inputs.nixpkgs.follows = "nixpkgs";
       inputs.systems.follows = "systems";
+      inputs.hyprland-protocols.follows = "hyprland-protocols";
       inputs.hyprlang.follows = "hyprlang";
       inputs.hyprutils.follows = "hyprutils";
       inputs.hyprwayland-scanner.follows = "hyprwayland-scanner";
     };
+
+    pre-commit-hooks = {
+      url = "github:cachix/git-hooks.nix";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
   };
 
   outputs = inputs @ {
@@ -76,7 +96,7 @@
     pkgsCrossFor = eachSystem (system: crossSystem:
       import nixpkgs {
         localSystem = system;
-        crossSystem = crossSystem;
+        inherit crossSystem;
         overlays = with self.overlays; [
           hyprland-packages
           hyprland-extras
@@ -91,6 +111,18 @@
         self.packages.${system})
       // {
         inherit (self.packages.${system}) xdg-desktop-portal-hyprland;
+        pre-commit-check = inputs.pre-commit-hooks.lib.${system}.run {
+          src = ./.;
+          hooks = {
+            hyprland-treewide-formatter = {
+              enable = true;
+              entry = "${self.formatter.${system}}/bin/hyprland-treewide-formatter";
+              pass_filenames = false;
+              excludes = ["subprojects"];
+              always_run = true;
+            };
+          };
+        };
       });
 
     packages = eachSystem (system: {
@@ -98,13 +130,11 @@
       inherit
         (pkgsFor.${system})
         # hyprland-packages
-        
         hyprland
         hyprland-debug
         hyprland-legacy-renderer
         hyprland-unwrapped
         # hyprland-extras
-        
         xdg-desktop-portal-hyprland
         ;
       hyprland-cross = (pkgsCrossFor.${system} "aarch64-linux").hyprland;
@@ -119,10 +149,11 @@
           hardeningDisable = ["fortify"];
           inputsFrom = [pkgsFor.${system}.hyprland];
           packages = [pkgsFor.${system}.clang-tools];
+          inherit (self.checks.${system}.pre-commit-check) shellHook;
         };
     });
 
-    formatter = eachSystem (system: nixpkgs.legacyPackages.${system}.alejandra);
+    formatter = eachSystem (system: pkgsFor.${system}.callPackage ./nix/formatter.nix {});
 
     nixosModules.default = import ./nix/module.nix inputs;
     homeManagerModules.default = import ./nix/hm-module.nix self;

hyprctl/CMakeLists.txt

@@ -5,7 +5,7 @@ project(
     DESCRIPTION "Control utility for Hyprland"
 )
 
-pkg_check_modules(deps REQUIRED IMPORTED_TARGET hyprutils>=0.1.1)
+pkg_check_modules(hyprctl_deps REQUIRED IMPORTED_TARGET hyprutils>=0.2.4 re2)
 
 add_executable(hyprctl "main.cpp")
 

hyprctl/Strings.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <string_view>
+
 const std::string_view USAGE = R"#(usage: hyprctl [flags] <command> [args...|--help]
 
 commands:

hyprctl/main.cpp

@@ -1,3 +1,5 @@
+#include <re2/re2.h>
+
 #include <cctype>
 #include <netdb.h>
 #include <netinet/in.h>
@@ -17,16 +19,12 @@
 
 #include <iostream>
 #include <string>
+#include <print>
 #include <fstream>
-#include <string>
 #include <vector>
-#include <deque>
 #include <filesystem>
 #include <cstdarg>
-#include <regex>
-#include <sys/socket.h>
 #include <hyprutils/string/String.hpp>
-#include <cstring>
 using namespace Hyprutils::String;
 
 #include "Strings.hpp"
@@ -44,18 +42,24 @@ struct SInstanceData {
     bool        valid = true;
 };
 
-void log(std::string str) {
+void log(const std::string& str) {
     if (quiet)
         return;
 
-    std::cout << str << "\n";
+    std::println("{}", str);
+}
+
+static int getUID() {
+    const auto UID   = getuid();
+    const auto PWUID = getpwuid(UID);
+    return PWUID ? PWUID->pw_uid : UID;
 }
 
 std::string getRuntimeDir() {
     const auto XDG = getenv("XDG_RUNTIME_DIR");
 
     if (!XDG) {
-        const std::string USERID = std::to_string(getpwuid(getuid())->pw_uid);
+        const std::string USERID = std::to_string(getUID());
         return "/run/user/" + USERID + "/hypr";
     }
 
@@ -65,6 +69,11 @@ std::string getRuntimeDir() {
 std::vector<SInstanceData> instances() {
     std::vector<SInstanceData> result;
 
+    try {
+        if (!std::filesystem::exists(getRuntimeDir()))
+            return {};
+    } catch (std::exception& e) { return {}; }
+
     for (const auto& el : std::filesystem::directory_iterator(getRuntimeDir())) {
         if (!el.is_directory() || !std::filesystem::exists(el.path().string() + "/hyprland.lock"))
             continue;
@@ -105,7 +114,7 @@ std::vector<SInstanceData> instances() {
 static volatile bool sigintReceived = false;
 void                 intHandler(int sig) {
     sigintReceived = true;
-    std::cout << "[hyprctl] SIGINT received, closing connection" << std::endl;
+    std::println("[hyprctl] SIGINT received, closing connection");
 }
 
 int rollingRead(const int socket) {
@@ -115,12 +124,12 @@ int rollingRead(const int socket) {
     constexpr size_t              BUFFER_SIZE = 8192;
     std::array<char, BUFFER_SIZE> buffer      = {0};
     long                          sizeWritten = 0;
-    std::cout << "[hyprctl] reading from socket following up log:" << std::endl;
+    std::println("[hyprctl] reading from socket following up log:");
     while (!sigintReceived) {
         sizeWritten = read(socket, buffer.data(), BUFFER_SIZE);
         if (sizeWritten < 0 && errno != EAGAIN) {
             if (errno != EINTR)
-                std::cout << "Couldn't read (5) " << strerror(errno) << ":" << errno << std::endl;
+                std::println("Couldn't read (5): {}: {}", strerror(errno), errno);
             close(socket);
             return 5;
         }
@@ -129,7 +138,7 @@ int rollingRead(const int socket) {
             break;
 
         if (sizeWritten > 0) {
-            std::cout << std::string(buffer.data(), sizeWritten);
+            std::println("{}", std::string(buffer.data(), sizeWritten));
             buffer.fill('\0');
         }
 
@@ -162,7 +171,7 @@ int request(std::string arg, int minArgs = 0, bool needRoll = false) {
         return 2;
     }
 
-    const std::string USERID = std::to_string(getpwuid(getuid())->pw_uid);
+    const std::string USERID = std::to_string(getUID());
 
     sockaddr_un       serverAddress = {0};
     serverAddress.sun_family        = AF_UNIX;
@@ -232,7 +241,7 @@ int requestHyprpaper(std::string arg) {
     sockaddr_un serverAddress = {0};
     serverAddress.sun_family  = AF_UNIX;
 
-    const std::string USERID = std::to_string(getpwuid(getuid())->pw_uid);
+    const std::string USERID = std::to_string(getUID());
 
     std::string       socketPath = getRuntimeDir() + "/" + instanceSignature + "/.hyprpaper.sock";
 
@@ -270,10 +279,11 @@ int requestHyprpaper(std::string arg) {
 }
 
 void batchRequest(std::string arg, bool json) {
-    std::string commands = arg.substr(arg.find_first_of(" ") + 1);
+    std::string commands = arg.substr(arg.find_first_of(' ') + 1);
 
     if (json) {
-        commands = "j/" + std::regex_replace(commands, std::regex(";\\s*"), ";j/");
+        RE2::GlobalReplace(&commands, ";\\s*", ";j/");
+        commands.insert(0, "j/");
     }
 
     std::string rq = "[[BATCH]]" + commands;
@@ -310,11 +320,11 @@ void instancesRequest(bool json) {
     log(result + "\n");
 }
 
-std::deque<std::string> splitArgs(int argc, char** argv) {
-    std::deque<std::string> result;
+std::vector<std::string> splitArgs(int argc, char** argv) {
+    std::vector<std::string> result;
 
     for (auto i = 1 /* skip the executable */; i < argc; ++i)
-        result.push_back(std::string(argv[i]));
+        result.emplace_back(argv[i]);
 
     return result;
 }
@@ -323,7 +333,7 @@ int main(int argc, char** argv) {
     bool parseArgs = true;
 
     if (argc < 2) {
-        std::cout << USAGE << std::endl;
+        std::println("{}", USAGE);
         return 1;
     }
 
@@ -360,7 +370,7 @@ int main(int argc, char** argv) {
                 ++i;
 
                 if (i >= ARGS.size()) {
-                    std::cout << USAGE << std::endl;
+                    std::println("{}", USAGE);
                     return 1;
                 }
 
@@ -371,24 +381,24 @@ int main(int argc, char** argv) {
                 const std::string& cmd = ARGS[0];
 
                 if (cmd == "hyprpaper") {
-                    std::cout << HYPRPAPER_HELP << std::endl;
+                    std::println("{}", HYPRPAPER_HELP);
                 } else if (cmd == "notify") {
-                    std::cout << NOTIFY_HELP << std::endl;
+                    std::println("{}", NOTIFY_HELP);
                 } else if (cmd == "output") {
-                    std::cout << OUTPUT_HELP << std::endl;
+                    std::println("{}", OUTPUT_HELP);
                 } else if (cmd == "plugin") {
-                    std::cout << PLUGIN_HELP << std::endl;
+                    std::println("{}", PLUGIN_HELP);
                 } else if (cmd == "setprop") {
-                    std::cout << SETPROP_HELP << std::endl;
+                    std::println("{}", SETPROP_HELP);
                 } else if (cmd == "switchxkblayout") {
-                    std::cout << SWITCHXKBLAYOUT_HELP << std::endl;
+                    std::println("{}", SWITCHXKBLAYOUT_HELP);
                 } else {
-                    std::cout << USAGE << std::endl;
+                    std::println("{}", USAGE);
                 }
 
                 return 1;
             } else {
-                std::cout << USAGE << std::endl;
+                std::println("{}", USAGE);
                 return 1;
             }
 
@@ -399,7 +409,7 @@ int main(int argc, char** argv) {
     }
 
     if (fullRequest.empty()) {
-        std::cout << USAGE << std::endl;
+        std::println("{}", USAGE);
         return 1;
     }
 
@@ -476,7 +486,7 @@ int main(int argc, char** argv) {
     else if (fullRequest.contains("/decorations"))
         exitStatus = request(fullRequest, 1);
     else if (fullRequest.contains("/--help"))
-        std::cout << USAGE << std::endl;
+        std::println("{}", USAGE);
     else if (fullRequest.contains("/rollinglog") && needRoll)
         exitStatus = request(fullRequest, 0, true);
     else {

hyprctl/meson.build

@@ -3,6 +3,7 @@ executable(
   'main.cpp',
   dependencies: [
     dependency('hyprutils', version: '>= 0.1.1'),
+    dependency('re2', required: true)
   ],
   install: true,
 )

hyprpm/CMakeLists.txt

@@ -9,11 +9,25 @@ file(GLOB_RECURSE SRCFILES CONFIGURE_DEPENDS "src/*.cpp")
 
 set(CMAKE_CXX_STANDARD 23)
 
-pkg_check_modules(deps REQUIRED IMPORTED_TARGET tomlplusplus hyprutils>=0.1.1)
+pkg_check_modules(hyprpm_deps REQUIRED IMPORTED_TARGET tomlplusplus hyprutils>=0.2.4)
+
+find_package(glaze QUIET)
+if (NOT glaze_FOUND)
+    set(GLAZE_VERSION v4.2.3)
+    message(STATUS "glaze dependency not found, retrieving ${GLAZE_VERSION} with FetchContent")
+    include(FetchContent)
+    FetchContent_Declare(
+        glaze
+        GIT_REPOSITORY https://github.com/stephenberry/glaze.git
+        GIT_TAG ${GLAZE_VERSION}
+        GIT_SHALLOW TRUE
+    )
+    FetchContent_MakeAvailable(glaze)
+endif()
 
 add_executable(hyprpm ${SRCFILES})
 
-target_link_libraries(hyprpm PUBLIC PkgConfig::deps)
+target_link_libraries(hyprpm PUBLIC PkgConfig::hyprpm_deps glaze::glaze)
 
 # binary
 install(TARGETS hyprpm)

hyprpm/hyprpm.usage

@@ -14,7 +14,7 @@ hyprpm [<FLAGS>]... <ARGUMENT>
         |   (list)                      "List all installed plugins"
         |   (enable <PLUGINS>)          "Load a plugin"
         |   (disable <PLUGINS>)         "Unload a plugin"
-        |   (reload)                    "Reload all plugins"
+        |   (reload)                    "Reload plugins to match the enabled/disabled state. Use -f to force reload."
         ;
 
 <PLUGINS> ::= {{{ hyprpm list | awk '/Plugin/{print $4}' }}};

hyprpm/src/core/DataState.cpp

@@ -1,14 +1,13 @@
 #include "DataState.hpp"
 #include <toml++/toml.hpp>
-#include <iostream>
-#include <filesystem>
+#include <print>
 #include <fstream>
 #include "PluginManager.hpp"
 
-std::string DataState::getDataStatePath() {
+std::filesystem::path DataState::getDataStatePath() {
     const auto HOME = getenv("HOME");
     if (!HOME) {
-        std::cerr << "DataState: no $HOME\n";
+        std::println(stderr, "DataState: no $HOME");
         throw std::runtime_error("no $HOME");
         return "";
     }
@@ -16,12 +15,29 @@ std::string DataState::getDataStatePath() {
     const auto XDG_DATA_HOME = getenv("XDG_DATA_HOME");
 
     if (XDG_DATA_HOME)
-        return std::string{XDG_DATA_HOME} + "/hyprpm";
-    return std::string{HOME} + "/.local/share/hyprpm";
+        return std::filesystem::path{XDG_DATA_HOME} / "hyprpm";
+    return std::filesystem::path{HOME} / ".local/share/hyprpm";
 }
 
 std::string DataState::getHeadersPath() {
-    return getDataStatePath() + "/headersRoot";
+    return getDataStatePath() / "headersRoot";
+}
+
+std::vector<std::filesystem::path> DataState::getPluginStates() {
+    ensureStateStoreExists();
+
+    std::vector<std::filesystem::path> states;
+    for (const auto& entry : std::filesystem::directory_iterator(getDataStatePath())) {
+        if (!entry.is_directory() || entry.path().stem() == "headersRoot")
+            continue;
+
+        const auto stateFile = entry.path() / "state.toml";
+        if (!std::filesystem::exists(stateFile))
+            continue;
+
+        states.emplace_back(stateFile);
+    }
+    return states;
 }
 
 void DataState::ensureStateStoreExists() {
@@ -37,7 +53,7 @@ void DataState::ensureStateStoreExists() {
 void DataState::addNewPluginRepo(const SPluginRepository& repo) {
     ensureStateStoreExists();
 
-    const auto PATH = getDataStatePath() + "/" + repo.name;
+    const auto PATH = getDataStatePath() / repo.name;
 
     std::filesystem::create_directories(PATH);
     // clang-format off
@@ -50,19 +66,21 @@ void DataState::addNewPluginRepo(const SPluginRepository& repo) {
         }}
     };
     for (auto const& p : repo.plugins) {
+        const auto filename = p.name + ".so";
+
         // copy .so to the good place
         if (std::filesystem::exists(p.filename))
-            std::filesystem::copy_file(p.filename, PATH + "/" + p.name + ".so");
+            std::filesystem::copy_file(p.filename, PATH / filename);
 
         DATA.emplace(p.name, toml::table{
-            {"filename", p.name + ".so"},
+            {"filename", filename},
             {"enabled", p.enabled},
             {"failed", p.failed}
         });
     }
     // clang-format on
 
-    std::ofstream ofs(PATH + "/state.toml", std::ios::trunc);
+    std::ofstream ofs(PATH / "state.toml", std::ios::trunc);
     ofs << DATA;
     ofs.close();
 }
@@ -72,17 +90,10 @@ bool DataState::pluginRepoExists(const std::string& urlOrName) {
 
     const auto PATH = getDataStatePath();
 
-    for (const auto& entry : std::filesystem::directory_iterator(PATH)) {
-        if (!entry.is_directory() || entry.path().stem() == "headersRoot")
-            continue;
-
-        if (!std::filesystem::exists(entry.path().string() + "/state.toml"))
-            continue;
-
-        auto       STATE = toml::parse_file(entry.path().string() + "/state.toml");
-
-        const auto NAME = STATE["repository"]["name"].value_or("");
-        const auto URL  = STATE["repository"]["url"].value_or("");
+    for (const auto& stateFile : getPluginStates()) {
+        const auto STATE = toml::parse_file(stateFile.c_str());
+        const auto NAME  = STATE["repository"]["name"].value_or("");
+        const auto URL   = STATE["repository"]["url"].value_or("");
 
         if (URL == urlOrName || NAME == urlOrName)
             return true;
@@ -96,29 +107,22 @@ void DataState::removePluginRepo(const std::string& urlOrName) {
 
     const auto PATH = getDataStatePath();
 
-    for (const auto& entry : std::filesystem::directory_iterator(PATH)) {
-        if (!entry.is_directory() || entry.path().stem() == "headersRoot")
-            continue;
-
-        if (!std::filesystem::exists(entry.path().string() + "/state.toml"))
-            continue;
-
-        auto       STATE = toml::parse_file(entry.path().string() + "/state.toml");
-
-        const auto NAME = STATE["repository"]["name"].value_or("");
-        const auto URL  = STATE["repository"]["url"].value_or("");
+    for (const auto& stateFile : getPluginStates()) {
+        const auto STATE = toml::parse_file(stateFile.c_str());
+        const auto NAME  = STATE["repository"]["name"].value_or("");
+        const auto URL   = STATE["repository"]["url"].value_or("");
 
         if (URL == urlOrName || NAME == urlOrName) {
 
             // unload the plugins!!
-            for (const auto& file : std::filesystem::directory_iterator(entry.path())) {
+            for (const auto& file : std::filesystem::directory_iterator(stateFile.parent_path())) {
                 if (!file.path().string().ends_with(".so"))
                     continue;
 
                 g_pPluginManager->loadUnloadPlugin(std::filesystem::absolute(file.path()), false);
             }
 
-            std::filesystem::remove_all(entry.path());
+            std::filesystem::remove_all(stateFile.parent_path());
             return;
         }
     }
@@ -139,7 +143,7 @@ void DataState::updateGlobalState(const SGlobalState& state) {
     };
     // clang-format on
 
-    std::ofstream ofs(PATH + "/state.toml", std::ios::trunc);
+    std::ofstream ofs(PATH / "state.toml", std::ios::trunc);
     ofs << DATA;
     ofs.close();
 }
@@ -147,12 +151,12 @@ void DataState::updateGlobalState(const SGlobalState& state) {
 SGlobalState DataState::getGlobalState() {
     ensureStateStoreExists();
 
-    const auto PATH = getDataStatePath();
+    const auto stateFile = getDataStatePath() / "state.toml";
 
-    if (!std::filesystem::exists(PATH + "/state.toml"))
+    if (!std::filesystem::exists(stateFile))
         return SGlobalState{};
 
-    auto         DATA = toml::parse_file(PATH + "/state.toml");
+    auto         DATA = toml::parse_file(stateFile.c_str());
 
     SGlobalState state;
     state.headersHashCompiled = DATA["state"]["hash"].value_or("");
@@ -167,15 +171,8 @@ std::vector<SPluginRepository> DataState::getAllRepositories() {
     const auto                     PATH = getDataStatePath();
 
     std::vector<SPluginRepository> repos;
-
-    for (const auto& entry : std::filesystem::directory_iterator(PATH)) {
-        if (!entry.is_directory() || entry.path().stem() == "headersRoot")
-            continue;
-
-        if (!std::filesystem::exists(entry.path().string() + "/state.toml"))
-            continue;
-
-        auto              STATE = toml::parse_file(entry.path().string() + "/state.toml");
+    for (const auto& stateFile : getPluginStates()) {
+        const auto        STATE = toml::parse_file(stateFile.c_str());
 
         const auto        NAME = STATE["repository"]["name"].value_or("");
         const auto        URL  = STATE["repository"]["url"].value_or("");
@@ -210,15 +207,8 @@ bool DataState::setPluginEnabled(const std::string& name, bool enabled) {
 
     const auto PATH = getDataStatePath();
 
-    for (const auto& entry : std::filesystem::directory_iterator(PATH)) {
-        if (!entry.is_directory() || entry.path().stem() == "headersRoot")
-            continue;
-
-        if (!std::filesystem::exists(entry.path().string() + "/state.toml"))
-            continue;
-
-        auto STATE = toml::parse_file(entry.path().string() + "/state.toml");
-
+    for (const auto& stateFile : getPluginStates()) {
+        const auto STATE = toml::parse_file(stateFile.c_str());
         for (const auto& [key, val] : STATE) {
             if (key == "repository")
                 continue;
@@ -231,10 +221,11 @@ bool DataState::setPluginEnabled(const std::string& name, bool enabled) {
             if (FAILED)
                 return false;
 
-            (*STATE[key].as_table()).insert_or_assign("enabled", enabled);
+            auto modifiedState = STATE;
+            (*modifiedState[key].as_table()).insert_or_assign("enabled", enabled);
 
-            std::ofstream state(entry.path().string() + "/state.toml", std::ios::trunc);
-            state << STATE;
+            std::ofstream state(stateFile, std::ios::trunc);
+            state << modifiedState;
             state.close();
 
             return true;
@@ -242,4 +233,4 @@ bool DataState::setPluginEnabled(const std::string& name, bool enabled) {
     }
 
     return false;
-}
+}

hyprpm/src/core/DataState.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include <filesystem>
 #include <string>
 #include <vector>
 #include "Plugin.hpp"
@@ -9,14 +10,15 @@ struct SGlobalState {
 };
 
 namespace DataState {
-    std::string                    getDataStatePath();
-    std::string                    getHeadersPath();
-    void                           ensureStateStoreExists();
-    void                           addNewPluginRepo(const SPluginRepository& repo);
-    void                           removePluginRepo(const std::string& urlOrName);
-    bool                           pluginRepoExists(const std::string& urlOrName);
-    void                           updateGlobalState(const SGlobalState& state);
-    SGlobalState                   getGlobalState();
-    bool                           setPluginEnabled(const std::string& name, bool enabled);
-    std::vector<SPluginRepository> getAllRepositories();
+    std::filesystem::path              getDataStatePath();
+    std::string                        getHeadersPath();
+    std::vector<std::filesystem::path> getPluginStates();
+    void                               ensureStateStoreExists();
+    void                               addNewPluginRepo(const SPluginRepository& repo);
+    void                               removePluginRepo(const std::string& urlOrName);
+    bool                               pluginRepoExists(const std::string& urlOrName);
+    void                               updateGlobalState(const SGlobalState& state);
+    SGlobalState                       getGlobalState();
+    bool                               setPluginEnabled(const std::string& name, bool enabled);
+    std::vector<SPluginRepository>     getAllRepositories();
 };

hyprpm/src/core/PluginManager.cpp

@@ -1,13 +1,14 @@
 #include "PluginManager.hpp"
 #include "../helpers/Colors.hpp"
+#include "../helpers/StringUtils.hpp"
 #include "../progress/CProgressBar.hpp"
 #include "Manifest.hpp"
 #include "DataState.hpp"
 
+#include <cstdio>
 #include <iostream>
-#include <array>
 #include <filesystem>
-#include <thread>
+#include <print>
 #include <fstream>
 #include <algorithm>
 #include <format>
@@ -18,39 +19,59 @@
 #include <unistd.h>
 
 #include <toml++/toml.hpp>
+#include <glaze/glaze.hpp>
 
 #include <hyprutils/string/String.hpp>
+#include <hyprutils/os/Process.hpp>
 using namespace Hyprutils::String;
+using namespace Hyprutils::OS;
 
 static std::string execAndGet(std::string cmd) {
     cmd += " 2>&1";
-    std::array<char, 128> buffer;
-    std::string           result;
-    using PcloseType = int (*)(FILE*);
-    const std::unique_ptr<FILE, PcloseType> pipe(popen(cmd.c_str(), "r"), static_cast<PcloseType>(pclose));
-    if (!pipe)
-        return "";
 
-    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
-        result += buffer.data();
-    }
-    return result;
+    CProcess proc("/bin/sh", {"-c", cmd});
+
+    if (!proc.runSync())
+        return "error";
+
+    return proc.stdOut();
 }
 
-SHyprlandVersion CPluginManager::getHyprlandVersion() {
-    static SHyprlandVersion ver;
-    static bool             once = false;
+static std::string getTempRoot() {
+    static auto ENV = getenv("XDG_RUNTIME_DIR");
+    if (!ENV) {
+        std::cerr << "\nERROR: XDG_RUNTIME_DIR not set!\n";
+        exit(1);
+    }
 
-    if (once)
-        return ver;
+    const auto STR = ENV + std::string{"/hyprpm/"};
 
-    once                 = true;
-    const auto HLVERCALL = execAndGet("hyprctl version");
+    return STR;
+}
+
+SHyprlandVersion CPluginManager::getHyprlandVersion(bool running) {
+    static bool             onceRunning   = false;
+    static bool             onceInstalled = false;
+    static SHyprlandVersion verRunning;
+    static SHyprlandVersion verInstalled;
+
+    if (onceRunning && running)
+        return verRunning;
+
+    if (onceInstalled && !running)
+        return verInstalled;
+
+    if (running)
+        onceRunning = true;
+    else
+        onceInstalled = true;
+
+    const auto HLVERCALL = running ? execAndGet("hyprctl version") : execAndGet("Hyprland --version");
     if (m_bVerbose)
-        std::cout << Colors::BLUE << "[v] " << Colors::RESET << "version returned: " << HLVERCALL << "\n";
+        std::println("{}", verboseString("{} version returned: {}", running ? "running" : "installed", HLVERCALL));
 
     if (!HLVERCALL.contains("Tag:")) {
-        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " You don't seem to be running Hyprland.";
+        std::println(stderr, "\n{}", failureString("You don't seem to be running Hyprland."));
         return SHyprlandVersion{};
     }
 
@@ -61,13 +82,13 @@ SHyprlandVersion CPluginManager::getHyprlandVersion() {
     hlbranch             = hlbranch.substr(0, hlbranch.find(" at commit "));
 
     std::string hldate = HLVERCALL.substr(HLVERCALL.find("Date: ") + 6);
-    hldate             = hldate.substr(0, hldate.find("\n"));
+    hldate             = hldate.substr(0, hldate.find('\n'));
 
     std::string hlcommits;
 
     if (HLVERCALL.contains("commits:")) {
         hlcommits = HLVERCALL.substr(HLVERCALL.find("commits:") + 9);
-        hlcommits = hlcommits.substr(0, hlcommits.find(" "));
+        hlcommits = hlcommits.substr(0, hlcommits.find(' '));
     }
 
     int commits = 0;
@@ -76,14 +97,20 @@ SHyprlandVersion CPluginManager::getHyprlandVersion() {
     } catch (...) { ; }
 
     if (m_bVerbose)
-        std::cout << Colors::BLUE << "[v] " << Colors::RESET << "parsed commit " << hlcommit << " at branch " << hlbranch << " on " << hldate << ", commits " << commits << "\n";
+        std::println("{}", verboseString("parsed commit {} at branch {} on {}, commits {}", hlcommit, hlbranch, hldate, commits));
+
+    auto ver = SHyprlandVersion{hlbranch, hlcommit, hldate, commits};
+
+    if (running)
+        verRunning = ver;
+    else
+        verInstalled = ver;
 
-    ver = SHyprlandVersion{hlbranch, hlcommit, hldate, commits};
     return ver;
 }
 
 bool CPluginManager::createSafeDirectory(const std::string& path) {
-    if (path.empty() || !path.starts_with("/tmp"))
+    if (path.empty() || !path.starts_with(getTempRoot()))
         return false;
 
     if (std::filesystem::exists(path))
@@ -102,20 +129,21 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     const auto HLVER = getHyprlandVersion();
 
     if (!hasDeps()) {
-        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not clone the plugin repository. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio\n";
+        std::println(stderr, "\n{}", failureString("Could not clone the plugin repository. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio, pkg-config"));
         return false;
     }
 
     if (DataState::pluginRepoExists(url)) {
-        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not clone the plugin repository. Repository already installed.\n";
+        std::println(stderr, "\n{}", failureString("Could not clone the plugin repository. Repository already installed."));
         return false;
     }
 
     auto GLOBALSTATE = DataState::getGlobalState();
     if (!GLOBALSTATE.dontWarnInstall) {
-        std::cout << Colors::YELLOW << "!" << Colors::RED << " Disclaimer:\n  " << Colors::RESET
-                  << "plugins, especially not official, have no guarantee of stability, availablity or security.\n  Run them at your own risk.\n  "
-                  << "This message will not appear again.\n";
+        std::println("{}!{} Disclaimer: {}", Colors::YELLOW, Colors::RED, Colors::RESET);
+        std::println("plugins, especially not official, have no guarantee of stability, availablity or security.\n"
+                     "Run them at your own risk.\n"
+                     "This message will not appear again.");
         GLOBALSTATE.dontWarnInstall = true;
         DataState::updateGlobalState(GLOBALSTATE);
     }
@@ -129,7 +157,7 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     std::getline(std::cin, input);
 
     if (input.size() > 0 && input[0] != 'Y' && input[0] != 'y') {
-        std::cout << "Aborting.\n";
+        std::println(stderr, "Aborting.");
         return false;
     }
 
@@ -140,72 +168,72 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
 
     progress.print();
 
-    if (!std::filesystem::exists("/tmp/hyprpm")) {
-        std::filesystem::create_directory("/tmp/hyprpm");
-        std::filesystem::permissions("/tmp/hyprpm", std::filesystem::perms::all, std::filesystem::perm_options::replace);
-    } else if (!std::filesystem::is_directory("/tmp/hyprpm")) {
-        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not prepare working dir for hyprpm\n";
+    if (!std::filesystem::exists(getTempRoot())) {
+        std::filesystem::create_directory(getTempRoot());
+        std::filesystem::permissions(getTempRoot(), std::filesystem::perms::owner_all, std::filesystem::perm_options::replace);
+    } else if (!std::filesystem::is_directory(getTempRoot())) {
+        std::println(stderr, "\n{}", failureString("Could not prepare working dir for hyprpm"));
         return false;
     }
 
     const std::string USERNAME = getpwuid(getuid())->pw_name;
 
-    m_szWorkingPluginDirectory = "/tmp/hyprpm/" + USERNAME;
+    m_szWorkingPluginDirectory = getTempRoot() + USERNAME;
 
     if (!createSafeDirectory(m_szWorkingPluginDirectory)) {
-        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not prepare working dir for repo\n";
+        std::println(stderr, "\n{}", failureString("Could not prepare working dir for repo"));
         return false;
     }
 
-    progress.printMessageAbove(std::string{Colors::RESET} + " → Cloning " + url);
+    progress.printMessageAbove(infoString("Cloning {}", url));
 
-    std::string ret = execAndGet("cd /tmp/hyprpm && git clone --recursive " + url + " " + USERNAME);
+    std::string ret = execAndGet(std::format("cd {} && git clone --recursive {} {}", getTempRoot(), url, USERNAME));
 
     if (!std::filesystem::exists(m_szWorkingPluginDirectory + "/.git")) {
-        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not clone the plugin repository. shell returned:\n" << ret << "\n";
+        std::println(stderr, "\n{}", failureString("Could not clone the plugin repository. shell returned:\n{}", ret));
         return false;
     }
 
     if (!rev.empty()) {
         std::string ret = execAndGet("git -C " + m_szWorkingPluginDirectory + " reset --hard --recurse-submodules " + rev);
         if (ret.compare(0, 6, "fatal:") == 0) {
-            std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not check out revision " << rev << ". shell returned:\n" << ret << "\n";
+            std::println(stderr, "\n{}", failureString("Could not check out revision {}. shell returned:\n{}", rev, ret));
             return false;
         }
         ret = execAndGet("git -C " + m_szWorkingPluginDirectory + " submodule update --init");
         if (m_bVerbose)
-            std::cout << Colors::BLUE << "[v] " << Colors::RESET << "git submodule update --init returned: " << ret << "\n";
+            std::println("{}", verboseString("git submodule update --init returned: {}", ret));
     }
 
     progress.m_iSteps = 1;
-    progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " cloned");
+    progress.printMessageAbove(successString("cloned"));
     progress.m_szCurrentMessage = "Reading the manifest";
     progress.print();
 
     std::unique_ptr<CManifest> pManifest;
 
     if (std::filesystem::exists(m_szWorkingPluginDirectory + "/hyprpm.toml")) {
-        progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " found hyprpm manifest");
+        progress.printMessageAbove(successString("found hyprpm manifest"));
         pManifest = std::make_unique<CManifest>(MANIFEST_HYPRPM, m_szWorkingPluginDirectory + "/hyprpm.toml");
     } else if (std::filesystem::exists(m_szWorkingPluginDirectory + "/hyprload.toml")) {
-        progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " found hyprload manifest");
+        progress.printMessageAbove(successString("found hyprload manifest"));
         pManifest = std::make_unique<CManifest>(MANIFEST_HYPRLOAD, m_szWorkingPluginDirectory + "/hyprload.toml");
     }
 
     if (!pManifest) {
-        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " The provided plugin repository does not have a valid manifest\n";
+        std::println(stderr, "\n{}", failureString("The provided plugin repository does not have a valid manifest"));
         return false;
     }
 
     if (!pManifest->m_bGood) {
-        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " The provided plugin repository has a corrupted manifest\n";
+        std::println(stderr, "\n{}", failureString("The provided plugin repository has a corrupted manifest"));
         return false;
     }
 
     progress.m_iSteps = 2;
-    progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " parsed manifest, found " + std::to_string(pManifest->m_vPlugins.size()) + " plugins:");
+    progress.printMessageAbove(successString("parsed manifest, found " + std::to_string(pManifest->m_vPlugins.size()) + " plugins:"));
     for (auto const& pl : pManifest->m_vPlugins) {
-        std::string message = std::string{Colors::RESET} + " → " + pl.name + " by ";
+        std::string message = "→ " + pl.name + " by ";
         for (auto const& a : pl.authors) {
             message += a + ", ";
         }
@@ -220,19 +248,19 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     if (!pManifest->m_sRepository.commitPins.empty()) {
         // check commit pins
 
-        progress.printMessageAbove(std::string{Colors::RESET} + " → Manifest has " + std::to_string(pManifest->m_sRepository.commitPins.size()) + " pins, checking");
+        progress.printMessageAbove(infoString("Manifest has {} pins, checking", pManifest->m_sRepository.commitPins.size()));
 
         for (auto const& [hl, plugin] : pManifest->m_sRepository.commitPins) {
             if (hl != HLVER.hash)
                 continue;
 
-            progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " commit pin " + plugin + " matched hl, resetting");
+            progress.printMessageAbove(successString("commit pin {} matched hl, resetting", plugin));
 
             execAndGet("cd " + m_szWorkingPluginDirectory + " && git reset --hard --recurse-submodules " + plugin);
 
             ret = execAndGet("git -C " + m_szWorkingPluginDirectory + " submodule update --init");
             if (m_bVerbose)
-                std::cout << Colors::BLUE << "[v] " << Colors::RESET << "git submodule update --init returned: " << ret << "\n";
+                std::println("{}", verboseString("git submodule update --init returned: {}", ret));
 
             break;
         }
@@ -244,12 +272,12 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     const auto HEADERSSTATUS = headersValid();
 
     if (HEADERSSTATUS != HEADERS_OK) {
-        std::cerr << "\n" << headerError(HEADERSSTATUS);
+        std::println("\n{}", headerError(HEADERSSTATUS));
         return false;
     }
 
     progress.m_iSteps = 3;
-    progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " Hyprland headers OK");
+    progress.printMessageAbove(successString("Hyprland headers OK"));
     progress.m_szCurrentMessage = "Building plugin(s)";
     progress.print();
 
@@ -257,35 +285,36 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
         std::string out;
 
         if (p.since > HLVER.commits && HLVER.commits >= 1 /* for --depth 1 clones, we can't check this. */) {
-            progress.printMessageAbove(std::string{Colors::RED} + "✖" + Colors::RESET + " Not building " + p.name + ": your Hyprland version is too old.\n");
+            progress.printMessageAbove(failureString("Not building {}: your Hyprland version is too old.\n", p.name));
             p.failed = true;
             continue;
         }
 
-        progress.printMessageAbove(std::string{Colors::RESET} + " → Building " + p.name);
+        progress.printMessageAbove(infoString("Building {}", p.name));
 
         for (auto const& bs : p.buildSteps) {
-            std::string cmd = std::format("cd {} && PKG_CONFIG_PATH=\"{}/share/pkgconfig\" {}", m_szWorkingPluginDirectory, DataState::getHeadersPath(), bs);
+            const std::string& cmd = std::format("cd {} && PKG_CONFIG_PATH=\"{}/share/pkgconfig\" {}", m_szWorkingPluginDirectory, DataState::getHeadersPath(), bs);
             out += " -> " + cmd + "\n" + execAndGet(cmd) + "\n";
         }
 
         if (m_bVerbose)
-            std::cout << Colors::BLUE << "[v] " << Colors::RESET << "shell returned: " << out << "\n";
+            std::println("{}", verboseString("shell returned: {}", out));
 
         if (!std::filesystem::exists(m_szWorkingPluginDirectory + "/" + p.output)) {
-            progress.printMessageAbove(std::string{Colors::RED} + "✖" + Colors::RESET + " Plugin " + p.name + " failed to build.\n" +
-                                       "  This likely means that the plugin is either outdated, not yet available for your version, or broken.\n  If you are on -git, update "
-                                       "first.\n  Try re-running with -v to see "
-                                       "more verbose output.\n");
+            progress.printMessageAbove(failureString("Plugin {} failed to build.\n"
+                                                     "  This likely means that the plugin is either outdated, not yet available for your version, or broken.\n"
+                                                     "  If you are on -git, update first\n"
+                                                     "  Try re-running with -v to see more verbose output.\n",
+                                                     p.name));
 
             p.failed = true;
             continue;
         }
 
-        progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " built " + p.name + " into " + p.output);
+        progress.printMessageAbove(successString("built {} into {}", p.name, p.output));
     }
 
-    progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " all plugins built");
+    progress.printMessageAbove(successString("all plugins built"));
     progress.m_iSteps           = 4;
     progress.m_szCurrentMessage = "Installing repository";
     progress.print();
@@ -304,13 +333,13 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     }
     DataState::addNewPluginRepo(repo);
 
-    progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " installed repository");
-    progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " you can now enable the plugin(s) with hyprpm enable");
+    progress.printMessageAbove(successString("installed repository"));
+    progress.printMessageAbove(successString("you can now enable the plugin(s) with hyprpm enable"));
     progress.m_iSteps           = 5;
     progress.m_szCurrentMessage = "Done!";
     progress.print();
 
-    std::cout << "\n";
+    std::print("\n");
 
     // remove build files
     std::filesystem::remove_all(m_szWorkingPluginDirectory);
@@ -320,7 +349,7 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
 
 bool CPluginManager::removePluginRepo(const std::string& urlOrName) {
     if (!DataState::pluginRepoExists(urlOrName)) {
-        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not remove the repository. Repository is not installed.\n";
+        std::println(stderr, "\n{}", failureString("Could not remove the repository. Repository is not installed."));
         return false;
     }
 
@@ -331,7 +360,7 @@ bool CPluginManager::removePluginRepo(const std::string& urlOrName) {
     std::getline(std::cin, input);
 
     if (input.size() > 0 && input[0] != 'Y' && input[0] != 'y') {
-        std::cout << "Aborting.\n";
+        std::println("Aborting.");
         return false;
     }
 
@@ -341,21 +370,21 @@ bool CPluginManager::removePluginRepo(const std::string& urlOrName) {
 }
 
 eHeadersErrors CPluginManager::headersValid() {
-    const auto HLVER = getHyprlandVersion();
+    const auto HLVER = getHyprlandVersion(false);
 
     if (!std::filesystem::exists(DataState::getHeadersPath() + "/share/pkgconfig/hyprland.pc"))
         return HEADERS_MISSING;
 
     // find headers commit
-    std::string cmd     = std::format("PKG_CONFIG_PATH=\"{}/share/pkgconfig\" pkgconf --cflags --keep-system-cflags hyprland", DataState::getHeadersPath());
-    auto        headers = execAndGet(cmd.c_str());
+    const std::string& cmd     = std::format("PKG_CONFIG_PATH=\"{}/share/pkgconfig\" pkgconf --cflags --keep-system-cflags hyprland", DataState::getHeadersPath());
+    auto               headers = execAndGet(cmd);
 
     if (!headers.contains("-I/"))
         return HEADERS_MISSING;
 
     headers.pop_back(); // pop newline
 
-    std::string verHeader = "";
+    std::string verHeader;
 
     while (!headers.empty()) {
         const auto PATH = headers.substr(0, headers.find(" -I/", 3));
@@ -403,20 +432,20 @@ bool CPluginManager::updateHeaders(bool force) {
 
     DataState::ensureStateStoreExists();
 
-    const auto HLVER = getHyprlandVersion();
+    const auto HLVER = getHyprlandVersion(false);
 
     if (!hasDeps()) {
-        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not update. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio\n";
+        std::println("\n{}", failureString("Could not update. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio, pkg-config"));
         return false;
     }
 
-    if (!std::filesystem::exists("/tmp/hyprpm")) {
-        std::filesystem::create_directory("/tmp/hyprpm");
-        std::filesystem::permissions("/tmp/hyprpm", std::filesystem::perms::all, std::filesystem::perm_options::replace);
+    if (!std::filesystem::exists(getTempRoot())) {
+        std::filesystem::create_directory(getTempRoot());
+        std::filesystem::permissions(getTempRoot(), std::filesystem::perms::owner_all, std::filesystem::perm_options::replace);
     }
 
     if (!force && headersValid() == HEADERS_OK) {
-        std::cout << "\n" << std::string{Colors::GREEN} + "✔" + Colors::RESET + " Headers up to date.\n";
+        std::println("\n{}", successString("Headers up to date."));
         return true;
     }
 
@@ -427,77 +456,76 @@ bool CPluginManager::updateHeaders(bool force) {
     progress.print();
 
     const std::string USERNAME   = getpwuid(getuid())->pw_name;
-    const auto        WORKINGDIR = "/tmp/hyprpm/hyprland-" + USERNAME;
+    const auto        WORKINGDIR = getTempRoot() + "hyprland-" + USERNAME;
 
     if (!createSafeDirectory(WORKINGDIR)) {
-        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not prepare working dir for hl\n";
+        std::println("\n{}", failureString("Could not prepare working dir for hl"));
         return false;
     }
 
-    progress.printMessageAbove(std::string{Colors::YELLOW} + "!" + Colors::RESET + " Cloning https://github.com/hyprwm/hyprland, this might take a moment.");
+    progress.printMessageAbove(statusString("!", Colors::YELLOW, "Cloning https://github.com/hyprwm/Hyprland, this might take a moment."));
 
-    const bool bShallow = (HLVER.branch == "main" || HLVER.branch == "") && !m_bNoShallow;
+    const bool bShallow = (HLVER.branch == "main") && !m_bNoShallow;
 
     // let us give a bit of leg-room for shallowing
     // due to timezones, etc.
-    const std::string SHALLOW_DATE =
-        trim(HLVER.date).empty() ? "" : execAndGet("LC_TIME=\"en_US.UTF-8\" date --date='" + HLVER.date + " - 1 weeks' '+\%a \%b \%d \%H:\%M:\%S \%Y'");
+    const std::string SHALLOW_DATE = trim(HLVER.date).empty() ? "" : execAndGet("LC_TIME=\"en_US.UTF-8\" date --date='" + HLVER.date + " - 1 weeks' '+%a %b %d %H:%M:%S %Y'");
 
     if (m_bVerbose && bShallow)
-        progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "will shallow since: " + SHALLOW_DATE);
+        progress.printMessageAbove(verboseString("will shallow since: {}", SHALLOW_DATE));
 
-    std::string ret =
-        execAndGet("cd /tmp/hyprpm && git clone --recursive https://github.com/hyprwm/hyprland hyprland-" + USERNAME + (bShallow ? " --shallow-since='" + SHALLOW_DATE + "'" : ""));
+    std::string ret = execAndGet(std::format("cd {} && git clone --recursive https://github.com/hyprwm/Hyprland hyprland-{}{}", getTempRoot(), USERNAME,
+                                             (bShallow ? " --shallow-since='" + SHALLOW_DATE + "'" : "")));
 
     if (!std::filesystem::exists(WORKINGDIR)) {
-        progress.printMessageAbove(std::string{Colors::RED} + "✖" + Colors::RESET + " Clone failed. Retrying without shallow.");
-        ret = execAndGet("cd /tmp/hyprpm && git clone --recursive https://github.com/hyprwm/hyprland hyprland-" + USERNAME);
+        progress.printMessageAbove(failureString("Clone failed. Retrying without shallow."));
+        ret = execAndGet(std::format("cd {} && git clone --recursive https://github.com/hyprwm/hyprland hyprland-{}", getTempRoot(), USERNAME));
     }
 
     if (!std::filesystem::exists(WORKINGDIR + "/.git")) {
-        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not clone the hyprland repository. shell returned:\n" << ret << "\n";
+        std::println(stderr, "\n{}", failureString("Could not clone the Hyprland repository. shell returned:\n{}", ret));
         return false;
     }
 
-    progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " cloned");
+    progress.printMessageAbove(successString("Hyprland cloned"));
     progress.m_iSteps           = 2;
     progress.m_szCurrentMessage = "Checking out sources";
     progress.print();
 
     if (m_bVerbose)
-        progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "will run: " + "cd " + WORKINGDIR + " && git checkout " + HLVER.hash + " 2>&1");
+        progress.printMessageAbove(verboseString("will run: cd {} && git checkout {} 2>&1", WORKINGDIR, HLVER.hash));
 
     ret = execAndGet("cd " + WORKINGDIR + " && git checkout " + HLVER.hash + " 2>&1");
 
     if (ret.contains("fatal: unable to read tree")) {
-        std::cerr << "\n"
-                  << Colors::RED << "✖" << Colors::RESET
-                  << " Could not checkout the running Hyprland commit. If you are on -git, try updating.\nYou can also try re-running hyprpm update with --no-shallow.\n";
+        std::println(stderr, "\n{}",
+                     failureString("Could not checkout the running Hyprland commit. If you are on -git, try updating.\n"
+                                   "You can also try re-running hyprpm update with --no-shallow."));
         return false;
     }
 
     if (m_bVerbose)
-        progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "git returned (co): " + ret);
+        progress.printMessageAbove(verboseString("git returned (co): {}", ret));
 
     ret = execAndGet("cd " + WORKINGDIR + " ; git rm subprojects/tracy ; git submodule update --init 2>&1 ; git reset --hard --recurse-submodules " + HLVER.hash);
 
     if (m_bVerbose)
-        progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "git returned (rs): " + ret);
+        progress.printMessageAbove(verboseString("git returned (rs): {}", ret));
 
-    progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " checked out to running ver");
+    progress.printMessageAbove(successString("checked out to running ver"));
     progress.m_iSteps           = 3;
     progress.m_szCurrentMessage = "Building Hyprland";
     progress.print();
 
-    progress.printMessageAbove(std::string{Colors::YELLOW} + "!" + Colors::RESET + " configuring Hyprland");
+    progress.printMessageAbove(statusString("!", Colors::YELLOW, "configuring Hyprland"));
 
     if (m_bVerbose)
-        progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "setting PREFIX for cmake to " + DataState::getHeadersPath());
+        progress.printMessageAbove(verboseString("setting PREFIX for cmake to {}", DataState::getHeadersPath()));
 
     ret = execAndGet(std::format("cd {} && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:STRING=\"{}\" -S . -B ./build -G Ninja", WORKINGDIR,
                                  DataState::getHeadersPath()));
     if (m_bVerbose)
-        progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "cmake returned: " + ret);
+        progress.printMessageAbove(verboseString("cmake returned: {}", ret));
 
     if (ret.contains("CMake Error at")) {
         // missing deps, let the user know.
@@ -506,48 +534,46 @@ bool CPluginManager::updateHeaders(bool force) {
         missing             = missing.substr(0, missing.find("-- Configuring incomplete"));
         missing             = missing.substr(0, missing.find_last_of('\n'));
 
-        std::cerr << "\n"
-                  << Colors::RED << "✖" << Colors::RESET << " Could not configure the hyprland source, cmake complained:\n"
-                  << missing << "\n\nThis likely means that you are missing the above dependencies or they are out of date.\n";
+        std::println(stderr, "\n{}",
+                     failureString("Could not configure the hyprland source, cmake complained:\n{}\n\n"
+                                   "This likely means that you are missing the above dependencies or they are out of date.",
+                                   missing));
         return false;
     }
 
-    progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " configured Hyprland");
+    progress.printMessageAbove(successString("configured Hyprland"));
     progress.m_iSteps           = 4;
     progress.m_szCurrentMessage = "Installing sources";
     progress.print();
 
-    std::string cmd =
+    const std::string& cmd =
         std::format("sed -i -e \"s#PREFIX = /usr/local#PREFIX = {}#\" {}/Makefile && cd {} && make installheaders", DataState::getHeadersPath(), WORKINGDIR, WORKINGDIR);
     if (m_bVerbose)
-        progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "installation will run: " + cmd);
+        progress.printMessageAbove(verboseString("installation will run: {}", cmd));
 
     ret = execAndGet(cmd);
 
     if (m_bVerbose)
-        std::cout << Colors::BLUE << "[v] " << Colors::RESET << "installer returned: " << ret << "\n";
+        std::println("{}", verboseString("installer returned: {}", ret));
 
     // remove build files
     std::filesystem::remove_all(WORKINGDIR);
 
     auto HEADERSVALID = headersValid();
     if (HEADERSVALID == HEADERS_OK) {
-        progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " installed headers");
+        progress.printMessageAbove(successString("installed headers"));
         progress.m_iSteps           = 5;
         progress.m_szCurrentMessage = "Done!";
         progress.print();
 
-        std::cout << "\n";
+        std::print("\n");
     } else {
-        progress.printMessageAbove(std::string{Colors::RED} + "✖" + Colors::RESET + " failed to install headers with error code " + std::to_string((int)HEADERSVALID) + " (" +
-                                   headerErrorShort(HEADERSVALID) + ")");
+        progress.printMessageAbove(failureString("failed to install headers with error code {} ({})", (int)HEADERSVALID, headerErrorShort(HEADERSVALID)));
         progress.m_iSteps           = 5;
         progress.m_szCurrentMessage = "Failed";
         progress.print();
 
-        std::cout << "\n";
-
-        std::cerr << "\n" << headerError(HEADERSVALID);
+        std::print(stderr, "\n\n{}", headerError(HEADERSVALID));
 
         return false;
     }
@@ -557,18 +583,18 @@ bool CPluginManager::updateHeaders(bool force) {
 
 bool CPluginManager::updatePlugins(bool forceUpdateAll) {
     if (headersValid() != HEADERS_OK) {
-        std::cout << "\n" << std::string{Colors::RED} + "✖" + Colors::RESET + " headers are not up-to-date, please run hyprpm update.\n";
+        std::println("{}", failureString("headers are not up-to-date, please run hyprpm update."));
         return false;
     }
 
     const auto REPOS = DataState::getAllRepositories();
 
     if (REPOS.size() < 1) {
-        std::cout << "\n" << std::string{Colors::RED} + "✖" + Colors::RESET + " No repos to update.\n";
+        std::println("{}", failureString("No repos to update."));
         return true;
     }
 
-    const auto   HLVER = getHyprlandVersion();
+    const auto   HLVER = getHyprlandVersion(false);
 
     CProgressBar progress;
     progress.m_iMaxSteps        = REPOS.size() * 2 + 2;
@@ -577,7 +603,7 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
     progress.print();
 
     const std::string USERNAME = getpwuid(getuid())->pw_name;
-    m_szWorkingPluginDirectory = "/tmp/hyprpm/" + USERNAME;
+    m_szWorkingPluginDirectory = getTempRoot() + USERNAME;
 
     for (auto const& repo : REPOS) {
         bool update = forceUpdateAll;
@@ -586,25 +612,26 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
         progress.m_szCurrentMessage = "Updating " + repo.name;
         progress.print();
 
-        progress.printMessageAbove(std::string{Colors::RESET} + " → checking for updates for " + repo.name);
+        progress.printMessageAbove(infoString("checking for updates for {}", repo.name));
 
         createSafeDirectory(m_szWorkingPluginDirectory);
 
-        progress.printMessageAbove(std::string{Colors::RESET} + " → Cloning " + repo.url);
+        progress.printMessageAbove(infoString("Cloning {}", repo.url));
 
-        std::string ret = execAndGet("cd /tmp/hyprpm && git clone --recursive " + repo.url + " " + USERNAME);
+        std::string ret = execAndGet(std::format("cd {} && git clone --recursive {} {}", getTempRoot(), repo.url, USERNAME));
 
         if (!std::filesystem::exists(m_szWorkingPluginDirectory + "/.git")) {
-            std::cout << "\n" << std::string{Colors::RED} + "✖" + Colors::RESET + " could not clone repo: shell returned:\n" + ret;
+            std::println("{}", failureString("could not clone repo: shell returned: {}", ret));
             return false;
         }
 
         if (!repo.rev.empty()) {
-            progress.printMessageAbove(std::string{Colors::RESET} + " → Plugin has revision set, resetting: " + repo.rev);
+            progress.printMessageAbove(infoString("Plugin has revision set, resetting: {}", repo.rev));
 
             std::string ret = execAndGet("git -C " + m_szWorkingPluginDirectory + " reset --hard --recurse-submodules " + repo.rev);
             if (ret.compare(0, 6, "fatal:") == 0) {
-                std::cout << "\n" << std::string{Colors::RED} + "✖" + Colors::RESET + " could not check out revision " + repo.rev + ": shell returned:\n" + ret;
+                std::println(stderr, "\n{}", failureString("could not check out revision {}: shell returned:\n{}", repo.rev, ret));
+
                 return false;
             }
         }
@@ -620,7 +647,7 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
 
         if (!update) {
             std::filesystem::remove_all(m_szWorkingPluginDirectory);
-            progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " repository " + repo.name + " is up-to-date.");
+            progress.printMessageAbove(successString("repository {} is up-to-date.", repo.name));
             progress.m_iSteps++;
             progress.print();
             continue;
@@ -628,41 +655,41 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
 
         // we need to update
 
-        progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " repository " + repo.name + " has updates.");
-        progress.printMessageAbove(std::string{Colors::RESET} + " → Building " + repo.name);
+        progress.printMessageAbove(successString("repository {} has updates.", repo.name));
+        progress.printMessageAbove(infoString("Building {}", repo.name));
         progress.m_iSteps++;
         progress.print();
 
         std::unique_ptr<CManifest> pManifest;
 
         if (std::filesystem::exists(m_szWorkingPluginDirectory + "/hyprpm.toml")) {
-            progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " found hyprpm manifest");
+            progress.printMessageAbove(successString("found hyprpm manifest"));
             pManifest = std::make_unique<CManifest>(MANIFEST_HYPRPM, m_szWorkingPluginDirectory + "/hyprpm.toml");
         } else if (std::filesystem::exists(m_szWorkingPluginDirectory + "/hyprload.toml")) {
-            progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " found hyprload manifest");
+            progress.printMessageAbove(successString("found hyprload manifest"));
             pManifest = std::make_unique<CManifest>(MANIFEST_HYPRLOAD, m_szWorkingPluginDirectory + "/hyprload.toml");
         }
 
         if (!pManifest) {
-            std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " The provided plugin repository does not have a valid manifest\n";
+            std::println(stderr, "\n{}", failureString("The provided plugin repository does not have a valid manifest"));
             continue;
         }
 
         if (!pManifest->m_bGood) {
-            std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " The provided plugin repository has a corrupted manifest\n";
+            std::println(stderr, "\n{}", failureString("The provided plugin repository has a corrupted manifest"));
             continue;
         }
 
         if (repo.rev.empty() && !pManifest->m_sRepository.commitPins.empty()) {
             // check commit pins unless a revision is specified
 
-            progress.printMessageAbove(std::string{Colors::RESET} + " → Manifest has " + std::to_string(pManifest->m_sRepository.commitPins.size()) + " pins, checking");
+            progress.printMessageAbove(infoString("Manifest has {} pins, checking", pManifest->m_sRepository.commitPins.size()));
 
             for (auto const& [hl, plugin] : pManifest->m_sRepository.commitPins) {
                 if (hl != HLVER.hash)
                     continue;
 
-                progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " commit pin " + plugin + " matched hl, resetting");
+                progress.printMessageAbove(successString("commit pin {} matched hl, resetting", plugin));
 
                 execAndGet("cd " + m_szWorkingPluginDirectory + " && git reset --hard --recurse-submodules " + plugin);
             }
@@ -672,32 +699,33 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
             std::string out;
 
             if (p.since > HLVER.commits && HLVER.commits >= 1000 /* for shallow clones, we can't check this. 1000 is an arbitrary number I chose. */) {
-                progress.printMessageAbove(std::string{Colors::RED} + "✖" + Colors::RESET + " Not building " + p.name + ": your Hyprland version is too old.\n");
+                progress.printMessageAbove(failureString("Not building {}: your Hyprland version is too old.\n", p.name));
                 p.failed = true;
                 continue;
             }
 
-            progress.printMessageAbove(std::string{Colors::RESET} + " → Building " + p.name);
+            progress.printMessageAbove(infoString("Building {}", p.name));
 
             for (auto const& bs : p.buildSteps) {
-                std::string cmd = std::format("cd {} && PKG_CONFIG_PATH=\"{}/share/pkgconfig\" {}", m_szWorkingPluginDirectory, DataState::getHeadersPath(), bs);
+                const std::string& cmd = std::format("cd {} && PKG_CONFIG_PATH=\"{}/share/pkgconfig\" {}", m_szWorkingPluginDirectory, DataState::getHeadersPath(), bs);
                 out += " -> " + cmd + "\n" + execAndGet(cmd) + "\n";
             }
 
             if (m_bVerbose)
-                std::cout << Colors::BLUE << "[v] " << Colors::RESET << "shell returned: " << out << "\n";
+                std::println("{}", verboseString("shell returned: {}", out));
 
             if (!std::filesystem::exists(m_szWorkingPluginDirectory + "/" + p.output)) {
-                std::cerr << "\n"
-                          << Colors::RED << "✖" << Colors::RESET << " Plugin " << p.name << " failed to build.\n"
-                          << "  This likely means that the plugin is either outdated, not yet available for your version, or broken.\n  If you are on -git, update first.\n  Try "
-                             "re-running with -v to see more verbose "
-                             "output.\n";
+                std::println(stderr,
+                             "\n{}\n"
+                             "  This likely means that the plugin is either outdated, not yet available for your version, or broken.\n"
+                             "If you are on -git, update first.\n"
+                             "Try re-running with -v to see more verbose output.",
+                             failureString("Plugin {} failed to build.", p.name));
                 p.failed = true;
                 continue;
             }
 
-            progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " built " + p.name + " into " + p.output);
+            progress.printMessageAbove(successString("built {} into {}", p.name, p.output));
         }
 
         // add repo toml to DataState
@@ -718,7 +746,7 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
 
         std::filesystem::remove_all(m_szWorkingPluginDirectory);
 
-        progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " updated " + repo.name);
+        progress.printMessageAbove(successString("updated {}", repo.name));
     }
 
     progress.m_iSteps++;
@@ -733,7 +761,7 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
     progress.m_szCurrentMessage = "Done!";
     progress.print();
 
-    std::cout << "\n";
+    std::print("\n");
 
     return true;
 }
@@ -741,55 +769,48 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
 bool CPluginManager::enablePlugin(const std::string& name) {
     bool ret = DataState::setPluginEnabled(name, true);
     if (ret)
-        std::cout << Colors::GREEN << "✔" << Colors::RESET << " Enabled " << name << "\n";
+        std::println("{}", successString("Enabled {}", name));
     return ret;
 }
 
 bool CPluginManager::disablePlugin(const std::string& name) {
     bool ret = DataState::setPluginEnabled(name, false);
     if (ret)
-        std::cout << Colors::GREEN << "✔" << Colors::RESET << " Disabled " << name << "\n";
+        std::println("{}", successString("Disabled {}", name));
     return ret;
 }
 
-ePluginLoadStateReturn CPluginManager::ensurePluginsLoadState() {
+ePluginLoadStateReturn CPluginManager::ensurePluginsLoadState(bool forceReload) {
     if (headersValid() != HEADERS_OK) {
-        std::cerr << "\n" << std::string{Colors::RED} + "✖" + Colors::RESET + " headers are not up-to-date, please run hyprpm update.\n";
+        std::println(stderr, "\n{}", failureString("headers are not up-to-date, please run hyprpm update."));
         return LOADSTATE_HEADERS_OUTDATED;
     }
 
     const auto HOME = getenv("HOME");
     const auto HIS  = getenv("HYPRLAND_INSTANCE_SIGNATURE");
     if (!HOME || !HIS) {
-        std::cerr << "PluginManager: no $HOME or HIS\n";
+        std::println(stderr, "PluginManager: no $HOME or $HYPRLAND_INSTANCE_SIGNATURE");
         return LOADSTATE_FAIL;
     }
-    const auto               HYPRPMPATH = DataState::getDataStatePath() + "/";
+    const auto HYPRPMPATH = DataState::getDataStatePath();
 
-    auto                     pluginLines = execAndGet("hyprctl plugins list | grep Plugin");
+    const auto json = glz::read_json<glz::json_t::array_t>(execAndGet("hyprctl plugins list -j"));
+    if (!json) {
+        std::println(stderr, "PluginManager: couldn't parse hyprctl output");
+        return LOADSTATE_FAIL;
+    }
 
     std::vector<std::string> loadedPlugins;
-
-    std::cout << Colors::GREEN << "✔" << Colors::RESET << " Ensuring plugin load state\n";
-
-    // iterate line by line
-    while (!pluginLines.empty()) {
-        auto plLine = pluginLines.substr(0, pluginLines.find("\n"));
-
-        if (pluginLines.find("\n") != std::string::npos)
-            pluginLines = pluginLines.substr(pluginLines.find("\n") + 1);
-        else
-            pluginLines = "";
-
-        if (plLine.back() != ':')
-            continue;
-
-        plLine = plLine.substr(7);
-        plLine = plLine.substr(0, plLine.find(" by "));
-
-        loadedPlugins.push_back(plLine);
+    for (const auto& plugin : json.value()) {
+        if (!plugin.is_object() || !plugin.contains("name")) {
+            std::println(stderr, "PluginManager: couldn't parse plugin object");
+            return LOADSTATE_FAIL;
+        }
+        loadedPlugins.emplace_back(plugin["name"].get<std::string>());
     }
 
+    std::println("{}", successString("Ensuring plugin load state"));
+
     // get state
     const auto REPOS = DataState::getAllRepositories();
 
@@ -815,12 +836,20 @@ ePluginLoadStateReturn CPluginManager::ensurePluginsLoadState() {
         return "";
     };
 
-    // unload disabled plugins
+    // if any of the loadUnloadPlugin calls return false, this is true
+    // bcs that means the header version doesn't match the running version
+    // (and Hyprland needs to restart)
+    bool hyprlandVersionMismatch = false;
+
+    // unload disabled plugins (or all if forceReload is true)
     for (auto const& p : loadedPlugins) {
-        if (!enabled(p)) {
+        if (forceReload || !enabled(p)) {
             // unload
-            loadUnloadPlugin(HYPRPMPATH + repoForName(p) + "/" + p + ".so", false);
-            std::cout << Colors::GREEN << "✔" << Colors::RESET << " Unloaded " << p << "\n";
+            if (!loadUnloadPlugin(HYPRPMPATH / repoForName(p) / (p + ".so"), false)) {
+                std::println("{}", infoString("{} will be unloaded after restarting Hyprland", p));
+                hyprlandVersionMismatch = true;
+            } else
+                std::println("{}", successString("Unloaded {}", p));
         }
     }
 
@@ -830,20 +859,31 @@ ePluginLoadStateReturn CPluginManager::ensurePluginsLoadState() {
             if (!p.enabled)
                 continue;
 
-            if (std::find_if(loadedPlugins.begin(), loadedPlugins.end(), [&](const auto& other) { return other == p.name; }) != loadedPlugins.end())
+            if (!forceReload && std::find_if(loadedPlugins.begin(), loadedPlugins.end(), [&](const auto& other) { return other == p.name; }) != loadedPlugins.end())
                 continue;
 
-            loadUnloadPlugin(HYPRPMPATH + repoForName(p.name) + "/" + p.filename, true);
-            std::cout << Colors::GREEN << "✔" << Colors::RESET << " Loaded " << p.name << "\n";
+            if (!loadUnloadPlugin(HYPRPMPATH / repoForName(p.name) / p.filename, true)) {
+                std::println("{}", infoString("{} will be loaded after restarting Hyprland", p.name));
+                hyprlandVersionMismatch = true;
+            } else
+                std::println("{}", successString("Loaded {}", p.name));
         }
     }
 
-    std::cout << Colors::GREEN << "✔" << Colors::RESET << " Plugin load state ensured\n";
+    std::println("{}", successString("Plugin load state ensured"));
 
-    return LOADSTATE_OK;
+    return hyprlandVersionMismatch ? LOADSTATE_HYPRLAND_UPDATED : LOADSTATE_OK;
 }
 
 bool CPluginManager::loadUnloadPlugin(const std::string& path, bool load) {
+    auto state = DataState::getGlobalState();
+    auto HLVER = getHyprlandVersion(true);
+
+    if (state.headersHashCompiled != HLVER.hash) {
+        std::println("{}", infoString("Running Hyprland version differs from plugin state, please restart Hyprland."));
+        return false;
+    }
+
     if (load)
         execAndGet("hyprctl plugin load " + path);
     else
@@ -856,16 +896,17 @@ void CPluginManager::listAllPlugins() {
     const auto REPOS = DataState::getAllRepositories();
 
     for (auto const& r : REPOS) {
-        std::cout << std::string{Colors::RESET} + " → Repository " + r.name + ":\n";
+        std::println("{}", infoString("Repository {}:", r.name));
 
         for (auto const& p : r.plugins) {
-
-            std::cout << std::string{Colors::RESET} + "  │ Plugin " + p.name;
+            std::println("  │ Plugin {}", p.name);
 
             if (!p.failed)
-                std::cout << "\n  └─ enabled: " << (p.enabled ? Colors::GREEN : Colors::RED) << (p.enabled ? "true" : "false") << Colors::RESET << "\n";
+                std::println("  └─ enabled: {}", (p.enabled ? std::string{Colors::GREEN} + "true" : std::string{Colors::RED} + "false"));
             else
-                std::cout << "\n  └─ enabled: " << Colors::RED << "Plugin failed to build" << Colors::RESET << "\n";
+                std::println("  └─ enabled: {}Plugin failed to build", Colors::RED);
+
+            std::println("{}", Colors::RESET);
         }
     }
 }
@@ -876,19 +917,19 @@ void CPluginManager::notify(const eNotifyIcons icon, uint32_t color, int duratio
 
 std::string CPluginManager::headerError(const eHeadersErrors err) {
     switch (err) {
-        case HEADERS_CORRUPTED: return std::string{Colors::RED} + "✖" + Colors::RESET + " Headers corrupted. Please run hyprpm update to fix those.\n";
-        case HEADERS_MISMATCHED: return std::string{Colors::RED} + "✖" + Colors::RESET + " Headers version mismatch. Please run hyprpm update to fix those.\n";
-        case HEADERS_NOT_HYPRLAND: return std::string{Colors::RED} + "✖" + Colors::RESET + " It doesn't seem you are running on hyprland.\n";
-        case HEADERS_MISSING: return std::string{Colors::RED} + "✖" + Colors::RESET + " Headers missing. Please run hyprpm update to fix those.\n";
+        case HEADERS_CORRUPTED: return failureString("Headers corrupted. Please run hyprpm update to fix those.\n");
+        case HEADERS_MISMATCHED: return failureString("Headers version mismatch. Please run hyprpm update to fix those.\n");
+        case HEADERS_NOT_HYPRLAND: return failureString("It doesn't seem you are running on hyprland.\n");
+        case HEADERS_MISSING: return failureString("Headers missing. Please run hyprpm update to fix those.\n");
         case HEADERS_DUPLICATED: {
-            return std::string{Colors::RED} + "✖" + Colors::RESET + " Headers duplicated!!! This is a very bad sign.\n" +
-                " This could be due to e.g. installing hyprland manually while a system package of hyprland is also installed.\n" +
-                " If the above doesn't apply, check your /usr/include and /usr/local/include directories\n and remove all the hyprland headers.\n";
+            return failureString("Headers duplicated!!! This is a very bad sign.\n"
+                                 "This could be due to e.g. installing hyprland manually while a system package of hyprland is also installed.\n"
+                                 "If the above doesn't apply, check your /usr/include and /usr/local/include directories\n and remove all the hyprland headers.\n");
         }
         default: break;
     }
 
-    return std::string{Colors::RED} + "✖" + Colors::RESET + " Unknown header error. Please run hyprpm update to fix those.\n";
+    return failureString("Unknown header error. Please run hyprpm update to fix those.\n");
 }
 
 std::string CPluginManager::headerErrorShort(const eHeadersErrors err) {

hyprpm/src/core/PluginManager.hpp

@@ -2,6 +2,7 @@
 
 #include <memory>
 #include <string>
+#include <utility>
 
 enum eHeadersErrors {
     HEADERS_OK = 0,
@@ -26,7 +27,8 @@ enum ePluginLoadStateReturn {
     LOADSTATE_OK = 0,
     LOADSTATE_FAIL,
     LOADSTATE_PARTIAL_FAIL,
-    LOADSTATE_HEADERS_OUTDATED
+    LOADSTATE_HEADERS_OUTDATED,
+    LOADSTATE_HYPRLAND_UPDATED
 };
 
 struct SHyprlandVersion {
@@ -49,10 +51,10 @@ class CPluginManager {
 
     bool                   enablePlugin(const std::string& name);
     bool                   disablePlugin(const std::string& name);
-    ePluginLoadStateReturn ensurePluginsLoadState();
+    ePluginLoadStateReturn ensurePluginsLoadState(bool forceReload = false);
 
     bool                   loadUnloadPlugin(const std::string& path, bool load);
-    SHyprlandVersion       getHyprlandVersion();
+    SHyprlandVersion       getHyprlandVersion(bool running = true);
 
     void                   notify(const eNotifyIcons icon, uint32_t color, int durationMs, const std::string& message);
 
@@ -68,7 +70,7 @@ class CPluginManager {
     std::string headerError(const eHeadersErrors err);
     std::string headerErrorShort(const eHeadersErrors err);
 
-    std::string m_szWorkingPluginDirectory = "";
+    std::string m_szWorkingPluginDirectory;
 };
 
 inline std::unique_ptr<CPluginManager> g_pPluginManager;

hyprpm/src/helpers/StringUtils.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <format>
+#include <string>
+#include "Colors.hpp"
+
+template <typename... Args>
+std::string statusString(const std::string_view emoji, const std::string_view color, const std::string_view fmt, Args&&... args) {
+    std::string ret = std::format("{}{}{} ", color, emoji, Colors::RESET);
+    ret += std::vformat(fmt, std::make_format_args(args...));
+    return ret;
+}
+
+template <typename... Args>
+std::string successString(const std::string_view fmt, Args&&... args) {
+    return statusString("✔", Colors::GREEN, fmt, args...);
+}
+
+template <typename... Args>
+std::string failureString(const std::string_view fmt, Args&&... args) {
+    return statusString("✖", Colors::RED, fmt, args...);
+}
+
+template <typename... Args>
+std::string verboseString(const std::string_view fmt, Args&&... args) {
+    return statusString("[v]", Colors::BLUE, fmt, args...);
+}
+
+template <typename... Args>
+std::string infoString(const std::string_view fmt, Args&&... args) {
+    return statusString("→", Colors::RESET, fmt, args...);
+}

hyprpm/src/main.cpp

@@ -1,15 +1,16 @@
-#include "progress/CProgressBar.hpp"
 #include "helpers/Colors.hpp"
+#include "helpers/StringUtils.hpp"
 #include "core/PluginManager.hpp"
 #include "core/DataState.hpp"
 
-#include <iostream>
+#include <cstdio>
 #include <vector>
 #include <string>
+#include <print>
 #include <chrono>
 #include <thread>
 
-const std::string HELP = R"#(┏ hyprpm, a Hyprland Plugin Manager
+constexpr std::string_view HELP = R"#(┏ hyprpm, a Hyprland Plugin Manager
 ┃
 ┣ add [url] [git rev]    → Install a new plugin repository from git. Git revision
 ┃                          is optional, when set, commit locks are ignored.
@@ -22,7 +23,8 @@ const std::string HELP = R"#(┏ hyprpm, a Hyprland Plugin Manager
 ┃
 ┣ Flags:
 ┃
-┣ --notify       | -n    → Send a hyprland notification for important events (e.g. load fail)
+┣ --notify       | -n    → Send a hyprland notification for important events (including both successes and fail events)
+┣ --notify-fail  | -nn   → Send a hyprland notification for fail events only
 ┣ --help         | -h    → Show this menu
 ┣ --verbose      | -v    → Enable too much logging
 ┣ --force        | -f    → Force an operation ignoring checks (e.g. update -f)
@@ -30,36 +32,38 @@ const std::string HELP = R"#(┏ hyprpm, a Hyprland Plugin Manager
 ┗
 )#";
 
-int               main(int argc, char** argv, char** envp) {
+int                        main(int argc, char** argv, char** envp) {
     std::vector<std::string> ARGS{argc};
     for (int i = 0; i < argc; ++i) {
         ARGS[i] = std::string{argv[i]};
     }
 
     if (ARGS.size() < 2) {
-        std::cout << HELP;
+        std::println(stderr, "{}", HELP);
         return 1;
     }
 
     std::vector<std::string> command;
-    bool                     notify = false, verbose = false, force = false, noShallow = false;
+    bool                     notify = false, notifyFail = false, verbose = false, force = false, noShallow = false;
 
     for (int i = 1; i < argc; ++i) {
         if (ARGS[i].starts_with("-")) {
             if (ARGS[i] == "--help" || ARGS[i] == "-h") {
-                std::cout << HELP;
+                std::println("{}", HELP);
                 return 0;
             } else if (ARGS[i] == "--notify" || ARGS[i] == "-n") {
                 notify = true;
+            } else if (ARGS[i] == "--notify-fail" || ARGS[i] == "-nn") {
+                notifyFail = notify = true;
             } else if (ARGS[i] == "--verbose" || ARGS[i] == "-v") {
                 verbose = true;
             } else if (ARGS[i] == "--no-shallow" || ARGS[i] == "-s") {
                 noShallow = true;
             } else if (ARGS[i] == "--force" || ARGS[i] == "-f") {
                 force = true;
-                std::cout << Colors::RED << "!" << Colors::RESET << " Using --force, I hope you know what you are doing.\n";
+                std::println("{}", statusString("!", Colors::RED, "Using --force, I hope you know what you are doing."));
             } else {
-                std::cerr << "Unrecognized option " << ARGS[i] << "\n";
+                std::println(stderr, "Unrecognized option {}", ARGS[i]);
                 return 1;
             }
         } else {
@@ -68,8 +72,8 @@ int               main(int argc, char** argv, char** envp) {
     }
 
     if (command.empty()) {
-        std::cout << HELP;
-        return 0;
+        std::println(stderr, "{}", HELP);
+        return 1;
     }
 
     g_pPluginManager               = std::make_unique<CPluginManager>();
@@ -78,7 +82,7 @@ int               main(int argc, char** argv, char** envp) {
 
     if (command[0] == "add") {
         if (command.size() < 2) {
-            std::cerr << Colors::RED << "✖" << Colors::RESET << " Not enough args for add.\n";
+            std::println(stderr, "{}", failureString("Not enough args for add."));
             return 1;
         }
 
@@ -90,7 +94,7 @@ int               main(int argc, char** argv, char** envp) {
         return g_pPluginManager->addNewPluginRepo(command[1], rev) ? 0 : 1;
     } else if (command[0] == "remove") {
         if (ARGS.size() < 2) {
-            std::cerr << Colors::RED << "✖" << Colors::RESET << " Not enough args for remove.\n";
+            std::println(stderr, "{}", failureString("Not enough args for remove."));
             return 1;
         }
 
@@ -99,7 +103,7 @@ int               main(int argc, char** argv, char** envp) {
         bool headersValid = g_pPluginManager->headersValid() == HEADERS_OK;
         bool headers      = g_pPluginManager->updateHeaders(force);
         if (headers) {
-            const auto HLVER            = g_pPluginManager->getHyprlandVersion();
+            const auto HLVER            = g_pPluginManager->getHyprlandVersion(false);
             auto       GLOBALSTATE      = DataState::getGlobalState();
             const auto COMPILEDOUTDATED = HLVER.hash != GLOBALSTATE.headersHashCompiled;
 
@@ -110,32 +114,39 @@ int               main(int argc, char** argv, char** envp) {
 
             auto ret2 = g_pPluginManager->ensurePluginsLoadState();
 
+            if (ret2 == LOADSTATE_HYPRLAND_UPDATED)
+                g_pPluginManager->notify(ICON_INFO, 0, 10000, "[hyprpm] Updated plugins, but Hyprland was updated. Please restart Hyprland.");
+
             if (ret2 != LOADSTATE_OK)
                 return 1;
         } else if (notify)
             g_pPluginManager->notify(ICON_ERROR, 0, 10000, "[hyprpm] Couldn't update headers");
     } else if (command[0] == "enable") {
         if (ARGS.size() < 2) {
-            std::cerr << Colors::RED << "✖" << Colors::RESET << " Not enough args for enable.\n";
+            std::println(stderr, "{}", failureString("Not enough args for enable."));
             return 1;
         }
 
         if (!g_pPluginManager->enablePlugin(command[1])) {
-            std::cerr << Colors::RED << "✖" << Colors::RESET << " Couldn't enable plugin (missing?)\n";
+            std::println(stderr, "{}", failureString("Couldn't enable plugin (missing?)"));
             return 1;
         }
 
         auto ret = g_pPluginManager->ensurePluginsLoadState();
+
+        if (ret == LOADSTATE_HYPRLAND_UPDATED)
+            g_pPluginManager->notify(ICON_INFO, 0, 10000, "[hyprpm] Enabled plugin, but Hyprland was updated. Please restart Hyprland.");
+
         if (ret != LOADSTATE_OK)
             return 1;
     } else if (command[0] == "disable") {
         if (command.size() < 2) {
-            std::cerr << Colors::RED << "✖" << Colors::RESET << " Not enough args for disable.\n";
+            std::println(stderr, "{}", failureString("Not enough args for disable."));
             return 1;
         }
 
         if (!g_pPluginManager->disablePlugin(command[1])) {
-            std::cerr << Colors::RED << "✖" << Colors::RESET << " Couldn't disable plugin (missing?)\n";
+            std::println(stderr, "{}", failureString("Couldn't disable plugin (missing?)"));
             return 1;
         }
 
@@ -143,7 +154,7 @@ int               main(int argc, char** argv, char** envp) {
         if (ret != LOADSTATE_OK)
             return 1;
     } else if (command[0] == "reload") {
-        auto ret = g_pPluginManager->ensurePluginsLoadState();
+        auto ret = g_pPluginManager->ensurePluginsLoadState(force);
 
         if (ret != LOADSTATE_OK && notify) {
             switch (ret) {
@@ -154,15 +165,16 @@ int               main(int argc, char** argv, char** envp) {
                     break;
                 default: break;
             }
-        } else if (notify) {
+            return 1;
+        } else if (notify && !notifyFail) {
             g_pPluginManager->notify(ICON_OK, 0, 4000, "[hyprpm] Loaded plugins");
         }
     } else if (command[0] == "list") {
         g_pPluginManager->listAllPlugins();
     } else {
-        std::cout << HELP;
+        std::println(stderr, "{}", HELP);
         return 1;
     }
 
     return 0;
-}
+}

hyprpm/src/meson.build

@@ -8,6 +8,7 @@ executable(
     dependency('hyprutils', version: '>= 0.1.1'),
     dependency('threads'),
     dependency('tomlplusplus'),
+    dependency('glaze', method: 'cmake'),
   ],
   install: true,
 )

hyprpm/src/progress/CProgressBar.cpp

@@ -1,11 +1,11 @@
 #include "CProgressBar.hpp"
 
-#include <iostream>
+#include <sys/ioctl.h>
 #include <algorithm>
 #include <cmath>
 #include <format>
 
-#include <sys/ioctl.h>
+#include <print>
 #include <stdio.h>
 #include <unistd.h>
 
@@ -16,11 +16,12 @@ void CProgressBar::printMessageAbove(const std::string& msg) {
     ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
 
     std::string spaces;
+    spaces.reserve(w.ws_col);
     for (size_t i = 0; i < w.ws_col; ++i) {
         spaces += ' ';
     }
 
-    std::cout << "\r" << spaces << "\r" << msg << "\n";
+    std::println("\r{}\r{}", spaces, msg);
     print();
 }
 
@@ -29,15 +30,16 @@ void CProgressBar::print() {
     ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
 
     if (m_bFirstPrint)
-        std::cout << "\n";
+        std::print("\n");
     m_bFirstPrint = false;
 
     std::string spaces;
+    spaces.reserve(w.ws_col);
     for (size_t i = 0; i < w.ws_col; ++i) {
         spaces += ' ';
     }
 
-    std::cout << "\r" << spaces << "\r";
+    std::print("\r{}\r", spaces);
 
     std::string message = "";
 
@@ -74,7 +76,7 @@ void CProgressBar::print() {
         message += "  " + std::format("{} / {}", m_iSteps, m_iMaxSteps) + " ";
 
     // draw message
-    std::cout << message + " " + m_szCurrentMessage;
+    std::print("{} {}", message, m_szCurrentMessage);
 
     std::fflush(stdout);
-}
+}

hyprpm/src/progress/CProgressBar.hpp

@@ -14,4 +14,4 @@ class CProgressBar {
 
   private:
     bool m_bFirstPrint = true;
-};
+};

meson.build

@@ -21,6 +21,7 @@ add_project_arguments(
     '-Wno-missing-field-initializers',
     '-Wno-narrowing',
     '-Wno-pointer-arith', datarootdir,
+    '-DHYPRLAND_VERSION="' + meson.project_version() + '"',
   ],
   language: 'cpp',
 )
@@ -30,8 +31,16 @@ if cpp_compiler.check_header('execinfo.h')
   add_project_arguments('-DHAS_EXECINFO', language: 'cpp')
 endif
 
-aquamarine = dependency('aquamarine')
+aquamarine = dependency('aquamarine', version: '>=0.4.5')
+hyprcursor = dependency('hyprcursor', version: '>=0.1.7')
+hyprgraphics = dependency('hyprgraphics', version: '>= 0.1.1')
+hyprlang = dependency('hyprlang', version: '>= 0.3.2')
+hyprutils = dependency('hyprutils', version: '>= 0.2.3')
 add_project_arguments(['-DAQUAMARINE_VERSION="@0@"'.format(aquamarine.version())], language: 'cpp')
+add_project_arguments(['-DHYPRCURSOR_VERSION="@0@"'.format(hyprcursor.version())], language: 'cpp')
+add_project_arguments(['-DHYPRGRAPHICS_VERSION="@0@"'.format(hyprgraphics.version())], language: 'cpp')
+add_project_arguments(['-DHYPRLANG_VERSION="@0@"'.format(hyprlang.version())], language: 'cpp')
+add_project_arguments(['-DHYPRUTILS_VERSION="@0@"'.format(hyprutils.version())], language: 'cpp')
 
 xcb_dep = dependency('xcb', required: get_option('xwayland'))
 xcb_composite_dep = dependency('xcb-composite', required: get_option('xwayland'))
@@ -49,10 +58,19 @@ endif
 
 backtrace_dep = cpp_compiler.find_library('execinfo', required: false)
 epoll_dep = dependency('epoll-shim', required: false) # timerfd on BSDs
+inotify_dep = dependency('libinotify', required: false) # inotify on BSDs
+
+re2 = dependency('re2', required: true)
 
 # Handle options
-if get_option('systemd').enabled()
+systemd_option = get_option('systemd')
+systemd = dependency('systemd', required: systemd_option)
+systemd_option.enable_auto_if(systemd.found())
+
+if (systemd_option.enabled())
+  message('Enabling systemd integration')
   add_project_arguments('-DUSES_SYSTEMD', language: 'cpp')
+  subdir('systemd')
 endif
 
 if get_option('legacy_renderer').enabled()
@@ -79,14 +97,19 @@ if get_option('tracy_enable') and get_option('buildtype') != 'debugoptimized'
   warning('Profiling builds should set -- buildtype = debugoptimized')
 endif
 
+
+
 subdir('protocols')
 subdir('src')
 subdir('hyprctl')
-subdir('hyprpm/src')
 subdir('assets')
 subdir('example')
 subdir('docs')
 
+if get_option('hyprpm').enabled()
+  subdir('hyprpm/src')
+endif
+
 # Generate hyprland.pc
 pkg_install_dir = join_paths(get_option('datadir'), 'pkgconfig')
 

meson_options.txt

@@ -1,4 +1,6 @@
 option('xwayland', type: 'feature', value: 'auto', description: 'Enable support for X11 applications')
 option('systemd', type: 'feature', value: 'auto', description: 'Enable systemd integration')
+option('uwsm', type: 'feature', value: 'enabled', description: 'Enable uwsm integration (only if systemd is enabled)')
 option('legacy_renderer', type: 'feature', value: 'disabled', description: 'Enable legacy renderer')
+option('hyprpm', type: 'feature', value: 'enabled', description: 'Enable hyprpm')
 option('tracy_enable', type: 'boolean', value: false , description: 'Enable profiling')

nix/default.nix

@@ -5,14 +5,18 @@
   pkg-config,
   pkgconf,
   makeWrapper,
+  cmake,
   meson,
   ninja,
   aquamarine,
   binutils,
   cairo,
   git,
+  glaze,
   hyprcursor,
+  hyprgraphics,
   hyprland-protocols,
+  hyprland-qtutils,
   hyprlang,
   hyprutils,
   hyprwayland-scanner,
@@ -25,6 +29,7 @@
   mesa,
   pango,
   pciutils,
+  re2,
   systemd,
   tomlplusplus,
   udis86-hyprland,
@@ -47,15 +52,16 @@
   nvidiaPatches ? false,
   hidpiXWayland ? false,
 }: let
-  inherit (builtins) baseNameOf foldl';
+  inherit (builtins) baseNameOf foldl' readFile;
   inherit (lib.asserts) assertMsg;
   inherit (lib.attrsets) mapAttrsToList;
   inherit (lib.lists) flatten concatLists optional optionals;
   inherit (lib.sources) cleanSourceWith cleanSource;
-  inherit (lib.strings) hasSuffix makeBinPath optionalString mesonBool mesonEnable;
+  inherit (lib.strings) hasSuffix makeBinPath optionalString mesonBool mesonEnable trim;
 
   adapters = flatten [
     stdenvAdapters.useMoldLinker
+    (lib.optional debug stdenvAdapters.keepDebugInfo)
   ];
 
   customStdenv = foldl' (acc: adapter: adapter acc) stdenv adapters;
@@ -63,12 +69,12 @@ in
   assert assertMsg (!nvidiaPatches) "The option `nvidiaPatches` has been removed.";
   assert assertMsg (!enableNvidiaPatches) "The option `enableNvidiaPatches` has been removed.";
   assert assertMsg (!hidpiXWayland) "The option `hidpiXWayland` has been removed. Please refer https://wiki.hyprland.org/Configuring/XWayland";
-    customStdenv.mkDerivation {
+    customStdenv.mkDerivation (finalAttrs: {
       pname = "hyprland${optionalString debug "-debug"}";
       inherit version;
 
       src = cleanSourceWith {
-        filter = name: type: let
+        filter = name: _type: let
           baseName = baseNameOf (toString name);
         in
           ! (hasSuffix ".nix" baseName);
@@ -87,6 +93,7 @@ in
       DATE = date;
       DIRTY = optionalString (commit == "") "dirty";
       HASH = commit;
+      TAG = "v${trim (readFile "${finalAttrs.src}/VERSION")}";
 
       depsBuildBuild = [
         pkg-config
@@ -97,6 +104,7 @@ in
         makeWrapper
         meson
         ninja
+        cmake # needed for glaze
         pkg-config
       ];
 
@@ -111,7 +119,9 @@ in
           aquamarine
           cairo
           git
+          glaze
           hyprcursor
+          hyprgraphics
           hyprland-protocols
           hyprlang
           hyprutils
@@ -123,6 +133,7 @@ in
           mesa
           pango
           pciutils
+          re2
           tomlplusplus
           udis86-hyprland
           wayland
@@ -147,14 +158,12 @@ in
         then "debugoptimized"
         else "release";
 
-      # we want as much debug info as possible
-      dontStrip = debug;
-
       mesonFlags = flatten [
         (mapAttrsToList mesonEnable {
           "xwayland" = enableXWayland;
           "legacy_renderer" = legacyRenderer;
-          "systemd" = withSystemd;
+          "uwsm" = false;
+          "hyprpm" = false;
         })
         (mapAttrsToList mesonBool {
           "b_pch" = false;
@@ -167,6 +176,7 @@ in
           wrapProgram $out/bin/Hyprland \
             --suffix PATH : ${makeBinPath [
             binutils
+            hyprland-qtutils
             pciutils
             pkgconf
           ]}
@@ -182,4 +192,4 @@ in
         platforms = lib.platforms.linux;
         mainProgram = "Hyprland";
       };
-    }
+    })

nix/formatter.nix

@@ -0,0 +1,64 @@
+{
+  writeShellApplication,
+  deadnix,
+  statix,
+  alejandra,
+  llvmPackages_19,
+  fd,
+}:
+writeShellApplication {
+  name = "hyprland-treewide-formatter";
+  runtimeInputs = [
+    deadnix
+    statix
+    alejandra
+    llvmPackages_19.clang-tools
+    fd
+  ];
+  text = ''
+    # shellcheck disable=SC2148
+
+    # common excludes
+    excludes="subprojects"
+
+    nix_format() {
+      if [ "$*" = 0 ]; then
+        fd '.*\.nix' . -E "$excludes" -x statix fix -- {} \;
+        fd '.*\.nix' . -E "$excludes" -X deadnix -e -- {} \; -X alejandra {} \;
+      elif [ -d "$1" ]; then
+        fd '.*\.nix' "$1" -E "$excludes" -i -x statix fix -- {} \;
+        fd '.*\.nix' "$1" -E "$excludes" -i -X deadnix -e -- {} \; -X alejandra {} \;
+      else
+        statix fix -- "$1"
+        deadnix -e "$1"
+        alejandra "$1"
+      fi
+    }
+
+    cpp_format() {
+      if [ "$*" = 0 ] || [ "$1" = "." ]; then
+        fd '.*\.cpp' . -E "$excludes"  | xargs clang-format --verbose -i
+      elif [ -d "$1" ]; then
+        fd '.*\.cpp' "$1" -E "$excludes" | xargs clang-format --verbose -i
+      else
+        clang-format --verbose -i "$1"
+      fi
+    }
+
+    for i in "$@"; do
+      case ''${i##*.} in
+        "nix")
+          nix_format "$i"
+          ;;
+        "cpp")
+          cpp_format "$i"
+          ;;
+        *)
+          nix_format "$i"
+          cpp_format "$i"
+          ;;
+      esac
+
+    done
+  '';
+}

nix/module.nix

@@ -7,15 +7,206 @@ inputs: {
   inherit (pkgs.stdenv.hostPlatform) system;
   cfg = config.programs.hyprland;
 
-  package = inputs.self.packages.${system}.hyprland;
-  portalPackage = inputs.self.packages.${system}.xdg-desktop-portal-hyprland.override {
-    hyprland = cfg.finalPackage;
-  };
+  # basically 1:1 taken from https://github.com/nix-community/home-manager/blob/master/modules/services/window-managers/hyprland.nix
+  toHyprconf = {
+    attrs,
+    indentLevel ? 0,
+    importantPrefixes ? ["$"],
+  }: let
+    inherit
+      (lib)
+      all
+      concatMapStringsSep
+      concatStrings
+      concatStringsSep
+      filterAttrs
+      foldl
+      generators
+      hasPrefix
+      isAttrs
+      isList
+      mapAttrsToList
+      replicate
+      ;
+
+    initialIndent = concatStrings (replicate indentLevel "  ");
+
+    toHyprconf' = indent: attrs: let
+      sections =
+        filterAttrs (n: v: isAttrs v || (isList v && all isAttrs v)) attrs;
+
+      mkSection = n: attrs:
+        if lib.isList attrs
+        then (concatMapStringsSep "\n" (a: mkSection n a) attrs)
+        else ''
+          ${indent}${n} {
+          ${toHyprconf' "  ${indent}" attrs}${indent}}
+        '';
+
+      mkFields = generators.toKeyValue {
+        listsAsDuplicateKeys = true;
+        inherit indent;
+      };
+
+      allFields =
+        filterAttrs (n: v: !(isAttrs v || (isList v && all isAttrs v)))
+        attrs;
+
+      isImportantField = n: _:
+        foldl (acc: prev:
+          if hasPrefix prev n
+          then true
+          else acc)
+        false
+        importantPrefixes;
+
+      importantFields = filterAttrs isImportantField allFields;
+
+      fields =
+        builtins.removeAttrs allFields
+        (mapAttrsToList (n: _: n) importantFields);
+    in
+      mkFields importantFields
+      + concatStringsSep "\n" (mapAttrsToList mkSection sections)
+      + mkFields fields;
+  in
+    toHyprconf' initialIndent attrs;
 in {
-  config = {
+  options = {
     programs.hyprland = {
-      package = lib.mkDefault package;
-      portalPackage = lib.mkDefault portalPackage;
+      plugins = lib.mkOption {
+        type = with lib.types; listOf (either package path);
+        default = [];
+        description = ''
+          List of Hyprland plugins to use. Can either be packages or
+          absolute plugin paths.
+        '';
+      };
+
+      settings = lib.mkOption {
+        type = with lib.types; let
+          valueType =
+            nullOr (oneOf [
+              bool
+              int
+              float
+              str
+              path
+              (attrsOf valueType)
+              (listOf valueType)
+            ])
+            // {
+              description = "Hyprland configuration value";
+            };
+        in
+          valueType;
+        default = {};
+        description = ''
+          Hyprland configuration written in Nix. Entries with the same key
+          should be written as lists. Variables' and colors' names should be
+          quoted. See <https://wiki.hyprland.org> for more examples.
+
+          ::: {.note}
+          Use the [](#programs.hyprland.plugins) option to
+          declare plugins.
+          :::
+
+        '';
+        example = lib.literalExpression ''
+          {
+            decoration = {
+              shadow_offset = "0 5";
+              "col.shadow" = "rgba(00000099)";
+            };
+
+            "$mod" = "SUPER";
+
+            bindm = [
+              # mouse movements
+              "$mod, mouse:272, movewindow"
+              "$mod, mouse:273, resizewindow"
+              "$mod ALT, mouse:272, resizewindow"
+            ];
+          }
+        '';
+      };
+
+      extraConfig = lib.mkOption {
+        type = lib.types.lines;
+        default = "";
+        example = ''
+          # window resize
+          bind = $mod, S, submap, resize
+
+          submap = resize
+          binde = , right, resizeactive, 10 0
+          binde = , left, resizeactive, -10 0
+          binde = , up, resizeactive, 0 -10
+          binde = , down, resizeactive, 0 10
+          bind = , escape, submap, reset
+          submap = reset
+        '';
+        description = ''
+          Extra configuration lines to add to `/etc/xdg/hypr/hyprland.conf`.
+        '';
+      };
+
+      sourceFirst =
+        lib.mkEnableOption ''
+          putting source entries at the top of the configuration
+        ''
+        // {
+          default = true;
+        };
+
+      importantPrefixes = lib.mkOption {
+        type = with lib.types; listOf str;
+        default = ["$" "bezier" "name"] ++ lib.optionals cfg.sourceFirst ["source"];
+        example = ["$" "bezier"];
+        description = ''
+          List of prefix of attributes to source at the top of the config.
+        '';
+      };
     };
   };
+  config = lib.mkMerge [
+    {
+      programs.hyprland = {
+        package = lib.mkDefault inputs.self.packages.${system}.hyprland;
+        portalPackage = lib.mkDefault (inputs.self.packages.${system}.xdg-desktop-portal-hyprland.override {
+          hyprland = cfg.finalPackage;
+        });
+      };
+    }
+    (lib.mkIf cfg.enable {
+      environment.etc."xdg/hypr/hyprland.conf" = let
+        shouldGenerate = cfg.extraConfig != "" || cfg.settings != {} || cfg.plugins != [];
+
+        pluginsToHyprconf = plugins:
+          toHyprconf {
+            attrs = {
+              plugin = let
+                mkEntry = entry:
+                  if lib.types.package.check entry
+                  then "${entry}/lib/lib${entry.pname}.so"
+                  else entry;
+              in
+                map mkEntry cfg.plugins;
+            };
+            inherit (cfg) importantPrefixes;
+          };
+      in
+        lib.mkIf shouldGenerate {
+          text =
+            lib.optionalString (cfg.plugins != [])
+            (pluginsToHyprconf cfg.plugins)
+            + lib.optionalString (cfg.settings != {})
+            (toHyprconf {
+              attrs = cfg.settings;
+              inherit (cfg) importantPrefixes;
+            })
+            + lib.optionalString (cfg.extraConfig != "") cfg.extraConfig;
+        };
+    })
+  ];
 }

nix/overlays.nix

@@ -22,14 +22,16 @@ in {
     # Dependencies
     inputs.aquamarine.overlays.default
     inputs.hyprcursor.overlays.default
+    inputs.hyprgraphics.overlays.default
     inputs.hyprland-protocols.overlays.default
+    inputs.hyprland-qtutils.overlays.default
     inputs.hyprlang.overlays.default
     inputs.hyprutils.overlays.default
     inputs.hyprwayland-scanner.overlays.default
     self.overlays.udis86
 
     # Hyprland packages themselves
-    (final: prev: let
+    (final: _prev: let
       date = mkDate (self.lastModifiedDate or "19700101");
     in {
       hyprland = final.callPackage ./default.nix {
@@ -40,7 +42,13 @@ in {
         inherit date;
       };
       hyprland-unwrapped = final.hyprland.override {wrapRuntimeDeps = false;};
-      hyprland-debug = final.hyprland.override {debug = true;};
+
+      # Build major libs with debug to get as much info as possible in a stacktrace
+      hyprland-debug = final.hyprland.override {
+        aquamarine = final.aquamarine.override {debug = true;};
+        hyprutils = final.hyprutils.override {debug = true;};
+        debug = true;
+      };
       hyprland-legacy-renderer = final.hyprland.override {legacyRenderer = true;};
 
       # deprecated packages
@@ -63,14 +71,14 @@ in {
   # Packages for extra software recommended for usage with Hyprland,
   # including forked or patched packages for compatibility.
   hyprland-extras = lib.composeManyExtensions [
-    inputs.xdph.overlays.xdg-desktop-portal-hyprland
+    inputs.xdph.overlays.default
   ];
 
   # udis86 from nixpkgs is too old, and also does not provide a .pc file
   # this version is the one used in the git submodule, and allows us to
   # fetch the source without '?submodules=1'
   udis86 = final: prev: {
-    udis86-hyprland = prev.udis86.overrideAttrs (self: super: {
+    udis86-hyprland = prev.udis86.overrideAttrs (_self: _super: {
       src = final.fetchFromGitHub {
         owner = "canihavesomecoffee";
         repo = "udis86";

protocols/frog-color-management-v1.xml

@@ -0,0 +1,366 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="frog_color_management_v1">
+
+	<copyright>
+		Copyright © 2023 Joshua Ashton for Valve Software
+		Copyright © 2023 Xaver Hugl
+
+		Permission is hereby granted, free of charge, to any person obtaining a
+		copy of this software and associated documentation files (the "Software"),
+		to deal in the Software without restriction, including without limitation
+		the rights to use, copy, modify, merge, publish, distribute, sublicense,
+		and/or sell copies of the Software, and to permit persons to whom the
+		Software is furnished to do so, subject to the following conditions:
+
+		The above copyright notice and this permission notice (including the next
+		paragraph) shall be included in all copies or substantial portions of the
+		Software.
+
+		THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+		IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+		FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+		THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+		LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+		FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+		DEALINGS IN THE SOFTWARE.
+	</copyright>
+
+	<description summary="experimental color management protocol">
+		The aim of this color management extension is to get HDR games working quickly,
+		and have an easy way to test implementations in the wild before the upstream
+		protocol is ready to be merged.
+		For that purpose it's intentionally limited and cut down and does not serve
+		all uses cases.
+	</description>
+
+	<interface name="frog_color_management_factory_v1" version="1">
+		<description summary="color management factory">
+			The color management factory singleton creates color managed surface objects.
+		</description>
+
+		<request name="destroy" type="destructor"></request>
+
+		<request name="get_color_managed_surface">
+			<description summary="create color management interface for surface">
+			</description>
+
+			<arg name="surface" type="object" interface="wl_surface"
+				summary="target surface" />
+			<arg name="callback" type="new_id" interface="frog_color_managed_surface"
+				summary="new color managed surface object" />
+		</request>
+	</interface>
+
+	<interface name="frog_color_managed_surface" version="1">
+		<description summary="color managed surface">
+			Interface for changing surface color management and HDR state.
+
+			An implementation must: support every part of the version
+			of the frog_color_managed_surface interface it exposes.
+			Including all known enums associated with a given version.
+		</description>
+
+		<request name="destroy" type="destructor">
+			<description summary="destroy color managed surface">
+				Destroying the color managed surface resets all known color
+				state for the surface back to 'undefined' implementation-specific
+				values.
+			</description>
+		</request>
+
+		<enum name="transfer_function">
+			<description summary="known transfer functions">
+				Extended information on the transfer functions described
+				here can be found in the Khronos Data Format specification:
+				https://registry.khronos.org/DataFormat/specs/1.3/dataformat.1.3.html
+			</description>
+			<entry name="undefined" value="0"
+				summary="specifies undefined, implementation-specific handling of the surface's transfer function." />
+			<entry name="srgb" value="1"
+				summary="specifies the sRGB non-linear EOTF. An implementation may: display this as Gamma 2.2 for the purposes of being consistent with content rendering across displays, rendering_intent and user expectations." />
+			<entry name="gamma_22" value="2" summary="specifies gamma 2.2 power curve as the EOTF" />
+			<entry name="st2084_pq" value="3"
+				summary="specifies the SMPTE ST2084 Perceptual Quantizer (PQ) EOTF" />
+			<entry name="scrgb_linear" value="4"
+				summary="specifies the scRGB (extended sRGB) linear EOTF. Note: Primaries outside the gamut triangle specified can be expressed with negative values for this transfer function." />
+		</enum>
+
+		<request name="set_known_transfer_function">
+			<description summary="sets a known transfer function for a surface" />
+			<arg name="transfer_function" type="uint" enum="transfer_function"
+				summary="transfer function for the surface" />
+		</request>
+
+		<enum name="primaries">
+			<description summary="known primaries" />
+			<entry name="undefined" value="0"
+				summary="specifies undefined, implementation-specific handling" />
+			<entry name="rec709" value="1" summary="specifies Rec.709/sRGB primaries with D65 white point" />
+			<entry name="rec2020" value="2"
+				summary="specifies Rec.2020/HDR10 primaries with D65 white point" />
+		</enum>
+
+		<request name="set_known_container_color_volume">
+			<description summary="sets the container color volume (primaries) for a surface" />
+			<arg name="primaries" type="uint" enum="primaries" summary="primaries for the surface" />
+		</request>
+
+		<enum name="render_intent">
+			<description summary="known render intents">
+				Extended information on render intents described
+				here can be found in ICC.1:2022:
+
+				https://www.color.org/specification/ICC.1-2022-05.pdf
+			</description>
+			<entry name="perceptual" value="0" summary="perceptual" />
+		</enum>
+
+		<request name="set_render_intent">
+			<description summary="sets the render intent for a surface">
+				NOTE: On a surface with "perceptual" (default) render intent, handling of the container's
+				color volume
+				is implementation-specific, and may differ between different transfer functions it is paired
+				with:
+				ie. sRGB + 709 rendering may have it's primaries widened to more of the available display's
+				gamut
+				to be be more pleasing for the viewer.
+				Compared to scRGB Linear + 709 being treated faithfully as 709
+				(including utilizing negatives out of the 709 gamut triangle)
+			</description>
+			<arg name="render_intent" type="uint" enum="render_intent"
+				summary="render intent for the surface" />
+		</request>
+
+		<request name="set_hdr_metadata">
+			<description summary="set HDR metadata for a surface">
+				Forwards HDR metadata from the client to the compositor.
+
+				HDR Metadata Infoframe as per CTA 861.G spec.
+
+				Usage of this HDR metadata is implementation specific and
+				outside of the scope of this protocol.
+			</description>
+			<arg name="mastering_display_primary_red_x" type="uint">
+				<description summary="red primary x coordinate">
+					Mastering Red Color Primary X Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="mastering_display_primary_red_y" type="uint">
+				<description summary="red primary y coordinate">
+					Mastering Red Color Primary Y Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="mastering_display_primary_green_x" type="uint">
+				<description summary="green primary x coordinate">
+					Mastering Green Color Primary X Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="mastering_display_primary_green_y" type="uint">
+				<description summary="green primary y coordinate">
+					Mastering Green Color Primary Y Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="mastering_display_primary_blue_x" type="uint">
+				<description summary="blue primary x coordinate">
+					Mastering Blue Color Primary X Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="mastering_display_primary_blue_y" type="uint">
+				<description summary="blue primary y coordinate">
+					Mastering Blue Color Primary Y Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="mastering_white_point_x" type="uint">
+				<description summary="white point x coordinate">
+					Mastering White Point X Coordinate of the Data.
+
+					These are coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="mastering_white_point_y" type="uint">
+				<description summary="white point y coordinate">
+					Mastering White Point Y Coordinate of the Data.
+
+					These are coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="max_display_mastering_luminance" type="uint">
+				<description summary="max display mastering luminance">
+					Max Mastering Display Luminance.
+					This value is coded as an unsigned 16-bit value in units of 1 cd/m2,
+					where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2.
+				</description>
+			</arg>
+			<arg name="min_display_mastering_luminance" type="uint">
+				<description summary="min display mastering luminance">
+					Min Mastering Display Luminance.
+					This value is coded as an unsigned 16-bit value in units of
+					0.0001 cd/m2, where 0x0001 represents 0.0001 cd/m2 and 0xFFFF
+					represents 6.5535 cd/m2.
+				</description>
+			</arg>
+			<arg name="max_cll" type="uint">
+				<description summary="max content light level">
+					Max Content Light Level.
+					This value is coded as an unsigned 16-bit value in units of 1 cd/m2,
+					where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2.
+				</description>
+			</arg>
+			<arg name="max_fall" type="uint">
+				<description summary="max frame average light level">
+					Max Frame Average Light Level.
+					This value is coded as an unsigned 16-bit value in units of 1 cd/m2,
+					where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2.
+				</description>
+			</arg>
+		</request>
+
+		<event name="preferred_metadata">
+			<description summary="preferred metadata for a surface">
+				Current preferred metadata for a surface.
+				The application should use this information to tone-map its buffers
+				to this target before committing.
+
+				This metadata does not necessarily correspond to any physical output, but
+				rather what the compositor thinks would be best for a given surface.
+			</description>
+			<arg name="transfer_function" type="uint" enum="transfer_function">
+				<description summary="output's current transfer function">
+					Specifies a known transfer function that corresponds to the
+					output the surface is targeting.
+				</description>
+			</arg>
+			<arg name="output_display_primary_red_x" type="uint">
+				<description summary="red primary x coordinate">
+					Output Red Color Primary X Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="output_display_primary_red_y" type="uint">
+				<description summary="red primary y coordinate">
+					Output Red Color Primary Y Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="output_display_primary_green_x" type="uint">
+				<description summary="green primary x coordinate">
+					Output Green Color Primary X Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="output_display_primary_green_y" type="uint">
+				<description summary="green primary y coordinate">
+					Output Green Color Primary Y Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="output_display_primary_blue_x" type="uint">
+				<description summary="blue primary x coordinate">
+					Output Blue Color Primary X Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="output_display_primary_blue_y" type="uint">
+				<description summary="blue primary y coordinate">
+					Output Blue Color Primary Y Coordinate of the Data.
+
+					Coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="output_white_point_x" type="uint">
+				<description summary="white point x coordinate">
+					Output White Point X Coordinate of the Data.
+
+					These are coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="output_white_point_y" type="uint">
+				<description summary="white point y coordinate">
+					Output White Point Y Coordinate of the Data.
+
+					These are coded as unsigned 16-bit values in units of
+					0.00002, where 0x0000 represents zero and 0xC350
+					represents 1.0000.
+				</description>
+			</arg>
+			<arg name="max_luminance" type="uint">
+				<description summary="maximum luminance">
+					Max Output Luminance
+					The max luminance in nits that the output is capable of rendering in small areas.
+					Content should: not exceed this value to avoid clipping.
+
+					This value is coded as an unsigned 16-bit value in units of 1 cd/m2,
+					where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2.
+				</description>
+			</arg>
+			<arg name="min_luminance" type="uint">
+				<description summary="minimum luminance">
+					Min Output Luminance
+					The min luminance that the output is capable of rendering.
+					Content should: not exceed this value to avoid clipping.
+
+					This value is coded as an unsigned 16-bit value in units of
+					0.0001 cd/m2, where 0x0001 represents 0.0001 cd/m2 and 0xFFFF
+					represents 6.5535 cd/m2.
+				</description>
+			</arg>
+			<arg name="max_full_frame_luminance" type="uint">
+				<description summary="maximum full frame luminance">
+					Max Full Frame Luminance
+					The max luminance in nits that the output is capable of rendering for the
+					full frame sustained.
+
+					This value is coded as an unsigned 16-bit value in units of 1 cd/m2,
+					where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2.
+				</description>
+			</arg>
+		</event>
+	</interface>
+</protocol>

protocols/meson.build

@@ -7,7 +7,7 @@ wayland_protos = dependency(
 
 hyprland_protos = dependency(
 	'hyprland-protocols',
-	version: '>=0.2',
+	version: '>=0.6',
 	fallback: 'hyprland-protocols',
 )
 
@@ -33,9 +33,14 @@ protocols = [
 	'wayland-drm.xml',
 	'wlr-data-control-unstable-v1.xml',
 	'wlr-screencopy-unstable-v1.xml',
+	'xx-color-management-v4.xml',
+	'frog-color-management-v1.xml',
 	hyprland_protocol_dir / 'protocols/hyprland-global-shortcuts-v1.xml',
 	hyprland_protocol_dir / 'protocols/hyprland-toplevel-export-v1.xml',
 	hyprland_protocol_dir / 'protocols/hyprland-focus-grab-v1.xml',
+	hyprland_protocol_dir / 'protocols/hyprland-ctm-control-v1.xml',
+	hyprland_protocol_dir / 'protocols/hyprland-surface-v1.xml',
+	hyprland_protocol_dir / 'protocols/hyprland-lock-notify-v1.xml',
 	wayland_protocol_dir / 'staging/tearing-control/tearing-control-v1.xml',
 	wayland_protocol_dir / 'staging/fractional-scale/fractional-scale-v1.xml',
 	wayland_protocol_dir / 'unstable/xdg-output/xdg-output-unstable-v1.xml',
@@ -64,6 +69,7 @@ protocols = [
 	wayland_protocol_dir / 'staging/linux-drm-syncobj/linux-drm-syncobj-v1.xml',
 	wayland_protocol_dir / 'staging/xdg-dialog/xdg-dialog-v1.xml',
 	wayland_protocol_dir / 'staging/single-pixel-buffer/single-pixel-buffer-v1.xml',
+	wayland_protocol_dir / 'staging/security-context/security-context-v1.xml',
 ]
 
 wl_protocols = []

src/Compositor.hpp

@@ -1,41 +1,23 @@
 #pragma once
 
-#include <memory>
-#include <deque>
 #include <list>
 #include <sys/resource.h>
 
 #include "defines.hpp"
-#include "debug/Log.hpp"
-#include "events/Events.hpp"
-#include "config/ConfigManager.hpp"
-#include "managers/ThreadManager.hpp"
 #include "managers/XWaylandManager.hpp"
-#include "managers/input/InputManager.hpp"
-#include "managers/LayoutManager.hpp"
 #include "managers/KeybindManager.hpp"
-#include "managers/AnimationManager.hpp"
-#include "managers/EventManager.hpp"
-#include "managers/ProtocolManager.hpp"
 #include "managers/SessionLockManager.hpp"
-#include "managers/HookSystemManager.hpp"
-#include "debug/HyprDebugOverlay.hpp"
-#include "debug/HyprNotificationOverlay.hpp"
-#include "helpers/Monitor.hpp"
-#include "desktop/Workspace.hpp"
 #include "desktop/Window.hpp"
-#include "render/Renderer.hpp"
-#include "render/OpenGL.hpp"
-#include "hyprerror/HyprError.hpp"
-#include "plugins/PluginSystem.hpp"
-#include "helpers/Watchdog.hpp"
+#include "protocols/types/ColorManagement.hpp"
+#include "helpers/memory/Memory.hpp"
 
 #include <aquamarine/backend/Backend.hpp>
 #include <aquamarine/output/Output.hpp>
 
 class CWLSurfaceResource;
+struct SWorkspaceRule;
 
-enum eManagersInitStage {
+enum eManagersInitStage : uint8_t {
     STAGE_PRIORITY = 0,
     STAGE_BASICINIT,
     STAGE_LATE
@@ -43,7 +25,7 @@ enum eManagersInitStage {
 
 class CCompositor {
   public:
-    CCompositor();
+    CCompositor(bool onlyConfig = false);
     ~CCompositor();
 
     wl_display*                                m_sWLDisplay;
@@ -59,8 +41,8 @@ class CCompositor {
     std::string                                m_szInstancePath      = "";
     std::string                                m_szCurrentSplash     = "error";
 
-    std::vector<SP<CMonitor>>                  m_vMonitors;
-    std::vector<SP<CMonitor>>                  m_vRealMonitors; // for all monitors, even those turned off
+    std::vector<PHLMONITOR>                    m_vMonitors;
+    std::vector<PHLMONITOR>                    m_vRealMonitors; // for all monitors, even those turned off
     std::vector<PHLWINDOW>                     m_vWindows;
     std::vector<PHLLS>                         m_vLayers;
     std::vector<PHLWORKSPACE>                  m_vWorkspaces;
@@ -80,7 +62,7 @@ class CCompositor {
 
     WP<CWLSurfaceResource>                     m_pLastFocus;
     PHLWINDOWREF                               m_pLastWindow;
-    WP<CMonitor>                               m_pLastMonitor;
+    PHLMONITORREF                              m_pLastMonitor;
 
     std::vector<PHLWINDOWREF>                  m_vWindowFocusHistory; // first element is the most recently focused.
 
@@ -89,74 +71,64 @@ class CCompositor {
     bool                                       m_bDPMSStateON    = true;
     bool                                       m_bUnsafeState    = false; // unsafe state is when there is no monitors.
     bool                                       m_bNextIsUnsafe   = false;
-    CMonitor*                                  m_pUnsafeOutput   = nullptr; // fallback output for the unsafe state
-    bool                                       m_bIsShuttingDown = false;
-    bool                                       m_bFinalRequests  = false;
-    bool                                       m_bDesktopEnvSet  = false;
-    bool                                       m_bEnableXwayland = true;
+    PHLMONITORREF                              m_pUnsafeOutput; // fallback output for the unsafe state
+    bool                                       m_bIsShuttingDown         = false;
+    bool                                       m_bFinalRequests          = false;
+    bool                                       m_bDesktopEnvSet          = false;
+    bool                                       m_bWantsXwayland          = true;
+    bool                                       m_bOnlyConfigVerification = false;
 
     // ------------------------------------------------- //
 
-    CMonitor*              getMonitorFromID(const MONITORID&);
-    CMonitor*              getMonitorFromName(const std::string&);
-    CMonitor*              getMonitorFromDesc(const std::string&);
-    CMonitor*              getMonitorFromCursor();
-    CMonitor*              getMonitorFromVector(const Vector2D&);
+    PHLMONITOR             getMonitorFromID(const MONITORID&);
+    PHLMONITOR             getMonitorFromName(const std::string&);
+    PHLMONITOR             getMonitorFromDesc(const std::string&);
+    PHLMONITOR             getMonitorFromCursor();
+    PHLMONITOR             getMonitorFromVector(const Vector2D&);
     void                   removeWindowFromVectorSafe(PHLWINDOW);
     void                   focusWindow(PHLWINDOW, SP<CWLSurfaceResource> pSurface = nullptr);
     void                   focusSurface(SP<CWLSurfaceResource>, PHLWINDOW pWindowOwner = nullptr);
-    bool                   monitorExists(CMonitor*);
+    bool                   monitorExists(PHLMONITOR);
     PHLWINDOW              vectorToWindowUnified(const Vector2D&, uint8_t properties, PHLWINDOW pIgnoreWindow = nullptr);
     SP<CWLSurfaceResource> vectorToLayerSurface(const Vector2D&, std::vector<PHLLSREF>*, Vector2D*, PHLLS*);
-    SP<CWLSurfaceResource> vectorToLayerPopupSurface(const Vector2D&, CMonitor* monitor, Vector2D*, PHLLS*);
+    SP<CWLSurfaceResource> vectorToLayerPopupSurface(const Vector2D&, PHLMONITOR monitor, Vector2D*, PHLLS*);
     SP<CWLSurfaceResource> vectorWindowToSurface(const Vector2D&, PHLWINDOW, Vector2D& sl);
     Vector2D               vectorToSurfaceLocal(const Vector2D&, PHLWINDOW, SP<CWLSurfaceResource>);
-    CMonitor*              getMonitorFromOutput(SP<Aquamarine::IOutput>);
-    CMonitor*              getRealMonitorFromOutput(SP<Aquamarine::IOutput>);
+    PHLMONITOR             getMonitorFromOutput(SP<Aquamarine::IOutput>);
+    PHLMONITOR             getRealMonitorFromOutput(SP<Aquamarine::IOutput>);
     PHLWINDOW              getWindowFromSurface(SP<CWLSurfaceResource>);
     PHLWINDOW              getWindowFromHandle(uint32_t);
-    bool                   isWorkspaceVisible(PHLWORKSPACE);
-    bool                   isWorkspaceVisibleNotCovered(PHLWORKSPACE);
     PHLWORKSPACE           getWorkspaceByID(const WORKSPACEID&);
     PHLWORKSPACE           getWorkspaceByName(const std::string&);
     PHLWORKSPACE           getWorkspaceByString(const std::string&);
     void                   sanityCheckWorkspaces();
-    void                   updateWorkspaceWindowDecos(const WORKSPACEID&);
-    void                   updateWorkspaceWindowData(const WORKSPACEID&);
-    int                    getWindowsOnWorkspace(const WORKSPACEID& id, std::optional<bool> onlyTiled = {}, std::optional<bool> onlyVisible = {});
-    int                    getGroupsOnWorkspace(const WORKSPACEID& id, std::optional<bool> onlyTiled = {}, std::optional<bool> onlyVisible = {});
     PHLWINDOW              getUrgentWindow();
-    bool                   hasUrgentWindowOnWorkspace(const WORKSPACEID&);
-    PHLWINDOW              getFirstWindowOnWorkspace(const WORKSPACEID&);
-    PHLWINDOW              getTopLeftWindowOnWorkspace(const WORKSPACEID&);
-    PHLWINDOW              getFullscreenWindowOnWorkspace(const WORKSPACEID&);
     bool                   isWindowActive(PHLWINDOW);
     void                   changeWindowZOrder(PHLWINDOW, bool);
     void                   cleanupFadingOut(const MONITORID& monid);
     PHLWINDOW              getWindowInDirection(PHLWINDOW, char);
-    PHLWINDOW              getNextWindowOnWorkspace(PHLWINDOW, bool focusableOnly = false, std::optional<bool> floating = {});
-    PHLWINDOW              getPrevWindowOnWorkspace(PHLWINDOW, bool focusableOnly = false, std::optional<bool> floating = {});
+    PHLWINDOW              getWindowInDirection(const CBox& box, PHLWORKSPACE pWorkspace, char dir, PHLWINDOW ignoreWindow = nullptr, bool useVectorAngles = false);
+    PHLWINDOW              getNextWindowOnWorkspace(PHLWINDOW, bool focusableOnly = false, std::optional<bool> floating = {}, bool visible = false);
+    PHLWINDOW              getPrevWindowOnWorkspace(PHLWINDOW, bool focusableOnly = false, std::optional<bool> floating = {}, bool visible = false);
     WORKSPACEID            getNextAvailableNamedWorkspace();
     bool                   isPointOnAnyMonitor(const Vector2D&);
-    bool                   isPointOnReservedArea(const Vector2D& point, const CMonitor* monitor = nullptr);
-    CMonitor*              getMonitorInDirection(const char&);
-    CMonitor*              getMonitorInDirection(CMonitor*, const char&);
+    bool                   isPointOnReservedArea(const Vector2D& point, const PHLMONITOR monitor = nullptr);
+    PHLMONITOR             getMonitorInDirection(const char&);
+    PHLMONITOR             getMonitorInDirection(PHLMONITOR, const char&);
     void                   updateAllWindowsAnimatedDecorationValues();
-    void                   updateWorkspaceWindows(const WORKSPACEID& id);
     void                   updateWindowAnimatedDecorationValues(PHLWINDOW);
     MONITORID              getNextAvailableMonitorID(std::string const& name);
-    void                   moveWorkspaceToMonitor(PHLWORKSPACE, CMonitor*, bool noWarpCursor = false);
-    void                   swapActiveWorkspaces(CMonitor*, CMonitor*);
-    CMonitor*              getMonitorFromString(const std::string&);
+    void                   moveWorkspaceToMonitor(PHLWORKSPACE, PHLMONITOR, bool noWarpCursor = false);
+    void                   swapActiveWorkspaces(PHLMONITOR, PHLMONITOR);
+    PHLMONITOR             getMonitorFromString(const std::string&);
     bool                   workspaceIDOutOfBounds(const WORKSPACEID&);
     void                   setWindowFullscreenInternal(const PHLWINDOW PWINDOW, const eFullscreenMode MODE);
     void                   setWindowFullscreenClient(const PHLWINDOW PWINDOW, const eFullscreenMode MODE);
-    void                   setWindowFullscreenState(const PHLWINDOW PWINDOW, const sFullscreenState state);
-    void                   changeWindowFullscreenModeInternal(const PHLWINDOW PWINDOW, const eFullscreenMode MODE, const bool ON);
+    void                   setWindowFullscreenState(const PHLWINDOW PWINDOW, const SFullscreenState state);
     void                   changeWindowFullscreenModeClient(const PHLWINDOW PWINDOW, const eFullscreenMode MODE, const bool ON);
     void                   updateFullscreenFadeOnWorkspace(PHLWORKSPACE);
     PHLWINDOW              getX11Parent(PHLWINDOW);
-    void                   scheduleFrameForMonitor(CMonitor*, Aquamarine::IOutput::scheduleFrameReason reason = Aquamarine::IOutput::AQ_SCHEDULE_CLIENT_UNKNOWN);
+    void                   scheduleFrameForMonitor(PHLMONITOR, Aquamarine::IOutput::scheduleFrameReason reason = Aquamarine::IOutput::AQ_SCHEDULE_CLIENT_UNKNOWN);
     void                   addToFadingOutSafe(PHLLS);
     void                   removeFromFadingOutSafe(PHLLS);
     void                   addToFadingOutSafe(PHLWINDOW);
@@ -165,11 +137,9 @@ class CCompositor {
     PHLLS                  getLayerSurfaceFromSurface(SP<CWLSurfaceResource>);
     void                   closeWindow(PHLWINDOW);
     Vector2D               parseWindowVectorArgsRelative(const std::string&, const Vector2D&);
-    void                   forceReportSizesToWindowsOnWorkspace(const WORKSPACEID&);
     PHLWORKSPACE           createNewWorkspace(const WORKSPACEID&, const MONITORID&, const std::string& name = "",
                                               bool isEmpty = true); // will be deleted next frame if left empty and unfocused!
-    void                   renameWorkspace(const WORKSPACEID&, const std::string& name = "");
-    void                   setActiveMonitor(CMonitor*);
+    void                   setActiveMonitor(PHLMONITOR);
     bool                   isWorkspaceSpecial(const WORKSPACEID&);
     WORKSPACEID            getNewSpecialID();
     void                   performUserChecks();
@@ -181,8 +151,11 @@ class CCompositor {
     void                   setPreferredScaleForSurface(SP<CWLSurfaceResource> pSurface, double scale);
     void                   setPreferredTransformForSurface(SP<CWLSurfaceResource> pSurface, wl_output_transform transform);
     void                   updateSuspendedStates();
-    PHLWINDOW              windowForCPointer(CWindow*);
     void                   onNewMonitor(SP<Aquamarine::IOutput> output);
+    void                   ensurePersistentWorkspacesPresent(const std::vector<SWorkspaceRule>& rules);
+
+    SImageDescription      getPreferredImageDescription();
+    bool                   shouldChangePreferredImageDescription();
 
     std::string            explicitConfigPath;
 
@@ -193,10 +166,11 @@ class CCompositor {
     void             setRandomSplash();
     void             initManagers(eManagersInitStage stage);
     void             prepareFallbackOutput();
+    bool             isWindowAvailableForCycle(PHLWINDOW pWindow, PHLWINDOW w, bool focusableOnly, std::optional<bool> floating, bool anyWorkspace = false);
 
     uint64_t         m_iHyprlandPID    = 0;
     wl_event_source* m_critSigSource   = nullptr;
     rlimit           m_sOriginalNofile = {0};
 };
 
-inline std::unique_ptr<CCompositor> g_pCompositor;
+inline UP<CCompositor> g_pCompositor;

src/SharedDefs.hpp

@@ -3,11 +3,11 @@
 #include "helpers/math/Math.hpp"
 #include <functional>
 #include <any>
+#include <string>
+#include <algorithm>
 #include <hyprutils/math/Box.hpp>
 
-using namespace Hyprutils::Math;
-
-enum eIcons {
+enum eIcons : uint8_t {
     ICON_WARNING = 0,
     ICON_INFO,
     ICON_HINT,
@@ -17,7 +17,7 @@ enum eIcons {
     ICON_NONE
 };
 
-enum eRenderStage {
+enum eRenderStage : uint8_t {
     RENDER_PRE = 0,      /* Before binding the gl context */
     RENDER_BEGIN,        /* Just when the rendering begins, nothing has been rendered yet. Damage, current render data in opengl valid. */
     RENDER_PRE_WINDOWS,  /* Pre windows, post bottom and overlay layers */
@@ -29,7 +29,7 @@ enum eRenderStage {
     RENDER_POST_WINDOW,  /* After rendering a window (any pass) */
 };
 
-enum eInputType {
+enum eInputType : uint8_t {
     INPUT_TYPE_AXIS = 0,
     INPUT_TYPE_BUTTON,
     INPUT_TYPE_DRAG_START,
@@ -41,7 +41,7 @@ struct SCallbackInfo {
     bool cancelled = false; /* on cancellable events, will cancel the event. */
 };
 
-enum eHyprCtlOutputFormat {
+enum eHyprCtlOutputFormat : uint8_t {
     FORMAT_NORMAL = 0,
     FORMAT_JSON
 };
@@ -52,6 +52,12 @@ struct SHyprCtlCommand {
     std::function<std::string(eHyprCtlOutputFormat, std::string)> fn;
 };
 
+struct SDispatchResult {
+    bool        passEvent = false;
+    bool        success   = true;
+    std::string error;
+};
+
 typedef int64_t                                              WINDOWID;
 typedef int64_t                                              MONITORID;
 typedef int64_t                                              WORKSPACEID;

src/config/ConfigDataValues.hpp

@@ -3,7 +3,7 @@
 #include "../helpers/varlist/VarList.hpp"
 #include <vector>
 
-enum eConfigValueDataTypes {
+enum eConfigValueDataTypes : int8_t {
     CVD_TYPE_INVALID   = -1,
     CVD_TYPE_GRADIENT  = 0,
     CVD_TYPE_CSS_VALUE = 1
@@ -11,7 +11,7 @@ enum eConfigValueDataTypes {
 
 class ICustomConfigValueData {
   public:
-    virtual ~ICustomConfigValueData() = 0;
+    virtual ~ICustomConfigValueData() = default;
 
     virtual eConfigValueDataTypes getDataType() = 0;
 
@@ -20,24 +20,40 @@ class ICustomConfigValueData {
 
 class CGradientValueData : public ICustomConfigValueData {
   public:
-    CGradientValueData() {};
-    CGradientValueData(CColor col) {
+    CGradientValueData() = default;
+    CGradientValueData(CHyprColor col) {
         m_vColors.push_back(col);
+        updateColorsOk();
     };
-    virtual ~CGradientValueData() {};
+    virtual ~CGradientValueData() = default;
 
     virtual eConfigValueDataTypes getDataType() {
         return CVD_TYPE_GRADIENT;
     }
 
-    void reset(CColor col) {
+    void reset(CHyprColor col) {
         m_vColors.clear();
         m_vColors.emplace_back(col);
         m_fAngle = 0;
+        updateColorsOk();
+    }
+
+    void updateColorsOk() {
+        m_vColorsOkLabA.clear();
+        for (auto& c : m_vColors) {
+            const auto OKLAB = c.asOkLab();
+            m_vColorsOkLabA.emplace_back(OKLAB.l);
+            m_vColorsOkLabA.emplace_back(OKLAB.a);
+            m_vColorsOkLabA.emplace_back(OKLAB.b);
+            m_vColorsOkLabA.emplace_back(c.a);
+        }
     }
 
     /* Vector containing the colors */
-    std::vector<CColor> m_vColors;
+    std::vector<CHyprColor> m_vColors;
+
+    /* Vector containing pure colors for shoving into opengl */
+    std::vector<float> m_vColorsOkLabA;
 
     /* Float corresponding to the angle (rad) */
     float m_fAngle = 0;

src/config/ConfigDescriptions.hpp

@@ -104,6 +104,30 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_INT,
         .data        = SConfigOptionDescription::SRangeData{0, 0, 4},
     },
+    SConfigOptionDescription{
+        .value       = "general:snap:enabled",
+        .description = "enable snapping for floating windows",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
+    SConfigOptionDescription{
+        .value       = "general:snap:window_gap",
+        .description = "minimum gap in pixels between windows before snapping",
+        .type        = CONFIG_OPTION_INT,
+        .data        = SConfigOptionDescription::SRangeData{10, 0, 100},
+    },
+    SConfigOptionDescription{
+        .value       = "general:snap:monitor_gap",
+        .description = "minimum gap in pixels between window and monitor edges before snapping",
+        .type        = CONFIG_OPTION_INT,
+        .data        = SConfigOptionDescription::SRangeData{10, 0, 100},
+    },
+    SConfigOptionDescription{
+        .value       = "general:snap:border_overlap",
+        .description = "if true, windows snap such that only one border's worth of space is between them",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
 
     /*
      * decoration:
@@ -115,6 +139,12 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_INT,
         .data        = SConfigOptionDescription::SRangeData{0, 0, 20},
     },
+    SConfigOptionDescription{
+        .value       = "decoration:rounding_power",
+        .description = "rouding power of corners (2 is a circle)",
+        .type        = CONFIG_OPTION_FLOAT,
+        .data        = SConfigOptionDescription::SFloatData{2, 2, 10},
+    },
     SConfigOptionDescription{
         .value       = "decoration:active_opacity",
         .description = "opacity of active windows. [0.0 - 1.0]",
@@ -134,49 +164,55 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .data        = SConfigOptionDescription::SFloatData{1, 0, 1},
     },
     SConfigOptionDescription{
-        .value       = "decoration:drop_shadow",
+        .value       = "decoration:shadow:enabled",
         .description = "enable drop shadows on windows",
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{true},
     },
     SConfigOptionDescription{
-        .value       = "decoration:shadow_range",
+        .value       = "decoration:shadow:range",
         .description = "Shadow range (size) in layout px",
         .type        = CONFIG_OPTION_INT,
         .data        = SConfigOptionDescription::SRangeData{4, 0, 100},
     },
     SConfigOptionDescription{
-        .value       = "decoration:shadow_render_power",
+        .value       = "decoration:shadow:render_power",
         .description = "in what power to render the falloff (more power, the faster the falloff) [1 - 4]",
         .type        = CONFIG_OPTION_INT,
         .data        = SConfigOptionDescription::SRangeData{3, 1, 4},
     },
     SConfigOptionDescription{
-        .value       = "decoration:shadow_ignore_window",
+        .value       = "decoration:shadow:sharp",
+        .description = "whether the shadow should be sharp or not. Akin to an infinitely high render power.",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
+    SConfigOptionDescription{
+        .value       = "decoration:shadow:ignore_window",
         .description = "if true, the shadow will not be rendered behind the window itself, only around it.",
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{true},
     },
     SConfigOptionDescription{
-        .value       = "decoration:col.shadow",
+        .value       = "decoration:shadow:color",
         .description = "shadow's color. Alpha dictates shadow's opacity.",
         .type        = CONFIG_OPTION_COLOR,
         .data        = SConfigOptionDescription::SColorData{0xee1a1a1a},
     },
     SConfigOptionDescription{
-        .value       = "decoration:col.shadow_inactive",
+        .value       = "decoration:shadow:color_inactive",
         .description = "inactive shadow color. (if not set, will fall back to col.shadow)",
         .type        = CONFIG_OPTION_COLOR,
-        .data        = SConfigOptionDescription::SColorData{}, //##TODO UNSET?
+        .data        = SConfigOptionDescription::SColorData{}, //TODO: UNSET?
     },
     SConfigOptionDescription{
-        .value       = "decoration:shadow_offset",
+        .value       = "decoration:shadow:offset",
         .description = "shadow's rendering offset.",
         .type        = CONFIG_OPTION_VECTOR,
         .data        = SConfigOptionDescription::SVectorData{{}, {-250, -250}, {250, 250}},
     },
     SConfigOptionDescription{
-        .value       = "decoration:shadow_scale",
+        .value       = "decoration:shadow:scale",
         .description = "shadow's scale. [0.0 - 1.0]",
         .type        = CONFIG_OPTION_FLOAT,
         .data        = SConfigOptionDescription::SFloatData{1, 0, 1},
@@ -238,7 +274,7 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .value       = "blur:ignore_opacity",
         .description = "make the blur layer ignore the opacity of the window",
         .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
+        .data        = SConfigOptionDescription::SBoolData{true},
     },
     SConfigOptionDescription{
         .value       = "blur:new_optimizations",
@@ -301,6 +337,18 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_FLOAT,
         .data        = SConfigOptionDescription::SFloatData{0.2, 0, 1},
     },
+    SConfigOptionDescription{
+        .value       = "blur:input_methods",
+        .description = "whether to blur input methods (e.g. fcitx5)",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
+    SConfigOptionDescription{
+        .value       = "blur:input_methods_ignorealpha",
+        .description = "works like ignorealpha in layer rules. If pixel opacity is below set value, will not blur. [0.0 - 1.0]",
+        .type        = CONFIG_OPTION_FLOAT,
+        .data        = SConfigOptionDescription::SFloatData{0.2, 0, 1},
+    },
 
     /*
      * animations:
@@ -590,16 +638,22 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
     },
     SConfigOptionDescription{
         .value       = "input:tablet:output",
-        .description = "the monitor to bind tablets. Empty means unbound..",
+        .description = "the monitor to bind tablets. Can be current or a monitor name. Leave empty to map across all monitors.",
         .type        = CONFIG_OPTION_STRING_SHORT,
         .data        = SConfigOptionDescription::SStringData{""}, //##TODO UNSET?
     },
     SConfigOptionDescription{
         .value       = "input:tablet:region_position",
-        .description = "position of the mapped region in monitor layout.",
+        .description = "position of the mapped region in monitor layout relative to the top left corner of the bound monitor or all monitors.",
         .type        = CONFIG_OPTION_VECTOR,
         .data        = SConfigOptionDescription::SVectorData{{}, {-20000, -20000}, {20000, 20000}},
     },
+    SConfigOptionDescription{
+        .value       = "input:tablet:absolute_region_position",
+        .description = "whether to treat the region_position as an absolute position in monitor layout. Only applies when output is empty.",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
     SConfigOptionDescription{
         .value       = "input:tablet:region_size",
         .description = "size of the mapped region. When this variable is set, tablet input will be mapped to the region. [0, 0] or invalid size means unset.",
@@ -748,6 +802,12 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{true},
     },
+    SConfigOptionDescription{
+        .value       = "group:merge_groups_on_groupbar",
+        .description = "whether one group will be merged with another when dragged into its groupbar",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{true},
+    },
     SConfigOptionDescription{
         .value       = "general:col.border_active",
         .description = "border color for inactive windows",
@@ -778,6 +838,24 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{true},
     },
+    SConfigOptionDescription{
+        .value       = "group:drag_into_group",
+        .description = "whether dragging a window into a unlocked group will merge them. Options: 0 (disabled), 1 (enabled), 2 (only when dragging into the groupbar)",
+        .type        = CONFIG_OPTION_CHOICE,
+        .data        = SConfigOptionDescription::SChoiceData{0, "disabled,enabled,only when dragging into the groupbar"},
+    },
+    SConfigOptionDescription{
+        .value       = "group:merge_floated_into_tiled_on_groupbar",
+        .description = "whether dragging a floating window into a tiled window groupbar will merge them",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
+    SConfigOptionDescription{
+        .value       = "group:group_on_movetoworkspace",
+        .description = "whether using movetoworkspace[silent] will merge the window into the workspace's solitary unlocked group",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
 
     /*
      * group:groupbar:
@@ -1061,6 +1139,18 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{false},
     },
+    SConfigOptionDescription{
+        .value       = "misc:disable_hyprland_qtutils_check",
+        .description = "disable the warning if hyprland-qtutils is missing",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
+    SConfigOptionDescription{
+        .value       = "misc:lockdead_screen_delay",
+        .description = "the delay in ms after the lockdead screen appears if the lock screen did not appear after a lock event occurred.",
+        .type        = CONFIG_OPTION_INT,
+        .data        = SConfigOptionDescription::SRangeData{1000, 0, 5000},
+    },
 
     /*
      * binds:
@@ -1116,6 +1206,12 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{true},
     },
+    SConfigOptionDescription{
+        .value       = "binds:movefocus_cycles_groupfirst",
+        .description = "If enabled, when in a grouped window, movefocus will cycle windows in the groups first, then at each ends of tabs, it'll move on to other windows/groups",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
     SConfigOptionDescription{
         .value       = "binds:disable_keybind_grabbing",
         .description = "If enabled, apps that request keybinds to be disabled (e.g. VMs) will not be able to do so.",
@@ -1128,6 +1224,12 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{true},
     },
+    SConfigOptionDescription{
+        .value       = "binds:allow_pin_fullscreen",
+        .description = "Allows fullscreen to pinned windows, and restore their pinned status afterwards",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
 
     /*
      * xwayland:
@@ -1193,6 +1295,30 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{false},
     },
+    SConfigOptionDescription{
+        .value       = "render:expand_undersized_textures",
+        .description = "Whether to expand textures that have not yet resized to be larger, or to just stretch them instead.",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{true},
+    },
+    SConfigOptionDescription{
+        .value       = "render:xp_mode",
+        .description = "Disable back buffer and bottom layer rendering.",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{true},
+    },
+    SConfigOptionDescription{
+        .value       = "render:ctm_animation",
+        .description = "Whether to enable a fade animation for CTM changes (hyprsunset). 2 means 'auto' (Yes on everything but Nvidia).",
+        .type        = CONFIG_OPTION_INT,
+        .data        = SConfigOptionDescription::SRangeData{2, 0, 2},
+    },
+    SConfigOptionDescription{
+        .value       = "render:allow_early_buffer_release",
+        .description = "Allow early buffer release event. Fixes stuttering and missing frames for some apps. May cause graphical glitches and memory leaks in others",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{true},
+    },
 
     /*
      * cursor:
@@ -1208,8 +1334,8 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
     SConfigOptionDescription{
         .value       = "cursor:no_hardware_cursors",
         .description = "disables hardware cursors",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
+        .type        = CONFIG_OPTION_CHOICE,
+        .data        = SConfigOptionDescription::SChoiceData{0, "Disabled,Enabled,Auto"},
     },
     SConfigOptionDescription{
         .value       = "cursor:no_break_fs_vrr",
@@ -1249,9 +1375,9 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
     },
     SConfigOptionDescription{
         .value       = "cursor:warp_on_change_workspace",
-        .description = "If true, move the cursor to the last focused window after changing the workspace.",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
+        .description = "Move the cursor to the last focused window after changing the workspace. Options: 0 (Disabled), 1 (Enabled), 2 (Force - ignores cursor:no_warps option)",
+        .type        = CONFIG_OPTION_CHOICE,
+        .data        = SConfigOptionDescription::SChoiceData{0, "Disabled,Enabled,Force"},
     },
     SConfigOptionDescription{
         .value       = "cursor:default_monitor",
@@ -1290,8 +1416,8 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .data        = SConfigOptionDescription::SBoolData{true},
     },
     SConfigOptionDescription{
-        .value       = "cursor:allow_dumb_copy",
-        .description = "Makes HW cursors work on Nvidia, at the cost of a possible hitch whenever the image changes",
+        .value       = "cursor:use_cpu_buffer",
+        .description = "Makes HW cursors use a CPU buffer. Required on Nvidia to have HW cursors. Experimental",
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{false},
     },
@@ -1434,12 +1560,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_FLOAT,
         .data        = SConfigOptionDescription::SFloatData{1, 0.1, 3},
     },
-    SConfigOptionDescription{
-        .value       = "dwindle:no_gaps_when_only",
-        .description = "whether to apply gaps when there is only one window on a workspace, aka. smart gaps. (default: disabled - 0) no border - 1, with border - 2 [0/1/2]",
-        .type        = CONFIG_OPTION_CHOICE,
-        .data        = SConfigOptionDescription::SChoiceData{0, "disabled,no border,with border"},
-    },
     SConfigOptionDescription{
         .value       = "dwindle:use_active_for_splits",
         .description = "whether to prefer the active window or the mouse position for splits",
@@ -1500,12 +1620,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_STRING_SHORT,
         .data        = SConfigOptionDescription::SStringData{"none"},
     },
-    SConfigOptionDescription{
-        .value       = "master:no_gaps_when_only",
-        .description = "whether to apply gaps when there is only one window on a workspace, aka. smart gaps. (default: disabled - 0) no border - 1, with border - 2 [0/1/2]",
-        .type        = CONFIG_OPTION_CHOICE,
-        .data        = SConfigOptionDescription::SChoiceData{0, "disabled,no border,with border"},
-    },
     SConfigOptionDescription{
         .value       = "master:orientation",
         .description = "default placement of the master area, can be left, right, top, bottom or center",
@@ -1519,8 +1633,20 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .data        = SConfigOptionDescription::SBoolData{true},
     },
     SConfigOptionDescription{
-        .value       = "master:always_center_master",
-        .description = "when using orientation=center, keep the master window centered, even when it is the only window in the workspace.",
+        .value       = "master:slave_count_for_center_master",
+        .description = "when using orientation=center, make the master window centered only when at least this many slave windows are open. (Set 0 to always_center_master)",
+        .type        = CONFIG_OPTION_INT,
+        .data        = SConfigOptionDescription::SRangeData{2, 0, 10}, //##TODO RANGE?
+    },
+    SConfigOptionDescription{
+        .value       = "master:center_master_slaves_on_right",
+        .description = "set if the slaves should appear on right of master when slave_count_for_center_master > 2",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{true},
+    },
+    SConfigOptionDescription{
+        .value       = "master:center_ignores_reserved",
+        .description = "centers the master window on monitor ignoring reserved areas",
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{false},
     },
@@ -1538,4 +1664,22 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{true},
     },
+    SConfigOptionDescription{
+        .value       = "experimental:wide_color_gamut",
+        .description = "force wide color gamut for all supported outputs",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
+    SConfigOptionDescription{
+        .value       = "experimental:hdr",
+        .description = "force static hdr for all supported outputs",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
+    SConfigOptionDescription{
+        .value       = "experimental:xx_color_management_v4",
+        .description = "enable color management protocol",
+        .type        = CONFIG_OPTION_BOOL,
+        .data        = SConfigOptionDescription::SBoolData{false},
+    },
 };

src/config/ConfigManager.hpp

@@ -1,33 +1,30 @@
 #pragma once
 
+#include <hyprutils/animation/AnimationConfig.hpp>
 #define CONFIG_MANAGER_H
 
 #include <map>
-#include "../debug/Log.hpp"
 #include <unordered_map>
 #include "../defines.hpp"
 #include <variant>
 #include <vector>
-#include <deque>
-#include <algorithm>
-#include <regex>
 #include <optional>
 #include <functional>
 #include <xf86drmMode.h>
-#include "../helpers/WLClasses.hpp"
 #include "../helpers/Monitor.hpp"
-#include "../helpers/varlist/VarList.hpp"
 #include "../desktop/Window.hpp"
-#include "../desktop/LayerSurface.hpp"
+#include "../desktop/LayerRule.hpp"
 
-#include "defaultConfig.hpp"
 #include "ConfigDataValues.hpp"
+#include "../SharedDefs.hpp"
+#include "../helpers/Color.hpp"
+#include "../desktop/DesktopTypes.hpp"
+#include "../helpers/memory/Memory.hpp"
+#include "../desktop/WindowRule.hpp"
+#include "../managers/XWaylandManager.hpp"
 
 #include <hyprlang.hpp>
 
-#define INITANIMCFG(name)           animationConfig[name] = {}
-#define CREATEANIMCFG(name, parent) animationConfig[name] = {false, "", "", 0.f, -1, &animationConfig["global"], &animationConfig[parent]}
-
 #define HANDLE void*
 
 struct SWorkspaceRule {
@@ -56,26 +53,14 @@ struct SMonitorAdditionalReservedArea {
     int right  = 0;
 };
 
-struct SAnimationPropertyConfig {
-    bool                      overridden = true;
-
-    std::string               internalBezier  = "";
-    std::string               internalStyle   = "";
-    float                     internalSpeed   = 0.f;
-    int                       internalEnabled = -1;
-
-    SAnimationPropertyConfig* pValues          = nullptr;
-    SAnimationPropertyConfig* pParentAnimation = nullptr;
-};
-
 struct SPluginKeyword {
-    HANDLE                       handle = 0;
+    HANDLE                       handle = nullptr;
     std::string                  name   = "";
     Hyprlang::PCONFIGHANDLERFUNC fn     = nullptr;
 };
 
 struct SPluginVariable {
-    HANDLE      handle = 0;
+    HANDLE      handle = nullptr;
     std::string name   = "";
 };
 
@@ -84,7 +69,7 @@ struct SExecRequestedRule {
     uint64_t    iPid   = 0;
 };
 
-enum eConfigOptionType : uint16_t {
+enum eConfigOptionType : uint8_t {
     CONFIG_OPTION_BOOL         = 0,
     CONFIG_OPTION_INT          = 1, /* e.g. 0/1/2*/
     CONFIG_OPTION_FLOAT        = 2,
@@ -96,7 +81,7 @@ enum eConfigOptionType : uint16_t {
     CONFIG_OPTION_VECTOR       = 8,
 };
 
-enum eConfigOptionFlags : uint32_t {
+enum eConfigOptionFlags : uint8_t {
     CONFIG_OPTION_FLAG_PERCENTAGE = (1 << 0),
 };
 
@@ -119,7 +104,7 @@ struct SConfigOptionDescription {
     };
 
     struct SColorData {
-        CColor color;
+        CHyprColor color;
     };
 
     struct SChoiceData {
@@ -148,12 +133,18 @@ struct SConfigOptionDescription {
     std::variant<SBoolData, SRangeData, SFloatData, SStringData, SColorData, SChoiceData, SGradientData, SVectorData> data;
 };
 
+struct SFirstExecRequest {
+    std::string exec      = "";
+    bool        withRules = false;
+};
+
 class CConfigManager {
   public:
     CConfigManager();
 
-    void                                                            tick();
     void                                                            init();
+    void                                                            reload();
+    std::string                                                     verify();
 
     int                                                             getDeviceInt(const std::string&, const std::string&, const std::string& fallback = "");
     float                                                           getDeviceFloat(const std::string&, const std::string&, const std::string& fallback = "");
@@ -165,147 +156,155 @@ class CConfigManager {
 
     void* const*                                                    getConfigValuePtr(const std::string&);
     Hyprlang::CConfigValue*                                         getHyprlangConfigValuePtr(const std::string& name, const std::string& specialCat = "");
-    void                                                            onPluginLoadUnload(const std::string& name, bool load);
-    static std::string                                              getMainConfigPath();
-    const std::string                                               getConfigString();
+    std::string                                                     getMainConfigPath();
+    std::string                                                     getConfigString();
 
-    SMonitorRule                                                    getMonitorRuleFor(const SP<CMonitor>);
+    SMonitorRule                                                    getMonitorRuleFor(const PHLMONITOR);
     SWorkspaceRule                                                  getWorkspaceRuleFor(PHLWORKSPACE workspace);
     std::string                                                     getDefaultWorkspaceFor(const std::string&);
 
-    CMonitor*                                                       getBoundMonitorForWS(const std::string&);
+    PHLMONITOR                                                      getBoundMonitorForWS(const std::string&);
     std::string                                                     getBoundMonitorStringForWS(const std::string&);
-    const std::deque<SWorkspaceRule>&                               getAllWorkspaceRules();
+    const std::vector<SWorkspaceRule>&                              getAllWorkspaceRules();
 
-    std::vector<SWindowRule>                                        getMatchingRules(PHLWINDOW, bool dynamic = true, bool shadowExec = false);
-    std::vector<SLayerRule>                                         getMatchingRules(PHLLS);
+    std::vector<SP<CWindowRule>>                                    getMatchingRules(PHLWINDOW, bool dynamic = true, bool shadowExec = false);
+    std::vector<SP<CLayerRule>>                                     getMatchingRules(PHLLS);
+    void                                                            ensurePersistentWorkspacesPresent();
 
     const std::vector<SConfigOptionDescription>&                    getAllDescriptions();
 
     std::unordered_map<std::string, SMonitorAdditionalReservedArea> m_mAdditionalReservedAreas;
 
-    std::unordered_map<std::string, SAnimationPropertyConfig>       getAnimationConfig();
+    const std::unordered_map<std::string, SP<Hyprutils::Animation::SAnimationPropertyConfig>>& getAnimationConfig();
 
-    void                                                            addPluginConfigVar(HANDLE handle, const std::string& name, const Hyprlang::CConfigValue& value);
+    void addPluginConfigVar(HANDLE handle, const std::string& name, const Hyprlang::CConfigValue& value);
     void addPluginKeyword(HANDLE handle, const std::string& name, Hyprlang::PCONFIGHANDLERFUNC fun, Hyprlang::SHandlerOptions opts = {});
     void removePluginConfig(HANDLE handle);
 
     // no-op when done.
-    void                      dispatchExecOnce();
-    void                      dispatchExecShutdown();
+    void                                               dispatchExecOnce();
+    void                                               dispatchExecShutdown();
 
-    void                      performMonitorReload();
-    void                      appendMonitorRule(const SMonitorRule&);
-    bool                      replaceMonitorRule(const SMonitorRule&);
-    void                      ensureMonitorStatus();
-    void                      ensureVRR(CMonitor* pMonitor = nullptr);
+    void                                               performMonitorReload();
+    void                                               ensureMonitorStatus();
+    void                                               ensureVRR(PHLMONITOR pMonitor = nullptr);
 
-    std::string               parseKeyword(const std::string&, const std::string&);
+    bool                                               shouldUseSoftwareCursors();
+    void                                               updateWatcher();
 
-    void                      addParseError(const std::string&);
+    std::string                                        parseKeyword(const std::string&, const std::string&);
 
-    SAnimationPropertyConfig* getAnimationPropertyConfig(const std::string&);
+    void                                               addParseError(const std::string&);
 
-    void                      addExecRule(const SExecRequestedRule&);
+    SP<Hyprutils::Animation::SAnimationPropertyConfig> getAnimationPropertyConfig(const std::string&);
 
-    void                      handlePluginLoads();
-    std::string               getErrors();
+    void                                               addExecRule(const SExecRequestedRule&);
+
+    void                                               handlePluginLoads();
+    std::string                                        getErrors();
 
     // keywords
-    std::optional<std::string>                                                              handleRawExec(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handleExecOnce(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handleExecShutdown(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handleMonitor(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handleBind(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handleUnbind(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handleWindowRule(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handleLayerRule(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handleWindowRuleV2(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handleWorkspaceRules(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handleBezier(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handleAnimation(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handleSource(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handleSubmap(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handleBlurLS(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handleBindWS(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handleEnv(const std::string&, const std::string&);
-    std::optional<std::string>                                                              handlePlugin(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleRawExec(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleExec(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleExecOnce(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleExecRawOnce(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleExecShutdown(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleMonitor(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleBind(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleUnbind(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleWindowRule(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleLayerRule(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleWindowRuleV2(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleWorkspaceRules(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleBezier(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleAnimation(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleSource(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleSubmap(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleBlurLS(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleBindWS(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handleEnv(const std::string&, const std::string&);
+    std::optional<std::string>                                                                     handlePlugin(const std::string&, const std::string&);
 
-    std::string                                                                             configCurrentPath;
+    std::string                                                                                    configCurrentPath;
 
-    std::unordered_map<std::string, std::function<CWindowOverridableVar<bool>*(PHLWINDOW)>> mbWindowProperties = {
-        {"allowsinput", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.allowsInput; }},
-        {"dimaround", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.dimAround; }},
-        {"decorate", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.decorate; }},
-        {"focusonactivate", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.focusOnActivate; }},
-        {"keepaspectratio", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.keepAspectRatio; }},
-        {"nearestneighbor", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.nearestNeighbor; }},
-        {"noanim", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noAnim; }},
-        {"noblur", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noBlur; }},
-        {"noborder", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noBorder; }},
-        {"nodim", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noDim; }},
-        {"nofocus", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noFocus; }},
-        {"nomaxsize", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noMaxSize; }},
-        {"norounding", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noRounding; }},
-        {"noshadow", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noShadow; }},
-        {"noshortcutsinhibit", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.noShortcutsInhibit; }},
-        {"opaque", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.opaque; }},
-        {"forcergbx", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.RGBX; }},
-        {"syncfullscreen", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.syncFullscreen; }},
-        {"immediate", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.tearing; }},
-        {"xray", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.xray; }},
+    std::unordered_map<std::string, std::function<CWindowOverridableVar<bool>*(const PHLWINDOW&)>> mbWindowProperties = {
+        {"allowsinput", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.allowsInput; }},
+        {"dimaround", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.dimAround; }},
+        {"decorate", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.decorate; }},
+        {"focusonactivate", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.focusOnActivate; }},
+        {"keepaspectratio", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.keepAspectRatio; }},
+        {"nearestneighbor", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.nearestNeighbor; }},
+        {"noanim", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noAnim; }},
+        {"noblur", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noBlur; }},
+        {"noborder", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noBorder; }},
+        {"nodim", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noDim; }},
+        {"nofocus", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noFocus; }},
+        {"nomaxsize", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noMaxSize; }},
+        {"norounding", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noRounding; }},
+        {"noshadow", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noShadow; }},
+        {"noshortcutsinhibit", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.noShortcutsInhibit; }},
+        {"opaque", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.opaque; }},
+        {"forcergbx", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.RGBX; }},
+        {"syncfullscreen", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.syncFullscreen; }},
+        {"immediate", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.tearing; }},
+        {"xray", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.xray; }},
     };
 
-    std::unordered_map<std::string, std::function<CWindowOverridableVar<int>*(PHLWINDOW)>> miWindowProperties = {
-        {"rounding", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.rounding; }}, {"bordersize", [](PHLWINDOW pWindow) { return &pWindow->m_sWindowData.borderSize; }}};
+    std::unordered_map<std::string, std::function<CWindowOverridableVar<int>*(const PHLWINDOW&)>> miWindowProperties = {
+        {"rounding", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.rounding; }},
+        {"bordersize", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.borderSize; }},
+    };
 
-    bool m_bWantsMonitorReload = false;
-    bool m_bForceReload        = false;
-    bool m_bNoMonitorReload    = false;
-    bool isLaunchingExecOnce   = false; // For exec-once to skip initial ws tracking
+    std::unordered_map<std::string, std::function<CWindowOverridableVar<float>*(PHLWINDOW)>> mfWindowProperties = {
+        {"roundingpower", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.roundingPower; }},
+        {"scrollmouse", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.scrollMouse; }},
+        {"scrolltouchpad", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.scrollTouchpad; }}};
+
+    bool m_bWantsMonitorReload                  = false;
+    bool m_bNoMonitorReload                     = false;
+    bool isLaunchingExecOnce                    = false; // For exec-once to skip initial ws tracking
+    bool m_bLastConfigVerificationWasSuccessful = true;
 
   private:
-    std::unique_ptr<Hyprlang::CConfig>                        m_pConfig;
+    UP<Hyprlang::CConfig>                            m_pConfig;
 
-    std::deque<std::string>                                   configPaths;       // stores all the config paths
-    std::unordered_map<std::string, time_t>                   configModifyTimes; // stores modify times
+    std::vector<std::string>                         m_configPaths;
 
-    std::unordered_map<std::string, SAnimationPropertyConfig> animationConfig; // stores all the animations with their set values
+    Hyprutils::Animation::CAnimationConfigTree       m_AnimationTree;
 
-    std::string                                               m_szCurrentSubmap = ""; // For storing the current keybind submap
+    std::string                                      m_szCurrentSubmap = ""; // For storing the current keybind submap
 
-    std::vector<SExecRequestedRule>                           execRequestedRules; // rules requested with exec, e.g. [workspace 2] kitty
+    std::vector<SExecRequestedRule>                  execRequestedRules; // rules requested with exec, e.g. [workspace 2] kitty
 
-    std::vector<std::string>                                  m_vDeclaredPlugins;
-    std::vector<SPluginKeyword>                               pluginKeywords;
-    std::vector<SPluginVariable>                              pluginVariables;
+    std::vector<std::string>                         m_vDeclaredPlugins;
+    std::vector<SPluginKeyword>                      pluginKeywords;
+    std::vector<SPluginVariable>                     pluginVariables;
 
-    bool                                                      isFirstLaunch = true; // For exec-once
+    bool                                             isFirstLaunch = true; // For exec-once
 
-    std::deque<SMonitorRule>                                  m_dMonitorRules;
-    std::deque<SWorkspaceRule>                                m_dWorkspaceRules;
-    std::deque<SWindowRule>                                   m_dWindowRules;
-    std::deque<SLayerRule>                                    m_dLayerRules;
-    std::deque<std::string>                                   m_dBlurLSNamespaces;
+    std::vector<SMonitorRule>                        m_vMonitorRules;
+    std::vector<SWorkspaceRule>                      m_vWorkspaceRules;
+    std::vector<SP<CWindowRule>>                     m_vWindowRules;
+    std::vector<SP<CLayerRule>>                      m_vLayerRules;
+    std::vector<std::string>                         m_dBlurLSNamespaces;
 
-    bool                                                      firstExecDispatched     = false;
-    bool                                                      m_bManualCrashInitiated = false;
-    std::deque<std::string>                                   firstExecRequests;
-    std::deque<std::string>                                   finalExecRequests;
+    bool                                             firstExecDispatched     = false;
+    bool                                             m_bManualCrashInitiated = false;
 
-    std::vector<std::pair<std::string, std::string>>          m_vFailedPluginConfigValues; // for plugin values of unloaded plugins
-    std::string                                               m_szConfigErrors = "";
+    std::vector<SFirstExecRequest>                   firstExecRequests; // bool is for if with rules
+    std::vector<std::string>                         finalExecRequests;
+
+    std::vector<std::pair<std::string, std::string>> m_vFailedPluginConfigValues; // for plugin values of unloaded plugins
+    std::string                                      m_szConfigErrors = "";
 
     // internal methods
-    void                              setAnimForChildren(SAnimationPropertyConfig* const);
-    void                              updateBlurredLS(const std::string&, const bool);
-    void                              setDefaultAnimationVars();
-    std::optional<std::string>        resetHLConfig();
-    static std::optional<std::string> generateConfig(std::string configPath);
-    static std::optional<std::string> verifyConfigExists();
-    void                              postConfigReload(const Hyprlang::CParseResult& result);
-    void                              reload();
-    SWorkspaceRule                    mergeWorkspaceRules(const SWorkspaceRule&, const SWorkspaceRule&);
+    void                       updateBlurredLS(const std::string&, const bool);
+    void                       setDefaultAnimationVars();
+    std::optional<std::string> resetHLConfig();
+    std::optional<std::string> generateConfig(std::string configPath);
+    std::optional<std::string> verifyConfigExists();
+    void                       postConfigReload(const Hyprlang::CParseResult& result);
+    SWorkspaceRule             mergeWorkspaceRules(const SWorkspaceRule&, const SWorkspaceRule&);
 };
 
-inline std::unique_ptr<CConfigManager> g_pConfigManager;
+inline UP<CConfigManager> g_pConfigManager;

src/config/ConfigValue.hpp

@@ -3,7 +3,6 @@
 #include <string>
 #include <typeindex>
 #include <hyprlang.hpp>
-#include "../debug/Log.hpp"
 #include "../macros.hpp"
 #include "ConfigManager.hpp"
 
@@ -13,6 +12,7 @@ class CConfigValue {
     CConfigValue(const std::string& val) {
         const auto PVHYPRLANG = g_pConfigManager->getHyprlangConfigValuePtr(val);
 
+        // NOLINTNEXTLINE
         p_ = PVHYPRLANG->getDataStaticPtr();
 
 #ifdef HYPRLAND_DEBUG
@@ -70,4 +70,4 @@ template <>
 inline Hyprlang::CUSTOMTYPE CConfigValue<Hyprlang::CUSTOMTYPE>::operator*() const {
     RASSERT(false, "Impossible to implement operator* of CConfigValue<Hyprlang::CUSTOMTYPE>, use ptr()");
     return *ptr();
-}
+}

src/config/ConfigWatcher.cpp

@@ -0,0 +1,81 @@
+#include "ConfigWatcher.hpp"
+#include <sys/inotify.h>
+#include "../debug/Log.hpp"
+#include <ranges>
+#include <fcntl.h>
+#include <unistd.h>
+#include <filesystem>
+
+using namespace Hyprutils::OS;
+
+CConfigWatcher::CConfigWatcher() : m_inotifyFd(inotify_init()) {
+    if (!m_inotifyFd.isValid()) {
+        Debug::log(ERR, "CConfigWatcher couldn't open an inotify node. Config will not be automatically reloaded");
+        return;
+    }
+
+    // TODO: make CFileDescriptor take F_GETFL, F_SETFL
+    const int FLAGS = fcntl(m_inotifyFd.get(), F_GETFL, 0);
+    if (fcntl(m_inotifyFd.get(), F_SETFL, FLAGS | O_NONBLOCK) < 0) {
+        Debug::log(ERR, "CConfigWatcher couldn't non-block inotify node. Config will not be automatically reloaded");
+        m_inotifyFd.reset();
+        return;
+    }
+}
+
+CFileDescriptor& CConfigWatcher::getInotifyFD() {
+    return m_inotifyFd;
+}
+
+void CConfigWatcher::setWatchList(const std::vector<std::string>& paths) {
+
+    // we clear all watches first, because whichever fired is now invalid
+    // or that is at least what it seems to be.
+    // since we don't know which fired,
+    // plus it doesn't matter that much, these ops are done rarely and fast anyways.
+
+    // cleanup old paths
+    for (auto& watch : m_watches) {
+        inotify_rm_watch(m_inotifyFd.get(), watch.wd);
+    }
+
+    m_watches.clear();
+
+    // add new paths
+    for (const auto& path : paths) {
+        m_watches.emplace_back(SInotifyWatch{
+            .wd   = inotify_add_watch(m_inotifyFd.get(), path.c_str(), IN_MODIFY | IN_DONT_FOLLOW),
+            .file = path,
+        });
+
+        std::error_code ec, ec2;
+        const auto      CANONICAL  = std::filesystem::canonical(path, ec);
+        const auto      IS_SYMLINK = std::filesystem::is_symlink(path, ec2);
+        if (!ec && !ec2 && IS_SYMLINK) {
+            m_watches.emplace_back(SInotifyWatch{
+                .wd   = inotify_add_watch(m_inotifyFd.get(), CANONICAL.c_str(), IN_MODIFY),
+                .file = path,
+            });
+        }
+    }
+}
+
+void CConfigWatcher::setOnChange(const std::function<void(const SConfigWatchEvent&)>& fn) {
+    m_watchCallback = fn;
+}
+
+void CConfigWatcher::onInotifyEvent() {
+    inotify_event ev;
+    while (read(m_inotifyFd.get(), &ev, sizeof(ev)) > 0) {
+        const auto WD = std::ranges::find_if(m_watches.begin(), m_watches.end(), [wd = ev.wd](const auto& e) { return e.wd == wd; });
+
+        if (WD == m_watches.end()) {
+            Debug::log(ERR, "CConfigWatcher: got an event for wd {} which we don't have?!", ev.wd);
+            return;
+        }
+
+        m_watchCallback(SConfigWatchEvent{
+            .file = WD->file,
+        });
+    }
+}

src/config/ConfigWatcher.hpp

@@ -0,0 +1,33 @@
+#pragma once
+#include "../helpers/memory/Memory.hpp"
+#include <vector>
+#include <string>
+#include <functional>
+#include <hyprutils/os/FileDescriptor.hpp>
+
+class CConfigWatcher {
+  public:
+    CConfigWatcher();
+    ~CConfigWatcher() = default;
+
+    struct SConfigWatchEvent {
+        std::string file;
+    };
+
+    Hyprutils::OS::CFileDescriptor& getInotifyFD();
+    void                            setWatchList(const std::vector<std::string>& paths);
+    void                            setOnChange(const std::function<void(const SConfigWatchEvent&)>& fn);
+    void                            onInotifyEvent();
+
+  private:
+    struct SInotifyWatch {
+        int         wd = -1;
+        std::string file;
+    };
+
+    std::function<void(const SConfigWatchEvent&)> m_watchCallback;
+    std::vector<SInotifyWatch>                    m_watches;
+    Hyprutils::OS::CFileDescriptor                m_inotifyFd;
+};
+
+inline UP<CConfigWatcher> g_pConfigWatcher = makeUnique<CConfigWatcher>();

src/config/defaultConfig.hpp

@@ -4,8 +4,8 @@
 
 inline const std::string AUTOCONFIG = R"#(
 # #######################################################################################
-# AUTOGENERATED HYPR CONFIG.
-# PLEASE USE THE CONFIG PROVIDED IN THE GIT REPO /examples/hypr.conf AND EDIT IT,
+# AUTOGENERATED HYPRLAND CONFIG.
+# PLEASE USE THE CONFIG PROVIDED IN THE GIT REPO /examples/hyprland.conf AND EDIT IT,
 # OR EDIT THIS ONE ACCORDING TO THE WIKI INSTRUCTIONS.
 # #######################################################################################
 
@@ -13,7 +13,7 @@ autogenerated = 1 # remove this line to remove the warning
 
 # This is an example Hyprland config file.
 # Refer to the wiki for more information.
-# https://wiki.hyprland.org/Configuring/Configuring-Hyprland/
+# https://wiki.hyprland.org/Configuring/
 
 # Please note not all available settings / options are set here.
 # For a full list, see the wiki
@@ -94,15 +94,18 @@ general {
 # https://wiki.hyprland.org/Configuring/Variables/#decoration
 decoration {
     rounding = 10
+    rounding_power = 2
 
     # Change transparency of focused and unfocused windows
     active_opacity = 1.0
     inactive_opacity = 1.0
 
-    drop_shadow = true
-    shadow_range = 4
-    shadow_render_power = 3
-    col.shadow = rgba(1a1a1aee)
+    shadow {
+        enabled = true
+        range = 4
+        render_power = 3
+        color = rgba(1a1a1aee)
+    }
 
     # https://wiki.hyprland.org/Configuring/Variables/#blur
     blur {
@@ -116,20 +119,44 @@ decoration {
 
 # https://wiki.hyprland.org/Configuring/Variables/#animations
 animations {
-    enabled = true
+    enabled = yes, please :)
 
     # Default animations, see https://wiki.hyprland.org/Configuring/Animations/ for more
 
-    bezier = myBezier, 0.05, 0.9, 0.1, 1.05
+    bezier = easeOutQuint,0.23,1,0.32,1
+    bezier = easeInOutCubic,0.65,0.05,0.36,1
+    bezier = linear,0,0,1,1
+    bezier = almostLinear,0.5,0.5,0.75,1.0
+    bezier = quick,0.15,0,0.1,1
 
-    animation = windows, 1, 7, myBezier
-    animation = windowsOut, 1, 7, default, popin 80%
-    animation = border, 1, 10, default
-    animation = borderangle, 1, 8, default
-    animation = fade, 1, 7, default
-    animation = workspaces, 1, 6, default
+    animation = global, 1, 10, default
+    animation = border, 1, 5.39, easeOutQuint
+    animation = windows, 1, 4.79, easeOutQuint
+    animation = windowsIn, 1, 4.1, easeOutQuint, popin 87%
+    animation = windowsOut, 1, 1.49, linear, popin 87%
+    animation = fadeIn, 1, 1.73, almostLinear
+    animation = fadeOut, 1, 1.46, almostLinear
+    animation = fade, 1, 3.03, quick
+    animation = layers, 1, 3.81, easeOutQuint
+    animation = layersIn, 1, 4, easeOutQuint, fade
+    animation = layersOut, 1, 1.5, linear, fade
+    animation = fadeLayersIn, 1, 1.79, almostLinear
+    animation = fadeLayersOut, 1, 1.39, almostLinear
+    animation = workspaces, 1, 1.94, almostLinear, fade
+    animation = workspacesIn, 1, 1.21, almostLinear, fade
+    animation = workspacesOut, 1, 1.94, almostLinear, fade
 }
 
+# Ref https://wiki.hyprland.org/Configuring/Workspace-Rules/
+# "Smart gaps" / "No gaps when only"
+# uncomment all if you wish to use that.
+# workspace = w[tv1], gapsout:0, gapsin:0
+# workspace = f[1], gapsout:0, gapsin:0
+# windowrulev2 = bordersize 0, floating:0, onworkspace:w[tv1]
+# windowrulev2 = rounding 0, floating:0, onworkspace:w[tv1]
+# windowrulev2 = bordersize 0, floating:0, onworkspace:f[1]
+# windowrulev2 = rounding 0, floating:0, onworkspace:f[1]
+
 # See https://wiki.hyprland.org/Configuring/Dwindle-Layout/ for more
 dwindle {
     pseudotile = true # Master switch for pseudotiling. Enabling is bound to mainMod + P in the keybinds section below
@@ -268,5 +295,9 @@ bindl = , XF86AudioPrev, exec, playerctl previous
 # Example windowrule v2
 # windowrulev2 = float,class:^(kitty)$,title:^(kitty)$
 
-windowrulev2 = suppressevent maximize, class:.* # You'll probably like this.
+# Ignore maximize requests from apps. You'll probably like this.
+windowrulev2 = suppressevent maximize, class:.*
+
+# Fix some dragging issues with XWayland
+windowrulev2 = nofocus,class:^$,title:^$,xwayland:1,floating:1,fullscreen:0,pinned:0
 )#";

src/debug/CrashReporter.cpp

@@ -2,10 +2,11 @@
 #include <fcntl.h>
 #include <sys/utsname.h>
 #include <link.h>
-#include <time.h>
-#include <errno.h>
+#include <ctime>
+#include <cerrno>
 #include <sys/stat.h>
 #include <filesystem>
+#include "../helpers/MiscFunctions.hpp"
 
 #include "../plugins/PluginSystem.hpp"
 #include "../signal-safe.hpp"
@@ -31,10 +32,10 @@ static char const* const MESSAGES[] = {"Sorry, didn't mean to...",
 
 // <random> is not async-signal-safe, fake it with time(NULL) instead
 char const* getRandomMessage() {
-    return MESSAGES[time(NULL) % (sizeof(MESSAGES) / sizeof(MESSAGES[0]))];
+    return MESSAGES[time(nullptr) % (sizeof(MESSAGES) / sizeof(MESSAGES[0]))];
 }
 
-[[noreturn]] inline void exit_with_error(char const* err) {
+[[noreturn]] inline void exitWithError(char const* err) {
     write(STDERR_FILENO, err, strlen(err));
     // perror() is not signal-safe, but we use it here
     // because if the crash-handler already crashed, it can't get any worse.
@@ -42,17 +43,17 @@ char const* getRandomMessage() {
     abort();
 }
 
-void CrashReporter::createAndSaveCrash(int sig) {
-    int reportFd;
+void NCrashReporter::createAndSaveCrash(int sig) {
+    int reportFd = -1;
 
     // We're in the signal handler, so we *only* have stack memory.
     // To save as much stack memory as possible,
     // destroy things as soon as possible.
     {
-        MaxLengthCString<255> reportPath;
+        CMaxLengthCString<255> reportPath;
 
-        const auto            HOME       = sig_getenv("HOME");
-        const auto            CACHE_HOME = sig_getenv("XDG_CACHE_HOME");
+        const auto             HOME       = sigGetenv("HOME");
+        const auto             CACHE_HOME = sigGetenv("XDG_CACHE_HOME");
 
         if (CACHE_HOME && CACHE_HOME[0] != '\0') {
             reportPath += CACHE_HOME;
@@ -61,24 +62,24 @@ void CrashReporter::createAndSaveCrash(int sig) {
             reportPath += HOME;
             reportPath += "/.cache/hyprland";
         } else {
-            exit_with_error("$CACHE_HOME and $HOME not set, nowhere to report crash\n");
+            exitWithError("$CACHE_HOME and $HOME not set, nowhere to report crash\n");
             return;
         }
 
-        int ret = mkdir(reportPath.get_str(), S_IRWXU);
+        int ret = mkdir(reportPath.getStr(), S_IRWXU);
         //__asm__("int $3");
         if (ret < 0 && errno != EEXIST) {
-            exit_with_error("failed to mkdir() crash report directory\n");
+            exitWithError("failed to mkdir() crash report directory\n");
         }
         reportPath += "/hyprlandCrashReport";
-        reportPath.write_num(getpid());
+        reportPath.writeNum(getpid());
         reportPath += ".txt";
 
         {
-            BufFileWriter<64> stderr(2);
+            CBufFileWriter<64> stderr(2);
             stderr += "Hyprland has crashed :( Consult the crash report at ";
             if (!reportPath.boundsExceeded()) {
-                stderr += reportPath.get_str();
+                stderr += reportPath.getStr();
             } else {
                 stderr += "[ERROR: Crash report path does not fit into memory! Check if your $CACHE_HOME/$HOME is too deeply nested. Max 255 characters.]";
             }
@@ -86,12 +87,12 @@ void CrashReporter::createAndSaveCrash(int sig) {
             stderr.flush();
         }
 
-        reportFd = open(reportPath.get_str(), O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
+        reportFd = open(reportPath.getStr(), O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
         if (reportFd < 0) {
-            exit_with_error("Failed to open crash report path for writing");
+            exitWithError("Failed to open crash report path for writing");
         }
     }
-    BufFileWriter<512> finalCrashReport(reportFd);
+    CBufFileWriter<512> finalCrashReport(reportFd);
 
     finalCrashReport += "--------------------------------------------\n   Hyprland Crash Report\n--------------------------------------------\n";
     finalCrashReport += getRandomMessage();
@@ -100,7 +101,7 @@ void CrashReporter::createAndSaveCrash(int sig) {
     finalCrashReport += "Hyprland received signal ";
     finalCrashReport.writeNum(sig);
     finalCrashReport += '(';
-    finalCrashReport += sig_strsignal(sig);
+    finalCrashReport += sigStrsignal(sig);
     finalCrashReport += ")\nVersion: ";
     finalCrashReport += GIT_COMMIT_HASH;
     finalCrashReport += "\nTag: ";
@@ -111,7 +112,7 @@ void CrashReporter::createAndSaveCrash(int sig) {
 #ifdef LEGACY_RENDERER
     finalCrashReport += "legacyrenderer\n";
 #endif
-#ifndef ISDEBUG
+#if ISDEBUG
     finalCrashReport += "debug\n";
 #endif
 #ifdef NO_XWAYLAND
@@ -122,9 +123,9 @@ void CrashReporter::createAndSaveCrash(int sig) {
     if (g_pPluginSystem && g_pPluginSystem->pluginCount() > 0) {
         finalCrashReport += "Hyprland seems to be running with plugins. This crash might not be Hyprland's fault.\nPlugins:\n";
 
-        size_t   count = g_pPluginSystem->pluginCount();
-        CPlugin* plugins[count];
-        g_pPluginSystem->sig_getPlugins(plugins, count);
+        const size_t          count = g_pPluginSystem->pluginCount();
+        std::vector<CPlugin*> plugins(count);
+        g_pPluginSystem->sigGetPlugins(plugins.data(), count);
 
         for (size_t i = 0; i < count; i++) {
             auto p = plugins[i];
@@ -159,9 +160,9 @@ void CrashReporter::createAndSaveCrash(int sig) {
 
     finalCrashReport += "GPU:\n\t";
 #if defined(__DragonFly__) || defined(__FreeBSD__)
-    finalCrashReport.writeCmdOutput("pciconf -lv | fgrep -A4 vga");
+    finalCrashReport.writeCmdOutput("pciconf -lv | grep -F -A4 vga");
 #else
-    finalCrashReport.writeCmdOutput("lspci -vnn | grep VGA");
+    finalCrashReport.writeCmdOutput("lspci -vnn | grep -E '(VGA|Display|3D)'");
 #endif
 
     finalCrashReport += "\n\nos-release:\n";
@@ -241,5 +242,5 @@ void CrashReporter::createAndSaveCrash(int sig) {
 
     finalCrashReport += "\n\nLog tail:\n";
 
-    finalCrashReport += std::string_view(Debug::rollingLog).substr(Debug::rollingLog.find("\n") + 1);
+    finalCrashReport += std::string_view(Debug::rollingLog).substr(Debug::rollingLog.find('\n') + 1);
 }

src/debug/CrashReporter.hpp

@@ -2,6 +2,6 @@
 
 #include "../defines.hpp"
 
-namespace CrashReporter {
+namespace NCrashReporter {
     void createAndSaveCrash(int sig);
 };

src/debug/HyprCtl.hpp

@@ -1,24 +1,26 @@
 #pragma once
 
-#include "../Compositor.hpp"
 #include <fstream>
 #include "../helpers/MiscFunctions.hpp"
+#include "../desktop/Window.hpp"
 #include <functional>
+#include <hyprutils/os/FileDescriptor.hpp>
 
 // exposed for main.cpp
 std::string systemInfoRequest(eHyprCtlOutputFormat format, std::string request);
+std::string versionRequest(eHyprCtlOutputFormat format, std::string request);
 
 class CHyprCtl {
   public:
     CHyprCtl();
     ~CHyprCtl();
 
-    std::string         makeDynamicCall(const std::string& input);
-    SP<SHyprCtlCommand> registerCommand(SHyprCtlCommand cmd);
-    void                unregisterCommand(const SP<SHyprCtlCommand>& cmd);
-    std::string         getReply(std::string);
+    std::string                    makeDynamicCall(const std::string& input);
+    SP<SHyprCtlCommand>            registerCommand(SHyprCtlCommand cmd);
+    void                           unregisterCommand(const SP<SHyprCtlCommand>& cmd);
+    std::string                    getReply(std::string);
 
-    int                 m_iSocketFD = -1;
+    Hyprutils::OS::CFileDescriptor m_iSocketFD;
 
     struct {
         bool all           = false;
@@ -37,4 +39,4 @@ class CHyprCtl {
     std::string                      m_socketPath;
 };
 
-inline std::unique_ptr<CHyprCtl> g_pHyprCtl;
+inline UP<CHyprCtl> g_pHyprCtl;

src/debug/HyprDebugOverlay.cpp

@@ -2,13 +2,21 @@
 #include "HyprDebugOverlay.hpp"
 #include "config/ConfigValue.hpp"
 #include "../Compositor.hpp"
+#include "../render/pass/TexPassElement.hpp"
+#include "../render/Renderer.hpp"
+#include "../managers/AnimationManager.hpp"
 
 CHyprDebugOverlay::CHyprDebugOverlay() {
     m_pTexture = makeShared<CTexture>();
 }
 
-void CHyprMonitorDebugOverlay::renderData(CMonitor* pMonitor, float durationUs) {
-    m_dLastRenderTimes.push_back(durationUs / 1000.f);
+void CHyprMonitorDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs) {
+    static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
+
+    if (!*PDEBUGOVERLAY)
+        return;
+
+    m_dLastRenderTimes.emplace_back(durationUs / 1000.f);
 
     if (m_dLastRenderTimes.size() > (long unsigned int)pMonitor->refreshRate)
         m_dLastRenderTimes.pop_front();
@@ -17,8 +25,13 @@ void CHyprMonitorDebugOverlay::renderData(CMonitor* pMonitor, float durationUs)
         m_pMonitor = pMonitor;
 }
 
-void CHyprMonitorDebugOverlay::renderDataNoOverlay(CMonitor* pMonitor, float durationUs) {
-    m_dLastRenderTimesNoOverlay.push_back(durationUs / 1000.f);
+void CHyprMonitorDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float durationUs) {
+    static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
+
+    if (!*PDEBUGOVERLAY)
+        return;
+
+    m_dLastRenderTimesNoOverlay.emplace_back(durationUs / 1000.f);
 
     if (m_dLastRenderTimesNoOverlay.size() > (long unsigned int)pMonitor->refreshRate)
         m_dLastRenderTimesNoOverlay.pop_front();
@@ -27,8 +40,13 @@ void CHyprMonitorDebugOverlay::renderDataNoOverlay(CMonitor* pMonitor, float dur
         m_pMonitor = pMonitor;
 }
 
-void CHyprMonitorDebugOverlay::frameData(CMonitor* pMonitor) {
-    m_dLastFrametimes.push_back(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - m_tpLastFrame).count() / 1000.f);
+void CHyprMonitorDebugOverlay::frameData(PHLMONITOR pMonitor) {
+    static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
+
+    if (!*PDEBUGOVERLAY)
+        return;
+
+    m_dLastFrametimes.emplace_back(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - m_tpLastFrame).count() / 1000.f);
 
     if (m_dLastFrametimes.size() > (long unsigned int)pMonitor->refreshRate)
         m_dLastFrametimes.pop_front();
@@ -39,7 +57,7 @@ void CHyprMonitorDebugOverlay::frameData(CMonitor* pMonitor) {
         m_pMonitor = pMonitor;
 
     // anim data too
-    const auto PMONITORFORTICKS = g_pHyprRenderer->m_pMostHzMonitor ? g_pHyprRenderer->m_pMostHzMonitor : g_pCompositor->m_pLastMonitor.get();
+    const auto PMONITORFORTICKS = g_pHyprRenderer->m_pMostHzMonitor ? g_pHyprRenderer->m_pMostHzMonitor.lock() : g_pCompositor->m_pLastMonitor.lock();
     if (PMONITORFORTICKS) {
         if (m_dLastAnimationTicks.size() > (long unsigned int)PMONITORFORTICKS->refreshRate)
             m_dLastAnimationTicks.pop_front();
@@ -180,29 +198,44 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
     double posX = 0, posY = 0;
     cairo_get_current_point(cr, &posX, &posY);
 
-    g_pHyprRenderer->damageBox(&m_wbLastDrawnBox);
+    g_pHyprRenderer->damageBox(m_wbLastDrawnBox);
     m_wbLastDrawnBox = {(int)g_pCompositor->m_vMonitors.front()->vecPosition.x + MARGIN_LEFT - 1, (int)g_pCompositor->m_vMonitors.front()->vecPosition.y + offset + MARGIN_TOP - 1,
                         (int)maxTextW + 2, posY - offset - MARGIN_TOP + 2};
-    g_pHyprRenderer->damageBox(&m_wbLastDrawnBox);
+    g_pHyprRenderer->damageBox(m_wbLastDrawnBox);
 
     return posY - offset;
 }
 
-void CHyprDebugOverlay::renderData(CMonitor* pMonitor, float durationUs) {
+void CHyprDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs) {
+    static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
+
+    if (!*PDEBUGOVERLAY)
+        return;
+
     m_mMonitorOverlays[pMonitor].renderData(pMonitor, durationUs);
 }
 
-void CHyprDebugOverlay::renderDataNoOverlay(CMonitor* pMonitor, float durationUs) {
+void CHyprDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float durationUs) {
+    static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
+
+    if (!*PDEBUGOVERLAY)
+        return;
+
     m_mMonitorOverlays[pMonitor].renderDataNoOverlay(pMonitor, durationUs);
 }
 
-void CHyprDebugOverlay::frameData(CMonitor* pMonitor) {
+void CHyprDebugOverlay::frameData(PHLMONITOR pMonitor) {
+    static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
+
+    if (!*PDEBUGOVERLAY)
+        return;
+
     m_mMonitorOverlays[pMonitor].frameData(pMonitor);
 }
 
 void CHyprDebugOverlay::draw() {
 
-    const auto PMONITOR = g_pCompositor->m_vMonitors.front().get();
+    const auto PMONITOR = g_pCompositor->m_vMonitors.front();
 
     if (!m_pCairoSurface || !m_pCairo) {
         m_pCairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
@@ -218,7 +251,7 @@ void CHyprDebugOverlay::draw() {
     // draw the things
     int offsetY = 0;
     for (auto const& m : g_pCompositor->m_vMonitors) {
-        offsetY += m_mMonitorOverlays[m.get()].draw(offsetY);
+        offsetY += m_mMonitorOverlays[m].draw(offsetY);
         offsetY += 5; // for padding between mons
     }
 
@@ -238,6 +271,8 @@ void CHyprDebugOverlay::draw() {
 
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
 
-    CBox pMonBox = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
-    g_pHyprOpenGL->renderTexture(m_pTexture, &pMonBox, 1.f);
+    CTexPassElement::SRenderData data;
+    data.tex = m_pTexture;
+    data.box = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
+    g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
 }

src/debug/HyprDebugOverlay.hpp

@@ -1,11 +1,10 @@
 #pragma once
 
 #include "../defines.hpp"
-#include "../helpers/Monitor.hpp"
 #include "../render/Texture.hpp"
-#include <deque>
 #include <cairo/cairo.h>
-#include <unordered_map>
+#include <map>
+#include <deque>
 
 class CHyprRenderer;
 
@@ -13,9 +12,9 @@ class CHyprMonitorDebugOverlay {
   public:
     int  draw(int offset);
 
-    void renderData(CMonitor* pMonitor, float durationUs);
-    void renderDataNoOverlay(CMonitor* pMonitor, float durationUs);
-    void frameData(CMonitor* pMonitor);
+    void renderData(PHLMONITOR pMonitor, float durationUs);
+    void renderDataNoOverlay(PHLMONITOR pMonitor, float durationUs);
+    void frameData(PHLMONITOR pMonitor);
 
   private:
     std::deque<float>                              m_dLastFrametimes;
@@ -23,7 +22,7 @@ class CHyprMonitorDebugOverlay {
     std::deque<float>                              m_dLastRenderTimesNoOverlay;
     std::deque<float>                              m_dLastAnimationTicks;
     std::chrono::high_resolution_clock::time_point m_tpLastFrame;
-    CMonitor*                                      m_pMonitor = nullptr;
+    PHLMONITORREF                                  m_pMonitor;
     CBox                                           m_wbLastDrawnBox;
 
     friend class CHyprRenderer;
@@ -33,20 +32,20 @@ class CHyprDebugOverlay {
   public:
     CHyprDebugOverlay();
     void draw();
-    void renderData(CMonitor*, float durationUs);
-    void renderDataNoOverlay(CMonitor*, float durationUs);
-    void frameData(CMonitor*);
+    void renderData(PHLMONITOR, float durationUs);
+    void renderDataNoOverlay(PHLMONITOR, float durationUs);
+    void frameData(PHLMONITOR);
 
   private:
-    std::unordered_map<CMonitor*, CHyprMonitorDebugOverlay> m_mMonitorOverlays;
+    std::map<PHLMONITORREF, CHyprMonitorDebugOverlay> m_mMonitorOverlays;
 
-    cairo_surface_t*                                        m_pCairoSurface = nullptr;
-    cairo_t*                                                m_pCairo        = nullptr;
+    cairo_surface_t*                                  m_pCairoSurface = nullptr;
+    cairo_t*                                          m_pCairo        = nullptr;
 
-    SP<CTexture>                                            m_pTexture;
+    SP<CTexture>                                      m_pTexture;
 
     friend class CHyprMonitorDebugOverlay;
     friend class CHyprRenderer;
 };
 
-inline std::unique_ptr<CHyprDebugOverlay> g_pDebugOverlay;
+inline UP<CHyprDebugOverlay> g_pDebugOverlay;

src/debug/HyprNotificationOverlay.cpp

@@ -3,8 +3,13 @@
 #include "HyprNotificationOverlay.hpp"
 #include "../Compositor.hpp"
 #include "../config/ConfigValue.hpp"
+#include "../render/pass/TexPassElement.hpp"
 
-inline auto iconBackendFromLayout(PangoLayout* layout) {
+#include "../managers/AnimationManager.hpp"
+#include "../managers/HookSystemManager.hpp"
+#include "../render/Renderer.hpp"
+
+static inline auto iconBackendFromLayout(PangoLayout* layout) {
     // preference: Nerd > FontAwesome > text
     auto eIconBackendChecks = std::array<eIconBackend, 2>{ICONS_BACKEND_NF, ICONS_BACKEND_FA};
     for (auto iconID : eIconBackendChecks) {
@@ -18,10 +23,10 @@ inline auto iconBackendFromLayout(PangoLayout* layout) {
 
 CHyprNotificationOverlay::CHyprNotificationOverlay() {
     static auto P = g_pHookSystem->hookDynamic("focusedMon", [&](void* self, SCallbackInfo& info, std::any param) {
-        if (m_dNotifications.size() == 0)
+        if (m_vNotifications.size() == 0)
             return;
 
-        g_pHyprRenderer->damageBox(&m_bLastDamage);
+        g_pHyprRenderer->damageBox(m_bLastDamage);
     });
 
     m_pTexture = makeShared<CTexture>();
@@ -34,34 +39,34 @@ CHyprNotificationOverlay::~CHyprNotificationOverlay() {
         cairo_surface_destroy(m_pCairoSurface);
 }
 
-void CHyprNotificationOverlay::addNotification(const std::string& text, const CColor& color, const float timeMs, const eIcons icon, const float fontSize) {
-    const auto PNOTIF = m_dNotifications.emplace_back(std::make_unique<SNotification>()).get();
+void CHyprNotificationOverlay::addNotification(const std::string& text, const CHyprColor& color, const float timeMs, const eIcons icon, const float fontSize) {
+    const auto PNOTIF = m_vNotifications.emplace_back(makeUnique<SNotification>()).get();
 
-    PNOTIF->text  = text;
-    PNOTIF->color = color == CColor(0) ? ICONS_COLORS[icon] : color;
+    PNOTIF->text  = icon != eIcons::ICON_NONE ? " " + text /* tiny bit of padding otherwise icon touches text */ : text;
+    PNOTIF->color = color == CHyprColor(0) ? ICONS_COLORS[icon] : color;
     PNOTIF->started.reset();
     PNOTIF->timeMs   = timeMs;
     PNOTIF->icon     = icon;
     PNOTIF->fontSize = fontSize;
 
     for (auto const& m : g_pCompositor->m_vMonitors) {
-        g_pCompositor->scheduleFrameForMonitor(m.get());
+        g_pCompositor->scheduleFrameForMonitor(m);
     }
 }
 
 void CHyprNotificationOverlay::dismissNotifications(const int amount) {
     if (amount == -1)
-        m_dNotifications.clear();
+        m_vNotifications.clear();
     else {
-        const int AMT = std::min(amount, static_cast<int>(m_dNotifications.size()));
+        const int AMT = std::min(amount, static_cast<int>(m_vNotifications.size()));
 
         for (int i = 0; i < AMT; ++i) {
-            m_dNotifications.pop_front();
+            m_vNotifications.erase(m_vNotifications.begin());
         }
     }
 }
 
-CBox CHyprNotificationOverlay::drawNotifications(CMonitor* pMonitor) {
+CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
     static constexpr auto ANIM_DURATION_MS   = 600.0;
     static constexpr auto ANIM_LAG_MS        = 100.0;
     static constexpr auto NOTIF_LEFTBAR_SIZE = 5.0;
@@ -87,7 +92,7 @@ CBox CHyprNotificationOverlay::drawNotifications(CMonitor* pMonitor) {
     const auto iconBackendID = iconBackendFromLayout(layout);
     const auto PBEZIER       = g_pAnimationManager->getBezier("default");
 
-    for (auto const& notif : m_dNotifications) {
+    for (auto const& notif : m_vNotifications) {
         const auto ICONPADFORNOTIF = notif->icon == ICON_NONE ? 0 : ICON_PAD;
         const auto FONTSIZE        = std::clamp((int)(notif->fontSize * ((pMonitor->vecPixelSize.x * SCALE) / 1920.f)), 8, 40);
 
@@ -182,12 +187,12 @@ CBox CHyprNotificationOverlay::drawNotifications(CMonitor* pMonitor) {
     g_object_unref(layout);
 
     // cleanup notifs
-    std::erase_if(m_dNotifications, [](const auto& notif) { return notif->started.getMillis() > notif->timeMs; });
+    std::erase_if(m_vNotifications, [](const auto& notif) { return notif->started.getMillis() > notif->timeMs; });
 
     return CBox{(int)(pMonitor->vecPosition.x + pMonitor->vecSize.x - maxWidth - 20), (int)pMonitor->vecPosition.y, (int)maxWidth + 20, (int)offsetY + 10};
 }
 
-void CHyprNotificationOverlay::draw(CMonitor* pMonitor) {
+void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) {
 
     const auto MONSIZE = pMonitor->vecTransformedSize;
 
@@ -205,7 +210,7 @@ void CHyprNotificationOverlay::draw(CMonitor* pMonitor) {
     }
 
     // Draw the notifications
-    if (m_dNotifications.size() == 0)
+    if (m_vNotifications.size() == 0)
         return;
 
     // Render to the monitor
@@ -220,8 +225,8 @@ void CHyprNotificationOverlay::draw(CMonitor* pMonitor) {
 
     CBox damage = drawNotifications(pMonitor);
 
-    g_pHyprRenderer->damageBox(&damage);
-    g_pHyprRenderer->damageBox(&m_bLastDamage);
+    g_pHyprRenderer->damageBox(damage);
+    g_pHyprRenderer->damageBox(m_bLastDamage);
 
     g_pCompositor->scheduleFrameForMonitor(pMonitor);
 
@@ -241,10 +246,14 @@ void CHyprNotificationOverlay::draw(CMonitor* pMonitor) {
 
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, MONSIZE.x, MONSIZE.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
 
-    CBox pMonBox = {0, 0, MONSIZE.x, MONSIZE.y};
-    g_pHyprOpenGL->renderTexture(m_pTexture, &pMonBox, 1.f);
+    CTexPassElement::SRenderData data;
+    data.tex = m_pTexture;
+    data.box = {0, 0, MONSIZE.x, MONSIZE.y};
+    data.a   = 1.F;
+
+    g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
 }
 
 bool CHyprNotificationOverlay::hasAny() {
-    return !m_dNotifications.empty();
+    return !m_vNotifications.empty();
 }

src/debug/HyprNotificationOverlay.hpp

@@ -2,15 +2,14 @@
 
 #include "../defines.hpp"
 #include "../helpers/Timer.hpp"
-#include "../helpers/Monitor.hpp"
 #include "../render/Texture.hpp"
 #include "../SharedDefs.hpp"
 
-#include <deque>
+#include <vector>
 
 #include <cairo/cairo.h>
 
-enum eIconBackend {
+enum eIconBackend : uint8_t {
     ICONS_BACKEND_NONE = 0,
     ICONS_BACKEND_NF,
     ICONS_BACKEND_FA
@@ -19,17 +18,17 @@ enum eIconBackend {
 static const std::array<std::array<std::string, ICON_NONE + 1>, 3 /* backends */> ICONS_ARRAY = {
     std::array<std::string, ICON_NONE + 1>{"[!]", "[i]", "[Hint]", "[Err]", "[?]", "[ok]", ""},
     std::array<std::string, ICON_NONE + 1>{"", "", "", "", "", "󰸞", ""}, std::array<std::string, ICON_NONE + 1>{"", "", "", "", "", ""}};
-static const std::array<CColor, ICON_NONE + 1> ICONS_COLORS = {CColor{255.0 / 255.0, 204 / 255.0, 102 / 255.0, 1.0},
-                                                               CColor{128 / 255.0, 255 / 255.0, 255 / 255.0, 1.0},
-                                                               CColor{179 / 255.0, 255 / 255.0, 204 / 255.0, 1.0},
-                                                               CColor{255 / 255.0, 77 / 255.0, 77 / 255.0, 1.0},
-                                                               CColor{255 / 255.0, 204 / 255.0, 153 / 255.0, 1.0},
-                                                               CColor{128 / 255.0, 255 / 255.0, 128 / 255.0, 1.0},
-                                                               CColor{0, 0, 0, 1.0}};
+static const std::array<CHyprColor, ICON_NONE + 1> ICONS_COLORS = {CHyprColor{255.0 / 255.0, 204 / 255.0, 102 / 255.0, 1.0},
+                                                                   CHyprColor{128 / 255.0, 255 / 255.0, 255 / 255.0, 1.0},
+                                                                   CHyprColor{179 / 255.0, 255 / 255.0, 204 / 255.0, 1.0},
+                                                                   CHyprColor{255 / 255.0, 77 / 255.0, 77 / 255.0, 1.0},
+                                                                   CHyprColor{255 / 255.0, 204 / 255.0, 153 / 255.0, 1.0},
+                                                                   CHyprColor{128 / 255.0, 255 / 255.0, 128 / 255.0, 1.0},
+                                                                   CHyprColor{0, 0, 0, 1.0}};
 
 struct SNotification {
     std::string text = "";
-    CColor      color;
+    CHyprColor  color;
     CTimer      started;
     float       timeMs   = 0;
     eIcons      icon     = ICON_NONE;
@@ -41,24 +40,24 @@ class CHyprNotificationOverlay {
     CHyprNotificationOverlay();
     ~CHyprNotificationOverlay();
 
-    void draw(CMonitor* pMonitor);
-    void addNotification(const std::string& text, const CColor& color, const float timeMs, const eIcons icon = ICON_NONE, const float fontSize = 13.f);
+    void draw(PHLMONITOR pMonitor);
+    void addNotification(const std::string& text, const CHyprColor& color, const float timeMs, const eIcons icon = ICON_NONE, const float fontSize = 13.f);
     void dismissNotifications(const int amount);
     bool hasAny();
 
   private:
-    CBox                                       drawNotifications(CMonitor* pMonitor);
-    CBox                                       m_bLastDamage;
+    CBox                           drawNotifications(PHLMONITOR pMonitor);
+    CBox                           m_bLastDamage;
 
-    std::deque<std::unique_ptr<SNotification>> m_dNotifications;
+    std::vector<UP<SNotification>> m_vNotifications;
 
-    cairo_surface_t*                           m_pCairoSurface = nullptr;
-    cairo_t*                                   m_pCairo        = nullptr;
+    cairo_surface_t*               m_pCairoSurface = nullptr;
+    cairo_t*                       m_pCairo        = nullptr;
 
-    CMonitor*                                  m_pLastMonitor = nullptr;
-    Vector2D                                   m_vecLastSize  = Vector2D(-1, -1);
+    PHLMONITORREF                  m_pLastMonitor;
+    Vector2D                       m_vecLastSize = Vector2D(-1, -1);
 
-    SP<CTexture>                               m_pTexture;
+    SP<CTexture>                   m_pTexture;
 };
 
-inline std::unique_ptr<CHyprNotificationOverlay> g_pHyprNotificationOverlay;
+inline UP<CHyprNotificationOverlay> g_pHyprNotificationOverlay;

src/debug/Log.cpp

@@ -1,10 +1,9 @@
 #include "Log.hpp"
 #include "../defines.hpp"
-#include "../Compositor.hpp"
 #include "RollingLogFollow.hpp"
 
 #include <fstream>
-#include <iostream>
+#include <print>
 #include <fcntl.h>
 
 void Debug::init(const std::string& IS) {
@@ -18,7 +17,7 @@ void Debug::close() {
     logOfs.close();
 }
 
-void Debug::log(LogLevel level, std::string str) {
+void Debug::log(eLogLevel level, std::string str) {
     if (level == TRACE && !trace)
         return;
 
@@ -26,6 +25,7 @@ void Debug::log(LogLevel level, std::string str) {
         return;
 
     std::string coloredStr = str;
+    //NOLINTBEGIN
     switch (level) {
         case LOG:
             str        = "[LOG] " + str;
@@ -53,13 +53,14 @@ void Debug::log(LogLevel level, std::string str) {
             break;
         default: break;
     }
+    //NOLINTEND
 
     rollingLog += str + "\n";
     if (rollingLog.size() > ROLLING_LOG_SIZE)
         rollingLog = rollingLog.substr(rollingLog.size() - ROLLING_LOG_SIZE);
 
-    if (RollingLogFollow::Get().IsRunning())
-        RollingLogFollow::Get().AddLog(str);
+    if (SRollingLogFollow::get().isRunning())
+        SRollingLogFollow::get().addLog(str);
 
     if (!disableLogs || !**disableLogs) {
         // log to a file
@@ -69,5 +70,5 @@ void Debug::log(LogLevel level, std::string str) {
 
     // log it to the stdout too.
     if (!disableStdout)
-        std::cout << ((coloredLogs && !**coloredLogs) ? str : coloredStr) << "\n";
+        std::println("{}", ((coloredLogs && !**coloredLogs) ? str : coloredStr));
 }

src/debug/Log.hpp

@@ -5,13 +5,11 @@
 #include <fstream>
 #include <chrono>
 #include <mutex>
-#include "../includes.hpp"
-#include "../helpers/MiscFunctions.hpp"
 
 #define LOGMESSAGESIZE   1024
 #define ROLLING_LOG_SIZE 4096
 
-enum LogLevel {
+enum eLogLevel : int8_t {
     NONE = -1,
     LOG  = 0,
     WARN,
@@ -21,6 +19,7 @@ enum LogLevel {
     TRACE
 };
 
+// NOLINTNEXTLINE(readability-identifier-naming)
 namespace Debug {
     inline std::string     logFile;
     inline std::ofstream   logOfs;
@@ -38,10 +37,11 @@ namespace Debug {
     void                   close();
 
     //
-    void log(LogLevel level, std::string str);
+    void log(eLogLevel level, std::string str);
 
     template <typename... Args>
-    void log(LogLevel level, std::format_string<Args...> fmt, Args&&... args) {
+    //NOLINTNEXTLINE
+    void log(eLogLevel level, std::format_string<Args...> fmt, Args&&... args) {
         std::lock_guard<std::mutex> guard(logMutex);
 
         if (level == TRACE && !trace)

src/debug/RollingLogFollow.hpp

@@ -2,8 +2,9 @@
 
 #include <shared_mutex>
 
+// NOLINTNEXTLINE(readability-identifier-naming)
 namespace Debug {
-    struct RollingLogFollow {
+    struct SRollingLogFollow {
         std::unordered_map<int, std::string> socketToRollingLogFollowQueue;
         std::shared_mutex                    m;
         bool                                 running                    = false;
@@ -15,12 +16,12 @@ namespace Debug {
             return socketToRollingLogFollowQueue[socket].empty();
         }
 
-        std::string DebugInfo() {
+        std::string debugInfo() {
             std::shared_lock<std::shared_mutex> r(m);
             return std::format("RollingLogFollow, got {} connections", socketToRollingLogFollowQueue.size());
         }
 
-        std::string GetLog(int socket) {
+        std::string getLog(int socket) {
             std::unique_lock<std::shared_mutex> w(m);
 
             const std::string                   ret = socketToRollingLogFollowQueue[socket];
@@ -29,7 +30,7 @@ namespace Debug {
             return ret;
         };
 
-        void AddLog(std::string log) {
+        void addLog(const std::string& log) {
             std::unique_lock<std::shared_mutex> w(m);
             running = true;
             std::vector<int> to_erase;
@@ -37,26 +38,26 @@ namespace Debug {
                 socketToRollingLogFollowQueue[p.first] += log + "\n";
         }
 
-        bool IsRunning() {
+        bool isRunning() {
             std::shared_lock<std::shared_mutex> r(m);
             return running;
         }
 
-        void StopFor(int socket) {
+        void stopFor(int socket) {
             std::unique_lock<std::shared_mutex> w(m);
             socketToRollingLogFollowQueue.erase(socket);
             if (socketToRollingLogFollowQueue.empty())
                 running = false;
         }
 
-        void StartFor(int socket) {
+        void startFor(int socket) {
             std::unique_lock<std::shared_mutex> w(m);
             socketToRollingLogFollowQueue[socket] = std::format("[LOG] Following log to socket: {} started\n", socket);
             running                               = true;
         }
 
-        static RollingLogFollow& Get() {
-            static RollingLogFollow     instance;
+        static SRollingLogFollow& get() {
+            static SRollingLogFollow    instance;
             static std::mutex           gm;
             std::lock_guard<std::mutex> lock(gm);
             return instance;

src/defines.hpp

@@ -1,3 +1,5 @@
+#pragma once
+
 #include "includes.hpp"
 #include "debug/Log.hpp"
 #include "helpers/Color.hpp"

src/desktop/DesktopTypes.hpp

@@ -1,8 +1,9 @@
 #pragma once
-#include "../macros.hpp"
+#include "../helpers/memory/Memory.hpp"
 class CWorkspace;
 class CWindow;
 class CLayerSurface;
+class CMonitor;
 
 /* Shared pointer to a workspace */
 typedef SP<CWorkspace> PHLWORKSPACE;
@@ -18,3 +19,8 @@ typedef WP<CWindow> PHLWINDOWREF;
 typedef SP<CLayerSurface> PHLLS;
 /* Weak pointer to a layer surface */
 typedef WP<CLayerSurface> PHLLSREF;
+
+/* Shared pointer to a monitor */
+typedef SP<CMonitor> PHLMONITOR;
+/* Weak pointer to a monitor */
+typedef WP<CMonitor> PHLMONITORREF;

src/desktop/LayerRule.cpp

@@ -0,0 +1,38 @@
+#include <re2/re2.h>
+#include "LayerRule.hpp"
+#include <unordered_set>
+#include <algorithm>
+#include "../debug/Log.hpp"
+
+static const auto RULES        = std::unordered_set<std::string>{"noanim", "blur", "blurpopups", "dimaround"};
+static const auto RULES_PREFIX = std::unordered_set<std::string>{"ignorealpha", "ignorezero", "xray", "animation", "order"};
+
+CLayerRule::CLayerRule(const std::string& rule_, const std::string& ns_) : targetNamespace(ns_), rule(rule_) {
+    const bool VALID = RULES.contains(rule) || std::any_of(RULES_PREFIX.begin(), RULES_PREFIX.end(), [&rule_](const auto& prefix) { return rule_.starts_with(prefix); });
+
+    if (!VALID)
+        return;
+
+    if (rule == "noanim")
+        ruleType = RULE_NOANIM;
+    else if (rule == "blur")
+        ruleType = RULE_BLUR;
+    else if (rule == "blurpopups")
+        ruleType = RULE_BLURPOPUPS;
+    else if (rule == "dimaround")
+        ruleType = RULE_DIMAROUND;
+    else if (rule.starts_with("ignorealpha"))
+        ruleType = RULE_IGNOREALPHA;
+    else if (rule.starts_with("ignorezero"))
+        ruleType = RULE_IGNOREZERO;
+    else if (rule.starts_with("xray"))
+        ruleType = RULE_XRAY;
+    else if (rule.starts_with("animation"))
+        ruleType = RULE_ANIMATION;
+    else if (rule.starts_with("order"))
+        ruleType = RULE_ORDER;
+    else {
+        Debug::log(ERR, "CLayerRule: didn't match a rule that was found valid?!");
+        ruleType = RULE_INVALID;
+    }
+}

src/desktop/LayerRule.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <string>
+#include <cstdint>
+#include "Rule.hpp"
+
+class CLayerRule {
+  public:
+    CLayerRule(const std::string& rule, const std::string& targetNS);
+
+    enum eRuleType : uint8_t {
+        RULE_INVALID = 0,
+        RULE_NOANIM,
+        RULE_BLUR,
+        RULE_BLURPOPUPS,
+        RULE_DIMAROUND,
+        RULE_IGNOREALPHA,
+        RULE_IGNOREZERO,
+        RULE_XRAY,
+        RULE_ANIMATION,
+        RULE_ORDER,
+        RULE_ZUMBA,
+    };
+
+    eRuleType           ruleType = RULE_INVALID;
+
+    const std::string   targetNamespace;
+    const std::string   rule;
+
+    CRuleRegexContainer targetNamespaceRegex;
+};

src/desktop/LayerSurface.cpp

@@ -4,11 +4,18 @@
 #include "../protocols/LayerShell.hpp"
 #include "../protocols/core/Compositor.hpp"
 #include "../managers/SeatManager.hpp"
+#include "../managers/AnimationManager.hpp"
+#include "../render/Renderer.hpp"
+#include "../config/ConfigManager.hpp"
+#include "../helpers/Monitor.hpp"
+#include "../managers/input/InputManager.hpp"
+#include "../managers/HookSystemManager.hpp"
+#include "../managers/EventManager.hpp"
 
 PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
-    PHLLS     pLS = SP<CLayerSurface>(new CLayerSurface(resource));
+    PHLLS pLS = SP<CLayerSurface>(new CLayerSurface(resource));
 
-    CMonitor* pMonitor = resource->monitor.empty() ? g_pCompositor->getMonitorFromCursor() : g_pCompositor->getMonitorFromName(resource->monitor);
+    auto  pMonitor = resource->monitor.empty() ? g_pCompositor->m_pLastMonitor.lock() : g_pCompositor->getMonitorFromName(resource->monitor);
 
     pLS->surface->assign(resource->surface.lock(), pLS);
 
@@ -18,29 +25,27 @@ PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
     }
 
     if (pMonitor->pMirrorOf)
-        pMonitor = g_pCompositor->m_vMonitors.front().get();
+        pMonitor = g_pCompositor->m_vMonitors.front();
 
     pLS->self = pLS;
 
     pLS->szNamespace = resource->layerNamespace;
 
-    pLS->layer     = resource->current.layer;
-    pLS->popupHead = std::make_unique<CPopup>(pLS);
-    pLS->monitorID = pMonitor->ID;
+    pLS->layer              = resource->current.layer;
+    pLS->popupHead          = makeUnique<CPopup>(pLS);
+    pLS->popupHead->m_pSelf = pLS->popupHead;
+    pLS->monitor            = pMonitor;
     pMonitor->m_aLayerSurfaceLayers[resource->current.layer].emplace_back(pLS);
 
     pLS->forceBlur = g_pConfigManager->shouldBlurLS(pLS->szNamespace);
 
-    pLS->alpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn"), pLS, AVARDAMAGE_ENTIRE);
-    pLS->realPosition.create(g_pConfigManager->getAnimationPropertyConfig("layersIn"), pLS, AVARDAMAGE_ENTIRE);
-    pLS->realSize.create(g_pConfigManager->getAnimationPropertyConfig("layersIn"), pLS, AVARDAMAGE_ENTIRE);
-    pLS->alpha.registerVar();
-    pLS->realPosition.registerVar();
-    pLS->realSize.registerVar();
+    g_pAnimationManager->createAnimation(0.f, pLS->alpha, g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn"), pLS, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(Vector2D(0, 0), pLS->realPosition, g_pConfigManager->getAnimationPropertyConfig("layersIn"), pLS, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(Vector2D(0, 0), pLS->realSize, g_pConfigManager->getAnimationPropertyConfig("layersIn"), pLS, AVARDAMAGE_ENTIRE);
 
     pLS->registerCallbacks();
 
-    pLS->alpha.setValueAndWarp(0.f);
+    pLS->alpha->setValueAndWarp(0.f);
 
     Debug::log(LOG, "LayerSurface {:x} (namespace {} layer {}) created on monitor {}", (uintptr_t)resource.get(), resource->layerNamespace, (int)pLS->layer, pMonitor->szName);
 
@@ -48,9 +53,9 @@ PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
 }
 
 void CLayerSurface::registerCallbacks() {
-    alpha.setUpdateCallback([this](void*) {
+    alpha->setUpdateCallback([this](auto) {
         if (dimAround)
-            g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(monitorID));
+            g_pHyprRenderer->damageMonitor(monitor.lock());
     });
 }
 
@@ -82,9 +87,9 @@ CLayerSurface::~CLayerSurface() {
 void CLayerSurface::onDestroy() {
     Debug::log(LOG, "LayerSurface {:x} destroyed", (uintptr_t)layerSurface.get());
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(monitorID);
+    const auto PMONITOR = monitor.lock();
 
-    if (!g_pCompositor->getMonitorFromID(monitorID))
+    if (!PMONITOR)
         Debug::log(WARN, "Layersurface destroyed on an invalid monitor (removed?)");
 
     if (!fadingOut) {
@@ -93,7 +98,7 @@ void CLayerSurface::onDestroy() {
             onUnmap();
         } else {
             Debug::log(LOG, "Removing LayerSurface that wasn't mapped.");
-            alpha.setValueAndWarp(0.f);
+            alpha->setValueAndWarp(0.f);
             fadingOut = true;
             g_pCompositor->addToFadingOutSafe(self.lock());
         }
@@ -110,7 +115,7 @@ void CLayerSurface::onDestroy() {
 
         // and damage
         CBox geomFixed = {geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y, geometry.width, geometry.height};
-        g_pHyprRenderer->damageBox(&geomFixed);
+        g_pHyprRenderer->damageBox(geomFixed);
     }
 
     readyToDelete = true;
@@ -137,7 +142,7 @@ void CLayerSurface::onMap() {
     g_pCompositor->removeFromFadingOutSafe(self.lock());
 
     // fix if it changed its mon
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(monitorID);
+    const auto PMONITOR = monitor.lock();
 
     if (!PMONITOR)
         return;
@@ -174,9 +179,8 @@ void CLayerSurface::onMap() {
     position = Vector2D(geometry.x, geometry.y);
 
     CBox geomFixed = {geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y, geometry.width, geometry.height};
-    g_pHyprRenderer->damageBox(&geomFixed);
-    const auto WORKSPACE  = PMONITOR->activeWorkspace;
-    const bool FULLSCREEN = WORKSPACE->m_bHasFullscreenWindow && WORKSPACE->m_efFullscreenMode == FSMODE_FULLSCREEN;
+    g_pHyprRenderer->damageBox(geomFixed);
+    const bool FULLSCREEN = PMONITOR->activeWorkspace && PMONITOR->activeWorkspace->m_bHasFullscreenWindow && PMONITOR->activeWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN;
 
     startAnimation(!(layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP && FULLSCREEN && !GRABSFOCUS));
     readyToDelete = false;
@@ -197,7 +201,7 @@ void CLayerSurface::onUnmap() {
 
     std::erase_if(g_pInputManager->m_dExclusiveLSes, [this](const auto& other) { return !other.lock() || other.lock() == self.lock(); });
 
-    if (!g_pCompositor->getMonitorFromID(monitorID) || g_pCompositor->m_bUnsafeState) {
+    if (!monitor || g_pCompositor->m_bUnsafeState) {
         Debug::log(WARN, "Layersurface unmapping on invalid monitor (removed?) ignoring.");
 
         g_pCompositor->addToFadingOutSafe(self.lock());
@@ -211,7 +215,7 @@ void CLayerSurface::onUnmap() {
     }
 
     // make a snapshot and start fade
-    g_pHyprOpenGL->makeLayerSnapshot(self.lock());
+    g_pHyprRenderer->makeLayerSnapshot(self.lock());
 
     startAnimation(false);
 
@@ -221,9 +225,9 @@ void CLayerSurface::onUnmap() {
 
     g_pCompositor->addToFadingOutSafe(self.lock());
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(monitorID);
+    const auto PMONITOR = monitor.lock();
 
-    const bool WASLASTFOCUS = g_pCompositor->m_pLastFocus == surface->resource();
+    const bool WASLASTFOCUS = g_pSeatManager->state.keyboardFocus == surface->resource() || g_pSeatManager->state.pointerFocus == surface->resource();
 
     if (!PMONITOR)
         return;
@@ -232,17 +236,17 @@ void CLayerSurface::onUnmap() {
     //                                vvvvvvvvvvvvv if there is a last focus and the last focus is not keyboard focusable, fallback to window
     if (WASLASTFOCUS || (g_pCompositor->m_pLastFocus && g_pCompositor->m_pLastFocus->hlSurface && !g_pCompositor->m_pLastFocus->hlSurface->keyboardFocusable()))
         g_pInputManager->refocusLastWindow(PMONITOR);
-    else if (g_pCompositor->m_pLastFocus)
+    else if (g_pCompositor->m_pLastFocus && g_pCompositor->m_pLastFocus != surface->resource())
         g_pSeatManager->setKeyboardFocus(g_pCompositor->m_pLastFocus.lock());
 
     CBox geomFixed = {geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y, geometry.width, geometry.height};
-    g_pHyprRenderer->damageBox(&geomFixed);
+    g_pHyprRenderer->damageBox(geomFixed);
 
     geomFixed = {geometry.x + (int)PMONITOR->vecPosition.x, geometry.y + (int)PMONITOR->vecPosition.y, (int)layerSurface->surface->current.size.x,
                  (int)layerSurface->surface->current.size.y};
-    g_pHyprRenderer->damageBox(&geomFixed);
+    g_pHyprRenderer->damageBox(geomFixed);
 
-    g_pInputManager->sendMotionEventsToFocused();
+    g_pInputManager->simulateMouseMovement();
 
     g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
 }
@@ -256,13 +260,13 @@ void CLayerSurface::onCommit() {
         if (layerSurface->surface && !layerSurface->surface->current.texture) {
             fadingOut = false;
             geometry  = {};
-            g_pHyprRenderer->arrangeLayersForMonitor(monitorID);
+            g_pHyprRenderer->arrangeLayersForMonitor(monitorID());
         }
 
         return;
     }
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(monitorID);
+    const auto PMONITOR = monitor.lock();
 
     if (!PMONITOR)
         return;
@@ -271,7 +275,7 @@ void CLayerSurface::onCommit() {
         g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR); // so that blur is recalc'd
 
     CBox geomFixed = {geometry.x, geometry.y, geometry.width, geometry.height};
-    g_pHyprRenderer->damageBox(&geomFixed);
+    g_pHyprRenderer->damageBox(geomFixed);
 
     if (layerSurface->current.committed != 0) {
         if (layerSurface->current.committed & CLayerShellResource::eCommittedState::STATE_LAYER) {
@@ -308,21 +312,31 @@ void CLayerSurface::onCommit() {
         }
     }
 
-    if (realPosition.goal() != geometry.pos()) {
-        if (realPosition.isBeingAnimated())
-            realPosition = geometry.pos();
+    if (realPosition->goal() != geometry.pos()) {
+        if (realPosition->isBeingAnimated())
+            *realPosition = geometry.pos();
         else
-            realPosition.setValueAndWarp(geometry.pos());
+            realPosition->setValueAndWarp(geometry.pos());
     }
-    if (realSize.goal() != geometry.size()) {
-        if (realSize.isBeingAnimated())
-            realSize = geometry.size();
+    if (realSize->goal() != geometry.size()) {
+        if (realSize->isBeingAnimated())
+            *realSize = geometry.size();
         else
-            realSize.setValueAndWarp(geometry.size());
+            realSize->setValueAndWarp(geometry.size());
     }
 
-    if (mapped) {
-        const bool WASLASTFOCUS = g_pCompositor->m_pLastFocus == surface->resource();
+    if (mapped && (layerSurface->current.committed & CLayerShellResource::eCommittedState::STATE_INTERACTIVITY)) {
+        bool WASLASTFOCUS = false;
+        layerSurface->surface->breadthfirst(
+            [&WASLASTFOCUS](SP<CWLSurfaceResource> surf, const Vector2D& offset, void* data) { WASLASTFOCUS = WASLASTFOCUS || g_pSeatManager->state.keyboardFocus == surf; },
+            nullptr);
+        if (!WASLASTFOCUS && popupHead) {
+            popupHead->breadthfirst(
+                [&WASLASTFOCUS](WP<CPopup> popup, void* data) {
+                    WASLASTFOCUS = WASLASTFOCUS || (popup->m_pWLSurface && g_pSeatManager->state.keyboardFocus == popup->m_pWLSurface->resource());
+                },
+                nullptr);
+        }
         const bool WASEXCLUSIVE = interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE;
         const bool ISEXCLUSIVE  = layerSurface->current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE;
 
@@ -332,11 +346,13 @@ void CLayerSurface::onCommit() {
             std::erase_if(g_pInputManager->m_dExclusiveLSes, [this](const auto& other) { return !other.lock() || other.lock() == self.lock(); });
 
         // if the surface was focused and interactive but now isn't, refocus
-        if (WASLASTFOCUS && !layerSurface->current.interactivity) {
+        if (WASLASTFOCUS && layerSurface->current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE) {
             // moveMouseUnified won't focus non interactive layers but it won't unfocus them either,
             // so unfocus the surface here.
             g_pCompositor->focusSurface(nullptr);
-            g_pInputManager->refocusLastWindow(g_pCompositor->getMonitorFromID(monitorID));
+            g_pInputManager->refocusLastWindow(monitor.lock());
+        } else if (WASLASTFOCUS && WASEXCLUSIVE && layerSurface->current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND) {
+            g_pInputManager->simulateMouseMovement();
         } else if (!WASEXCLUSIVE && ISEXCLUSIVE) {
             // if now exclusive and not previously
             g_pSeatManager->setGrab(nullptr);
@@ -367,54 +383,73 @@ void CLayerSurface::applyRules() {
     animationStyle.reset();
 
     for (auto const& rule : g_pConfigManager->getMatchingRules(self.lock())) {
-        if (rule.rule == "noanim")
-            noAnimations = true;
-        else if (rule.rule == "blur")
-            forceBlur = true;
-        else if (rule.rule == "blurpopups")
-            forceBlurPopups = true;
-        else if (rule.rule.starts_with("ignorealpha") || rule.rule.starts_with("ignorezero")) {
-            const auto  FIRST_SPACE_POS = rule.rule.find_first_of(' ');
-            std::string alphaValue      = "";
-            if (FIRST_SPACE_POS != std::string::npos)
-                alphaValue = rule.rule.substr(FIRST_SPACE_POS + 1);
+        switch (rule->ruleType) {
+            case CLayerRule::RULE_NOANIM: {
+                noAnimations = true;
+                break;
+            }
+            case CLayerRule::RULE_BLUR: {
+                forceBlur = true;
+                break;
+            }
+            case CLayerRule::RULE_BLURPOPUPS: {
+                forceBlurPopups = true;
+                break;
+            }
+            case CLayerRule::RULE_IGNOREALPHA:
+            case CLayerRule::RULE_IGNOREZERO: {
+                const auto  FIRST_SPACE_POS = rule->rule.find_first_of(' ');
+                std::string alphaValue      = "";
+                if (FIRST_SPACE_POS != std::string::npos)
+                    alphaValue = rule->rule.substr(FIRST_SPACE_POS + 1);
 
-            try {
-                ignoreAlpha = true;
-                if (!alphaValue.empty())
-                    ignoreAlphaValue = std::stof(alphaValue);
-            } catch (...) { Debug::log(ERR, "Invalid value passed to ignoreAlpha"); }
-        } else if (rule.rule == "dimaround") {
-            dimAround = true;
-        } else if (rule.rule.starts_with("xray")) {
-            CVarList vars{rule.rule, 0, ' '};
-            try {
-                xray = configStringToInt(vars[1]);
-            } catch (...) {}
-        } else if (rule.rule.starts_with("animation")) {
-            CVarList vars{rule.rule, 2, 's'};
-            animationStyle = vars[1];
-        } else if (rule.rule.starts_with("order")) {
-            CVarList vars{rule.rule, 2, 's'};
-            try {
-                order = std::stoi(vars[1]);
-            } catch (...) { Debug::log(ERR, "Invalid value passed to order"); }
+                try {
+                    ignoreAlpha = true;
+                    if (!alphaValue.empty())
+                        ignoreAlphaValue = std::stof(alphaValue);
+                } catch (...) { Debug::log(ERR, "Invalid value passed to ignoreAlpha"); }
+                break;
+            }
+            case CLayerRule::RULE_DIMAROUND: {
+                dimAround = true;
+                break;
+            }
+            case CLayerRule::RULE_XRAY: {
+                CVarList vars{rule->rule, 0, ' '};
+                try {
+                    xray = configStringToInt(vars[1]).value_or(false);
+                } catch (...) {}
+                break;
+            }
+            case CLayerRule::RULE_ANIMATION: {
+                CVarList vars{rule->rule, 2, 's'};
+                animationStyle = vars[1];
+                break;
+            }
+            case CLayerRule::RULE_ORDER: {
+                CVarList vars{rule->rule, 2, 's'};
+                try {
+                    order = std::stoi(vars[1]);
+                } catch (...) { Debug::log(ERR, "Invalid value passed to order"); }
+                break;
+            }
+            default: break;
         }
     }
 }
 
 void CLayerSurface::startAnimation(bool in, bool instant) {
-    const auto ANIMSTYLE = animationStyle.value_or(realPosition.m_pConfig->pValues->internalStyle);
     if (in) {
-        realPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("layersIn");
-        realSize.m_pConfig     = g_pConfigManager->getAnimationPropertyConfig("layersIn");
-        alpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn");
+        realPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersIn"));
+        realSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersIn"));
+        alpha->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn"));
     } else {
-        realPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("layersOut");
-        realSize.m_pConfig     = g_pConfigManager->getAnimationPropertyConfig("layersOut");
-        alpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig("fadeLayersOut");
+        realPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersOut"));
+        realSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersOut"));
+        alpha->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeLayersOut"));
     }
 
+    const auto ANIMSTYLE = animationStyle.value_or(realPosition->getStyle());
     if (ANIMSTYLE.starts_with("slide")) {
         // get closest edge
         const auto MIDDLE = geometry.middle();
@@ -455,9 +490,9 @@ void CLayerSurface::startAnimation(bool in, bool instant) {
             }
         }
 
-        realSize.setValueAndWarp(geometry.size());
-        alpha.setValueAndWarp(in ? 0.f : 1.f);
-        alpha = in ? 1.f : 0.f;
+        realSize->setValueAndWarp(geometry.size());
+        alpha->setValueAndWarp(in ? 0.f : 1.f);
+        *alpha = in ? 1.f : 0.f;
 
         Vector2D prePos;
 
@@ -482,11 +517,11 @@ void CLayerSurface::startAnimation(bool in, bool instant) {
         }
 
         if (in) {
-            realPosition.setValueAndWarp(prePos);
-            realPosition = geometry.pos();
+            realPosition->setValueAndWarp(prePos);
+            *realPosition = geometry.pos();
         } else {
-            realPosition.setValueAndWarp(geometry.pos());
-            realPosition = prePos;
+            realPosition->setValueAndWarp(geometry.pos());
+            *realPosition = prePos;
         }
 
     } else if (ANIMSTYLE.starts_with("popin")) {
@@ -505,25 +540,25 @@ void CLayerSurface::startAnimation(bool in, bool instant) {
         const auto GOALSIZE = (geometry.size() * minPerc).clamp({5, 5});
         const auto GOALPOS  = geometry.pos() + (geometry.size() - GOALSIZE) / 2.f;
 
-        alpha.setValueAndWarp(in ? 0.f : 1.f);
-        alpha = in ? 1.f : 0.f;
+        alpha->setValueAndWarp(in ? 0.f : 1.f);
+        *alpha = in ? 1.f : 0.f;
 
         if (in) {
-            realSize.setValueAndWarp(GOALSIZE);
-            realPosition.setValueAndWarp(GOALPOS);
-            realSize     = geometry.size();
-            realPosition = geometry.pos();
+            realSize->setValueAndWarp(GOALSIZE);
+            realPosition->setValueAndWarp(GOALPOS);
+            *realSize     = geometry.size();
+            *realPosition = geometry.pos();
         } else {
-            realSize.setValueAndWarp(geometry.size());
-            realPosition.setValueAndWarp(geometry.pos());
-            realSize     = GOALSIZE;
-            realPosition = GOALPOS;
+            realSize->setValueAndWarp(geometry.size());
+            realPosition->setValueAndWarp(geometry.pos());
+            *realSize     = GOALSIZE;
+            *realPosition = GOALPOS;
         }
     } else {
         // fade
-        realPosition.setValueAndWarp(geometry.pos());
-        realSize.setValueAndWarp(geometry.size());
-        alpha = in ? 1.f : 0.f;
+        realPosition->setValueAndWarp(geometry.pos());
+        realSize->setValueAndWarp(geometry.size());
+        *alpha = in ? 1.f : 0.f;
     }
 
     if (!in)
@@ -534,7 +569,7 @@ bool CLayerSurface::isFadedOut() {
     if (!fadingOut)
         return false;
 
-    return !realPosition.isBeingAnimated() && !realSize.isBeingAnimated() && !alpha.isBeingAnimated();
+    return !realPosition->isBeingAnimated() && !realSize->isBeingAnimated() && !alpha->isBeingAnimated();
 }
 
 int CLayerSurface::popupsCount() {
@@ -542,6 +577,10 @@ int CLayerSurface::popupsCount() {
         return 0;
 
     int no = -1; // we have one dummy
-    popupHead->breadthfirst([](CPopup* p, void* data) { *(int*)data += 1; }, &no);
+    popupHead->breadthfirst([](WP<CPopup> p, void* data) { *(int*)data += 1; }, &no);
     return no;
 }
+
+MONITORID CLayerSurface::monitorID() {
+    return monitor ? monitor->ID : MONITOR_INVALID;
+}

src/desktop/LayerSurface.hpp

@@ -5,11 +5,6 @@
 #include "WLSurface.hpp"
 #include "../helpers/AnimatedVariable.hpp"
 
-struct SLayerRule {
-    std::string targetNamespace = "";
-    std::string rule            = "";
-};
-
 class CLayerShellResource;
 
 class CLayerSurface {
@@ -22,17 +17,17 @@ class CLayerSurface {
   public:
     ~CLayerSurface();
 
-    void                        applyRules();
-    void                        startAnimation(bool in, bool instant = false);
-    bool                        isFadedOut();
-    int                         popupsCount();
+    void                    applyRules();
+    void                    startAnimation(bool in, bool instant = false);
+    bool                    isFadedOut();
+    int                     popupsCount();
 
-    CAnimatedVariable<Vector2D> realPosition;
-    CAnimatedVariable<Vector2D> realSize;
-    CAnimatedVariable<float>    alpha;
+    PHLANIMVAR<Vector2D>    realPosition;
+    PHLANIMVAR<Vector2D>    realSize;
+    PHLANIMVAR<float>       alpha;
 
-    WP<CLayerShellResource>     layerSurface;
-    wl_list                     link;
+    WP<CLayerShellResource> layerSurface;
+    wl_list                 link;
 
     // the header providing the enum type cannot be imported here
     int                        interactivity = 0;
@@ -42,7 +37,7 @@ class CLayerSurface {
     bool                       mapped = false;
     uint32_t                   layer  = 0;
 
-    MONITORID                  monitorID = -1;
+    PHLMONITORREF              monitor;
 
     bool                       fadingOut     = false;
     bool                       readyToDelete = false;
@@ -64,12 +59,13 @@ class CLayerSurface {
     CBox                       geometry = {0, 0, 0, 0};
     Vector2D                   position;
     std::string                szNamespace = "";
-    std::unique_ptr<CPopup>    popupHead;
+    UP<CPopup>                 popupHead;
 
     void                       onDestroy();
     void                       onMap();
     void                       onUnmap();
     void                       onCommit();
+    MONITORID                  monitorID();
 
   private:
     struct {
@@ -83,6 +79,6 @@ class CLayerSurface {
 
     // For the list lookup
     bool operator==(const CLayerSurface& rhs) const {
-        return layerSurface == rhs.layerSurface && monitorID == rhs.monitorID;
+        return layerSurface == rhs.layerSurface && monitor == rhs.monitor;
     }
 };

src/desktop/Popup.cpp

@@ -4,6 +4,12 @@
 #include "../protocols/LayerShell.hpp"
 #include "../protocols/XDGShell.hpp"
 #include "../protocols/core/Compositor.hpp"
+#include "../managers/SeatManager.hpp"
+#include "../managers/eventLoop/EventLoopManager.hpp"
+#include "../desktop/LayerSurface.hpp"
+#include "../managers/input/InputManager.hpp"
+#include "../render/Renderer.hpp"
+#include "../render/OpenGL.hpp"
 #include <ranges>
 
 CPopup::CPopup(PHLWINDOW pOwner) : m_pWindowOwner(pOwner) {
@@ -14,13 +20,11 @@ CPopup::CPopup(PHLLS pOwner) : m_pLayerOwner(pOwner) {
     initAllSignals();
 }
 
-CPopup::CPopup(SP<CXDGPopupResource> popup, CPopup* pOwner) : m_pParent(pOwner), m_pResource(popup) {
+CPopup::CPopup(SP<CXDGPopupResource> popup, WP<CPopup> pOwner) :
+    m_pWindowOwner(pOwner->m_pWindowOwner), m_pLayerOwner(pOwner->m_pLayerOwner), m_pParent(pOwner), m_pResource(popup) {
     m_pWLSurface = CWLSurface::create();
     m_pWLSurface->assign(popup->surface->surface.lock(), this);
 
-    m_pLayerOwner  = pOwner->m_pLayerOwner;
-    m_pWindowOwner = pOwner->m_pWindowOwner;
-
     m_vLastSize = popup->surface->current.geometry.size();
     reposition();
 
@@ -55,7 +59,8 @@ void CPopup::initAllSignals() {
 }
 
 void CPopup::onNewPopup(SP<CXDGPopupResource> popup) {
-    const auto POPUP = m_vChildren.emplace_back(makeShared<CPopup>(popup, this)).get();
+    const auto& POPUP = m_vChildren.emplace_back(makeShared<CPopup>(popup, m_pSelf));
+    POPUP->m_pSelf    = POPUP;
     Debug::log(LOG, "New popup at {:x}", (uintptr_t)POPUP);
 }
 
@@ -80,13 +85,14 @@ void CPopup::onMap() {
 
     CBox       box = m_pWLSurface->resource()->extends();
     box.translate(COORDS).expand(4);
-    g_pHyprRenderer->damageBox(&box);
+    g_pHyprRenderer->damageBox(box);
 
     m_vLastPos = coordsRelativeToParent();
 
     g_pInputManager->simulateMouseMovement();
 
-    m_pSubsurfaceHead = std::make_unique<CSubsurface>(this);
+    m_pSubsurfaceHead          = makeUnique<CSubsurface>(m_pSelf);
+    m_pSubsurfaceHead->m_pSelf = m_pSubsurfaceHead;
 
     //unconstrain();
     sendScale();
@@ -106,31 +112,37 @@ void CPopup::onUnmap() {
         return;
     }
 
+    m_bMapped = false;
+
     m_vLastSize = m_pResource->surface->surface->current.size;
 
     const auto COORDS = coordsGlobal();
 
     CBox       box = m_pWLSurface->resource()->extends();
     box.translate(COORDS).expand(4);
-    g_pHyprRenderer->damageBox(&box);
+    g_pHyprRenderer->damageBox(box);
 
     m_pSubsurfaceHead.reset();
 
-    g_pInputManager->simulateMouseMovement();
-
     if (!m_pLayerOwner.expired() && m_pLayerOwner->layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
         g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_pLayerOwner->layer));
 
     // damage all children
     breadthfirst(
-        [](CPopup* p, void* data) {
+        [](WP<CPopup> p, void* data) {
             if (!p->m_pResource)
                 return;
 
             auto box = CBox{p->coordsGlobal(), p->size()};
-            g_pHyprRenderer->damageBox(&box);
+            g_pHyprRenderer->damageBox(box);
         },
         nullptr);
+
+    // TODO: probably refocus, but without a motion event?
+    // const bool WASLASTFOCUS = g_pSeatManager->state.keyboardFocus == m_pWLSurface->resource() || g_pSeatManager->state.pointerFocus == m_pWLSurface->resource();
+
+    // if (WASLASTFOCUS)
+    //     g_pInputManager->simulateMouseMovement();
 }
 
 void CPopup::onCommit(bool ignoreSiblings) {
@@ -162,10 +174,10 @@ void CPopup::onCommit(bool ignoreSiblings) {
 
     if (m_vLastSize != m_pResource->surface->surface->current.size || m_bRequestedReposition || m_vLastPos != COORDSLOCAL) {
         CBox box = {localToGlobal(m_vLastPos), m_vLastSize};
-        g_pHyprRenderer->damageBox(&box);
+        g_pHyprRenderer->damageBox(box);
         m_vLastSize = m_pResource->surface->surface->current.size;
         box         = {COORDS, m_vLastSize};
-        g_pHyprRenderer->damageBox(&box);
+        g_pHyprRenderer->damageBox(box);
 
         m_vLastPos = COORDSLOCAL;
     }
@@ -215,7 +227,7 @@ Vector2D CPopup::coordsRelativeToParent() {
     if (!m_pResource)
         return {};
 
-    CPopup* current = this;
+    WP<CPopup> current = m_pSelf;
     offset -= current->m_pResource->surface->current.geometry.pos();
 
     while (current->m_pParent && current->m_pResource) {
@@ -239,16 +251,16 @@ Vector2D CPopup::localToGlobal(const Vector2D& rel) {
 
 Vector2D CPopup::t1ParentCoords() {
     if (!m_pWindowOwner.expired())
-        return m_pWindowOwner->m_vRealPosition.value();
+        return m_pWindowOwner->m_vRealPosition->value();
     if (!m_pLayerOwner.expired())
-        return m_pLayerOwner->realPosition.value();
+        return m_pLayerOwner->realPosition->value();
 
     ASSERT(false);
     return {};
 }
 
 void CPopup::recheckTree() {
-    CPopup* curr = this;
+    WP<CPopup> curr = m_pSelf;
     while (curr->m_pParent) {
         curr = curr->m_pParent;
     }
@@ -288,16 +300,17 @@ bool CPopup::visible() {
     return false;
 }
 
-void CPopup::bfHelper(std::vector<CPopup*> nodes, std::function<void(CPopup*, void*)> fn, void* data) {
+void CPopup::bfHelper(std::vector<WP<CPopup>> const& nodes, std::function<void(WP<CPopup>, void*)> fn, void* data) {
     for (auto const& n : nodes) {
         fn(n, data);
     }
 
-    std::vector<CPopup*> nodes2;
+    std::vector<WP<CPopup>> nodes2;
+    nodes2.reserve(nodes.size() * 2);
 
     for (auto const& n : nodes) {
         for (auto const& c : n->m_vChildren) {
-            nodes2.push_back(c.get());
+            nodes2.push_back(c->m_pSelf);
         }
     }
 
@@ -305,18 +318,18 @@ void CPopup::bfHelper(std::vector<CPopup*> nodes, std::function<void(CPopup*, vo
         bfHelper(nodes2, fn, data);
 }
 
-void CPopup::breadthfirst(std::function<void(CPopup*, void*)> fn, void* data) {
-    std::vector<CPopup*> popups;
-    popups.push_back(this);
+void CPopup::breadthfirst(std::function<void(WP<CPopup>, void*)> fn, void* data) {
+    std::vector<WP<CPopup>> popups;
+    popups.push_back(m_pSelf);
     bfHelper(popups, fn, data);
 }
 
-CPopup* CPopup::at(const Vector2D& globalCoords, bool allowsInput) {
-    std::vector<CPopup*> popups;
-    breadthfirst([](CPopup* popup, void* data) { ((std::vector<CPopup*>*)data)->push_back(popup); }, &popups);
+WP<CPopup> CPopup::at(const Vector2D& globalCoords, bool allowsInput) {
+    std::vector<WP<CPopup>> popups;
+    breadthfirst([](WP<CPopup> popup, void* data) { ((std::vector<WP<CPopup>>*)data)->push_back(popup); }, &popups);
 
     for (auto const& p : popups | std::views::reverse) {
-        if (!p->m_pResource)
+        if (!p->m_pResource || !p->m_bMapped)
             continue;
 
         if (!allowsInput) {
@@ -335,5 +348,5 @@ CPopup* CPopup::at(const Vector2D& globalCoords, bool allowsInput) {
         }
     }
 
-    return nullptr;
+    return {};
 }

src/desktop/Popup.hpp

@@ -1,9 +1,9 @@
 #pragma once
 
 #include <vector>
-#include <memory>
 #include "Subsurface.hpp"
 #include "../helpers/signal/Signal.hpp"
+#include "../helpers/memory/Memory.hpp"
 
 class CXDGPopupResource;
 
@@ -14,7 +14,7 @@ class CPopup {
     CPopup(PHLLS pOwner);
 
     // real nodes
-    CPopup(SP<CXDGPopupResource> popup, CPopup* pOwner);
+    CPopup(SP<CXDGPopupResource> popup, WP<CPopup> pOwner);
 
     ~CPopup();
 
@@ -36,11 +36,13 @@ class CPopup {
     bool           visible();
 
     // will also loop over this node
-    void    breadthfirst(std::function<void(CPopup*, void*)> fn, void* data);
-    CPopup* at(const Vector2D& globalCoords, bool allowsInput = false);
+    void       breadthfirst(std::function<void(WP<CPopup>, void*)> fn, void* data);
+    WP<CPopup> at(const Vector2D& globalCoords, bool allowsInput = false);
 
     //
     SP<CWLSurface> m_pWLSurface;
+    WP<CPopup>     m_pSelf;
+    bool           m_bMapped = false;
 
   private:
     // T1 owners, each popup has to have one of these
@@ -48,7 +50,7 @@ class CPopup {
     PHLLSREF     m_pLayerOwner;
 
     // T2 owners
-    CPopup*               m_pParent = nullptr;
+    WP<CPopup>            m_pParent;
 
     WP<CXDGPopupResource> m_pResource;
 
@@ -57,12 +59,11 @@ class CPopup {
 
     bool                  m_bRequestedReposition = false;
 
-    bool                  m_bInert  = false;
-    bool                  m_bMapped = false;
+    bool                  m_bInert = false;
 
     //
-    std::vector<SP<CPopup>>      m_vChildren;
-    std::unique_ptr<CSubsurface> m_pSubsurfaceHead;
+    std::vector<SP<CPopup>> m_vChildren;
+    UP<CSubsurface>         m_pSubsurfaceHead;
 
     struct {
         CHyprSignalListener newPopup;
@@ -81,5 +82,5 @@ class CPopup {
 
     Vector2D    localToGlobal(const Vector2D& rel);
     Vector2D    t1ParentCoords();
-    static void bfHelper(std::vector<CPopup*> nodes, std::function<void(CPopup*, void*)> fn, void* data);
+    static void bfHelper(std::vector<WP<CPopup>> const& nodes, std::function<void(WP<CPopup>, void*)> fn, void* data);
 };

src/desktop/Rule.cpp

@@ -0,0 +1,22 @@
+#include <re2/re2.h>
+#include "../helpers/memory/Memory.hpp"
+#include "Rule.hpp"
+#include "../debug/Log.hpp"
+
+CRuleRegexContainer::CRuleRegexContainer(const std::string& regex_) {
+    const bool NEGATIVE = regex_.starts_with("negative:");
+
+    negative = NEGATIVE;
+    regex    = makeUnique<RE2>(NEGATIVE ? regex_.substr(9) : regex_);
+
+    // TODO: maybe pop an error?
+    if (!regex->ok())
+        Debug::log(ERR, "RuleRegexContainer: regex {} failed to parse!", regex_);
+}
+
+bool CRuleRegexContainer::passes(const std::string& str) const {
+    if (!regex)
+        return false;
+
+    return RE2::FullMatch(str, *regex) != negative;
+}

src/desktop/Rule.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <hyprutils/memory/UniquePtr.hpp>
+
+//NOLINTNEXTLINE
+namespace re2 {
+    class RE2;
+};
+
+class CRuleRegexContainer {
+  public:
+    CRuleRegexContainer() = default;
+
+    CRuleRegexContainer(const std::string& regex);
+
+    bool passes(const std::string& str) const;
+
+  private:
+    Hyprutils::Memory::CUniquePointer<re2::RE2> regex;
+    bool                                        negative = false;
+};

src/desktop/Subsurface.cpp

@@ -4,13 +4,15 @@
 #include "../config/ConfigValue.hpp"
 #include "../protocols/core/Compositor.hpp"
 #include "../protocols/core/Subcompositor.hpp"
+#include "../render/Renderer.hpp"
+#include "../managers/input/InputManager.hpp"
 
 CSubsurface::CSubsurface(PHLWINDOW pOwner) : m_pWindowParent(pOwner) {
     initSignals();
     initExistingSubsurfaces(pOwner->m_pWLSurface->resource());
 }
 
-CSubsurface::CSubsurface(CPopup* pOwner) : m_pPopupParent(pOwner) {
+CSubsurface::CSubsurface(WP<CPopup> pOwner) : m_pPopupParent(pOwner) {
     initSignals();
     initExistingSubsurfaces(pOwner->m_pWLSurface->resource());
 }
@@ -22,17 +24,13 @@ CSubsurface::CSubsurface(SP<CWLSubsurfaceResource> pSubsurface, PHLWINDOW pOwner
     initExistingSubsurfaces(pSubsurface->surface.lock());
 }
 
-CSubsurface::CSubsurface(SP<CWLSubsurfaceResource> pSubsurface, CPopup* pOwner) : m_pSubsurface(pSubsurface), m_pPopupParent(pOwner) {
+CSubsurface::CSubsurface(SP<CWLSubsurfaceResource> pSubsurface, WP<CPopup> pOwner) : m_pSubsurface(pSubsurface), m_pPopupParent(pOwner) {
     m_pWLSurface = CWLSurface::create();
     m_pWLSurface->assign(pSubsurface->surface.lock(), this);
     initSignals();
     initExistingSubsurfaces(pSubsurface->surface.lock());
 }
 
-CSubsurface::~CSubsurface() {
-    ;
-}
-
 void CSubsurface::initSignals() {
     if (m_pSubsurface) {
         listeners.commitSubsurface  = m_pSubsurface->surface->events.commit.registerListener([this](std::any d) { onCommit(); });
@@ -99,11 +97,20 @@ void CSubsurface::onCommit() {
     checkSiblingDamage();
 
     if (m_vLastSize != m_pWLSurface->resource()->current.size) {
-        CBox box{COORDS, m_vLastSize};
-        g_pHyprRenderer->damageBox(&box);
-        m_vLastSize = m_pWLSurface->resource()->current.size;
-        box         = {COORDS, m_vLastSize};
-        g_pHyprRenderer->damageBox(&box);
+        // TODO: fix this
+        // CBox box{COORDS, m_vLastSize};
+        // g_pHyprRenderer->damageBox(box);
+        // m_vLastSize = m_pWLSurface->resource()->current.size;
+        // box         = {COORDS, m_vLastSize};
+        // g_pHyprRenderer->damageBox(box);
+
+        CBox box;
+        if (m_pPopupParent)
+            box = m_pPopupParent->m_pWLSurface->getSurfaceBoxGlobal().value_or(CBox{});
+        else if (m_pWindowParent)
+            box = m_pWindowParent->getWindowMainSurfaceBox();
+
+        g_pHyprRenderer->damageBox(box);
     }
 }
 
@@ -121,16 +128,18 @@ void CSubsurface::onDestroy() {
 }
 
 void CSubsurface::onNewSubsurface(SP<CWLSubsurfaceResource> pSubsurface) {
-    CSubsurface* PSUBSURFACE = nullptr;
+    WP<CSubsurface> PSUBSURFACE;
 
     if (!m_pWindowParent.expired())
-        PSUBSURFACE = m_vChildren.emplace_back(std::make_unique<CSubsurface>(pSubsurface, m_pWindowParent.lock())).get();
+        PSUBSURFACE = m_vChildren.emplace_back(makeUnique<CSubsurface>(pSubsurface, m_pWindowParent.lock()));
     else if (m_pPopupParent)
-        PSUBSURFACE = m_vChildren.emplace_back(std::make_unique<CSubsurface>(pSubsurface, m_pPopupParent)).get();
+        PSUBSURFACE = m_vChildren.emplace_back(makeUnique<CSubsurface>(pSubsurface, m_pPopupParent));
+
+    PSUBSURFACE->m_pSelf = PSUBSURFACE;
 
     ASSERT(PSUBSURFACE);
 
-    PSUBSURFACE->m_pParent = this;
+    PSUBSURFACE->m_pParent = m_pSelf;
 }
 
 void CSubsurface::onMap() {
@@ -139,7 +148,7 @@ void CSubsurface::onMap() {
     const auto COORDS = coordsGlobal();
     CBox       box{COORDS, m_vLastSize};
     box.expand(4);
-    g_pHyprRenderer->damageBox(&box);
+    g_pHyprRenderer->damageBox(box);
 
     if (!m_pWindowParent.expired())
         m_pWindowParent->updateSurfaceScaleTransformDetails();
@@ -149,7 +158,7 @@ void CSubsurface::onUnmap() {
     const auto COORDS = coordsGlobal();
     CBox       box{COORDS, m_vLastSize};
     box.expand(4);
-    g_pHyprRenderer->damageBox(&box);
+    g_pHyprRenderer->damageBox(box);
 
     if (m_pWLSurface->resource() == g_pCompositor->m_pLastFocus)
         g_pInputManager->releaseAllMouseButtons();
@@ -169,7 +178,7 @@ Vector2D CSubsurface::coordsGlobal() {
     Vector2D coords = coordsRelativeToParent();
 
     if (!m_pWindowParent.expired())
-        coords += m_pWindowParent->m_vRealPosition.value();
+        coords += m_pWindowParent->m_vRealPosition->value();
     else if (m_pPopupParent)
         coords += m_pPopupParent->coordsGlobal();
 

src/desktop/Subsurface.hpp

@@ -11,28 +11,30 @@ class CSubsurface {
   public:
     // root dummy nodes
     CSubsurface(PHLWINDOW pOwner);
-    CSubsurface(CPopup* pOwner);
+    CSubsurface(WP<CPopup> pOwner);
 
     // real nodes
     CSubsurface(SP<CWLSubsurfaceResource> pSubsurface, PHLWINDOW pOwner);
-    CSubsurface(SP<CWLSubsurfaceResource> pSubsurface, CPopup* pOwner);
+    CSubsurface(SP<CWLSubsurfaceResource> pSubsurface, WP<CPopup> pOwner);
 
-    ~CSubsurface();
+    ~CSubsurface() = default;
 
-    Vector2D coordsRelativeToParent();
-    Vector2D coordsGlobal();
+    Vector2D        coordsRelativeToParent();
+    Vector2D        coordsGlobal();
 
-    Vector2D size();
+    Vector2D        size();
 
-    void     onCommit();
-    void     onDestroy();
-    void     onNewSubsurface(SP<CWLSubsurfaceResource> pSubsurface);
-    void     onMap();
-    void     onUnmap();
+    void            onCommit();
+    void            onDestroy();
+    void            onNewSubsurface(SP<CWLSubsurfaceResource> pSubsurface);
+    void            onMap();
+    void            onUnmap();
 
-    bool     visible();
+    bool            visible();
 
-    void     recheckDamageForSubsurfaces();
+    void            recheckDamageForSubsurfaces();
+
+    WP<CSubsurface> m_pSelf;
 
   private:
     struct {
@@ -48,16 +50,16 @@ class CSubsurface {
     Vector2D                  m_vLastSize = {};
 
     // if nullptr, means it's a dummy node
-    CSubsurface*                              m_pParent = nullptr;
+    WP<CSubsurface>              m_pParent;
 
-    PHLWINDOWREF                              m_pWindowParent;
-    CPopup*                                   m_pPopupParent = nullptr;
+    PHLWINDOWREF                 m_pWindowParent;
+    WP<CPopup>                   m_pPopupParent;
 
-    std::vector<std::unique_ptr<CSubsurface>> m_vChildren;
+    std::vector<UP<CSubsurface>> m_vChildren;
 
-    bool                                      m_bInert = false;
+    bool                         m_bInert = false;
 
-    void                                      initSignals();
-    void                                      initExistingSubsurfaces(SP<CWLSurfaceResource> pSurface);
-    void                                      checkSiblingDamage();
-};
+    void                         initSignals();
+    void                         initExistingSubsurfaces(SP<CWLSurfaceResource> pSurface);
+    void                         checkSiblingDamage();
+};

src/desktop/WLSurface.cpp

@@ -1,7 +1,9 @@
 #include "WLSurface.hpp"
-#include "../Compositor.hpp"
+#include "LayerSurface.hpp"
+#include "../desktop/Window.hpp"
 #include "../protocols/core/Compositor.hpp"
 #include "../protocols/LayerShell.hpp"
+#include "../render/Renderer.hpp"
 
 void CWLSurface::assign(SP<CWLSurfaceResource> pSurface) {
     m_pResource = pSurface;
@@ -72,7 +74,7 @@ Vector2D CWLSurface::correctSmallVec() const {
     const auto SIZE = getViewporterCorrectedSize();
     const auto O    = m_pWindowOwner.lock();
 
-    return Vector2D{(O->m_vReportedSize.x - SIZE.x) / 2, (O->m_vReportedSize.y - SIZE.y) / 2}.clamp({}, {INFINITY, INFINITY}) * (O->m_vRealSize.value() / O->m_vReportedSize);
+    return Vector2D{(O->m_vReportedSize.x - SIZE.x) / 2, (O->m_vReportedSize.y - SIZE.y) / 2}.clamp({}, {INFINITY, INFINITY}) * (O->m_vRealSize->value() / O->m_vReportedSize);
 }
 
 Vector2D CWLSurface::correctSmallVecBuf() const {

src/desktop/WLSurface.hpp

@@ -84,7 +84,11 @@ class CWLSurface {
     static SP<CWLSurface> fromResource(SP<CWLSurfaceResource> pSurface);
 
     // used by the alpha-modifier protocol
-    float m_pAlphaModifier = 1.F;
+    float m_fAlphaModifier = 1.F;
+
+    // used by the hyprland-surface protocol
+    float   m_fOverallOpacity = 1.F;
+    CRegion m_visibleRegion;
 
     struct {
         CSignal destroy;
@@ -116,4 +120,5 @@ class CWLSurface {
     } listeners;
 
     friend class CPointerConstraint;
-};
+    friend class CXxColorManagerV4;
+};

src/desktop/Window.hpp

@@ -1,10 +1,10 @@
 #pragma once
 
-#include <deque>
+#include <vector>
 #include <string>
+#include <optional>
 
 #include "../config/ConfigDataValues.hpp"
-#include "../defines.hpp"
 #include "../helpers/AnimatedVariable.hpp"
 #include "../helpers/math/Math.hpp"
 #include "../helpers/signal/Signal.hpp"
@@ -12,23 +12,25 @@
 #include "../macros.hpp"
 #include "../managers/XWaylandManager.hpp"
 #include "../render/decorations/IHyprWindowDecoration.hpp"
+#include "../render/Transformer.hpp"
 #include "DesktopTypes.hpp"
 #include "Popup.hpp"
 #include "Subsurface.hpp"
 #include "WLSurface.hpp"
 #include "Workspace.hpp"
+#include "WindowRule.hpp"
 
 class CXDGSurfaceResource;
 class CXWaylandSurface;
 
-enum eIdleInhibitMode {
+enum eIdleInhibitMode : uint8_t {
     IDLEINHIBIT_NONE = 0,
     IDLEINHIBIT_ALWAYS,
     IDLEINHIBIT_FULLSCREEN,
     IDLEINHIBIT_FOCUS
 };
 
-enum eGroupRules {
+enum eGroupRules : uint8_t {
     // effective only during first map, except for _ALWAYS variant
     GROUP_NONE        = 0,
     GROUP_SET         = 1 << 0, // Open as new group or add to focused group
@@ -40,7 +42,7 @@ enum eGroupRules {
     GROUP_OVERRIDE    = 1 << 6, // Override other rules
 };
 
-enum eGetWindowProperties {
+enum eGetWindowProperties : uint8_t {
     WINDOW_ONLY      = 0,
     RESERVED_EXTENTS = 1 << 0,
     INPUT_EXTENTS    = 1 << 1,
@@ -50,12 +52,13 @@ enum eGetWindowProperties {
     USE_PROP_TILED   = 1 << 5,
 };
 
-enum eSuppressEvents {
+enum eSuppressEvents : uint8_t {
     SUPPRESS_NONE               = 0,
     SUPPRESS_FULLSCREEN         = 1 << 0,
     SUPPRESS_MAXIMIZE           = 1 << 1,
     SUPPRESS_ACTIVATE           = 1 << 2,
     SUPPRESS_ACTIVATE_FOCUSONLY = 1 << 3,
+    SUPPRESS_FULLSCREEN_OUTPUT  = 1 << 4,
 };
 
 class IWindowTransformer;
@@ -64,7 +67,7 @@ struct SAlphaValue {
     float m_fAlpha;
     bool  m_bOverride;
 
-    float applyAlpha(float alpha) {
+    float applyAlpha(float alpha) const {
         if (m_bOverride)
             return m_fAlpha;
         else
@@ -72,8 +75,8 @@ struct SAlphaValue {
     };
 };
 
-enum eOverridePriority {
-    PRIORITY_LAYOUT,
+enum eOverridePriority : uint8_t {
+    PRIORITY_LAYOUT = 0,
     PRIORITY_WORKSPACE_RULE,
     PRIORITY_WINDOW_RULE,
     PRIORITY_SET_PROP,
@@ -85,9 +88,7 @@ class CWindowOverridableVar {
     CWindowOverridableVar(T const& value, eOverridePriority priority) {
         values[priority] = value;
     }
-    CWindowOverridableVar(T const& value) {
-        defaultValue = value;
-    }
+    CWindowOverridableVar(T const& value) : defaultValue{value} {}
 
     CWindowOverridableVar()  = default;
     ~CWindowOverridableVar() = default;
@@ -144,6 +145,13 @@ class CWindowOverridableVar {
             unset(priority);
     }
 
+    operator std::optional<T>() {
+        if (hasValue())
+            return value();
+        else
+            return std::nullopt;
+    }
+
   private:
     std::map<eOverridePriority, T> values;
     T                              defaultValue; // used for toggling, so required for bool
@@ -177,8 +185,12 @@ struct SWindowData {
     CWindowOverridableVar<bool>               renderUnfocused    = false;
 
     CWindowOverridableVar<int>                rounding;
+    CWindowOverridableVar<float>              roundingPower;
     CWindowOverridableVar<int>                borderSize;
 
+    CWindowOverridableVar<float>              scrollMouse;
+    CWindowOverridableVar<float>              scrollTouchpad;
+
     CWindowOverridableVar<std::string>        animationStyle;
     CWindowOverridableVar<Vector2D>           maxSize;
     CWindowOverridableVar<Vector2D>           minSize;
@@ -187,32 +199,12 @@ struct SWindowData {
     CWindowOverridableVar<CGradientValueData> inactiveBorderColor;
 };
 
-struct SWindowRule {
-    std::string szRule;
-    std::string szValue;
-
-    bool        v2 = false;
-    std::string szTitle;
-    std::string szClass;
-    std::string szInitialTitle;
-    std::string szInitialClass;
-    std::string szTag;
-    int         bX11              = -1; // -1 means "ANY"
-    int         bFloating         = -1;
-    int         bFullscreen       = -1;
-    int         bPinned           = -1;
-    int         bFocus            = -1;
-    std::string szFullscreenState = ""; // empty means any
-    std::string szOnWorkspace     = ""; // empty means any
-    std::string szWorkspace       = ""; // empty means any
-};
-
 struct SInitialWorkspaceToken {
     PHLWINDOWREF primaryOwner;
     std::string  workspace;
 };
 
-struct sFullscreenState {
+struct SFullscreenState {
     eFullscreenMode internal = FSMODE_NONE;
     eFullscreenMode client   = FSMODE_NONE;
 };
@@ -243,8 +235,8 @@ class CWindow {
     Vector2D m_vSize     = Vector2D(0, 0);
 
     // this is the real position and size used to draw the thing
-    CAnimatedVariable<Vector2D> m_vRealPosition;
-    CAnimatedVariable<Vector2D> m_vRealSize;
+    PHLANIMVAR<Vector2D> m_vRealPosition;
+    PHLANIMVAR<Vector2D> m_vRealSize;
 
     // for not spamming the protocols
     Vector2D                                     m_vReportedPosition;
@@ -271,13 +263,13 @@ class CWindow {
     bool             m_bIsFloating      = false;
     bool             m_bDraggingTiled   = false; // for dragging around tiled windows
     bool             m_bWasMaximized    = false;
-    sFullscreenState m_sFullscreenState = {.internal = FSMODE_NONE, .client = FSMODE_NONE};
-    MONITORID        m_iMonitorID       = -1;
+    SFullscreenState m_sFullscreenState = {.internal = FSMODE_NONE, .client = FSMODE_NONE};
     std::string      m_szTitle          = "";
     std::string      m_szClass          = "";
     std::string      m_szInitialTitle   = "";
     std::string      m_szInitialClass   = "";
     PHLWORKSPACE     m_pWorkspace;
+    PHLMONITORREF    m_pMonitor;
 
     bool             m_bIsMapped = false;
 
@@ -298,33 +290,37 @@ class CWindow {
     bool m_bNoInitialFocus = false;
 
     // Fullscreen and Maximize
-    bool m_bWantsInitialFullscreen = false;
+    bool      m_bWantsInitialFullscreen        = false;
+    MONITORID m_iWantsInitialFullscreenMonitor = MONITOR_INVALID;
 
     // bitfield eSuppressEvents
     uint64_t m_eSuppressedEvents = SUPPRESS_NONE;
 
     // desktop components
-    std::unique_ptr<CSubsurface> m_pSubsurfaceHead;
-    std::unique_ptr<CPopup>      m_pPopupHead;
+    UP<CSubsurface> m_pSubsurfaceHead;
+    UP<CPopup>      m_pPopupHead;
 
     // Animated border
-    CGradientValueData       m_cRealBorderColor         = {0};
-    CGradientValueData       m_cRealBorderColorPrevious = {0};
-    CAnimatedVariable<float> m_fBorderFadeAnimationProgress;
-    CAnimatedVariable<float> m_fBorderAngleAnimationProgress;
+    CGradientValueData m_cRealBorderColor         = {0};
+    CGradientValueData m_cRealBorderColorPrevious = {0};
+    PHLANIMVAR<float>  m_fBorderFadeAnimationProgress;
+    PHLANIMVAR<float>  m_fBorderAngleAnimationProgress;
 
     // Fade in-out
-    CAnimatedVariable<float> m_fAlpha;
-    bool                     m_bFadingOut     = false;
-    bool                     m_bReadyToDelete = false;
-    Vector2D                 m_vOriginalClosedPos;  // these will be used for calculations later on in
-    Vector2D                 m_vOriginalClosedSize; // drawing the closing animations
-    SBoxExtents              m_eOriginalClosedExtents;
-    bool                     m_bAnimatingIn = false;
+    PHLANIMVAR<float> m_fAlpha;
+    bool              m_bFadingOut     = false;
+    bool              m_bReadyToDelete = false;
+    Vector2D          m_vOriginalClosedPos;  // these will be used for calculations later on in
+    Vector2D          m_vOriginalClosedSize; // drawing the closing animations
+    SBoxExtents       m_eOriginalClosedExtents;
+    bool              m_bAnimatingIn = false;
 
     // For pinned (sticky) windows
     bool m_bPinned = false;
 
+    // For preserving pinned state when fullscreening a pinned window
+    bool m_bPinFullscreened = false;
+
     // urgency hint
     bool m_bIsUrgent = false;
 
@@ -333,30 +329,32 @@ class CWindow {
 
     // Window decorations
     // TODO: make this a SP.
-    std::deque<std::unique_ptr<IHyprWindowDecoration>> m_dWindowDecorations;
-    std::vector<IHyprWindowDecoration*>                m_vDecosToRemove;
+    std::vector<UP<IHyprWindowDecoration>> m_dWindowDecorations;
+    std::vector<IHyprWindowDecoration*>    m_vDecosToRemove;
 
     // Special render data, rules, etc
     SWindowData m_sWindowData;
 
     // Transformers
-    std::vector<std::unique_ptr<IWindowTransformer>> m_vTransformers;
+    std::vector<UP<IWindowTransformer>> m_vTransformers;
 
     // for alpha
-    CAnimatedVariable<float> m_fActiveInactiveAlpha;
+    PHLANIMVAR<float> m_fActiveInactiveAlpha;
+    PHLANIMVAR<float> m_fMovingFromWorkspaceAlpha;
 
     // animated shadow color
-    CAnimatedVariable<CColor> m_cRealShadowColor;
+    PHLANIMVAR<CHyprColor> m_cRealShadowColor;
 
     // animated tint
-    CAnimatedVariable<float> m_fDimPercent;
+    PHLANIMVAR<float> m_fDimPercent;
 
     // animate moving to an invisible workspace
-    int                      m_iMonitorMovedFrom = -1; // -1 means not moving
-    CAnimatedVariable<float> m_fMovingToWorkspaceAlpha;
+    int               m_iMonitorMovedFrom = -1; // -1 means not moving
+    PHLANIMVAR<float> m_fMovingToWorkspaceAlpha;
 
     // swallowing
     PHLWINDOWREF m_pSwallowed;
+    bool         m_bGroupSwallowed = false;
 
     // focus stuff
     bool m_bStayFocused = false;
@@ -383,13 +381,13 @@ class CWindow {
     bool     m_bTearingHint = false;
 
     // stores the currently matched window rules
-    std::vector<SWindowRule> m_vMatchedRules;
+    std::vector<SP<CWindowRule>> m_vMatchedRules;
 
     // window tags
     CTagKeeper m_tags;
 
     // For the list lookup
-    bool operator==(const CWindow& rhs) {
+    bool operator==(const CWindow& rhs) const {
         return m_pXDGSurface == rhs.m_pXDGSurface && m_pXWaylandSurface == rhs.m_pXWaylandSurface && m_vPosition == rhs.m_vPosition && m_vSize == rhs.m_vSize &&
             m_bFadingOut == rhs.m_bFadingOut;
     }
@@ -398,50 +396,49 @@ class CWindow {
     CBox                   getFullWindowBoundingBox();
     SBoxExtents            getFullWindowExtents();
     CBox                   getWindowBoxUnified(uint64_t props);
-    CBox                   getWindowMainSurfaceBox();
     CBox                   getWindowIdealBoundingBoxIgnoreReserved();
-    void                   addWindowDeco(std::unique_ptr<IHyprWindowDecoration> deco);
+    void                   addWindowDeco(UP<IHyprWindowDecoration> deco);
     void                   updateWindowDecos();
     void                   removeWindowDeco(IHyprWindowDecoration* deco);
     void                   uncacheWindowDecos();
     bool                   checkInputOnDecos(const eInputType, const Vector2D&, std::any = {});
     pid_t                  getPID();
     IHyprWindowDecoration* getDecorationByType(eDecorationType);
-    void                   removeDecorationByType(eDecorationType);
     void                   updateToplevel();
     void                   updateSurfaceScaleTransformDetails(bool force = false);
     void                   moveToWorkspace(PHLWORKSPACE);
-    PHLWINDOW              X11TransientFor();
+    PHLWINDOW              x11TransientFor();
     void                   onUnmap();
     void                   onMap();
     void                   setHidden(bool hidden);
     bool                   isHidden();
-    void                   applyDynamicRule(const SWindowRule& r);
+    void                   applyDynamicRule(const SP<CWindowRule>& r);
     void                   updateDynamicRules();
     SBoxExtents            getFullWindowReservedArea();
     Vector2D               middle();
     bool                   opaque();
     float                  rounding();
+    float                  roundingPower();
     bool                   canBeTorn();
     void                   setSuspended(bool suspend);
-    bool                   visibleOnMonitor(CMonitor* pMonitor);
+    bool                   visibleOnMonitor(PHLMONITOR pMonitor);
     WORKSPACEID            workspaceID();
+    MONITORID              monitorID();
     bool                   onSpecialWorkspace();
     void                   activate(bool force = false);
     int                    surfacesCount();
-
+    void                   clampWindowSize(const std::optional<Vector2D> minSize, const std::optional<Vector2D> maxSize);
     bool                   isFullscreen();
     bool                   isEffectiveInternalFSMode(const eFullscreenMode);
-
     int                    getRealBorderSize();
+    float                  getScrollMouse();
+    float                  getScrollTouchpad();
     void                   updateWindowData();
     void                   updateWindowData(const struct SWorkspaceRule&);
-
-    void                   onBorderAngleAnimEnd(void* ptr);
+    void                   onBorderAngleAnimEnd(WP<Hyprutils::Animation::CBaseAnimatedVariable> pav);
     bool                   isInCurvedCorner(double x, double y);
     bool                   hasPopupAt(const Vector2D& pos);
     int                    popupsCount();
-
     void                   applyGroupRules();
     void                   createGroup();
     void                   destroyGroup();
@@ -458,17 +455,25 @@ class CWindow {
     void                   switchWithWindowInGroup(PHLWINDOW pWindow);
     void                   setAnimationsToMove();
     void                   onWorkspaceAnimUpdate();
+    void                   onFocusAnimUpdate();
     void                   onUpdateState();
     void                   onUpdateMeta();
     void                   onX11Configure(CBox box);
     void                   onResourceChangeX11();
     std::string            fetchTitle();
     std::string            fetchClass();
-    void                   warpCursor();
+    void                   warpCursor(bool force = false);
     PHLWINDOW              getSwallower();
     void                   unsetWindowData(eOverridePriority priority);
     bool                   isX11OverrideRedirect();
     bool                   isModal();
+    Vector2D               requestedMinSize();
+    Vector2D               requestedMaxSize();
+    void                   sendWindowSize(Vector2D size, bool force = false, std::optional<Vector2D> overridePos = std::nullopt);
+
+    CBox                   getWindowMainSurfaceBox() const {
+        return {m_vRealPosition->value().x, m_vRealPosition->value().y, m_vRealSize->value().x, m_vRealSize->value().y};
+    }
 
     // listeners
     void onAck(uint32_t serial);
@@ -555,7 +560,7 @@ struct std::formatter<PHLWINDOW, CharT> : std::formatter<CharT> {
         if (formatWorkspace)
             std::format_to(out, ", workspace: {}", w->m_pWorkspace ? w->workspaceID() : WORKSPACE_INVALID);
         if (formatMonitor)
-            std::format_to(out, ", monitor: {}", w->m_iMonitorID);
+            std::format_to(out, ", monitor: {}", w->monitorID());
         if (formatClass)
             std::format_to(out, ", class: {}", w->m_szClass);
         return std::format_to(out, "]");

src/desktop/WindowRule.cpp

@@ -0,0 +1,91 @@
+#include "WindowRule.hpp"
+#include <unordered_set>
+#include <algorithm>
+#include <re2/re2.h>
+#include "../config/ConfigManager.hpp"
+
+static const auto RULES = std::unordered_set<std::string>{
+    "float", "fullscreen", "maximize", "noinitialfocus", "pin", "stayfocused", "tile", "renderunfocused",
+};
+static const auto RULES_PREFIX = std::unordered_set<std::string>{
+    "animation", "bordercolor", "bordersize", "center",   "fullscreenstate", "group",       "idleinhibit",    "maxsize", "minsize",       "monitor", "move",      "opacity",
+    "plugin:",   "prop",        "pseudo",     "rounding", "roundingpower",   "scrollmouse", "scrolltouchpad", "size",    "suppressevent", "tag",     "workspace", "xray",
+};
+
+CWindowRule::CWindowRule(const std::string& rule, const std::string& value, bool isV2, bool isExecRule) : szValue(value), szRule(rule), v2(isV2), execRule(isExecRule) {
+    const auto VALS  = CVarList(rule, 2, ' ');
+    const bool VALID = RULES.contains(rule) || std::any_of(RULES_PREFIX.begin(), RULES_PREFIX.end(), [&rule](auto prefix) { return rule.starts_with(prefix); }) ||
+        (g_pConfigManager->mbWindowProperties.find(VALS[0]) != g_pConfigManager->mbWindowProperties.end()) ||
+        (g_pConfigManager->miWindowProperties.find(VALS[0]) != g_pConfigManager->miWindowProperties.end()) ||
+        (g_pConfigManager->mfWindowProperties.find(VALS[0]) != g_pConfigManager->mfWindowProperties.end());
+
+    if (!VALID)
+        return;
+
+    if (rule == "float")
+        ruleType = RULE_FLOAT;
+    else if (rule == "fullscreen")
+        ruleType = RULE_FULLSCREEN;
+    else if (rule == "maximize")
+        ruleType = RULE_MAXIMIZE;
+    else if (rule == "noinitialfocus")
+        ruleType = RULE_NOINITIALFOCUS;
+    else if (rule == "pin")
+        ruleType = RULE_PIN;
+    else if (rule == "stayfocused")
+        ruleType = RULE_STAYFOCUSED;
+    else if (rule == "tile")
+        ruleType = RULE_TILE;
+    else if (rule == "renderunfocused")
+        ruleType = RULE_RENDERUNFOCUSED;
+    else if (rule.starts_with("animation"))
+        ruleType = RULE_ANIMATION;
+    else if (rule.starts_with("bordercolor"))
+        ruleType = RULE_BORDERCOLOR;
+    else if (rule.starts_with("center"))
+        ruleType = RULE_CENTER;
+    else if (rule.starts_with("fullscreenstate"))
+        ruleType = RULE_FULLSCREENSTATE;
+    else if (rule.starts_with("group"))
+        ruleType = RULE_GROUP;
+    else if (rule.starts_with("idleinhibit"))
+        ruleType = RULE_IDLEINHIBIT;
+    else if (rule.starts_with("maxsize"))
+        ruleType = RULE_MAXSIZE;
+    else if (rule.starts_with("minsize"))
+        ruleType = RULE_MINSIZE;
+    else if (rule.starts_with("monitor"))
+        ruleType = RULE_MONITOR;
+    else if (rule.starts_with("move"))
+        ruleType = RULE_MOVE;
+    else if (rule.starts_with("opacity"))
+        ruleType = RULE_OPACITY;
+    else if (rule.starts_with("plugin:"))
+        ruleType = RULE_PLUGIN;
+    else if (rule.starts_with("pseudo"))
+        ruleType = RULE_PSEUDO;
+    else if (rule.starts_with("size"))
+        ruleType = RULE_SIZE;
+    else if (rule.starts_with("suppressevent"))
+        ruleType = RULE_SUPPRESSEVENT;
+    else if (rule.starts_with("tag"))
+        ruleType = RULE_TAG;
+    else if (rule.starts_with("workspace"))
+        ruleType = RULE_WORKSPACE;
+    else if (rule.starts_with("prop"))
+        ruleType = RULE_PROP;
+    else {
+        // check if this is a prop.
+        const CVarList VARS(rule, 0, 's', true);
+        if (g_pConfigManager->miWindowProperties.find(VARS[0]) != g_pConfigManager->miWindowProperties.end() ||
+            g_pConfigManager->mbWindowProperties.find(VARS[0]) != g_pConfigManager->mbWindowProperties.end() ||
+            g_pConfigManager->mfWindowProperties.find(VARS[0]) != g_pConfigManager->mfWindowProperties.end()) {
+            *const_cast<std::string*>(&szRule) = "prop " + rule;
+            ruleType                           = RULE_PROP;
+            Debug::log(LOG, "CWindowRule: direct prop rule found, rewritten {} -> {}", rule, szRule);
+        } else {
+            Debug::log(ERR, "CWindowRule: didn't match a rule that was found valid?!");
+            ruleType = RULE_INVALID;
+        }
+    }
+}

src/desktop/WindowRule.hpp

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <string>
+#include <cstdint>
+#include "Rule.hpp"
+
+class CWindowRule {
+  public:
+    CWindowRule(const std::string& rule, const std::string& value, bool isV2 = false, bool isExecRule = false);
+
+    enum eRuleType : uint8_t {
+        RULE_INVALID = 0,
+        RULE_FLOAT,
+        RULE_FULLSCREEN,
+        RULE_MAXIMIZE,
+        RULE_NOINITIALFOCUS,
+        RULE_PIN,
+        RULE_STAYFOCUSED,
+        RULE_TILE,
+        RULE_RENDERUNFOCUSED,
+        RULE_ANIMATION,
+        RULE_BORDERCOLOR,
+        RULE_CENTER,
+        RULE_FULLSCREENSTATE,
+        RULE_GROUP,
+        RULE_IDLEINHIBIT,
+        RULE_MAXSIZE,
+        RULE_MINSIZE,
+        RULE_MONITOR,
+        RULE_MOVE,
+        RULE_OPACITY,
+        RULE_PLUGIN,
+        RULE_PSEUDO,
+        RULE_SIZE,
+        RULE_SUPPRESSEVENT,
+        RULE_TAG,
+        RULE_WORKSPACE,
+        RULE_PROP,
+    };
+
+    eRuleType         ruleType = RULE_INVALID;
+
+    const std::string szValue;
+    const std::string szRule;
+    const bool        v2       = false;
+    const bool        execRule = false;
+
+    std::string       szTitle;
+    std::string       szClass;
+    std::string       szInitialTitle;
+    std::string       szInitialClass;
+    std::string       szTag;
+    int               bX11              = -1; // -1 means "ANY"
+    int               bFloating         = -1;
+    int               bFullscreen       = -1;
+    int               bPinned           = -1;
+    int               bFocus            = -1;
+    std::string       szFullscreenState = ""; // empty means any
+    std::string       szOnWorkspace     = ""; // empty means any
+    std::string       szWorkspace       = ""; // empty means any
+
+    // precompiled regexes
+    CRuleRegexContainer rTitle;
+    CRuleRegexContainer rClass;
+    CRuleRegexContainer rInitialTitle;
+    CRuleRegexContainer rInitialClass;
+    CRuleRegexContainer rV1Regex;
+};

src/desktop/Workspace.cpp

@@ -1,37 +1,33 @@
 #include "Workspace.hpp"
 #include "../Compositor.hpp"
 #include "../config/ConfigValue.hpp"
+#include "config/ConfigManager.hpp"
+#include "managers/AnimationManager.hpp"
+#include "../managers/EventManager.hpp"
+#include "../managers/HookSystemManager.hpp"
 
+#include <hyprutils/animation/AnimatedVariable.hpp>
 #include <hyprutils/string/String.hpp>
 using namespace Hyprutils::String;
 
-PHLWORKSPACE CWorkspace::create(WORKSPACEID id, MONITORID monitorID, std::string name, bool special, bool isEmpty) {
-    PHLWORKSPACE workspace = makeShared<CWorkspace>(id, monitorID, name, special, isEmpty);
+PHLWORKSPACE CWorkspace::create(WORKSPACEID id, PHLMONITOR monitor, std::string name, bool special, bool isEmpty) {
+    PHLWORKSPACE workspace = makeShared<CWorkspace>(id, monitor, name, special, isEmpty);
     workspace->init(workspace);
     return workspace;
 }
 
-CWorkspace::CWorkspace(WORKSPACEID id, MONITORID monitorID, std::string name, bool special, bool isEmpty) {
-    m_iMonitorID          = monitorID;
-    m_iID                 = id;
-    m_szName              = name;
-    m_bIsSpecialWorkspace = special;
-    m_bWasCreatedEmpty    = isEmpty;
+CWorkspace::CWorkspace(WORKSPACEID id, PHLMONITOR monitor, std::string name, bool special, bool isEmpty) :
+    m_iID(id), m_szName(name), m_pMonitor(monitor), m_bIsSpecialWorkspace(special), m_bWasCreatedEmpty(isEmpty) {
+    ;
 }
 
 void CWorkspace::init(PHLWORKSPACE self) {
     m_pSelf = self;
 
-    m_vRenderOffset.create(m_bIsSpecialWorkspace ? g_pConfigManager->getAnimationPropertyConfig("specialWorkspaceIn") :
-                                                   g_pConfigManager->getAnimationPropertyConfig("workspacesIn"),
-                           self, AVARDAMAGE_ENTIRE);
-    m_fAlpha.create(AVARTYPE_FLOAT,
-                    m_bIsSpecialWorkspace ? g_pConfigManager->getAnimationPropertyConfig("specialWorkspaceIn") : g_pConfigManager->getAnimationPropertyConfig("workspacesIn"), self,
-                    AVARDAMAGE_ENTIRE);
-    m_fAlpha.setValueAndWarp(1.f);
-
-    m_vRenderOffset.registerVar();
-    m_fAlpha.registerVar();
+    g_pAnimationManager->createAnimation(Vector2D(0, 0), m_vRenderOffset,
+                                         g_pConfigManager->getAnimationPropertyConfig(m_bIsSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"), self, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, m_fAlpha, g_pConfigManager->getAnimationPropertyConfig(m_bIsSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"), self,
+                                         AVARDAMAGE_ENTIRE);
 
     const auto RULEFORTHIS = g_pConfigManager->getWorkspaceRuleFor(self);
     if (RULEFORTHIS.defaultName.has_value())
@@ -58,16 +54,11 @@ void CWorkspace::init(PHLWORKSPACE self) {
     EMIT_HOOK_EVENT("createWorkspace", this);
 }
 
-SWorkspaceIDName CWorkspace::getPrevWorkspaceIDName(bool perMonitor) const {
-    if (perMonitor)
-        return m_sPrevWorkspacePerMonitor;
-
+SWorkspaceIDName CWorkspace::getPrevWorkspaceIDName() const {
     return m_sPrevWorkspace;
 }
 
 CWorkspace::~CWorkspace() {
-    m_vRenderOffset.unregister();
-
     Debug::log(LOG, "Destroying workspace ID {}", m_iID);
 
     // check if g_pHookSystem and g_pEventManager exist, they might be destroyed as in when the compositor is closing.
@@ -85,15 +76,15 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
     if (!instant) {
         const std::string ANIMNAME = std::format("{}{}", m_bIsSpecialWorkspace ? "specialWorkspace" : "workspaces", in ? "In" : "Out");
 
-        m_fAlpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig(ANIMNAME);
-        m_vRenderOffset.m_pConfig = g_pConfigManager->getAnimationPropertyConfig(ANIMNAME);
+        m_fAlpha->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
+        m_vRenderOffset->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
     }
 
-    const auto  ANIMSTYLE     = m_fAlpha.m_pConfig->pValues->internalStyle;
+    const auto  ANIMSTYLE     = m_fAlpha->getStyle();
     static auto PWORKSPACEGAP = CConfigValue<Hyprlang::INT>("general:gaps_workspaces");
 
     // set floating windows offset callbacks
-    m_vRenderOffset.setUpdateCallback([&](void*) {
+    m_vRenderOffset->setUpdateCallback([&](auto) {
         for (auto const& w : g_pCompositor->m_vWindows) {
             if (!validMapped(w) || w->workspaceID() != m_iID)
                 continue;
@@ -103,94 +94,94 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
     });
 
     if (ANIMSTYLE.starts_with("slidefade")) {
-        const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+        const auto PMONITOR = m_pMonitor.lock();
         float      movePerc = 100.f;
 
-        if (ANIMSTYLE.find("%") != std::string::npos) {
+        if (ANIMSTYLE.find('%') != std::string::npos) {
             try {
                 auto percstr = ANIMSTYLE.substr(ANIMSTYLE.find_last_of(' ') + 1);
                 movePerc     = std::stoi(percstr.substr(0, percstr.length() - 1));
             } catch (std::exception& e) { Debug::log(ERR, "Error in startAnim: invalid percentage"); }
         }
 
-        m_fAlpha.setValueAndWarp(1.f);
-        m_vRenderOffset.setValueAndWarp(Vector2D(0, 0));
+        m_fAlpha->setValueAndWarp(1.f);
+        m_vRenderOffset->setValueAndWarp(Vector2D(0, 0));
 
         if (ANIMSTYLE.starts_with("slidefadevert")) {
             if (in) {
-                m_fAlpha.setValueAndWarp(0.f);
-                m_vRenderOffset.setValueAndWarp(Vector2D(0.0, (left ? PMONITOR->vecSize.y : -PMONITOR->vecSize.y) * (movePerc / 100.f)));
-                m_fAlpha        = 1.f;
-                m_vRenderOffset = Vector2D(0, 0);
+                m_fAlpha->setValueAndWarp(0.f);
+                m_vRenderOffset->setValueAndWarp(Vector2D(0.0, (left ? PMONITOR->vecSize.y : -PMONITOR->vecSize.y) * (movePerc / 100.f)));
+                *m_fAlpha        = 1.f;
+                *m_vRenderOffset = Vector2D(0, 0);
             } else {
-                m_fAlpha.setValueAndWarp(1.f);
-                m_fAlpha        = 0.f;
-                m_vRenderOffset = Vector2D(0.0, (left ? -PMONITOR->vecSize.y : PMONITOR->vecSize.y) * (movePerc / 100.f));
+                m_fAlpha->setValueAndWarp(1.f);
+                *m_fAlpha        = 0.f;
+                *m_vRenderOffset = Vector2D(0.0, (left ? -PMONITOR->vecSize.y : PMONITOR->vecSize.y) * (movePerc / 100.f));
             }
         } else {
             if (in) {
-                m_fAlpha.setValueAndWarp(0.f);
-                m_vRenderOffset.setValueAndWarp(Vector2D((left ? PMONITOR->vecSize.x : -PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0));
-                m_fAlpha        = 1.f;
-                m_vRenderOffset = Vector2D(0, 0);
+                m_fAlpha->setValueAndWarp(0.f);
+                m_vRenderOffset->setValueAndWarp(Vector2D((left ? PMONITOR->vecSize.x : -PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0));
+                *m_fAlpha        = 1.f;
+                *m_vRenderOffset = Vector2D(0, 0);
             } else {
-                m_fAlpha.setValueAndWarp(1.f);
-                m_fAlpha        = 0.f;
-                m_vRenderOffset = Vector2D((left ? -PMONITOR->vecSize.x : PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0);
+                m_fAlpha->setValueAndWarp(1.f);
+                *m_fAlpha        = 0.f;
+                *m_vRenderOffset = Vector2D((left ? -PMONITOR->vecSize.x : PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0);
             }
         }
     } else if (ANIMSTYLE == "fade") {
-        m_vRenderOffset.setValueAndWarp(Vector2D(0, 0)); // fix a bug, if switching from slide -> fade.
+        m_vRenderOffset->setValueAndWarp(Vector2D(0, 0)); // fix a bug, if switching from slide -> fade.
 
         if (in) {
-            m_fAlpha.setValueAndWarp(0.f);
-            m_fAlpha = 1.f;
+            m_fAlpha->setValueAndWarp(0.f);
+            *m_fAlpha = 1.f;
         } else {
-            m_fAlpha.setValueAndWarp(1.f);
-            m_fAlpha = 0.f;
+            m_fAlpha->setValueAndWarp(1.f);
+            *m_fAlpha = 0.f;
         }
     } else if (ANIMSTYLE == "slidevert") {
         // fallback is slide
-        const auto PMONITOR  = g_pCompositor->getMonitorFromID(m_iMonitorID);
+        const auto PMONITOR  = m_pMonitor.lock();
         const auto YDISTANCE = PMONITOR->vecSize.y + *PWORKSPACEGAP;
 
-        m_fAlpha.setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
+        m_fAlpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
 
         if (in) {
-            m_vRenderOffset.setValueAndWarp(Vector2D(0.0, left ? YDISTANCE : -YDISTANCE));
-            m_vRenderOffset = Vector2D(0, 0);
+            m_vRenderOffset->setValueAndWarp(Vector2D(0.0, left ? YDISTANCE : -YDISTANCE));
+            *m_vRenderOffset = Vector2D(0, 0);
         } else {
-            m_vRenderOffset = Vector2D(0.0, left ? -YDISTANCE : YDISTANCE);
+            *m_vRenderOffset = Vector2D(0.0, left ? -YDISTANCE : YDISTANCE);
         }
     } else {
         // fallback is slide
-        const auto PMONITOR  = g_pCompositor->getMonitorFromID(m_iMonitorID);
+        const auto PMONITOR  = m_pMonitor.lock();
         const auto XDISTANCE = PMONITOR->vecSize.x + *PWORKSPACEGAP;
 
-        m_fAlpha.setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
+        m_fAlpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
 
         if (in) {
-            m_vRenderOffset.setValueAndWarp(Vector2D(left ? XDISTANCE : -XDISTANCE, 0.0));
-            m_vRenderOffset = Vector2D(0, 0);
+            m_vRenderOffset->setValueAndWarp(Vector2D(left ? XDISTANCE : -XDISTANCE, 0.0));
+            *m_vRenderOffset = Vector2D(0, 0);
         } else {
-            m_vRenderOffset = Vector2D(left ? -XDISTANCE : XDISTANCE, 0.0);
+            *m_vRenderOffset = Vector2D(left ? -XDISTANCE : XDISTANCE, 0.0);
         }
     }
 
     if (m_bIsSpecialWorkspace) {
         // required for open/close animations
         if (in) {
-            m_fAlpha.setValueAndWarp(0.f);
-            m_fAlpha = 1.f;
+            m_fAlpha->setValueAndWarp(0.f);
+            *m_fAlpha = 1.f;
         } else {
-            m_fAlpha.setValueAndWarp(1.f);
-            m_fAlpha = 0.f;
+            m_fAlpha->setValueAndWarp(1.f);
+            *m_fAlpha = 0.f;
         }
     }
 
     if (instant) {
-        m_vRenderOffset.warp();
-        m_fAlpha.warp();
+        m_vRenderOffset->warp();
+        m_fAlpha->warp();
     }
 }
 
@@ -224,10 +215,7 @@ void CWorkspace::rememberPrevWorkspace(const PHLWORKSPACE& prev) {
     m_sPrevWorkspace.id   = prev->m_iID;
     m_sPrevWorkspace.name = prev->m_szName;
 
-    if (prev->m_iMonitorID == m_iMonitorID) {
-        m_sPrevWorkspacePerMonitor.id   = prev->m_iID;
-        m_sPrevWorkspacePerMonitor.name = prev->m_szName;
-    }
+    prev->m_pMonitor->addPrevWorkspaceID(prev->m_iID);
 }
 
 std::string CWorkspace::getConfigName() {
@@ -278,9 +266,9 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
             // f - fullscreen state : f[-1], f[0], f[1], or f[2] for different fullscreen states
             //                        -1: no fullscreen, 0: fullscreen, 1: maximized, 2: fullscreen without sending fs state to window
 
-            const auto  NEXTSPACE = selector.find_first_of(' ', i);
-            std::string prop      = selector.substr(i, NEXTSPACE == std::string::npos ? std::string::npos : NEXTSPACE - i);
-            i                     = std::min(NEXTSPACE, std::string::npos - 1);
+            const auto  CLOSING_BRACKET = selector.find_first_of(']', i);
+            std::string prop            = selector.substr(i, CLOSING_BRACKET == std::string::npos ? std::string::npos : CLOSING_BRACKET + 1 - i);
+            i                           = std::min(CLOSING_BRACKET, std::string::npos - 1);
 
             if (cur == 'r') {
                 WORKSPACEID from = 0, to = 0;
@@ -296,7 +284,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
                     return false;
                 }
 
-                const auto DASHPOS = prop.find("-");
+                const auto DASHPOS = prop.find('-');
                 const auto LHS = prop.substr(0, DASHPOS), RHS = prop.substr(DASHPOS + 1);
 
                 if (!isNumber(LHS) || !isNumber(RHS)) {
@@ -332,7 +320,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 const auto SHOULDBESPECIAL = configStringToInt(prop);
 
-                if ((bool)SHOULDBESPECIAL != m_bIsSpecialWorkspace)
+                if (SHOULDBESPECIAL && (bool)*SHOULDBESPECIAL != m_bIsSpecialWorkspace)
                     return false;
                 continue;
             }
@@ -347,7 +335,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 const auto PMONITOR = g_pCompositor->getMonitorFromString(prop);
 
-                if (!(PMONITOR ? PMONITOR->ID == m_iMonitorID : false))
+                if (!(PMONITOR ? PMONITOR == m_pMonitor : false))
                     return false;
                 continue;
             }
@@ -367,7 +355,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 const auto WANTSNAMED = configStringToInt(prop);
 
-                if (WANTSNAMED != (m_iID <= -1337))
+                if (WANTSNAMED && *WANTSNAMED != (m_iID <= -1337))
                     return false;
                 continue;
             }
@@ -422,18 +410,18 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                     int count;
                     if (wantsCountGroup)
-                        count = g_pCompositor->getGroupsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
-                                                                    wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
+                        count = getGroups(wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
+                                          wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
                     else
-                        count = g_pCompositor->getWindowsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
-                                                                     wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
+                        count = getWindows(wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
+                                           wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
 
                     if (count != from)
                         return false;
                     continue;
                 }
 
-                const auto DASHPOS = prop.find("-");
+                const auto DASHPOS = prop.find('-');
                 const auto LHS = prop.substr(0, DASHPOS), RHS = prop.substr(DASHPOS + 1);
 
                 if (!isNumber(LHS) || !isNumber(RHS)) {
@@ -456,11 +444,11 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 WORKSPACEID count;
                 if (wantsCountGroup)
-                    count = g_pCompositor->getGroupsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
-                                                                wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
+                    count = getGroups(wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
+                                      wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
                 else
-                    count = g_pCompositor->getWindowsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
-                                                                 wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
+                    count = getWindows(wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
+                                       wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
 
                 if (std::clamp(count, from, to) != count)
                     return false;
@@ -512,12 +500,151 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 }
 
 void CWorkspace::markInert() {
-    m_bInert     = true;
-    m_iID        = WORKSPACE_INVALID;
-    m_iMonitorID = MONITOR_INVALID;
-    m_bVisible   = false;
+    m_bInert   = true;
+    m_iID      = WORKSPACE_INVALID;
+    m_bVisible = false;
+    m_pMonitor.reset();
 }
 
 bool CWorkspace::inert() {
     return m_bInert;
 }
+
+MONITORID CWorkspace::monitorID() {
+    return m_pMonitor ? m_pMonitor->ID : MONITOR_INVALID;
+}
+
+PHLWINDOW CWorkspace::getFullscreenWindow() {
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (w->m_pWorkspace == m_pSelf && w->isFullscreen())
+            return w;
+    }
+
+    return nullptr;
+}
+
+bool CWorkspace::isVisible() {
+    return m_bVisible;
+}
+
+bool CWorkspace::isVisibleNotCovered() {
+    const auto PMONITOR = m_pMonitor.lock();
+    if (PMONITOR->activeSpecialWorkspace)
+        return PMONITOR->activeSpecialWorkspace->m_iID == m_iID;
+
+    return PMONITOR->activeWorkspace->m_iID == m_iID;
+}
+
+int CWorkspace::getWindows(std::optional<bool> onlyTiled, std::optional<bool> onlyVisible) {
+    int no = 0;
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (w->workspaceID() != m_iID || !w->m_bIsMapped)
+            continue;
+        if (onlyTiled.has_value() && w->m_bIsFloating == onlyTiled.value())
+            continue;
+        if (onlyVisible.has_value() && w->isHidden() == onlyVisible.value())
+            continue;
+        no++;
+    }
+
+    return no;
+}
+
+int CWorkspace::getGroups(std::optional<bool> onlyTiled, std::optional<bool> onlyVisible) {
+    int no = 0;
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (w->workspaceID() != m_iID || !w->m_bIsMapped)
+            continue;
+        if (!w->m_sGroupData.head)
+            continue;
+        if (onlyTiled.has_value() && w->m_bIsFloating == onlyTiled.value())
+            continue;
+        if (onlyVisible.has_value() && w->isHidden() == onlyVisible.value())
+            continue;
+        no++;
+    }
+    return no;
+}
+
+PHLWINDOW CWorkspace::getFirstWindow() {
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (w->m_pWorkspace == m_pSelf && w->m_bIsMapped && !w->isHidden())
+            return w;
+    }
+
+    return nullptr;
+}
+
+PHLWINDOW CWorkspace::getTopLeftWindow() {
+    const auto PMONITOR = m_pMonitor.lock();
+
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (w->m_pWorkspace != m_pSelf || !w->m_bIsMapped || w->isHidden())
+            continue;
+
+        const auto WINDOWIDEALBB = w->getWindowIdealBoundingBoxIgnoreReserved();
+
+        if (WINDOWIDEALBB.x <= PMONITOR->vecPosition.x + 1 && WINDOWIDEALBB.y <= PMONITOR->vecPosition.y + 1)
+            return w;
+    }
+    return nullptr;
+}
+
+bool CWorkspace::hasUrgentWindow() {
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (w->m_pWorkspace == m_pSelf && w->m_bIsMapped && w->m_bIsUrgent)
+            return true;
+    }
+
+    return false;
+}
+
+void CWorkspace::updateWindowDecos() {
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (w->m_pWorkspace != m_pSelf)
+            continue;
+
+        w->updateWindowDecos();
+    }
+}
+
+void CWorkspace::updateWindowData() {
+    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_pSelf.lock());
+
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (w->m_pWorkspace != m_pSelf)
+            continue;
+
+        w->updateWindowData(WORKSPACERULE);
+    }
+}
+
+void CWorkspace::forceReportSizesToWindows() {
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (w->m_pWorkspace != m_pSelf || !w->m_bIsMapped || w->isHidden())
+            continue;
+
+        w->sendWindowSize(w->m_vRealSize->goal(), true);
+    }
+}
+
+void CWorkspace::rename(const std::string& name) {
+    if (g_pCompositor->isWorkspaceSpecial(m_iID))
+        return;
+
+    Debug::log(LOG, "CWorkspace::rename: Renaming workspace {} to '{}'", m_iID, name);
+    m_szName = name;
+
+    g_pEventManager->postEvent({"renameworkspace", std::to_string(m_iID) + "," + m_szName});
+}
+
+void CWorkspace::updateWindows() {
+    m_bHasFullscreenWindow = std::ranges::any_of(g_pCompositor->m_vWindows, [this](const auto& w) { return w->m_bIsMapped && w->m_pWorkspace == m_pSelf && w->isFullscreen(); });
+
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (!w->m_bIsMapped || w->m_pWorkspace != m_pSelf)
+            continue;
+
+        w->updateDynamicRules();
+    }
+}

src/desktop/Workspace.hpp

@@ -17,29 +17,26 @@ class CWindow;
 
 class CWorkspace {
   public:
-    static PHLWORKSPACE create(WORKSPACEID id, MONITORID monitorID, std::string name, bool special = false, bool isEmpty = true);
+    static PHLWORKSPACE create(WORKSPACEID id, PHLMONITOR monitor, std::string name, bool special = false, bool isEmpty = true);
     // use create() don't use this
-    CWorkspace(WORKSPACEID id, MONITORID monitorID, std::string name, bool special = false, bool isEmpty = true);
+    CWorkspace(WORKSPACEID id, PHLMONITOR monitor, std::string name, bool special = false, bool isEmpty = true);
     ~CWorkspace();
 
     // Workspaces ID-based have IDs > 0
     // and workspaces name-based have IDs starting with -1337
-    WORKSPACEID m_iID        = WORKSPACE_INVALID;
-    std::string m_szName     = "";
-    MONITORID   m_iMonitorID = MONITOR_INVALID;
-    // Previous workspace ID and name is stored during a workspace change, allowing travel
-    // to the previous workspace.
-    SWorkspaceIDName m_sPrevWorkspace, m_sPrevWorkspacePerMonitor;
+    WORKSPACEID     m_iID    = WORKSPACE_INVALID;
+    std::string     m_szName = "";
+    PHLMONITORREF   m_pMonitor;
 
-    bool             m_bHasFullscreenWindow = false;
-    eFullscreenMode  m_efFullscreenMode     = FSMODE_NONE;
+    bool            m_bHasFullscreenWindow = false;
+    eFullscreenMode m_efFullscreenMode     = FSMODE_NONE;
 
-    wl_array         m_wlrCoordinateArr;
+    wl_array        m_wlrCoordinateArr;
 
     // for animations
-    CAnimatedVariable<Vector2D> m_vRenderOffset;
-    CAnimatedVariable<float>    m_fAlpha;
-    bool                        m_bForceRendering = false;
+    PHLANIMVAR<Vector2D> m_vRenderOffset;
+    PHLANIMVAR<float>    m_fAlpha;
+    bool                 m_bForceRendering = false;
 
     // allows damage to propagate.
     bool m_bVisible = false;
@@ -63,25 +60,35 @@ class CWorkspace {
 
     // Inert: destroyed and invalid. If this is true, release the ptr you have.
     bool             inert();
-
     void             startAnim(bool in, bool left, bool instant = false);
     void             setActive(bool on);
-
     void             moveToMonitor(const MONITORID&);
-
+    MONITORID        monitorID();
     PHLWINDOW        getLastFocusedWindow();
     void             rememberPrevWorkspace(const PHLWORKSPACE& prevWorkspace);
-
     std::string      getConfigName();
-
     bool             matchesStaticSelector(const std::string& selector);
-
     void             markInert();
-
-    SWorkspaceIDName getPrevWorkspaceIDName(bool perMonitor) const;
+    SWorkspaceIDName getPrevWorkspaceIDName() const;
+    void             updateWindowDecos();
+    void             updateWindowData();
+    int              getWindows(std::optional<bool> onlyTiled = {}, std::optional<bool> onlyVisible = {});
+    int              getGroups(std::optional<bool> onlyTiled = {}, std::optional<bool> onlyVisible = {});
+    bool             hasUrgentWindow();
+    PHLWINDOW        getFirstWindow();
+    PHLWINDOW        getTopLeftWindow();
+    PHLWINDOW        getFullscreenWindow();
+    bool             isVisible();
+    bool             isVisibleNotCovered();
+    void             rename(const std::string& name = "");
+    void             forceReportSizesToWindows();
+    void             updateWindows();
 
   private:
-    void                 init(PHLWORKSPACE self);
+    void init(PHLWORKSPACE self);
+    // Previous workspace ID and name is stored during a workspace change, allowing travel
+    // to the previous workspace.
+    SWorkspaceIDName     m_sPrevWorkspace;
 
     SP<HOOK_CALLBACK_FN> m_pFocusedWindowHook;
     bool                 m_bInert = true;

src/devices/IHID.hpp

@@ -4,14 +4,14 @@
 #include <string>
 #include "../helpers/signal/Signal.hpp"
 
-enum eHIDCapabilityType : uint32_t {
+enum eHIDCapabilityType : uint8_t {
     HID_INPUT_CAPABILITY_KEYBOARD = (1 << 0),
     HID_INPUT_CAPABILITY_POINTER  = (1 << 1),
     HID_INPUT_CAPABILITY_TOUCH    = (1 << 2),
     HID_INPUT_CAPABILITY_TABLET   = (1 << 3),
 };
 
-enum eHIDType {
+enum eHIDType : uint8_t {
     HID_TYPE_UNKNOWN = 0,
     HID_TYPE_POINTER,
     HID_TYPE_KEYBOARD,
@@ -27,7 +27,7 @@ enum eHIDType {
 */
 class IHID {
   public:
-    virtual ~IHID() {}
+    virtual ~IHID() = default;
 
     virtual uint32_t getCapabilities() = 0;
     virtual eHIDType getType();
@@ -36,5 +36,5 @@ class IHID {
         CSignal destroy;
     } events;
 
-    std::string deviceName;
+    std::string deviceName, hlName;
 };

src/devices/IKeyboard.cpp

@@ -8,6 +8,8 @@
 #include <aquamarine/input/Input.hpp>
 #include <cstring>
 
+using namespace Hyprutils::OS;
+
 #define LED_COUNT 3
 
 constexpr static std::array<const char*, 8> MODNAMES = {
@@ -41,13 +43,14 @@ void IKeyboard::clearManuallyAllocd() {
     if (xkbKeymap)
         xkb_keymap_unref(xkbKeymap);
 
-    if (xkbKeymapFD >= 0)
-        close(xkbKeymapFD);
+    if (xkbSymState)
+        xkb_state_unref(xkbSymState);
 
+    xkbSymState    = nullptr;
     xkbKeymap      = nullptr;
     xkbState       = nullptr;
     xkbStaticState = nullptr;
-    xkbKeymapFD    = -1;
+    xkbKeymapFD.reset();
 }
 
 void IKeyboard::setKeymap(const SStringRuleNames& rules) {
@@ -143,31 +146,30 @@ void IKeyboard::setKeymap(const SStringRuleNames& rules) {
 void IKeyboard::updateKeymapFD() {
     Debug::log(LOG, "Updating keymap fd for keyboard {}", deviceName);
 
-    if (xkbKeymapFD >= 0)
-        close(xkbKeymapFD);
-    xkbKeymapFD = -1;
+    if (xkbKeymapFD.isValid())
+        xkbKeymapFD.reset();
 
     auto cKeymapStr = xkb_keymap_get_as_string(xkbKeymap, XKB_KEYMAP_FORMAT_TEXT_V1);
     xkbKeymapString = cKeymapStr;
     free(cKeymapStr);
 
-    int rw, ro;
-    if (!allocateSHMFilePair(xkbKeymapString.length() + 1, &rw, &ro))
+    CFileDescriptor rw, ro;
+    if (!allocateSHMFilePair(xkbKeymapString.length() + 1, rw, ro))
         Debug::log(ERR, "IKeyboard: failed to allocate shm pair for the keymap");
     else {
-        auto keymapFDDest = mmap(nullptr, xkbKeymapString.length() + 1, PROT_READ | PROT_WRITE, MAP_SHARED, rw, 0);
-        close(rw);
+        auto keymapFDDest = mmap(nullptr, xkbKeymapString.length() + 1, PROT_READ | PROT_WRITE, MAP_SHARED, rw.get(), 0);
+        rw.reset();
         if (keymapFDDest == MAP_FAILED) {
             Debug::log(ERR, "IKeyboard: failed to mmap a shm pair for the keymap");
-            close(ro);
+            ro.reset();
         } else {
             memcpy(keymapFDDest, xkbKeymapString.c_str(), xkbKeymapString.length());
             munmap(keymapFDDest, xkbKeymapString.length() + 1);
-            xkbKeymapFD = ro;
+            xkbKeymapFD = std::move(ro);
         }
     }
 
-    Debug::log(LOG, "Updated keymap fd to {}", xkbKeymapFD);
+    Debug::log(LOG, "Updated keymap fd to {}", xkbKeymapFD.get());
 }
 
 void IKeyboard::updateXKBTranslationState(xkb_keymap* const keymap) {
@@ -178,13 +180,18 @@ void IKeyboard::updateXKBTranslationState(xkb_keymap* const keymap) {
     if (xkbState)
         xkb_state_unref(xkbState);
 
+    if (xkbSymState)
+        xkb_state_unref(xkbSymState);
+
     xkbState       = nullptr;
     xkbStaticState = nullptr;
+    xkbSymState    = nullptr;
 
     if (keymap) {
         Debug::log(LOG, "Updating keyboard {:x}'s translation state from a provided keymap", (uintptr_t)this);
         xkbStaticState = xkb_state_new(keymap);
         xkbState       = xkb_state_new(keymap);
+        xkbSymState    = xkb_state_new(keymap);
         return;
     }
 
@@ -230,6 +237,7 @@ void IKeyboard::updateXKBTranslationState(xkb_keymap* const keymap) {
 
             xkbState       = xkb_state_new(KEYMAP);
             xkbStaticState = xkb_state_new(KEYMAP);
+            xkbSymState    = xkb_state_new(KEYMAP);
 
             xkb_keymap_unref(KEYMAP);
             xkb_context_unref(PCONTEXT);
@@ -252,6 +260,7 @@ void IKeyboard::updateXKBTranslationState(xkb_keymap* const keymap) {
 
     xkbState       = xkb_state_new(NEWKEYMAP);
     xkbStaticState = xkb_state_new(NEWKEYMAP);
+    xkbSymState    = xkb_state_new(NEWKEYMAP);
 
     xkb_keymap_unref(NEWKEYMAP);
     xkb_context_unref(PCONTEXT);
@@ -332,6 +341,9 @@ void IKeyboard::updateModifiers(uint32_t depressed, uint32_t latched, uint32_t l
 
     xkb_state_update_mask(xkbState, depressed, latched, locked, 0, 0, group);
 
+    if (xkbSymState)
+        xkb_state_update_mask(xkbSymState, 0, 0, 0, 0, 0, group);
+
     if (!updateModifiersState())
         return;
 
@@ -382,6 +394,9 @@ void IKeyboard::updateXkbStateWithKey(uint32_t xkbKey, bool pressed) {
     xkb_state_update_key(xkbState, xkbKey, pressed ? XKB_KEY_DOWN : XKB_KEY_UP);
 
     if (updateModifiersState()) {
+        if (xkbSymState)
+            xkb_state_update_mask(xkbSymState, 0, 0, 0, 0, 0, modifiersState.group);
+
         keyboardEvents.modifiers.emit(SModifiersEvent{
             .depressed = modifiersState.depressed,
             .latched   = modifiersState.latched,

src/devices/IKeyboard.hpp

@@ -6,6 +6,7 @@
 
 #include <optional>
 #include <xkbcommon/xkbcommon.h>
+#include <hyprutils/os/FileDescriptor.hpp>
 
 AQUAMARINE_FORWARD(IKeyboard);
 
@@ -82,8 +83,9 @@ class IKeyboard : public IHID {
     bool               keymapOverridden = false;
 
     xkb_layout_index_t activeLayout = 0;
-    xkb_state *        xkbState = nullptr, *xkbStaticState /* Static state: never gets modifiers or layout changes sent, used for keybinds. */ = nullptr;
-    xkb_keymap*        xkbKeymap = nullptr;
+    xkb_state *        xkbState = nullptr, *xkbStaticState /* Static state: never gets modifiers or layout changes sent, used for keybinds. */ = nullptr,
+              *xkbSymState = nullptr /* Same as static but gets layouts */;
+    xkb_keymap* xkbKeymap  = nullptr;
 
     struct {
         uint32_t depressed = 0, latched = 0, locked = 0, group = 0;
@@ -93,10 +95,9 @@ class IKeyboard : public IHID {
     std::array<xkb_mod_index_t, 8> modIndexes = {XKB_MOD_INVALID};
     uint32_t                       leds       = 0;
 
-    std::string                    hlName          = "";
     std::string                    xkbFilePath     = "";
     std::string                    xkbKeymapString = "";
-    int                            xkbKeymapFD     = -1;
+    Hyprutils::OS::CFileDescriptor xkbKeymapFD;
 
     SStringRuleNames               currentRules;
     int                            repeatRate        = 0;

src/devices/IPointer.hpp

@@ -19,6 +19,7 @@ class IPointer : public IHID {
     struct SMotionEvent {
         uint32_t timeMs = 0;
         Vector2D delta, unaccel;
+        bool     mouse = false;
     };
 
     struct SMotionAbsoluteEvent {
@@ -31,6 +32,7 @@ class IPointer : public IHID {
         uint32_t                timeMs = 0;
         uint32_t                button = 0;
         wl_pointer_button_state state  = WL_POINTER_BUTTON_STATE_PRESSED;
+        bool                    mouse  = false;
     };
 
     struct SAxisEvent {
@@ -40,6 +42,7 @@ class IPointer : public IHID {
         wl_pointer_axis_relative_direction relativeDirection = WL_POINTER_AXIS_RELATIVE_DIRECTION_IDENTICAL;
         double                             delta             = 0.0;
         int32_t                            deltaDiscrete     = 0;
+        bool                               mouse             = false;
     };
 
     struct SSwipeBeginEvent {
@@ -104,7 +107,6 @@ class IPointer : public IHID {
         CSignal holdEnd;
     } pointerEvents;
 
-    std::string  hlName;
     bool         connected   = false; // means connected to the cursor
     std::string  boundOutput = "";
 

src/devices/ITouch.hpp

@@ -44,7 +44,6 @@ class ITouch : public IHID {
         CSignal frame;
     } touchEvents;
 
-    std::string hlName      = "";
     std::string boundOutput = "";
 
     WP<ITouch>  self;

src/devices/Keyboard.cpp

@@ -1,6 +1,5 @@
 #include "Keyboard.hpp"
 #include "../defines.hpp"
-#include "../Compositor.hpp"
 
 #include <aquamarine/input/Input.hpp>
 

src/devices/Mouse.cpp

@@ -26,6 +26,7 @@ CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : mouse(mouse_) {
             .timeMs  = E.timeMs,
             .delta   = E.delta,
             .unaccel = E.unaccel,
+            .mouse   = true,
         });
     });
 
@@ -46,6 +47,7 @@ CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : mouse(mouse_) {
             .timeMs = E.timeMs,
             .button = E.button,
             .state  = E.pressed ? WL_POINTER_BUTTON_STATE_PRESSED : WL_POINTER_BUTTON_STATE_RELEASED,
+            .mouse  = true,
         });
     });
 
@@ -59,6 +61,7 @@ CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : mouse(mouse_) {
             .relativeDirection = (wl_pointer_axis_relative_direction)E.direction,
             .delta             = E.delta,
             .deltaDiscrete     = E.discrete,
+            .mouse             = true,
         });
     });
 

src/devices/Tablet.cpp

@@ -197,7 +197,7 @@ CTabletPad::CTabletPad(SP<Aquamarine::ITabletPad> pad_) : pad(pad_) {
         });
     });
 
-    listeners.attach = pad->events.attach.registerListener([this](std::any d) {
+    listeners.attach = pad->events.attach.registerListener([](std::any d) {
         ; // TODO: this doesn't do anything in aq atm
     });
 

src/devices/Tablet.hpp

@@ -3,7 +3,6 @@
 #include "IHID.hpp"
 #include "../macros.hpp"
 #include "../helpers/math/Math.hpp"
-#include "../helpers/math/Math.hpp"
 
 AQUAMARINE_FORWARD(ITablet);
 AQUAMARINE_FORWARD(ITabletTool);
@@ -27,7 +26,7 @@ class CTablet : public IHID {
     virtual eHIDType        getType();
     SP<Aquamarine::ITablet> aq();
 
-    enum eTabletToolAxes {
+    enum eTabletToolAxes : uint16_t {
         HID_TABLET_TOOL_AXIS_X        = (1 << 0),
         HID_TABLET_TOOL_AXIS_Y        = (1 << 1),
         HID_TABLET_TOOL_AXIS_TILT_X   = (1 << 2),
@@ -92,10 +91,10 @@ class CTablet : public IHID {
     WP<CTablet> self;
 
     bool        relativeInput = false;
-    std::string hlName        = "";
+    bool        absolutePos   = false;
     std::string boundOutput   = "";
     CBox        activeArea;
-    CBox        boundBox; // output-local
+    CBox        boundBox;
 
   private:
     CTablet(SP<Aquamarine::ITablet> tablet);
@@ -154,8 +153,6 @@ class CTabletPad : public IHID {
     WP<CTabletPad>  self;
     WP<CTabletTool> parent;
 
-    std::string     hlName;
-
   private:
     CTabletPad(SP<Aquamarine::ITabletPad> pad);
 
@@ -175,7 +172,7 @@ class CTabletTool : public IHID {
     static SP<CTabletTool> create(SP<Aquamarine::ITabletTool> tool);
     ~CTabletTool();
 
-    enum eTabletToolType {
+    enum eTabletToolType : uint8_t {
         HID_TABLET_TOOL_TYPE_PEN = 1,
         HID_TABLET_TOOL_TYPE_ERASER,
         HID_TABLET_TOOL_TYPE_BRUSH,
@@ -186,7 +183,7 @@ class CTabletTool : public IHID {
         HID_TABLET_TOOL_TYPE_TOTEM,
     };
 
-    enum eTabletToolCapabilities {
+    enum eTabletToolCapabilities : uint8_t {
         HID_TABLET_TOOL_CAPABILITY_TILT     = (1 << 0),
         HID_TABLET_TOOL_CAPABILITY_PRESSURE = (1 << 1),
         HID_TABLET_TOOL_CAPABILITY_DISTANCE = (1 << 2),
@@ -210,8 +207,6 @@ class CTabletTool : public IHID {
     std::vector<uint32_t>       buttonsDown;
     Vector2D                    absolutePos; // last known absolute position.
 
-    std::string                 hlName;
-
   private:
     CTabletTool(SP<Aquamarine::ITabletTool> tool);
 

src/devices/VirtualPointer.cpp

@@ -11,7 +11,7 @@ SP<CVirtualPointer> CVirtualPointer::create(SP<CVirtualPointerV1Resource> resour
 }
 
 CVirtualPointer::CVirtualPointer(SP<CVirtualPointerV1Resource> resource) : pointer(resource) {
-    if (!resource->good())
+    if UNLIKELY (!resource->good())
         return;
 
     listeners.destroy = pointer->events.destroy.registerListener([this](std::any d) {
@@ -38,7 +38,7 @@ CVirtualPointer::CVirtualPointer(SP<CVirtualPointerV1Resource> resource) : point
     listeners.holdBegin      = pointer->events.holdBegin.registerListener([this](std::any d) { pointerEvents.holdBegin.emit(d); });
     listeners.holdEnd        = pointer->events.holdEnd.registerListener([this](std::any d) { pointerEvents.holdEnd.emit(d); });
 
-    boundOutput = resource->boundOutput ? resource->boundOutput->szName : "entire";
+    boundOutput = resource->boundOutput ? resource->boundOutput->szName : "";
 
     deviceName = pointer->name;
 }