props: bump version to 0.40.0

fixes #5873

.github/actions/setup_base/action.yml

@@ -12,7 +12,6 @@ runs:
     - name: Get required pacman pkgs
       shell: bash
       run: |
-        sed -i -e "1i [extra-testing]\nInclude = /etc/pacman.d/mirrorlist" "/etc/pacman.conf"
         sed -i 's/SigLevel    = Required DatabaseOptional/SigLevel    = Optional TrustAll/' /etc/pacman.conf
         pacman --noconfirm --noprogressbar -Syyu
         pacman --noconfirm --noprogressbar -Sy \
@@ -25,6 +24,7 @@ runs:
           glslang \
           go \
           hyprlang \
+          hyprcursor \
           jq \
           libc++ \
           libdisplay-info \
@@ -44,6 +44,7 @@ runs:
           pango \
           pixman \
           pkgconf \
+          pugixml \
           scdoc \
           seatd \
           systemd \
@@ -58,11 +59,11 @@ runs:
           libzip \
           librsvg
 
-    - name: Get hyprcursor-git
+    - name: Get hyprwayland-scanner-git
       shell: bash
       run: |
-        git clone https://github.com/hyprwm/hyprcursor --recursive
-        cd hyprcursor
+        git clone https://github.com/hyprwm/hyprwayland-scanner --recursive
+        cd hyprwayland-scanner
         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

.github/workflows/ci.yaml

@@ -63,6 +63,25 @@ jobs:
       - name: Compile
         run: ninja -C build
 
+  no-pch:
+    name: "Build Hyprland without precompiled headers (Arch)"
+    runs-on: ubuntu-latest
+    container:
+      image: archlinux
+    steps:
+      - name: Checkout repository actions
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: .github/actions
+
+      - name: Setup base
+        uses: ./.github/actions/setup_base
+        with:
+          INSTALL_XORG_PKGS: true
+
+      - name: Compile
+        run: make nopch
+
   noxwayland:
     name: "Build Hyprland in pure Wayland (Arch)"
     runs-on: ubuntu-latest

.github/workflows/nix-build.yml

@@ -26,4 +26,4 @@ jobs:
           name: hyprland
           authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
 
-      - run: nix build .#${{ matrix.package }} -L
+      - run: nix build .#${{ matrix.package }} --extra-substituters "https://hyprland.cachix.org" -L

.github/workflows/release.yaml

@@ -18,6 +18,7 @@ jobs:
       - name: Generate version
         id: genversion
         run: |
+          git fetch --unshallow || echo "failed unshallowing"
           bash -c scripts/generateVersion.sh
           mv scripts/generateVersion.sh scripts/generateVersion.sh.bak
 

.gitignore

@@ -17,8 +17,8 @@ result*
 .cache
 
 *.o
-*-protocol.c
-*-protocol.h
+protocols/*.c*
+protocols/*.h*
 .ccls-cache
 *.so
 

.gitmodules

@@ -10,3 +10,4 @@
 [submodule "subprojects/wlroots-hyprland"]
 	path = subprojects/wlroots-hyprland
 	url = https://github.com/hyprwm/wlroots-hyprland
+	ignore = dirty

CMakeLists.txt

@@ -105,11 +105,11 @@ endif()
 find_package(OpenGL REQUIRED COMPONENTS ${GLES_VERSION})
 
 pkg_check_modules(deps REQUIRED IMPORTED_TARGET
-    xkbcommon
+    xkbcommon uuid
     wayland-server wayland-client wayland-cursor wayland-protocols
     cairo pango pangocairo pixman-1
     libdrm libinput hwdata libseat libdisplay-info libliftoff libudev gbm
-    hyprlang>=0.3.2 hyprcursor
+    hyprwayland-scanner>=0.3.4 hyprlang>=0.3.2 hyprcursor>=0.1.7
 )
 
 file(GLOB_RECURSE SRCFILES CONFIGURE_DEPENDS "src/*.cpp")
@@ -164,6 +164,12 @@ if(HAVE_LIBEXECINFO)
     target_link_libraries(Hyprland execinfo)
 endif()
 
+check_include_file("sys/timerfd.h" HAS_TIMERFD)
+pkg_check_modules(epoll IMPORTED_TARGET epoll-shim)
+if(NOT HAS_TIMERFD AND epoll_FOUND)
+    target_link_libraries(Hyprland PkgConfig::epoll)
+endif()
+
 if(LEGACY_RENDERER)
     message(STATUS "Using the legacy GLES2 renderer!")
     add_compile_definitions(LEGACY_RENDERER)
@@ -174,7 +180,7 @@ if(NO_XWAYLAND)
     add_compile_definitions(NO_XWAYLAND)
 else()
     message(STATUS "XWAYLAND Enabled (NO_XWAYLAND not defined) checking deps...")
-    pkg_check_modules(xdeps REQUIRED IMPORTED_TARGET xcb xwayland xcb-util xcb-render xcb-image xcb-xfixes xcb-icccm xcb-composite xcb-res xcb-ewmh)
+    pkg_check_modules(xdeps REQUIRED IMPORTED_TARGET xcb xwayland xcb-util xcb-render xcb-xfixes xcb-icccm xcb-composite xcb-res xcb-ewmh)
     pkg_check_modules(xcb_errors IMPORTED_TARGET xcb-errors)
     target_link_libraries(Hyprland PkgConfig::xdeps)
     if(xcb_errors_FOUND)
@@ -185,20 +191,8 @@ endif()
 if(NO_SYSTEMD)
     message(STATUS "SYSTEMD support is disabled...")
 else()
-    message(STATUS "SYSTEMD support is requested (NO_SYSTEMD not defined) checking deps...")
-    check_include_file("systemd/sd-daemon.h" SYSTEMDH)
-    if(SYSTEMDH)
-        pkg_check_modules(LIBSYSTEMD libsystemd)
-        if (LIBSYSTEMD_FOUND)
-            add_compile_definitions(USES_SYSTEMD)
-            target_link_libraries(Hyprland "${LIBSYSTEMD_LIBRARIES}")
-            message(STATUS "Systemd found")
-        else()
-            message(WARNING "Systemd support requested but systemd libraries were not found")
-        endif()
-    else()
-        message(WARNING "Systemd support requested but systemd headers were not found")
-    endif()
+    message(STATUS "SYSTEMD support is requested (NO_SYSTEMD not defined)...")
+    add_compile_definitions(USES_SYSTEMD)
 endif()
 
 set(CPACK_PROJECT_NAME ${PROJECT_NAME})
@@ -232,6 +226,19 @@ function(protocol protoPath protoName external)
         target_sources(Hyprland PRIVATE protocols/${protoName}-protocol.c)
     endif()
 endfunction()
+function(protocolNew protoPath protoName external)
+    if (external)
+        execute_process(
+            COMMAND hyprwayland-scanner ${protoPath} ${CMAKE_SOURCE_DIR}/protocols/
+            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+        target_sources(Hyprland PRIVATE protocols/${protoName}.cpp)
+    else()
+        execute_process(
+            COMMAND hyprwayland-scanner ${WAYLAND_PROTOCOLS_DIR}/${protoPath} ${CMAKE_SOURCE_DIR}/protocols/
+            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+        target_sources(Hyprland PRIVATE protocols/${protoName}.cpp)
+    endif()
+endfunction()
 
 target_link_libraries(Hyprland
         ${CMAKE_SOURCE_DIR}/subprojects/wlroots-hyprland/build/libwlroots.a
@@ -239,24 +246,41 @@ target_link_libraries(Hyprland
         OpenGL::GL
         Threads::Threads
         libudis86
+        uuid
 )
 
-protocol("protocols/idle.xml" "idle" true)
-protocol("protocols/pointer-constraints-unstable-v1.xml" "pointer-constraints-unstable-v1" true)
 protocol("protocols/tablet-unstable-v2.xml" "tablet-unstable-v2" true)
-protocol("protocols/wlr-foreign-toplevel-management-unstable-v1.xml" "wlr-foreign-toplevel-management-unstable-v1" true)
 protocol("protocols/wlr-layer-shell-unstable-v1.xml" "wlr-layer-shell-unstable-v1" true)
-protocol("protocols/wlr-output-power-management-unstable-v1.xml" "wlr-output-power-management-unstable-v1" true)
 protocol("protocols/wlr-screencopy-unstable-v1.xml" "wlr-screencopy-unstable-v1" true)
 protocol("subprojects/hyprland-protocols/protocols/hyprland-global-shortcuts-v1.xml" "hyprland-global-shortcuts-v1" true)
 protocol("subprojects/hyprland-protocols/protocols/hyprland-toplevel-export-v1.xml" "hyprland-toplevel-export-v1" true)
 protocol("stable/xdg-shell/xdg-shell.xml" "xdg-shell" false)
 protocol("unstable/linux-dmabuf/linux-dmabuf-unstable-v1.xml" "linux-dmabuf-unstable-v1" false)
-protocol("unstable/xdg-output/xdg-output-unstable-v1.xml" "xdg-output-unstable-v1" false)
-protocol("staging/fractional-scale/fractional-scale-v1.xml" "fractional-scale-v1" false)
-protocol("staging/tearing-control/tearing-control-v1.xml" "tearing-control-v1" false)
 protocol("unstable/text-input/text-input-unstable-v1.xml" "text-input-unstable-v1" false)
-protocol("staging/cursor-shape/cursor-shape-v1.xml" "cursor-shape-v1" false)
+
+protocolNew("protocols/wlr-gamma-control-unstable-v1.xml" "wlr-gamma-control-unstable-v1" true)
+protocolNew("protocols/wlr-foreign-toplevel-management-unstable-v1.xml" "wlr-foreign-toplevel-management-unstable-v1" true)
+protocolNew("protocols/wlr-output-power-management-unstable-v1.xml" "wlr-output-power-management-unstable-v1" true)
+protocolNew("protocols/virtual-keyboard-unstable-v1.xml" "virtual-keyboard-unstable-v1" true)
+protocolNew("protocols/wlr-virtual-pointer-unstable-v1.xml" "wlr-virtual-pointer-unstable-v1" true)
+protocolNew("protocols/input-method-unstable-v2.xml" "input-method-unstable-v2" true)
+protocolNew("protocols/wlr-output-management-unstable-v1.xml" "wlr-output-management-unstable-v1" true)
+protocolNew("staging/tearing-control/tearing-control-v1.xml" "tearing-control-v1" false)
+protocolNew("staging/fractional-scale/fractional-scale-v1.xml" "fractional-scale-v1" false)
+protocolNew("unstable/xdg-output/xdg-output-unstable-v1.xml" "xdg-output-unstable-v1" false)
+protocolNew("staging/cursor-shape/cursor-shape-v1.xml" "cursor-shape-v1" false)
+protocolNew("unstable/idle-inhibit/idle-inhibit-unstable-v1.xml" "idle-inhibit-unstable-v1" false)
+protocolNew("unstable/relative-pointer/relative-pointer-unstable-v1.xml" "relative-pointer-unstable-v1" false)
+protocolNew("unstable/xdg-decoration/xdg-decoration-unstable-v1.xml" "xdg-decoration-unstable-v1" false)
+protocolNew("staging/alpha-modifier/alpha-modifier-v1.xml" "alpha-modifier-v1" false)
+protocolNew("staging/ext-foreign-toplevel-list/ext-foreign-toplevel-list-v1.xml" "ext-foreign-toplevel-list-v1" false)
+protocolNew("unstable/pointer-gestures/pointer-gestures-unstable-v1.xml" "pointer-gestures-unstable-v1" false)
+protocolNew("unstable/keyboard-shortcuts-inhibit/keyboard-shortcuts-inhibit-unstable-v1.xml" "keyboard-shortcuts-inhibit-unstable-v1" false)
+protocolNew("unstable/text-input/text-input-unstable-v3.xml" "text-input-unstable-v3" false)
+protocolNew("unstable/pointer-constraints/pointer-constraints-unstable-v1.xml" "pointer-constraints-unstable-v1" false)
+protocolNew("staging/xdg-activation/xdg-activation-v1.xml" "xdg-activation-v1" false)
+protocolNew("staging/ext-idle-notify/ext-idle-notify-v1.xml" "ext-idle-notify-v1" false)
+protocolNew("staging/ext-session-lock/ext-session-lock-v1.xml" "ext-session-lock-v1" false)
 
 # tools
 add_subdirectory(hyprctl)

Makefile

@@ -20,9 +20,13 @@ debug:
 	cmake --build ./build --config Debug --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
 	chmod -R 777 ./build
 
+nopch:
+	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:STRING=${PREFIX} -DCMAKE_DISABLE_PRECOMPILE_HEADERS=ON -S . -B ./build -G Ninja
+	cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
+
 clear:
 	rm -rf build
-	rm -f ./protocols/*-protocol.h ./protocols/*-protocol.c
+	rm -f ./protocols/*.h ./protocols/*.c ./protocols/*.cpp ./protocols/*.hpp
 	rm -rf ./subprojects/wlroots-hyprland/build
 
 all:
@@ -95,7 +99,8 @@ installheaders:
 	find src -name '*.h*' -print0 | cpio --quiet -0dump ${PREFIX}/include/hyprland
 	cd subprojects/wlroots-hyprland/include && find . -name '*.h*' -print0 | cpio --quiet -0dump ${PREFIX}/include/hyprland/wlroots-hyprland && cd ../../..
 	cd subprojects/wlroots-hyprland/build/include && find . -name '*.h*' -print0 | cpio --quiet -0dump ${PREFIX}/include/hyprland/wlroots-hyprland && cd ../../../..
-	cp ./protocols/*-protocol.h ${PREFIX}/include/hyprland/protocols
+	cp ./protocols/*.h ${PREFIX}/include/hyprland/protocols
+	cp ./protocols/*.hpp ${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
 

README.md

@@ -10,7 +10,6 @@
 [![Badge Pull Requests]][Pull Requests] 
 [![Badge Issues]][Issues] 
 ![Badge Hi Mom]<br>
-[![Badge Discord]][Discord]
 
 <br>
 
@@ -45,11 +44,11 @@ easy IPC, much more QoL stuff than other wlr-based compositors and more...
 - Tearing support for better gaming performance
 - Easily expandable and readable codebase
 - Fast and active development
-- Not scared to provide bleeding-edge features
+- Not afraid to provide bleeding-edge features
 - Config reloaded instantly upon saving
 - Fully dynamic workspaces
 - Two built-in layouts and more available as plugins
-- Closely follows `wlroots-git`
+- Uses forked wlroots with QoL patches
 - Global keybinds passed to your apps of choice
 - Tiling/pseudotiling/floating/fullscreen windows
 - Special workspaces (scratchpads)
@@ -103,7 +102,6 @@ easy IPC, much more QoL stuff than other wlr-based compositors and more...
 <!----------------------------------------------------------------------------->
 
 [Configure]: https://wiki.hyprland.org/Configuring/Configuring-Hyprland/
-[Discord]: https://discord.gg/hQ9XvMUjjr
 [Stars]: https://starchart.cc/hyprwm/Hyprland
 [Hypr]: https://github.com/hyprwm/Hypr
 
@@ -138,7 +136,6 @@ easy IPC, much more QoL stuff than other wlr-based compositors and more...
 
 [Badge Workflow]: https://github.com/hyprwm/Hyprland/actions/workflows/ci.yaml/badge.svg
 
-[Badge Discord]: https://img.shields.io/badge/Join%20the-Discord%20server-6666ff
 [Badge Issues]: https://img.shields.io/github/issues/hyprwm/Hyprland
 [Badge Pull Requests]: https://img.shields.io/github/issues-pr/hyprwm/Hyprland
 [Badge Language]: https://img.shields.io/github/languages/top/hyprwm/Hyprland

docs/ISSUE_GUIDELINES.md

@@ -34,16 +34,16 @@ If your bug crashes Hyprland, append additionally:
 ## Obtaining the Hyprland log
 If you are in a TTY, and the hyprland session that crashed was the last one you launched, the log will be printed with
 ```
-cat /tmp/hypr/$(ls -t /tmp/hypr/ | head -n 1)/hyprland.log
+cat $XDG_RUNTIME_DIR/hypr/$(ls -t $XDG_RUNTIME_DIR/hypr | head -n 1)/hyprland.log
 ```
 feel free to send it to a file, save, copy, etc.
 
 if you are in a Hyprland session, and you want the log of the last session, use
 ```
-cat /tmp/hypr/$(ls -t /tmp/hypr/ | head -n 2 | tail -n 1)/hyprland.log
+cat $XDG_RUNTIME_DIR/hypr/$(ls -t $XDG_RUNTIME_DIR/hypr | head -n 2 | tail -n 1)/hyprland.log
 ```
 
-basically, directories in /tmp/hypr are your sessions.
+basically, directories in $XDG_RUNTIME_DIR/hypr are your sessions.
 
 ## Obtaining the Hyprland Crash Report (v0.22.0beta and up)
 

example/hyprland.conf

@@ -1,70 +1,97 @@
 # This is an example Hyprland config file.
-#
 # Refer to the wiki for more information.
+# https://wiki.hyprland.org/Configuring/Configuring-Hyprland/
 
-#
 # Please note not all available settings / options are set here.
 # For a full list, see the wiki
-#
+
+# You can split this configuration into multiple files
+# Create your files separately and then link them to this file like this:
+# source = ~/.config/hypr/myColors.conf
+
+
+################
+### MONITORS ###
+################
 
 # See https://wiki.hyprland.org/Configuring/Monitors/
 monitor=,preferred,auto,auto
 
 
-# See https://wiki.hyprland.org/Configuring/Keywords/ for more
+###################
+### MY PROGRAMS ###
+###################
 
-# Execute your favorite apps at launch
-# exec-once = waybar & hyprpaper & firefox
-
-# Source a file (multi-file configs)
-# source = ~/.config/hypr/myColors.conf
+# See https://wiki.hyprland.org/Configuring/Keywords/
 
 # Set programs that you use
 $terminal = kitty
 $fileManager = dolphin
 $menu = wofi --show drun
 
-# Some default env vars.
+
+#################
+### AUTOSTART ###
+#################
+
+# Autostart necessary processes (like notifications daemons, status bars, etc.)
+# Or execute your favorite apps at launch like this:
+
+# exec-once = $terminal
+# exec-once = nm-applet &
+# exec-once = waybar & hyprpaper & firefox
+
+
+#############################
+### ENVIRONMENT VARIABLES ###
+#############################
+
+# See https://wiki.hyprland.org/Configuring/Environment-variables/
+
 env = XCURSOR_SIZE,24
-env = QT_QPA_PLATFORMTHEME,qt5ct # change to qt6ct if you have that
+env = HYPRCURSOR_SIZE,24
 
-# For all categories, see https://wiki.hyprland.org/Configuring/Variables/
-input {
-    kb_layout = us
-    kb_variant =
-    kb_model =
-    kb_options =
-    kb_rules =
 
-    follow_mouse = 1
+#####################
+### LOOK AND FEEL ###
+#####################
 
-    touchpad {
-        natural_scroll = false
-    }
-
-    sensitivity = 0 # -1.0 - 1.0, 0 means no modification.
-}
-
-general {
-    # See https://wiki.hyprland.org/Configuring/Variables/ for more
+# Refer to https://wiki.hyprland.org/Configuring/Variables/
 
+# https://wiki.hyprland.org/Configuring/Variables/#general
+general { 
     gaps_in = 5
     gaps_out = 20
+
     border_size = 2
+
+    # https://wiki.hyprland.org/Configuring/Variables/#variable-types for info about colors
     col.active_border = rgba(33ccffee) rgba(00ff99ee) 45deg
     col.inactive_border = rgba(595959aa)
 
-    layout = dwindle
+    # Set to true enable resizing windows by clicking and dragging on borders and gaps
+    resize_on_border = false 
 
     # Please see https://wiki.hyprland.org/Configuring/Tearing/ before you turn this on
     allow_tearing = false
+
+    layout = dwindle
 }
 
+# https://wiki.hyprland.org/Configuring/Variables/#decoration
 decoration {
-    # See https://wiki.hyprland.org/Configuring/Variables/ for more
-
     rounding = 10
 
+    # Change transparency of focused and unfocused windows
+    active_opacity = 1.0
+    inactive_opacity = 1.0
+
+    drop_shadow = true
+    shadow_range = 4
+    shadow_render_power = 3
+    col.shadow = rgba(1a1a1aee)
+
+    # https://wiki.hyprland.org/Configuring/Variables/#blur
     blur {
         enabled = true
         size = 3
@@ -72,17 +99,13 @@ decoration {
         
         vibrancy = 0.1696
     }
-
-    drop_shadow = true
-    shadow_range = 4
-    shadow_render_power = 3
-    col.shadow = rgba(1a1a1aee)
 }
 
+# https://wiki.hyprland.org/Configuring/Variables/#animations
 animations {
     enabled = true
 
-    # Some default animations, see https://wiki.hyprland.org/Configuring/Animations/ for more
+    # Default animations, see https://wiki.hyprland.org/Configuring/Animations/ for more
 
     bezier = myBezier, 0.05, 0.9, 0.1, 1.05
 
@@ -94,25 +117,48 @@ animations {
     animation = workspaces, 1, 6, default
 }
 
+# See https://wiki.hyprland.org/Configuring/Dwindle-Layout/ for more
 dwindle {
-    # See https://wiki.hyprland.org/Configuring/Dwindle-Layout/ for more
-    pseudotile = true # master switch for pseudotiling. Enabling is bound to mainMod + P in the keybinds section below
-    preserve_split = true # you probably want this
+    pseudotile = true # Master switch for pseudotiling. Enabling is bound to mainMod + P in the keybinds section below
+    preserve_split = true # You probably want this
 }
 
+# See https://wiki.hyprland.org/Configuring/Master-Layout/ for more
 master {
-    # See https://wiki.hyprland.org/Configuring/Master-Layout/ for more
     new_is_master = true
 }
 
-gestures {
-    # See https://wiki.hyprland.org/Configuring/Variables/ for more
-    workspace_swipe = false
+# https://wiki.hyprland.org/Configuring/Variables/#misc
+misc { 
+    force_default_wallpaper = -1 # Set to 0 or 1 to disable the anime mascot wallpapers
+    disable_hyprland_logo = false # If true disables the random hyprland logo / anime girl background. :(
 }
 
-misc {
-    # See https://wiki.hyprland.org/Configuring/Variables/ for more
-    force_default_wallpaper = -1 # Set to 0 or 1 to disable the anime mascot wallpapers
+
+#############
+### INPUT ###
+#############
+
+# https://wiki.hyprland.org/Configuring/Variables/#input
+input {
+    kb_layout = us
+    kb_variant =
+    kb_model =
+    kb_options =
+    kb_rules =
+
+    follow_mouse = 1
+
+    sensitivity = 0 # -1.0 - 1.0, 0 means no modification.
+
+    touchpad {
+        natural_scroll = false
+    }
+}
+
+# https://wiki.hyprland.org/Configuring/Variables/#gestures
+gestures {
+    workspace_swipe = false
 }
 
 # Example per-device config
@@ -122,16 +168,13 @@ device {
     sensitivity = -0.5
 }
 
-# Example windowrule v1
-# windowrule = float, ^(kitty)$
-# Example windowrule v2
-# windowrulev2 = float,class:^(kitty)$,title:^(kitty)$
-# See https://wiki.hyprland.org/Configuring/Window-Rules/ for more
-windowrulev2 = suppressevent maximize, class:.* # You'll probably like this.
 
+####################
+### KEYBINDINGSS ###
+####################
 
-# See https://wiki.hyprland.org/Configuring/Keywords/ for more
-$mainMod = SUPER
+# See https://wiki.hyprland.org/Configuring/Keywords/
+$mainMod = SUPER # Sets "Windows" key as main modifier
 
 # Example binds, see https://wiki.hyprland.org/Configuring/Binds/ for more
 bind = $mainMod, Q, exec, $terminal
@@ -184,3 +227,19 @@ bind = $mainMod, mouse_up, workspace, e-1
 # Move/resize windows with mainMod + LMB/RMB and dragging
 bindm = $mainMod, mouse:272, movewindow
 bindm = $mainMod, mouse:273, resizewindow
+
+
+##############################
+### WINDOWS AND WORKSPACES ###
+##############################
+
+# See https://wiki.hyprland.org/Configuring/Window-Rules/ for more
+# See https://wiki.hyprland.org/Configuring/Workspace-Rules/ for workspace rules
+
+# Example windowrule v1
+# windowrule = float, ^(kitty)$
+
+# Example windowrule v2
+# windowrulev2 = float,class:^(kitty)$,title:^(kitty)$
+
+windowrulev2 = suppressevent maximize, class:.* # You'll probably like this.

flake.lock

@@ -13,11 +13,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1712434681,
-        "narHash": "sha256-qwmR2p1oc48Bj7gUDvb1oGL19Rjs2PmEmk4ChV01A5o=",
+        "lastModified": 1713612213,
+        "narHash": "sha256-zJboXgWNpNhKyNF8H/3UYzWkx7w00TOCGKi3cwi+tsw=",
         "owner": "hyprwm",
         "repo": "hyprcursor",
-        "rev": "818d8c4b69e0997483d60b75f701fe14b561a7a3",
+        "rev": "cab4746180f210a3c1dd3d53e45c510e309e90e1",
         "type": "github"
       },
       "original": {
@@ -59,11 +59,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1711671891,
-        "narHash": "sha256-C/Wwsy/RLxHP1axFFl+AnwJRWfd8gxDKKoa8nt8Qk3c=",
+        "lastModified": 1713121246,
+        "narHash": "sha256-502X0Q0fhN6tJK7iEUA8CghONKSatW/Mqj4Wappd++0=",
         "owner": "hyprwm",
         "repo": "hyprlang",
-        "rev": "c1402612146ba06606ebf64963a02bc1efe11e74",
+        "rev": "78fcaa27ae9e1d782faa3ff06c8ea55ddce63706",
         "type": "github"
       },
       "original": {
@@ -72,13 +72,36 @@
         "type": "github"
       }
     },
+    "hyprwayland-scanner": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ],
+        "systems": [
+          "systems"
+        ]
+      },
+      "locked": {
+        "lastModified": 1714755542,
+        "narHash": "sha256-D0pg+ZRwrt4lavZ97Ca8clsgbPA3duLj8iEM7riaIFY=",
+        "owner": "hyprwm",
+        "repo": "hyprwayland-scanner",
+        "rev": "1270ebaa539e56d61b708c24b072b09cbbd3a828",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hyprwm",
+        "repo": "hyprwayland-scanner",
+        "type": "github"
+      }
+    },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1712439257,
-        "narHash": "sha256-aSpiNepFOMk9932HOax0XwNxbA38GOUVOiXfUVPOrck=",
+        "lastModified": 1714253743,
+        "narHash": "sha256-mdTQw2XlariysyScCv2tTE45QSU9v/ezLcHJ22f0Nxc=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "ff0dbd94265ac470dda06a657d5fe49de93b4599",
+        "rev": "58a1abdbae3217ca6b702f03d3b35125d88a2994",
         "type": "github"
       },
       "original": {
@@ -93,6 +116,7 @@
         "hyprcursor": "hyprcursor",
         "hyprland-protocols": "hyprland-protocols",
         "hyprlang": "hyprlang",
+        "hyprwayland-scanner": "hyprwayland-scanner",
         "nixpkgs": "nixpkgs",
         "systems": "systems",
         "wlroots": "wlroots",
@@ -117,17 +141,17 @@
     "wlroots": {
       "flake": false,
       "locked": {
-        "lastModified": 1712935342,
-        "narHash": "sha256-zzIbTFNFd/as42jyGx23fil2uBDYYv+8GA5JmRq5y9c=",
+        "lastModified": 1713731601,
+        "narHash": "sha256-bdcKdtLkusvv85DNuJsajZLFeq7bXp+x5AGP1Sd4wD8=",
         "owner": "hyprwm",
         "repo": "wlroots-hyprland",
-        "rev": "62eeffbe233d199f520a5755c344e85f8eab7940",
+        "rev": "5c1d51c5a2793480f5b6c4341ad0797052aec2ea",
         "type": "github"
       },
       "original": {
         "owner": "hyprwm",
         "repo": "wlroots-hyprland",
-        "rev": "62eeffbe233d199f520a5755c344e85f8eab7940",
+        "rev": "5c1d51c5a2793480f5b6c4341ad0797052aec2ea",
         "type": "github"
       }
     },
@@ -147,11 +171,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1709299639,
-        "narHash": "sha256-jYqJM5khksLIbqSxCLUUcqEgI+O2LdlSlcMEBs39CAU=",
+        "lastModified": 1714060055,
+        "narHash": "sha256-j43TS9wv9luaAlpxcxw0sjxkbcc2mGANVR2RYgo3RCw=",
         "owner": "hyprwm",
         "repo": "xdg-desktop-portal-hyprland",
-        "rev": "2d2fb547178ec025da643db57d40a971507b82fe",
+        "rev": "0fe840441e43da12cd7865ed9aa8cdc35a8da85a",
         "type": "github"
       },
       "original": {

flake.nix

@@ -11,7 +11,7 @@
       type = "github";
       owner = "hyprwm";
       repo = "wlroots-hyprland";
-      rev = "62eeffbe233d199f520a5755c344e85f8eab7940";
+      rev = "5c1d51c5a2793480f5b6c4341ad0797052aec2ea";
       flake = false;
     };
 
@@ -34,6 +34,12 @@
       inputs.systems.follows = "systems";
     };
 
+    hyprwayland-scanner = {
+      url = "github:hyprwm/hyprwayland-scanner";
+      inputs.nixpkgs.follows = "nixpkgs";
+      inputs.systems.follows = "systems";
+    };
+
     xdph = {
       url = "github:hyprwm/xdg-desktop-portal-hyprland";
       inputs.nixpkgs.follows = "nixpkgs";

hyprctl/main.cpp

@@ -8,6 +8,7 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/un.h>
+#include <pwd.h>
 #include <unistd.h>
 #include <ranges>
 #include <algorithm>
@@ -38,24 +39,34 @@ struct SInstanceData {
     bool        valid = true;
 };
 
+std::string getRuntimeDir() {
+    const auto XDG = getenv("XDG_RUNTIME_DIR");
+
+    if (!XDG) {
+        const std::string USERID = std::to_string(getpwuid(getuid())->pw_uid);
+        return "/run/user/" + USERID + "/hypr";
+    }
+
+    return std::string{XDG} + "/hypr";
+}
+
 std::vector<SInstanceData> instances() {
     std::vector<SInstanceData> result;
 
-    for (const auto& el : std::filesystem::directory_iterator("/tmp/hypr")) {
-        if (el.is_directory() || !el.path().string().ends_with(".lock"))
+    for (const auto& el : std::filesystem::directory_iterator(getRuntimeDir())) {
+        if (!el.is_directory() || !std::filesystem::exists(el.path().string() + "/hyprland.lock"))
             continue;
 
         // read lock
         SInstanceData* data = &result.emplace_back();
-        data->id            = el.path().string();
-        data->id            = data->id.substr(data->id.find_last_of('/') + 1, data->id.find(".lock") - data->id.find_last_of('/') - 1);
+        data->id            = el.path().filename().string();
 
         try {
-            data->time = std::stoull(data->id.substr(data->id.find_first_of('_') + 1));
+            data->time = std::stoull(data->id.substr(data->id.find_first_of('_') + 1, data->id.find_last_of('_') - (data->id.find_first_of('_') + 1)));
         } catch (std::exception& e) { continue; }
 
         // read file
-        std::ifstream ifs(el.path().string());
+        std::ifstream ifs(el.path().string() + "/hyprland.lock");
 
         int           i = 0;
         for (std::string line; std::getline(ifs, line); ++i) {
@@ -99,10 +110,12 @@ void request(std::string arg, int minArgs = 0) {
         return;
     }
 
-    sockaddr_un serverAddress = {0};
-    serverAddress.sun_family  = AF_UNIX;
+    const std::string USERID = std::to_string(getpwuid(getuid())->pw_uid);
 
-    std::string socketPath = "/tmp/hypr/" + instanceSignature + "/.socket.sock";
+    sockaddr_un       serverAddress = {0};
+    serverAddress.sun_family        = AF_UNIX;
+
+    std::string socketPath = getRuntimeDir() + "/" + instanceSignature + "/.socket.sock";
 
     strncpy(serverAddress.sun_path, socketPath.c_str(), sizeof(serverAddress.sun_path) - 1);
 
@@ -160,7 +173,9 @@ void requestHyprpaper(std::string arg) {
     sockaddr_un serverAddress = {0};
     serverAddress.sun_family  = AF_UNIX;
 
-    std::string socketPath = "/tmp/hypr/" + instanceSignature + "/.hyprpaper.sock";
+    const std::string USERID = std::to_string(getpwuid(getuid())->pw_uid);
+
+    std::string       socketPath = getRuntimeDir() + "/" + instanceSignature + "/.hyprpaper.sock";
 
     strncpy(serverAddress.sun_path, socketPath.c_str(), sizeof(serverAddress.sun_path) - 1);
 

hyprctl/meson.build

@@ -2,6 +2,6 @@ executable('hyprctl', 'main.cpp',
   install: true
 )
 
-install_data('hyprctl.bash', install_dir: join_paths(get_option('datadir'), 'bash-completions'), install_tag: 'runtime', rename: 'hyprctl')
+install_data('hyprctl.bash', install_dir: join_paths(get_option('datadir'), 'bash-completion/completions'), install_tag: 'runtime', rename: 'hyprctl')
 install_data('hyprctl.fish', install_dir: join_paths(get_option('datadir'), 'fish/vendor_completions.d'), install_tag: 'runtime')
 install_data('hyprctl.zsh', install_dir: join_paths(get_option('datadir'), 'zsh/site-functions'), install_tag: 'runtime', rename: '_hyprctl')

hyprpm/src/core/PluginManager.cpp

@@ -12,6 +12,11 @@
 #include <algorithm>
 #include <format>
 
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <pwd.h>
+#include <unistd.h>
+
 #include <toml++/toml.hpp>
 
 static std::string removeBeginEndSpacesTabs(std::string str) {
@@ -92,9 +97,30 @@ SHyprlandVersion CPluginManager::getHyprlandVersion() {
     return ver;
 }
 
+bool CPluginManager::createSafeDirectory(const std::string& path) {
+    if (path.empty() || !path.starts_with("/tmp"))
+        return false;
+
+    if (std::filesystem::exists(path))
+        std::filesystem::remove_all(path);
+
+    if (std::filesystem::exists(path))
+        return false;
+
+    if (mkdir(path.c_str(), S_IRWXU) < 0)
+        return false;
+
+    return true;
+}
+
 bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string& rev) {
     const auto HLVER = getHyprlandVersion();
 
+    if (!hasDeps()) {
+        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not clone the plugin repository. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio\n";
+        return false;
+    }
+
     if (DataState::pluginRepoExists(url)) {
         std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not clone the plugin repository. Repository already installed.\n";
         return false;
@@ -132,24 +158,31 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     if (!std::filesystem::exists("/tmp/hyprpm")) {
         std::filesystem::create_directory("/tmp/hyprpm");
         std::filesystem::permissions("/tmp/hyprpm", std::filesystem::perms::all, std::filesystem::perm_options::replace);
+    } else if (!std::filesystem::is_directory("/tmp/hyprpm")) {
+        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not prepare working dir for hyprpm\n";
+        return false;
     }
 
-    if (std::filesystem::exists("/tmp/hyprpm/new")) {
-        progress.printMessageAbove(std::string{Colors::YELLOW} + "!" + Colors::RESET + " old plugin repo build files found in temp directory, removing.");
-        std::filesystem::remove_all("/tmp/hyprpm/new");
+    const std::string USERNAME = getpwuid(getuid())->pw_name;
+
+    m_szWorkingPluginDirectory = "/tmp/hyprpm/" + USERNAME;
+
+    if (!createSafeDirectory(m_szWorkingPluginDirectory)) {
+        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not prepare working dir for repo\n";
+        return false;
     }
 
     progress.printMessageAbove(std::string{Colors::RESET} + " → Cloning " + url);
 
-    std::string ret = execAndGet("cd /tmp/hyprpm && git clone --recursive " + url + " new");
+    std::string ret = execAndGet("cd /tmp/hyprpm && git clone --recursive " + url + " " + USERNAME);
 
-    if (!std::filesystem::exists("/tmp/hyprpm/new")) {
+    if (!std::filesystem::exists(m_szWorkingPluginDirectory + "/.git")) {
         std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not clone the plugin repository. shell returned:\n" << ret << "\n";
         return false;
     }
 
     if (!rev.empty()) {
-        std::string ret = execAndGet("git -C /tmp/hyprpm/new reset --hard --recurse-submodules " + rev);
+        std::string ret = execAndGet("git -C " + m_szWorkingPluginDirectory + " reset --hard --recurse-submodules " + rev);
         if (ret.compare(0, 6, "fatal:") == 0) {
             std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not check out revision " << rev << ". shell returned:\n" << ret << "\n";
             return false;
@@ -163,12 +196,12 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
 
     std::unique_ptr<CManifest> pManifest;
 
-    if (std::filesystem::exists("/tmp/hyprpm/new/hyprpm.toml")) {
+    if (std::filesystem::exists(m_szWorkingPluginDirectory + "/hyprpm.toml")) {
         progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " found hyprpm manifest");
-        pManifest = std::make_unique<CManifest>(MANIFEST_HYPRPM, "/tmp/hyprpm/new/hyprpm.toml");
-    } else if (std::filesystem::exists("/tmp/hyprpm/new/hyprload.toml")) {
+        pManifest = std::make_unique<CManifest>(MANIFEST_HYPRPM, m_szWorkingPluginDirectory + "/hyprpm.toml");
+    } else if (std::filesystem::exists(m_szWorkingPluginDirectory + "/hyprload.toml")) {
         progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " found hyprload manifest");
-        pManifest = std::make_unique<CManifest>(MANIFEST_HYPRLOAD, "/tmp/hyprpm/new/hyprload.toml");
+        pManifest = std::make_unique<CManifest>(MANIFEST_HYPRLOAD, m_szWorkingPluginDirectory + "/hyprload.toml");
     }
 
     if (!pManifest) {
@@ -207,7 +240,7 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
 
             progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " commit pin " + plugin + " matched hl, resetting");
 
-            execAndGet("cd /tmp/hyprpm/new/ && git reset --hard --recurse-submodules " + plugin);
+            execAndGet("cd " + m_szWorkingPluginDirectory + " && git reset --hard --recurse-submodules " + plugin);
         }
     }
 
@@ -238,14 +271,14 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
         progress.printMessageAbove(std::string{Colors::RESET} + " → Building " + p.name);
 
         for (auto& bs : p.buildSteps) {
-            std::string cmd = std::format("cd /tmp/hyprpm/new && PKG_CONFIG_PATH=\"{}/share/pkgconfig\" {}", DataState::getHeadersPath(), bs);
+            std::string cmd = std::format("cd {} && PKG_CONFIG_PATH=\"{}/share/pkgconfig\" {}", m_szWorkingPluginDirectory, DataState::getHeadersPath(), bs);
             out += " -> " + cmd + "\n" + execAndGet(cmd) + "\n";
         }
 
         if (m_bVerbose)
             std::cout << Colors::BLUE << "[v] " << Colors::RESET << "shell returned: " << out << "\n";
 
-        if (!std::filesystem::exists("/tmp/hyprpm/new/" + p.output)) {
+        if (!std::filesystem::exists(m_szWorkingPluginDirectory + "/" + p.output)) {
             progress.printMessageAbove(std::string{Colors::RED} + "✖" + Colors::RESET + " Plugin " + p.name + " failed to build.\n" +
                                        "  This likely means that the plugin is either outdated, not yet available for your version, or broken.\n  If you are on -git, update "
                                        "first.\n  Try re-running with -v to see "
@@ -265,7 +298,7 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
 
     // add repo toml to DataState
     SPluginRepository repo;
-    std::string       repohash = execAndGet("cd /tmp/hyprpm/new/ && git rev-parse HEAD");
+    std::string       repohash = execAndGet("cd " + m_szWorkingPluginDirectory + " && git rev-parse HEAD");
     if (repohash.length() > 0)
         repohash.pop_back();
     repo.name = pManifest->m_sRepository.name.empty() ? url.substr(url.find_last_of('/') + 1) : pManifest->m_sRepository.name;
@@ -273,7 +306,7 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     repo.rev  = rev;
     repo.hash = repohash;
     for (auto& p : pManifest->m_vPlugins) {
-        repo.plugins.push_back(SPlugin{p.name, "/tmp/hyprpm/new/" + p.output, false, p.failed});
+        repo.plugins.push_back(SPlugin{p.name, m_szWorkingPluginDirectory + "/" + p.output, false, p.failed});
     }
     DataState::addNewPluginRepo(repo);
 
@@ -286,7 +319,7 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     std::cout << "\n";
 
     // remove build files
-    std::filesystem::remove_all("/tmp/hyprpm/new");
+    std::filesystem::remove_all(m_szWorkingPluginDirectory);
 
     return true;
 }
@@ -378,6 +411,11 @@ bool CPluginManager::updateHeaders(bool force) {
 
     const auto HLVER = getHyprlandVersion();
 
+    if (!hasDeps()) {
+        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not update. Dependencies not satisfied. Hyprpm requires: cmake, meson, cpio\n";
+        return false;
+    }
+
     if (!std::filesystem::exists("/tmp/hyprpm")) {
         std::filesystem::create_directory("/tmp/hyprpm");
         std::filesystem::permissions("/tmp/hyprpm", std::filesystem::perms::all, std::filesystem::perm_options::replace);
@@ -394,16 +432,31 @@ bool CPluginManager::updateHeaders(bool force) {
     progress.m_szCurrentMessage = "Cloning the hyprland repository";
     progress.print();
 
-    if (std::filesystem::exists("/tmp/hyprpm/hyprland")) {
-        progress.printMessageAbove(std::string{Colors::YELLOW} + "!" + Colors::RESET + " old hyprland source files found in temp directory, removing.");
-        std::filesystem::remove_all("/tmp/hyprpm/hyprland");
+    const std::string USERNAME   = getpwuid(getuid())->pw_name;
+    const auto        WORKINGDIR = "/tmp/hyprpm/hyprland-" + USERNAME;
+
+    if (!createSafeDirectory(WORKINGDIR)) {
+        std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not prepare working dir for hl\n";
+        return false;
     }
 
     progress.printMessageAbove(std::string{Colors::YELLOW} + "!" + Colors::RESET + " Cloning https://github.com/hyprwm/hyprland, this might take a moment.");
 
-    std::string ret = execAndGet("cd /tmp/hyprpm && git clone --recursive https://github.com/hyprwm/hyprland hyprland --shallow-since='" + HLVER.date + "'");
+    // let us give a bit of leg-room for shallowing
+    // due to timezones, etc.
+    const std::string SHALLOW_DATE = removeBeginEndSpacesTabs(HLVER.date).empty() ? "" : execAndGet("date --date='" + HLVER.date + " - 1 weeks' '+\%a \%b \%d \%H:\%M:\%S \%Y'");
 
-    if (!std::filesystem::exists("/tmp/hyprpm/hyprland")) {
+    if (m_bVerbose)
+        progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "will shallow since: " + SHALLOW_DATE);
+
+    std::string ret = execAndGet("cd /tmp/hyprpm && git clone --recursive https://github.com/hyprwm/hyprland hyprland-" + USERNAME + " --shallow-since='" + SHALLOW_DATE + "'");
+
+    if (!std::filesystem::exists(WORKINGDIR)) {
+        progress.printMessageAbove(std::string{Colors::RED} + "✖" + Colors::RESET + " Clone failed. Retrying without shallow.");
+        ret = execAndGet("cd /tmp/hyprpm && git clone --recursive https://github.com/hyprwm/hyprland hyprland-" + USERNAME);
+    }
+
+    if (!std::filesystem::exists(WORKINGDIR + "/.git")) {
         std::cerr << "\n" << Colors::RED << "✖" << Colors::RESET << " Could not clone the hyprland repository. shell returned:\n" << ret << "\n";
         return false;
     }
@@ -413,11 +466,15 @@ bool CPluginManager::updateHeaders(bool force) {
     progress.m_szCurrentMessage = "Checking out sources";
     progress.print();
 
-    ret = execAndGet("cd /tmp/hyprpm/hyprland && git checkout " + HLVER.branch +
-                     " 2>&1 && git rm subprojects/tracy && git submodule update --init 2>&1 && git reset --hard --recurse-submodules " + HLVER.hash);
+    ret = execAndGet("cd " + WORKINGDIR + " && git checkout " + HLVER.branch + " 2>&1");
 
     if (m_bVerbose)
-        progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "git returned: " + ret);
+        progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "git returned (co): " + ret);
+
+    ret = execAndGet("cd " + WORKINGDIR + " && git rm subprojects/tracy && git submodule update --init 2>&1 && git reset --hard --recurse-submodules " + HLVER.hash);
+
+    if (m_bVerbose)
+        progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "git returned (rs): " + ret);
 
     progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " checked out to running ver");
     progress.m_iSteps           = 3;
@@ -429,14 +486,13 @@ bool CPluginManager::updateHeaders(bool force) {
     if (m_bVerbose)
         progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "setting PREFIX for cmake to " + DataState::getHeadersPath());
 
-    ret = execAndGet(
-        std::format("cd /tmp/hyprpm/hyprland && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:STRING=\"{}\" -S . -B ./build -G Ninja",
-                    DataState::getHeadersPath()));
+    ret = execAndGet(std::format("cd {} && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:STRING=\"{}\" -S . -B ./build -G Ninja", WORKINGDIR,
+                                 DataState::getHeadersPath()));
     if (m_bVerbose)
         progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "cmake returned: " + ret);
 
     // le hack. Wlroots has to generate its build/include
-    ret = execAndGet("cd /tmp/hyprpm/hyprland/subprojects/wlroots-hyprland && meson setup -Drenderers=gles2 -Dexamples=false build");
+    ret = execAndGet("cd " + WORKINGDIR + "/subprojects/wlroots-hyprland && meson setup -Drenderers=gles2 -Dexamples=false build");
     if (m_bVerbose)
         progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "meson returned: " + ret);
 
@@ -445,8 +501,8 @@ 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 = {}#\" /tmp/hyprpm/hyprland/Makefile && cd /tmp/hyprpm/hyprland && make installheaders",
-                                  DataState::getHeadersPath());
+    std::string cmd =
+        std::format("sed -i -e \"s#PREFIX = /usr/local#PREFIX = {}#\" {}/Makefile && cd {} && make installheaders", DataState::getHeadersPath(), WORKINGDIR, WORKINGDIR);
     if (m_bVerbose)
         progress.printMessageAbove(std::string{Colors::BLUE} + "[v] " + Colors::RESET + "installation will run: " + cmd);
 
@@ -456,7 +512,7 @@ bool CPluginManager::updateHeaders(bool force) {
         std::cout << Colors::BLUE << "[v] " << Colors::RESET << "installer returned: " << ret << "\n";
 
     // remove build files
-    std::filesystem::remove_all("/tmp/hyprpm/hyprland");
+    std::filesystem::remove_all(WORKINGDIR);
 
     auto HEADERSVALID = headersValid();
     if (HEADERSVALID == HEADERS_OK) {
@@ -503,6 +559,9 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
     progress.m_szCurrentMessage = "Updating repositories";
     progress.print();
 
+    const std::string USERNAME = getpwuid(getuid())->pw_name;
+    m_szWorkingPluginDirectory = "/tmp/hyprpm/" + USERNAME;
+
     for (auto& repo : REPOS) {
         bool update = forceUpdateAll;
 
@@ -512,16 +571,13 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
 
         progress.printMessageAbove(std::string{Colors::RESET} + " → checking for updates for " + repo.name);
 
-        if (std::filesystem::exists("/tmp/hyprpm/update")) {
-            progress.printMessageAbove(std::string{Colors::YELLOW} + "!" + Colors::RESET + " old update build files found in temp directory, removing.");
-            std::filesystem::remove_all("/tmp/hyprpm/update");
-        }
+        createSafeDirectory(m_szWorkingPluginDirectory);
 
         progress.printMessageAbove(std::string{Colors::RESET} + " → Cloning " + repo.url);
 
-        std::string ret = execAndGet("cd /tmp/hyprpm && git clone --recursive " + repo.url + " update");
+        std::string ret = execAndGet("cd /tmp/hyprpm && git clone --recursive " + repo.url + " " + USERNAME);
 
-        if (!std::filesystem::exists("/tmp/hyprpm/update")) {
+        if (!std::filesystem::exists(m_szWorkingPluginDirectory + "/.git")) {
             std::cout << "\n" << std::string{Colors::RED} + "✖" + Colors::RESET + " could not clone repo: shell returned:\n" + ret;
             return false;
         }
@@ -529,7 +585,7 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
         if (!repo.rev.empty()) {
             progress.printMessageAbove(std::string{Colors::RESET} + " → Plugin has revision set, resetting: " + repo.rev);
 
-            std::string ret = execAndGet("git -C /tmp/hyprpm/update reset --hard --recurse-submodules " + repo.rev);
+            std::string ret = execAndGet("git -C " + m_szWorkingPluginDirectory + " reset --hard --recurse-submodules " + repo.rev);
             if (ret.compare(0, 6, "fatal:") == 0) {
                 std::cout << "\n" << std::string{Colors::RED} + "✖" + Colors::RESET + " could not check out revision " + repo.rev + ": shell returned:\n" + ret;
                 return false;
@@ -538,7 +594,7 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
 
         if (!update) {
             // check if git has updates
-            std::string hash = execAndGet("cd /tmp/hyprpm/update && git rev-parse HEAD");
+            std::string hash = execAndGet("cd " + m_szWorkingPluginDirectory + " && git rev-parse HEAD");
             if (!hash.empty())
                 hash.pop_back();
 
@@ -546,7 +602,7 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
         }
 
         if (!update) {
-            std::filesystem::remove_all("/tmp/hyprpm/update");
+            std::filesystem::remove_all(m_szWorkingPluginDirectory);
             progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " repository " + repo.name + " is up-to-date.");
             progress.m_iSteps++;
             progress.print();
@@ -562,12 +618,12 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
 
         std::unique_ptr<CManifest> pManifest;
 
-        if (std::filesystem::exists("/tmp/hyprpm/update/hyprpm.toml")) {
+        if (std::filesystem::exists(m_szWorkingPluginDirectory + "/hyprpm.toml")) {
             progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " found hyprpm manifest");
-            pManifest = std::make_unique<CManifest>(MANIFEST_HYPRPM, "/tmp/hyprpm/update/hyprpm.toml");
-        } else if (std::filesystem::exists("/tmp/hyprpm/update/hyprload.toml")) {
+            pManifest = std::make_unique<CManifest>(MANIFEST_HYPRPM, m_szWorkingPluginDirectory + "/hyprpm.toml");
+        } else if (std::filesystem::exists(m_szWorkingPluginDirectory + "/hyprload.toml")) {
             progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " found hyprload manifest");
-            pManifest = std::make_unique<CManifest>(MANIFEST_HYPRLOAD, "/tmp/hyprpm/update/hyprload.toml");
+            pManifest = std::make_unique<CManifest>(MANIFEST_HYPRLOAD, m_szWorkingPluginDirectory + "/hyprload.toml");
         }
 
         if (!pManifest) {
@@ -591,14 +647,14 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
 
                 progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " commit pin " + plugin + " matched hl, resetting");
 
-                execAndGet("cd /tmp/hyprpm/update/ && git reset --hard --recurse-submodules " + plugin);
+                execAndGet("cd " + m_szWorkingPluginDirectory + " && git reset --hard --recurse-submodules " + plugin);
             }
         }
 
         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. */) {
+            if (p.since > HLVER.commits && HLVER.commits >= 1000 /* for shallow clones, we can't check this. 1000 is an arbitrary number I chose. */) {
                 progress.printMessageAbove(std::string{Colors::RED} + "✖" + Colors::RESET + " Not building " + p.name + ": your Hyprland version is too old.\n");
                 p.failed = true;
                 continue;
@@ -607,14 +663,14 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
             progress.printMessageAbove(std::string{Colors::RESET} + " → Building " + p.name);
 
             for (auto& bs : p.buildSteps) {
-                std::string cmd = std::format("cd /tmp/hyprpm/update && PKG_CONFIG_PATH=\"{}/share/pkgconfig\" {}", DataState::getHeadersPath(), bs);
+                std::string cmd = std::format("cd {} && PKG_CONFIG_PATH=\"{}/share/pkgconfig\" {}", m_szWorkingPluginDirectory, DataState::getHeadersPath(), bs);
                 out += " -> " + cmd + "\n" + execAndGet(cmd) + "\n";
             }
 
             if (m_bVerbose)
                 std::cout << Colors::BLUE << "[v] " << Colors::RESET << "shell returned: " << out << "\n";
 
-            if (!std::filesystem::exists("/tmp/hyprpm/update/" + p.output)) {
+            if (!std::filesystem::exists(m_szWorkingPluginDirectory + "/" + p.output)) {
                 std::cerr << "\n"
                           << Colors::RED << "✖" << Colors::RESET << " Plugin " << p.name << " failed to build.\n"
                           << "  This likely means that the plugin is either outdated, not yet available for your version, or broken.\n  If you are on -git, update first.\n  Try "
@@ -630,20 +686,20 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
         // add repo toml to DataState
         SPluginRepository newrepo = repo;
         newrepo.plugins.clear();
-        execAndGet(
-            "cd /tmp/hyprpm/update/ && git pull --recurse-submodules && git reset --hard --recurse-submodules"); // repo hash in the state.toml has to match head and not any pin
-        std::string repohash = execAndGet("cd /tmp/hyprpm/update && git rev-parse HEAD");
+        execAndGet("cd " + m_szWorkingPluginDirectory +
+                   " && git pull --recurse-submodules && git reset --hard --recurse-submodules"); // repo hash in the state.toml has to match head and not any pin
+        std::string repohash = execAndGet("cd " + m_szWorkingPluginDirectory + " && git rev-parse HEAD");
         if (repohash.length() > 0)
             repohash.pop_back();
         newrepo.hash = repohash;
         for (auto& 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, "/tmp/hyprpm/update/" + p.output, OLDPLUGINIT != repo.plugins.end() ? OLDPLUGINIT->enabled : false});
+            newrepo.plugins.push_back(SPlugin{p.name, m_szWorkingPluginDirectory + "/" + p.output, OLDPLUGINIT != repo.plugins.end() ? OLDPLUGINIT->enabled : false});
         }
         DataState::removePluginRepo(newrepo.name);
         DataState::addNewPluginRepo(newrepo);
 
-        std::filesystem::remove_all("/tmp/hyprpm/update");
+        std::filesystem::remove_all(m_szWorkingPluginDirectory);
 
         progress.printMessageAbove(std::string{Colors::GREEN} + "✔" + Colors::RESET + " updated " + repo.name);
     }
@@ -817,3 +873,13 @@ std::string CPluginManager::headerError(const eHeadersErrors err) {
 
     return std::string{Colors::RED} + "✖" + Colors::RESET + " Unknown header error. Please run hyprpm update to fix those.\n";
 }
+
+bool CPluginManager::hasDeps() {
+    std::vector<std::string> deps = {"meson", "cpio", "cmake"};
+    for (auto& d : deps) {
+        if (!execAndGet("which " + d + " 2>&1").contains("/"))
+            return false;
+    }
+
+    return true;
+}

hyprpm/src/core/PluginManager.hpp

@@ -56,10 +56,17 @@ class CPluginManager {
 
     void                   notify(const eNotifyIcons icon, uint32_t color, int durationMs, const std::string& message);
 
+    bool                   hasDeps();
+
     bool                   m_bVerbose = false;
 
+    // will delete recursively if exists!!
+    bool createSafeDirectory(const std::string& path);
+
   private:
     std::string headerError(const eHeadersErrors err);
+
+    std::string m_szWorkingPluginDirectory = "";
 };
 
 inline std::unique_ptr<CPluginManager> g_pPluginManager;

hyprpm/src/meson.build

@@ -9,6 +9,6 @@ executable('hyprpm', src,
   install : true
 )
 
-install_data('../hyprpm.bash', install_dir: join_paths(get_option('datadir'), 'bash-completions'), install_tag: 'runtime', rename: 'hyprpm')
+install_data('../hyprpm.bash', install_dir: join_paths(get_option('datadir'), 'bash-completion/completions'), install_tag: 'runtime', rename: 'hyprpm')
 install_data('../hyprpm.fish', install_dir: join_paths(get_option('datadir'), 'fish/vendor_completions.d'), install_tag: 'runtime')
 install_data('../hyprpm.zsh', install_dir: join_paths(get_option('datadir'), 'zsh/site-functions'), install_tag: 'runtime', rename: '_hyprpm')

meson.build

@@ -51,14 +51,10 @@ if not have_xwayland
 endif
 
 backtrace_dep = cpp_compiler.find_library('execinfo', required: false)
-systemd_dep = dependency('libsystemd', required: get_option('systemd'))
+epoll_dep = dependency('epoll-shim', required: false) # timerfd on BSDs
 
 if get_option('systemd').enabled()
-  if systemd_dep.found()
-    add_project_arguments('-DUSES_SYSTEMD', language: 'cpp')
-  else
-  	error('Cannot enable systemd in Hyprland: libsystemd was not found')
-  endif
+  add_project_arguments('-DUSES_SYSTEMD', language: 'cpp')
 endif
 
 if get_option('legacy_renderer').enabled()

nix/default.nix

@@ -12,11 +12,13 @@
   hyprcursor,
   hyprland-protocols,
   hyprlang,
+  hyprwayland-scanner,
   jq,
   libGL,
   libdrm,
   libexecinfo,
   libinput,
+  libuuid,
   libxcb,
   libxkbcommon,
   mesa,
@@ -86,6 +88,7 @@ in
     '';
 
     nativeBuildInputs = [
+      hyprwayland-scanner
       jq
       makeWrapper
       meson
@@ -111,6 +114,7 @@ in
         libdrm
         libGL
         libinput
+        libuuid
         libxkbcommon
         mesa
         pango
@@ -144,7 +148,6 @@ in
       ${lib.optionalString wrapRuntimeDeps ''
         wrapProgram $out/bin/Hyprland \
           --suffix PATH : ${lib.makeBinPath [
-          stdenv.cc
           binutils
           pciutils
           pkgconf

nix/overlays.nix

@@ -24,8 +24,10 @@ in {
     inputs.hyprcursor.overlays.default
     inputs.hyprland-protocols.overlays.default
     inputs.hyprlang.overlays.default
+    inputs.hyprwayland-scanner.overlays.default
     self.overlays.wlroots-hyprland
     self.overlays.udis86
+    self.overlays.wayland-protocols
     # Hyprland packages themselves
     (final: prev: let
       date = mkDate (self.lastModifiedDate or "19700101");
@@ -75,4 +77,14 @@ in {
       src = inputs.wlroots;
     };
   };
+
+  wayland-protocols = final: prev: {
+    wayland-protocols = prev.wayland-protocols.overrideAttrs (self: super: {
+      version = "1.35";
+      src = prev.fetchurl {
+        url = "https://gitlab.freedesktop.org/wayland/${super.pname}/-/releases/${self.version}/downloads/${super.pname}-${self.version}.tar.xz";
+        hash = "sha256-N6JxaigTPcgZNBxWiinSHoy3ITDlwSah/PyfQsI9las=";
+      };
+    });
+  };
 }

nix/patches/meson-build.patch

@@ -1,5 +1,5 @@
 diff --git a/meson.build b/meson.build
-index 1d2c7f9f..c5ef4e67 100644
+index 40883073..d8f2e536 100644
 --- a/meson.build
 +++ b/meson.build
 @@ -33,20 +33,7 @@ if cpp_compiler.check_header('execinfo.h')
@@ -24,7 +24,7 @@ index 1d2c7f9f..c5ef4e67 100644
    add_project_arguments('-DNO_XWAYLAND', language: 'cpp')
  endif
  
-@@ -69,8 +56,6 @@ if get_option('buildtype') == 'debug'
+@@ -65,8 +52,6 @@ if get_option('buildtype') == 'debug'
    add_project_arguments('-DHYPRLAND_DEBUG', language: 'cpp')
  endif
  
@@ -34,7 +34,7 @@ index 1d2c7f9f..c5ef4e67 100644
  headers = globber.stdout().strip().split('\n')
  foreach file : headers
 diff --git a/src/meson.build b/src/meson.build
-index 45701f5f..3505cefe 100644
+index 15c69552..327aa4fb 100644
 --- a/src/meson.build
 +++ b/src/meson.build
 @@ -9,7 +9,7 @@ executable('Hyprland', src,
@@ -46,14 +46,14 @@ index 45701f5f..3505cefe 100644
      dependency('cairo'),
      dependency('hyprcursor'),
      dependency('hyprlang', version: '>= 0.3.2'),
-@@ -16,12 +16,12 @@ executable('Hyprland', src,
+@@ -17,10 +17,10 @@ executable('Hyprland', src,
      dependency('egl'),
      dependency('xkbcommon'),
      dependency('libinput'),
 -    xcb_dep,
 +    dependency('xcb', required: get_option('xwayland')),
      backtrace_dep,
-     systemd_dep,
+     epoll_dep,
 -    udis86,
 +    dependency('udis86'),
  

nix/wlroots.nix

@@ -1,6 +1,7 @@
 {
   version,
   src,
+  git,
   wlroots,
   enableXWayland ? true,
 }:
@@ -10,4 +11,6 @@ wlroots.overrideAttrs (old: {
   pname = "${old.pname}-hyprland";
 
   patches = [ ]; # don't inherit old.patches
+
+  nativeBuildInputs = old.nativeBuildInputs ++ [ git ];
 })

props.json

@@ -1,3 +1,3 @@
 {
-    "version": "0.39.0"
+    "version": "0.40.0"
 }

protocols/idle.xml

@@ -1,49 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<protocol name="idle">
-  <copyright><![CDATA[
-    Copyright (C) 2015 Martin Gräßlin
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as published by
-    the Free Software Foundation, either version 2.1 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-  ]]></copyright>
-  <interface  name="org_kde_kwin_idle" version="1">
-      <description summary="User idle time manager">
-        This interface allows to monitor user idle time on a given seat. The interface
-        allows to register timers which trigger after no user activity was registered
-        on the seat for a given interval. It notifies when user activity resumes.
-
-        This is useful for applications wanting to perform actions when the user is not
-        interacting with the system, e.g. chat applications setting the user as away, power
-        management features to dim screen, etc..
-      </description>
-      <request name="get_idle_timeout">
-        <arg name="id" type="new_id" interface="org_kde_kwin_idle_timeout"/>
-        <arg name="seat" type="object" interface="wl_seat"/>
-        <arg name="timeout" type="uint" summary="The idle timeout in msec"/>
-      </request>
-  </interface>
-  <interface name="org_kde_kwin_idle_timeout" version="1">
-      <request name="release" type="destructor">
-        <description summary="release the timeout object"/>
-      </request>
-      <request name="simulate_user_activity">
-          <description summary="Simulates user activity for this timeout, behaves just like real user activity on the seat"/>
-      </request>
-      <event name="idle">
-          <description summary="Triggered when there has not been any user activity in the requested idle time interval"/>
-      </event>
-      <event name="resumed">
-          <description summary="Triggered on the first user activity after an idle event"/>
-      </event>
-  </interface>
-</protocol>

protocols/input-method-unstable-v2.xml

@@ -0,0 +1,494 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="input_method_unstable_v2">
+
+  <copyright>
+    Copyright © 2008-2011 Kristian Høgsberg
+    Copyright © 2010-2011 Intel Corporation
+    Copyright © 2012-2013 Collabora, Ltd.
+    Copyright © 2012, 2013 Intel Corporation
+    Copyright © 2015, 2016 Jan Arne Petersen
+    Copyright © 2017, 2018 Red Hat, Inc.
+    Copyright © 2018       Purism SPC
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+  </copyright>
+
+  <description summary="Protocol for creating input methods">
+    This protocol allows applications to act as input methods for compositors.
+
+    An input method context is used to manage the state of the input method.
+
+    Text strings are UTF-8 encoded, their indices and lengths are in bytes.
+
+    This document adheres to the RFC 2119 when using words like "must",
+    "should", "may", etc.
+
+    Warning! The protocol described in this file is experimental and
+    backward incompatible changes may be made. Backward compatible changes
+    may be added together with the corresponding interface version bump.
+    Backward incompatible changes are done by bumping the version number in
+    the protocol and interface names and resetting the interface version.
+    Once the protocol is to be declared stable, the 'z' prefix and the
+    version number in the protocol and interface names are removed and the
+    interface version number is reset.
+  </description>
+
+  <interface name="zwp_input_method_v2" version="1">
+    <description summary="input method">
+      An input method object allows for clients to compose text.
+
+      The objects connects the client to a text input in an application, and
+      lets the client to serve as an input method for a seat.
+
+      The zwp_input_method_v2 object can occupy two distinct states: active and
+      inactive. In the active state, the object is associated to and
+      communicates with a text input. In the inactive state, there is no
+      associated text input, and the only communication is with the compositor.
+      Initially, the input method is in the inactive state.
+
+      Requests issued in the inactive state must be accepted by the compositor.
+      Because of the serial mechanism, and the state reset on activate event,
+      they will not have any effect on the state of the next text input.
+
+      There must be no more than one input method object per seat.
+    </description>
+
+    <enum name="error">
+      <entry name="role" value="0" summary="wl_surface has another role"/>
+    </enum>
+
+    <event name="activate">
+      <description summary="input method has been requested">
+        Notification that a text input focused on this seat requested the input
+        method to be activated.
+
+        This event serves the purpose of providing the compositor with an
+        active input method.
+
+        This event resets all state associated with previous enable, disable,
+        surrounding_text, text_change_cause, and content_type events, as well
+        as the state associated with set_preedit_string, commit_string, and
+        delete_surrounding_text requests. In addition, it marks the
+        zwp_input_method_v2 object as active, and makes any existing
+        zwp_input_popup_surface_v2 objects visible.
+
+        The surrounding_text, and content_type events must follow before the
+        next done event if the text input supports the respective
+        functionality.
+
+        State set with this event is double-buffered. It will get applied on
+        the next zwp_input_method_v2.done event, and stay valid until changed.
+      </description>
+    </event>
+
+    <event name="deactivate">
+      <description summary="deactivate event">
+        Notification that no focused text input currently needs an active 
+        input method on this seat.
+
+        This event marks the zwp_input_method_v2 object as inactive. The
+        compositor must make all existing zwp_input_popup_surface_v2 objects
+        invisible until the next activate event.
+
+        State set with this event is double-buffered. It will get applied on
+        the next zwp_input_method_v2.done event, and stay valid until changed.
+      </description>
+    </event>
+
+    <event name="surrounding_text">
+      <description summary="surrounding text event">
+        Updates the surrounding plain text around the cursor, excluding the
+        preedit text.
+
+        If any preedit text is present, it is replaced with the cursor for the
+        purpose of this event.
+
+        The argument text is a buffer containing the preedit string, and must
+        include the cursor position, and the complete selection. It should
+        contain additional characters before and after these. There is a
+        maximum length of wayland messages, so text can not be longer than 4000
+        bytes.
+
+        cursor is the byte offset of the cursor within the text buffer.
+
+        anchor is the byte offset of the selection anchor within the text
+        buffer. If there is no selected text, anchor must be the same as
+        cursor.
+
+        If this event does not arrive before the first done event, the input
+        method may assume that the text input does not support this
+        functionality and ignore following surrounding_text events.
+
+        Values set with this event are double-buffered. They will get applied
+        and set to initial values on the next zwp_input_method_v2.done
+        event.
+
+        The initial state for affected fields is empty, meaning that the text
+        input does not support sending surrounding text. If the empty values
+        get applied, subsequent attempts to change them may have no effect.
+      </description>
+      <arg name="text" type="string"/>
+      <arg name="cursor" type="uint"/>
+      <arg name="anchor" type="uint"/>
+    </event>
+
+    <event name="text_change_cause">
+      <description summary="indicates the cause of surrounding text change">
+        Tells the input method why the text surrounding the cursor changed.
+
+        Whenever the client detects an external change in text, cursor, or
+        anchor position, it must issue this request to the compositor. This
+        request is intended to give the input method a chance to update the
+        preedit text in an appropriate way, e.g. by removing it when the user
+        starts typing with a keyboard.
+
+        cause describes the source of the change.
+
+        The value set with this event is double-buffered. It will get applied
+        and set to its initial value on the next zwp_input_method_v2.done
+        event.
+
+        The initial value of cause is input_method.
+      </description>
+      <arg name="cause" type="uint" enum="zwp_text_input_v3.change_cause"/>
+    </event>
+
+    <event name="content_type">
+      <description summary="content purpose and hint">
+        Indicates the content type and hint for the current
+        zwp_input_method_v2 instance.
+
+        Values set with this event are double-buffered. They will get applied
+        on the next zwp_input_method_v2.done event.
+
+        The initial value for hint is none, and the initial value for purpose
+        is normal.
+      </description>
+      <arg name="hint" type="uint" enum="zwp_text_input_v3.content_hint"/>
+      <arg name="purpose" type="uint" enum="zwp_text_input_v3.content_purpose"/>
+    </event>
+
+    <event name="done">
+      <description summary="apply state">
+        Atomically applies state changes recently sent to the client.
+
+        The done event establishes and updates the state of the client, and
+        must be issued after any changes to apply them.
+
+        Text input state (content purpose, content hint, surrounding text, and
+        change cause) is conceptually double-buffered within an input method
+        context.
+
+        Events modify the pending state, as opposed to the current state in use
+        by the input method. A done event atomically applies all pending state,
+        replacing the current state. After done, the new pending state is as
+        documented for each related request.
+
+        Events must be applied in the order of arrival.
+
+        Neither current nor pending state are modified unless noted otherwise.
+      </description>
+    </event>
+
+    <request name="commit_string">
+      <description summary="commit string">
+        Send the commit string text for insertion to the application.
+
+        Inserts a string at current cursor position (see commit event
+        sequence). The string to commit could be either just a single character
+        after a key press or the result of some composing.
+
+        The argument text is a buffer containing the string to insert. There is
+        a maximum length of wayland messages, so text can not be longer than
+        4000 bytes.
+
+        Values set with this event are double-buffered. They must be applied
+        and reset to initial on the next zwp_text_input_v3.commit request.
+
+        The initial value of text is an empty string.
+      </description>
+      <arg name="text" type="string"/>
+    </request>
+
+    <request name="set_preedit_string">
+      <description summary="pre-edit string">
+        Send the pre-edit string text to the application text input.
+
+        Place a new composing text (pre-edit) at the current cursor position.
+        Any previously set composing text must be removed. Any previously
+        existing selected text must be removed. The cursor is moved to a new
+        position within the preedit string.
+
+        The argument text is a buffer containing the preedit string. There is
+        a maximum length of wayland messages, so text can not be longer than
+        4000 bytes.
+
+        The arguments cursor_begin and cursor_end are counted in bytes relative
+        to the beginning of the submitted string buffer. Cursor should be
+        hidden by the text input when both are equal to -1.
+
+        cursor_begin indicates the beginning of the cursor. cursor_end
+        indicates the end of the cursor. It may be equal or different than
+        cursor_begin.
+
+        Values set with this event are double-buffered. They must be applied on
+        the next zwp_input_method_v2.commit event.
+
+        The initial value of text is an empty string. The initial value of
+        cursor_begin, and cursor_end are both 0.
+      </description>
+      <arg name="text" type="string"/>
+      <arg name="cursor_begin" type="int"/>
+      <arg name="cursor_end" type="int"/>
+    </request>
+
+    <request name="delete_surrounding_text">
+      <description summary="delete text">
+        Remove the surrounding text.
+
+        before_length and after_length are the number of bytes before and after
+        the current cursor index (excluding the preedit text) to delete.
+
+        If any preedit text is present, it is replaced with the cursor for the
+        purpose of this event. In effect before_length is counted from the
+        beginning of preedit text, and after_length from its end (see commit
+        event sequence).
+
+        Values set with this event are double-buffered. They must be applied
+        and reset to initial on the next zwp_input_method_v2.commit request.
+
+        The initial values of both before_length and after_length are 0.
+      </description>
+      <arg name="before_length" type="uint"/>
+      <arg name="after_length" type="uint"/>
+    </request>
+
+    <request name="commit">
+      <description summary="apply state">
+        Apply state changes from commit_string, set_preedit_string and
+        delete_surrounding_text requests.
+
+        The state relating to these events is double-buffered, and each one
+        modifies the pending state. This request replaces the current state
+        with the pending state.
+
+        The connected text input is expected to proceed by evaluating the
+        changes in the following order:
+
+        1. Replace existing preedit string with the cursor.
+        2. Delete requested surrounding text.
+        3. Insert commit string with the cursor at its end.
+        4. Calculate surrounding text to send.
+        5. Insert new preedit text in cursor position.
+        6. Place cursor inside preedit text.
+
+        The serial number reflects the last state of the zwp_input_method_v2
+        object known to the client. The value of the serial argument must be
+        equal to the number of done events already issued by that object. When
+        the compositor receives a commit request with a serial different than
+        the number of past done events, it must proceed as normal, except it
+        should not change the current state of the zwp_input_method_v2 object.
+      </description>
+      <arg name="serial" type="uint"/>
+    </request>
+
+    <request name="get_input_popup_surface">
+      <description summary="create popup surface">
+        Creates a new zwp_input_popup_surface_v2 object wrapping a given
+        surface.
+
+        The surface gets assigned the "input_popup" role. If the surface
+        already has an assigned role, the compositor must issue a protocol
+        error.
+      </description>
+      <arg name="id" type="new_id" interface="zwp_input_popup_surface_v2"/>
+      <arg name="surface" type="object" interface="wl_surface"/>
+    </request>
+
+    <request name="grab_keyboard">
+      <description summary="grab hardware keyboard">
+        Allow an input method to receive hardware keyboard input and process
+        key events to generate text events (with pre-edit) over the wire. This
+        allows input methods which compose multiple key events for inputting
+        text like it is done for CJK languages.
+
+        The compositor should send all keyboard events on the seat to the grab
+        holder via the returned wl_keyboard object. Nevertheless, the
+        compositor may decide not to forward any particular event. The
+        compositor must not further process any event after it has been
+        forwarded to the grab holder.
+
+        Releasing the resulting wl_keyboard object releases the grab.
+      </description>
+      <arg name="keyboard" type="new_id"
+        interface="zwp_input_method_keyboard_grab_v2"/>
+    </request>
+
+    <event name="unavailable">
+      <description summary="input method unavailable">
+        The input method ceased to be available.
+
+        The compositor must issue this event as the only event on the object if
+        there was another input_method object associated with the same seat at
+        the time of its creation.
+
+        The compositor must issue this request when the object is no longer
+        usable, e.g. due to seat removal.
+
+        The input method context becomes inert and should be destroyed after
+        deactivation is handled. Any further requests and events except for the
+        destroy request must be ignored.
+      </description>
+    </event>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the text input">
+        Destroys the zwp_text_input_v2 object and any associated child
+        objects, i.e. zwp_input_popup_surface_v2 and
+        zwp_input_method_keyboard_grab_v2.
+      </description>
+    </request>
+  </interface>
+
+  <interface name="zwp_input_popup_surface_v2" version="1">
+    <description summary="popup surface">
+      This interface marks a surface as a popup for interacting with an input
+      method.
+
+      The compositor should place it near the active text input area. It must
+      be visible if and only if the input method is in the active state.
+
+      The client must not destroy the underlying wl_surface while the
+      zwp_input_popup_surface_v2 object exists.
+    </description>
+
+    <event name="text_input_rectangle">
+      <description summary="set text input area position">
+        Notify about the position of the area of the text input expressed as a
+        rectangle in surface local coordinates.
+
+        This is a hint to the input method telling it the relative position of
+        the text being entered.
+      </description>
+      <arg name="x" type="int"/>
+      <arg name="y" type="int"/>
+      <arg name="width" type="int"/>
+      <arg name="height" type="int"/>
+    </event>
+
+    <request name="destroy" type="destructor"/>
+  </interface>
+
+  <interface name="zwp_input_method_keyboard_grab_v2" version="1">
+    <!-- Closely follows wl_keyboard version 6 -->
+    <description summary="keyboard grab">
+      The zwp_input_method_keyboard_grab_v2 interface represents an exclusive
+      grab of the wl_keyboard interface associated with the seat.
+    </description>
+
+    <event name="keymap">
+      <description summary="keyboard mapping">
+        This event provides a file descriptor to the client which can be
+        memory-mapped to provide a keyboard mapping description.
+      </description>
+      <arg name="format" type="uint" enum="wl_keyboard.keymap_format"
+        summary="keymap format"/>
+      <arg name="fd" type="fd" summary="keymap file descriptor"/>
+      <arg name="size" type="uint" summary="keymap size, in bytes"/>
+    </event>
+
+    <event name="key">
+      <description summary="key event">
+        A key was pressed or released.
+        The time argument is a timestamp with millisecond granularity, with an
+        undefined base.
+      </description>
+      <arg name="serial" type="uint" summary="serial number of the key event"/>
+      <arg name="time" type="uint" summary="timestamp with millisecond granularity"/>
+      <arg name="key" type="uint" summary="key that produced the event"/>
+      <arg name="state" type="uint" enum="wl_keyboard.key_state"
+        summary="physical state of the key"/>
+    </event>
+
+    <event name="modifiers">
+      <description summary="modifier and group state">
+        Notifies clients that the modifier and/or group state has changed, and
+        it should update its local state.
+      </description>
+      <arg name="serial" type="uint" summary="serial number of the modifiers event"/>
+      <arg name="mods_depressed" type="uint" summary="depressed modifiers"/>
+      <arg name="mods_latched" type="uint" summary="latched modifiers"/>
+      <arg name="mods_locked" type="uint" summary="locked modifiers"/>
+      <arg name="group" type="uint" summary="keyboard layout"/>
+    </event>
+
+    <request name="release" type="destructor">
+      <description summary="release the grab object"/>
+    </request>
+
+    <event name="repeat_info">
+      <description summary="repeat rate and delay">
+        Informs the client about the keyboard's repeat rate and delay.
+
+        This event is sent as soon as the zwp_input_method_keyboard_grab_v2
+        object has been created, and is guaranteed to be received by the
+        client before any key press event.
+
+        Negative values for either rate or delay are illegal. A rate of zero
+        will disable any repeating (regardless of the value of delay).
+
+        This event can be sent later on as well with a new value if necessary,
+        so clients should continue listening for the event past the creation
+        of zwp_input_method_keyboard_grab_v2.
+      </description>
+      <arg name="rate" type="int"
+	   summary="the rate of repeating keys in characters per second"/>
+      <arg name="delay" type="int"
+	   summary="delay in milliseconds since key down until repeating starts"/>
+    </event>
+  </interface>
+
+  <interface name="zwp_input_method_manager_v2" version="1">
+    <description summary="input method manager">
+      The input method manager allows the client to become the input method on
+      a chosen seat.
+
+      No more than one input method must be associated with any seat at any
+      given time.
+    </description>
+
+    <request name="get_input_method">
+      <description summary="request an input method object">
+        Request a new input zwp_input_method_v2 object associated with a given
+        seat.
+      </description>
+      <arg name="seat" type="object" interface="wl_seat"/>
+      <arg name="input_method" type="new_id" interface="zwp_input_method_v2"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the input method manager">
+        Destroys the zwp_input_method_manager_v2 object.
+
+        The zwp_input_method_v2 objects originating from it remain valid.
+      </description>
+    </request>
+  </interface>
+</protocol>

protocols/meson.build

@@ -17,27 +17,52 @@ wayland_scanner = find_program(
 	wayland_scanner_dep.get_variable('wayland_scanner'),
 	native: true,
 )
+hyprwayland_scanner_dep = dependency('hyprwayland-scanner', native: true)
+hyprwayland_scanner = find_program(
+	hyprwayland_scanner_dep.get_variable('hyprwayland_scanner'),
+	native: true,
+)
 
 protocols = [
   [wl_protocol_dir, 'stable/xdg-shell/xdg-shell.xml'],
   [wl_protocol_dir, 'unstable/linux-dmabuf/linux-dmabuf-unstable-v1.xml'],
   [wl_protocol_dir, 'unstable/text-input/text-input-unstable-v1.xml'],
-  [wl_protocol_dir, 'unstable/xdg-output/xdg-output-unstable-v1.xml'],
-  [wl_protocol_dir, 'staging/fractional-scale/fractional-scale-v1.xml'],
-  [wl_protocol_dir, 'staging/cursor-shape/cursor-shape-v1.xml'],
-  [wl_protocol_dir, 'staging/tearing-control/tearing-control-v1.xml'],
-  ['wlr-foreign-toplevel-management-unstable-v1.xml'],
   ['wlr-layer-shell-unstable-v1.xml'],
-  ['wlr-output-power-management-unstable-v1.xml'],
   ['wlr-screencopy-unstable-v1.xml'],
-  ['pointer-constraints-unstable-v1.xml'],
   ['tablet-unstable-v2.xml'],
-  ['idle.xml'],
   [hl_protocol_dir, 'protocols/hyprland-toplevel-export-v1.xml'],
   [hl_protocol_dir, 'protocols/hyprland-global-shortcuts-v1.xml']
 ]
+
+new_protocols = [
+  ['wlr-gamma-control-unstable-v1.xml'],
+  ['wlr-foreign-toplevel-management-unstable-v1.xml'],
+  ['wlr-output-power-management-unstable-v1.xml'],
+  ['input-method-unstable-v2.xml'],
+  ['virtual-keyboard-unstable-v1.xml'],
+  ['wlr-virtual-pointer-unstable-v1.xml'],
+  ['wlr-output-management-unstable-v1.xml'],
+  [wl_protocol_dir, 'staging/tearing-control/tearing-control-v1.xml'],
+  [wl_protocol_dir, 'staging/fractional-scale/fractional-scale-v1.xml'],
+  [wl_protocol_dir, 'unstable/xdg-output/xdg-output-unstable-v1.xml'],
+  [wl_protocol_dir, 'staging/cursor-shape/cursor-shape-v1.xml'],
+  [wl_protocol_dir, 'unstable/idle-inhibit/idle-inhibit-unstable-v1.xml'],
+  [wl_protocol_dir, 'unstable/relative-pointer/relative-pointer-unstable-v1.xml'],
+  [wl_protocol_dir, 'unstable/xdg-decoration/xdg-decoration-unstable-v1.xml'],
+  [wl_protocol_dir, 'staging/alpha-modifier/alpha-modifier-v1.xml'],
+  [wl_protocol_dir, 'staging/ext-foreign-toplevel-list/ext-foreign-toplevel-list-v1.xml'],
+  [wl_protocol_dir, 'unstable/pointer-gestures/pointer-gestures-unstable-v1.xml'],
+  [wl_protocol_dir, 'unstable/keyboard-shortcuts-inhibit/keyboard-shortcuts-inhibit-unstable-v1.xml'],
+  [wl_protocol_dir, 'unstable/text-input/text-input-unstable-v3.xml'],
+  [wl_protocol_dir, 'unstable/pointer-constraints/pointer-constraints-unstable-v1.xml'],
+  [wl_protocol_dir, 'staging/xdg-activation/xdg-activation-v1.xml'],
+  [wl_protocol_dir, 'staging/ext-idle-notify/ext-idle-notify-v1.xml'],
+  [wl_protocol_dir, 'staging/ext-session-lock/ext-session-lock-v1.xml'],
+]
+
 wl_protos_src = []
 wl_protos_headers = []
+
 foreach p : protocols
 	xml = join_paths(p)
 	wl_protos_src += custom_target(
@@ -56,15 +81,28 @@ foreach p : protocols
 	)
 endforeach
 
+new_wl_protos = []
+foreach p : new_protocols
+	xml = join_paths(p)
+	new_wl_protos += custom_target(
+		xml.underscorify(),
+		input: xml,
+		install: true,
+		install_dir: [false, join_paths(get_option('includedir'), 'hyprland/protocols')],
+		output: ['@BASENAME@.cpp', '@BASENAME@.hpp'],
+		command: [hyprwayland_scanner, '@INPUT@', '@OUTDIR@'],
+	)
+endforeach
+
 wayland_server = dependency('wayland-server', version: '>=1.20.0')
 
 lib_server_protos = static_library(
 	'server_protos',
-	wl_protos_src + wl_protos_headers,
+	wl_protos_src + wl_protos_headers + new_wl_protos,
 	dependencies: wayland_server.partial_dependency(compile_args: true),
 )
 
 server_protos = declare_dependency(
 	link_with: lib_server_protos,
-	sources: wl_protos_headers,
+	sources: wl_protos_headers + new_wl_protos,
 )

protocols/pointer-constraints-unstable-v1.xml

@@ -1,339 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<protocol name="pointer_constraints_unstable_v1">
-
-  <copyright>
-    Copyright © 2014      Jonas Ådahl
-    Copyright © 2015      Red Hat Inc.
-
-    Permission is hereby granted, free of charge, to any person obtaining a
-    copy of this software and associated documentation files (the "Software"),
-    to deal in the Software without restriction, including without limitation
-    the rights to use, copy, modify, merge, publish, distribute, sublicense,
-    and/or sell copies of the Software, and to permit persons to whom the
-    Software is furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice (including the next
-    paragraph) shall be included in all copies or substantial portions of the
-    Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
-    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-    DEALINGS IN THE SOFTWARE.
-  </copyright>
-
-  <description summary="protocol for constraining pointer motions">
-    This protocol specifies a set of interfaces used for adding constraints to
-    the motion of a pointer. Possible constraints include confining pointer
-    motions to a given region, or locking it to its current position.
-
-    In order to constrain the pointer, a client must first bind the global
-    interface "wp_pointer_constraints" which, if a compositor supports pointer
-    constraints, is exposed by the registry. Using the bound global object, the
-    client uses the request that corresponds to the type of constraint it wants
-    to make. See wp_pointer_constraints for more details.
-
-    Warning! The protocol described in this file is experimental and backward
-    incompatible changes may be made. Backward compatible changes may be added
-    together with the corresponding interface version bump. Backward
-    incompatible changes are done by bumping the version number in the protocol
-    and interface names and resetting the interface version. Once the protocol
-    is to be declared stable, the 'z' prefix and the version number in the
-    protocol and interface names are removed and the interface version number is
-    reset.
-  </description>
-
-  <interface name="zwp_pointer_constraints_v1" version="1">
-    <description summary="constrain the movement of a pointer">
-      The global interface exposing pointer constraining functionality. It
-      exposes two requests: lock_pointer for locking the pointer to its
-      position, and confine_pointer for locking the pointer to a region.
-
-      The lock_pointer and confine_pointer requests create the objects
-      wp_locked_pointer and wp_confined_pointer respectively, and the client can
-      use these objects to interact with the lock.
-
-      For any surface, only one lock or confinement may be active across all
-      wl_pointer objects of the same seat. If a lock or confinement is requested
-      when another lock or confinement is active or requested on the same surface
-      and with any of the wl_pointer objects of the same seat, an
-      'already_constrained' error will be raised.
-    </description>
-
-    <enum name="error">
-      <description summary="wp_pointer_constraints error values">
-	These errors can be emitted in response to wp_pointer_constraints
-	requests.
-      </description>
-      <entry name="already_constrained" value="1"
-	     summary="pointer constraint already requested on that surface"/>
-    </enum>
-
-    <enum name="lifetime">
-      <description summary="constraint lifetime">
-	These values represent different lifetime semantics. They are passed
-	as arguments to the factory requests to specify how the constraint
-	lifetimes should be managed.
-      </description>
-      <entry name="oneshot" value="1">
-	<description summary="the pointer constraint is defunct once deactivated">
-	  A oneshot pointer constraint will never reactivate once it has been
-	  deactivated. See the corresponding deactivation event
-	  (wp_locked_pointer.unlocked and wp_confined_pointer.unconfined) for
-	  details.
-	</description>
-      </entry>
-      <entry name="persistent" value="2">
-	<description summary="the pointer constraint may reactivate">
-	  A persistent pointer constraint may again reactivate once it has
-	  been deactivated. See the corresponding deactivation event
-	  (wp_locked_pointer.unlocked and wp_confined_pointer.unconfined) for
-	  details.
-	</description>
-      </entry>
-    </enum>
-
-    <request name="destroy" type="destructor">
-      <description summary="destroy the pointer constraints manager object">
-	Used by the client to notify the server that it will no longer use this
-	pointer constraints object.
-      </description>
-    </request>
-
-    <request name="lock_pointer">
-      <description summary="lock pointer to a position">
-	The lock_pointer request lets the client request to disable movements of
-	the virtual pointer (i.e. the cursor), effectively locking the pointer
-	to a position. This request may not take effect immediately; in the
-	future, when the compositor deems implementation-specific constraints
-	are satisfied, the pointer lock will be activated and the compositor
-	sends a locked event.
-
-	The protocol provides no guarantee that the constraints are ever
-	satisfied, and does not require the compositor to send an error if the
-	constraints cannot ever be satisfied. It is thus possible to request a
-	lock that will never activate.
-
-	There may not be another pointer constraint of any kind requested or
-	active on the surface for any of the wl_pointer objects of the seat of
-	the passed pointer when requesting a lock. If there is, an error will be
-	raised. See general pointer lock documentation for more details.
-
-	The intersection of the region passed with this request and the input
-	region of the surface is used to determine where the pointer must be
-	in order for the lock to activate. It is up to the compositor whether to
-	warp the pointer or require some kind of user interaction for the lock
-	to activate. If the region is null the surface input region is used.
-
-	A surface may receive pointer focus without the lock being activated.
-
-	The request creates a new object wp_locked_pointer which is used to
-	interact with the lock as well as receive updates about its state. See
-	the the description of wp_locked_pointer for further information.
-
-	Note that while a pointer is locked, the wl_pointer objects of the
-	corresponding seat will not emit any wl_pointer.motion events, but
-	relative motion events will still be emitted via wp_relative_pointer
-	objects of the same seat. wl_pointer.axis and wl_pointer.button events
-	are unaffected.
-      </description>
-      <arg name="id" type="new_id" interface="zwp_locked_pointer_v1"/>
-      <arg name="surface" type="object" interface="wl_surface"
-	   summary="surface to lock pointer to"/>
-      <arg name="pointer" type="object" interface="wl_pointer"
-	   summary="the pointer that should be locked"/>
-      <arg name="region" type="object" interface="wl_region" allow-null="true"
-	   summary="region of surface"/>
-      <arg name="lifetime" type="uint" enum="lifetime" summary="lock lifetime"/>
-    </request>
-
-    <request name="confine_pointer">
-      <description summary="confine pointer to a region">
-	The confine_pointer request lets the client request to confine the
-	pointer cursor to a given region. This request may not take effect
-	immediately; in the future, when the compositor deems implementation-
-	specific constraints are satisfied, the pointer confinement will be
-	activated and the compositor sends a confined event.
-
-	The intersection of the region passed with this request and the input
-	region of the surface is used to determine where the pointer must be
-	in order for the confinement to activate. It is up to the compositor
-	whether to warp the pointer or require some kind of user interaction for
-	the confinement to activate. If the region is null the surface input
-	region is used.
-
-	The request will create a new object wp_confined_pointer which is used
-	to interact with the confinement as well as receive updates about its
-	state. See the the description of wp_confined_pointer for further
-	information.
-      </description>
-      <arg name="id" type="new_id" interface="zwp_confined_pointer_v1"/>
-      <arg name="surface" type="object" interface="wl_surface"
-	   summary="surface to lock pointer to"/>
-      <arg name="pointer" type="object" interface="wl_pointer"
-	   summary="the pointer that should be confined"/>
-      <arg name="region" type="object" interface="wl_region" allow-null="true"
-	   summary="region of surface"/>
-      <arg name="lifetime" type="uint" enum="lifetime" summary="confinement lifetime"/>
-    </request>
-  </interface>
-
-  <interface name="zwp_locked_pointer_v1" version="1">
-    <description summary="receive relative pointer motion events">
-      The wp_locked_pointer interface represents a locked pointer state.
-
-      While the lock of this object is active, the wl_pointer objects of the
-      associated seat will not emit any wl_pointer.motion events.
-
-      This object will send the event 'locked' when the lock is activated.
-      Whenever the lock is activated, it is guaranteed that the locked surface
-      will already have received pointer focus and that the pointer will be
-      within the region passed to the request creating this object.
-
-      To unlock the pointer, send the destroy request. This will also destroy
-      the wp_locked_pointer object.
-
-      If the compositor decides to unlock the pointer the unlocked event is
-      sent. See wp_locked_pointer.unlock for details.
-
-      When unlocking, the compositor may warp the cursor position to the set
-      cursor position hint. If it does, it will not result in any relative
-      motion events emitted via wp_relative_pointer.
-
-      If the surface the lock was requested on is destroyed and the lock is not
-      yet activated, the wp_locked_pointer object is now defunct and must be
-      destroyed.
-    </description>
-
-    <request name="destroy" type="destructor">
-      <description summary="destroy the locked pointer object">
-	Destroy the locked pointer object. If applicable, the compositor will
-	unlock the pointer.
-      </description>
-    </request>
-
-    <request name="set_cursor_position_hint">
-      <description summary="set the pointer cursor position hint">
-	Set the cursor position hint relative to the top left corner of the
-	surface.
-
-	If the client is drawing its own cursor, it should update the position
-	hint to the position of its own cursor. A compositor may use this
-	information to warp the pointer upon unlock in order to avoid pointer
-	jumps.
-
-	The cursor position hint is double buffered. The new hint will only take
-	effect when the associated surface gets it pending state applied. See
-	wl_surface.commit for details.
-      </description>
-      <arg name="surface_x" type="fixed"
-	   summary="surface-local x coordinate"/>
-      <arg name="surface_y" type="fixed"
-	   summary="surface-local y coordinate"/>
-    </request>
-
-    <request name="set_region">
-      <description summary="set a new lock region">
-	Set a new region used to lock the pointer.
-
-	The new lock region is double-buffered. The new lock region will
-	only take effect when the associated surface gets its pending state
-	applied. See wl_surface.commit for details.
-
-	For details about the lock region, see wp_locked_pointer.
-      </description>
-      <arg name="region" type="object" interface="wl_region" allow-null="true"
-	   summary="region of surface"/>
-    </request>
-
-    <event name="locked">
-      <description summary="lock activation event">
-	Notification that the pointer lock of the seat's pointer is activated.
-      </description>
-    </event>
-
-    <event name="unlocked">
-      <description summary="lock deactivation event">
-	Notification that the pointer lock of the seat's pointer is no longer
-	active. If this is a oneshot pointer lock (see
-	wp_pointer_constraints.lifetime) this object is now defunct and should
-	be destroyed. If this is a persistent pointer lock (see
-	wp_pointer_constraints.lifetime) this pointer lock may again
-	reactivate in the future.
-      </description>
-    </event>
-  </interface>
-
-  <interface name="zwp_confined_pointer_v1" version="1">
-    <description summary="confined pointer object">
-      The wp_confined_pointer interface represents a confined pointer state.
-
-      This object will send the event 'confined' when the confinement is
-      activated. Whenever the confinement is activated, it is guaranteed that
-      the surface the pointer is confined to will already have received pointer
-      focus and that the pointer will be within the region passed to the request
-      creating this object. It is up to the compositor to decide whether this
-      requires some user interaction and if the pointer will warp to within the
-      passed region if outside.
-
-      To unconfine the pointer, send the destroy request. This will also destroy
-      the wp_confined_pointer object.
-
-      If the compositor decides to unconfine the pointer the unconfined event is
-      sent. The wp_confined_pointer object is at this point defunct and should
-      be destroyed.
-    </description>
-
-    <request name="destroy" type="destructor">
-      <description summary="destroy the confined pointer object">
-	Destroy the confined pointer object. If applicable, the compositor will
-	unconfine the pointer.
-      </description>
-    </request>
-
-    <request name="set_region">
-      <description summary="set a new confine region">
-	Set a new region used to confine the pointer.
-
-	The new confine region is double-buffered. The new confine region will
-	only take effect when the associated surface gets its pending state
-	applied. See wl_surface.commit for details.
-
-	If the confinement is active when the new confinement region is applied
-	and the pointer ends up outside of newly applied region, the pointer may
-	warped to a position within the new confinement region. If warped, a
-	wl_pointer.motion event will be emitted, but no
-	wp_relative_pointer.relative_motion event.
-
-	The compositor may also, instead of using the new region, unconfine the
-	pointer.
-
-	For details about the confine region, see wp_confined_pointer.
-      </description>
-      <arg name="region" type="object" interface="wl_region" allow-null="true"
-	   summary="region of surface"/>
-    </request>
-
-    <event name="confined">
-      <description summary="pointer confined">
-	Notification that the pointer confinement of the seat's pointer is
-	activated.
-      </description>
-    </event>
-
-    <event name="unconfined">
-      <description summary="pointer unconfined">
-	Notification that the pointer confinement of the seat's pointer is no
-	longer active. If this is a oneshot pointer confinement (see
-	wp_pointer_constraints.lifetime) this object is now defunct and should
-	be destroyed. If this is a persistent pointer confinement (see
-	wp_pointer_constraints.lifetime) this pointer confinement may again
-	reactivate in the future.
-      </description>
-    </event>
-  </interface>
-
-</protocol>

protocols/virtual-keyboard-unstable-v1.xml

@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="virtual_keyboard_unstable_v1">
+  <copyright>
+    Copyright © 2008-2011  Kristian Høgsberg
+    Copyright © 2010-2013  Intel Corporation
+    Copyright © 2012-2013  Collabora, Ltd.
+    Copyright © 2018       Purism SPC
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+  </copyright>
+
+  <interface name="zwp_virtual_keyboard_v1" version="1">
+    <description summary="virtual keyboard">
+      The virtual keyboard provides an application with requests which emulate
+      the behaviour of a physical keyboard.
+
+      This interface can be used by clients on its own to provide raw input
+      events, or it can accompany the input method protocol.
+    </description>
+
+    <request name="keymap">
+      <description summary="keyboard mapping">
+        Provide a file descriptor to the compositor which can be
+        memory-mapped to provide a keyboard mapping description.
+
+        Format carries a value from the keymap_format enumeration.
+      </description>
+      <arg name="format" type="uint" summary="keymap format"/>
+      <arg name="fd" type="fd" summary="keymap file descriptor"/>
+      <arg name="size" type="uint" summary="keymap size, in bytes"/>
+    </request>
+
+    <enum name="error">
+      <entry name="no_keymap" value="0" summary="No keymap was set"/>
+    </enum>
+
+    <request name="key">
+      <description summary="key event">
+        A key was pressed or released.
+        The time argument is a timestamp with millisecond granularity, with an
+        undefined base. All requests regarding a single object must share the
+        same clock.
+
+        Keymap must be set before issuing this request.
+
+        State carries a value from the key_state enumeration.
+      </description>
+      <arg name="time" type="uint" summary="timestamp with millisecond granularity"/>
+      <arg name="key" type="uint" summary="key that produced the event"/>
+      <arg name="state" type="uint" summary="physical state of the key"/>
+    </request>
+
+    <request name="modifiers">
+      <description summary="modifier and group state">
+        Notifies the compositor that the modifier and/or group state has
+        changed, and it should update state.
+
+        The client should use wl_keyboard.modifiers event to synchronize its
+        internal state with seat state.
+
+        Keymap must be set before issuing this request.
+      </description>
+      <arg name="mods_depressed" type="uint" summary="depressed modifiers"/>
+      <arg name="mods_latched" type="uint" summary="latched modifiers"/>
+      <arg name="mods_locked" type="uint" summary="locked modifiers"/>
+      <arg name="group" type="uint" summary="keyboard layout"/>
+    </request>
+
+    <request name="destroy" type="destructor" since="1">
+      <description summary="destroy the virtual keyboard keyboard object"/>
+    </request>
+  </interface>
+
+  <interface name="zwp_virtual_keyboard_manager_v1" version="1">
+    <description summary="virtual keyboard manager">
+      A virtual keyboard manager allows an application to provide keyboard
+      input events as if they came from a physical keyboard.
+    </description>
+
+    <enum name="error">
+      <entry name="unauthorized" value="0" summary="client not authorized to use the interface"/>
+    </enum>
+
+    <request name="create_virtual_keyboard">
+      <description summary="Create a new virtual keyboard">
+        Creates a new virtual keyboard associated to a seat.
+
+        If the compositor enables a keyboard to perform arbitrary actions, it
+        should present an error when an untrusted client requests a new
+        keyboard.
+      </description>
+      <arg name="seat" type="object" interface="wl_seat"/>
+      <arg name="id" type="new_id" interface="zwp_virtual_keyboard_v1"/>
+    </request>
+  </interface>
+</protocol>

protocols/wlr-gamma-control-unstable-v1.xml

@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="wlr_gamma_control_unstable_v1">
+  <copyright>
+    Copyright © 2015 Giulio camuffo
+    Copyright © 2018 Simon Ser
+
+    Permission to use, copy, modify, distribute, and sell this
+    software and its documentation for any purpose is hereby granted
+    without fee, provided that the above copyright notice appear in
+    all copies and that both that copyright notice and this permission
+    notice appear in supporting documentation, and that the name of
+    the copyright holders not be used in advertising or publicity
+    pertaining to distribution of the software without specific,
+    written prior permission.  The copyright holders make no
+    representations about the suitability of this software for any
+    purpose.  It is provided "as is" without express or implied
+    warranty.
+
+    THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+    SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+    FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+    ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+    THIS SOFTWARE.
+  </copyright>
+
+  <description summary="manage gamma tables of outputs">
+    This protocol allows a privileged client to set the gamma tables for
+    outputs.
+
+    Warning! The protocol described in this file is experimental and
+    backward incompatible changes may be made. Backward compatible changes
+    may be added together with the corresponding interface version bump.
+    Backward incompatible changes are done by bumping the version number in
+    the protocol and interface names and resetting the interface version.
+    Once the protocol is to be declared stable, the 'z' prefix and the
+    version number in the protocol and interface names are removed and the
+    interface version number is reset.
+  </description>
+
+  <interface name="zwlr_gamma_control_manager_v1" version="1">
+    <description summary="manager to create per-output gamma controls">
+      This interface is a manager that allows creating per-output gamma
+      controls.
+    </description>
+
+    <request name="get_gamma_control">
+      <description summary="get a gamma control for an output">
+        Create a gamma control that can be used to adjust gamma tables for the
+        provided output.
+      </description>
+      <arg name="id" type="new_id" interface="zwlr_gamma_control_v1"/>
+      <arg name="output" type="object" interface="wl_output"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the manager">
+        All objects created by the manager will still remain valid, until their
+        appropriate destroy request has been called.
+      </description>
+    </request>
+  </interface>
+
+  <interface name="zwlr_gamma_control_v1" version="1">
+    <description summary="adjust gamma tables for an output">
+      This interface allows a client to adjust gamma tables for a particular
+      output.
+
+      The client will receive the gamma size, and will then be able to set gamma
+      tables. At any time the compositor can send a failed event indicating that
+      this object is no longer valid.
+
+      There can only be at most one gamma control object per output, which
+      has exclusive access to this particular output. When the gamma control
+      object is destroyed, the gamma table is restored to its original value.
+    </description>
+
+    <event name="gamma_size">
+      <description summary="size of gamma ramps">
+        Advertise the size of each gamma ramp.
+
+        This event is sent immediately when the gamma control object is created.
+      </description>
+      <arg name="size" type="uint" summary="number of elements in a ramp"/>
+    </event>
+
+    <enum name="error">
+      <entry name="invalid_gamma" value="1" summary="invalid gamma tables"/>
+    </enum>
+
+    <request name="set_gamma">
+      <description summary="set the gamma table">
+        Set the gamma table. The file descriptor can be memory-mapped to provide
+        the raw gamma table, which contains successive gamma ramps for the red,
+        green and blue channels. Each gamma ramp is an array of 16-byte unsigned
+        integers which has the same length as the gamma size.
+
+        The file descriptor data must have the same length as three times the
+        gamma size.
+      </description>
+      <arg name="fd" type="fd" summary="gamma table file descriptor"/>
+    </request>
+
+    <event name="failed">
+      <description summary="object no longer valid">
+        This event indicates that the gamma control is no longer valid. This
+        can happen for a number of reasons, including:
+        - The output doesn't support gamma tables
+        - Setting the gamma tables failed
+        - Another client already has exclusive gamma control for this output
+        - The compositor has transferred gamma control to another client
+
+        Upon receiving this event, the client should destroy this object.
+      </description>
+    </event>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy this control">
+        Destroys the gamma control object. If the object is still valid, this
+        restores the original gamma tables.
+      </description>
+    </request>
+  </interface>
+</protocol>

protocols/wlr-output-management-unstable-v1.xml

@@ -0,0 +1,601 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="wlr_output_management_unstable_v1">
+  <copyright>
+    Copyright © 2019 Purism SPC
+
+    Permission to use, copy, modify, distribute, and sell this
+    software and its documentation for any purpose is hereby granted
+    without fee, provided that the above copyright notice appear in
+    all copies and that both that copyright notice and this permission
+    notice appear in supporting documentation, and that the name of
+    the copyright holders not be used in advertising or publicity
+    pertaining to distribution of the software without specific,
+    written prior permission.  The copyright holders make no
+    representations about the suitability of this software for any
+    purpose.  It is provided "as is" without express or implied
+    warranty.
+
+    THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+    SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+    FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+    ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+    THIS SOFTWARE.
+  </copyright>
+
+  <description summary="protocol to configure output devices">
+    This protocol exposes interfaces to obtain and modify output device
+    configuration.
+
+    Warning! The protocol described in this file is experimental and
+    backward incompatible changes may be made. Backward compatible changes
+    may be added together with the corresponding interface version bump.
+    Backward incompatible changes are done by bumping the version number in
+    the protocol and interface names and resetting the interface version.
+    Once the protocol is to be declared stable, the 'z' prefix and the
+    version number in the protocol and interface names are removed and the
+    interface version number is reset.
+  </description>
+
+  <interface name="zwlr_output_manager_v1" version="4">
+    <description summary="output device configuration manager">
+      This interface is a manager that allows reading and writing the current
+      output device configuration.
+
+      Output devices that display pixels (e.g. a physical monitor or a virtual
+      output in a window) are represented as heads. Heads cannot be created nor
+      destroyed by the client, but they can be enabled or disabled and their
+      properties can be changed. Each head may have one or more available modes.
+
+      Whenever a head appears (e.g. a monitor is plugged in), it will be
+      advertised via the head event. Immediately after the output manager is
+      bound, all current heads are advertised.
+
+      Whenever a head's properties change, the relevant wlr_output_head events
+      will be sent. Not all head properties will be sent: only properties that
+      have changed need to.
+
+      Whenever a head disappears (e.g. a monitor is unplugged), a
+      wlr_output_head.finished event will be sent.
+
+      After one or more heads appear, change or disappear, the done event will
+      be sent. It carries a serial which can be used in a create_configuration
+      request to update heads properties.
+
+      The information obtained from this protocol should only be used for output
+      configuration purposes. This protocol is not designed to be a generic
+      output property advertisement protocol for regular clients. Instead,
+      protocols such as xdg-output should be used.
+    </description>
+
+    <event name="head">
+      <description summary="introduce a new head">
+        This event introduces a new head. This happens whenever a new head
+        appears (e.g. a monitor is plugged in) or after the output manager is
+        bound.
+      </description>
+      <arg name="head" type="new_id" interface="zwlr_output_head_v1"/>
+    </event>
+
+    <event name="done">
+      <description summary="sent all information about current configuration">
+        This event is sent after all information has been sent after binding to
+        the output manager object and after any subsequent changes. This applies
+        to child head and mode objects as well. In other words, this event is
+        sent whenever a head or mode is created or destroyed and whenever one of
+        their properties has been changed. Not all state is re-sent each time
+        the current configuration changes: only the actual changes are sent.
+
+        This allows changes to the output configuration to be seen as atomic,
+        even if they happen via multiple events.
+
+        A serial is sent to be used in a future create_configuration request.
+      </description>
+      <arg name="serial" type="uint" summary="current configuration serial"/>
+    </event>
+
+    <request name="create_configuration">
+      <description summary="create a new output configuration object">
+        Create a new output configuration object. This allows to update head
+        properties.
+      </description>
+      <arg name="id" type="new_id" interface="zwlr_output_configuration_v1"/>
+      <arg name="serial" type="uint"/>
+    </request>
+
+    <request name="stop">
+      <description summary="stop sending events">
+        Indicates the client no longer wishes to receive events for output
+        configuration changes. However the compositor may emit further events,
+        until the finished event is emitted.
+
+        The client must not send any more requests after this one.
+      </description>
+    </request>
+
+    <event name="finished" type="destructor">
+      <description summary="the compositor has finished with the manager">
+        This event indicates that the compositor is done sending manager events.
+        The compositor will destroy the object immediately after sending this
+        event, so it will become invalid and the client should release any
+        resources associated with it.
+      </description>
+    </event>
+  </interface>
+
+  <interface name="zwlr_output_head_v1" version="4">
+    <description summary="output device">
+      A head is an output device. The difference between a wl_output object and
+      a head is that heads are advertised even if they are turned off. A head
+      object only advertises properties and cannot be used directly to change
+      them.
+
+      A head has some read-only properties: modes, name, description and
+      physical_size. These cannot be changed by clients.
+
+      Other properties can be updated via a wlr_output_configuration object.
+
+      Properties sent via this interface are applied atomically via the
+      wlr_output_manager.done event. No guarantees are made regarding the order
+      in which properties are sent.
+    </description>
+
+    <event name="name">
+      <description summary="head name">
+        This event describes the head name.
+
+        The naming convention is compositor defined, but limited to alphanumeric
+        characters and dashes (-). Each name is unique among all wlr_output_head
+        objects, but if a wlr_output_head object is destroyed the same name may
+        be reused later. The names will also remain consistent across sessions
+        with the same hardware and software configuration.
+
+        Examples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc. However, do
+        not assume that the name is a reflection of an underlying DRM
+        connector, X11 connection, etc.
+
+        If the compositor implements the xdg-output protocol and this head is
+        enabled, the xdg_output.name event must report the same name.
+
+        The name event is sent after a wlr_output_head object is created. This
+        event is only sent once per object, and the name does not change over
+        the lifetime of the wlr_output_head object.
+      </description>
+      <arg name="name" type="string"/>
+    </event>
+
+    <event name="description">
+      <description summary="head description">
+        This event describes a human-readable description of the head.
+
+        The description is a UTF-8 string with no convention defined for its
+        contents. Examples might include 'Foocorp 11" Display' or 'Virtual X11
+        output via :1'. However, do not assume that the name is a reflection of
+        the make, model, serial of the underlying DRM connector or the display
+        name of the underlying X11 connection, etc.
+
+        If the compositor implements xdg-output and this head is enabled,
+        the xdg_output.description must report the same description.
+
+        The description event is sent after a wlr_output_head object is created.
+        This event is only sent once per object, and the description does not
+        change over the lifetime of the wlr_output_head object.
+      </description>
+      <arg name="description" type="string"/>
+    </event>
+
+    <event name="physical_size">
+      <description summary="head physical size">
+        This event describes the physical size of the head. This event is only
+        sent if the head has a physical size (e.g. is not a projector or a
+        virtual device).
+      </description>
+      <arg name="width" type="int" summary="width in millimeters of the output"/>
+      <arg name="height" type="int" summary="height in millimeters of the output"/>
+    </event>
+
+    <event name="mode">
+      <description summary="introduce a mode">
+        This event introduces a mode for this head. It is sent once per
+        supported mode.
+      </description>
+      <arg name="mode" type="new_id" interface="zwlr_output_mode_v1"/>
+    </event>
+
+    <event name="enabled">
+      <description summary="head is enabled or disabled">
+        This event describes whether the head is enabled. A disabled head is not
+        mapped to a region of the global compositor space.
+
+        When a head is disabled, some properties (current_mode, position,
+        transform and scale) are irrelevant.
+      </description>
+      <arg name="enabled" type="int" summary="zero if disabled, non-zero if enabled"/>
+    </event>
+
+    <event name="current_mode">
+      <description summary="current mode">
+        This event describes the mode currently in use for this head. It is only
+        sent if the output is enabled.
+      </description>
+      <arg name="mode" type="object" interface="zwlr_output_mode_v1"/>
+    </event>
+
+    <event name="position">
+      <description summary="current position">
+        This events describes the position of the head in the global compositor
+        space. It is only sent if the output is enabled.
+      </description>
+      <arg name="x" type="int"
+        summary="x position within the global compositor space"/>
+      <arg name="y" type="int"
+        summary="y position within the global compositor space"/>
+    </event>
+
+    <event name="transform">
+      <description summary="current transformation">
+        This event describes the transformation currently applied to the head.
+        It is only sent if the output is enabled.
+      </description>
+      <arg name="transform" type="int" enum="wl_output.transform"/>
+    </event>
+
+    <event name="scale">
+      <description summary="current scale">
+        This events describes the scale of the head in the global compositor
+        space. It is only sent if the output is enabled.
+      </description>
+      <arg name="scale" type="fixed"/>
+    </event>
+
+    <event name="finished">
+      <description summary="the head has disappeared">
+        This event indicates that the head is no longer available. The head
+        object becomes inert. Clients should send a destroy request and release
+        any resources associated with it.
+      </description>
+    </event>
+
+    <!-- Version 2 additions -->
+
+    <event name="make" since="2">
+      <description summary="head manufacturer">
+        This event describes the manufacturer of the head.
+
+        This must report the same make as the wl_output interface does in its
+        geometry event.
+
+        Together with the model and serial_number events the purpose is to
+        allow clients to recognize heads from previous sessions and for example
+        load head-specific configurations back.
+
+        It is not guaranteed this event will be ever sent. A reason for that
+        can be that the compositor does not have information about the make of
+        the head or the definition of a make is not sensible in the current
+        setup, for example in a virtual session. Clients can still try to
+        identify the head by available information from other events but should
+        be aware that there is an increased risk of false positives.
+
+        It is not recommended to display the make string in UI to users. For
+        that the string provided by the description event should be preferred.
+      </description>
+      <arg name="make" type="string"/>
+    </event>
+
+    <event name="model" since="2">
+      <description summary="head model">
+        This event describes the model of the head.
+
+        This must report the same model as the wl_output interface does in its
+        geometry event.
+
+        Together with the make and serial_number events the purpose is to
+        allow clients to recognize heads from previous sessions and for example
+        load head-specific configurations back.
+
+        It is not guaranteed this event will be ever sent. A reason for that
+        can be that the compositor does not have information about the model of
+        the head or the definition of a model is not sensible in the current
+        setup, for example in a virtual session. Clients can still try to
+        identify the head by available information from other events but should
+        be aware that there is an increased risk of false positives.
+
+        It is not recommended to display the model string in UI to users. For
+        that the string provided by the description event should be preferred.
+      </description>
+      <arg name="model" type="string"/>
+    </event>
+
+    <event name="serial_number" since="2">
+      <description summary="head serial number">
+        This event describes the serial number of the head.
+
+        Together with the make and model events the purpose is to allow clients
+        to recognize heads from previous sessions and for example load head-
+        specific configurations back.
+
+        It is not guaranteed this event will be ever sent. A reason for that
+        can be that the compositor does not have information about the serial
+        number of the head or the definition of a serial number is not sensible
+        in the current setup. Clients can still try to identify the head by
+        available information from other events but should be aware that there
+        is an increased risk of false positives.
+
+        It is not recommended to display the serial_number string in UI to
+        users. For that the string provided by the description event should be
+        preferred.
+      </description>
+      <arg name="serial_number" type="string"/>
+    </event>
+
+    <!-- Version 3 additions -->
+
+    <request name="release" type="destructor" since="3">
+      <description summary="destroy the head object">
+        This request indicates that the client will no longer use this head
+        object.
+      </description>
+    </request>
+
+    <!-- Version 4 additions -->
+
+    <enum name="adaptive_sync_state" since="4">
+      <entry name="disabled" value="0" summary="adaptive sync is disabled"/>
+      <entry name="enabled" value="1" summary="adaptive sync is enabled"/>
+    </enum>
+
+    <event name="adaptive_sync" since="4">
+      <description summary="current adaptive sync state">
+        This event describes whether adaptive sync is currently enabled for
+        the head or not. Adaptive sync is also known as Variable Refresh
+        Rate or VRR.
+      </description>
+      <arg name="state" type="uint" enum="adaptive_sync_state"/>
+    </event>
+  </interface>
+
+  <interface name="zwlr_output_mode_v1" version="3">
+    <description summary="output mode">
+      This object describes an output mode.
+
+      Some heads don't support output modes, in which case modes won't be
+      advertised.
+
+      Properties sent via this interface are applied atomically via the
+      wlr_output_manager.done event. No guarantees are made regarding the order
+      in which properties are sent.
+    </description>
+
+    <event name="size">
+      <description summary="mode size">
+        This event describes the mode size. The size is given in physical
+        hardware units of the output device. This is not necessarily the same as
+        the output size in the global compositor space. For instance, the output
+        may be scaled or transformed.
+      </description>
+      <arg name="width" type="int" summary="width of the mode in hardware units"/>
+      <arg name="height" type="int" summary="height of the mode in hardware units"/>
+    </event>
+
+    <event name="refresh">
+      <description summary="mode refresh rate">
+        This event describes the mode's fixed vertical refresh rate. It is only
+        sent if the mode has a fixed refresh rate.
+      </description>
+      <arg name="refresh" type="int" summary="vertical refresh rate in mHz"/>
+    </event>
+
+    <event name="preferred">
+      <description summary="mode is preferred">
+        This event advertises this mode as preferred.
+      </description>
+    </event>
+
+    <event name="finished">
+      <description summary="the mode has disappeared">
+        This event indicates that the mode is no longer available. The mode
+        object becomes inert. Clients should send a destroy request and release
+        any resources associated with it.
+      </description>
+    </event>
+
+    <!-- Version 3 additions -->
+
+    <request name="release" type="destructor" since="3">
+      <description summary="destroy the mode object">
+        This request indicates that the client will no longer use this mode
+        object.
+      </description>
+    </request>
+  </interface>
+
+  <interface name="zwlr_output_configuration_v1" version="4">
+    <description summary="output configuration">
+      This object is used by the client to describe a full output configuration.
+
+      First, the client needs to setup the output configuration. Each head can
+      be either enabled (and configured) or disabled. It is a protocol error to
+      send two enable_head or disable_head requests with the same head. It is a
+      protocol error to omit a head in a configuration.
+
+      Then, the client can apply or test the configuration. The compositor will
+      then reply with a succeeded, failed or cancelled event. Finally the client
+      should destroy the configuration object.
+    </description>
+
+    <enum name="error">
+      <entry name="already_configured_head" value="1"
+        summary="head has been configured twice"/>
+      <entry name="unconfigured_head" value="2"
+        summary="head has not been configured"/>
+      <entry name="already_used" value="3"
+        summary="request sent after configuration has been applied or tested"/>
+    </enum>
+
+    <request name="enable_head">
+      <description summary="enable and configure a head">
+        Enable a head. This request creates a head configuration object that can
+        be used to change the head's properties.
+      </description>
+      <arg name="id" type="new_id" interface="zwlr_output_configuration_head_v1"
+        summary="a new object to configure the head"/>
+      <arg name="head" type="object" interface="zwlr_output_head_v1"
+        summary="the head to be enabled"/>
+    </request>
+
+    <request name="disable_head">
+      <description summary="disable a head">
+        Disable a head.
+      </description>
+      <arg name="head" type="object" interface="zwlr_output_head_v1"
+        summary="the head to be disabled"/>
+    </request>
+
+    <request name="apply">
+      <description summary="apply the configuration">
+        Apply the new output configuration.
+
+        In case the configuration is successfully applied, there is no guarantee
+        that the new output state matches completely the requested
+        configuration. For instance, a compositor might round the scale if it
+        doesn't support fractional scaling.
+
+        After this request has been sent, the compositor must respond with an
+        succeeded, failed or cancelled event. Sending a request that isn't the
+        destructor is a protocol error.
+      </description>
+    </request>
+
+    <request name="test">
+      <description summary="test the configuration">
+        Test the new output configuration. The configuration won't be applied,
+        but will only be validated.
+
+        Even if the compositor succeeds to test a configuration, applying it may
+        fail.
+
+        After this request has been sent, the compositor must respond with an
+        succeeded, failed or cancelled event. Sending a request that isn't the
+        destructor is a protocol error.
+      </description>
+    </request>
+
+    <event name="succeeded">
+      <description summary="configuration changes succeeded">
+        Sent after the compositor has successfully applied the changes or
+        tested them.
+
+        Upon receiving this event, the client should destroy this object.
+
+        If the current configuration has changed, events to describe the changes
+        will be sent followed by a wlr_output_manager.done event.
+      </description>
+    </event>
+
+    <event name="failed">
+      <description summary="configuration changes failed">
+        Sent if the compositor rejects the changes or failed to apply them. The
+        compositor should revert any changes made by the apply request that
+        triggered this event.
+
+        Upon receiving this event, the client should destroy this object.
+      </description>
+    </event>
+
+    <event name="cancelled">
+      <description summary="configuration has been cancelled">
+        Sent if the compositor cancels the configuration because the state of an
+        output changed and the client has outdated information (e.g. after an
+        output has been hotplugged).
+
+        The client can create a new configuration with a newer serial and try
+        again.
+
+        Upon receiving this event, the client should destroy this object.
+      </description>
+    </event>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the output configuration">
+        Using this request a client can tell the compositor that it is not going
+        to use the configuration object anymore. Any changes to the outputs
+        that have not been applied will be discarded.
+
+        This request also destroys wlr_output_configuration_head objects created
+        via this object.
+      </description>
+    </request>
+  </interface>
+
+  <interface name="zwlr_output_configuration_head_v1" version="4">
+    <description summary="head configuration">
+      This object is used by the client to update a single head's configuration.
+
+      It is a protocol error to set the same property twice.
+    </description>
+
+    <enum name="error">
+      <entry name="already_set" value="1" summary="property has already been set"/>
+      <entry name="invalid_mode" value="2" summary="mode doesn't belong to head"/>
+      <entry name="invalid_custom_mode" value="3" summary="mode is invalid"/>
+      <entry name="invalid_transform" value="4" summary="transform value outside enum"/>
+      <entry name="invalid_scale" value="5" summary="scale negative or zero"/>
+      <entry name="invalid_adaptive_sync_state" value="6" since="4"
+        summary="invalid enum value used in the set_adaptive_sync request"/>
+    </enum>
+
+    <request name="set_mode">
+      <description summary="set the mode">
+        This request sets the head's mode.
+      </description>
+      <arg name="mode" type="object" interface="zwlr_output_mode_v1"/>
+    </request>
+
+    <request name="set_custom_mode">
+      <description summary="set a custom mode">
+        This request assigns a custom mode to the head. The size is given in
+        physical hardware units of the output device. If set to zero, the
+        refresh rate is unspecified.
+
+        It is a protocol error to set both a mode and a custom mode.
+      </description>
+      <arg name="width" type="int" summary="width of the mode in hardware units"/>
+      <arg name="height" type="int" summary="height of the mode in hardware units"/>
+      <arg name="refresh" type="int" summary="vertical refresh rate in mHz or zero"/>
+    </request>
+
+    <request name="set_position">
+      <description summary="set the position">
+        This request sets the head's position in the global compositor space.
+      </description>
+      <arg name="x" type="int" summary="x position in the global compositor space"/>
+      <arg name="y" type="int" summary="y position in the global compositor space"/>
+    </request>
+
+    <request name="set_transform">
+      <description summary="set the transform">
+        This request sets the head's transform.
+      </description>
+      <arg name="transform" type="int" enum="wl_output.transform"/>
+    </request>
+
+    <request name="set_scale">
+      <description summary="set the scale">
+        This request sets the head's scale.
+      </description>
+      <arg name="scale" type="fixed"/>
+    </request>
+
+    <!-- Version 4 additions -->
+
+    <request name="set_adaptive_sync" since="4">
+      <description summary="enable/disable adaptive sync">
+        This request enables/disables adaptive sync. Adaptive sync is also
+        known as Variable Refresh Rate or VRR.
+      </description>
+      <arg name="state" type="uint" enum="zwlr_output_head_v1.adaptive_sync_state"/>
+    </request>
+  </interface>
+</protocol>

protocols/wlr-virtual-pointer-unstable-v1.xml

@@ -0,0 +1,152 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="wlr_virtual_pointer_unstable_v1">
+  <copyright>
+    Copyright © 2019 Josef Gajdusek
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+  </copyright>
+
+  <interface name="zwlr_virtual_pointer_v1" version="2">
+    <description summary="virtual pointer">
+      This protocol allows clients to emulate a physical pointer device. The
+      requests are mostly mirror opposites of those specified in wl_pointer.
+    </description>
+
+    <enum name="error">
+      <entry name="invalid_axis" value="0"
+        summary="client sent invalid axis enumeration value" />
+      <entry name="invalid_axis_source" value="1"
+        summary="client sent invalid axis source enumeration value" />
+    </enum>
+
+    <request name="motion">
+      <description summary="pointer relative motion event">
+        The pointer has moved by a relative amount to the previous request.
+
+        Values are in the global compositor space.
+      </description>
+      <arg name="time" type="uint" summary="timestamp with millisecond granularity"/>
+      <arg name="dx" type="fixed" summary="displacement on the x-axis"/>
+      <arg name="dy" type="fixed" summary="displacement on the y-axis"/>
+    </request>
+
+    <request name="motion_absolute">
+      <description summary="pointer absolute motion event">
+        The pointer has moved in an absolute coordinate frame.
+
+        Value of x can range from 0 to x_extent, value of y can range from 0
+        to y_extent.
+      </description>
+      <arg name="time" type="uint" summary="timestamp with millisecond granularity"/>
+      <arg name="x" type="uint" summary="position on the x-axis"/>
+      <arg name="y" type="uint" summary="position on the y-axis"/>
+      <arg name="x_extent" type="uint" summary="extent of the x-axis"/>
+      <arg name="y_extent" type="uint" summary="extent of the y-axis"/>
+    </request>
+
+    <request name="button">
+      <description summary="button event">
+        A button was pressed or released.
+      </description>
+      <arg name="time" type="uint" summary="timestamp with millisecond granularity"/>
+      <arg name="button" type="uint" summary="button that produced the event"/>
+      <arg name="state" type="uint" enum="wl_pointer.button_state" summary="physical state of the button"/>
+    </request>
+
+    <request name="axis">
+      <description summary="axis event">
+        Scroll and other axis requests.
+      </description>
+      <arg name="time" type="uint" summary="timestamp with millisecond granularity"/>
+      <arg name="axis" type="uint" enum="wl_pointer.axis" summary="axis type"/>
+      <arg name="value" type="fixed" summary="length of vector in touchpad coordinates"/>
+    </request>
+
+    <request name="frame">
+      <description summary="end of a pointer event sequence">
+        Indicates the set of events that logically belong together.
+      </description>
+    </request>
+
+    <request name="axis_source">
+      <description summary="axis source event">
+        Source information for scroll and other axis.
+      </description>
+      <arg name="axis_source" type="uint" enum="wl_pointer.axis_source" summary="source of the axis event"/>
+    </request>
+
+    <request name="axis_stop">
+      <description summary="axis stop event">
+        Stop notification for scroll and other axes.
+      </description>
+      <arg name="time" type="uint" summary="timestamp with millisecond granularity"/>
+      <arg name="axis" type="uint" enum="wl_pointer.axis" summary="the axis stopped with this event"/>
+    </request>
+
+    <request name="axis_discrete">
+      <description summary="axis click event">
+        Discrete step information for scroll and other axes.
+
+        This event allows the client to extend data normally sent using the axis
+        event with discrete value.
+      </description>
+      <arg name="time" type="uint" summary="timestamp with millisecond granularity"/>
+      <arg name="axis" type="uint" enum="wl_pointer.axis" summary="axis type"/>
+      <arg name="value" type="fixed" summary="length of vector in touchpad coordinates"/>
+      <arg name="discrete" type="int" summary="number of steps"/>
+    </request>
+
+    <request name="destroy" type="destructor" since="1">
+      <description summary="destroy the virtual pointer object"/>
+    </request>
+  </interface>
+
+  <interface name="zwlr_virtual_pointer_manager_v1" version="2">
+    <description summary="virtual pointer manager">
+      This object allows clients to create individual virtual pointer objects.
+    </description>
+
+    <request name="create_virtual_pointer">
+      <description summary="Create a new virtual pointer">
+        Creates a new virtual pointer. The optional seat is a suggestion to the
+        compositor.
+      </description>
+      <arg name="seat" type="object" interface="wl_seat" allow-null="true"/>
+      <arg name="id" type="new_id" interface="zwlr_virtual_pointer_v1"/>
+    </request>
+
+    <request name="destroy" type="destructor" since="1">
+      <description summary="destroy the virtual pointer manager"/>
+    </request>
+
+    <!-- Version 2 additions -->
+    <request name="create_virtual_pointer_with_output" since="2">
+      <description summary="Create a new virtual pointer">
+        Creates a new virtual pointer. The seat and the output arguments are
+        optional. If the seat argument is set, the compositor should assign the
+        input device to the requested seat. If the output argument is set, the
+        compositor should map the input device to the requested output.
+      </description>
+      <arg name="seat" type="object" interface="wl_seat" allow-null="true"/>
+      <arg name="output" type="object" interface="wl_output" allow-null="true"/>
+      <arg name="id" type="new_id" interface="zwlr_virtual_pointer_v1"/>
+    </request>
+  </interface>
+</protocol>

scripts/hyprlandStaticAsan.diff

@@ -1,20 +1,13 @@
 diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 1190876d..0e7573f9 100755
+index f54cdf5d..ad7c3e73 100755
 --- a/CMakeLists.txt
 +++ b/CMakeLists.txt
-@@ -110,6 +110,7 @@ pkg_check_modules(deps REQUIRED IMPORTED_TARGET
-     cairo pango pangocairo pixman-1
-     libdrm libinput hwdata libseat libdisplay-info libliftoff libudev gbm
-     hyprlang>=0.3.2 hyprcursor
-+    libffi
- )
- 
- file(GLOB_RECURSE SRCFILES CONFIGURE_DEPENDS "src/*.cpp")
-@@ -130,6 +131,7 @@ if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
+@@ -130,6 +130,8 @@ if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
          message(STATUS "Enabling ASan")
  
          target_link_libraries(Hyprland asan)
-+        target_link_libraries(Hyprland ${CMAKE_SOURCE_DIR}/libwayland-server.a)
++        pkg_check_modules(ffidep REQUIRED IMPORTED_TARGET libffi)
++        target_link_libraries(Hyprland ${CMAKE_SOURCE_DIR}/libwayland-server.a PkgConfig::ffidep)
          target_compile_options(Hyprland PUBLIC -fsanitize=address)
      endif()
  

src/Compositor.hpp

@@ -40,61 +40,44 @@ class CCompositor {
     ~CCompositor();
 
     // ------------------ WLR BASICS ------------------ //
-    wl_display*                                m_sWLDisplay;
-    wl_event_loop*                             m_sWLEventLoop;
-    wlr_backend*                               m_sWLRBackend;
-    wlr_session*                               m_sWLRSession;
-    wlr_renderer*                              m_sWLRRenderer;
-    wlr_allocator*                             m_sWLRAllocator;
-    wlr_compositor*                            m_sWLRCompositor;
-    wlr_subcompositor*                         m_sWLRSubCompositor;
-    wlr_data_device_manager*                   m_sWLRDataDevMgr;
-    wlr_drm*                                   m_sWRLDRM;
-    wlr_drm_lease_v1_manager*                  m_sWRLDRMLeaseMgr;
-    wlr_xdg_activation_v1*                     m_sWLRXDGActivation;
-    wlr_output_layout*                         m_sWLROutputLayout;
-    wlr_idle_notifier_v1*                      m_sWLRIdleNotifier;
-    wlr_layer_shell_v1*                        m_sWLRLayerShell;
-    wlr_xdg_shell*                             m_sWLRXDGShell;
-    wlr_cursor*                                m_sWLRCursor;
-    wlr_virtual_keyboard_manager_v1*           m_sWLRVKeyboardMgr;
-    wlr_output_manager_v1*                     m_sWLROutputMgr;
-    wlr_presentation*                          m_sWLRPresentation;
-    wlr_keyboard_shortcuts_inhibit_manager_v1* m_sWLRKbShInhibitMgr;
-    wlr_egl*                                   m_sWLREGL;
-    int                                        m_iDRMFD;
-    wlr_pointer_constraints_v1*                m_sWLRPointerConstraints;
-    wlr_relative_pointer_manager_v1*           m_sWLRRelPointerMgr;
-    wlr_server_decoration_manager*             m_sWLRServerDecoMgr;
-    wlr_xdg_decoration_manager_v1*             m_sWLRXDGDecoMgr;
-    wlr_virtual_pointer_manager_v1*            m_sWLRVirtPtrMgr;
-    wlr_foreign_toplevel_manager_v1*           m_sWLRToplevelMgr;
-    wlr_tablet_manager_v2*                     m_sWLRTabletManager;
-    wlr_xdg_foreign_registry*                  m_sWLRForeignRegistry;
-    wlr_idle_inhibit_manager_v1*               m_sWLRIdleInhibitMgr;
-    wlr_pointer_gestures_v1*                   m_sWLRPointerGestures;
-    wlr_output_power_manager_v1*               m_sWLROutputPowerMgr;
-    wlr_input_method_manager_v2*               m_sWLRIMEMgr;
-    wlr_text_input_manager_v3*                 m_sWLRTextInputMgr;
-    wlr_xdg_activation_v1*                     m_sWLRActivation;
-    wlr_linux_dmabuf_v1*                       m_sWLRLinuxDMABuf;
-    wlr_backend*                               m_sWLRHeadlessBackend;
-    wlr_session_lock_manager_v1*               m_sWLRSessionLockMgr;
-    wlr_gamma_control_manager_v1*              m_sWLRGammaCtrlMgr;
-    wlr_cursor_shape_manager_v1*               m_sWLRCursorShapeMgr;
-    wlr_tearing_control_manager_v1*            m_sWLRTearingControlMgr;
+    wl_display*                    m_sWLDisplay;
+    wl_event_loop*                 m_sWLEventLoop;
+    wlr_backend*                   m_sWLRBackend;
+    wlr_session*                   m_sWLRSession;
+    wlr_renderer*                  m_sWLRRenderer;
+    wlr_allocator*                 m_sWLRAllocator;
+    wlr_compositor*                m_sWLRCompositor;
+    wlr_subcompositor*             m_sWLRSubCompositor;
+    wlr_data_device_manager*       m_sWLRDataDevMgr;
+    wlr_drm*                       m_sWRLDRM;
+    wlr_drm_lease_v1_manager*      m_sWRLDRMLeaseMgr;
+    wlr_output_layout*             m_sWLROutputLayout;
+    wlr_layer_shell_v1*            m_sWLRLayerShell;
+    wlr_xdg_shell*                 m_sWLRXDGShell;
+    wlr_cursor*                    m_sWLRCursor;
+    wlr_presentation*              m_sWLRPresentation;
+    wlr_egl*                       m_sWLREGL;
+    int                            m_iDRMFD;
+    wlr_server_decoration_manager* m_sWLRServerDecoMgr;
+    wlr_tablet_manager_v2*         m_sWLRTabletManager;
+    wlr_xdg_foreign_registry*      m_sWLRForeignRegistry;
+    wlr_linux_dmabuf_v1*           m_sWLRLinuxDMABuf;
+    wlr_backend*                   m_sWLRHeadlessBackend;
     // ------------------------------------------------- //
 
+    std::string                               m_szHyprTempDataRoot = "";
+
     std::string                               m_szWLDisplaySocket   = "";
     std::string                               m_szInstanceSignature = "";
+    std::string                               m_szInstancePath      = "";
     std::string                               m_szCurrentSplash     = "error";
 
-    std::vector<std::shared_ptr<CMonitor>>    m_vMonitors;
-    std::vector<std::shared_ptr<CMonitor>>    m_vRealMonitors; // for all monitors, even those turned off
-    std::vector<std::unique_ptr<CWindow>>     m_vWindows;
+    std::vector<SP<CMonitor>>                 m_vMonitors;
+    std::vector<SP<CMonitor>>                 m_vRealMonitors; // for all monitors, even those turned off
+    std::vector<PHLWINDOW>                    m_vWindows;
     std::vector<PHLWORKSPACE>                 m_vWorkspaces;
-    std::vector<CWindow*>                     m_vWindowsFadingOut;
-    std::vector<SLayerSurface*>               m_vSurfacesFadingOut;
+    std::vector<PHLWINDOWREF>                 m_vWindowsFadingOut;
+    std::vector<PHLLSREF>                     m_vSurfacesFadingOut;
 
     std::unordered_map<std::string, uint64_t> m_mMonitorIDMap;
 
@@ -104,11 +87,11 @@ class CCompositor {
     void                                      createLockFile();
     void                                      removeLockFile();
 
-    wlr_surface*                              m_pLastFocus   = nullptr;
-    CWindow*                                  m_pLastWindow  = nullptr;
+    wlr_surface*                              m_pLastFocus = nullptr;
+    PHLWINDOWREF                              m_pLastWindow;
     CMonitor*                                 m_pLastMonitor = nullptr;
 
-    std::vector<CWindow*>                     m_vWindowFocusHistory; // first element is the most recently focused.
+    std::vector<PHLWINDOWREF>                 m_vWindowFocusHistory; // first element is the most recently focused.
 
     SSeat                                     m_sSeat;
 
@@ -123,92 +106,88 @@ class CCompositor {
 
     // ------------------------------------------------- //
 
-    CMonitor*      getMonitorFromID(const int&);
-    CMonitor*      getMonitorFromName(const std::string&);
-    CMonitor*      getMonitorFromDesc(const std::string&);
-    CMonitor*      getMonitorFromCursor();
-    CMonitor*      getMonitorFromVector(const Vector2D&);
-    void           removeWindowFromVectorSafe(CWindow*);
-    void           focusWindow(CWindow*, wlr_surface* pSurface = nullptr);
-    void           focusSurface(wlr_surface*, CWindow* pWindowOwner = nullptr);
-    bool           windowExists(CWindow*);
-    bool           windowValidMapped(CWindow*);
-    bool           monitorExists(CMonitor*);
-    CWindow*       vectorToWindowUnified(const Vector2D&, uint8_t properties, CWindow* pIgnoreWindow = nullptr);
-    wlr_surface*   vectorToLayerSurface(const Vector2D&, std::vector<std::unique_ptr<SLayerSurface>>*, Vector2D*, SLayerSurface**);
-    wlr_surface*   vectorToLayerPopupSurface(const Vector2D&, CMonitor* monitor, Vector2D*, SLayerSurface**);
-    wlr_surface*   vectorWindowToSurface(const Vector2D&, CWindow*, Vector2D& sl);
-    Vector2D       vectorToSurfaceLocal(const Vector2D&, CWindow*, wlr_surface*);
-    CMonitor*      getMonitorFromOutput(wlr_output*);
-    CMonitor*      getRealMonitorFromOutput(wlr_output*);
-    CWindow*       getWindowFromSurface(wlr_surface*);
-    CWindow*       getWindowFromHandle(uint32_t);
-    CWindow*       getWindowFromZWLRHandle(wl_resource*);
-    bool           isWorkspaceVisible(PHLWORKSPACE);
-    PHLWORKSPACE   getWorkspaceByID(const int&);
-    PHLWORKSPACE   getWorkspaceByName(const std::string&);
-    PHLWORKSPACE   getWorkspaceByString(const std::string&);
-    void           sanityCheckWorkspaces();
-    void           updateWorkspaceWindowDecos(const int&);
-    void           updateWorkspaceSpecialRenderData(const int&);
-    int            getWindowsOnWorkspace(const int& id, std::optional<bool> onlyTiled = {});
-    int            getGroupsOnWorkspace(const int& id, std::optional<bool> onlyTiled = {});
-    CWindow*       getUrgentWindow();
-    bool           hasUrgentWindowOnWorkspace(const int&);
-    CWindow*       getFirstWindowOnWorkspace(const int&);
-    CWindow*       getTopLeftWindowOnWorkspace(const int&);
-    CWindow*       getFullscreenWindowOnWorkspace(const int&);
-    bool           doesSeatAcceptInput(wlr_surface*);
-    bool           isWindowActive(CWindow*);
-    void           changeWindowZOrder(CWindow*, bool);
-    void           cleanupFadingOut(const int& monid);
-    CWindow*       getWindowInDirection(CWindow*, char);
-    CWindow*       getNextWindowOnWorkspace(CWindow*, bool focusableOnly = false, std::optional<bool> floating = {});
-    CWindow*       getPrevWindowOnWorkspace(CWindow*, bool focusableOnly = false, std::optional<bool> floating = {});
-    int            getNextAvailableNamedWorkspace();
-    bool           isPointOnAnyMonitor(const Vector2D&);
-    bool           isPointOnReservedArea(const Vector2D& point, const CMonitor* monitor = nullptr);
-    CMonitor*      getMonitorInDirection(const char&);
-    CMonitor*      getMonitorInDirection(CMonitor*, const char&);
-    void           updateAllWindowsAnimatedDecorationValues();
-    void           updateWorkspaceWindows(const int64_t& id);
-    void           updateWindowAnimatedDecorationValues(CWindow*);
-    int            getNextAvailableMonitorID(std::string const& name);
-    void           moveWorkspaceToMonitor(PHLWORKSPACE, CMonitor*, bool noWarpCursor = false);
-    void           swapActiveWorkspaces(CMonitor*, CMonitor*);
-    CMonitor*      getMonitorFromString(const std::string&);
-    bool           workspaceIDOutOfBounds(const int64_t&);
-    void           setWindowFullscreen(CWindow*, bool, eFullscreenMode mode = FULLSCREEN_INVALID);
-    void           updateFullscreenFadeOnWorkspace(PHLWORKSPACE);
-    CWindow*       getX11Parent(CWindow*);
-    void           scheduleFrameForMonitor(CMonitor*);
-    void           addToFadingOutSafe(SLayerSurface*);
-    void           addToFadingOutSafe(CWindow*);
-    CWindow*       getWindowByRegex(const std::string&);
-    void           warpCursorTo(const Vector2D&, bool force = false);
-    SLayerSurface* getLayerSurfaceFromWlr(wlr_layer_surface_v1*);
-    SLayerSurface* getLayerSurfaceFromSurface(wlr_surface*);
-    void           closeWindow(CWindow*);
-    Vector2D       parseWindowVectorArgsRelative(const std::string&, const Vector2D&);
-    void           forceReportSizesToWindowsOnWorkspace(const int&);
-    PHLWORKSPACE   createNewWorkspace(const int&, const int&, const std::string& name = ""); // will be deleted next frame if left empty and unfocused!
-    void           renameWorkspace(const int&, const std::string& name = "");
-    void           setActiveMonitor(CMonitor*);
-    bool           isWorkspaceSpecial(const int&);
-    int            getNewSpecialID();
-    void           performUserChecks();
-    void           moveWindowToWorkspaceSafe(CWindow* pWindow, PHLWORKSPACE pWorkspace);
-    CWindow*       getForceFocus();
-    void           notifyIdleActivity();
-    void           setIdleActivityInhibit(bool inhibit);
-    void           arrangeMonitors();
-    void           enterUnsafeState();
-    void           leaveUnsafeState();
-    void           setPreferredScaleForSurface(wlr_surface* pSurface, double scale);
-    void           setPreferredTransformForSurface(wlr_surface* pSurface, wl_output_transform transform);
-    void           updateSuspendedStates();
+    CMonitor*    getMonitorFromID(const int&);
+    CMonitor*    getMonitorFromName(const std::string&);
+    CMonitor*    getMonitorFromDesc(const std::string&);
+    CMonitor*    getMonitorFromCursor();
+    CMonitor*    getMonitorFromVector(const Vector2D&);
+    void         removeWindowFromVectorSafe(PHLWINDOW);
+    void         focusWindow(PHLWINDOW, wlr_surface* pSurface = nullptr);
+    void         focusSurface(wlr_surface*, PHLWINDOW pWindowOwner = nullptr);
+    bool         monitorExists(CMonitor*);
+    PHLWINDOW    vectorToWindowUnified(const Vector2D&, uint8_t properties, PHLWINDOW pIgnoreWindow = nullptr);
+    wlr_surface* vectorToLayerSurface(const Vector2D&, std::vector<PHLLS>*, Vector2D*, PHLLS*);
+    wlr_surface* vectorToLayerPopupSurface(const Vector2D&, CMonitor* monitor, Vector2D*, PHLLS*);
+    wlr_surface* vectorWindowToSurface(const Vector2D&, PHLWINDOW, Vector2D& sl);
+    Vector2D     vectorToSurfaceLocal(const Vector2D&, PHLWINDOW, wlr_surface*);
+    CMonitor*    getMonitorFromOutput(wlr_output*);
+    CMonitor*    getRealMonitorFromOutput(wlr_output*);
+    PHLWINDOW    getWindowFromSurface(wlr_surface*);
+    PHLWINDOW    getWindowFromHandle(uint32_t);
+    bool         isWorkspaceVisible(PHLWORKSPACE);
+    PHLWORKSPACE getWorkspaceByID(const int&);
+    PHLWORKSPACE getWorkspaceByName(const std::string&);
+    PHLWORKSPACE getWorkspaceByString(const std::string&);
+    void         sanityCheckWorkspaces();
+    void         updateWorkspaceWindowDecos(const int&);
+    void         updateWorkspaceSpecialRenderData(const int&);
+    int          getWindowsOnWorkspace(const int& id, std::optional<bool> onlyTiled = {}, std::optional<bool> onlyVisible = {});
+    int          getGroupsOnWorkspace(const int& id, std::optional<bool> onlyTiled = {}, std::optional<bool> onlyVisible = {});
+    PHLWINDOW    getUrgentWindow();
+    bool         hasUrgentWindowOnWorkspace(const int&);
+    PHLWINDOW    getFirstWindowOnWorkspace(const int&);
+    PHLWINDOW    getTopLeftWindowOnWorkspace(const int&);
+    PHLWINDOW    getFullscreenWindowOnWorkspace(const int&);
+    bool         doesSeatAcceptInput(wlr_surface*);
+    bool         isWindowActive(PHLWINDOW);
+    void         changeWindowZOrder(PHLWINDOW, bool);
+    void         cleanupFadingOut(const int& monid);
+    PHLWINDOW    getWindowInDirection(PHLWINDOW, char);
+    PHLWINDOW    getNextWindowOnWorkspace(PHLWINDOW, bool focusableOnly = false, std::optional<bool> floating = {});
+    PHLWINDOW    getPrevWindowOnWorkspace(PHLWINDOW, bool focusableOnly = false, std::optional<bool> floating = {});
+    int          getNextAvailableNamedWorkspace();
+    bool         isPointOnAnyMonitor(const Vector2D&);
+    bool         isPointOnReservedArea(const Vector2D& point, const CMonitor* monitor = nullptr);
+    CMonitor*    getMonitorInDirection(const char&);
+    CMonitor*    getMonitorInDirection(CMonitor*, const char&);
+    void         updateAllWindowsAnimatedDecorationValues();
+    void         updateWorkspaceWindows(const int64_t& id);
+    void         updateWindowAnimatedDecorationValues(PHLWINDOW);
+    int          getNextAvailableMonitorID(std::string const& name);
+    void         moveWorkspaceToMonitor(PHLWORKSPACE, CMonitor*, bool noWarpCursor = false);
+    void         swapActiveWorkspaces(CMonitor*, CMonitor*);
+    CMonitor*    getMonitorFromString(const std::string&);
+    bool         workspaceIDOutOfBounds(const int64_t&);
+    void         setWindowFullscreen(PHLWINDOW, bool, eFullscreenMode mode = FULLSCREEN_INVALID);
+    void         updateFullscreenFadeOnWorkspace(PHLWORKSPACE);
+    PHLWINDOW    getX11Parent(PHLWINDOW);
+    void         scheduleFrameForMonitor(CMonitor*);
+    void         addToFadingOutSafe(PHLLS);
+    void         addToFadingOutSafe(PHLWINDOW);
+    PHLWINDOW    getWindowByRegex(const std::string&);
+    void         warpCursorTo(const Vector2D&, bool force = false);
+    PHLLS        getLayerSurfaceFromWlr(wlr_layer_surface_v1*);
+    PHLLS        getLayerSurfaceFromSurface(wlr_surface*);
+    void         closeWindow(PHLWINDOW);
+    Vector2D     parseWindowVectorArgsRelative(const std::string&, const Vector2D&);
+    void         forceReportSizesToWindowsOnWorkspace(const int&);
+    PHLWORKSPACE createNewWorkspace(const int&, const int&, const std::string& name = ""); // will be deleted next frame if left empty and unfocused!
+    void         renameWorkspace(const int&, const std::string& name = "");
+    void         setActiveMonitor(CMonitor*);
+    bool         isWorkspaceSpecial(const int&);
+    int          getNewSpecialID();
+    void         performUserChecks();
+    void         moveWindowToWorkspaceSafe(PHLWINDOW pWindow, PHLWORKSPACE pWorkspace);
+    PHLWINDOW    getForceFocus();
+    void         arrangeMonitors();
+    void         enterUnsafeState();
+    void         leaveUnsafeState();
+    void         setPreferredScaleForSurface(wlr_surface* pSurface, double scale);
+    void         setPreferredTransformForSurface(wlr_surface* pSurface, wl_output_transform transform);
+    void         updateSuspendedStates();
+    PHLWINDOW    windowForCPointer(CWindow*);
 
-    std::string    explicitConfigPath;
+    std::string  explicitConfigPath;
 
   private:
     void     initAllSignals();

src/config/ConfigManager.cpp

@@ -16,6 +16,7 @@
 #include <fstream>
 #include <iostream>
 #include <sstream>
+#include <ranges>
 
 extern "C" char**             environ;
 
@@ -318,6 +319,7 @@ CConfigManager::CConfigManager() {
     m_pConfig->addConfigValue("general:layout", {"dwindle"});
     m_pConfig->addConfigValue("general:allow_tearing", Hyprlang::INT{0});
     m_pConfig->addConfigValue("general:resize_corner", Hyprlang::INT{0});
+    m_pConfig->addConfigValue("general:default_cursor_monitor", {STRVAL_EMPTY});
 
     m_pConfig->addConfigValue("misc:disable_hyprland_logo", Hyprlang::INT{0});
     m_pConfig->addConfigValue("misc:disable_splash_rendering", Hyprlang::INT{0});
@@ -350,6 +352,7 @@ CConfigManager::CConfigManager() {
     m_pConfig->addConfigValue("misc:new_window_takes_over_fullscreen", Hyprlang::INT{0});
     m_pConfig->addConfigValue("misc:enable_hyprcursor", Hyprlang::INT{1});
     m_pConfig->addConfigValue("misc:hide_cursor_on_key_press", Hyprlang::INT{0});
+    m_pConfig->addConfigValue("misc:initial_workspace_tracking", Hyprlang::INT{1});
 
     m_pConfig->addConfigValue("group:insert_after_current", Hyprlang::INT{1});
     m_pConfig->addConfigValue("group:focus_removed_window", Hyprlang::INT{1});
@@ -376,6 +379,7 @@ CConfigManager::CConfigManager() {
     m_pConfig->addConfigValue("debug:error_limit", Hyprlang::INT{5});
     m_pConfig->addConfigValue("debug:watchdog_timeout", Hyprlang::INT{5});
     m_pConfig->addConfigValue("debug:disable_scale_checks", Hyprlang::INT{0});
+    m_pConfig->addConfigValue("debug:colored_stdout_logs", Hyprlang::INT{1});
 
     m_pConfig->addConfigValue("decoration:rounding", Hyprlang::INT{0});
     m_pConfig->addConfigValue("decoration:blur:enabled", Hyprlang::INT{1});
@@ -591,7 +595,7 @@ CConfigManager::CConfigManager() {
     setDefaultAnimationVars();
     resetHLConfig();
 
-    Debug::log(LOG,
+    Debug::log(INFO,
                "!!!!HEY YOU, YES YOU!!!!: further logs to stdout / logfile are disabled by default. BEFORE SENDING THIS LOG, ENABLE THEM. Use debug:disable_logs = false to do so: "
                "https://wiki.hyprland.org/Configuring/Variables/#debug");
 
@@ -817,6 +821,8 @@ void CConfigManager::postConfigReload(const Hyprlang::CParseResult& result) {
     if (Debug::disableStdout && isFirstLaunch)
         Debug::log(LOG, "Disabling stdout logs! Check the log for further logs.");
 
+    Debug::coloredLogs = reinterpret_cast<int64_t* const*>(m_pConfig->getConfigValuePtr("debug:colored_stdout_logs")->getDataStaticPtr());
+
     for (auto& m : g_pCompositor->m_vMonitors) {
         // mark blur dirty
         g_pHyprOpenGL->markBlurDirtyForMonitor(m.get());
@@ -825,6 +831,10 @@ void CConfigManager::postConfigReload(const Hyprlang::CParseResult& result) {
 
         // Force the compositor to fully re-render all monitors
         m->forceFullFrames = 2;
+
+        // also force mirrors, as the aspect ratio could've changed
+        for (auto& mirror : m->mirrors)
+            mirror->forceFullFrames = 3;
     }
 
     // Reset no monitor reload
@@ -945,7 +955,7 @@ std::string CConfigManager::getDeviceString(const std::string& dev, const std::s
 }
 
 SMonitorRule CConfigManager::getMonitorRuleFor(const CMonitor& PMONITOR) {
-    for (auto& r : m_dMonitorRules) {
+    for (auto& r : m_dMonitorRules | std::views::reverse) {
         if (PMONITOR.matchesStaticSelector(r.name)) {
             return r;
         }
@@ -961,7 +971,11 @@ SMonitorRule CConfigManager::getMonitorRuleFor(const CMonitor& PMONITOR) {
 
     Debug::log(WARN, "No rules configured. Using the default hardcoded one.");
 
-    return SMonitorRule{.name = "", .resolution = Vector2D(0, 0), .offset = Vector2D(-INT32_MAX, -INT32_MAX), .scale = -1}; // 0, 0 is preferred and -1, -1 is auto
+    return SMonitorRule{.autoDir    = eAutoDirs::DIR_AUTO_RIGHT,
+                        .name       = "",
+                        .resolution = Vector2D(0, 0),
+                        .offset     = Vector2D(-INT32_MAX, -INT32_MAX),
+                        .scale      = -1}; // 0, 0 is preferred and -1, -1 is auto
 }
 
 SWorkspaceRule CConfigManager::getWorkspaceRuleFor(PHLWORKSPACE pWorkspace) {
@@ -970,41 +984,56 @@ SWorkspaceRule CConfigManager::getWorkspaceRuleFor(PHLWORKSPACE pWorkspace) {
         if (!pWorkspace->matchesStaticSelector(rule.workspaceString))
             continue;
 
-        if (rule.isDefault)
-            mergedRule.isDefault = true;
-        if (rule.isPersistent)
-            mergedRule.isPersistent = true;
-        if (rule.gapsIn.has_value())
-            mergedRule.gapsIn = rule.gapsIn;
-        if (rule.gapsOut.has_value())
-            mergedRule.gapsOut = rule.gapsOut;
-        if (rule.borderSize.has_value())
-            mergedRule.borderSize = rule.borderSize;
-        if (rule.border.has_value())
-            mergedRule.border = rule.border;
-        if (rule.rounding.has_value())
-            mergedRule.rounding = rule.rounding;
-        if (rule.decorate.has_value())
-            mergedRule.decorate = rule.decorate;
-        if (rule.shadow.has_value())
-            mergedRule.shadow = rule.shadow;
-        if (rule.onCreatedEmptyRunCmd.has_value())
-            mergedRule.onCreatedEmptyRunCmd = rule.onCreatedEmptyRunCmd;
-        if (rule.defaultName.has_value())
-            mergedRule.defaultName = rule.defaultName;
-
-        if (!rule.layoutopts.empty()) {
-            for (const auto& layoutopt : rule.layoutopts) {
-                mergedRule.layoutopts[layoutopt.first] = layoutopt.second;
-            }
-        }
+        mergedRule = mergeWorkspaceRules(mergedRule, rule);
     }
 
     return mergedRule;
 }
 
-std::vector<SWindowRule> CConfigManager::getMatchingRules(CWindow* pWindow, bool dynamic, bool shadowExec) {
-    if (!g_pCompositor->windowExists(pWindow))
+SWorkspaceRule CConfigManager::mergeWorkspaceRules(const SWorkspaceRule& rule1, const SWorkspaceRule& rule2) {
+    SWorkspaceRule mergedRule = rule1;
+
+    if (rule1.monitor.empty())
+        mergedRule.monitor = rule2.monitor;
+    if (rule1.workspaceString.empty())
+        mergedRule.workspaceString = rule2.workspaceString;
+    if (rule1.workspaceName.empty())
+        mergedRule.workspaceName = rule2.workspaceName;
+    if (rule1.workspaceId == WORKSPACE_INVALID)
+        mergedRule.workspaceId = rule2.workspaceId;
+
+    if (rule2.isDefault)
+        mergedRule.isDefault = true;
+    if (rule2.isPersistent)
+        mergedRule.isPersistent = true;
+    if (rule2.gapsIn.has_value())
+        mergedRule.gapsIn = rule2.gapsIn;
+    if (rule2.gapsOut.has_value())
+        mergedRule.gapsOut = rule2.gapsOut;
+    if (rule2.borderSize.has_value())
+        mergedRule.borderSize = rule2.borderSize;
+    if (rule2.border.has_value())
+        mergedRule.border = rule2.border;
+    if (rule2.rounding.has_value())
+        mergedRule.rounding = rule2.rounding;
+    if (rule2.decorate.has_value())
+        mergedRule.decorate = rule2.decorate;
+    if (rule2.shadow.has_value())
+        mergedRule.shadow = rule2.shadow;
+    if (rule2.onCreatedEmptyRunCmd.has_value())
+        mergedRule.onCreatedEmptyRunCmd = rule2.onCreatedEmptyRunCmd;
+    if (rule2.defaultName.has_value())
+        mergedRule.defaultName = rule2.defaultName;
+    if (!rule2.layoutopts.empty()) {
+        for (const auto& layoutopt : rule2.layoutopts) {
+            mergedRule.layoutopts[layoutopt.first] = layoutopt.second;
+        }
+    }
+    return mergedRule;
+}
+
+std::vector<SWindowRule> CConfigManager::getMatchingRules(PHLWINDOW pWindow, bool dynamic, bool shadowExec) {
+    if (!valid(pWindow))
         return std::vector<SWindowRule>();
 
     std::vector<SWindowRule> returns;
@@ -1089,7 +1118,7 @@ std::vector<SWindowRule> CConfigManager::getMatchingRules(CWindow* pWindow, bool
                 }
 
                 if (rule.bFocus != -1) {
-                    if (rule.bFocus != (g_pCompositor->m_pLastWindow == pWindow))
+                    if (rule.bFocus != (g_pCompositor->m_pLastWindow.lock() == pWindow))
                         continue;
                 }
 
@@ -1159,7 +1188,7 @@ std::vector<SWindowRule> CConfigManager::getMatchingRules(CWindow* pWindow, bool
     return returns;
 }
 
-std::vector<SLayerRule> CConfigManager::getMatchingRules(SLayerSurface* pLS) {
+std::vector<SLayerRule> CConfigManager::getMatchingRules(PHLLS pLS) {
     std::vector<SLayerRule> returns;
 
     if (!pLS->layerSurface || pLS->fadingOut)
@@ -1167,7 +1196,7 @@ std::vector<SLayerRule> CConfigManager::getMatchingRules(SLayerSurface* pLS) {
 
     for (auto& lr : m_dLayerRules) {
         if (lr.targetNamespace.starts_with("address:0x")) {
-            if (std::format("address:0x{:x}", (uintptr_t)pLS) != lr.targetNamespace)
+            if (std::format("address:0x{:x}", (uintptr_t)pLS.get()) != lr.targetNamespace)
                 continue;
         } else {
             std::regex NSCHECK(lr.targetNamespace);
@@ -1217,6 +1246,10 @@ void CConfigManager::dispatchExecOnce() {
     g_pCompositor->performUserChecks();
 }
 
+void CConfigManager::appendMonitorRule(const SMonitorRule& r) {
+    m_dMonitorRules.emplace_back(r);
+}
+
 void CConfigManager::performMonitorReload() {
 
     bool overAgain = false;
@@ -1635,6 +1668,21 @@ std::optional<std::string> CConfigManager::handleMonitor(const std::string& comm
 
     if (ARGS[2].starts_with("auto")) {
         newrule.offset = Vector2D(-INT32_MAX, -INT32_MAX);
+        // If this is the first monitor rule needs to be on the right.
+        if (ARGS[2] == "auto-right" || ARGS[2] == "auto" || m_dMonitorRules.empty())
+            newrule.autoDir = eAutoDirs::DIR_AUTO_RIGHT;
+        else if (ARGS[2] == "auto-left")
+            newrule.autoDir = eAutoDirs::DIR_AUTO_LEFT;
+        else if (ARGS[2] == "auto-up")
+            newrule.autoDir = eAutoDirs::DIR_AUTO_UP;
+        else if (ARGS[2] == "auto-down")
+            newrule.autoDir = eAutoDirs::DIR_AUTO_DOWN;
+        else {
+            Debug::log(WARN,
+                       "Invalid auto direction. Valid options are 'auto',"
+                       "'auto-up', 'auto-down', 'auto-left', and 'auto-right'.");
+            error += "invalid auto direction ";
+        }
     } else {
         if (!ARGS[2].contains("x")) {
             error += "invalid offset ";
@@ -1780,12 +1828,15 @@ std::optional<std::string> CConfigManager::handleAnimation(const std::string& co
     PANIM->second.overridden = true;
     PANIM->second.pValues    = &PANIM->second;
 
-    // on/off
-    PANIM->second.internalEnabled = ARGS[1] == "1";
+    // This helper casts strings like "1", "true", "off", "yes"... to int.
+    int64_t enabledInt = configStringToInt(ARGS[1]) == 1;
 
-    if (ARGS[1] != "0" && ARGS[1] != "1")
+    // Checking that the int is 1 or 0 because the helper can return integers out of range.
+    if (enabledInt != 0 && enabledInt != 1)
         return "invalid animation on/off state";
 
+    PANIM->second.internalEnabled = configStringToInt(ARGS[1]) == 1;
+
     if (PANIM->second.internalEnabled) {
         // speed
         if (isNumber(ARGS[2], true)) {
@@ -1944,7 +1995,7 @@ bool windowRuleValid(const std::string& RULE) {
         RULE == "nomaxsize" || RULE == "pin" || RULE == "noanim" || RULE == "dimaround" || RULE == "windowdance" || RULE == "maximize" || RULE == "keepaspectratio" ||
         RULE.starts_with("animation") || RULE.starts_with("rounding") || RULE.starts_with("workspace") || RULE.starts_with("bordercolor") || RULE == "forcergbx" ||
         RULE == "noinitialfocus" || RULE == "stayfocused" || RULE.starts_with("bordersize") || RULE.starts_with("xray") || RULE.starts_with("center") ||
-        RULE.starts_with("group") || RULE == "immediate" || RULE == "nearestneighbor" || RULE.starts_with("suppressevent");
+        RULE.starts_with("group") || RULE == "immediate" || RULE == "nearestneighbor" || RULE.starts_with("suppressevent") || RULE.starts_with("plugin:");
 }
 
 bool layerRuleValid(const std::string& RULE) {
@@ -2307,7 +2358,7 @@ std::optional<std::string> CConfigManager::handleWorkspaceRules(const std::strin
     if (IT == m_dWorkspaceRules.end())
         m_dWorkspaceRules.emplace_back(wsRule);
     else
-        *IT = wsRule;
+        *IT = mergeWorkspaceRules(*IT, wsRule);
 
     return {};
 }

src/config/ConfigManager.hpp

@@ -17,6 +17,7 @@
 #include "../helpers/Monitor.hpp"
 #include "../helpers/VarList.hpp"
 #include "../desktop/Window.hpp"
+#include "../desktop/LayerSurface.hpp"
 
 #include "defaultConfig.hpp"
 #include "ConfigDataValues.hpp"
@@ -28,8 +29,6 @@
 
 #define HANDLE void*
 
-class CWindow;
-
 struct SWorkspaceRule {
     std::string                        monitor         = "";
     std::string                        workspaceString = "";
@@ -113,8 +112,8 @@ class CConfigManager {
     std::string                                                     getBoundMonitorStringForWS(const std::string&);
     const std::deque<SWorkspaceRule>&                               getAllWorkspaceRules();
 
-    std::vector<SWindowRule>                                        getMatchingRules(CWindow*, bool dynamic = true, bool shadowExec = false);
-    std::vector<SLayerRule>                                         getMatchingRules(SLayerSurface*);
+    std::vector<SWindowRule>                                        getMatchingRules(PHLWINDOW, bool dynamic = true, bool shadowExec = false);
+    std::vector<SLayerRule>                                         getMatchingRules(PHLLS);
 
     std::unordered_map<std::string, SMonitorAdditionalReservedArea> m_mAdditionalReservedAreas;
 
@@ -128,6 +127,7 @@ class CConfigManager {
     void                      dispatchExecOnce();
 
     void                      performMonitorReload();
+    void                      appendMonitorRule(const SMonitorRule&);
     bool                      m_bWantsMonitorReload = false;
     bool                      m_bForceReload        = false;
     bool                      m_bNoMonitorReload    = false;
@@ -205,6 +205,7 @@ class CConfigManager {
     std::optional<std::string> verifyConfigExists();
     void                       postConfigReload(const Hyprlang::CParseResult& result);
     void                       reload();
+    SWorkspaceRule             mergeWorkspaceRules(const SWorkspaceRule&, const SWorkspaceRule&);
 };
 
 inline std::unique_ptr<CConfigManager> g_pConfigManager;

src/config/defaultConfig.hpp

@@ -9,87 +9,116 @@ inline const std::string AUTOCONFIG = R"#(
 # OR EDIT THIS ONE ACCORDING TO THE WIKI INSTRUCTIONS.
 # #######################################################################################
 
-#
+autogenerated = 1 # remove this line to remove the warning
+
+# This is an example Hyprland config file.
+# Refer to the wiki for more information.
+# https://wiki.hyprland.org/Configuring/Configuring-Hyprland/
+
 # Please note not all available settings / options are set here.
 # For a full list, see the wiki
-#
 
-autogenerated = 1 # remove this line to remove the warning
+# You can split this configuration into multiple files
+# Create your files separately and then link them to this file like this:
+# source = ~/.config/hypr/myColors.conf
+
+
+################
+### MONITORS ###
+################
 
 # See https://wiki.hyprland.org/Configuring/Monitors/
 monitor=,preferred,auto,auto
 
 
-# See https://wiki.hyprland.org/Configuring/Keywords/ for more
+###################
+### MY PROGRAMS ###
+###################
 
-# Execute your favorite apps at launch
-# exec-once = waybar & hyprpaper & firefox
-
-# Source a file (multi-file configs)
-# source = ~/.config/hypr/myColors.conf
+# See https://wiki.hyprland.org/Configuring/Keywords/
 
 # Set programs that you use
 $terminal = kitty
 $fileManager = dolphin
 $menu = wofi --show drun
 
-# Some default env vars.
+
+#################
+### AUTOSTART ###
+#################
+
+# Autostart necessary processes (like notifications daemons, status bars, etc.)
+# Or execute your favorite apps at launch like this:
+
+# exec-once = $terminal
+# exec-once = nm-applet &
+# exec-once = waybar & hyprpaper & firefox
+
+
+#############################
+### ENVIRONMENT VARIABLES ###
+#############################
+
+# See https://wiki.hyprland.org/Configuring/Environment-variables/
+
 env = XCURSOR_SIZE,24
-env = QT_QPA_PLATFORMTHEME,qt5ct # change to qt6ct if you have that
+env = HYPRCURSOR_SIZE,24
 
-# For all categories, see https://wiki.hyprland.org/Configuring/Variables/
-input {
-    kb_layout = us
-    kb_variant =
-    kb_model =
-    kb_options =
-    kb_rules =
 
-    follow_mouse = 1
+#####################
+### LOOK AND FEEL ###
+#####################
 
-    touchpad {
-        natural_scroll = no
-    }
-
-    sensitivity = 0 # -1.0 to 1.0, 0 means no modification.
-}
-
-general {
-    # See https://wiki.hyprland.org/Configuring/Variables/ for more
+# Refer to https://wiki.hyprland.org/Configuring/Variables/
 
+# https://wiki.hyprland.org/Configuring/Variables/#general
+general { 
     gaps_in = 5
     gaps_out = 20
+
     border_size = 2
+
+    # https://wiki.hyprland.org/Configuring/Variables/#variable-types for info about colors
     col.active_border = rgba(33ccffee) rgba(00ff99ee) 45deg
     col.inactive_border = rgba(595959aa)
 
-    layout = dwindle
+    # Set to true enable resizing windows by clicking and dragging on borders and gaps
+    resize_on_border = false 
 
     # Please see https://wiki.hyprland.org/Configuring/Tearing/ before you turn this on
     allow_tearing = false
+
+    layout = dwindle
 }
 
+# https://wiki.hyprland.org/Configuring/Variables/#decoration
 decoration {
-    # See https://wiki.hyprland.org/Configuring/Variables/ for more
-
     rounding = 10
-    
+
+    # Change transparency of focused and unfocused windows
+    active_opacity = 1.0
+    inactive_opacity = 1.0
+
+    drop_shadow = true
+    shadow_range = 4
+    shadow_render_power = 3
+    col.shadow = rgba(1a1a1aee)
+
+    # https://wiki.hyprland.org/Configuring/Variables/#blur
     blur {
         enabled = true
         size = 3
         passes = 1
+        
+        vibrancy = 0.1696
     }
-
-    drop_shadow = yes
-    shadow_range = 4
-    shadow_render_power = 3
-    col.shadow = rgba(1a1a1aee)
 }
 
+# https://wiki.hyprland.org/Configuring/Variables/#animations
 animations {
-    enabled = yes
+    enabled = true
 
-    # Some default animations, see https://wiki.hyprland.org/Configuring/Animations/ for more
+    # Default animations, see https://wiki.hyprland.org/Configuring/Animations/ for more
 
     bezier = myBezier, 0.05, 0.9, 0.1, 1.05
 
@@ -101,25 +130,48 @@ animations {
     animation = workspaces, 1, 6, default
 }
 
+# See https://wiki.hyprland.org/Configuring/Dwindle-Layout/ for more
 dwindle {
-    # See https://wiki.hyprland.org/Configuring/Dwindle-Layout/ for more
-    pseudotile = yes # master switch for pseudotiling. Enabling is bound to mainMod + P in the keybinds section below
-    preserve_split = yes # you probably want this
+    pseudotile = true # Master switch for pseudotiling. Enabling is bound to mainMod + P in the keybinds section below
+    preserve_split = true # You probably want this
 }
 
+# See https://wiki.hyprland.org/Configuring/Master-Layout/ for more
 master {
-    # See https://wiki.hyprland.org/Configuring/Master-Layout/ for more
     new_is_master = true
 }
 
-gestures {
-    # See https://wiki.hyprland.org/Configuring/Variables/ for more
-    workspace_swipe = off
+# https://wiki.hyprland.org/Configuring/Variables/#misc
+misc { 
+    force_default_wallpaper = -1 # Set to 0 or 1 to disable the anime mascot wallpapers
+    disable_hyprland_logo = false # If true disables the random hyprland logo / anime girl background. :(
 }
 
-misc {
-    # See https://wiki.hyprland.org/Configuring/Variables/ for more
-    force_default_wallpaper = -1 # Set to 0 or 1 to disable the anime mascot wallpapers
+
+#############
+### INPUT ###
+#############
+
+# https://wiki.hyprland.org/Configuring/Variables/#input
+input {
+    kb_layout = us
+    kb_variant =
+    kb_model =
+    kb_options =
+    kb_rules =
+
+    follow_mouse = 1
+
+    sensitivity = 0 # -1.0 - 1.0, 0 means no modification.
+
+    touchpad {
+        natural_scroll = false
+    }
+}
+
+# https://wiki.hyprland.org/Configuring/Variables/#gestures
+gestures {
+    workspace_swipe = false
 }
 
 # Example per-device config
@@ -129,23 +181,20 @@ device {
     sensitivity = -0.5
 }
 
-# Example windowrule v1
-# windowrule = float, ^(kitty)$
-# Example windowrule v2
-# windowrulev2 = float,class:^(kitty)$,title:^(kitty)$
-# See https://wiki.hyprland.org/Configuring/Window-Rules/ for more
-windowrulev2 = suppressevent maximize, class:.* # You'll probably like this.
 
+####################
+### KEYBINDINGSS ###
+####################
 
-# See https://wiki.hyprland.org/Configuring/Keywords/ for more
-$mainMod = SUPER
+# See https://wiki.hyprland.org/Configuring/Keywords/
+$mainMod = SUPER # Sets "Windows" key as main modifier
 
 # Example binds, see https://wiki.hyprland.org/Configuring/Binds/ for more
 bind = $mainMod, Q, exec, $terminal
-bind = $mainMod, C, killactive, 
-bind = $mainMod, M, exit, 
+bind = $mainMod, C, killactive,
+bind = $mainMod, M, exit,
 bind = $mainMod, E, exec, $fileManager
-bind = $mainMod, V, togglefloating, 
+bind = $mainMod, V, togglefloating,
 bind = $mainMod, R, exec, $menu
 bind = $mainMod, P, pseudo, # dwindle
 bind = $mainMod, J, togglesplit, # dwindle
@@ -191,4 +240,20 @@ bind = $mainMod, mouse_up, workspace, e-1
 # Move/resize windows with mainMod + LMB/RMB and dragging
 bindm = $mainMod, mouse:272, movewindow
 bindm = $mainMod, mouse:273, resizewindow
+
+
+##############################
+### WINDOWS AND WORKSPACES ###
+##############################
+
+# See https://wiki.hyprland.org/Configuring/Window-Rules/ for more
+# See https://wiki.hyprland.org/Configuring/Workspace-Rules/ for workspace rules
+
+# Example windowrule v1
+# windowrule = float, ^(kitty)$
+
+# Example windowrule v2
+# windowrulev2 = float,class:^(kitty)$,title:^(kitty)$
+
+windowrulev2 = suppressevent maximize, class:.* # You'll probably like this.
 )#";

src/debug/CrashReporter.cpp

@@ -1,59 +1,127 @@
 #include "CrashReporter.hpp"
-#include <random>
+#include <fcntl.h>
 #include <sys/utsname.h>
-#include <fstream>
-#include <signal.h>
 #include <link.h>
+#include <time.h>
+#include <errno.h>
+#include <sys/stat.h>
 
 #include "../plugins/PluginSystem.hpp"
+#include "../signal-safe.hpp"
 
 #if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__)
 #include <sys/sysctl.h>
 #endif
 
-std::string getRandomMessage() {
+static char const* const MESSAGES[] = {"Sorry, didn't mean to...",
+                                       "This was an accident, I swear!",
+                                       "Calm down, it was a misinput! MISINPUT!",
+                                       "Oops",
+                                       "Vaxry is going to be upset.",
+                                       "Who tried dividing by zero?!",
+                                       "Maybe you should try dusting your PC in the meantime?",
+                                       "I tried so hard, and got so far...",
+                                       "I don't feel so good...",
+                                       "*thud*",
+                                       "Well this is awkward.",
+                                       "\"stable\"",
+                                       "I hope you didn't have any unsaved progress.",
+                                       "All these computers..."};
 
-    const std::vector<std::string>  MESSAGES = {"Sorry, didn't mean to...",
-                                                "This was an accident, I swear!",
-                                                "Calm down, it was a misinput! MISINPUT!",
-                                                "Oops",
-                                                "Vaxry is going to be upset.",
-                                                "Who tried dividing by zero?!",
-                                                "Maybe you should try dusting your PC in the meantime?",
-                                                "I tried so hard, and got so far...",
-                                                "I don't feel so good...",
-                                                "*thud*",
-                                                "Well this is awkward.",
-                                                "\"stable\"",
-                                                "I hope you didn't have any unsaved progress.",
-                                                "All these computers..."};
+// <random> is not async-signal-safe, fake it with time(NULL) instead
+char const* getRandomMessage() {
+    return MESSAGES[time(NULL) % (sizeof(MESSAGES) / sizeof(MESSAGES[0]))];
+}
 
-    std::random_device              dev;
-    std::mt19937                    engine(dev());
-    std::uniform_int_distribution<> distribution(0, MESSAGES.size() - 1);
-
-    return MESSAGES[distribution(engine)];
+[[noreturn]] inline void exit_with_error(char const* err) {
+    write(STDERR_FILENO, err, strlen(err));
+    // perror() is not signal-safe, but we use it here
+    // because if the crash-handler already crashed, it can't get any worse.
+    perror("");
+    abort();
 }
 
 void CrashReporter::createAndSaveCrash(int sig) {
+    int reportFd;
 
-    // get the backtrace
-    const int   PID = getpid();
+    // We're in the signal handler, so we *only* have stack memory.
+    // To save as much stack memory as possible,
+    // destroy things as soon as possible.
+    {
+        MaxLengthCString<255> reportPath;
 
-    std::string finalCrashReport = "";
+        const auto            HOME       = sig_getenv("HOME");
+        const auto            CACHE_HOME = sig_getenv("XDG_CACHE_HOME");
+
+        if (CACHE_HOME && CACHE_HOME[0] != '\0') {
+            reportPath += CACHE_HOME;
+            reportPath += "/hyprland";
+        } else if (HOME && HOME[0] != '\0') {
+            reportPath += HOME;
+            reportPath += "/.cache/hyprland";
+        } else {
+            exit_with_error("$CACHE_HOME and $HOME not set, nowhere to report crash\n");
+            return;
+        }
+
+        int ret = mkdir(reportPath.get_str(), S_IRWXU);
+        //__asm__("int $3");
+        if (ret < 0 && errno != EEXIST) {
+            exit_with_error("failed to mkdir() crash report directory\n");
+        }
+        reportPath += "/hyprlandCrashReport";
+        reportPath.write_num(getpid());
+        reportPath += ".txt";
+
+        {
+            BufFileWriter<64> stderr(2);
+            stderr += "Hyprland has crashed :( Consult the crash report at ";
+            if (!reportPath.boundsExceeded()) {
+                stderr += reportPath.get_str();
+            } else {
+                stderr += "[ERROR: Crash report path does not fit into memory! Check if your $CACHE_HOME/$HOME is too deeply nested. Max 255 characters.]";
+            }
+            stderr += " for more information.\n";
+            stderr.flush();
+        }
+
+        reportFd = open(reportPath.get_str(), O_WRONLY | O_CREAT, S_IRWXU);
+        if (reportFd < 0) {
+            exit_with_error("Failed to open crash report path for writing");
+        }
+    }
+    BufFileWriter<512> finalCrashReport(reportFd);
 
     finalCrashReport += "--------------------------------------------\n   Hyprland Crash Report\n--------------------------------------------\n";
-    finalCrashReport += getRandomMessage() + "\n\n";
+    finalCrashReport += getRandomMessage();
+    finalCrashReport += "\n\n";
 
-    finalCrashReport += std::format("Hyprland received signal {} ({})\n\n", sig, (const char*)strsignal(sig));
+    finalCrashReport += "Hyprland received signal ";
+    finalCrashReport.writeNum(sig);
+    finalCrashReport += '(';
+    finalCrashReport += sig_strsignal(sig);
+    finalCrashReport += ")\nVersion: ";
+    finalCrashReport += GIT_COMMIT_HASH;
+    finalCrashReport += "\nTag: ";
+    finalCrashReport += GIT_TAG;
+    finalCrashReport += "\n\n";
 
-    finalCrashReport += std::format("Version: {}\nTag: {}\n\n", GIT_COMMIT_HASH, GIT_TAG);
-
-    if (g_pPluginSystem && !g_pPluginSystem->getAllPlugins().empty()) {
+    if (g_pPluginSystem && g_pPluginSystem->pluginCount() > 0) {
         finalCrashReport += "Hyprland seems to be running with plugins. This crash might not be Hyprland's fault.\nPlugins:\n";
 
-        for (auto& p : g_pPluginSystem->getAllPlugins()) {
-            finalCrashReport += std::format("\t{} ({}) {}\n", p->name, p->author, p->version);
+        size_t   count = g_pPluginSystem->pluginCount();
+        CPlugin* plugins[count];
+        g_pPluginSystem->sig_getPlugins(plugins, count);
+
+        for (size_t i = 0; i < count; i++) {
+            auto p = plugins[i];
+            finalCrashReport += '\t';
+            finalCrashReport += p->name;
+            finalCrashReport += " (";
+            finalCrashReport += p->author;
+            finalCrashReport += ") ";
+            finalCrashReport += p->version;
+            finalCrashReport += '\n';
         }
 
         finalCrashReport += "\n\n";
@@ -61,21 +129,36 @@ void CrashReporter::createAndSaveCrash(int sig) {
 
     finalCrashReport += "System info:\n";
 
-    struct utsname unameInfo;
-    uname(&unameInfo);
+    {
+        struct utsname unameInfo;
+        uname(&unameInfo);
 
-    finalCrashReport += std::format("\tSystem name: {}\n\tNode name: {}\n\tRelease: {}\n\tVersion: {}\n\n", std::string{unameInfo.sysname}, std::string{unameInfo.nodename},
-                                    std::string{unameInfo.release}, std::string{unameInfo.version});
+        finalCrashReport += "\tSystem name: ";
+        finalCrashReport += unameInfo.sysname;
+        finalCrashReport += "\n\tNode name: ";
+        finalCrashReport += unameInfo.nodename;
+        finalCrashReport += "\n\tRelease: ";
+        finalCrashReport += unameInfo.release;
+        finalCrashReport += "\n\tVersion: ";
+        finalCrashReport += unameInfo.version;
+        finalCrashReport += "\n\n";
+    }
 
+    finalCrashReport += "GPU:\n\t";
 #if defined(__DragonFly__) || defined(__FreeBSD__)
-    const std::string GPUINFO = execAndGet("pciconf -lv | fgrep -A4 vga");
+    finalCrashReport.writeCmdOutput("pciconf -lv | fgrep -A4 vga");
 #else
-    const std::string GPUINFO = execAndGet("lspci -vnn | grep VGA");
+    finalCrashReport.writeCmdOutput("lspci -vnn | grep VGA");
 #endif
 
-    finalCrashReport += "GPU:\n\t" + GPUINFO;
+    finalCrashReport += "\n\nos-release:\n";
+    finalCrashReport.writeCmdOutput("cat /etc/os-release | sed 's/^/\t/'");
 
-    finalCrashReport += std::format("\n\nos-release:\n\t{}\n\n\n", replaceInString(execAndGet("cat /etc/os-release"), "\n", "\n\t"));
+    // dladdr1()/backtrace_symbols()/this entire section allocates, and hence is NOT async-signal-safe.
+    // Make sure that we save the current known crash report information,
+    // so that if we are caught in a deadlock during a call to malloc(),
+    // there is still something to debug from.
+    finalCrashReport.flush();
 
     finalCrashReport += "Backtrace:\n";
 
@@ -132,7 +215,10 @@ void CrashReporter::createAndSaveCrash(int sig) {
     std::stringstream ssin(ADDR2LINE);
 
     for (size_t i = 0; i < CALLSTACK.size(); ++i) {
-        finalCrashReport += std::format("\t#{} | {}", i, CALLSTACK[i].desc);
+        finalCrashReport += "\t#";
+        finalCrashReport.writeNum(i);
+        finalCrashReport += " | ";
+        finalCrashReport += CALLSTACK[i].desc;
         std::string functionInfo;
         std::string fileLineInfo;
         std::getline(ssin, functionInfo);
@@ -142,32 +228,5 @@ void CrashReporter::createAndSaveCrash(int sig) {
 
     finalCrashReport += "\n\nLog tail:\n";
 
-    finalCrashReport += Debug::rollingLog.substr(Debug::rollingLog.find("\n") + 1);
-
-    const auto HOME       = getenv("HOME");
-    const auto CACHE_HOME = getenv("XDG_CACHE_HOME");
-
-    if (!HOME)
-        return;
-
-    std::ofstream ofs;
-    std::string   reportDir;
-
-    if (!CACHE_HOME || std::string(CACHE_HOME).empty())
-        reportDir = std::string(HOME) + "/.cache/hyprland";
-    else
-        reportDir = std::string(CACHE_HOME) + "/hyprland";
-
-    if (!std::filesystem::exists(reportDir))
-        std::filesystem::create_directory(reportDir);
-    const auto path = reportDir + "/hyprlandCrashReport" + std::to_string(PID) + ".txt";
-
-    ofs.open(path, std::ios::trunc);
-
-    ofs << finalCrashReport;
-
-    ofs.close();
-
-    Debug::disableStdout = false;
-    Debug::log(CRIT, "Hyprland has crashed :( Consult the crash report at {} for more information.", path);
+    finalCrashReport += std::string_view(Debug::rollingLog).substr(Debug::rollingLog.find("\n") + 1);
 }

src/debug/HyprCtl.cpp

@@ -19,6 +19,9 @@
 #include "../config/ConfigValue.hpp"
 #include "../managers/CursorManager.hpp"
 #include "../hyprerror/HyprError.hpp"
+#include "../devices/IPointer.hpp"
+#include "../devices/IKeyboard.hpp"
+#include "../devices/ITouch.hpp"
 
 static void trimTrailingComma(std::string& str) {
     if (!str.empty() && str.back() == ',')
@@ -107,9 +110,10 @@ std::string monitorsRequest(eHyprCtlOutputFormat format, std::string request) {
     "currentFormat": "{}",
     "availableModes": [{}]
 }},)#",
-                m->ID, escapeJSONStrings(m->szName), escapeJSONStrings(m->szShortDescription), (m->output->make ? m->output->make : ""), (m->output->model ? m->output->model : ""),
-                (m->output->serial ? 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(),
+                m->ID, escapeJSONStrings(m->szName), escapeJSONStrings(m->szShortDescription), escapeJSONStrings(m->output->make ? m->output->make : ""),
+                escapeJSONStrings(m->output->model ? m->output->model : ""), escapeJSONStrings(m->output->serial ? 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.get() == g_pCompositor->m_pLastMonitor ? "true" : "false"),
                 (m->dpmsStatus ? "true" : "false"), (m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED ? "true" : "false"),
@@ -141,21 +145,21 @@ std::string monitorsRequest(eHyprCtlOutputFormat format, std::string request) {
     return result;
 }
 
-static std::string getGroupedData(CWindow* w, eHyprCtlOutputFormat format) {
+static std::string getGroupedData(PHLWINDOW w, eHyprCtlOutputFormat format) {
     const bool isJson = format == eHyprCtlOutputFormat::FORMAT_JSON;
-    if (!w->m_sGroupData.pNextWindow)
+    if (w->m_sGroupData.pNextWindow.expired())
         return isJson ? "" : "0";
 
     std::ostringstream result;
 
-    CWindow*           head = w->getGroupHead();
-    CWindow*           curr = head;
+    PHLWINDOW          head = w->getGroupHead();
+    PHLWINDOW          curr = head;
     while (true) {
         if (isJson)
-            result << std::format("\"0x{:x}\"", (uintptr_t)curr);
+            result << std::format("\"0x{:x}\"", (uintptr_t)curr.get());
         else
-            result << std::format("{:x}", (uintptr_t)curr);
-        curr = curr->m_sGroupData.pNextWindow;
+            result << std::format("{:x}", (uintptr_t)curr.get());
+        curr = curr->m_sGroupData.pNextWindow.lock();
         // We've wrapped around to the start, break out without trailing comma
         if (curr == head)
             break;
@@ -165,10 +169,10 @@ static std::string getGroupedData(CWindow* w, eHyprCtlOutputFormat format) {
     return result.str();
 }
 
-static std::string getWindowData(CWindow* w, eHyprCtlOutputFormat format) {
-    auto getFocusHistoryID = [](CWindow* wnd) -> int {
+static std::string getWindowData(PHLWINDOW w, eHyprCtlOutputFormat format) {
+    auto getFocusHistoryID = [](PHLWINDOW wnd) -> int {
         for (size_t i = 0; i < g_pCompositor->m_vWindowFocusHistory.size(); ++i) {
-            if (g_pCompositor->m_vWindowFocusHistory[i] == wnd)
+            if (g_pCompositor->m_vWindowFocusHistory[i].lock() == wnd)
                 return i;
         }
         return -1;
@@ -202,24 +206,24 @@ static std::string getWindowData(CWindow* w, eHyprCtlOutputFormat format) {
     "swallowing": "0x{:x}",
     "focusHistoryID": {}
 }},)#",
-            (uintptr_t)w, (w->m_bIsMapped ? "true" : "false"), (w->isHidden() ? "true" : "false"), (int)w->m_vRealPosition.goal().x, (int)w->m_vRealPosition.goal().y,
+            (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"), (int64_t)w->m_iMonitorID,
             escapeJSONStrings(g_pXWaylandManager->getAppIDClass(w)), escapeJSONStrings(g_pXWaylandManager->getTitle(w)), escapeJSONStrings(w->m_szInitialClass),
             escapeJSONStrings(w->m_szInitialTitle), w->getPID(), ((int)w->m_bIsX11 == 1 ? "true" : "false"), (w->m_bPinned ? "true" : "false"),
             (w->m_bIsFullscreen ? "true" : "false"), (w->m_bIsFullscreen ? (w->m_pWorkspace ? (int)w->m_pWorkspace->m_efFullscreenMode : 0) : 0),
-            w->m_bFakeFullscreenState ? "true" : "false", getGroupedData(w, format), (uintptr_t)w->m_pSwallowed, getFocusHistoryID(w));
+            w->m_bFakeFullscreenState ? "true" : "false", getGroupedData(w, format), (uintptr_t)w->m_pSwallowed.lock().get(), getFocusHistoryID(w));
     } else {
         return std::format("Window {:x} -> {}:\n\tmapped: {}\n\thidden: {}\n\tat: {},{}\n\tsize: {},{}\n\tworkspace: {} ({})\n\tfloating: {}\n\tmonitor: {}\n\tclass: {}\n\ttitle: "
                            "{}\n\tinitialClass: {}\n\tinitialTitle: {}\n\tpid: "
                            "{}\n\txwayland: {}\n\tpinned: "
                            "{}\n\tfullscreen: {}\n\tfullscreenmode: {}\n\tfakefullscreen: {}\n\tgrouped: {}\n\tswallowing: {:x}\n\tfocusHistoryID: {}\n\n",
-                           (uintptr_t)w, w->m_szTitle, (int)w->m_bIsMapped, (int)w->isHidden(), (int)w->m_vRealPosition.goal().x, (int)w->m_vRealPosition.goal().y,
+                           (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 ? "" : std::to_string(w->workspaceID())), (int)w->m_bIsFloating, (int64_t)w->m_iMonitorID, g_pXWaylandManager->getAppIDClass(w),
+                           (!w->m_pWorkspace ? "" : w->m_pWorkspace->m_szName), (int)w->m_bIsFloating, (int64_t)w->m_iMonitorID, g_pXWaylandManager->getAppIDClass(w),
                            g_pXWaylandManager->getTitle(w), w->m_szInitialClass, w->m_szInitialTitle, w->getPID(), (int)w->m_bIsX11, (int)w->m_bPinned, (int)w->m_bIsFullscreen,
                            (w->m_bIsFullscreen ? (w->m_pWorkspace ? w->m_pWorkspace->m_efFullscreenMode : 0) : 0), (int)w->m_bFakeFullscreenState, getGroupedData(w, format),
-                           (uintptr_t)w->m_pSwallowed, getFocusHistoryID(w));
+                           (uintptr_t)w->m_pSwallowed.lock().get(), getFocusHistoryID(w));
     }
 }
 
@@ -232,7 +236,7 @@ std::string clientsRequest(eHyprCtlOutputFormat format, std::string request) {
             if (!w->m_bIsMapped && !g_pHyprCtl->m_sCurrentRequestParams.all)
                 continue;
 
-            result += getWindowData(w.get(), format);
+            result += getWindowData(w, format);
         }
 
         trimTrailingComma(result);
@@ -243,7 +247,7 @@ std::string clientsRequest(eHyprCtlOutputFormat format, std::string request) {
             if (!w->m_bIsMapped && !g_pHyprCtl->m_sCurrentRequestParams.all)
                 continue;
 
-            result += getWindowData(w.get(), format);
+            result += getWindowData(w, format);
         }
     }
     return result;
@@ -265,11 +269,11 @@ static std::string getWorkspaceData(PHLWORKSPACE w, eHyprCtlOutputFormat format)
 }})#",
                            w->m_iID, escapeJSONStrings(w->m_szName), escapeJSONStrings(PMONITOR ? PMONITOR->szName : "?"),
                            escapeJSONStrings(PMONITOR ? std::to_string(PMONITOR->ID) : "null"), g_pCompositor->getWindowsOnWorkspace(w->m_iID),
-                           ((int)w->m_bHasFullscreenWindow == 1 ? "true" : "false"), (uintptr_t)PLASTW, PLASTW ? escapeJSONStrings(PLASTW->m_szTitle) : "");
+                           ((int)w->m_bHasFullscreenWindow == 1 ? "true" : "false"), (uintptr_t)PLASTW.get(), PLASTW ? escapeJSONStrings(PLASTW->m_szTitle) : "");
     } else {
         return std::format("workspace ID {} ({}) on monitor {}:\n\tmonitorID: {}\n\twindows: {}\n\thasfullscreen: {}\n\tlastwindow: 0x{:x}\n\tlastwindowtitle: {}\n\n", w->m_iID,
                            w->m_szName, PMONITOR ? PMONITOR->szName : "?", PMONITOR ? std::to_string(PMONITOR->ID) : "null", g_pCompositor->getWindowsOnWorkspace(w->m_iID),
-                           (int)w->m_bHasFullscreenWindow, (uintptr_t)PLASTW, PLASTW ? PLASTW->m_szTitle : "");
+                           (int)w->m_bHasFullscreenWindow, (uintptr_t)PLASTW.get(), PLASTW ? PLASTW->m_szTitle : "");
     }
 }
 
@@ -374,9 +378,9 @@ std::string workspaceRulesRequest(eHyprCtlOutputFormat format, std::string reque
 }
 
 std::string activeWindowRequest(eHyprCtlOutputFormat format, std::string request) {
-    const auto PWINDOW = g_pCompositor->m_pLastWindow;
+    const auto PWINDOW = g_pCompositor->m_pLastWindow.lock();
 
-    if (!g_pCompositor->windowValidMapped(PWINDOW))
+    if (!validMapped(PWINDOW))
         return format == eHyprCtlOutputFormat::FORMAT_JSON ? "{}" : "Invalid";
 
     auto result = getWindowData(PWINDOW, format);
@@ -513,23 +517,24 @@ std::string devicesRequest(eHyprCtlOutputFormat format, std::string request) {
         result += "{\n";
         result += "\"mice\": [\n";
 
-        for (auto& m : g_pInputManager->m_lMice) {
+        for (auto& m : g_pInputManager->m_vPointers) {
             result += std::format(
                 R"#(    {{
         "address": "0x{:x}",
         "name": "{}",
         "defaultSpeed": {:.5f}
     }},)#",
-                (uintptr_t)&m, escapeJSONStrings(m.name),
-                wlr_input_device_is_libinput(m.mouse) ? libinput_device_config_accel_get_default_speed((libinput_device*)wlr_libinput_get_device_handle(m.mouse)) : 0.f);
+                (uintptr_t)m.get(), escapeJSONStrings(m->hlName),
+                wlr_input_device_is_libinput(&m->wlr()->base) ? libinput_device_config_accel_get_default_speed((libinput_device*)wlr_libinput_get_device_handle(&m->wlr()->base)) :
+                                                                0.f);
         }
 
         trimTrailingComma(result);
         result += "\n],\n";
 
         result += "\"keyboards\": [\n";
-        for (auto& k : g_pInputManager->m_lKeyboards) {
-            const auto KM = g_pInputManager->getActiveLayoutForKeyboard(&k);
+        for (auto& k : g_pInputManager->m_vKeyboards) {
+            const auto KM = k->getActiveLayout();
             result += std::format(
                 R"#(    {{
         "address": "0x{:x}",
@@ -542,9 +547,9 @@ std::string devicesRequest(eHyprCtlOutputFormat format, std::string request) {
         "active_keymap": "{}",
         "main": {}
     }},)#",
-                (uintptr_t)&k, escapeJSONStrings(k.name), escapeJSONStrings(k.currentRules.rules), escapeJSONStrings(k.currentRules.model),
-                escapeJSONStrings(k.currentRules.layout), escapeJSONStrings(k.currentRules.variant), escapeJSONStrings(k.currentRules.options), escapeJSONStrings(KM),
-                (k.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),
+                (k->active ? "true" : "false"));
         }
 
         trimTrailingComma(result);
@@ -589,13 +594,13 @@ std::string devicesRequest(eHyprCtlOutputFormat format, std::string request) {
 
         result += "\"touch\": [\n";
 
-        for (auto& d : g_pInputManager->m_lTouchDevices) {
+        for (auto& d : g_pInputManager->m_vTouches) {
             result += std::format(
                 R"#(    {{
         "address": "0x{:x}",
         "name": "{}"
     }},)#",
-                (uintptr_t)&d, d.name);
+                (uintptr_t)d.get(), escapeJSONStrings(d->hlName));
         }
 
         trimTrailingComma(result);
@@ -609,7 +614,7 @@ std::string devicesRequest(eHyprCtlOutputFormat format, std::string request) {
         "address": "0x{:x}",
         "name": "{}"
     }},)#",
-                (uintptr_t)&d, d.pWlrDevice ? d.pWlrDevice->name : "");
+                (uintptr_t)&d, escapeJSONStrings(d.pWlrDevice ? d.pWlrDevice->name : ""));
         }
 
         trimTrailingComma(result);
@@ -620,19 +625,20 @@ std::string devicesRequest(eHyprCtlOutputFormat format, std::string request) {
     } else {
         result += "mice:\n";
 
-        for (auto& m : g_pInputManager->m_lMice) {
-            result += std::format(
-                "\tMouse at {:x}:\n\t\t{}\n\t\t\tdefault speed: {:.5f}\n", (uintptr_t)&m, m.name,
-                (wlr_input_device_is_libinput(m.mouse) ? libinput_device_config_accel_get_default_speed((libinput_device*)wlr_libinput_get_device_handle(m.mouse)) : 0.f));
+        for (auto& 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,
+                                  (wlr_input_device_is_libinput(&m->wlr()->base) ?
+                                       libinput_device_config_accel_get_default_speed((libinput_device*)wlr_libinput_get_device_handle(&m->wlr()->base)) :
+                                       0.f));
         }
 
         result += "\n\nKeyboards:\n";
 
-        for (auto& k : g_pInputManager->m_lKeyboards) {
-            const auto KM = g_pInputManager->getActiveLayoutForKeyboard(&k);
+        for (auto& 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\tmain: {}\n",
-                                  (uintptr_t)&k, k.name, k.currentRules.rules, k.currentRules.model, k.currentRules.layout, k.currentRules.variant, k.currentRules.options, KM,
-                                  (k.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, (k->active ? "yes" : "no"));
         }
 
         result += "\n\nTablets:\n";
@@ -651,8 +657,8 @@ std::string devicesRequest(eHyprCtlOutputFormat format, std::string request) {
 
         result += "\n\nTouch:\n";
 
-        for (auto& d : g_pInputManager->m_lTouchDevices) {
-            result += std::format("\tTouch Device at {:x}:\n\t\t{}\n", (uintptr_t)&d, d.name);
+        for (auto& 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";
@@ -694,8 +700,8 @@ std::string animationsRequest(eHyprCtlOutputFormat format, std::string request)
     "speed": {:.2f},
     "style": "{}"
 }},)#",
-                               ac.first, ac.second.overridden ? "true" : "false", ac.second.internalBezier, ac.second.internalEnabled ? "true" : "false", ac.second.internalSpeed,
-                               ac.second.internalStyle);
+                               ac.first, ac.second.overridden ? "true" : "false", escapeJSONStrings(ac.second.internalBezier), ac.second.internalEnabled ? "true" : "false",
+                               ac.second.internalSpeed, escapeJSONStrings(ac.second.internalStyle));
         }
 
         ret[ret.length() - 1] = ']';
@@ -707,7 +713,7 @@ std::string animationsRequest(eHyprCtlOutputFormat format, std::string request)
 {{
     "name": "{}"
 }},)#",
-                               bz.first);
+                               escapeJSONStrings(bz.first));
         }
 
         trimTrailingComma(ret);
@@ -834,7 +840,7 @@ std::string versionRequest(eHyprCtlOutputFormat format, std::string request) {
     "commit_message": "{}",
     "commit_date": "{}",
     "tag": "{}",
-    "commits": {},
+    "commits": "{}",
     "flags": [)#",
             GIT_BRANCH, GIT_COMMIT_HASH, (strcmp(GIT_DIRTY, "dirty") == 0 ? "true" : "false"), escapeJSONStrings(commitMsg), GIT_COMMIT_DATE, GIT_TAG, GIT_COMMITS);
 
@@ -1068,13 +1074,13 @@ std::string switchXKBLayoutRequest(eHyprCtlOutputFormat format, std::string requ
     const auto CMD = vars[2];
 
     // get kb
-    const auto PKEYBOARD = std::find_if(g_pInputManager->m_lKeyboards.begin(), g_pInputManager->m_lKeyboards.end(),
-                                        [&](const SKeyboard& other) { return other.name == g_pInputManager->deviceNameToInternalString(KB); });
+    const auto PKEYBOARD = std::find_if(g_pInputManager->m_vKeyboards.begin(), g_pInputManager->m_vKeyboards.end(),
+                                        [&](const auto& other) { return other->hlName == g_pInputManager->deviceNameToInternalString(KB); });
 
-    if (PKEYBOARD == g_pInputManager->m_lKeyboards.end())
+    if (PKEYBOARD == g_pInputManager->m_vKeyboards.end())
         return "device not found";
 
-    const auto         PWLRKEYBOARD = wlr_keyboard_from_input_device(PKEYBOARD->keyboard);
+    const auto         PWLRKEYBOARD = (*PKEYBOARD)->wlr();
     const auto         LAYOUTS      = xkb_keymap_num_layouts(PWLRKEYBOARD->keymap);
     xkb_layout_index_t activeLayout = 0;
     while (activeLayout < LAYOUTS) {
@@ -1142,7 +1148,7 @@ std::string dispatchSetProp(eHyprCtlOutputFormat format, std::string request) {
     if (vars.size() < 4)
         return "not enough args";
 
-    const auto PLASTWINDOW = g_pCompositor->m_pLastWindow;
+    const auto PLASTWINDOW = g_pCompositor->m_pLastWindow.lock();
     const auto PWINDOW     = g_pCompositor->getWindowByRegex(vars[1]);
 
     if (!PWINDOW)
@@ -1746,7 +1752,7 @@ void CHyprCtl::startHyprCtlSocket() {
 
     sockaddr_un SERVERADDRESS = {.sun_family = AF_UNIX};
 
-    std::string socketPath = "/tmp/hypr/" + g_pCompositor->m_szInstanceSignature + "/.socket.sock";
+    std::string socketPath = g_pCompositor->m_szInstancePath + "/.socket.sock";
 
     strcpy(SERVERADDRESS.sun_path, socketPath.c_str());
 

src/debug/HyprNotificationOverlay.cpp

@@ -3,7 +3,7 @@
 #include <pango/pangocairo.h>
 
 CHyprNotificationOverlay::CHyprNotificationOverlay() {
-    g_pHookSystem->hookDynamic("focusedMon", [&](void* self, SCallbackInfo& info, std::any param) {
+    static auto P = g_pHookSystem->hookDynamic("focusedMon", [&](void* self, SCallbackInfo& info, std::any param) {
         if (m_dNotifications.size() == 0)
             return;
 
@@ -36,6 +36,13 @@ CHyprNotificationOverlay::CHyprNotificationOverlay() {
     m_szIconFontName = fonts.substr(COLON + 2, LASTCHAR - (COLON + 2));
 }
 
+CHyprNotificationOverlay::~CHyprNotificationOverlay() {
+    if (m_pCairo)
+        cairo_destroy(m_pCairo);
+    if (m_pCairoSurface)
+        cairo_surface_destroy(m_pCairoSurface);
+}
+
 void CHyprNotificationOverlay::addNotification(const std::string& text, const CColor& color, const float timeMs, const eIcons icon, const float fontSize) {
     const auto PNOTIF = m_dNotifications.emplace_back(std::make_unique<SNotification>()).get();
 
@@ -76,7 +83,7 @@ CBox CHyprNotificationOverlay::drawNotifications(CMonitor* pMonitor) {
 
     const auto            SCALE = pMonitor->scale;
 
-    const auto            MONSIZE = pMonitor->vecPixelSize;
+    const auto            MONSIZE = pMonitor->vecTransformedSize;
 
     cairo_text_extents_t  cairoExtents;
     int                   iconW = 0, iconH = 0;
@@ -185,16 +192,19 @@ CBox CHyprNotificationOverlay::drawNotifications(CMonitor* pMonitor) {
 
 void CHyprNotificationOverlay::draw(CMonitor* pMonitor) {
 
-    if (m_pLastMonitor != pMonitor || !m_pCairo || !m_pCairoSurface) {
+    const auto MONSIZE = pMonitor->vecTransformedSize;
+
+    if (m_pLastMonitor != pMonitor || m_vecLastSize != MONSIZE || !m_pCairo || !m_pCairoSurface) {
 
         if (m_pCairo && m_pCairoSurface) {
             cairo_destroy(m_pCairo);
             cairo_surface_destroy(m_pCairoSurface);
         }
 
-        m_pCairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y);
+        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
@@ -232,12 +242,12 @@ void CHyprNotificationOverlay::draw(CMonitor* pMonitor) {
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
 #endif
 
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, MONSIZE.x, MONSIZE.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
 
-    CBox pMonBox = {0, 0, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y};
+    CBox pMonBox = {0, 0, MONSIZE.x, MONSIZE.y};
     g_pHyprOpenGL->renderTexture(m_tTexture, &pMonBox, 1.f);
 }
 
 bool CHyprNotificationOverlay::hasAny() {
     return !m_dNotifications.empty();
-}
+}

src/debug/HyprNotificationOverlay.hpp

@@ -39,6 +39,7 @@ struct SNotification {
 class CHyprNotificationOverlay {
   public:
     CHyprNotificationOverlay();
+    ~CHyprNotificationOverlay();
 
     void draw(CMonitor* pMonitor);
     void addNotification(const std::string& text, const CColor& color, const float timeMs, const eIcons icon = ICON_NONE, const float fontSize = 13.f);
@@ -55,6 +56,7 @@ class CHyprNotificationOverlay {
     cairo_t*                                   m_pCairo        = nullptr;
 
     CMonitor*                                  m_pLastMonitor = nullptr;
+    Vector2D                                   m_vecLastSize  = Vector2D(-1, -1);
 
     CTexture                                   m_tTexture;
 
@@ -62,4 +64,4 @@ class CHyprNotificationOverlay {
     std::string                                m_szIconFontName = "Sans";
 };
 
-inline std::unique_ptr<CHyprNotificationOverlay> g_pHyprNotificationOverlay;
+inline std::unique_ptr<CHyprNotificationOverlay> g_pHyprNotificationOverlay;

src/debug/Log.cpp

@@ -6,7 +6,7 @@
 #include <iostream>
 
 void Debug::init(const std::string& IS) {
-    logFile = "/tmp/hypr/" + IS + (ISDEBUG ? "/hyprlandd.log" : "/hyprland.log");
+    logFile = IS + (ISDEBUG ? "/hyprlandd.log" : "/hyprland.log");
 }
 
 void Debug::wlrLog(wlr_log_importance level, const char* fmt, va_list args) {
@@ -32,3 +32,57 @@ void Debug::wlrLog(wlr_log_importance level, const char* fmt, va_list args) {
     if (!disableStdout)
         std::cout << output << "\n";
 }
+
+void Debug::log(LogLevel level, std::string str) {
+    if (level == TRACE && !trace)
+        return;
+
+    if (shuttingDown)
+        return;
+
+    std::string coloredStr = str;
+    switch (level) {
+        case LOG:
+            str        = "[LOG] " + str;
+            coloredStr = str;
+            break;
+        case WARN:
+            str        = "[WARN] " + str;
+            coloredStr = "\033[1;33m" + str + "\033[0m"; // yellow
+            break;
+        case ERR:
+            str        = "[ERR] " + str;
+            coloredStr = "\033[1;31m" + str + "\033[0m"; // red
+            break;
+        case CRIT:
+            str        = "[CRITICAL] " + str;
+            coloredStr = "\033[1;35m" + str + "\033[0m"; // magenta
+            break;
+        case INFO:
+            str        = "[INFO] " + str;
+            coloredStr = "\033[1;32m" + str + "\033[0m"; // green
+            break;
+        case TRACE:
+            str        = "[TRACE] " + str;
+            coloredStr = "\033[1;34m" + str + "\033[0m"; // blue
+            break;
+        default: break;
+    }
+
+    rollingLog += str + "\n";
+    if (rollingLog.size() > ROLLING_LOG_SIZE)
+        rollingLog = rollingLog.substr(rollingLog.size() - ROLLING_LOG_SIZE);
+
+    if (!disableLogs || !**disableLogs) {
+        // log to a file
+        std::ofstream ofs;
+        ofs.open(logFile, std::ios::out | std::ios::app);
+        ofs << str << "\n";
+
+        ofs.close();
+    }
+
+    // log it to the stdout too.
+    if (!disableStdout)
+        std::cout << ((coloredLogs && !**coloredLogs) ? str : coloredStr) << "\n";
+}

src/debug/Log.hpp

@@ -27,10 +27,15 @@ namespace Debug {
     inline bool            disableStdout = false;
     inline bool            trace         = false;
     inline bool            shuttingDown  = false;
+    inline int64_t* const* coloredLogs   = nullptr;
 
     inline std::string     rollingLog = ""; // rolling log contains the ROLLING_LOG_SIZE tail of the log
 
     void                   init(const std::string& IS);
+
+    //
+    void log(LogLevel level, std::string str);
+
     template <typename... Args>
     void log(LogLevel level, std::format_string<Args...> fmt, Args&&... args) {
         if (level == TRACE && !trace)
@@ -41,16 +46,6 @@ namespace Debug {
 
         std::string logMsg = "";
 
-        switch (level) {
-            case LOG: logMsg += "[LOG] "; break;
-            case WARN: logMsg += "[WARN] "; break;
-            case ERR: logMsg += "[ERR] "; break;
-            case CRIT: logMsg += "[CRITICAL] "; break;
-            case INFO: logMsg += "[INFO] "; break;
-            case TRACE: logMsg += "[TRACE] "; break;
-            default: break;
-        }
-
         // print date and time to the ofs
         if (disableTime && !**disableTime) {
 #ifndef _LIBCPP_VERSION
@@ -58,7 +53,6 @@ namespace Debug {
 #else
             auto c = std::chrono::hh_mm_ss{std::chrono::system_clock::now() - std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now())};
             logMsg += std::format("{:%H}:{:%M}:{:%S}", c.hours(), c.minutes(), c.subseconds());
-
 #endif
         }
 
@@ -69,22 +63,7 @@ namespace Debug {
         // 3. this is actually what std::format in stdlib does
         logMsg += std::vformat(fmt.get(), std::make_format_args(args...));
 
-        rollingLog += logMsg + "\n";
-        if (rollingLog.size() > ROLLING_LOG_SIZE)
-            rollingLog = rollingLog.substr(rollingLog.size() - ROLLING_LOG_SIZE);
-
-        if (!disableLogs || !**disableLogs) {
-            // log to a file
-            std::ofstream ofs;
-            ofs.open(logFile, std::ios::out | std::ios::app);
-            ofs << logMsg << "\n";
-
-            ofs.close();
-        }
-
-        // log it to the stdout too.
-        if (!disableStdout)
-            std::cout << logMsg << "\n";
+        log(level, logMsg);
     }
 
     void wlrLog(wlr_log_importance level, const char* fmt, va_list args);

src/defines.hpp

@@ -3,3 +3,16 @@
 #include "helpers/WLListener.hpp"
 #include "helpers/Color.hpp"
 #include "macros.hpp"
+
+class CWindow;
+class CLayerSurface;
+
+/* Shared pointer to a window */
+typedef SP<CWindow> PHLWINDOW;
+/* Weak pointer to a window */
+typedef WP<CWindow> PHLWINDOWREF;
+
+/* Shared pointer to a layer surface */
+typedef SP<CLayerSurface> PHLLS;
+/* Weak pointer to a layer surface */
+typedef WP<CLayerSurface> PHLLSREF;

src/desktop/Constraint.cpp

@@ -1,131 +0,0 @@
-#include "Constraint.hpp"
-#include "WLSurface.hpp"
-#include "../Compositor.hpp"
-
-CConstraint::CConstraint(wlr_pointer_constraint_v1* constraint, CWLSurface* owner) : m_pOwner(owner), m_pConstraint(constraint) {
-    RASSERT(!constraint->data, "CConstraint: attempted to duplicate ownership");
-
-    constraint->data = this;
-    initSignals();
-
-    m_vCursorPosOnActivate = g_pInputManager->getMouseCoordsInternal();
-
-    g_pInputManager->m_vConstraints.push_back(this);
-
-    if (g_pCompositor->m_pLastFocus == m_pOwner->wlr())
-        activate();
-}
-
-CConstraint::~CConstraint() {
-    std::erase(g_pInputManager->m_vConstraints, this);
-}
-
-static void onConstraintDestroy(void* owner, void* data) {
-    const auto CONSTRAINT = (CConstraint*)owner;
-    CONSTRAINT->onDestroy();
-}
-
-static void onConstraintSetRegion(void* owner, void* data) {
-    const auto CONSTRAINT = (CConstraint*)owner;
-    CONSTRAINT->onSetRegion();
-}
-
-void CConstraint::initSignals() {
-    hyprListener_setConstraintRegion.initCallback(&m_pConstraint->events.set_region, ::onConstraintSetRegion, this, "CConstraint");
-    hyprListener_destroyConstraint.initCallback(&m_pConstraint->events.destroy, ::onConstraintDestroy, this, "CConstraint");
-}
-
-void CConstraint::onDestroy() {
-    hyprListener_setConstraintRegion.removeCallback();
-    hyprListener_destroyConstraint.removeCallback();
-
-    if (active() && isLocked())
-        g_pCompositor->warpCursorTo(logicPositionHint(), true);
-
-    // this is us
-    m_pOwner->m_pConstraint.reset();
-}
-
-void CConstraint::onSetRegion() {
-    if (!m_bActive)
-        return;
-
-    m_rRegion.set(&m_pConstraint->region);
-    m_vPositionHint = m_rRegion.closestPoint(m_vPositionHint);
-    g_pInputManager->simulateMouseMovement(); // to warp the cursor if anything's amiss
-}
-
-void CConstraint::onCommit() {
-    if (!m_bActive)
-        return;
-
-    const auto COMMITTED = m_pConstraint->current.committed;
-
-    if (COMMITTED & WLR_POINTER_CONSTRAINT_V1_STATE_CURSOR_HINT) {
-        m_bHintSet      = true;
-        m_vPositionHint = {m_pConstraint->current.cursor_hint.x, m_pConstraint->current.cursor_hint.y};
-        g_pInputManager->simulateMouseMovement();
-    }
-
-    if (COMMITTED & WLR_POINTER_CONSTRAINT_V1_STATE_REGION)
-        onSetRegion();
-}
-
-CRegion CConstraint::logicConstraintRegion() {
-    CRegion    rg            = m_rRegion;
-    const auto SURFBOX       = m_pOwner->getSurfaceBoxGlobal();
-    const auto CONSTRAINTPOS = SURFBOX.has_value() ? SURFBOX->pos() : Vector2D{};
-    rg.translate(CONSTRAINTPOS);
-    return rg;
-}
-
-CWLSurface* CConstraint::owner() {
-    return m_pOwner;
-}
-
-bool CConstraint::isLocked() {
-    return m_pConstraint->type == WLR_POINTER_CONSTRAINT_V1_LOCKED;
-}
-
-Vector2D CConstraint::logicPositionHint() {
-    const auto SURFBOX       = m_pOwner->getSurfaceBoxGlobal();
-    const auto CONSTRAINTPOS = SURFBOX.has_value() ? SURFBOX->pos() : Vector2D{};
-
-    return m_bHintSet ? CONSTRAINTPOS + m_vPositionHint : m_vCursorPosOnActivate;
-}
-
-void CConstraint::deactivate() {
-    if (!m_bActive)
-        return;
-
-    m_bActive = false;
-
-    if (isLocked())
-        g_pCompositor->warpCursorTo(logicPositionHint(), true);
-
-    if (m_pConstraint->lifetime == ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ONESHOT)
-        m_bDead = true;
-
-    wlr_pointer_constraint_v1_send_deactivated(m_pConstraint);
-}
-
-void CConstraint::activate() {
-    if (m_bActive || m_bDead)
-        return;
-
-    m_bActive = true;
-
-    // TODO: hack, probably not a super duper great idea
-    if (g_pCompositor->m_sSeat.seat->pointer_state.focused_surface != m_pOwner->wlr()) {
-        const auto SURFBOX = m_pOwner->getSurfaceBoxGlobal();
-        const auto LOCAL   = SURFBOX.has_value() ? logicPositionHint() - SURFBOX->pos() : Vector2D{};
-        wlr_seat_pointer_enter(g_pCompositor->m_sSeat.seat, m_pOwner->wlr(), LOCAL.x, LOCAL.y);
-    }
-
-    g_pCompositor->warpCursorTo(logicPositionHint(), true);
-    wlr_pointer_constraint_v1_send_activated(m_pConstraint);
-}
-
-bool CConstraint::active() {
-    return m_bActive;
-}

src/desktop/Constraint.hpp

@@ -1,44 +0,0 @@
-#pragma once
-
-#include "../includes.hpp"
-#include "../helpers/Region.hpp"
-#include "../helpers/WLListener.hpp"
-
-class CWLSurface;
-
-class CConstraint {
-  public:
-    CConstraint(wlr_pointer_constraint_v1* constraint, CWLSurface* owner);
-    ~CConstraint();
-
-    void        onCommit();
-    void        onDestroy();
-    void        onSetRegion();
-    CRegion     logicConstraintRegion();
-    bool        isLocked();
-    Vector2D    logicPositionHint();
-
-    void        deactivate();
-    void        activate();
-    bool        active();
-
-    CWLSurface* owner();
-
-  private:
-    bool                       m_bActive = false;
-    CWLSurface*                m_pOwner  = nullptr;
-    wlr_pointer_constraint_v1* m_pConstraint;
-
-    CRegion                    m_rRegion;
-    bool                       m_bHintSet             = false;
-    Vector2D                   m_vPositionHint        = {-1, -1};
-    Vector2D                   m_vCursorPosOnActivate = {-1, -1};
-
-    // for oneshot constraints that have been activated once
-    bool m_bDead = false;
-
-    DYNLISTENER(destroyConstraint);
-    DYNLISTENER(setConstraintRegion);
-
-    void initSignals();
-};

src/desktop/LayerSurface.cpp

@@ -0,0 +1,589 @@
+#include "LayerSurface.hpp"
+#include "../Compositor.hpp"
+#include "../events/Events.hpp"
+
+void Events::listener_newLayerSurface(wl_listener* listener, void* data) {
+    const auto WLRLAYERSURFACE = (wlr_layer_surface_v1*)data;
+
+    if (!WLRLAYERSURFACE->output) {
+        const auto PMONITOR = g_pCompositor->getMonitorFromCursor();
+
+        if (!PMONITOR) {
+            Debug::log(ERR, "No monitor at cursor on new layer without a monitor. Ignoring.");
+            wlr_layer_surface_v1_destroy(WLRLAYERSURFACE);
+            return;
+        }
+
+        Debug::log(LOG, "New LayerSurface has no preferred monitor. Assigning Monitor {}", PMONITOR->szName);
+
+        WLRLAYERSURFACE->output = PMONITOR->output;
+    }
+
+    auto PMONITOR = g_pCompositor->getMonitorFromOutput(WLRLAYERSURFACE->output);
+
+    if (!WLRLAYERSURFACE->output || !PMONITOR || PMONITOR->pMirrorOf) {
+        PMONITOR                = g_pCompositor->m_vMonitors.front().get();
+        WLRLAYERSURFACE->output = PMONITOR->output; // TODO: current mon
+    }
+
+    const auto PLS = PMONITOR->m_aLayerSurfaceLayers[WLRLAYERSURFACE->pending.layer].emplace_back(CLayerSurface::create(WLRLAYERSURFACE));
+
+    Debug::log(LOG, "LayerSurface {:x} (namespace {} layer {}) created on monitor {}", (uintptr_t)WLRLAYERSURFACE, WLRLAYERSURFACE->_namespace, (int)PLS->layer, PMONITOR->szName);
+}
+
+static void onCommit(void* owner, void* data) {
+    const auto LS = ((CLayerSurface*)owner)->self.lock();
+
+    LS->onCommit();
+}
+
+static void onMap(void* owner, void* data) {
+    const auto LS = ((CLayerSurface*)owner)->self.lock();
+
+    LS->onMap();
+}
+
+static void onUnmap(void* owner, void* data) {
+    const auto LS = ((CLayerSurface*)owner)->self.lock();
+
+    LS->onUnmap();
+}
+
+static void onDestroy(void* owner, void* data) {
+    const auto LS = ((CLayerSurface*)owner)->self.lock();
+
+    LS->onDestroy();
+}
+
+// IMPL
+
+PHLLS CLayerSurface::create(wlr_layer_surface_v1* pWLRLS) {
+    PHLLS pLS = std::shared_ptr<CLayerSurface>(new CLayerSurface);
+
+    auto  PMONITOR = g_pCompositor->getMonitorFromOutput(pWLRLS->output);
+
+    pLS->self = pLS;
+
+    pLS->szNamespace = pWLRLS->_namespace;
+
+    pLS->hyprListener_commitLayerSurface.initCallback(&pWLRLS->surface->events.commit, ::onCommit, pLS.get(), "layerSurface");
+    pLS->hyprListener_destroyLayerSurface.initCallback(&pWLRLS->events.destroy, ::onDestroy, pLS.get(), "layerSurface");
+    pLS->hyprListener_mapLayerSurface.initCallback(&pWLRLS->surface->events.map, ::onMap, pLS.get(), "layerSurface");
+    pLS->hyprListener_unmapLayerSurface.initCallback(&pWLRLS->surface->events.unmap, ::onUnmap, pLS.get(), "layerSurface");
+
+    pLS->layerSurface = pWLRLS;
+    pLS->layer        = pWLRLS->current.layer;
+    pWLRLS->data      = pLS.get();
+    pLS->monitorID    = PMONITOR->ID;
+    pLS->popupHead    = std::make_unique<CPopup>(pLS);
+
+    pLS->forceBlur = g_pConfigManager->shouldBlurLS(pLS->szNamespace);
+
+    pLS->alpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn"), pLS, AVARDAMAGE_ENTIRE);
+    pLS->realPosition.create(g_pConfigManager->getAnimationPropertyConfig("layersIn"), pLS, AVARDAMAGE_ENTIRE);
+    pLS->realSize.create(g_pConfigManager->getAnimationPropertyConfig("layersIn"), pLS, AVARDAMAGE_ENTIRE);
+    pLS->alpha.registerVar();
+    pLS->realPosition.registerVar();
+    pLS->realSize.registerVar();
+
+    pLS->registerCallbacks();
+
+    pLS->alpha.setValueAndWarp(0.f);
+
+    pLS->surface.assign(pWLRLS->surface);
+
+    return pLS;
+}
+
+void CLayerSurface::registerCallbacks() {
+    alpha.setUpdateCallback([this](void*) {
+        if (dimAround)
+            g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(monitorID));
+    });
+}
+
+CLayerSurface::CLayerSurface() {
+    ;
+}
+
+CLayerSurface::~CLayerSurface() {
+    if (!g_pHyprOpenGL)
+        return;
+
+    surface.unassign();
+    g_pHyprRenderer->makeEGLCurrent();
+    std::erase_if(g_pHyprOpenGL->m_mLayerFramebuffers, [&](const auto& other) { return other.first.expired() || other.first.lock() == self.lock(); });
+}
+
+void CLayerSurface::onDestroy() {
+    Debug::log(LOG, "LayerSurface {:x} destroyed", (uintptr_t)layerSurface);
+
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(monitorID);
+
+    popupHead.reset();
+
+    if (!g_pCompositor->getMonitorFromID(monitorID))
+        Debug::log(WARN, "Layersurface destroyed on an invalid monitor (removed?)");
+
+    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.");
+            alpha.setValueAndWarp(0.f);
+            fadingOut = true;
+            g_pCompositor->addToFadingOutSafe(self.lock());
+        }
+    }
+
+    noProcess = true;
+
+    hyprListener_commitLayerSurface.removeCallback();
+    hyprListener_destroyLayerSurface.removeCallback();
+    hyprListener_mapLayerSurface.removeCallback();
+    hyprListener_unmapLayerSurface.removeCallback();
+
+    // rearrange to fix the reserved areas
+    if (PMONITOR) {
+        g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
+        PMONITOR->scheduledRecalc = true;
+
+        // and damage
+        CBox geomFixed = {geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y, geometry.width, geometry.height};
+        g_pHyprRenderer->damageBox(&geomFixed);
+    }
+
+    readyToDelete = true;
+    layerSurface  = nullptr;
+    surface.unassign();
+}
+
+void CLayerSurface::onMap() {
+    Debug::log(LOG, "LayerSurface {:x} mapped", (uintptr_t)layerSurface);
+
+    mapped            = true;
+    keyboardExclusive = layerSurface->current.keyboard_interactive;
+
+    // fix if it changed its mon
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(monitorID);
+
+    if (!PMONITOR)
+        return;
+
+    applyRules();
+
+    if ((uint64_t)monitorID != PMONITOR->ID) {
+        const auto POLDMON = g_pCompositor->getMonitorFromID(monitorID);
+        for (auto it = POLDMON->m_aLayerSurfaceLayers[layer].begin(); it != POLDMON->m_aLayerSurfaceLayers[layer].end(); it++) {
+            if (*it == self.lock()) {
+                PMONITOR->m_aLayerSurfaceLayers[layer].emplace_back(std::move(*it));
+                POLDMON->m_aLayerSurfaceLayers[layer].erase(it);
+                break;
+            }
+        }
+        monitorID                 = PMONITOR->ID;
+        PMONITOR->scheduledRecalc = true;
+        g_pHyprRenderer->arrangeLayersForMonitor(POLDMON->ID);
+    }
+
+    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
+
+    wlr_surface_send_enter(surface.wlr(), PMONITOR->output);
+
+    if (layerSurface->current.keyboard_interactive == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE)
+        g_pInputManager->m_dExclusiveLSes.push_back(self);
+
+    const bool GRABSFOCUS = layerSurface->current.keyboard_interactive != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE &&
+        // don't focus if constrained
+        (g_pCompositor->m_sSeat.mouse.expired() || !g_pInputManager->isConstrained());
+
+    if (GRABSFOCUS) {
+        g_pInputManager->releaseAllMouseButtons();
+        g_pCompositor->focusSurface(surface.wlr());
+
+        const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y);
+        wlr_seat_pointer_notify_enter(g_pCompositor->m_sSeat.seat, surface.wlr(), LOCAL.x, LOCAL.y);
+        wlr_seat_pointer_notify_motion(g_pCompositor->m_sSeat.seat, 0, LOCAL.x, LOCAL.y);
+        g_pInputManager->m_bEmptyFocusCursorSet = false;
+    }
+
+    position = Vector2D(geometry.x, geometry.y);
+
+    CBox geomFixed = {geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y, geometry.width, geometry.height};
+    g_pHyprRenderer->damageBox(&geomFixed);
+    const auto WORKSPACE  = PMONITOR->activeWorkspace;
+    const bool FULLSCREEN = WORKSPACE->m_bHasFullscreenWindow && WORKSPACE->m_efFullscreenMode == FULLSCREEN_FULL;
+
+    startAnimation(!(layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP && FULLSCREEN && !GRABSFOCUS));
+    readyToDelete = false;
+    fadingOut     = false;
+
+    g_pEventManager->postEvent(SHyprIPCEvent{"openlayer", szNamespace});
+    EMIT_HOOK_EVENT("openLayer", self.lock());
+
+    g_pCompositor->setPreferredScaleForSurface(surface.wlr(), PMONITOR->scale);
+    g_pCompositor->setPreferredTransformForSurface(surface.wlr(), PMONITOR->transform);
+}
+
+void CLayerSurface::onUnmap() {
+    Debug::log(LOG, "LayerSurface {:x} unmapped", (uintptr_t)layerSurface);
+
+    g_pEventManager->postEvent(SHyprIPCEvent{"closelayer", std::string(layerSurface->_namespace ? layerSurface->_namespace : "")});
+    EMIT_HOOK_EVENT("closeLayer", self.lock());
+
+    std::erase_if(g_pInputManager->m_dExclusiveLSes, [this](const auto& other) { return !other.lock() || other.lock() == self.lock(); });
+
+    if (!g_pInputManager->m_dExclusiveLSes.empty())
+        g_pCompositor->focusSurface(g_pInputManager->m_dExclusiveLSes[0].lock()->layerSurface->surface);
+
+    if (!g_pCompositor->getMonitorFromID(monitorID) || g_pCompositor->m_bUnsafeState) {
+        Debug::log(WARN, "Layersurface unmapping on invalid monitor (removed?) ignoring.");
+
+        g_pCompositor->addToFadingOutSafe(self.lock());
+
+        mapped = false;
+
+        startAnimation(false);
+        return;
+    }
+
+    // make a snapshot and start fade
+    g_pHyprOpenGL->makeLayerSnapshot(self.lock());
+
+    startAnimation(false);
+
+    mapped = false;
+
+    g_pCompositor->addToFadingOutSafe(self.lock());
+
+    const auto PMONITOR = g_pCompositor->getMonitorFromOutput(layerSurface->output);
+
+    const bool WASLASTFOCUS = g_pCompositor->m_pLastFocus == layerSurface->surface;
+
+    surface = nullptr;
+
+    if (!PMONITOR)
+        return;
+
+    // refocus if needed
+    if (WASLASTFOCUS) {
+        g_pInputManager->releaseAllMouseButtons();
+
+        Vector2D     surfaceCoords;
+        PHLLS        pFoundLayerSurface;
+        wlr_surface* foundSurface = nullptr;
+
+        g_pCompositor->m_pLastFocus = nullptr;
+
+        // find LS-es to focus
+        foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
+                                                           &surfaceCoords, &pFoundLayerSurface);
+
+        if (!foundSurface)
+            foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
+                                                               &surfaceCoords, &pFoundLayerSurface);
+
+        if (!foundSurface && g_pCompositor->m_pLastWindow.lock() && g_pCompositor->isWorkspaceVisible(g_pCompositor->m_pLastWindow.lock()->m_pWorkspace)) {
+            // if there isn't any, focus the last window
+            const auto PLASTWINDOW = g_pCompositor->m_pLastWindow.lock();
+            g_pCompositor->focusWindow(nullptr);
+            g_pCompositor->focusWindow(PLASTWINDOW);
+        } else {
+            // otherwise, full refocus
+            g_pInputManager->refocus();
+        }
+    }
+
+    CBox geomFixed = {geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y, geometry.width, geometry.height};
+    g_pHyprRenderer->damageBox(&geomFixed);
+
+    geomFixed = {geometry.x + (int)PMONITOR->vecPosition.x, geometry.y + (int)PMONITOR->vecPosition.y, (int)layerSurface->surface->current.width,
+                 (int)layerSurface->surface->current.height};
+    g_pHyprRenderer->damageBox(&geomFixed);
+
+    g_pInputManager->sendMotionEventsToFocused();
+}
+
+void CLayerSurface::onCommit() {
+    if (!layerSurface || !layerSurface->output)
+        return;
+
+    const auto PMONITOR = g_pCompositor->getMonitorFromOutput(layerSurface->output);
+
+    if (!PMONITOR)
+        return;
+
+    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 = {geometry.x, geometry.y, geometry.width, geometry.height};
+    g_pHyprRenderer->damageBox(&geomFixed);
+
+    // fix if it changed its mon
+    if ((uint64_t)monitorID != PMONITOR->ID) {
+        const auto POLDMON = g_pCompositor->getMonitorFromID(monitorID);
+
+        for (auto it = POLDMON->m_aLayerSurfaceLayers[layer].begin(); it != POLDMON->m_aLayerSurfaceLayers[layer].end(); it++) {
+            if (*it == self.lock()) {
+                PMONITOR->m_aLayerSurfaceLayers[layer].emplace_back(std::move(*it));
+                POLDMON->m_aLayerSurfaceLayers[layer].erase(it);
+                break;
+            }
+        }
+
+        monitorID                 = PMONITOR->ID;
+        PMONITOR->scheduledRecalc = true;
+        g_pHyprRenderer->arrangeLayersForMonitor(POLDMON->ID);
+    }
+
+    if (layerSurface->current.committed != 0) {
+        if (layer != layerSurface->current.layer) {
+
+            for (auto it = PMONITOR->m_aLayerSurfaceLayers[layer].begin(); it != PMONITOR->m_aLayerSurfaceLayers[layer].end(); it++) {
+                if (*it == self.lock()) {
+                    PMONITOR->m_aLayerSurfaceLayers[layerSurface->current.layer].emplace_back(std::move(*it));
+                    PMONITOR->m_aLayerSurfaceLayers[layer].erase(it);
+                    break;
+                }
+            }
+
+            layer = layerSurface->current.layer;
+
+            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->ID);
+
+        PMONITOR->scheduledRecalc = true;
+    } else {
+        position = Vector2D(geometry.x, geometry.y);
+
+        // update geom if it changed
+        if (layerSurface->surface->current.scale == 1 && PMONITOR->scale != 1.f && layerSurface->surface->current.viewport.has_dst) {
+            // fractional scaling. Dirty hack.
+            geometry = {geometry.x, geometry.y, (int)(layerSurface->surface->current.viewport.dst_width), (int)(layerSurface->surface->current.viewport.dst_height)};
+        } else {
+            // this is because some apps like e.g. rofi-lbonn can't fucking use the protocol correctly.
+            geometry = {geometry.x, geometry.y, (int)layerSurface->surface->current.width, (int)layerSurface->surface->current.height};
+        }
+    }
+
+    if (realPosition.goal() != geometry.pos()) {
+        if (realPosition.isBeingAnimated())
+            realPosition = geometry.pos();
+        else
+            realPosition.setValueAndWarp(geometry.pos());
+    }
+    if (realSize.goal() != geometry.size()) {
+        if (realSize.isBeingAnimated())
+            realSize = geometry.size();
+        else
+            realSize.setValueAndWarp(geometry.size());
+    }
+
+    if (layerSurface->current.keyboard_interactive && (g_pCompositor->m_sSeat.mouse.expired() || !g_pInputManager->isConstrained()) // don't focus if constrained
+        && !keyboardExclusive && mapped) {
+        g_pCompositor->focusSurface(layerSurface->surface);
+
+        const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(geometry.x + PMONITOR->vecPosition.x, geometry.y + PMONITOR->vecPosition.y);
+        wlr_seat_pointer_notify_enter(g_pCompositor->m_sSeat.seat, layerSurface->surface, LOCAL.x, LOCAL.y);
+        wlr_seat_pointer_notify_motion(g_pCompositor->m_sSeat.seat, 0, LOCAL.x, LOCAL.y);
+        g_pInputManager->m_bEmptyFocusCursorSet = false;
+    } else if (!layerSurface->current.keyboard_interactive && (g_pCompositor->m_sSeat.mouse.expired() || !g_pInputManager->isConstrained()) && keyboardExclusive) {
+        g_pInputManager->refocus();
+    }
+
+    keyboardExclusive = layerSurface->current.keyboard_interactive;
+
+    g_pHyprRenderer->damageSurface(layerSurface->surface, position.x, position.y);
+
+    g_pCompositor->setPreferredScaleForSurface(layerSurface->surface, PMONITOR->scale);
+    g_pCompositor->setPreferredTransformForSurface(layerSurface->surface, PMONITOR->transform);
+}
+
+void CLayerSurface::applyRules() {
+    noAnimations     = false;
+    forceBlur        = false;
+    ignoreAlpha      = false;
+    ignoreAlphaValue = 0.f;
+    dimAround        = false;
+    xray             = -1;
+    animationStyle.reset();
+
+    for (auto& rule : g_pConfigManager->getMatchingRules(self.lock())) {
+        if (rule.rule == "noanim")
+            noAnimations = true;
+        else if (rule.rule == "blur")
+            forceBlur = true;
+        else if (rule.rule == "blurpopups")
+            forceBlurPopups = true;
+        else if (rule.rule.starts_with("ignorealpha") || rule.rule.starts_with("ignorezero")) {
+            const auto  FIRST_SPACE_POS = rule.rule.find_first_of(' ');
+            std::string alphaValue      = "";
+            if (FIRST_SPACE_POS != std::string::npos)
+                alphaValue = rule.rule.substr(FIRST_SPACE_POS + 1);
+
+            try {
+                ignoreAlpha = true;
+                if (!alphaValue.empty())
+                    ignoreAlphaValue = std::stof(alphaValue);
+            } catch (...) { Debug::log(ERR, "Invalid value passed to ignoreAlpha"); }
+        } else if (rule.rule == "dimaround") {
+            dimAround = true;
+        } else if (rule.rule.starts_with("xray")) {
+            CVarList vars{rule.rule, 0, ' '};
+            try {
+                xray = configStringToInt(vars[1]);
+            } catch (...) {}
+        } else if (rule.rule.starts_with("animation")) {
+            CVarList vars{rule.rule, 2, 's'};
+            animationStyle = vars[1];
+        }
+    }
+}
+
+void CLayerSurface::startAnimation(bool in, bool instant) {
+    const auto ANIMSTYLE = animationStyle.value_or(realPosition.m_pConfig->pValues->internalStyle);
+    if (in) {
+        realPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("layersIn");
+        realSize.m_pConfig     = g_pConfigManager->getAnimationPropertyConfig("layersIn");
+        alpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn");
+    } else {
+        realPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("layersOut");
+        realSize.m_pConfig     = g_pConfigManager->getAnimationPropertyConfig("layersOut");
+        alpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig("fadeLayersOut");
+    }
+
+    if (ANIMSTYLE.starts_with("slide")) {
+        // get closest edge
+        const auto MIDDLE = geometry.middle();
+
+        const auto PMONITOR = g_pCompositor->getMonitorFromVector(MIDDLE);
+
+        int        force = -1;
+
+        CVarList   args(ANIMSTYLE, 0, 's');
+        if (args.size() > 1) {
+            const auto ARG2 = args[1];
+            if (ARG2 == "top")
+                force = 0;
+            else if (ARG2 == "bottom")
+                force = 1;
+            else if (ARG2 == "left")
+                force = 2;
+            else if (ARG2 == "right")
+                force = 3;
+        }
+
+        const std::array<Vector2D, 4> edgePoints = {
+            PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x / 2, 0},
+            PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x / 2, PMONITOR->vecSize.y},
+            PMONITOR->vecPosition + Vector2D{0, PMONITOR->vecSize.y},
+            PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x, PMONITOR->vecSize.y / 2},
+        };
+
+        float closest = std::numeric_limits<float>::max();
+        int   leader  = force;
+        if (leader == -1) {
+            for (size_t i = 0; i < 4; ++i) {
+                float dist = MIDDLE.distance(edgePoints[i]);
+                if (dist < closest) {
+                    leader  = i;
+                    closest = dist;
+                }
+            }
+        }
+
+        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 = {geometry.x, PMONITOR->vecPosition.y - geometry.h};
+                break;
+            case 1:
+                // BOTTOM
+                prePos = {geometry.x, PMONITOR->vecPosition.y + PMONITOR->vecSize.y};
+                break;
+            case 2:
+                // LEFT
+                prePos = {PMONITOR->vecPosition.x - geometry.w, geometry.y};
+                break;
+            case 3:
+                // RIGHT
+                prePos = {PMONITOR->vecPosition.x + PMONITOR->vecSize.x, geometry.y};
+                break;
+            default: UNREACHABLE();
+        }
+
+        if (in) {
+            realPosition.setValueAndWarp(prePos);
+            realPosition = geometry.pos();
+        } else {
+            realPosition.setValueAndWarp(geometry.pos());
+            realPosition = prePos;
+        }
+
+    } else if (ANIMSTYLE.starts_with("popin")) {
+        float minPerc = 0.f;
+        if (ANIMSTYLE.find("%") != std::string::npos) {
+            try {
+                auto percstr = ANIMSTYLE.substr(ANIMSTYLE.find_last_of(' '));
+                minPerc      = std::stoi(percstr.substr(0, percstr.length() - 1));
+            } catch (std::exception& e) {
+                ; // oops
+            }
+        }
+
+        minPerc *= 0.01;
+
+        const auto GOALSIZE = (geometry.size() * minPerc).clamp({5, 5});
+        const auto GOALPOS  = geometry.pos() + (geometry.size() - GOALSIZE) / 2.f;
+
+        alpha.setValueAndWarp(in ? 0.f : 1.f);
+        alpha = in ? 1.f : 0.f;
+
+        if (in) {
+            realSize.setValueAndWarp(GOALSIZE);
+            realPosition.setValueAndWarp(GOALPOS);
+            realSize     = geometry.size();
+            realPosition = geometry.pos();
+        } else {
+            realSize.setValueAndWarp(geometry.size());
+            realPosition.setValueAndWarp(geometry.pos());
+            realSize     = GOALSIZE;
+            realPosition = GOALPOS;
+        }
+    } else {
+        // fade
+        realPosition.setValueAndWarp(geometry.pos());
+        realSize.setValueAndWarp(geometry.size());
+        alpha = in ? 1.f : 0.f;
+    }
+
+    if (!in)
+        fadingOut = true;
+}
+
+bool CLayerSurface::isFadedOut() {
+    if (!fadingOut)
+        return false;
+
+    return !realPosition.isBeingAnimated() && !realSize.isBeingAnimated() && !alpha.isBeingAnimated();
+}
+
+int CLayerSurface::popupsCount() {
+    if (!layerSurface || !mapped || fadingOut)
+        return 0;
+
+    int no = 0;
+    wlr_layer_surface_v1_for_each_popup_surface(
+        layerSurface, [](wlr_surface* s, int x, int y, void* data) { *(int*)data += 1; }, &no);
+    return no;
+}

src/desktop/LayerSurface.hpp

@@ -0,0 +1,85 @@
+#pragma once
+
+#include <string>
+#include "../defines.hpp"
+#include "WLSurface.hpp"
+#include "../helpers/AnimatedVariable.hpp"
+#include "wlr-layer-shell-unstable-v1-protocol.h"
+
+struct SLayerRule {
+    std::string targetNamespace = "";
+    std::string rule            = "";
+};
+
+class CLayerSurface {
+  public:
+    static PHLLS create(wlr_layer_surface_v1*);
+
+  private:
+    CLayerSurface();
+
+  public:
+    ~CLayerSurface();
+
+    void                        applyRules();
+    void                        startAnimation(bool in, bool instant = false);
+    bool                        isFadedOut();
+    int                         popupsCount();
+
+    CAnimatedVariable<Vector2D> realPosition;
+    CAnimatedVariable<Vector2D> realSize;
+    CAnimatedVariable<float>    alpha;
+
+    wlr_layer_surface_v1*       layerSurface;
+    wl_list                     link;
+
+    bool                        keyboardExclusive = false;
+
+    CWLSurface                  surface;
+
+    bool                        mapped = false;
+
+    int                         monitorID = -1;
+
+    bool                        fadingOut     = false;
+    bool                        readyToDelete = false;
+    bool                        noProcess     = false;
+    bool                        noAnimations  = false;
+
+    bool                        forceBlur        = false;
+    bool                        forceBlurPopups  = false;
+    int                         xray             = -1;
+    bool                        ignoreAlpha      = false;
+    float                       ignoreAlphaValue = 0.f;
+    bool                        dimAround        = false;
+
+    std::optional<std::string>  animationStyle;
+
+    zwlr_layer_shell_v1_layer   layer;
+
+    PHLLSREF                    self;
+
+    CBox                        geometry = {0, 0, 0, 0};
+    Vector2D                    position;
+    std::string                 szNamespace = "";
+
+    void                        onDestroy();
+    void                        onMap();
+    void                        onUnmap();
+    void                        onCommit();
+
+  private:
+    std::unique_ptr<CPopup> popupHead;
+
+    DYNLISTENER(destroyLayerSurface);
+    DYNLISTENER(mapLayerSurface);
+    DYNLISTENER(unmapLayerSurface);
+    DYNLISTENER(commitLayerSurface);
+
+    void registerCallbacks();
+
+    // For the list lookup
+    bool operator==(const CLayerSurface& rhs) const {
+        return layerSurface == rhs.layerSurface && monitorID == rhs.monitorID;
+    }
+};

src/desktop/Popup.cpp

@@ -2,11 +2,11 @@
 #include "../config/ConfigValue.hpp"
 #include "../Compositor.hpp"
 
-CPopup::CPopup(CWindow* pOwner) : m_pWindowOwner(pOwner) {
+CPopup::CPopup(PHLWINDOW pOwner) : m_pWindowOwner(pOwner) {
     initAllSignals();
 }
 
-CPopup::CPopup(SLayerSurface* pOwner) : m_pLayerOwner(pOwner) {
+CPopup::CPopup(PHLLS pOwner) : m_pLayerOwner(pOwner) {
     initAllSignals();
 }
 
@@ -69,8 +69,8 @@ static void onRepositionPopup(void* owner, void* data) {
 void CPopup::initAllSignals() {
 
     if (!m_pWLR) {
-        if (m_pWindowOwner)
-            hyprListener_newPopup.initCallback(&m_pWindowOwner->m_uSurface.xdg->events.new_popup, ::onNewPopup, this, "CPopup Head");
+        if (!m_pWindowOwner.expired())
+            hyprListener_newPopup.initCallback(&m_pWindowOwner.lock()->m_uSurface.xdg->events.new_popup, ::onNewPopup, this, "CPopup Head");
         else if (m_pLayerOwner)
             hyprListener_newPopup.initCallback(&m_pLayerOwner->layerSurface->events.new_popup, ::onNewPopup, this, "CPopup Head");
         else
@@ -146,12 +146,12 @@ void CPopup::onCommit(bool ignoreSiblings) {
         return;
     }
 
-    if (m_pWindowOwner && (!m_pWindowOwner->m_bIsMapped || !m_pWindowOwner->m_pWorkspace->m_bVisible)) {
+    if (!m_pWindowOwner.expired() && (!m_pWindowOwner.lock()->m_bIsMapped || !m_pWindowOwner.lock()->m_pWorkspace->m_bVisible)) {
         m_vLastSize = {m_pWLR->base->current.geometry.width, m_pWLR->base->current.geometry.height};
 
         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_pWindowOwner);
+            Debug::log(LOG, "Refusing to commit damage from a subsurface of {} because it's invisible.", m_pWindowOwner.lock());
         return;
     }
 
@@ -230,8 +230,8 @@ Vector2D CPopup::localToGlobal(const Vector2D& rel) {
 }
 
 Vector2D CPopup::t1ParentCoords() {
-    if (m_pWindowOwner)
-        return m_pWindowOwner->m_vRealPosition.value();
+    if (!m_pWindowOwner.expired())
+        return m_pWindowOwner.lock()->m_vRealPosition.value();
     if (m_pLayerOwner)
         return m_pLayerOwner->realPosition.value();
 
@@ -260,8 +260,8 @@ Vector2D CPopup::size() {
 }
 
 void CPopup::sendScale() {
-    if (m_pWindowOwner)
-        g_pCompositor->setPreferredScaleForSurface(m_sWLSurface.wlr(), m_pWindowOwner->m_pWLSurface.m_fLastScale);
+    if (!m_pWindowOwner.expired())
+        g_pCompositor->setPreferredScaleForSurface(m_sWLSurface.wlr(), m_pWindowOwner.lock()->m_pWLSurface.m_fLastScale);
     else if (m_pLayerOwner)
         g_pCompositor->setPreferredScaleForSurface(m_sWLSurface.wlr(), m_pLayerOwner->surface.m_fLastScale);
     else

src/desktop/Popup.hpp

@@ -4,13 +4,11 @@
 #include <memory>
 #include "Subsurface.hpp"
 
-struct SLayerSurface;
-
 class CPopup {
   public:
     // dummy head nodes
-    CPopup(CWindow* pOwner);
-    CPopup(SLayerSurface* pOwner);
+    CPopup(PHLWINDOW pOwner);
+    CPopup(PHLLS pOwner);
 
     // real nodes
     CPopup(wlr_xdg_popup* popup, CPopup* pOwner);
@@ -35,8 +33,8 @@ class CPopup {
 
   private:
     // T1 owners, each popup has to have one of these
-    CWindow*       m_pWindowOwner = nullptr;
-    SLayerSurface* m_pLayerOwner  = nullptr;
+    PHLWINDOWREF m_pWindowOwner;
+    PHLLS        m_pLayerOwner;
 
     // T2 owners
     CPopup*        m_pParent = nullptr;

src/desktop/Subsurface.cpp

@@ -5,7 +5,7 @@
 
 static void onNewSubsurface(void* owner, void* data);
 
-CSubsurface::CSubsurface(CWindow* pOwner) : m_pWindowParent(pOwner) {
+CSubsurface::CSubsurface(PHLWINDOW pOwner) : m_pWindowParent(pOwner) {
     initSignals();
     initExistingSubsurfaces(pOwner->m_pWLSurface.wlr());
 }
@@ -15,7 +15,7 @@ CSubsurface::CSubsurface(CPopup* pOwner) : m_pPopupParent(pOwner) {
     initExistingSubsurfaces(pOwner->m_sWLSurface.wlr());
 }
 
-CSubsurface::CSubsurface(wlr_subsurface* pSubsurface, CWindow* pOwner) : m_pSubsurface(pSubsurface), m_pWindowParent(pOwner) {
+CSubsurface::CSubsurface(wlr_subsurface* pSubsurface, PHLWINDOW pOwner) : m_pSubsurface(pSubsurface), m_pWindowParent(pOwner) {
     m_sWLSurface.assign(pSubsurface->surface, this);
     initSignals();
     initExistingSubsurfaces(pSubsurface->surface);
@@ -73,8 +73,8 @@ void CSubsurface::initSignals() {
         hyprListener_mapSubsurface.initCallback(&m_pSubsurface->surface->events.map, &onMapSubsurface, this, "CSubsurface");
         hyprListener_unmapSubsurface.initCallback(&m_pSubsurface->surface->events.unmap, &onUnmapSubsurface, this, "CSubsurface");
     } else {
-        if (m_pWindowParent)
-            hyprListener_newSubsurface.initCallback(&m_pWindowParent->m_pWLSurface.wlr()->events.new_subsurface, &::onNewSubsurface, this, "CSubsurface Head");
+        if (!m_pWindowParent.expired())
+            hyprListener_newSubsurface.initCallback(&m_pWindowParent.lock()->m_pWLSurface.wlr()->events.new_subsurface, &::onNewSubsurface, this, "CSubsurface Head");
         else if (m_pPopupParent)
             hyprListener_newSubsurface.initCallback(&m_pPopupParent->m_sWLSurface.wlr()->events.new_subsurface, &::onNewSubsurface, this, "CSubsurface Head");
         else
@@ -86,7 +86,7 @@ void CSubsurface::checkSiblingDamage() {
     if (!m_pParent)
         return; // ??????????
 
-    const double SCALE = m_pWindowParent && m_pWindowParent->m_bIsX11 ? 1.0 / m_pWindowParent->m_fX11SurfaceScaledBy : 1.0;
+    const double SCALE = m_pWindowParent.lock() && m_pWindowParent.lock()->m_bIsX11 ? 1.0 / m_pWindowParent.lock()->m_fX11SurfaceScaledBy : 1.0;
 
     for (auto& n : m_pParent->m_vChildren) {
         if (n.get() == this)
@@ -106,12 +106,12 @@ void CSubsurface::recheckDamageForSubsurfaces() {
 
 void CSubsurface::onCommit() {
     // no damaging if it's not visible
-    if (m_pWindowParent && (!m_pWindowParent->m_bIsMapped || !m_pWindowParent->m_pWorkspace->m_bVisible)) {
+    if (!m_pWindowParent.expired() && (!m_pWindowParent.lock()->m_bIsMapped || !m_pWindowParent.lock()->m_pWorkspace->m_bVisible)) {
         m_vLastSize = Vector2D{m_sWLSurface.wlr()->current.width, m_sWLSurface.wlr()->current.height};
 
         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_pWindowParent);
+            Debug::log(LOG, "Refusing to commit damage from a subsurface of {} because it's invisible.", m_pWindowParent.lock());
         return;
     }
 
@@ -121,8 +121,8 @@ void CSubsurface::onCommit() {
 
     if (m_pPopupParent)
         m_pPopupParent->recheckTree();
-    if (m_pWindowParent) // I hate you firefox why are you doing this
-        m_pWindowParent->m_pPopupHead->recheckTree();
+    if (!m_pWindowParent.expired()) // I hate you firefox why are you doing this
+        m_pWindowParent.lock()->m_pPopupHead->recheckTree();
 
     // I do not think this is correct, but it solves a lot of issues with some apps (e.g. firefox)
     checkSiblingDamage();
@@ -152,8 +152,8 @@ void CSubsurface::onDestroy() {
 void CSubsurface::onNewSubsurface(wlr_subsurface* pSubsurface) {
     CSubsurface* PSUBSURFACE = nullptr;
 
-    if (m_pWindowParent)
-        PSUBSURFACE = m_vChildren.emplace_back(std::make_unique<CSubsurface>(pSubsurface, m_pWindowParent)).get();
+    if (!m_pWindowParent.expired())
+        PSUBSURFACE = m_vChildren.emplace_back(std::make_unique<CSubsurface>(pSubsurface, m_pWindowParent.lock())).get();
     else if (m_pPopupParent)
         PSUBSURFACE = m_vChildren.emplace_back(std::make_unique<CSubsurface>(pSubsurface, m_pPopupParent)).get();
     PSUBSURFACE->m_pParent = this;
@@ -169,8 +169,8 @@ void CSubsurface::onMap() {
     box.expand(4);
     g_pHyprRenderer->damageBox(&box);
 
-    if (m_pWindowParent)
-        m_pWindowParent->updateSurfaceScaleTransformDetails();
+    if (!m_pWindowParent.expired())
+        m_pWindowParent.lock()->updateSurfaceScaleTransformDetails();
 }
 
 void CSubsurface::onUnmap() {
@@ -206,8 +206,8 @@ Vector2D CSubsurface::coordsRelativeToParent() {
 Vector2D CSubsurface::coordsGlobal() {
     Vector2D coords = coordsRelativeToParent();
 
-    if (m_pWindowParent)
-        coords += m_pWindowParent->m_vRealPosition.value();
+    if (!m_pWindowParent.expired())
+        coords += m_pWindowParent.lock()->m_vRealPosition.value();
     else if (m_pPopupParent)
         coords += m_pPopupParent->coordsGlobal();
 

src/desktop/Subsurface.hpp

@@ -4,17 +4,16 @@
 #include <vector>
 #include "WLSurface.hpp"
 
-class CWindow;
 class CPopup;
 
 class CSubsurface {
   public:
     // root dummy nodes
-    CSubsurface(CWindow* pOwner);
+    CSubsurface(PHLWINDOW pOwner);
     CSubsurface(CPopup* pOwner);
 
     // real nodes
-    CSubsurface(wlr_subsurface* pSubsurface, CWindow* pOwner);
+    CSubsurface(wlr_subsurface* pSubsurface, PHLWINDOW pOwner);
     CSubsurface(wlr_subsurface* pSubsurface, CPopup* pOwner);
 
     ~CSubsurface();
@@ -46,8 +45,8 @@ class CSubsurface {
     // if nullptr, means it's a dummy node
     CSubsurface*                              m_pParent = nullptr;
 
-    CWindow*                                  m_pWindowParent = nullptr;
-    CPopup*                                   m_pPopupParent  = nullptr;
+    PHLWINDOWREF                              m_pWindowParent;
+    CPopup*                                   m_pPopupParent = nullptr;
 
     std::vector<std::unique_ptr<CSubsurface>> m_vChildren;
 

src/desktop/WLSurface.cpp

@@ -7,14 +7,14 @@ void CWLSurface::assign(wlr_surface* pSurface) {
     m_bInert = false;
 }
 
-void CWLSurface::assign(wlr_surface* pSurface, CWindow* pOwner) {
+void CWLSurface::assign(wlr_surface* pSurface, PHLWINDOW pOwner) {
     m_pWindowOwner = pOwner;
     m_pWLRSurface  = pSurface;
     init();
     m_bInert = false;
 }
 
-void CWLSurface::assign(wlr_surface* pSurface, SLayerSurface* pOwner) {
+void CWLSurface::assign(wlr_surface* pSurface, PHLLS pOwner) {
     m_pLayerOwner = pOwner;
     m_pWLRSurface = pSurface;
     init();
@@ -52,20 +52,22 @@ wlr_surface* CWLSurface::wlr() const {
 }
 
 bool CWLSurface::small() const {
-    if (!m_pWindowOwner || !exists())
+    if (!validMapped(m_pWindowOwner) || !exists())
         return false;
 
-    return m_pWindowOwner->m_vReportedSize.x > m_pWLRSurface->current.buffer_width + 1 || m_pWindowOwner->m_vReportedSize.y > m_pWLRSurface->current.buffer_height + 1;
+    const auto O = m_pWindowOwner.lock();
+
+    return O->m_vReportedSize.x > m_pWLRSurface->current.buffer_width + 1 || O->m_vReportedSize.y > m_pWLRSurface->current.buffer_height + 1;
 }
 
 Vector2D CWLSurface::correctSmallVec() const {
-    if (!m_pWindowOwner || !exists() || !small() || m_bFillIgnoreSmall)
+    if (!validMapped(m_pWindowOwner) || !exists() || !small() || m_bFillIgnoreSmall)
         return {};
 
     const auto SIZE = getViewporterCorrectedSize();
+    const auto O    = m_pWindowOwner.lock();
 
-    return Vector2D{(m_pWindowOwner->m_vReportedSize.x - SIZE.x) / 2, (m_pWindowOwner->m_vReportedSize.y - SIZE.y) / 2}.clamp({}, {INFINITY, INFINITY}) *
-        (m_pWindowOwner->m_vRealSize.value() / m_pWindowOwner->m_vReportedSize);
+    return Vector2D{(O->m_vReportedSize.x - SIZE.x) / 2, (O->m_vReportedSize.y - SIZE.y) / 2}.clamp({}, {INFINITY, INFINITY}) * (O->m_vRealSize.value() / O->m_vReportedSize);
 }
 
 Vector2D CWLSurface::getViewporterCorrectedSize() const {
@@ -103,16 +105,18 @@ void CWLSurface::destroy() {
     if (!m_pWLRSurface)
         return;
 
+    events.destroy.emit();
+
     m_pConstraint.reset();
 
     hyprListener_destroy.removeCallback();
     hyprListener_commit.removeCallback();
     m_pWLRSurface->data = nullptr;
-    m_pWindowOwner      = nullptr;
-    m_pLayerOwner       = nullptr;
-    m_pPopupOwner       = nullptr;
-    m_pSubsurfaceOwner  = nullptr;
-    m_bInert            = true;
+    m_pWindowOwner.reset();
+    m_pLayerOwner.reset();
+    m_pPopupOwner      = nullptr;
+    m_pSubsurfaceOwner = nullptr;
+    m_bInert           = true;
 
     if (g_pCompositor && g_pCompositor->m_pLastFocus == m_pWLRSurface)
         g_pCompositor->m_pLastFocus = nullptr;
@@ -146,12 +150,12 @@ void CWLSurface::init() {
     Debug::log(LOG, "CWLSurface {:x} called init()", (uintptr_t)this);
 }
 
-CWindow* CWLSurface::getWindow() {
-    return m_pWindowOwner;
+PHLWINDOW CWLSurface::getWindow() {
+    return m_pWindowOwner.lock();
 }
 
-SLayerSurface* CWLSurface::getLayer() {
-    return m_pLayerOwner;
+PHLLS CWLSurface::getLayer() {
+    return m_pLayerOwner.lock();
 }
 
 CPopup* CWLSurface::getPopup() {
@@ -163,17 +167,17 @@ CSubsurface* CWLSurface::getSubsurface() {
 }
 
 bool CWLSurface::desktopComponent() {
-    return m_pLayerOwner || m_pWindowOwner || m_pSubsurfaceOwner || m_pPopupOwner;
+    return !m_pLayerOwner.expired() || !m_pWindowOwner.expired() || m_pSubsurfaceOwner || m_pPopupOwner;
 }
 
 std::optional<CBox> CWLSurface::getSurfaceBoxGlobal() {
     if (!desktopComponent())
         return {};
 
-    if (m_pWindowOwner)
-        return m_pWindowOwner->getWindowMainSurfaceBox();
-    if (m_pLayerOwner)
-        return m_pLayerOwner->geometry;
+    if (!m_pWindowOwner.expired())
+        return m_pWindowOwner.lock()->getWindowMainSurfaceBox();
+    if (!m_pLayerOwner.expired())
+        return m_pLayerOwner.lock()->geometry;
     if (m_pPopupOwner)
         return CBox{m_pPopupOwner->coordsGlobal(), m_pPopupOwner->size()};
     if (m_pSubsurfaceOwner)
@@ -182,15 +186,14 @@ std::optional<CBox> CWLSurface::getSurfaceBoxGlobal() {
     return {};
 }
 
-void CWLSurface::appendConstraint(wlr_pointer_constraint_v1* constraint) {
-    m_pConstraint = std::make_unique<CConstraint>(constraint, this);
+void CWLSurface::appendConstraint(std::weak_ptr<CPointerConstraint> constraint) {
+    m_pConstraint = constraint;
 }
 
 void CWLSurface::onCommit() {
-    if (m_pConstraint)
-        m_pConstraint->onCommit();
+    ;
 }
 
-CConstraint* CWLSurface::constraint() {
-    return m_pConstraint.get();
+std::shared_ptr<CPointerConstraint> CWLSurface::constraint() {
+    return m_pConstraint.lock();
 }

src/desktop/WLSurface.hpp

@@ -2,12 +2,11 @@
 
 #include "../defines.hpp"
 #include "../helpers/Region.hpp"
-#include "Constraint.hpp"
+#include "../helpers/signal/Signal.hpp"
 
-class CWindow;
-struct SLayerSurface;
 class CSubsurface;
 class CPopup;
+class CPointerConstraint;
 
 class CWLSurface {
   public:
@@ -16,8 +15,8 @@ class CWLSurface {
 
     // anonymous surfaces are non-desktop components, e.g. a cursor surface or a DnD
     void assign(wlr_surface* pSurface);
-    void assign(wlr_surface* pSurface, CWindow* pOwner);
-    void assign(wlr_surface* pSurface, SLayerSurface* pOwner);
+    void assign(wlr_surface* pSurface, PHLWINDOW pOwner);
+    void assign(wlr_surface* pSurface, PHLLS pOwner);
     void assign(wlr_surface* pSurface, CSubsurface* pOwner);
     void assign(wlr_surface* pSurface, CPopup* pOwner);
     void unassign();
@@ -36,15 +35,15 @@ class CWLSurface {
     void         onCommit();
 
     // getters for owners.
-    CWindow*       getWindow();
-    SLayerSurface* getLayer();
-    CPopup*        getPopup();
-    CSubsurface*   getSubsurface();
+    PHLWINDOW    getWindow();
+    PHLLS        getLayer();
+    CPopup*      getPopup();
+    CSubsurface* getSubsurface();
 
     // desktop components misc utils
-    std::optional<CBox> getSurfaceBoxGlobal();
-    void                appendConstraint(wlr_pointer_constraint_v1* constraint);
-    CConstraint*        constraint();
+    std::optional<CBox>                 getSurfaceBoxGlobal();
+    void                                appendConstraint(std::weak_ptr<CPointerConstraint> constraint);
+    std::shared_ptr<CPointerConstraint> constraint();
 
     // allow stretching. Useful for plugins.
     bool m_bFillIgnoreSmall = false;
@@ -81,25 +80,32 @@ class CWLSurface {
         return (CWLSurface*)pSurface->data;
     }
 
+    // used by the alpha-modifier protocol
+    float m_pAlphaModifier = 1.F;
+
+    struct {
+        CSignal destroy;
+    } events;
+
   private:
-    bool           m_bInert = true;
+    bool         m_bInert = true;
 
-    wlr_surface*   m_pWLRSurface = nullptr;
+    wlr_surface* m_pWLRSurface = nullptr;
 
-    CWindow*       m_pWindowOwner     = nullptr;
-    SLayerSurface* m_pLayerOwner      = nullptr;
-    CPopup*        m_pPopupOwner      = nullptr;
-    CSubsurface*   m_pSubsurfaceOwner = nullptr;
+    PHLWINDOWREF m_pWindowOwner;
+    PHLLSREF     m_pLayerOwner;
+    CPopup*      m_pPopupOwner      = nullptr;
+    CSubsurface* m_pSubsurfaceOwner = nullptr;
 
     //
-    std::unique_ptr<CConstraint> m_pConstraint;
+    std::weak_ptr<CPointerConstraint> m_pConstraint;
 
-    void                         destroy();
-    void                         init();
-    bool                         desktopComponent();
+    void                              destroy();
+    void                              init();
+    bool                              desktopComponent();
 
     DYNLISTENER(destroy);
     DYNLISTENER(commit);
 
-    friend class CConstraint;
+    friend class CPointerConstraint;
 };

src/desktop/Window.cpp

@@ -5,32 +5,45 @@
 #include "../render/decorations/CHyprBorderDecoration.hpp"
 #include "../config/ConfigValue.hpp"
 #include <any>
+#include "../managers/TokenManager.hpp"
+
+PHLWINDOW CWindow::create() {
+    PHLWINDOW pWindow = std::shared_ptr<CWindow>(new CWindow);
+
+    pWindow->m_pSelf = pWindow;
+
+    pWindow->m_vRealPosition.create(g_pConfigManager->getAnimationPropertyConfig("windowsIn"), pWindow, AVARDAMAGE_ENTIRE);
+    pWindow->m_vRealSize.create(g_pConfigManager->getAnimationPropertyConfig("windowsIn"), pWindow, AVARDAMAGE_ENTIRE);
+    pWindow->m_fBorderFadeAnimationProgress.create(g_pConfigManager->getAnimationPropertyConfig("border"), pWindow, AVARDAMAGE_BORDER);
+    pWindow->m_fBorderAngleAnimationProgress.create(g_pConfigManager->getAnimationPropertyConfig("borderangle"), pWindow, AVARDAMAGE_BORDER);
+    pWindow->m_fAlpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
+    pWindow->m_fActiveInactiveAlpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeSwitch"), pWindow, AVARDAMAGE_ENTIRE);
+    pWindow->m_cRealShadowColor.create(g_pConfigManager->getAnimationPropertyConfig("fadeShadow"), pWindow, AVARDAMAGE_SHADOW);
+    pWindow->m_fDimPercent.create(g_pConfigManager->getAnimationPropertyConfig("fadeDim"), pWindow, AVARDAMAGE_ENTIRE);
+
+    pWindow->addWindowDeco(std::make_unique<CHyprDropShadowDecoration>(pWindow));
+    pWindow->addWindowDeco(std::make_unique<CHyprBorderDecoration>(pWindow));
+
+    return pWindow;
+}
 
 CWindow::CWindow() {
-    m_vRealPosition.create(g_pConfigManager->getAnimationPropertyConfig("windowsIn"), this, AVARDAMAGE_ENTIRE);
-    m_vRealSize.create(g_pConfigManager->getAnimationPropertyConfig("windowsIn"), this, AVARDAMAGE_ENTIRE);
-    m_fBorderFadeAnimationProgress.create(g_pConfigManager->getAnimationPropertyConfig("border"), this, AVARDAMAGE_BORDER);
-    m_fBorderAngleAnimationProgress.create(g_pConfigManager->getAnimationPropertyConfig("borderangle"), this, AVARDAMAGE_BORDER);
-    m_fAlpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeIn"), this, AVARDAMAGE_ENTIRE);
-    m_fActiveInactiveAlpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeSwitch"), this, AVARDAMAGE_ENTIRE);
-    m_cRealShadowColor.create(g_pConfigManager->getAnimationPropertyConfig("fadeShadow"), this, AVARDAMAGE_SHADOW);
-    m_fDimPercent.create(g_pConfigManager->getAnimationPropertyConfig("fadeDim"), this, AVARDAMAGE_ENTIRE);
-
-    addWindowDeco(std::make_unique<CHyprDropShadowDecoration>(this));
-    addWindowDeco(std::make_unique<CHyprBorderDecoration>(this));
+    ;
 }
 
 CWindow::~CWindow() {
-    if (g_pCompositor->isWindowActive(this)) {
-        g_pCompositor->m_pLastFocus  = nullptr;
-        g_pCompositor->m_pLastWindow = nullptr;
+    if (g_pCompositor->m_pLastWindow.lock().get() == this) {
+        g_pCompositor->m_pLastFocus = nullptr;
+        g_pCompositor->m_pLastWindow.reset();
     }
 
+    events.destroy.emit();
+
     if (!g_pHyprOpenGL)
         return;
 
     g_pHyprRenderer->makeEGLCurrent();
-    std::erase_if(g_pHyprOpenGL->m_mWindowFramebuffers, [&](const auto& other) { return other.first == this; });
+    std::erase_if(g_pHyprOpenGL->m_mWindowFramebuffers, [&](const auto& other) { return !other.first.lock() || other.first.lock().get() == this; });
 }
 
 SWindowDecorationExtents CWindow::getFullWindowExtents() {
@@ -47,7 +60,7 @@ SWindowDecorationExtents CWindow::getFullWindowExtents() {
 
     SWindowDecorationExtents maxExtents = {{BORDERSIZE + 2, BORDERSIZE + 2}, {BORDERSIZE + 2, BORDERSIZE + 2}};
 
-    const auto               EXTENTS = g_pDecorationPositioner->getWindowDecorationExtents(this);
+    const auto               EXTENTS = g_pDecorationPositioner->getWindowDecorationExtents(m_pSelf.lock());
 
     if (EXTENTS.topLeft.x > maxExtents.topLeft.x)
         maxExtents.topLeft.x = EXTENTS.topLeft.x;
@@ -150,11 +163,11 @@ CBox CWindow::getWindowBoxUnified(uint64_t properties) {
 
     SWindowDecorationExtents EXTENTS = {{0, 0}, {0, 0}};
     if (properties & RESERVED_EXTENTS)
-        EXTENTS.addExtents(g_pDecorationPositioner->getWindowDecorationReserved(this));
+        EXTENTS.addExtents(g_pDecorationPositioner->getWindowDecorationReserved(m_pSelf.lock()));
     if (properties & INPUT_EXTENTS)
-        EXTENTS.addExtents(g_pDecorationPositioner->getWindowDecorationExtents(this, true));
+        EXTENTS.addExtents(g_pDecorationPositioner->getWindowDecorationExtents(m_pSelf.lock(), true));
     if (properties & FULL_EXTENTS)
-        EXTENTS.addExtents(g_pDecorationPositioner->getWindowDecorationExtents(this, false));
+        EXTENTS.addExtents(g_pDecorationPositioner->getWindowDecorationExtents(m_pSelf.lock(), false));
 
     CBox box = {m_vRealPosition.value().x, m_vRealPosition.value().y, m_vRealSize.value().x, m_vRealSize.value().y};
     box.addExtents(EXTENTS);
@@ -167,11 +180,10 @@ CBox CWindow::getWindowMainSurfaceBox() {
 }
 
 SWindowDecorationExtents CWindow::getFullWindowReservedArea() {
-    return g_pDecorationPositioner->getWindowDecorationReserved(this);
+    return g_pDecorationPositioner->getWindowDecorationReserved(m_pSelf.lock());
 }
 
 void CWindow::updateWindowDecos() {
-    bool recalc = false;
 
     if (!m_bIsMapped || isHidden())
         return;
@@ -180,18 +192,14 @@ void CWindow::updateWindowDecos() {
         for (auto it = m_dWindowDecorations.begin(); it != m_dWindowDecorations.end(); it++) {
             if (it->get() == wd) {
                 g_pDecorationPositioner->uncacheDecoration(it->get());
-                it     = m_dWindowDecorations.erase(it);
-                recalc = true;
+                it = m_dWindowDecorations.erase(it);
                 if (it == m_dWindowDecorations.end())
                     break;
             }
         }
     }
 
-    g_pDecorationPositioner->onWindowUpdate(this);
-
-    if (recalc)
-        g_pLayoutManager->getCurrentLayout()->recalculateWindow(this);
+    g_pDecorationPositioner->onWindowUpdate(m_pSelf.lock());
 
     m_vDecosToRemove.clear();
 
@@ -203,22 +211,22 @@ void CWindow::updateWindowDecos() {
     }
 
     for (auto& wd : decos) {
-        wd->updateWindow(this);
+        wd->updateWindow(m_pSelf.lock());
     }
 }
 
 void CWindow::addWindowDeco(std::unique_ptr<IHyprWindowDecoration> deco) {
     m_dWindowDecorations.emplace_back(std::move(deco));
-    g_pDecorationPositioner->forceRecalcFor(this);
+    g_pDecorationPositioner->forceRecalcFor(m_pSelf.lock());
     updateWindowDecos();
-    g_pLayoutManager->getCurrentLayout()->recalculateWindow(this);
+    g_pLayoutManager->getCurrentLayout()->recalculateWindow(m_pSelf.lock());
 }
 
 void CWindow::removeWindowDeco(IHyprWindowDecoration* deco) {
     m_vDecosToRemove.push_back(deco);
-    g_pDecorationPositioner->forceRecalcFor(this);
+    g_pDecorationPositioner->forceRecalcFor(m_pSelf.lock());
     updateWindowDecos();
-    g_pLayoutManager->getCurrentLayout()->recalculateWindow(this);
+    g_pLayoutManager->getCurrentLayout()->recalculateWindow(m_pSelf.lock());
 }
 
 void CWindow::uncacheWindowDecos() {
@@ -271,66 +279,8 @@ IHyprWindowDecoration* CWindow::getDecorationByType(eDecorationType type) {
     return nullptr;
 }
 
-void CWindow::createToplevelHandle() {
-    if (m_bIsX11 && (m_bX11DoesntWantBorders || m_iX11Type == 2))
-        return; // don't create a toplevel
-
-    m_phForeignToplevel = wlr_foreign_toplevel_handle_v1_create(g_pCompositor->m_sWLRToplevelMgr);
-
-    wlr_foreign_toplevel_handle_v1_set_app_id(m_phForeignToplevel, g_pXWaylandManager->getAppIDClass(this).c_str());
-    wlr_foreign_toplevel_handle_v1_output_enter(m_phForeignToplevel, g_pCompositor->getMonitorFromID(m_iMonitorID)->output);
-    wlr_foreign_toplevel_handle_v1_set_title(m_phForeignToplevel, m_szTitle.c_str());
-    wlr_foreign_toplevel_handle_v1_set_maximized(m_phForeignToplevel, false);
-    wlr_foreign_toplevel_handle_v1_set_minimized(m_phForeignToplevel, false);
-    wlr_foreign_toplevel_handle_v1_set_fullscreen(m_phForeignToplevel, false);
-
-    // handle events
-    hyprListener_toplevelActivate.initCallback(
-        &m_phForeignToplevel->events.request_activate, [&](void* owner, void* data) { g_pLayoutManager->getCurrentLayout()->requestFocusForWindow(this); }, this, "Toplevel");
-
-    hyprListener_toplevelFullscreen.initCallback(
-        &m_phForeignToplevel->events.request_fullscreen,
-        [&](void* owner, void* data) {
-            const auto EV = (wlr_foreign_toplevel_handle_v1_fullscreen_event*)data;
-
-            g_pCompositor->setWindowFullscreen(this, EV->fullscreen, FULLSCREEN_FULL);
-        },
-        this, "Toplevel");
-
-    hyprListener_toplevelClose.initCallback(
-        &m_phForeignToplevel->events.request_close, [&](void* owner, void* data) { g_pCompositor->closeWindow(this); }, this, "Toplevel");
-
-    m_iLastToplevelMonitorID = m_iMonitorID;
-}
-
-void CWindow::destroyToplevelHandle() {
-    if (!m_phForeignToplevel)
-        return;
-
-    hyprListener_toplevelActivate.removeCallback();
-    hyprListener_toplevelClose.removeCallback();
-    hyprListener_toplevelFullscreen.removeCallback();
-
-    wlr_foreign_toplevel_handle_v1_destroy(m_phForeignToplevel);
-    m_phForeignToplevel = nullptr;
-}
-
 void CWindow::updateToplevel() {
     updateSurfaceScaleTransformDetails();
-
-    if (!m_phForeignToplevel)
-        return;
-
-    wlr_foreign_toplevel_handle_v1_set_title(m_phForeignToplevel, m_szTitle.c_str());
-    wlr_foreign_toplevel_handle_v1_set_fullscreen(m_phForeignToplevel, m_bIsFullscreen);
-
-    if (m_iLastToplevelMonitorID != m_iMonitorID) {
-        if (const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iLastToplevelMonitorID); PMONITOR && PMONITOR->m_bEnabled)
-            wlr_foreign_toplevel_handle_v1_output_leave(m_phForeignToplevel, PMONITOR->output);
-        wlr_foreign_toplevel_handle_v1_output_enter(m_phForeignToplevel, g_pCompositor->getMonitorFromID(m_iMonitorID)->output);
-
-        m_iLastToplevelMonitorID = m_iMonitorID;
-    }
 }
 
 void sendEnterIter(wlr_surface* pSurface, int x, int y, void* data) {
@@ -382,6 +332,22 @@ void CWindow::moveToWorkspace(PHLWORKSPACE pWorkspace) {
     if (m_pWorkspace == pWorkspace)
         return;
 
+    static auto PINITIALWSTRACKING = CConfigValue<Hyprlang::INT>("misc:initial_workspace_tracking");
+
+    if (!m_szInitialWorkspaceToken.empty()) {
+        const auto TOKEN = g_pTokenManager->getToken(m_szInitialWorkspaceToken);
+        if (TOKEN) {
+            if (*PINITIALWSTRACKING == 2) {
+                // persistent
+                SInitialWorkspaceToken token = std::any_cast<SInitialWorkspaceToken>(TOKEN->data);
+                if (token.primaryOwner.lock().get() == this) {
+                    token.workspace = pWorkspace->getConfigName();
+                    TOKEN->data     = token;
+                }
+            }
+        }
+    }
+
     static auto PCLOSEONLASTSPECIAL = CConfigValue<Hyprlang::INT>("misc:close_special_on_empty");
 
     const auto  OLDWORKSPACE = m_pWorkspace;
@@ -392,23 +358,27 @@ void CWindow::moveToWorkspace(PHLWORKSPACE pWorkspace) {
 
     g_pCompositor->updateWorkspaceWindows(OLDWORKSPACE->m_iID);
     g_pCompositor->updateWorkspaceSpecialRenderData(OLDWORKSPACE->m_iID);
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(OLDWORKSPACE->m_iMonitorID);
+
     g_pCompositor->updateWorkspaceWindows(workspaceID());
     g_pCompositor->updateWorkspaceSpecialRenderData(workspaceID());
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_iMonitorID);
+
     g_pCompositor->updateAllWindowsAnimatedDecorationValues();
 
     if (valid(pWorkspace)) {
         g_pEventManager->postEvent(SHyprIPCEvent{"movewindow", std::format("{:x},{}", (uintptr_t)this, pWorkspace->m_szName)});
         g_pEventManager->postEvent(SHyprIPCEvent{"movewindowv2", std::format("{:x},{},{}", (uintptr_t)this, pWorkspace->m_iID, pWorkspace->m_szName)});
-        EMIT_HOOK_EVENT("moveWindow", (std::vector<std::any>{this, pWorkspace}));
+        EMIT_HOOK_EVENT("moveWindow", (std::vector<std::any>{m_pSelf.lock(), pWorkspace}));
     }
 
-    if (m_pSwallowed) {
-        m_pSwallowed->moveToWorkspace(pWorkspace);
-        m_pSwallowed->m_iMonitorID = m_iMonitorID;
+    if (const auto SWALLOWED = m_pSwallowed.lock()) {
+        SWALLOWED->moveToWorkspace(pWorkspace);
+        SWALLOWED->m_iMonitorID = m_iMonitorID;
     }
 
     // update xwayland coords
-    g_pXWaylandManager->setWindowSize(this, m_vRealSize.value());
+    g_pXWaylandManager->setWindowSize(m_pSelf.lock(), m_vRealSize.value());
 
     if (OLDWORKSPACE && g_pCompositor->isWorkspaceSpecial(OLDWORKSPACE->m_iID) && g_pCompositor->getWindowsOnWorkspace(OLDWORKSPACE->m_iID) == 0 && *PCLOSEONLASTSPECIAL) {
         if (const auto PMONITOR = g_pCompositor->getMonitorFromID(OLDWORKSPACE->m_iMonitorID); PMONITOR)
@@ -416,7 +386,7 @@ void CWindow::moveToWorkspace(PHLWORKSPACE pWorkspace) {
     }
 }
 
-CWindow* CWindow::X11TransientFor() {
+PHLWINDOW CWindow::X11TransientFor() {
     if (!m_bIsX11)
         return nullptr;
 
@@ -425,11 +395,11 @@ CWindow* CWindow::X11TransientFor() {
 
     auto PPARENT = g_pCompositor->getWindowFromSurface(m_uSurface.xwayland->parent->surface);
 
-    while (g_pCompositor->windowValidMapped(PPARENT) && PPARENT->m_uSurface.xwayland->parent) {
+    while (validMapped(PPARENT) && PPARENT->m_uSurface.xwayland->parent) {
         PPARENT = g_pCompositor->getWindowFromSurface(PPARENT->m_uSurface.xwayland->parent->surface);
     }
 
-    if (!g_pCompositor->windowValidMapped(PPARENT))
+    if (!validMapped(PPARENT))
         return nullptr;
 
     return PPARENT;
@@ -451,8 +421,24 @@ void unregisterVar(void* ptr) {
 void CWindow::onUnmap() {
     static auto PCLOSEONLASTSPECIAL = CConfigValue<Hyprlang::INT>("misc:close_special_on_empty");
 
-    if (g_pCompositor->m_pLastWindow == this)
-        g_pCompositor->m_pLastWindow = nullptr;
+    if (g_pCompositor->m_pLastWindow.lock().get() == this)
+        g_pCompositor->m_pLastWindow.reset();
+    if (g_pInputManager->currentlyDraggedWindow.lock().get() == this)
+        g_pInputManager->currentlyDraggedWindow.reset();
+
+    static auto PINITIALWSTRACKING = CConfigValue<Hyprlang::INT>("misc:initial_workspace_tracking");
+
+    if (!m_szInitialWorkspaceToken.empty()) {
+        const auto TOKEN = g_pTokenManager->getToken(m_szInitialWorkspaceToken);
+        if (TOKEN) {
+            if (*PINITIALWSTRACKING == 2) {
+                // persistent token, but the first window got removed so the token is gone
+                SInitialWorkspaceToken token = std::any_cast<SInitialWorkspaceToken>(TOKEN->data);
+                if (token.primaryOwner.lock().get() == this)
+                    g_pTokenManager->removeToken(TOKEN);
+            }
+        }
+    }
 
     m_iLastWorkspace = m_pWorkspace->m_iID;
 
@@ -467,7 +453,7 @@ void CWindow::onUnmap() {
 
     m_vRealSize.setCallbackOnBegin(nullptr);
 
-    std::erase_if(g_pCompositor->m_vWindowFocusHistory, [&](const auto& other) { return other == this; });
+    std::erase_if(g_pCompositor->m_vWindowFocusHistory, [&](const auto& other) { return other.expired() || other.lock().get() == this; });
 
     hyprListener_unmapWindow.removeCallback();
 
@@ -479,11 +465,12 @@ void CWindow::onUnmap() {
 
     const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
 
-    if (PMONITOR && PMONITOR->solitaryClient == this)
-        PMONITOR->solitaryClient = nullptr;
+    if (PMONITOR && PMONITOR->solitaryClient.lock().get() == this)
+        PMONITOR->solitaryClient.reset();
 
     g_pCompositor->updateWorkspaceWindows(workspaceID());
     g_pCompositor->updateWorkspaceSpecialRenderData(workspaceID());
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_iMonitorID);
     g_pCompositor->updateAllWindowsAnimatedDecorationValues();
 
     m_pWorkspace.reset();
@@ -520,7 +507,7 @@ void CWindow::onMap() {
     m_fBorderAngleAnimationProgress.setValueAndWarp(0.f);
     m_fBorderAngleAnimationProgress = 1.f;
 
-    g_pCompositor->m_vWindowFocusHistory.push_back(this);
+    g_pCompositor->m_vWindowFocusHistory.push_back(m_pSelf);
 
     hyprListener_unmapWindow.initCallback(m_bIsX11 ? &m_uSurface.xwayland->surface->events.unmap : &m_uSurface.xdg->surface->events.unmap, &Events::listener_unmapWindow, this,
                                           "CWindow");
@@ -528,19 +515,11 @@ void CWindow::onMap() {
     m_vReportedSize = m_vPendingReportedSize;
     m_bAnimatingIn  = true;
 
-    for (const auto& ctrl : g_pHyprRenderer->m_vTearingControllers) {
-        if (ctrl->pWlrHint->surface != m_pWLSurface.wlr())
-            continue;
-
-        m_bTearingHint = ctrl->pWlrHint->current;
-        break;
-    }
-
     if (m_bIsX11)
         return;
 
-    m_pSubsurfaceHead = std::make_unique<CSubsurface>(this);
-    m_pPopupHead      = std::make_unique<CPopup>(this);
+    m_pSubsurfaceHead = std::make_unique<CSubsurface>(m_pSelf.lock());
+    m_pPopupHead      = std::make_unique<CPopup>(m_pSelf.lock());
 }
 
 void CWindow::onBorderAngleAnimEnd(void* ptr) {
@@ -562,8 +541,8 @@ void CWindow::onBorderAngleAnimEnd(void* ptr) {
 void CWindow::setHidden(bool hidden) {
     m_bHidden = hidden;
 
-    if (hidden && g_pCompositor->m_pLastWindow == this) {
-        g_pCompositor->m_pLastWindow = nullptr;
+    if (hidden && g_pCompositor->m_pLastWindow.lock().get() == this) {
+        g_pCompositor->m_pLastWindow.reset();
     }
 
     setSuspended(hidden);
@@ -722,8 +701,7 @@ void CWindow::applyDynamicRule(const SWindowRule& r) {
             m_sAdditionalConfigData.maxSize = VEC;
             m_vRealSize                     = Vector2D(std::min((double)m_sAdditionalConfigData.maxSize.toUnderlying().x, m_vRealSize.goal().x),
                                                        std::min((double)m_sAdditionalConfigData.maxSize.toUnderlying().y, m_vRealSize.goal().y));
-            g_pXWaylandManager->setWindowSize(this, m_vRealSize.goal());
-            setHidden(false);
+            g_pXWaylandManager->setWindowSize(m_pSelf.lock(), m_vRealSize.goal());
         } catch (std::exception& e) { Debug::log(ERR, "maxsize rule \"{}\" failed with: {}", r.szRule, e.what()); }
     } else if (r.szRule.starts_with("minsize")) {
         try {
@@ -738,8 +716,9 @@ void CWindow::applyDynamicRule(const SWindowRule& r) {
             m_sAdditionalConfigData.minSize = VEC;
             m_vRealSize                     = Vector2D(std::max((double)m_sAdditionalConfigData.minSize.toUnderlying().x, m_vRealSize.goal().x),
                                                        std::max((double)m_sAdditionalConfigData.minSize.toUnderlying().y, m_vRealSize.goal().y));
-            g_pXWaylandManager->setWindowSize(this, m_vRealSize.goal());
-            setHidden(false);
+            g_pXWaylandManager->setWindowSize(m_pSelf.lock(), m_vRealSize.goal());
+            if (m_sGroupData.pNextWindow.expired())
+                setHidden(false);
         } catch (std::exception& e) { Debug::log(ERR, "minsize rule \"{}\" failed with: {}", r.szRule, e.what()); }
     }
 }
@@ -769,11 +748,13 @@ void CWindow::updateDynamicRules() {
     m_sAdditionalConfigData.nearestNeighbor = false;
     m_eIdleInhibitMode                      = IDLEINHIBIT_NONE;
 
-    const auto WINDOWRULES = g_pConfigManager->getMatchingRules(this);
-    for (auto& r : WINDOWRULES) {
+    m_vMatchedRules = g_pConfigManager->getMatchingRules(m_pSelf.lock());
+    for (auto& r : m_vMatchedRules) {
         applyDynamicRule(r);
     }
 
+    EMIT_HOOK_EVENT("windowUpdateRules", m_pSelf.lock());
+
     g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_iMonitorID);
 }
 
@@ -833,7 +814,7 @@ void CWindow::applyGroupRules() {
     if ((m_eGroupRules & GROUP_SET && m_bFirstMap) || m_eGroupRules & GROUP_SET_ALWAYS)
         createGroup();
 
-    if (m_sGroupData.pNextWindow && ((m_eGroupRules & GROUP_LOCK && m_bFirstMap) || m_eGroupRules & GROUP_LOCK_ALWAYS))
+    if (m_sGroupData.pNextWindow.lock() && ((m_eGroupRules & GROUP_LOCK && m_bFirstMap) || m_eGroupRules & GROUP_LOCK_ALWAYS))
         getGroupHead()->m_sGroupData.locked = true;
 }
 
@@ -843,45 +824,46 @@ void CWindow::createGroup() {
         return;
     }
 
-    if (!m_sGroupData.pNextWindow) {
-        m_sGroupData.pNextWindow = this;
+    if (m_sGroupData.pNextWindow.expired()) {
+        m_sGroupData.pNextWindow = m_pSelf;
         m_sGroupData.head        = true;
         m_sGroupData.locked      = false;
         m_sGroupData.deny        = false;
 
-        addWindowDeco(std::make_unique<CHyprGroupBarDecoration>(this));
+        addWindowDeco(std::make_unique<CHyprGroupBarDecoration>(m_pSelf.lock()));
 
-        g_pLayoutManager->getCurrentLayout()->recalculateWindow(this);
         g_pCompositor->updateWorkspaceWindows(workspaceID());
         g_pCompositor->updateWorkspaceSpecialRenderData(workspaceID());
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_iMonitorID);
         g_pCompositor->updateAllWindowsAnimatedDecorationValues();
     }
 }
 
 void CWindow::destroyGroup() {
-    if (m_sGroupData.pNextWindow == this) {
+    if (m_sGroupData.pNextWindow.lock().get() == this) {
         if (m_eGroupRules & GROUP_SET_ALWAYS) {
             Debug::log(LOG, "destoryGroup: window:{:x},title:{} has rule [group set always], ignored", (uintptr_t)this, this->m_szTitle);
             return;
         }
-        m_sGroupData.pNextWindow = nullptr;
-        m_sGroupData.head        = false;
+        m_sGroupData.pNextWindow.reset();
+        m_sGroupData.head = false;
         updateWindowDecos();
         g_pCompositor->updateWorkspaceWindows(workspaceID());
         g_pCompositor->updateWorkspaceSpecialRenderData(workspaceID());
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_iMonitorID);
         g_pCompositor->updateAllWindowsAnimatedDecorationValues();
         return;
     }
 
-    CWindow*              curr = this;
-    std::vector<CWindow*> members;
+    PHLWINDOW              curr = m_pSelf.lock();
+    std::vector<PHLWINDOW> members;
     do {
-        const auto PLASTWIN                = curr;
-        curr                               = curr->m_sGroupData.pNextWindow;
-        PLASTWIN->m_sGroupData.pNextWindow = nullptr;
+        const auto PLASTWIN = curr;
+        curr                = curr->m_sGroupData.pNextWindow.lock();
+        PLASTWIN->m_sGroupData.pNextWindow.reset();
         curr->setHidden(false);
         members.push_back(curr);
-    } while (curr != this);
+    } while (curr.get() != this);
 
     for (auto& w : members) {
         if (w->m_sGroupData.head)
@@ -899,72 +881,73 @@ void CWindow::destroyGroup() {
 
     g_pCompositor->updateWorkspaceWindows(workspaceID());
     g_pCompositor->updateWorkspaceSpecialRenderData(workspaceID());
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_iMonitorID);
     g_pCompositor->updateAllWindowsAnimatedDecorationValues();
 }
 
-CWindow* CWindow::getGroupHead() {
-    CWindow* curr = this;
+PHLWINDOW CWindow::getGroupHead() {
+    PHLWINDOW curr = m_pSelf.lock();
     while (!curr->m_sGroupData.head)
-        curr = curr->m_sGroupData.pNextWindow;
+        curr = curr->m_sGroupData.pNextWindow.lock();
     return curr;
 }
 
-CWindow* CWindow::getGroupTail() {
-    CWindow* curr = this;
-    while (!curr->m_sGroupData.pNextWindow->m_sGroupData.head)
-        curr = curr->m_sGroupData.pNextWindow;
+PHLWINDOW CWindow::getGroupTail() {
+    PHLWINDOW curr = m_pSelf.lock();
+    while (!curr->m_sGroupData.pNextWindow.lock()->m_sGroupData.head)
+        curr = curr->m_sGroupData.pNextWindow.lock();
     return curr;
 }
 
-CWindow* CWindow::getGroupCurrent() {
-    CWindow* curr = this;
+PHLWINDOW CWindow::getGroupCurrent() {
+    PHLWINDOW curr = m_pSelf.lock();
     while (curr->isHidden())
-        curr = curr->m_sGroupData.pNextWindow;
+        curr = curr->m_sGroupData.pNextWindow.lock();
     return curr;
 }
 
 int CWindow::getGroupSize() {
-    int      size = 1;
-    CWindow* curr = this;
-    while (curr->m_sGroupData.pNextWindow != this) {
-        curr = curr->m_sGroupData.pNextWindow;
+    int       size = 1;
+    PHLWINDOW curr = m_pSelf.lock();
+    while (curr->m_sGroupData.pNextWindow.lock().get() != this) {
+        curr = curr->m_sGroupData.pNextWindow.lock();
         size++;
     }
     return size;
 }
 
-bool CWindow::canBeGroupedInto(CWindow* pWindow) {
-    return !g_pKeybindManager->m_bGroupsLocked                                          // global group lock disengaged
-        && ((m_eGroupRules & GROUP_INVADE && m_bFirstMap)                               // window ignore local group locks, or
-            || (!pWindow->getGroupHead()->m_sGroupData.locked                           //      target unlocked
-                && !(m_sGroupData.pNextWindow && getGroupHead()->m_sGroupData.locked))) //      source unlocked or isn't group
-        && !m_sGroupData.deny                                                           // source is not denied entry
-        && !(m_eGroupRules & GROUP_BARRED && m_bFirstMap);                              // group rule doesn't prevent adding window
+bool CWindow::canBeGroupedInto(PHLWINDOW pWindow) {
+    return !g_pKeybindManager->m_bGroupsLocked                                                 // global group lock disengaged
+        && ((m_eGroupRules & GROUP_INVADE && m_bFirstMap)                                      // window ignore local group locks, or
+            || (!pWindow->getGroupHead()->m_sGroupData.locked                                  //      target unlocked
+                && !(m_sGroupData.pNextWindow.lock() && getGroupHead()->m_sGroupData.locked))) //      source unlocked or isn't group
+        && !m_sGroupData.deny                                                                  // source is not denied entry
+        && !(m_eGroupRules & GROUP_BARRED && m_bFirstMap);                                     // group rule doesn't prevent adding window
 }
 
-CWindow* CWindow::getGroupWindowByIndex(int index) {
+PHLWINDOW CWindow::getGroupWindowByIndex(int index) {
     const int SIZE = getGroupSize();
     index          = ((index % SIZE) + SIZE) % SIZE;
-    CWindow* curr  = getGroupHead();
+    PHLWINDOW curr = getGroupHead();
     while (index > 0) {
-        curr = curr->m_sGroupData.pNextWindow;
+        curr = curr->m_sGroupData.pNextWindow.lock();
         index--;
     }
     return curr;
 }
 
-void CWindow::setGroupCurrent(CWindow* pWindow) {
-    CWindow* curr     = this->m_sGroupData.pNextWindow;
-    bool     isMember = false;
-    while (curr != this) {
+void CWindow::setGroupCurrent(PHLWINDOW pWindow) {
+    PHLWINDOW curr     = m_sGroupData.pNextWindow.lock();
+    bool      isMember = false;
+    while (curr.get() != this) {
         if (curr == pWindow) {
             isMember = true;
             break;
         }
-        curr = curr->m_sGroupData.pNextWindow;
+        curr = curr->m_sGroupData.pNextWindow.lock();
     }
 
-    if (!isMember && pWindow != this)
+    if (!isMember && pWindow.get() != this)
         return;
 
     const auto PCURRENT   = getGroupCurrent();
@@ -974,7 +957,7 @@ void CWindow::setGroupCurrent(CWindow* pWindow) {
     const auto PWINDOWSIZE = PCURRENT->m_vRealSize.goal();
     const auto PWINDOWPOS  = PCURRENT->m_vRealPosition.goal();
 
-    const auto CURRENTISFOCUS = PCURRENT == g_pCompositor->m_pLastWindow;
+    const auto CURRENTISFOCUS = PCURRENT == g_pCompositor->m_pLastWindow.lock();
 
     if (FULLSCREEN)
         g_pCompositor->setWindowFullscreen(PCURRENT, false, WORKSPACE->m_efFullscreenMode);
@@ -1002,14 +985,14 @@ void CWindow::setGroupCurrent(CWindow* pWindow) {
     pWindow->updateWindowDecos();
 }
 
-void CWindow::insertWindowToGroup(CWindow* pWindow) {
-    const auto BEGINAT = this;
-    const auto ENDAT   = m_sGroupData.pNextWindow;
+void CWindow::insertWindowToGroup(PHLWINDOW pWindow) {
+    const auto BEGINAT = m_pSelf.lock();
+    const auto ENDAT   = m_sGroupData.pNextWindow.lock();
 
     if (!pWindow->getDecorationByType(DECORATION_GROUPBAR))
         pWindow->addWindowDeco(std::make_unique<CHyprGroupBarDecoration>(pWindow));
 
-    if (!pWindow->m_sGroupData.pNextWindow) {
+    if (!pWindow->m_sGroupData.pNextWindow.lock()) {
         BEGINAT->m_sGroupData.pNextWindow = pWindow;
         pWindow->m_sGroupData.pNextWindow = ENDAT;
         pWindow->m_sGroupData.head        = false;
@@ -1024,26 +1007,26 @@ void CWindow::insertWindowToGroup(CWindow* pWindow) {
     STAIL->m_sGroupData.pNextWindow   = ENDAT;
 }
 
-CWindow* CWindow::getGroupPrevious() {
-    CWindow* curr = m_sGroupData.pNextWindow;
+PHLWINDOW CWindow::getGroupPrevious() {
+    PHLWINDOW curr = m_sGroupData.pNextWindow.lock();
 
-    while (curr != this && curr->m_sGroupData.pNextWindow != this)
-        curr = curr->m_sGroupData.pNextWindow;
+    while (curr != m_pSelf.lock() && curr->m_sGroupData.pNextWindow.lock().get() != this)
+        curr = curr->m_sGroupData.pNextWindow.lock();
 
     return curr;
 }
 
-void CWindow::switchWithWindowInGroup(CWindow* pWindow) {
-    if (!m_sGroupData.pNextWindow || !pWindow->m_sGroupData.pNextWindow)
+void CWindow::switchWithWindowInGroup(PHLWINDOW pWindow) {
+    if (!m_sGroupData.pNextWindow.lock() || !pWindow->m_sGroupData.pNextWindow.lock())
         return;
 
-    if (m_sGroupData.pNextWindow == pWindow) { // A -> this -> pWindow -> B >> A -> pWindow -> this -> B
+    if (m_sGroupData.pNextWindow.lock() == pWindow) { // A -> this -> pWindow -> B >> A -> pWindow -> this -> B
         getGroupPrevious()->m_sGroupData.pNextWindow = pWindow;
         m_sGroupData.pNextWindow                     = pWindow->m_sGroupData.pNextWindow;
-        pWindow->m_sGroupData.pNextWindow            = this;
+        pWindow->m_sGroupData.pNextWindow            = m_pSelf;
 
-    } else if (pWindow->m_sGroupData.pNextWindow == this) { // A -> pWindow -> this -> B >> A -> this -> pWindow -> B
-        pWindow->getGroupPrevious()->m_sGroupData.pNextWindow = this;
+    } else if (pWindow->m_sGroupData.pNextWindow.lock().get() == this) { // A -> pWindow -> this -> B >> A -> this -> pWindow -> B
+        pWindow->getGroupPrevious()->m_sGroupData.pNextWindow = m_pSelf;
         pWindow->m_sGroupData.pNextWindow                     = m_sGroupData.pNextWindow;
         m_sGroupData.pNextWindow                              = pWindow;
 
@@ -1057,21 +1040,21 @@ void CWindow::switchWithWindowInGroup(CWindow* pWindow) {
 }
 
 void CWindow::updateGroupOutputs() {
-    if (!m_sGroupData.pNextWindow)
+    if (m_sGroupData.pNextWindow.expired())
         return;
 
-    CWindow*   curr = m_sGroupData.pNextWindow;
+    PHLWINDOW  curr = m_sGroupData.pNextWindow.lock();
 
     const auto WS = m_pWorkspace;
 
-    while (curr != this) {
+    while (curr.get() != this) {
         curr->m_iMonitorID = m_iMonitorID;
         curr->moveToWorkspace(WS);
 
         curr->m_vRealPosition = m_vRealPosition.goal();
         curr->m_vRealSize     = m_vRealSize.goal();
 
-        curr = curr->m_sGroupData.pNextWindow;
+        curr = curr->m_sGroupData.pNextWindow.lock();
     }
 }
 
@@ -1136,7 +1119,7 @@ void CWindow::updateSpecialRenderData(const SWorkspaceRule& workspaceRule) {
 }
 
 int CWindow::getRealBorderSize() {
-    if (!m_sSpecialRenderData.border || m_sAdditionalConfigData.forceNoBorder)
+    if (!m_sSpecialRenderData.border || m_sAdditionalConfigData.forceNoBorder || (m_pWorkspace && m_bIsFullscreen && (m_pWorkspace->m_efFullscreenMode == FULLSCREEN_FULL)))
         return 0;
 
     if (m_sAdditionalConfigData.borderSize.toUnderlying() != -1)
@@ -1238,3 +1221,60 @@ int CWindow::workspaceID() {
 bool CWindow::onSpecialWorkspace() {
     return m_pWorkspace ? m_pWorkspace->m_bIsSpecialWorkspace : g_pCompositor->isWorkspaceSpecial(m_iLastWorkspace);
 }
+
+std::unordered_map<std::string, std::string> CWindow::getEnv() {
+
+    const auto PID = getPID();
+
+    if (PID <= 1)
+        return {};
+
+    std::unordered_map<std::string, std::string> results;
+
+    //
+    std::string   environFile = "/proc/" + std::to_string(PID) + "/environ";
+    std::ifstream ifs(environFile, std::ios::binary);
+
+    if (!ifs.good())
+        return {};
+
+    std::vector<char> buffer;
+    size_t            needle = 0;
+    buffer.resize(512, '\0');
+    while (ifs.read(buffer.data() + needle, 512)) {
+        buffer.resize(buffer.size() + 512, '\0');
+        needle += 512;
+    }
+
+    std::replace(buffer.begin(), buffer.end() - 1, '\0', '\n');
+
+    CVarList envs(std::string{buffer.data(), needle - 1}, 0, '\n', true);
+
+    for (auto& e : envs) {
+        if (!e.contains('='))
+            continue;
+
+        const auto EQ            = e.find_first_of('=');
+        results[e.substr(0, EQ)] = e.substr(EQ + 1);
+    }
+
+    return results;
+}
+
+void CWindow::activate() {
+    static auto PFOCUSONACTIVATE = CConfigValue<Hyprlang::INT>("misc:focus_on_activate");
+
+    g_pEventManager->postEvent(SHyprIPCEvent{"urgent", std::format("{:x}", (uintptr_t)this)});
+    EMIT_HOOK_EVENT("urgent", m_pSelf.lock());
+
+    m_bIsUrgent = true;
+
+    if (!*PFOCUSONACTIVATE || (m_eSuppressedEvents & SUPPRESS_ACTIVATE_FOCUSONLY) || (m_eSuppressedEvents & SUPPRESS_ACTIVATE))
+        return;
+
+    if (m_bIsFloating)
+        g_pCompositor->changeWindowZOrder(m_pSelf.lock(), true);
+
+    g_pCompositor->focusWindow(m_pSelf.lock());
+    g_pCompositor->warpCursorTo(middle());
+}

src/desktop/Window.hpp

@@ -12,6 +12,7 @@
 #include "../macros.hpp"
 #include "../managers/XWaylandManager.hpp"
 #include "DesktopTypes.hpp"
+#include "../helpers/signal/Signal.hpp"
 
 enum eIdleInhibitMode {
     IDLEINHIBIT_NONE = 0,
@@ -187,9 +188,19 @@ struct SWindowRule {
     std::string szWorkspace   = ""; // empty means any
 };
 
+struct SInitialWorkspaceToken {
+    PHLWINDOWREF primaryOwner;
+    std::string  workspace;
+};
+
 class CWindow {
   public:
+    static PHLWINDOW create();
+
+  private:
     CWindow();
+
+  public:
     ~CWindow();
 
     DYNLISTENER(commitWindow);
@@ -216,6 +227,10 @@ class CWindow {
 
     CWLSurface m_pWLSurface;
 
+    struct {
+        CSignal destroy;
+    } events;
+
     union {
         wlr_xdg_surface*      xdg;
         wlr_xwayland_surface* xwayland;
@@ -267,13 +282,13 @@ class CWindow {
     bool m_bCreatedOverFullscreen = false;
 
     // XWayland stuff
-    bool     m_bIsX11                = false;
-    CWindow* m_pX11Parent            = nullptr;
-    uint64_t m_iX11Type              = 0;
-    bool     m_bIsModal              = false;
-    bool     m_bX11DoesntWantBorders = false;
-    bool     m_bX11ShouldntFocus     = false;
-    float    m_fX11SurfaceScaledBy   = 1.f;
+    bool         m_bIsX11 = false;
+    PHLWINDOWREF m_pX11Parent;
+    uint64_t     m_iX11Type              = 0;
+    bool         m_bIsModal              = false;
+    bool         m_bX11DoesntWantBorders = false;
+    bool         m_bX11ShouldntFocus     = false;
+    float        m_fX11SurfaceScaledBy   = 1.f;
     //
 
     // For nofocus
@@ -314,10 +329,7 @@ class CWindow {
     bool m_bFakeFullscreenState = false;
 
     // for proper cycling. While cycling we can't just move the pointers, so we need to keep track of the last cycled window.
-    CWindow* m_pLastCycledWindow = nullptr;
-
-    // Foreign Toplevel proto
-    wlr_foreign_toplevel_handle_v1* m_phForeignToplevel = nullptr;
+    PHLWINDOWREF m_pLastCycledWindow;
 
     // Window decorations
     std::deque<std::unique_ptr<IHyprWindowDecoration>> m_dWindowDecorations;
@@ -340,7 +352,7 @@ class CWindow {
     CAnimatedVariable<float> m_fDimPercent;
 
     // swallowing
-    CWindow* m_pSwallowed = nullptr;
+    PHLWINDOWREF m_pSwallowed;
 
     // focus stuff
     bool m_bStayFocused = false;
@@ -352,17 +364,23 @@ class CWindow {
     // for idle inhibiting windows
     eIdleInhibitMode m_eIdleInhibitMode = IDLEINHIBIT_NONE;
 
+    // initial token. Will be unregistered on workspace change or timeout of 2 minutes
+    std::string m_szInitialWorkspaceToken = "";
+
     // for groups
     struct SGroupData {
-        CWindow* pNextWindow = nullptr; // nullptr means no grouping. Self means single group.
-        bool     head        = false;
-        bool     locked      = false; // per group lock
-        bool     deny        = false; // deny window from enter a group or made a group
+        PHLWINDOWREF pNextWindow; // nullptr means no grouping. Self means single group.
+        bool         head   = false;
+        bool         locked = false; // per group lock
+        bool         deny   = false; // deny window from enter a group or made a group
     } m_sGroupData;
     uint16_t m_eGroupRules = GROUP_NONE;
 
     bool     m_bTearingHint = false;
 
+    // stores the currently matched window rules
+    std::vector<SWindowRule> m_vMatchedRules;
+
     // For the list lookup
     bool operator==(const CWindow& rhs) {
         return m_uSurface.xdg == rhs.m_uSurface.xdg && m_uSurface.xwayland == rhs.m_uSurface.xwayland && m_vPosition == rhs.m_vPosition && m_vSize == rhs.m_vSize &&
@@ -383,12 +401,10 @@ class CWindow {
     pid_t                    getPID();
     IHyprWindowDecoration*   getDecorationByType(eDecorationType);
     void                     removeDecorationByType(eDecorationType);
-    void                     createToplevelHandle();
-    void                     destroyToplevelHandle();
     void                     updateToplevel();
     void                     updateSurfaceScaleTransformDetails();
     void                     moveToWorkspace(PHLWORKSPACE);
-    CWindow*                 X11TransientFor();
+    PHLWINDOW                X11TransientFor();
     void                     onUnmap();
     void                     onMap();
     void                     setHidden(bool hidden);
@@ -405,6 +421,7 @@ class CWindow {
     bool                     visibleOnMonitor(CMonitor* pMonitor);
     int                      workspaceID();
     bool                     onSpecialWorkspace();
+    void                     activate();
 
     int                      getRealBorderSize();
     void                     updateSpecialRenderData();
@@ -418,20 +435,26 @@ class CWindow {
     void                     applyGroupRules();
     void                     createGroup();
     void                     destroyGroup();
-    CWindow*                 getGroupHead();
-    CWindow*                 getGroupTail();
-    CWindow*                 getGroupCurrent();
-    CWindow*                 getGroupPrevious();
-    CWindow*                 getGroupWindowByIndex(int);
+    PHLWINDOW                getGroupHead();
+    PHLWINDOW                getGroupTail();
+    PHLWINDOW                getGroupCurrent();
+    PHLWINDOW                getGroupPrevious();
+    PHLWINDOW                getGroupWindowByIndex(int);
     int                      getGroupSize();
-    bool                     canBeGroupedInto(CWindow* pWindow);
-    void                     setGroupCurrent(CWindow* pWindow);
-    void                     insertWindowToGroup(CWindow* pWindow);
+    bool                     canBeGroupedInto(PHLWINDOW pWindow);
+    void                     setGroupCurrent(PHLWINDOW pWindow);
+    void                     insertWindowToGroup(PHLWINDOW pWindow);
     void                     updateGroupOutputs();
-    void                     switchWithWindowInGroup(CWindow* pWindow);
+    void                     switchWithWindowInGroup(PHLWINDOW pWindow);
     void                     setAnimationsToMove();
     void                     onWorkspaceAnimUpdate();
 
+    //
+    std::unordered_map<std::string, std::string> getEnv();
+
+    //
+    PHLWINDOWREF m_pSelf;
+
   private:
     // For hidden windows and stuff
     bool m_bHidden        = false;
@@ -439,6 +462,26 @@ class CWindow {
     int  m_iLastWorkspace = WORKSPACE_INVALID;
 };
 
+inline bool valid(PHLWINDOW w) {
+    return w.get();
+}
+
+inline bool valid(PHLWINDOWREF w) {
+    return w.lock().get();
+}
+
+inline bool validMapped(PHLWINDOW w) {
+    if (!valid(w))
+        return false;
+    return w->m_bIsMapped;
+}
+
+inline bool validMapped(PHLWINDOWREF w) {
+    if (!valid(w))
+        return false;
+    return w.lock()->m_bIsMapped;
+}
+
 /**
     format specification
     - 'x', only address, equivalent of (uintpr_t)CWindow*
@@ -448,7 +491,7 @@ class CWindow {
 */
 
 template <typename CharT>
-struct std::formatter<CWindow*, CharT> : std::formatter<CharT> {
+struct std::formatter<PHLWINDOW, CharT> : std::formatter<CharT> {
     bool formatAddressOnly = false;
     bool formatWorkspace   = false;
     bool formatMonitor     = false;
@@ -458,18 +501,18 @@ struct std::formatter<CWindow*, CharT> : std::formatter<CharT> {
         FORMAT_FLAG('m', formatMonitor)     //
         FORMAT_FLAG('w', formatWorkspace)   //
         FORMAT_FLAG('c', formatClass),
-        CWindow*)
+        PHLWINDOW)
 
     template <typename FormatContext>
-    auto format(CWindow* const& w, FormatContext& ctx) const {
+    auto format(PHLWINDOW const& w, FormatContext& ctx) const {
         auto&& out = ctx.out();
         if (formatAddressOnly)
-            return std::format_to(out, "{:x}", (uintptr_t)w);
+            return std::format_to(out, "{:x}", (uintptr_t)w.get());
         if (!w)
             return std::format_to(out, "[Window nullptr]");
 
         std::format_to(out, "[");
-        std::format_to(out, "Window {:x}: title: \"{}\"", (uintptr_t)w, w->m_szTitle);
+        std::format_to(out, "Window {:x}: title: \"{}\"", (uintptr_t)w.get(), w->m_szTitle);
         if (formatWorkspace)
             std::format_to(out, ", workspace: {}", w->m_pWorkspace ? w->workspaceID() : WORKSPACE_INVALID);
         if (formatMonitor)

src/desktop/Workspace.cpp

@@ -33,10 +33,10 @@ void CWorkspace::init(PHLWORKSPACE self) {
         m_szName = RULEFORTHIS.defaultName.value();
 
     m_pFocusedWindowHook = g_pHookSystem->hookDynamic("closeWindow", [this](void* self, SCallbackInfo& info, std::any param) {
-        const auto PWINDOW = std::any_cast<CWindow*>(param);
+        const auto PWINDOW = std::any_cast<PHLWINDOW>(param);
 
-        if (PWINDOW == m_pLastFocusedWindow)
-            m_pLastFocusedWindow = nullptr;
+        if (PWINDOW == m_pLastFocusedWindow.lock())
+            m_pLastFocusedWindow.reset();
     });
 
     m_bInert = false;
@@ -75,7 +75,7 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
     // set floating windows offset callbacks
     m_vRenderOffset.setUpdateCallback([&](void*) {
         for (auto& w : g_pCompositor->m_vWindows) {
-            if (!g_pCompositor->windowValidMapped(w.get()) || w->workspaceID() != m_iID)
+            if (!validMapped(w) || w->workspaceID() != m_iID)
                 continue;
 
             w->onWorkspaceAnimUpdate();
@@ -182,11 +182,11 @@ void CWorkspace::moveToMonitor(const int& id) {
     ; // empty until https://gitlab.freedesktop.org/wayland/wayland-protocols/-/merge_requests/40
 }
 
-CWindow* CWorkspace::getLastFocusedWindow() {
-    if (!g_pCompositor->windowValidMapped(m_pLastFocusedWindow) || m_pLastFocusedWindow->workspaceID() != m_iID)
+PHLWINDOW CWorkspace::getLastFocusedWindow() {
+    if (!validMapped(m_pLastFocusedWindow) || m_pLastFocusedWindow.lock()->workspaceID() != m_iID)
         return nullptr;
 
-    return m_pLastFocusedWindow;
+    return m_pLastFocusedWindow.lock();
 }
 
 void CWorkspace::rememberPrevWorkspace(const PHLWORKSPACE& prev) {
@@ -207,7 +207,7 @@ void CWorkspace::rememberPrevWorkspace(const PHLWORKSPACE& prev) {
 
 std::string CWorkspace::getConfigName() {
     if (m_bIsSpecialWorkspace) {
-        return "special:" + m_szName;
+        return m_szName;
     }
 
     if (m_iID > 0)
@@ -251,6 +251,9 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
             // m - monitor: m[monitor_selector]
             // w - windowCount: w[1-4] or w[1], optional flag t or f for tiled or floating and
             //                  flag g to count groups instead of windows, e.g. w[t1-2], w[fg4]
+            //                  flag v will count only visible windows
+            // f - fullscreen state : f[-1], f[0], f[1], or f[2] for different fullscreen states
+            //                        -1: no fullscreen, 0: fullscreen, 1: maximized, 2: fullscreen without sending fs state to window
 
             const auto  NEXTSPACE = selector.find_first_of(' ', i);
             std::string prop      = selector.substr(i, NEXTSPACE == std::string::npos ? std::string::npos : NEXTSPACE - i);
@@ -355,8 +358,9 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 prop = prop.substr(2, prop.length() - 3);
 
-                int  wantsOnlyTiled  = -1;
-                bool wantsCountGroup = false;
+                int  wantsOnlyTiled    = -1;
+                bool wantsCountGroup   = false;
+                bool wantsCountVisible = false;
 
                 int  flagCount = 0;
                 for (auto& flag : prop) {
@@ -369,6 +373,9 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
                     } else if (flag == 'g' && !wantsCountGroup) {
                         wantsCountGroup = true;
                         flagCount++;
+                    } else if (flag == 'v' && !wantsCountVisible) {
+                        wantsCountVisible = true;
+                        flagCount++;
                     } else {
                         break;
                     }
@@ -392,9 +399,11 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                     int count;
                     if (wantsCountGroup)
-                        count = g_pCompositor->getGroupsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled));
+                        count = g_pCompositor->getGroupsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
+                                                                    wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
                     else
-                        count = g_pCompositor->getWindowsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled));
+                        count = g_pCompositor->getWindowsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
+                                                                     wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
 
                     if (count != from)
                         return false;
@@ -424,15 +433,55 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 int count;
                 if (wantsCountGroup)
-                    count = g_pCompositor->getGroupsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled));
+                    count = g_pCompositor->getGroupsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
+                                                                wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
                 else
-                    count = g_pCompositor->getWindowsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled));
+                    count = g_pCompositor->getWindowsOnWorkspace(m_iID, wantsOnlyTiled == -1 ? std::nullopt : std::optional<bool>((bool)wantsOnlyTiled),
+                                                                 wantsCountVisible ? std::optional<bool>(wantsCountVisible) : std::nullopt);
 
                 if (std::clamp(count, from, to) != count)
                     return false;
                 continue;
             }
 
+            if (cur == 'f') {
+                if (!prop.starts_with("f[") || !prop.ends_with("]")) {
+                    Debug::log(LOG, "Invalid selector {}", selector);
+                    return false;
+                }
+
+                prop        = prop.substr(2, prop.length() - 3);
+                int FSSTATE = -1;
+                try {
+                    FSSTATE = std::stoi(prop);
+                } catch (std::exception& e) {
+                    Debug::log(LOG, "Invalid selector {}", selector);
+                    return false;
+                }
+
+                switch (FSSTATE) {
+                    case -1: // no fullscreen
+                        if (m_bHasFullscreenWindow)
+                            return false;
+                        break;
+                    case 0: // fullscreen full
+                        if (!m_bHasFullscreenWindow || m_efFullscreenMode != FULLSCREEN_FULL)
+                            return false;
+                        break;
+                    case 1: // maximized
+                        if (!m_bHasFullscreenWindow || m_efFullscreenMode != FULLSCREEN_MAXIMIZED)
+                            return false;
+                        break;
+                    case 2: // fullscreen without sending fullscreen state to window
+                        if (!m_bHasFullscreenWindow || m_efFullscreenMode != FULLSCREEN_FULL || !g_pCompositor->getFullscreenWindowOnWorkspace(m_iID) ||
+                            !g_pCompositor->getFullscreenWindowOnWorkspace(m_iID)->m_bDontSendFullscreen)
+                            return false;
+                        break;
+                    default: break;
+                }
+                continue;
+            }
+
             Debug::log(LOG, "Invalid selector {}", selector);
             return false;
         }

src/desktop/Workspace.hpp

@@ -49,7 +49,7 @@ class CWorkspace {
     bool m_bIsSpecialWorkspace = false;
 
     // last window
-    CWindow* m_pLastFocusedWindow = nullptr;
+    PHLWINDOWREF m_pLastFocusedWindow;
 
     // user-set
     bool m_bDefaultFloating = false;
@@ -68,7 +68,7 @@ class CWorkspace {
 
     void        moveToMonitor(const int&);
 
-    CWindow*    getLastFocusedWindow();
+    PHLWINDOW   getLastFocusedWindow();
     void        rememberPrevWorkspace(const PHLWORKSPACE& prevWorkspace);
 
     std::string getConfigName();
@@ -78,11 +78,11 @@ class CWorkspace {
     void        markInert();
 
   private:
-    void                      init(PHLWORKSPACE self);
+    void                              init(PHLWORKSPACE self);
 
-    HOOK_CALLBACK_FN*         m_pFocusedWindowHook = nullptr;
-    bool                      m_bInert             = true;
-    std::weak_ptr<CWorkspace> m_pSelf;
+    std::shared_ptr<HOOK_CALLBACK_FN> m_pFocusedWindowHook;
+    bool                              m_bInert = true;
+    std::weak_ptr<CWorkspace>         m_pSelf;
 };
 
 inline bool valid(const PHLWORKSPACE& ref) {

src/devices/IHID.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include "../helpers/signal/Signal.hpp"
+
+enum eHIDCapabilityType : uint32_t {
+    HID_INPUT_CAPABILITY_KEYBOARD = (1 << 0),
+    HID_INPUT_CAPABILITY_POINTER  = (1 << 1),
+    HID_INPUT_CAPABILITY_TOUCH    = (1 << 2),
+};
+
+/*
+    Base class for a HID device.
+    This could be a keyboard, a mouse, or a touchscreen.
+*/
+class IHID {
+  public:
+    virtual uint32_t getCapabilities() = 0;
+
+    struct {
+        CSignal destroy;
+    } events;
+
+    std::string deviceName;
+};

src/devices/IKeyboard.cpp

@@ -0,0 +1,134 @@
+#include "IKeyboard.hpp"
+#include "../defines.hpp"
+#include "../helpers/VarList.hpp"
+#include "../managers/input/InputManager.hpp"
+
+uint32_t IKeyboard::getCapabilities() {
+    return HID_INPUT_CAPABILITY_KEYBOARD;
+}
+
+IKeyboard::~IKeyboard() {
+    events.destroy.emit();
+
+    if (!xkbTranslationState)
+        return;
+
+    xkb_state_unref(xkbTranslationState);
+    xkbTranslationState = nullptr;
+}
+
+void IKeyboard::updateXKBTranslationState(xkb_keymap* const keymap) {
+
+    if (xkbTranslationState)
+        xkb_state_unref(xkbTranslationState);
+
+    if (keymap) {
+        Debug::log(LOG, "Updating keyboard {:x}'s translation state from a provided keymap", (uintptr_t)this);
+        xkbTranslationState = xkb_state_new(keymap);
+        return;
+    }
+
+    const auto WLRKB      = wlr();
+    const auto KEYMAP     = WLRKB->keymap;
+    const auto STATE      = WLRKB->xkb_state;
+    const auto LAYOUTSNUM = xkb_keymap_num_layouts(KEYMAP);
+
+    const auto PCONTEXT = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
+
+    for (uint32_t i = 0; i < LAYOUTSNUM; ++i) {
+        if (xkb_state_layout_index_is_active(STATE, i, XKB_STATE_LAYOUT_EFFECTIVE)) {
+            Debug::log(LOG, "Updating keyboard {:x}'s translation state from an active index {}", (uintptr_t)this, i);
+
+            CVarList       keyboardLayouts(currentRules.layout, 0, ',');
+            CVarList       keyboardModels(currentRules.model, 0, ',');
+            CVarList       keyboardVariants(currentRules.variant, 0, ',');
+
+            xkb_rule_names rules = {.rules = "", .model = "", .layout = "", .variant = "", .options = ""};
+
+            std::string    layout, model, variant;
+            layout  = keyboardLayouts[i % keyboardLayouts.size()];
+            model   = keyboardModels[i % keyboardModels.size()];
+            variant = keyboardVariants[i % keyboardVariants.size()];
+
+            rules.layout  = layout.c_str();
+            rules.model   = model.c_str();
+            rules.variant = variant.c_str();
+
+            auto KEYMAP = xkb_keymap_new_from_names(PCONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
+
+            if (!KEYMAP) {
+                Debug::log(ERR, "updateXKBTranslationState: keymap failed 1, fallback without model/variant");
+                rules.model   = "";
+                rules.variant = "";
+                KEYMAP        = xkb_keymap_new_from_names(PCONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
+            }
+
+            if (!KEYMAP) {
+                Debug::log(ERR, "updateXKBTranslationState: keymap failed 2, fallback to us");
+                rules.layout = "us";
+                KEYMAP       = xkb_keymap_new_from_names(PCONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
+            }
+
+            xkbTranslationState = xkb_state_new(KEYMAP);
+
+            xkb_keymap_unref(KEYMAP);
+            xkb_context_unref(PCONTEXT);
+
+            return;
+        }
+    }
+
+    Debug::log(LOG, "Updating keyboard {:x}'s translation state from an unknown index", (uintptr_t)this);
+
+    xkb_rule_names rules = {
+        .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);
+
+    xkbTranslationState = xkb_state_new(NEWKEYMAP);
+
+    xkb_keymap_unref(NEWKEYMAP);
+    xkb_context_unref(PCONTEXT);
+}
+
+std::string IKeyboard::getActiveLayout() {
+    const auto WLRKB      = wlr();
+    const auto KEYMAP     = WLRKB->keymap;
+    const auto STATE      = WLRKB->xkb_state;
+    const auto LAYOUTSNUM = xkb_keymap_num_layouts(KEYMAP);
+
+    for (uint32_t i = 0; i < LAYOUTSNUM; ++i) {
+        if (xkb_state_layout_index_is_active(STATE, i, XKB_STATE_LAYOUT_EFFECTIVE)) {
+            const auto LAYOUTNAME = xkb_keymap_layout_get_name(KEYMAP, i);
+
+            if (LAYOUTNAME)
+                return std::string(LAYOUTNAME);
+            return "error";
+        }
+    }
+
+    return "none";
+}
+
+void IKeyboard::updateLEDs() {
+    auto keyboard = wlr();
+
+    if (!keyboard || keyboard->xkb_state == nullptr)
+        return;
+
+    uint32_t leds = 0;
+    for (uint32_t i = 0; i < WLR_LED_COUNT; ++i) {
+        if (xkb_state_led_index_is_active(keyboard->xkb_state, keyboard->led_indexes[i]))
+            leds |= (1 << i);
+    }
+
+    if (isVirtual() && g_pInputManager->shouldIgnoreVirtualKeyboard(self.lock()))
+        return;
+
+    wlr_keyboard_led_update(wlr(), leds);
+}

src/devices/IKeyboard.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "IHID.hpp"
+#include "../helpers/WLListener.hpp"
+#include "../macros.hpp"
+#include "../helpers/Vector2D.hpp"
+
+#include <xkbcommon/xkbcommon.h>
+
+struct wlr_keyboard;
+
+class IKeyboard : public IHID {
+  public:
+    virtual ~IKeyboard();
+    virtual uint32_t      getCapabilities();
+    virtual bool          isVirtual() = 0;
+    virtual wlr_keyboard* wlr()       = 0;
+
+    struct SKeyEvent {
+        uint32_t              timeMs     = 0;
+        uint32_t              keycode    = 0;
+        bool                  updateMods = false;
+        wl_keyboard_key_state state      = WL_KEYBOARD_KEY_STATE_PRESSED;
+    };
+
+    struct {
+        CSignal key;
+        CSignal modifiers;
+        CSignal keymap;
+        CSignal repeatInfo;
+    } keyboardEvents;
+
+    struct SStringRuleNames {
+        std::string layout  = "";
+        std::string model   = "";
+        std::string variant = "";
+        std::string options = "";
+        std::string rules   = "";
+    };
+
+    void               updateXKBTranslationState(xkb_keymap* const keymap = nullptr);
+    std::string        getActiveLayout();
+    void               updateLEDs();
+
+    bool               active  = false;
+    bool               enabled = true;
+
+    xkb_layout_index_t activeLayout        = 0;
+    xkb_state*         xkbTranslationState = nullptr;
+
+    std::string        hlName      = "";
+    std::string        xkbFilePath = "";
+
+    SStringRuleNames   currentRules;
+    int                repeatRate        = 0;
+    int                repeatDelay       = 0;
+    int                numlockOn         = -1;
+    bool               resolveBindsBySym = false;
+
+    WP<IKeyboard>      self;
+};

src/devices/IPointer.cpp

@@ -0,0 +1,5 @@
+#include "IPointer.hpp"
+
+uint32_t IPointer::getCapabilities() {
+    return HID_INPUT_CAPABILITY_POINTER;
+}

src/devices/IPointer.hpp

@@ -0,0 +1,110 @@
+#pragma once
+
+#include "IHID.hpp"
+#include "../helpers/WLListener.hpp"
+#include "../macros.hpp"
+#include "../helpers/Vector2D.hpp"
+
+struct wlr_pointer;
+
+/*
+    Base class for a pointer.
+*/
+class IPointer : public IHID {
+  public:
+    virtual uint32_t     getCapabilities();
+    virtual bool         isVirtual() = 0;
+    virtual wlr_pointer* wlr()       = 0;
+
+    struct SMotionEvent {
+        uint32_t timeMs = 0;
+        Vector2D delta, unaccel;
+    };
+
+    struct SMotionAbsoluteEvent {
+        uint32_t timeMs = 0;
+        Vector2D absolute; // 0.0 - 1.0
+    };
+
+    struct SButtonEvent {
+        uint32_t                timeMs = 0;
+        uint32_t                button = 0;
+        wl_pointer_button_state state  = WL_POINTER_BUTTON_STATE_PRESSED;
+    };
+
+    struct SAxisEvent {
+        uint32_t                           timeMs            = 0;
+        wl_pointer_axis_source             source            = WL_POINTER_AXIS_SOURCE_WHEEL;
+        wl_pointer_axis                    axis              = WL_POINTER_AXIS_VERTICAL_SCROLL;
+        wl_pointer_axis_relative_direction relativeDirection = WL_POINTER_AXIS_RELATIVE_DIRECTION_IDENTICAL;
+        double                             delta             = 0.0;
+        int32_t                            deltaDiscrete     = 0;
+    };
+
+    struct SSwipeBeginEvent {
+        uint32_t timeMs  = 0;
+        uint32_t fingers = 0;
+    };
+
+    struct SSwipeUpdateEvent {
+        uint32_t timeMs  = 0;
+        uint32_t fingers = 0;
+        Vector2D delta;
+    };
+
+    struct SSwipeEndEvent {
+        uint32_t timeMs    = 0;
+        bool     cancelled = false;
+    };
+
+    struct SPinchBeginEvent {
+        uint32_t timeMs  = 0;
+        uint32_t fingers = 0;
+    };
+
+    struct SPinchUpdateEvent {
+        uint32_t timeMs  = 0;
+        uint32_t fingers = 0;
+        Vector2D delta;
+        double   scale = 1.0, rotation = 0.0;
+    };
+
+    struct SPinchEndEvent {
+        uint32_t timeMs    = 0;
+        bool     cancelled = false;
+    };
+
+    struct SHoldBeginEvent {
+        uint32_t timeMs  = 0;
+        uint32_t fingers = 0;
+    };
+
+    struct SHoldEndEvent {
+        uint32_t timeMs    = 0;
+        bool     cancelled = false;
+    };
+
+    struct {
+        CSignal motion;
+        CSignal motionAbsolute;
+        CSignal button;
+        CSignal axis;
+        CSignal frame;
+
+        CSignal swipeBegin;
+        CSignal swipeEnd;
+        CSignal swipeUpdate;
+
+        CSignal pinchBegin;
+        CSignal pinchEnd;
+        CSignal pinchUpdate;
+
+        CSignal holdBegin;
+        CSignal holdEnd;
+    } pointerEvents;
+
+    std::string  hlName;
+    bool         connected = false; // means connected to the cursor
+
+    WP<IPointer> self;
+};

src/devices/ITouch.cpp

@@ -0,0 +1,5 @@
+#include "ITouch.hpp"
+
+uint32_t ITouch::getCapabilities() {
+    return HID_INPUT_CAPABILITY_TOUCH;
+}

src/devices/ITouch.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "IHID.hpp"
+#include "../helpers/WLListener.hpp"
+#include "../macros.hpp"
+#include "../helpers/Vector2D.hpp"
+
+struct wlr_touch;
+
+class ITouch : public IHID {
+  public:
+    virtual uint32_t   getCapabilities();
+    virtual bool       isVirtual() = 0;
+    virtual wlr_touch* wlr()       = 0;
+
+    struct SDownEvent {
+        uint32_t timeMs  = 0;
+        int32_t  touchID = 0;
+        Vector2D pos;
+    };
+
+    struct SUpEvent {
+        uint32_t timeMs  = 0;
+        int32_t  touchID = 0;
+    };
+
+    struct SMotionEvent {
+        uint32_t timeMs  = 0;
+        int32_t  touchID = 0;
+        Vector2D pos;
+    };
+
+    struct SCancelEvent {
+        uint32_t timeMs  = 0;
+        int32_t  touchID = 0;
+    };
+
+    struct {
+        CSignal down;
+        CSignal up;
+        CSignal motion;
+        CSignal cancel;
+        CSignal frame;
+    } touchEvents;
+
+    std::string hlName      = "";
+    std::string boundOutput = "";
+
+    WP<ITouch>  self;
+};

src/devices/Keyboard.cpp

@@ -0,0 +1,64 @@
+#include "Keyboard.hpp"
+#include "../defines.hpp"
+
+SP<CKeyboard> CKeyboard::create(wlr_keyboard* keeb) {
+    SP<CKeyboard> pKeeb = SP<CKeyboard>(new CKeyboard(keeb));
+
+    pKeeb->self = pKeeb;
+
+    return pKeeb;
+}
+
+bool CKeyboard::isVirtual() {
+    return false;
+}
+
+wlr_keyboard* CKeyboard::wlr() {
+    return keyboard;
+}
+
+CKeyboard::CKeyboard(wlr_keyboard* keeb) : keyboard(keeb) {
+    if (!keeb)
+        return;
+
+    // clang-format off
+    hyprListener_destroy.initCallback(&keeb->base.events.destroy, [this] (void* owner, void* data) {
+        disconnectCallbacks();
+        keyboard = nullptr;
+	events.destroy.emit();
+    }, this, "CKeyboard");
+
+    hyprListener_key.initCallback(&keeb->events.key, [this] (void* owner, void* data) {
+        auto E = (wlr_keyboard_key_event*)data;
+
+        keyboardEvents.key.emit(SKeyEvent{
+            .timeMs     = E->time_msec,
+            .keycode    = E->keycode,
+            .updateMods = E->update_state,
+            .state      = E->state,
+        });
+    }, this, "CKeyboard");
+
+    hyprListener_keymap.initCallback(&keeb->events.keymap, [this] (void* owner, void* data) {
+        keyboardEvents.keymap.emit();
+    }, this, "CKeyboard");
+
+    hyprListener_modifiers.initCallback(&keeb->events.modifiers, [this] (void* owner, void* data) {
+        keyboardEvents.modifiers.emit();
+    }, this, "CKeyboard");
+
+    hyprListener_repeatInfo.initCallback(&keeb->events.repeat_info, [this] (void* owner, void* data) {
+        keyboardEvents.repeatInfo.emit();
+    }, this, "CKeyboard");
+    // clang-format on
+
+    deviceName = keeb->base.name ? keeb->base.name : "UNKNOWN";
+}
+
+void CKeyboard::disconnectCallbacks() {
+    hyprListener_destroy.removeCallback();
+    hyprListener_key.removeCallback();
+    hyprListener_keymap.removeCallback();
+    hyprListener_repeatInfo.removeCallback();
+    hyprListener_modifiers.removeCallback();
+}

src/devices/Keyboard.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "IKeyboard.hpp"
+
+class CKeyboard : public IKeyboard {
+  public:
+    static SP<CKeyboard>  create(wlr_keyboard* keeb);
+
+    virtual bool          isVirtual();
+    virtual wlr_keyboard* wlr();
+
+  private:
+    CKeyboard(wlr_keyboard* keeb);
+
+    wlr_keyboard* keyboard = nullptr;
+
+    void          disconnectCallbacks();
+
+    DYNLISTENER(destroy);
+    DYNLISTENER(key);
+    DYNLISTENER(modifiers);
+    DYNLISTENER(keymap);
+    DYNLISTENER(repeatInfo);
+};

src/devices/Mouse.cpp

@@ -0,0 +1,169 @@
+#include "Mouse.hpp"
+#include "../defines.hpp"
+
+SP<CMouse> CMouse::create(wlr_pointer* mouse) {
+    SP<CMouse> pMouse = SP<CMouse>(new CMouse(mouse));
+
+    pMouse->self = pMouse;
+
+    return pMouse;
+}
+
+CMouse::CMouse(wlr_pointer* mouse_) : mouse(mouse_) {
+    if (!mouse)
+        return;
+
+    // clang-format off
+    hyprListener_destroy.initCallback(&mouse->base.events.destroy, [this] (void* owner, void* data) {
+        disconnectCallbacks();
+        mouse = nullptr;
+        events.destroy.emit();
+    }, this, "CMouse");
+
+    hyprListener_motion.initCallback(&mouse->events.motion, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_motion_event*)data;
+
+        pointerEvents.motion.emit(SMotionEvent{
+            .timeMs  = E->time_msec,
+            .delta   = {E->delta_x, E->delta_y},
+            .unaccel = {E->unaccel_dx, E->unaccel_dy},
+        });
+    }, this, "CMouse");
+
+    hyprListener_motionAbsolute.initCallback(&mouse->events.motion_absolute, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_motion_absolute_event*)data;
+
+        pointerEvents.motionAbsolute.emit(SMotionAbsoluteEvent{
+            .timeMs   = E->time_msec,
+            .absolute = {E->x, E->y},
+        });
+    }, this, "CMouse");
+
+    hyprListener_button.initCallback(&mouse->events.button, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_button_event*)data;
+
+        pointerEvents.button.emit(SButtonEvent{
+            .timeMs = E->time_msec,
+            .button = E->button,
+            .state  = (wl_pointer_button_state)E->state,
+        });
+    }, this, "CMouse");
+
+    hyprListener_axis.initCallback(&mouse->events.axis, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_axis_event*)data;
+
+        pointerEvents.axis.emit(SAxisEvent{
+            .timeMs            = E->time_msec,
+            .source            = E->source,
+            .axis              = E->orientation,
+            .relativeDirection = E->relative_direction,
+            .delta             = E->delta,
+            .deltaDiscrete     = E->delta_discrete,
+        });
+    }, this, "CMouse");
+
+    hyprListener_swipeBegin.initCallback(&mouse->events.swipe_begin, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_swipe_begin_event*)data;
+
+        pointerEvents.swipeBegin.emit(SSwipeBeginEvent{
+            .timeMs  = E->time_msec,
+            .fingers = E->fingers,
+        });
+    }, this, "CMouse");
+
+    hyprListener_swipeEnd.initCallback(&mouse->events.swipe_end, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_swipe_end_event*)data;
+
+        pointerEvents.swipeEnd.emit(SSwipeEndEvent{
+            .timeMs    = E->time_msec,
+            .cancelled = E->cancelled,
+        });
+    }, this, "CMouse");
+
+    hyprListener_swipeUpdate.initCallback(&mouse->events.swipe_update, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_swipe_update_event*)data;
+
+        pointerEvents.swipeUpdate.emit(SSwipeUpdateEvent{
+            .timeMs  = E->time_msec,
+            .fingers = E->fingers,
+            .delta   = {E->dx, E->dy},
+        });
+    }, this, "CMouse");
+
+    hyprListener_pinchBegin.initCallback(&mouse->events.pinch_begin, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_pinch_begin_event*)data;
+
+        pointerEvents.pinchBegin.emit(SPinchBeginEvent{
+            .timeMs    = E->time_msec,
+            .fingers   = E->fingers,
+        });
+    }, this, "CMouse");
+
+    hyprListener_pinchEnd.initCallback(&mouse->events.pinch_end, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_pinch_end_event*)data;
+
+        pointerEvents.pinchEnd.emit(SPinchEndEvent{
+            .timeMs    = E->time_msec,
+            .cancelled = E->cancelled,
+        });
+    }, this, "CMouse");
+
+    hyprListener_pinchUpdate.initCallback(&mouse->events.pinch_update, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_pinch_update_event*)data;
+
+        pointerEvents.pinchUpdate.emit(SPinchUpdateEvent{
+            .timeMs   = E->time_msec,
+            .fingers  = E->fingers,
+            .delta    = {E->dx, E->dy},
+            .scale    = E->scale,
+            .rotation = E->rotation,
+        });
+    }, this, "CMouse");
+
+    hyprListener_holdBegin.initCallback(&mouse->events.hold_begin, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_hold_begin_event*)data;
+
+        pointerEvents.holdBegin.emit(SHoldBeginEvent{
+            .timeMs  = E->time_msec,
+            .fingers = E->fingers,
+        });
+    }, this, "CMouse");
+
+    hyprListener_holdEnd.initCallback(&mouse->events.hold_end, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_hold_end_event*)data;
+
+        pointerEvents.holdEnd.emit(SHoldEndEvent{
+            .timeMs    = E->time_msec,
+            .cancelled = E->cancelled,
+        });
+    }, this, "CMouse");
+
+    // clang-format on
+
+    deviceName = mouse->base.name ? mouse->base.name : "UNKNOWN";
+}
+
+void CMouse::disconnectCallbacks() {
+    hyprListener_destroy.removeCallback();
+    hyprListener_motion.removeCallback();
+    hyprListener_motionAbsolute.removeCallback();
+    hyprListener_button.removeCallback();
+    hyprListener_axis.removeCallback();
+    hyprListener_frame.removeCallback();
+    hyprListener_swipeBegin.removeCallback();
+    hyprListener_swipeEnd.removeCallback();
+    hyprListener_swipeUpdate.removeCallback();
+    hyprListener_pinchBegin.removeCallback();
+    hyprListener_pinchEnd.removeCallback();
+    hyprListener_pinchUpdate.removeCallback();
+    hyprListener_holdBegin.removeCallback();
+    hyprListener_holdEnd.removeCallback();
+}
+
+bool CMouse::isVirtual() {
+    return false;
+}
+
+wlr_pointer* CMouse::wlr() {
+    return mouse;
+}

src/devices/Mouse.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "IPointer.hpp"
+
+class CMouse : public IPointer {
+  public:
+    static SP<CMouse>    create(wlr_pointer* mouse);
+
+    virtual bool         isVirtual();
+    virtual wlr_pointer* wlr();
+
+  private:
+    CMouse(wlr_pointer* mouse);
+
+    wlr_pointer* mouse = nullptr;
+
+    void         disconnectCallbacks();
+
+    DYNLISTENER(destroy);
+    DYNLISTENER(motion);
+    DYNLISTENER(motionAbsolute);
+    DYNLISTENER(button);
+    DYNLISTENER(axis);
+    DYNLISTENER(frame);
+
+    DYNLISTENER(swipeBegin);
+    DYNLISTENER(swipeEnd);
+    DYNLISTENER(swipeUpdate);
+
+    DYNLISTENER(pinchBegin);
+    DYNLISTENER(pinchEnd);
+    DYNLISTENER(pinchUpdate);
+
+    DYNLISTENER(holdBegin);
+    DYNLISTENER(holdEnd);
+};

src/devices/TouchDevice.cpp

@@ -0,0 +1,85 @@
+#include "TouchDevice.hpp"
+#include "../defines.hpp"
+
+SP<CTouchDevice> CTouchDevice::create(wlr_touch* touch) {
+    SP<CTouchDevice> pTouch = SP<CTouchDevice>(new CTouchDevice(touch));
+
+    pTouch->self = pTouch;
+
+    return pTouch;
+}
+
+CTouchDevice::CTouchDevice(wlr_touch* touch_) : touch(touch_) {
+    if (!touch)
+        return;
+
+    // clang-format off
+    hyprListener_destroy.initCallback(&touch->base.events.destroy, [this] (void* owner, void* data) {
+        events.destroy.emit();
+        disconnectCallbacks();
+        touch = nullptr;
+    }, this, "CTouchDevice");
+
+    hyprListener_down.initCallback(&touch->events.down, [this] (void* owner, void* data) {
+        auto E = (wlr_touch_down_event*)data;
+
+        touchEvents.down.emit(SDownEvent{
+            .timeMs  = E->time_msec,
+            .touchID = E->touch_id,
+            .pos     = {E->x, E->y},
+        });
+    }, this, "CTouchDevice");
+
+    hyprListener_up.initCallback(&touch->events.up, [this] (void* owner, void* data) {
+        auto E = (wlr_touch_up_event*)data;
+
+        touchEvents.up.emit(SUpEvent{
+            .timeMs  = E->time_msec,
+            .touchID = E->touch_id
+        });
+    }, this, "CTouchDevice");
+
+    hyprListener_motion.initCallback(&touch->events.motion, [this] (void* owner, void* data) {
+        auto E = (wlr_touch_motion_event*)data;
+
+        touchEvents.motion.emit(SMotionEvent{
+            .timeMs  = E->time_msec,
+            .touchID = E->touch_id,
+            .pos     = {E->x, E->y},
+        });
+    }, this, "CTouchDevice");
+
+    hyprListener_cancel.initCallback(&touch->events.cancel, [this] (void* owner, void* data) {
+        auto E = (wlr_touch_cancel_event*)data;
+
+        touchEvents.cancel.emit(SCancelEvent{
+            .timeMs  = E->time_msec,
+            .touchID = E->touch_id
+        });
+    }, this, "CTouchDevice");
+
+    hyprListener_frame.initCallback(&touch->events.frame, [this] (void* owner, void* data) {
+        touchEvents.frame.emit();
+    }, this, "CTouchDevice");
+
+    // clang-format on
+
+    deviceName = touch->base.name ? touch->base.name : "UNKNOWN";
+}
+
+bool CTouchDevice::isVirtual() {
+    return false;
+}
+
+wlr_touch* CTouchDevice::wlr() {
+    return touch;
+}
+
+void CTouchDevice::disconnectCallbacks() {
+    hyprListener_destroy.removeCallback();
+    hyprListener_down.removeCallback();
+    hyprListener_up.removeCallback();
+    hyprListener_motion.removeCallback();
+    hyprListener_cancel.removeCallback();
+    hyprListener_frame.removeCallback();
+}

src/devices/TouchDevice.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "ITouch.hpp"
+
+class CTouchDevice : public ITouch {
+  public:
+    static SP<CTouchDevice> create(wlr_touch* touch);
+
+    virtual bool            isVirtual();
+    virtual wlr_touch*      wlr();
+
+  private:
+    CTouchDevice(wlr_touch* touch);
+
+    wlr_touch* touch = nullptr;
+
+    void       disconnectCallbacks();
+
+    DYNLISTENER(destroy);
+    DYNLISTENER(down);
+    DYNLISTENER(up);
+    DYNLISTENER(motion);
+    DYNLISTENER(cancel);
+    DYNLISTENER(frame);
+};

src/devices/VirtualKeyboard.cpp

@@ -0,0 +1,75 @@
+#include "VirtualKeyboard.hpp"
+#include "../defines.hpp"
+#include "../protocols/VirtualKeyboard.hpp"
+
+SP<CVirtualKeyboard> CVirtualKeyboard::create(SP<CVirtualKeyboardV1Resource> keeb) {
+    SP<CVirtualKeyboard> pKeeb = SP<CVirtualKeyboard>(new CVirtualKeyboard(keeb));
+
+    pKeeb->self = pKeeb;
+
+    return pKeeb;
+}
+
+CVirtualKeyboard::CVirtualKeyboard(SP<CVirtualKeyboardV1Resource> keeb_) : keyboard(keeb_) {
+    if (!keeb_)
+        return;
+
+    auto keeb = keeb_->wlr();
+
+    // clang-format off
+    hyprListener_destroy.initCallback(&keeb->base.events.destroy, [this] (void* owner, void* data) {
+        disconnectCallbacks();
+        keyboard.reset();
+	events.destroy.emit();
+    }, this, "CVirtualKeyboard");
+
+    hyprListener_key.initCallback(&keeb->events.key, [this] (void* owner, void* data) {
+        auto E = (wlr_keyboard_key_event*)data;
+
+        keyboardEvents.key.emit(SKeyEvent{
+            .timeMs     = E->time_msec,
+            .keycode    = E->keycode,
+            .updateMods = E->update_state,
+            .state      = E->state,
+        });
+    }, this, "CVirtualKeyboard");
+
+    hyprListener_keymap.initCallback(&keeb->events.keymap, [this] (void* owner, void* data) {
+        keyboardEvents.keymap.emit();
+    }, this, "CVirtualKeyboard");
+
+    hyprListener_modifiers.initCallback(&keeb->events.modifiers, [this] (void* owner, void* data) {
+        keyboardEvents.modifiers.emit();
+    }, this, "CVirtualKeyboard");
+
+    hyprListener_repeatInfo.initCallback(&keeb->events.repeat_info, [this] (void* owner, void* data) {
+        keyboardEvents.repeatInfo.emit();
+    }, this, "CVirtualKeyboard");
+    // clang-format on
+
+    deviceName = keeb->base.name ? keeb->base.name : "UNKNOWN";
+}
+
+bool CVirtualKeyboard::isVirtual() {
+    return true;
+}
+
+wlr_keyboard* CVirtualKeyboard::wlr() {
+    if (keyboard.expired())
+        return nullptr;
+    return keyboard.lock()->wlr();
+}
+
+void CVirtualKeyboard::disconnectCallbacks() {
+    hyprListener_destroy.removeCallback();
+    hyprListener_key.removeCallback();
+    hyprListener_keymap.removeCallback();
+    hyprListener_repeatInfo.removeCallback();
+    hyprListener_modifiers.removeCallback();
+}
+
+wl_client* CVirtualKeyboard::getClient() {
+    if (keyboard.expired())
+        return nullptr;
+    return keyboard.lock()->client();
+}

src/devices/VirtualKeyboard.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "IKeyboard.hpp"
+
+class CVirtualKeyboardV1Resource;
+
+class CVirtualKeyboard : public IKeyboard {
+  public:
+    static SP<CVirtualKeyboard> create(SP<CVirtualKeyboardV1Resource> keeb);
+
+    virtual bool                isVirtual();
+    virtual wlr_keyboard*       wlr();
+
+    wl_client*                  getClient();
+
+  private:
+    CVirtualKeyboard(SP<CVirtualKeyboardV1Resource> keeb);
+
+    WP<CVirtualKeyboardV1Resource> keyboard;
+
+    void                           disconnectCallbacks();
+
+    DYNLISTENER(destroy);
+    DYNLISTENER(key);
+    DYNLISTENER(modifiers);
+    DYNLISTENER(keymap);
+    DYNLISTENER(repeatInfo);
+};

src/devices/VirtualPointer.cpp

@@ -0,0 +1,172 @@
+#include "VirtualPointer.hpp"
+#include "../protocols/VirtualPointer.hpp"
+
+SP<CVirtualPointer> CVirtualPointer::create(SP<CVirtualPointerV1Resource> resource) {
+    SP<CVirtualPointer> pPointer = SP<CVirtualPointer>(new CVirtualPointer(resource));
+
+    pPointer->self = pPointer;
+
+    return pPointer;
+}
+
+CVirtualPointer::CVirtualPointer(SP<CVirtualPointerV1Resource> resource) : pointer(resource) {
+    if (!resource->good())
+        return;
+
+    auto mouse = resource->wlr();
+
+    // clang-format off
+    hyprListener_destroy.initCallback(&mouse->base.events.destroy, [this] (void* owner, void* data) {
+        disconnectCallbacks();
+        events.destroy.emit();
+    }, this, "CVirtualPointer");
+
+    hyprListener_motion.initCallback(&mouse->events.motion, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_motion_event*)data;
+
+        pointerEvents.motion.emit(SMotionEvent{
+            .timeMs  = E->time_msec,
+            .delta   = {E->delta_x, E->delta_y},
+            .unaccel = {E->unaccel_dx, E->unaccel_dy},
+        });
+    }, this, "CVirtualPointer");
+
+    hyprListener_motionAbsolute.initCallback(&mouse->events.motion_absolute, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_motion_absolute_event*)data;
+
+        pointerEvents.motionAbsolute.emit(SMotionAbsoluteEvent{
+            .timeMs   = E->time_msec,
+            .absolute = {E->x, E->y},
+        });
+    }, this, "CVirtualPointer");
+
+    hyprListener_button.initCallback(&mouse->events.button, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_button_event*)data;
+
+        pointerEvents.button.emit(SButtonEvent{
+            .timeMs = E->time_msec,
+            .button = E->button,
+            .state  = (wl_pointer_button_state)E->state,
+        });
+    }, this, "CVirtualPointer");
+
+    hyprListener_axis.initCallback(&mouse->events.axis, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_axis_event*)data;
+
+        pointerEvents.axis.emit(SAxisEvent{
+            .timeMs            = E->time_msec,
+            .source            = E->source,
+            .axis              = E->orientation,
+            .relativeDirection = E->relative_direction,
+            .delta             = E->delta,
+            .deltaDiscrete     = E->delta_discrete,
+        });
+    }, this, "CVirtualPointer");
+
+    hyprListener_swipeBegin.initCallback(&mouse->events.swipe_begin, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_swipe_begin_event*)data;
+
+        pointerEvents.swipeBegin.emit(SSwipeBeginEvent{
+            .timeMs  = E->time_msec,
+            .fingers = E->fingers,
+        });
+    }, this, "CVirtualPointer");
+
+    hyprListener_swipeEnd.initCallback(&mouse->events.swipe_end, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_swipe_end_event*)data;
+
+        pointerEvents.swipeEnd.emit(SSwipeEndEvent{
+            .timeMs    = E->time_msec,
+            .cancelled = E->cancelled,
+        });
+    }, this, "CVirtualPointer");
+
+    hyprListener_swipeUpdate.initCallback(&mouse->events.swipe_update, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_swipe_update_event*)data;
+
+        pointerEvents.swipeUpdate.emit(SSwipeUpdateEvent{
+            .timeMs  = E->time_msec,
+            .fingers = E->fingers,
+            .delta   = {E->dx, E->dy},
+        });
+    }, this, "CVirtualPointer");
+
+    hyprListener_pinchBegin.initCallback(&mouse->events.pinch_begin, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_pinch_begin_event*)data;
+
+        pointerEvents.pinchBegin.emit(SPinchBeginEvent{
+            .timeMs    = E->time_msec,
+            .fingers   = E->fingers,
+        });
+    }, this, "CVirtualPointer");
+
+    hyprListener_pinchEnd.initCallback(&mouse->events.pinch_end, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_pinch_end_event*)data;
+
+        pointerEvents.pinchEnd.emit(SPinchEndEvent{
+            .timeMs    = E->time_msec,
+            .cancelled = E->cancelled,
+        });
+    }, this, "CVirtualPointer");
+
+    hyprListener_pinchUpdate.initCallback(&mouse->events.pinch_update, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_pinch_update_event*)data;
+
+        pointerEvents.pinchUpdate.emit(SPinchUpdateEvent{
+            .timeMs   = E->time_msec,
+            .fingers  = E->fingers,
+            .delta    = {E->dx, E->dy},
+            .scale    = E->scale,
+            .rotation = E->rotation,
+        });
+    }, this, "CVirtualPointer");
+
+    hyprListener_holdBegin.initCallback(&mouse->events.hold_begin, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_hold_begin_event*)data;
+
+        pointerEvents.holdBegin.emit(SHoldBeginEvent{
+            .timeMs  = E->time_msec,
+            .fingers = E->fingers,
+        });
+    }, this, "CVirtualPointer");
+
+    hyprListener_holdEnd.initCallback(&mouse->events.hold_end, [this] (void* owner, void* data) {
+        auto E = (wlr_pointer_hold_end_event*)data;
+
+        pointerEvents.holdEnd.emit(SHoldEndEvent{
+            .timeMs    = E->time_msec,
+            .cancelled = E->cancelled,
+        });
+    }, this, "CVirtualPointer");
+
+    // clang-format on
+
+    deviceName = mouse->base.name ? mouse->base.name : "UNKNOWN";
+}
+
+bool CVirtualPointer::isVirtual() {
+    return true;
+}
+
+void CVirtualPointer::disconnectCallbacks() {
+    hyprListener_destroy.removeCallback();
+    hyprListener_motion.removeCallback();
+    hyprListener_motionAbsolute.removeCallback();
+    hyprListener_button.removeCallback();
+    hyprListener_axis.removeCallback();
+    hyprListener_frame.removeCallback();
+    hyprListener_swipeBegin.removeCallback();
+    hyprListener_swipeEnd.removeCallback();
+    hyprListener_swipeUpdate.removeCallback();
+    hyprListener_pinchBegin.removeCallback();
+    hyprListener_pinchEnd.removeCallback();
+    hyprListener_pinchUpdate.removeCallback();
+    hyprListener_holdBegin.removeCallback();
+    hyprListener_holdEnd.removeCallback();
+}
+
+wlr_pointer* CVirtualPointer::wlr() {
+    if (pointer.expired())
+        return nullptr;
+    return pointer.lock()->wlr();
+}

src/devices/VirtualPointer.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "IPointer.hpp"
+
+class CVirtualPointerV1Resource;
+
+class CVirtualPointer : public IPointer {
+  public:
+    static SP<CVirtualPointer> create(SP<CVirtualPointerV1Resource> resource);
+
+    virtual bool               isVirtual();
+    virtual wlr_pointer*       wlr();
+
+  private:
+    CVirtualPointer(SP<CVirtualPointerV1Resource>);
+
+    WP<CVirtualPointerV1Resource> pointer;
+
+    void                          disconnectCallbacks();
+
+    DYNLISTENER(destroy);
+    DYNLISTENER(motion);
+    DYNLISTENER(motionAbsolute);
+    DYNLISTENER(button);
+    DYNLISTENER(axis);
+    DYNLISTENER(frame);
+
+    DYNLISTENER(swipeBegin);
+    DYNLISTENER(swipeEnd);
+    DYNLISTENER(swipeUpdate);
+
+    DYNLISTENER(pinchBegin);
+    DYNLISTENER(pinchEnd);
+    DYNLISTENER(pinchUpdate);
+
+    DYNLISTENER(holdBegin);
+    DYNLISTENER(holdEnd);
+};

src/events/Devices.cpp

@@ -4,6 +4,7 @@
 #include "../helpers/WLClasses.hpp"
 #include "../managers/input/InputManager.hpp"
 #include "../render/Renderer.hpp"
+#include "../protocols/PointerGestures.hpp"
 
 // ---------------------------------------------------- //
 //   _____  ________      _______ _____ ______  _____   //
@@ -15,23 +16,6 @@
 //                                                      //
 // ---------------------------------------------------- //
 
-void Events::listener_keyboardDestroy(void* owner, void* data) {
-    SKeyboard* PKEYBOARD = (SKeyboard*)owner;
-    g_pInputManager->destroyKeyboard(PKEYBOARD);
-
-    Debug::log(LOG, "Destroyed keyboard {:x}", (uintptr_t)PKEYBOARD);
-}
-
-void Events::listener_keyboardKey(void* owner, void* data) {
-    SKeyboard* PKEYBOARD = (SKeyboard*)owner;
-    g_pInputManager->onKeyboardKey((wlr_keyboard_key_event*)data, PKEYBOARD);
-}
-
-void Events::listener_keyboardMod(void* owner, void* data) {
-    SKeyboard* PKEYBOARD = (SKeyboard*)owner;
-    g_pInputManager->onKeyboardMod(data, PKEYBOARD);
-}
-
 void Events::listener_mouseFrame(wl_listener* listener, void* data) {
     wlr_seat_pointer_notify_frame(g_pCompositor->m_sSeat.seat);
 }
@@ -92,35 +76,6 @@ void Events::listener_newInput(wl_listener* listener, void* data) {
     g_pInputManager->updateCapabilities();
 }
 
-void Events::listener_newConstraint(wl_listener* listener, void* data) {
-    const auto PCONSTRAINT = (wlr_pointer_constraint_v1*)data;
-
-    Debug::log(LOG, "New mouse constraint at {:x}", (uintptr_t)PCONSTRAINT);
-
-    const auto SURFACE = CWLSurface::surfaceFromWlr(PCONSTRAINT->surface);
-
-    if (!SURFACE) {
-        Debug::log(ERR, "Refusing a constraint from an unassigned wl_surface {:x}", (uintptr_t)PCONSTRAINT->surface);
-        return;
-    }
-
-    SURFACE->appendConstraint(PCONSTRAINT);
-}
-
-void Events::listener_newVirtPtr(wl_listener* listener, void* data) {
-    const auto EV      = (wlr_virtual_pointer_v1_new_pointer_event*)data;
-    const auto POINTER = EV->new_pointer;
-    const auto DEVICE  = &POINTER->pointer.base;
-
-    g_pInputManager->newMouse(DEVICE, true);
-}
-
-void Events::listener_destroyMouse(void* owner, void* data) {
-    const auto PMOUSE = (SMouse*)owner;
-
-    g_pInputManager->destroyMouse(PMOUSE->mouse);
-}
-
 void Events::listener_swipeBegin(wl_listener* listener, void* data) {
     const auto EVENT = (wlr_pointer_swipe_begin_event*)data;
 
@@ -141,23 +96,17 @@ void Events::listener_swipeEnd(wl_listener* listener, void* data) {
 
 void Events::listener_pinchBegin(wl_listener* listener, void* data) {
     const auto EV = (wlr_pointer_pinch_begin_event*)data;
-    wlr_pointer_gestures_v1_send_pinch_begin(g_pCompositor->m_sWLRPointerGestures, g_pCompositor->m_sSeat.seat, EV->time_msec, EV->fingers);
+    PROTO::pointerGestures->pinchBegin(EV->time_msec, EV->fingers);
 }
 
 void Events::listener_pinchUpdate(wl_listener* listener, void* data) {
     const auto EV = (wlr_pointer_pinch_update_event*)data;
-    wlr_pointer_gestures_v1_send_pinch_update(g_pCompositor->m_sWLRPointerGestures, g_pCompositor->m_sSeat.seat, EV->time_msec, EV->dx, EV->dy, EV->scale, EV->rotation);
+    PROTO::pointerGestures->pinchUpdate(EV->time_msec, {EV->dx, EV->dy}, EV->scale, EV->rotation);
 }
 
 void Events::listener_pinchEnd(wl_listener* listener, void* data) {
     const auto EV = (wlr_pointer_pinch_end_event*)data;
-    wlr_pointer_gestures_v1_send_pinch_end(g_pCompositor->m_sWLRPointerGestures, g_pCompositor->m_sSeat.seat, EV->time_msec, EV->cancelled);
-}
-
-void Events::listener_newVirtualKeyboard(wl_listener* listener, void* data) {
-    const auto WLRKB = (wlr_virtual_keyboard_v1*)data;
-
-    g_pInputManager->newVirtualKeyboard(&WLRKB->keyboard.base);
+    PROTO::pointerGestures->pinchEnd(EV->time_msec, EV->cancelled);
 }
 
 void Events::listener_touchBegin(wl_listener* listener, void* data) {
@@ -177,9 +126,11 @@ void Events::listener_touchFrame(wl_listener* listener, void* data) {
 }
 
 void Events::listener_holdBegin(wl_listener* listener, void* data) {
-    g_pInputManager->onPointerHoldBegin((wlr_pointer_hold_begin_event*)data);
+    const auto EV = (wlr_pointer_hold_begin_event*)data;
+    PROTO::pointerGestures->holdBegin(EV->time_msec, EV->fingers);
 }
 
 void Events::listener_holdEnd(wl_listener* listener, void* data) {
-    g_pInputManager->onPointerHoldEnd((wlr_pointer_hold_end_event*)data);
+    const auto EV = (wlr_pointer_hold_end_event*)data;
+    PROTO::pointerGestures->holdEnd(EV->time_msec, EV->cancelled);
 }

src/events/Events.hpp

@@ -17,14 +17,9 @@ namespace Events {
 
     // Layer events
     LISTENER(newLayerSurface);
-    DYNLISTENFUNC(destroyLayerSurface);
-    DYNLISTENFUNC(mapLayerSurface);
-    DYNLISTENFUNC(unmapLayerSurface);
-    DYNLISTENFUNC(commitLayerSurface);
 
     // Surface XDG (window)
     LISTENER(newXDGToplevel);
-    LISTENER(activateXDG);
 
     // Window events
     DYNLISTENFUNC(commitWindow);
@@ -59,23 +54,12 @@ namespace Events {
 
     // Virt Ptr
     LISTENER(newVirtPtr);
-    DYNLISTENFUNC(destroyMouse);
-
-    DYNLISTENFUNC(keyboardKey);
-    DYNLISTENFUNC(keyboardMod);
-    DYNLISTENFUNC(keyboardDestroy);
-
-    LISTENER(newConstraint);
 
     // Various
     LISTENER(requestMouse);
     LISTENER(requestSetSel);
     LISTENER(requestSetPrimarySel);
 
-    // outputMgr
-    LISTENER(outputMgrApply);
-    LISTENER(outputMgrTest);
-
     // Monitor part 2 the sequel
     DYNLISTENFUNC(monitorFrame);
     DYNLISTENFUNC(monitorDestroy);
@@ -99,14 +83,9 @@ namespace Events {
     DYNLISTENFUNC(destroyDragIcon);
     DYNLISTENFUNC(commitDragIcon);
 
-    // Deco XDG
-    LISTENER(NewXDGDeco);
-
     // Renderer destroy
     LISTENER(RendererDestroy);
 
-    LISTENER(newIdleInhibitor);
-
     // session
     LISTENER(sessionActive);
 
@@ -118,14 +97,6 @@ namespace Events {
     LISTENER(pinchUpdate);
     LISTENER(pinchEnd);
 
-    // Power
-    LISTENER(powerMgrSetMode);
-
-    // IME
-    LISTENER(newIME);
-    LISTENER(newTextInput);
-    LISTENER(newVirtualKeyboard);
-
     // Touch
     LISTENER(touchBegin);
     LISTENER(touchEnd);
@@ -137,16 +108,4 @@ namespace Events {
 
     // Session Lock
     LISTENER(newSessionLock);
-
-    // Gamma control
-    LISTENER(setGamma);
-
-    // Cursor shape
-    LISTENER(setCursorShape);
-
-    // Tearing hints
-    LISTENER(newTearingHint);
-
-    // Shortcut inhibitor
-    LISTENER(newShortcutInhibitor);
 };

src/events/Layers.cpp

@@ -1,364 +0,0 @@
-#include "../Compositor.hpp"
-#include "../helpers/WLClasses.hpp"
-#include "../managers/input/InputManager.hpp"
-#include "../render/Renderer.hpp"
-#include "Events.hpp"
-
-// --------------------------------------------- //
-//    _           __     ________ _____   _____  //
-//  | |        /\\ \   / /  ____|  __ \ / ____|  //
-//  | |       /  \\ \_/ /| |__  | |__) | (___    //
-//  | |      / /\ \\   / |  __| |  _  / \___ \   //
-//  | |____ / ____ \| |  | |____| | \ \ ____) |  //
-//  |______/_/    \_\_|  |______|_|  \_\_____/   //
-//                                               //
-// --------------------------------------------- //
-
-void Events::listener_newLayerSurface(wl_listener* listener, void* data) {
-    const auto WLRLAYERSURFACE = (wlr_layer_surface_v1*)data;
-
-    if (!WLRLAYERSURFACE->output) {
-        const auto PMONITOR = g_pCompositor->getMonitorFromCursor();
-
-        if (!PMONITOR) {
-            Debug::log(ERR, "No monitor at cursor on new layer without a monitor. Ignoring.");
-            wlr_layer_surface_v1_destroy(WLRLAYERSURFACE);
-            return;
-        }
-
-        Debug::log(LOG, "New LayerSurface has no preferred monitor. Assigning Monitor {}", PMONITOR->szName);
-
-        WLRLAYERSURFACE->output = PMONITOR->output;
-    }
-
-    auto PMONITOR = (CMonitor*)g_pCompositor->getMonitorFromOutput(WLRLAYERSURFACE->output);
-
-    if (!WLRLAYERSURFACE->output || !PMONITOR || PMONITOR->pMirrorOf) {
-        PMONITOR                = g_pCompositor->m_vMonitors.front().get();
-        WLRLAYERSURFACE->output = PMONITOR->output; // TODO: current mon
-    }
-
-    SLayerSurface* layerSurface = PMONITOR->m_aLayerSurfaceLayers[WLRLAYERSURFACE->pending.layer].emplace_back(std::make_unique<SLayerSurface>()).get();
-
-    layerSurface->szNamespace = WLRLAYERSURFACE->_namespace;
-
-    layerSurface->hyprListener_commitLayerSurface.initCallback(&WLRLAYERSURFACE->surface->events.commit, &Events::listener_commitLayerSurface, layerSurface, "layerSurface");
-    layerSurface->hyprListener_destroyLayerSurface.initCallback(&WLRLAYERSURFACE->events.destroy, &Events::listener_destroyLayerSurface, layerSurface, "layerSurface");
-    layerSurface->hyprListener_mapLayerSurface.initCallback(&WLRLAYERSURFACE->surface->events.map, &Events::listener_mapLayerSurface, layerSurface, "layerSurface");
-    layerSurface->hyprListener_unmapLayerSurface.initCallback(&WLRLAYERSURFACE->surface->events.unmap, &Events::listener_unmapLayerSurface, layerSurface, "layerSurface");
-
-    layerSurface->layerSurface = WLRLAYERSURFACE;
-    layerSurface->layer        = WLRLAYERSURFACE->current.layer;
-    WLRLAYERSURFACE->data      = layerSurface;
-    layerSurface->monitorID    = PMONITOR->ID;
-    layerSurface->popupHead    = std::make_unique<CPopup>(layerSurface);
-
-    layerSurface->forceBlur = g_pConfigManager->shouldBlurLS(layerSurface->szNamespace);
-
-    Debug::log(LOG, "LayerSurface {:x} (namespace {} layer {}) created on monitor {}", (uintptr_t)layerSurface->layerSurface, layerSurface->layerSurface->_namespace,
-               (int)layerSurface->layer, PMONITOR->szName);
-}
-
-void Events::listener_destroyLayerSurface(void* owner, void* data) {
-    SLayerSurface* layersurface = (SLayerSurface*)owner;
-
-    Debug::log(LOG, "LayerSurface {:x} destroyed", (uintptr_t)layersurface->layerSurface);
-
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(layersurface->monitorID);
-
-    layersurface->popupHead.reset();
-
-    if (!g_pCompositor->getMonitorFromID(layersurface->monitorID))
-        Debug::log(WARN, "Layersurface destroyed on an invalid monitor (removed?)");
-
-    if (!layersurface->fadingOut) {
-        if (layersurface->mapped) {
-            Debug::log(LOG, "Forcing an unmap of a LS that did a straight destroy!");
-            listener_unmapLayerSurface(layersurface, nullptr);
-        } else {
-            Debug::log(LOG, "Removing LayerSurface that wasn't mapped.");
-            layersurface->alpha.setValueAndWarp(0.f);
-            layersurface->fadingOut = true;
-            g_pCompositor->addToFadingOutSafe(layersurface);
-        }
-    }
-
-    layersurface->noProcess = true;
-
-    layersurface->hyprListener_commitLayerSurface.removeCallback();
-    layersurface->hyprListener_destroyLayerSurface.removeCallback();
-    layersurface->hyprListener_mapLayerSurface.removeCallback();
-    layersurface->hyprListener_unmapLayerSurface.removeCallback();
-
-    // rearrange to fix the reserved areas
-    if (PMONITOR) {
-        g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
-        PMONITOR->scheduledRecalc = true;
-
-        // and damage
-        CBox geomFixed = {layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y, layersurface->geometry.width,
-                          layersurface->geometry.height};
-        g_pHyprRenderer->damageBox(&geomFixed);
-    }
-
-    layersurface->readyToDelete = true;
-    layersurface->layerSurface  = nullptr;
-}
-
-void Events::listener_mapLayerSurface(void* owner, void* data) {
-    SLayerSurface* layersurface = (SLayerSurface*)owner;
-
-    Debug::log(LOG, "LayerSurface {:x} mapped", (uintptr_t)layersurface->layerSurface);
-
-    layersurface->mapped            = true;
-    layersurface->keyboardExclusive = layersurface->layerSurface->current.keyboard_interactive;
-    layersurface->surface           = layersurface->layerSurface->surface;
-
-    // fix if it changed its mon
-    const auto PMONITOR = g_pCompositor->getMonitorFromOutput(layersurface->layerSurface->output);
-
-    if (!PMONITOR)
-        return;
-
-    layersurface->applyRules();
-
-    if ((uint64_t)layersurface->monitorID != PMONITOR->ID) {
-        const auto POLDMON = g_pCompositor->getMonitorFromID(layersurface->monitorID);
-        for (auto it = POLDMON->m_aLayerSurfaceLayers[layersurface->layer].begin(); it != POLDMON->m_aLayerSurfaceLayers[layersurface->layer].end(); it++) {
-            if (it->get() == layersurface) {
-                PMONITOR->m_aLayerSurfaceLayers[layersurface->layer].emplace_back(std::move(*it));
-                POLDMON->m_aLayerSurfaceLayers[layersurface->layer].erase(it);
-                break;
-            }
-        }
-        layersurface->monitorID   = PMONITOR->ID;
-        PMONITOR->scheduledRecalc = true;
-        g_pHyprRenderer->arrangeLayersForMonitor(POLDMON->ID);
-    }
-
-    g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
-
-    wlr_surface_send_enter(layersurface->layerSurface->surface, layersurface->layerSurface->output);
-
-    if (layersurface->layerSurface->current.keyboard_interactive == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE)
-        g_pInputManager->m_dExclusiveLSes.push_back(layersurface);
-
-    const bool GRABSFOCUS = layersurface->layerSurface->current.keyboard_interactive != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE &&
-        // don't focus if constrained
-        (!g_pCompositor->m_sSeat.mouse || !g_pInputManager->isConstrained());
-
-    if (GRABSFOCUS) {
-        g_pInputManager->releaseAllMouseButtons();
-        g_pCompositor->focusSurface(layersurface->layerSurface->surface);
-
-        const auto LOCAL =
-            g_pInputManager->getMouseCoordsInternal() - Vector2D(layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y);
-        wlr_seat_pointer_notify_enter(g_pCompositor->m_sSeat.seat, layersurface->layerSurface->surface, LOCAL.x, LOCAL.y);
-        wlr_seat_pointer_notify_motion(g_pCompositor->m_sSeat.seat, 0, LOCAL.x, LOCAL.y);
-        g_pInputManager->m_bEmptyFocusCursorSet = false;
-    }
-
-    layersurface->position = Vector2D(layersurface->geometry.x, layersurface->geometry.y);
-
-    CBox geomFixed = {layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y, layersurface->geometry.width,
-                      layersurface->geometry.height};
-    g_pHyprRenderer->damageBox(&geomFixed);
-    const auto WORKSPACE  = PMONITOR->activeWorkspace;
-    const bool FULLSCREEN = WORKSPACE->m_bHasFullscreenWindow && WORKSPACE->m_efFullscreenMode == FULLSCREEN_FULL;
-
-    layersurface->startAnimation(!(layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP && FULLSCREEN && !GRABSFOCUS));
-    layersurface->readyToDelete = false;
-    layersurface->fadingOut     = false;
-
-    g_pEventManager->postEvent(SHyprIPCEvent{"openlayer", std::string(layersurface->layerSurface->_namespace ? layersurface->layerSurface->_namespace : "")});
-    EMIT_HOOK_EVENT("openLayer", layersurface);
-
-    g_pCompositor->setPreferredScaleForSurface(layersurface->layerSurface->surface, PMONITOR->scale);
-    g_pCompositor->setPreferredTransformForSurface(layersurface->layerSurface->surface, PMONITOR->transform);
-}
-
-void Events::listener_unmapLayerSurface(void* owner, void* data) {
-    SLayerSurface* layersurface = (SLayerSurface*)owner;
-
-    Debug::log(LOG, "LayerSurface {:x} unmapped", (uintptr_t)layersurface->layerSurface);
-
-    g_pEventManager->postEvent(SHyprIPCEvent{"closelayer", std::string(layersurface->layerSurface->_namespace ? layersurface->layerSurface->_namespace : "")});
-    EMIT_HOOK_EVENT("closeLayer", layersurface);
-
-    std::erase(g_pInputManager->m_dExclusiveLSes, layersurface);
-
-    if (!g_pInputManager->m_dExclusiveLSes.empty())
-        g_pCompositor->focusSurface(g_pInputManager->m_dExclusiveLSes[0]->layerSurface->surface);
-
-    if (!g_pCompositor->getMonitorFromID(layersurface->monitorID) || g_pCompositor->m_bUnsafeState) {
-        Debug::log(WARN, "Layersurface unmapping on invalid monitor (removed?) ignoring.");
-
-        g_pCompositor->addToFadingOutSafe(layersurface);
-
-        layersurface->mapped = false;
-
-        layersurface->startAnimation(false);
-        return;
-    }
-
-    // make a snapshot and start fade
-    g_pHyprOpenGL->makeLayerSnapshot(layersurface);
-
-    layersurface->startAnimation(false);
-
-    layersurface->mapped = false;
-
-    g_pCompositor->addToFadingOutSafe(layersurface);
-
-    const auto PMONITOR = g_pCompositor->getMonitorFromOutput(layersurface->layerSurface->output);
-
-    const bool WASLASTFOCUS = g_pCompositor->m_pLastFocus == layersurface->layerSurface->surface;
-
-    layersurface->surface = nullptr;
-
-    if (!PMONITOR)
-        return;
-
-    // refocus if needed
-    if (WASLASTFOCUS) {
-        g_pInputManager->releaseAllMouseButtons();
-
-        Vector2D       surfaceCoords;
-        SLayerSurface* pFoundLayerSurface = nullptr;
-        wlr_surface*   foundSurface       = nullptr;
-
-        g_pCompositor->m_pLastFocus = nullptr;
-
-        // find LS-es to focus
-        foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
-                                                           &surfaceCoords, &pFoundLayerSurface);
-
-        if (!foundSurface)
-            foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
-                                                               &surfaceCoords, &pFoundLayerSurface);
-
-        if (!foundSurface && g_pCompositor->m_pLastWindow && g_pCompositor->isWorkspaceVisible(g_pCompositor->m_pLastWindow->m_pWorkspace)) {
-            // if there isn't any, focus the last window
-            const auto PLASTWINDOW = g_pCompositor->m_pLastWindow;
-            g_pCompositor->focusWindow(nullptr);
-            g_pCompositor->focusWindow(PLASTWINDOW);
-        } else {
-            // otherwise, full refocus
-            g_pInputManager->refocus();
-        }
-    }
-
-    CBox geomFixed = {layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y, layersurface->geometry.width,
-                      layersurface->geometry.height};
-    g_pHyprRenderer->damageBox(&geomFixed);
-
-    geomFixed = {layersurface->geometry.x + (int)PMONITOR->vecPosition.x, layersurface->geometry.y + (int)PMONITOR->vecPosition.y,
-                 (int)layersurface->layerSurface->surface->current.width, (int)layersurface->layerSurface->surface->current.height};
-    g_pHyprRenderer->damageBox(&geomFixed);
-
-    g_pInputManager->sendMotionEventsToFocused();
-}
-
-void Events::listener_commitLayerSurface(void* owner, void* data) {
-    SLayerSurface* layersurface = (SLayerSurface*)owner;
-
-    if (!layersurface->layerSurface || !layersurface->layerSurface->output)
-        return;
-
-    const auto PMONITOR = g_pCompositor->getMonitorFromOutput(layersurface->layerSurface->output);
-
-    if (!PMONITOR)
-        return;
-
-    if (layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND || layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM)
-        g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR); // so that blur is recalc'd
-
-    CBox geomFixed = {layersurface->geometry.x, layersurface->geometry.y, layersurface->geometry.width, layersurface->geometry.height};
-    g_pHyprRenderer->damageBox(&geomFixed);
-
-    // fix if it changed its mon
-    if ((uint64_t)layersurface->monitorID != PMONITOR->ID) {
-        const auto POLDMON = g_pCompositor->getMonitorFromID(layersurface->monitorID);
-
-        for (auto it = POLDMON->m_aLayerSurfaceLayers[layersurface->layer].begin(); it != POLDMON->m_aLayerSurfaceLayers[layersurface->layer].end(); it++) {
-            if (it->get() == layersurface) {
-                PMONITOR->m_aLayerSurfaceLayers[layersurface->layer].emplace_back(std::move(*it));
-                POLDMON->m_aLayerSurfaceLayers[layersurface->layer].erase(it);
-                break;
-            }
-        }
-
-        layersurface->monitorID   = PMONITOR->ID;
-        PMONITOR->scheduledRecalc = true;
-        g_pHyprRenderer->arrangeLayersForMonitor(POLDMON->ID);
-    }
-
-    if (layersurface->layerSurface->current.committed != 0) {
-        if (layersurface->layer != layersurface->layerSurface->current.layer) {
-
-            for (auto it = PMONITOR->m_aLayerSurfaceLayers[layersurface->layer].begin(); it != PMONITOR->m_aLayerSurfaceLayers[layersurface->layer].end(); it++) {
-                if (it->get() == layersurface) {
-                    PMONITOR->m_aLayerSurfaceLayers[layersurface->layerSurface->current.layer].emplace_back(std::move(*it));
-                    PMONITOR->m_aLayerSurfaceLayers[layersurface->layer].erase(it);
-                    break;
-                }
-            }
-
-            layersurface->layer = layersurface->layerSurface->current.layer;
-
-            if (layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND || layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM)
-                g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR); // so that blur is recalc'd
-        }
-
-        g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
-
-        PMONITOR->scheduledRecalc = true;
-    } else {
-        layersurface->position = Vector2D(layersurface->geometry.x, layersurface->geometry.y);
-
-        // update geom if it changed
-        if (layersurface->layerSurface->surface->current.scale == 1 && PMONITOR->scale != 1.f && layersurface->layerSurface->surface->current.viewport.has_dst) {
-            // fractional scaling. Dirty hack.
-            layersurface->geometry = {layersurface->geometry.x, layersurface->geometry.y, (int)(layersurface->layerSurface->surface->current.viewport.dst_width),
-                                      (int)(layersurface->layerSurface->surface->current.viewport.dst_height)};
-        } else {
-            // this is because some apps like e.g. rofi-lbonn can't fucking use the protocol correctly.
-            layersurface->geometry = {layersurface->geometry.x, layersurface->geometry.y, (int)layersurface->layerSurface->surface->current.width,
-                                      (int)layersurface->layerSurface->surface->current.height};
-        }
-    }
-
-    if (layersurface->realPosition.goal() != layersurface->geometry.pos()) {
-        if (layersurface->realPosition.isBeingAnimated())
-            layersurface->realPosition = layersurface->geometry.pos();
-        else
-            layersurface->realPosition.setValueAndWarp(layersurface->geometry.pos());
-    }
-    if (layersurface->realSize.goal() != layersurface->geometry.size()) {
-        if (layersurface->realSize.isBeingAnimated())
-            layersurface->realSize = layersurface->geometry.size();
-        else
-            layersurface->realSize.setValueAndWarp(layersurface->geometry.size());
-    }
-
-    if (layersurface->layerSurface->current.keyboard_interactive && (!g_pCompositor->m_sSeat.mouse || !g_pInputManager->isConstrained()) // don't focus if constrained
-        && !layersurface->keyboardExclusive && layersurface->mapped) {
-        g_pCompositor->focusSurface(layersurface->layerSurface->surface);
-
-        const auto LOCAL =
-            g_pInputManager->getMouseCoordsInternal() - Vector2D(layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y);
-        wlr_seat_pointer_notify_enter(g_pCompositor->m_sSeat.seat, layersurface->layerSurface->surface, LOCAL.x, LOCAL.y);
-        wlr_seat_pointer_notify_motion(g_pCompositor->m_sSeat.seat, 0, LOCAL.x, LOCAL.y);
-        g_pInputManager->m_bEmptyFocusCursorSet = false;
-    } else if (!layersurface->layerSurface->current.keyboard_interactive && (!g_pCompositor->m_sSeat.mouse || !g_pInputManager->isConstrained()) &&
-               layersurface->keyboardExclusive) {
-        g_pInputManager->refocus();
-    }
-
-    layersurface->keyboardExclusive = layersurface->layerSurface->current.keyboard_interactive;
-
-    g_pHyprRenderer->damageSurface(layersurface->layerSurface->surface, layersurface->position.x, layersurface->position.y);
-
-    g_pCompositor->setPreferredScaleForSurface(layersurface->layerSurface->surface, PMONITOR->scale);
-    g_pCompositor->setPreferredTransformForSurface(layersurface->layerSurface->surface, PMONITOR->transform);
-}

src/events/Misc.cpp

@@ -16,16 +16,6 @@
 //                                //
 // ------------------------------ //
 
-void Events::listener_outputMgrApply(wl_listener* listener, void* data) {
-    const auto CONFIG = (wlr_output_configuration_v1*)data;
-    g_pHyprRenderer->outputMgrApplyTest(CONFIG, false);
-}
-
-void Events::listener_outputMgrTest(wl_listener* listener, void* data) {
-    const auto CONFIG = (wlr_output_configuration_v1*)data;
-    g_pHyprRenderer->outputMgrApplyTest(CONFIG, true);
-}
-
 void Events::listener_leaseRequest(wl_listener* listener, void* data) {
     const auto               REQUEST = (wlr_drm_lease_request_v1*)data;
     struct wlr_drm_lease_v1* lease   = wlr_drm_lease_request_v1_grant(REQUEST);
@@ -141,7 +131,8 @@ void Events::listener_destroyDrag(void* owner, void* data) {
     g_pInputManager->m_sDrag.dragIcon = nullptr;
     g_pInputManager->m_sDrag.hyprListener_destroy.removeCallback();
 
-    g_pCompositor->focusWindow(g_pCompositor->m_pLastWindow, g_pCompositor->m_pLastWindow ? g_pXWaylandManager->getWindowSurface(g_pCompositor->m_pLastWindow) : nullptr);
+    g_pCompositor->focusWindow(g_pCompositor->m_pLastWindow.lock(),
+                               g_pCompositor->m_pLastWindow.lock() ? g_pXWaylandManager->getWindowSurface(g_pCompositor->m_pLastWindow.lock()) : nullptr);
 }
 
 void Events::listener_mapDragIcon(void* owner, void* data) {
@@ -186,109 +177,3 @@ void Events::listener_sessionActive(wl_listener* listener, void* data) {
 
     g_pConfigManager->m_bWantsMonitorReload = true;
 }
-
-void Events::listener_powerMgrSetMode(wl_listener* listener, void* data) {
-    Debug::log(LOG, "PowerMgr set mode!");
-
-    const auto EVENT    = (wlr_output_power_v1_set_mode_event*)data;
-    const auto PMONITOR = g_pCompositor->getMonitorFromOutput(EVENT->output);
-
-    if (!PMONITOR) {
-        Debug::log(ERR, "Invalid powerMgrSetMode output");
-        return;
-    }
-
-    wlr_output_state_set_enabled(PMONITOR->state.wlr(), EVENT->mode == 1);
-
-    if (!PMONITOR->state.commit())
-        Debug::log(ERR, "Couldn't set power mode");
-}
-
-void Events::listener_newIME(wl_listener* listener, void* data) {
-    Debug::log(LOG, "New IME added!");
-
-    g_pInputManager->m_sIMERelay.onNewIME((wlr_input_method_v2*)data);
-}
-
-void Events::listener_newTextInput(wl_listener* listener, void* data) {
-    Debug::log(LOG, "New TextInput added!");
-
-    g_pInputManager->m_sIMERelay.onNewTextInput((wlr_text_input_v3*)data);
-}
-
-void Events::listener_newSessionLock(wl_listener* listener, void* data) {
-    Debug::log(LOG, "New session lock!");
-
-    g_pSessionLockManager->onNewSessionLock((wlr_session_lock_v1*)data);
-}
-
-void Events::listener_setGamma(wl_listener* listener, void* data) {
-    Debug::log(LOG, "New Gamma event at {:x}", (uintptr_t)data);
-
-    const auto E = (wlr_gamma_control_manager_v1_set_gamma_event*)data;
-
-    const auto PMONITOR = g_pCompositor->getMonitorFromOutput(E->output);
-
-    if (!PMONITOR) {
-        Debug::log(ERR, "Gamma event object references non-existent output {:x} ?", (uintptr_t)E->output);
-        return;
-    }
-
-    PMONITOR->gammaChanged = true;
-
-    g_pCompositor->scheduleFrameForMonitor(PMONITOR);
-}
-
-void Events::listener_setCursorShape(wl_listener* listener, void* data) {
-    const auto E = (wlr_cursor_shape_manager_v1_request_set_shape_event*)data;
-
-    g_pInputManager->processMouseRequest(E);
-}
-
-void Events::listener_newTearingHint(wl_listener* listener, void* data) {
-    Debug::log(LOG, "New tearing hint at {:x}", (uintptr_t)data);
-
-    const auto NEWCTRL = g_pHyprRenderer->m_vTearingControllers.emplace_back(std::make_unique<STearingController>()).get();
-    NEWCTRL->pWlrHint  = (wlr_tearing_control_v1*)data;
-
-    NEWCTRL->hyprListener_destroy.initCallback(
-        &NEWCTRL->pWlrHint->events.destroy,
-        [&](void* owner, void* data) {
-            Debug::log(LOG, "Destroyed {:x} tearing hint", (uintptr_t)((STearingController*)owner)->pWlrHint);
-
-            std::erase_if(g_pHyprRenderer->m_vTearingControllers, [&](const auto& other) { return other.get() == owner; });
-        },
-        NEWCTRL, "TearingController");
-
-    NEWCTRL->hyprListener_set.initCallback(
-        &NEWCTRL->pWlrHint->events.set_hint,
-        [&](void* owner, void* data) {
-            const auto TEARINGHINT = (STearingController*)owner;
-
-            const auto PWINDOW = g_pCompositor->getWindowFromSurface(TEARINGHINT->pWlrHint->surface);
-
-            if (PWINDOW) {
-                PWINDOW->m_bTearingHint = (bool)TEARINGHINT->pWlrHint->current;
-
-                Debug::log(LOG, "Hint {:x} (window {}) set tearing hint to {}", (uintptr_t)TEARINGHINT->pWlrHint, PWINDOW, (uint32_t)TEARINGHINT->pWlrHint->current);
-            }
-        },
-        NEWCTRL, "TearingController");
-}
-
-void Events::listener_newShortcutInhibitor(wl_listener* listener, void* data) {
-    const auto INHIBITOR = (wlr_keyboard_shortcuts_inhibitor_v1*)data;
-
-    const auto PINH = &g_pKeybindManager->m_lShortcutInhibitors.emplace_back();
-    PINH->hyprListener_destroy.initCallback(
-        &INHIBITOR->events.destroy,
-        [](void* owner, void* data) {
-            const auto OWNER = (SShortcutInhibitor*)owner;
-            g_pKeybindManager->m_lShortcutInhibitors.remove(*OWNER);
-        },
-        PINH, "ShortcutInhibitor");
-
-    PINH->pWlrInhibitor = INHIBITOR;
-
-    Debug::log(LOG, "New shortcut inhibitor for surface {:x}", (uintptr_t)INHIBITOR->surface);
-}

src/events/Monitors.cpp

@@ -16,57 +16,45 @@
 //                                                           //
 // --------------------------------------------------------- //
 
-void Events::listener_change(wl_listener* listener, void* data) {
-    // layout got changed, let's update monitors.
-    const auto CONFIG = wlr_output_configuration_v1_create();
+static void checkDefaultCursorWarp(std::shared_ptr<CMonitor>* PNEWMONITORWRAP, std::string monitorName) {
+    const auto  PNEWMONITOR = PNEWMONITORWRAP->get();
 
-    if (!CONFIG)
-        return;
+    static auto PCURSORMONITOR    = CConfigValue<std::string>("general:default_cursor_monitor");
+    static auto firstMonitorAdded = std::chrono::system_clock::now();
+    static bool cursorDefaultDone = false;
+    static bool firstLaunch       = true;
 
-    for (auto& m : g_pCompositor->m_vRealMonitors) {
-        if (!m->output)
-            continue;
+    const auto  POS = PNEWMONITOR->middle();
 
-        if (g_pCompositor->m_pUnsafeOutput == m.get())
-            continue;
-
-        const auto CONFIGHEAD = wlr_output_configuration_head_v1_create(CONFIG, m->output);
-
-        CBox       BOX;
-        wlr_output_layout_get_box(g_pCompositor->m_sWLROutputLayout, m->output, BOX.pWlr());
-        BOX.applyFromWlr();
-
-        //m->vecSize.x = BOX.width;
-        // m->vecSize.y = BOX.height;
-        m->vecPosition.x = BOX.x;
-        m->vecPosition.y = BOX.y;
-
-        CONFIGHEAD->state.enabled = m->output->enabled;
-        CONFIGHEAD->state.mode    = m->output->current_mode;
-        if (!m->output->current_mode) {
-            CONFIGHEAD->state.custom_mode = {
-                m->output->width,
-                m->output->height,
-                m->output->refresh,
-            };
-        }
-        CONFIGHEAD->state.x                     = m->vecPosition.x;
-        CONFIGHEAD->state.y                     = m->vecPosition.y;
-        CONFIGHEAD->state.transform             = m->transform;
-        CONFIGHEAD->state.scale                 = m->scale;
-        CONFIGHEAD->state.adaptive_sync_enabled = m->vrrActive;
+    // by default, cursor should be set to first monitor detected
+    // this is needed as a default if the monitor given in config above doesn't exist
+    if (firstLaunch) {
+        firstLaunch = false;
+        g_pCompositor->warpCursorTo(POS, true);
+        g_pInputManager->refocus();
     }
 
-    wlr_output_manager_v1_set_configuration(g_pCompositor->m_sWLROutputMgr, CONFIG);
+    if (cursorDefaultDone || *PCURSORMONITOR == STRVAL_EMPTY)
+        return;
+
+    // after 10s, don't set cursor to default monitor
+    auto timePassedSec = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - firstMonitorAdded);
+    if (timePassedSec.count() > 10) {
+        cursorDefaultDone = true;
+        return;
+    }
+
+    if (*PCURSORMONITOR == monitorName) {
+        cursorDefaultDone = true;
+        g_pCompositor->warpCursorTo(POS, true);
+        g_pInputManager->refocus();
+    }
 }
 
 void Events::listener_newOutput(wl_listener* listener, void* data) {
     // new monitor added, let's accommodate for that.
     const auto OUTPUT = (wlr_output*)data;
 
-    // for warping the cursor on launch
-    static bool firstLaunch = true;
-
     if (!OUTPUT->name) {
         Debug::log(ERR, "New monitor has no name?? Ignoring");
         return;
@@ -101,17 +89,12 @@ void Events::listener_newOutput(wl_listener* listener, void* data) {
     g_pConfigManager->m_bWantsMonitorReload = true;
     g_pCompositor->scheduleFrameForMonitor(PNEWMONITOR);
 
-    if (firstLaunch) {
-        firstLaunch    = false;
-        const auto POS = PNEWMONITOR->middle();
-        if (g_pCompositor->m_sSeat.mouse)
-            wlr_cursor_warp(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, POS.x, POS.y);
-    } else {
-        for (auto& w : g_pCompositor->m_vWindows) {
-            if (w->m_iMonitorID == PNEWMONITOR->ID) {
-                w->m_iLastSurfaceMonitorID = -1;
-                w->updateSurfaceScaleTransformDetails();
-            }
+    checkDefaultCursorWarp(PNEWMONITORWRAP, OUTPUT->name);
+
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (w->m_iMonitorID == PNEWMONITOR->ID) {
+            w->m_iLastSurfaceMonitorID = -1;
+            w->updateSurfaceScaleTransformDetails();
         }
     }
 }
@@ -146,7 +129,7 @@ void Events::listener_monitorFrame(void* owner, void* data) {
 
     PMONITOR->tearingState.busy = false;
 
-    if (PMONITOR->tearingState.activelyTearing && PMONITOR->solitaryClient /* can be invalidated by a recheck */) {
+    if (PMONITOR->tearingState.activelyTearing && PMONITOR->solitaryClient.lock() /* can be invalidated by a recheck */) {
 
         if (!PMONITOR->tearingState.frameScheduledWhileBusy)
             return; // we did not schedule a frame yet to be displayed, but we are tearing. Why render?

src/events/Windows.cpp

@@ -3,6 +3,7 @@
 #include "../Compositor.hpp"
 #include "../helpers/WLClasses.hpp"
 #include "../managers/input/InputManager.hpp"
+#include "../managers/TokenManager.hpp"
 #include "../render/Renderer.hpp"
 #include "../config/ConfigValue.hpp"
 
@@ -42,15 +43,16 @@ void setAnimToMove(void* data) {
 }
 
 void Events::listener_mapWindow(void* owner, void* data) {
-    CWindow*    PWINDOW = (CWindow*)owner;
+    PHLWINDOW   PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
 
-    static auto PINACTIVEALPHA  = CConfigValue<Hyprlang::FLOAT>("decoration:inactive_opacity");
-    static auto PACTIVEALPHA    = CConfigValue<Hyprlang::FLOAT>("decoration:active_opacity");
-    static auto PDIMSTRENGTH    = CConfigValue<Hyprlang::FLOAT>("decoration:dim_strength");
-    static auto PSWALLOW        = CConfigValue<Hyprlang::INT>("misc:enable_swallow");
-    static auto PSWALLOWREGEX   = CConfigValue<std::string>("misc:swallow_regex");
-    static auto PSWALLOWEXREGEX = CConfigValue<std::string>("misc:swallow_exception_regex");
-    static auto PNEWTAKESOVERFS = CConfigValue<Hyprlang::INT>("misc:new_window_takes_over_fullscreen");
+    static auto PINACTIVEALPHA     = CConfigValue<Hyprlang::FLOAT>("decoration:inactive_opacity");
+    static auto PACTIVEALPHA       = CConfigValue<Hyprlang::FLOAT>("decoration:active_opacity");
+    static auto PDIMSTRENGTH       = CConfigValue<Hyprlang::FLOAT>("decoration:dim_strength");
+    static auto PSWALLOW           = CConfigValue<Hyprlang::INT>("misc:enable_swallow");
+    static auto PSWALLOWREGEX      = CConfigValue<std::string>("misc:swallow_regex");
+    static auto PSWALLOWEXREGEX    = CConfigValue<std::string>("misc:swallow_exception_regex");
+    static auto PNEWTAKESOVERFS    = CConfigValue<Hyprlang::INT>("misc:new_window_takes_over_fullscreen");
+    static auto PINITIALWSTRACKING = CConfigValue<Hyprlang::INT>("misc:initial_workspace_tracking");
 
     auto        PMONITOR = g_pCompositor->m_pLastMonitor;
     if (!g_pCompositor->m_pLastMonitor) {
@@ -66,6 +68,43 @@ void Events::listener_mapWindow(void* owner, void* data) {
     PWINDOW->m_szTitle        = g_pXWaylandManager->getTitle(PWINDOW);
     PWINDOW->m_iX11Type       = PWINDOW->m_bIsX11 ? (PWINDOW->m_uSurface.xwayland->override_redirect ? 2 : 1) : 1;
     PWINDOW->m_bFirstMap      = true;
+    PWINDOW->m_szInitialTitle = PWINDOW->m_szTitle;
+    PWINDOW->m_szInitialClass = g_pXWaylandManager->getAppIDClass(PWINDOW);
+
+    // check for token
+    std::string requestedWorkspace = "";
+    bool        workspaceSilent    = false;
+
+    if (*PINITIALWSTRACKING) {
+        const auto WINDOWENV = PWINDOW->getEnv();
+        if (WINDOWENV.contains("HL_INITIAL_WORKSPACE_TOKEN")) {
+            const auto SZTOKEN = WINDOWENV.at("HL_INITIAL_WORKSPACE_TOKEN");
+            Debug::log(LOG, "New window contains HL_INITIAL_WORKSPACE_TOKEN: {}", SZTOKEN);
+            const auto TOKEN = g_pTokenManager->getToken(SZTOKEN);
+            if (TOKEN) {
+                // find workspace and use it
+                SInitialWorkspaceToken WS = std::any_cast<SInitialWorkspaceToken>(TOKEN->data);
+
+                Debug::log(LOG, "HL_INITIAL_WORKSPACE_TOKEN {} -> {}", SZTOKEN, WS.workspace);
+
+                if (g_pCompositor->getWorkspaceByString(WS.workspace) != PWINDOW->m_pWorkspace) {
+                    requestedWorkspace = WS.workspace;
+                    workspaceSilent    = true;
+                }
+
+                if (*PINITIALWSTRACKING == 1) // one-shot token
+                    g_pTokenManager->removeToken(TOKEN);
+                else if (*PINITIALWSTRACKING == 2) { // persistent
+                    if (WS.primaryOwner.expired()) {
+                        WS.primaryOwner = PWINDOW;
+                        TOKEN->data     = WS;
+                    }
+
+                    PWINDOW->m_szInitialWorkspaceToken = SZTOKEN;
+                }
+            }
+        }
+    }
 
     if (g_pInputManager->m_bLastFocusOnLS) // waybar fix
         g_pInputManager->releaseAllMouseButtons();
@@ -73,9 +112,6 @@ void Events::listener_mapWindow(void* owner, void* data) {
     // Set all windows tiled regardless of anything
     g_pXWaylandManager->setWindowStyleTiled(PWINDOW, WLR_EDGE_LEFT | WLR_EDGE_RIGHT | WLR_EDGE_TOP | WLR_EDGE_BOTTOM);
 
-    // Foreign Toplevel
-    PWINDOW->createToplevelHandle();
-
     // checks if the window wants borders and sets the appropriate flag
     g_pXWaylandManager->checkBorders(PWINDOW);
 
@@ -108,10 +144,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
     }
 
     // window rules
-    const auto  WINDOWRULES        = g_pConfigManager->getMatchingRules(PWINDOW, false);
-    std::string requestedWorkspace = "";
-    bool        workspaceSilent    = false;
-    bool        requestsFullscreen = PWINDOW->m_bWantsInitialFullscreen ||
+    PWINDOW->m_vMatchedRules = g_pConfigManager->getMatchingRules(PWINDOW, false);
+    bool requestsFullscreen  = PWINDOW->m_bWantsInitialFullscreen ||
         (!PWINDOW->m_bIsX11 && PWINDOW->m_uSurface.xdg->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL && PWINDOW->m_uSurface.xdg->toplevel->requested.fullscreen) ||
         (PWINDOW->m_bIsX11 && PWINDOW->m_uSurface.xwayland->fullscreen);
     bool requestsFakeFullscreen = false;
@@ -119,10 +153,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
     bool overridingNoFullscreen = false;
     bool overridingNoMaximize   = false;
 
-    PWINDOW->m_szInitialTitle = g_pXWaylandManager->getTitle(PWINDOW);
-    PWINDOW->m_szInitialClass = g_pXWaylandManager->getAppIDClass(PWINDOW);
-
-    for (auto& r : WINDOWRULES) {
+    for (auto& r : PWINDOW->m_vMatchedRules) {
         if (r.szRule.starts_with("monitor")) {
             try {
                 const auto MONITORSTR = removeBeginEndSpacesTabs(r.szRule.substr(r.szRule.find(' ')));
@@ -312,7 +343,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PWINDOW->m_bCreatedOverFullscreen = true;
 
         // size and move rules
-        for (auto& r : WINDOWRULES) {
+        for (auto& r : PWINDOW->m_vMatchedRules) {
             if (r.szRule.starts_with("size")) {
                 try {
                     const auto VALUE    = r.szRule.substr(r.szRule.find(' ') + 1);
@@ -356,10 +387,14 @@ void Events::listener_mapWindow(void* owner, void* data) {
                     int        posY = 0;
 
                     if (POSXSTR.starts_with("100%-")) {
-                        const auto POSXRAW = POSXSTR.substr(5);
+                        const bool subtractWindow = POSXSTR.starts_with("100%-w-");
+                        const auto POSXRAW        = (subtractWindow) ? POSXSTR.substr(7) : POSXSTR.substr(5);
                         posX =
                             PMONITOR->vecSize.x - (!POSXRAW.contains('%') ? std::stoi(POSXRAW) : std::stof(POSXRAW.substr(0, POSXRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.x);
 
+                        if (subtractWindow)
+                            posX -= PWINDOW->m_vRealSize.goal().x;
+
                         if (CURSOR)
                             Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!");
                     } else if (!CURSOR) {
@@ -375,10 +410,14 @@ void Events::listener_mapWindow(void* owner, void* data) {
                     }
 
                     if (POSYSTR.starts_with("100%-")) {
-                        const auto POSYRAW = POSYSTR.substr(5);
+                        const bool subtractWindow = POSYSTR.starts_with("100%-w-");
+                        const auto POSYRAW        = (subtractWindow) ? POSYSTR.substr(7) : POSYSTR.substr(5);
                         posY =
                             PMONITOR->vecSize.y - (!POSYRAW.contains('%') ? std::stoi(POSYRAW) : std::stof(POSYRAW.substr(0, POSYRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.y);
 
+                        if (subtractWindow)
+                            posY -= PWINDOW->m_vRealSize.goal().y;
+
                         if (CURSOR)
                             Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!");
                     } else if (!CURSOR) {
@@ -431,7 +470,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PWINDOW->m_vPseudoSize = PWINDOW->m_vRealSize.goal() - Vector2D(10, 10);
     }
 
-    const auto PFOCUSEDWINDOWPREV = g_pCompositor->m_pLastWindow;
+    const auto PFOCUSEDWINDOWPREV = g_pCompositor->m_pLastWindow.lock();
 
     if (PWINDOW->m_sAdditionalConfigData.forceAllowsInput) {
         PWINDOW->m_sAdditionalConfigData.noFocus = false;
@@ -468,28 +507,30 @@ void Events::listener_mapWindow(void* owner, void* data) {
     }
 
     if (!PWINDOW->m_bIsX11) {
-        PWINDOW->hyprListener_setTitleWindow.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.set_title, &Events::listener_setTitleWindow, PWINDOW, "XDG Window Late");
-        PWINDOW->hyprListener_requestMaximize.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_maximize, &Events::listener_requestMaximize, PWINDOW,
+        PWINDOW->hyprListener_setTitleWindow.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.set_title, &Events::listener_setTitleWindow, PWINDOW.get(), "XDG Window Late");
+        PWINDOW->hyprListener_requestMaximize.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_maximize, &Events::listener_requestMaximize, PWINDOW.get(),
                                                            "XDG Window Late");
-        PWINDOW->hyprListener_requestMinimize.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_minimize, &Events::listener_requestMinimize, PWINDOW,
+        PWINDOW->hyprListener_requestMinimize.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_minimize, &Events::listener_requestMinimize, PWINDOW.get(),
                                                            "XDG Window Late");
-        PWINDOW->hyprListener_requestMove.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_move, &Events::listener_requestMove, PWINDOW, "XDG Window Late");
-        PWINDOW->hyprListener_requestResize.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_resize, &Events::listener_requestResize, PWINDOW, "XDG Window Late");
-        PWINDOW->hyprListener_fullscreenWindow.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_fullscreen, &Events::listener_fullscreenWindow, PWINDOW,
+        PWINDOW->hyprListener_requestMove.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_move, &Events::listener_requestMove, PWINDOW.get(), "XDG Window Late");
+        PWINDOW->hyprListener_requestResize.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_resize, &Events::listener_requestResize, PWINDOW.get(),
+                                                         "XDG Window Late");
+        PWINDOW->hyprListener_fullscreenWindow.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_fullscreen, &Events::listener_fullscreenWindow, PWINDOW.get(),
                                                             "XDG Window Late");
-        PWINDOW->hyprListener_ackConfigure.initCallback(&PWINDOW->m_uSurface.xdg->events.ack_configure, &Events::listener_ackConfigure, PWINDOW, "XDG Window Late");
+        PWINDOW->hyprListener_ackConfigure.initCallback(&PWINDOW->m_uSurface.xdg->events.ack_configure, &Events::listener_ackConfigure, PWINDOW.get(), "XDG Window Late");
     } else {
-        PWINDOW->hyprListener_fullscreenWindow.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_fullscreen, &Events::listener_fullscreenWindow, PWINDOW,
+        PWINDOW->hyprListener_fullscreenWindow.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_fullscreen, &Events::listener_fullscreenWindow, PWINDOW.get(),
                                                             "XWayland Window Late");
-        PWINDOW->hyprListener_activateX11.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_activate, &Events::listener_activateX11, PWINDOW, "XWayland Window Late");
-        PWINDOW->hyprListener_setTitleWindow.initCallback(&PWINDOW->m_uSurface.xwayland->events.set_title, &Events::listener_setTitleWindow, PWINDOW, "XWayland Window Late");
-        PWINDOW->hyprListener_requestMinimize.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_minimize, &Events::listener_requestMinimize, PWINDOW,
+        PWINDOW->hyprListener_activateX11.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_activate, &Events::listener_activateX11, PWINDOW.get(),
+                                                       "XWayland Window Late");
+        PWINDOW->hyprListener_setTitleWindow.initCallback(&PWINDOW->m_uSurface.xwayland->events.set_title, &Events::listener_setTitleWindow, PWINDOW.get(), "XWayland Window Late");
+        PWINDOW->hyprListener_requestMinimize.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_minimize, &Events::listener_requestMinimize, PWINDOW.get(),
                                                            "Xwayland Window Late");
-        PWINDOW->hyprListener_requestMaximize.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_maximize, &Events::listener_requestMaximize, PWINDOW,
+        PWINDOW->hyprListener_requestMaximize.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_maximize, &Events::listener_requestMaximize, PWINDOW.get(),
                                                            "Xwayland Window Late");
 
         if (PWINDOW->m_iX11Type == 2)
-            PWINDOW->hyprListener_setGeometryX11U.initCallback(&PWINDOW->m_uSurface.xwayland->events.set_geometry, &Events::listener_unmanagedSetGeometry, PWINDOW,
+            PWINDOW->hyprListener_setGeometryX11U.initCallback(&PWINDOW->m_uSurface.xwayland->events.set_geometry, &Events::listener_unmanagedSetGeometry, PWINDOW.get(),
                                                                "XWayland Window Late");
     }
 
@@ -519,7 +560,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
     PWINDOW->updateToplevel();
 
     if (workspaceSilent) {
-        if (g_pCompositor->windowValidMapped(PFOCUSEDWINDOWPREV)) {
+        if (validMapped(PFOCUSEDWINDOWPREV)) {
             g_pCompositor->focusWindow(PFOCUSEDWINDOWPREV);
             PFOCUSEDWINDOWPREV->updateWindowDecos(); // need to for some reason i cba to find out why
         } else if (!PFOCUSEDWINDOWPREV)
@@ -548,14 +589,14 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
             if (ppid) {
                 // get window by pid
-                std::vector<CWindow*> found;
-                CWindow*              finalFound = nullptr;
+                std::vector<PHLWINDOW> found;
+                PHLWINDOW              finalFound;
                 for (auto& w : g_pCompositor->m_vWindows) {
                     if (!w->m_bIsMapped || w->isHidden())
                         continue;
 
                     if (w->getPID() == ppid) {
-                        found.push_back(w.get());
+                        found.push_back(w);
                     }
                 }
 
@@ -626,7 +667,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
     g_pCompositor->setPreferredScaleForSurface(PWINDOW->m_pWLSurface.wlr(), PMONITOR->scale);
     g_pCompositor->setPreferredTransformForSurface(PWINDOW->m_pWLSurface.wlr(), PMONITOR->transform);
 
-    if (!g_pCompositor->m_sSeat.mouse || !g_pInputManager->isConstrained())
+    if (g_pCompositor->m_sSeat.mouse.expired() || !g_pInputManager->isConstrained())
         g_pInputManager->sendMotionEventsToFocused();
 
     // fix some xwayland apps that don't behave nicely
@@ -639,7 +680,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
 }
 
 void Events::listener_unmapWindow(void* owner, void* data) {
-    CWindow* PWINDOW = (CWindow*)owner;
+    PHLWINDOW PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
 
     Debug::log(LOG, "{:c} unmapped", PWINDOW);
 
@@ -687,18 +728,18 @@ void Events::listener_unmapWindow(void* owner, void* data) {
     g_pHyprOpenGL->makeWindowSnapshot(PWINDOW);
 
     // swallowing
-    if (PWINDOW->m_pSwallowed && g_pCompositor->windowExists(PWINDOW->m_pSwallowed)) {
-        PWINDOW->m_pSwallowed->setHidden(false);
-        g_pLayoutManager->getCurrentLayout()->onWindowCreated(PWINDOW->m_pSwallowed);
-        PWINDOW->m_pSwallowed = nullptr;
+    if (valid(PWINDOW->m_pSwallowed)) {
+        PWINDOW->m_pSwallowed.lock()->setHidden(false);
+        g_pLayoutManager->getCurrentLayout()->onWindowCreated(PWINDOW->m_pSwallowed.lock());
+        PWINDOW->m_pSwallowed.reset();
     }
 
     bool wasLastWindow = false;
 
-    if (PWINDOW == g_pCompositor->m_pLastWindow) {
-        wasLastWindow                = true;
-        g_pCompositor->m_pLastWindow = nullptr;
-        g_pCompositor->m_pLastFocus  = nullptr;
+    if (PWINDOW == g_pCompositor->m_pLastWindow.lock()) {
+        wasLastWindow = true;
+        g_pCompositor->m_pLastWindow.reset();
+        g_pCompositor->m_pLastFocus = nullptr;
 
         g_pInputManager->releaseAllMouseButtons();
     }
@@ -720,7 +761,7 @@ void Events::listener_unmapWindow(void* owner, void* data) {
 
         Debug::log(LOG, "On closed window, new focused candidate is {}", PWINDOWCANDIDATE);
 
-        if (PWINDOWCANDIDATE != g_pCompositor->m_pLastWindow && PWINDOWCANDIDATE)
+        if (PWINDOWCANDIDATE != g_pCompositor->m_pLastWindow.lock() && PWINDOWCANDIDATE)
             g_pCompositor->focusWindow(PWINDOWCANDIDATE);
 
         if (!PWINDOWCANDIDATE && g_pCompositor->getWindowsOnWorkspace(PWINDOW->workspaceID()) == 0)
@@ -729,10 +770,10 @@ void Events::listener_unmapWindow(void* owner, void* data) {
         g_pInputManager->sendMotionEventsToFocused();
 
         // CWindow::onUnmap will remove this window's active status, but we can't really do it above.
-        if (PWINDOW == g_pCompositor->m_pLastWindow || !g_pCompositor->m_pLastWindow) {
+        if (PWINDOW == g_pCompositor->m_pLastWindow.lock() || !g_pCompositor->m_pLastWindow.lock()) {
             g_pEventManager->postEvent(SHyprIPCEvent{"activewindow", ","});
-            g_pEventManager->postEvent(SHyprIPCEvent{"activewindowv2", ","});
-            EMIT_HOOK_EVENT("activeWindow", (CWindow*)nullptr);
+            g_pEventManager->postEvent(SHyprIPCEvent{"activewindowv2", ""});
+            EMIT_HOOK_EVENT("activeWindow", (PHLWINDOW) nullptr);
         }
     } else {
         Debug::log(LOG, "Unmapped was not focused, ignoring a refocus.");
@@ -751,9 +792,6 @@ void Events::listener_unmapWindow(void* owner, void* data) {
     g_pAnimationManager->onWindowPostCreateClose(PWINDOW, true);
     PWINDOW->m_fAlpha = 0.f;
 
-    // Destroy Foreign Toplevel
-    PWINDOW->destroyToplevelHandle();
-
     // recheck idle inhibitors
     g_pInputManager->recheckIdleInhibitorStatus();
 
@@ -765,7 +803,7 @@ void Events::listener_unmapWindow(void* owner, void* data) {
 }
 
 void Events::listener_ackConfigure(void* owner, void* data) {
-    CWindow*   PWINDOW = (CWindow*)owner;
+    PHLWINDOW  PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
     const auto E       = (wlr_xdg_surface_configure*)data;
 
     // find last matching serial
@@ -779,7 +817,7 @@ void Events::listener_ackConfigure(void* owner, void* data) {
 }
 
 void Events::listener_commitWindow(void* owner, void* data) {
-    CWindow* PWINDOW = (CWindow*)owner;
+    PHLWINDOW PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
 
     if (!PWINDOW->m_bIsX11 && PWINDOW->m_uSurface.xdg->initial_commit) {
         Vector2D predSize = g_pLayoutManager->getCurrentLayout()->predictSizeForNewWindow(PWINDOW);
@@ -839,7 +877,7 @@ void Events::listener_commitWindow(void* owner, void* data) {
 
     // tearing: if solitary, redraw it. This still might be a single surface window
     const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
-    if (PMONITOR && PMONITOR->solitaryClient == PWINDOW && PWINDOW->canBeTorn() && PMONITOR->tearingState.canTear &&
+    if (PMONITOR && PMONITOR->solitaryClient.lock() == PWINDOW && PWINDOW->canBeTorn() && PMONITOR->tearingState.canTear &&
         PWINDOW->m_pWLSurface.wlr()->current.committed & WLR_SURFACE_STATE_BUFFER) {
         CRegion damageBox{&PWINDOW->m_pWLSurface.wlr()->buffer_damage};
 
@@ -855,16 +893,16 @@ void Events::listener_commitWindow(void* owner, void* data) {
 }
 
 void Events::listener_destroyWindow(void* owner, void* data) {
-    CWindow* PWINDOW = (CWindow*)owner;
+    PHLWINDOW PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
 
     Debug::log(LOG, "{:c} destroyed, queueing.", PWINDOW);
 
     if (PWINDOW->m_bIsX11)
         Debug::log(LOG, "XWayland class raw: {}", PWINDOW->m_uSurface.xwayland->_class ? PWINDOW->m_uSurface.xwayland->_class : "null");
 
-    if (PWINDOW == g_pCompositor->m_pLastWindow) {
-        g_pCompositor->m_pLastWindow = nullptr;
-        g_pCompositor->m_pLastFocus  = nullptr;
+    if (PWINDOW == g_pCompositor->m_pLastWindow.lock()) {
+        g_pCompositor->m_pLastWindow.reset();
+        g_pCompositor->m_pLastFocus = nullptr;
     }
 
     PWINDOW->m_pWLSurface.unassign();
@@ -891,9 +929,9 @@ void Events::listener_destroyWindow(void* owner, void* data) {
 }
 
 void Events::listener_setTitleWindow(void* owner, void* data) {
-    CWindow* PWINDOW = (CWindow*)owner;
+    PHLWINDOW PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
 
-    if (!g_pCompositor->windowValidMapped(PWINDOW))
+    if (!validMapped(PWINDOW))
         return;
 
     const auto NEWTITLE = g_pXWaylandManager->getTitle(PWINDOW);
@@ -902,12 +940,12 @@ void Events::listener_setTitleWindow(void* owner, void* data) {
         return;
 
     PWINDOW->m_szTitle = NEWTITLE;
-    g_pEventManager->postEvent(SHyprIPCEvent{"windowtitle", std::format("{:x}", (uintptr_t)PWINDOW)});
+    g_pEventManager->postEvent(SHyprIPCEvent{"windowtitle", std::format("{:x}", (uintptr_t)PWINDOW.get())});
     EMIT_HOOK_EVENT("windowTitle", PWINDOW);
 
-    if (PWINDOW == g_pCompositor->m_pLastWindow) { // if it's the active, let's post an event to update others
+    if (PWINDOW == g_pCompositor->m_pLastWindow.lock()) { // if it's the active, let's post an event to update others
         g_pEventManager->postEvent(SHyprIPCEvent{"activewindow", g_pXWaylandManager->getAppIDClass(PWINDOW) + "," + PWINDOW->m_szTitle});
-        g_pEventManager->postEvent(SHyprIPCEvent{"activewindowv2", std::format("{:x}", (uintptr_t)PWINDOW)});
+        g_pEventManager->postEvent(SHyprIPCEvent{"activewindowv2", std::format("{:x}", (uintptr_t)PWINDOW.get())});
         EMIT_HOOK_EVENT("activeWindow", PWINDOW);
     }
 
@@ -919,7 +957,7 @@ void Events::listener_setTitleWindow(void* owner, void* data) {
 }
 
 void Events::listener_fullscreenWindow(void* owner, void* data) {
-    CWindow* PWINDOW = (CWindow*)owner;
+    PHLWINDOW PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
 
     if (!PWINDOW->m_bIsMapped) {
         PWINDOW->m_bWantsInitialFullscreen = true;
@@ -977,40 +1015,8 @@ void Events::listener_fullscreenWindow(void* owner, void* data) {
     Debug::log(LOG, "{} fullscreen to {}", PWINDOW, PWINDOW->m_bIsFullscreen);
 }
 
-void Events::listener_activateXDG(wl_listener* listener, void* data) {
-    const auto  E = (wlr_xdg_activation_v1_request_activate_event*)data;
-
-    static auto PFOCUSONACTIVATE = CConfigValue<Hyprlang::INT>("misc:focus_on_activate");
-
-    Debug::log(LOG, "Activate request for surface at {:x}", (uintptr_t)E->surface);
-
-    if (!wlr_xdg_surface_try_from_wlr_surface(E->surface))
-        return;
-
-    const auto PWINDOW = g_pCompositor->getWindowFromSurface(E->surface);
-
-    if (!PWINDOW || PWINDOW == g_pCompositor->m_pLastWindow || (PWINDOW->m_eSuppressedEvents & SUPPRESS_ACTIVATE))
-        return;
-
-    g_pEventManager->postEvent(SHyprIPCEvent{"urgent", std::format("{:x}", (uintptr_t)PWINDOW)});
-    EMIT_HOOK_EVENT("urgent", PWINDOW);
-
-    PWINDOW->m_bIsUrgent = true;
-
-    if (!*PFOCUSONACTIVATE || (PWINDOW->m_eSuppressedEvents & SUPPRESS_ACTIVATE_FOCUSONLY))
-        return;
-
-    if (PWINDOW->m_bIsFloating)
-        g_pCompositor->changeWindowZOrder(PWINDOW, true);
-
-    g_pCompositor->focusWindow(PWINDOW);
-    g_pCompositor->warpCursorTo(PWINDOW->middle());
-}
-
 void Events::listener_activateX11(void* owner, void* data) {
-    const auto  PWINDOW = (CWindow*)owner;
-
-    static auto PFOCUSONACTIVATE = CConfigValue<Hyprlang::INT>("misc:focus_on_activate");
+    PHLWINDOW PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
 
     Debug::log(LOG, "X11 Activate request for window {}", PWINDOW);
 
@@ -1018,7 +1024,7 @@ void Events::listener_activateX11(void* owner, void* data) {
 
         Debug::log(LOG, "Unmanaged X11 {} requests activate", PWINDOW);
 
-        if (g_pCompositor->m_pLastWindow && g_pCompositor->m_pLastWindow->getPID() != PWINDOW->getPID())
+        if (g_pCompositor->m_pLastWindow.lock() && g_pCompositor->m_pLastWindow.lock()->getPID() != PWINDOW->getPID())
             return;
 
         if (!wlr_xwayland_or_surface_wants_focus(PWINDOW->m_uSurface.xwayland))
@@ -1028,24 +1034,14 @@ void Events::listener_activateX11(void* owner, void* data) {
         return;
     }
 
-    if (PWINDOW == g_pCompositor->m_pLastWindow || (PWINDOW->m_eSuppressedEvents & SUPPRESS_ACTIVATE))
+    if (PWINDOW == g_pCompositor->m_pLastWindow.lock() || (PWINDOW->m_eSuppressedEvents & SUPPRESS_ACTIVATE))
         return;
 
-    g_pEventManager->postEvent(SHyprIPCEvent{"urgent", std::format("{:x}", (uintptr_t)PWINDOW)});
-    EMIT_HOOK_EVENT("urgent", PWINDOW);
-
-    if (!*PFOCUSONACTIVATE || (PWINDOW->m_eSuppressedEvents & SUPPRESS_ACTIVATE_FOCUSONLY))
-        return;
-
-    if (PWINDOW->m_bIsFloating)
-        g_pCompositor->changeWindowZOrder(PWINDOW, true);
-
-    g_pCompositor->focusWindow(PWINDOW);
-    g_pCompositor->warpCursorTo(PWINDOW->middle());
+    PWINDOW->activate();
 }
 
 void Events::listener_configureX11(void* owner, void* data) {
-    CWindow*   PWINDOW = (CWindow*)owner;
+    PHLWINDOW  PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
 
     const auto E = (wlr_xwayland_surface_configure_event*)data;
 
@@ -1060,7 +1056,7 @@ void Events::listener_configureX11(void* owner, void* data) {
 
     g_pHyprRenderer->damageWindow(PWINDOW);
 
-    if (!PWINDOW->m_bIsFloating || PWINDOW->m_bIsFullscreen || g_pInputManager->currentlyDraggedWindow == PWINDOW) {
+    if (!PWINDOW->m_bIsFloating || PWINDOW->m_bIsFullscreen || g_pInputManager->currentlyDraggedWindow.lock() == PWINDOW) {
         g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goal(), true);
         g_pInputManager->refocus();
         g_pHyprRenderer->damageWindow(PWINDOW);
@@ -1111,7 +1107,7 @@ void Events::listener_configureX11(void* owner, void* data) {
 }
 
 void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
-    CWindow* PWINDOW = (CWindow*)owner;
+    PHLWINDOW PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
 
     if (!PWINDOW->m_bIsMapped)
         return;
@@ -1176,16 +1172,16 @@ void Events::listener_setOverrideRedirect(void* owner, void* data) {
 }
 
 void Events::listener_associateX11(void* owner, void* data) {
-    const auto PWINDOW = (CWindow*)owner;
+    PHLWINDOW PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
 
-    PWINDOW->hyprListener_mapWindow.initCallback(&PWINDOW->m_uSurface.xwayland->surface->events.map, &Events::listener_mapWindow, PWINDOW, "XWayland Window");
-    PWINDOW->hyprListener_commitWindow.initCallback(&PWINDOW->m_uSurface.xwayland->surface->events.commit, &Events::listener_commitWindow, PWINDOW, "XWayland Window");
+    PWINDOW->hyprListener_mapWindow.initCallback(&PWINDOW->m_uSurface.xwayland->surface->events.map, &Events::listener_mapWindow, PWINDOW.get(), "XWayland Window");
+    PWINDOW->hyprListener_commitWindow.initCallback(&PWINDOW->m_uSurface.xwayland->surface->events.commit, &Events::listener_commitWindow, PWINDOW.get(), "XWayland Window");
 
     PWINDOW->m_pWLSurface.assign(g_pXWaylandManager->getWindowSurface(PWINDOW), PWINDOW);
 }
 
 void Events::listener_dissociateX11(void* owner, void* data) {
-    const auto PWINDOW = (CWindow*)owner;
+    PHLWINDOW PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
 
     PWINDOW->m_pWLSurface.unassign();
 
@@ -1200,7 +1196,7 @@ void Events::listener_surfaceXWayland(wl_listener* listener, void* data) {
     if (XWSURFACE->parent)
         Debug::log(LOG, "Window parent data: {} at {:x}", XWSURFACE->parent->_class ? XWSURFACE->parent->_class : "null", (uintptr_t)XWSURFACE->parent);
 
-    const auto PNEWWINDOW = (CWindow*)g_pCompositor->m_vWindows.emplace_back(std::make_unique<CWindow>()).get();
+    const auto PNEWWINDOW = g_pCompositor->m_vWindows.emplace_back(CWindow::create());
 
     PNEWWINDOW->m_uSurface.xwayland = XWSURFACE;
     PNEWWINDOW->m_iX11Type          = XWSURFACE->override_redirect ? 2 : 1;
@@ -1208,11 +1204,11 @@ void Events::listener_surfaceXWayland(wl_listener* listener, void* data) {
 
     PNEWWINDOW->m_pX11Parent = g_pCompositor->getX11Parent(PNEWWINDOW);
 
-    PNEWWINDOW->hyprListener_associateX11.initCallback(&XWSURFACE->events.associate, &Events::listener_associateX11, PNEWWINDOW, "XWayland Window");
-    PNEWWINDOW->hyprListener_dissociateX11.initCallback(&XWSURFACE->events.dissociate, &Events::listener_dissociateX11, PNEWWINDOW, "XWayland Window");
-    PNEWWINDOW->hyprListener_destroyWindow.initCallback(&XWSURFACE->events.destroy, &Events::listener_destroyWindow, PNEWWINDOW, "XWayland Window");
-    PNEWWINDOW->hyprListener_setOverrideRedirect.initCallback(&XWSURFACE->events.set_override_redirect, &Events::listener_setOverrideRedirect, PNEWWINDOW, "XWayland Window");
-    PNEWWINDOW->hyprListener_configureX11.initCallback(&XWSURFACE->events.request_configure, &Events::listener_configureX11, PNEWWINDOW, "XWayland Window");
+    PNEWWINDOW->hyprListener_associateX11.initCallback(&XWSURFACE->events.associate, &Events::listener_associateX11, PNEWWINDOW.get(), "XWayland Window");
+    PNEWWINDOW->hyprListener_dissociateX11.initCallback(&XWSURFACE->events.dissociate, &Events::listener_dissociateX11, PNEWWINDOW.get(), "XWayland Window");
+    PNEWWINDOW->hyprListener_destroyWindow.initCallback(&XWSURFACE->events.destroy, &Events::listener_destroyWindow, PNEWWINDOW.get(), "XWayland Window");
+    PNEWWINDOW->hyprListener_setOverrideRedirect.initCallback(&XWSURFACE->events.set_override_redirect, &Events::listener_setOverrideRedirect, PNEWWINDOW.get(), "XWayland Window");
+    PNEWWINDOW->hyprListener_configureX11.initCallback(&XWSURFACE->events.request_configure, &Events::listener_configureX11, PNEWWINDOW.get(), "XWayland Window");
 }
 
 void Events::listener_newXDGToplevel(wl_listener* listener, void* data) {
@@ -1222,32 +1218,26 @@ void Events::listener_newXDGToplevel(wl_listener* listener, void* data) {
 
     Debug::log(LOG, "New XDG Toplevel created. (class: {})", XDGSURFACE->toplevel->app_id ? XDGSURFACE->toplevel->app_id : "null");
 
-    const auto PNEWWINDOW      = g_pCompositor->m_vWindows.emplace_back(std::make_unique<CWindow>()).get();
+    const auto PNEWWINDOW      = g_pCompositor->m_vWindows.emplace_back(CWindow::create());
     PNEWWINDOW->m_uSurface.xdg = XDGSURFACE;
 
-    PNEWWINDOW->hyprListener_mapWindow.initCallback(&XDGSURFACE->surface->events.map, &Events::listener_mapWindow, PNEWWINDOW, "XDG Window");
-    PNEWWINDOW->hyprListener_destroyWindow.initCallback(&XDGSURFACE->events.destroy, &Events::listener_destroyWindow, PNEWWINDOW, "XDG Window");
-    PNEWWINDOW->hyprListener_commitWindow.initCallback(&XDGSURFACE->surface->events.commit, &Events::listener_commitWindow, PNEWWINDOW, "XDG Window");
+    PNEWWINDOW->hyprListener_mapWindow.initCallback(&XDGSURFACE->surface->events.map, &Events::listener_mapWindow, PNEWWINDOW.get(), "XDG Window");
+    PNEWWINDOW->hyprListener_destroyWindow.initCallback(&XDGSURFACE->events.destroy, &Events::listener_destroyWindow, PNEWWINDOW.get(), "XDG Window");
+    PNEWWINDOW->hyprListener_commitWindow.initCallback(&XDGSURFACE->surface->events.commit, &Events::listener_commitWindow, PNEWWINDOW.get(), "XDG Window");
 
     PNEWWINDOW->m_pWLSurface.assign(g_pXWaylandManager->getWindowSurface(PNEWWINDOW), PNEWWINDOW);
 }
 
-void Events::listener_NewXDGDeco(wl_listener* listener, void* data) {
-    const auto WLRDECO = (wlr_xdg_toplevel_decoration_v1*)data;
-    wlr_xdg_toplevel_decoration_v1_set_mode(WLRDECO, WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
-}
-
 void Events::listener_requestMaximize(void* owner, void* data) {
-    const auto PWINDOW = (CWindow*)owner;
+    PHLWINDOW PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
 
     if (PWINDOW->m_eSuppressedEvents & SUPPRESS_MAXIMIZE)
         return;
 
     Debug::log(LOG, "Maximize request for {}", PWINDOW);
     if (!PWINDOW->m_bIsX11) {
-        const auto EV = (wlr_foreign_toplevel_handle_v1_maximized_event*)data;
 
-        g_pCompositor->setWindowFullscreen(PWINDOW, EV ? EV->maximized : !PWINDOW->m_bIsFullscreen,
+        g_pCompositor->setWindowFullscreen(PWINDOW, !PWINDOW->m_bIsFullscreen,
                                            FULLSCREEN_MAXIMIZED); // this will be rejected if there already is a fullscreen window
 
         wlr_xdg_surface_schedule_configure(PWINDOW->m_uSurface.xdg);
@@ -1260,7 +1250,7 @@ void Events::listener_requestMaximize(void* owner, void* data) {
 }
 
 void Events::listener_requestMinimize(void* owner, void* data) {
-    const auto PWINDOW = (CWindow*)owner;
+    PHLWINDOW PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
 
     Debug::log(LOG, "Minimize request for {}", PWINDOW);
 
@@ -1270,26 +1260,25 @@ void Events::listener_requestMinimize(void* owner, void* data) {
 
         const auto E = (wlr_xwayland_minimize_event*)data;
 
-        g_pEventManager->postEvent({"minimize", std::format("{:x},{}", (uintptr_t)PWINDOW, (int)E->minimize)});
-        EMIT_HOOK_EVENT("minimize", (std::vector<void*>{PWINDOW, (void*)E->minimize}));
+        g_pEventManager->postEvent({"minimize", std::format("{:x},{}", (uintptr_t)PWINDOW.get(), (int)E->minimize)});
+        EMIT_HOOK_EVENT("minimize", (std::vector<std::any>{PWINDOW, E->minimize}));
 
-        wlr_xwayland_surface_set_minimized(PWINDOW->m_uSurface.xwayland, E->minimize && g_pCompositor->m_pLastWindow != PWINDOW); // fucking DXVK
+        wlr_xwayland_surface_set_minimized(PWINDOW->m_uSurface.xwayland, E->minimize && g_pCompositor->m_pLastWindow.lock() != PWINDOW); // fucking DXVK
     } else {
-        const auto E = (wlr_foreign_toplevel_handle_v1_minimized_event*)data;
-        g_pEventManager->postEvent({"minimize", std::format("{:x},{}", (uintptr_t)PWINDOW, E ? (int)E->minimized : 1)});
-        EMIT_HOOK_EVENT("minimize", (std::vector<void*>{PWINDOW, (void*)(E ? (uint64_t)E->minimized : 1)}));
+        g_pEventManager->postEvent({"minimize", std::format("{:x},{}", (uintptr_t)PWINDOW.get(), 1)});
+        EMIT_HOOK_EVENT("minimize", (std::vector<std::any>{PWINDOW, (int64_t)(1)}));
     }
 }
 
 void Events::listener_requestMove(void* owner, void* data) {
-    const auto PWINDOW = (CWindow*)owner;
+    PHLWINDOW PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
 
     // ignore
     wlr_xdg_surface_schedule_configure(PWINDOW->m_uSurface.xdg);
 }
 
 void Events::listener_requestResize(void* owner, void* data) {
-    const auto PWINDOW = (CWindow*)owner;
+    PHLWINDOW PWINDOW = ((CWindow*)owner)->m_pSelf.lock();
 
     // ignore
     wlr_xdg_surface_schedule_configure(PWINDOW->m_uSurface.xdg);

src/helpers/AnimatedVariable.cpp

@@ -6,7 +6,7 @@ CBaseAnimatedVariable::CBaseAnimatedVariable(ANIMATEDVARTYPE type) : m_Type(type
     ; // dummy var
 }
 
-void CBaseAnimatedVariable::create(SAnimationPropertyConfig* pAnimConfig, CWindow* pWindow, AVARDAMAGEPOLICY policy) {
+void CBaseAnimatedVariable::create(SAnimationPropertyConfig* pAnimConfig, PHLWINDOW pWindow, AVARDAMAGEPOLICY policy) {
     m_eDamagePolicy = policy;
     m_pConfig       = pAnimConfig;
     m_pWindow       = pWindow;
@@ -14,7 +14,7 @@ void CBaseAnimatedVariable::create(SAnimationPropertyConfig* pAnimConfig, CWindo
     m_bDummy = false;
 }
 
-void CBaseAnimatedVariable::create(SAnimationPropertyConfig* pAnimConfig, SLayerSurface* pLayer, AVARDAMAGEPOLICY policy) {
+void CBaseAnimatedVariable::create(SAnimationPropertyConfig* pAnimConfig, PHLLS pLayer, AVARDAMAGEPOLICY policy) {
     m_eDamagePolicy = policy;
     m_pConfig       = pAnimConfig;
     m_pLayer        = pLayer;

src/helpers/AnimatedVariable.hpp

@@ -6,7 +6,7 @@
 #include <type_traits>
 #include "Vector2D.hpp"
 #include "Color.hpp"
-#include "../macros.hpp"
+#include "../defines.hpp"
 #include "../debug/Log.hpp"
 #include "../desktop/DesktopTypes.hpp"
 
@@ -49,11 +49,11 @@ enum AVARDAMAGEPOLICY {
 };
 
 class CAnimationManager;
-struct SLayerSurface;
 struct SAnimationPropertyConfig;
 class CHyprRenderer;
 class CWindow;
 class CWorkspace;
+class CLayerSurface;
 
 // Utility to define a concept as a list of possible type
 template <class T, class... U>
@@ -68,8 +68,8 @@ concept Animable = OneOf<T, Vector2D, float, CColor>;
 class CBaseAnimatedVariable {
   public:
     CBaseAnimatedVariable(ANIMATEDVARTYPE type);
-    void create(SAnimationPropertyConfig* pAnimConfig, CWindow* pWindow, AVARDAMAGEPOLICY policy);
-    void create(SAnimationPropertyConfig* pAnimConfig, SLayerSurface* pLayer, AVARDAMAGEPOLICY policy);
+    void create(SAnimationPropertyConfig* pAnimConfig, PHLWINDOW pWindow, AVARDAMAGEPOLICY policy);
+    void create(SAnimationPropertyConfig* pAnimConfig, PHLLS pLayer, AVARDAMAGEPOLICY policy);
     void create(SAnimationPropertyConfig* pAnimConfig, PHLWORKSPACE pWorkspace, AVARDAMAGEPOLICY policy);
     void create(SAnimationPropertyConfig* pAnimConfig, AVARDAMAGEPOLICY policy);
 
@@ -140,14 +140,14 @@ class CBaseAnimatedVariable {
         m_bRemoveEndAfterRan   = false;
     }
 
-    CWindow* getWindow() {
-        return (CWindow*)m_pWindow;
+    PHLWINDOW getWindow() {
+        return m_pWindow.lock();
     }
 
   protected:
-    void*                                 m_pWindow = nullptr;
+    PHLWINDOWREF                          m_pWindow;
     std::weak_ptr<CWorkspace>             m_pWorkspace;
-    void*                                 m_pLayer = nullptr;
+    PHLLSREF                              m_pLayer;
 
     SAnimationPropertyConfig*             m_pConfig = nullptr;
 
@@ -199,7 +199,7 @@ class CBaseAnimatedVariable {
 
     friend class CAnimationManager;
     friend class CWorkspace;
-    friend struct SLayerSurface;
+    friend class CLayerSurface;
     friend class CHyprRenderer;
 };
 
@@ -208,12 +208,12 @@ class CAnimatedVariable : public CBaseAnimatedVariable {
   public:
     CAnimatedVariable() : CBaseAnimatedVariable(typeToANIMATEDVARTYPE<VarType>) {} // dummy var
 
-    void create(const VarType& value, SAnimationPropertyConfig* pAnimConfig, CWindow* pWindow, AVARDAMAGEPOLICY policy) {
+    void create(const VarType& value, SAnimationPropertyConfig* pAnimConfig, PHLWINDOW pWindow, AVARDAMAGEPOLICY policy) {
         create(pAnimConfig, pWindow, policy);
         m_Value = value;
         m_Goal  = value;
     }
-    void create(const VarType& value, SAnimationPropertyConfig* pAnimConfig, SLayerSurface* pLayer, AVARDAMAGEPOLICY policy) {
+    void create(const VarType& value, SAnimationPropertyConfig* pAnimConfig, PHLLS pLayer, AVARDAMAGEPOLICY policy) {
         create(pAnimConfig, pLayer, policy);
         m_Value = value;
         m_Goal  = value;
@@ -304,6 +304,6 @@ class CAnimatedVariable : public CBaseAnimatedVariable {
 
     friend class CAnimationManager;
     friend class CWorkspace;
-    friend struct SLayerSurface;
+    friend class CLayerSurface;
     friend class CHyprRenderer;
 };

src/helpers/MiscFunctions.cpp

@@ -2,9 +2,12 @@
 #include "../defines.hpp"
 #include <algorithm>
 #include "../Compositor.hpp"
+#include "../managers/TokenManager.hpp"
 #include <optional>
 #include <set>
 #include <sys/utsname.h>
+#include <sys/mman.h>
+#include <fcntl.h>
 #include <iomanip>
 #include <sstream>
 #ifdef HAS_EXECINFO
@@ -256,7 +259,7 @@ bool isDirection(const char& arg) {
 int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
     int result = WORKSPACE_INVALID;
     if (in.starts_with("special")) {
-        outName = "special";
+        outName = "special:special";
 
         if (in.length() > 8) {
             const auto NAME = in.substr(8);
@@ -302,13 +305,14 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
         outName = PLASTWORKSPACE->m_szName;
         return PLASTWORKSPACE->m_iID;
     } else {
-        if (in[0] == 'r' && (in[1] == '-' || in[1] == '+') && isNumber(in.substr(2))) {
+        if (in[0] == 'r' && (in[1] == '-' || in[1] == '+' || in[1] == '~') && isNumber(in.substr(2))) {
+            bool absolute = in[1] == '~';
             if (!g_pCompositor->m_pLastMonitor) {
                 Debug::log(ERR, "Relative monitor workspace on monitor null!");
                 return WORKSPACE_INVALID;
             }
 
-            const auto PLUSMINUSRESULT = getPlusMinusKeywordResult(in.substr(1), 0);
+            const auto PLUSMINUSRESULT = getPlusMinusKeywordResult(in.substr(absolute ? 2 : 1), 0);
 
             if (!PLUSMINUSRESULT.has_value())
                 return WORKSPACE_INVALID;
@@ -346,103 +350,124 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
             }
             std::sort(namedWSes.begin(), namedWSes.end());
 
-            // Just take a blind guess at where we'll probably end up
-            int  activeWSID    = g_pCompositor->m_pLastMonitor->activeWorkspace ? g_pCompositor->m_pLastMonitor->activeWorkspace->m_iID : 1;
-            int  predictedWSID = activeWSID + remains;
-            int  remainingWSes = 0;
-            char walkDir       = in[1];
+            if (absolute) {
+                // 1-index
+                remains -= 1;
 
-            // sanitize. 0 means invalid oob in -
-            predictedWSID = std::max(predictedWSID, 0);
-
-            // Count how many invalidWSes are in between (how bad the prediction was)
-            int  beginID = in[1] == '+' ? activeWSID + 1 : predictedWSID;
-            int  endID   = in[1] == '+' ? predictedWSID : activeWSID;
-            auto begin   = invalidWSes.upper_bound(beginID - 1); // upper_bound is >, we want >=
-            for (auto it = begin; *it <= endID && it != invalidWSes.end(); it++) {
-                remainingWSes++;
-            }
-
-            // Handle named workspaces. They are treated like always before other workspaces
-            if (activeWSID < 0) {
-                // Behaviour similar to 'm'
-                // Find current
-                int currentItem = -1;
-                for (size_t i = 0; i < namedWSes.size(); i++) {
-                    if (namedWSes[i] == activeWSID) {
-                        currentItem = i;
-                        break;
-                    }
-                }
-
-                currentItem += remains;
-                currentItem = std::max(currentItem, 0);
-                if (currentItem >= (int)namedWSes.size()) {
-                    // At the seam between namedWSes and normal WSes. Behave like r+[diff] at imaginary ws 0
-                    int diff      = currentItem - (namedWSes.size() - 1);
-                    predictedWSID = diff;
-                    int  beginID  = 1;
-                    int  endID    = predictedWSID;
-                    auto begin    = invalidWSes.upper_bound(beginID - 1); // upper_bound is >, we want >=
-                    for (auto it = begin; *it <= endID && it != invalidWSes.end(); it++) {
-                        remainingWSes++;
-                    }
-                    walkDir = '+';
+                // traverse valid workspaces until we reach the remains
+                if ((size_t)remains < namedWSes.size()) {
+                    result = namedWSes[remains];
                 } else {
-                    // We found our final ws.
-                    remainingWSes = 0;
-                    predictedWSID = namedWSes[currentItem];
-                }
-            }
-
-            // Go in the search direction for remainingWSes
-            // The performance impact is directly proportional to the number of open and bound workspaces
-            int finalWSID = predictedWSID;
-            if (walkDir == '-') {
-                int beginID = finalWSID;
-                int curID   = finalWSID;
-                while (--curID > 0 && remainingWSes > 0) {
-                    if (!invalidWSes.contains(curID)) {
-                        remainingWSes--;
+                    remains -= namedWSes.size();
+                    result = 0;
+                    while (remains >= 0) {
+                        result++;
+                        if (!invalidWSes.contains(result)) {
+                            remains--;
+                        }
                     }
-                    finalWSID = curID;
                 }
-                if (finalWSID <= 0 || invalidWSes.contains(finalWSID)) {
-                    if (namedWSes.size()) {
-                        // Go to the named workspaces
-                        // Need remainingWSes more
-                        int namedWSIdx = namedWSes.size() - remainingWSes;
-                        // Sanitze
-                        namedWSIdx = std::clamp(namedWSIdx, 0, (int)namedWSes.size() - 1);
-                        finalWSID  = namedWSes[namedWSIdx];
-                    } else {
-                        // Couldn't find valid workspace in negative direction, search last first one back up positive direction
+            } else {
+
+                // Just take a blind guess at where we'll probably end up
+                int  activeWSID    = g_pCompositor->m_pLastMonitor->activeWorkspace ? g_pCompositor->m_pLastMonitor->activeWorkspace->m_iID : 1;
+                int  predictedWSID = activeWSID + remains;
+                int  remainingWSes = 0;
+                char walkDir       = in[1];
+
+                // sanitize. 0 means invalid oob in -
+                predictedWSID = std::max(predictedWSID, 0);
+
+                // Count how many invalidWSes are in between (how bad the prediction was)
+                int  beginID = in[1] == '+' ? activeWSID + 1 : predictedWSID;
+                int  endID   = in[1] == '+' ? predictedWSID : activeWSID;
+                auto begin   = invalidWSes.upper_bound(beginID - 1); // upper_bound is >, we want >=
+                for (auto it = begin; *it <= endID && it != invalidWSes.end(); it++) {
+                    remainingWSes++;
+                }
+
+                // Handle named workspaces. They are treated like always before other workspaces
+                if (activeWSID < 0) {
+                    // Behaviour similar to 'm'
+                    // Find current
+                    int currentItem = -1;
+                    for (size_t i = 0; i < namedWSes.size(); i++) {
+                        if (namedWSes[i] == activeWSID) {
+                            currentItem = i;
+                            break;
+                        }
+                    }
+
+                    currentItem += remains;
+                    currentItem = std::max(currentItem, 0);
+                    if (currentItem >= (int)namedWSes.size()) {
+                        // At the seam between namedWSes and normal WSes. Behave like r+[diff] at imaginary ws 0
+                        int diff      = currentItem - (namedWSes.size() - 1);
+                        predictedWSID = diff;
+                        int  beginID  = 1;
+                        int  endID    = predictedWSID;
+                        auto begin    = invalidWSes.upper_bound(beginID - 1); // upper_bound is >, we want >=
+                        for (auto it = begin; *it <= endID && it != invalidWSes.end(); it++) {
+                            remainingWSes++;
+                        }
                         walkDir = '+';
-                        // We know, that everything less than beginID is invalid, so don't bother with that
-                        finalWSID     = beginID;
-                        remainingWSes = 1;
+                    } else {
+                        // We found our final ws.
+                        remainingWSes = 0;
+                        predictedWSID = namedWSes[currentItem];
                     }
                 }
-            }
-            if (walkDir == '+') {
-                int curID = finalWSID;
-                while (++curID < INT32_MAX && remainingWSes > 0) {
-                    if (!invalidWSes.contains(curID)) {
-                        remainingWSes--;
+
+                // Go in the search direction for remainingWSes
+                // The performance impact is directly proportional to the number of open and bound workspaces
+                int finalWSID = predictedWSID;
+                if (walkDir == '-') {
+                    int beginID = finalWSID;
+                    int curID   = finalWSID;
+                    while (--curID > 0 && remainingWSes > 0) {
+                        if (!invalidWSes.contains(curID)) {
+                            remainingWSes--;
+                        }
+                        finalWSID = curID;
+                    }
+                    if (finalWSID <= 0 || invalidWSes.contains(finalWSID)) {
+                        if (namedWSes.size()) {
+                            // Go to the named workspaces
+                            // Need remainingWSes more
+                            int namedWSIdx = namedWSes.size() - remainingWSes;
+                            // Sanitze
+                            namedWSIdx = std::clamp(namedWSIdx, 0, (int)namedWSes.size() - 1);
+                            finalWSID  = namedWSes[namedWSIdx];
+                        } else {
+                            // Couldn't find valid workspace in negative direction, search last first one back up positive direction
+                            walkDir = '+';
+                            // We know, that everything less than beginID is invalid, so don't bother with that
+                            finalWSID     = beginID;
+                            remainingWSes = 1;
+                        }
                     }
-                    finalWSID = curID;
                 }
+                if (walkDir == '+') {
+                    int curID = finalWSID;
+                    while (++curID < INT32_MAX && remainingWSes > 0) {
+                        if (!invalidWSes.contains(curID)) {
+                            remainingWSes--;
+                        }
+                        finalWSID = curID;
+                    }
+                }
+                result = finalWSID;
             }
 
-            result                = finalWSID;
             const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(result);
             if (PWORKSPACE)
                 outName = g_pCompositor->getWorkspaceByID(result)->m_szName;
             else
-                outName = std::to_string(finalWSID);
+                outName = std::to_string(result);
 
-        } else if ((in[0] == 'm' || in[0] == 'e') && (in[1] == '-' || in[1] == '+') && isNumber(in.substr(2))) {
+        } else if ((in[0] == 'm' || in[0] == 'e') && (in[1] == '-' || in[1] == '+' || in[1] == '~') && isNumber(in.substr(2))) {
             bool onAllMonitors = in[0] == 'e';
+            bool absolute      = in[1] == '~';
 
             if (!g_pCompositor->m_pLastMonitor) {
                 Debug::log(ERR, "Relative monitor workspace on monitor null!");
@@ -450,7 +475,7 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
             }
 
             // monitor relative
-            const auto PLUSMINUSRESULT = getPlusMinusKeywordResult(in.substr(1), 0);
+            const auto PLUSMINUSRESULT = getPlusMinusKeywordResult(in.substr(absolute ? 2 : 1), 0);
 
             if (!PLUSMINUSRESULT.has_value())
                 return WORKSPACE_INVALID;
@@ -470,27 +495,40 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
 
             std::sort(validWSes.begin(), validWSes.end());
 
-            // get the offset
-            remains = remains < 0 ? -((-remains) % validWSes.size()) : remains % validWSes.size();
-
-            // get the current item
-            int activeWSID  = g_pCompositor->m_pLastMonitor->activeWorkspace ? g_pCompositor->m_pLastMonitor->activeWorkspace->m_iID : 1;
             int currentItem = -1;
-            for (size_t i = 0; i < validWSes.size(); i++) {
-                if (validWSes[i] == activeWSID) {
-                    currentItem = i;
-                    break;
+
+            if (absolute) {
+                // 1-index
+                currentItem = remains - 1;
+
+                // clamp
+                if (currentItem < 0) {
+                    currentItem = 0;
+                } else if (currentItem >= (int)validWSes.size()) {
+                    currentItem = validWSes.size() - 1;
                 }
-            }
+            } else {
+                // get the offset
+                remains = remains < 0 ? -((-remains) % validWSes.size()) : remains % validWSes.size();
 
-            // apply
-            currentItem += remains;
+                // get the current item
+                int activeWSID = g_pCompositor->m_pLastMonitor->activeWorkspace ? g_pCompositor->m_pLastMonitor->activeWorkspace->m_iID : 1;
+                for (size_t i = 0; i < validWSes.size(); i++) {
+                    if (validWSes[i] == activeWSID) {
+                        currentItem = i;
+                        break;
+                    }
+                }
 
-            // sanitize
-            if (currentItem >= (int)validWSes.size()) {
-                currentItem = currentItem % validWSes.size();
-            } else if (currentItem < 0) {
-                currentItem = validWSes.size() + currentItem;
+                // apply
+                currentItem += remains;
+
+                // sanitize
+                if (currentItem >= (int)validWSes.size()) {
+                    currentItem = currentItem % validWSes.size();
+                } else if (currentItem < 0) {
+                    currentItem = validWSes.size() + currentItem;
+                }
             }
 
             result  = validWSes[currentItem];
@@ -833,4 +871,36 @@ bool envEnabled(const std::string& env) {
     if (!ENV)
         return false;
     return std::string(ENV) == "1";
-}
+}
+
+std::pair<int, std::string> openExclusiveShm() {
+    std::string name = g_pTokenManager->getRandomUUID();
+
+    for (size_t i = 0; i < 69; ++i) {
+        int fd = shm_open(name.c_str(), O_RDWR | O_CREAT | O_EXCL, 0600);
+        if (fd >= 0)
+            return {fd, name};
+    }
+
+    return {-1, ""};
+}
+
+int allocateSHMFile(size_t len) {
+    auto [fd, name] = openExclusiveShm();
+    if (fd < 0)
+        return -1;
+
+    shm_unlink(name.c_str());
+
+    int ret;
+    do {
+        ret = ftruncate(fd, len);
+    } while (ret < 0 && errno == EINTR);
+
+    if (ret < 0) {
+        close(fd);
+        return -1;
+    }
+
+    return fd;
+}

src/helpers/MiscFunctions.hpp

@@ -38,6 +38,7 @@ void                             throwError(const std::string& err);
 uint32_t                         drmFormatToGL(uint32_t drm);
 uint32_t                         glFormatToType(uint32_t gl);
 bool                             envEnabled(const std::string& env);
+int                              allocateSHMFile(size_t len);
 
 template <typename... Args>
 [[deprecated("use std::format instead")]] std::string getFormat(std::format_string<Args...> fmt, Args&&... args) {

src/helpers/Monitor.cpp

@@ -1,10 +1,9 @@
 #include "Monitor.hpp"
-
 #include "MiscFunctions.hpp"
-
 #include "../Compositor.hpp"
-
 #include "../config/ConfigValue.hpp"
+#include "../protocols/GammaControl.hpp"
+#include "../devices/ITouch.hpp"
 
 int ratHandler(void* data) {
     g_pHyprRenderer->renderMonitor((CMonitor*)data);
@@ -26,6 +25,8 @@ CMonitor::~CMonitor() {
     hyprListener_monitorNeedsFrame.removeCallback();
     hyprListener_monitorCommit.removeCallback();
     hyprListener_monitorBind.removeCallback();
+
+    events.destroy.emit();
 }
 
 void CMonitor::onConnect(bool noRule) {
@@ -145,10 +146,10 @@ void CMonitor::onConnect(bool noRule) {
     if (!noRule)
         g_pHyprRenderer->applyMonitorRule(this, &monitorRule, true);
 
-    for (const auto& PTOUCHDEV : g_pInputManager->m_lTouchDevices) {
-        if (matchesStaticSelector(PTOUCHDEV.boundOutput)) {
-            Debug::log(LOG, "Binding touch device {} to output {}", PTOUCHDEV.name, szName);
-            wlr_cursor_map_input_to_output(g_pCompositor->m_sWLRCursor, PTOUCHDEV.pWlrDevice, output);
+    for (const auto& PTOUCHDEV : g_pInputManager->m_vTouches) {
+        if (matchesStaticSelector(PTOUCHDEV->boundOutput)) {
+            Debug::log(LOG, "Binding touch device {} to output {}", PTOUCHDEV->hlName, szName);
+            wlr_cursor_map_input_to_output(g_pCompositor->m_sWLRCursor, &PTOUCHDEV->wlr()->base, output);
         }
     }
 
@@ -214,6 +215,10 @@ void CMonitor::onConnect(bool noRule) {
     renderTimer = wl_event_loop_add_timer(g_pCompositor->m_sWLEventLoop, ratHandler, this);
 
     g_pCompositor->scheduleFrameForMonitor(this);
+
+    PROTO::gamma->applyGammaToState(this);
+
+    events.connect.emit();
 }
 
 void CMonitor::onDisconnect(bool destroy) {
@@ -228,6 +233,8 @@ void CMonitor::onDisconnect(bool destroy) {
 
     Debug::log(LOG, "onDisconnect called for {}", output->name);
 
+    events.disconnect.emit();
+
     // Cleanup everything. Move windows back, snap cursor, shit.
     CMonitor* BACKUPMON = nullptr;
     for (auto& m : g_pCompositor->m_vMonitors) {
@@ -297,8 +304,8 @@ void CMonitor::onDisconnect(bool destroy) {
             w->startAnim(true, true, true);
         }
     } else {
-        g_pCompositor->m_pLastFocus   = nullptr;
-        g_pCompositor->m_pLastWindow  = nullptr;
+        g_pCompositor->m_pLastFocus = nullptr;
+        g_pCompositor->m_pLastWindow.reset();
         g_pCompositor->m_pLastMonitor = nullptr;
     }
 
@@ -571,9 +578,9 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo
         }
 
         if (!noFocus && !g_pCompositor->m_pLastMonitor->activeSpecialWorkspace &&
-            !(g_pCompositor->m_pLastWindow && g_pCompositor->m_pLastWindow->m_bPinned && g_pCompositor->m_pLastWindow->m_iMonitorID == ID)) {
+            !(g_pCompositor->m_pLastWindow.lock() && g_pCompositor->m_pLastWindow.lock()->m_bPinned && g_pCompositor->m_pLastWindow.lock()->m_iMonitorID == ID)) {
             static auto PFOLLOWMOUSE = CConfigValue<Hyprlang::INT>("input:follow_mouse");
-            CWindow*    pWindow      = pWorkspace->getLastFocusedWindow();
+            auto        pWindow      = pWorkspace->getLastFocusedWindow();
 
             if (!pWindow) {
                 if (*PFOLLOWMOUSE == 1)
@@ -629,7 +636,7 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
 
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
 
-        if (!(g_pCompositor->m_pLastWindow && g_pCompositor->m_pLastWindow->m_bPinned && g_pCompositor->m_pLastWindow->m_iMonitorID == ID)) {
+        if (!(g_pCompositor->m_pLastWindow.lock() && g_pCompositor->m_pLastWindow.lock()->m_bPinned && g_pCompositor->m_pLastWindow.lock()->m_iMonitorID == ID)) {
             if (const auto PLAST = activeWorkspace->getLastFocusedWindow(); PLAST)
                 g_pCompositor->focusWindow(PLAST);
             else
@@ -697,7 +704,7 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
 
     g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
 
-    if (!(g_pCompositor->m_pLastWindow && g_pCompositor->m_pLastWindow->m_bPinned && g_pCompositor->m_pLastWindow->m_iMonitorID == ID)) {
+    if (!(g_pCompositor->m_pLastWindow.lock() && g_pCompositor->m_pLastWindow.lock()->m_bPinned && g_pCompositor->m_pLastWindow.lock()->m_iMonitorID == ID)) {
         if (const auto PLAST = pWorkspace->getLastFocusedWindow(); PLAST)
             g_pCompositor->focusWindow(PLAST);
         else

src/helpers/Monitor.hpp

@@ -10,8 +10,18 @@
 #include "Timer.hpp"
 #include "Region.hpp"
 #include <optional>
+#include "signal/Signal.hpp"
+
+// Enum for the different types of auto directions, e.g. auto-left, auto-up.
+enum class eAutoDirs {
+    DIR_AUTO_UP,
+    DIR_AUTO_DOWN,
+    DIR_AUTO_LEFT,
+    DIR_AUTO_RIGHT
+};
 
 struct SMonitorRule {
+    eAutoDirs           autoDir;
     std::string         name        = "";
     Vector2D            resolution  = Vector2D(1280, 720);
     Vector2D            offset      = Vector2D(0, 0);
@@ -83,10 +93,10 @@ class CMonitor {
     bool                    noFrameSchedule = false;
     bool                    scheduledRecalc = false;
     wl_output_transform     transform       = WL_OUTPUT_TRANSFORM_NORMAL;
-    bool                    gammaChanged    = false;
     float                   xwaylandScale   = 1.f;
     std::array<float, 9>    projMatrix      = {0};
     std::optional<Vector2D> forceSize;
+    wlr_output_mode*        currentMode = nullptr;
 
     bool                    dpmsStatus       = true;
     bool                    vrrActive        = false; // this can be TRUE even if VRR is not active in the case that this display does not support it.
@@ -109,7 +119,7 @@ class CMonitor {
     std::vector<CMonitor*> mirrors;
 
     // for tearing
-    CWindow* solitaryClient = nullptr;
+    PHLWINDOWREF solitaryClient;
 
     struct {
         bool canTear         = false;
@@ -120,7 +130,15 @@ class CMonitor {
         bool frameScheduledWhileBusy = false;
     } tearingState;
 
-    std::array<std::vector<std::unique_ptr<SLayerSurface>>, 4> m_aLayerSurfaceLayers;
+    struct {
+        CSignal destroy;
+        CSignal connect;
+        CSignal disconnect;
+        CSignal dpmsChanged;
+        CSignal modeChanged;
+    } events;
+
+    std::array<std::vector<PHLLS>, 4> m_aLayerSurfaceLayers;
 
     DYNLISTENER(monitorFrame);
     DYNLISTENER(monitorDestroy);

src/helpers/Region.cpp

@@ -8,7 +8,7 @@ CRegion::CRegion() {
     pixman_region32_init(&m_rRegion);
 }
 
-CRegion::CRegion(pixman_region32_t* ref) {
+CRegion::CRegion(const pixman_region32_t* const ref) {
     pixman_region32_init(&m_rRegion);
     pixman_region32_copy(&m_rRegion, ref);
 }

src/helpers/Region.hpp

@@ -11,7 +11,7 @@ class CRegion {
     /* Create an empty region */
     CRegion();
     /* Create from a reference. Copies, does not own. */
-    CRegion(pixman_region32_t* ref);
+    CRegion(const pixman_region32_t* const ref);
     /* Create from a box */
     CRegion(double x, double y, double w, double h);
     /* Create from a wlr_box */

src/helpers/SdDaemon.cpp

@@ -0,0 +1,58 @@
+#include "SdDaemon.hpp"
+
+#include <memory>
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+
+namespace Systemd {
+    int SdBooted(void) {
+        if (!faccessat(AT_FDCWD, "/run/systemd/system/", F_OK, AT_SYMLINK_NOFOLLOW))
+            return true;
+
+        if (errno == ENOENT)
+            return false;
+
+        return -errno;
+    }
+
+    int SdNotify(int unsetEnvironment, const char* state) {
+        int fd = socket(AF_UNIX, SOCK_DGRAM, 0);
+        if (fd == -1)
+            return -errno;
+
+        constexpr char envVar[] = "NOTIFY_SOCKET";
+
+        auto           cleanup = [unsetEnvironment, envVar](int* fd) {
+            if (unsetEnvironment)
+                unsetenv(envVar);
+            close(*fd);
+        };
+        std::unique_ptr<int, decltype(cleanup)> fdCleaup(&fd, cleanup);
+
+        const char*                             addr = getenv(envVar);
+        if (!addr)
+            return 0;
+
+        // address length must be at most this; see man 7 unix
+        size_t             addrLen = strnlen(addr, 107);
+
+        struct sockaddr_un unixAddr;
+        unixAddr.sun_family = AF_UNIX;
+        strncpy(unixAddr.sun_path, addr, addrLen);
+        if (unixAddr.sun_path[0] == '@')
+            unixAddr.sun_path[0] = '\0';
+
+        if (!connect(fd, (const sockaddr*)&unixAddr, sizeof(struct sockaddr_un)))
+            return 1;
+
+        // arbitrary value which seems to be enough for s-d messages
+        size_t stateLen = strnlen(state, 128);
+        if (write(fd, state, stateLen) >= 0)
+            return 1;
+
+        return -errno;
+    }
+}

src/helpers/SdDaemon.hpp

@@ -0,0 +1,6 @@
+#pragma once
+
+namespace Systemd {
+    int SdBooted(void);
+    int SdNotify(int unset_environment, const char* state);
+}

src/helpers/WLClasses.cpp

@@ -1,289 +1 @@
 #include "WLClasses.hpp"
-#include "../config/ConfigManager.hpp"
-#include "../Compositor.hpp"
-
-SLayerSurface::SLayerSurface() {
-    alpha.create(g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn"), this, AVARDAMAGE_ENTIRE);
-    realPosition.create(g_pConfigManager->getAnimationPropertyConfig("layersIn"), this, AVARDAMAGE_ENTIRE);
-    realSize.create(g_pConfigManager->getAnimationPropertyConfig("layersIn"), this, AVARDAMAGE_ENTIRE);
-    alpha.registerVar();
-    realPosition.registerVar();
-    realSize.registerVar();
-
-    alpha.setUpdateCallback([this](void*) {
-        if (dimAround)
-            g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(monitorID));
-    });
-
-    alpha.setValueAndWarp(0.f);
-}
-
-SLayerSurface::~SLayerSurface() {
-    if (!g_pHyprOpenGL)
-        return;
-
-    g_pHyprRenderer->makeEGLCurrent();
-    std::erase_if(g_pHyprOpenGL->m_mLayerFramebuffers, [&](const auto& other) { return other.first == this; });
-}
-
-void SLayerSurface::applyRules() {
-    noAnimations     = false;
-    forceBlur        = false;
-    ignoreAlpha      = false;
-    ignoreAlphaValue = 0.f;
-    dimAround        = false;
-    xray             = -1;
-    animationStyle.reset();
-
-    for (auto& rule : g_pConfigManager->getMatchingRules(this)) {
-        if (rule.rule == "noanim")
-            noAnimations = true;
-        else if (rule.rule == "blur")
-            forceBlur = true;
-        else if (rule.rule == "blurpopups")
-            forceBlurPopups = true;
-        else if (rule.rule.starts_with("ignorealpha") || rule.rule.starts_with("ignorezero")) {
-            const auto  FIRST_SPACE_POS = rule.rule.find_first_of(' ');
-            std::string alphaValue      = "";
-            if (FIRST_SPACE_POS != std::string::npos)
-                alphaValue = rule.rule.substr(FIRST_SPACE_POS + 1);
-
-            try {
-                ignoreAlpha = true;
-                if (!alphaValue.empty())
-                    ignoreAlphaValue = std::stof(alphaValue);
-            } catch (...) { Debug::log(ERR, "Invalid value passed to ignoreAlpha"); }
-        } else if (rule.rule == "dimaround") {
-            dimAround = true;
-        } else if (rule.rule.starts_with("xray")) {
-            CVarList vars{rule.rule, 0, ' '};
-            try {
-                xray = configStringToInt(vars[1]);
-            } catch (...) {}
-        } else if (rule.rule.starts_with("animation")) {
-            CVarList vars{rule.rule, 2, 's'};
-            animationStyle = vars[1];
-        }
-    }
-}
-
-void SLayerSurface::startAnimation(bool in, bool instant) {
-    const auto ANIMSTYLE = animationStyle.value_or(realPosition.m_pConfig->pValues->internalStyle);
-    if (in) {
-        realPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("layersIn");
-        realSize.m_pConfig     = g_pConfigManager->getAnimationPropertyConfig("layersIn");
-        alpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig("fadeLayersIn");
-    } else {
-        realPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("layersOut");
-        realSize.m_pConfig     = g_pConfigManager->getAnimationPropertyConfig("layersOut");
-        alpha.m_pConfig        = g_pConfigManager->getAnimationPropertyConfig("fadeLayersOut");
-    }
-
-    if (ANIMSTYLE.starts_with("slide")) {
-        // get closest edge
-        const auto MIDDLE = geometry.middle();
-
-        const auto PMONITOR = g_pCompositor->getMonitorFromVector(MIDDLE);
-
-        int        force = -1;
-
-        CVarList   args(ANIMSTYLE, 0, 's');
-        if (args.size() > 1) {
-            const auto ARG2 = args[1];
-            if (ARG2 == "top")
-                force = 0;
-            else if (ARG2 == "bottom")
-                force = 1;
-            else if (ARG2 == "left")
-                force = 2;
-            else if (ARG2 == "right")
-                force = 3;
-        }
-
-        const std::array<Vector2D, 4> edgePoints = {
-            PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x / 2, 0},
-            PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x / 2, PMONITOR->vecSize.y},
-            PMONITOR->vecPosition + Vector2D{0, PMONITOR->vecSize.y},
-            PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x, PMONITOR->vecSize.y / 2},
-        };
-
-        float closest = std::numeric_limits<float>::max();
-        int   leader  = force;
-        if (leader == -1) {
-            for (size_t i = 0; i < 4; ++i) {
-                float dist = MIDDLE.distance(edgePoints[i]);
-                if (dist < closest) {
-                    leader  = i;
-                    closest = dist;
-                }
-            }
-        }
-
-        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 = {geometry.x, PMONITOR->vecPosition.y - geometry.h};
-                break;
-            case 1:
-                // BOTTOM
-                prePos = {geometry.x, PMONITOR->vecPosition.y + PMONITOR->vecSize.y};
-                break;
-            case 2:
-                // LEFT
-                prePos = {PMONITOR->vecPosition.x - geometry.w, geometry.y};
-                break;
-            case 3:
-                // RIGHT
-                prePos = {PMONITOR->vecPosition.x + PMONITOR->vecSize.x, geometry.y};
-                break;
-            default: UNREACHABLE();
-        }
-
-        if (in) {
-            realPosition.setValueAndWarp(prePos);
-            realPosition = geometry.pos();
-        } else {
-            realPosition.setValueAndWarp(geometry.pos());
-            realPosition = prePos;
-        }
-
-    } else if (ANIMSTYLE.starts_with("popin")) {
-        float minPerc = 0.f;
-        if (ANIMSTYLE.find("%") != std::string::npos) {
-            try {
-                auto percstr = ANIMSTYLE.substr(ANIMSTYLE.find_last_of(' '));
-                minPerc      = std::stoi(percstr.substr(0, percstr.length() - 1));
-            } catch (std::exception& e) {
-                ; // oops
-            }
-        }
-
-        minPerc *= 0.01;
-
-        const auto GOALSIZE = (geometry.size() * minPerc).clamp({5, 5});
-        const auto GOALPOS  = geometry.pos() + (geometry.size() - GOALSIZE) / 2.f;
-
-        alpha.setValueAndWarp(in ? 0.f : 1.f);
-        alpha = in ? 1.f : 0.f;
-
-        if (in) {
-            realSize.setValueAndWarp(GOALSIZE);
-            realPosition.setValueAndWarp(GOALPOS);
-            realSize     = geometry.size();
-            realPosition = geometry.pos();
-        } else {
-            realSize.setValueAndWarp(geometry.size());
-            realPosition.setValueAndWarp(geometry.pos());
-            realSize     = GOALSIZE;
-            realPosition = GOALPOS;
-        }
-    } else {
-        // fade
-        realPosition.setValueAndWarp(geometry.pos());
-        realSize.setValueAndWarp(geometry.size());
-        alpha = in ? 1.f : 0.f;
-    }
-
-    if (!in)
-        fadingOut = true;
-}
-
-bool SLayerSurface::isFadedOut() {
-    if (!fadingOut)
-        return false;
-
-    return !realPosition.isBeingAnimated() && !realSize.isBeingAnimated() && !alpha.isBeingAnimated();
-}
-
-int SLayerSurface::popupsCount() {
-    if (!layerSurface || !mapped || fadingOut)
-        return 0;
-
-    int no = 0;
-    wlr_layer_surface_v1_for_each_popup_surface(
-        layerSurface, [](wlr_surface* s, int x, int y, void* data) { *(int*)data += 1; }, &no);
-    return no;
-}
-
-void SKeyboard::updateXKBTranslationState(xkb_keymap* const keymap) {
-    xkb_state_unref(xkbTranslationState);
-
-    if (keymap) {
-        Debug::log(LOG, "Updating keyboard {:x}'s translation state from a provided keymap", (uintptr_t)this);
-        xkbTranslationState = xkb_state_new(keymap);
-        return;
-    }
-
-    const auto WLRKB      = wlr_keyboard_from_input_device(keyboard);
-    const auto KEYMAP     = WLRKB->keymap;
-    const auto STATE      = WLRKB->xkb_state;
-    const auto LAYOUTSNUM = xkb_keymap_num_layouts(KEYMAP);
-
-    const auto PCONTEXT = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
-
-    for (uint32_t i = 0; i < LAYOUTSNUM; ++i) {
-        if (xkb_state_layout_index_is_active(STATE, i, XKB_STATE_LAYOUT_EFFECTIVE)) {
-            Debug::log(LOG, "Updating keyboard {:x}'s translation state from an active index {}", (uintptr_t)this, i);
-
-            CVarList       keyboardLayouts(currentRules.layout, 0, ',');
-            CVarList       keyboardModels(currentRules.model, 0, ',');
-            CVarList       keyboardVariants(currentRules.variant, 0, ',');
-
-            xkb_rule_names rules = {.rules = "", .model = "", .layout = "", .variant = "", .options = ""};
-
-            std::string    layout, model, variant;
-            layout  = keyboardLayouts[i % keyboardLayouts.size()];
-            model   = keyboardModels[i % keyboardModels.size()];
-            variant = keyboardVariants[i % keyboardVariants.size()];
-
-            rules.layout  = layout.c_str();
-            rules.model   = model.c_str();
-            rules.variant = variant.c_str();
-
-            auto KEYMAP = xkb_keymap_new_from_names(PCONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
-
-            if (!KEYMAP) {
-                Debug::log(ERR, "updateXKBTranslationState: keymap failed 1, fallback without model/variant");
-                rules.model   = "";
-                rules.variant = "";
-                KEYMAP        = xkb_keymap_new_from_names(PCONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
-            }
-
-            if (!KEYMAP) {
-                Debug::log(ERR, "updateXKBTranslationState: keymap failed 2, fallback to us");
-                rules.layout = "us";
-                KEYMAP       = xkb_keymap_new_from_names(PCONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
-            }
-
-            xkbTranslationState = xkb_state_new(KEYMAP);
-
-            xkb_keymap_unref(KEYMAP);
-            xkb_context_unref(PCONTEXT);
-
-            return;
-        }
-    }
-
-    Debug::log(LOG, "Updating keyboard {:x}'s translation state from an unknown index", (uintptr_t)this);
-
-    xkb_rule_names rules = {
-        .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);
-
-    xkbTranslationState = xkb_state_new(NEWKEYMAP);
-
-    xkb_keymap_unref(NEWKEYMAP);
-    xkb_context_unref(PCONTEXT);
-}

src/helpers/WLClasses.hpp

@@ -2,78 +2,17 @@
 
 #include "../events/Events.hpp"
 #include "../defines.hpp"
-#include "wlr-layer-shell-unstable-v1-protocol.h"
 #include "../desktop/Window.hpp"
 #include "../desktop/Subsurface.hpp"
 #include "../desktop/Popup.hpp"
 #include "AnimatedVariable.hpp"
 #include "../desktop/WLSurface.hpp"
+#include "signal/Listener.hpp"
 #include "Region.hpp"
 
-struct SLayerRule {
-    std::string targetNamespace = "";
-    std::string rule            = "";
-};
-
-struct SLayerSurface {
-    SLayerSurface();
-    ~SLayerSurface();
-
-    void                        applyRules();
-    void                        startAnimation(bool in, bool instant = false);
-    bool                        isFadedOut();
-    int                         popupsCount();
-
-    CAnimatedVariable<Vector2D> realPosition;
-    CAnimatedVariable<Vector2D> realSize;
-
-    wlr_layer_surface_v1*       layerSurface;
-    wl_list                     link;
-
-    bool                        keyboardExclusive = false;
-
-    CWLSurface                  surface;
-
-    // desktop components
-    std::unique_ptr<CPopup> popupHead;
-
-    DYNLISTENER(destroyLayerSurface);
-    DYNLISTENER(mapLayerSurface);
-    DYNLISTENER(unmapLayerSurface);
-    DYNLISTENER(commitLayerSurface);
-
-    CBox                       geometry = {0, 0, 0, 0};
-    Vector2D                   position;
-    zwlr_layer_shell_v1_layer  layer;
-
-    bool                       mapped = false;
-
-    int                        monitorID = -1;
-
-    std::string                szNamespace = "";
-
-    CAnimatedVariable<float>   alpha;
-    bool                       fadingOut     = false;
-    bool                       readyToDelete = false;
-    bool                       noProcess     = false;
-    bool                       noAnimations  = false;
-
-    bool                       forceBlur        = false;
-    bool                       forceBlurPopups  = false;
-    int                        xray             = -1;
-    bool                       ignoreAlpha      = false;
-    float                      ignoreAlphaValue = 0.f;
-    bool                       dimAround        = false;
-
-    std::optional<std::string> animationStyle;
-
-    // For the list lookup
-    bool operator==(const SLayerSurface& rhs) const {
-        return layerSurface == rhs.layerSurface && monitorID == rhs.monitorID;
-    }
-};
-
 class CMonitor;
+class IPointer;
+class IKeyboard;
 
 struct SRenderData {
     CMonitor* pMonitor;
@@ -108,9 +47,9 @@ struct SRenderData {
     bool squishOversized = true;
 
     // for calculating UV
-    CWindow* pWindow = nullptr;
+    PHLWINDOW pWindow;
 
-    bool     popup = false;
+    bool      popup = false;
 };
 
 struct SExtensionFindingData {
@@ -119,69 +58,12 @@ struct SExtensionFindingData {
     wlr_surface** found;
 };
 
-struct SStringRuleNames {
-    std::string layout  = "";
-    std::string model   = "";
-    std::string variant = "";
-    std::string options = "";
-    std::string rules   = "";
-};
-
-struct SKeyboard {
-    wlr_input_device* keyboard;
-
-    DYNLISTENER(keyboardMod);
-    DYNLISTENER(keyboardKey);
-    DYNLISTENER(keyboardKeymap);
-    DYNLISTENER(keyboardDestroy);
-
-    bool               isVirtual = false;
-    bool               active    = false;
-    bool               enabled   = true;
-
-    xkb_layout_index_t activeLayout        = 0;
-    xkb_state*         xkbTranslationState = nullptr;
-
-    std::string        name        = "";
-    std::string        xkbFilePath = "";
-
-    SStringRuleNames   currentRules;
-    int                repeatRate        = 0;
-    int                repeatDelay       = 0;
-    int                numlockOn         = -1;
-    bool               resolveBindsBySym = false;
-
-    void               updateXKBTranslationState(xkb_keymap* const keymap = nullptr);
-
-    // For the list lookup
-    bool operator==(const SKeyboard& rhs) const {
-        return keyboard == rhs.keyboard;
-    }
-};
-
-struct SMouse {
-    wlr_input_device* mouse = nullptr;
-
-    std::string       name = "";
-
-    bool              virt = false;
-
-    bool              connected = false; // means connected to the cursor
-
-    DYNLISTENER(destroyMouse);
-
-    bool operator==(const SMouse& b) const {
-        return mouse == b.mouse;
-    }
-};
-
-class CMonitor;
-
 struct SSeat {
-    wlr_seat*  seat            = nullptr;
-    wl_client* exclusiveClient = nullptr;
+    wlr_seat*     seat            = nullptr;
+    wl_client*    exclusiveClient = nullptr;
 
-    SMouse*    mouse = nullptr;
+    WP<IPointer>  mouse;
+    WP<IKeyboard> keyboard;
 };
 
 struct SDrag {
@@ -269,18 +151,6 @@ struct STabletPad {
     }
 };
 
-struct SIdleInhibitor {
-    wlr_idle_inhibitor_v1* pWlrInhibitor   = nullptr;
-    CWindow*               pWindow         = nullptr;
-    HOOK_CALLBACK_FN*      onWindowDestroy = nullptr;
-
-    DYNLISTENER(Destroy);
-
-    bool operator==(const SIdleInhibitor& b) const {
-        return pWlrInhibitor == b.pWlrInhibitor;
-    }
-};
-
 struct SSwipeGesture {
     PHLWORKSPACE pWorkspaceBegin = nullptr;
 
@@ -294,28 +164,6 @@ struct SSwipeGesture {
     CMonitor*    pMonitor = nullptr;
 };
 
-struct SIMEKbGrab {
-    wlr_input_method_keyboard_grab_v2* pWlrKbGrab = nullptr;
-
-    wlr_keyboard*                      pKeyboard = nullptr;
-
-    DYNLISTENER(grabDestroy);
-};
-
-struct STouchDevice {
-    wlr_input_device* pWlrDevice = nullptr;
-
-    std::string       name = "";
-
-    std::string       boundOutput = "";
-
-    DYNLISTENER(destroy);
-
-    bool operator==(const STouchDevice& other) const {
-        return pWlrDevice == other.pWlrDevice;
-    }
-};
-
 struct SSwitchDevice {
     wlr_input_device* pWlrDevice = nullptr;
 
@@ -328,24 +176,3 @@ struct SSwitchDevice {
         return pWlrDevice == other.pWlrDevice;
     }
 };
-
-struct STearingController {
-    wlr_tearing_control_v1* pWlrHint = nullptr;
-
-    DYNLISTENER(set);
-    DYNLISTENER(destroy);
-
-    bool operator==(const STearingController& other) const {
-        return pWlrHint == other.pWlrHint;
-    }
-};
-
-struct SShortcutInhibitor {
-    wlr_keyboard_shortcuts_inhibitor_v1* pWlrInhibitor = nullptr;
-
-    DYNLISTENER(destroy);
-
-    bool operator==(const SShortcutInhibitor& other) const {
-        return pWlrInhibitor == other.pWlrInhibitor;
-    }
-};

src/helpers/WLListener.cpp

@@ -12,7 +12,7 @@ void handleWrapped(wl_listener* listener, void* data) {
 
     try {
         pWrap->m_pSelf->emit(data);
-    } catch (std::exception& e) { Debug::log(ERR, "Listener {} timed out and was killed by Watchdog!!!", (uintptr_t)listener); }
+    } catch (std::exception& e) { Debug::log(ERR, "Listener {} threw or timed out and was killed by Watchdog!!! This is bad. what(): {}", (uintptr_t)listener, e.what()); }
 
     if (g_pWatchdog)
         g_pWatchdog->endWatching();

src/helpers/signal/Listener.cpp

@@ -0,0 +1,21 @@
+#include "Listener.hpp"
+#include "Signal.hpp"
+
+CSignalListener::CSignalListener(std::function<void(std::any)> handler) : m_fHandler(handler) {
+    ;
+}
+
+void CSignalListener::emit(std::any data) {
+    if (!m_fHandler)
+        return;
+
+    m_fHandler(data);
+}
+
+CStaticSignalListener::CStaticSignalListener(std::function<void(void*, std::any)> handler, void* owner) : m_pOwner(owner), m_fHandler(handler) {
+    ;
+}
+
+void CStaticSignalListener::emit(std::any data) {
+    m_fHandler(m_pOwner, data);
+}

src/helpers/signal/Listener.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <any>
+#include <memory>
+#include <functional>
+
+class CSignal;
+
+class CSignalListener {
+  public:
+    CSignalListener(std::function<void(std::any)> handler);
+
+    CSignalListener(CSignalListener&&)       = delete;
+    CSignalListener(CSignalListener&)        = delete;
+    CSignalListener(const CSignalListener&)  = delete;
+    CSignalListener(const CSignalListener&&) = delete;
+
+    void emit(std::any data);
+
+  private:
+    std::function<void(std::any)> m_fHandler;
+};
+
+typedef std::shared_ptr<CSignalListener> CHyprSignalListener;
+
+class CStaticSignalListener {
+  public:
+    CStaticSignalListener(std::function<void(void*, std::any)> handler, void* owner);
+
+    CStaticSignalListener(CStaticSignalListener&&)       = delete;
+    CStaticSignalListener(CStaticSignalListener&)        = delete;
+    CStaticSignalListener(const CStaticSignalListener&)  = delete;
+    CStaticSignalListener(const CStaticSignalListener&&) = delete;
+
+    void emit(std::any data);
+
+  private:
+    void*                                m_pOwner = nullptr;
+    std::function<void(void*, std::any)> m_fHandler;
+};

src/helpers/signal/Signal.cpp

@@ -0,0 +1,30 @@
+#include "Signal.hpp"
+#include <algorithm>
+
+void CSignal::emit(std::any data) {
+    bool dirty = false;
+
+    for (auto& l : m_vListeners) {
+        if (const CHyprSignalListener L = l.lock())
+            L->emit(data);
+        else
+            dirty = true;
+    }
+
+    for (auto& l : m_vStaticListeners) {
+        l->emit(data);
+    }
+
+    if (dirty)
+        std::erase_if(m_vListeners, [](const auto& other) { return other.expired(); });
+}
+
+CHyprSignalListener CSignal::registerListener(std::function<void(std::any)> handler) {
+    CHyprSignalListener listener = std::make_shared<CSignalListener>(handler);
+    m_vListeners.emplace_back(std::weak_ptr<CSignalListener>(listener));
+    return listener;
+}
+
+void CSignal::registerStaticListener(std::function<void(void*, std::any)> handler, void* owner) {
+    m_vStaticListeners.emplace_back(std::make_unique<CStaticSignalListener>(handler, owner));
+}

src/helpers/signal/Signal.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <functional>
+#include <any>
+#include <vector>
+#include <memory>
+
+#include "Listener.hpp"
+
+class CSignal {
+  public:
+    void emit(std::any data = {});
+
+    //
+    [[nodiscard("Listener is unregistered when the ptr is lost")]] CHyprSignalListener registerListener(std::function<void(std::any)> handler);
+
+    // this is for static listeners. They die with this signal.
+    // TODO: can we somehow rid of the void* data and make it a custom this?
+    void registerStaticListener(std::function<void(void*, std::any)> handler, void* owner);
+
+  private:
+    std::vector<std::weak_ptr<CSignalListener>>         m_vListeners;
+    std::vector<std::unique_ptr<CStaticSignalListener>> m_vStaticListeners;
+};

src/hyprerror/HyprError.cpp

@@ -6,7 +6,7 @@ CHyprError::CHyprError() {
     m_fFadeOpacity.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), AVARDAMAGE_NONE);
     m_fFadeOpacity.registerVar();
 
-    g_pHookSystem->hookDynamic("focusedMon", [&](void* self, SCallbackInfo& info, std::any param) {
+    static auto P = g_pHookSystem->hookDynamic("focusedMon", [&](void* self, SCallbackInfo& info, std::any param) {
         if (!m_bIsCreated)
             return;
 
@@ -14,7 +14,7 @@ CHyprError::CHyprError() {
         m_bMonitorChanged = true;
     });
 
-    g_pHookSystem->hookDynamic("preRender", [&](void* self, SCallbackInfo& info, std::any param) {
+    static auto P2 = g_pHookSystem->hookDynamic("preRender", [&](void* self, SCallbackInfo& info, std::any param) {
         if (!m_bIsCreated)
             return;