[gha] Nix: update inputs

* core: Don't damage the entire surface every frame

* core: Damage buffer on dims or transform change

* core: Use guards for scale and tr equality checks

.github/ISSUE_TEMPLATE/bug.yml

@@ -1,15 +1,117 @@
-name: Do not open issues, go to discussions please!
-description: Do not open an issue
+name: Bug Report
+description: Something is not working right
+labels: ["bug"]
 body:
   - type: checkboxes
     attributes:
-      label: Please close this issue.
-      description: Users cannot open issues. I want my issue to be closed.
+      label: Already reported ? *
+      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: Yes, I want this issue to be closed.
+        - label: I have searched the existing open and closed issues.
+          required: true
+
+  - type: dropdown
+    id: type
+    attributes:
+      label: Regression?
+      description: |
+        Regression means that something used to work but no longer does.
+        **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:
+        - "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: body
+    id: ver
     attributes:
-      label: Issue body
+      label: System Info and Hyprland Version
+      description: |
+        Paste the output of `hyprctl systeminfo` here. If you can't
+        launch Hyprland, paste the output of `Hyprland --systeminfo`.
+      value: "<details>
+        <summary>System/Version info</summary>
+
+
+        ```
+
+        <Paste the output of the command here, without removing any formatting around this>
+
+        ```
+
+
+        </details>"
+    validations:
+      required: true
+
+  - type: textarea
+    id: desc
+    attributes:
+      label: Description
+      description: "What went wrong?"
+    validations:
+      required: true
+
+  - type: textarea
+    id: repro
+    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: Additional info & File uploads
+      description: |
+        Tip: You can attach files by clicking this area to highlight it and then dragging files in.

.github/ISSUE_TEMPLATE/feature.yml

@@ -0,0 +1,19 @@
+name: Feature Request
+description: I'd like to request additional functionality
+labels: ["enhancement"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Before opening a new issue, take a moment to search through the current open ones.
+
+        ---
+
+  - type: textarea
+    id: desc
+    attributes:
+      label: Description
+      description: "Describe your idea"
+    validations:
+      required: true
+

.github/actions/setup_base/action.yml

@@ -20,7 +20,6 @@ runs:
           clang \
           cmake \
           git \
-          glaze \
           glm \
           glslang \
           go \
@@ -65,6 +64,15 @@ runs:
           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
       run: |

.github/workflows/close-issues.yml

@@ -1,101 +0,0 @@
-name: Close Unauthorized Issues
-
-on:
-  workflow_dispatch:
-  issues:
-    types: [opened]
-
-jobs:
-  close-unauthorized-issues:
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-    steps:
-      # XXX: This *could* be done in Bash by abusing GitHub's own tool to interact with its API
-      # but that's too much of a hack, and we'll be adding a layer of abstraction. github-script
-      # is a workflow that eases interaction with GitHub API in the workflow run context.
-      - name: "Close 'unauthorized' issues"
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            const ALLOWED_USERS = ['vaxerski', 'fufexan', 'NotAShelf'];
-            const CLOSING_COMMENT = 'Users are no longer allowed to open issues themselves, please open a discussion instead.\n\nPlease see the [wiki](https://wiki.hyprland.org/Contributing-and-Debugging/Issue-Guidelines/) on why this is the case.\n\nWe are volunteers, and we need your cooperation to make the best software we can. Thank you for understanding! ❤️\n\n[Open a discussion here](https://github.com/hyprwm/Hyprland/discussions)';
-
-            async function closeUnauthorizedIssue(issueNumber, userName) {
-              if (ALLOWED_USERS.includes(userName)) {
-                console.log(`Issue #${issueNumber} - Created by authorized user ${userName}`);
-                return;
-              }
-
-              console.log(`Issue #${issueNumber} - Unauthorized, closing`);
-
-              await github.rest.issues.update({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: issueNumber,
-                state: 'closed',
-                state_reason: 'not_planned'
-              });
-
-              await github.rest.issues.createComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: issueNumber,
-                body: CLOSING_COMMENT
-              });
-            }
-
-            if (context.eventName === 'issues' && context.payload.action === 'opened') {
-              // Direct access to the issue that triggered the workflow
-              const issue = context.payload.issue;
-
-              // Skip if this is a PR
-              if (issue.pull_request) {
-                console.log(`Issue #${issue.number} - Skipping, this is a pull request`);
-                return;
-              }
-
-              // Process the single issue that triggered the workflow
-              await closeUnauthorizedIssue(issue.number, issue.user.login);
-            } else {
-              // For manual runs, we need to handle pagination
-              async function* fetchAllOpenIssues() {
-                let page = 1;
-                let hasNextPage = true;
-
-                while (hasNextPage) {
-                  const response = await github.rest.issues.listForRepo({
-                    owner: context.repo.owner,
-                    repo: context.repo.repo,
-                    state: 'open',
-                    per_page: 100,
-                    page: page
-                  });
-
-                  if (response.data.length === 0) {
-                    hasNextPage = false;
-                  } else {
-                    for (const issue of response.data) {
-                      yield issue;
-                    }
-                    page++;
-                  }
-                }
-              }
-
-              // Process issues one by one
-              for await (const issue of fetchAllOpenIssues()) {
-                try {
-                  // Skip pull requests
-                  if (issue.pull_request) {
-                    console.log(`Issue #${issue.number} - Skipping, this is a pull request`);
-                    continue;
-                  }
-
-                  await closeUnauthorizedIssue(issue.number, issue.user.login);
-                } catch (error) {
-                  console.error(`Error processing issue #${issue.number}: ${error.message}`);
-                }
-              }
-            }

.github/workflows/stale.yml

@@ -0,0 +1,28 @@
+# This workflow warns and then closes issues and PRs that have had no activity for a specified amount of time.
+#
+# You can adjust the behavior by modifying this file.
+# For more information, see:
+# https://github.com/actions/stale
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+    - cron: "7 */4 * * *"
+  workflow_dispatch:
+
+jobs:
+  stale:
+    if: github.repository == 'hyprwm/Hyprland'
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/stale@v9
+        with:
+          repo-token: ${{ secrets.STALEBOT_PAT }}
+          stale-issue-label: "stale"
+          stale-pr-label: "stale"
+          operations-per-run: 40
+          days-before-close: -1

.gitignore

@@ -28,8 +28,6 @@ protocols/*.c*
 protocols/*.h*
 .ccls-cache
 *.so
-src/render/shaders/*.inc
-src/render/shaders/Shaders.hpp
 
 hyprctl/hyprctl
 

CMakeLists.txt

@@ -25,9 +25,6 @@ message(STATUS "Gathering git info")
 # Get git info hash and branch
 execute_process(COMMAND ./scripts/generateVersion.sh
                 WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
-# Make shader files includable
-execute_process(COMMAND ./scripts/generateShaderIncludes.sh
-                WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
 
 find_package(PkgConfig REQUIRED)
 
@@ -89,7 +86,6 @@ add_compile_options(
   -Wno-missing-field-initializers
   -Wno-narrowing
   -Wno-pointer-arith
-  -Wno-clobbered
   -fmacro-prefix-map=${CMAKE_SOURCE_DIR}/=)
 
 set(CMAKE_EXECUTABLE_ENABLE_EXPORTS TRUE)
@@ -109,7 +105,7 @@ find_package(OpenGL REQUIRED COMPONENTS ${GLES_VERSION})
 pkg_check_modules(aquamarine_dep REQUIRED IMPORTED_TARGET aquamarine>=0.8.0)
 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.7.0)
+pkg_check_modules(hyprutils_dep REQUIRED IMPORTED_TARGET hyprutils>=0.5.1)
 pkg_check_modules(hyprgraphics_dep REQUIRED IMPORTED_TARGET hyprgraphics>=0.1.1)
 
 string(REPLACE "." ";" AQ_VERSION_LIST ${aquamarine_dep_VERSION})
@@ -133,7 +129,7 @@ pkg_check_modules(
   xkbcommon
   uuid
   wayland-server>=1.22.90
-  wayland-protocols>=1.43
+  wayland-protocols>=1.41
   cairo
   pango
   pangocairo
@@ -317,7 +313,7 @@ endfunction()
 
 target_link_libraries(Hyprland OpenGL::EGL OpenGL::GL Threads::Threads)
 
-pkg_check_modules(hyprland_protocols_dep hyprland-protocols>=0.6.4)
+pkg_check_modules(hyprland_protocols_dep hyprland-protocols>=0.6.2)
 if(hyprland_protocols_dep_FOUND)
   pkg_get_variable(HYPRLAND_PROTOCOLS hyprland-protocols pkgdatadir)
   message(STATUS "hyprland-protocols dependency set to ${HYPRLAND_PROTOCOLS}")
@@ -349,7 +345,6 @@ 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("${HYPRLAND_PROTOCOLS}/protocols" "hyprland-toplevel-mapping-v1" true)
 
 protocolnew("staging/tearing-control" "tearing-control-v1" false)
 protocolnew("staging/fractional-scale" "fractional-scale-v1" false)
@@ -384,8 +379,6 @@ protocolnew("staging/single-pixel-buffer" "single-pixel-buffer-v1" false)
 protocolnew("staging/security-context" "security-context-v1" false)
 protocolnew("staging/content-type" "content-type-v1" false)
 protocolnew("staging/color-management" "color-management-v1" false)
-protocolnew("staging/xdg-toplevel-tag" "xdg-toplevel-tag-v1" false)
-protocolnew("staging/xdg-system-bell" "xdg-system-bell-v1" false)
 
 protocolwayland()
 
@@ -451,7 +444,5 @@ install(
   DIRECTORY ${HEADERS_SRC}
   DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hyprland
   FILES_MATCHING
-  PATTERN "*.h"
-  PATTERN "*.hpp"
-  PATTERN "*.inc"
-  )
+  PATTERN "*.h*"
+  PATTERN "*.frag")

Makefile

@@ -52,7 +52,7 @@ installheaders:
 
 	cmake --build ./build --config Release --target generate-protocol-headers
 
-	find src -type f \( -name '*.hpp' -o -name '*.h' -o -name '*.inc' \) -print0 | cpio --quiet -0dump ${PREFIX}/include/hyprland
+	find src -name '*.h*' -print0 | cpio --quiet -0dump ${PREFIX}/include/hyprland
 	cp ./protocols/*.h* ${PREFIX}/include/hyprland/protocols
 	cp ./build/hyprland.pc ${PREFIX}/share/pkgconfig
 	if [ -d /usr/share/pkgconfig ]; then cp ./build/hyprland.pc /usr/share/pkgconfig 2>/dev/null || true; fi

SECURITY.md

@@ -1,32 +0,0 @@
-# Hyprland Development Security Policy
-
-If you have a bug that affects the security of your system, you may
-want to privately disclose it instead of making it immediately public.
-
-## Supported versions
-
-_Only_ the most recent release on Github is supported. There are no LTS releases.
-
-## What is not a security issue
-
-Some examples of issues that should not be reported as security issues:
-
-- An app can execute a command when ran outside of a sandbox
-- An app can write / read hyprland sockets when ran outside of a sandbox
-- Crashes
-- Things that are protected via permissions when the permission system is disabled
-
-## What is a security issue
-
-Some examples of issues that should be reported as security issues:
-
-- Sandboxed application executing arbitrary code via Hyprland
-- Application being able to modify Hyprland's code on the fly
-- Application being able to keylog / track user's activity beyond what the wayland protocols allow
-
-## How to report security issues
-
-Please report your security issues via either of these channels:
-- Mail: `vaxry [at] vaxry [dot] net`
-- Matrix: `@vaxry:matrix.vaxry.net`
-- Discord: `@vaxry`

VERSION

@@ -1 +1 @@
-0.49.0
+0.48.1

example/hyprland.conf

@@ -52,23 +52,6 @@ env = XCURSOR_SIZE,24
 env = HYPRCURSOR_SIZE,24
 
 
-###################
-### PERMISSIONS ###
-###################
-
-# See https://wiki.hyprland.org/Configuring/Permissions/
-# Please note permission changes here require a Hyprland restart and are not applied on-the-fly
-# for security reasons
-
-# ecosystem {
-#   enforce_permissions = 1
-# }
-
-# permission = /usr/(bin|local/bin)/grim, screencopy, allow
-# permission = /usr/(lib|libexec|lib64)/xdg-desktop-portal-hyprland, screencopy, allow
-# permission = /usr/(bin|local/bin)/hyprpm, plugin, allow
-
-
 #####################
 ### LOOK AND FEEL ###
 #####################
@@ -277,8 +260,8 @@ bindel = ,XF86AudioRaiseVolume, exec, wpctl set-volume -l 1 @DEFAULT_AUDIO_SINK@
 bindel = ,XF86AudioLowerVolume, exec, wpctl set-volume @DEFAULT_AUDIO_SINK@ 5%-
 bindel = ,XF86AudioMute, exec, wpctl set-mute @DEFAULT_AUDIO_SINK@ toggle
 bindel = ,XF86AudioMicMute, exec, wpctl set-mute @DEFAULT_AUDIO_SOURCE@ toggle
-bindel = ,XF86MonBrightnessUp, exec, brightnessctl -e4 -n2 set 5%+
-bindel = ,XF86MonBrightnessDown, exec, brightnessctl -e4 -n2 set 5%-
+bindel = ,XF86MonBrightnessUp, exec, brightnessctl s 10%+
+bindel = ,XF86MonBrightnessDown, exec, brightnessctl s 10%-
 
 # Requires playerctl
 bindl = , XF86AudioNext, exec, playerctl next

flake.lock

@@ -16,11 +16,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1745357003,
-        "narHash": "sha256-jYwzQkv1r7HN/4qrAuKp+NR4YYNp2xDrOX5O9YVqkWo=",
+        "lastModified": 1742213273,
+        "narHash": "sha256-0l0vDb4anfsBu1rOs94bC73Hub+xEivgBAo6QXl2MmU=",
         "owner": "hyprwm",
         "repo": "aquamarine",
-        "rev": "a19cf76ee1a15c1c12083fa372747ce46387289f",
+        "rev": "484b732195cc53f4536ce4bd59a5c6402b1e7ccf",
         "type": "github"
       },
       "original": {
@@ -79,11 +79,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1745948457,
-        "narHash": "sha256-lzTV10FJTCGNtMdgW5YAhCAqezeAzKOd/97HbQK8GTU=",
+        "lastModified": 1742215578,
+        "narHash": "sha256-zfs71PXVVPEe56WEyNi2TJQPs0wabU4WAlq0XV7GcdE=",
         "owner": "hyprwm",
         "repo": "hyprcursor",
-        "rev": "ac903e80b33ba6a88df83d02232483d99f327573",
+        "rev": "2fd36421c21aa87e2fe3bee11067540ae612f719",
         "type": "github"
       },
       "original": {
@@ -105,11 +105,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1745015490,
-        "narHash": "sha256-apEJ9zoSzmslhJ2vOKFcXTMZLUFYzh1ghfB6Rbw3Low=",
+        "lastModified": 1739049071,
+        "narHash": "sha256-3+7TpXMrbsUXSwgr5VAKAnmkzMb6JO+Rvc9XRb5NMg4=",
         "owner": "hyprwm",
         "repo": "hyprgraphics",
-        "rev": "60754910946b4e2dc1377b967b7156cb989c5873",
+        "rev": "175c6b29b6ff82100539e7c4363a35a02c74dd73",
         "type": "github"
       },
       "original": {
@@ -128,11 +128,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1743714874,
-        "narHash": "sha256-yt8F7NhMFCFHUHy/lNjH/pjZyIDFNk52Q4tivQ31WFo=",
+        "lastModified": 1738422629,
+        "narHash": "sha256-5v+bv75wJWvahyM2xcMTSNNxmV8a7hb01Eey5zYnBJw=",
         "owner": "hyprwm",
         "repo": "hyprland-protocols",
-        "rev": "3a5c2bda1c1a4e55cc1330c782547695a93f05b2",
+        "rev": "755aef8dab49d0fc4663c715fa4ad221b2aedaed",
         "type": "github"
       },
       "original": {
@@ -189,11 +189,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1745951494,
-        "narHash": "sha256-2dModE32doiyQMmd6EDAQeZnz+5LOs6KXyE0qX76WIg=",
+        "lastModified": 1739048983,
+        "narHash": "sha256-REhTcXq4qs3B3cCDtLlYDz0GZvmsBSh947Ub6pQWGTQ=",
         "owner": "hyprwm",
         "repo": "hyprland-qtutils",
-        "rev": "4be1d324faf8d6e82c2be9f8510d299984dfdd2e",
+        "rev": "3504a293c8f8db4127cb0f7cfc1a318ffb4316f8",
         "type": "github"
       },
       "original": {
@@ -215,11 +215,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1746655412,
-        "narHash": "sha256-kVQ0bHVtX6baYxRWWIh4u3LNJZb9Zcm2xBeDPOGz5BY=",
+        "lastModified": 1741191527,
+        "narHash": "sha256-kM+11Nch47Xwfgtw2EpRitJuORy4miwoMuRi5tyMBDY=",
         "owner": "hyprwm",
         "repo": "hyprlang",
-        "rev": "557241780c179cf7ef224df392f8e67dab6cef83",
+        "rev": "72df3861f1197e41b078faa3e38eedd60e00018d",
         "type": "github"
       },
       "original": {
@@ -238,11 +238,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1746635225,
-        "narHash": "sha256-W9G9bb0zRYDBRseHbVez0J8qVpD5QbizX67H/vsudhM=",
+        "lastModified": 1742984269,
+        "narHash": "sha256-uz9FaCIbga/gQ5ZG1Hb4HVVjTWT1qjjCAFlCXiaefxg=",
         "owner": "hyprwm",
         "repo": "hyprutils",
-        "rev": "674ea57373f08b7609ce93baff131117a0dfe70d",
+        "rev": "7248194a2ce0106ae647b70d0526a96dc9d6ad60",
         "type": "github"
       },
       "original": {
@@ -276,11 +276,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1746461020,
-        "narHash": "sha256-7+pG1I9jvxNlmln4YgnlW4o+w0TZX24k688mibiFDUE=",
+        "lastModified": 1742889210,
+        "narHash": "sha256-hw63HnwnqU3ZQfsMclLhMvOezpM7RSB0dMAtD5/sOiw=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "3730d8a308f94996a9ba7c7138ede69c1b9ac4ae",
+        "rev": "698214a32beb4f4c8e3942372c694f40848b360d",
         "type": "github"
       },
       "original": {
@@ -299,11 +299,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1746537231,
-        "narHash": "sha256-Wb2xeSyOsCoTCTj7LOoD6cdKLEROyFAArnYoS+noCWo=",
+        "lastModified": 1742649964,
+        "narHash": "sha256-DwOTp7nvfi8mRfuL1escHDXabVXFGT1VlPD1JHrtrco=",
         "owner": "cachix",
         "repo": "git-hooks.nix",
-        "rev": "fa466640195d38ec97cf0493d6d6882bc4d14969",
+        "rev": "dcf5072734cb576d2b0c59b2ac44f5050b5eac82",
         "type": "github"
       },
       "original": {
@@ -365,11 +365,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1745871725,
-        "narHash": "sha256-M24SNc2flblWGXFkGQfqSlEOzAGZnMc9QG3GH4K/KbE=",
+        "lastModified": 1741934139,
+        "narHash": "sha256-ZhTcTH9FoeAtbPfWGrhkH7RjLJZ7GeF18nygLAMR+WE=",
         "owner": "hyprwm",
         "repo": "xdg-desktop-portal-hyprland",
-        "rev": "76bbf1a6b1378e4ab5230bad00ad04bc287c969e",
+        "rev": "150b0b6f52bb422a1b232a53698606fe0320dde0",
         "type": "github"
       },
       "original": {

hyprctl/hyprctl.bash

@@ -23,7 +23,7 @@ _hyprctl () {
     local words cword
     _get_comp_words_by_ref -n "$COMP_WORDBREAKS" words cword
 
-    declare -a literals=(resizeactive 2 changegroupactive -r moveintogroup forceallowsinput 4 ::= systeminfo all layouts setprop animationstyle switchxkblayout create denywindowfromgroup headless activebordercolor exec setcursor wayland focusurgentorlast workspacerules movecurrentworkspacetomonitor movetoworkspacesilent hyprpaper alpha inactivebordercolor movegroupwindow movecursortocorner movewindowpixel prev movewindow globalshortcuts clients dimaround setignoregrouplock splash execr monitors 0 forcenoborder -q animations 1 nomaxsize splitratio moveactive pass swapnext devices layers rounding lockactivegroup 5 moveworkspacetomonitor -f -i --quiet forcenodim pin 0 1 forceopaque forcenoshadow setfloating minsize alphaoverride sendshortcut workspaces cyclenext alterzorder togglegroup lockgroups bordersize dpms focuscurrentorlast -1 --batch notify remove instances 1 3 moveoutofgroup killactive 2 movetoworkspace movecursor configerrors closewindow swapwindow tagwindow forcerendererreload centerwindow auto focuswindow seterror nofocus alphafullscreen binds version -h togglespecialworkspace fullscreen windowdancecompat 0 keyword toggleopaque 3 --instance togglefloating renameworkspace alphafullscreenoverride activeworkspace x11 kill forceopaqueoverriden output global dispatch reload forcenoblur -j event --help disable -1 activewindow keepaspectratio dismissnotify focusmonitor movefocus plugin exit workspace fullscreenstate getoption alphainactiveoverride alphainactive decorations settiled config-only descriptions resizewindowpixel fakefullscreen rollinglog swapactiveworkspaces submap next movewindoworgroup cursorpos forcenoanims focusworkspaceoncurrentmonitor maxsize sendkeystate)
+    declare -a literals=(resizeactive 2 changegroupactive -r moveintogroup forceallowsinput 4 ::= systeminfo all layouts setprop animationstyle switchxkblayout create denywindowfromgroup headless activebordercolor exec setcursor wayland focusurgentorlast workspacerules movecurrentworkspacetomonitor movetoworkspacesilent hyprpaper alpha inactivebordercolor movegroupwindow movecursortocorner movewindowpixel prev movewindow globalshortcuts clients dimaround setignoregrouplock splash execr monitors 0 forcenoborder -q animations 1 nomaxsize splitratio moveactive pass swapnext devices layers rounding lockactivegroup 5 moveworkspacetomonitor -f -i --quiet forcenodim pin 0 1 forceopaque forcenoshadow setfloating minsize alphaoverride sendshortcut workspaces cyclenext alterzorder togglegroup lockgroups bordersize dpms focuscurrentorlast -1 --batch notify remove instances 1 3 moveoutofgroup killactive 2 movetoworkspace movecursor configerrors closewindow swapwindow tagwindow forcerendererreload centerwindow auto focuswindow seterror nofocus alphafullscreen binds version -h togglespecialworkspace fullscreen windowdancecompat 0 keyword toggleopaque 3 --instance togglefloating renameworkspace alphafullscreenoverride activeworkspace x11 kill forceopaqueoverriden output global dispatch reload forcenoblur -j event --help disable -1 activewindow keepaspectratio dismissnotify focusmonitor movefocus plugin exit workspace fullscreenstate getoption alphainactiveoverride alphainactive decorations settiled config-only descriptions resizewindowpixel fakefullscreen rollinglog swapactiveworkspaces submap next movewindoworgroup cursorpos forcenoanims focusworkspaceoncurrentmonitor maxsize)
     declare -A literal_transitions
     literal_transitions[0]="([120]=14 [43]=2 [125]=21 [81]=2 [3]=21 [51]=2 [50]=2 [128]=2 [89]=2 [58]=21 [8]=2 [10]=2 [11]=3 [130]=4 [13]=5 [97]=6 [101]=2 [102]=21 [133]=7 [100]=2 [137]=2 [22]=2 [19]=2 [140]=8 [25]=2 [143]=2 [107]=9 [146]=10 [69]=2 [33]=2 [34]=2 [78]=21 [114]=2 [37]=2 [151]=2 [116]=2 [121]=13 [123]=21 [39]=11 [42]=21 [79]=15 [118]=12)"
     literal_transitions[1]="([81]=2 [51]=2 [50]=2 [128]=2 [8]=2 [89]=2 [10]=2 [11]=3 [130]=4 [13]=5 [97]=6 [101]=2 [133]=7 [100]=2 [22]=2 [19]=2 [137]=2 [140]=8 [25]=2 [143]=2 [107]=9 [146]=10 [69]=2 [33]=2 [34]=2 [114]=2 [37]=2 [151]=2 [116]=2 [39]=11 [118]=12 [121]=13 [120]=14 [79]=15 [43]=2)"

hyprctl/hyprctl.fish

@@ -29,7 +29,7 @@ function _hyprctl
         set COMP_CWORD (count $COMP_WORDS)
     end
 
-    set literals "resizeactive" "2" "changegroupactive" "-r" "moveintogroup" "forceallowsinput" "4" "::=" "systeminfo" "all" "layouts" "setprop" "animationstyle" "switchxkblayout" "create" "denywindowfromgroup" "headless" "activebordercolor" "exec" "setcursor" "wayland" "focusurgentorlast" "workspacerules" "movecurrentworkspacetomonitor" "movetoworkspacesilent" "hyprpaper" "alpha" "inactivebordercolor" "movegroupwindow" "movecursortocorner" "movewindowpixel" "prev" "movewindow" "globalshortcuts" "clients" "dimaround" "setignoregrouplock" "splash" "execr" "monitors" "0" "forcenoborder" "-q" "animations" "1" "nomaxsize" "splitratio" "moveactive" "pass" "swapnext" "devices" "layers" "rounding" "lockactivegroup" "5" "moveworkspacetomonitor" "-f" "-i" "--quiet" "forcenodim" "pin" "0" "1" "forceopaque" "forcenoshadow" "setfloating" "minsize" "alphaoverride" "sendshortcut" "workspaces" "cyclenext" "alterzorder" "togglegroup" "lockgroups" "bordersize" "dpms" "focuscurrentorlast" "-1" "--batch" "notify" "remove" "instances" "1" "3" "moveoutofgroup" "killactive" "2" "movetoworkspace" "movecursor" "configerrors" "closewindow" "swapwindow" "tagwindow" "forcerendererreload" "centerwindow" "auto" "focuswindow" "seterror" "nofocus" "alphafullscreen" "binds" "version" "-h" "togglespecialworkspace" "fullscreen" "windowdancecompat" "0" "keyword" "toggleopaque" "3" "--instance" "togglefloating" "renameworkspace" "alphafullscreenoverride" "activeworkspace" "x11" "kill" "forceopaqueoverriden" "output" "global" "dispatch" "reload" "forcenoblur" "-j" "event" "--help" "disable" "-1" "activewindow" "keepaspectratio" "dismissnotify" "focusmonitor" "movefocus" "plugin" "exit" "workspace" "fullscreenstate" "getoption" "alphainactiveoverride" "alphainactive" "decorations" "settiled" "config-only" "descriptions" "resizewindowpixel" "fakefullscreen" "rollinglog" "swapactiveworkspaces" "submap" "next" "movewindoworgroup" "cursorpos" "forcenoanims" "focusworkspaceoncurrentmonitor" "maxsize" "sendkeystate"
+    set literals "resizeactive" "2" "changegroupactive" "-r" "moveintogroup" "forceallowsinput" "4" "::=" "systeminfo" "all" "layouts" "setprop" "animationstyle" "switchxkblayout" "create" "denywindowfromgroup" "headless" "activebordercolor" "exec" "setcursor" "wayland" "focusurgentorlast" "workspacerules" "movecurrentworkspacetomonitor" "movetoworkspacesilent" "hyprpaper" "alpha" "inactivebordercolor" "movegroupwindow" "movecursortocorner" "movewindowpixel" "prev" "movewindow" "globalshortcuts" "clients" "dimaround" "setignoregrouplock" "splash" "execr" "monitors" "0" "forcenoborder" "-q" "animations" "1" "nomaxsize" "splitratio" "moveactive" "pass" "swapnext" "devices" "layers" "rounding" "lockactivegroup" "5" "moveworkspacetomonitor" "-f" "-i" "--quiet" "forcenodim" "pin" "0" "1" "forceopaque" "forcenoshadow" "setfloating" "minsize" "alphaoverride" "sendshortcut" "workspaces" "cyclenext" "alterzorder" "togglegroup" "lockgroups" "bordersize" "dpms" "focuscurrentorlast" "-1" "--batch" "notify" "remove" "instances" "1" "3" "moveoutofgroup" "killactive" "2" "movetoworkspace" "movecursor" "configerrors" "closewindow" "swapwindow" "tagwindow" "forcerendererreload" "centerwindow" "auto" "focuswindow" "seterror" "nofocus" "alphafullscreen" "binds" "version" "-h" "togglespecialworkspace" "fullscreen" "windowdancecompat" "0" "keyword" "toggleopaque" "3" "--instance" "togglefloating" "renameworkspace" "alphafullscreenoverride" "activeworkspace" "x11" "kill" "forceopaqueoverriden" "output" "global" "dispatch" "reload" "forcenoblur" "-j" "event" "--help" "disable" "-1" "activewindow" "keepaspectratio" "dismissnotify" "focusmonitor" "movefocus" "plugin" "exit" "workspace" "fullscreenstate" "getoption" "alphainactiveoverride" "alphainactive" "decorations" "settiled" "config-only" "descriptions" "resizewindowpixel" "fakefullscreen" "rollinglog" "swapactiveworkspaces" "submap" "next" "movewindoworgroup" "cursorpos" "forcenoanims" "focusworkspaceoncurrentmonitor" "maxsize"
 
     set descriptions
     set descriptions[1] "Resize the active window"

hyprctl/hyprctl.usage

@@ -106,7 +106,6 @@ hyprctl [<OPTIONS>]... <ARGUMENTS>
                 |  (execr)           	                              "Execute a raw shell command"
                 |  (pass)            	                              "Pass the key to a specified window"
                 |  (sendshortcut)            	                      "On shortcut X sends shortcut Y to a specified window"
-                |  (sendkeystate)            	                      "Send a key with specific state (down/repeat/up) to a specified window (window must keep focus for events to continue)"
                 |  (killactive)          	                          "Close the active window"
                 |  (closewindow)         	                          "Close a specified window"
                 |  (workspace)           	                          "Change the workspace"

hyprctl/hyprctl.zsh

@@ -17,7 +17,7 @@ _hyprctl_cmd_0 () {
 }
 
 _hyprctl () {
-    local -a literals=("resizeactive" "2" "changegroupactive" "-r" "moveintogroup" "forceallowsinput" "4" "::=" "systeminfo" "all" "layouts" "setprop" "animationstyle" "switchxkblayout" "create" "denywindowfromgroup" "headless" "activebordercolor" "exec" "setcursor" "wayland" "focusurgentorlast" "workspacerules" "movecurrentworkspacetomonitor" "movetoworkspacesilent" "hyprpaper" "alpha" "inactivebordercolor" "movegroupwindow" "movecursortocorner" "movewindowpixel" "prev" "movewindow" "globalshortcuts" "clients" "dimaround" "setignoregrouplock" "splash" "execr" "monitors" "0" "forcenoborder" "-q" "animations" "1" "nomaxsize" "splitratio" "moveactive" "pass" "swapnext" "devices" "layers" "rounding" "lockactivegroup" "5" "moveworkspacetomonitor" "-f" "-i" "--quiet" "forcenodim" "pin" "0" "1" "forceopaque" "forcenoshadow" "setfloating" "minsize" "alphaoverride" "sendshortcut" "workspaces" "cyclenext" "alterzorder" "togglegroup" "lockgroups" "bordersize" "dpms" "focuscurrentorlast" "-1" "--batch" "notify" "remove" "instances" "1" "3" "moveoutofgroup" "killactive" "2" "movetoworkspace" "movecursor" "configerrors" "closewindow" "swapwindow" "tagwindow" "forcerendererreload" "centerwindow" "auto" "focuswindow" "seterror" "nofocus" "alphafullscreen" "binds" "version" "-h" "togglespecialworkspace" "fullscreen" "windowdancecompat" "0" "keyword" "toggleopaque" "3" "--instance" "togglefloating" "renameworkspace" "alphafullscreenoverride" "activeworkspace" "x11" "kill" "forceopaqueoverriden" "output" "global" "dispatch" "reload" "forcenoblur" "-j" "event" "--help" "disable" "-1" "activewindow" "keepaspectratio" "dismissnotify" "focusmonitor" "movefocus" "plugin" "exit" "workspace" "fullscreenstate" "getoption" "alphainactiveoverride" "alphainactive" "decorations" "settiled" "config-only" "descriptions" "resizewindowpixel" "fakefullscreen" "rollinglog" "swapactiveworkspaces" "submap" "next" "movewindoworgroup" "cursorpos" "forcenoanims" "focusworkspaceoncurrentmonitor" "maxsize" "sendkeystate")
+    local -a literals=("resizeactive" "2" "changegroupactive" "-r" "moveintogroup" "forceallowsinput" "4" "::=" "systeminfo" "all" "layouts" "setprop" "animationstyle" "switchxkblayout" "create" "denywindowfromgroup" "headless" "activebordercolor" "exec" "setcursor" "wayland" "focusurgentorlast" "workspacerules" "movecurrentworkspacetomonitor" "movetoworkspacesilent" "hyprpaper" "alpha" "inactivebordercolor" "movegroupwindow" "movecursortocorner" "movewindowpixel" "prev" "movewindow" "globalshortcuts" "clients" "dimaround" "setignoregrouplock" "splash" "execr" "monitors" "0" "forcenoborder" "-q" "animations" "1" "nomaxsize" "splitratio" "moveactive" "pass" "swapnext" "devices" "layers" "rounding" "lockactivegroup" "5" "moveworkspacetomonitor" "-f" "-i" "--quiet" "forcenodim" "pin" "0" "1" "forceopaque" "forcenoshadow" "setfloating" "minsize" "alphaoverride" "sendshortcut" "workspaces" "cyclenext" "alterzorder" "togglegroup" "lockgroups" "bordersize" "dpms" "focuscurrentorlast" "-1" "--batch" "notify" "remove" "instances" "1" "3" "moveoutofgroup" "killactive" "2" "movetoworkspace" "movecursor" "configerrors" "closewindow" "swapwindow" "tagwindow" "forcerendererreload" "centerwindow" "auto" "focuswindow" "seterror" "nofocus" "alphafullscreen" "binds" "version" "-h" "togglespecialworkspace" "fullscreen" "windowdancecompat" "0" "keyword" "toggleopaque" "3" "--instance" "togglefloating" "renameworkspace" "alphafullscreenoverride" "activeworkspace" "x11" "kill" "forceopaqueoverriden" "output" "global" "dispatch" "reload" "forcenoblur" "-j" "event" "--help" "disable" "-1" "activewindow" "keepaspectratio" "dismissnotify" "focusmonitor" "movefocus" "plugin" "exit" "workspace" "fullscreenstate" "getoption" "alphainactiveoverride" "alphainactive" "decorations" "settiled" "config-only" "descriptions" "resizewindowpixel" "fakefullscreen" "rollinglog" "swapactiveworkspaces" "submap" "next" "movewindoworgroup" "cursorpos" "forcenoanims" "focusworkspaceoncurrentmonitor" "maxsize")
 
     local -A descriptions
     descriptions[1]="Resize the active window"

hyprpm/CMakeLists.txt

@@ -9,11 +9,11 @@ file(GLOB_RECURSE SRCFILES CONFIGURE_DEPENDS "src/*.cpp")
 
 set(CMAKE_CXX_STANDARD 23)
 
-pkg_check_modules(hyprpm_deps REQUIRED IMPORTED_TARGET tomlplusplus hyprutils>=0.7.0)
+pkg_check_modules(hyprpm_deps REQUIRED IMPORTED_TARGET tomlplusplus hyprutils>=0.2.4)
 
 find_package(glaze QUIET)
 if (NOT glaze_FOUND)
-    set(GLAZE_VERSION v5.1.1)
+    set(GLAZE_VERSION v4.2.3)
     message(STATUS "glaze dependency not found, retrieving ${GLAZE_VERSION} with FetchContent")
     include(FetchContent)
     FetchContent_Declare(

hyprpm/src/core/DataState.cpp

@@ -1,41 +1,22 @@
 #include "DataState.hpp"
-#include <sys/stat.h>
 #include <toml++/toml.hpp>
 #include <print>
-#include <sstream>
 #include <fstream>
 #include "PluginManager.hpp"
-#include "../helpers/Die.hpp"
-#include "../helpers/Sys.hpp"
-#include "../helpers/StringUtils.hpp"
-
-static std::string getTempRoot() {
-    static auto ENV = getenv("XDG_RUNTIME_DIR");
-    if (!ENV) {
-        std::cerr << "\nERROR: XDG_RUNTIME_DIR not set!\n";
-        exit(1);
-    }
-
-    const auto STR = ENV + std::string{"/hyprpm/"};
-
-    return STR;
-}
-
-// write the state to a file
-static bool writeState(const std::string& str, const std::string& to) {
-    // create temp file in a safe temp root
-    std::ofstream of(getTempRoot() + ".temp-state", std::ios::trunc);
-    if (!of.good())
-        return false;
-
-    of << str;
-    of.close();
-
-    return NSys::root::install(getTempRoot() + ".temp-state", to, "644");
-}
 
 std::filesystem::path DataState::getDataStatePath() {
-    return std::filesystem::path("/var/cache/hyprpm/" + g_pPluginManager->m_szUsername);
+    const auto HOME = getenv("HOME");
+    if (!HOME) {
+        std::println(stderr, "DataState: no $HOME");
+        throw std::runtime_error("no $HOME");
+        return "";
+    }
+
+    const auto XDG_DATA_HOME = getenv("XDG_DATA_HOME");
+
+    if (XDG_DATA_HOME)
+        return std::filesystem::path{XDG_DATA_HOME} / "hyprpm";
+    return std::filesystem::path{HOME} / ".local/share/hyprpm";
 }
 
 std::string DataState::getHeadersPath() {
@@ -60,20 +41,13 @@ std::vector<std::filesystem::path> DataState::getPluginStates() {
 }
 
 void DataState::ensureStateStoreExists() {
-    std::error_code ec;
-    if (!std::filesystem::exists(getHeadersPath(), ec) || ec) {
-        std::println("{}", infoString("The hyprpm state store doesn't exist. Creating now..."));
-        if (!std::filesystem::exists("/var/cache/hyprpm/", ec) || ec) {
-            if (!NSys::root::createDirectory("/var/cache/hyprpm", "755"))
-                Debug::die("ensureStateStoreExists: Failed to run a superuser cmd");
-        }
-        if (!std::filesystem::exists(getDataStatePath(), ec) || ec) {
-            if (!NSys::root::createDirectory(getDataStatePath().string(), "755"))
-                Debug::die("ensureStateStoreExists: Failed to run a superuser cmd");
-        }
-        if (!NSys::root::createDirectory(getHeadersPath(), "755"))
-            Debug::die("ensureStateStoreExists: Failed to run a superuser cmd");
-    }
+    const auto PATH = getDataStatePath();
+
+    if (!std::filesystem::exists(PATH))
+        std::filesystem::create_directories(PATH);
+
+    if (!std::filesystem::exists(getHeadersPath()))
+        std::filesystem::create_directories(getHeadersPath());
 }
 
 void DataState::addNewPluginRepo(const SPluginRepository& repo) {
@@ -81,11 +55,7 @@ void DataState::addNewPluginRepo(const SPluginRepository& repo) {
 
     const auto PATH = getDataStatePath() / repo.name;
 
-    std::error_code ec;
-    if (!std::filesystem::exists(PATH, ec) || ec) {
-        if (!NSys::root::createDirectory(PATH.string(), "755"))
-            Debug::die("addNewPluginRepo: failed to create cache dir");
-    }
+    std::filesystem::create_directories(PATH);
     // clang-format off
     auto DATA = toml::table{
         {"repository", toml::table{
@@ -98,11 +68,9 @@ void DataState::addNewPluginRepo(const SPluginRepository& repo) {
     for (auto const& p : repo.plugins) {
         const auto filename = p.name + ".so";
 
-        // copy .so to the good place and chmod 755
-        if (std::filesystem::exists(p.filename)) {
-            if (!NSys::root::install(p.filename, (PATH / filename).string(), "0755"))
-                Debug::die("addNewPluginRepo: failed to install so file");
-        }
+        // copy .so to the good place
+        if (std::filesystem::exists(p.filename))
+            std::filesystem::copy_file(p.filename, PATH / filename);
 
         DATA.emplace(p.name, toml::table{
             {"filename", filename},
@@ -112,16 +80,16 @@ void DataState::addNewPluginRepo(const SPluginRepository& repo) {
     }
     // clang-format on
 
-    std::stringstream ss;
-    ss << DATA;
-
-    if (!writeState(ss.str(), (PATH / "state.toml").string()))
-        Debug::die("{}", failureString("Failed to write plugin state"));
+    std::ofstream ofs(PATH / "state.toml", std::ios::trunc);
+    ofs << DATA;
+    ofs.close();
 }
 
 bool DataState::pluginRepoExists(const std::string& urlOrName) {
     ensureStateStoreExists();
 
+    const auto PATH = getDataStatePath();
+
     for (const auto& stateFile : getPluginStates()) {
         const auto STATE = toml::parse_file(stateFile.c_str());
         const auto NAME  = STATE["repository"]["name"].value_or("");
@@ -137,6 +105,8 @@ bool DataState::pluginRepoExists(const std::string& urlOrName) {
 void DataState::removePluginRepo(const std::string& urlOrName) {
     ensureStateStoreExists();
 
+    const auto PATH = getDataStatePath();
+
     for (const auto& stateFile : getPluginStates()) {
         const auto STATE = toml::parse_file(stateFile.c_str());
         const auto NAME  = STATE["repository"]["name"].value_or("");
@@ -152,14 +122,7 @@ void DataState::removePluginRepo(const std::string& urlOrName) {
                 g_pPluginManager->loadUnloadPlugin(std::filesystem::absolute(file.path()), false);
             }
 
-            const auto PATH = stateFile.parent_path().string();
-
-            if (!PATH.starts_with("/var/cache/hyprpm") || PATH.contains('\''))
-                return; // WTF?
-
-            // scary!
-            if (!NSys::root::removeRecursive(PATH))
-                Debug::die("removePluginRepo: failed to remove dir");
+            std::filesystem::remove_all(stateFile.parent_path());
             return;
         }
     }
@@ -170,11 +133,7 @@ void DataState::updateGlobalState(const SGlobalState& state) {
 
     const auto PATH = getDataStatePath();
 
-    std::error_code ec;
-    if (!std::filesystem::exists(PATH, ec) || ec) {
-        if (!NSys::root::createDirectory(PATH.string(), "755"))
-            Debug::die("updateGlobalState: failed to create dir");
-    }
+    std::filesystem::create_directories(PATH);
     // clang-format off
     auto DATA = toml::table{
         {"state", toml::table{
@@ -184,11 +143,9 @@ void DataState::updateGlobalState(const SGlobalState& state) {
     };
     // clang-format on
 
-    std::stringstream ss;
-    ss << DATA;
-
-    if (!writeState(ss.str(), (PATH / "state.toml").string()))
-        Debug::die("{}", failureString("Failed to write plugin state"));
+    std::ofstream ofs(PATH / "state.toml", std::ios::trunc);
+    ofs << DATA;
+    ofs.close();
 }
 
 SGlobalState DataState::getGlobalState() {
@@ -196,8 +153,7 @@ SGlobalState DataState::getGlobalState() {
 
     const auto stateFile = getDataStatePath() / "state.toml";
 
-    std::error_code ec;
-    if (!std::filesystem::exists(stateFile, ec) || ec)
+    if (!std::filesystem::exists(stateFile))
         return SGlobalState{};
 
     auto         DATA = toml::parse_file(stateFile.c_str());
@@ -212,6 +168,8 @@ SGlobalState DataState::getGlobalState() {
 std::vector<SPluginRepository> DataState::getAllRepositories() {
     ensureStateStoreExists();
 
+    const auto                     PATH = getDataStatePath();
+
     std::vector<SPluginRepository> repos;
     for (const auto& stateFile : getPluginStates()) {
         const auto        STATE = toml::parse_file(stateFile.c_str());
@@ -247,6 +205,8 @@ std::vector<SPluginRepository> DataState::getAllRepositories() {
 bool DataState::setPluginEnabled(const std::string& name, bool enabled) {
     ensureStateStoreExists();
 
+    const auto PATH = getDataStatePath();
+
     for (const auto& stateFile : getPluginStates()) {
         const auto STATE = toml::parse_file(stateFile.c_str());
         for (const auto& [key, val] : STATE) {
@@ -264,11 +224,9 @@ bool DataState::setPluginEnabled(const std::string& name, bool enabled) {
             auto modifiedState = STATE;
             (*modifiedState[key].as_table()).insert_or_assign("enabled", enabled);
 
-            std::stringstream ss;
-            ss << modifiedState;
-
-            if (!writeState(ss.str(), stateFile.string()))
-                Debug::die("{}", failureString("Failed to write plugin state"));
+            std::ofstream state(stateFile, std::ios::trunc);
+            state << modifiedState;
+            state.close();
 
             return true;
         }
@@ -276,18 +234,3 @@ bool DataState::setPluginEnabled(const std::string& name, bool enabled) {
 
     return false;
 }
-
-void DataState::purgeAllCache() {
-    std::error_code ec;
-    if (!std::filesystem::exists(getDataStatePath()) && !ec) {
-        std::println("{}", infoString("Nothing to do"));
-        return;
-    }
-
-    const auto PATH = getDataStatePath().string();
-    if (PATH.contains('\''))
-        return;
-    // scary!
-    if (!NSys::root::removeRecursive(PATH))
-        Debug::die("Failed to run a superuser cmd");
-}

hyprpm/src/core/DataState.hpp

@@ -18,7 +18,6 @@ namespace DataState {
     void                               removePluginRepo(const std::string& urlOrName);
     bool                               pluginRepoExists(const std::string& urlOrName);
     void                               updateGlobalState(const SGlobalState& state);
-    void                               purgeAllCache();
     SGlobalState                       getGlobalState();
     bool                               setPluginEnabled(const std::string& name, bool enabled);
     std::vector<SPluginRepository>     getAllRepositories();

hyprpm/src/core/HyprlandSocket.cpp

@@ -1,85 +0,0 @@
-#include "HyprlandSocket.hpp"
-#include <pwd.h>
-#include <sys/socket.h>
-#include "../helpers/StringUtils.hpp"
-#include <print>
-#include <sys/un.h>
-#include <unistd.h>
-
-static int getUID() {
-    const auto UID   = getuid();
-    const auto PWUID = getpwuid(UID);
-    return PWUID ? PWUID->pw_uid : UID;
-}
-
-static std::string getRuntimeDir() {
-    const auto XDG = getenv("XDG_RUNTIME_DIR");
-
-    if (!XDG) {
-        const std::string USERID = std::to_string(getUID());
-        return "/run/user/" + USERID + "/hypr";
-    }
-
-    return std::string{XDG} + "/hypr";
-}
-
-std::string NHyprlandSocket::send(const std::string& cmd) {
-    const auto SERVERSOCKET = socket(AF_UNIX, SOCK_STREAM, 0);
-
-    if (SERVERSOCKET < 0) {
-        std::println("{}", failureString("Couldn't open a socket (1)"));
-        return "";
-    }
-
-    const auto HIS = getenv("HYPRLAND_INSTANCE_SIGNATURE");
-
-    if (!HIS) {
-        std::println("{}", failureString("HYPRLAND_INSTANCE_SIGNATURE was not set! (Is Hyprland running?) (3)"));
-        return "";
-    }
-
-    sockaddr_un serverAddress = {0};
-    serverAddress.sun_family  = AF_UNIX;
-
-    std::string socketPath = getRuntimeDir() + "/" + HIS + "/.socket.sock";
-
-    strncpy(serverAddress.sun_path, socketPath.c_str(), sizeof(serverAddress.sun_path) - 1);
-
-    if (connect(SERVERSOCKET, (sockaddr*)&serverAddress, SUN_LEN(&serverAddress)) < 0) {
-        std::println("{}", failureString("Couldn't connect to " + socketPath + ". (4)"));
-        return "";
-    }
-
-    auto sizeWritten = write(SERVERSOCKET, cmd.c_str(), cmd.length());
-
-    if (sizeWritten < 0) {
-        std::println("{}", failureString("Couldn't write (5)"));
-        return "";
-    }
-
-    std::string      reply               = "";
-    constexpr size_t BUFFER_SIZE         = 8192;
-    char             buffer[BUFFER_SIZE] = {0};
-
-    sizeWritten = read(SERVERSOCKET, buffer, BUFFER_SIZE);
-
-    if (sizeWritten < 0) {
-        std::println("{}", failureString("Couldn't read (6)"));
-        return "";
-    }
-
-    reply += std::string(buffer, sizeWritten);
-
-    while (sizeWritten == BUFFER_SIZE) {
-        sizeWritten = read(SERVERSOCKET, buffer, BUFFER_SIZE);
-        if (sizeWritten < 0) {
-            std::println("{}", failureString("Couldn't read (7)"));
-            return "";
-        }
-        reply += std::string(buffer, sizeWritten);
-    }
-
-    close(SERVERSOCKET);
-
-    return reply;
-}

hyprpm/src/core/HyprlandSocket.hpp

@@ -1,7 +0,0 @@
-#pragma once
-
-#include <string>
-
-namespace NHyprlandSocket {
-    std::string send(const std::string& cmd);
-};

hyprpm/src/core/Manifest.cpp

@@ -1,12 +1,6 @@
 #include "Manifest.hpp"
 #include <toml++/toml.hpp>
-#include <algorithm>
-
-// Alphanumerics and -_ allowed for plugin names. No magic names.
-// [A-Za-z0-9\-_]*
-static bool validManifestName(const std::string_view& n) {
-    return std::ranges::all_of(n, [](const char& c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '-' || c == '_' || c == '=' || (c >= '0' && c <= '9'); });
-}
+#include <iostream>
 
 CManifest::CManifest(const eManifestType type, const std::string& path) {
     auto manifest = toml::parse_file(path);
@@ -17,17 +11,11 @@ CManifest::CManifest(const eManifestType type, const std::string& path) {
                 continue;
 
             CManifest::SManifestPlugin plugin;
-
-            if (!validManifestName(key.str())) {
-                m_good = false;
-                return;
-            }
-
             plugin.name = key;
-            m_plugins.push_back(plugin);
+            m_vPlugins.push_back(plugin);
         }
 
-        for (auto& plugin : m_plugins) {
+        for (auto& plugin : m_vPlugins) {
             plugin.description = manifest[plugin.name]["description"].value_or("?");
             plugin.version     = manifest[plugin.name]["version"].value_or("?");
             plugin.output      = manifest[plugin.name]["build"]["output"].value_or("?");
@@ -49,21 +37,21 @@ CManifest::CManifest(const eManifestType type, const std::string& path) {
             }
 
             if (plugin.output.empty() || plugin.buildSteps.empty()) {
-                m_good = false;
+                m_bGood = false;
                 return;
             }
         }
     } else if (type == MANIFEST_HYPRPM) {
-        m_repository.name = manifest["repository"]["name"].value_or("");
+        m_sRepository.name = manifest["repository"]["name"].value_or("");
         auto authors       = manifest["repository"]["authors"].as_array();
         if (authors) {
             for (auto&& a : *authors) {
-                m_repository.authors.push_back(a.as_string()->value_or("?"));
+                m_sRepository.authors.push_back(a.as_string()->value_or("?"));
             }
         } else {
             auto author = manifest["repository"]["author"].value_or("");
             if (!std::string{author}.empty())
-                m_repository.authors.push_back(author);
+                m_sRepository.authors.push_back(author);
         }
 
         auto pins = manifest["repository"]["commit_pins"].as_array();
@@ -71,7 +59,7 @@ CManifest::CManifest(const eManifestType type, const std::string& path) {
             for (auto&& pin : *pins) {
                 auto pinArr = pin.as_array();
                 if (pinArr && pinArr->get(1))
-                    m_repository.commitPins.push_back(std::make_pair<>(pinArr->get(0)->as_string()->get(), pinArr->get(1)->as_string()->get()));
+                    m_sRepository.commitPins.push_back(std::make_pair<>(pinArr->get(0)->as_string()->get(), pinArr->get(1)->as_string()->get()));
             }
         }
 
@@ -80,17 +68,11 @@ CManifest::CManifest(const eManifestType type, const std::string& path) {
                 continue;
 
             CManifest::SManifestPlugin plugin;
-
-            if (!validManifestName(key.str())) {
-                m_good = false;
-                return;
-            }
-
             plugin.name = key;
-            m_plugins.push_back(plugin);
+            m_vPlugins.push_back(plugin);
         }
 
-        for (auto& plugin : m_plugins) {
+        for (auto& plugin : m_vPlugins) {
             plugin.description = manifest[plugin.name]["description"].value_or("?");
             plugin.output      = manifest[plugin.name]["output"].value_or("?");
             plugin.since       = manifest[plugin.name]["since_hyprland"].value_or(0);
@@ -112,12 +94,12 @@ CManifest::CManifest(const eManifestType type, const std::string& path) {
             }
 
             if (plugin.output.empty() || plugin.buildSteps.empty()) {
-                m_good = false;
+                m_bGood = false;
                 return;
             }
         }
     } else {
         // ???
-        m_good = false;
+        m_bGood = false;
     }
 }

hyprpm/src/core/Manifest.hpp

@@ -27,8 +27,8 @@ class CManifest {
         std::string                                      name;
         std::vector<std::string>                         authors;
         std::vector<std::pair<std::string, std::string>> commitPins;
-    } m_repository;
+    } m_sRepository;
 
-    std::vector<SManifestPlugin> m_plugins;
-    bool                         m_good = true;
+    std::vector<SManifestPlugin> m_vPlugins;
+    bool                         m_bGood = true;
 };

hyprpm/src/core/PluginManager.cpp

@@ -4,9 +4,6 @@
 #include "../progress/CProgressBar.hpp"
 #include "Manifest.hpp"
 #include "DataState.hpp"
-#include "HyprlandSocket.hpp"
-#include "../helpers/Sys.hpp"
-#include "../helpers/Die.hpp"
 
 #include <cstdio>
 #include <iostream>
@@ -52,13 +49,6 @@ static std::string getTempRoot() {
     return STR;
 }
 
-CPluginManager::CPluginManager() {
-    if (NSys::isSuperuser())
-        Debug::die("Don't run hyprpm as a superuser.");
-
-    m_szUsername = getpwuid(NSys::getUID())->pw_name;
-}
-
 SHyprlandVersion CPluginManager::getHyprlandVersion(bool running) {
     static bool             onceRunning   = false;
     static bool             onceInstalled = false;
@@ -76,7 +66,7 @@ SHyprlandVersion CPluginManager::getHyprlandVersion(bool running) {
     else
         onceInstalled = true;
 
-    const auto HLVERCALL = running ? NHyprlandSocket::send("/version") : execAndGet("Hyprland --version");
+    const auto HLVERCALL = running ? execAndGet("hyprctl version") : execAndGet("Hyprland --version");
     if (m_bVerbose)
         std::println("{}", verboseString("{} version returned: {}", running ? "running" : "installed", HLVERCALL));
 
@@ -139,8 +129,7 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     const auto HLVER = getHyprlandVersion();
 
     if (!hasDeps()) {
-        std::println(stderr, "\n{}",
-                     failureString("Could not clone the plugin repository. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio, pkg-config, git, g++, gcc"));
+        std::println(stderr, "\n{}", failureString("Could not clone the plugin repository. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio, pkg-config"));
         return false;
     }
 
@@ -236,14 +225,14 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
         return false;
     }
 
-    if (!pManifest->m_good) {
+    if (!pManifest->m_bGood) {
         std::println(stderr, "\n{}", failureString("The provided plugin repository has a corrupted manifest"));
         return false;
     }
 
     progress.m_iSteps = 2;
-    progress.printMessageAbove(successString("parsed manifest, found " + std::to_string(pManifest->m_plugins.size()) + " plugins:"));
-    for (auto const& pl : pManifest->m_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 = "→ " + pl.name + " by ";
         for (auto const& a : pl.authors) {
             message += a + ", ";
@@ -256,12 +245,12 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
         progress.printMessageAbove(message);
     }
 
-    if (!pManifest->m_repository.commitPins.empty()) {
+    if (!pManifest->m_sRepository.commitPins.empty()) {
         // check commit pins
 
-        progress.printMessageAbove(infoString("Manifest has {} pins, checking", pManifest->m_repository.commitPins.size()));
+        progress.printMessageAbove(infoString("Manifest has {} pins, checking", pManifest->m_sRepository.commitPins.size()));
 
-        for (auto const& [hl, plugin] : pManifest->m_repository.commitPins) {
+        for (auto const& [hl, plugin] : pManifest->m_sRepository.commitPins) {
             if (hl != HLVER.hash)
                 continue;
 
@@ -284,7 +273,6 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
 
     if (HEADERSSTATUS != HEADERS_OK) {
         std::println("\n{}", headerError(HEADERSSTATUS));
-        std::println("\n{}", infoString("if the problem persists, try running hyprpm purge-cache."));
         return false;
     }
 
@@ -293,7 +281,7 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     progress.m_szCurrentMessage = "Building plugin(s)";
     progress.print();
 
-    for (auto& p : pManifest->m_plugins) {
+    for (auto& p : pManifest->m_vPlugins) {
         std::string out;
 
         if (p.since > HLVER.commits && HLVER.commits >= 1 /* for --depth 1 clones, we can't check this. */) {
@@ -336,11 +324,11 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     std::string       repohash = execAndGet("cd " + m_szWorkingPluginDirectory + " && git rev-parse HEAD");
     if (repohash.length() > 0)
         repohash.pop_back();
-    repo.name = pManifest->m_repository.name.empty() ? url.substr(url.find_last_of('/') + 1) : pManifest->m_repository.name;
+    repo.name = pManifest->m_sRepository.name.empty() ? url.substr(url.find_last_of('/') + 1) : pManifest->m_sRepository.name;
     repo.url  = url;
     repo.rev  = rev;
     repo.hash = repohash;
-    for (auto const& p : pManifest->m_plugins) {
+    for (auto const& p : pManifest->m_vPlugins) {
         repo.plugins.push_back(SPlugin{p.name, m_szWorkingPluginDirectory + "/" + p.output, false, p.failed});
     }
     DataState::addNewPluginRepo(repo);
@@ -447,7 +435,7 @@ bool CPluginManager::updateHeaders(bool force) {
     const auto HLVER = getHyprlandVersion(false);
 
     if (!hasDeps()) {
-        std::println("\n{}", failureString("Could not update. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio, pkg-config, git, g++, gcc"));
+        std::println("\n{}", failureString("Could not update. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio, pkg-config"));
         return false;
     }
 
@@ -560,21 +548,13 @@ bool CPluginManager::updateHeaders(bool force) {
     progress.m_szCurrentMessage = "Installing sources";
     progress.print();
 
-    std::string cmd = std::format("sed -i -e \"s#PREFIX = /usr/local#PREFIX = {}#\" {}/Makefile", DataState::getHeadersPath(), WORKINGDIR);
+    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(verboseString("prepare install will run: {}", cmd));
+        progress.printMessageAbove(verboseString("installation will run: {}", cmd));
 
     ret = execAndGet(cmd);
 
-    cmd = std::format("make -C '{}' installheaders && chmod -R 644 '{}' && find '{}' -type d -exec chmod o+x {{}} \\;", WORKINGDIR, DataState::getHeadersPath(),
-                      DataState::getHeadersPath());
-
-    if (m_bVerbose)
-        progress.printMessageAbove(verboseString("install will run as sudo: {}", cmd));
-
-    // WORKINGDIR and headersPath should not contain anything unsafe. Usernames can't contain cmd exec parts.
-    ret = NSys::root::runAsSuperuserUnsafe(cmd);
-
     if (m_bVerbose)
         std::println("{}", verboseString("installer returned: {}", ret));
 
@@ -588,14 +568,9 @@ bool CPluginManager::updateHeaders(bool force) {
         progress.m_szCurrentMessage = "Done!";
         progress.print();
 
-        auto GLOBALSTATE                = DataState::getGlobalState();
-        GLOBALSTATE.headersHashCompiled = HLVER.hash;
-        DataState::updateGlobalState(GLOBALSTATE);
-
         std::print("\n");
     } else {
         progress.printMessageAbove(failureString("failed to install headers with error code {} ({})", (int)HEADERSVALID, headerErrorShort(HEADERSVALID)));
-        progress.printMessageAbove(infoString("if the problem persists, try running hyprpm purge-cache."));
         progress.m_iSteps           = 5;
         progress.m_szCurrentMessage = "Failed";
         progress.print();
@@ -702,17 +677,17 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
             continue;
         }
 
-        if (!pManifest->m_good) {
-            std::println(stderr, "\n{}", failureString("The provided plugin repository has a bad manifest"));
+        if (!pManifest->m_bGood) {
+            std::println(stderr, "\n{}", failureString("The provided plugin repository has a corrupted manifest"));
             continue;
         }
 
-        if (repo.rev.empty() && !pManifest->m_repository.commitPins.empty()) {
+        if (repo.rev.empty() && !pManifest->m_sRepository.commitPins.empty()) {
             // check commit pins unless a revision is specified
 
-            progress.printMessageAbove(infoString("Manifest has {} pins, checking", pManifest->m_repository.commitPins.size()));
+            progress.printMessageAbove(infoString("Manifest has {} pins, checking", pManifest->m_sRepository.commitPins.size()));
 
-            for (auto const& [hl, plugin] : pManifest->m_repository.commitPins) {
+            for (auto const& [hl, plugin] : pManifest->m_sRepository.commitPins) {
                 if (hl != HLVER.hash)
                     continue;
 
@@ -722,7 +697,7 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
             }
         }
 
-        for (auto& p : pManifest->m_plugins) {
+        for (auto& p : pManifest->m_vPlugins) {
             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. */) {
@@ -764,7 +739,7 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
         if (repohash.length() > 0)
             repohash.pop_back();
         newrepo.hash = repohash;
-        for (auto const& p : pManifest->m_plugins) {
+        for (auto const& p : pManifest->m_vPlugins) {
             const auto OLDPLUGINIT = std::find_if(repo.plugins.begin(), repo.plugins.end(), [&](const auto& other) { return other.name == p.name; });
             newrepo.plugins.push_back(SPlugin{p.name, m_szWorkingPluginDirectory + "/" + p.output, OLDPLUGINIT != repo.plugins.end() ? OLDPLUGINIT->enabled : false});
         }
@@ -821,9 +796,9 @@ ePluginLoadStateReturn CPluginManager::ensurePluginsLoadState(bool forceReload)
     }
     const auto HYPRPMPATH = DataState::getDataStatePath();
 
-    const auto json = glz::read_json<glz::json_t::array_t>(NHyprlandSocket::send("j/plugins list"));
+    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 plugin list output");
+        std::println(stderr, "PluginManager: couldn't parse hyprctl output");
         return LOADSTATE_FAIL;
     }
 
@@ -907,15 +882,14 @@ bool CPluginManager::loadUnloadPlugin(const std::string& path, bool load) {
     auto HLVER = getHyprlandVersion(true);
 
     if (state.headersHashCompiled != HLVER.hash) {
-        if (load)
-            std::println("{}", infoString("Running Hyprland version ({}) differs from plugin state ({}), please restart Hyprland.", HLVER.hash, state.headersHashCompiled));
+        std::println("{}", infoString("Running Hyprland version differs from plugin state, please restart Hyprland."));
         return false;
     }
 
     if (load)
-        NHyprlandSocket::send("/plugin load " + path);
+        execAndGet("hyprctl plugin load " + path);
     else
-        NHyprlandSocket::send("/plugin unload " + path);
+        execAndGet("hyprctl plugin unload " + path);
 
     return true;
 }
@@ -940,7 +914,7 @@ void CPluginManager::listAllPlugins() {
 }
 
 void CPluginManager::notify(const eNotifyIcons icon, uint32_t color, int durationMs, const std::string& message) {
-    NHyprlandSocket::send("/notify " + std::to_string((int)icon) + " " + std::to_string(durationMs) + " " + std::to_string(color) + " " + message);
+    execAndGet("hyprctl notify " + std::to_string((int)icon) + " " + std::to_string(durationMs) + " " + std::to_string(color) + " " + message);
 }
 
 std::string CPluginManager::headerError(const eHeadersErrors err) {
@@ -973,7 +947,7 @@ std::string CPluginManager::headerErrorShort(const eHeadersErrors err) {
 }
 
 bool CPluginManager::hasDeps() {
-    std::vector<std::string> deps = {"meson", "cpio", "cmake", "pkg-config", "g++", "gcc", "git"};
+    std::vector<std::string> deps = {"meson", "cpio", "cmake", "pkg-config"};
     for (auto const& d : deps) {
         if (!execAndGet("command -v " + d).contains("/"))
             return false;

hyprpm/src/core/PluginManager.hpp

@@ -40,8 +40,6 @@ struct SHyprlandVersion {
 
 class CPluginManager {
   public:
-    CPluginManager();
-
     bool                   addNewPluginRepo(const std::string& url, const std::string& rev);
     bool                   removePluginRepo(const std::string& urlOrName);
 
@@ -64,7 +62,7 @@ class CPluginManager {
 
     bool                   m_bVerbose   = false;
     bool                   m_bNoShallow = false;
-    std::string            m_szCustomHlUrl, m_szUsername;
+    std::string            m_szCustomHlUrl;
 
     // will delete recursively if exists!!
     bool createSafeDirectory(const std::string& path);

hyprpm/src/helpers/Die.hpp

@@ -1,15 +0,0 @@
-#pragma once
-
-#include <format>
-#include <iostream>
-
-// NOLINTNEXTLINE
-namespace Debug {
-    template <typename... Args>
-    void die(std::format_string<Args...> fmt, Args&&... args) {
-        const std::string logMsg = std::vformat(fmt.get(), std::make_format_args(args...));
-
-        std::cout << "\n[ERR] " << logMsg << "\n";
-        exit(1);
-    }
-};

hyprpm/src/helpers/Sys.cpp

@@ -1,167 +0,0 @@
-#include "Sys.hpp"
-#include "Die.hpp"
-#include "StringUtils.hpp"
-
-#include <pwd.h>
-#include <unistd.h>
-#include <print>
-#include <filesystem>
-#include <algorithm>
-
-#include <hyprutils/os/Process.hpp>
-#include <hyprutils/string/VarList.hpp>
-
-using namespace Hyprutils::OS;
-using namespace Hyprutils::String;
-
-inline constexpr std::array<std::string_view, 3> SUPERUSER_BINARIES = {
-    "sudo",
-    "doas",
-    "run0",
-};
-
-static std::string validSubinsAsStr() {
-    std::ostringstream oss;
-    auto               it = SUPERUSER_BINARIES.begin();
-    if (it != SUPERUSER_BINARIES.end()) {
-        oss << *it++;
-        for (; it != SUPERUSER_BINARIES.end(); ++it)
-            oss << ", " << *it;
-    }
-
-    return oss.str();
-}
-
-static bool executableExistsInPath(const std::string& exe) {
-    const char* PATHENV = std::getenv("PATH");
-    if (!PATHENV)
-        return false;
-
-    CVarList        paths(PATHENV, 0, ':', true);
-    std::error_code ec;
-
-    for (const auto& PATH : paths) {
-        std::filesystem::path candidate = std::filesystem::path(PATH) / exe;
-        if (!std::filesystem::exists(candidate, ec) || ec)
-            continue;
-        if (!std::filesystem::is_regular_file(candidate, ec) || ec)
-            continue;
-        auto perms = std::filesystem::status(candidate, ec).permissions();
-        if (ec)
-            continue;
-        if ((perms & std::filesystem::perms::others_exec) != std::filesystem::perms::none)
-            return true;
-    }
-
-    return false;
-}
-
-static std::string subin() {
-    static std::string bin;
-    static bool        once = true;
-    if (!once)
-        return bin;
-
-    for (const auto& BIN : SUPERUSER_BINARIES) {
-        if (!executableExistsInPath(std::string{BIN}))
-            continue;
-
-        bin = BIN;
-        break;
-    }
-
-    once = false;
-
-    if (bin.empty())
-        Debug::die("{}", failureString("No valid superuser binary present. Supported: {}", validSubinsAsStr()));
-
-    return bin;
-}
-
-static bool verifyStringValid(const std::string& s) {
-    return std::ranges::none_of(s, [](const char& c) { return c == '`' || c == '$' || c == '(' || c == ')' || c == '\'' || c == '"'; });
-}
-
-int NSys::getUID() {
-    const auto UID   = getuid();
-    const auto PWUID = getpwuid(UID);
-    return PWUID ? PWUID->pw_uid : UID;
-}
-
-int NSys::getEUID() {
-    const auto UID   = geteuid();
-    const auto PWUID = getpwuid(UID);
-    return PWUID ? PWUID->pw_uid : UID;
-}
-
-bool NSys::isSuperuser() {
-    return getuid() != geteuid() || geteuid() == 0;
-}
-
-void NSys::root::cacheSudo() {
-    // "caches" the sudo so that the prompt later doesn't pop up in a weird spot
-    // sudo will not ask us again for a moment
-    CProcess proc(subin(), {"echo", "hyprland"});
-    proc.runSync();
-}
-
-void NSys::root::dropSudo() {
-    if (subin() != "sudo") {
-        std::println("{}", infoString("Don't know how to drop timestamp for '{}', ignoring.", subin()));
-        return;
-    }
-
-    CProcess proc(subin(), {"-k"});
-    proc.runSync();
-}
-
-bool NSys::root::createDirectory(const std::string& path, const std::string& mode) {
-    if (!verifyStringValid(path))
-        return false;
-
-    if (!std::ranges::all_of(mode, [](const char& c) { return c >= '0' && c <= '9'; }))
-        return false;
-
-    CProcess proc(subin(), {"mkdir", "-p", "-m", mode, path});
-
-    return proc.runSync() && proc.exitCode() == 0;
-}
-
-bool NSys::root::removeRecursive(const std::string& path) {
-    if (!verifyStringValid(path))
-        return false;
-
-    std::error_code   ec;
-    const std::string PATH_ABSOLUTE = std::filesystem::canonical(path, ec);
-
-    if (ec)
-        return false;
-
-    if (!PATH_ABSOLUTE.starts_with("/var/cache/hyprpm"))
-        return false;
-
-    CProcess proc(subin(), {"rm", "-fr", PATH_ABSOLUTE});
-
-    return proc.runSync() && proc.exitCode() == 0;
-}
-
-bool NSys::root::install(const std::string& what, const std::string& where, const std::string& mode) {
-    if (!verifyStringValid(what) || !verifyStringValid(where))
-        return false;
-
-    if (!std::ranges::all_of(mode, [](const char& c) { return c >= '0' && c <= '9'; }))
-        return false;
-
-    CProcess proc(subin(), {"install", "-m" + mode, "-o", "root", "-g", "root", what, where});
-
-    return proc.runSync() && proc.exitCode() == 0;
-}
-
-std::string NSys::root::runAsSuperuserUnsafe(const std::string& cmd) {
-    CProcess proc(subin(), {"/bin/sh", "-c", cmd});
-
-    if (!proc.runSync())
-        return "";
-
-    return proc.stdOut();
-}

hyprpm/src/helpers/Sys.hpp

@@ -1,23 +0,0 @@
-#pragma once
-
-#include <string>
-
-namespace NSys {
-    bool isSuperuser();
-    int  getUID();
-    int  getEUID();
-
-    // NOLINTNEXTLINE
-    namespace root {
-        void cacheSudo();
-        void dropSudo();
-
-        //
-        [[nodiscard("Discarding could lead to vulnerabilities and bugs")]] bool createDirectory(const std::string& path, const std::string& mode);
-        [[nodiscard("Discarding could lead to vulnerabilities and bugs")]] bool removeRecursive(const std::string& path);
-        [[nodiscard("Discarding could lead to vulnerabilities and bugs")]] bool install(const std::string& what, const std::string& where, const std::string& mode);
-
-        // Do not use this unless absolutely necessary!
-        std::string runAsSuperuserUnsafe(const std::string& cmd);
-    };
-};

hyprpm/src/main.cpp

@@ -2,36 +2,34 @@
 #include "helpers/StringUtils.hpp"
 #include "core/PluginManager.hpp"
 #include "core/DataState.hpp"
-#include "helpers/Sys.hpp"
 
+#include <cstdio>
 #include <vector>
 #include <string>
 #include <print>
-
-#include <hyprutils/utils/ScopeGuard.hpp>
-using namespace Hyprutils::Utils;
+#include <chrono>
+#include <thread>
 
 constexpr std::string_view HELP = R"#(┏ hyprpm, a Hyprland Plugin Manager
 ┃
-┣ add [url] [git rev]    → Install a new plugin repository from git. Git revision.
+┣ add [url] [git rev]    → Install a new plugin repository from git. Git revision
 ┃                          is optional, when set, commit locks are ignored.
-┣ remove [url/name]      → Remove an installed plugin repository.
-┣ enable [name]          → Enable a plugin.
-┣ disable [name]         → Disable a plugin.
-┣ update                 → Check and update all plugins if needed.
+┣ remove [url/name]      → Remove an installed plugin repository
+┣ enable [name]          → Enable a plugin
+┣ disable [name]         → Disable a plugin
+┣ update                 → Check and update all plugins if needed
 ┣ reload                 → Reload hyprpm state. Ensure all enabled plugins are loaded.
-┣ list                   → List all installed plugins.
-┣ purge-cache            → Remove the entire hyprpm cache, built plugins, hyprpm settings and headers.
+┣ list                   → List all installed plugins
 ┃
 ┣ Flags:
 ┃
-┣ --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).
-┣ --no-shallow   | -s    → Disable shallow cloning of Hyprland sources.
-┣ --hl-url       |       → Pass a custom hyprland source url.
+┣ --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)
+┣ --no-shallow   | -s    → Disable shallow cloning of Hyprland sources
+┣ --hl-url       |       → Pass a custom hyprland source url
 ┗
 )#";
 
@@ -98,11 +96,9 @@ int                        main(int argc, char** argv, char** envp) {
         }
 
         std::string rev = "";
-        if (command.size() >= 3)
+        if (command.size() >= 3) {
             rev = command[2];
-
-        NSys::root::cacheSudo();
-        CScopeGuard x([] { NSys::root::dropSudo(); });
+        }
 
         return g_pPluginManager->addNewPluginRepo(command[1], rev) ? 0 : 1;
     } else if (command[0] == "remove") {
@@ -111,17 +107,10 @@ int                        main(int argc, char** argv, char** envp) {
             return 1;
         }
 
-        NSys::root::cacheSudo();
-        CScopeGuard x([] { NSys::root::dropSudo(); });
-
         return g_pPluginManager->removePluginRepo(command[1]) ? 0 : 1;
     } else if (command[0] == "update") {
-        NSys::root::cacheSudo();
-        CScopeGuard x([] { NSys::root::dropSudo(); });
-
         bool headersValid = g_pPluginManager->headersValid() == HEADERS_OK;
         bool headers      = g_pPluginManager->updateHeaders(force);
-
         if (headers) {
             const auto HLVER            = g_pPluginManager->getHyprlandVersion(false);
             auto       GLOBALSTATE      = DataState::getGlobalState();
@@ -152,9 +141,6 @@ int                        main(int argc, char** argv, char** envp) {
             return 1;
         }
 
-        NSys::root::cacheSudo();
-        CScopeGuard x([] { NSys::root::dropSudo(); });
-
         auto ret = g_pPluginManager->ensurePluginsLoadState();
 
         if (ret == LOADSTATE_HYPRLAND_UPDATED)
@@ -173,11 +159,7 @@ int                        main(int argc, char** argv, char** envp) {
             return 1;
         }
 
-        NSys::root::cacheSudo();
-        CScopeGuard x([] { NSys::root::dropSudo(); });
-
         auto ret = g_pPluginManager->ensurePluginsLoadState();
-
         if (ret != LOADSTATE_OK)
             return 1;
     } else if (command[0] == "reload") {
@@ -199,10 +181,6 @@ int                        main(int argc, char** argv, char** envp) {
         } else if (notify && !notifyFail) {
             g_pPluginManager->notify(ICON_OK, 0, 4000, "[hyprpm] Loaded plugins");
         }
-    } else if (command[0] == "purge-cache") {
-        NSys::root::cacheSudo();
-        CScopeGuard x([] { NSys::root::dropSudo(); });
-        DataState::purgeAllCache();
     } else if (command[0] == "list") {
         g_pPluginManager->listAllPlugins();
     } else {

hyprpm/src/progress/CProgressBar.cpp

@@ -1,78 +1,82 @@
 #include "CProgressBar.hpp"
 
 #include <sys/ioctl.h>
-#include <unistd.h>
+#include <algorithm>
 #include <cmath>
 #include <format>
-#include <print>
-#include <cstdio>
 
-#include <algorithm>
-#include <sstream>
+#include <print>
+#include <stdio.h>
+#include <unistd.h>
 
 #include "../helpers/Colors.hpp"
 
-static winsize getTerminalSize() {
-    winsize w{};
-    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
-    return w;
-}
-
-static void clearCurrentLine() {
-    std::print("\r\33[2K"); // ansi escape sequence to clear entire line
-}
-
 void CProgressBar::printMessageAbove(const std::string& msg) {
-    clearCurrentLine();
-    std::print("\r{}\n", msg);
+    struct winsize w;
+    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
 
-    print(); // reprint bar underneath
+    std::string spaces;
+    spaces.reserve(w.ws_col);
+    for (size_t i = 0; i < w.ws_col; ++i) {
+        spaces += ' ';
+    }
+
+    std::println("\r{}\r{}", spaces, msg);
+    print();
 }
 
 void CProgressBar::print() {
-    const auto w = getTerminalSize();
+    struct winsize w;
+    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
 
-    if (m_bFirstPrint) {
+    if (m_bFirstPrint)
         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 += ' ';
     }
 
-    clearCurrentLine();
+    std::print("\r{}\r", spaces);
 
-    float percentDone = 0.0f;
-    if (m_fPercentage >= 0.0f)
+    std::string message = "";
+
+    float       percentDone = 0;
+    if (m_fPercentage >= 0)
         percentDone = m_fPercentage;
-    else {
-        // check for divide-by-zero
-        percentDone = m_iMaxSteps > 0 ? static_cast<float>(m_iSteps) / m_iMaxSteps : 0.0f;
-    }
-    // clamp to ensure no overflows (sanity check)
-    percentDone = std::clamp(percentDone, 0.0f, 1.0f);
+    else
+        percentDone = (float)m_iSteps / (float)m_iMaxSteps;
 
-    const size_t       BARWIDTH = std::clamp<size_t>(w.ws_col - m_szCurrentMessage.length() - 2, 0, 50);
+    const auto BARWIDTH = std::clamp(w.ws_col - static_cast<unsigned long>(m_szCurrentMessage.length()) - 2, 0UL, 50UL);
 
-    std::ostringstream oss;
-    oss << ' ' << Colors::GREEN;
-
-    size_t filled = static_cast<size_t>(std::floor(percentDone * BARWIDTH));
+    // draw bar
+    message += std::string{" "} + Colors::GREEN;
     size_t i = 0;
-
-    for (; i < filled; ++i)
-        oss << "━";
+    for (; i < std::floor(percentDone * BARWIDTH); ++i) {
+        message += "━";
+    }
 
     if (i < BARWIDTH) {
-        oss << "╍" << Colors::RESET;
-        ++i;
-        for (; i < BARWIDTH; ++i)
-            oss << "━";
+        i++;
+
+        message += std::string{"╍"} + Colors::RESET;
+
+        for (; i < BARWIDTH; ++i) {
+            message += "━";
+        }
     } else
-        oss << Colors::RESET;
+        message += Colors::RESET;
 
-    if (m_fPercentage >= 0.0f)
-        oss << "  " << std::format("{}%", static_cast<int>(percentDone * 100.0)) << ' ';
+    // draw progress
+    if (m_fPercentage >= 0)
+        message += "  " + std::format("{}%", static_cast<int>(percentDone * 100.0)) + " ";
     else
-        oss << "  " << std::format("{} / {}", m_iSteps, m_iMaxSteps) << ' ';
+        message += "  " + std::format("{} / {}", m_iSteps, m_iMaxSteps) + " ";
+
+    // draw message
+    std::print("{} {}", message, m_szCurrentMessage);
 
-    std::print("{} {}", oss.str(), m_szCurrentMessage);
     std::fflush(stdout);
 }

meson.build

@@ -35,7 +35,7 @@ aquamarine = dependency('aquamarine', version: '>=0.8.0')
 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.7.0')
+hyprutils = dependency('hyprutils', version: '>= 0.2.3')
 aquamarine_version_list = aquamarine.version().split('.')
 add_project_arguments(['-DAQUAMARINE_VERSION="@0@"'.format(aquamarine.version())], language: 'cpp')
 add_project_arguments(['-DAQUAMARINE_VERSION_MAJOR=@0@'.format(aquamarine_version_list.get(0))], language: 'cpp')
@@ -87,11 +87,9 @@ endif
 
 # Generate hyprland version and populate version.h
 run_command('sh', '-c', 'scripts/generateVersion.sh', check: true)
-# Make shader files includable
-run_command('sh', '-c', 'scripts/generateShaderIncludes.sh', check: true)
 
 # Install headers
-globber = run_command('find', 'src', '-name', '*.h*', '-o', '-name', '*.inc', check: true)
+globber = run_command('find', 'src', '-name', '*.h*', '-o', '-name', '*.frag', check: true)
 headers = globber.stdout().strip().split('\n')
 foreach file : headers
   install_headers(file, subdir: 'hyprland', preserve_path: true)

nix/default.nix

@@ -11,7 +11,6 @@
   aquamarine,
   binutils,
   cairo,
-  epoll-shim,
   git,
   glaze,
   hyprcursor,
@@ -142,7 +141,6 @@ in
           wayland-scanner
           xorg.libXcursor
         ]
-        (optionals customStdenv.hostPlatform.isBSD [ epoll-shim ])
         (optionals customStdenv.hostPlatform.isMusl [libexecinfo])
         (optionals enableXWayland [
           xorg.libxcb
@@ -155,8 +153,6 @@ in
         (optional withSystemd systemd)
       ];
 
-      strictDeps = true;
-
       mesonBuildType =
         if debug
         then "debug"
@@ -166,7 +162,6 @@ in
         (mapAttrsToList mesonEnable {
           "xwayland" = enableXWayland;
           "legacy_renderer" = legacyRenderer;
-          "systemd" = withSystemd;
           "uwsm" = false;
           "hyprpm" = false;
         })

nix/module.nix

@@ -126,14 +126,13 @@ in {
             bottomCommandsPrefixes = cfg.bottomPrefixes;
           }
           {
-            "exec-once" = let
+            plugin = let
               mkEntry = entry:
                 if lib.types.package.check entry
                 then "${entry}/lib/lib${entry.pname}.so"
                 else entry;
-              hyprctl = lib.getExe' config.programs.hyprland.package "hyprctl";
             in
-              map (p: "${hyprctl} plugin load ${mkEntry p}") cfg.plugins;
+              map mkEntry cfg.plugins;
           };
       in
         lib.mkIf shouldGenerate {

nix/overlays.nix

@@ -29,7 +29,6 @@ in {
     inputs.hyprutils.overlays.default
     inputs.hyprwayland-scanner.overlays.default
     self.overlays.udis86
-    self.overlays.wayland-protocols
 
     # Hyprland packages themselves
     (final: _prev: let
@@ -90,16 +89,4 @@ in {
       patches = [];
     });
   };
-
-  # TODO: remove when https://github.com/NixOS/nixpkgs/pull/397497 lands in master
-  wayland-protocols = final: prev: {
-    wayland-protocols = prev.wayland-protocols.overrideAttrs (self: super: {
-      version = "1.43";
-
-      src = final.fetchurl {
-        url = "https://gitlab.freedesktop.org/wayland/${self.pname}/-/releases/${self.version}/downloads/${self.pname}-${self.version}.tar.xz";
-        hash = "sha256-ujw0Jd0nxXtSkek9upe+EkeWAeALyrJNJkcZSMtkNlM=";
-      };
-    });
-  };
 }

protocols/meson.build

@@ -1,13 +1,13 @@
 wayland_protos = dependency(
 	'wayland-protocols',
-	version: '>=1.43',
+	version: '>=1.41',
 	fallback: 'wayland-protocols',
 	default_options: ['tests=false'],
 )
 
 hyprland_protos = dependency(
 	'hyprland-protocols',
-	version: '>=0.6.4',
+	version: '>=0.6.2',
 	fallback: 'hyprland-protocols',
 )
 
@@ -37,7 +37,6 @@ protocols = [
 	'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-toplevel-mapping-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',
@@ -73,8 +72,6 @@ protocols = [
 	wayland_protocol_dir / 'staging/security-context/security-context-v1.xml',
 	wayland_protocol_dir / 'staging/content-type/content-type-v1.xml',
 	wayland_protocol_dir / 'staging/color-management/color-management-v1.xml',
-	wayland_protocol_dir / 'staging/xdg-toplevel-tag/xdg-toplevel-tag-v1.xml',
-	wayland_protocol_dir / 'staging/xdg-system-bell/xdg-system-bell-v1.xml',
 ]
 
 wl_protocols = []
@@ -90,7 +87,7 @@ foreach protocol : protocols
 endforeach
 
 # wayland.xml generation
-wayland_scanner = dependency('wayland-scanner', native: true)
+wayland_scanner = dependency('wayland-scanner')
 wayland_scanner_datadir = wayland_scanner.get_variable('pkgdatadir')
 
 wayland_xml = wayland_scanner_datadir / 'wayland.xml'

scripts/generateShaderIncludes.sh

@@ -1,24 +0,0 @@
-#!/bin/sh
-
-SHADERS_SRC="./src/render/shaders/glsl"
-
-echo "-- Generating shader includes"
-
-if [ ! -d ./src/render/shaders ]; then
-	mkdir ./src/render/shaders
-fi
-
-echo '#pragma once' > ./src/render/shaders/Shaders.hpp
-echo '#include <map>' >> ./src/render/shaders/Shaders.hpp
-echo 'static const std::map<std::string, std::string> SHADERS = {' >> ./src/render/shaders/Shaders.hpp
-
-for filename in `ls ${SHADERS_SRC}`; do
-	echo "--	${filename}"
-	
-	{ echo 'R"#('; cat ${SHADERS_SRC}/${filename}; echo ')#"'; } > ./src/render/shaders/${filename}.inc
-	echo "{\"${filename}\"," >> ./src/render/shaders/Shaders.hpp
-	echo "#include \"./${filename}.inc\"" >> ./src/render/shaders/Shaders.hpp
-	echo "}," >> ./src/render/shaders/Shaders.hpp
-done
-
-echo '};' >> ./src/render/shaders/Shaders.hpp

src/Compositor.hpp

@@ -25,29 +25,28 @@ class CCompositor {
     CCompositor(bool onlyConfig = false);
     ~CCompositor();
 
-    wl_display*                                  m_wlDisplay   = nullptr;
-    wl_event_loop*                               m_wlEventLoop = nullptr;
-    int                                          m_drmFD       = -1;
-    bool                                         m_initialized = false;
-    SP<Aquamarine::CBackend>                     m_aqBackend;
+    wl_display*                                m_sWLDisplay   = nullptr;
+    wl_event_loop*                             m_sWLEventLoop = nullptr;
+    int                                        m_iDRMFD       = -1;
+    bool                                       m_bInitialized = false;
+    SP<Aquamarine::CBackend>                   m_pAqBackend;
 
-    std::string                                  m_hyprTempDataRoot = "";
+    std::string                                m_szHyprTempDataRoot = "";
 
-    std::string                                  m_wlDisplaySocket   = "";
-    std::string                                  m_instanceSignature = "";
-    std::string                                  m_instancePath      = "";
-    std::string                                  m_currentSplash     = "error";
+    std::string                                m_szWLDisplaySocket   = "";
+    std::string                                m_szInstanceSignature = "";
+    std::string                                m_szInstancePath      = "";
+    std::string                                m_szCurrentSplash     = "error";
 
-    std::vector<PHLMONITOR>                      m_monitors;
-    std::vector<PHLMONITOR>                      m_realMonitors; // for all monitors, even those turned off
-    std::vector<PHLWINDOW>                       m_windows;
-    std::vector<PHLLS>                           m_layers;
-    std::vector<PHLWORKSPACE>                    m_workspaces;
-    std::vector<PHLWINDOWREF>                    m_windowsFadingOut;
-    std::vector<PHLLSREF>                        m_surfacesFadingOut;
+    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;
+    std::vector<PHLWINDOWREF>                  m_vWindowsFadingOut;
+    std::vector<PHLLSREF>                      m_vSurfacesFadingOut;
 
-    std::unordered_map<std::string, MONITORID>   m_monitorIDMap;
-    std::unordered_map<std::string, WORKSPACEID> m_seenMonitorWorkspaceMap; // map of seen monitor names to workspace IDs
+    std::unordered_map<std::string, MONITORID> m_mMonitorIDMap;
 
     void                                       initServer(std::string socketName, int socketFd);
     void                                       startCompositor();
@@ -56,22 +55,23 @@ class CCompositor {
     void                                       bumpNofile();
     void                                       restoreNofile();
 
-    WP<CWLSurfaceResource>                       m_lastFocus;
-    PHLWINDOWREF                                 m_lastWindow;
-    PHLMONITORREF                                m_lastMonitor;
+    WP<CWLSurfaceResource>                     m_pLastFocus;
+    PHLWINDOWREF                               m_pLastWindow;
+    PHLMONITORREF                              m_pLastMonitor;
 
-    std::vector<PHLWINDOWREF>                    m_windowFocusHistory; // first element is the most recently focused
+    std::vector<PHLWINDOWREF>                  m_vWindowFocusHistory; // first element is the most recently focused.
 
-    bool                                         m_readyToProcess = false;
-    bool                                         m_sessionActive  = true;
-    bool                                         m_dpmsStateOn    = true;
-    bool                                         m_unsafeState    = false; // unsafe state is when there is no monitors
-    PHLMONITORREF                                m_unsafeOutput;           // fallback output for the unsafe state
-    bool                                         m_isShuttingDown         = false;
-    bool                                         m_finalRequests          = false;
-    bool                                         m_desktopEnvSet          = false;
-    bool                                         m_wantsXwayland          = true;
-    bool                                         m_onlyConfigVerification = false;
+    bool                                       m_bReadyToProcess = false;
+    bool                                       m_bSessionActive  = true;
+    bool                                       m_bDPMSStateON    = true;
+    bool                                       m_bUnsafeState    = false; // unsafe state is when there is no monitors.
+    bool                                       m_bNextIsUnsafe   = false;
+    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;
 
     // ------------------------------------------------- //
 
@@ -85,7 +85,7 @@ class CCompositor {
     void                   focusSurface(SP<CWLSurfaceResource>, PHLWINDOW pWindowOwner = nullptr);
     bool                   monitorExists(PHLMONITOR);
     PHLWINDOW              vectorToWindowUnified(const Vector2D&, uint8_t properties, PHLWINDOW pIgnoreWindow = nullptr);
-    SP<CWLSurfaceResource> vectorToLayerSurface(const Vector2D&, std::vector<PHLLSREF>*, Vector2D*, PHLLS*, bool aboveLockscreen = false);
+    SP<CWLSurfaceResource> vectorToLayerSurface(const Vector2D&, std::vector<PHLLSREF>*, 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>);
@@ -152,7 +152,7 @@ class CCompositor {
     NColorManagement::SImageDescription getPreferredImageDescription();
     bool                                shouldChangePreferredImageDescription();
 
-    std::string                         m_explicitConfigPath;
+    std::string                         explicitConfigPath;
 
   private:
     void             initAllSignals();
@@ -165,9 +165,9 @@ class CCompositor {
     void             removeLockFile();
     void             setMallocThreshold();
 
-    uint64_t         m_hyprlandPID    = 0;
+    uint64_t         m_iHyprlandPID    = 0;
     wl_event_source* m_critSigSource   = nullptr;
-    rlimit           m_originalNofile = {};
+    rlimit           m_sOriginalNofile = {};
 };
 
 inline UP<CCompositor> g_pCompositor;

src/config/ConfigDataValues.hpp

@@ -2,13 +2,11 @@
 #include "../defines.hpp"
 #include "../helpers/varlist/VarList.hpp"
 #include <vector>
-#include <map>
 
 enum eConfigValueDataTypes : int8_t {
     CVD_TYPE_INVALID   = -1,
     CVD_TYPE_GRADIENT  = 0,
-    CVD_TYPE_CSS_VALUE   = 1,
-    CVD_TYPE_FONT_WEIGHT = 2,
+    CVD_TYPE_CSS_VALUE = 1
 };
 
 class ICustomConfigValueData {
@@ -24,7 +22,7 @@ class CGradientValueData : public ICustomConfigValueData {
   public:
     CGradientValueData() = default;
     CGradientValueData(CHyprColor col) {
-        m_colors.push_back(col);
+        m_vColors.push_back(col);
         updateColorsOk();
     };
     virtual ~CGradientValueData() = default;
@@ -34,39 +32,39 @@ class CGradientValueData : public ICustomConfigValueData {
     }
 
     void reset(CHyprColor col) {
-        m_colors.clear();
-        m_colors.emplace_back(col);
-        m_angle = 0;
+        m_vColors.clear();
+        m_vColors.emplace_back(col);
+        m_fAngle = 0;
         updateColorsOk();
     }
 
     void updateColorsOk() {
-        m_colorsOkLabA.clear();
-        for (auto& c : m_colors) {
+        m_vColorsOkLabA.clear();
+        for (auto& c : m_vColors) {
             const auto OKLAB = c.asOkLab();
-            m_colorsOkLabA.emplace_back(OKLAB.l);
-            m_colorsOkLabA.emplace_back(OKLAB.a);
-            m_colorsOkLabA.emplace_back(OKLAB.b);
-            m_colorsOkLabA.emplace_back(c.a);
+            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<CHyprColor> m_colors;
+    std::vector<CHyprColor> m_vColors;
 
     /* Vector containing pure colors for shoving into opengl */
-    std::vector<float> m_colorsOkLabA;
+    std::vector<float> m_vColorsOkLabA;
 
     /* Float corresponding to the angle (rad) */
-    float m_angle = 0;
+    float m_fAngle = 0;
 
     //
     bool operator==(const CGradientValueData& other) const {
-        if (other.m_colors.size() != m_colors.size() || m_angle != other.m_angle)
+        if (other.m_vColors.size() != m_vColors.size() || m_fAngle != other.m_fAngle)
             return false;
 
-        for (size_t i = 0; i < m_colors.size(); ++i)
-            if (m_colors[i] != other.m_colors[i])
+        for (size_t i = 0; i < m_vColors.size(); ++i)
+            if (m_vColors[i] != other.m_vColors[i])
                 return false;
 
         return true;
@@ -74,28 +72,28 @@ class CGradientValueData : public ICustomConfigValueData {
 
     virtual std::string toString() {
         std::string result;
-        for (auto& c : m_colors) {
+        for (auto& c : m_vColors) {
             result += std::format("{:x} ", c.getAsHex());
         }
 
-        result += std::format("{}deg", (int)(m_angle * 180.0 / M_PI));
+        result += std::format("{}deg", (int)(m_fAngle * 180.0 / M_PI));
         return result;
     }
 };
 
 class CCssGapData : public ICustomConfigValueData {
   public:
-    CCssGapData() : m_top(0), m_right(0), m_bottom(0), m_left(0) {};
-    CCssGapData(int64_t global) : m_top(global), m_right(global), m_bottom(global), m_left(global) {};
-    CCssGapData(int64_t vertical, int64_t horizontal) : m_top(vertical), m_right(horizontal), m_bottom(vertical), m_left(horizontal) {};
-    CCssGapData(int64_t top, int64_t horizontal, int64_t bottom) : m_top(top), m_right(horizontal), m_bottom(bottom), m_left(horizontal) {};
-    CCssGapData(int64_t top, int64_t right, int64_t bottom, int64_t left) : m_top(top), m_right(right), m_bottom(bottom), m_left(left) {};
+    CCssGapData() : top(0), right(0), bottom(0), left(0) {};
+    CCssGapData(int64_t global) : top(global), right(global), bottom(global), left(global) {};
+    CCssGapData(int64_t vertical, int64_t horizontal) : top(vertical), right(horizontal), bottom(vertical), left(horizontal) {};
+    CCssGapData(int64_t top, int64_t horizontal, int64_t bottom) : top(top), right(horizontal), bottom(bottom), left(horizontal) {};
+    CCssGapData(int64_t top, int64_t right, int64_t bottom, int64_t left) : top(top), right(right), bottom(bottom), left(left) {};
 
     /* Css like directions */
-    int64_t m_top;
-    int64_t m_right;
-    int64_t m_bottom;
-    int64_t m_left;
+    int64_t top;
+    int64_t right;
+    int64_t bottom;
+    int64_t left;
 
     void    parseGapData(CVarList varlist) {
         switch (varlist.size()) {
@@ -124,10 +122,10 @@ class CCssGapData : public ICustomConfigValueData {
     }
 
     void reset(int64_t global) {
-        m_top    = global;
-        m_right  = global;
-        m_bottom = global;
-        m_left   = global;
+        top    = global;
+        right  = global;
+        bottom = global;
+        left   = global;
     }
 
     virtual eConfigValueDataTypes getDataType() {
@@ -135,44 +133,6 @@ class CCssGapData : public ICustomConfigValueData {
     }
 
     virtual std::string toString() {
-        return std::format("{} {} {} {}", m_top, m_right, m_bottom, m_left);
-    }
-};
-
-class CFontWeightConfigValueData : public ICustomConfigValueData {
-  public:
-    CFontWeightConfigValueData() = default;
-    CFontWeightConfigValueData(const char* weight) {
-        parseWeight(weight);
-    }
-
-    int64_t                       m_value = 400; // default to normal weight
-
-    virtual eConfigValueDataTypes getDataType() {
-        return CVD_TYPE_FONT_WEIGHT;
-    }
-
-    virtual std::string toString() {
-        return std::format("{}", m_value);
-    }
-
-    void parseWeight(const std::string& strWeight) {
-        auto lcWeight{strWeight};
-        transform(strWeight.begin(), strWeight.end(), lcWeight.begin(), ::tolower);
-
-        // values taken from Pango weight enums
-        const auto WEIGHTS = std::map<std::string, int>{
-            {"thin", 100},   {"ultralight", 200}, {"light", 300}, {"semilight", 350}, {"book", 380},  {"normal", 400},
-            {"medium", 500}, {"semibold", 600},   {"bold", 700},  {"ultrabold", 800}, {"heavy", 900}, {"ultraheavy", 1000},
-        };
-
-        auto weight = WEIGHTS.find(lcWeight);
-        if (weight != WEIGHTS.end())
-            m_value = weight->second;
-        else {
-            int w_i = std::stoi(strWeight);
-            if (w_i < 100 || w_i > 1000)
-                m_value = 400;
-        }
+        return std::format("{} {} {} {}", top, right, bottom, left);
     }
 };

src/config/ConfigDescriptions.hpp

@@ -247,12 +247,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_STRING_LONG,
         .data        = SConfigOptionDescription::SStringData{""}, //##TODO UNSET?
     },
-    SConfigOptionDescription{
-        .value       = "decoration:border_part_of_window",
-        .description = "whether the border should be treated as a part of the window.",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{true},
-    },
 
     /*
      * blur:
@@ -372,12 +366,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{true},
     },
-    SConfigOptionDescription{
-        .value       = "animations:workspace_wraparound",
-        .description = "changes the direction of slide animations between the first and last workspaces",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{true},
-    },
 
     /*
      * input:
@@ -903,18 +891,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_STRING_SHORT,
         .data        = SConfigOptionDescription::SStringData{STRVAL_EMPTY}, //##TODO UNSET?
     },
-    SConfigOptionDescription{
-        .value       = "group:groupbar:font_weight_active",
-        .description = "weight of the font used to display active groupbar titles",
-        .type        = CONFIG_OPTION_STRING_SHORT,
-        .data        = SConfigOptionDescription::SStringData{"normal"},
-    },
-    SConfigOptionDescription{
-        .value       = "group:groupbar:font_weight_inactive",
-        .description = "weight of the font used to display inactive groupbar titles",
-        .type        = CONFIG_OPTION_STRING_SHORT,
-        .data        = SConfigOptionDescription::SStringData{"normal"},
-    },
     SConfigOptionDescription{
         .value       = "group:groupbar:font_size",
         .description = "font size of groupbar title",
@@ -933,12 +909,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_INT,
         .data        = SConfigOptionDescription::SRangeData{14, 1, 64},
     },
-    SConfigOptionDescription{
-        .value       = "group:groupbar:indicator_gap",
-        .description = "height of the gap between the groupbar indicator and title",
-        .type        = CONFIG_OPTION_INT,
-        .data        = SConfigOptionDescription::SRangeData{0, 0, 64},
-    },
     SConfigOptionDescription{
         .value       = "group:groupbar:indicator_height",
         .description = "height of the groupbar indicator",
@@ -1035,18 +1005,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_INT,
         .data        = SConfigOptionDescription::SRangeData{2, 0, 20},
     },
-    SConfigOptionDescription{
-        .value       = "group:groupbar:keep_upper_gap",
-        .description = "keep an upper gap above gradient",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{true},
-    },
-    SConfigOptionDescription{
-        .value       = "group:groupbar:text_offset",
-        .description = "set an offset for a text",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SRangeData{0, -20, 20},
-    },
 
     /*
      * misc:
@@ -1259,12 +1217,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{true},
     },
-    SConfigOptionDescription{
-        .value       = "misc:anr_missed_pings",
-        .description = "number of missed pings before showing the ANR dialog",
-        .type        = CONFIG_OPTION_INT,
-        .data        = SConfigOptionDescription::SRangeData{1, 1, 10},
-    },
 
     /*
      * binds:
@@ -1288,12 +1240,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{false},
     },
-    SConfigOptionDescription{
-        .value       = "binds:hide_special_on_workspace_change",
-        .description = "If enabled, changing the active workspace (including to itself) will hide the special workspace on the monitor where the newly active workspace resides.",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{false},
-    },
     SConfigOptionDescription{
         .value       = "binds:allow_workspace_cycles",
         .description = "If enabled, workspaces don’t forget their previous workspace, so cycles can be created by switching to the first workspace in a sequence, then endlessly "
@@ -1350,12 +1296,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{false},
     },
-    SConfigOptionDescription{
-        .value       = "binds:drag_threshold",
-        .description = "Movement threshold in pixels for window dragging and c/g bind flags. 0 to disable and grab on mousedown.",
-        .type        = CONFIG_OPTION_INT,
-        .data        = SConfigOptionDescription::SRangeData{0, 0, INT_MAX},
-    },
 
     /*
      * xwayland:
@@ -1450,12 +1390,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{true},
     },
-    SConfigOptionDescription{
-        .value       = "render:send_content_type",
-        .description = "Report content type to allow monitor profile autoswitch (may result in a black screen during the switch)",
-        .type        = CONFIG_OPTION_BOOL,
-        .data        = SConfigOptionDescription::SBoolData{true},
-    },
 
     /*
      * cursor:
@@ -1510,13 +1444,6 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_CHOICE,
         .data        = SConfigOptionDescription::SChoiceData{0, "Disabled,Enabled,Force"},
     },
-    SConfigOptionDescription{
-        .value       = "cursor:warp_on_toggle_special",
-        .description = "Move the cursor to the last focused window when toggling a special 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",
         .description = "the name of a default monitor for the cursor to be set to on startup (see hyprctl monitors for names)",
@@ -1641,6 +1568,12 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_BOOL,
         .data        = SConfigOptionDescription::SBoolData{false},
     },
+    SConfigOptionDescription{
+        .value       = "debug:watchdog_timeout",
+        .description = "sets the timeout in seconds for watchdog to abort processing of a signal of the main thread. Set to 0 to disable.",
+        .type        = CONFIG_OPTION_INT,
+        .data        = SConfigOptionDescription::SRangeData{5, 0, 20},
+    },
     SConfigOptionDescription{
         .value       = "debug:disable_scale_checks",
         .description = "disables verification of the scale factors. Will result in pixel alignment and rounding errors.",
@@ -1817,10 +1750,12 @@ inline static const std::vector<SConfigOptionDescription> CONFIG_OPTIONS = {
         .type        = CONFIG_OPTION_INT,
         .data        = SConfigOptionDescription::SRangeData{2, 0, 10}, //##TODO RANGE?
     },
-    SConfigOptionDescription{.value       = "master:center_master_fallback",
-                             .description = "Set fallback for center master when slaves are less than slave_count_for_center_master, can be left ,right ,top ,bottom",
-                             .type        = CONFIG_OPTION_STRING_SHORT,
-                             .data        = SConfigOptionDescription::SStringData{"left"}},
+    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",

src/config/ConfigManager.hpp

@@ -141,18 +141,8 @@ struct SFirstExecRequest {
 struct SFloatCache {
     size_t hash;
 
-    SFloatCache(PHLWINDOW window, bool initial) {
-        // Base hash from class/title
-        size_t baseHash = initial ? (std::hash<std::string>{}(window->m_initialClass) ^ (std::hash<std::string>{}(window->m_initialTitle) << 1)) :
-                                    (std::hash<std::string>{}(window->m_class) ^ (std::hash<std::string>{}(window->m_title) << 1));
-
-        // Use empty string as default tag value
-        std::string tagValue = "";
-        if (auto xdgTag = window->xdgTag())
-            tagValue = xdgTag.value();
-
-        // Combine hashes
-        hash = baseHash ^ (std::hash<std::string>{}(tagValue) << 2);
+    SFloatCache(PHLWINDOW window) {
+        hash = std::hash<std::string>{}(window->m_szClass) ^ (std::hash<std::string>{}(window->m_szTitle) << 1);
     }
 
     bool operator==(const SFloatCache& other) const {
@@ -254,49 +244,48 @@ class CConfigManager {
     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> handlePermission(const std::string&, const std::string&);
 
-    std::string                m_configCurrentPath;
+    std::string                configCurrentPath;
 
-    bool                       m_wantsMonitorReload                  = false;
-    bool                       m_noMonitorReload                     = false;
-    bool                       m_isLaunchingExecOnce                 = false; // For exec-once to skip initial ws tracking
-    bool                       m_lastConfigVerificationWasSuccessful = true;
+    bool                       m_bWantsMonitorReload                  = false;
+    bool                       m_bNoMonitorReload                     = false;
+    bool                       isLaunchingExecOnce                    = false; // For exec-once to skip initial ws tracking
+    bool                       m_bLastConfigVerificationWasSuccessful = true;
 
     void                       storeFloatingSize(PHLWINDOW window, const Vector2D& size);
     std::optional<Vector2D>    getStoredFloatingSize(PHLWINDOW window);
 
   private:
-    UP<Hyprlang::CConfig>                            m_config;
+    UP<Hyprlang::CConfig>                            m_pConfig;
 
     std::vector<std::string>                         m_configPaths;
 
-    Hyprutils::Animation::CAnimationConfigTree       m_animationTree;
+    Hyprutils::Animation::CAnimationConfigTree       m_AnimationTree;
 
-    std::string                                      m_currentSubmap = ""; // For storing the current keybind submap
+    std::string                                      m_szCurrentSubmap = ""; // For storing the current keybind submap
 
-    std::vector<SExecRequestedRule>                  m_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_declaredPlugins;
-    std::vector<SPluginKeyword>                      m_pluginKeywords;
-    std::vector<SPluginVariable>                     m_pluginVariables;
+    std::vector<std::string>                         m_vDeclaredPlugins;
+    std::vector<SPluginKeyword>                      pluginKeywords;
+    std::vector<SPluginVariable>                     pluginVariables;
 
-    bool                                             m_isFirstLaunch = true; // For exec-once
+    bool                                             isFirstLaunch = true; // For exec-once
 
-    std::vector<SMonitorRule>                        m_monitorRules;
-    std::vector<SWorkspaceRule>                      m_workspaceRules;
-    std::vector<SP<CWindowRule>>                     m_windowRules;
-    std::vector<SP<CLayerRule>>                      m_layerRules;
-    std::vector<std::string>                         m_blurLSNamespaces;
+    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                                             m_firstExecDispatched  = false;
-    bool                                             m_manualCrashInitiated = false;
+    bool                                             firstExecDispatched     = false;
+    bool                                             m_bManualCrashInitiated = false;
 
-    std::vector<SFirstExecRequest>                   m_firstExecRequests; // bool is for if with rules
-    std::vector<std::string>                         m_finalExecRequests;
+    std::vector<SFirstExecRequest>                   firstExecRequests; // bool is for if with rules
+    std::vector<std::string>                         finalExecRequests;
 
-    std::vector<std::pair<std::string, std::string>> m_failedPluginConfigValues; // for plugin values of unloaded plugins
-    std::string                                      m_configErrors = "";
+    std::vector<std::pair<std::string, std::string>> m_vFailedPluginConfigValues; // for plugin values of unloaded plugins
+    std::string                                      m_szConfigErrors = "";
 
     uint32_t                                         m_configValueNumber = 0;
 

src/config/ConfigValue.cpp

@@ -1,15 +0,0 @@
-#include "ConfigValue.hpp"
-#include "ConfigManager.hpp"
-#include "../macros.hpp"
-
-void local__configValuePopulate(void* const** p, const std::string& val) {
-    const auto PVHYPRLANG = g_pConfigManager->getHyprlangConfigValuePtr(val);
-
-    *p = PVHYPRLANG->getDataStaticPtr();
-}
-
-std::type_index local__configValueTypeIdx(const std::string& val) {
-    const auto PVHYPRLANG = g_pConfigManager->getHyprlangConfigValuePtr(val);
-    const auto ANY        = PVHYPRLANG->getValue();
-    return std::type_index(ANY.type());
-}

src/config/ConfigValue.hpp

@@ -4,19 +4,21 @@
 #include <typeindex>
 #include <hyprlang.hpp>
 #include "../macros.hpp"
-
-// giga hack to avoid including configManager here
-// NOLINTNEXTLINE
-void            local__configValuePopulate(void* const** p, const std::string& val);
-std::type_index local__configValueTypeIdx(const std::string& val);
+#include "ConfigManager.hpp"
 
 template <typename T>
 class CConfigValue {
   public:
     CConfigValue(const std::string& val) {
+        const auto PVHYPRLANG = g_pConfigManager->getHyprlangConfigValuePtr(val);
+
+        // NOLINTNEXTLINE
+        p_ = PVHYPRLANG->getDataStaticPtr();
+
 #ifdef HYPRLAND_DEBUG
         // verify type
-        const auto TYPE = local__configValueTypeIdx(val);
+        const auto ANY  = PVHYPRLANG->getValue();
+        const auto TYPE = std::type_index(ANY.type());
 
         // exceptions
         const bool STRINGEX = (typeid(T) == typeid(std::string) && TYPE == typeid(Hyprlang::STRING));
@@ -24,8 +26,6 @@ class CConfigValue {
 
         RASSERT(typeid(T) == TYPE || STRINGEX || CUSTOMEX, "Mismatched type in CConfigValue<T>, got {} but has {}", typeid(T).name(), TYPE.name());
 #endif
-
-        local__configValuePopulate(&p_, val);
     }
 
     T* ptr() const {

src/config/defaultConfig.hpp

@@ -65,23 +65,6 @@ env = XCURSOR_SIZE,24
 env = HYPRCURSOR_SIZE,24
 
 
-###################
-### PERMISSIONS ###
-###################
-
-# See https://wiki.hyprland.org/Configuring/Permissions/
-# Please note permission changes here require a Hyprland restart and are not applied on-the-fly
-# for security reasons
-
-# ecosystem {
-#   enforce_permissions = 1
-# }
-
-# permission = /usr/(bin|local/bin)/grim, screencopy, allow
-# permission = /usr/(lib|libexec|lib64)/xdg-desktop-portal-hyprland, screencopy, allow
-# permission = /usr/(bin|local/bin)/hyprpm, plugin, allow
-
-
 #####################
 ### LOOK AND FEEL ###
 #####################
@@ -290,8 +273,8 @@ bindel = ,XF86AudioRaiseVolume, exec, wpctl set-volume -l 1 @DEFAULT_AUDIO_SINK@
 bindel = ,XF86AudioLowerVolume, exec, wpctl set-volume @DEFAULT_AUDIO_SINK@ 5%-
 bindel = ,XF86AudioMute, exec, wpctl set-mute @DEFAULT_AUDIO_SINK@ toggle
 bindel = ,XF86AudioMicMute, exec, wpctl set-mute @DEFAULT_AUDIO_SOURCE@ toggle
-bindel = ,XF86MonBrightnessUp, exec, brightnessctl -e4 -n2 set 5%+
-bindel = ,XF86MonBrightnessDown, exec, brightnessctl -e4 -n2 set 5%-
+bindel = ,XF86MonBrightnessUp, exec, brightnessctl s 10%+
+bindel = ,XF86MonBrightnessDown, exec, brightnessctl s 10%-
 
 # Requires playerctl
 bindl = , XF86AudioNext, exec, playerctl next

src/debug/CrashReporter.cpp

@@ -130,11 +130,11 @@ void NCrashReporter::createAndSaveCrash(int sig) {
         for (size_t i = 0; i < count; i++) {
             auto p = plugins[i];
             finalCrashReport += '\t';
-            finalCrashReport += p->m_name;
+            finalCrashReport += p->name;
             finalCrashReport += " (";
-            finalCrashReport += p->m_author;
+            finalCrashReport += p->author;
             finalCrashReport += ") ";
-            finalCrashReport += p->m_version;
+            finalCrashReport += p->version;
             finalCrashReport += '\n';
         }
 
@@ -192,7 +192,7 @@ void NCrashReporter::createAndSaveCrash(int sig) {
 #endif
     };
     u_int  miblen        = sizeof(mib) / sizeof(mib[0]);
-    char   exe[PATH_MAX] = "/nonexistent";
+    char   exe[PATH_MAX] = "";
     size_t sz            = sizeof(exe);
     sysctl(mib, miblen, &exe, &sz, NULL, 0);
     const auto FPATH = std::filesystem::canonical(exe);
@@ -242,5 +242,5 @@ void NCrashReporter::createAndSaveCrash(int sig) {
 
     finalCrashReport += "\n\nLog tail:\n";
 
-    finalCrashReport += std::string_view(Debug::m_rollingLog).substr(Debug::m_rollingLog.find('\n') + 1);
+    finalCrashReport += std::string_view(Debug::rollingLog).substr(Debug::rollingLog.find('\n') + 1);
 }

src/debug/HyprCtl.cpp

@@ -17,7 +17,6 @@
 #include <sys/poll.h>
 #include <filesystem>
 #include <ranges>
-#include <sys/eventfd.h>
 
 #include <sstream>
 #include <string>
@@ -25,7 +24,6 @@
 #include <numeric>
 
 #include <hyprutils/string/String.hpp>
-#include <hyprutils/os/FileDescriptor.hpp>
 using namespace Hyprutils::String;
 using namespace Hyprutils::OS;
 #include <aquamarine/input/Input.hpp>
@@ -53,29 +51,6 @@ using namespace Hyprutils::OS;
 #include "../managers/AnimationManager.hpp"
 #include "../debug/HyprNotificationOverlay.hpp"
 #include "../render/Renderer.hpp"
-#include "../render/OpenGL.hpp"
-
-#if defined(__DragonFly__) || defined(__FreeBSD__)
-#include <sys/ucred.h>
-#define CRED_T   xucred
-#define CRED_LVL SOL_LOCAL
-#define CRED_OPT LOCAL_PEERCRED
-#define CRED_PID cr_pid
-#elif defined(__NetBSD__)
-#define CRED_T   unpcbid
-#define CRED_LVL SOL_LOCAL
-#define CRED_OPT LOCAL_PEEREID
-#define CRED_PID unp_pid
-#else
-#if defined(__OpenBSD__)
-#define CRED_T sockpeercred
-#else
-#define CRED_T ucred
-#endif
-#define CRED_LVL SOL_SOCKET
-#define CRED_OPT SO_PEERCRED
-#define CRED_PID pid
-#endif
 
 static void trimTrailingComma(std::string& str) {
     if (!str.empty() && str.back() == ',')
@@ -97,7 +72,7 @@ static std::string formatToString(uint32_t drmFormat) {
 static std::string availableModesForOutput(PHLMONITOR pMonitor, eHyprCtlOutputFormat format) {
     std::string result;
 
-    for (auto const& m : pMonitor->m_output->modes) {
+    for (auto const& m : pMonitor->output->modes) {
         if (format == FORMAT_NORMAL)
             result += std::format("{}x{}@{:.2f}Hz ", m->pixelSize.x, m->pixelSize.y, m->refreshRate / 1000.0);
         else
@@ -111,7 +86,7 @@ static std::string availableModesForOutput(PHLMONITOR pMonitor, eHyprCtlOutputFo
 
 std::string CHyprCtl::getMonitorData(Hyprutils::Memory::CSharedPointer<CMonitor> m, eHyprCtlOutputFormat format) {
     std::string result;
-    if (!m->m_output || m->m_id == -1)
+    if (!m->output || m->ID == -1)
         return "";
 
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
@@ -152,28 +127,27 @@ std::string CHyprCtl::getMonitorData(Hyprutils::Memory::CSharedPointer<CMonitor>
     "availableModes": [{}]
 }},)#",
 
-            m->m_id, escapeJSONStrings(m->m_name), escapeJSONStrings(m->m_shortDescription), escapeJSONStrings(m->m_output->make), escapeJSONStrings(m->m_output->model),
-            escapeJSONStrings(m->m_output->serial), (int)m->m_pixelSize.x, (int)m->m_pixelSize.y, m->m_refreshRate, (int)m->m_position.x, (int)m->m_position.y,
-            m->activeWorkspaceID(), (!m->m_activeWorkspace ? "" : escapeJSONStrings(m->m_activeWorkspace->m_name)), m->activeSpecialWorkspaceID(),
-            escapeJSONStrings(m->m_activeSpecialWorkspace ? m->m_activeSpecialWorkspace->m_name : ""), (int)m->m_reservedTopLeft.x, (int)m->m_reservedTopLeft.y,
-            (int)m->m_reservedBottomRight.x, (int)m->m_reservedBottomRight.y, m->m_scale, (int)m->m_transform, (m == g_pCompositor->m_lastMonitor ? "true" : "false"),
-            (m->m_dpmsStatus ? "true" : "false"), (m->m_output->state->state().adaptiveSync ? "true" : "false"), (uint64_t)m->m_solitaryClient.get(),
-            (m->m_tearingState.activelyTearing ? "true" : "false"), (uint64_t)m->m_lastScanout.get(), (m->m_enabled ? "false" : "true"),
-            formatToString(m->m_output->state->state().drmFormat), m->m_mirrorOf ? std::format("{}", m->m_mirrorOf->m_id) : "none", availableModesForOutput(m, format));
+            m->ID, escapeJSONStrings(m->szName), escapeJSONStrings(m->szShortDescription), escapeJSONStrings(m->output->make), escapeJSONStrings(m->output->model),
+            escapeJSONStrings(m->output->serial), (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y,
+            m->activeWorkspaceID(), (!m->activeWorkspace ? "" : escapeJSONStrings(m->activeWorkspace->m_szName)), m->activeSpecialWorkspaceID(),
+            escapeJSONStrings(m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_szName : ""), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y,
+            (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m == g_pCompositor->m_pLastMonitor ? "true" : "false"),
+            (m->dpmsStatus ? "true" : "false"), (m->output->state->state().adaptiveSync ? "true" : "false"), (uint64_t)m->solitaryClient.get(),
+            (m->tearingState.activelyTearing ? "true" : "false"), (uint64_t)m->lastScanout.get(), (m->m_bEnabled ? "false" : "true"),
+            formatToString(m->output->state->state().drmFormat), m->pMirrorOf ? std::format("{}", m->pMirrorOf->ID) : "none", availableModesForOutput(m, format));
 
     } else {
-        result +=
-            std::format("Monitor {} (ID {}):\n\t{}x{}@{:.5f} at {}x{}\n\tdescription: {}\n\tmake: {}\n\tmodel: {}\n\tserial: {}\n\tactive workspace: {} ({})\n\t"
+        result += std::format("Monitor {} (ID {}):\n\t{}x{}@{:.5f} at {}x{}\n\tdescription: {}\n\tmake: {}\n\tmodel: {}\n\tserial: {}\n\tactive workspace: {} ({})\n\t"
                               "special workspace: {} ({})\n\treserved: {} {} {} {}\n\tscale: {:.2f}\n\ttransform: {}\n\tfocused: {}\n\t"
                               "dpmsStatus: {}\n\tvrr: {}\n\tsolitary: {:x}\n\tactivelyTearing: {}\n\tdirectScanoutTo: {:x}\n\tdisabled: {}\n\tcurrentFormat: {}\n\tmirrorOf: "
                               "{}\n\tavailableModes: {}\n\n",
-                        m->m_name, m->m_id, (int)m->m_pixelSize.x, (int)m->m_pixelSize.y, m->m_refreshRate, (int)m->m_position.x, (int)m->m_position.y, m->m_shortDescription,
-                        m->m_output->make, m->m_output->model, m->m_output->serial, m->activeWorkspaceID(), (!m->m_activeWorkspace ? "" : m->m_activeWorkspace->m_name),
-                        m->activeSpecialWorkspaceID(), (m->m_activeSpecialWorkspace ? m->m_activeSpecialWorkspace->m_name : ""), (int)m->m_reservedTopLeft.x,
-                        (int)m->m_reservedTopLeft.y, (int)m->m_reservedBottomRight.x, (int)m->m_reservedBottomRight.y, m->m_scale, (int)m->m_transform,
-                        (m == g_pCompositor->m_lastMonitor ? "yes" : "no"), (int)m->m_dpmsStatus, m->m_output->state->state().adaptiveSync, (uint64_t)m->m_solitaryClient.get(),
-                        m->m_tearingState.activelyTearing, (uint64_t)m->m_lastScanout.get(), !m->m_enabled, formatToString(m->m_output->state->state().drmFormat),
-                        m->m_mirrorOf ? std::format("{}", m->m_mirrorOf->m_id) : "none", availableModesForOutput(m, format));
+                              m->szName, m->ID, (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y, m->szShortDescription,
+                              m->output->make, m->output->model, m->output->serial, m->activeWorkspaceID(), (!m->activeWorkspace ? "" : m->activeWorkspace->m_szName),
+                              m->activeSpecialWorkspaceID(), (m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_szName : ""), (int)m->vecReservedTopLeft.x,
+                              (int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform,
+                              (m == g_pCompositor->m_pLastMonitor ? "yes" : "no"), (int)m->dpmsStatus, m->output->state->state().adaptiveSync, (uint64_t)m->solitaryClient.get(),
+                              m->tearingState.activelyTearing, (uint64_t)m->lastScanout.get(), !m->m_bEnabled, formatToString(m->output->state->state().drmFormat),
+                              m->pMirrorOf ? std::format("{}", m->pMirrorOf->ID) : "none", availableModesForOutput(m, format));
     }
 
     return result;
@@ -193,7 +167,7 @@ static std::string monitorsRequest(eHyprCtlOutputFormat format, std::string requ
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         result += "[";
 
-        for (auto const& m : allMonitors ? g_pCompositor->m_realMonitors : g_pCompositor->m_monitors) {
+        for (auto const& m : allMonitors ? g_pCompositor->m_vRealMonitors : g_pCompositor->m_vMonitors) {
             result += CHyprCtl::getMonitorData(m, format);
         }
 
@@ -201,8 +175,8 @@ static std::string monitorsRequest(eHyprCtlOutputFormat format, std::string requ
 
         result += "]";
     } else {
-        for (auto const& m : allMonitors ? g_pCompositor->m_realMonitors : g_pCompositor->m_monitors) {
-            if (!m->m_output || m->m_id == -1)
+        for (auto const& m : allMonitors ? g_pCompositor->m_vRealMonitors : g_pCompositor->m_vMonitors) {
+            if (!m->output || m->ID == -1)
                 continue;
 
             result += CHyprCtl::getMonitorData(m, format);
@@ -224,7 +198,7 @@ static std::string getTagsData(PHLWINDOW w, eHyprCtlOutputFormat format) {
 
 static std::string getGroupedData(PHLWINDOW w, eHyprCtlOutputFormat format) {
     const bool isJson = format == eHyprCtlOutputFormat::FORMAT_JSON;
-    if (w->m_groupData.pNextWindow.expired())
+    if (w->m_sGroupData.pNextWindow.expired())
         return isJson ? "" : "0";
 
     std::ostringstream result;
@@ -236,7 +210,7 @@ static std::string getGroupedData(PHLWINDOW w, eHyprCtlOutputFormat format) {
             result << std::format("\"0x{:x}\"", (uintptr_t)curr.get());
         else
             result << std::format("{:x}", (uintptr_t)curr.get());
-        curr = curr->m_groupData.pNextWindow.lock();
+        curr = curr->m_sGroupData.pNextWindow.lock();
         // We've wrapped around to the start, break out without trailing comma
         if (curr == head)
             break;
@@ -248,8 +222,8 @@ static std::string getGroupedData(PHLWINDOW w, eHyprCtlOutputFormat format) {
 
 std::string CHyprCtl::getWindowData(PHLWINDOW w, eHyprCtlOutputFormat format) {
     auto getFocusHistoryID = [](PHLWINDOW wnd) -> int {
-        for (size_t i = 0; i < g_pCompositor->m_windowFocusHistory.size(); ++i) {
-            if (g_pCompositor->m_windowFocusHistory[i].lock() == wnd)
+        for (size_t i = 0; i < g_pCompositor->m_vWindowFocusHistory.size(); ++i) {
+            if (g_pCompositor->m_vWindowFocusHistory[i].lock() == wnd)
                 return i;
         }
         return -1;
@@ -283,29 +257,27 @@ std::string CHyprCtl::getWindowData(PHLWINDOW w, eHyprCtlOutputFormat format) {
     "tags": [{}],
     "swallowing": "0x{:x}",
     "focusHistoryID": {},
-    "inhibitingIdle": {},
-    "xdgTag": "{}",
-    "xdgDescription": "{}"
+    "inhibitingIdle": {}
 }},)#",
-            (uintptr_t)w.get(), (w->m_isMapped ? "true" : "false"), (w->isHidden() ? "true" : "false"), (int)w->m_realPosition->goal().x, (int)w->m_realPosition->goal().y,
-            (int)w->m_realSize->goal().x, (int)w->m_realSize->goal().y, w->m_workspace ? w->workspaceID() : WORKSPACE_INVALID,
-            escapeJSONStrings(!w->m_workspace ? "" : w->m_workspace->m_name), ((int)w->m_isFloating == 1 ? "true" : "false"), (w->m_isPseudotiled ? "true" : "false"),
-            (int64_t)w->monitorID(), escapeJSONStrings(w->m_class), escapeJSONStrings(w->m_title), escapeJSONStrings(w->m_initialClass), escapeJSONStrings(w->m_initialTitle),
-            w->getPID(), ((int)w->m_isX11 == 1 ? "true" : "false"), (w->m_pinned ? "true" : "false"), (uint8_t)w->m_fullscreenState.internal, (uint8_t)w->m_fullscreenState.client,
-            getGroupedData(w, format), getTagsData(w, format), (uintptr_t)w->m_swallowed.get(), getFocusHistoryID(w),
-            (g_pInputManager->isWindowInhibiting(w, false) ? "true" : "false"), escapeJSONStrings(w->xdgTag().value_or("")), escapeJSONStrings(w->xdgDescription().value_or("")));
+            (uintptr_t)w.get(), (w->m_bIsMapped ? "true" : "false"), (w->isHidden() ? "true" : "false"), (int)w->m_vRealPosition->goal().x, (int)w->m_vRealPosition->goal().y,
+            (int)w->m_vRealSize->goal().x, (int)w->m_vRealSize->goal().y, w->m_pWorkspace ? w->workspaceID() : WORKSPACE_INVALID,
+            escapeJSONStrings(!w->m_pWorkspace ? "" : w->m_pWorkspace->m_szName), ((int)w->m_bIsFloating == 1 ? "true" : "false"), (w->m_bIsPseudotiled ? "true" : "false"),
+            (int64_t)w->monitorID(), escapeJSONStrings(w->m_szClass), escapeJSONStrings(w->m_szTitle), escapeJSONStrings(w->m_szInitialClass),
+            escapeJSONStrings(w->m_szInitialTitle), w->getPID(), ((int)w->m_bIsX11 == 1 ? "true" : "false"), (w->m_bPinned ? "true" : "false"),
+            (uint8_t)w->m_sFullscreenState.internal, (uint8_t)w->m_sFullscreenState.client, getGroupedData(w, format), getTagsData(w, format), (uintptr_t)w->m_pSwallowed.get(),
+            getFocusHistoryID(w), (g_pInputManager->isWindowInhibiting(w, false) ? "true" : "false"));
     } else {
         return std::format(
             "Window {:x} -> {}:\n\tmapped: {}\n\thidden: {}\n\tat: {},{}\n\tsize: {},{}\n\tworkspace: {} ({})\n\tfloating: {}\n\tpseudo: {}\n\tmonitor: {}\n\tclass: {}\n\ttitle: "
             "{}\n\tinitialClass: {}\n\tinitialTitle: {}\n\tpid: "
             "{}\n\txwayland: {}\n\tpinned: "
-            "{}\n\tfullscreen: {}\n\tfullscreenClient: {}\n\tgrouped: {}\n\ttags: {}\n\tswallowing: {:x}\n\tfocusHistoryID: {}\n\tinhibitingIdle: {}\n\txdgTag: "
-            "{}\n\txdgDescription: {}\n\n",
-            (uintptr_t)w.get(), w->m_title, (int)w->m_isMapped, (int)w->isHidden(), (int)w->m_realPosition->goal().x, (int)w->m_realPosition->goal().y,
-            (int)w->m_realSize->goal().x, (int)w->m_realSize->goal().y, w->m_workspace ? w->workspaceID() : WORKSPACE_INVALID, (!w->m_workspace ? "" : w->m_workspace->m_name),
-            (int)w->m_isFloating, (int)w->m_isPseudotiled, (int64_t)w->monitorID(), w->m_class, w->m_title, w->m_initialClass, w->m_initialTitle, w->getPID(), (int)w->m_isX11,
-            (int)w->m_pinned, (uint8_t)w->m_fullscreenState.internal, (uint8_t)w->m_fullscreenState.client, getGroupedData(w, format), getTagsData(w, format),
-            (uintptr_t)w->m_swallowed.get(), getFocusHistoryID(w), (int)g_pInputManager->isWindowInhibiting(w, false), w->xdgTag().value_or(""), w->xdgDescription().value_or(""));
+            "{}\n\tfullscreen: {}\n\tfullscreenClient: {}\n\tgrouped: {}\n\ttags: {}\n\tswallowing: {:x}\n\tfocusHistoryID: {}\n\tinhibitingIdle: {}\n\n",
+            (uintptr_t)w.get(), w->m_szTitle, (int)w->m_bIsMapped, (int)w->isHidden(), (int)w->m_vRealPosition->goal().x, (int)w->m_vRealPosition->goal().y,
+            (int)w->m_vRealSize->goal().x, (int)w->m_vRealSize->goal().y, w->m_pWorkspace ? w->workspaceID() : WORKSPACE_INVALID,
+            (!w->m_pWorkspace ? "" : w->m_pWorkspace->m_szName), (int)w->m_bIsFloating, (int)w->m_bIsPseudotiled, (int64_t)w->monitorID(), w->m_szClass, w->m_szTitle,
+            w->m_szInitialClass, w->m_szInitialTitle, w->getPID(), (int)w->m_bIsX11, (int)w->m_bPinned, (uint8_t)w->m_sFullscreenState.internal,
+            (uint8_t)w->m_sFullscreenState.client, getGroupedData(w, format), getTagsData(w, format), (uintptr_t)w->m_pSwallowed.get(), getFocusHistoryID(w),
+            (int)g_pInputManager->isWindowInhibiting(w, false));
     }
 }
 
@@ -314,8 +286,8 @@ static std::string clientsRequest(eHyprCtlOutputFormat format, std::string reque
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         result += "[";
 
-        for (auto const& w : g_pCompositor->m_windows) {
-            if (!w->m_isMapped && !g_pHyprCtl->m_currentRequestParams.all)
+        for (auto const& w : g_pCompositor->m_vWindows) {
+            if (!w->m_bIsMapped && !g_pHyprCtl->m_sCurrentRequestParams.all)
                 continue;
 
             result += CHyprCtl::getWindowData(w, format);
@@ -325,8 +297,8 @@ static std::string clientsRequest(eHyprCtlOutputFormat format, std::string reque
 
         result += "]";
     } else {
-        for (auto const& w : g_pCompositor->m_windows) {
-            if (!w->m_isMapped && !g_pHyprCtl->m_currentRequestParams.all)
+        for (auto const& w : g_pCompositor->m_vWindows) {
+            if (!w->m_bIsMapped && !g_pHyprCtl->m_sCurrentRequestParams.all)
                 continue;
 
             result += CHyprCtl::getWindowData(w, format);
@@ -337,7 +309,7 @@ static std::string clientsRequest(eHyprCtlOutputFormat format, std::string reque
 
 std::string CHyprCtl::getWorkspaceData(PHLWORKSPACE w, eHyprCtlOutputFormat format) {
     const auto PLASTW   = w->getLastFocusedWindow();
-    const auto PMONITOR = w->m_monitor.lock();
+    const auto PMONITOR = w->m_pMonitor.lock();
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         return std::format(R"#({{
     "id": {},
@@ -350,14 +322,14 @@ std::string CHyprCtl::getWorkspaceData(PHLWORKSPACE w, eHyprCtlOutputFormat form
     "lastwindowtitle": "{}",
     "ispersistent": {}
 }})#",
-                           w->m_id, escapeJSONStrings(w->m_name), escapeJSONStrings(PMONITOR ? PMONITOR->m_name : "?"),
-                           escapeJSONStrings(PMONITOR ? std::to_string(PMONITOR->m_id) : "null"), w->getWindows(), w->m_hasFullscreenWindow ? "true" : "false",
-                           (uintptr_t)PLASTW.get(), PLASTW ? escapeJSONStrings(PLASTW->m_title) : "", w->m_persistent ? "true" : "false");
+                           w->m_iID, escapeJSONStrings(w->m_szName), escapeJSONStrings(PMONITOR ? PMONITOR->szName : "?"),
+                           escapeJSONStrings(PMONITOR ? std::to_string(PMONITOR->ID) : "null"), w->getWindows(), w->m_bHasFullscreenWindow ? "true" : "false",
+                           (uintptr_t)PLASTW.get(), PLASTW ? escapeJSONStrings(PLASTW->m_szTitle) : "", w->m_bPersistent ? "true" : "false");
     } else {
         return std::format(
             "workspace ID {} ({}) on monitor {}:\n\tmonitorID: {}\n\twindows: {}\n\thasfullscreen: {}\n\tlastwindow: 0x{:x}\n\tlastwindowtitle: {}\n\tispersistent: {}\n\n",
-            w->m_id, w->m_name, PMONITOR ? PMONITOR->m_name : "?", PMONITOR ? std::to_string(PMONITOR->m_id) : "null", w->getWindows(), (int)w->m_hasFullscreenWindow,
-            (uintptr_t)PLASTW.get(), PLASTW ? PLASTW->m_title : "", (int)w->m_persistent);
+            w->m_iID, w->m_szName, PMONITOR ? PMONITOR->szName : "?", PMONITOR ? std::to_string(PMONITOR->ID) : "null", w->getWindows(), (int)w->m_bHasFullscreenWindow,
+            (uintptr_t)PLASTW.get(), PLASTW ? PLASTW->m_szTitle : "", (int)w->m_bPersistent);
     }
 }
 
@@ -368,10 +340,10 @@ static std::string getWorkspaceRuleData(const SWorkspaceRule& r, eHyprCtlOutputF
         const std::string default_    = (bool)(r.isDefault) ? std::format(",\n    \"default\": {}", boolToString(r.isDefault)) : "";
         const std::string persistent  = (bool)(r.isPersistent) ? std::format(",\n    \"persistent\": {}", boolToString(r.isPersistent)) : "";
         const std::string gapsIn      = (bool)(r.gapsIn) ?
-                 std::format(",\n    \"gapsIn\": [{}, {}, {}, {}]", r.gapsIn.value().m_top, r.gapsIn.value().m_right, r.gapsIn.value().m_bottom, r.gapsIn.value().m_left) :
+                 std::format(",\n    \"gapsIn\": [{}, {}, {}, {}]", r.gapsIn.value().top, r.gapsIn.value().right, r.gapsIn.value().bottom, r.gapsIn.value().left) :
                  "";
         const std::string gapsOut     = (bool)(r.gapsOut) ?
-                std::format(",\n    \"gapsOut\": [{}, {}, {}, {}]", r.gapsOut.value().m_top, r.gapsOut.value().m_right, r.gapsOut.value().m_bottom, r.gapsOut.value().m_left) :
+                std::format(",\n    \"gapsOut\": [{}, {}, {}, {}]", r.gapsOut.value().top, r.gapsOut.value().right, r.gapsOut.value().bottom, r.gapsOut.value().left) :
                 "";
         const std::string borderSize  = (bool)(r.borderSize) ? std::format(",\n    \"borderSize\": {}", r.borderSize.value()) : "";
         const std::string border      = (bool)(r.noBorder) ? std::format(",\n    \"border\": {}", boolToString(!r.noBorder.value())) : "";
@@ -391,11 +363,11 @@ static std::string getWorkspaceRuleData(const SWorkspaceRule& r, eHyprCtlOutputF
         const std::string monitor     = std::format("\tmonitor: {}\n", r.monitor.empty() ? "<unset>" : escapeJSONStrings(r.monitor));
         const std::string default_    = std::format("\tdefault: {}\n", (bool)(r.isDefault) ? boolToString(r.isDefault) : "<unset>");
         const std::string persistent  = std::format("\tpersistent: {}\n", (bool)(r.isPersistent) ? boolToString(r.isPersistent) : "<unset>");
-        const std::string gapsIn     = (bool)(r.gapsIn) ? std::format("\tgapsIn: {} {} {} {}\n", std::to_string(r.gapsIn.value().m_top), std::to_string(r.gapsIn.value().m_right),
-                                                                      std::to_string(r.gapsIn.value().m_bottom), std::to_string(r.gapsIn.value().m_left)) :
+        const std::string gapsIn      = (bool)(r.gapsIn) ? std::format("\tgapsIn: {} {} {} {}\n", std::to_string(r.gapsIn.value().top), std::to_string(r.gapsIn.value().right),
+                                                                       std::to_string(r.gapsIn.value().bottom), std::to_string(r.gapsIn.value().left)) :
                                                            std::format("\tgapsIn: <unset>\n");
-        const std::string gapsOut = (bool)(r.gapsOut) ? std::format("\tgapsOut: {} {} {} {}\n", std::to_string(r.gapsOut.value().m_top), std::to_string(r.gapsOut.value().m_right),
-                                                                    std::to_string(r.gapsOut.value().m_bottom), std::to_string(r.gapsOut.value().m_left)) :
+        const std::string gapsOut     = (bool)(r.gapsOut) ? std::format("\tgapsOut: {} {} {} {}\n", std::to_string(r.gapsOut.value().top), std::to_string(r.gapsOut.value().right),
+                                                                        std::to_string(r.gapsOut.value().bottom), std::to_string(r.gapsOut.value().left)) :
                                                             std::format("\tgapsOut: <unset>\n");
         const std::string borderSize  = std::format("\tborderSize: {}\n", (bool)(r.borderSize) ? std::to_string(r.borderSize.value()) : "<unset>");
         const std::string border      = std::format("\tborder: {}\n", (bool)(r.noBorder) ? boolToString(!r.noBorder.value()) : "<unset>");
@@ -412,11 +384,11 @@ static std::string getWorkspaceRuleData(const SWorkspaceRule& r, eHyprCtlOutputF
 }
 
 static std::string activeWorkspaceRequest(eHyprCtlOutputFormat format, std::string request) {
-    if (!g_pCompositor->m_lastMonitor)
+    if (!g_pCompositor->m_pLastMonitor)
         return "unsafe state";
 
     std::string result = "";
-    auto        w      = g_pCompositor->m_lastMonitor->m_activeWorkspace;
+    auto        w      = g_pCompositor->m_pLastMonitor->activeWorkspace;
 
     if (!valid(w))
         return "internal error";
@@ -429,7 +401,7 @@ static std::string workspacesRequest(eHyprCtlOutputFormat format, std::string re
 
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         result += "[";
-        for (auto const& w : g_pCompositor->m_workspaces) {
+        for (auto const& w : g_pCompositor->m_vWorkspaces) {
             result += CHyprCtl::getWorkspaceData(w, format);
             result += ",";
         }
@@ -437,7 +409,7 @@ static std::string workspacesRequest(eHyprCtlOutputFormat format, std::string re
         trimTrailingComma(result);
         result += "]";
     } else {
-        for (auto const& w : g_pCompositor->m_workspaces) {
+        for (auto const& w : g_pCompositor->m_vWorkspaces) {
             result += CHyprCtl::getWorkspaceData(w, format);
         }
     }
@@ -466,7 +438,7 @@ static std::string workspaceRulesRequest(eHyprCtlOutputFormat format, std::strin
 }
 
 static std::string activeWindowRequest(eHyprCtlOutputFormat format, std::string request) {
-    const auto PWINDOW = g_pCompositor->m_lastWindow.lock();
+    const auto PWINDOW = g_pCompositor->m_pLastWindow.lock();
 
     if (!validMapped(PWINDOW))
         return format == eHyprCtlOutputFormat::FORMAT_JSON ? "{}" : "Invalid";
@@ -485,15 +457,15 @@ static std::string layersRequest(eHyprCtlOutputFormat format, std::string reques
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         result += "{\n";
 
-        for (auto const& mon : g_pCompositor->m_monitors) {
+        for (auto const& mon : g_pCompositor->m_vMonitors) {
             result += std::format(
                 R"#("{}": {{
     "levels": {{
 )#",
-                escapeJSONStrings(mon->m_name));
+                escapeJSONStrings(mon->szName));
 
             int layerLevel = 0;
-            for (auto const& level : mon->m_layerSurfaceLayers) {
+            for (auto const& level : mon->m_aLayerSurfaceLayers) {
                 result += std::format(
                     R"#(
         "{}": [
@@ -510,7 +482,7 @@ static std::string layersRequest(eHyprCtlOutputFormat format, std::string reques
                     "namespace": "{}",
                     "pid": {}
                 }},)#",
-                        (uintptr_t)layer.get(), layer->m_geometry.x, layer->m_geometry.y, layer->m_geometry.width, layer->m_geometry.height, escapeJSONStrings(layer->m_namespace),
+                        (uintptr_t)layer.get(), layer->geometry.x, layer->geometry.y, layer->geometry.width, layer->geometry.height, escapeJSONStrings(layer->szNamespace),
                         layer->getPID());
                 }
 
@@ -534,16 +506,16 @@ static std::string layersRequest(eHyprCtlOutputFormat format, std::string reques
         result += "\n}\n";
 
     } else {
-        for (auto const& mon : g_pCompositor->m_monitors) {
-            result += std::format("Monitor {}:\n", mon->m_name);
+        for (auto const& mon : g_pCompositor->m_vMonitors) {
+            result += std::format("Monitor {}:\n", mon->szName);
             int                                     layerLevel = 0;
             static const std::array<std::string, 4> levelNames = {"background", "bottom", "top", "overlay"};
-            for (auto const& level : mon->m_layerSurfaceLayers) {
+            for (auto const& level : mon->m_aLayerSurfaceLayers) {
                 result += std::format("\tLayer level {} ({}):\n", layerLevel, levelNames[layerLevel]);
 
                 for (auto const& layer : level) {
-                    result += std::format("\t\tLayer {:x}: xywh: {} {} {} {}, namespace: {}, pid: {}\n", (uintptr_t)layer.get(), layer->m_geometry.x, layer->m_geometry.y,
-                                          layer->m_geometry.width, layer->m_geometry.height, layer->m_namespace, layer->getPID());
+                    result += std::format("\t\tLayer {:x}: xywh: {} {} {} {}, namespace: {}, pid: {}\n", (uintptr_t)layer.get(), layer->geometry.x, layer->geometry.y,
+                                          layer->geometry.width, layer->geometry.height, layer->szNamespace, layer->getPID());
                 }
 
                 layerLevel++;
@@ -604,26 +576,26 @@ static std::string devicesRequest(eHyprCtlOutputFormat format, std::string reque
     std::string result = "";
 
     auto        getModState = [](SP<IKeyboard> keyboard, const char* xkbModName) -> bool {
-        auto IDX = xkb_keymap_mod_get_index(keyboard->m_xkbKeymap, xkbModName);
+        auto IDX = xkb_keymap_mod_get_index(keyboard->xkbKeymap, xkbModName);
 
         if (IDX == XKB_MOD_INVALID)
             return false;
 
-        return (keyboard->m_modifiersState.locked & (1 << IDX)) > 0;
+        return (keyboard->modifiersState.locked & (1 << IDX)) > 0;
     };
 
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         result += "{\n";
         result += "\"mice\": [\n";
 
-        for (auto const& m : g_pInputManager->m_pointers) {
+        for (auto const& m : g_pInputManager->m_vPointers) {
             result += std::format(
                 R"#(    {{
         "address": "0x{:x}",
         "name": "{}",
         "defaultSpeed": {:.5f}
     }},)#",
-                (uintptr_t)m.get(), escapeJSONStrings(m->m_hlName),
+                (uintptr_t)m.get(), escapeJSONStrings(m->hlName),
                 m->aq() && m->aq()->getLibinputHandle() ? libinput_device_config_accel_get_default_speed(m->aq()->getLibinputHandle()) : 0.f);
         }
 
@@ -631,7 +603,7 @@ static std::string devicesRequest(eHyprCtlOutputFormat format, std::string reque
         result += "\n],\n";
 
         result += "\"keyboards\": [\n";
-        for (auto const& k : g_pInputManager->m_keyboards) {
+        for (auto const& k : g_pInputManager->m_vKeyboards) {
             const auto KM = k->getActiveLayout();
             result += std::format(
                 R"#(    {{
@@ -647,9 +619,9 @@ static std::string devicesRequest(eHyprCtlOutputFormat format, std::string reque
         "numLock": {},
         "main": {}
     }},)#",
-                (uintptr_t)k.get(), escapeJSONStrings(k->m_hlName), escapeJSONStrings(k->m_currentRules.rules), escapeJSONStrings(k->m_currentRules.model),
-                escapeJSONStrings(k->m_currentRules.layout), escapeJSONStrings(k->m_currentRules.variant), escapeJSONStrings(k->m_currentRules.options), escapeJSONStrings(KM),
-                (getModState(k, XKB_MOD_NAME_CAPS) ? "true" : "false"), (getModState(k, XKB_MOD_NAME_NUM) ? "true" : "false"), (k->m_active ? "true" : "false"));
+                (uintptr_t)k.get(), escapeJSONStrings(k->hlName), escapeJSONStrings(k->currentRules.rules), escapeJSONStrings(k->currentRules.model),
+                escapeJSONStrings(k->currentRules.layout), escapeJSONStrings(k->currentRules.variant), escapeJSONStrings(k->currentRules.options), escapeJSONStrings(KM),
+                (getModState(k, XKB_MOD_NAME_CAPS) ? "true" : "false"), (getModState(k, XKB_MOD_NAME_NUM) ? "true" : "false"), (k->active ? "true" : "false"));
         }
 
         trimTrailingComma(result);
@@ -657,7 +629,7 @@ static std::string devicesRequest(eHyprCtlOutputFormat format, std::string reque
 
         result += "\"tablets\": [\n";
 
-        for (auto const& d : g_pInputManager->m_tabletPads) {
+        for (auto const& d : g_pInputManager->m_vTabletPads) {
             result += std::format(
                 R"#(    {{
         "address": "0x{:x}",
@@ -667,19 +639,19 @@ static std::string devicesRequest(eHyprCtlOutputFormat format, std::string reque
             "name": "{}"
         }}
     }},)#",
-                (uintptr_t)d.get(), (uintptr_t)d->m_parent.get(), escapeJSONStrings(d->m_parent ? d->m_parent->m_hlName : ""));
+                (uintptr_t)d.get(), (uintptr_t)d->parent.get(), escapeJSONStrings(d->parent ? d->parent->hlName : ""));
         }
 
-        for (auto const& d : g_pInputManager->m_tablets) {
+        for (auto const& d : g_pInputManager->m_vTablets) {
             result += std::format(
                 R"#(    {{
         "address": "0x{:x}",
         "name": "{}"
     }},)#",
-                (uintptr_t)d.get(), escapeJSONStrings(d->m_hlName));
+                (uintptr_t)d.get(), escapeJSONStrings(d->hlName));
         }
 
-        for (auto const& d : g_pInputManager->m_tabletTools) {
+        for (auto const& d : g_pInputManager->m_vTabletTools) {
             result += std::format(
                 R"#(    {{
         "address": "0x{:x}",
@@ -693,13 +665,13 @@ static std::string devicesRequest(eHyprCtlOutputFormat format, std::string reque
 
         result += "\"touch\": [\n";
 
-        for (auto const& d : g_pInputManager->m_touches) {
+        for (auto const& d : g_pInputManager->m_vTouches) {
             result += std::format(
                 R"#(    {{
         "address": "0x{:x}",
         "name": "{}"
     }},)#",
-                (uintptr_t)d.get(), escapeJSONStrings(d->m_hlName));
+                (uintptr_t)d.get(), escapeJSONStrings(d->hlName));
         }
 
         trimTrailingComma(result);
@@ -707,7 +679,7 @@ static std::string devicesRequest(eHyprCtlOutputFormat format, std::string reque
 
         result += "\"switches\": [\n";
 
-        for (auto const& d : g_pInputManager->m_switches) {
+        for (auto const& d : g_pInputManager->m_lSwitches) {
             result += std::format(
                 R"#(    {{
         "address": "0x{:x}",
@@ -724,45 +696,45 @@ static std::string devicesRequest(eHyprCtlOutputFormat format, std::string reque
     } else {
         result += "mice:\n";
 
-        for (auto const& m : g_pInputManager->m_pointers) {
-            result += std::format("\tMouse at {:x}:\n\t\t{}\n\t\t\tdefault speed: {:.5f}\n", (uintptr_t)m.get(), m->m_hlName,
+        for (auto const& m : g_pInputManager->m_vPointers) {
+            result += std::format("\tMouse at {:x}:\n\t\t{}\n\t\t\tdefault speed: {:.5f}\n", (uintptr_t)m.get(), m->hlName,
                                   (m->aq() && m->aq()->getLibinputHandle() ? libinput_device_config_accel_get_default_speed(m->aq()->getLibinputHandle()) : 0.f));
         }
 
         result += "\n\nKeyboards:\n";
 
-        for (auto const& k : g_pInputManager->m_keyboards) {
+        for (auto const& k : g_pInputManager->m_vKeyboards) {
             const auto KM = k->getActiveLayout();
-            result += std::format("\tKeyboard at {:x}:\n\t\t{}\n\t\t\trules: r \"{}\", m \"{}\", l \"{}\", v \"{}\", o \"{}\"\n\t\t\tactive keymap: {}\n\t\t\tcapsLock: "
+            result +=
+                std::format("\tKeyboard at {:x}:\n\t\t{}\n\t\t\trules: r \"{}\", m \"{}\", l \"{}\", v \"{}\", o \"{}\"\n\t\t\tactive keymap: {}\n\t\t\tcapsLock: "
                             "{}\n\t\t\tnumLock: {}\n\t\t\tmain: {}\n",
-                                  (uintptr_t)k.get(), k->m_hlName, k->m_currentRules.rules, k->m_currentRules.model, k->m_currentRules.layout, k->m_currentRules.variant,
-                                  k->m_currentRules.options, KM, (getModState(k, XKB_MOD_NAME_CAPS) ? "yes" : "no"), (getModState(k, XKB_MOD_NAME_NUM) ? "yes" : "no"),
-                                  (k->m_active ? "yes" : "no"));
+                            (uintptr_t)k.get(), k->hlName, k->currentRules.rules, k->currentRules.model, k->currentRules.layout, k->currentRules.variant, k->currentRules.options,
+                            KM, (getModState(k, XKB_MOD_NAME_CAPS) ? "yes" : "no"), (getModState(k, XKB_MOD_NAME_NUM) ? "yes" : "no"), (k->active ? "yes" : "no"));
         }
 
         result += "\n\nTablets:\n";
 
-        for (auto const& d : g_pInputManager->m_tabletPads) {
-            result += std::format("\tTablet Pad at {:x} (belongs to {:x} -> {})\n", (uintptr_t)d.get(), (uintptr_t)d->m_parent.get(), d->m_parent ? d->m_parent->m_hlName : "");
+        for (auto const& d : g_pInputManager->m_vTabletPads) {
+            result += std::format("\tTablet Pad at {:x} (belongs to {:x} -> {})\n", (uintptr_t)d.get(), (uintptr_t)d->parent.get(), d->parent ? d->parent->hlName : "");
         }
 
-        for (auto const& d : g_pInputManager->m_tablets) {
-            result += std::format("\tTablet at {:x}:\n\t\t{}\n\t\t\tsize: {}x{}mm\n", (uintptr_t)d.get(), d->m_hlName, d->aq()->physicalSize.x, d->aq()->physicalSize.y);
+        for (auto const& d : g_pInputManager->m_vTablets) {
+            result += std::format("\tTablet at {:x}:\n\t\t{}\n\t\t\tsize: {}x{}mm\n", (uintptr_t)d.get(), d->hlName, d->aq()->physicalSize.x, d->aq()->physicalSize.y);
         }
 
-        for (auto const& d : g_pInputManager->m_tabletTools) {
+        for (auto const& d : g_pInputManager->m_vTabletTools) {
             result += std::format("\tTablet Tool at {:x}\n", (uintptr_t)d.get());
         }
 
         result += "\n\nTouch:\n";
 
-        for (auto const& d : g_pInputManager->m_touches) {
-            result += std::format("\tTouch Device at {:x}:\n\t\t{}\n", (uintptr_t)d.get(), d->m_hlName);
+        for (auto const& d : g_pInputManager->m_vTouches) {
+            result += std::format("\tTouch Device at {:x}:\n\t\t{}\n", (uintptr_t)d.get(), d->hlName);
         }
 
         result += "\n\nSwitches:\n";
 
-        for (auto const& d : g_pInputManager->m_switches) {
+        for (auto const& d : g_pInputManager->m_lSwitches) {
             result += std::format("\tSwitch Device at {:x}:\n\t\t{}\n", (uintptr_t)&d, d.pDevice ? d.pDevice->getName() : "");
         }
     }
@@ -828,10 +800,10 @@ static std::string rollinglogRequest(eHyprCtlOutputFormat format, std::string re
 
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         result += "[\n\"log\":\"";
-        result += escapeJSONStrings(Debug::m_rollingLog);
+        result += escapeJSONStrings(Debug::rollingLog);
         result += "\"]";
     } else {
-        result = Debug::m_rollingLog;
+        result = Debug::rollingLog;
     }
 
     return result;
@@ -866,7 +838,7 @@ static std::string globalShortcutsRequest(eHyprCtlOutputFormat format, std::stri
 static std::string bindsRequest(eHyprCtlOutputFormat format, std::string request) {
     std::string ret = "";
     if (format == eHyprCtlOutputFormat::FORMAT_NORMAL) {
-        for (auto const& kb : g_pKeybindManager->m_keybinds) {
+        for (auto const& kb : g_pKeybindManager->m_vKeybinds) {
             ret += "bind";
             if (kb->locked)
                 ret += "l";
@@ -887,7 +859,7 @@ static std::string bindsRequest(eHyprCtlOutputFormat format, std::string request
     } else {
         // json
         ret += "[";
-        for (auto const& kb : g_pKeybindManager->m_keybinds) {
+        for (auto const& kb : g_pKeybindManager->m_vKeybinds) {
             ret += std::format(
                 R"#(
 {{
@@ -1052,12 +1024,12 @@ std::string systemInfoRequest(eHyprCtlOutputFormat format, std::string request)
     result += "plugins:\n";
     if (g_pPluginSystem) {
         for (auto const& pl : g_pPluginSystem->getAllPlugins()) {
-            result += std::format("  {} by {} ver {}\n", pl->m_name, pl->m_author, pl->m_version);
+            result += std::format("  {} by {} ver {}\n", pl->name, pl->author, pl->version);
         }
     } else
         result += "\tunknown: not runtime\n";
 
-    if (g_pHyprCtl && g_pHyprCtl->m_currentRequestParams.sysInfoConfig) {
+    if (g_pHyprCtl && g_pHyprCtl->m_sCurrentRequestParams.sysInfoConfig) {
         result += "\n======Config-Start======\n";
         result += g_pConfigManager->getConfigString();
         result += "\n======Config-End========\n";
@@ -1076,8 +1048,8 @@ static std::string dispatchRequest(eHyprCtlOutputFormat format, std::string in)
     if ((int)in.find_first_of(' ') != -1)
         DISPATCHARG = in.substr(in.find_first_of(' ') + 1);
 
-    const auto DISPATCHER = g_pKeybindManager->m_dispatchers.find(DISPATCHSTR);
-    if (DISPATCHER == g_pKeybindManager->m_dispatchers.end())
+    const auto DISPATCHER = g_pKeybindManager->m_mDispatchers.find(DISPATCHSTR);
+    if (DISPATCHER == g_pKeybindManager->m_mDispatchers.end())
         return "Invalid dispatcher";
 
     SDispatchResult res = DISPATCHER->second(DISPATCHARG);
@@ -1113,7 +1085,7 @@ static std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in)
 
     // if we are executing a dynamic source we have to reload everything, so every if will have a check for source.
     if (COMMAND == "monitor" || COMMAND == "source")
-        g_pConfigManager->m_wantsMonitorReload = true; // for monitor keywords
+        g_pConfigManager->m_bWantsMonitorReload = true; // for monitor keywords
 
     if (COMMAND.contains("input") || COMMAND.contains("device") || COMMAND == "source") {
         g_pInputManager->setKeyboardLayout();     // update kb layout
@@ -1128,10 +1100,10 @@ static std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in)
         g_pLayoutManager->switchToLayout(*PLAYOUT); // update layout
 
     if (COMMAND.contains("decoration:screen_shader") || COMMAND == "source")
-        g_pHyprOpenGL->m_reloadScreenShader = true;
+        g_pHyprOpenGL->m_bReloadScreenShader = true;
 
     if (COMMAND.contains("blur") || COMMAND == "source") {
-        for (auto& [m, rd] : g_pHyprOpenGL->m_monitorRenderResources) {
+        for (auto& [m, rd] : g_pHyprOpenGL->m_mMonitorRenderResources) {
             rd.blurFBDirty = true;
         }
     }
@@ -1142,9 +1114,9 @@ static std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in)
     // decorations will probably need a repaint
     if (COMMAND.contains("decoration:") || COMMAND.contains("border") || COMMAND == "workspace" || COMMAND.contains("zoom_factor") || COMMAND == "source" ||
         COMMAND.starts_with("windowrule")) {
-        for (auto const& m : g_pCompositor->m_monitors) {
+        for (auto const& m : g_pCompositor->m_vMonitors) {
             g_pHyprRenderer->damageMonitor(m);
-            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->m_id);
+            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
         }
     }
 
@@ -1161,7 +1133,7 @@ static std::string reloadRequest(eHyprCtlOutputFormat format, std::string reques
     const auto REQMODE = request.substr(request.find_last_of(' ') + 1);
 
     if (REQMODE == "config-only")
-        g_pConfigManager->m_noMonitorReload = true;
+        g_pConfigManager->m_bNoMonitorReload = true;
 
     g_pConfigManager->reload();
 
@@ -1175,7 +1147,7 @@ static std::string killRequest(eHyprCtlOutputFormat format, std::string request)
 }
 
 static std::string splashRequest(eHyprCtlOutputFormat format, std::string request) {
-    return g_pCompositor->m_currentSplash;
+    return g_pCompositor->m_szCurrentSplash;
 }
 
 static std::string cursorPosRequest(eHyprCtlOutputFormat format, std::string request) {
@@ -1255,20 +1227,19 @@ static std::string switchXKBLayoutRequest(eHyprCtlOutputFormat format, std::stri
     SP<IKeyboard> pKeyboard;
 
     auto          updateKeyboard = [](const SP<IKeyboard> KEEB, const std::string& CMD) -> std::optional<std::string> {
-        const auto         LAYOUTS      = xkb_keymap_num_layouts(KEEB->m_xkbKeymap);
+        const auto         LAYOUTS      = xkb_keymap_num_layouts(KEEB->xkbKeymap);
         xkb_layout_index_t activeLayout = 0;
         while (activeLayout < LAYOUTS) {
-            if (xkb_state_layout_index_is_active(KEEB->m_xkbState, activeLayout, XKB_STATE_LAYOUT_EFFECTIVE) == 1)
+            if (xkb_state_layout_index_is_active(KEEB->xkbState, activeLayout, XKB_STATE_LAYOUT_EFFECTIVE) == 1)
                 break;
 
             activeLayout++;
         }
 
         if (CMD == "next")
-            KEEB->updateModifiers(KEEB->m_modifiersState.depressed, KEEB->m_modifiersState.latched, KEEB->m_modifiersState.locked, activeLayout > LAYOUTS ? 0 : activeLayout + 1);
+            KEEB->updateModifiers(KEEB->modifiersState.depressed, KEEB->modifiersState.latched, KEEB->modifiersState.locked, activeLayout > LAYOUTS ? 0 : activeLayout + 1);
         else if (CMD == "prev")
-            KEEB->updateModifiers(KEEB->m_modifiersState.depressed, KEEB->m_modifiersState.latched, KEEB->m_modifiersState.locked,
-                                  activeLayout == 0 ? LAYOUTS - 1 : activeLayout - 1);
+            KEEB->updateModifiers(KEEB->modifiersState.depressed, KEEB->modifiersState.latched, KEEB->modifiersState.locked, activeLayout == 0 ? LAYOUTS - 1 : activeLayout - 1);
         else {
             int requestedLayout = 0;
             try {
@@ -1279,15 +1250,15 @@ static std::string switchXKBLayoutRequest(eHyprCtlOutputFormat format, std::stri
                 return "layout idx out of range of " + std::to_string(LAYOUTS);
             }
 
-            KEEB->updateModifiers(KEEB->m_modifiersState.depressed, KEEB->m_modifiersState.latched, KEEB->m_modifiersState.locked, requestedLayout);
+            KEEB->updateModifiers(KEEB->modifiersState.depressed, KEEB->modifiersState.latched, KEEB->modifiersState.locked, requestedLayout);
         }
 
         return std::nullopt;
     };
 
     if (KB == "main" || KB == "active" || KB == "current") {
-        for (auto const& k : g_pInputManager->m_keyboards) {
-            if (!k->m_active)
+        for (auto const& k : g_pInputManager->m_vKeyboards) {
+            if (!k->active)
                 continue;
 
             pKeyboard = k;
@@ -1295,17 +1266,17 @@ static std::string switchXKBLayoutRequest(eHyprCtlOutputFormat format, std::stri
         }
     } else if (KB == "all") {
         std::string result = "";
-        for (auto const& k : g_pInputManager->m_keyboards) {
+        for (auto const& k : g_pInputManager->m_vKeyboards) {
             auto res = updateKeyboard(k, CMD);
             if (res.has_value())
                 result += *res + "\n";
         }
         return result.empty() ? "ok" : result;
     } else {
-        auto k = std::find_if(g_pInputManager->m_keyboards.begin(), g_pInputManager->m_keyboards.end(),
-                              [&](const auto& other) { return other->m_hlName == g_pInputManager->deviceNameToInternalString(KB); });
+        auto k = std::find_if(g_pInputManager->m_vKeyboards.begin(), g_pInputManager->m_vKeyboards.end(),
+                              [&](const auto& other) { return other->hlName == g_pInputManager->deviceNameToInternalString(KB); });
 
-        if (k == g_pInputManager->m_keyboards.end())
+        if (k == g_pInputManager->m_vKeyboards.end())
             return "device not found";
 
         pKeyboard = *k;
@@ -1352,7 +1323,7 @@ static std::string dispatchSeterror(eHyprCtlOutputFormat format, std::string req
 }
 
 static std::string dispatchSetProp(eHyprCtlOutputFormat format, std::string request) {
-    auto result = g_pKeybindManager->m_dispatchers["setprop"](request.substr(request.find_first_of(' ') + 1));
+    auto result = g_pKeybindManager->m_mDispatchers["setprop"](request.substr(request.find_first_of(' ') + 1));
     return "DEPRECATED: use hyprctl dispatch setprop instead" + (result.success ? "" : "\n" + result.error);
 }
 
@@ -1422,7 +1393,7 @@ static std::string decorationRequest(eHyprCtlOutputFormat format, std::string re
     std::string result = "";
     if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
         result += "[";
-        for (auto const& wd : PWINDOW->m_windowDecorations) {
+        for (auto const& wd : PWINDOW->m_dWindowDecorations) {
             result += "{\n\"decorationName\": \"" + wd->getDisplayName() + "\",\n\"priority\": " + std::to_string(wd->getPositioningInfo().priority) + "\n},";
         }
 
@@ -1430,7 +1401,7 @@ static std::string decorationRequest(eHyprCtlOutputFormat format, std::string re
         result += "]";
     } else {
         result = +"Decoration\tPriority\n";
-        for (auto const& wd : PWINDOW->m_windowDecorations) {
+        for (auto const& wd : PWINDOW->m_dWindowDecorations) {
             result += wd->getDisplayName() + "\t" + std::to_string(wd->getPositioningInfo().priority) + "\n";
         }
     }
@@ -1449,8 +1420,8 @@ static std::string dispatchOutput(eHyprCtlOutputFormat format, std::string reque
     bool       added = false;
 
     if (!vars[3].empty()) {
-        for (auto const& m : g_pCompositor->m_realMonitors) {
-            if (m->m_name == vars[3])
+        for (auto const& m : g_pCompositor->m_vRealMonitors) {
+            if (m->szName == vars[3])
                 return "Name already taken";
         }
     }
@@ -1459,7 +1430,7 @@ static std::string dispatchOutput(eHyprCtlOutputFormat format, std::string reque
         if (g_pCompositor->getMonitorFromName(vars[3]))
             return "A real monitor already uses that name.";
 
-        for (auto const& impl : g_pCompositor->m_aqBackend->getImplementations() | std::views::reverse) {
+        for (auto const& impl : g_pCompositor->m_pAqBackend->getImplementations() | std::views::reverse) {
             auto type = impl->type();
 
             if (type == Aquamarine::AQ_BACKEND_HEADLESS && (vars[2] == "headless" || vars[2] == "auto")) {
@@ -1484,10 +1455,10 @@ static std::string dispatchOutput(eHyprCtlOutputFormat format, std::string reque
         if (!PMONITOR)
             return "output not found";
 
-        if (!PMONITOR->m_createdByUser)
+        if (!PMONITOR->createdByUser)
             return "cannot remove a real display. Use the monitor keyword.";
 
-        PMONITOR->m_output->destroy();
+        PMONITOR->output->destroy();
     }
 
     return "ok";
@@ -1506,18 +1477,10 @@ static std::string dispatchPlugin(eHyprCtlOutputFormat format, std::string reque
         if (vars.size() < 3)
             return "not enough args";
 
-        g_pHyprCtl->m_currentRequestParams.pendingPromise = CPromise<std::string>::make([PATH](SP<CPromiseResolver<std::string>> resolver) {
-            g_pPluginSystem->loadPlugin(PATH)->then([resolver, PATH](SP<CPromiseResult<CPlugin*>> result) {
-                if (result->hasError()) {
-                    resolver->reject(result->error());
-                    return;
-                }
+        const auto PLUGIN = g_pPluginSystem->loadPlugin(PATH);
 
-                resolver->resolve("ok");
-            });
-        });
-
-        return "ok";
+        if (!PLUGIN)
+            return "error in loading plugin, last error: " + g_pPluginSystem->m_szLastError;
     } else if (OPERATION == "unload") {
         if (vars.size() < 3)
             return "not enough args";
@@ -1548,7 +1511,7 @@ static std::string dispatchPlugin(eHyprCtlOutputFormat format, std::string reque
     "version": "{}",
     "description": "{}"
 }},)#",
-                    escapeJSONStrings(p->m_name), escapeJSONStrings(p->m_author), (uintptr_t)p->m_handle, escapeJSONStrings(p->m_version), escapeJSONStrings(p->m_description));
+                    escapeJSONStrings(p->name), escapeJSONStrings(p->author), (uintptr_t)p->m_pHandle, escapeJSONStrings(p->version), escapeJSONStrings(p->description));
             }
             trimTrailingComma(result);
             result += "]";
@@ -1557,8 +1520,8 @@ static std::string dispatchPlugin(eHyprCtlOutputFormat format, std::string reque
                 return "no plugins loaded";
 
             for (auto const& p : PLUGINS) {
-                result += std::format("\nPlugin {} by {}:\n\tHandle: {:x}\n\tVersion: {}\n\tDescription: {}\n", p->m_name, p->m_author, (uintptr_t)p->m_handle, p->m_version,
-                                      p->m_description);
+                result +=
+                    std::format("\nPlugin {} by {}:\n\tHandle: {:x}\n\tVersion: {}\n\tDescription: {}\n", p->name, p->author, (uintptr_t)p->m_pHandle, p->version, p->description);
             }
         }
 
@@ -1680,13 +1643,6 @@ static std::string submapRequest(eHyprCtlOutputFormat format, std::string reques
     return format == FORMAT_JSON ? std::format("{{\"{}\"}}\n", escapeJSONStrings(submap)) : (submap + "\n");
 }
 
-static std::string reloadShaders(eHyprCtlOutputFormat format, std::string request) {
-    if (g_pHyprOpenGL->initShaders())
-        return format == FORMAT_JSON ? "{\"ok\": true}" : "ok";
-    else
-        return format == FORMAT_JSON ? "{\"ok\": false}" : "error";
-}
-
 CHyprCtl::CHyprCtl() {
     registerCommand(SHyprCtlCommand{"workspaces", true, workspacesRequest});
     registerCommand(SHyprCtlCommand{"workspacerules", true, workspaceRulesRequest});
@@ -1709,7 +1665,6 @@ CHyprCtl::CHyprCtl() {
     registerCommand(SHyprCtlCommand{"locked", true, getIsLocked});
     registerCommand(SHyprCtlCommand{"descriptions", true, getDescriptions});
     registerCommand(SHyprCtlCommand{"submap", true, submapRequest});
-    registerCommand(SHyprCtlCommand{.name = "reloadshaders", .exact = true, .fn = reloadShaders});
 
     registerCommand(SHyprCtlCommand{"monitors", false, monitorsRequest});
     registerCommand(SHyprCtlCommand{"reload", false, reloadRequest});
@@ -1738,18 +1693,17 @@ CHyprCtl::~CHyprCtl() {
 }
 
 SP<SHyprCtlCommand> CHyprCtl::registerCommand(SHyprCtlCommand cmd) {
-    return m_commands.emplace_back(makeShared<SHyprCtlCommand>(cmd));
+    return m_vCommands.emplace_back(makeShared<SHyprCtlCommand>(cmd));
 }
 
 void CHyprCtl::unregisterCommand(const SP<SHyprCtlCommand>& cmd) {
-    std::erase(m_commands, cmd);
+    std::erase(m_vCommands, cmd);
 }
 
 std::string CHyprCtl::getReply(std::string request) {
     auto format             = eHyprCtlOutputFormat::FORMAT_NORMAL;
     bool reloadAll          = false;
-    m_currentRequestParams.all           = false;
-    m_currentRequestParams.sysInfoConfig = false;
+    m_sCurrentRequestParams = {};
 
     // process flags for non-batch requests
     if (!request.starts_with("[[BATCH]]") && request.contains("/")) {
@@ -1773,9 +1727,9 @@ std::string CHyprCtl::getReply(std::string request) {
             else if (c == 'r')
                 reloadAll = true;
             else if (c == 'a')
-                m_currentRequestParams.all = true;
+                m_sCurrentRequestParams.all = true;
             else if (c == 'c')
-                m_currentRequestParams.sysInfoConfig = true;
+                m_sCurrentRequestParams.sysInfoConfig = true;
         }
 
         if (sepIndex < request.size())
@@ -1785,7 +1739,7 @@ std::string CHyprCtl::getReply(std::string request) {
     std::string result = "";
 
     // parse exact cmds first, then non-exact.
-    for (auto const& cmd : m_commands) {
+    for (auto const& cmd : m_vCommands) {
         if (!cmd->exact)
             continue;
 
@@ -1796,7 +1750,7 @@ std::string CHyprCtl::getReply(std::string request) {
     }
 
     if (result.empty())
-        for (auto const& cmd : m_commands) {
+        for (auto const& cmd : m_vCommands) {
             if (cmd->exact)
                 continue;
 
@@ -1810,7 +1764,7 @@ std::string CHyprCtl::getReply(std::string request) {
         return "unknown request";
 
     if (reloadAll) {
-        g_pConfigManager->m_wantsMonitorReload = true; // for monitor keywords
+        g_pConfigManager->m_bWantsMonitorReload = true; // for monitor keywords
 
         g_pInputManager->setKeyboardLayout();     // update kb layout
         g_pInputManager->setPointerConfigs();     // update mouse cfgs
@@ -1821,23 +1775,23 @@ std::string CHyprCtl::getReply(std::string request) {
 
         g_pLayoutManager->switchToLayout(*PLAYOUT); // update layout
 
-        g_pHyprOpenGL->m_reloadScreenShader = true;
+        g_pHyprOpenGL->m_bReloadScreenShader = true;
 
-        for (auto& [m, rd] : g_pHyprOpenGL->m_monitorRenderResources) {
+        for (auto& [m, rd] : g_pHyprOpenGL->m_mMonitorRenderResources) {
             rd.blurFBDirty = true;
         }
 
-        for (auto const& w : g_pCompositor->m_windows) {
-            if (!w->m_isMapped || !w->m_workspace || !w->m_workspace->isVisible())
+        for (auto const& w : g_pCompositor->m_vWindows) {
+            if (!w->m_bIsMapped || !w->m_pWorkspace || !w->m_pWorkspace->isVisible())
                 continue;
 
             w->updateDynamicRules();
             g_pCompositor->updateWindowAnimatedDecorationValues(w);
         }
 
-        for (auto const& m : g_pCompositor->m_monitors) {
+        for (auto const& m : g_pCompositor->m_vMonitors) {
             g_pHyprRenderer->damageMonitor(m);
-            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->m_id);
+            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
         }
     }
 
@@ -1892,26 +1846,16 @@ static int hyprCtlFDTick(int fd, uint32_t mask, void* data) {
     if (mask & WL_EVENT_ERROR || mask & WL_EVENT_HANGUP)
         return 0;
 
-    if (!g_pHyprCtl->m_socketFD.isValid())
+    if (!g_pHyprCtl->m_iSocketFD.isValid())
         return 0;
 
     sockaddr_in            clientAddress;
     socklen_t              clientSize = sizeof(clientAddress);
 
-    const auto             ACCEPTEDCONNECTION = accept4(g_pHyprCtl->m_socketFD.get(), (sockaddr*)&clientAddress, &clientSize, SOCK_CLOEXEC);
+    const auto             ACCEPTEDCONNECTION = accept4(g_pHyprCtl->m_iSocketFD.get(), (sockaddr*)&clientAddress, &clientSize, SOCK_CLOEXEC);
 
     std::array<char, 1024> readBuffer;
 
-    // try to get creds
-    CRED_T   creds;
-    uint32_t len = sizeof(creds);
-    if (getsockopt(ACCEPTEDCONNECTION, CRED_LVL, CRED_OPT, &creds, &len) == -1)
-        Debug::log(ERR, "Hyprctl: failed to get peer creds");
-    else {
-        g_pHyprCtl->m_currentRequestParams.pid = creds.CRED_PID;
-        Debug::log(LOG, "Hyprctl: new connection from pid {}", creds.CRED_PID);
-    }
-
     //
     pollfd pollfds[1] = {
         {
@@ -1948,19 +1892,6 @@ static int hyprCtlFDTick(int fd, uint32_t mask, void* data) {
         reply = "Err: " + std::string(e.what());
     }
 
-    if (g_pHyprCtl->m_currentRequestParams.pendingPromise) {
-        // we have a promise pending
-        g_pHyprCtl->m_currentRequestParams.pendingPromise->then([ACCEPTEDCONNECTION, request](SP<CPromiseResult<std::string>> result) {
-            const auto RES = result->hasError() ? result->error() : result->result();
-            successWrite(ACCEPTEDCONNECTION, RES);
-
-            // No rollinglog or ensureMonitor here. These are only for plugins for now.
-
-            close(ACCEPTEDCONNECTION);
-        });
-
-        g_pHyprCtl->m_currentRequestParams.pendingPromise.reset();
-    } else {
     successWrite(ACCEPTEDCONNECTION, reply);
 
     if (isFollowUpRollingLogRequest(request)) {
@@ -1971,38 +1902,35 @@ static int hyprCtlFDTick(int fd, uint32_t mask, void* data) {
     } else
         close(ACCEPTEDCONNECTION);
 
-        if (g_pConfigManager->m_wantsMonitorReload)
+    if (g_pConfigManager->m_bWantsMonitorReload)
         g_pConfigManager->ensureMonitorStatus();
 
-        g_pHyprCtl->m_currentRequestParams.pid = 0;
-    }
-
     return 0;
 }
 
 void CHyprCtl::startHyprCtlSocket() {
-    m_socketFD = CFileDescriptor{socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0)};
+    m_iSocketFD = CFileDescriptor{socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0)};
 
-    if (!m_socketFD.isValid()) {
+    if (!m_iSocketFD.isValid()) {
         Debug::log(ERR, "Couldn't start the Hyprland Socket. (1) IPC will not work.");
         return;
     }
 
     sockaddr_un SERVERADDRESS = {.sun_family = AF_UNIX};
 
-    m_socketPath = g_pCompositor->m_instancePath + "/.socket.sock";
+    m_socketPath = g_pCompositor->m_szInstancePath + "/.socket.sock";
 
     strcpy(SERVERADDRESS.sun_path, m_socketPath.c_str());
 
-    if (bind(m_socketFD.get(), (sockaddr*)&SERVERADDRESS, SUN_LEN(&SERVERADDRESS)) < 0) {
+    if (bind(m_iSocketFD.get(), (sockaddr*)&SERVERADDRESS, SUN_LEN(&SERVERADDRESS)) < 0) {
         Debug::log(ERR, "Couldn't start the Hyprland Socket. (2) IPC will not work.");
         return;
     }
 
     // 10 max queued.
-    listen(m_socketFD.get(), 10);
+    listen(m_iSocketFD.get(), 10);
 
     Debug::log(LOG, "Hypr socket started at {}", m_socketPath);
 
-    m_eventSource = wl_event_loop_add_fd(g_pCompositor->m_wlEventLoop, m_socketFD.get(), WL_EVENT_READABLE, hyprCtlFDTick, nullptr);
+    m_eventSource = wl_event_loop_add_fd(g_pCompositor->m_sWLEventLoop, m_iSocketFD.get(), WL_EVENT_READABLE, hyprCtlFDTick, nullptr);
 }

src/debug/HyprCtl.hpp

@@ -2,10 +2,8 @@
 
 #include <fstream>
 #include "../helpers/MiscFunctions.hpp"
-#include "../helpers/defer/Promise.hpp"
 #include "../desktop/Window.hpp"
 #include <functional>
-#include <sys/types.h>
 #include <hyprutils/os/FileDescriptor.hpp>
 
 // exposed for main.cpp
@@ -22,14 +20,12 @@ class CHyprCtl {
     void                           unregisterCommand(const SP<SHyprCtlCommand>& cmd);
     std::string                    getReply(std::string);
 
-    Hyprutils::OS::CFileDescriptor m_socketFD;
+    Hyprutils::OS::CFileDescriptor m_iSocketFD;
 
     struct {
         bool all           = false;
         bool sysInfoConfig = false;
-        pid_t                     pid           = 0;
-        SP<CPromise<std::string>> pendingPromise;
-    } m_currentRequestParams;
+    } m_sCurrentRequestParams;
 
     static std::string getWindowData(PHLWINDOW w, eHyprCtlOutputFormat format);
     static std::string getWorkspaceData(PHLWORKSPACE w, eHyprCtlOutputFormat format);
@@ -38,7 +34,7 @@ class CHyprCtl {
   private:
     void                             startHyprCtlSocket();
 
-    std::vector<SP<SHyprCtlCommand>> m_commands;
+    std::vector<SP<SHyprCtlCommand>> m_vCommands;
     wl_event_source*                 m_eventSource = nullptr;
     std::string                      m_socketPath;
 };

src/debug/HyprDebugOverlay.cpp

@@ -7,7 +7,7 @@
 #include "../managers/AnimationManager.hpp"
 
 CHyprDebugOverlay::CHyprDebugOverlay() {
-    m_texture = makeShared<CTexture>();
+    m_pTexture = makeShared<CTexture>();
 }
 
 void CHyprMonitorDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs) {
@@ -16,13 +16,13 @@ void CHyprMonitorDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs)
     if (!*PDEBUGOVERLAY)
         return;
 
-    m_lastRenderTimes.emplace_back(durationUs / 1000.f);
+    m_dLastRenderTimes.emplace_back(durationUs / 1000.f);
 
-    if (m_lastRenderTimes.size() > (long unsigned int)pMonitor->m_refreshRate)
-        m_lastRenderTimes.pop_front();
+    if (m_dLastRenderTimes.size() > (long unsigned int)pMonitor->refreshRate)
+        m_dLastRenderTimes.pop_front();
 
-    if (!m_monitor)
-        m_monitor = pMonitor;
+    if (!m_pMonitor)
+        m_pMonitor = pMonitor;
 }
 
 void CHyprMonitorDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float durationUs) {
@@ -31,13 +31,13 @@ void CHyprMonitorDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float du
     if (!*PDEBUGOVERLAY)
         return;
 
-    m_lastRenderTimesNoOverlay.emplace_back(durationUs / 1000.f);
+    m_dLastRenderTimesNoOverlay.emplace_back(durationUs / 1000.f);
 
-    if (m_lastRenderTimesNoOverlay.size() > (long unsigned int)pMonitor->m_refreshRate)
-        m_lastRenderTimesNoOverlay.pop_front();
+    if (m_dLastRenderTimesNoOverlay.size() > (long unsigned int)pMonitor->refreshRate)
+        m_dLastRenderTimesNoOverlay.pop_front();
 
-    if (!m_monitor)
-        m_monitor = pMonitor;
+    if (!m_pMonitor)
+        m_pMonitor = pMonitor;
 }
 
 void CHyprMonitorDebugOverlay::frameData(PHLMONITOR pMonitor) {
@@ -46,36 +46,36 @@ void CHyprMonitorDebugOverlay::frameData(PHLMONITOR pMonitor) {
     if (!*PDEBUGOVERLAY)
         return;
 
-    m_lastFrametimes.emplace_back(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - m_lastFrame).count() / 1000.f);
+    m_dLastFrametimes.emplace_back(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - m_tpLastFrame).count() / 1000.f);
 
-    if (m_lastFrametimes.size() > (long unsigned int)pMonitor->m_refreshRate)
-        m_lastFrametimes.pop_front();
+    if (m_dLastFrametimes.size() > (long unsigned int)pMonitor->refreshRate)
+        m_dLastFrametimes.pop_front();
 
-    m_lastFrame = std::chrono::high_resolution_clock::now();
+    m_tpLastFrame = std::chrono::high_resolution_clock::now();
 
-    if (!m_monitor)
-        m_monitor = pMonitor;
+    if (!m_pMonitor)
+        m_pMonitor = pMonitor;
 
     // anim data too
-    const auto PMONITORFORTICKS = g_pHyprRenderer->m_mostHzMonitor ? g_pHyprRenderer->m_mostHzMonitor.lock() : g_pCompositor->m_lastMonitor.lock();
+    const auto PMONITORFORTICKS = g_pHyprRenderer->m_pMostHzMonitor ? g_pHyprRenderer->m_pMostHzMonitor.lock() : g_pCompositor->m_pLastMonitor.lock();
     if (PMONITORFORTICKS) {
-        if (m_lastAnimationTicks.size() > (long unsigned int)PMONITORFORTICKS->m_refreshRate)
-            m_lastAnimationTicks.pop_front();
+        if (m_dLastAnimationTicks.size() > (long unsigned int)PMONITORFORTICKS->refreshRate)
+            m_dLastAnimationTicks.pop_front();
 
-        m_lastAnimationTicks.push_back(g_pAnimationManager->m_lastTickTimeMs);
+        m_dLastAnimationTicks.push_back(g_pAnimationManager->m_fLastTickTime);
     }
 }
 
 int CHyprMonitorDebugOverlay::draw(int offset) {
 
-    if (!m_monitor)
+    if (!m_pMonitor)
         return 0;
 
     // get avg fps
     float avgFrametime = 0;
     float maxFrametime = 0;
     float minFrametime = 9999;
-    for (auto const& ft : m_lastFrametimes) {
+    for (auto const& ft : m_dLastFrametimes) {
         if (ft > maxFrametime)
             maxFrametime = ft;
         if (ft < minFrametime)
@@ -83,12 +83,12 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
         avgFrametime += ft;
     }
     float varFrametime = maxFrametime - minFrametime;
-    avgFrametime /= m_lastFrametimes.size() == 0 ? 1 : m_lastFrametimes.size();
+    avgFrametime /= m_dLastFrametimes.size() == 0 ? 1 : m_dLastFrametimes.size();
 
     float avgRenderTime = 0;
     float maxRenderTime = 0;
     float minRenderTime = 9999;
-    for (auto const& rt : m_lastRenderTimes) {
+    for (auto const& rt : m_dLastRenderTimes) {
         if (rt > maxRenderTime)
             maxRenderTime = rt;
         if (rt < minRenderTime)
@@ -96,12 +96,12 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
         avgRenderTime += rt;
     }
     float varRenderTime = maxRenderTime - minRenderTime;
-    avgRenderTime /= m_lastRenderTimes.size() == 0 ? 1 : m_lastRenderTimes.size();
+    avgRenderTime /= m_dLastRenderTimes.size() == 0 ? 1 : m_dLastRenderTimes.size();
 
     float avgRenderTimeNoOverlay = 0;
     float maxRenderTimeNoOverlay = 0;
     float minRenderTimeNoOverlay = 9999;
-    for (auto const& rt : m_lastRenderTimesNoOverlay) {
+    for (auto const& rt : m_dLastRenderTimesNoOverlay) {
         if (rt > maxRenderTimeNoOverlay)
             maxRenderTimeNoOverlay = rt;
         if (rt < minRenderTimeNoOverlay)
@@ -109,12 +109,12 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
         avgRenderTimeNoOverlay += rt;
     }
     float varRenderTimeNoOverlay = maxRenderTimeNoOverlay - minRenderTimeNoOverlay;
-    avgRenderTimeNoOverlay /= m_lastRenderTimes.size() == 0 ? 1 : m_lastRenderTimes.size();
+    avgRenderTimeNoOverlay /= m_dLastRenderTimes.size() == 0 ? 1 : m_dLastRenderTimes.size();
 
     float avgAnimMgrTick = 0;
     float maxAnimMgrTick = 0;
     float minAnimMgrTick = 9999;
-    for (auto const& at : m_lastAnimationTicks) {
+    for (auto const& at : m_dLastAnimationTicks) {
         if (at > maxAnimMgrTick)
             maxAnimMgrTick = at;
         if (at < minAnimMgrTick)
@@ -122,13 +122,13 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
         avgAnimMgrTick += at;
     }
     float varAnimMgrTick = maxAnimMgrTick - minAnimMgrTick;
-    avgAnimMgrTick /= m_lastAnimationTicks.size() == 0 ? 1 : m_lastAnimationTicks.size();
+    avgAnimMgrTick /= m_dLastAnimationTicks.size() == 0 ? 1 : m_dLastAnimationTicks.size();
 
     const float           FPS      = 1.f / (avgFrametime / 1000.f); // frametimes are in ms
-    const float           idealFPS = m_lastFrametimes.size();
+    const float           idealFPS = m_dLastFrametimes.size();
 
     static auto           fontFamily = CConfigValue<std::string>("misc:font_family");
-    PangoLayout*          layoutText = pango_cairo_create_layout(g_pDebugOverlay->m_cairo);
+    PangoLayout*          layoutText = pango_cairo_create_layout(g_pDebugOverlay->m_pCairo);
     PangoFontDescription* pangoFD    = pango_font_description_new();
 
     pango_font_description_set_family(pangoFD, (*fontFamily).c_str());
@@ -137,7 +137,7 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
 
     float maxTextW = 0;
     int   fontSize = 0;
-    auto  cr       = g_pDebugOverlay->m_cairo;
+    auto  cr       = g_pDebugOverlay->m_pCairo;
 
     auto  showText = [cr, layoutText, pangoFD, &maxTextW, &fontSize](const char* text, int size) {
         if (fontSize != size) {
@@ -163,22 +163,22 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
     const int MARGIN_TOP  = 8;
     const int MARGIN_LEFT = 4;
     cairo_move_to(cr, MARGIN_LEFT, MARGIN_TOP + offset);
-    cairo_set_source_rgba(g_pDebugOverlay->m_cairo, 1.f, 1.f, 1.f, 1.f);
+    cairo_set_source_rgba(g_pDebugOverlay->m_pCairo, 1.f, 1.f, 1.f, 1.f);
 
     std::string text;
-    showText(m_monitor->m_name.c_str(), 10);
+    showText(m_pMonitor->szName.c_str(), 10);
 
     if (FPS > idealFPS * 0.95f)
-        cairo_set_source_rgba(g_pDebugOverlay->m_cairo, 0.2f, 1.f, 0.2f, 1.f);
+        cairo_set_source_rgba(g_pDebugOverlay->m_pCairo, 0.2f, 1.f, 0.2f, 1.f);
     else if (FPS > idealFPS * 0.8f)
-        cairo_set_source_rgba(g_pDebugOverlay->m_cairo, 1.f, 1.f, 0.2f, 1.f);
+        cairo_set_source_rgba(g_pDebugOverlay->m_pCairo, 1.f, 1.f, 0.2f, 1.f);
     else
-        cairo_set_source_rgba(g_pDebugOverlay->m_cairo, 1.f, 0.2f, 0.2f, 1.f);
+        cairo_set_source_rgba(g_pDebugOverlay->m_pCairo, 1.f, 0.2f, 0.2f, 1.f);
 
     text = std::format("{} FPS", (int)FPS);
     showText(text.c_str(), 16);
 
-    cairo_set_source_rgba(g_pDebugOverlay->m_cairo, 1.f, 1.f, 1.f, 1.f);
+    cairo_set_source_rgba(g_pDebugOverlay->m_pCairo, 1.f, 1.f, 1.f, 1.f);
 
     text = std::format("Avg Frametime: {:.2f}ms (var {:.2f}ms)", avgFrametime, varFrametime);
     showText(text.c_str(), 10);
@@ -198,10 +198,10 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
     double posX = 0, posY = 0;
     cairo_get_current_point(cr, &posX, &posY);
 
-    g_pHyprRenderer->damageBox(m_lastDrawnBox);
-    m_lastDrawnBox = {(int)g_pCompositor->m_monitors.front()->m_position.x + MARGIN_LEFT - 1, (int)g_pCompositor->m_monitors.front()->m_position.y + offset + MARGIN_TOP - 1,
+    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_lastDrawnBox);
+    g_pHyprRenderer->damageBox(m_wbLastDrawnBox);
 
     return posY - offset;
 }
@@ -212,7 +212,7 @@ void CHyprDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs) {
     if (!*PDEBUGOVERLAY)
         return;
 
-    m_monitorOverlays[pMonitor].renderData(pMonitor, durationUs);
+    m_mMonitorOverlays[pMonitor].renderData(pMonitor, durationUs);
 }
 
 void CHyprDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float durationUs) {
@@ -221,7 +221,7 @@ void CHyprDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float durationU
     if (!*PDEBUGOVERLAY)
         return;
 
-    m_monitorOverlays[pMonitor].renderDataNoOverlay(pMonitor, durationUs);
+    m_mMonitorOverlays[pMonitor].renderDataNoOverlay(pMonitor, durationUs);
 }
 
 void CHyprDebugOverlay::frameData(PHLMONITOR pMonitor) {
@@ -230,37 +230,37 @@ void CHyprDebugOverlay::frameData(PHLMONITOR pMonitor) {
     if (!*PDEBUGOVERLAY)
         return;
 
-    m_monitorOverlays[pMonitor].frameData(pMonitor);
+    m_mMonitorOverlays[pMonitor].frameData(pMonitor);
 }
 
 void CHyprDebugOverlay::draw() {
 
-    const auto PMONITOR = g_pCompositor->m_monitors.front();
+    const auto PMONITOR = g_pCompositor->m_vMonitors.front();
 
-    if (!m_cairoSurface || !m_cairo) {
-        m_cairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y);
-        m_cairo        = cairo_create(m_cairoSurface);
+    if (!m_pCairoSurface || !m_pCairo) {
+        m_pCairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
+        m_pCairo        = cairo_create(m_pCairoSurface);
     }
 
     // clear the pixmap
-    cairo_save(m_cairo);
-    cairo_set_operator(m_cairo, CAIRO_OPERATOR_CLEAR);
-    cairo_paint(m_cairo);
-    cairo_restore(m_cairo);
+    cairo_save(m_pCairo);
+    cairo_set_operator(m_pCairo, CAIRO_OPERATOR_CLEAR);
+    cairo_paint(m_pCairo);
+    cairo_restore(m_pCairo);
 
     // draw the things
     int offsetY = 0;
-    for (auto const& m : g_pCompositor->m_monitors) {
-        offsetY += m_monitorOverlays[m].draw(offsetY);
+    for (auto const& m : g_pCompositor->m_vMonitors) {
+        offsetY += m_mMonitorOverlays[m].draw(offsetY);
         offsetY += 5; // for padding between mons
     }
 
-    cairo_surface_flush(m_cairoSurface);
+    cairo_surface_flush(m_pCairoSurface);
 
     // copy the data to an OpenGL texture we have
-    const auto DATA = cairo_image_surface_get_data(m_cairoSurface);
-    m_texture->allocate();
-    glBindTexture(GL_TEXTURE_2D, m_texture->m_texID);
+    const auto DATA = cairo_image_surface_get_data(m_pCairoSurface);
+    m_pTexture->allocate();
+    glBindTexture(GL_TEXTURE_2D, m_pTexture->m_iTexID);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 
@@ -269,10 +269,10 @@ void CHyprDebugOverlay::draw() {
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
 #endif
 
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
 
     CTexPassElement::SRenderData data;
-    data.tex = m_texture;
-    data.box = {0, 0, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y};
-    g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(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

@@ -17,13 +17,13 @@ class CHyprMonitorDebugOverlay {
     void frameData(PHLMONITOR pMonitor);
 
   private:
-    std::deque<float>                              m_lastFrametimes;
-    std::deque<float>                              m_lastRenderTimes;
-    std::deque<float>                              m_lastRenderTimesNoOverlay;
-    std::deque<float>                              m_lastAnimationTicks;
-    std::chrono::high_resolution_clock::time_point m_lastFrame;
-    PHLMONITORREF                                  m_monitor;
-    CBox                                           m_lastDrawnBox;
+    std::deque<float>                              m_dLastFrametimes;
+    std::deque<float>                              m_dLastRenderTimes;
+    std::deque<float>                              m_dLastRenderTimesNoOverlay;
+    std::deque<float>                              m_dLastAnimationTicks;
+    std::chrono::high_resolution_clock::time_point m_tpLastFrame;
+    PHLMONITORREF                                  m_pMonitor;
+    CBox                                           m_wbLastDrawnBox;
 
     friend class CHyprRenderer;
 };
@@ -37,12 +37,12 @@ class CHyprDebugOverlay {
     void frameData(PHLMONITOR);
 
   private:
-    std::map<PHLMONITORREF, CHyprMonitorDebugOverlay> m_monitorOverlays;
+    std::map<PHLMONITORREF, CHyprMonitorDebugOverlay> m_mMonitorOverlays;
 
-    cairo_surface_t*                                  m_cairoSurface = nullptr;
-    cairo_t*                                          m_cairo        = nullptr;
+    cairo_surface_t*                                  m_pCairoSurface = nullptr;
+    cairo_t*                                          m_pCairo        = nullptr;
 
-    SP<CTexture>                                      m_texture;
+    SP<CTexture>                                      m_pTexture;
 
     friend class CHyprMonitorDebugOverlay;
     friend class CHyprRenderer;

src/debug/HyprNotificationOverlay.cpp

@@ -23,24 +23,24 @@ static inline auto iconBackendFromLayout(PangoLayout* layout) {
 
 CHyprNotificationOverlay::CHyprNotificationOverlay() {
     static auto P = g_pHookSystem->hookDynamic("focusedMon", [&](void* self, SCallbackInfo& info, std::any param) {
-        if (m_notifications.size() == 0)
+        if (m_vNotifications.size() == 0)
             return;
 
-        g_pHyprRenderer->damageBox(m_lastDamage);
+        g_pHyprRenderer->damageBox(m_bLastDamage);
     });
 
-    m_texture = makeShared<CTexture>();
+    m_pTexture = makeShared<CTexture>();
 }
 
 CHyprNotificationOverlay::~CHyprNotificationOverlay() {
-    if (m_cairo)
-        cairo_destroy(m_cairo);
-    if (m_cairoSurface)
-        cairo_surface_destroy(m_cairoSurface);
+    if (m_pCairo)
+        cairo_destroy(m_pCairo);
+    if (m_pCairoSurface)
+        cairo_surface_destroy(m_pCairoSurface);
 }
 
 void CHyprNotificationOverlay::addNotification(const std::string& text, const CHyprColor& color, const float timeMs, const eIcons icon, const float fontSize) {
-    const auto PNOTIF = m_notifications.emplace_back(makeUnique<SNotification>()).get();
+    const auto PNOTIF = m_vNotifications.emplace_back(makeUnique<SNotification>()).get();
 
     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;
@@ -49,19 +49,19 @@ void CHyprNotificationOverlay::addNotification(const std::string& text, const CH
     PNOTIF->icon     = icon;
     PNOTIF->fontSize = fontSize;
 
-    for (auto const& m : g_pCompositor->m_monitors) {
+    for (auto const& m : g_pCompositor->m_vMonitors) {
         g_pCompositor->scheduleFrameForMonitor(m);
     }
 }
 
 void CHyprNotificationOverlay::dismissNotifications(const int amount) {
     if (amount == -1)
-        m_notifications.clear();
+        m_vNotifications.clear();
     else {
-        const int AMT = std::min(amount, static_cast<int>(m_notifications.size()));
+        const int AMT = std::min(amount, static_cast<int>(m_vNotifications.size()));
 
         for (int i = 0; i < AMT; ++i) {
-            m_notifications.erase(m_notifications.begin());
+            m_vNotifications.erase(m_vNotifications.begin());
         }
     }
 }
@@ -77,12 +77,12 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
     float                 offsetY  = 10;
     float                 maxWidth = 0;
 
-    const auto            SCALE   = pMonitor->m_scale;
-    const auto            MONSIZE = pMonitor->m_transformedSize;
+    const auto            SCALE   = pMonitor->scale;
+    const auto            MONSIZE = pMonitor->vecTransformedSize;
 
     static auto           fontFamily = CConfigValue<std::string>("misc:font_family");
 
-    PangoLayout*          layout  = pango_cairo_create_layout(m_cairo);
+    PangoLayout*          layout  = pango_cairo_create_layout(m_pCairo);
     PangoFontDescription* pangoFD = pango_font_description_new();
 
     pango_font_description_set_family(pangoFD, (*fontFamily).c_str());
@@ -92,9 +92,9 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
     const auto iconBackendID = iconBackendFromLayout(layout);
     const auto PBEZIER       = g_pAnimationManager->getBezier("default");
 
-    for (auto const& notif : m_notifications) {
+    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->m_pixelSize.x * SCALE) / 1920.f)), 8, 40);
+        const auto FONTSIZE        = std::clamp((int)(notif->fontSize * ((pMonitor->vecPixelSize.x * SCALE) / 1920.f)), 8, 40);
 
         // first rect (bg, col)
         const float FIRSTRECTANIMP =
@@ -139,17 +139,17 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
         const auto NOTIFSIZE = Vector2D{textW + 20.0 + iconW + 2 * ICONPADFORNOTIF, textH + 10.0};
 
         // draw rects
-        cairo_set_source_rgba(m_cairo, notif->color.r, notif->color.g, notif->color.b, notif->color.a);
-        cairo_rectangle(m_cairo, MONSIZE.x - (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC, offsetY, (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC, NOTIFSIZE.y);
-        cairo_fill(m_cairo);
+        cairo_set_source_rgba(m_pCairo, notif->color.r, notif->color.g, notif->color.b, notif->color.a);
+        cairo_rectangle(m_pCairo, MONSIZE.x - (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC, offsetY, (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC, NOTIFSIZE.y);
+        cairo_fill(m_pCairo);
 
-        cairo_set_source_rgb(m_cairo, 0.f, 0.f, 0.f);
-        cairo_rectangle(m_cairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC, offsetY, NOTIFSIZE.x * SECONDRECTPERC, NOTIFSIZE.y);
-        cairo_fill(m_cairo);
+        cairo_set_source_rgb(m_pCairo, 0.f, 0.f, 0.f);
+        cairo_rectangle(m_pCairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC, offsetY, NOTIFSIZE.x * SECONDRECTPERC, NOTIFSIZE.y);
+        cairo_fill(m_pCairo);
 
-        cairo_set_source_rgba(m_cairo, notif->color.r, notif->color.g, notif->color.b, notif->color.a);
-        cairo_rectangle(m_cairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC + 3, offsetY + NOTIFSIZE.y - 4, THIRDRECTPERC * (NOTIFSIZE.x - 6), 2);
-        cairo_fill(m_cairo);
+        cairo_set_source_rgba(m_pCairo, notif->color.r, notif->color.g, notif->color.b, notif->color.a);
+        cairo_rectangle(m_pCairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC + 3, offsetY + NOTIFSIZE.y - 4, THIRDRECTPERC * (NOTIFSIZE.x - 6), 2);
+        cairo_fill(m_pCairo);
 
         // draw gradient
         if (notif->icon != ICON_NONE) {
@@ -158,23 +158,23 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
                                                   MONSIZE.x - (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC + GRADIENT_SIZE, offsetY);
             cairo_pattern_add_color_stop_rgba(pattern, 0, ICONCOLOR.r, ICONCOLOR.g, ICONCOLOR.b, ICONCOLOR.a / 3.0);
             cairo_pattern_add_color_stop_rgba(pattern, 1, ICONCOLOR.r, ICONCOLOR.g, ICONCOLOR.b, 0);
-            cairo_rectangle(m_cairo, MONSIZE.x - (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC, offsetY, GRADIENT_SIZE, NOTIFSIZE.y);
-            cairo_set_source(m_cairo, pattern);
-            cairo_fill(m_cairo);
+            cairo_rectangle(m_pCairo, MONSIZE.x - (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC, offsetY, GRADIENT_SIZE, NOTIFSIZE.y);
+            cairo_set_source(m_pCairo, pattern);
+            cairo_fill(m_pCairo);
             cairo_pattern_destroy(pattern);
 
             // draw icon
-            cairo_set_source_rgb(m_cairo, 1.f, 1.f, 1.f);
-            cairo_move_to(m_cairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC + NOTIF_LEFTBAR_SIZE + ICONPADFORNOTIF - 1, offsetY - 2 + std::round((NOTIFSIZE.y - iconH) / 2.0));
+            cairo_set_source_rgb(m_pCairo, 1.f, 1.f, 1.f);
+            cairo_move_to(m_pCairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC + NOTIF_LEFTBAR_SIZE + ICONPADFORNOTIF - 1, offsetY - 2 + std::round((NOTIFSIZE.y - iconH) / 2.0));
             pango_layout_set_text(layout, ICON.c_str(), -1);
-            pango_cairo_show_layout(m_cairo, layout);
+            pango_cairo_show_layout(m_pCairo, layout);
         }
 
         // draw text
-        cairo_set_source_rgb(m_cairo, 1.f, 1.f, 1.f);
-        cairo_move_to(m_cairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC + NOTIF_LEFTBAR_SIZE + iconW + 2 * ICONPADFORNOTIF, offsetY - 2 + std::round((NOTIFSIZE.y - textH) / 2.0));
+        cairo_set_source_rgb(m_pCairo, 1.f, 1.f, 1.f);
+        cairo_move_to(m_pCairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC + NOTIF_LEFTBAR_SIZE + iconW + 2 * ICONPADFORNOTIF, offsetY - 2 + std::round((NOTIFSIZE.y - textH) / 2.0));
         pango_layout_set_text(layout, notif->text.c_str(), -1);
-        pango_cairo_show_layout(m_cairo, layout);
+        pango_cairo_show_layout(m_pCairo, layout);
 
         // adjust offset and move on
         offsetY += NOTIFSIZE.y + 10;
@@ -187,55 +187,55 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
     g_object_unref(layout);
 
     // cleanup notifs
-    std::erase_if(m_notifications, [](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->m_position.x + pMonitor->m_size.x - maxWidth - 20), (int)pMonitor->m_position.y, (int)maxWidth + 20, (int)offsetY + 10};
+    return CBox{(int)(pMonitor->vecPosition.x + pMonitor->vecSize.x - maxWidth - 20), (int)pMonitor->vecPosition.y, (int)maxWidth + 20, (int)offsetY + 10};
 }
 
 void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) {
 
-    const auto MONSIZE = pMonitor->m_transformedSize;
+    const auto MONSIZE = pMonitor->vecTransformedSize;
 
-    if (m_lastMonitor != pMonitor || m_lastSize != MONSIZE || !m_cairo || !m_cairoSurface) {
+    if (m_pLastMonitor != pMonitor || m_vecLastSize != MONSIZE || !m_pCairo || !m_pCairoSurface) {
 
-        if (m_cairo && m_cairoSurface) {
-            cairo_destroy(m_cairo);
-            cairo_surface_destroy(m_cairoSurface);
+        if (m_pCairo && m_pCairoSurface) {
+            cairo_destroy(m_pCairo);
+            cairo_surface_destroy(m_pCairoSurface);
         }
 
-        m_cairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, MONSIZE.x, MONSIZE.y);
-        m_cairo        = cairo_create(m_cairoSurface);
-        m_lastMonitor  = pMonitor;
-        m_lastSize     = MONSIZE;
+        m_pCairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, MONSIZE.x, MONSIZE.y);
+        m_pCairo        = cairo_create(m_pCairoSurface);
+        m_pLastMonitor  = pMonitor;
+        m_vecLastSize   = MONSIZE;
     }
 
     // Draw the notifications
-    if (m_notifications.size() == 0)
+    if (m_vNotifications.size() == 0)
         return;
 
     // Render to the monitor
 
     // clear the pixmap
-    cairo_save(m_cairo);
-    cairo_set_operator(m_cairo, CAIRO_OPERATOR_CLEAR);
-    cairo_paint(m_cairo);
-    cairo_restore(m_cairo);
+    cairo_save(m_pCairo);
+    cairo_set_operator(m_pCairo, CAIRO_OPERATOR_CLEAR);
+    cairo_paint(m_pCairo);
+    cairo_restore(m_pCairo);
 
-    cairo_surface_flush(m_cairoSurface);
+    cairo_surface_flush(m_pCairoSurface);
 
     CBox damage = drawNotifications(pMonitor);
 
     g_pHyprRenderer->damageBox(damage);
-    g_pHyprRenderer->damageBox(m_lastDamage);
+    g_pHyprRenderer->damageBox(m_bLastDamage);
 
     g_pCompositor->scheduleFrameForMonitor(pMonitor);
 
-    m_lastDamage = damage;
+    m_bLastDamage = damage;
 
     // copy the data to an OpenGL texture we have
-    const auto DATA = cairo_image_surface_get_data(m_cairoSurface);
-    m_texture->allocate();
-    glBindTexture(GL_TEXTURE_2D, m_texture->m_texID);
+    const auto DATA = cairo_image_surface_get_data(m_pCairoSurface);
+    m_pTexture->allocate();
+    glBindTexture(GL_TEXTURE_2D, m_pTexture->m_iTexID);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 
@@ -247,13 +247,13 @@ void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) {
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, MONSIZE.x, MONSIZE.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
 
     CTexPassElement::SRenderData data;
-    data.tex = m_texture;
+    data.tex = m_pTexture;
     data.box = {0, 0, MONSIZE.x, MONSIZE.y};
     data.a   = 1.F;
 
-    g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(data));
+    g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
 }
 
 bool CHyprNotificationOverlay::hasAny() {
-    return !m_notifications.empty();
+    return !m_vNotifications.empty();
 }

src/debug/HyprNotificationOverlay.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "../defines.hpp"
-#include "../helpers/time/Timer.hpp"
+#include "../helpers/Timer.hpp"
 #include "../render/Texture.hpp"
 #include "../SharedDefs.hpp"
 
@@ -47,17 +47,17 @@ class CHyprNotificationOverlay {
 
   private:
     CBox                           drawNotifications(PHLMONITOR pMonitor);
-    CBox                           m_lastDamage;
+    CBox                           m_bLastDamage;
 
-    std::vector<UP<SNotification>> m_notifications;
+    std::vector<UP<SNotification>> m_vNotifications;
 
-    cairo_surface_t*               m_cairoSurface = nullptr;
-    cairo_t*                       m_cairo        = nullptr;
+    cairo_surface_t*               m_pCairoSurface = nullptr;
+    cairo_t*                       m_pCairo        = nullptr;
 
-    PHLMONITORREF                  m_lastMonitor;
-    Vector2D                       m_lastSize = Vector2D(-1, -1);
+    PHLMONITORREF                  m_pLastMonitor;
+    Vector2D                       m_vecLastSize = Vector2D(-1, -1);
 
-    SP<CTexture>                   m_texture;
+    SP<CTexture>                   m_pTexture;
 };
 
 inline UP<CHyprNotificationOverlay> g_pHyprNotificationOverlay;

src/debug/Log.cpp

@@ -7,21 +7,21 @@
 #include <fcntl.h>
 
 void Debug::init(const std::string& IS) {
-    m_logFile = IS + (ISDEBUG ? "/hyprlandd.log" : "/hyprland.log");
-    m_logOfs.open(m_logFile, std::ios::out | std::ios::app);
-    auto handle = m_logOfs.native_handle();
+    logFile = IS + (ISDEBUG ? "/hyprlandd.log" : "/hyprland.log");
+    logOfs.open(logFile, std::ios::out | std::ios::app);
+    auto handle = logOfs.native_handle();
     fcntl(handle, F_SETFD, FD_CLOEXEC);
 }
 
 void Debug::close() {
-    m_logOfs.close();
+    logOfs.close();
 }
 
 void Debug::log(eLogLevel level, std::string str) {
-    if (level == TRACE && !m_trace)
+    if (level == TRACE && !trace)
         return;
 
-    if (m_shuttingDown)
+    if (shuttingDown)
         return;
 
     std::string coloredStr = str;
@@ -55,20 +55,20 @@ void Debug::log(eLogLevel level, std::string str) {
     }
     //NOLINTEND
 
-    m_rollingLog += str + "\n";
-    if (m_rollingLog.size() > ROLLING_LOG_SIZE)
-        m_rollingLog = m_rollingLog.substr(m_rollingLog.size() - ROLLING_LOG_SIZE);
+    rollingLog += str + "\n";
+    if (rollingLog.size() > ROLLING_LOG_SIZE)
+        rollingLog = rollingLog.substr(rollingLog.size() - ROLLING_LOG_SIZE);
 
     if (SRollingLogFollow::get().isRunning())
         SRollingLogFollow::get().addLog(str);
 
-    if (!m_disableLogs || !**m_disableLogs) {
+    if (!disableLogs || !**disableLogs) {
         // log to a file
-        m_logOfs << str << "\n";
-        m_logOfs.flush();
+        logOfs << str << "\n";
+        logOfs.flush();
     }
 
     // log it to the stdout too.
-    if (!m_disableStdout)
-        std::println("{}", ((m_coloredLogs && !**m_coloredLogs) ? str : coloredStr));
+    if (!disableStdout)
+        std::println("{}", ((coloredLogs && !**coloredLogs) ? str : coloredStr));
 }

src/debug/Log.hpp

@@ -21,17 +21,17 @@ enum eLogLevel : int8_t {
 
 // NOLINTNEXTLINE(readability-identifier-naming)
 namespace Debug {
-    inline std::string     m_logFile;
-    inline std::ofstream   m_logOfs;
-    inline int64_t* const* m_disableLogs   = nullptr;
-    inline int64_t* const* m_disableTime   = nullptr;
-    inline bool            m_disableStdout = false;
-    inline bool            m_trace         = false;
-    inline bool            m_shuttingDown  = false;
-    inline int64_t* const* m_coloredLogs   = nullptr;
+    inline std::string     logFile;
+    inline std::ofstream   logOfs;
+    inline int64_t* const* disableLogs   = nullptr;
+    inline int64_t* const* disableTime   = nullptr;
+    inline bool            disableStdout = false;
+    inline bool            trace         = false;
+    inline bool            shuttingDown  = false;
+    inline int64_t* const* coloredLogs   = nullptr;
 
-    inline std::string     m_rollingLog = ""; // rolling log contains the ROLLING_LOG_SIZE tail of the log
-    inline std::mutex      m_logMutex;
+    inline std::string     rollingLog = ""; // rolling log contains the ROLLING_LOG_SIZE tail of the log
+    inline std::mutex      logMutex;
 
     void                   init(const std::string& IS);
     void                   close();
@@ -42,18 +42,18 @@ namespace Debug {
     template <typename... Args>
     //NOLINTNEXTLINE
     void log(eLogLevel level, std::format_string<Args...> fmt, Args&&... args) {
-        std::lock_guard<std::mutex> guard(m_logMutex);
+        std::lock_guard<std::mutex> guard(logMutex);
 
-        if (level == TRACE && !m_trace)
+        if (level == TRACE && !trace)
             return;
 
-        if (m_shuttingDown)
+        if (shuttingDown)
             return;
 
         std::string logMsg = "";
 
         // print date and time to the ofs
-        if (m_disableTime && !**m_disableTime) {
+        if (disableTime && !**disableTime) {
 #ifndef _LIBCPP_VERSION
             static auto current_zone = std::chrono::current_zone();
             const auto  zt           = std::chrono::zoned_time{current_zone, std::chrono::system_clock::now()};

src/debug/RollingLogFollow.hpp

@@ -5,55 +5,55 @@
 // NOLINTNEXTLINE(readability-identifier-naming)
 namespace Debug {
     struct SRollingLogFollow {
-        std::unordered_map<int, std::string> m_socketToRollingLogFollowQueue;
-        std::shared_mutex                    m_mutex;
-        bool                                 m_running                  = false;
+        std::unordered_map<int, std::string> socketToRollingLogFollowQueue;
+        std::shared_mutex                    m;
+        bool                                 running                    = false;
         static constexpr size_t              ROLLING_LOG_FOLLOW_TOO_BIG = 8192;
 
         // Returns true if the queue is empty for the given socket
         bool isEmpty(int socket) {
-            std::shared_lock<std::shared_mutex> r(m_mutex);
-            return m_socketToRollingLogFollowQueue[socket].empty();
+            std::shared_lock<std::shared_mutex> r(m);
+            return socketToRollingLogFollowQueue[socket].empty();
         }
 
         std::string debugInfo() {
-            std::shared_lock<std::shared_mutex> r(m_mutex);
-            return std::format("RollingLogFollow, got {} connections", m_socketToRollingLogFollowQueue.size());
+            std::shared_lock<std::shared_mutex> r(m);
+            return std::format("RollingLogFollow, got {} connections", socketToRollingLogFollowQueue.size());
         }
 
         std::string getLog(int socket) {
-            std::unique_lock<std::shared_mutex> w(m_mutex);
+            std::unique_lock<std::shared_mutex> w(m);
 
-            const std::string                   ret = m_socketToRollingLogFollowQueue[socket];
-            m_socketToRollingLogFollowQueue[socket] = "";
+            const std::string                   ret = socketToRollingLogFollowQueue[socket];
+            socketToRollingLogFollowQueue[socket]   = "";
 
             return ret;
         };
 
         void addLog(const std::string& log) {
-            std::unique_lock<std::shared_mutex> w(m_mutex);
-            m_running = true;
+            std::unique_lock<std::shared_mutex> w(m);
+            running = true;
             std::vector<int> to_erase;
-            for (const auto& p : m_socketToRollingLogFollowQueue)
-                m_socketToRollingLogFollowQueue[p.first] += log + "\n";
+            for (const auto& p : socketToRollingLogFollowQueue)
+                socketToRollingLogFollowQueue[p.first] += log + "\n";
         }
 
         bool isRunning() {
-            std::shared_lock<std::shared_mutex> r(m_mutex);
-            return m_running;
+            std::shared_lock<std::shared_mutex> r(m);
+            return running;
         }
 
         void stopFor(int socket) {
-            std::unique_lock<std::shared_mutex> w(m_mutex);
-            m_socketToRollingLogFollowQueue.erase(socket);
-            if (m_socketToRollingLogFollowQueue.empty())
-                m_running = false;
+            std::unique_lock<std::shared_mutex> w(m);
+            socketToRollingLogFollowQueue.erase(socket);
+            if (socketToRollingLogFollowQueue.empty())
+                running = false;
         }
 
         void startFor(int socket) {
-            std::unique_lock<std::shared_mutex> w(m_mutex);
-            m_socketToRollingLogFollowQueue[socket] = std::format("[LOG] Following log to socket: {} started\n", socket);
-            m_running                               = true;
+            std::unique_lock<std::shared_mutex> w(m);
+            socketToRollingLogFollowQueue[socket] = std::format("[LOG] Following log to socket: {} started\n", socket);
+            running                               = true;
         }
 
         static SRollingLogFollow& get() {

src/desktop/LayerRule.cpp

@@ -5,36 +5,34 @@
 #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", "abovelock"};
+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_) : m_targetNamespace(ns_), m_rule(rule_) {
-    const bool VALID = RULES.contains(m_rule) || std::ranges::any_of(RULES_PREFIX, [&rule_](const auto& prefix) { return rule_.starts_with(prefix); });
+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 (m_rule == "noanim")
-        m_ruleType = RULE_NOANIM;
-    else if (m_rule == "blur")
-        m_ruleType = RULE_BLUR;
-    else if (m_rule == "blurpopups")
-        m_ruleType = RULE_BLURPOPUPS;
-    else if (m_rule == "dimaround")
-        m_ruleType = RULE_DIMAROUND;
-    else if (m_rule.starts_with("ignorealpha"))
-        m_ruleType = RULE_IGNOREALPHA;
-    else if (m_rule.starts_with("ignorezero"))
-        m_ruleType = RULE_IGNOREZERO;
-    else if (m_rule.starts_with("xray"))
-        m_ruleType = RULE_XRAY;
-    else if (m_rule.starts_with("animation"))
-        m_ruleType = RULE_ANIMATION;
-    else if (m_rule.starts_with("order"))
-        m_ruleType = RULE_ORDER;
-    else if (m_rule.starts_with("abovelock"))
-        m_ruleType = RULE_ABOVELOCK;
+    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?!");
-        m_ruleType = RULE_INVALID;
+        ruleType = RULE_INVALID;
     }
 }

src/desktop/LayerRule.hpp

@@ -14,7 +14,6 @@ class CLayerRule {
         RULE_BLUR,
         RULE_BLURPOPUPS,
         RULE_DIMAROUND,
-        RULE_ABOVELOCK,
         RULE_IGNOREALPHA,
         RULE_IGNOREZERO,
         RULE_XRAY,
@@ -23,10 +22,10 @@ class CLayerRule {
         RULE_ZUMBA,
     };
 
-    eRuleType           m_ruleType = RULE_INVALID;
+    eRuleType           ruleType = RULE_INVALID;
 
-    const std::string   m_targetNamespace;
-    const std::string   m_rule;
+    const std::string   targetNamespace;
+    const std::string   rule;
 
-    CRuleRegexContainer m_targetNamespaceRegex;
+    CRuleRegexContainer targetNamespaceRegex;
 };

src/desktop/LayerSurface.cpp

@@ -15,436 +15,424 @@
 PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
     PHLLS pLS = SP<CLayerSurface>(new CLayerSurface(resource));
 
-    auto  pMonitor = resource->m_monitor.empty() ? g_pCompositor->m_lastMonitor.lock() : g_pCompositor->getMonitorFromName(resource->m_monitor);
+    auto  pMonitor = resource->monitor.empty() ? g_pCompositor->m_pLastMonitor.lock() : g_pCompositor->getMonitorFromName(resource->monitor);
 
-    pLS->m_surface->assign(resource->m_surface.lock(), pLS);
+    pLS->surface->assign(resource->surface.lock(), pLS);
 
     if (!pMonitor) {
         Debug::log(ERR, "New LS has no monitor??");
         return pLS;
     }
 
-    if (pMonitor->m_mirrorOf)
-        pMonitor = g_pCompositor->m_monitors.front();
+    if (pMonitor->pMirrorOf)
+        pMonitor = g_pCompositor->m_vMonitors.front();
 
-    pLS->m_self = pLS;
+    pLS->self = pLS;
 
-    pLS->m_namespace = resource->m_layerNamespace;
+    pLS->szNamespace = resource->layerNamespace;
 
-    pLS->m_layer     = resource->m_current.layer;
-    pLS->m_popupHead = CPopup::create(pLS);
-    pLS->m_monitor   = pMonitor;
-    pMonitor->m_layerSurfaceLayers[resource->m_current.layer].emplace_back(pLS);
+    pLS->layer     = resource->current.layer;
+    pLS->popupHead = CPopup::create(pLS);
+    pLS->monitor   = pMonitor;
+    pMonitor->m_aLayerSurfaceLayers[resource->current.layer].emplace_back(pLS);
 
-    pLS->m_forceBlur = g_pConfigManager->shouldBlurLS(pLS->m_namespace);
+    pLS->forceBlur = g_pConfigManager->shouldBlurLS(pLS->szNamespace);
 
-    g_pAnimationManager->createAnimation(0.f, pLS->m_alpha, g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn"), pLS, AVARDAMAGE_ENTIRE);
-    g_pAnimationManager->createAnimation(Vector2D(0, 0), pLS->m_realPosition, g_pConfigManager->getAnimationPropertyConfig("layersIn"), pLS, AVARDAMAGE_ENTIRE);
-    g_pAnimationManager->createAnimation(Vector2D(0, 0), pLS->m_realSize, g_pConfigManager->getAnimationPropertyConfig("layersIn"), pLS, AVARDAMAGE_ENTIRE);
+    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->m_alpha->setValueAndWarp(0.f);
+    pLS->alpha->setValueAndWarp(0.f);
 
-    Debug::log(LOG, "LayerSurface {:x} (namespace {} layer {}) created on monitor {}", (uintptr_t)resource.get(), resource->m_layerNamespace, (int)pLS->m_layer, pMonitor->m_name);
+    Debug::log(LOG, "LayerSurface {:x} (namespace {} layer {}) created on monitor {}", (uintptr_t)resource.get(), resource->layerNamespace, (int)pLS->layer, pMonitor->szName);
 
     return pLS;
 }
 
 void CLayerSurface::registerCallbacks() {
-    m_alpha->setUpdateCallback([this](auto) {
-        if (m_dimAround)
-            g_pHyprRenderer->damageMonitor(m_monitor.lock());
+    alpha->setUpdateCallback([this](auto) {
+        if (dimAround)
+            g_pHyprRenderer->damageMonitor(monitor.lock());
     });
 }
 
-CLayerSurface::CLayerSurface(SP<CLayerShellResource> resource_) : m_layerSurface(resource_) {
-    m_listeners.commit  = m_layerSurface->m_events.commit.registerListener([this](std::any d) { onCommit(); });
-    m_listeners.map     = m_layerSurface->m_events.map.registerListener([this](std::any d) { onMap(); });
-    m_listeners.unmap   = m_layerSurface->m_events.unmap.registerListener([this](std::any d) { onUnmap(); });
-    m_listeners.destroy = m_layerSurface->m_events.destroy.registerListener([this](std::any d) { onDestroy(); });
+CLayerSurface::CLayerSurface(SP<CLayerShellResource> resource_) : layerSurface(resource_) {
+    listeners.commit  = layerSurface->events.commit.registerListener([this](std::any d) { onCommit(); });
+    listeners.map     = layerSurface->events.map.registerListener([this](std::any d) { onMap(); });
+    listeners.unmap   = layerSurface->events.unmap.registerListener([this](std::any d) { onUnmap(); });
+    listeners.destroy = layerSurface->events.destroy.registerListener([this](std::any d) { onDestroy(); });
 
-    m_surface = CWLSurface::create();
+    surface = CWLSurface::create();
 }
 
 CLayerSurface::~CLayerSurface() {
     if (!g_pHyprOpenGL)
         return;
 
-    if (m_surface)
-        m_surface->unassign();
+    if (surface)
+        surface->unassign();
     g_pHyprRenderer->makeEGLCurrent();
-    std::erase_if(g_pHyprOpenGL->m_layerFramebuffers, [&](const auto& other) { return other.first.expired() || other.first.lock() == m_self.lock(); });
+    std::erase_if(g_pHyprOpenGL->m_mLayerFramebuffers, [&](const auto& other) { return other.first.expired() || other.first.lock() == self.lock(); });
 
-    for (auto const& mon : g_pCompositor->m_realMonitors) {
-        for (auto& lsl : mon->m_layerSurfaceLayers) {
+    for (auto const& mon : g_pCompositor->m_vRealMonitors) {
+        for (auto& lsl : mon->m_aLayerSurfaceLayers) {
             std::erase_if(lsl, [this](auto& ls) { return ls.expired() || ls.get() == this; });
         }
     }
 }
 
 void CLayerSurface::onDestroy() {
-    Debug::log(LOG, "LayerSurface {:x} destroyed", (uintptr_t)m_layerSurface.get());
+    Debug::log(LOG, "LayerSurface {:x} destroyed", (uintptr_t)layerSurface.get());
 
-    const auto PMONITOR = m_monitor.lock();
+    const auto PMONITOR = monitor.lock();
 
     if (!PMONITOR)
         Debug::log(WARN, "Layersurface destroyed on an invalid monitor (removed?)");
 
-    if (!m_fadingOut) {
-        if (m_mapped) {
+    if (!fadingOut) {
+        if (mapped) {
             Debug::log(LOG, "Forcing an unmap of a LS that did a straight destroy!");
             onUnmap();
         } else {
             Debug::log(LOG, "Removing LayerSurface that wasn't mapped.");
-            if (m_alpha)
-                m_alpha->setValueAndWarp(0.f);
-            m_fadingOut = true;
-            g_pCompositor->addToFadingOutSafe(m_self.lock());
+            if (alpha)
+                alpha->setValueAndWarp(0.f);
+            fadingOut = true;
+            g_pCompositor->addToFadingOutSafe(self.lock());
         }
     }
 
-    m_popupHead.reset();
+    popupHead.reset();
 
-    m_noProcess = true;
+    noProcess = true;
 
     // rearrange to fix the reserved areas
     if (PMONITOR) {
-        g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->m_id);
-        PMONITOR->m_scheduledRecalc = true;
+        g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
+        PMONITOR->scheduledRecalc = true;
 
         // and damage
-        CBox geomFixed = {m_geometry.x + PMONITOR->m_position.x, m_geometry.y + PMONITOR->m_position.y, m_geometry.width, m_geometry.height};
+        CBox geomFixed = {geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y, geometry.width, geometry.height};
         g_pHyprRenderer->damageBox(geomFixed);
     }
 
-    m_readyToDelete = true;
-    m_layerSurface.reset();
-    if (m_surface)
-        m_surface->unassign();
+    readyToDelete = true;
+    layerSurface.reset();
+    if (surface)
+        surface->unassign();
 
-    m_listeners.unmap.reset();
-    m_listeners.destroy.reset();
-    m_listeners.map.reset();
-    m_listeners.commit.reset();
+    listeners.unmap.reset();
+    listeners.destroy.reset();
+    listeners.map.reset();
+    listeners.commit.reset();
 }
 
 void CLayerSurface::onMap() {
-    Debug::log(LOG, "LayerSurface {:x} mapped", (uintptr_t)m_layerSurface.get());
+    Debug::log(LOG, "LayerSurface {:x} mapped", (uintptr_t)layerSurface.get());
 
-    m_mapped        = true;
-    m_interactivity = m_layerSurface->m_current.interactivity;
+    mapped        = true;
+    interactivity = layerSurface->current.interactivity;
 
-    m_layerSurface->m_surface->map();
+    layerSurface->surface->map();
 
     // this layer might be re-mapped.
-    m_fadingOut = false;
-    g_pCompositor->removeFromFadingOutSafe(m_self.lock());
+    fadingOut = false;
+    g_pCompositor->removeFromFadingOutSafe(self.lock());
 
     // fix if it changed its mon
-    const auto PMONITOR = m_monitor.lock();
+    const auto PMONITOR = monitor.lock();
 
     if (!PMONITOR)
         return;
 
     applyRules();
 
-    PMONITOR->m_scheduledRecalc = true;
+    PMONITOR->scheduledRecalc = true;
 
-    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->m_id);
+    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
 
-    m_surface->resource()->enter(PMONITOR->m_self.lock());
+    surface->resource()->enter(PMONITOR->self.lock());
 
-    const bool ISEXCLUSIVE = m_layerSurface->m_current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE;
+    const bool ISEXCLUSIVE = layerSurface->current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE;
 
     if (ISEXCLUSIVE)
-        g_pInputManager->m_exclusiveLSes.push_back(m_self);
+        g_pInputManager->m_dExclusiveLSes.push_back(self);
 
     const bool GRABSFOCUS = ISEXCLUSIVE ||
-        (m_layerSurface->m_current.interactivity != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE &&
+        (layerSurface->current.interactivity != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE &&
          // don't focus if constrained
-         (g_pSeatManager->m_mouse.expired() || !g_pInputManager->isConstrained()));
+         (g_pSeatManager->mouse.expired() || !g_pInputManager->isConstrained()));
 
     if (GRABSFOCUS) {
         // TODO: use the new superb really very cool grab
         g_pSeatManager->setGrab(nullptr);
         g_pInputManager->releaseAllMouseButtons();
-        g_pCompositor->focusSurface(m_surface->resource());
+        g_pCompositor->focusSurface(surface->resource());
 
-        const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(m_geometry.x + PMONITOR->m_position.x, m_geometry.y + PMONITOR->m_position.y);
-        g_pSeatManager->setPointerFocus(m_surface->resource(), LOCAL);
-        g_pInputManager->m_emptyFocusCursorSet = false;
+        const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y);
+        g_pSeatManager->setPointerFocus(surface->resource(), LOCAL);
+        g_pInputManager->m_bEmptyFocusCursorSet = false;
     }
 
-    m_position = Vector2D(m_geometry.x, m_geometry.y);
+    position = Vector2D(geometry.x, geometry.y);
 
-    CBox geomFixed = {m_geometry.x + PMONITOR->m_position.x, m_geometry.y + PMONITOR->m_position.y, m_geometry.width, m_geometry.height};
+    CBox geomFixed = {geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y, geometry.width, geometry.height};
     g_pHyprRenderer->damageBox(geomFixed);
-    const bool FULLSCREEN = PMONITOR->m_activeWorkspace && PMONITOR->m_activeWorkspace->m_hasFullscreenWindow && PMONITOR->m_activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN;
+    const bool FULLSCREEN = PMONITOR->activeWorkspace && PMONITOR->activeWorkspace->m_bHasFullscreenWindow && PMONITOR->activeWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN;
 
-    startAnimation(!(m_layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP && FULLSCREEN && !GRABSFOCUS));
-    m_readyToDelete = false;
-    m_fadingOut     = false;
+    startAnimation(!(layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP && FULLSCREEN && !GRABSFOCUS));
+    readyToDelete = false;
+    fadingOut     = false;
 
-    g_pEventManager->postEvent(SHyprIPCEvent{.event = "openlayer", .data = m_namespace});
-    EMIT_HOOK_EVENT("openLayer", m_self.lock());
+    g_pEventManager->postEvent(SHyprIPCEvent{"openlayer", szNamespace});
+    EMIT_HOOK_EVENT("openLayer", self.lock());
 
-    g_pCompositor->setPreferredScaleForSurface(m_surface->resource(), PMONITOR->m_scale);
-    g_pCompositor->setPreferredTransformForSurface(m_surface->resource(), PMONITOR->m_transform);
+    g_pCompositor->setPreferredScaleForSurface(surface->resource(), PMONITOR->scale);
+    g_pCompositor->setPreferredTransformForSurface(surface->resource(), PMONITOR->transform);
 }
 
 void CLayerSurface::onUnmap() {
-    Debug::log(LOG, "LayerSurface {:x} unmapped", (uintptr_t)m_layerSurface.get());
+    Debug::log(LOG, "LayerSurface {:x} unmapped", (uintptr_t)layerSurface.get());
 
-    g_pEventManager->postEvent(SHyprIPCEvent{.event = "closelayer", .data = m_layerSurface->m_layerNamespace});
-    EMIT_HOOK_EVENT("closeLayer", m_self.lock());
+    g_pEventManager->postEvent(SHyprIPCEvent{"closelayer", layerSurface->layerNamespace});
+    EMIT_HOOK_EVENT("closeLayer", self.lock());
 
-    std::erase_if(g_pInputManager->m_exclusiveLSes, [this](const auto& other) { return !other || other == m_self; });
+    std::erase_if(g_pInputManager->m_dExclusiveLSes, [this](const auto& other) { return !other.lock() || other.lock() == self.lock(); });
 
-    if (!m_monitor || g_pCompositor->m_unsafeState) {
+    if (!monitor || g_pCompositor->m_bUnsafeState) {
         Debug::log(WARN, "Layersurface unmapping on invalid monitor (removed?) ignoring.");
 
-        g_pCompositor->addToFadingOutSafe(m_self.lock());
+        g_pCompositor->addToFadingOutSafe(self.lock());
 
-        m_mapped = false;
-        if (m_layerSurface && m_layerSurface->m_surface)
-            m_layerSurface->m_surface->unmap();
+        mapped = false;
+        if (layerSurface && layerSurface->surface)
+            layerSurface->surface->unmap();
 
         startAnimation(false);
         return;
     }
 
-    // end any pending animations so that snapshot has right dimensions
-    m_realPosition->warp();
-    m_realSize->warp();
-
     // make a snapshot and start fade
-    g_pHyprRenderer->makeLayerSnapshot(m_self.lock());
+    g_pHyprRenderer->makeLayerSnapshot(self.lock());
 
     startAnimation(false);
 
-    m_mapped = false;
-    if (m_layerSurface && m_layerSurface->m_surface)
-        m_layerSurface->m_surface->unmap();
+    mapped = false;
+    if (layerSurface && layerSurface->surface)
+        layerSurface->surface->unmap();
 
-    g_pCompositor->addToFadingOutSafe(m_self.lock());
+    g_pCompositor->addToFadingOutSafe(self.lock());
 
-    const auto PMONITOR = m_monitor.lock();
+    const auto PMONITOR = monitor.lock();
 
-    const bool WASLASTFOCUS = g_pSeatManager->m_state.keyboardFocus == m_surface->resource() || g_pSeatManager->m_state.pointerFocus == m_surface->resource();
+    const bool WASLASTFOCUS = g_pSeatManager->state.keyboardFocus == surface->resource() || g_pSeatManager->state.pointerFocus == surface->resource();
 
     if (!PMONITOR)
         return;
 
     // refocus if needed
     //                                vvvvvvvvvvvvv if there is a last focus and the last focus is not keyboard focusable, fallback to window
-    if (WASLASTFOCUS || (g_pCompositor->m_lastFocus && g_pCompositor->m_lastFocus->m_hlSurface && !g_pCompositor->m_lastFocus->m_hlSurface->keyboardFocusable())) {
-        if (!g_pInputManager->refocusLastWindow(PMONITOR))
-            g_pInputManager->refocus();
-    } else if (g_pCompositor->m_lastFocus && g_pCompositor->m_lastFocus != m_surface->resource())
-        g_pSeatManager->setKeyboardFocus(g_pCompositor->m_lastFocus.lock());
+    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 && g_pCompositor->m_pLastFocus != surface->resource())
+        g_pSeatManager->setKeyboardFocus(g_pCompositor->m_pLastFocus.lock());
 
-    CBox geomFixed = {m_geometry.x + PMONITOR->m_position.x, m_geometry.y + PMONITOR->m_position.y, m_geometry.width, m_geometry.height};
+    CBox geomFixed = {geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y, geometry.width, geometry.height};
     g_pHyprRenderer->damageBox(geomFixed);
 
-    geomFixed = {m_geometry.x + (int)PMONITOR->m_position.x, m_geometry.y + (int)PMONITOR->m_position.y, (int)m_layerSurface->m_surface->m_current.size.x,
-                 (int)m_layerSurface->m_surface->m_current.size.y};
+    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_pInputManager->simulateMouseMovement();
 
-    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->m_id);
+    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
 }
 
 void CLayerSurface::onCommit() {
-    if (!m_layerSurface)
+    if (!layerSurface)
         return;
 
-    if (!m_mapped) {
+    if (!mapped) {
         // we're re-mapping if this is the case
-        if (m_layerSurface->m_surface && !m_layerSurface->m_surface->m_current.texture) {
-            m_fadingOut = false;
-            m_geometry  = {};
+        if (layerSurface->surface && !layerSurface->surface->current.texture) {
+            fadingOut = false;
+            geometry  = {};
             g_pHyprRenderer->arrangeLayersForMonitor(monitorID());
         }
 
         return;
     }
 
-    const auto PMONITOR = m_monitor.lock();
+    const auto PMONITOR = monitor.lock();
 
     if (!PMONITOR)
         return;
 
-    if (m_layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND || m_layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM)
+    if (layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND || layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM)
         g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR); // so that blur is recalc'd
 
-    CBox geomFixed = {m_geometry.x, m_geometry.y, m_geometry.width, m_geometry.height};
+    CBox geomFixed = {geometry.x, geometry.y, geometry.width, geometry.height};
     g_pHyprRenderer->damageBox(geomFixed);
 
-    if (m_layerSurface->m_current.committed != 0) {
-        if (m_layerSurface->m_current.committed & CLayerShellResource::eCommittedState::STATE_LAYER) {
+    if (layerSurface->current.committed != 0) {
+        if (layerSurface->current.committed & CLayerShellResource::eCommittedState::STATE_LAYER) {
 
-            for (auto it = PMONITOR->m_layerSurfaceLayers[m_layer].begin(); it != PMONITOR->m_layerSurfaceLayers[m_layer].end(); it++) {
-                if (*it == m_self) {
-                    if (m_layerSurface->m_current.layer == m_layer)
+            for (auto it = PMONITOR->m_aLayerSurfaceLayers[layer].begin(); it != PMONITOR->m_aLayerSurfaceLayers[layer].end(); it++) {
+                if (*it == self) {
+                    if (layerSurface->current.layer == layer)
                         break;
-                    PMONITOR->m_layerSurfaceLayers[m_layerSurface->m_current.layer].emplace_back(*it);
-                    PMONITOR->m_layerSurfaceLayers[m_layer].erase(it);
+                    PMONITOR->m_aLayerSurfaceLayers[layerSurface->current.layer].emplace_back(*it);
+                    PMONITOR->m_aLayerSurfaceLayers[layer].erase(it);
                     break;
                 }
             }
 
-            m_layer = m_layerSurface->m_current.layer;
+            layer = layerSurface->current.layer;
 
-            if (m_layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND || m_layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM)
+            if (layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND || layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM)
                 g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR); // so that blur is recalc'd
         }
 
-        g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->m_id);
+        g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
 
-        PMONITOR->m_scheduledRecalc = true;
+        PMONITOR->scheduledRecalc = true;
     } else {
-        m_position = Vector2D(m_geometry.x, m_geometry.y);
+        position = Vector2D(geometry.x, geometry.y);
 
         // update geom if it changed
-        if (m_layerSurface->m_surface->m_current.scale == 1 && PMONITOR->m_scale != 1.f && m_layerSurface->m_surface->m_current.viewport.hasDestination) {
+        if (layerSurface->surface->current.scale == 1 && PMONITOR->scale != 1.f && layerSurface->surface->current.viewport.hasDestination) {
             // fractional scaling. Dirty hack.
-            m_geometry = {m_geometry.pos(), m_layerSurface->m_surface->m_current.viewport.destination};
+            geometry = {geometry.pos(), layerSurface->surface->current.viewport.destination};
         } else {
             // this is because some apps like e.g. rofi-lbonn can't fucking use the protocol correctly.
-            m_geometry = {m_geometry.pos(), m_layerSurface->m_surface->m_current.size};
+            geometry = {geometry.pos(), layerSurface->surface->current.size};
         }
     }
 
-    if (m_realPosition->goal() != m_geometry.pos()) {
-        if (m_realPosition->isBeingAnimated())
-            *m_realPosition = m_geometry.pos();
+    if (realPosition->goal() != geometry.pos()) {
+        if (realPosition->isBeingAnimated())
+            *realPosition = geometry.pos();
         else
-            m_realPosition->setValueAndWarp(m_geometry.pos());
+            realPosition->setValueAndWarp(geometry.pos());
     }
-    if (m_realSize->goal() != m_geometry.size()) {
-        if (m_realSize->isBeingAnimated())
-            *m_realSize = m_geometry.size();
+    if (realSize->goal() != geometry.size()) {
+        if (realSize->isBeingAnimated())
+            *realSize = geometry.size();
         else
-            m_realSize->setValueAndWarp(m_geometry.size());
+            realSize->setValueAndWarp(geometry.size());
     }
 
-    if (m_mapped && (m_layerSurface->m_current.committed & CLayerShellResource::eCommittedState::STATE_INTERACTIVITY)) {
+    if (mapped && (layerSurface->current.committed & CLayerShellResource::eCommittedState::STATE_INTERACTIVITY)) {
         bool WASLASTFOCUS = false;
-        m_layerSurface->m_surface->breadthfirst(
-            [&WASLASTFOCUS](SP<CWLSurfaceResource> surf, const Vector2D& offset, void* data) { WASLASTFOCUS = WASLASTFOCUS || g_pSeatManager->m_state.keyboardFocus == surf; },
+        layerSurface->surface->breadthfirst(
+            [&WASLASTFOCUS](SP<CWLSurfaceResource> surf, const Vector2D& offset, void* data) { WASLASTFOCUS = WASLASTFOCUS || g_pSeatManager->state.keyboardFocus == surf; },
             nullptr);
-        if (!WASLASTFOCUS && m_popupHead) {
-            m_popupHead->breadthfirst(
+        if (!WASLASTFOCUS && popupHead) {
+            popupHead->breadthfirst(
                 [&WASLASTFOCUS](WP<CPopup> popup, void* data) {
-                    WASLASTFOCUS = WASLASTFOCUS || (popup->m_wlSurface && g_pSeatManager->m_state.keyboardFocus == popup->m_wlSurface->resource());
+                    WASLASTFOCUS = WASLASTFOCUS || (popup->m_pWLSurface && g_pSeatManager->state.keyboardFocus == popup->m_pWLSurface->resource());
                 },
                 nullptr);
         }
-        const bool WASEXCLUSIVE = m_interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE;
-        const bool ISEXCLUSIVE  = m_layerSurface->m_current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE;
+        const bool WASEXCLUSIVE = interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE;
+        const bool ISEXCLUSIVE  = layerSurface->current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE;
 
         if (!WASEXCLUSIVE && ISEXCLUSIVE)
-            g_pInputManager->m_exclusiveLSes.push_back(m_self);
+            g_pInputManager->m_dExclusiveLSes.push_back(self);
         else if (WASEXCLUSIVE && !ISEXCLUSIVE)
-            std::erase_if(g_pInputManager->m_exclusiveLSes, [this](const auto& other) { return !other.lock() || other.lock() == m_self.lock(); });
+            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 && m_layerSurface->m_current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE) {
+        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(m_monitor.lock());
-        } else if (WASLASTFOCUS && WASEXCLUSIVE && m_layerSurface->m_current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND) {
+            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);
             g_pInputManager->releaseAllMouseButtons();
-            g_pCompositor->focusSurface(m_surface->resource());
+            g_pCompositor->focusSurface(surface->resource());
 
-            const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(m_geometry.x + PMONITOR->m_position.x, m_geometry.y + PMONITOR->m_position.y);
-            g_pSeatManager->setPointerFocus(m_surface->resource(), LOCAL);
-            g_pInputManager->m_emptyFocusCursorSet = false;
+            const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y);
+            g_pSeatManager->setPointerFocus(surface->resource(), LOCAL);
+            g_pInputManager->m_bEmptyFocusCursorSet = false;
         }
     }
 
-    m_interactivity = m_layerSurface->m_current.interactivity;
+    interactivity = layerSurface->current.interactivity;
 
-    g_pHyprRenderer->damageSurface(m_surface->resource(), m_position.x, m_position.y);
+    g_pHyprRenderer->damageSurface(surface->resource(), position.x, position.y);
 
-    g_pCompositor->setPreferredScaleForSurface(m_surface->resource(), PMONITOR->m_scale);
-    g_pCompositor->setPreferredTransformForSurface(m_surface->resource(), PMONITOR->m_transform);
+    g_pCompositor->setPreferredScaleForSurface(surface->resource(), PMONITOR->scale);
+    g_pCompositor->setPreferredTransformForSurface(surface->resource(), PMONITOR->transform);
 }
 
 void CLayerSurface::applyRules() {
-    m_noAnimations     = false;
-    m_forceBlur        = false;
-    m_ignoreAlpha      = false;
-    m_ignoreAlphaValue = 0.f;
-    m_dimAround        = false;
-    m_xray             = -1;
-    m_animationStyle.reset();
+    noAnimations     = false;
+    forceBlur        = false;
+    ignoreAlpha      = false;
+    ignoreAlphaValue = 0.f;
+    dimAround        = false;
+    xray             = -1;
+    animationStyle.reset();
 
-    for (auto const& rule : g_pConfigManager->getMatchingRules(m_self.lock())) {
-        switch (rule->m_ruleType) {
+    for (auto const& rule : g_pConfigManager->getMatchingRules(self.lock())) {
+        switch (rule->ruleType) {
             case CLayerRule::RULE_NOANIM: {
-                m_noAnimations = true;
+                noAnimations = true;
                 break;
             }
             case CLayerRule::RULE_BLUR: {
-                m_forceBlur = true;
+                forceBlur = true;
                 break;
             }
             case CLayerRule::RULE_BLURPOPUPS: {
-                m_forceBlurPopups = true;
+                forceBlurPopups = true;
                 break;
             }
             case CLayerRule::RULE_IGNOREALPHA:
             case CLayerRule::RULE_IGNOREZERO: {
-                const auto  FIRST_SPACE_POS = rule->m_rule.find_first_of(' ');
+                const auto  FIRST_SPACE_POS = rule->rule.find_first_of(' ');
                 std::string alphaValue      = "";
                 if (FIRST_SPACE_POS != std::string::npos)
-                    alphaValue = rule->m_rule.substr(FIRST_SPACE_POS + 1);
+                    alphaValue = rule->rule.substr(FIRST_SPACE_POS + 1);
 
                 try {
-                    m_ignoreAlpha = true;
+                    ignoreAlpha = true;
                     if (!alphaValue.empty())
-                        m_ignoreAlphaValue = std::stof(alphaValue);
+                        ignoreAlphaValue = std::stof(alphaValue);
                 } catch (...) { Debug::log(ERR, "Invalid value passed to ignoreAlpha"); }
                 break;
             }
             case CLayerRule::RULE_DIMAROUND: {
-                m_dimAround = true;
+                dimAround = true;
                 break;
             }
             case CLayerRule::RULE_XRAY: {
-                CVarList vars{rule->m_rule, 0, ' '};
-                m_xray = configStringToInt(vars[1]).value_or(false);
-
+                CVarList vars{rule->rule, 0, ' '};
+                try {
+                    xray = configStringToInt(vars[1]).value_or(false);
+                } catch (...) {}
                 break;
             }
             case CLayerRule::RULE_ANIMATION: {
-                CVarList vars{rule->m_rule, 2, 's'};
-                m_animationStyle = vars[1];
+                CVarList vars{rule->rule, 2, 's'};
+                animationStyle = vars[1];
                 break;
             }
             case CLayerRule::RULE_ORDER: {
-                CVarList vars{rule->m_rule, 2, 's'};
+                CVarList vars{rule->rule, 2, 's'};
                 try {
-                    m_order = std::stoi(vars[1]);
+                    order = std::stoi(vars[1]);
                 } catch (...) { Debug::log(ERR, "Invalid value passed to order"); }
                 break;
             }
-            case CLayerRule::RULE_ABOVELOCK: {
-                m_aboveLockscreen = true;
-
-                CVarList vars{rule->m_rule, 0, ' '};
-                m_aboveLockscreenInteractable = configStringToInt(vars[1]).value_or(false);
-
-                break;
-            }
             default: break;
         }
     }
@@ -452,19 +440,19 @@ void CLayerSurface::applyRules() {
 
 void CLayerSurface::startAnimation(bool in, bool instant) {
     if (in) {
-        m_realPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersIn"));
-        m_realSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersIn"));
-        m_alpha->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn"));
+        realPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersIn"));
+        realSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersIn"));
+        alpha->setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn"));
     } else {
-        m_realPosition->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersOut"));
-        m_realSize->setConfig(g_pConfigManager->getAnimationPropertyConfig("layersOut"));
-        m_alpha->setConfig(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 = m_animationStyle.value_or(m_realPosition->getStyle());
+    const auto ANIMSTYLE = animationStyle.value_or(realPosition->getStyle());
     if (ANIMSTYLE.starts_with("slide")) {
         // get closest edge
-        const auto MIDDLE = m_geometry.middle();
+        const auto MIDDLE = geometry.middle();
 
         const auto PMONITOR = g_pCompositor->getMonitorFromVector(MIDDLE);
 
@@ -484,10 +472,10 @@ void CLayerSurface::startAnimation(bool in, bool instant) {
         }
 
         const std::array<Vector2D, 4> edgePoints = {
-            PMONITOR->m_position + Vector2D{PMONITOR->m_size.x / 2, 0.0},
-            PMONITOR->m_position + Vector2D{PMONITOR->m_size.x / 2, PMONITOR->m_size.y},
-            PMONITOR->m_position + Vector2D{0.0, PMONITOR->m_size.y},
-            PMONITOR->m_position + Vector2D{PMONITOR->m_size.x, PMONITOR->m_size.y / 2},
+            PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x / 2, 0.0},
+            PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x / 2, PMONITOR->vecSize.y},
+            PMONITOR->vecPosition + Vector2D{0.0, PMONITOR->vecSize.y},
+            PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x, PMONITOR->vecSize.y / 2},
         };
 
         float closest = std::numeric_limits<float>::max();
@@ -502,38 +490,38 @@ void CLayerSurface::startAnimation(bool in, bool instant) {
             }
         }
 
-        m_realSize->setValueAndWarp(m_geometry.size());
-        m_alpha->setValueAndWarp(in ? 0.f : 1.f);
-        *m_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;
 
         switch (leader) {
             case 0:
                 // TOP
-                prePos = {m_geometry.x, PMONITOR->m_position.y - m_geometry.h};
+                prePos = {geometry.x, PMONITOR->vecPosition.y - geometry.h};
                 break;
             case 1:
                 // BOTTOM
-                prePos = {m_geometry.x, PMONITOR->m_position.y + PMONITOR->m_size.y};
+                prePos = {geometry.x, PMONITOR->vecPosition.y + PMONITOR->vecSize.y};
                 break;
             case 2:
                 // LEFT
-                prePos = {PMONITOR->m_position.x - m_geometry.w, m_geometry.y};
+                prePos = {PMONITOR->vecPosition.x - geometry.w, geometry.y};
                 break;
             case 3:
                 // RIGHT
-                prePos = {PMONITOR->m_position.x + PMONITOR->m_size.x, m_geometry.y};
+                prePos = {PMONITOR->vecPosition.x + PMONITOR->vecSize.x, geometry.y};
                 break;
             default: UNREACHABLE();
         }
 
         if (in) {
-            m_realPosition->setValueAndWarp(prePos);
-            *m_realPosition = m_geometry.pos();
+            realPosition->setValueAndWarp(prePos);
+            *realPosition = geometry.pos();
         } else {
-            m_realPosition->setValueAndWarp(m_geometry.pos());
-            *m_realPosition = prePos;
+            realPosition->setValueAndWarp(geometry.pos());
+            *realPosition = prePos;
         }
 
     } else if (ANIMSTYLE.starts_with("popin")) {
@@ -549,62 +537,62 @@ void CLayerSurface::startAnimation(bool in, bool instant) {
 
         minPerc *= 0.01;
 
-        const auto GOALSIZE = (m_geometry.size() * minPerc).clamp({5, 5});
-        const auto GOALPOS  = m_geometry.pos() + (m_geometry.size() - GOALSIZE) / 2.f;
+        const auto GOALSIZE = (geometry.size() * minPerc).clamp({5, 5});
+        const auto GOALPOS  = geometry.pos() + (geometry.size() - GOALSIZE) / 2.f;
 
-        m_alpha->setValueAndWarp(in ? 0.f : 1.f);
-        *m_alpha = in ? 1.f : 0.f;
+        alpha->setValueAndWarp(in ? 0.f : 1.f);
+        *alpha = in ? 1.f : 0.f;
 
         if (in) {
-            m_realSize->setValueAndWarp(GOALSIZE);
-            m_realPosition->setValueAndWarp(GOALPOS);
-            *m_realSize     = m_geometry.size();
-            *m_realPosition = m_geometry.pos();
+            realSize->setValueAndWarp(GOALSIZE);
+            realPosition->setValueAndWarp(GOALPOS);
+            *realSize     = geometry.size();
+            *realPosition = geometry.pos();
         } else {
-            m_realSize->setValueAndWarp(m_geometry.size());
-            m_realPosition->setValueAndWarp(m_geometry.pos());
-            *m_realSize     = GOALSIZE;
-            *m_realPosition = GOALPOS;
+            realSize->setValueAndWarp(geometry.size());
+            realPosition->setValueAndWarp(geometry.pos());
+            *realSize     = GOALSIZE;
+            *realPosition = GOALPOS;
         }
     } else {
         // fade
-        m_realPosition->setValueAndWarp(m_geometry.pos());
-        m_realSize->setValueAndWarp(m_geometry.size());
-        *m_alpha = in ? 1.f : 0.f;
+        realPosition->setValueAndWarp(geometry.pos());
+        realSize->setValueAndWarp(geometry.size());
+        *alpha = in ? 1.f : 0.f;
     }
 
     if (!in)
-        m_fadingOut = true;
+        fadingOut = true;
 }
 
 bool CLayerSurface::isFadedOut() {
-    if (!m_fadingOut)
+    if (!fadingOut)
         return false;
 
-    return !m_realPosition->isBeingAnimated() && !m_realSize->isBeingAnimated() && !m_alpha->isBeingAnimated();
+    return !realPosition->isBeingAnimated() && !realSize->isBeingAnimated() && !alpha->isBeingAnimated();
 }
 
 int CLayerSurface::popupsCount() {
-    if (!m_layerSurface || !m_mapped || m_fadingOut)
+    if (!layerSurface || !mapped || fadingOut)
         return 0;
 
     int no = -1; // we have one dummy
-    m_popupHead->breadthfirst([](WP<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 m_monitor ? m_monitor->m_id : MONITOR_INVALID;
+    return monitor ? monitor->ID : MONITOR_INVALID;
 }
 
 pid_t CLayerSurface::getPID() {
     pid_t PID = -1;
 
-    if (!m_layerSurface || !m_layerSurface->m_surface || !m_layerSurface->m_surface->getResource() || !m_layerSurface->m_surface->getResource()->resource() ||
-        !m_layerSurface->m_surface->getResource()->resource()->client)
+    if (!layerSurface || !layerSurface->surface || !layerSurface->surface->getResource() || !layerSurface->surface->getResource()->resource() ||
+        !layerSurface->surface->getResource()->resource()->client)
         return -1;
 
-    wl_client_get_credentials(m_layerSurface->m_surface->getResource()->resource()->client, &PID, nullptr, nullptr);
+    wl_client_get_credentials(layerSurface->surface->getResource()->resource()->client, &PID, nullptr, nullptr);
 
     return PID;
 }

src/desktop/LayerSurface.hpp

@@ -22,45 +22,44 @@ class CLayerSurface {
     bool                    isFadedOut();
     int                     popupsCount();
 
-    PHLANIMVAR<Vector2D>    m_realPosition;
-    PHLANIMVAR<Vector2D>    m_realSize;
-    PHLANIMVAR<float>       m_alpha;
+    PHLANIMVAR<Vector2D>    realPosition;
+    PHLANIMVAR<Vector2D>    realSize;
+    PHLANIMVAR<float>       alpha;
 
-    WP<CLayerShellResource> m_layerSurface;
+    WP<CLayerShellResource> layerSurface;
+    wl_list                 link;
 
     // the header providing the enum type cannot be imported here
-    int                        m_interactivity = 0;
+    int                        interactivity = 0;
 
-    SP<CWLSurface>             m_surface;
+    SP<CWLSurface>             surface;
 
-    bool                       m_mapped = false;
-    uint32_t                   m_layer  = 0;
+    bool                       mapped = false;
+    uint32_t                   layer  = 0;
 
-    PHLMONITORREF              m_monitor;
+    PHLMONITORREF              monitor;
 
-    bool                       m_fadingOut     = false;
-    bool                       m_readyToDelete = false;
-    bool                       m_noProcess     = false;
-    bool                       m_noAnimations  = false;
+    bool                       fadingOut     = false;
+    bool                       readyToDelete = false;
+    bool                       noProcess     = false;
+    bool                       noAnimations  = false;
 
-    bool                       m_forceBlur                   = false;
-    bool                       m_forceBlurPopups             = false;
-    int64_t                    m_xray                        = -1;
-    bool                       m_ignoreAlpha                 = false;
-    float                      m_ignoreAlphaValue            = 0.f;
-    bool                       m_dimAround                   = false;
-    int64_t                    m_order                       = 0;
-    bool                       m_aboveLockscreen             = false;
-    bool                       m_aboveLockscreenInteractable = false;
+    bool                       forceBlur        = false;
+    bool                       forceBlurPopups  = false;
+    int64_t                    xray             = -1;
+    bool                       ignoreAlpha      = false;
+    float                      ignoreAlphaValue = 0.f;
+    bool                       dimAround        = false;
+    int64_t                    order            = 0;
 
-    std::optional<std::string> m_animationStyle;
+    std::optional<std::string> animationStyle;
 
-    PHLLSREF                   m_self;
+    PHLLSREF                   self;
 
-    CBox                       m_geometry = {0, 0, 0, 0};
-    Vector2D                   m_position;
-    std::string                m_namespace = "";
-    UP<CPopup>                 m_popupHead;
+    CBox                       geometry = {0, 0, 0, 0};
+    Vector2D                   position;
+    std::string                szNamespace = "";
+    UP<CPopup>                 popupHead;
 
     pid_t                      getPID();
 
@@ -76,12 +75,12 @@ class CLayerSurface {
         CHyprSignalListener map;
         CHyprSignalListener unmap;
         CHyprSignalListener commit;
-    } m_listeners;
+    } listeners;
 
     void registerCallbacks();
 
     // For the list lookup
     bool operator==(const CLayerSurface& rhs) const {
-        return m_layerSurface == rhs.m_layerSurface && m_monitor == rhs.m_monitor;
+        return layerSurface == rhs.layerSurface && monitor == rhs.monitor;
     }
 };

src/desktop/Popup.cpp

@@ -5,6 +5,7 @@
 #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"
@@ -13,31 +14,31 @@
 
 UP<CPopup> CPopup::create(PHLWINDOW pOwner) {
     auto popup            = UP<CPopup>(new CPopup());
-    popup->m_windowOwner = pOwner;
-    popup->m_self        = popup;
+    popup->m_pWindowOwner = pOwner;
+    popup->m_pSelf        = popup;
     popup->initAllSignals();
     return popup;
 }
 
 UP<CPopup> CPopup::create(PHLLS pOwner) {
     auto popup           = UP<CPopup>(new CPopup());
-    popup->m_layerOwner = pOwner;
-    popup->m_self       = popup;
+    popup->m_pLayerOwner = pOwner;
+    popup->m_pSelf       = popup;
     popup->initAllSignals();
     return popup;
 }
 
 UP<CPopup> CPopup::create(SP<CXDGPopupResource> resource, WP<CPopup> pOwner) {
     auto popup            = UP<CPopup>(new CPopup());
-    popup->m_resource    = resource;
-    popup->m_windowOwner = pOwner->m_windowOwner;
-    popup->m_layerOwner  = pOwner->m_layerOwner;
-    popup->m_parent      = pOwner;
-    popup->m_self        = popup;
-    popup->m_wlSurface   = CWLSurface::create();
-    popup->m_wlSurface->assign(resource->m_surface->m_surface.lock(), popup.get());
+    popup->m_pResource    = resource;
+    popup->m_pWindowOwner = pOwner->m_pWindowOwner;
+    popup->m_pLayerOwner  = pOwner->m_pLayerOwner;
+    popup->m_pParent      = pOwner;
+    popup->m_pSelf        = popup;
+    popup->m_pWLSurface   = CWLSurface::create();
+    popup->m_pWLSurface->assign(resource->surface->surface.lock(), popup.get());
 
-    popup->m_lastSize = resource->m_surface->m_current.geometry.size();
+    popup->m_vLastSize = resource->surface->current.geometry.size();
     popup->reposition();
 
     popup->initAllSignals();
@@ -45,114 +46,104 @@ UP<CPopup> CPopup::create(SP<CXDGPopupResource> resource, WP<CPopup> pOwner) {
 }
 
 CPopup::~CPopup() {
-    if (m_wlSurface)
-        m_wlSurface->unassign();
+    if (m_pWLSurface)
+        m_pWLSurface->unassign();
 }
 
 void CPopup::initAllSignals() {
 
-    if (!m_resource) {
-        if (!m_windowOwner.expired())
-            m_listeners.newPopup =
-                m_windowOwner->m_xdgSurface->m_events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast<SP<CXDGPopupResource>>(d)); });
-        else if (!m_layerOwner.expired())
-            m_listeners.newPopup =
-                m_layerOwner->m_layerSurface->m_events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast<SP<CXDGPopupResource>>(d)); });
+    if (!m_pResource) {
+        if (!m_pWindowOwner.expired())
+            listeners.newPopup = m_pWindowOwner->m_pXDGSurface->events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast<SP<CXDGPopupResource>>(d)); });
+        else if (!m_pLayerOwner.expired())
+            listeners.newPopup = m_pLayerOwner->layerSurface->events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast<SP<CXDGPopupResource>>(d)); });
         else
             ASSERT(false);
 
         return;
     }
 
-    m_listeners.reposition = m_resource->m_events.reposition.registerListener([this](std::any d) { this->onReposition(); });
-    m_listeners.map        = m_resource->m_surface->m_events.map.registerListener([this](std::any d) { this->onMap(); });
-    m_listeners.unmap      = m_resource->m_surface->m_events.unmap.registerListener([this](std::any d) { this->onUnmap(); });
-    m_listeners.dismissed  = m_resource->m_events.dismissed.registerListener([this](std::any d) { this->onUnmap(); });
-    m_listeners.destroy    = m_resource->m_surface->m_events.destroy.registerListener([this](std::any d) { this->onDestroy(); });
-    m_listeners.commit     = m_resource->m_surface->m_events.commit.registerListener([this](std::any d) { this->onCommit(); });
-    m_listeners.newPopup   = m_resource->m_surface->m_events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast<SP<CXDGPopupResource>>(d)); });
+    listeners.reposition = m_pResource->events.reposition.registerListener([this](std::any d) { this->onReposition(); });
+    listeners.map        = m_pResource->surface->events.map.registerListener([this](std::any d) { this->onMap(); });
+    listeners.unmap      = m_pResource->surface->events.unmap.registerListener([this](std::any d) { this->onUnmap(); });
+    listeners.dismissed  = m_pResource->events.dismissed.registerListener([this](std::any d) { this->onUnmap(); });
+    listeners.destroy    = m_pResource->surface->events.destroy.registerListener([this](std::any d) { this->onDestroy(); });
+    listeners.commit     = m_pResource->surface->events.commit.registerListener([this](std::any d) { this->onCommit(); });
+    listeners.newPopup   = m_pResource->surface->events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast<SP<CXDGPopupResource>>(d)); });
 }
 
 void CPopup::onNewPopup(SP<CXDGPopupResource> popup) {
-    const auto& POPUP = m_children.emplace_back(CPopup::create(popup, m_self));
-    POPUP->m_self     = POPUP;
+    const auto& POPUP = m_vChildren.emplace_back(CPopup::create(popup, m_pSelf));
+    POPUP->m_pSelf    = POPUP;
     Debug::log(LOG, "New popup at {:x}", (uintptr_t)POPUP);
 }
 
 void CPopup::onDestroy() {
-    m_inert = true;
+    m_bInert = true;
 
-    if (!m_parent)
+    if (!m_pParent)
         return; // head node
 
-    std::erase_if(m_parent->m_children, [this](const auto& other) { return other.get() == this; });
+    std::erase_if(m_pParent->m_vChildren, [this](const auto& other) { return other.get() == this; });
 }
 
 void CPopup::onMap() {
-    if (m_mapped)
+    if (m_bMapped)
         return;
 
-    m_mapped   = true;
-    m_lastSize = m_resource->m_surface->m_surface->m_current.size;
+    m_bMapped   = true;
+    m_vLastSize = m_pResource->surface->surface->current.size;
 
     const auto COORDS   = coordsGlobal();
     const auto PMONITOR = g_pCompositor->getMonitorFromVector(COORDS);
 
-    CBox       box = m_wlSurface->resource()->extends();
+    CBox       box = m_pWLSurface->resource()->extends();
     box.translate(COORDS).expand(4);
     g_pHyprRenderer->damageBox(box);
 
-    m_lastPos = coordsRelativeToParent();
+    m_vLastPos = coordsRelativeToParent();
 
     g_pInputManager->simulateMouseMovement();
 
-    m_subsurfaceHead = CSubsurface::create(m_self);
+    m_pSubsurfaceHead = CSubsurface::create(m_pSelf);
 
     //unconstrain();
     sendScale();
-    m_resource->m_surface->m_surface->enter(PMONITOR->m_self.lock());
+    m_pResource->surface->surface->enter(PMONITOR->self.lock());
 
-    if (!m_layerOwner.expired() && m_layerOwner->m_layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
-        g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_layerOwner->m_layer));
+    if (!m_pLayerOwner.expired() && m_pLayerOwner->layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
+        g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_pLayerOwner->layer));
 }
 
 void CPopup::onUnmap() {
-    if (!m_mapped)
+    if (!m_bMapped)
         return;
 
-    if (!m_resource || !m_resource->m_surface) {
+    if (!m_pResource || !m_pResource->surface) {
         Debug::log(ERR, "CPopup: orphaned (no surface/resource) and unmaps??");
         onDestroy();
         return;
     }
 
-    m_mapped = false;
+    m_bMapped = false;
 
-    // if the popup committed a different size right now, we also need to damage the old size.
-    const Vector2D MAX_DAMAGE_SIZE = {std::max(m_lastSize.x, m_resource->m_surface->m_surface->m_current.size.x),
-                                      std::max(m_lastSize.y, m_resource->m_surface->m_surface->m_current.size.y)};
-
-    m_lastSize = m_resource->m_surface->m_surface->m_current.size;
+    m_vLastSize = m_pResource->surface->surface->current.size;
 
     const auto COORDS = coordsGlobal();
 
-    CBox       box = m_wlSurface->resource()->extends();
+    CBox       box = m_pWLSurface->resource()->extends();
     box.translate(COORDS).expand(4);
     g_pHyprRenderer->damageBox(box);
 
-    // damage the last popup's explicit max size as well
-    box = CBox{COORDS, MAX_DAMAGE_SIZE}.expand(4);
-    g_pHyprRenderer->damageBox(box);
+    m_pSubsurfaceHead.reset();
 
-    m_subsurfaceHead.reset();
-
-    if (!m_layerOwner.expired() && m_layerOwner->m_layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
-        g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_layerOwner->m_layer));
+    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(
         [](WP<CPopup> p, void* data) {
-            if (!p->m_resource)
+            if (!p->m_pResource)
                 return;
 
             auto box = CBox{p->coordsGlobal(), p->size()};
@@ -168,59 +159,59 @@ void CPopup::onUnmap() {
 }
 
 void CPopup::onCommit(bool ignoreSiblings) {
-    if (!m_resource || !m_resource->m_surface) {
+    if (!m_pResource || !m_pResource->surface) {
         Debug::log(ERR, "CPopup: orphaned (no surface/resource) and commits??");
         onDestroy();
         return;
     }
 
-    if (m_resource->m_surface->m_initialCommit) {
-        m_resource->m_surface->scheduleConfigure();
+    if (m_pResource->surface->initialCommit) {
+        m_pResource->surface->scheduleConfigure();
         return;
     }
 
-    if (!m_windowOwner.expired() && (!m_windowOwner->m_isMapped || !m_windowOwner->m_workspace->m_visible)) {
-        m_lastSize = m_resource->m_surface->m_surface->m_current.size;
+    if (!m_pWindowOwner.expired() && (!m_pWindowOwner->m_bIsMapped || !m_pWindowOwner->m_pWorkspace->m_bVisible)) {
+        m_vLastSize = m_pResource->surface->surface->current.size;
 
         static auto PLOGDAMAGE = CConfigValue<Hyprlang::INT>("debug:log_damage");
         if (*PLOGDAMAGE)
-            Debug::log(LOG, "Refusing to commit damage from a subsurface of {} because it's invisible.", m_windowOwner.lock());
+            Debug::log(LOG, "Refusing to commit damage from a subsurface of {} because it's invisible.", m_pWindowOwner.lock());
         return;
     }
 
-    if (!m_resource->m_surface->m_mapped)
+    if (!m_pResource->surface->mapped)
         return;
 
     const auto COORDS      = coordsGlobal();
     const auto COORDSLOCAL = coordsRelativeToParent();
 
-    if (m_lastSize != m_resource->m_surface->m_surface->m_current.size || m_requestedReposition || m_lastPos != COORDSLOCAL) {
-        CBox box = {localToGlobal(m_lastPos), m_lastSize};
+    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);
-        m_lastSize = m_resource->m_surface->m_surface->m_current.size;
-        box        = {COORDS, m_lastSize};
+        m_vLastSize = m_pResource->surface->surface->current.size;
+        box         = {COORDS, m_vLastSize};
         g_pHyprRenderer->damageBox(box);
 
-        m_lastPos = COORDSLOCAL;
+        m_vLastPos = COORDSLOCAL;
     }
 
-    if (!ignoreSiblings && m_subsurfaceHead)
-        m_subsurfaceHead->recheckDamageForSubsurfaces();
+    if (!ignoreSiblings && m_pSubsurfaceHead)
+        m_pSubsurfaceHead->recheckDamageForSubsurfaces();
 
-    g_pHyprRenderer->damageSurface(m_wlSurface->resource(), COORDS.x, COORDS.y);
+    g_pHyprRenderer->damageSurface(m_pWLSurface->resource(), COORDS.x, COORDS.y);
 
-    m_requestedReposition = false;
+    m_bRequestedReposition = false;
 
-    if (!m_layerOwner.expired() && m_layerOwner->m_layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
-        g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_layerOwner->m_layer));
+    if (!m_pLayerOwner.expired() && m_pLayerOwner->layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
+        g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_pLayerOwner->layer));
 }
 
 void CPopup::onReposition() {
     Debug::log(LOG, "Popup {:x} requests reposition", (uintptr_t)this);
 
-    m_requestedReposition = true;
+    m_bRequestedReposition = true;
 
-    m_lastPos = coordsRelativeToParent();
+    m_vLastPos = coordsRelativeToParent();
 
     reposition();
 }
@@ -232,32 +223,32 @@ void CPopup::reposition() {
     if (!PMONITOR)
         return;
 
-    CBox box = {PMONITOR->m_position.x, PMONITOR->m_position.y, PMONITOR->m_size.x, PMONITOR->m_size.y};
-    m_resource->applyPositioning(box, COORDS);
+    CBox box = {PMONITOR->vecPosition.x, PMONITOR->vecPosition.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y};
+    m_pResource->applyPositioning(box, COORDS);
 }
 
 SP<CWLSurface> CPopup::getT1Owner() {
-    if (m_windowOwner)
-        return m_windowOwner->m_wlSurface;
+    if (m_pWindowOwner)
+        return m_pWindowOwner->m_pWLSurface;
     else
-        return m_layerOwner->m_surface;
+        return m_pLayerOwner->surface;
 }
 
 Vector2D CPopup::coordsRelativeToParent() {
     Vector2D offset;
 
-    if (!m_resource)
+    if (!m_pResource)
         return {};
 
-    WP<CPopup> current = m_self;
-    offset -= current->m_resource->m_surface->m_current.geometry.pos();
+    WP<CPopup> current = m_pSelf;
+    offset -= current->m_pResource->surface->current.geometry.pos();
 
-    while (current->m_parent && current->m_resource) {
+    while (current->m_pParent && current->m_pResource) {
 
-        offset += current->m_wlSurface->resource()->m_current.offset;
-        offset += current->m_resource->m_geometry.pos();
+        offset += current->m_pWLSurface->resource()->current.offset;
+        offset += current->m_pResource->geometry.pos();
 
-        current = current->m_parent;
+        current = current->m_pParent;
     }
 
     return offset;
@@ -272,30 +263,30 @@ Vector2D CPopup::localToGlobal(const Vector2D& rel) {
 }
 
 Vector2D CPopup::t1ParentCoords() {
-    if (!m_windowOwner.expired())
-        return m_windowOwner->m_realPosition->value();
-    if (!m_layerOwner.expired())
-        return m_layerOwner->m_realPosition->value();
+    if (!m_pWindowOwner.expired())
+        return m_pWindowOwner->m_vRealPosition->value();
+    if (!m_pLayerOwner.expired())
+        return m_pLayerOwner->realPosition->value();
 
     ASSERT(false);
     return {};
 }
 
 void CPopup::recheckTree() {
-    WP<CPopup> curr = m_self;
-    while (curr->m_parent) {
-        curr = curr->m_parent;
+    WP<CPopup> curr = m_pSelf;
+    while (curr->m_pParent) {
+        curr = curr->m_pParent;
     }
 
     curr->recheckChildrenRecursive();
 }
 
 void CPopup::recheckChildrenRecursive() {
-    if (m_inert || !m_wlSurface)
+    if (m_bInert || !m_pWLSurface)
         return;
 
     std::vector<WP<CPopup>> cpy;
-    std::ranges::for_each(m_children, [&cpy](const auto& el) { cpy.emplace_back(el); });
+    std::ranges::for_each(m_vChildren, [&cpy](const auto& el) { cpy.emplace_back(el); });
     for (auto const& c : cpy) {
         c->onCommit(true);
         c->recheckChildrenRecursive();
@@ -303,25 +294,25 @@ void CPopup::recheckChildrenRecursive() {
 }
 
 Vector2D CPopup::size() {
-    return m_lastSize;
+    return m_vLastSize;
 }
 
 void CPopup::sendScale() {
-    if (!m_windowOwner.expired())
-        g_pCompositor->setPreferredScaleForSurface(m_wlSurface->resource(), m_windowOwner->m_wlSurface->m_lastScaleFloat);
-    else if (!m_layerOwner.expired())
-        g_pCompositor->setPreferredScaleForSurface(m_wlSurface->resource(), m_layerOwner->m_surface->m_lastScaleFloat);
+    if (!m_pWindowOwner.expired())
+        g_pCompositor->setPreferredScaleForSurface(m_pWLSurface->resource(), m_pWindowOwner->m_pWLSurface->m_fLastScale);
+    else if (!m_pLayerOwner.expired())
+        g_pCompositor->setPreferredScaleForSurface(m_pWLSurface->resource(), m_pLayerOwner->surface->m_fLastScale);
     else
         UNREACHABLE();
 }
 
 bool CPopup::visible() {
-    if (!m_windowOwner.expired())
-        return g_pHyprRenderer->shouldRenderWindow(m_windowOwner.lock());
-    if (!m_layerOwner.expired())
+    if (!m_pWindowOwner.expired())
+        return g_pHyprRenderer->shouldRenderWindow(m_pWindowOwner.lock());
+    if (!m_pLayerOwner.expired())
         return true;
-    if (m_parent)
-        return m_parent->visible();
+    if (m_pParent)
+        return m_pParent->visible();
 
     return false;
 }
@@ -335,8 +326,8 @@ void CPopup::bfHelper(std::vector<WP<CPopup>> const& nodes, std::function<void(W
     nodes2.reserve(nodes.size() * 2);
 
     for (auto const& n : nodes) {
-        for (auto const& c : n->m_children) {
-            nodes2.push_back(c->m_self);
+        for (auto const& c : n->m_vChildren) {
+            nodes2.push_back(c->m_pSelf);
         }
     }
 
@@ -346,7 +337,7 @@ void CPopup::bfHelper(std::vector<WP<CPopup>> const& nodes, std::function<void(W
 
 void CPopup::breadthfirst(std::function<void(WP<CPopup>, void*)> fn, void* data) {
     std::vector<WP<CPopup>> popups;
-    popups.push_back(m_self);
+    popups.push_back(m_pSelf);
     bfHelper(popups, fn, data);
 }
 
@@ -355,14 +346,14 @@ WP<CPopup> CPopup::at(const Vector2D& globalCoords, bool allowsInput) {
     breadthfirst([&popups](WP<CPopup> popup, void* data) { popups.push_back(popup); }, &popups);
 
     for (auto const& p : popups | std::views::reverse) {
-        if (!p->m_resource || !p->m_mapped)
+        if (!p->m_pResource || !p->m_bMapped)
             continue;
 
         if (!allowsInput) {
-            const bool HASSURFACE = p->m_resource && p->m_resource->m_surface;
+            const bool HASSURFACE = p->m_pResource && p->m_pResource->surface;
 
-            Vector2D   offset = HASSURFACE ? p->m_resource->m_surface->m_current.geometry.pos() : Vector2D{};
-            Vector2D   size   = HASSURFACE ? p->m_resource->m_surface->m_current.geometry.size() : p->size();
+            Vector2D   offset = HASSURFACE ? p->m_pResource->surface->current.geometry.pos() : Vector2D{};
+            Vector2D   size   = HASSURFACE ? p->m_pResource->surface->current.geometry.size() : p->size();
 
             if (size == Vector2D{})
                 size = p->size();
@@ -371,7 +362,7 @@ WP<CPopup> CPopup::at(const Vector2D& globalCoords, bool allowsInput) {
             if (BOX.containsPoint(globalCoords))
                 return p;
         } else {
-            const auto REGION = CRegion{p->m_wlSurface->resource()->m_current.input}.intersect(CBox{{}, p->m_wlSurface->resource()->m_current.size}).translate(p->coordsGlobal());
+            const auto REGION = CRegion{p->m_pWLSurface->resource()->current.input}.intersect(CBox{{}, p->m_pWLSurface->resource()->current.size}).translate(p->coordsGlobal());
             if (REGION.containsPoint(globalCoords))
                 return p;
         }
@@ -381,5 +372,5 @@ WP<CPopup> CPopup::at(const Vector2D& globalCoords, bool allowsInput) {
 }
 
 bool CPopup::inert() const {
-    return m_inert;
+    return m_bInert;
 }

src/desktop/Popup.hpp

@@ -41,32 +41,32 @@ class CPopup {
     WP<CPopup> at(const Vector2D& globalCoords, bool allowsInput = false);
 
     //
-    SP<CWLSurface> m_wlSurface;
-    WP<CPopup>     m_self;
-    bool           m_mapped = false;
+    SP<CWLSurface> m_pWLSurface;
+    WP<CPopup>     m_pSelf;
+    bool           m_bMapped = false;
 
   private:
     CPopup() = default;
 
     // T1 owners, each popup has to have one of these
-    PHLWINDOWREF m_windowOwner;
-    PHLLSREF     m_layerOwner;
+    PHLWINDOWREF m_pWindowOwner;
+    PHLLSREF     m_pLayerOwner;
 
     // T2 owners
-    WP<CPopup>            m_parent;
+    WP<CPopup>            m_pParent;
 
-    WP<CXDGPopupResource> m_resource;
+    WP<CXDGPopupResource> m_pResource;
 
-    Vector2D              m_lastSize = {};
-    Vector2D              m_lastPos  = {};
+    Vector2D              m_vLastSize = {};
+    Vector2D              m_vLastPos  = {};
 
-    bool                  m_requestedReposition = false;
+    bool                  m_bRequestedReposition = false;
 
-    bool                  m_inert = false;
+    bool                  m_bInert = false;
 
     //
-    std::vector<UP<CPopup>> m_children;
-    UP<CSubsurface>         m_subsurfaceHead;
+    std::vector<UP<CPopup>> m_vChildren;
+    UP<CSubsurface>         m_pSubsurfaceHead;
 
     struct {
         CHyprSignalListener newPopup;
@@ -76,7 +76,7 @@ class CPopup {
         CHyprSignalListener commit;
         CHyprSignalListener dismissed;
         CHyprSignalListener reposition;
-    } m_listeners;
+    } listeners;
 
     void        initAllSignals();
     void        reposition();

src/desktop/Rule.cpp

@@ -6,17 +6,17 @@
 CRuleRegexContainer::CRuleRegexContainer(const std::string& regex_) {
     const bool NEGATIVE = regex_.starts_with("negative:");
 
-    m_negative = NEGATIVE;
-    m_regex    = makeUnique<RE2>(NEGATIVE ? regex_.substr(9) : regex_);
+    negative = NEGATIVE;
+    regex    = makeUnique<RE2>(NEGATIVE ? regex_.substr(9) : regex_);
 
     // TODO: maybe pop an error?
-    if (!m_regex->ok())
+    if (!regex->ok())
         Debug::log(ERR, "RuleRegexContainer: regex {} failed to parse!", regex_);
 }
 
 bool CRuleRegexContainer::passes(const std::string& str) const {
-    if (!m_regex)
+    if (!regex)
         return false;
 
-    return RE2::FullMatch(str, *m_regex) != m_negative;
+    return RE2::FullMatch(str, *regex) != negative;
 }

src/desktop/Rule.hpp

@@ -16,6 +16,6 @@ class CRuleRegexContainer {
     bool passes(const std::string& str) const;
 
   private:
-    Hyprutils::Memory::CUniquePointer<re2::RE2> m_regex;
-    bool                                        m_negative = false;
+    Hyprutils::Memory::CUniquePointer<re2::RE2> regex;
+    bool                                        negative = false;
 };

src/desktop/Subsurface.cpp

@@ -9,61 +9,61 @@
 
 UP<CSubsurface> CSubsurface::create(PHLWINDOW pOwner) {
     auto subsurface             = UP<CSubsurface>(new CSubsurface());
-    subsurface->m_windowParent = pOwner;
-    subsurface->m_self         = subsurface;
+    subsurface->m_pWindowParent = pOwner;
+    subsurface->m_pSelf         = subsurface;
 
     subsurface->initSignals();
-    subsurface->initExistingSubsurfaces(pOwner->m_wlSurface->resource());
+    subsurface->initExistingSubsurfaces(pOwner->m_pWLSurface->resource());
     return subsurface;
 }
 
 UP<CSubsurface> CSubsurface::create(WP<CPopup> pOwner) {
     auto subsurface            = UP<CSubsurface>(new CSubsurface());
-    subsurface->m_popupParent = pOwner;
-    subsurface->m_self        = subsurface;
+    subsurface->m_pPopupParent = pOwner;
+    subsurface->m_pSelf        = subsurface;
     subsurface->initSignals();
-    subsurface->initExistingSubsurfaces(pOwner->m_wlSurface->resource());
+    subsurface->initExistingSubsurfaces(pOwner->m_pWLSurface->resource());
     return subsurface;
 }
 
 UP<CSubsurface> CSubsurface::create(SP<CWLSubsurfaceResource> pSubsurface, PHLWINDOW pOwner) {
     auto subsurface             = UP<CSubsurface>(new CSubsurface());
-    subsurface->m_windowParent = pOwner;
-    subsurface->m_subsurface   = pSubsurface;
-    subsurface->m_self         = subsurface;
-    subsurface->m_wlSurface    = CWLSurface::create();
-    subsurface->m_wlSurface->assign(pSubsurface->m_surface.lock(), subsurface.get());
+    subsurface->m_pWindowParent = pOwner;
+    subsurface->m_pSubsurface   = pSubsurface;
+    subsurface->m_pSelf         = subsurface;
+    subsurface->m_pWLSurface    = CWLSurface::create();
+    subsurface->m_pWLSurface->assign(pSubsurface->surface.lock(), subsurface.get());
     subsurface->initSignals();
-    subsurface->initExistingSubsurfaces(pSubsurface->m_surface.lock());
+    subsurface->initExistingSubsurfaces(pSubsurface->surface.lock());
     return subsurface;
 }
 
 UP<CSubsurface> CSubsurface::create(SP<CWLSubsurfaceResource> pSubsurface, WP<CPopup> pOwner) {
     auto subsurface            = UP<CSubsurface>(new CSubsurface());
-    subsurface->m_popupParent = pOwner;
-    subsurface->m_subsurface  = pSubsurface;
-    subsurface->m_self        = subsurface;
-    subsurface->m_wlSurface   = CWLSurface::create();
-    subsurface->m_wlSurface->assign(pSubsurface->m_surface.lock(), subsurface.get());
+    subsurface->m_pPopupParent = pOwner;
+    subsurface->m_pSubsurface  = pSubsurface;
+    subsurface->m_pSelf        = subsurface;
+    subsurface->m_pWLSurface   = CWLSurface::create();
+    subsurface->m_pWLSurface->assign(pSubsurface->surface.lock(), subsurface.get());
     subsurface->initSignals();
-    subsurface->initExistingSubsurfaces(pSubsurface->m_surface.lock());
+    subsurface->initExistingSubsurfaces(pSubsurface->surface.lock());
     return subsurface;
 }
 
 void CSubsurface::initSignals() {
-    if (m_subsurface) {
-        m_listeners.commitSubsurface  = m_subsurface->m_surface->m_events.commit.registerListener([this](std::any d) { onCommit(); });
-        m_listeners.destroySubsurface = m_subsurface->m_events.destroy.registerListener([this](std::any d) { onDestroy(); });
-        m_listeners.mapSubsurface     = m_subsurface->m_surface->m_events.map.registerListener([this](std::any d) { onMap(); });
-        m_listeners.unmapSubsurface   = m_subsurface->m_surface->m_events.unmap.registerListener([this](std::any d) { onUnmap(); });
-        m_listeners.newSubsurface =
-            m_subsurface->m_surface->m_events.newSubsurface.registerListener([this](std::any d) { onNewSubsurface(std::any_cast<SP<CWLSubsurfaceResource>>(d)); });
+    if (m_pSubsurface) {
+        listeners.commitSubsurface  = m_pSubsurface->surface->events.commit.registerListener([this](std::any d) { onCommit(); });
+        listeners.destroySubsurface = m_pSubsurface->events.destroy.registerListener([this](std::any d) { onDestroy(); });
+        listeners.mapSubsurface     = m_pSubsurface->surface->events.map.registerListener([this](std::any d) { onMap(); });
+        listeners.unmapSubsurface   = m_pSubsurface->surface->events.unmap.registerListener([this](std::any d) { onUnmap(); });
+        listeners.newSubsurface =
+            m_pSubsurface->surface->events.newSubsurface.registerListener([this](std::any d) { onNewSubsurface(std::any_cast<SP<CWLSubsurfaceResource>>(d)); });
     } else {
-        if (m_windowParent)
-            m_listeners.newSubsurface = m_windowParent->m_wlSurface->resource()->m_events.newSubsurface.registerListener(
+        if (m_pWindowParent)
+            listeners.newSubsurface = m_pWindowParent->m_pWLSurface->resource()->events.newSubsurface.registerListener(
                 [this](std::any d) { onNewSubsurface(std::any_cast<SP<CWLSubsurfaceResource>>(d)); });
-        else if (m_popupParent)
-            m_listeners.newSubsurface = m_popupParent->m_wlSurface->resource()->m_events.newSubsurface.registerListener(
+        else if (m_pPopupParent)
+            listeners.newSubsurface = m_pPopupParent->m_pWLSurface->resource()->events.newSubsurface.registerListener(
                 [this](std::any d) { onNewSubsurface(std::any_cast<SP<CWLSubsurfaceResource>>(d)); });
         else
             ASSERT(false);
@@ -71,102 +71,115 @@ void CSubsurface::initSignals() {
 }
 
 void CSubsurface::checkSiblingDamage() {
-    if (!m_parent)
+    if (!m_pParent)
         return; // ??????????
 
-    const double SCALE = m_windowParent.lock() && m_windowParent->m_isX11 ? 1.0 / m_windowParent->m_X11SurfaceScaledBy : 1.0;
+    const double SCALE = m_pWindowParent.lock() && m_pWindowParent->m_bIsX11 ? 1.0 / m_pWindowParent->m_fX11SurfaceScaledBy : 1.0;
 
-    for (auto const& n : m_parent->m_children) {
+    for (auto const& n : m_pParent->m_vChildren) {
         if (n.get() == this)
             continue;
 
         const auto COORDS = n->coordsGlobal();
-        g_pHyprRenderer->damageSurface(n->m_wlSurface->resource(), COORDS.x, COORDS.y, SCALE);
+        g_pHyprRenderer->damageSurface(n->m_pWLSurface->resource(), COORDS.x, COORDS.y, SCALE);
     }
 }
 
 void CSubsurface::recheckDamageForSubsurfaces() {
-    for (auto const& n : m_children) {
+    for (auto const& n : m_vChildren) {
         const auto COORDS = n->coordsGlobal();
-        g_pHyprRenderer->damageSurface(n->m_wlSurface->resource(), COORDS.x, COORDS.y);
+        g_pHyprRenderer->damageSurface(n->m_pWLSurface->resource(), COORDS.x, COORDS.y);
     }
 }
 
 void CSubsurface::onCommit() {
     // no damaging if it's not visible
-    if (!m_windowParent.expired() && (!m_windowParent->m_isMapped || !m_windowParent->m_workspace->m_visible)) {
-        m_lastSize = m_wlSurface->resource()->m_current.size;
+    if (!m_pWindowParent.expired() && (!m_pWindowParent->m_bIsMapped || !m_pWindowParent->m_pWorkspace->m_bVisible)) {
+        m_vLastSize = m_pWLSurface->resource()->current.size;
 
         static auto PLOGDAMAGE = CConfigValue<Hyprlang::INT>("debug:log_damage");
         if (*PLOGDAMAGE)
-            Debug::log(LOG, "Refusing to commit damage from a subsurface of {} because it's invisible.", m_windowParent.lock());
+            Debug::log(LOG, "Refusing to commit damage from a subsurface of {} because it's invisible.", m_pWindowParent.lock());
         return;
     }
 
     const auto COORDS = coordsGlobal();
 
-    g_pHyprRenderer->damageSurface(m_wlSurface->resource(), COORDS.x, COORDS.y);
+    g_pHyprRenderer->damageSurface(m_pWLSurface->resource(), COORDS.x, COORDS.y);
 
-    if (m_popupParent && !m_popupParent->inert() && m_popupParent->m_wlSurface)
-        m_popupParent->recheckTree();
-    if (!m_windowParent.expired()) // I hate you firefox why are you doing this
-        m_windowParent->m_popupHead->recheckTree();
+    if (m_pPopupParent && !m_pPopupParent->inert() && m_pPopupParent->m_pWLSurface)
+        m_pPopupParent->recheckTree();
+    if (!m_pWindowParent.expired()) // I hate you firefox why are you doing this
+        m_pWindowParent->m_pPopupHead->recheckTree();
 
     // I do not think this is correct, but it solves a lot of issues with some apps (e.g. firefox)
     checkSiblingDamage();
 
-    if (m_lastSize != m_wlSurface->resource()->m_current.size || m_lastPosition != m_subsurface->m_position) {
-        damageLastArea();
-        m_lastSize     = m_wlSurface->resource()->m_current.size;
-        m_lastPosition = m_subsurface->m_position;
+    if (m_vLastSize != m_pWLSurface->resource()->current.size) {
+        // 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 && !m_pPopupParent->inert() && m_pPopupParent->m_pWLSurface)
+            box = m_pPopupParent->m_pWLSurface->getSurfaceBoxGlobal().value_or(CBox{});
+        else if (m_pWindowParent)
+            box = m_pWindowParent->getWindowMainSurfaceBox();
+
+        g_pHyprRenderer->damageBox(box);
     }
 }
 
 void CSubsurface::onDestroy() {
     // destroy children
-    m_children.clear();
+    m_vChildren.clear();
 
-    m_inert = true;
+    m_bInert = true;
 
-    if (!m_subsurface)
+    if (!m_pSubsurface)
         return; // dummy node, nothing to do, it's the parent dying
 
     // kill ourselves
-    std::erase_if(m_parent->m_children, [this](const auto& other) { return other.get() == this; });
+    std::erase_if(m_pParent->m_vChildren, [this](const auto& other) { return other.get() == this; });
 }
 
 void CSubsurface::onNewSubsurface(SP<CWLSubsurfaceResource> pSubsurface) {
     WP<CSubsurface> PSUBSURFACE;
 
-    if (!m_windowParent.expired())
-        PSUBSURFACE = m_children.emplace_back(CSubsurface::create(pSubsurface, m_windowParent.lock()));
-    else if (m_popupParent)
-        PSUBSURFACE = m_children.emplace_back(CSubsurface::create(pSubsurface, m_popupParent));
+    if (!m_pWindowParent.expired())
+        PSUBSURFACE = m_vChildren.emplace_back(CSubsurface::create(pSubsurface, m_pWindowParent.lock()));
+    else if (m_pPopupParent)
+        PSUBSURFACE = m_vChildren.emplace_back(CSubsurface::create(pSubsurface, m_pPopupParent));
 
-    PSUBSURFACE->m_self = PSUBSURFACE;
+    PSUBSURFACE->m_pSelf = PSUBSURFACE;
 
     ASSERT(PSUBSURFACE);
 
-    PSUBSURFACE->m_parent = m_self;
+    PSUBSURFACE->m_pParent = m_pSelf;
 }
 
 void CSubsurface::onMap() {
-    m_lastSize     = m_wlSurface->resource()->m_current.size;
-    m_lastPosition = m_subsurface->m_position;
+    m_vLastSize = m_pWLSurface->resource()->current.size;
 
     const auto COORDS = coordsGlobal();
-    CBox       box{COORDS, m_lastSize};
+    CBox       box{COORDS, m_vLastSize};
     box.expand(4);
     g_pHyprRenderer->damageBox(box);
 
-    if (!m_windowParent.expired())
-        m_windowParent->updateSurfaceScaleTransformDetails();
+    if (!m_pWindowParent.expired())
+        m_pWindowParent->updateSurfaceScaleTransformDetails();
 }
 
 void CSubsurface::onUnmap() {
-    damageLastArea();
+    const auto COORDS = coordsGlobal();
+    CBox       box{COORDS, m_vLastSize};
+    box.expand(4);
+    g_pHyprRenderer->damageBox(box);
 
-    if (m_wlSurface->resource() == g_pCompositor->m_lastFocus)
+    if (m_pWLSurface->resource() == g_pCompositor->m_pLastFocus)
         g_pInputManager->releaseAllMouseButtons();
 
     g_pInputManager->simulateMouseMovement();
@@ -174,49 +187,42 @@ void CSubsurface::onUnmap() {
     // TODO: should this remove children? Currently it won't, only on .destroy
 }
 
-void CSubsurface::damageLastArea() {
-    const auto COORDS = coordsGlobal() + m_lastPosition - m_subsurface->m_position;
-    CBox       box{COORDS, m_lastSize};
-    box.expand(4);
-    g_pHyprRenderer->damageBox(box);
-}
-
 Vector2D CSubsurface::coordsRelativeToParent() {
-    if (!m_subsurface)
+    if (!m_pSubsurface)
         return {};
-    return m_subsurface->posRelativeToParent();
+    return m_pSubsurface->posRelativeToParent();
 }
 
 Vector2D CSubsurface::coordsGlobal() {
     Vector2D coords = coordsRelativeToParent();
 
-    if (!m_windowParent.expired())
-        coords += m_windowParent->m_realPosition->value();
-    else if (m_popupParent)
-        coords += m_popupParent->coordsGlobal();
+    if (!m_pWindowParent.expired())
+        coords += m_pWindowParent->m_vRealPosition->value();
+    else if (m_pPopupParent)
+        coords += m_pPopupParent->coordsGlobal();
 
     return coords;
 }
 
 void CSubsurface::initExistingSubsurfaces(SP<CWLSurfaceResource> pSurface) {
-    for (auto const& s : pSurface->m_subsurfaces) {
-        if (!s || s->m_surface->m_hlSurface /* already assigned */)
+    for (auto const& s : pSurface->subsurfaces) {
+        if (!s || s->surface->hlSurface /* already assigned */)
             continue;
         onNewSubsurface(s.lock());
     }
 }
 
 Vector2D CSubsurface::size() {
-    return m_wlSurface->resource()->m_current.size;
+    return m_pWLSurface->resource()->current.size;
 }
 
 bool CSubsurface::visible() {
-    if (!m_windowParent.expired())
-        return g_pHyprRenderer->shouldRenderWindow(m_windowParent.lock());
-    if (m_popupParent)
-        return m_popupParent->visible();
-    if (m_parent)
-        return m_parent->visible();
+    if (!m_pWindowParent.expired())
+        return g_pHyprRenderer->shouldRenderWindow(m_pWindowParent.lock());
+    if (m_pPopupParent)
+        return m_pPopupParent->visible();
+    if (m_pParent)
+        return m_pParent->visible();
 
     return false;
 }

src/desktop/Subsurface.hpp

@@ -34,7 +34,7 @@ class CSubsurface {
 
     void            recheckDamageForSubsurfaces();
 
-    WP<CSubsurface> m_self;
+    WP<CSubsurface> m_pSelf;
 
   private:
     CSubsurface() = default;
@@ -45,25 +45,23 @@ class CSubsurface {
         CHyprSignalListener mapSubsurface;
         CHyprSignalListener unmapSubsurface;
         CHyprSignalListener newSubsurface;
-    } m_listeners;
+    } listeners;
 
-    WP<CWLSubsurfaceResource> m_subsurface;
-    SP<CWLSurface>            m_wlSurface;
-    Vector2D                  m_lastSize     = {};
-    Vector2D                  m_lastPosition = {};
+    WP<CWLSubsurfaceResource> m_pSubsurface;
+    SP<CWLSurface>            m_pWLSurface;
+    Vector2D                  m_vLastSize = {};
 
     // if nullptr, means it's a dummy node
-    WP<CSubsurface>              m_parent;
+    WP<CSubsurface>              m_pParent;
 
-    PHLWINDOWREF                 m_windowParent;
-    WP<CPopup>                   m_popupParent;
+    PHLWINDOWREF                 m_pWindowParent;
+    WP<CPopup>                   m_pPopupParent;
 
-    std::vector<UP<CSubsurface>> m_children;
+    std::vector<UP<CSubsurface>> m_vChildren;
 
-    bool                         m_inert = false;
+    bool                         m_bInert = false;
 
     void                         initSignals();
     void                         initExistingSubsurfaces(SP<CWLSurfaceResource> pSurface);
     void                         checkSiblingDamage();
-    void                         damageLastArea();
 };

src/desktop/WLSurface.cpp

@@ -6,37 +6,37 @@
 #include "../render/Renderer.hpp"
 
 void CWLSurface::assign(SP<CWLSurfaceResource> pSurface) {
-    m_resource = pSurface;
+    m_pResource = pSurface;
     init();
-    m_inert = false;
+    m_bInert = false;
 }
 
 void CWLSurface::assign(SP<CWLSurfaceResource> pSurface, PHLWINDOW pOwner) {
-    m_windowOwner = pOwner;
-    m_resource    = pSurface;
+    m_pWindowOwner = pOwner;
+    m_pResource    = pSurface;
     init();
-    m_inert = false;
+    m_bInert = false;
 }
 
 void CWLSurface::assign(SP<CWLSurfaceResource> pSurface, PHLLS pOwner) {
-    m_layerOwner = pOwner;
-    m_resource   = pSurface;
+    m_pLayerOwner = pOwner;
+    m_pResource   = pSurface;
     init();
-    m_inert = false;
+    m_bInert = false;
 }
 
 void CWLSurface::assign(SP<CWLSurfaceResource> pSurface, CSubsurface* pOwner) {
-    m_subsurfaceOwner = pOwner;
-    m_resource        = pSurface;
+    m_pSubsurfaceOwner = pOwner;
+    m_pResource        = pSurface;
     init();
-    m_inert = false;
+    m_bInert = false;
 }
 
 void CWLSurface::assign(SP<CWLSurfaceResource> pSurface, CPopup* pOwner) {
-    m_popupOwner = pOwner;
-    m_resource   = pSurface;
+    m_pPopupOwner = pOwner;
+    m_pResource   = pSurface;
     init();
-    m_inert = false;
+    m_bInert = false;
 }
 
 void CWLSurface::unassign() {
@@ -48,67 +48,66 @@ CWLSurface::~CWLSurface() {
 }
 
 bool CWLSurface::exists() const {
-    return m_resource;
+    return m_pResource;
 }
 
 SP<CWLSurfaceResource> CWLSurface::resource() const {
-    return m_resource.lock();
+    return m_pResource.lock();
 }
 
 bool CWLSurface::small() const {
-    if (!validMapped(m_windowOwner) || !exists())
+    if (!validMapped(m_pWindowOwner) || !exists())
         return false;
 
-    if (!m_resource->m_current.texture)
+    if (!m_pResource->current.texture)
         return false;
 
-    const auto O = m_windowOwner.lock();
+    const auto O = m_pWindowOwner.lock();
 
-    return O->m_reportedSize.x > m_resource->m_current.size.x + 1 || O->m_reportedSize.y > m_resource->m_current.size.y + 1;
+    return O->m_vReportedSize.x > m_pResource->current.size.x + 1 || O->m_vReportedSize.y > m_pResource->current.size.y + 1;
 }
 
 Vector2D CWLSurface::correctSmallVec() const {
-    if (!validMapped(m_windowOwner) || !exists() || !small() || m_fillIgnoreSmall)
+    if (!validMapped(m_pWindowOwner) || !exists() || !small() || m_bFillIgnoreSmall)
         return {};
 
     const auto SIZE = getViewporterCorrectedSize();
-    const auto O    = m_windowOwner.lock();
+    const auto O    = m_pWindowOwner.lock();
 
-    return Vector2D{(O->m_reportedSize.x - SIZE.x) / 2, (O->m_reportedSize.y - SIZE.y) / 2}.clamp({}, {INFINITY, INFINITY}) * (O->m_realSize->value() / O->m_reportedSize);
+    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 {
-    if (!exists() || !small() || m_fillIgnoreSmall || !m_resource->m_current.texture)
+    if (!exists() || !small() || m_bFillIgnoreSmall || !m_pResource->current.texture)
         return {};
 
     const auto SIZE = getViewporterCorrectedSize();
-    const auto BS   = m_resource->m_current.bufferSize;
+    const auto BS   = m_pResource->current.bufferSize;
 
     return Vector2D{(BS.x - SIZE.x) / 2, (BS.y - SIZE.y) / 2}.clamp({}, {INFINITY, INFINITY});
 }
 
 Vector2D CWLSurface::getViewporterCorrectedSize() const {
-    if (!exists() || !m_resource->m_current.texture)
+    if (!exists() || !m_pResource->current.texture)
         return {};
 
-    return m_resource->m_current.viewport.hasDestination ? m_resource->m_current.viewport.destination : m_resource->m_current.bufferSize;
+    return m_pResource->current.viewport.hasDestination ? m_pResource->current.viewport.destination : m_pResource->current.bufferSize;
 }
 
 CRegion CWLSurface::computeDamage() const {
-    if (!m_resource->m_current.texture)
+    if (!m_pResource->current.texture)
         return {};
 
-    CRegion damage = m_resource->m_current.accumulateBufferDamage();
-    damage.transform(wlTransformToHyprutils(m_resource->m_current.transform), m_resource->m_current.bufferSize.x, m_resource->m_current.bufferSize.y);
+    CRegion damage = m_pResource->current.accumulateBufferDamage();
+    damage.transform(wlTransformToHyprutils(m_pResource->current.transform), m_pResource->current.bufferSize.x, m_pResource->current.bufferSize.y);
 
-    const auto BUFSIZE    = m_resource->m_current.bufferSize;
+    const auto BUFSIZE    = m_pResource->current.bufferSize;
     const auto CORRECTVEC = correctSmallVecBuf();
 
-    if (m_resource->m_current.viewport.hasSource)
-        damage.intersect(m_resource->m_current.viewport.source);
+    if (m_pResource->current.viewport.hasSource)
+        damage.intersect(m_pResource->current.viewport.source);
 
-    const auto SCALEDSRCSIZE =
-        m_resource->m_current.viewport.hasSource ? m_resource->m_current.viewport.source.size() * m_resource->m_current.scale : m_resource->m_current.bufferSize;
+    const auto SCALEDSRCSIZE = m_pResource->current.viewport.hasSource ? m_pResource->current.viewport.source.size() * m_pResource->current.scale : m_pResource->current.bufferSize;
 
     damage.scale({BUFSIZE.x / SCALEDSRCSIZE.x, BUFSIZE.y / SCALEDSRCSIZE.y});
     damage.translate(CORRECTVEC);
@@ -116,120 +115,120 @@ CRegion CWLSurface::computeDamage() const {
     // go from buffer coords in the damage to hl logical
 
     const auto     BOX   = getSurfaceBoxGlobal();
-    const Vector2D SCALE = BOX.has_value() ? BOX->size() / m_resource->m_current.bufferSize :
-                                             Vector2D{1.0 / m_resource->m_current.scale, 1.0 / m_resource->m_current.scale /* Wrong... but we can't really do better */};
+    const Vector2D SCALE = BOX.has_value() ? BOX->size() / m_pResource->current.bufferSize :
+                                             Vector2D{1.0 / m_pResource->current.scale, 1.0 / m_pResource->current.scale /* Wrong... but we can't really do better */};
 
     damage.scale(SCALE);
 
-    if (m_windowOwner)
-        damage.scale(m_windowOwner->m_X11SurfaceScaledBy); // fix xwayland:force_zero_scaling stuff that will be fucked by the above a bit
+    if (m_pWindowOwner)
+        damage.scale(m_pWindowOwner->m_fX11SurfaceScaledBy); // fix xwayland:force_zero_scaling stuff that will be fucked by the above a bit
 
     return damage;
 }
 
 void CWLSurface::destroy() {
-    if (!m_resource)
+    if (!m_pResource)
         return;
 
-    m_events.destroy.emit();
+    events.destroy.emit();
 
-    m_constraint.reset();
+    m_pConstraint.reset();
 
-    m_listeners.destroy.reset();
-    m_resource->m_hlSurface.reset();
-    m_windowOwner.reset();
-    m_layerOwner.reset();
-    m_popupOwner      = nullptr;
-    m_subsurfaceOwner = nullptr;
-    m_inert           = true;
+    listeners.destroy.reset();
+    m_pResource->hlSurface.reset();
+    m_pWindowOwner.reset();
+    m_pLayerOwner.reset();
+    m_pPopupOwner      = nullptr;
+    m_pSubsurfaceOwner = nullptr;
+    m_bInert           = true;
 
-    if (g_pHyprRenderer && g_pHyprRenderer->m_lastCursorData.surf && g_pHyprRenderer->m_lastCursorData.surf->get() == this)
-        g_pHyprRenderer->m_lastCursorData.surf.reset();
+    if (g_pHyprRenderer && g_pHyprRenderer->m_sLastCursorData.surf && g_pHyprRenderer->m_sLastCursorData.surf->get() == this)
+        g_pHyprRenderer->m_sLastCursorData.surf.reset();
 
-    m_resource.reset();
+    m_pResource.reset();
 
     Debug::log(LOG, "CWLSurface {:x} called destroy()", (uintptr_t)this);
 }
 
 void CWLSurface::init() {
-    if (!m_resource)
+    if (!m_pResource)
         return;
 
-    RASSERT(!m_resource->m_hlSurface, "Attempted to duplicate CWLSurface ownership!");
+    RASSERT(!m_pResource->hlSurface, "Attempted to duplicate CWLSurface ownership!");
 
-    m_resource->m_hlSurface = m_self.lock();
+    m_pResource->hlSurface = self.lock();
 
-    m_listeners.destroy = m_resource->m_events.destroy.registerListener([this](std::any d) { destroy(); });
+    listeners.destroy = m_pResource->events.destroy.registerListener([this](std::any d) { destroy(); });
 
     Debug::log(LOG, "CWLSurface {:x} called init()", (uintptr_t)this);
 }
 
 PHLWINDOW CWLSurface::getWindow() const {
-    return m_windowOwner.lock();
+    return m_pWindowOwner.lock();
 }
 
 PHLLS CWLSurface::getLayer() const {
-    return m_layerOwner.lock();
+    return m_pLayerOwner.lock();
 }
 
 CPopup* CWLSurface::getPopup() const {
-    return m_popupOwner;
+    return m_pPopupOwner;
 }
 
 CSubsurface* CWLSurface::getSubsurface() const {
-    return m_subsurfaceOwner;
+    return m_pSubsurfaceOwner;
 }
 
 bool CWLSurface::desktopComponent() const {
-    return !m_layerOwner.expired() || !m_windowOwner.expired() || m_subsurfaceOwner || m_popupOwner;
+    return !m_pLayerOwner.expired() || !m_pWindowOwner.expired() || m_pSubsurfaceOwner || m_pPopupOwner;
 }
 
 std::optional<CBox> CWLSurface::getSurfaceBoxGlobal() const {
     if (!desktopComponent())
         return {};
 
-    if (!m_windowOwner.expired())
-        return m_windowOwner->getWindowMainSurfaceBox();
-    if (!m_layerOwner.expired())
-        return m_layerOwner->m_geometry;
-    if (m_popupOwner)
-        return CBox{m_popupOwner->coordsGlobal(), m_popupOwner->size()};
-    if (m_subsurfaceOwner)
-        return CBox{m_subsurfaceOwner->coordsGlobal(), m_subsurfaceOwner->size()};
+    if (!m_pWindowOwner.expired())
+        return m_pWindowOwner->getWindowMainSurfaceBox();
+    if (!m_pLayerOwner.expired())
+        return m_pLayerOwner->geometry;
+    if (m_pPopupOwner)
+        return CBox{m_pPopupOwner->coordsGlobal(), m_pPopupOwner->size()};
+    if (m_pSubsurfaceOwner)
+        return CBox{m_pSubsurfaceOwner->coordsGlobal(), m_pSubsurfaceOwner->size()};
 
     return {};
 }
 
 void CWLSurface::appendConstraint(WP<CPointerConstraint> constraint) {
-    m_constraint = constraint;
+    m_pConstraint = constraint;
 }
 
 SP<CPointerConstraint> CWLSurface::constraint() const {
-    return m_constraint.lock();
+    return m_pConstraint.lock();
 }
 
 bool CWLSurface::visible() {
-    if (!m_windowOwner.expired())
-        return g_pHyprRenderer->shouldRenderWindow(m_windowOwner.lock());
-    if (!m_layerOwner.expired())
+    if (!m_pWindowOwner.expired())
+        return g_pHyprRenderer->shouldRenderWindow(m_pWindowOwner.lock());
+    if (!m_pLayerOwner.expired())
         return true;
-    if (m_popupOwner)
-        return m_popupOwner->visible();
-    if (m_subsurfaceOwner)
-        return m_subsurfaceOwner->visible();
+    if (m_pPopupOwner)
+        return m_pPopupOwner->visible();
+    if (m_pSubsurfaceOwner)
+        return m_pSubsurfaceOwner->visible();
     return true; // non-desktop, we don't know much.
 }
 
 SP<CWLSurface> CWLSurface::fromResource(SP<CWLSurfaceResource> pSurface) {
     if (!pSurface)
         return nullptr;
-    return pSurface->m_hlSurface.lock();
+    return pSurface->hlSurface.lock();
 }
 
 bool CWLSurface::keyboardFocusable() const {
-    if (m_windowOwner || m_popupOwner || m_subsurfaceOwner)
+    if (m_pWindowOwner || m_pPopupOwner || m_pSubsurfaceOwner)
         return true;
-    if (m_layerOwner && m_layerOwner->m_layerSurface)
-        return m_layerOwner->m_layerSurface->m_current.interactivity != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE;
+    if (m_pLayerOwner && m_pLayerOwner->layerSurface)
+        return m_pLayerOwner->layerSurface->current.interactivity != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE;
     return false;
 }

src/desktop/WLSurface.hpp

@@ -13,7 +13,7 @@ class CWLSurface {
   public:
     static SP<CWLSurface> create() {
         auto p  = SP<CWLSurface>(new CWLSurface);
-        p->m_self = p;
+        p->self = p;
         return p;
     }
     ~CWLSurface();
@@ -53,17 +53,17 @@ class CWLSurface {
     SP<CPointerConstraint> constraint() const;
 
     // allow stretching. Useful for plugins.
-    bool m_fillIgnoreSmall = false;
+    bool m_bFillIgnoreSmall = false;
 
     // track surface data and avoid dupes
-    float               m_lastScaleFloat = 0;
-    int                 m_lastScaleInt   = 0;
-    wl_output_transform m_lastTransform  = (wl_output_transform)-1;
+    float               m_fLastScale     = 0;
+    int                 m_iLastScale     = 0;
+    wl_output_transform m_eLastTransform = (wl_output_transform)-1;
 
     //
     CWLSurface& operator=(SP<CWLSurfaceResource> pSurface) {
         destroy();
-        m_resource = pSurface;
+        m_pResource = pSurface;
         init();
 
         return *this;
@@ -84,32 +84,32 @@ class CWLSurface {
     static SP<CWLSurface> fromResource(SP<CWLSurfaceResource> pSurface);
 
     // used by the alpha-modifier protocol
-    float m_alphaModifier = 1.F;
+    float m_fAlphaModifier = 1.F;
 
     // used by the hyprland-surface protocol
-    float   m_overallOpacity = 1.F;
+    float   m_fOverallOpacity = 1.F;
     CRegion m_visibleRegion;
 
     struct {
         CSignal destroy;
-    } m_events;
+    } events;
 
-    WP<CWLSurface> m_self;
+    WP<CWLSurface> self;
 
   private:
     CWLSurface() = default;
 
-    bool                   m_inert = true;
+    bool                   m_bInert = true;
 
-    WP<CWLSurfaceResource> m_resource;
+    WP<CWLSurfaceResource> m_pResource;
 
-    PHLWINDOWREF           m_windowOwner;
-    PHLLSREF               m_layerOwner;
-    CPopup*                m_popupOwner      = nullptr;
-    CSubsurface*           m_subsurfaceOwner = nullptr;
+    PHLWINDOWREF           m_pWindowOwner;
+    PHLLSREF               m_pLayerOwner;
+    CPopup*                m_pPopupOwner      = nullptr;
+    CSubsurface*           m_pSubsurfaceOwner = nullptr;
 
     //
-    WP<CPointerConstraint> m_constraint;
+    WP<CPointerConstraint> m_pConstraint;
 
     void                   destroy();
     void                   init();
@@ -117,7 +117,7 @@ class CWLSurface {
 
     struct {
         CHyprSignalListener destroy;
-    } m_listeners;
+    } listeners;
 
     friend class CPointerConstraint;
     friend class CXxColorManagerV4;

src/desktop/Window.hpp

@@ -6,6 +6,8 @@
 
 #include "../config/ConfigDataValues.hpp"
 #include "../helpers/AnimatedVariable.hpp"
+#include "../helpers/math/Math.hpp"
+#include "../helpers/signal/Signal.hpp"
 #include "../helpers/TagKeeper.hpp"
 #include "../macros.hpp"
 #include "../managers/XWaylandManager.hpp"
@@ -17,7 +19,6 @@
 #include "WLSurface.hpp"
 #include "Workspace.hpp"
 #include "WindowRule.hpp"
-#include "WindowOverridableVar.hpp"
 #include "../protocols/types/ContentType.hpp"
 
 class CXDGSurfaceResource;
@@ -50,7 +51,6 @@ enum eGetWindowProperties : uint8_t {
     FLOATING_ONLY    = 1 << 3,
     ALLOW_FLOATING   = 1 << 4,
     USE_PROP_TILED   = 1 << 5,
-    SKIP_FULLSCREEN_PRIORITY = 1 << 6,
 };
 
 enum eSuppressEvents : uint8_t {
@@ -65,21 +65,103 @@ enum eSuppressEvents : uint8_t {
 class IWindowTransformer;
 
 struct SAlphaValue {
-    float alpha;
-    bool  overridden;
+    float m_fAlpha;
+    bool  m_bOverride;
 
-    float applyAlpha(float a) const {
-        if (overridden)
-            return alpha;
+    float applyAlpha(float alpha) const {
+        if (m_bOverride)
+            return m_fAlpha;
         else
-            return alpha * a;
+            return m_fAlpha * alpha;
     };
 };
 
+enum eOverridePriority : uint8_t {
+    PRIORITY_LAYOUT = 0,
+    PRIORITY_WORKSPACE_RULE,
+    PRIORITY_WINDOW_RULE,
+    PRIORITY_SET_PROP,
+};
+
+template <typename T>
+class CWindowOverridableVar {
+  public:
+    CWindowOverridableVar(T const& value, eOverridePriority priority) {
+        values[priority] = value;
+    }
+    CWindowOverridableVar(T const& value) : defaultValue{value} {}
+
+    CWindowOverridableVar()  = default;
+    ~CWindowOverridableVar() = default;
+
+    CWindowOverridableVar<T>& operator=(CWindowOverridableVar<T> const& other) {
+        // Self-assignment check
+        if (this == &other)
+            return *this;
+
+        for (auto const& value : other.values) {
+            values[value.first] = value.second;
+        }
+
+        return *this;
+    }
+
+    void unset(eOverridePriority priority) {
+        values.erase(priority);
+    }
+
+    bool hasValue() {
+        return !values.empty();
+    }
+
+    T value() {
+        if (!values.empty())
+            return std::prev(values.end())->second;
+        else
+            throw std::bad_optional_access();
+    }
+
+    T valueOr(T const& other) {
+        if (hasValue())
+            return value();
+        else
+            return other;
+    }
+
+    T valueOrDefault() {
+        return valueOr(defaultValue);
+    }
+
+    eOverridePriority getPriority() {
+        if (!values.empty())
+            return std::prev(values.end())->first;
+        else
+            throw std::bad_optional_access();
+    }
+
+    void matchOptional(std::optional<T> const& optValue, eOverridePriority priority) {
+        if (optValue.has_value())
+            values[priority] = optValue.value();
+        else
+            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
+};
+
 struct SWindowData {
-    CWindowOverridableVar<SAlphaValue>        alpha           = SAlphaValue{.alpha = 1.f, .overridden = false};
-    CWindowOverridableVar<SAlphaValue>        alphaInactive   = SAlphaValue{.alpha = 1.f, .overridden = false};
-    CWindowOverridableVar<SAlphaValue>        alphaFullscreen = SAlphaValue{.alpha = 1.f, .overridden = false};
+    CWindowOverridableVar<SAlphaValue>        alpha           = SAlphaValue{1.f, false};
+    CWindowOverridableVar<SAlphaValue>        alphaInactive   = SAlphaValue{1.f, false};
+    CWindowOverridableVar<SAlphaValue>        alphaFullscreen = SAlphaValue{1.f, false};
 
     CWindowOverridableVar<bool>               allowsInput        = false;
     CWindowOverridableVar<bool>               dimAround          = false;
@@ -102,14 +184,13 @@ struct SWindowData {
     CWindowOverridableVar<bool>               tearing            = false;
     CWindowOverridableVar<bool>               xray               = false;
     CWindowOverridableVar<bool>               renderUnfocused    = false;
-    CWindowOverridableVar<bool>               noFollowMouse      = false;
 
-    CWindowOverridableVar<Hyprlang::INT>      borderSize = {std::string("general:border_size"), Hyprlang::INT(0), std::nullopt};
-    CWindowOverridableVar<Hyprlang::INT>      rounding   = {std::string("decoration:rounding"), Hyprlang::INT(0), std::nullopt};
+    CWindowOverridableVar<int>                rounding;
+    CWindowOverridableVar<float>              roundingPower;
+    CWindowOverridableVar<int>                borderSize;
 
-    CWindowOverridableVar<Hyprlang::FLOAT>    roundingPower  = {std::string("decoration:rounding_power")};
-    CWindowOverridableVar<Hyprlang::FLOAT>    scrollMouse    = {std::string("input:scroll_factor")};
-    CWindowOverridableVar<Hyprlang::FLOAT>    scrollTouchpad = {std::string("input:touchpad:scroll_factor")};
+    CWindowOverridableVar<float>              scrollMouse;
+    CWindowOverridableVar<float>              scrollTouchpad;
 
     CWindowOverridableVar<std::string>        animationStyle;
     CWindowOverridableVar<Vector2D>           maxSize;
@@ -143,151 +224,154 @@ class CWindow {
   public:
     ~CWindow();
 
-    SP<CWLSurface> m_wlSurface;
+    SP<CWLSurface> m_pWLSurface;
 
     struct {
         CSignal destroy;
-    } m_events;
+    } events;
 
-    WP<CXDGSurfaceResource> m_xdgSurface;
-    WP<CXWaylandSurface>    m_xwaylandSurface;
+    WP<CXDGSurfaceResource> m_pXDGSurface;
+    WP<CXWaylandSurface>    m_pXWaylandSurface;
 
     // this is the position and size of the "bounding box"
-    Vector2D m_position = Vector2D(0, 0);
-    Vector2D m_size     = Vector2D(0, 0);
+    Vector2D m_vPosition = Vector2D(0, 0);
+    Vector2D m_vSize     = Vector2D(0, 0);
 
     // this is the real position and size used to draw the thing
-    PHLANIMVAR<Vector2D> m_realPosition;
-    PHLANIMVAR<Vector2D> m_realSize;
+    PHLANIMVAR<Vector2D> m_vRealPosition;
+    PHLANIMVAR<Vector2D> m_vRealSize;
 
     // for not spamming the protocols
-    Vector2D                                     m_reportedPosition;
-    Vector2D                                     m_reportedSize;
-    Vector2D                                     m_pendingReportedSize;
-    std::optional<std::pair<uint32_t, Vector2D>> m_pendingSizeAck;
-    std::vector<std::pair<uint32_t, Vector2D>>   m_pendingSizeAcks;
+    Vector2D                                     m_vReportedPosition;
+    Vector2D                                     m_vReportedSize;
+    Vector2D                                     m_vPendingReportedSize;
+    std::optional<std::pair<uint32_t, Vector2D>> m_pPendingSizeAck;
+    std::vector<std::pair<uint32_t, Vector2D>>   m_vPendingSizeAcks;
 
     // for restoring floating statuses
-    Vector2D m_lastFloatingSize;
-    Vector2D m_lastFloatingPosition;
+    Vector2D m_vLastFloatingSize;
+    Vector2D m_vLastFloatingPosition;
 
     // for floating window offset in workspace animations
-    Vector2D m_floatingOffset = Vector2D(0, 0);
+    Vector2D m_vFloatingOffset = Vector2D(0, 0);
 
     // this is used for pseudotiling
-    bool     m_isPseudotiled = false;
-    Vector2D m_pseudoSize    = Vector2D(1280, 720);
+    bool     m_bIsPseudotiled = false;
+    Vector2D m_vPseudoSize    = Vector2D(1280, 720);
 
     // for recovering relative cursor position
-    Vector2D         m_relativeCursorCoordsOnLastWarp = Vector2D(-1, -1);
+    Vector2D         m_vRelativeCursorCoordsOnLastWarp = Vector2D(-1, -1);
 
-    bool             m_firstMap        = false; // for layouts
-    bool             m_isFloating      = false;
-    bool             m_draggingTiled   = false; // for dragging around tiled windows
-    SFullscreenState m_fullscreenState = {.internal = FSMODE_NONE, .client = FSMODE_NONE};
-    std::string      m_title           = "";
-    std::string      m_class           = "";
-    std::string      m_initialTitle    = "";
-    std::string      m_initialClass    = "";
-    PHLWORKSPACE     m_workspace;
-    PHLMONITORREF    m_monitor;
+    bool             m_bFirstMap        = false; // for layouts
+    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};
+    std::string      m_szTitle          = "";
+    std::string      m_szClass          = "";
+    std::string      m_szInitialTitle   = "";
+    std::string      m_szInitialClass   = "";
+    PHLWORKSPACE     m_pWorkspace;
+    PHLMONITORREF    m_pMonitor;
 
-    bool             m_isMapped = false;
+    bool             m_bIsMapped = false;
 
-    bool             m_requestsFloat = false;
+    bool             m_bRequestsFloat = false;
 
     // This is for fullscreen apps
-    bool m_createdOverFullscreen = false;
+    bool m_bCreatedOverFullscreen = false;
 
     // XWayland stuff
-    bool  m_isX11                = false;
-    bool  m_X11DoesntWantBorders = false;
-    bool  m_X11ShouldntFocus     = false;
-    float m_X11SurfaceScaledBy   = 1.f;
+    bool         m_bIsX11 = false;
+    PHLWINDOWREF m_pX11Parent;
+    bool         m_bX11DoesntWantBorders = false;
+    bool         m_bX11ShouldntFocus     = false;
+    float        m_fX11SurfaceScaledBy   = 1.f;
     //
 
     // For nofocus
-    bool m_noInitialFocus = false;
+    bool m_bNoInitialFocus = false;
 
     // Fullscreen and Maximize
-    bool      m_wantsInitialFullscreen        = false;
-    MONITORID m_wantsInitialFullscreenMonitor = MONITOR_INVALID;
+    bool      m_bWantsInitialFullscreen        = false;
+    MONITORID m_iWantsInitialFullscreenMonitor = MONITOR_INVALID;
 
-    // bitfield suppressEvents
-    uint64_t m_suppressedEvents = SUPPRESS_NONE;
+    // bitfield eSuppressEvents
+    uint64_t m_eSuppressedEvents = SUPPRESS_NONE;
 
     // desktop components
-    UP<CSubsurface> m_subsurfaceHead;
-    UP<CPopup>      m_popupHead;
+    UP<CSubsurface> m_pSubsurfaceHead;
+    UP<CPopup>      m_pPopupHead;
 
     // Animated border
-    CGradientValueData m_realBorderColor         = {0};
-    CGradientValueData m_realBorderColorPrevious = {0};
-    PHLANIMVAR<float>  m_borderFadeAnimationProgress;
-    PHLANIMVAR<float>  m_borderAngleAnimationProgress;
+    CGradientValueData m_cRealBorderColor         = {0};
+    CGradientValueData m_cRealBorderColorPrevious = {0};
+    PHLANIMVAR<float>  m_fBorderFadeAnimationProgress;
+    PHLANIMVAR<float>  m_fBorderAngleAnimationProgress;
 
     // Fade in-out
-    PHLANIMVAR<float> m_alpha;
-    bool              m_fadingOut     = false;
-    bool              m_readyToDelete = false;
-    Vector2D          m_originalClosedPos;  // these will be used for calculations later on in
-    Vector2D          m_originalClosedSize; // drawing the closing animations
-    SBoxExtents       m_originalClosedExtents;
-    bool              m_animatingIn = 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_pinned = false;
+    bool m_bPinned = false;
 
     // For preserving pinned state when fullscreening a pinned window
-    bool m_pinFullscreened = false;
+    bool m_bPinFullscreened = false;
 
     // urgency hint
-    bool m_isUrgent = false;
+    bool m_bIsUrgent = false;
 
     // for proper cycling. While cycling we can't just move the pointers, so we need to keep track of the last cycled window.
-    PHLWINDOWREF m_lastCycledWindow;
+    PHLWINDOWREF m_pLastCycledWindow;
 
     // Window decorations
     // TODO: make this a SP.
-    std::vector<UP<IHyprWindowDecoration>> m_windowDecorations;
-    std::vector<IHyprWindowDecoration*>    m_decosToRemove;
+    std::vector<UP<IHyprWindowDecoration>> m_dWindowDecorations;
+    std::vector<IHyprWindowDecoration*>    m_vDecosToRemove;
 
     // Special render data, rules, etc
-    SWindowData m_windowData;
+    SWindowData m_sWindowData;
 
     // Transformers
-    std::vector<UP<IWindowTransformer>> m_transformers;
+    std::vector<UP<IWindowTransformer>> m_vTransformers;
 
     // for alpha
-    PHLANIMVAR<float> m_activeInactiveAlpha;
-    PHLANIMVAR<float> m_movingFromWorkspaceAlpha;
+    PHLANIMVAR<float> m_fActiveInactiveAlpha;
+    PHLANIMVAR<float> m_fMovingFromWorkspaceAlpha;
 
     // animated shadow color
-    PHLANIMVAR<CHyprColor> m_realShadowColor;
+    PHLANIMVAR<CHyprColor> m_cRealShadowColor;
 
     // animated tint
-    PHLANIMVAR<float> m_dimPercent;
+    PHLANIMVAR<float> m_fDimPercent;
 
     // animate moving to an invisible workspace
-    int               m_monitorMovedFrom = -1; // -1 means not moving
-    PHLANIMVAR<float> m_movingToWorkspaceAlpha;
+    int               m_iMonitorMovedFrom = -1; // -1 means not moving
+    PHLANIMVAR<float> m_fMovingToWorkspaceAlpha;
 
     // swallowing
-    PHLWINDOWREF m_swallowed;
-    bool         m_currentlySwallowed = false;
-    bool         m_groupSwallowed     = false;
+    PHLWINDOWREF m_pSwallowed;
+    bool         m_bCurrentlySwallowed = false;
+    bool         m_bGroupSwallowed     = false;
 
     // focus stuff
-    bool m_stayFocused = false;
+    bool m_bStayFocused = false;
 
     // for toplevel monitor events
-    MONITORID m_lastSurfaceMonitorID = -1;
+    MONITORID m_iLastToplevelMonitorID = -1;
+    MONITORID m_iLastSurfaceMonitorID  = -1;
 
     // for idle inhibiting windows
-    eIdleInhibitMode m_idleInhibitMode = IDLEINHIBIT_NONE;
+    eIdleInhibitMode m_eIdleInhibitMode = IDLEINHIBIT_NONE;
 
     // initial token. Will be unregistered on workspace change or timeout of 2 minutes
-    std::string m_initialWorkspaceToken = "";
+    std::string m_szInitialWorkspaceToken = "";
 
     // for groups
     struct SGroupData {
@@ -295,13 +379,13 @@ class CWindow {
         bool         head   = false;
         bool         locked = false; // per group lock
         bool         deny   = false; // deny window from enter a group or made a group
-    } m_groupData;
-    uint16_t m_groupRules = GROUP_NONE;
+    } m_sGroupData;
+    uint16_t m_eGroupRules = GROUP_NONE;
 
-    bool     m_tearingHint = false;
+    bool     m_bTearingHint = false;
 
     // stores the currently matched window rules
-    std::vector<SP<CWindowRule>> m_matchedRules;
+    std::vector<SP<CWindowRule>> m_vMatchedRules;
 
     // window tags
     CTagKeeper m_tags;
@@ -309,13 +393,10 @@ class CWindow {
     // ANR
     PHLANIMVAR<float> m_notRespondingTint;
 
-    // For the noclosefor windowrule
-    Time::steady_tp m_closeableSince = Time::steadyNow();
-
     // For the list lookup
     bool operator==(const CWindow& rhs) const {
-        return m_xdgSurface == rhs.m_xdgSurface && m_xwaylandSurface == rhs.m_xwaylandSurface && m_position == rhs.m_position && m_size == rhs.m_size &&
-            m_fadingOut == rhs.m_fadingOut;
+        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;
     }
 
     // methods
@@ -405,12 +486,9 @@ class CWindow {
     void                       setContentType(NContentType::eContentType contentType);
     void                       deactivateGroupMembers();
     bool                       isNotResponding();
-    std::optional<std::string> xdgTag();
-    std::optional<std::string> xdgDescription();
-    PHLWINDOW                  parent();
 
     CBox                       getWindowMainSurfaceBox() const {
-        return {m_realPosition->value().x, m_realPosition->value().y, m_realSize->value().x, m_realSize->value().y};
+        return {m_vRealPosition->value().x, m_vRealPosition->value().y, m_vRealSize->value().x, m_vRealSize->value().y};
     }
 
     // listeners
@@ -420,7 +498,7 @@ class CWindow {
     std::unordered_map<std::string, std::string> getEnv();
 
     //
-    PHLWINDOWREF m_self;
+    PHLWINDOWREF m_pSelf;
 
     // make private once we move listeners to inside CWindow
     struct {
@@ -435,13 +513,13 @@ class CWindow {
         CHyprSignalListener updateState;
         CHyprSignalListener updateMetadata;
         CHyprSignalListener resourceChange;
-    } m_listeners;
+    } listeners;
 
   private:
     // For hidden windows and stuff
-    bool        m_hidden        = false;
-    bool        m_suspended     = false;
-    WORKSPACEID m_lastWorkspace = WORKSPACE_INVALID;
+    bool        m_bHidden        = false;
+    bool        m_bSuspended     = false;
+    WORKSPACEID m_iLastWorkspace = WORKSPACE_INVALID;
 };
 
 inline bool valid(PHLWINDOW w) {
@@ -455,49 +533,48 @@ inline bool valid(PHLWINDOWREF w) {
 inline bool validMapped(PHLWINDOW w) {
     if (!valid(w))
         return false;
-    return w->m_isMapped;
+    return w->m_bIsMapped;
 }
 
 inline bool validMapped(PHLWINDOWREF w) {
     if (!valid(w))
         return false;
-    return w->m_isMapped;
+    return w->m_bIsMapped;
 }
 
 namespace NWindowProperties {
     static const std::unordered_map<std::string, std::function<CWindowOverridableVar<bool>*(const PHLWINDOW&)>> boolWindowProperties = {
-        {"allowsinput", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.allowsInput; }},
-        {"dimaround", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.dimAround; }},
-        {"decorate", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.decorate; }},
-        {"focusonactivate", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.focusOnActivate; }},
-        {"keepaspectratio", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.keepAspectRatio; }},
-        {"nearestneighbor", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.nearestNeighbor; }},
-        {"noanim", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noAnim; }},
-        {"noblur", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noBlur; }},
-        {"noborder", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noBorder; }},
-        {"nodim", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noDim; }},
-        {"nofocus", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noFocus; }},
-        {"nomaxsize", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noMaxSize; }},
-        {"norounding", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noRounding; }},
-        {"noshadow", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noShadow; }},
-        {"noshortcutsinhibit", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noShortcutsInhibit; }},
-        {"opaque", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.opaque; }},
-        {"forcergbx", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.RGBX; }},
-        {"syncfullscreen", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.syncFullscreen; }},
-        {"immediate", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.tearing; }},
-        {"xray", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.xray; }},
-        {"nofollowmouse", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.noFollowMouse; }},
+        {"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; }},
     };
 
-    const std::unordered_map<std::string, std::function<CWindowOverridableVar<Hyprlang::INT>*(const PHLWINDOW&)>> intWindowProperties = {
-        {"rounding", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.rounding; }},
-        {"bordersize", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.borderSize; }},
+    const std::unordered_map<std::string, std::function<CWindowOverridableVar<int>*(const PHLWINDOW&)>> intWindowProperties = {
+        {"rounding", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.rounding; }},
+        {"bordersize", [](const PHLWINDOW& pWindow) { return &pWindow->m_sWindowData.borderSize; }},
     };
 
-    const std::unordered_map<std::string, std::function<CWindowOverridableVar<Hyprlang::FLOAT>*(PHLWINDOW)>> floatWindowProperties = {
-        {"roundingpower", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.roundingPower; }},
-        {"scrollmouse", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.scrollMouse; }},
-        {"scrolltouchpad", [](const PHLWINDOW& pWindow) { return &pWindow->m_windowData.scrollTouchpad; }},
+    const std::unordered_map<std::string, std::function<CWindowOverridableVar<float>*(PHLWINDOW)>> floatWindowProperties = {
+        {"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; }},
     };
 };
 
@@ -531,13 +608,13 @@ struct std::formatter<PHLWINDOW, CharT> : std::formatter<CharT> {
             return std::format_to(out, "[Window nullptr]");
 
         std::format_to(out, "[");
-        std::format_to(out, "Window {:x}: title: \"{}\"", (uintptr_t)w.get(), w->m_title);
+        std::format_to(out, "Window {:x}: title: \"{}\"", (uintptr_t)w.get(), w->m_szTitle);
         if (formatWorkspace)
-            std::format_to(out, ", workspace: {}", w->m_workspace ? w->workspaceID() : WORKSPACE_INVALID);
+            std::format_to(out, ", workspace: {}", w->m_pWorkspace ? w->workspaceID() : WORKSPACE_INVALID);
         if (formatMonitor)
             std::format_to(out, ", monitor: {}", w->monitorID());
         if (formatClass)
-            std::format_to(out, ", class: {}", w->m_class);
+            std::format_to(out, ", class: {}", w->m_szClass);
         return std::format_to(out, "]");
     }
 };

src/desktop/WindowOverridableVar.hpp

@@ -1,132 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <type_traits>
-#include <any>
-#include "../config/ConfigValue.hpp"
-
-enum eOverridePriority : uint8_t {
-    PRIORITY_LAYOUT = 0,
-    PRIORITY_WORKSPACE_RULE,
-    PRIORITY_WINDOW_RULE,
-    PRIORITY_SET_PROP,
-};
-
-template <typename T>
-T clampOptional(T const& value, std::optional<T> const& min, std::optional<T> const& max) {
-    return std::clamp(value, min.value_or(std::numeric_limits<T>::min()), max.value_or(std::numeric_limits<T>::max()));
-}
-
-template <typename T, bool Extended = std::is_same_v<T, bool> || std::is_same_v<T, Hyprlang::INT> || std::is_same_v<T, Hyprlang::FLOAT>>
-class CWindowOverridableVar {
-  public:
-    CWindowOverridableVar(T const& value, eOverridePriority priority) {
-        m_values[priority] = value;
-    }
-
-    CWindowOverridableVar(T const& value) : m_defaultValue{value} {}
-    CWindowOverridableVar(T const& value, std::optional<T> const& min, std::optional<T> const& max = std::nullopt) : m_defaultValue{value}, m_minValue{min}, m_maxValue{max} {}
-    CWindowOverridableVar(std::string const& value)
-        requires(Extended && !std::is_same_v<T, bool>)
-        : m_configValue(SP<CConfigValue<T>>(new CConfigValue<T>(value))) {}
-    CWindowOverridableVar(std::string const& value, std::optional<T> const& min, std::optional<T> const& max = std::nullopt)
-        requires(Extended && !std::is_same_v<T, bool>)
-        : m_minValue(min), m_maxValue(max), m_configValue(SP<CConfigValue<T>>(new CConfigValue<T>(value))) {}
-
-    CWindowOverridableVar()  = default;
-    ~CWindowOverridableVar() = default;
-
-    CWindowOverridableVar& operator=(CWindowOverridableVar<T> const& other) {
-        // Self-assignment check
-        if (this == &other)
-            return *this;
-
-        for (auto const& value : other.m_values) {
-            if constexpr (Extended && !std::is_same_v<T, bool>)
-                m_values[value.first] = clampOptional(value.second, m_minValue, m_maxValue);
-            else
-                m_values[value.first] = value.second;
-        }
-
-        return *this;
-    }
-
-    void unset(eOverridePriority priority) {
-        m_values.erase(priority);
-    }
-
-    bool hasValue() {
-        return !m_values.empty();
-    }
-
-    T value() {
-        if (!m_values.empty())
-            return std::prev(m_values.end())->second;
-        else
-            throw std::bad_optional_access();
-    }
-
-    T valueOr(T const& other) {
-        if (hasValue())
-            return value();
-        else
-            return other;
-    }
-
-    T valueOrDefault()
-        requires(Extended && !std::is_same_v<T, bool>)
-    {
-        if (hasValue())
-            return value();
-        else if (m_defaultValue.has_value())
-            return m_defaultValue.value();
-        else
-            return **std::any_cast<SP<CConfigValue<T>>>(m_configValue);
-    }
-
-    T valueOrDefault()
-        requires(!Extended || std::is_same_v<T, bool>)
-    {
-        if (hasValue())
-            return value();
-        else if (!m_defaultValue.has_value())
-            throw std::bad_optional_access();
-        else
-            return m_defaultValue.value();
-    }
-
-    eOverridePriority getPriority() {
-        if (!m_values.empty())
-            return std::prev(m_values.end())->first;
-        else
-            throw std::bad_optional_access();
-    }
-
-    void increment(T const& other, eOverridePriority priority) {
-        if constexpr (std::is_same_v<T, bool>)
-            m_values[priority] = valueOr(false) ^ other;
-        else
-            m_values[priority] = clampOptional(valueOrDefault() + other, m_minValue, m_maxValue);
-    }
-
-    void matchOptional(std::optional<T> const& optValue, eOverridePriority priority) {
-        if (optValue.has_value())
-            m_values[priority] = optValue.value();
-        else
-            unset(priority);
-    }
-
-    operator std::optional<T>() {
-        if (hasValue())
-            return value();
-        else
-            return std::nullopt;
-    }
-
-  private:
-    std::map<eOverridePriority, T> m_values;
-    std::optional<T>               m_defaultValue; // used for toggling, so required for bool
-    std::optional<T>               m_minValue;
-    std::optional<T>               m_maxValue;
-    std::any                       m_configValue; // only there for select variables
-};

src/desktop/WindowRule.cpp

@@ -8,90 +8,89 @@ static const auto RULES = std::unordered_set<std::string>{
     "float", "fullscreen", "maximize", "noinitialfocus", "pin", "stayfocused", "tile", "renderunfocused", "persistentsize",
 };
 static const auto RULES_PREFIX = std::unordered_set<std::string>{
-    "animation",     "bordercolor", "bordersize", "center",  "content", "fullscreenstate", "group",    "idleinhibit",   "maxsize",     "minsize",        "monitor",
-    "move",          "noclosefor",  "opacity",    "plugin:", "prop",    "pseudo",          "rounding", "roundingpower", "scrollmouse", "scrolltouchpad", "size",
-    "suppressevent", "tag",         "workspace",  "xray",
+    "animation", "bordercolor",   "bordersize", "center",    "content", "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) : m_value(value), m_rule(rule), m_v2(isV2), m_execRule(isExecRule) {
+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::ranges::any_of(RULES_PREFIX, [&rule](auto prefix) { return rule.starts_with(prefix); }) ||
-        (NWindowProperties::boolWindowProperties.contains(VALS[0])) || (NWindowProperties::intWindowProperties.contains(VALS[0])) ||
-        (NWindowProperties::floatWindowProperties.contains(VALS[0]));
+    const bool VALID = RULES.contains(rule) || std::any_of(RULES_PREFIX.begin(), RULES_PREFIX.end(), [&rule](auto prefix) { return rule.starts_with(prefix); }) ||
+        (NWindowProperties::boolWindowProperties.find(VALS[0]) != NWindowProperties::boolWindowProperties.end()) ||
+        (NWindowProperties::intWindowProperties.find(VALS[0]) != NWindowProperties::intWindowProperties.end()) ||
+        (NWindowProperties::floatWindowProperties.find(VALS[0]) != NWindowProperties::floatWindowProperties.end());
 
     if (!VALID)
         return;
 
     if (rule == "float")
-        m_ruleType = RULE_FLOAT;
+        ruleType = RULE_FLOAT;
     else if (rule == "fullscreen")
-        m_ruleType = RULE_FULLSCREEN;
+        ruleType = RULE_FULLSCREEN;
     else if (rule == "maximize")
-        m_ruleType = RULE_MAXIMIZE;
+        ruleType = RULE_MAXIMIZE;
     else if (rule == "noinitialfocus")
-        m_ruleType = RULE_NOINITIALFOCUS;
+        ruleType = RULE_NOINITIALFOCUS;
     else if (rule == "pin")
-        m_ruleType = RULE_PIN;
+        ruleType = RULE_PIN;
     else if (rule == "stayfocused")
-        m_ruleType = RULE_STAYFOCUSED;
+        ruleType = RULE_STAYFOCUSED;
     else if (rule == "tile")
-        m_ruleType = RULE_TILE;
+        ruleType = RULE_TILE;
     else if (rule == "renderunfocused")
-        m_ruleType = RULE_RENDERUNFOCUSED;
+        ruleType = RULE_RENDERUNFOCUSED;
     else if (rule == "persistentsize")
-        m_ruleType = RULE_PERSISTENTSIZE;
+        ruleType = RULE_PERSISTENTSIZE;
     else if (rule.starts_with("animation"))
-        m_ruleType = RULE_ANIMATION;
+        ruleType = RULE_ANIMATION;
     else if (rule.starts_with("bordercolor"))
-        m_ruleType = RULE_BORDERCOLOR;
+        ruleType = RULE_BORDERCOLOR;
     else if (rule.starts_with("center"))
-        m_ruleType = RULE_CENTER;
+        ruleType = RULE_CENTER;
     else if (rule.starts_with("fullscreenstate"))
-        m_ruleType = RULE_FULLSCREENSTATE;
+        ruleType = RULE_FULLSCREENSTATE;
     else if (rule.starts_with("group"))
-        m_ruleType = RULE_GROUP;
+        ruleType = RULE_GROUP;
     else if (rule.starts_with("idleinhibit"))
-        m_ruleType = RULE_IDLEINHIBIT;
+        ruleType = RULE_IDLEINHIBIT;
     else if (rule.starts_with("maxsize"))
-        m_ruleType = RULE_MAXSIZE;
+        ruleType = RULE_MAXSIZE;
     else if (rule.starts_with("minsize"))
-        m_ruleType = RULE_MINSIZE;
+        ruleType = RULE_MINSIZE;
     else if (rule.starts_with("monitor"))
-        m_ruleType = RULE_MONITOR;
+        ruleType = RULE_MONITOR;
     else if (rule.starts_with("move"))
-        m_ruleType = RULE_MOVE;
+        ruleType = RULE_MOVE;
     else if (rule.starts_with("opacity"))
-        m_ruleType = RULE_OPACITY;
+        ruleType = RULE_OPACITY;
     else if (rule.starts_with("plugin:"))
-        m_ruleType = RULE_PLUGIN;
+        ruleType = RULE_PLUGIN;
     else if (rule.starts_with("pseudo"))
-        m_ruleType = RULE_PSEUDO;
+        ruleType = RULE_PSEUDO;
     else if (rule.starts_with("size"))
-        m_ruleType = RULE_SIZE;
+        ruleType = RULE_SIZE;
     else if (rule.starts_with("suppressevent"))
-        m_ruleType = RULE_SUPPRESSEVENT;
+        ruleType = RULE_SUPPRESSEVENT;
     else if (rule.starts_with("tag"))
-        m_ruleType = RULE_TAG;
+        ruleType = RULE_TAG;
     else if (rule.starts_with("workspace"))
-        m_ruleType = RULE_WORKSPACE;
+        ruleType = RULE_WORKSPACE;
     else if (rule.starts_with("prop"))
-        m_ruleType = RULE_PROP;
+        ruleType = RULE_PROP;
     else if (rule.starts_with("content"))
-        m_ruleType = RULE_CONTENT;
-    else if (rule.starts_with("noclosefor"))
-        m_ruleType = RULE_NOCLOSEFOR;
+        ruleType = RULE_CONTENT;
     else {
         // check if this is a prop.
         const CVarList VARS(rule, 0, 's', true);
-        const bool     ISPROP = NWindowProperties::intWindowProperties.contains(VARS[0]) || NWindowProperties::boolWindowProperties.contains(VARS[0]) ||
-            NWindowProperties::floatWindowProperties.contains(VARS[0]);
-        if (ISPROP) {
-            *const_cast<std::string*>(&m_rule) = "prop " + rule;
-            m_ruleType                         = RULE_PROP;
-            Debug::log(LOG, "CWindowRule: direct prop rule found, rewritten {} -> {}", rule, m_rule);
+        if (NWindowProperties::intWindowProperties.find(VARS[0]) != NWindowProperties::intWindowProperties.end() ||
+            NWindowProperties::boolWindowProperties.find(VARS[0]) != NWindowProperties::boolWindowProperties.end() ||
+            NWindowProperties::floatWindowProperties.find(VARS[0]) != NWindowProperties::floatWindowProperties.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?!");
-            m_ruleType = RULE_INVALID;
+            ruleType = RULE_INVALID;
         }
     }
 }

src/desktop/WindowRule.hpp

@@ -38,36 +38,34 @@ class CWindowRule {
         RULE_PROP,
         RULE_CONTENT,
         RULE_PERSISTENTSIZE,
-        RULE_NOCLOSEFOR,
     };
 
-    eRuleType         m_ruleType = RULE_INVALID;
+    eRuleType         ruleType = RULE_INVALID;
 
-    const std::string m_value;
-    const std::string m_rule;
-    const bool        m_v2       = false;
-    const bool        m_execRule = false;
+    const std::string szValue;
+    const std::string szRule;
+    const bool        v2       = false;
+    const bool        execRule = false;
 
-    std::string       m_title;
-    std::string       m_class;
-    std::string       m_initialTitle;
-    std::string       m_initialClass;
-    std::string       m_tag;
-    int               m_X11             = -1; // -1 means "ANY"
-    int               m_floating        = -1;
-    int               m_fullscreen      = -1;
-    int               m_pinned          = -1;
-    int               m_focus           = -1;
-    std::string       m_fullscreenState = ""; // empty means any
-    std::string       m_onWorkspace     = ""; // empty means any
-    std::string       m_workspace       = ""; // empty means any
-    std::string       m_contentType     = ""; // empty means any
-    std::string       m_xdgTag          = ""; // empty means any
+    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
+    std::string       szContentType     = ""; // empty means any
 
     // precompiled regexes
-    CRuleRegexContainer m_titleRegex;
-    CRuleRegexContainer m_classRegex;
-    CRuleRegexContainer m_initialTitleRegex;
-    CRuleRegexContainer m_initialClassRegex;
-    CRuleRegexContainer m_v1Regex;
+    CRuleRegexContainer rTitle;
+    CRuleRegexContainer rClass;
+    CRuleRegexContainer rInitialTitle;
+    CRuleRegexContainer rInitialClass;
+    CRuleRegexContainer rV1Regex;
 };

src/desktop/Workspace.cpp

@@ -17,76 +17,76 @@ PHLWORKSPACE CWorkspace::create(WORKSPACEID id, PHLMONITOR monitor, std::string
 }
 
 CWorkspace::CWorkspace(WORKSPACEID id, PHLMONITOR monitor, std::string name, bool special, bool isEmpty) :
-    m_id(id), m_name(name), m_monitor(monitor), m_isSpecialWorkspace(special), m_wasCreatedEmpty(isEmpty) {
+    m_iID(id), m_szName(name), m_pMonitor(monitor), m_bIsSpecialWorkspace(special), m_bWasCreatedEmpty(isEmpty) {
     ;
 }
 
 void CWorkspace::init(PHLWORKSPACE self) {
-    m_self = self;
+    m_pSelf = self;
 
-    g_pAnimationManager->createAnimation(Vector2D(0, 0), m_renderOffset, g_pConfigManager->getAnimationPropertyConfig(m_isSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"),
-                                         self, AVARDAMAGE_ENTIRE);
-    g_pAnimationManager->createAnimation(1.f, m_alpha, g_pConfigManager->getAnimationPropertyConfig(m_isSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"), self,
+    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())
-        m_name = RULEFORTHIS.defaultName.value();
+        m_szName = RULEFORTHIS.defaultName.value();
 
-    m_focusedWindowHook = g_pHookSystem->hookDynamic("closeWindow", [this](void* self, SCallbackInfo& info, std::any param) {
+    m_pFocusedWindowHook = g_pHookSystem->hookDynamic("closeWindow", [this](void* self, SCallbackInfo& info, std::any param) {
         const auto PWINDOW = std::any_cast<PHLWINDOW>(param);
 
-        if (PWINDOW == m_lastFocusedWindow.lock())
-            m_lastFocusedWindow.reset();
+        if (PWINDOW == m_pLastFocusedWindow.lock())
+            m_pLastFocusedWindow.reset();
     });
 
-    m_inert = false;
+    m_bInert = false;
 
     const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(self);
-    m_persistent             = WORKSPACERULE.isPersistent;
+    m_bPersistent            = WORKSPACERULE.isPersistent;
 
-    if (self->m_wasCreatedEmpty)
+    if (self->m_bWasCreatedEmpty)
         if (auto cmd = WORKSPACERULE.onCreatedEmptyRunCmd)
-            CKeybindManager::spawnWithRules(*cmd, self);
+            g_pKeybindManager->spawnWithRules(*cmd, self);
 
-    g_pEventManager->postEvent({.event = "createworkspace", .data = m_name});
-    g_pEventManager->postEvent({.event = "createworkspacev2", .data = std::format("{},{}", m_id, m_name)});
+    g_pEventManager->postEvent({"createworkspace", m_szName});
+    g_pEventManager->postEvent({"createworkspacev2", std::format("{},{}", m_iID, m_szName)});
     EMIT_HOOK_EVENT("createWorkspace", this);
 }
 
 SWorkspaceIDName CWorkspace::getPrevWorkspaceIDName() const {
-    return m_prevWorkspace;
+    return m_sPrevWorkspace;
 }
 
 CWorkspace::~CWorkspace() {
-    Debug::log(LOG, "Destroying workspace ID {}", m_id);
+    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.
     if (g_pHookSystem)
-        g_pHookSystem->unhook(m_focusedWindowHook);
+        g_pHookSystem->unhook(m_pFocusedWindowHook);
 
     if (g_pEventManager) {
-        g_pEventManager->postEvent({.event = "destroyworkspace", .data = m_name});
-        g_pEventManager->postEvent({.event = "destroyworkspacev2", .data = std::format("{},{}", m_id, m_name)});
+        g_pEventManager->postEvent({"destroyworkspace", m_szName});
+        g_pEventManager->postEvent({"destroyworkspacev2", std::format("{},{}", m_iID, m_szName)});
         EMIT_HOOK_EVENT("destroyWorkspace", this);
     }
 }
 
 void CWorkspace::startAnim(bool in, bool left, bool instant) {
     if (!instant) {
-        const std::string ANIMNAME = std::format("{}{}", m_isSpecialWorkspace ? "specialWorkspace" : "workspaces", in ? "In" : "Out");
+        const std::string ANIMNAME = std::format("{}{}", m_bIsSpecialWorkspace ? "specialWorkspace" : "workspaces", in ? "In" : "Out");
 
-        m_alpha->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
-        m_renderOffset->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
+        m_fAlpha->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
+        m_vRenderOffset->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
     }
 
-    const auto  ANIMSTYLE     = m_alpha->getStyle();
+    const auto  ANIMSTYLE     = m_fAlpha->getStyle();
     static auto PWORKSPACEGAP = CConfigValue<Hyprlang::INT>("general:gaps_workspaces");
 
     // set floating windows offset callbacks
-    m_renderOffset->setUpdateCallback([&](auto) {
-        for (auto const& w : g_pCompositor->m_windows) {
-            if (!validMapped(w) || w->workspaceID() != m_id)
+    m_vRenderOffset->setUpdateCallback([&](auto) {
+        for (auto const& w : g_pCompositor->m_vWindows) {
+            if (!validMapped(w) || w->workspaceID() != m_iID)
                 continue;
 
             w->onWorkspaceAnimUpdate();
@@ -94,7 +94,7 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
     });
 
     if (ANIMSTYLE.starts_with("slidefade")) {
-        const auto PMONITOR = m_monitor.lock();
+        const auto PMONITOR = m_pMonitor.lock();
         float      movePerc = 100.f;
 
         if (ANIMSTYLE.find('%') != std::string::npos) {
@@ -104,84 +104,84 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
             } catch (std::exception& e) { Debug::log(ERR, "Error in startAnim: invalid percentage"); }
         }
 
-        m_alpha->setValueAndWarp(1.f);
-        m_renderOffset->setValueAndWarp(Vector2D(0, 0));
+        m_fAlpha->setValueAndWarp(1.f);
+        m_vRenderOffset->setValueAndWarp(Vector2D(0, 0));
 
         if (ANIMSTYLE.starts_with("slidefadevert")) {
             if (in) {
-                m_alpha->setValueAndWarp(0.f);
-                m_renderOffset->setValueAndWarp(Vector2D(0.0, (left ? PMONITOR->m_size.y : -PMONITOR->m_size.y) * (movePerc / 100.f)));
-                *m_alpha        = 1.f;
-                *m_renderOffset = 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_alpha->setValueAndWarp(1.f);
-                *m_alpha        = 0.f;
-                *m_renderOffset = Vector2D(0.0, (left ? -PMONITOR->m_size.y : PMONITOR->m_size.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_alpha->setValueAndWarp(0.f);
-                m_renderOffset->setValueAndWarp(Vector2D((left ? PMONITOR->m_size.x : -PMONITOR->m_size.x) * (movePerc / 100.f), 0.0));
-                *m_alpha        = 1.f;
-                *m_renderOffset = 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_alpha->setValueAndWarp(1.f);
-                *m_alpha        = 0.f;
-                *m_renderOffset = Vector2D((left ? -PMONITOR->m_size.x : PMONITOR->m_size.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_renderOffset->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_alpha->setValueAndWarp(0.f);
-            *m_alpha = 1.f;
+            m_fAlpha->setValueAndWarp(0.f);
+            *m_fAlpha = 1.f;
         } else {
-            m_alpha->setValueAndWarp(1.f);
-            *m_alpha = 0.f;
+            m_fAlpha->setValueAndWarp(1.f);
+            *m_fAlpha = 0.f;
         }
     } else if (ANIMSTYLE == "slidevert") {
         // fallback is slide
-        const auto PMONITOR  = m_monitor.lock();
-        const auto YDISTANCE = PMONITOR->m_size.y + *PWORKSPACEGAP;
+        const auto PMONITOR  = m_pMonitor.lock();
+        const auto YDISTANCE = PMONITOR->vecSize.y + *PWORKSPACEGAP;
 
-        m_alpha->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_renderOffset->setValueAndWarp(Vector2D(0.0, left ? YDISTANCE : -YDISTANCE));
-            *m_renderOffset = Vector2D(0, 0);
+            m_vRenderOffset->setValueAndWarp(Vector2D(0.0, left ? YDISTANCE : -YDISTANCE));
+            *m_vRenderOffset = Vector2D(0, 0);
         } else {
-            *m_renderOffset = Vector2D(0.0, left ? -YDISTANCE : YDISTANCE);
+            *m_vRenderOffset = Vector2D(0.0, left ? -YDISTANCE : YDISTANCE);
         }
     } else {
         // fallback is slide
-        const auto PMONITOR  = m_monitor.lock();
-        const auto XDISTANCE = PMONITOR->m_size.x + *PWORKSPACEGAP;
+        const auto PMONITOR  = m_pMonitor.lock();
+        const auto XDISTANCE = PMONITOR->vecSize.x + *PWORKSPACEGAP;
 
-        m_alpha->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_renderOffset->setValueAndWarp(Vector2D(left ? XDISTANCE : -XDISTANCE, 0.0));
-            *m_renderOffset = Vector2D(0, 0);
+            m_vRenderOffset->setValueAndWarp(Vector2D(left ? XDISTANCE : -XDISTANCE, 0.0));
+            *m_vRenderOffset = Vector2D(0, 0);
         } else {
-            *m_renderOffset = Vector2D(left ? -XDISTANCE : XDISTANCE, 0.0);
+            *m_vRenderOffset = Vector2D(left ? -XDISTANCE : XDISTANCE, 0.0);
         }
     }
 
-    if (m_isSpecialWorkspace) {
+    if (m_bIsSpecialWorkspace) {
         // required for open/close animations
         if (in) {
-            m_alpha->setValueAndWarp(0.f);
-            *m_alpha = 1.f;
+            m_fAlpha->setValueAndWarp(0.f);
+            *m_fAlpha = 1.f;
         } else {
-            m_alpha->setValueAndWarp(1.f);
-            *m_alpha = 0.f;
+            m_fAlpha->setValueAndWarp(1.f);
+            *m_fAlpha = 0.f;
         }
     }
 
     if (instant) {
-        m_renderOffset->warp();
-        m_alpha->warp();
+        m_vRenderOffset->warp();
+        m_fAlpha->warp();
     }
 }
 
@@ -194,39 +194,39 @@ void CWorkspace::moveToMonitor(const MONITORID& id) {
 }
 
 PHLWINDOW CWorkspace::getLastFocusedWindow() {
-    if (!validMapped(m_lastFocusedWindow) || m_lastFocusedWindow->workspaceID() != m_id)
+    if (!validMapped(m_pLastFocusedWindow) || m_pLastFocusedWindow->workspaceID() != m_iID)
         return nullptr;
 
-    return m_lastFocusedWindow.lock();
+    return m_pLastFocusedWindow.lock();
 }
 
 void CWorkspace::rememberPrevWorkspace(const PHLWORKSPACE& prev) {
     if (!prev) {
-        m_prevWorkspace.id   = -1;
-        m_prevWorkspace.name = "";
+        m_sPrevWorkspace.id   = -1;
+        m_sPrevWorkspace.name = "";
         return;
     }
 
-    if (prev->m_id == m_id) {
+    if (prev->m_iID == m_iID) {
         Debug::log(LOG, "Tried to set prev workspace to the same as current one");
         return;
     }
 
-    m_prevWorkspace.id   = prev->m_id;
-    m_prevWorkspace.name = prev->m_name;
+    m_sPrevWorkspace.id   = prev->m_iID;
+    m_sPrevWorkspace.name = prev->m_szName;
 
-    prev->m_monitor->addPrevWorkspaceID(prev->m_id);
+    prev->m_pMonitor->addPrevWorkspaceID(prev->m_iID);
 }
 
 std::string CWorkspace::getConfigName() {
-    if (m_isSpecialWorkspace) {
-        return m_name;
+    if (m_bIsSpecialWorkspace) {
+        return m_szName;
     }
 
-    if (m_id > 0)
-        return std::to_string(m_id);
+    if (m_iID > 0)
+        return std::to_string(m_iID);
 
-    return "name:" + m_name;
+    return "name:" + m_szName;
 }
 
 bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
@@ -241,12 +241,12 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
         if (wsid == WORKSPACE_INVALID)
             return false;
 
-        return wsid == m_id;
+        return wsid == m_iID;
 
     } else if (selector.starts_with("name:")) {
-        return m_name == selector.substr(5);
+        return m_szName == selector.substr(5);
     } else if (selector.starts_with("special")) {
-        return m_name == selector;
+        return m_szName == selector;
     } else {
         // parse selector
 
@@ -306,7 +306,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
                     return false;
                 }
 
-                if (std::clamp(m_id, from, to) != m_id)
+                if (std::clamp(m_iID, from, to) != m_iID)
                     return false;
                 continue;
             }
@@ -321,7 +321,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 const auto SHOULDBESPECIAL = configStringToInt(prop);
 
-                if (SHOULDBESPECIAL && (bool)*SHOULDBESPECIAL != m_isSpecialWorkspace)
+                if (SHOULDBESPECIAL && (bool)*SHOULDBESPECIAL != m_bIsSpecialWorkspace)
                     return false;
                 continue;
             }
@@ -336,7 +336,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 const auto PMONITOR = g_pCompositor->getMonitorFromString(prop);
 
-                if (!(PMONITOR ? PMONITOR == m_monitor : false))
+                if (!(PMONITOR ? PMONITOR == m_pMonitor : false))
                     return false;
                 continue;
             }
@@ -349,14 +349,14 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 prop = prop.substr(2, prop.length() - 3);
 
-                if (prop.starts_with("s:") && !m_name.starts_with(prop.substr(2)))
+                if (prop.starts_with("s:") && !m_szName.starts_with(prop.substr(2)))
                     return false;
-                if (prop.starts_with("e:") && !m_name.ends_with(prop.substr(2)))
+                if (prop.starts_with("e:") && !m_szName.ends_with(prop.substr(2)))
                     return false;
 
                 const auto WANTSNAMED = configStringToInt(prop);
 
-                if (WANTSNAMED && *WANTSNAMED != (m_id <= -1337))
+                if (WANTSNAMED && *WANTSNAMED != (m_iID <= -1337))
                     return false;
                 continue;
             }
@@ -481,15 +481,15 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 switch (FSSTATE) {
                     case -1: // no fullscreen
-                        if (m_hasFullscreenWindow)
+                        if (m_bHasFullscreenWindow)
                             return false;
                         break;
                     case 0: // fullscreen full
-                        if (!m_hasFullscreenWindow || m_fullscreenMode != FSMODE_FULLSCREEN)
+                        if (!m_bHasFullscreenWindow || m_efFullscreenMode != FSMODE_FULLSCREEN)
                             return false;
                         break;
                     case 1: // maximized
-                        if (!m_hasFullscreenWindow || m_fullscreenMode != FSMODE_MAXIMIZED)
+                        if (!m_bHasFullscreenWindow || m_efFullscreenMode != FSMODE_MAXIMIZED)
                             return false;
                         break;
                     default: break;
@@ -509,23 +509,23 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 }
 
 void CWorkspace::markInert() {
-    m_inert   = true;
-    m_id      = WORKSPACE_INVALID;
-    m_visible = false;
-    m_monitor.reset();
+    m_bInert   = true;
+    m_iID      = WORKSPACE_INVALID;
+    m_bVisible = false;
+    m_pMonitor.reset();
 }
 
 bool CWorkspace::inert() {
-    return m_inert;
+    return m_bInert;
 }
 
 MONITORID CWorkspace::monitorID() {
-    return m_monitor ? m_monitor->m_id : MONITOR_INVALID;
+    return m_pMonitor ? m_pMonitor->ID : MONITOR_INVALID;
 }
 
 PHLWINDOW CWorkspace::getFullscreenWindow() {
-    for (auto const& w : g_pCompositor->m_windows) {
-        if (w->m_workspace == m_self && w->isFullscreen())
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (w->m_pWorkspace == m_pSelf && w->isFullscreen())
             return w;
     }
 
@@ -533,25 +533,25 @@ PHLWINDOW CWorkspace::getFullscreenWindow() {
 }
 
 bool CWorkspace::isVisible() {
-    return m_visible;
+    return m_bVisible;
 }
 
 bool CWorkspace::isVisibleNotCovered() {
-    const auto PMONITOR = m_monitor.lock();
-    if (PMONITOR->m_activeSpecialWorkspace)
-        return PMONITOR->m_activeSpecialWorkspace->m_id == m_id;
+    const auto PMONITOR = m_pMonitor.lock();
+    if (PMONITOR->activeSpecialWorkspace)
+        return PMONITOR->activeSpecialWorkspace->m_iID == m_iID;
 
-    return PMONITOR->m_activeWorkspace->m_id == m_id;
+    return PMONITOR->activeWorkspace->m_iID == m_iID;
 }
 
 int CWorkspace::getWindows(std::optional<bool> onlyTiled, std::optional<bool> onlyPinned, std::optional<bool> onlyVisible) {
     int no = 0;
-    for (auto const& w : g_pCompositor->m_windows) {
-        if (w->workspaceID() != m_id || !w->m_isMapped)
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (w->workspaceID() != m_iID || !w->m_bIsMapped)
             continue;
-        if (onlyTiled.has_value() && w->m_isFloating == onlyTiled.value())
+        if (onlyTiled.has_value() && w->m_bIsFloating == onlyTiled.value())
             continue;
-        if (onlyPinned.has_value() && w->m_pinned != onlyPinned.value())
+        if (onlyPinned.has_value() && w->m_bPinned != onlyPinned.value())
             continue;
         if (onlyVisible.has_value() && w->isHidden() == onlyVisible.value())
             continue;
@@ -563,14 +563,14 @@ int CWorkspace::getWindows(std::optional<bool> onlyTiled, std::optional<bool> on
 
 int CWorkspace::getGroups(std::optional<bool> onlyTiled, std::optional<bool> onlyPinned, std::optional<bool> onlyVisible) {
     int no = 0;
-    for (auto const& w : g_pCompositor->m_windows) {
-        if (w->workspaceID() != m_id || !w->m_isMapped)
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (w->workspaceID() != m_iID || !w->m_bIsMapped)
             continue;
-        if (!w->m_groupData.head)
+        if (!w->m_sGroupData.head)
             continue;
-        if (onlyTiled.has_value() && w->m_isFloating == onlyTiled.value())
+        if (onlyTiled.has_value() && w->m_bIsFloating == onlyTiled.value())
             continue;
-        if (onlyPinned.has_value() && w->m_pinned != onlyPinned.value())
+        if (onlyPinned.has_value() && w->m_bPinned != onlyPinned.value())
             continue;
         if (onlyVisible.has_value() && w->isHidden() == onlyVisible.value())
             continue;
@@ -580,8 +580,8 @@ int CWorkspace::getGroups(std::optional<bool> onlyTiled, std::optional<bool> onl
 }
 
 PHLWINDOW CWorkspace::getFirstWindow() {
-    for (auto const& w : g_pCompositor->m_windows) {
-        if (w->m_workspace == m_self && w->m_isMapped && !w->isHidden())
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (w->m_pWorkspace == m_pSelf && w->m_bIsMapped && !w->isHidden())
             return w;
     }
 
@@ -589,27 +589,32 @@ PHLWINDOW CWorkspace::getFirstWindow() {
 }
 
 PHLWINDOW CWorkspace::getTopLeftWindow() {
-    const auto PMONITOR = m_monitor.lock();
+    const auto PMONITOR = m_pMonitor.lock();
 
-    for (auto const& w : g_pCompositor->m_windows) {
-        if (w->m_workspace != m_self || !w->m_isMapped || w->isHidden())
+    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->m_position.x + 1 && WINDOWIDEALBB.y <= PMONITOR->m_position.y + 1)
+        if (WINDOWIDEALBB.x <= PMONITOR->vecPosition.x + 1 && WINDOWIDEALBB.y <= PMONITOR->vecPosition.y + 1)
             return w;
     }
     return nullptr;
 }
 
 bool CWorkspace::hasUrgentWindow() {
-    return std::ranges::any_of(g_pCompositor->m_windows, [this](const auto& w) { return w->m_workspace == m_self && w->m_isMapped && w->m_isUrgent; });
+    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_windows) {
-        if (w->m_workspace != m_self)
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (w->m_pWorkspace != m_pSelf)
             continue;
 
         w->updateWindowDecos();
@@ -617,10 +622,10 @@ void CWorkspace::updateWindowDecos() {
 }
 
 void CWorkspace::updateWindowData() {
-    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_self.lock());
+    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_pSelf.lock());
 
-    for (auto const& w : g_pCompositor->m_windows) {
-        if (w->m_workspace != m_self)
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (w->m_pWorkspace != m_pSelf)
             continue;
 
         w->updateWindowData(WORKSPACERULE);
@@ -628,8 +633,8 @@ void CWorkspace::updateWindowData() {
 }
 
 void CWorkspace::forceReportSizesToWindows() {
-    for (auto const& w : g_pCompositor->m_windows) {
-        if (w->m_workspace != m_self || !w->m_isMapped || w->isHidden())
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (w->m_pWorkspace != m_pSelf || !w->m_bIsMapped || w->isHidden())
             continue;
 
         w->sendWindowSize(true);
@@ -637,26 +642,26 @@ void CWorkspace::forceReportSizesToWindows() {
 }
 
 void CWorkspace::rename(const std::string& name) {
-    if (g_pCompositor->isWorkspaceSpecial(m_id))
+    if (g_pCompositor->isWorkspaceSpecial(m_iID))
         return;
 
-    Debug::log(LOG, "CWorkspace::rename: Renaming workspace {} to '{}'", m_id, name);
-    m_name = name;
+    Debug::log(LOG, "CWorkspace::rename: Renaming workspace {} to '{}'", m_iID, name);
+    m_szName = name;
 
-    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_self.lock());
-    m_persistent             = WORKSPACERULE.isPersistent;
+    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_pSelf.lock());
+    m_bPersistent            = WORKSPACERULE.isPersistent;
 
     if (WORKSPACERULE.isPersistent)
-        g_pCompositor->ensurePersistentWorkspacesPresent(std::vector<SWorkspaceRule>{WORKSPACERULE}, m_self.lock());
+        g_pCompositor->ensurePersistentWorkspacesPresent(std::vector<SWorkspaceRule>{WORKSPACERULE}, m_pSelf.lock());
 
-    g_pEventManager->postEvent({.event = "renameworkspace", .data = std::to_string(m_id) + "," + m_name});
+    g_pEventManager->postEvent({"renameworkspace", std::to_string(m_iID) + "," + m_szName});
 }
 
 void CWorkspace::updateWindows() {
-    m_hasFullscreenWindow = std::ranges::any_of(g_pCompositor->m_windows, [this](const auto& w) { return w->m_isMapped && w->m_workspace == m_self && w->isFullscreen(); });
+    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_windows) {
-        if (!w->m_isMapped || w->m_workspace != m_self)
+    for (auto const& w : g_pCompositor->m_vWindows) {
+        if (!w->m_bIsMapped || w->m_pWorkspace != m_pSelf)
             continue;
 
         w->updateDynamicRules();

src/desktop/Workspace.hpp

@@ -2,6 +2,7 @@
 
 #include "../helpers/AnimatedVariable.hpp"
 #include <string>
+#include "../defines.hpp"
 #include "DesktopTypes.hpp"
 #include "../helpers/MiscFunctions.hpp"
 
@@ -23,39 +24,39 @@ class CWorkspace {
 
     // Workspaces ID-based have IDs > 0
     // and workspaces name-based have IDs starting with -1337
-    WORKSPACEID     m_id   = WORKSPACE_INVALID;
-    std::string     m_name = "";
-    PHLMONITORREF   m_monitor;
+    WORKSPACEID     m_iID    = WORKSPACE_INVALID;
+    std::string     m_szName = "";
+    PHLMONITORREF   m_pMonitor;
 
-    bool            m_hasFullscreenWindow = false;
-    eFullscreenMode m_fullscreenMode      = FSMODE_NONE;
+    bool            m_bHasFullscreenWindow = false;
+    eFullscreenMode m_efFullscreenMode     = FSMODE_NONE;
 
     wl_array        m_wlrCoordinateArr;
 
     // for animations
-    PHLANIMVAR<Vector2D> m_renderOffset;
-    PHLANIMVAR<float>    m_alpha;
-    bool                 m_forceRendering = false;
+    PHLANIMVAR<Vector2D> m_vRenderOffset;
+    PHLANIMVAR<float>    m_fAlpha;
+    bool                 m_bForceRendering = false;
 
     // allows damage to propagate.
-    bool m_visible = false;
+    bool m_bVisible = false;
 
     // "scratchpad"
-    bool m_isSpecialWorkspace = false;
+    bool m_bIsSpecialWorkspace = false;
 
     // last window
-    PHLWINDOWREF m_lastFocusedWindow;
+    PHLWINDOWREF m_pLastFocusedWindow;
 
     // user-set
-    bool m_defaultFloating = false;
-    bool m_defaultPseudo   = false;
+    bool m_bDefaultFloating = false;
+    bool m_bDefaultPseudo   = false;
 
     // last monitor (used on reconnect)
-    std::string m_lastMonitor = "";
+    std::string m_szLastMonitor = "";
 
-    bool        m_wasCreatedEmpty = true;
+    bool        m_bWasCreatedEmpty = true;
 
-    bool        m_persistent = false;
+    bool        m_bPersistent = false;
 
     // Inert: destroyed and invalid. If this is true, release the ptr you have.
     bool             inert();
@@ -87,11 +88,11 @@ class CWorkspace {
     void init(PHLWORKSPACE self);
     // Previous workspace ID and name is stored during a workspace change, allowing travel
     // to the previous workspace.
-    SWorkspaceIDName     m_prevWorkspace;
+    SWorkspaceIDName     m_sPrevWorkspace;
 
-    SP<HOOK_CALLBACK_FN> m_focusedWindowHook;
-    bool                 m_inert = true;
-    WP<CWorkspace>       m_self;
+    SP<HOOK_CALLBACK_FN> m_pFocusedWindowHook;
+    bool                 m_bInert = true;
+    WP<CWorkspace>       m_pSelf;
 };
 
 inline bool valid(const PHLWORKSPACE& ref) {

src/devices/IHID.hpp

@@ -34,8 +34,7 @@ class IHID {
 
     struct {
         CSignal destroy;
-    } m_events;
+    } events;
 
-    std::string m_deviceName;
-    std::string m_hlName;
+    std::string deviceName, hlName;
 };

src/devices/IKeyboard.cpp

@@ -28,38 +28,38 @@ eHIDType IKeyboard::getType() {
 }
 
 IKeyboard::~IKeyboard() {
-    m_events.destroy.emit();
+    events.destroy.emit();
 
     clearManuallyAllocd();
 }
 
 void IKeyboard::clearManuallyAllocd() {
-    if (m_xkbStaticState)
-        xkb_state_unref(m_xkbStaticState);
+    if (xkbStaticState)
+        xkb_state_unref(xkbStaticState);
 
-    if (m_xkbState)
-        xkb_state_unref(m_xkbState);
+    if (xkbState)
+        xkb_state_unref(xkbState);
 
-    if (m_xkbKeymap)
-        xkb_keymap_unref(m_xkbKeymap);
+    if (xkbKeymap)
+        xkb_keymap_unref(xkbKeymap);
 
-    if (m_xkbSymState)
-        xkb_state_unref(m_xkbSymState);
+    if (xkbSymState)
+        xkb_state_unref(xkbSymState);
 
-    m_xkbSymState    = nullptr;
-    m_xkbKeymap      = nullptr;
-    m_xkbState       = nullptr;
-    m_xkbStaticState = nullptr;
-    m_xkbKeymapFD.reset();
+    xkbSymState    = nullptr;
+    xkbKeymap      = nullptr;
+    xkbState       = nullptr;
+    xkbStaticState = nullptr;
+    xkbKeymapFD.reset();
 }
 
 void IKeyboard::setKeymap(const SStringRuleNames& rules) {
-    if (m_keymapOverridden) {
+    if (keymapOverridden) {
         Debug::log(LOG, "Ignoring setKeymap: keymap is overridden");
         return;
     }
 
-    m_currentRules          = rules;
+    currentRules            = rules;
     xkb_rule_names XKBRULES = {
         .rules   = rules.rules.c_str(),
         .model   = rules.model.c_str(),
@@ -80,21 +80,21 @@ void IKeyboard::setKeymap(const SStringRuleNames& rules) {
     Debug::log(LOG, "Attempting to create a keymap for layout {} with variant {} (rules: {}, model: {}, options: {})", rules.layout, rules.variant, rules.rules, rules.model,
                rules.options);
 
-    if (!m_xkbFilePath.empty()) {
-        auto path = absolutePath(m_xkbFilePath, g_pConfigManager->m_configCurrentPath);
+    if (!xkbFilePath.empty()) {
+        auto path = absolutePath(xkbFilePath, g_pConfigManager->configCurrentPath);
 
         if (FILE* const KEYMAPFILE = fopen(path.c_str(), "r"); !KEYMAPFILE)
             Debug::log(ERR, "Cannot open input:kb_file= file for reading");
         else {
-            m_xkbKeymap = xkb_keymap_new_from_file(CONTEXT, KEYMAPFILE, XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
+            xkbKeymap = xkb_keymap_new_from_file(CONTEXT, KEYMAPFILE, XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
             fclose(KEYMAPFILE);
         }
     }
 
-    if (!m_xkbKeymap)
-        m_xkbKeymap = xkb_keymap_new_from_names(CONTEXT, &XKBRULES, XKB_KEYMAP_COMPILE_NO_FLAGS);
+    if (!xkbKeymap)
+        xkbKeymap = xkb_keymap_new_from_names(CONTEXT, &XKBRULES, XKB_KEYMAP_COMPILE_NO_FLAGS);
 
-    if (!m_xkbKeymap) {
+    if (!xkbKeymap) {
         g_pConfigManager->addParseError("Invalid keyboard layout passed. ( rules: " + rules.rules + ", model: " + rules.model + ", variant: " + rules.variant +
                                         ", options: " + rules.options + ", layout: " + rules.layout + " )");
 
@@ -102,38 +102,38 @@ void IKeyboard::setKeymap(const SStringRuleNames& rules) {
                    rules.options);
         memset(&XKBRULES, 0, sizeof(XKBRULES));
 
-        m_currentRules.rules   = "";
-        m_currentRules.model   = "";
-        m_currentRules.variant = "";
-        m_currentRules.options = "";
-        m_currentRules.layout  = "us";
+        currentRules.rules   = "";
+        currentRules.model   = "";
+        currentRules.variant = "";
+        currentRules.options = "";
+        currentRules.layout  = "us";
 
-        m_xkbKeymap = xkb_keymap_new_from_names(CONTEXT, &XKBRULES, XKB_KEYMAP_COMPILE_NO_FLAGS);
+        xkbKeymap = xkb_keymap_new_from_names(CONTEXT, &XKBRULES, XKB_KEYMAP_COMPILE_NO_FLAGS);
     }
 
-    updateXKBTranslationState(m_xkbKeymap);
+    updateXKBTranslationState(xkbKeymap);
 
-    const auto NUMLOCKON = g_pConfigManager->getDeviceInt(m_hlName, "numlock_by_default", "input:numlock_by_default");
+    const auto NUMLOCKON = g_pConfigManager->getDeviceInt(hlName, "numlock_by_default", "input:numlock_by_default");
 
     if (NUMLOCKON == 1) {
         // lock numlock
-        const auto IDX = xkb_map_mod_get_index(m_xkbKeymap, XKB_MOD_NAME_NUM);
+        const auto IDX = xkb_map_mod_get_index(xkbKeymap, XKB_MOD_NAME_NUM);
 
         if (IDX != XKB_MOD_INVALID)
-            m_modifiersState.locked |= (uint32_t)1 << IDX;
+            modifiersState.locked |= (uint32_t)1 << IDX;
 
         // 0 to avoid mods getting stuck if depressed during reload
-        updateModifiers(0, 0, m_modifiersState.locked, m_modifiersState.group);
+        updateModifiers(0, 0, modifiersState.locked, modifiersState.group);
     }
 
-    for (size_t i = 0; i < std::min(LEDNAMES.size(), m_ledIndexes.size()); ++i) {
-        m_ledIndexes[i] = xkb_map_led_get_index(m_xkbKeymap, LEDNAMES[i]);
-        Debug::log(LOG, "xkb: LED index {} (name {}) got index {}", i, LEDNAMES[i], m_ledIndexes[i]);
+    for (size_t i = 0; i < std::min(LEDNAMES.size(), ledIndexes.size()); ++i) {
+        ledIndexes[i] = xkb_map_led_get_index(xkbKeymap, LEDNAMES[i]);
+        Debug::log(LOG, "xkb: LED index {} (name {}) got index {}", i, LEDNAMES[i], ledIndexes[i]);
     }
 
-    for (size_t i = 0; i < std::min(MODNAMES.size(), m_modIndexes.size()); ++i) {
-        m_modIndexes[i] = xkb_map_mod_get_index(m_xkbKeymap, MODNAMES[i]);
-        Debug::log(LOG, "xkb: Mod index {} (name {}) got index {}", i, MODNAMES[i], m_modIndexes[i]);
+    for (size_t i = 0; i < std::min(MODNAMES.size(), modIndexes.size()); ++i) {
+        modIndexes[i] = xkb_map_mod_get_index(xkbKeymap, MODNAMES[i]);
+        Debug::log(LOG, "xkb: Mod index {} (name {}) got index {}", i, MODNAMES[i], modIndexes[i]);
     }
 
     updateKeymapFD();
@@ -144,59 +144,59 @@ void IKeyboard::setKeymap(const SStringRuleNames& rules) {
 }
 
 void IKeyboard::updateKeymapFD() {
-    Debug::log(LOG, "Updating keymap fd for keyboard {}", m_deviceName);
+    Debug::log(LOG, "Updating keymap fd for keyboard {}", deviceName);
 
-    if (m_xkbKeymapFD.isValid())
-        m_xkbKeymapFD.reset();
+    if (xkbKeymapFD.isValid())
+        xkbKeymapFD.reset();
 
-    auto cKeymapStr   = xkb_keymap_get_as_string(m_xkbKeymap, XKB_KEYMAP_FORMAT_TEXT_V1);
-    m_xkbKeymapString = cKeymapStr;
+    auto cKeymapStr = xkb_keymap_get_as_string(xkbKeymap, XKB_KEYMAP_FORMAT_TEXT_V1);
+    xkbKeymapString = cKeymapStr;
     free(cKeymapStr);
 
     CFileDescriptor rw, ro;
-    if (!allocateSHMFilePair(m_xkbKeymapString.length() + 1, 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, m_xkbKeymapString.length() + 1, PROT_READ | PROT_WRITE, MAP_SHARED, rw.get(), 0);
+        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");
             ro.reset();
         } else {
-            memcpy(keymapFDDest, m_xkbKeymapString.c_str(), m_xkbKeymapString.length());
-            munmap(keymapFDDest, m_xkbKeymapString.length() + 1);
-            m_xkbKeymapFD = std::move(ro);
+            memcpy(keymapFDDest, xkbKeymapString.c_str(), xkbKeymapString.length());
+            munmap(keymapFDDest, xkbKeymapString.length() + 1);
+            xkbKeymapFD = std::move(ro);
         }
     }
 
-    Debug::log(LOG, "Updated keymap fd to {}", m_xkbKeymapFD.get());
+    Debug::log(LOG, "Updated keymap fd to {}", xkbKeymapFD.get());
 }
 
 void IKeyboard::updateXKBTranslationState(xkb_keymap* const keymap) {
 
-    if (m_xkbStaticState)
-        xkb_state_unref(m_xkbStaticState);
+    if (xkbStaticState)
+        xkb_state_unref(xkbStaticState);
 
-    if (m_xkbState)
-        xkb_state_unref(m_xkbState);
+    if (xkbState)
+        xkb_state_unref(xkbState);
 
-    if (m_xkbSymState)
-        xkb_state_unref(m_xkbSymState);
+    if (xkbSymState)
+        xkb_state_unref(xkbSymState);
 
-    m_xkbState       = nullptr;
-    m_xkbStaticState = nullptr;
-    m_xkbSymState    = nullptr;
+    xkbState       = nullptr;
+    xkbStaticState = nullptr;
+    xkbSymState    = nullptr;
 
     if (keymap) {
         Debug::log(LOG, "Updating keyboard {:x}'s translation state from a provided keymap", (uintptr_t)this);
-        m_xkbStaticState = xkb_state_new(keymap);
-        m_xkbState       = xkb_state_new(keymap);
-        m_xkbSymState    = xkb_state_new(keymap);
+        xkbStaticState = xkb_state_new(keymap);
+        xkbState       = xkb_state_new(keymap);
+        xkbSymState    = xkb_state_new(keymap);
         return;
     }
 
-    const auto KEYMAP     = m_xkbKeymap;
-    const auto STATE      = m_xkbState;
+    const auto KEYMAP     = xkbKeymap;
+    const auto STATE      = xkbState;
     const auto LAYOUTSNUM = xkb_keymap_num_layouts(KEYMAP);
 
     const auto PCONTEXT = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
@@ -205,9 +205,9 @@ void IKeyboard::updateXKBTranslationState(xkb_keymap* const keymap) {
         if (xkb_state_layout_index_is_active(STATE, i, XKB_STATE_LAYOUT_EFFECTIVE) == 1) {
             Debug::log(LOG, "Updating keyboard {:x}'s translation state from an active index {}", (uintptr_t)this, i);
 
-            CVarList       keyboardLayouts(m_currentRules.layout, 0, ',');
-            CVarList       keyboardModels(m_currentRules.model, 0, ',');
-            CVarList       keyboardVariants(m_currentRules.variant, 0, ',');
+            CVarList       keyboardLayouts(currentRules.layout, 0, ',');
+            CVarList       keyboardModels(currentRules.model, 0, ',');
+            CVarList       keyboardVariants(currentRules.variant, 0, ',');
 
             xkb_rule_names rules = {.rules = "", .model = "", .layout = "", .variant = "", .options = ""};
 
@@ -235,9 +235,9 @@ void IKeyboard::updateXKBTranslationState(xkb_keymap* const keymap) {
                 KEYMAP       = xkb_keymap_new_from_names(PCONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
             }
 
-            m_xkbState       = xkb_state_new(KEYMAP);
-            m_xkbStaticState = xkb_state_new(KEYMAP);
-            m_xkbSymState    = xkb_state_new(KEYMAP);
+            xkbState       = xkb_state_new(KEYMAP);
+            xkbStaticState = xkb_state_new(KEYMAP);
+            xkbSymState    = xkb_state_new(KEYMAP);
 
             xkb_keymap_unref(KEYMAP);
             xkb_context_unref(PCONTEXT);
@@ -249,26 +249,26 @@ void IKeyboard::updateXKBTranslationState(xkb_keymap* const keymap) {
     Debug::log(LOG, "Updating keyboard {:x}'s translation state from an unknown index", (uintptr_t)this);
 
     xkb_rule_names rules = {
-        .rules   = m_currentRules.rules.c_str(),
-        .model   = m_currentRules.model.c_str(),
-        .layout  = m_currentRules.layout.c_str(),
-        .variant = m_currentRules.variant.c_str(),
-        .options = m_currentRules.options.c_str(),
+        .rules   = currentRules.rules.c_str(),
+        .model   = currentRules.model.c_str(),
+        .layout  = currentRules.layout.c_str(),
+        .variant = currentRules.variant.c_str(),
+        .options = currentRules.options.c_str(),
     };
 
     const auto NEWKEYMAP = xkb_keymap_new_from_names(PCONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
 
-    m_xkbState       = xkb_state_new(NEWKEYMAP);
-    m_xkbStaticState = xkb_state_new(NEWKEYMAP);
-    m_xkbSymState    = xkb_state_new(NEWKEYMAP);
+    xkbState       = xkb_state_new(NEWKEYMAP);
+    xkbStaticState = xkb_state_new(NEWKEYMAP);
+    xkbSymState    = xkb_state_new(NEWKEYMAP);
 
     xkb_keymap_unref(NEWKEYMAP);
     xkb_context_unref(PCONTEXT);
 }
 
 std::string IKeyboard::getActiveLayout() {
-    const auto KEYMAP     = m_xkbKeymap;
-    const auto STATE      = m_xkbState;
+    const auto KEYMAP     = xkbKeymap;
+    const auto STATE      = xkbState;
     const auto LAYOUTSNUM = xkb_keymap_num_layouts(KEYMAP);
 
     for (uint32_t i = 0; i < LAYOUTSNUM; ++i) {
@@ -285,12 +285,12 @@ std::string IKeyboard::getActiveLayout() {
 }
 
 std::optional<uint32_t> IKeyboard::getLEDs() {
-    if (m_xkbState == nullptr)
+    if (xkbState == nullptr)
         return {};
 
     uint32_t leds = 0;
-    for (uint32_t i = 0; i < std::min((size_t)LED_COUNT, m_ledIndexes.size()); ++i) {
-        if (xkb_state_led_index_is_active(m_xkbState, m_ledIndexes[i]))
+    for (uint32_t i = 0; i < std::min((size_t)LED_COUNT, ledIndexes.size()); ++i) {
+        if (xkb_state_led_index_is_active(xkbState, ledIndexes[i]))
             leds |= (1 << i);
     }
 
@@ -307,10 +307,10 @@ void IKeyboard::updateLEDs() {
 }
 
 void IKeyboard::updateLEDs(uint32_t leds) {
-    if (!m_xkbState)
+    if (!xkbState)
         return;
 
-    if (isVirtual() && g_pInputManager->shouldIgnoreVirtualKeyboard(m_self.lock()))
+    if (isVirtual() && g_pInputManager->shouldIgnoreVirtualKeyboard(self.lock()))
         return;
 
     if (!aq())
@@ -320,13 +320,13 @@ void IKeyboard::updateLEDs(uint32_t leds) {
 }
 
 uint32_t IKeyboard::getModifiers() {
-    uint32_t modMask = m_modifiersState.depressed | m_modifiersState.latched;
+    uint32_t modMask = modifiersState.depressed | modifiersState.latched;
     uint32_t mods    = 0;
-    for (size_t i = 0; i < m_modIndexes.size(); ++i) {
-        if (m_modIndexes[i] == XKB_MOD_INVALID)
+    for (size_t i = 0; i < modIndexes.size(); ++i) {
+        if (modIndexes[i] == XKB_MOD_INVALID)
             continue;
 
-        if (!(modMask & (1 << m_modIndexes[i])))
+        if (!(modMask & (1 << modIndexes[i])))
             continue;
 
         mods |= (1 << i);
@@ -336,50 +336,50 @@ uint32_t IKeyboard::getModifiers() {
 }
 
 void IKeyboard::updateModifiers(uint32_t depressed, uint32_t latched, uint32_t locked, uint32_t group) {
-    if (!m_xkbState)
+    if (!xkbState)
         return;
 
-    xkb_state_update_mask(m_xkbState, depressed, latched, locked, 0, 0, group);
+    xkb_state_update_mask(xkbState, depressed, latched, locked, 0, 0, group);
 
-    if (m_xkbSymState)
-        xkb_state_update_mask(m_xkbSymState, 0, 0, 0, 0, 0, group);
+    if (xkbSymState)
+        xkb_state_update_mask(xkbSymState, 0, 0, 0, 0, 0, group);
 
     if (!updateModifiersState())
         return;
 
-    m_keyboardEvents.modifiers.emit(SModifiersEvent{
-        .depressed = m_modifiersState.depressed,
-        .latched   = m_modifiersState.latched,
-        .locked    = m_modifiersState.locked,
-        .group     = m_modifiersState.group,
+    keyboardEvents.modifiers.emit(SModifiersEvent{
+        .depressed = modifiersState.depressed,
+        .latched   = modifiersState.latched,
+        .locked    = modifiersState.locked,
+        .group     = modifiersState.group,
     });
 
     updateLEDs();
 }
 
 bool IKeyboard::updateModifiersState() {
-    if (!m_xkbState)
+    if (!xkbState)
         return false;
 
-    auto depressed = xkb_state_serialize_mods(m_xkbState, XKB_STATE_MODS_DEPRESSED);
-    auto latched   = xkb_state_serialize_mods(m_xkbState, XKB_STATE_MODS_LATCHED);
-    auto locked    = xkb_state_serialize_mods(m_xkbState, XKB_STATE_MODS_LOCKED);
-    auto group     = xkb_state_serialize_layout(m_xkbState, XKB_STATE_LAYOUT_EFFECTIVE);
+    auto depressed = xkb_state_serialize_mods(xkbState, XKB_STATE_MODS_DEPRESSED);
+    auto latched   = xkb_state_serialize_mods(xkbState, XKB_STATE_MODS_LATCHED);
+    auto locked    = xkb_state_serialize_mods(xkbState, XKB_STATE_MODS_LOCKED);
+    auto group     = xkb_state_serialize_layout(xkbState, XKB_STATE_LAYOUT_EFFECTIVE);
 
-    if (depressed == m_modifiersState.depressed && latched == m_modifiersState.latched && locked == m_modifiersState.locked && group == m_modifiersState.group)
+    if (depressed == modifiersState.depressed && latched == modifiersState.latched && locked == modifiersState.locked && group == modifiersState.group)
         return false;
 
-    m_modifiersState.depressed = depressed;
-    m_modifiersState.latched   = latched;
-    m_modifiersState.locked    = locked;
-    m_modifiersState.group     = group;
+    modifiersState.depressed = depressed;
+    modifiersState.latched   = latched;
+    modifiersState.locked    = locked;
+    modifiersState.group     = group;
 
     return true;
 }
 
 void IKeyboard::updateXkbStateWithKey(uint32_t xkbKey, bool pressed) {
 
-    const auto contains = std::find(m_pressedXKB.begin(), m_pressedXKB.end(), xkbKey) != m_pressedXKB.end();
+    const auto contains = std::find(pressedXKB.begin(), pressedXKB.end(), xkbKey) != pressedXKB.end();
 
     if (contains && pressed)
         return;
@@ -387,21 +387,21 @@ void IKeyboard::updateXkbStateWithKey(uint32_t xkbKey, bool pressed) {
         return;
 
     if (contains)
-        std::erase(m_pressedXKB, xkbKey);
+        std::erase(pressedXKB, xkbKey);
     else
-        m_pressedXKB.emplace_back(xkbKey);
+        pressedXKB.emplace_back(xkbKey);
 
-    xkb_state_update_key(m_xkbState, xkbKey, pressed ? XKB_KEY_DOWN : XKB_KEY_UP);
+    xkb_state_update_key(xkbState, xkbKey, pressed ? XKB_KEY_DOWN : XKB_KEY_UP);
 
     if (updateModifiersState()) {
-        if (m_xkbSymState)
-            xkb_state_update_mask(m_xkbSymState, 0, 0, 0, 0, 0, m_modifiersState.group);
+        if (xkbSymState)
+            xkb_state_update_mask(xkbSymState, 0, 0, 0, 0, 0, modifiersState.group);
 
-        m_keyboardEvents.modifiers.emit(SModifiersEvent{
-            .depressed = m_modifiersState.depressed,
-            .latched   = m_modifiersState.latched,
-            .locked    = m_modifiersState.locked,
-            .group     = m_modifiersState.group,
+        keyboardEvents.modifiers.emit(SModifiersEvent{
+            .depressed = modifiersState.depressed,
+            .latched   = modifiersState.latched,
+            .locked    = modifiersState.locked,
+            .group     = modifiersState.group,
         });
     }
 }

src/devices/IKeyboard.hpp

@@ -52,7 +52,7 @@ class IKeyboard : public IHID {
         CSignal modifiers;
         CSignal keymap;
         CSignal repeatInfo;
-    } m_keyboardEvents;
+    } keyboardEvents;
 
     struct SStringRuleNames {
         std::string layout  = "";
@@ -74,46 +74,41 @@ class IKeyboard : public IHID {
     void                    updateXkbStateWithKey(uint32_t xkbKey, bool pressed);
     void                    updateKeymapFD();
 
-    bool                    m_active     = false;
-    bool                    m_enabled    = true;
-    bool                    m_allowBinds = true;
+    bool                    active  = false;
+    bool                    enabled = true;
 
     // if the keymap is overridden by the implementation,
     // don't try to set keyboard rules anymore, to avoid overwriting the requested one.
     // e.g. Virtual keyboards with custom maps.
-    bool               m_keymapOverridden = false;
+    bool               keymapOverridden = false;
 
-    xkb_layout_index_t m_activeLayout = 0;
-    xkb_state*         m_xkbState     = nullptr;
-
-    // never gets modifiers or layout changes sent, used for keybinds
-    xkb_state*  m_xkbStaticState = nullptr;
-    xkb_state*  m_xkbSymState    = nullptr; // same as static but gets layouts
-
-    xkb_keymap* m_xkbKeymap = nullptr;
+    xkb_layout_index_t activeLayout = 0;
+    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;
-    } m_modifiersState;
+    } modifiersState;
 
-    std::array<xkb_led_index_t, 3> m_ledIndexes = {XKB_MOD_INVALID};
-    std::array<xkb_mod_index_t, 8> m_modIndexes = {XKB_MOD_INVALID};
-    uint32_t                       m_leds       = 0;
+    std::array<xkb_led_index_t, 3> ledIndexes = {XKB_MOD_INVALID};
+    std::array<xkb_mod_index_t, 8> modIndexes = {XKB_MOD_INVALID};
+    uint32_t                       leds       = 0;
 
-    std::string                    m_xkbFilePath     = "";
-    std::string                    m_xkbKeymapString = "";
-    Hyprutils::OS::CFileDescriptor m_xkbKeymapFD;
+    std::string                    xkbFilePath     = "";
+    std::string                    xkbKeymapString = "";
+    Hyprutils::OS::CFileDescriptor xkbKeymapFD;
 
-    SStringRuleNames               m_currentRules;
-    int                            m_repeatRate        = 0;
-    int                            m_repeatDelay       = 0;
-    int                            m_numlockOn         = -1;
-    bool                           m_resolveBindsBySym = false;
+    SStringRuleNames               currentRules;
+    int                            repeatRate        = 0;
+    int                            repeatDelay       = 0;
+    int                            numlockOn         = -1;
+    bool                           resolveBindsBySym = false;
 
-    WP<IKeyboard>                  m_self;
+    WP<IKeyboard>                  self;
 
   private:
     void                  clearManuallyAllocd();
 
-    std::vector<uint32_t> m_pressedXKB;
+    std::vector<uint32_t> pressedXKB;
 };

src/devices/IPointer.hpp

@@ -106,13 +106,13 @@ class IPointer : public IHID {
 
         CSignal holdBegin;
         CSignal holdEnd;
-    } m_pointerEvents;
+    } pointerEvents;
 
-    bool         m_connected   = false; // means connected to the cursor
-    std::string  m_boundOutput = "";
-    bool         m_flipX       = false; // decide to invert horizontal movement
-    bool         m_flipY       = false; // decide to invert vertical movement
-    bool         m_isTouchpad  = false;
+    bool         connected   = false; // means connected to the cursor
+    std::string  boundOutput = "";
+    bool         flipX       = false; // decide to invert horizontal movement
+    bool         flipY       = false; // decide to invert vertical movement
+    bool         isTouchpad  = false;
 
-    WP<IPointer> m_self;
+    WP<IPointer> self;
 };

src/devices/ITouch.hpp

@@ -42,9 +42,9 @@ class ITouch : public IHID {
         CSignal motion;
         CSignal cancel;
         CSignal frame;
-    } m_touchEvents;
+    } touchEvents;
 
-    std::string m_boundOutput = "";
+    std::string boundOutput = "";
 
-    WP<ITouch>  m_self;
+    WP<ITouch>  self;
 };

src/devices/Keyboard.cpp

@@ -6,7 +6,7 @@
 SP<CKeyboard> CKeyboard::create(SP<Aquamarine::IKeyboard> keeb) {
     SP<CKeyboard> pKeeb = SP<CKeyboard>(new CKeyboard(keeb));
 
-    pKeeb->m_self = pKeeb;
+    pKeeb->self = pKeeb;
 
     return pKeeb;
 }
@@ -16,22 +16,22 @@ bool CKeyboard::isVirtual() {
 }
 
 SP<Aquamarine::IKeyboard> CKeyboard::aq() {
-    return m_keyboard.lock();
+    return keyboard.lock();
 }
 
-CKeyboard::CKeyboard(SP<Aquamarine::IKeyboard> keeb) : m_keyboard(keeb) {
+CKeyboard::CKeyboard(SP<Aquamarine::IKeyboard> keeb) : keyboard(keeb) {
     if (!keeb)
         return;
 
-    m_listeners.destroy = keeb->events.destroy.registerListener([this](std::any d) {
-        m_keyboard.reset();
-        m_events.destroy.emit();
+    listeners.destroy = keeb->events.destroy.registerListener([this](std::any d) {
+        keyboard.reset();
+        events.destroy.emit();
     });
 
-    m_listeners.key = keeb->events.key.registerListener([this](std::any d) {
+    listeners.key = keeb->events.key.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IKeyboard::SKeyEvent>(d);
 
-        m_keyboardEvents.key.emit(SKeyEvent{
+        keyboardEvents.key.emit(SKeyEvent{
             .timeMs  = E.timeMs,
             .keycode = E.key,
             .state   = E.pressed ? WL_KEYBOARD_KEY_STATE_PRESSED : WL_KEYBOARD_KEY_STATE_RELEASED,
@@ -40,16 +40,16 @@ CKeyboard::CKeyboard(SP<Aquamarine::IKeyboard> keeb) : m_keyboard(keeb) {
         updateXkbStateWithKey(E.key + 8, E.pressed);
     });
 
-    m_listeners.modifiers = keeb->events.modifiers.registerListener([this](std::any d) {
+    listeners.modifiers = keeb->events.modifiers.registerListener([this](std::any d) {
         updateModifiersState();
 
-        m_keyboardEvents.modifiers.emit(SModifiersEvent{
-            .depressed = m_modifiersState.depressed,
-            .latched   = m_modifiersState.latched,
-            .locked    = m_modifiersState.locked,
-            .group     = m_modifiersState.group,
+        keyboardEvents.modifiers.emit(SModifiersEvent{
+            .depressed = modifiersState.depressed,
+            .latched   = modifiersState.latched,
+            .locked    = modifiersState.locked,
+            .group     = modifiersState.group,
         });
     });
 
-    m_deviceName = keeb->getName();
+    deviceName = keeb->getName();
 }

src/devices/Keyboard.hpp

@@ -12,11 +12,11 @@ class CKeyboard : public IKeyboard {
   private:
     CKeyboard(SP<Aquamarine::IKeyboard> keeb);
 
-    WP<Aquamarine::IKeyboard> m_keyboard;
+    WP<Aquamarine::IKeyboard> keyboard;
 
     struct {
         CHyprSignalListener destroy;
         CHyprSignalListener key;
         CHyprSignalListener modifiers;
-    } m_listeners;
+    } listeners;
 };

src/devices/Mouse.cpp

@@ -5,51 +5,51 @@
 SP<CMouse> CMouse::create(SP<Aquamarine::IPointer> mouse) {
     SP<CMouse> pMouse = SP<CMouse>(new CMouse(mouse));
 
-    pMouse->m_self = pMouse;
+    pMouse->self = pMouse;
 
     return pMouse;
 }
 
-CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : m_mouse(mouse_) {
-    if (!m_mouse)
+CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : mouse(mouse_) {
+    if (!mouse)
         return;
 
-    if (auto handle = m_mouse->getLibinputHandle()) {
+    if (auto handle = mouse->getLibinputHandle()) {
         double w = 0, h = 0;
-        m_isTouchpad = libinput_device_has_capability(handle, LIBINPUT_DEVICE_CAP_POINTER) && libinput_device_get_size(handle, &w, &h) == 0;
+        isTouchpad = libinput_device_has_capability(handle, LIBINPUT_DEVICE_CAP_POINTER) && libinput_device_get_size(handle, &w, &h) == 0;
     }
 
-    m_listeners.destroy = m_mouse->events.destroy.registerListener([this](std::any d) {
-        m_mouse.reset();
-        m_events.destroy.emit();
+    listeners.destroy = mouse->events.destroy.registerListener([this](std::any d) {
+        mouse.reset();
+        events.destroy.emit();
     });
 
-    m_listeners.motion = m_mouse->events.move.registerListener([this](std::any d) {
+    listeners.motion = mouse->events.move.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SMoveEvent>(d);
 
-        m_pointerEvents.motion.emit(SMotionEvent{
+        pointerEvents.motion.emit(SMotionEvent{
             .timeMs  = E.timeMs,
             .delta   = E.delta,
             .unaccel = E.unaccel,
             .mouse   = true,
-            .device  = m_self.lock(),
+            .device  = self.lock(),
         });
     });
 
-    m_listeners.motionAbsolute = m_mouse->events.warp.registerListener([this](std::any d) {
+    listeners.motionAbsolute = mouse->events.warp.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SWarpEvent>(d);
 
-        m_pointerEvents.motionAbsolute.emit(SMotionAbsoluteEvent{
+        pointerEvents.motionAbsolute.emit(SMotionAbsoluteEvent{
             .timeMs   = E.timeMs,
             .absolute = E.absolute,
-            .device   = m_self.lock(),
+            .device   = self.lock(),
         });
     });
 
-    m_listeners.button = m_mouse->events.button.registerListener([this](std::any d) {
+    listeners.button = mouse->events.button.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SButtonEvent>(d);
 
-        m_pointerEvents.button.emit(SButtonEvent{
+        pointerEvents.button.emit(SButtonEvent{
             .timeMs = E.timeMs,
             .button = E.button,
             .state  = E.pressed ? WL_POINTER_BUTTON_STATE_PRESSED : WL_POINTER_BUTTON_STATE_RELEASED,
@@ -57,10 +57,10 @@ CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : m_mouse(mouse_) {
         });
     });
 
-    m_listeners.axis = m_mouse->events.axis.registerListener([this](std::any d) {
+    listeners.axis = mouse->events.axis.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SAxisEvent>(d);
 
-        m_pointerEvents.axis.emit(SAxisEvent{
+        pointerEvents.axis.emit(SAxisEvent{
             .timeMs            = E.timeMs,
             .source            = (wl_pointer_axis_source)E.source,
             .axis              = (wl_pointer_axis)E.axis,
@@ -71,58 +71,58 @@ CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : m_mouse(mouse_) {
         });
     });
 
-    m_listeners.frame = m_mouse->events.frame.registerListener([this](std::any d) { m_pointerEvents.frame.emit(); });
+    listeners.frame = mouse->events.frame.registerListener([this](std::any d) { pointerEvents.frame.emit(); });
 
-    m_listeners.swipeBegin = m_mouse->events.swipeBegin.registerListener([this](std::any d) {
+    listeners.swipeBegin = mouse->events.swipeBegin.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SSwipeBeginEvent>(d);
 
-        m_pointerEvents.swipeBegin.emit(SSwipeBeginEvent{
+        pointerEvents.swipeBegin.emit(SSwipeBeginEvent{
             .timeMs  = E.timeMs,
             .fingers = E.fingers,
         });
     });
 
-    m_listeners.swipeEnd = m_mouse->events.swipeEnd.registerListener([this](std::any d) {
+    listeners.swipeEnd = mouse->events.swipeEnd.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SSwipeEndEvent>(d);
 
-        m_pointerEvents.swipeEnd.emit(SSwipeEndEvent{
+        pointerEvents.swipeEnd.emit(SSwipeEndEvent{
             .timeMs    = E.timeMs,
             .cancelled = E.cancelled,
         });
     });
 
-    m_listeners.swipeUpdate = m_mouse->events.swipeUpdate.registerListener([this](std::any d) {
+    listeners.swipeUpdate = mouse->events.swipeUpdate.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SSwipeUpdateEvent>(d);
 
-        m_pointerEvents.swipeUpdate.emit(SSwipeUpdateEvent{
+        pointerEvents.swipeUpdate.emit(SSwipeUpdateEvent{
             .timeMs  = E.timeMs,
             .fingers = E.fingers,
             .delta   = E.delta,
         });
     });
 
-    m_listeners.pinchBegin = m_mouse->events.pinchBegin.registerListener([this](std::any d) {
+    listeners.pinchBegin = mouse->events.pinchBegin.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SPinchBeginEvent>(d);
 
-        m_pointerEvents.pinchBegin.emit(SPinchBeginEvent{
+        pointerEvents.pinchBegin.emit(SPinchBeginEvent{
             .timeMs  = E.timeMs,
             .fingers = E.fingers,
         });
     });
 
-    m_listeners.pinchEnd = m_mouse->events.pinchEnd.registerListener([this](std::any d) {
+    listeners.pinchEnd = mouse->events.pinchEnd.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SPinchEndEvent>(d);
 
-        m_pointerEvents.pinchEnd.emit(SPinchEndEvent{
+        pointerEvents.pinchEnd.emit(SPinchEndEvent{
             .timeMs    = E.timeMs,
             .cancelled = E.cancelled,
         });
     });
 
-    m_listeners.pinchUpdate = m_mouse->events.pinchUpdate.registerListener([this](std::any d) {
+    listeners.pinchUpdate = mouse->events.pinchUpdate.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SPinchUpdateEvent>(d);
 
-        m_pointerEvents.pinchUpdate.emit(SPinchUpdateEvent{
+        pointerEvents.pinchUpdate.emit(SPinchUpdateEvent{
             .timeMs   = E.timeMs,
             .fingers  = E.fingers,
             .delta    = E.delta,
@@ -131,25 +131,25 @@ CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : m_mouse(mouse_) {
         });
     });
 
-    m_listeners.holdBegin = m_mouse->events.holdBegin.registerListener([this](std::any d) {
+    listeners.holdBegin = mouse->events.holdBegin.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SHoldBeginEvent>(d);
 
-        m_pointerEvents.holdBegin.emit(SHoldBeginEvent{
+        pointerEvents.holdBegin.emit(SHoldBeginEvent{
             .timeMs  = E.timeMs,
             .fingers = E.fingers,
         });
     });
 
-    m_listeners.holdEnd = m_mouse->events.holdEnd.registerListener([this](std::any d) {
+    listeners.holdEnd = mouse->events.holdEnd.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IPointer::SHoldEndEvent>(d);
 
-        m_pointerEvents.holdEnd.emit(SHoldEndEvent{
+        pointerEvents.holdEnd.emit(SHoldEndEvent{
             .timeMs    = E.timeMs,
             .cancelled = E.cancelled,
         });
     });
 
-    m_deviceName = m_mouse->getName();
+    deviceName = mouse->getName();
 }
 
 bool CMouse::isVirtual() {
@@ -157,5 +157,5 @@ bool CMouse::isVirtual() {
 }
 
 SP<Aquamarine::IPointer> CMouse::aq() {
-    return m_mouse.lock();
+    return mouse.lock();
 }

src/devices/Mouse.hpp

@@ -12,7 +12,7 @@ class CMouse : public IPointer {
   private:
     CMouse(SP<Aquamarine::IPointer> mouse);
 
-    WP<Aquamarine::IPointer> m_mouse;
+    WP<Aquamarine::IPointer> mouse;
 
     struct {
         CHyprSignalListener destroy;
@@ -33,5 +33,5 @@ class CMouse : public IPointer {
 
         CHyprSignalListener holdBegin;
         CHyprSignalListener holdEnd;
-    } m_listeners;
+    } listeners;
 };

src/devices/Tablet.cpp

@@ -7,7 +7,7 @@
 SP<CTablet> CTablet::create(SP<Aquamarine::ITablet> tablet) {
     SP<CTablet> pTab = SP<CTablet>(new CTablet(tablet));
 
-    pTab->m_self = pTab;
+    pTab->self = pTab;
 
     PROTO::tablet->registerDevice(pTab);
 
@@ -17,7 +17,7 @@ SP<CTablet> CTablet::create(SP<Aquamarine::ITablet> tablet) {
 SP<CTabletTool> CTabletTool::create(SP<Aquamarine::ITabletTool> tablet) {
     SP<CTabletTool> pTab = SP<CTabletTool>(new CTabletTool(tablet));
 
-    pTab->m_self = pTab;
+    pTab->self = pTab;
 
     PROTO::tablet->registerDevice(pTab);
 
@@ -27,7 +27,7 @@ SP<CTabletTool> CTabletTool::create(SP<Aquamarine::ITabletTool> tablet) {
 SP<CTabletPad> CTabletPad::create(SP<Aquamarine::ITabletPad> tablet) {
     SP<CTabletPad> pTab = SP<CTabletPad>(new CTabletPad(tablet));
 
-    pTab->m_self = pTab;
+    pTab->self = pTab;
 
     PROTO::tablet->registerDevice(pTab);
 
@@ -62,24 +62,24 @@ uint32_t CTablet::getCapabilities() {
 }
 
 SP<Aquamarine::ITablet> CTablet::aq() {
-    return m_tablet.lock();
+    return tablet.lock();
 }
 
-CTablet::CTablet(SP<Aquamarine::ITablet> tablet_) : m_tablet(tablet_) {
-    if (!m_tablet)
+CTablet::CTablet(SP<Aquamarine::ITablet> tablet_) : tablet(tablet_) {
+    if (!tablet)
         return;
 
-    m_listeners.destroy = m_tablet->events.destroy.registerListener([this](std::any d) {
-        m_tablet.reset();
-        m_events.destroy.emit();
+    listeners.destroy = tablet->events.destroy.registerListener([this](std::any d) {
+        tablet.reset();
+        events.destroy.emit();
     });
 
-    m_listeners.axis = m_tablet->events.axis.registerListener([this](std::any d) {
+    listeners.axis = tablet->events.axis.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITablet::SAxisEvent>(d);
 
-        m_tabletEvents.axis.emit(SAxisEvent{
+        tabletEvents.axis.emit(SAxisEvent{
             .tool        = E.tool,
-            .tablet      = m_self.lock(),
+            .tablet      = self.lock(),
             .timeMs      = E.timeMs,
             .updatedAxes = aqUpdateToHl(E.updatedAxes),
             .axis        = E.absolute,
@@ -93,43 +93,43 @@ CTablet::CTablet(SP<Aquamarine::ITablet> tablet_) : m_tablet(tablet_) {
         });
     });
 
-    m_listeners.proximity = m_tablet->events.proximity.registerListener([this](std::any d) {
+    listeners.proximity = tablet->events.proximity.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITablet::SProximityEvent>(d);
 
-        m_tabletEvents.proximity.emit(SProximityEvent{
+        tabletEvents.proximity.emit(SProximityEvent{
             .tool      = E.tool,
-            .tablet    = m_self.lock(),
+            .tablet    = self.lock(),
             .timeMs    = E.timeMs,
             .proximity = E.absolute,
             .in        = E.in,
         });
     });
 
-    m_listeners.tip = m_tablet->events.tip.registerListener([this](std::any d) {
+    listeners.tip = tablet->events.tip.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITablet::STipEvent>(d);
 
-        m_tabletEvents.tip.emit(STipEvent{
+        tabletEvents.tip.emit(STipEvent{
             .tool   = E.tool,
-            .tablet = m_self.lock(),
+            .tablet = self.lock(),
             .timeMs = E.timeMs,
             .tip    = E.absolute,
             .in     = E.down,
         });
     });
 
-    m_listeners.button = m_tablet->events.button.registerListener([this](std::any d) {
+    listeners.button = tablet->events.button.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITablet::SButtonEvent>(d);
 
-        m_tabletEvents.button.emit(SButtonEvent{
+        tabletEvents.button.emit(SButtonEvent{
             .tool   = E.tool,
-            .tablet = m_self.lock(),
+            .tablet = self.lock(),
             .timeMs = E.timeMs,
             .button = E.button,
             .down   = E.down,
         });
     });
 
-    m_deviceName = m_tablet->getName();
+    deviceName = tablet->getName();
 }
 
 CTablet::~CTablet() {
@@ -145,26 +145,26 @@ uint32_t CTabletPad::getCapabilities() {
 }
 
 SP<Aquamarine::ITabletPad> CTabletPad::aq() {
-    return m_pad.lock();
+    return pad.lock();
 }
 
 eHIDType CTabletPad::getType() {
     return HID_TYPE_TABLET_PAD;
 }
 
-CTabletPad::CTabletPad(SP<Aquamarine::ITabletPad> pad_) : m_pad(pad_) {
-    if (!m_pad)
+CTabletPad::CTabletPad(SP<Aquamarine::ITabletPad> pad_) : pad(pad_) {
+    if (!pad)
         return;
 
-    m_listeners.destroy = m_pad->events.destroy.registerListener([this](std::any d) {
-        m_pad.reset();
-        m_events.destroy.emit();
+    listeners.destroy = pad->events.destroy.registerListener([this](std::any d) {
+        pad.reset();
+        events.destroy.emit();
     });
 
-    m_listeners.button = m_pad->events.button.registerListener([this](std::any d) {
+    listeners.button = pad->events.button.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITabletPad::SButtonEvent>(d);
 
-        m_padEvents.button.emit(SButtonEvent{
+        padEvents.button.emit(SButtonEvent{
             .timeMs = E.timeMs,
             .button = E.button,
             .down   = E.down,
@@ -173,10 +173,10 @@ CTabletPad::CTabletPad(SP<Aquamarine::ITabletPad> pad_) : m_pad(pad_) {
         });
     });
 
-    m_listeners.ring = m_pad->events.ring.registerListener([this](std::any d) {
+    listeners.ring = pad->events.ring.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITabletPad::SRingEvent>(d);
 
-        m_padEvents.ring.emit(SRingEvent{
+        padEvents.ring.emit(SRingEvent{
             .timeMs   = E.timeMs,
             .finger   = E.source == Aquamarine::ITabletPad::AQ_TABLET_PAD_RING_SOURCE_FINGER,
             .ring     = E.ring,
@@ -185,10 +185,10 @@ CTabletPad::CTabletPad(SP<Aquamarine::ITabletPad> pad_) : m_pad(pad_) {
         });
     });
 
-    m_listeners.strip = m_pad->events.strip.registerListener([this](std::any d) {
+    listeners.strip = pad->events.strip.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITabletPad::SStripEvent>(d);
 
-        m_padEvents.strip.emit(SStripEvent{
+        padEvents.strip.emit(SStripEvent{
             .timeMs   = E.timeMs,
             .finger   = E.source == Aquamarine::ITabletPad::AQ_TABLET_PAD_STRIP_SOURCE_FINGER,
             .strip    = E.strip,
@@ -197,11 +197,11 @@ CTabletPad::CTabletPad(SP<Aquamarine::ITabletPad> pad_) : m_pad(pad_) {
         });
     });
 
-    m_listeners.attach = m_pad->events.attach.registerListener([](std::any d) {
+    listeners.attach = pad->events.attach.registerListener([](std::any d) {
         ; // TODO: this doesn't do anything in aq atm
     });
 
-    m_deviceName = m_pad->getName();
+    deviceName = pad->getName();
 }
 
 CTabletPad::~CTabletPad() {
@@ -213,36 +213,36 @@ uint32_t CTabletTool::getCapabilities() {
 }
 
 SP<Aquamarine::ITabletTool> CTabletTool::aq() {
-    return m_tool.lock();
+    return tool.lock();
 }
 
 eHIDType CTabletTool::getType() {
     return HID_TYPE_TABLET_TOOL;
 }
 
-CTabletTool::CTabletTool(SP<Aquamarine::ITabletTool> tool_) : m_tool(tool_) {
-    if (!m_tool)
+CTabletTool::CTabletTool(SP<Aquamarine::ITabletTool> tool_) : tool(tool_) {
+    if (!tool)
         return;
 
-    m_listeners.destroyTool = m_tool->events.destroy.registerListener([this](std::any d) {
-        m_tool.reset();
-        m_events.destroy.emit();
+    listeners.destroyTool = tool->events.destroy.registerListener([this](std::any d) {
+        tool.reset();
+        events.destroy.emit();
     });
 
-    if (m_tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_TILT)
-        m_toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_TILT;
-    if (m_tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_PRESSURE)
-        m_toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_PRESSURE;
-    if (m_tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_DISTANCE)
-        m_toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_DISTANCE;
-    if (m_tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_ROTATION)
-        m_toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_ROTATION;
-    if (m_tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_SLIDER)
-        m_toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_SLIDER;
-    if (m_tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_WHEEL)
-        m_toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_WHEEL;
+    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_TILT)
+        toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_TILT;
+    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_PRESSURE)
+        toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_PRESSURE;
+    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_DISTANCE)
+        toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_DISTANCE;
+    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_ROTATION)
+        toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_ROTATION;
+    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_SLIDER)
+        toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_SLIDER;
+    if (tool->capabilities & Aquamarine::ITabletTool::AQ_TABLET_TOOL_CAPABILITY_WHEEL)
+        toolCapabilities |= HID_TABLET_TOOL_CAPABILITY_WHEEL;
 
-    m_deviceName = std::format("{:x}-{:x}", m_tool->serial, m_tool->id);
+    deviceName = std::format("{:x}-{:x}", tool->serial, tool->id);
 }
 
 CTabletTool::~CTabletTool() {
@@ -250,25 +250,25 @@ CTabletTool::~CTabletTool() {
 }
 
 SP<CWLSurfaceResource> CTabletTool::getSurface() {
-    return m_surface.lock();
+    return pSurface.lock();
 }
 
 void CTabletTool::setSurface(SP<CWLSurfaceResource> surf) {
-    if (surf == m_surface)
+    if (surf == pSurface)
         return;
 
-    if (m_surface) {
-        m_listeners.destroySurface.reset();
-        m_surface.reset();
+    if (pSurface) {
+        listeners.destroySurface.reset();
+        pSurface.reset();
     }
 
-    m_surface = surf;
+    pSurface = surf;
 
     if (surf) {
-        m_listeners.destroySurface = surf->m_events.destroy.registerListener([this](std::any d) {
-            PROTO::tablet->proximityOut(m_self.lock());
-            m_surface.reset();
-            m_listeners.destroySurface.reset();
+        listeners.destroySurface = surf->events.destroy.registerListener([this](std::any d) {
+            PROTO::tablet->proximityOut(self.lock());
+            pSurface.reset();
+            listeners.destroySurface.reset();
         });
     }
 }

src/devices/Tablet.hpp

@@ -86,20 +86,20 @@ class CTablet : public IHID {
         CSignal proximity;
         CSignal tip;
         CSignal button;
-    } m_tabletEvents;
+    } tabletEvents;
 
-    WP<CTablet> m_self;
+    WP<CTablet> self;
 
-    bool        m_relativeInput = false;
-    bool        m_absolutePos   = false;
-    std::string m_boundOutput   = "";
-    CBox        m_activeArea;
-    CBox        m_boundBox;
+    bool        relativeInput = false;
+    bool        absolutePos   = false;
+    std::string boundOutput   = "";
+    CBox        activeArea;
+    CBox        boundBox;
 
   private:
     CTablet(SP<Aquamarine::ITablet> tablet);
 
-    WP<Aquamarine::ITablet> m_tablet;
+    WP<Aquamarine::ITablet> tablet;
 
     struct {
         CHyprSignalListener destroy;
@@ -107,7 +107,7 @@ class CTablet : public IHID {
         CHyprSignalListener proximity;
         CHyprSignalListener tip;
         CHyprSignalListener button;
-    } m_listeners;
+    } listeners;
 };
 
 class CTabletPad : public IHID {
@@ -148,15 +148,15 @@ class CTabletPad : public IHID {
         CSignal ring;
         CSignal strip;
         CSignal attach;
-    } m_padEvents;
+    } padEvents;
 
-    WP<CTabletPad>  m_self;
-    WP<CTabletTool> m_parent;
+    WP<CTabletPad>  self;
+    WP<CTabletTool> parent;
 
   private:
     CTabletPad(SP<Aquamarine::ITabletPad> pad);
 
-    WP<Aquamarine::ITabletPad> m_pad;
+    WP<Aquamarine::ITabletPad> pad;
 
     struct {
         CHyprSignalListener destroy;
@@ -164,7 +164,7 @@ class CTabletPad : public IHID {
         CHyprSignalListener strip;
         CHyprSignalListener button;
         CHyprSignalListener attach;
-    } m_listeners;
+    } listeners;
 };
 
 class CTabletTool : public IHID {
@@ -198,23 +198,23 @@ class CTabletTool : public IHID {
     SP<CWLSurfaceResource>      getSurface();
     void                        setSurface(SP<CWLSurfaceResource>);
 
-    WP<CTabletTool>             m_self;
-    Vector2D                    m_tilt;
-    bool                        m_active           = false; // true if in proximity
-    uint32_t                    m_toolCapabilities = 0;
+    WP<CTabletTool>             self;
+    Vector2D                    tilt;
+    bool                        active           = false; // true if in proximity
+    uint32_t                    toolCapabilities = 0;
 
-    bool                        m_isDown = false;
-    std::vector<uint32_t>       m_buttonsDown;
-    Vector2D                    m_absolutePos; // last known absolute position.
+    bool                        isDown = false;
+    std::vector<uint32_t>       buttonsDown;
+    Vector2D                    absolutePos; // last known absolute position.
 
   private:
     CTabletTool(SP<Aquamarine::ITabletTool> tool);
 
-    WP<CWLSurfaceResource>      m_surface;
-    WP<Aquamarine::ITabletTool> m_tool;
+    WP<CWLSurfaceResource>      pSurface;
+    WP<Aquamarine::ITabletTool> tool;
 
     struct {
         CHyprSignalListener destroySurface;
         CHyprSignalListener destroyTool;
-    } m_listeners;
+    } listeners;
 };

src/devices/TouchDevice.cpp

@@ -5,62 +5,62 @@
 SP<CTouchDevice> CTouchDevice::create(SP<Aquamarine::ITouch> touch) {
     SP<CTouchDevice> pTouch = SP<CTouchDevice>(new CTouchDevice(touch));
 
-    pTouch->m_self = pTouch;
+    pTouch->self = pTouch;
 
     return pTouch;
 }
 
-CTouchDevice::CTouchDevice(SP<Aquamarine::ITouch> touch_) : m_touch(touch_) {
-    if (!m_touch)
+CTouchDevice::CTouchDevice(SP<Aquamarine::ITouch> touch_) : touch(touch_) {
+    if (!touch)
         return;
 
-    m_listeners.destroy = m_touch->events.destroy.registerListener([this](std::any d) {
-        m_events.destroy.emit();
-        m_touch.reset();
+    listeners.destroy = touch->events.destroy.registerListener([this](std::any d) {
+        events.destroy.emit();
+        touch.reset();
     });
 
-    m_listeners.down = m_touch->events.down.registerListener([this](std::any d) {
+    listeners.down = touch->events.down.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITouch::SDownEvent>(d);
 
-        m_touchEvents.down.emit(SDownEvent{
+        touchEvents.down.emit(SDownEvent{
             .timeMs  = E.timeMs,
             .touchID = E.touchID,
             .pos     = E.pos,
-            .device  = m_self.lock(),
+            .device  = self.lock(),
         });
     });
 
-    m_listeners.up = m_touch->events.up.registerListener([this](std::any d) {
+    listeners.up = touch->events.up.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITouch::SUpEvent>(d);
 
-        m_touchEvents.up.emit(SUpEvent{
+        touchEvents.up.emit(SUpEvent{
             .timeMs  = E.timeMs,
             .touchID = E.touchID,
         });
     });
 
-    m_listeners.motion = m_touch->events.move.registerListener([this](std::any d) {
+    listeners.motion = touch->events.move.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITouch::SMotionEvent>(d);
 
-        m_touchEvents.motion.emit(SMotionEvent{
+        touchEvents.motion.emit(SMotionEvent{
             .timeMs  = E.timeMs,
             .touchID = E.touchID,
             .pos     = E.pos,
         });
     });
 
-    m_listeners.cancel = m_touch->events.cancel.registerListener([this](std::any d) {
+    listeners.cancel = touch->events.cancel.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::ITouch::SCancelEvent>(d);
 
-        m_touchEvents.cancel.emit(SCancelEvent{
+        touchEvents.cancel.emit(SCancelEvent{
             .timeMs  = E.timeMs,
             .touchID = E.touchID,
         });
     });
 
-    m_listeners.frame = m_touch->events.frame.registerListener([this](std::any d) { m_touchEvents.frame.emit(); });
+    listeners.frame = touch->events.frame.registerListener([this](std::any d) { touchEvents.frame.emit(); });
 
-    m_deviceName = m_touch->getName();
+    deviceName = touch->getName();
 }
 
 bool CTouchDevice::isVirtual() {
@@ -68,5 +68,5 @@ bool CTouchDevice::isVirtual() {
 }
 
 SP<Aquamarine::ITouch> CTouchDevice::aq() {
-    return m_touch.lock();
+    return touch.lock();
 }

src/devices/TouchDevice.hpp

@@ -12,7 +12,7 @@ class CTouchDevice : public ITouch {
   private:
     CTouchDevice(SP<Aquamarine::ITouch> touch);
 
-    WP<Aquamarine::ITouch> m_touch;
+    WP<Aquamarine::ITouch> touch;
 
     struct {
         CHyprSignalListener destroy;
@@ -21,5 +21,5 @@ class CTouchDevice : public ITouch {
         CHyprSignalListener motion;
         CHyprSignalListener cancel;
         CHyprSignalListener frame;
-    } m_listeners;
+    } listeners;
 };

src/devices/VirtualKeyboard.cpp

@@ -5,43 +5,43 @@
 SP<CVirtualKeyboard> CVirtualKeyboard::create(SP<CVirtualKeyboardV1Resource> keeb) {
     SP<CVirtualKeyboard> pKeeb = SP<CVirtualKeyboard>(new CVirtualKeyboard(keeb));
 
-    pKeeb->m_self = pKeeb;
+    pKeeb->self = pKeeb;
 
     return pKeeb;
 }
 
-CVirtualKeyboard::CVirtualKeyboard(SP<CVirtualKeyboardV1Resource> keeb_) : m_keyboard(keeb_) {
+CVirtualKeyboard::CVirtualKeyboard(SP<CVirtualKeyboardV1Resource> keeb_) : keyboard(keeb_) {
     if (!keeb_)
         return;
 
-    m_listeners.destroy = keeb_->m_events.destroy.registerListener([this](std::any d) {
-        m_keyboard.reset();
-        m_events.destroy.emit();
+    listeners.destroy = keeb_->events.destroy.registerListener([this](std::any d) {
+        keyboard.reset();
+        events.destroy.emit();
     });
 
-    m_listeners.key       = keeb_->m_events.key.registerListener([this](std::any d) { m_keyboardEvents.key.emit(d); });
-    m_listeners.modifiers = keeb_->m_events.modifiers.registerListener([this](std::any d) {
+    listeners.key       = keeb_->events.key.registerListener([this](std::any d) { keyboardEvents.key.emit(d); });
+    listeners.modifiers = keeb_->events.modifiers.registerListener([this](std::any d) {
         auto E = std::any_cast<SModifiersEvent>(d);
         updateModifiers(E.depressed, E.latched, E.locked, E.group);
-        m_keyboardEvents.modifiers.emit(SModifiersEvent{
-            .depressed = m_modifiersState.depressed,
-            .latched   = m_modifiersState.latched,
-            .locked    = m_modifiersState.locked,
-            .group     = m_modifiersState.group,
+        keyboardEvents.modifiers.emit(SModifiersEvent{
+            .depressed = modifiersState.depressed,
+            .latched   = modifiersState.latched,
+            .locked    = modifiersState.locked,
+            .group     = modifiersState.group,
         });
     });
-    m_listeners.keymap    = keeb_->m_events.keymap.registerListener([this](std::any d) {
+    listeners.keymap    = keeb_->events.keymap.registerListener([this](std::any d) {
         auto E = std::any_cast<SKeymapEvent>(d);
-        if (m_xkbKeymap)
-            xkb_keymap_unref(m_xkbKeymap);
-        m_xkbKeymap        = xkb_keymap_ref(E.keymap);
-        m_keymapOverridden = true;
-        updateXKBTranslationState(m_xkbKeymap);
+        if (xkbKeymap)
+            xkb_keymap_unref(xkbKeymap);
+        xkbKeymap        = xkb_keymap_ref(E.keymap);
+        keymapOverridden = true;
+        updateXKBTranslationState(xkbKeymap);
         updateKeymapFD();
-        m_keyboardEvents.keymap.emit(d);
+        keyboardEvents.keymap.emit(d);
     });
 
-    m_deviceName = keeb_->m_name;
+    deviceName = keeb_->name;
 }
 
 bool CVirtualKeyboard::isVirtual() {
@@ -53,7 +53,7 @@ SP<Aquamarine::IKeyboard> CVirtualKeyboard::aq() {
 }
 
 wl_client* CVirtualKeyboard::getClient() {
-    if (m_keyboard.expired())
+    if (keyboard.expired())
         return nullptr;
-    return m_keyboard->client();
+    return keyboard->client();
 }

src/devices/VirtualKeyboard.hpp

@@ -16,12 +16,12 @@ class CVirtualKeyboard : public IKeyboard {
   private:
     CVirtualKeyboard(SP<CVirtualKeyboardV1Resource> keeb);
 
-    WP<CVirtualKeyboardV1Resource> m_keyboard;
+    WP<CVirtualKeyboardV1Resource> keyboard;
 
     struct {
         CHyprSignalListener destroy;
         CHyprSignalListener key;
         CHyprSignalListener modifiers;
         CHyprSignalListener keymap;
-    } m_listeners;
+    } listeners;
 };

src/devices/VirtualPointer.cpp

@@ -5,46 +5,46 @@
 SP<CVirtualPointer> CVirtualPointer::create(SP<CVirtualPointerV1Resource> resource) {
     SP<CVirtualPointer> pPointer = SP<CVirtualPointer>(new CVirtualPointer(resource));
 
-    pPointer->m_self = pPointer;
+    pPointer->self = pPointer;
 
     return pPointer;
 }
 
-CVirtualPointer::CVirtualPointer(SP<CVirtualPointerV1Resource> resource) : m_pointer(resource) {
+CVirtualPointer::CVirtualPointer(SP<CVirtualPointerV1Resource> resource) : pointer(resource) {
     if UNLIKELY (!resource->good())
         return;
 
-    m_listeners.destroy = m_pointer->m_events.destroy.registerListener([this](std::any d) {
-        m_pointer.reset();
-        m_events.destroy.emit();
+    listeners.destroy = pointer->events.destroy.registerListener([this](std::any d) {
+        pointer.reset();
+        events.destroy.emit();
     });
 
-    m_listeners.motion         = m_pointer->m_events.move.registerListener([this](std::any d) {
+    listeners.motion         = pointer->events.move.registerListener([this](std::any d) {
         auto E   = std::any_cast<SMotionEvent>(d);
-        E.device = m_self.lock();
-        m_pointerEvents.motion.emit(E);
+        E.device = self.lock();
+        pointerEvents.motion.emit(E);
     });
-    m_listeners.motionAbsolute = m_pointer->m_events.warp.registerListener([this](std::any d) {
+    listeners.motionAbsolute = pointer->events.warp.registerListener([this](std::any d) {
         // we need to unpack the event and add our device here because it's required to calculate the position correctly
         auto E   = std::any_cast<SMotionAbsoluteEvent>(d);
-        E.device = m_self.lock();
-        m_pointerEvents.motionAbsolute.emit(E);
+        E.device = self.lock();
+        pointerEvents.motionAbsolute.emit(E);
     });
-    m_listeners.button         = m_pointer->m_events.button.registerListener([this](std::any d) { m_pointerEvents.button.emit(d); });
-    m_listeners.axis           = m_pointer->m_events.axis.registerListener([this](std::any d) { m_pointerEvents.axis.emit(d); });
-    m_listeners.frame          = m_pointer->m_events.frame.registerListener([this](std::any d) { m_pointerEvents.frame.emit(); });
-    m_listeners.swipeBegin     = m_pointer->m_events.swipeBegin.registerListener([this](std::any d) { m_pointerEvents.swipeBegin.emit(d); });
-    m_listeners.swipeEnd       = m_pointer->m_events.swipeEnd.registerListener([this](std::any d) { m_pointerEvents.swipeEnd.emit(d); });
-    m_listeners.swipeUpdate    = m_pointer->m_events.swipeUpdate.registerListener([this](std::any d) { m_pointerEvents.swipeUpdate.emit(d); });
-    m_listeners.pinchBegin     = m_pointer->m_events.pinchBegin.registerListener([this](std::any d) { m_pointerEvents.pinchBegin.emit(d); });
-    m_listeners.pinchEnd       = m_pointer->m_events.pinchEnd.registerListener([this](std::any d) { m_pointerEvents.pinchEnd.emit(d); });
-    m_listeners.pinchUpdate    = m_pointer->m_events.pinchUpdate.registerListener([this](std::any d) { m_pointerEvents.pinchUpdate.emit(d); });
-    m_listeners.holdBegin      = m_pointer->m_events.holdBegin.registerListener([this](std::any d) { m_pointerEvents.holdBegin.emit(d); });
-    m_listeners.holdEnd        = m_pointer->m_events.holdEnd.registerListener([this](std::any d) { m_pointerEvents.holdEnd.emit(d); });
+    listeners.button         = pointer->events.button.registerListener([this](std::any d) { pointerEvents.button.emit(d); });
+    listeners.axis           = pointer->events.axis.registerListener([this](std::any d) { pointerEvents.axis.emit(d); });
+    listeners.frame          = pointer->events.frame.registerListener([this](std::any d) { pointerEvents.frame.emit(); });
+    listeners.swipeBegin     = pointer->events.swipeBegin.registerListener([this](std::any d) { pointerEvents.swipeBegin.emit(d); });
+    listeners.swipeEnd       = pointer->events.swipeEnd.registerListener([this](std::any d) { pointerEvents.swipeEnd.emit(d); });
+    listeners.swipeUpdate    = pointer->events.swipeUpdate.registerListener([this](std::any d) { pointerEvents.swipeUpdate.emit(d); });
+    listeners.pinchBegin     = pointer->events.pinchBegin.registerListener([this](std::any d) { pointerEvents.pinchBegin.emit(d); });
+    listeners.pinchEnd       = pointer->events.pinchEnd.registerListener([this](std::any d) { pointerEvents.pinchEnd.emit(d); });
+    listeners.pinchUpdate    = pointer->events.pinchUpdate.registerListener([this](std::any d) { pointerEvents.pinchUpdate.emit(d); });
+    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); });
 
-    m_boundOutput = resource->m_boundOutput ? resource->m_boundOutput->m_name : "";
+    boundOutput = resource->boundOutput ? resource->boundOutput->szName : "";
 
-    m_deviceName = m_pointer->m_name;
+    deviceName = pointer->name;
 }
 
 bool CVirtualPointer::isVirtual() {

src/devices/VirtualPointer.hpp

@@ -14,7 +14,7 @@ class CVirtualPointer : public IPointer {
   private:
     CVirtualPointer(SP<CVirtualPointerV1Resource>);
 
-    WP<CVirtualPointerV1Resource> m_pointer;
+    WP<CVirtualPointerV1Resource> pointer;
 
     struct {
         CHyprSignalListener destroy;
@@ -35,5 +35,5 @@ class CVirtualPointer : public IPointer {
 
         CHyprSignalListener holdBegin;
         CHyprSignalListener holdEnd;
-    } m_listeners;
+    } listeners;
 };

src/helpers/AsyncDialogBox.cpp

@@ -1,134 +0,0 @@
-#include "AsyncDialogBox.hpp"
-#include "./fs/FsUtils.hpp"
-#include <csignal>
-#include <algorithm>
-#include <unistd.h>
-#include "../managers/eventLoop/EventLoopManager.hpp"
-
-using namespace Hyprutils::OS;
-
-static std::vector<pid_t> asyncDialogBoxes;
-
-//
-SP<CAsyncDialogBox> CAsyncDialogBox::create(const std::string& title, const std::string& description, std::vector<std::string> buttons) {
-    if (!NFsUtils::executableExistsInPath("hyprland-dialog")) {
-        Debug::log(ERR, "CAsyncDialogBox: cannot create, no hyprland-dialog");
-        return nullptr;
-    }
-
-    auto dialog = SP<CAsyncDialogBox>(new CAsyncDialogBox(title, description, buttons));
-
-    dialog->m_selfWeakReference = dialog;
-
-    return dialog;
-}
-
-bool CAsyncDialogBox::isAsyncDialogBox(pid_t pid) {
-    return std::ranges::contains(asyncDialogBoxes, pid);
-}
-
-CAsyncDialogBox::CAsyncDialogBox(const std::string& title, const std::string& description, std::vector<std::string> buttons) :
-    m_title(title), m_description(description), m_buttons(buttons) {
-    ;
-}
-
-static int onFdWrite(int fd, uint32_t mask, void* data) {
-    auto box = (CAsyncDialogBox*)data;
-
-    box->onWrite(fd, mask);
-
-    return 0;
-}
-
-void CAsyncDialogBox::onWrite(int fd, uint32_t mask) {
-    if (mask & WL_EVENT_READABLE) {
-        std::array<char, 1024> buf;
-        int                    ret = 0;
-
-        // make the FD nonblock for a moment
-        // TODO: can we avoid this without risking a blocking read()?
-        int fdFlags = fcntl(fd, F_GETFL, 0);
-        if (fcntl(fd, F_SETFL, fdFlags | O_NONBLOCK) < 0) {
-            Debug::log(ERR, "CAsyncDialogBox::onWrite: fcntl 1 failed!");
-            return;
-        }
-
-        while ((ret = read(m_pipeReadFd.get(), buf.data(), 1023)) > 0) {
-            m_stdout += std::string_view{(char*)buf.data(), (size_t)ret};
-        }
-
-        // restore the flags (otherwise libwayland wont give us a hangup)
-        if (fcntl(fd, F_SETFL, fdFlags) < 0) {
-            Debug::log(ERR, "CAsyncDialogBox::onWrite: fcntl 2 failed!");
-            return;
-        }
-    }
-
-    if (mask & (WL_EVENT_HANGUP | WL_EVENT_ERROR)) {
-        Debug::log(LOG, "CAsyncDialogBox: dialog {:x} hung up, closed.");
-
-        m_promiseResolver->resolve(m_stdout);
-        std::erase(asyncDialogBoxes, m_dialogPid);
-
-        wl_event_source_remove(m_readEventSource);
-        m_selfReference.reset();
-        return;
-    }
-}
-
-SP<CPromise<std::string>> CAsyncDialogBox::open() {
-    std::string buttonsString = "";
-    for (auto& b : m_buttons) {
-        buttonsString += b + ";";
-    }
-    if (!buttonsString.empty())
-        buttonsString.pop_back();
-
-    CProcess proc("hyprland-dialog", std::vector<std::string>{"--title", m_title, "--text", m_description, "--buttons", buttonsString});
-
-    int      outPipe[2];
-    if (pipe(outPipe)) {
-        Debug::log(ERR, "CAsyncDialogBox::open: failed to pipe()");
-        return nullptr;
-    }
-
-    m_pipeReadFd = CFileDescriptor(outPipe[0]);
-
-    proc.setStdoutFD(outPipe[1]);
-
-    m_readEventSource = wl_event_loop_add_fd(g_pEventLoopManager->m_wayland.loop, m_pipeReadFd.get(), WL_EVENT_READABLE, ::onFdWrite, this);
-
-    if (!m_readEventSource) {
-        Debug::log(ERR, "CAsyncDialogBox::open: failed to add read fd to loop");
-        return nullptr;
-    }
-
-    m_selfReference = m_selfWeakReference.lock();
-
-    if (!proc.runAsync()) {
-        Debug::log(ERR, "CAsyncDialogBox::open: failed to run async");
-        wl_event_source_remove(m_readEventSource);
-        return nullptr;
-    }
-
-    m_dialogPid = proc.pid();
-    asyncDialogBoxes.emplace_back(m_dialogPid);
-
-    // close the write fd, only the dialog owns it now
-    close(outPipe[1]);
-
-    auto promise = CPromise<std::string>::make([this](SP<CPromiseResolver<std::string>> r) { m_promiseResolver = r; });
-
-    return promise;
-}
-
-void CAsyncDialogBox::kill() {
-    if (m_dialogPid <= 0)
-        return;
-
-    ::kill(m_dialogPid, SIGKILL);
-}
-
-bool CAsyncDialogBox::isRunning() const {
-    return m_readEventSource;
-}

src/helpers/AsyncDialogBox.hpp

@@ -1,48 +0,0 @@
-#pragma once
-
-#include "../macros.hpp"
-#include "./memory/Memory.hpp"
-#include "./defer/Promise.hpp"
-
-#include <vector>
-#include <functional>
-
-#include <hyprutils/os/Process.hpp>
-#include <hyprutils/os/FileDescriptor.hpp>
-
-struct wl_event_source;
-
-class CAsyncDialogBox {
-  public:
-    static SP<CAsyncDialogBox> create(const std::string& title, const std::string& description, std::vector<std::string> buttons);
-    static bool                isAsyncDialogBox(pid_t pid);
-
-    CAsyncDialogBox(const CAsyncDialogBox&)                     = delete;
-    CAsyncDialogBox(CAsyncDialogBox&&)                          = delete;
-    CAsyncDialogBox&          operator=(const CAsyncDialogBox&) = delete;
-    CAsyncDialogBox&          operator=(CAsyncDialogBox&&)      = delete;
-
-    SP<CPromise<std::string>> open();
-    void                      kill();
-    bool                      isRunning() const;
-
-    void                      onWrite(int fd, uint32_t mask);
-
-  private:
-    CAsyncDialogBox(const std::string& title, const std::string& description, std::vector<std::string> buttons);
-
-    pid_t                             m_dialogPid       = 0;
-    wl_event_source*                  m_readEventSource = nullptr;
-    Hyprutils::OS::CFileDescriptor    m_pipeReadFd;
-    std::string                       m_stdout = "";
-
-    const std::string                 m_title;
-    const std::string                 m_description;
-    const std::vector<std::string>    m_buttons;
-
-    SP<CPromiseResolver<std::string>> m_promiseResolver;
-
-    // WARNING: cyclic reference. This will be removed once the event source is removed to avoid dangling pointers
-    SP<CAsyncDialogBox> m_selfReference;
-    WP<CAsyncDialogBox> m_selfWeakReference;
-};

src/helpers/Color.cpp

@@ -8,11 +8,11 @@
 CHyprColor::CHyprColor() = default;
 
 CHyprColor::CHyprColor(float r_, float g_, float b_, float a_) : r(r_), g(g_), b(b_), a(a_) {
-    m_okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab();
+    okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab();
 }
 
 CHyprColor::CHyprColor(uint64_t hex) : r(RED(hex)), g(GREEN(hex)), b(BLUE(hex)), a(ALPHA(hex)) {
-    m_okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab();
+    okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab();
 }
 
 CHyprColor::CHyprColor(const Hyprgraphics::CColor& color, float a_) : a(a_) {
@@ -21,7 +21,7 @@ CHyprColor::CHyprColor(const Hyprgraphics::CColor& color, float a_) : a(a_) {
     g               = SRGB.g;
     b               = SRGB.b;
 
-    m_okLab = color.asOkLab();
+    okLab = color.asOkLab();
 }
 
 uint32_t CHyprColor::getAsHex() const {
@@ -33,11 +33,11 @@ Hyprgraphics::CColor::SSRGB CHyprColor::asRGB() const {
 }
 
 Hyprgraphics::CColor::SOkLab CHyprColor::asOkLab() const {
-    return m_okLab;
+    return okLab;
 }
 
 Hyprgraphics::CColor::SHSL CHyprColor::asHSL() const {
-    return Hyprgraphics::CColor(m_okLab).asHSL();
+    return Hyprgraphics::CColor(okLab).asHSL();
 }
 
 CHyprColor CHyprColor::stripA() const {

src/helpers/Color.hpp

@@ -43,7 +43,7 @@ class CHyprColor {
     double r = 0, g = 0, b = 0, a = 0;
 
   private:
-    Hyprgraphics::CColor::SOkLab m_okLab; // cache for the OkLab representation
+    Hyprgraphics::CColor::SOkLab okLab; // cache for the OkLab representation
 };
 
 //NOLINTNEXTLINE

src/helpers/DamageRing.cpp

@@ -1,43 +1,43 @@
 #include "DamageRing.hpp"
 
 void CDamageRing::setSize(const Vector2D& size_) {
-    if (size_ == m_size)
+    if (size_ == size)
         return;
 
-    m_size = size_;
+    size = size_;
 
     damageEntire();
 }
 
 bool CDamageRing::damage(const CRegion& rg) {
-    CRegion clipped = rg.copy().intersect(CBox{{}, m_size});
+    CRegion clipped = rg.copy().intersect(CBox{{}, size});
     if (clipped.empty())
         return false;
 
-    m_current.add(clipped);
+    current.add(clipped);
     return true;
 }
 
 void CDamageRing::damageEntire() {
-    damage(CBox{{}, m_size});
+    damage(CBox{{}, size});
 }
 
 void CDamageRing::rotate() {
-    m_previousIdx = (m_previousIdx + DAMAGE_RING_PREVIOUS_LEN - 1) % DAMAGE_RING_PREVIOUS_LEN;
+    previousIdx = (previousIdx + DAMAGE_RING_PREVIOUS_LEN - 1) % DAMAGE_RING_PREVIOUS_LEN;
 
-    m_previous[m_previousIdx] = m_current;
-    m_current.clear();
+    previous[previousIdx] = current;
+    current.clear();
 }
 
 CRegion CDamageRing::getBufferDamage(int age) {
     if (age <= 0 || age > DAMAGE_RING_PREVIOUS_LEN + 1)
-        return CBox{{}, m_size};
+        return CBox{{}, size};
 
-    CRegion damage = m_current;
+    CRegion damage = current;
 
     for (int i = 0; i < age - 1; ++i) {
-        int j = (m_previousIdx + i) % DAMAGE_RING_PREVIOUS_LEN;
-        damage.add(m_previous.at(j));
+        int j = (previousIdx + i) % DAMAGE_RING_PREVIOUS_LEN;
+        damage.add(previous.at(j));
     }
 
     // don't return a ludicrous amount of rects
@@ -48,5 +48,5 @@ CRegion CDamageRing::getBufferDamage(int age) {
 }
 
 bool CDamageRing::hasChanged() {
-    return !m_current.empty();
+    return !current.empty();
 }

src/helpers/DamageRing.hpp

@@ -15,8 +15,8 @@ class CDamageRing {
     bool    hasChanged();
 
   private:
-    Vector2D                                      m_size;
-    CRegion                                       m_current;
-    std::array<CRegion, DAMAGE_RING_PREVIOUS_LEN> m_previous;
-    size_t                                        m_previousIdx = 0;
+    Vector2D                                      size;
+    CRegion                                       current;
+    std::array<CRegion, DAMAGE_RING_PREVIOUS_LEN> previous;
+    size_t                                        previousIdx = 0;
 };

src/helpers/MiscFunctions.cpp

@@ -122,7 +122,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             const auto NAME = in.substr(8);
             const auto WS   = g_pCompositor->getWorkspaceByName("special:" + NAME);
 
-            return {WS ? WS->m_id : g_pCompositor->getNewSpecialID(), "special:" + NAME};
+            return {WS ? WS->m_iID : g_pCompositor->getNewSpecialID(), "special:" + NAME};
         }
 
         result.id = SPECIAL_WORKSPACE_START;
@@ -133,13 +133,13 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
         if (!WORKSPACE) {
             result.id = g_pCompositor->getNextAvailableNamedWorkspace();
         } else {
-            result.id = WORKSPACE->m_id;
+            result.id = WORKSPACE->m_iID;
         }
         result.name = WORKSPACENAME;
     } else if (in.starts_with("empty")) {
         const bool same_mon = in.substr(5).contains("m");
         const bool next     = in.substr(5).contains("n");
-        if ((same_mon || next) && !g_pCompositor->m_lastMonitor) {
+        if ((same_mon || next) && !g_pCompositor->m_pLastMonitor) {
             Debug::log(ERR, "Empty monitor workspace on monitor null!");
             return {WORKSPACE_INVALID};
         }
@@ -148,12 +148,12 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
         if (same_mon) {
             for (auto const& rule : g_pConfigManager->getAllWorkspaceRules()) {
                 const auto PMONITOR = g_pCompositor->getMonitorFromName(rule.monitor);
-                if (PMONITOR && (PMONITOR->m_id != g_pCompositor->m_lastMonitor->m_id))
+                if (PMONITOR && (PMONITOR->ID != g_pCompositor->m_pLastMonitor->ID))
                     invalidWSes.insert(rule.workspaceId);
             }
         }
 
-        WORKSPACEID id = next ? g_pCompositor->m_lastMonitor->activeWorkspaceID() : 0;
+        WORKSPACEID id = next ? g_pCompositor->m_pLastMonitor->activeWorkspaceID() : 0;
         while (++id < LONG_MAX) {
             const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(id);
             if (!invalidWSes.contains(id) && (!PWORKSPACE || PWORKSPACE->getWindows() == 0)) {
@@ -162,47 +162,24 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             }
         }
     } else if (in.starts_with("prev")) {
-        if (!g_pCompositor->m_lastMonitor)
+        if (!g_pCompositor->m_pLastMonitor)
             return {WORKSPACE_INVALID};
 
-        const auto PWORKSPACE = g_pCompositor->m_lastMonitor->m_activeWorkspace;
+        const auto PWORKSPACE = g_pCompositor->m_pLastMonitor->activeWorkspace;
 
         if (!valid(PWORKSPACE))
             return {WORKSPACE_INVALID};
 
-        const auto PREVWORKSPACEIDNAME = PWORKSPACE->getPrevWorkspaceIDName();
+        const auto PLASTWORKSPACE = g_pCompositor->getWorkspaceByID(PWORKSPACE->getPrevWorkspaceIDName().id);
 
-        if (PREVWORKSPACEIDNAME.id == -1)
+        if (!PLASTWORKSPACE)
             return {WORKSPACE_INVALID};
 
-        const auto PLASTWORKSPACE = g_pCompositor->getWorkspaceByID(PREVWORKSPACEIDNAME.id);
-
-        if (!PLASTWORKSPACE) {
-            Debug::log(LOG, "previous workspace {} doesn't exist yet", PREVWORKSPACEIDNAME.id);
-            return {PREVWORKSPACEIDNAME.id, PREVWORKSPACEIDNAME.name};
-        }
-
-        return {PLASTWORKSPACE->m_id, PLASTWORKSPACE->m_name};
-    } else if (in == "next") {
-        if (!g_pCompositor->m_lastMonitor || !g_pCompositor->m_lastMonitor->m_activeWorkspace) {
-            Debug::log(ERR, "no active monitor or workspace for 'next'");
-            return {WORKSPACE_INVALID};
-        }
-
-        auto        PCURRENTWORKSPACE = g_pCompositor->m_lastMonitor->m_activeWorkspace;
-
-        WORKSPACEID nextId = PCURRENTWORKSPACE->m_id + 1;
-
-        if (nextId <= 0)
-            return {WORKSPACE_INVALID};
-
-        result.id   = nextId;
-        result.name = std::to_string(nextId);
-        return result;
+        return {PLASTWORKSPACE->m_iID, PLASTWORKSPACE->m_szName};
     } else {
         if (in[0] == 'r' && (in[1] == '-' || in[1] == '+' || in[1] == '~') && isNumber(in.substr(2))) {
             bool absolute = in[1] == '~';
-            if (!g_pCompositor->m_lastMonitor) {
+            if (!g_pCompositor->m_pLastMonitor) {
                 Debug::log(ERR, "Relative monitor workspace on monitor null!");
                 return {WORKSPACE_INVALID};
             }
@@ -219,15 +196,15 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             std::set<WORKSPACEID> invalidWSes;
 
             // Collect all the workspaces we can't jump to.
-            for (auto const& ws : g_pCompositor->m_workspaces) {
-                if (ws->m_isSpecialWorkspace || (ws->m_monitor != g_pCompositor->m_lastMonitor)) {
+            for (auto const& ws : g_pCompositor->m_vWorkspaces) {
+                if (ws->m_bIsSpecialWorkspace || (ws->m_pMonitor != g_pCompositor->m_pLastMonitor)) {
                     // Can't jump to this workspace
-                    invalidWSes.insert(ws->m_id);
+                    invalidWSes.insert(ws->m_iID);
                 }
             }
             for (auto const& rule : g_pConfigManager->getAllWorkspaceRules()) {
                 const auto PMONITOR = g_pCompositor->getMonitorFromName(rule.monitor);
-                if (!PMONITOR || PMONITOR->m_id == g_pCompositor->m_lastMonitor->m_id) {
+                if (!PMONITOR || PMONITOR->ID == g_pCompositor->m_pLastMonitor->ID) {
                     // Can't be invalid
                     continue;
                 }
@@ -237,11 +214,11 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
 
             // Prepare all named workspaces in case when we need them
             std::vector<WORKSPACEID> namedWSes;
-            for (auto const& ws : g_pCompositor->m_workspaces) {
-                if (ws->m_isSpecialWorkspace || (ws->m_monitor != g_pCompositor->m_lastMonitor) || ws->m_id >= 0)
+            for (auto const& ws : g_pCompositor->m_vWorkspaces) {
+                if (ws->m_bIsSpecialWorkspace || (ws->m_pMonitor != g_pCompositor->m_pLastMonitor) || ws->m_iID >= 0)
                     continue;
 
-                namedWSes.push_back(ws->m_id);
+                namedWSes.push_back(ws->m_iID);
             }
             std::sort(namedWSes.begin(), namedWSes.end());
 
@@ -265,7 +242,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             } else {
 
                 // Just take a blind guess at where we'll probably end up
-                WORKSPACEID activeWSID    = g_pCompositor->m_lastMonitor->m_activeWorkspace ? g_pCompositor->m_lastMonitor->m_activeWorkspace->m_id : 1;
+                WORKSPACEID activeWSID    = g_pCompositor->m_pLastMonitor->activeWorkspace ? g_pCompositor->m_pLastMonitor->activeWorkspace->m_iID : 1;
                 WORKSPACEID predictedWSID = activeWSID + remains;
                 int         remainingWSes = 0;
                 char        walkDir       = in[1];
@@ -356,7 +333,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
 
             const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(result.id);
             if (PWORKSPACE)
-                result.name = g_pCompositor->getWorkspaceByID(result.id)->m_name;
+                result.name = g_pCompositor->getWorkspaceByID(result.id)->m_szName;
             else
                 result.name = std::to_string(result.id);
 
@@ -364,7 +341,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             bool onAllMonitors = in[0] == 'e';
             bool absolute      = in[1] == '~';
 
-            if (!g_pCompositor->m_lastMonitor) {
+            if (!g_pCompositor->m_pLastMonitor) {
                 Debug::log(ERR, "Relative monitor workspace on monitor null!");
                 return {WORKSPACE_INVALID};
             }
@@ -381,11 +358,11 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             int                      remains = (int)result.id;
 
             std::vector<WORKSPACEID> validWSes;
-            for (auto const& ws : g_pCompositor->m_workspaces) {
-                if (ws->m_isSpecialWorkspace || (ws->m_monitor != g_pCompositor->m_lastMonitor && !onAllMonitors))
+            for (auto const& ws : g_pCompositor->m_vWorkspaces) {
+                if (ws->m_bIsSpecialWorkspace || (ws->m_pMonitor != g_pCompositor->m_pLastMonitor && !onAllMonitors))
                     continue;
 
-                validWSes.push_back(ws->m_id);
+                validWSes.push_back(ws->m_iID);
             }
 
             std::sort(validWSes.begin(), validWSes.end());
@@ -407,7 +384,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
                 remains = remains < 0 ? -((-remains) % validWSes.size()) : remains % validWSes.size();
 
                 // get the current item
-                WORKSPACEID activeWSID = g_pCompositor->m_lastMonitor->m_activeWorkspace ? g_pCompositor->m_lastMonitor->m_activeWorkspace->m_id : 1;
+                WORKSPACEID activeWSID = g_pCompositor->m_pLastMonitor->activeWorkspace ? g_pCompositor->m_pLastMonitor->activeWorkspace->m_iID : 1;
                 for (ssize_t i = 0; i < (ssize_t)validWSes.size(); i++) {
                     if (validWSes[i] == activeWSID) {
                         currentItem = i;
@@ -427,11 +404,11 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             }
 
             result.id   = validWSes[currentItem];
-            result.name = g_pCompositor->getWorkspaceByID(validWSes[currentItem])->m_name;
+            result.name = g_pCompositor->getWorkspaceByID(validWSes[currentItem])->m_szName;
         } else {
             if (in[0] == '+' || in[0] == '-') {
-                if (g_pCompositor->m_lastMonitor) {
-                    const auto PLUSMINUSRESULT = getPlusMinusKeywordResult(in, g_pCompositor->m_lastMonitor->activeWorkspaceID());
+                if (g_pCompositor->m_pLastMonitor) {
+                    const auto PLUSMINUSRESULT = getPlusMinusKeywordResult(in, g_pCompositor->m_pLastMonitor->activeWorkspaceID());
                     if (!PLUSMINUSRESULT.has_value())
                         return {WORKSPACE_INVALID};
 
@@ -446,7 +423,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
                 // maybe name
                 const auto PWORKSPACE = g_pCompositor->getWorkspaceByName(in);
                 if (PWORKSPACE)
-                    result.id = PWORKSPACE->m_id;
+                    result.id = PWORKSPACE->m_iID;
             }
 
             result.name = std::to_string(result.id);
@@ -840,38 +817,3 @@ float stringToPercentage(const std::string& VALUE, const float REL) {
     else
         return std::stof(VALUE);
 }
-
-// Checks if Nvidia driver major version is at least given version.
-// Useful for explicit_sync_kms and ctm_animation as they only work
-// past certain driver versions.
-bool isNvidiaDriverVersionAtLeast(int threshold) {
-    static int  driverMajor = 0;
-    static bool once        = true;
-
-    if (once) {
-        once = false;
-
-        std::error_code ec;
-        if (std::filesystem::exists("/sys/module/nvidia_drm/version", ec) && !ec) {
-            std::ifstream ifs("/sys/module/nvidia_drm/version");
-            if (ifs.good()) {
-                try {
-                    std::string driverInfo((std::istreambuf_iterator<char>(ifs)), (std::istreambuf_iterator<char>()));
-
-                    size_t      firstDot = driverInfo.find('.');
-                    if (firstDot != std::string::npos)
-                        driverMajor = std::stoi(driverInfo.substr(0, firstDot));
-
-                    Debug::log(LOG, "Parsed NVIDIA major version: {}", driverMajor);
-
-                } catch (std::exception& e) {
-                    driverMajor = 0; // Default to 0 if parsing fails
-                }
-
-                ifs.close();
-            }
-        }
-    }
-
-    return driverMajor >= threshold;
-}

src/helpers/MiscFunctions.hpp

@@ -39,7 +39,6 @@ bool                                envEnabled(const std::string& env);
 Hyprutils::OS::CFileDescriptor      allocateSHMFile(size_t len);
 bool                                allocateSHMFilePair(size_t size, Hyprutils::OS::CFileDescriptor& rw_fd_ptr, Hyprutils::OS::CFileDescriptor& ro_fd_ptr);
 float                               stringToPercentage(const std::string& VALUE, const float REL);
-bool                                isNvidiaDriverVersionAtLeast(int threshold);
 
 template <typename... Args>
 [[deprecated("use std::format instead")]] std::string getFormat(std::format_string<Args...> fmt, Args&&... args) {