version: bump to 0.24.0

If debug:manual_crash is set on startup, parseKeyword tries
to call g_pHyprNotificationOverlay->addNotification, but
g_pHyprNotificationOverlay isn't initialized yet (is nullptr)

This commit adds a sanity check for that.

.github/workflows/ci.yaml

@@ -12,15 +12,14 @@ jobs:
         run: |
            sed -i 's/SigLevel    = Required DatabaseOptional/SigLevel    = Optional TrustAll/' /etc/pacman.conf
            pacman --noconfirm --noprogressbar -Syyu
-           pacman --noconfirm --noprogressbar -Sy glslang libepoxy libfontenc libxcvt libxfont2 libxkbfile vulkan-headers vulkan-validation-layers xcb-util-errors xcb-util-renderutil xcb-util-wm xorg-fonts-encodings xorg-server-common xorg-setxkbmap xorg-xkbcomp xorg-xwayland git cmake go clang lld libc++ pkgconf meson ninja wayland wayland-protocols libinput libxkbcommon pixman glm libdrm libglvnd cairo pango systemd scdoc base-devel seatd
+           pacman --noconfirm --noprogressbar -Sy glslang libepoxy libfontenc libxcvt libxfont2 libxkbfile vulkan-headers vulkan-validation-layers xcb-util-errors xcb-util-renderutil xcb-util-wm xorg-fonts-encodings xorg-server-common xorg-setxkbmap xorg-xkbcomp xorg-xwayland git cmake go clang lld libc++ pkgconf meson ninja wayland wayland-protocols libinput libxkbcommon pixman glm libdrm libglvnd cairo pango systemd scdoc base-devel seatd python libliftoff
       - name: Set up user
         run: |
           useradd -m githubuser
           echo -e "root ALL=(ALL:ALL) ALL\ngithubuser ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers
-      - name: Build wlroots
+      - name: Install libdisplay-info from the AUR
         run: |
-          su githubuser -c "cd ~ && git clone https://gitlab.freedesktop.org/wlroots/wlroots" 
-          su githubuser -c "cd ~/wlroots && meson build/ --prefix=/usr && ninja -C build/ && sudo ninja -C build/ install && cd .."
+          su githubuser -c "cd ~ && git clone https://aur.archlinux.org/libdisplay-info.git && cd ./libdisplay-info && makepkg -si --skippgpcheck --noconfirm --noprogressbar"
       - name: Fix permissions for git
         run: |
           git config --global --add safe.directory /__w/Hyprland/Hyprland
@@ -62,7 +61,14 @@ jobs:
         run: |
           sed -i 's/SigLevel    = Required DatabaseOptional/SigLevel    = Optional TrustAll/' /etc/pacman.conf
           pacman --noconfirm --noprogressbar -Syyu
-          pacman --noconfirm --noprogressbar -Sy glslang libepoxy libfontenc libxcvt libxfont2 libxkbfile vulkan-headers vulkan-validation-layers git go clang lld libc++ pkgconf meson ninja wayland wayland-protocols libinput libxkbcommon pixman glm libdrm libglvnd cairo pango systemd scdoc base-devel seatd cmake 
+          pacman --noconfirm --noprogressbar -Sy glslang libepoxy libfontenc libxcvt libxfont2 libxkbfile vulkan-headers vulkan-validation-layers git go clang lld libc++ pkgconf meson ninja wayland wayland-protocols libinput libxkbcommon pixman glm libdrm libglvnd cairo pango systemd scdoc base-devel seatd cmake jq python libliftoff
+      - name: Set up user
+        run: |
+          useradd -m githubuser
+          echo -e "root ALL=(ALL:ALL) ALL\ngithubuser ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers
+      - name: Install libdisplay-info from the AUR
+        run: |
+          su githubuser -c "cd ~ && git clone https://aur.archlinux.org/libdisplay-info.git && cd ./libdisplay-info && makepkg -si --skippgpcheck --noconfirm --noprogressbar"
       - name: Checkout Hyprland
         uses: actions/checkout@v3
         with:
@@ -84,7 +90,14 @@ jobs:
         run: |
           sed -i 's/SigLevel    = Required DatabaseOptional/SigLevel    = Optional TrustAll/' /etc/pacman.conf
           pacman --noconfirm --noprogressbar -Syyu
-          pacman --noconfirm --noprogressbar -Sy glslang libepoxy libfontenc libxcvt libxfont2 libxkbfile vulkan-headers vulkan-validation-layers git cmake go clang lld libc++ pkgconf meson ninja wayland wayland-protocols libinput libxkbcommon pixman glm libdrm libglvnd cairo pango systemd scdoc base-devel seatd
+          pacman --noconfirm --noprogressbar -Sy glslang libepoxy libfontenc libxcvt libxfont2 libxkbfile vulkan-headers vulkan-validation-layers git cmake go clang lld libc++ pkgconf meson ninja wayland wayland-protocols libinput libxkbcommon pixman glm libdrm libglvnd cairo pango systemd scdoc base-devel seatd libliftoff
+      - name: Set up user
+        run: |
+          useradd -m githubuser
+          echo -e "root ALL=(ALL:ALL) ALL\ngithubuser ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers
+      - name: Install libdisplay-info from the AUR
+        run: |
+          su githubuser -c "cd ~ && git clone https://aur.archlinux.org/libdisplay-info.git && cd ./libdisplay-info && makepkg -si --skippgpcheck --noconfirm --noprogressbar"
       - name: Checkout Hyprland
         uses: actions/checkout@v3
         with:

.github/workflows/nix-build.yaml

@@ -5,26 +5,22 @@ jobs:
   nix:
     name: "Build Hyprland (Nix)"
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        package:
-        - default
-        - hyprland-no-hidpi
     steps:
     - name: Clone repository
       uses: actions/checkout@v3
       with:
         submodules: recursive
     - name: Install nix
-      uses: cachix/install-nix-action@v18
+      uses: cachix/install-nix-action@v20
       with:
         install_url: https://nixos.org/nix/install
         extra_nix_config: |
           auto-optimise-store = true
+          access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
           experimental-features = nix-command flakes
     - uses: cachix/cachix-action@v12
       with:
         name: hyprland
         authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
-    - name: Build Hyprland with default settings
-      run: nix build .#${{ matrix.package }} --print-build-logs
+    - name: Build packages
+      run: nix flake check --print-build-logs --accept-flake-config

.github/workflows/nix-meson-ver-update.yaml

@@ -1,26 +0,0 @@
-name: "Nix & Meson: update version"
-
-on: [workflow_dispatch]
-
-jobs:
-  update:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Clone repository
-      uses: actions/checkout@v3
-    - name: Update flake and meson version
-      run: |
-        REGEX="([0-9]+(\.[0-9a-zA-Z]+)+)"
-
-        CRT_REV=$(git show-ref --tags --head --abbrev | head -n 1 | head -c 7)
-        TAG_REV=$(git show-ref --tags --abbrev | tail -n 1 | head -c 7)
-        CRT_VER=$(sed -nEe "/$REGEX/{p;q;}" meson.build | awk -F\' '{print $2}')
-        VERSION=$(git show-ref --tags --abbrev | tail -n 1 | tail -c +20)
-
-        if [[ $TAG_REV = $CRT_REV ]] || [[ $CRT_VER != $VERSION ]]; then
-          sed -Ei "s/$REGEX/$VERSION/g" meson.build
-          sed -Ei "s/$REGEX/$VERSION/g" flake.nix
-        fi
-    - uses: stefanzweifel/git-auto-commit-action@v4
-      with:
-        commit_message: "[gha] bump flake and meson version"

.github/workflows/nix-update.yaml

@@ -9,14 +9,21 @@ jobs:
     - name: Clone repository
       uses: actions/checkout@v3
     - name: Install nix
-      uses: cachix/install-nix-action@v18
+      uses: cachix/install-nix-action@v20
       with:
         install_url: https://nixos.org/nix/install
         extra_nix_config: |
           auto-optimise-store = true
+          access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
           experimental-features = nix-command flakes
     - name: Update lockfile
       run: nix/update-inputs.sh
+    - uses: cachix/cachix-action@v12
+      with:
+        name: hyprland
+        authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
+    - name: Build Waybar-Hyprland
+      run: nix build .#waybar-hyprland --print-build-logs
     - uses: stefanzweifel/git-auto-commit-action@v4
       with:
         commit_message: "[gha] bump flake inputs"

.gitignore

@@ -12,6 +12,7 @@ _deps
 build/
 result*
 /.vscode/
+/.idea/
 .envrc
 .cache
 
@@ -19,6 +20,7 @@ result*
 *-protocol.c
 *-protocol.h
 .ccls-cache
+*.so
 
 hyprctl/hyprctl
 

.gitmodules

@@ -4,3 +4,6 @@
 [submodule "subprojects/hyprland-protocols"]
 	path = subprojects/hyprland-protocols
 	url = https://github.com/hyprwm/hyprland-protocols
+[submodule "subprojects/udis86"]
+	path = subprojects/udis86
+	url = https://github.com/canihavesomecoffee/udis86

CMakeLists.txt

@@ -1,6 +1,13 @@
-cmake_minimum_required(VERSION 3.4)
-project(Hyprland 
+cmake_minimum_required(VERSION 3.19)
+include(CheckIncludeFile)
+
+# Get version
+file(READ ${CMAKE_CURRENT_SOURCE_DIR}/props.json PROPS)
+string(JSON VER GET ${PROPS} version)
+
+project(Hyprland
     DESCRIPTION "A Modern C++ Wayland Compositor"
+    VERSION ${VER}
 )
 
 set(CMAKE_MESSAGE_LOG_LEVEL "STATUS")
@@ -35,62 +42,85 @@ execute_process(
 #
 #
 
-IF(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
+if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
     message(STATUS "Configuring Hyprland in Debug with CMake")
-    add_definitions( -DHYPRLAND_DEBUG )
-ELSE()
-    add_compile_options( -O3 )
+    add_compile_definitions(HYPRLAND_DEBUG)
+else()
+    add_compile_options(-O3)
     message(STATUS "Configuring Hyprland in Release with CMake")
-ENDIF(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
+endif()
 
-include_directories(. PRIVATE "subprojects/wlroots/include/")
-include_directories(. PRIVATE "subprojects/wlroots/build/include/")
+include_directories(
+  .
+  "subprojects/wlroots/include/"
+  "subprojects/wlroots/build/include/"
+  "subprojects/udis86/")
 set(CMAKE_CXX_STANDARD 23)
-add_compile_options(-DWLR_USE_UNSTABLE)
-add_compile_options(-Wall -Wextra -Wno-unused-parameter -Wno-unused-value -Wno-missing-field-initializers -Wno-narrowing)
+add_compile_definitions(WLR_USE_UNSTABLE)
+add_compile_options(-Wall -Wextra -Wno-unused-parameter -Wno-unused-value -Wno-missing-field-initializers -Wno-narrowing -Wno-pointer-arith)
+add_link_options(-rdynamic)
+set(CMAKE_ENABLE_EXPORTS TRUE)
 
 message(STATUS "Checking deps...")
 
 find_package(Threads REQUIRED)
 
 find_package(PkgConfig REQUIRED)
-pkg_check_modules(deps REQUIRED IMPORTED_TARGET wayland-server wayland-client wayland-cursor wayland-protocols cairo libdrm egl xkbcommon libinput) # we do not check for wlroots, as we provide it ourselves
+pkg_check_modules(deps REQUIRED IMPORTED_TARGET wayland-server wayland-client wayland-cursor wayland-protocols cairo libdrm egl xkbcommon libinput pango pangocairo) # we do not check for wlroots, as we provide it ourselves
 
-file(GLOB_RECURSE SRCFILES "src/*.cpp")
+file(GLOB_RECURSE SRCFILES CONFIGURE_DEPENDS "src/*.cpp")
 
 add_executable(Hyprland ${SRCFILES})
 
-IF(LEGACY_RENDERER MATCHES true)
-    message(STATUS "Using the legacy GLES2 renderer!")
-    add_definitions( -DLEGACY_RENDERER )
-ENDIF(LEGACY_RENDERER MATCHES true)
+if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
+    message(STATUS "Setting debug flags")
 
-IF(NO_XWAYLAND MATCHES true)
+    target_link_libraries(Hyprland asan)
+
+    add_compile_options(-pg -no-pie -fno-builtin -fsanitize=address)
+    add_link_options(-pg -no-pie -fno-builtin)
+endif()
+
+include(CheckLibraryExists)
+check_library_exists(execinfo backtrace "" HAVE_LIBEXECINFO)
+if(HAVE_LIBEXECINFO)
+    target_link_libraries(Hyprland PRIVATE execinfo)
+endif()
+
+if(LEGACY_RENDERER)
+    message(STATUS "Using the legacy GLES2 renderer!")
+    add_compile_definitions(LEGACY_RENDERER)
+endif()
+
+if(NO_XWAYLAND)
     message(STATUS "Using the NO_XWAYLAND flag, disabling XWayland!")
-    add_definitions( -DNO_XWAYLAND )
-ELSE()
+    add_compile_definitions(NO_XWAYLAND)
+else()
     message(STATUS "XWAYLAND Enabled (NO_XWAYLAND not defined) checking deps...")
     pkg_check_modules(xcbdep REQUIRED xcb)
     target_link_libraries(Hyprland xcb)
-ENDIF(NO_XWAYLAND MATCHES true)
+endif()
 
-IF(NO_SYSTEMD MATCHES true)
+if(NO_SYSTEMD)
     message(STATUS "SYSTEMD support is disabled...")
-ELSE()
+else()
     message(STATUS "SYSTEMD support is requested (NO_SYSTEMD not defined) checking deps...")
     pkg_check_modules(LIBSYSTEMD libsystemd)
-    IF(LIBSYSTEMD_FOUND)
-        add_definitions( -DUSES_SYSTEMD )
+    check_include_file("systemd/sd-daemon.h" SYSTEMDH)
+    if(LIBSYSTEMD_FOUND AND SYSTEMDH)
+        add_compile_definitions(USES_SYSTEMD)
         target_link_libraries(Hyprland "${LIBSYSTEMD_LIBRARIES}")
-    ELSE()
-        message(WARNING "Systemd support requested but libsystemd was not found")
-    ENDIF(LIBSYSTEMD_FOUND)
-ENDIF(NO_SYSTEMD MATCHES true)
+    else()
+        message(WARNING "Systemd support requested but libsystemd or systemd headers were not found")
+    endif()
+endif()
 
-target_compile_definitions(Hyprland PRIVATE "-DGIT_COMMIT_HASH=\"${GIT_COMMIT_HASH}\"")
-target_compile_definitions(Hyprland PRIVATE "-DGIT_BRANCH=\"${GIT_BRANCH}\"")
-target_compile_definitions(Hyprland PRIVATE "-DGIT_COMMIT_MESSAGE=\"${GIT_COMMIT_MESSAGE}\"")
-target_compile_definitions(Hyprland PRIVATE "-DGIT_DIRTY=\"${GIT_DIRTY}\"")
+target_compile_definitions(Hyprland
+    PRIVATE
+    "GIT_COMMIT_HASH=\"${GIT_COMMIT_HASH}\""
+    "GIT_BRANCH=\"${GIT_BRANCH}\""
+    "GIT_COMMIT_MESSAGE=\"${GIT_COMMIT_MESSAGE}\""
+    "GIT_DIRTY=\"${GIT_DIRTY}\"")
 
 target_link_libraries(Hyprland rt)
 
@@ -102,16 +132,6 @@ message(STATUS "Setting link libraries")
 
 target_link_libraries(Hyprland PkgConfig::deps)
 
-IF(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
-    message(STATUS "Setting debug flags")
-
-    target_link_libraries(Hyprland asan)
-
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pg -no-pie -fno-builtin -fsanitize=address")
-    SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pg -no-pie -fno-builtin")
-    SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pg -no-pie -fno-builtin")
-ENDIF(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
-
 target_link_libraries(Hyprland
         ${CMAKE_SOURCE_DIR}/subprojects/wlroots/build/libwlroots.so.12032 # wlroots is provided by us
         pixman-1
@@ -122,4 +142,8 @@ target_link_libraries(Hyprland
         ${CMAKE_SOURCE_DIR}/ext-workspace-unstable-v1-protocol.o
         ${CMAKE_SOURCE_DIR}/wlr-foreign-toplevel-management-unstable-v1-protocol.o
         ${CMAKE_SOURCE_DIR}/hyprland-toplevel-export-v1-protocol.o
+        ${CMAKE_SOURCE_DIR}/fractional-scale-v1-protocol.o
+        ${CMAKE_SOURCE_DIR}/text-input-unstable-v1-protocol.o
+        ${CMAKE_SOURCE_DIR}/wlr-screencopy-unstable-v1-protocol.o
+        ${CMAKE_SOURCE_DIR}/subprojects/udis86/build/libudis86/liblibudis86.a
 )

LICENSE

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2022, vaxerski
+Copyright (c) 2022-2023, vaxerski
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

Makefile

@@ -121,20 +121,40 @@ wlr-foreign-toplevel-management-unstable-v1-protocol.c:
 
 wlr-foreign-toplevel-management-unstable-v1-protocol.o: wlr-foreign-toplevel-management-unstable-v1-protocol.h
 
+fractional-scale-v1-protocol.h:
+	$(WAYLAND_SCANNER) server-header \
+		$(WAYLAND_PROTOCOLS)/staging/fractional-scale/fractional-scale-v1.xml $@
+
+fractional-scale-v1-protocol.c:
+	$(WAYLAND_SCANNER) private-code \
+		$(WAYLAND_PROTOCOLS)/staging/fractional-scale/fractional-scale-v1.xml $@
+
+fractional-scale-v1-protocol.o: fractional-scale-v1-protocol.h
+
+text-input-unstable-v1-protocol.h:
+	$(WAYLAND_SCANNER) server-header \
+		$(WAYLAND_PROTOCOLS)/unstable/text-input/text-input-unstable-v1.xml $@
+
+text-input-unstable-v1-protocol.c:
+	$(WAYLAND_SCANNER) private-code \
+		$(WAYLAND_PROTOCOLS)/unstable/text-input/text-input-unstable-v1.xml $@
+
+text-input-unstable-v1-protocol.o: text-input-unstable-v1-protocol.h
+
 legacyrenderer:
-	mkdir -p build && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DLEGACY_RENDERER:STRING=true -H./ -B./build -G Ninja
+	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DLEGACY_RENDERER:BOOL=true -S . -B ./build -G Ninja
 	cmake --build ./build --config Release --target all -j$(shell nproc)
 
 legacyrendererdebug:
-	mkdir -p build && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Debug -DLEGACY_RENDERER:STRING=true -H./ -B./build -G Ninja
+	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Debug -DLEGACY_RENDERER:BOOL=true -S . -B ./build -G Ninja
 	cmake --build ./build --config Release --target all -j$(shell nproc)
 
 release:
-	mkdir -p build && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -H./ -B./build -G Ninja
+	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -S . -B ./build -G Ninja
 	cmake --build ./build --config Release --target all -j$(shell nproc)
 
 debug:
-	mkdir -p build && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Debug -H./ -B./build -G Ninja
+	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Debug -S . -B ./build -G Ninja
 	cmake --build ./build --config Debug --target all -j$(shell nproc)
 
 clear:
@@ -146,24 +166,26 @@ clear:
 all:
 	make clear
 	make fixwlr
-	cd ./subprojects/wlroots && meson build/ --buildtype=release && ninja -C build/ && cp ./build/libwlroots.so.12032 /usr/lib/ && cd ../..
+	cd ./subprojects/wlroots && meson setup build/ --buildtype=release && ninja -C build/ && cp ./build/libwlroots.so.12032 ${PREFIX}/lib/ || echo "Could not install libwlroots to ${PREFIX}/lib/libwlroots.so.12032"
+	cd subprojects/udis86 && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -S . -B./build -G Ninja && cmake --build ./build --config Release --target all -j$(shell nproc)
 	make protocols
 	make release
-	cd hyprctl && make all && cd ..
+	make -C hyprctl all
 
 install:
 	make clear
 	make fixwlr
-	cd ./subprojects/wlroots && meson build/ --buildtype=release && ninja -C build/ && cp ./build/libwlroots.so.12032 /usr/lib/ && cd ../..
+	cd ./subprojects/wlroots && meson setup build/ --buildtype=release && ninja -C build/ && cp ./build/libwlroots.so.12032 ${PREFIX}/lib/ || echo "Could not install libwlroots to ${PREFIX}/lib/libwlroots.so.12032"
+	cd subprojects/udis86 && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -S . -B./build -G Ninja && cmake --build ./build --config Release --target all -j$(shell nproc) && cd ../..
 	make protocols
 	make release
-	cd hyprctl && make all && cd ..
+	make -C hyprctl all
 
-	mkdir -p /usr/share/wayland-sessions
+	mkdir -p ${PREFIX}/share/wayland-sessions
 	mkdir -p ${PREFIX}/bin
 	cp ./build/Hyprland ${PREFIX}/bin
 	cp ./hyprctl/hyprctl ${PREFIX}/bin
-	if [ ! -f /usr/share/wayland-sessions/hyprland.desktop ]; then cp ./example/hyprland.desktop /usr/share/wayland-sessions; fi
+	if [ ! -f ${PREFIX}/share/wayland-sessions/hyprland.desktop ]; then cp ./example/hyprland.desktop ${PREFIX}/share/wayland-sessions; fi
 	mkdir -p ${PREFIX}/share/hyprland
 	cp ./assets/wall_2K.png ${PREFIX}/share/hyprland
 	cp ./assets/wall_4K.png ${PREFIX}/share/hyprland
@@ -179,12 +201,12 @@ uninstall:
 	rm -f ${PREFIX}/share/wayland-sessions/hyprland.desktop
 	rm -f ${PREFIX}/bin/Hyprland
 	rm -f ${PREFIX}/bin/hyprctl
-	rm -f /usr/lib/libwlroots.so.12032
+	rm -f ${PREFIX}/lib/libwlroots.so.12032
 	rm -rf ${PREFIX}/share/hyprland
 	rm -f ${PREFIX}/share/man/man1/Hyprland.1
 	rm -f ${PREFIX}/share/man/man1/hyprctl.1
 
-protocols: xdg-shell-protocol.o wlr-layer-shell-unstable-v1-protocol.o wlr-screencopy-unstable-v1-protocol.o idle-protocol.o ext-workspace-unstable-v1-protocol.o pointer-constraints-unstable-v1-protocol.o tablet-unstable-v2-protocol.o wlr-output-power-management-unstable-v1-protocol.o linux-dmabuf-unstable-v1-protocol.o hyprland-toplevel-export-v1-protocol.o wlr-foreign-toplevel-management-unstable-v1-protocol.o
+protocols: xdg-shell-protocol.o wlr-layer-shell-unstable-v1-protocol.o wlr-screencopy-unstable-v1-protocol.o idle-protocol.o ext-workspace-unstable-v1-protocol.o pointer-constraints-unstable-v1-protocol.o tablet-unstable-v2-protocol.o wlr-output-power-management-unstable-v1-protocol.o linux-dmabuf-unstable-v1-protocol.o hyprland-toplevel-export-v1-protocol.o wlr-foreign-toplevel-management-unstable-v1-protocol.o fractional-scale-v1-protocol.o text-input-unstable-v1-protocol.o
 
 fixwlr:
 	sed -i -E 's/(soversion = 12)([^032]|$$)/soversion = 12032/g' subprojects/wlroots/meson.build
@@ -196,20 +218,32 @@ config:
 
 	make fixwlr
 
-	cd subprojects/wlroots && meson ./build --prefix=/usr --buildtype=release -Dwerror=false -Dexamples=false
-	cd subprojects/wlroots && ninja -C build/
+	meson setup subprojects/wlroots/build subprojects/wlroots --prefix=${PREFIX} --buildtype=release -Dwerror=false -Dexamples=false
+	ninja -C subprojects/wlroots/build/
 
-	cd subprojects/wlroots && ninja -C build/ install
+	ninja -C subprojects/wlroots/build/ install
+
+	cd subprojects/udis86 && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -S . -B ./build -G Ninja && cmake --build ./build --config Release --target all -j$(shell nproc)
+
+pluginenv:
+	make protocols
+
+	cd subprojects/udis86 && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -S . -B ./build -G Ninja && cmake --build ./build --config Release --target all -j$(shell nproc)
+
+	make fixwlr
+
+	meson setup subprojects/wlroots/build subprojects/wlroots --prefix=${PREFIX} --buildtype=release -Dwerror=false -Dexamples=false
+	ninja -C subprojects/wlroots/build/
 
 configdebug:
 	make protocols
 
 	make fixwlr
 
-	cd subprojects/wlroots && meson ./build --prefix=/usr --buildtype=debug -Dwerror=false -Dexamples=false -Db_sanitize=address
-	cd subprojects/wlroots && ninja -C build/
+	meson setup subprojects/wlroots/build subprojects/wlroots --prefix=${PREFIX} --buildtype=debug -Dwerror=false -Dexamples=false -Db_sanitize=address
+	ninja -C subprojects/wlroots/build/
 
-	cd subprojects/wlroots && ninja -C build/ install
+	ninja -C subprojects/wlroots/build/ install
 
 man:
 	pandoc ./docs/Hyprland.1.rst \

README.md

@@ -16,7 +16,7 @@
 
 Hyprland is a dynamic tiling Wayland compositor based on wlroots that doesn't sacrifice on its looks.
 
-It supports multiple layouts, fancy effects, has a very flexible IPC model allowing for a lot of customization, and more.
+It supports multiple layouts, fancy effects, has a very flexible IPC model allowing for a lot of customization, a powerful plugin system and more.
 <br>
 <br>
 
@@ -42,6 +42,7 @@ Although Hyprland is pretty stable, it may have some bugs.
 # Features
 
 - Easily expandable and readable codebase
+- Plugin support
 - Config reloaded instantly upon saving
 - Custom bezier curve based animations
 - Dual Kawase blur
@@ -130,7 +131,7 @@ Although Hyprland is pretty stable, it may have some bugs.
 
 [Contribute]: https://wiki.hyprland.org/Contributing-and-Debugging/
 [Install]: https://wiki.hyprland.org/Getting-Started/Installation/
-[Quick Start]: https://wiki.hyprland.org/Getting-Started/Quick-start/
+[Quick Start]: https://wiki.hyprland.org/Getting-Started/Master-Tutorial/
 [License]: LICENSE
 
 

docs/Hyprland.1

@@ -1,6 +1,6 @@
 .\" Automatically generated by Pandoc 2.9.2.1
 .\"
-.TH "Hyprland" "1" "26 Dec 2022" "" "Hyprland User Manual"
+.TH "Hyprland" "1" "03 Apr 2023" "" "Hyprland User Manual"
 .hy
 .SH NAME
 .PP

docs/ISSUE_GUIDELINES.md

@@ -3,14 +3,14 @@
 First of all, please remember to:
 - Check that your issue is not a duplicate
 - Read the [FAQ](https://github.com/vaxerski/Hyprland/wiki/FAQ)
-- Read the [Configuring Page](https://github.com/vaxerski/Hyprland/wiki/Configuring-Hyprland)
+- Read the [Configuring Page](https://wiki.hyprland.org/Configuring/Configuring-Hyprland)
 
 <br/>
 
 # Reporting suggestions
 Suggestions are welcome.
 
-Many features can be implemented using bash scripts and Hyprland sockets, read up on those [Here](https://github.com/vaxerski/Hyprland/wiki/IPC). Please do not suggest features that can be implemented as such.
+Many features can be implemented using bash scripts and Hyprland sockets, read up on those [Here](https://wiki.hyprland.org/IPC). Please do not suggest features that can be implemented as such.
 
 <br/>
 
@@ -25,8 +25,9 @@ If your bug is one that doesn't crash Hyprland, but feels like invalid behavior,
 
 If your bug crashes Hyprland, append additionally:
 - The Hyprland log
-- Coredump / Coredump analysis (with a stacktrace)
 - Your config
+- (v0.22.0beta and up) The Hyprland Crash Report
+- (v0.21.0beta and below) Coredump / Coredump analysis (with a stacktrace)
 
 **Important**: Please do NOT use any package for reporting bugs! Clone and compile from source.
 
@@ -44,7 +45,14 @@ cat /tmp/hypr/$(ls -t /tmp/hypr/ | head -n 2 | tail -n 1)/hyprland.log
 
 basically, directories in /tmp/hypr are your sessions.
 
-## Obtaining the Hyprland coredump
+## Obtaining the Hyprland Crash Report (v0.22.0beta and up)
+
+If you have `$XDG_CACHE_HOME` set, the crash report directory is `$XDG_CACHE_HOME/hyprland`. If not, it's `~/.hyprland`
+
+Go to the crash report directory and you should find a file named `hyprlandCrashReport[XXXX].txt` where `[XXXX]` is the PID of the process that crashed.
+
+Attach that file to your issue.
+## Obtaining the Hyprland coredump (v0.21.0beta and below)
 If you are on systemd, you can simply use
 ```
 coredumpctl
@@ -66,9 +74,7 @@ Make sure you're on latest git. Run `git pull --recurse-submodules` to sync ever
 > Note: The config file used will be `hyprlandd.conf` instead of `hyprland.conf`
 
 2. `cd ~`
-3. For your own convenience, launch Hyprland from a tty with the envvar `ASAN_OPTIONS="log_path=asan.log"`:
- - If using a wrapper, add `export ASAN_OPTIONS="log_path=asan.log"` in a separate line before the `exec Hyprland` line.
- - If launching straight from the tty, execute `ASAN_OPTIONS="log_path=asan.log" ~/path/to/Hyprland`
+3. For your own convenience, launch Hyprland from a tty with the envvar `ASAN_OPTIONS="log_path=asan.log" ~/path/to/Hyprland`
 4. Reproduce the crash. Hyprland should instantly close.
 5. Check out your `~` and find a file called `asan.log.XXXXX` where `XXXXX` will be a number corresponding to the PID of the Hyprland instance that crashed.
 6. That is your coredump. Attach it to your issue.

docs/hyprctl.1

@@ -1,6 +1,6 @@
 .\" Automatically generated by Pandoc 2.9.2.1
 .\"
-.TH "hyprctl" "1" "26 Dec 2022" "" "hyprctl User Manual"
+.TH "hyprctl" "1" "03 Apr 2023" "" "hyprctl User Manual"
 .hy
 .SH NAME
 .PP

example/examplePlugin/Makefile

@@ -0,0 +1,8 @@
+# compile with HYPRLAND_HEADERS=<path_to_hl> make all
+# make sure that the path above is to the root hl repo directory, NOT src/
+# and that you have ran `make protocols` in the hl dir.
+
+all:
+	g++ -shared -fPIC --no-gnu-unique main.cpp customLayout.cpp customDecoration.cpp -o examplePlugin.so -g -I "/usr/include/pixman-1" -I "/usr/include/libdrm" -I "${HYPRLAND_HEADERS}" -I "${HYPRLAND_HEADERS}/subprojects/wlroots/include" -I "${HYPRLAND_HEADERS}/subprojects/wlroots/include" -I "${HYPRLAND_HEADERS}/subprojects/wlroots/build/include" -std=c++23
+clean:
+	rm ./examplePlugin.so

example/examplePlugin/customDecoration.cpp

@@ -0,0 +1,74 @@
+#include "customDecoration.hpp"
+#include "../../src/Window.hpp"
+#include "../../src/Compositor.hpp"
+#include "globals.hpp"
+
+CCustomDecoration::CCustomDecoration(CWindow* pWindow) {
+    m_pWindow         = pWindow;
+    m_vLastWindowPos  = pWindow->m_vRealPosition.vec();
+    m_vLastWindowSize = pWindow->m_vRealSize.vec();
+}
+
+CCustomDecoration::~CCustomDecoration() {
+    damageEntire();
+}
+
+SWindowDecorationExtents CCustomDecoration::getWindowDecorationExtents() {
+    return m_seExtents;
+}
+
+void CCustomDecoration::draw(CMonitor* pMonitor, float a, const Vector2D& offset) {
+    if (!g_pCompositor->windowValidMapped(m_pWindow))
+        return;
+
+    if (!m_pWindow->m_sSpecialRenderData.decorate)
+        return;
+
+    static auto* const PCOLOR      = &HyprlandAPI::getConfigValue(PHANDLE, "plugin:example:border_color")->intValue;
+    static auto* const PROUNDING   = &HyprlandAPI::getConfigValue(PHANDLE, "decoration:rounding")->intValue;
+    static auto* const PBORDERSIZE = &HyprlandAPI::getConfigValue(PHANDLE, "general:border_size")->intValue;
+
+    const auto         ROUNDING = !m_pWindow->m_sSpecialRenderData.rounding ?
+                0 :
+                (m_pWindow->m_sAdditionalConfigData.rounding.toUnderlying() == -1 ? *PROUNDING : m_pWindow->m_sAdditionalConfigData.rounding.toUnderlying());
+
+    // draw the border
+    wlr_box fullBox = {(int)(m_vLastWindowPos.x - *PBORDERSIZE), (int)(m_vLastWindowPos.y - *PBORDERSIZE), (int)(m_vLastWindowSize.x + 2.0 * *PBORDERSIZE),
+                       (int)(m_vLastWindowSize.y + 2.0 * *PBORDERSIZE)};
+
+    fullBox.x -= pMonitor->vecPosition.x;
+    fullBox.y -= pMonitor->vecPosition.y;
+
+    m_seExtents = {{m_vLastWindowPos.x - fullBox.x - pMonitor->vecPosition.x + 2, m_vLastWindowPos.y - fullBox.y - pMonitor->vecPosition.y + 2},
+                   {fullBox.x + fullBox.width + pMonitor->vecPosition.x - m_vLastWindowPos.x - m_vLastWindowSize.x + 2,
+                    fullBox.y + fullBox.height + pMonitor->vecPosition.y - m_vLastWindowPos.y - m_vLastWindowSize.y + 2}};
+
+    fullBox.x += offset.x;
+    fullBox.y += offset.y;
+
+    if (fullBox.width < 1 || fullBox.height < 1)
+        return; // don't draw invisible shadows
+
+    g_pHyprOpenGL->scissor((wlr_box*)nullptr);
+
+    scaleBox(&fullBox, pMonitor->scale);
+    g_pHyprOpenGL->renderBorder(&fullBox, CColor(*PCOLOR), *PROUNDING * pMonitor->scale + *PBORDERSIZE * 2, a);
+}
+
+eDecorationType CCustomDecoration::getDecorationType() {
+    return DECORATION_CUSTOM;
+}
+
+void CCustomDecoration::updateWindow(CWindow* pWindow) {
+
+    m_vLastWindowPos  = pWindow->m_vRealPosition.vec();
+    m_vLastWindowSize = pWindow->m_vRealSize.vec();
+
+    damageEntire();
+}
+
+void CCustomDecoration::damageEntire() {
+    wlr_box dm = {(int)(m_vLastWindowPos.x - m_seExtents.topLeft.x), (int)(m_vLastWindowPos.y - m_seExtents.topLeft.y),
+                  (int)(m_vLastWindowSize.x + m_seExtents.topLeft.x + m_seExtents.bottomRight.x), (int)m_seExtents.topLeft.y};
+    g_pHyprRenderer->damageBox(&dm);
+}

example/examplePlugin/customDecoration.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#define WLR_USE_UNSTABLE
+
+#include "../../src/render/decorations/IHyprWindowDecoration.hpp"
+
+class CCustomDecoration : public IHyprWindowDecoration {
+  public:
+    CCustomDecoration(CWindow*);
+    virtual ~CCustomDecoration();
+
+    virtual SWindowDecorationExtents getWindowDecorationExtents();
+
+    virtual void                     draw(CMonitor*, float a, const Vector2D& offset);
+
+    virtual eDecorationType          getDecorationType();
+
+    virtual void                     updateWindow(CWindow*);
+
+    virtual void                     damageEntire();
+
+  private:
+    SWindowDecorationExtents m_seExtents;
+
+    CWindow*                 m_pWindow = nullptr;
+
+    Vector2D                 m_vLastWindowPos;
+    Vector2D                 m_vLastWindowSize;
+};

example/examplePlugin/customLayout.cpp

@@ -0,0 +1,80 @@
+#include "customLayout.hpp"
+#include "../../src/Compositor.hpp"
+#include "globals.hpp"
+
+void CHyprCustomLayout::onWindowCreatedTiling(CWindow* pWindow) {
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto SIZE     = PMONITOR->vecSize;
+
+    // these are used for focus and move calculations, and are *required* to touch for moving focus to work properly.
+    pWindow->m_vPosition = Vector2D{(SIZE.x / 2.0) * (m_vWindowData.size() % 2), (SIZE.y / 2.0) * (int)(m_vWindowData.size() > 1)};
+    pWindow->m_vSize     = SIZE / 2.0;
+
+    // this is the actual pos and size of the window (where it's rendered)
+    pWindow->m_vRealPosition = pWindow->m_vPosition + Vector2D{10, 10};
+    pWindow->m_vRealSize     = pWindow->m_vSize - Vector2D{20, 20};
+
+    const auto PDATA = &m_vWindowData.emplace_back();
+    PDATA->pWindow   = pWindow;
+}
+
+void CHyprCustomLayout::onWindowRemovedTiling(CWindow* pWindow) {
+    std::erase_if(m_vWindowData, [&](const auto& other) { return other.pWindow == pWindow; });
+}
+
+bool CHyprCustomLayout::isWindowTiled(CWindow* pWindow) {
+    return std::find_if(m_vWindowData.begin(), m_vWindowData.end(), [&](const auto& other) { return other.pWindow == pWindow; }) != m_vWindowData.end();
+}
+
+void CHyprCustomLayout::recalculateMonitor(const int& eIdleInhibitMode) {
+    ; // empty
+}
+
+void CHyprCustomLayout::recalculateWindow(CWindow* pWindow) {
+    ; // empty
+}
+
+void CHyprCustomLayout::resizeActiveWindow(const Vector2D& delta, CWindow* pWindow) {
+    ; // empty
+}
+
+void CHyprCustomLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscreenMode mode, bool on) {
+    ; // empty
+}
+
+std::any CHyprCustomLayout::layoutMessage(SLayoutMessageHeader header, std::string content) {
+    return "";
+}
+
+SWindowRenderLayoutHints CHyprCustomLayout::requestRenderHints(CWindow* pWindow) {
+    return {};
+}
+
+void CHyprCustomLayout::switchWindows(CWindow* pWindowA, CWindow* pWindowB) {
+    ; // empty
+}
+
+void CHyprCustomLayout::alterSplitRatio(CWindow* pWindow, float delta, bool exact) {
+    ; // empty
+}
+
+std::string CHyprCustomLayout::getLayoutName() {
+    return "custom";
+}
+
+void CHyprCustomLayout::replaceWindowDataWith(CWindow* from, CWindow* to) {
+    ; // empty
+}
+
+void CHyprCustomLayout::onEnable() {
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (w->isHidden() || !w->m_bIsMapped || w->m_bFadingOut || w->m_bIsFloating)
+            continue;
+
+        onWindowCreatedTiling(w.get());
+    }
+}
+
+void CHyprCustomLayout::onDisable() {
+    m_vWindowData.clear();
+}

example/examplePlugin/customLayout.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#define WLR_USE_UNSTABLE
+
+#include "../../src/layout/IHyprLayout.hpp"
+
+struct SWindowData {
+    CWindow* pWindow = nullptr;
+};
+
+class CHyprCustomLayout : public IHyprLayout {
+  public:
+    virtual void                     onWindowCreatedTiling(CWindow*);
+    virtual void                     onWindowRemovedTiling(CWindow*);
+    virtual bool                     isWindowTiled(CWindow*);
+    virtual void                     recalculateMonitor(const int&);
+    virtual void                     recalculateWindow(CWindow*);
+    virtual void                     resizeActiveWindow(const Vector2D&, CWindow* pWindow = nullptr);
+    virtual void                     fullscreenRequestForWindow(CWindow*, eFullscreenMode, bool);
+    virtual std::any                 layoutMessage(SLayoutMessageHeader, std::string);
+    virtual SWindowRenderLayoutHints requestRenderHints(CWindow*);
+    virtual void                     switchWindows(CWindow*, CWindow*);
+    virtual void                     alterSplitRatio(CWindow*, float, bool);
+    virtual std::string              getLayoutName();
+    virtual void                     replaceWindowDataWith(CWindow* from, CWindow* to);
+
+    virtual void                     onEnable();
+    virtual void                     onDisable();
+
+  private:
+    std::vector<SWindowData> m_vWindowData;
+};

example/examplePlugin/globals.hpp

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <src/plugins/PluginAPI.hpp>
+
+inline HANDLE PHANDLE = nullptr;

example/examplePlugin/main.cpp

@@ -0,0 +1,95 @@
+#define WLR_USE_UNSTABLE
+
+#include "globals.hpp"
+
+#include <src/Window.hpp>
+#include <src/Compositor.hpp>
+#include "customLayout.hpp"
+#include "customDecoration.hpp"
+
+#include <unistd.h>
+#include <thread>
+
+// Methods
+inline std::unique_ptr<CHyprCustomLayout> g_pCustomLayout;
+inline CFunctionHook*                     g_pFocusHook     = nullptr;
+inline CFunctionHook*                     g_pMotionHook    = nullptr;
+inline CFunctionHook*                     g_pMouseDownHook = nullptr;
+typedef void (*origFocusWindow)(void*, CWindow*, wlr_surface*);
+typedef void (*origMotion)(wlr_seat*, uint32_t, double, double);
+typedef void (*origMouseDownNormal)(void*, wlr_pointer_button_event*);
+
+// Do NOT change this function.
+APICALL EXPORT std::string PLUGIN_API_VERSION() {
+    return HYPRLAND_API_VERSION;
+}
+
+static void onActiveWindowChange(void* self, std::any data) {
+    try {
+        auto* const PWINDOW = std::any_cast<CWindow*>(data);
+
+        HyprlandAPI::addNotification(PHANDLE, "[ExamplePlugin] Active window: " + (PWINDOW ? PWINDOW->m_szTitle : "None"), CColor{0.f, 0.5f, 1.f, 1.f}, 5000);
+    } catch (std::bad_any_cast& e) { HyprlandAPI::addNotification(PHANDLE, "[ExamplePlugin] Active window: None", CColor{0.f, 0.5f, 1.f, 1.f}, 5000); }
+}
+
+static void onNewWindow(void* self, std::any data) {
+    auto* const PWINDOW = std::any_cast<CWindow*>(data);
+
+    HyprlandAPI::addWindowDecoration(PHANDLE, PWINDOW, new CCustomDecoration(PWINDOW));
+}
+
+void hkFocusWindow(void* thisptr, CWindow* pWindow, wlr_surface* pSurface) {
+    // HyprlandAPI::addNotification(PHANDLE, getFormat("FocusWindow with %lx %lx", pWindow, pSurface), CColor{0.f, 1.f, 1.f, 1.f}, 5000);
+    (*(origFocusWindow)g_pFocusHook->m_pOriginal)(thisptr, pWindow, pSurface);
+}
+
+void hkNotifyMotion(wlr_seat* wlr_seat, uint32_t time_msec, double sx, double sy) {
+    // HyprlandAPI::addNotification(PHANDLE, getFormat("NotifyMotion with %lf %lf", sx, sy), CColor{0.f, 1.f, 1.f, 1.f}, 5000);
+    (*(origMotion)g_pMotionHook->m_pOriginal)(wlr_seat, time_msec, sx, sy);
+}
+
+void hkProcessMouseDownNormal(void* thisptr, wlr_pointer_button_event* e) {
+    // HyprlandAPI::addNotification(PHANDLE, "Mouse down normal!", CColor{0.8f, 0.2f, 0.5f, 1.0f}, 5000);
+    (*(origMouseDownNormal)g_pMouseDownHook->m_pOriginal)(thisptr, e);
+}
+
+APICALL EXPORT PLUGIN_DESCRIPTION_INFO PLUGIN_INIT(HANDLE handle) {
+    PHANDLE = handle;
+
+    HyprlandAPI::addNotification(PHANDLE, "Hello World from an example plugin!", CColor{0.f, 1.f, 1.f, 1.f}, 5000);
+
+    HyprlandAPI::registerCallbackDynamic(PHANDLE, "activeWindow", [&](void* self, std::any data) { onActiveWindowChange(self, data); });
+    HyprlandAPI::registerCallbackDynamic(PHANDLE, "openWindow", [&](void* self, std::any data) { onNewWindow(self, data); });
+
+    g_pCustomLayout = std::make_unique<CHyprCustomLayout>();
+
+    HyprlandAPI::addLayout(PHANDLE, "custom", g_pCustomLayout.get());
+
+    HyprlandAPI::addConfigValue(PHANDLE, "plugin:example:border_color", SConfigValue{.intValue = configStringToInt("rgb(44ee44)")});
+
+    HyprlandAPI::addDispatcher(PHANDLE, "example", [](std::string arg) { HyprlandAPI::addNotification(PHANDLE, "Arg passed: " + arg, CColor{0.5f, 0.5f, 0.7f, 1.0f}, 5000); });
+
+    // Hook a public member
+    g_pFocusHook = HyprlandAPI::createFunctionHook(PHANDLE, (void*)&CCompositor::focusWindow, (void*)&hkFocusWindow);
+    // Hook a public non-member
+    g_pMotionHook = HyprlandAPI::createFunctionHook(PHANDLE, (void*)&wlr_seat_pointer_notify_motion, (void*)&hkNotifyMotion);
+    // Hook a private member
+    static const auto METHODS = HyprlandAPI::findFunctionsByName(PHANDLE, "processMouseDownNormal");
+    g_pMouseDownHook          = HyprlandAPI::createFunctionHook(PHANDLE, METHODS[0].address, (void*)&hkProcessMouseDownNormal);
+
+    // fancy notifications
+    HyprlandAPI::addNotificationV2(PHANDLE, {{"text", "Example hint"}, {"time", (uint64_t)10000}, {"color", CColor(0.2, 0.2, 0.9, 1.0)}, {"icon", ICON_HINT}});
+
+    // Enable our hooks
+    g_pFocusHook->hook();
+    g_pMotionHook->hook();
+    g_pMouseDownHook->hook();
+
+    HyprlandAPI::reloadConfig();
+
+    return {"ExamplePlugin", "An example plugin", "Vaxry", "1.0"};
+}
+
+APICALL EXPORT void PLUGIN_EXIT() {
+    HyprlandAPI::invokeHyprctlCommand("seterror", "disable");
+}

example/hyprland.conf

@@ -19,6 +19,9 @@ monitor=,preferred,auto,auto
 # Source a file (multi-file configs)
 # source = ~/.config/hypr/myColors.conf
 
+# Some default env vars.
+env = XCURSOR_SIZE,24
+
 # For all categories, see https://wiki.hyprland.org/Configuring/Variables/
 input {
     kb_layout = us
@@ -30,7 +33,7 @@ input {
     follow_mouse = 1
 
     touchpad {
-        natural_scroll = no
+        natural_scroll = false
     }
 
     sensitivity = 0 # -1.0 - 1.0, 0 means no modification.
@@ -52,19 +55,19 @@ decoration {
     # See https://wiki.hyprland.org/Configuring/Variables/ for more
 
     rounding = 10
-    blur = yes
+    blur = true
     blur_size = 3
     blur_passes = 1
-    blur_new_optimizations = on
+    blur_new_optimizations = true
 
-    drop_shadow = yes
+    drop_shadow = true
     shadow_range = 4
     shadow_render_power = 3
     col.shadow = rgba(1a1a1aee)
 }
 
 animations {
-    enabled = yes
+    enabled = true
 
     # Some default animations, see https://wiki.hyprland.org/Configuring/Animations/ for more
 
@@ -73,14 +76,15 @@ animations {
     animation = windows, 1, 7, myBezier
     animation = windowsOut, 1, 7, default, popin 80%
     animation = border, 1, 10, default
+    animation = borderangle, 1, 8, default
     animation = fade, 1, 7, default
     animation = workspaces, 1, 6, default
 }
 
 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
 }
 
 master {
@@ -90,12 +94,12 @@ master {
 
 gestures {
     # See https://wiki.hyprland.org/Configuring/Variables/ for more
-    workspace_swipe = off
+    workspace_swipe = false
 }
 
 # Example per-device config
 # See https://wiki.hyprland.org/Configuring/Keywords/#executing for more
-device:epic mouse V1 {
+device:epic-mouse-v1 {
     sensitivity = -0.5
 }
 
@@ -111,10 +115,10 @@ $mainMod = SUPER
 
 # Example binds, see https://wiki.hyprland.org/Configuring/Binds/ for more
 bind = $mainMod, Q, exec, kitty
-bind = $mainMod, C, killactive, 
-bind = $mainMod, M, exit, 
+bind = $mainMod, C, killactive,
+bind = $mainMod, M, exit,
 bind = $mainMod, E, exec, dolphin
-bind = $mainMod, V, togglefloating, 
+bind = $mainMod, V, togglefloating,
 bind = $mainMod, R, exec, wofi --show drun
 bind = $mainMod, P, pseudo, # dwindle
 bind = $mainMod, J, togglesplit, # dwindle

flake.lock

@@ -1,29 +1,17 @@
 {
   "nodes": {
     "hyprland-protocols": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1670703428,
-        "narHash": "sha256-4KUW5SKR0Y9uaYGcYwy53YJ3B/sgiprCL4fRGO+mpOA=",
-        "owner": "hyprwm",
-        "repo": "hyprland-protocols",
-        "rev": "d0d6db8cb5bef6d93ca3ad8fb2124964173396da",
-        "type": "github"
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
       },
-      "original": {
-        "owner": "hyprwm",
-        "repo": "hyprland-protocols",
-        "type": "github"
-      }
-    },
-    "hyprland-protocols_2": {
-      "flake": false,
       "locked": {
-        "lastModified": 1670703428,
-        "narHash": "sha256-4KUW5SKR0Y9uaYGcYwy53YJ3B/sgiprCL4fRGO+mpOA=",
+        "lastModified": 1671839510,
+        "narHash": "sha256-+PY1qqJfmZzzROgcIY4I7AkCwpnC+qBIYk2eFoA9RWc=",
         "owner": "hyprwm",
         "repo": "hyprland-protocols",
-        "rev": "d0d6db8cb5bef6d93ca3ad8fb2124964173396da",
+        "rev": "b8f55e02a328c47ed373133c52483bbfa20a1b75",
         "type": "github"
       },
       "original": {
@@ -34,11 +22,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1672791794,
-        "narHash": "sha256-mqGPpGmwap0Wfsf3o2b6qHJW1w2kk/I6cGCGIU+3t6o=",
+        "lastModified": 1680669251,
+        "narHash": "sha256-AVNE+0u4HlI3v96KCXE9risH7NKqj0QDLLfSckYXIbA=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "9813adc7f7c0edd738c6bdd8431439688bb0cb3d",
+        "rev": "9c8ff8b426a8b07b9e0a131ac3218740dc85ba1e",
         "type": "github"
       },
       "original": {
@@ -60,11 +48,11 @@
       "flake": false,
       "locked": {
         "host": "gitlab.freedesktop.org",
-        "lastModified": 1671183014,
-        "narHash": "sha256-oMWT5Zbe/3HFINAk38jNVxiZ4PCYvPJj2Jo4iiyBtm0=",
+        "lastModified": 1680810405,
+        "narHash": "sha256-LmI/4Yp/pOOoI4RxLRx9I90NBsiqdRLVOfbATKlgpkg=",
         "owner": "wlroots",
         "repo": "wlroots",
-        "rev": "dc7cc98cf21a8dc19ab8895505500e3700646af0",
+        "rev": "7abda952d0000b72d240fe1d41457b9288f0b6e5",
         "type": "gitlab"
       },
       "original": {
@@ -76,17 +64,19 @@
     },
     "xdph": {
       "inputs": {
-        "hyprland-protocols": "hyprland-protocols_2",
+        "hyprland-protocols": [
+          "hyprland-protocols"
+        ],
         "nixpkgs": [
           "nixpkgs"
         ]
       },
       "locked": {
-        "lastModified": 1671837878,
-        "narHash": "sha256-OmFDyktTc/l+3wHboHeFpAQgPt3r7jjqZf8MrwuUGMo=",
+        "lastModified": 1673116118,
+        "narHash": "sha256-eR0yDSkR2XYMesfdRWJs25kAdXET2mbNNHu5t+KUcKA=",
         "owner": "hyprwm",
         "repo": "xdg-desktop-portal-hyprland",
-        "rev": "e47f4cec698080768821b271510985ab94a37e91",
+        "rev": "d479c846531fd0e1d2357c9588b8310a2b859ef2",
         "type": "github"
       },
       "original": {

flake.nix

@@ -8,14 +8,15 @@
       flake = false;
     };
 
-    xdph = {
-      url = "github:hyprwm/xdg-desktop-portal-hyprland";
+    hyprland-protocols = {
+      url = "github:hyprwm/hyprland-protocols";
       inputs.nixpkgs.follows = "nixpkgs";
     };
 
-    hyprland-protocols = {
-      url = "github:hyprwm/hyprland-protocols";
-      flake = false;
+    xdph = {
+      url = "github:hyprwm/xdg-desktop-portal-hyprland";
+      inputs.nixpkgs.follows = "nixpkgs";
+      inputs.hyprland-protocols.follows = "hyprland-protocols";
     };
   };
 
@@ -33,6 +34,8 @@
 
     pkgsFor = nixpkgs.legacyPackages;
 
+    props = builtins.fromJSON (builtins.readFile ./props.json);
+
     mkDate = longDate: (lib.concatStringsSep "-" [
       (builtins.substring 0 4 longDate)
       (builtins.substring 4 2 longDate)
@@ -43,25 +46,64 @@
       wlroots-hyprland = prev.callPackage ./nix/wlroots.nix {
         version = mkDate (inputs.wlroots.lastModifiedDate or "19700101") + "_" + (inputs.wlroots.shortRev or "dirty");
         src = inputs.wlroots;
+        libdisplay-info = prev.libdisplay-info.overrideAttrs (old: {
+          version = "0.1.1+date=2023-03-02";
+          src = prev.fetchFromGitLab {
+            domain = "gitlab.freedesktop.org";
+            owner = "emersion";
+            repo = old.pname;
+            rev = "147d6611a64a6ab04611b923e30efacaca6fc678";
+            sha256 = "sha256-/q79o13Zvu7x02SBGu0W5yQznQ+p7ltZ9L6cMW5t/o4=";
+          };
+        });
+
+        libliftoff = prev.libliftoff.overrideAttrs (old: {
+          version = "0.5.0-dev";
+          src = prev.fetchFromGitLab {
+            domain = "gitlab.freedesktop.org";
+            owner = "emersion";
+            repo = old.pname;
+            rev = "d98ae243280074b0ba44bff92215ae8d785658c0";
+            sha256 = "sha256-DjwlS8rXE7srs7A8+tHqXyUsFGtucYSeq6X0T/pVOc8=";
+          };
+
+          NIX_CFLAGS_COMPILE = toString [
+            "-Wno-error=sign-conversion"
+          ];
+        });
       };
       hyprland = prev.callPackage ./nix/default.nix {
         stdenv = prev.gcc12Stdenv;
-        version = "0.19.2beta" + "+date=" + (mkDate (self.lastModifiedDate or "19700101")) + "_" + (self.shortRev or "dirty");
+        version = props.version + "+date=" + (mkDate (self.lastModifiedDate or "19700101")) + "_" + (self.shortRev or "dirty");
         wlroots = wlroots-hyprland;
-        inherit (inputs) hyprland-protocols;
+        commit = self.rev or "";
+        inherit (inputs.hyprland-protocols.packages.${prev.stdenv.hostPlatform.system}) hyprland-protocols;
+        inherit udis86;
       };
       hyprland-debug = hyprland.override {debug = true;};
-      hyprland-no-hidpi = hyprland.override {hidpiXWayland = false;};
+      hyprland-hidpi = hyprland.override {hidpiXWayland = true;};
+      hyprland-nvidia = hyprland.override {nvidiaPatches = true;};
+      hyprland-no-hidpi = builtins.trace "hyprland-no-hidpi was removed. Please use the default package." hyprland;
+
+      udis86 = prev.callPackage ./nix/udis86.nix {};
 
       waybar-hyprland = prev.waybar.overrideAttrs (oldAttrs: {
+        postPatch = ''
+          # use hyprctl to switch workspaces
+          sed -i 's/zext_workspace_handle_v1_activate(workspace_handle_);/const std::string command = "hyprctl dispatch workspace " + name_;\n\tsystem(command.c_str());/g' src/modules/wlr/workspace_manager.cpp
+        '';
         mesonFlags = oldAttrs.mesonFlags ++ ["-Dexperimental=true"];
       });
 
-      xdg-desktop-portal-hyprland = inputs.xdph.packages.${prev.hostPlatform.system}.default.override {
-        hyprland-share-picker = inputs.xdph.packages.${prev.hostPlatform.system}.hyprland-share-picker.override {inherit hyprland;};
+      xdg-desktop-portal-hyprland = inputs.xdph.packages.${prev.stdenv.hostPlatform.system}.default.override {
+        hyprland-share-picker = inputs.xdph.packages.${prev.stdenv.hostPlatform.system}.hyprland-share-picker.override {inherit hyprland;};
       };
     };
 
+    checks = genSystems (system:
+      (lib.filterAttrs (n: _: (lib.hasPrefix "hyprland" n) && !(lib.hasSuffix "debug" n)) self.packages.${system})
+      // {inherit (self.packages.${system}) xdg-desktop-portal-hyprland;});
+
     packages = genSystems (system:
       (self.overlays.default null pkgsFor.${system})
       // {

hyprctl/main.cpp

@@ -27,6 +27,7 @@ commands:
     activewindow
     layers
     devices
+    binds
     dispatch
     keyword
     version
@@ -38,6 +39,10 @@ commands:
     getoption
     cursorpos
     switchxkblayout
+    seterror
+    setprop
+    plugin
+    notify
 
 flags:
     -j -> output in JSON
@@ -167,7 +172,7 @@ void requestHyprpaper(std::string arg) {
 
 int dispatchRequest(int argc, char** argv) {
 
-    if (argc < 4) {
+    if (argc < 3) {
         std::cout << "Usage: hyprctl dispatch <dispatcher> <arg>\n\
             Execute a hyprland keybind dispatcher with the given argument";
         return 1;
@@ -334,10 +339,22 @@ int main(int argc, char** argv) {
         request(fullRequest);
     else if (fullRequest.contains("/getoption"))
         request(fullRequest);
+    else if (fullRequest.contains("/binds"))
+        request(fullRequest);
     else if (fullRequest.contains("/cursorpos"))
         request(fullRequest);
+    else if (fullRequest.contains("/animations"))
+        request(fullRequest);
     else if (fullRequest.contains("/switchxkblayout"))
         request(fullRequest, 2);
+    else if (fullRequest.contains("/seterror"))
+        request(fullRequest, 1);
+    else if (fullRequest.contains("/setprop"))
+        request(fullRequest, 3);
+    else if (fullRequest.contains("/plugin"))
+        request(fullRequest, 1);
+    else if (fullRequest.contains("/notify"))
+        request(fullRequest, 2);
     else if (fullRequest.contains("/output"))
         exitStatus = outputRequest(argc, argv);
     else if (fullRequest.contains("/setcursor"))

meson.build

@@ -1,9 +1,11 @@
 project('Hyprland', 'cpp', 'c',
-  version : '0.19.2beta',
+  version : run_command('jq', '-r', '.version', join_paths(meson.source_root(), 'props.json'), check: true).stdout().strip(),
   default_options : [
     'warning_level=2',
     'default_library=static',
     'optimization=3',
+    'buildtype=release',
+    'debug=false'
     # 'cpp_std=c++23' # not yet supported by meson, as of version 0.63.0
     ])
 
@@ -41,25 +43,34 @@ wlroots = subproject('wlroots', default_options: ['examples=false'])
 have_xwlr = wlroots.get_variable('features').get('xwayland')
 xcb_dep = dependency('xcb', required: get_option('xwayland'))
 
+cmake = import('cmake')
+udis = cmake.subproject('udis86')
+udis86 = udis.dependency('libudis86')
+
 if get_option('xwayland').enabled() and not have_xwlr
 	error('Cannot enable Xwayland in Hyprland: wlroots has been built without Xwayland support')
 endif
 have_xwayland = xcb_dep.found() and have_xwlr
 
 if not have_xwayland
-add_project_arguments('-DNO_XWAYLAND', language: 'cpp')
+  add_project_arguments('-DNO_XWAYLAND', language: 'cpp')
 endif
 
+backtrace_dep = cpp_compiler.find_library('execinfo', required: false)
 systemd_dep = dependency('libsystemd', required: get_option('systemd'))
 
-if get_option('systemd').enabled() 
+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')
+    add_project_arguments('-DUSES_SYSTEMD', language: 'cpp')
+  else
+  	error('Cannot enable systemd in Hyprland: libsystemd was not found')
   endif
 endif
 
+if get_option('legacy_renderer').enabled()
+  add_project_arguments('-DLEGACY_RENDERER', language: 'cpp')
+endif
+
 if get_option('buildtype') == 'debug'
   add_project_arguments('-DHYPRLAND_DEBUG', language: 'cpp')
 endif

meson_options.txt

@@ -1,2 +1,3 @@
 option('xwayland', type: 'feature', value: 'auto', description: 'Enable support for X11 applications')
 option('systemd', type: 'feature', value: 'auto', description: 'Enable systemd integration')
+option('legacy_renderer', type: 'feature', value: 'disabled', description: 'Enable legacy renderer')

nix/default.nix

@@ -1,22 +1,22 @@
 {
   lib,
   stdenv,
-  fetchFromGitHub,
-  fetchpatch,
   pkg-config,
   meson,
   ninja,
   cairo,
   git,
   hyprland-protocols,
+  jq,
   libdrm,
   libinput,
   libxcb,
   libxkbcommon,
   mesa,
-  mount,
+  pango,
   pciutils,
   systemd,
+  udis86,
   wayland,
   wayland-protocols,
   wayland-scanner,
@@ -25,11 +25,12 @@
   xwayland,
   debug ? false,
   enableXWayland ? true,
-  hidpiXWayland ? true,
+  hidpiXWayland ? false,
   legacyRenderer ? false,
   nvidiaPatches ? false,
   withSystemd ? true,
   version ? "git",
+  commit,
 }: let
   assertXWayland = lib.assertMsg (hidpiXWayland -> enableXWayland) ''
     Hyprland: cannot have hidpiXWayland when enableXWayland is false.
@@ -51,6 +52,7 @@ in
       };
 
       nativeBuildInputs = [
+        jq
         meson
         ninja
         pkg-config
@@ -65,10 +67,13 @@ in
         [
           git
           cairo
+          hyprland-protocols
           libdrm
           libinput
           libxkbcommon
           mesa
+          pango
+          udis86
           wayland
           wayland-protocols
           wayland-scanner
@@ -84,8 +89,9 @@ in
         else "release";
 
       mesonFlags = builtins.concatLists [
-        (lib.optional (!enableXWayland) "-Dxwayland=disabled")
-        (lib.optional legacyRenderer "-DLEGACY_RENDERER:STRING=true")
+        ["-Dauto_features=disabled"]
+        (lib.optional enableXWayland "-Dxwayland=enabled")
+        (lib.optional legacyRenderer "-Dlegacy_renderer=enabled")
         (lib.optional withSystemd "-Dsystemd=enabled")
       ];
 
@@ -97,10 +103,9 @@ in
       postPatch = ''
         # Fix hardcoded paths to /usr installation
         sed -i "s#/usr#$out#" src/render/OpenGL.cpp
-
-        # for some reason rmdir doesn't work in a dirty tree
-        rmdir subprojects/hyprland-protocols || true
-        ln -s ${hyprland-protocols} subprojects/hyprland-protocols
+        substituteInPlace meson.build \
+          --replace "@GIT_COMMIT_HASH@" '${commit}' \
+          --replace "@GIT_DIRTY@" '${if commit == "" then "dirty" else ""}'
       '';
 
       passthru.providedSessions = ["hyprland"];

nix/hm-module.nix

@@ -5,7 +5,7 @@ self: {
   ...
 }: let
   cfg = config.wayland.windowManager.hyprland;
-  defaultHyprlandPackage = self.packages.${pkgs.hostPlatform.system}.default.override {
+  defaultHyprlandPackage = self.packages.${pkgs.stdenv.hostPlatform.system}.default.override {
     enableXWayland = cfg.xwayland.enable;
     hidpiXWayland = cfg.xwayland.hidpi;
     nvidiaPatches = cfg.nvidiaPatches;
@@ -67,7 +67,7 @@ in {
       };
       hidpi = lib.mkOption {
         type = lib.types.bool;
-        default = true;
+        default = false;
         description = ''
           Enable HiDPI XWayland.
         '';
@@ -78,7 +78,7 @@ in {
       type = lib.types.bool;
       default = false;
       defaultText = lib.literalExpression "false";
-      example = lib.liberalExpression "true";
+      example = lib.literalExpression "true";
       description = ''
         Patch wlroots for better Nvidia support.
       '';

nix/meson-build.patch

@@ -1,34 +1,64 @@
 diff --git a/meson.build b/meson.build
-index 22ee4bf..5528613 100644
+index f3802553..6a924a79 100644
 --- a/meson.build
 +++ b/meson.build
-@@ -2,16 +2,10 @@ project('Hyprland', 'cpp', 'c',
-   version : '0.1',
-   default_options : ['warning_level=3', 'cpp_std=c++20', 'default_library=static'])
-
+@@ -21,9 +21,9 @@ else
+ endif
+ 
+ GIT_BRANCH = run_command('git', 'rev-parse', '--abbrev-ref', 'HEAD', check: false).stdout().strip()
+-GIT_COMMIT_HASH = run_command('git', 'rev-parse', 'HEAD', check: false).stdout().strip()
++GIT_COMMIT_HASH = '@GIT_COMMIT_HASH@'
+ GIT_COMMIT_MESSAGE = run_command('sh', '-c', 'git show | head -n 5 | tail -n 1', check: false).stdout().strip()
+-GIT_DIRTY = run_command('sh', '-c', 'git diff-index --quiet HEAD -- || echo "dirty"', check: false).stdout().strip()
++GIT_DIRTY = '@GIT_DIRTY@'
+ 
+ add_project_arguments(
+   [
+@@ -39,21 +39,8 @@ add_project_arguments(
+   ],
+   language: 'cpp')
+ 
 -wlroots = subproject('wlroots', default_options: ['examples=false'])
 -have_xwlr = wlroots.get_variable('features').get('xwayland')
-+wlroots = dependency('wlroots', version: '>=0.16.0')
- xcb_dep = dependency('xcb', required: get_option('xwayland'))
-
+-xcb_dep = dependency('xcb', required: get_option('xwayland'))
+-
+-cmake = import('cmake')
+-udis = cmake.subproject('udis86')
+-udis86 = udis.dependency('libudis86')
+-
 -if get_option('xwayland').enabled() and not have_xwlr
 -	error('Cannot enable Xwayland in Hyprland: wlroots has been built without Xwayland support')
 -endif
 -have_xwayland = xcb_dep.found() and have_xwlr
 -
 -if not have_xwayland
-+if not xcb_dep.found()
- add_project_arguments('-DNO_XWAYLAND', language: 'cpp')
+-  add_project_arguments('-DNO_XWAYLAND', language: 'cpp')
++if get_option('xwayland').disabled()
++  add_project_arguments('-DNO_XWAYLAND', language: 'cpp')
  endif
-
+ 
+ backtrace_dep = cpp_compiler.find_library('execinfo', required: false)
 diff --git a/src/meson.build b/src/meson.build
-index 5d64188..a676333 100644
+index 7b658d31..60aa4057 100644
 --- a/src/meson.build
 +++ b/src/meson.build
-@@ -7,5 +7,5 @@ executable('Hyprland', src,
+@@ -7,16 +7,16 @@ executable('Hyprland', src,
      server_protos,
      dependency('wayland-server'),
      dependency('wayland-client'),
 -    wlroots.get_variable('wlroots'),
-+    wlroots,
++    dependency('wlroots'),
      dependency('cairo'),
+     dependency('libdrm'),
+     dependency('egl'),
+     dependency('xkbcommon'),
+     dependency('libinput'),
+-    xcb_dep,
++    dependency('xcb', required: get_option('xwayland')),
+     backtrace_dep,
+     systemd_dep,
+-    udis86,
++    dependency('udis86'),
+ 
+     dependency('pixman-1'),
+     dependency('gl', 'opengl'),

nix/module.nix

@@ -8,7 +8,7 @@ inputs: {
 with lib; let
   cfg = config.programs.hyprland;
 
-  defaultHyprlandPackage = inputs.self.packages.${pkgs.hostPlatform.system}.default.override {
+  defaultHyprlandPackage = inputs.self.packages.${pkgs.stdenv.hostPlatform.system}.default.override {
     enableXWayland = cfg.xwayland.enable;
     hidpiXWayland = cfg.xwayland.hidpi;
     nvidiaPatches = cfg.nvidiaPatches;
@@ -47,7 +47,7 @@ in {
       };
       hidpi = mkOption {
         type = types.bool;
-        default = true;
+        default = false;
         description = ''
           Enable HiDPI XWayland.
         '';
@@ -57,7 +57,7 @@ in {
     nvidiaPatches = mkOption {
       type = types.bool;
       default = false;
-      example = liberalExpression "true";
+      example = literalExpression "true";
       description = ''
         Patch wlroots for better Nvidia support.
       '';
@@ -94,8 +94,8 @@ in {
       enable = mkDefault true;
       # xdg-desktop-portal-hyprland
       extraPortals = lib.mkIf (cfg.package != null) [
-        (inputs.xdph.packages.${pkgs.hostPlatform.system}.xdg-desktop-portal-hyprland.override {
-          hyprland-share-picker = inputs.xdph.packages.${pkgs.hostPlatform.system}.hyprland-share-picker.override {
+        (inputs.xdph.packages.${pkgs.stdenv.hostPlatform.system}.xdg-desktop-portal-hyprland.override {
+          hyprland-share-picker = inputs.xdph.packages.${pkgs.stdenv.hostPlatform.system}.hyprland-share-picker.override {
             hyprland = cfg.package;
           };
         })

nix/udis86.nix

@@ -0,0 +1,32 @@
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+  autoreconfHook,
+  python3,
+}:
+stdenv.mkDerivation {
+  pname = "udis86";
+  version = "unstable-2022-10-13";
+
+  src = fetchFromGitHub {
+    owner = "canihavesomecoffee";
+    repo = "udis86";
+    rev = "5336633af70f3917760a6d441ff02d93477b0c86";
+    hash = "sha256-HifdUQPGsKQKQprByeIznvRLONdOXeolOsU5nkwIv3g=";
+  };
+
+  nativeBuildInputs = [autoreconfHook python3];
+
+  configureFlags = ["--enable-shared"];
+
+  outputs = ["bin" "out" "dev" "lib"];
+
+  meta = with lib; {
+    homepage = "https://udis86.sourceforge.net";
+    license = licenses.bsd2;
+    mainProgram = "udcli";
+    description = "Easy-to-use, minimalistic x86 disassembler library (libudis86)";
+    platforms = platforms.all;
+  };
+}

nix/wlroots-hidpi.patch

@@ -0,0 +1,164 @@
+diff --git a/include/xwayland/xwm.h b/include/xwayland/xwm.h
+index 3d540522..1c5a2e37 100644
+--- a/include/xwayland/xwm.h
++++ b/include/xwayland/xwm.h
+@@ -88,6 +88,7 @@ enum atom_name {
+ 	DND_ACTION_PRIVATE,
+ 	NET_CLIENT_LIST,
+ 	NET_CLIENT_LIST_STACKING,
++	XWAYLAND_GLOBAL_OUTPUT_SCALE,
+ 	ATOM_LAST // keep last
+ };
+ 
+@@ -96,6 +97,7 @@ struct wlr_xwm {
+ 	struct wl_event_source *event_source;
+ 	struct wlr_seat *seat;
+ 	uint32_t ping_timeout;
++	uint32_t scale;
+ 
+ 	xcb_atom_t atoms[ATOM_LAST];
+ 	xcb_connection_t *xcb_conn;
+diff --git a/xwayland/xwm.c b/xwayland/xwm.c
+index 5f857f24..21584ebd 100644
+--- a/xwayland/xwm.c
++++ b/xwayland/xwm.c
+@@ -19,6 +19,14 @@
+ #include <xcb/xfixes.h>
+ #include "xwayland/xwm.h"
+ 
++static int32_t scale(struct wlr_xwm *xwm, uint32_t val) {
++	return val * xwm->scale;
++}
++
++static int32_t unscale(struct wlr_xwm *xwm, uint32_t val) {
++	return (val + xwm->scale/2) / xwm->scale;
++}
++
+ static const char *const atom_map[ATOM_LAST] = {
+ 	[WL_SURFACE_ID] = "WL_SURFACE_ID",
+ 	[WL_SURFACE_SERIAL] = "WL_SURFACE_SERIAL",
+@@ -90,6 +98,7 @@ static const char *const atom_map[ATOM_LAST] = {
+ 	[DND_ACTION_PRIVATE] = "XdndActionPrivate",
+ 	[NET_CLIENT_LIST] = "_NET_CLIENT_LIST",
+ 	[NET_CLIENT_LIST_STACKING] = "_NET_CLIENT_LIST_STACKING",
++	[XWAYLAND_GLOBAL_OUTPUT_SCALE] = "_XWAYLAND_GLOBAL_OUTPUT_SCALE",
+ };
+ 
+ #define STARTUP_INFO_REMOVE_PREFIX "remove: ID="
+@@ -965,8 +974,8 @@ static void xwm_handle_create_notify(struct wlr_xwm *xwm,
+ 		return;
+ 	}
+ 
+-	xwayland_surface_create(xwm, ev->window, ev->x, ev->y,
+-		ev->width, ev->height, ev->override_redirect);
++	xwayland_surface_create(xwm, ev->window, unscale(xwm, ev->x), unscale(xwm, ev->y),
++		unscale(xwm, ev->width), unscale(xwm, ev->height), ev->override_redirect);
+ }
+ 
+ static void xwm_handle_destroy_notify(struct wlr_xwm *xwm,
+@@ -997,10 +1006,10 @@ static void xwm_handle_configure_request(struct wlr_xwm *xwm,
+ 
+ 	struct wlr_xwayland_surface_configure_event wlr_event = {
+ 		.surface = surface,
+-		.x = mask & XCB_CONFIG_WINDOW_X ? ev->x : surface->x,
+-		.y = mask & XCB_CONFIG_WINDOW_Y ? ev->y : surface->y,
+-		.width = mask & XCB_CONFIG_WINDOW_WIDTH ? ev->width : surface->width,
+-		.height = mask & XCB_CONFIG_WINDOW_HEIGHT ? ev->height : surface->height,
++		.x = mask & XCB_CONFIG_WINDOW_X ? unscale(xwm, ev->x) : surface->x,
++		.y = mask & XCB_CONFIG_WINDOW_Y ? unscale(xwm, ev->y) : surface->y,
++		.width = mask & XCB_CONFIG_WINDOW_WIDTH ? unscale(xwm, ev->width) : surface->width,
++		.height = mask & XCB_CONFIG_WINDOW_HEIGHT ? unscale(xwm, ev->height) : surface->height,
+ 		.mask = mask,
+ 	};
+ 
+@@ -1015,14 +1024,14 @@ static void xwm_handle_configure_notify(struct wlr_xwm *xwm,
+ 	}
+ 
+ 	bool geometry_changed =
+-		(xsurface->x != ev->x || xsurface->y != ev->y ||
+-		 xsurface->width != ev->width || xsurface->height != ev->height);
++		(xsurface->x != unscale(xwm, ev->x) || xsurface->y != unscale(xwm, ev->y) ||
++		 xsurface->width != unscale(xwm, ev->width) || xsurface->height != unscale(xwm, ev->height));
+ 
+ 	if (geometry_changed) {
+-		xsurface->x = ev->x;
+-		xsurface->y = ev->y;
+-		xsurface->width = ev->width;
+-		xsurface->height = ev->height;
++		xsurface->x = unscale(xwm, ev->x);
++		xsurface->y = unscale(xwm, ev->y);
++		xsurface->width = unscale(xwm, ev->width);
++		xsurface->height = unscale(xwm, ev->height);
+ 	}
+ 
+ 	if (xsurface->override_redirect != ev->override_redirect) {
+@@ -1133,6 +1142,20 @@ static void xwm_handle_property_notify(struct wlr_xwm *xwm,
+ 		xcb_property_notify_event_t *ev) {
+ 	struct wlr_xwayland_surface *xsurface = lookup_surface(xwm, ev->window);
+ 	if (xsurface == NULL) {
++		if (ev->atom == xwm->atoms[XWAYLAND_GLOBAL_OUTPUT_SCALE]) {
++			xcb_get_property_cookie_t cookie = xcb_get_property(xwm->xcb_conn, 0,
++					ev->window, ev->atom, XCB_ATOM_ANY, 0, 2048);
++			xcb_get_property_reply_t *reply = xcb_get_property_reply(xwm->xcb_conn,
++					cookie, NULL);
++			if (reply == NULL) {
++				return;
++			}
++			if (reply->type == XCB_ATOM_CARDINAL) {
++				xwm->scale = *(uint32_t*)xcb_get_property_value(reply);
++			}
++			free(reply);
++		}
++
+ 		return;
+ 	}
+ 
+@@ -1760,16 +1783,17 @@ void wlr_xwayland_surface_configure(struct wlr_xwayland_surface *xsurface,
+ 	int old_w = xsurface->width;
+ 	int old_h = xsurface->height;
+ 
++	struct wlr_xwm *xwm = xsurface->xwm;
++
+ 	xsurface->x = x;
+ 	xsurface->y = y;
+ 	xsurface->width = width;
+ 	xsurface->height = height;
+ 
+-	struct wlr_xwm *xwm = xsurface->xwm;
+ 	uint32_t mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
+ 		XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
+ 		XCB_CONFIG_WINDOW_BORDER_WIDTH;
+-	uint32_t values[] = {x, y, width, height, 0};
++	uint32_t values[] = {scale(xwm, x), scale(xwm, y), scale(xwm, width), scale(xwm, height), 0};
+ 	xcb_configure_window(xwm->xcb_conn, xsurface->window_id, mask, values);
+ 
+ 	// If the window size did not change, then we cannot rely on
+@@ -1777,15 +1801,15 @@ void wlr_xwayland_surface_configure(struct wlr_xwayland_surface *xsurface,
+ 	// we are supposed to send a synthetic event. See ICCCM part
+ 	// 4.1.5. But we ignore override-redirect windows as ICCCM does
+ 	// not apply to them.
+-	if (width == old_w && height == old_h && !xsurface->override_redirect) {
++	if (scale(xwm, width) == scale(xwm, old_w) && scale(xwm, height) == scale(xwm, old_h) && !xsurface->override_redirect) {
+ 		xcb_configure_notify_event_t configure_notify = {
+ 			.response_type = XCB_CONFIGURE_NOTIFY,
+ 			.event = xsurface->window_id,
+ 			.window = xsurface->window_id,
+-			.x = x,
+-			.y = y,
+-			.width = width,
+-			.height = height,
++			.x = scale(xwm, x),
++			.y = scale(xwm, y),
++			.width = scale(xwm, width),
++			.height = scale(xwm, height),
+ 		};
+ 
+ 		xcb_send_event(xwm->xcb_conn, 0, xsurface->window_id,
+@@ -2122,6 +2146,7 @@ struct wlr_xwm *xwm_create(struct wlr_xwayland *xwayland, int wm_fd) {
+ 	wl_list_init(&xwm->pending_startup_ids);
+ 	xwm->ping_timeout = 10000;
+ 
++	xwm->scale = 1;
+ 	xwm->xcb_conn = xcb_connect_to_fd(wm_fd, NULL);
+ 
+ 	int rc = xcb_connection_has_error(xwm->xcb_conn);

nix/wlroots.nix

@@ -7,6 +7,8 @@
   fetchpatch,
   lib,
   hwdata,
+  libliftoff,
+  libdisplay-info,
   hidpiXWayland ? true,
   enableXWayland ? true,
   nvidiaPatches ? false,
@@ -33,10 +35,8 @@ assert (lib.assertMsg (hidpiXWayland -> enableXWayland) ''
       patches =
         (old.patches or [])
         ++ (lib.optionals (enableXWayland && hidpiXWayland) [
-          (fetchpatch {
-            url = "https://gitlab.freedesktop.org/lilydjwg/wlroots/-/commit/6c5ffcd1fee9e44780a6a8792f74ecfbe24a1ca7.diff";
-            sha256 = "sha256-Eo1pTa/PIiJsRZwIUnHGTIFFIedzODVf0ZeuXb0a3TQ=";
-          })
+          # adapted from https://gitlab.freedesktop.org/lilydjwg/wlroots/-/commit/6c5ffcd1fee9e44780a6a8792f74ecfbe24a1ca7
+          ./wlroots-hidpi.patch
           (fetchpatch {
             url = "https://gitlab.freedesktop.org/wlroots/wlroots/-/commit/18595000f3a21502fd60bf213122859cc348f9af.diff";
             sha256 = "sha256-jvfkAMh3gzkfuoRhB4E9T5X1Hu62wgUjj4tZkJm0mrI=";
@@ -58,7 +58,11 @@ assert (lib.assertMsg (hidpiXWayland -> enableXWayland) ''
           ''
           else ""
         );
-      buildInputs = old.buildInputs ++ [hwdata];
+      buildInputs = old.buildInputs ++ [hwdata libliftoff libdisplay-info];
+
+      NIX_CFLAGS_COMPILE = toString [
+        "-Wno-error=maybe-uninitialized"
+      ];
     }))
   .override {
     xwayland = xwayland.overrideAttrs (old: {

nix/xwayland-hidpi.patch

@@ -1,8 +1,8 @@
 diff --git a/hw/xwayland/xwayland-cursor.c b/hw/xwayland/xwayland-cursor.c
-index c4457cc2a61b2103b47f996b51dbbe9eb87bd715..4a33e1f33e73c35c1691564ef4852e7501b02245 100644
+index e3c1aaa50..eba29b5ba 100644
 --- a/hw/xwayland/xwayland-cursor.c
 +++ b/hw/xwayland/xwayland-cursor.c
-@@ -171,6 +171,8 @@ xwl_cursor_attach_pixmap(struct xwl_seat *xwl_seat,
+@@ -164,6 +164,8 @@ xwl_cursor_attach_pixmap(struct xwl_seat *xwl_seat,
      }
  
      wl_surface_attach(xwl_cursor->surface, buffer, 0, 0);
@@ -11,7 +11,7 @@ index c4457cc2a61b2103b47f996b51dbbe9eb87bd715..4a33e1f33e73c35c1691564ef4852e75
      xwl_surface_damage(xwl_seat->xwl_screen, xwl_cursor->surface, 0, 0,
                         xwl_seat->x_cursor->bits->width,
                         xwl_seat->x_cursor->bits->height);
-@@ -190,6 +192,7 @@ xwl_cursor_attach_pixmap(struct xwl_seat *xwl_seat,
+@@ -195,6 +197,7 @@ xwl_cursor_clear_frame_cb(struct xwl_cursor *xwl_cursor)
  void
  xwl_seat_set_cursor(struct xwl_seat *xwl_seat)
  {
@@ -19,7 +19,7 @@ index c4457cc2a61b2103b47f996b51dbbe9eb87bd715..4a33e1f33e73c35c1691564ef4852e75
      struct xwl_cursor *xwl_cursor = &xwl_seat->cursor;
      PixmapPtr pixmap;
      CursorPtr cursor;
-@@ -220,8 +223,8 @@ xwl_seat_set_cursor(struct xwl_seat *xwl_seat)
+@@ -225,8 +228,8 @@ xwl_seat_set_cursor(struct xwl_seat *xwl_seat)
      wl_pointer_set_cursor(xwl_seat->wl_pointer,
                            xwl_seat->pointer_enter_serial,
                            xwl_cursor->surface,
@@ -30,7 +30,7 @@ index c4457cc2a61b2103b47f996b51dbbe9eb87bd715..4a33e1f33e73c35c1691564ef4852e75
  
      xwl_cursor_attach_pixmap(xwl_seat, xwl_cursor, pixmap);
  }
-@@ -230,6 +233,7 @@ void
+@@ -235,6 +238,7 @@ void
  xwl_tablet_tool_set_cursor(struct xwl_tablet_tool *xwl_tablet_tool)
  {
      struct xwl_seat *xwl_seat = xwl_tablet_tool->seat;
@@ -38,24 +38,23 @@ index c4457cc2a61b2103b47f996b51dbbe9eb87bd715..4a33e1f33e73c35c1691564ef4852e75
      struct xwl_cursor *xwl_cursor = &xwl_tablet_tool->cursor;
      PixmapPtr pixmap;
      CursorPtr cursor;
-@@ -258,9 +262,9 @@ xwl_tablet_tool_set_cursor(struct xwl_tablet_tool *xwl_tablet_tool)
+@@ -263,8 +267,9 @@ xwl_tablet_tool_set_cursor(struct xwl_tablet_tool *xwl_tablet_tool)
      zwp_tablet_tool_v2_set_cursor(xwl_tablet_tool->tool,
                                    xwl_tablet_tool->proximity_in_serial,
                                    xwl_cursor->surface,
 -                                  xwl_seat->x_cursor->bits->xhot,
 -                                  xwl_seat->x_cursor->bits->yhot);
--
 +                                  xwl_scale_to(xwl_screen, xwl_seat->x_cursor->bits->xhot),
 +                                  xwl_scale_to(xwl_screen, xwl_seat->x_cursor->bits->yhot));
 +    wl_surface_set_buffer_scale(xwl_cursor->surface, xwl_screen->global_output_scale);
+ 
      xwl_cursor_attach_pixmap(xwl_seat, xwl_cursor, pixmap);
  }
- 
 diff --git a/hw/xwayland/xwayland-input.c b/hw/xwayland/xwayland-input.c
-index 26b3630c73b62514fe3ba7824371f79868e953f3..55cd8d466a55db03948abe93ffa03bf129b5e17a 100644
+index 6e0600e4e..4a22ebff0 100644
 --- a/hw/xwayland/xwayland-input.c
 +++ b/hw/xwayland/xwayland-input.c
-@@ -412,8 +412,8 @@ pointer_handle_enter(void *data, struct wl_pointer *pointer,
+@@ -507,8 +507,8 @@ pointer_handle_enter(void *data, struct wl_pointer *pointer,
      DeviceIntPtr dev = get_pointer_device(xwl_seat);
      DeviceIntPtr master;
      int i;
@@ -66,7 +65,7 @@ index 26b3630c73b62514fe3ba7824371f79868e953f3..55cd8d466a55db03948abe93ffa03bf1
      int dx, dy;
      ScreenPtr pScreen = xwl_seat->xwl_screen->screen;
      ValuatorMask mask;
-@@ -592,13 +592,14 @@ pointer_handle_motion(void *data, struct wl_pointer *pointer,
+@@ -731,13 +731,14 @@ pointer_handle_motion(void *data, struct wl_pointer *pointer,
                        uint32_t time, wl_fixed_t sx_w, wl_fixed_t sy_w)
  {
      struct xwl_seat *xwl_seat = data;
@@ -83,17 +82,7 @@ index 26b3630c73b62514fe3ba7824371f79868e953f3..55cd8d466a55db03948abe93ffa03bf1
  
      if (wl_proxy_get_version((struct wl_proxy *) xwl_seat->wl_pointer) < 5)
          dispatch_pointer_motion_event(xwl_seat);
-@@ -672,7 +673,8 @@ pointer_handle_axis(void *data, struct wl_pointer *pointer,
-         xorg_list_del(&pending->l);
-         free(pending);
-     } else {
--        valuator_mask_set_double(&mask, index, wl_fixed_to_double(value) / divisor);
-+        double scaled_value = wl_fixed_to_double(value);
-+        valuator_mask_set_double(&mask, index, scaled_value / divisor);
-     }
- 
-     QueuePointerEvents(get_pointer_device(xwl_seat),
-@@ -740,12 +742,13 @@ relative_pointer_handle_relative_motion(void *data,
+@@ -887,12 +888,13 @@ relative_pointer_handle_relative_motion(void *data,
                                          wl_fixed_t dy_unaccelf)
  {
      struct xwl_seat *xwl_seat = data;
@@ -111,7 +100,7 @@ index 26b3630c73b62514fe3ba7824371f79868e953f3..55cd8d466a55db03948abe93ffa03bf1
  
      if (!xwl_seat->focus_window)
          return;
-@@ -1057,8 +1060,8 @@ touch_handle_down(void *data, struct wl_touch *wl_touch,
+@@ -1382,8 +1384,8 @@ touch_handle_down(void *data, struct wl_touch *wl_touch,
  
      xwl_touch->window = wl_surface_get_user_data(surface);
      xwl_touch->id = id;
@@ -122,18 +111,18 @@ index 26b3630c73b62514fe3ba7824371f79868e953f3..55cd8d466a55db03948abe93ffa03bf1
      xorg_list_add(&xwl_touch->link_touch, &xwl_seat->touches);
  
      xwl_touch_send_event(xwl_touch, xwl_seat, XI_TouchBegin);
-@@ -1094,8 +1097,8 @@ touch_handle_motion(void *data, struct wl_touch *wl_touch,
+@@ -1419,8 +1421,8 @@ touch_handle_motion(void *data, struct wl_touch *wl_touch,
      if (!xwl_touch)
          return;
  
 -    xwl_touch->x = wl_fixed_to_int(sx_w);
 -    xwl_touch->y = wl_fixed_to_int(sy_w);
-+    xwl_touch->x = wl_fixed_to_int(sx_w) * xwl_seat->xwl_screen->global_output_scale;;
-+    xwl_touch->y = wl_fixed_to_int(sy_w) * xwl_seat->xwl_screen->global_output_scale;;
++    xwl_touch->x = wl_fixed_to_int(sx_w) * xwl_seat->xwl_screen->global_output_scale;
++    xwl_touch->y = wl_fixed_to_int(sy_w) * xwl_seat->xwl_screen->global_output_scale;
      xwl_touch_send_event(xwl_touch, xwl_seat, XI_TouchUpdate);
  }
  
-@@ -1726,8 +1729,8 @@ tablet_tool_motion(void *data, struct zwp_tablet_tool_v2 *tool,
+@@ -2110,8 +2112,8 @@ tablet_tool_motion(void *data, struct zwp_tablet_tool_v2 *tool,
      struct xwl_tablet_tool *xwl_tablet_tool = data;
      struct xwl_seat *xwl_seat = xwl_tablet_tool->seat;
      int32_t dx, dy;
@@ -144,7 +133,7 @@ index 26b3630c73b62514fe3ba7824371f79868e953f3..55cd8d466a55db03948abe93ffa03bf1
  
      if (!xwl_seat->tablet_focus_window)
          return;
-@@ -2714,6 +2717,7 @@ xwl_pointer_warp_emulator_set_fake_pos(struct xwl_pointer_warp_emulator *warp_em
+@@ -3152,6 +3154,7 @@ xwl_pointer_warp_emulator_set_fake_pos(struct xwl_pointer_warp_emulator *warp_em
                                         int x,
                                         int y)
  {
@@ -152,7 +141,7 @@ index 26b3630c73b62514fe3ba7824371f79868e953f3..55cd8d466a55db03948abe93ffa03bf1
      struct zwp_locked_pointer_v1 *locked_pointer =
          warp_emulator->locked_pointer;
      WindowPtr window;
-@@ -2725,6 +2729,7 @@ xwl_pointer_warp_emulator_set_fake_pos(struct xwl_pointer_warp_emulator *warp_em
+@@ -3163,6 +3166,7 @@ xwl_pointer_warp_emulator_set_fake_pos(struct xwl_pointer_warp_emulator *warp_em
      if (!warp_emulator->xwl_seat->focus_window)
          return;
  
@@ -160,7 +149,7 @@ index 26b3630c73b62514fe3ba7824371f79868e953f3..55cd8d466a55db03948abe93ffa03bf1
      window = warp_emulator->xwl_seat->focus_window->window;
      if (x >= window->drawable.x ||
          y >= window->drawable.y ||
-@@ -2733,8 +2738,8 @@ xwl_pointer_warp_emulator_set_fake_pos(struct xwl_pointer_warp_emulator *warp_em
+@@ -3171,8 +3175,8 @@ xwl_pointer_warp_emulator_set_fake_pos(struct xwl_pointer_warp_emulator *warp_em
          sx = x - window->drawable.x;
          sy = y - window->drawable.y;
          zwp_locked_pointer_v1_set_cursor_position_hint(locked_pointer,
@@ -172,21 +161,21 @@ index 26b3630c73b62514fe3ba7824371f79868e953f3..55cd8d466a55db03948abe93ffa03bf1
      }
  }
 diff --git a/hw/xwayland/xwayland-output.c b/hw/xwayland/xwayland-output.c
-index ef705bc01bf8c2d2f170cda9ba21ed8293f50559..b8f6cd51bd240ed5e16271eb4749db18868bea7b 100644
+index 661e1828d..6c60aba34 100644
 --- a/hw/xwayland/xwayland-output.c
 +++ b/hw/xwayland/xwayland-output.c
-@@ -191,6 +191,9 @@ update_screen_size(struct xwl_output *xwl_output, int width, int height)
+@@ -186,6 +186,9 @@ update_backing_pixmaps(struct xwl_screen *xwl_screen, int width, int height)
+ static void
+ update_screen_size(struct xwl_screen *xwl_screen, int width, int height)
  {
-     struct xwl_screen *xwl_screen = xwl_output->xwl_screen;
- 
 +    width *= xwl_screen->global_output_scale;
 +    height *= xwl_screen->global_output_scale;
 +
-     if (xwl_screen->root_clip_mode == ROOT_CLIP_FULL)
-         SetRootClip(xwl_screen->screen, ROOT_CLIP_NONE);
+     xwl_screen->width = width;
+     xwl_screen->height = height;
  
-@@ -497,14 +500,15 @@ xwl_output_set_emulated_mode(struct xwl_output *xwl_output, ClientPtr client,
-     xwl_output_set_randr_emu_props(xwl_output->xwl_screen, client);
+@@ -597,14 +600,15 @@ xwl_output_set_emulated_mode(struct xwl_output *xwl_output, ClientPtr client,
+                                              new_emulated_height);
  }
  
 -static void
@@ -203,20 +192,20 @@ index ef705bc01bf8c2d2f170cda9ba21ed8293f50559..b8f6cd51bd240ed5e16271eb4749db18
  
      /* Clear out the "done" received flags */
      xwl_output->wl_output_done = FALSE;
-@@ -523,10 +527,10 @@ apply_output_change(struct xwl_output *xwl_output)
+@@ -623,10 +627,10 @@ apply_output_change(struct xwl_output *xwl_output)
      }
- 
-     /* Build a fresh modes array using the current refresh rate */
--    randr_modes = output_get_rr_modes(xwl_output, mode_width, mode_height, &count);
-+    randr_modes = output_get_rr_modes(xwl_output, mode_width * scale, mode_height * scale, &count);
-     RROutputSetModes(xwl_output->randr_output, randr_modes, count, 1);
-     RRCrtcNotify(xwl_output->randr_crtc, randr_modes[0],
--                 xwl_output->x, xwl_output->y,
-+                 xwl_output->x * scale, xwl_output->y * scale,
-                  xwl_output->rotation, NULL, 1, &xwl_output->randr_output);
-     /* RROutputSetModes takes ownership of the passed in modes, so we only
-      * have to free the pointer array.
-@@ -567,7 +571,7 @@ output_handle_done(void *data, struct wl_output *wl_output)
+     if (xwl_output->randr_output) {
+         /* Build a fresh modes array using the current refresh rate */
+-        randr_modes = output_get_rr_modes(xwl_output, mode_width, mode_height, &count);
++        randr_modes = output_get_rr_modes(xwl_output, mode_width * scale, mode_height * scale, &count);
+         RROutputSetModes(xwl_output->randr_output, randr_modes, count, 1);
+         RRCrtcNotify(xwl_output->randr_crtc, randr_modes[0],
+-                     xwl_output->x, xwl_output->y,
++                     xwl_output->x * scale, xwl_output->y * scale,
+                      xwl_output->rotation, NULL, 1, &xwl_output->randr_output);
+         /* RROutputSetModes takes ownership of the passed in modes, so we only
+          * have to free the pointer array.
+@@ -686,7 +690,7 @@ output_handle_done(void *data, struct wl_output *wl_output)
       */
      if (xwl_output->xdg_output_done || !xwl_output->xdg_output ||
          zxdg_output_v1_get_version(xwl_output->xdg_output) >= 3)
@@ -225,7 +214,7 @@ index ef705bc01bf8c2d2f170cda9ba21ed8293f50559..b8f6cd51bd240ed5e16271eb4749db18
  }
  
  static void
-@@ -610,7 +614,7 @@ xdg_output_handle_done(void *data, struct zxdg_output_v1 *xdg_output)
+@@ -746,7 +750,7 @@ xdg_output_handle_done(void *data, struct zxdg_output_v1 *xdg_output)
      xwl_output->xdg_output_done = TRUE;
      if (xwl_output->wl_output_done &&
          zxdg_output_v1_get_version(xdg_output) < 3)
@@ -234,17 +223,17 @@ index ef705bc01bf8c2d2f170cda9ba21ed8293f50559..b8f6cd51bd240ed5e16271eb4749db18
  }
  
  static void
-@@ -678,6 +682,8 @@ xwl_output_create(struct xwl_screen *xwl_screen, uint32_t id)
-     RROutputSetConnection(xwl_output->randr_output, RR_Connected);
-     RRTellChanged(xwl_screen->screen);
- 
-+    xwl_output->scale = 1;
+@@ -857,6 +861,8 @@ xwl_output_create(struct xwl_screen *xwl_screen, uint32_t id,
+         RRCrtcGammaSetSize(xwl_output->randr_crtc, 256);
+         RROutputSetCrtcs(xwl_output->randr_output, &xwl_output->randr_crtc, 1);
+         RROutputSetConnection(xwl_output->randr_output, RR_Connected);
 +
++        xwl_output->scale = 1;
+     }
      /* We want the output to be in the list as soon as created so we can
       * use it when binding to the xdg-output protocol...
-      */
 diff --git a/hw/xwayland/xwayland-output.h b/hw/xwayland/xwayland-output.h
-index 02b9831083e82a33d85d4404e39d00f06f6c56fd..ec089757f44178dcd7f9c48907f790ce1b2a2729 100644
+index a95288e4f..46d1ead2a 100644
 --- a/hw/xwayland/xwayland-output.h
 +++ b/hw/xwayland/xwayland-output.h
 @@ -53,7 +53,7 @@ struct xwl_output {
@@ -256,7 +245,7 @@ index 02b9831083e82a33d85d4404e39d00f06f6c56fd..ec089757f44178dcd7f9c48907f790ce
      Rotation rotation;
      Bool wl_output_done;
      Bool xdg_output_done;
-@@ -100,6 +100,8 @@ void xwl_output_set_emulated_mode(struct xwl_output *xwl_output,
+@@ -102,6 +102,8 @@ void xwl_output_set_emulated_mode(struct xwl_output *xwl_output,
  void xwl_output_set_window_randr_emu_props(struct xwl_screen *xwl_screen,
                                             WindowPtr window);
  
@@ -266,20 +255,20 @@ index 02b9831083e82a33d85d4404e39d00f06f6c56fd..ec089757f44178dcd7f9c48907f790ce
  
  #endif /* XWAYLAND_OUTPUT_H */
 diff --git a/hw/xwayland/xwayland-present.c b/hw/xwayland/xwayland-present.c
-index c9cf8c2f569a319034e0789e7587414e50237065..5be0c208ca46b1a53a136885fdc8ab44251fe7ff 100644
+index 189e7cfd6..555434031 100644
 --- a/hw/xwayland/xwayland-present.c
 +++ b/hw/xwayland/xwayland-present.c
-@@ -680,6 +680,8 @@ xwl_present_flip(WindowPtr present_window,
+@@ -764,6 +764,8 @@ xwl_present_flip(WindowPtr present_window,
  
      /* We can flip directly to the main surface (full screen window without clips) */
      wl_surface_attach(xwl_window->surface, buffer, 0, 0);
-+     wl_surface_set_buffer_scale(xwl_window->surface,
-+                                 xwl_window->xwl_screen->global_output_scale);
++    wl_surface_set_buffer_scale(xwl_window->surface,
++                                xwl_window->xwl_screen->global_output_scale);
  
-     if (!xwl_window->frame_callback)
-         xwl_window_create_frame_callback(xwl_window);
+     if (xorg_list_is_empty(&xwl_present_window->frame_callback_list)) {
+         xorg_list_add(&xwl_present_window->frame_callback_list,
 diff --git a/hw/xwayland/xwayland-screen.c b/hw/xwayland/xwayland-screen.c
-index bb18e5c94fbc7134c801e4e1979e8184079d352e..4ec2de7d123dd36315df07a1e95b1f417925f0f8 100644
+index 46ab4fed7..b2d7022e6 100644
 --- a/hw/xwayland/xwayland-screen.c
 +++ b/hw/xwayland/xwayland-screen.c
 @@ -51,6 +51,7 @@
@@ -290,7 +279,7 @@ index bb18e5c94fbc7134c801e4e1979e8184079d352e..4ec2de7d123dd36315df07a1e95b1f41
  
  #ifdef MITSHM
  #include "shmint.h"
-@@ -110,6 +111,12 @@ xwl_screen_has_resolution_change_emulation(struct xwl_screen *xwl_screen)
+@@ -111,6 +112,12 @@ xwl_screen_has_resolution_change_emulation(struct xwl_screen *xwl_screen)
      return xwl_screen->rootless && xwl_screen_has_viewport_support(xwl_screen);
  }
  
@@ -303,7 +292,7 @@ index bb18e5c94fbc7134c801e4e1979e8184079d352e..4ec2de7d123dd36315df07a1e95b1f41
  /* Return the output @ 0x0, falling back to the first output in the list */
  struct xwl_output *
  xwl_screen_get_first_output(struct xwl_screen *xwl_screen)
-@@ -127,6 +134,37 @@ xwl_screen_get_first_output(struct xwl_screen *xwl_screen)
+@@ -128,6 +135,38 @@ xwl_screen_get_first_output(struct xwl_screen *xwl_screen)
      return xorg_list_first_entry(&xwl_screen->output_list, struct xwl_output, link);
  }
  
@@ -338,10 +327,11 @@ index bb18e5c94fbc7134c801e4e1979e8184079d352e..4ec2de7d123dd36315df07a1e95b1f41
 +    }
 +}
 +
- static void
- xwl_property_callback(CallbackListPtr *pcbl, void *closure,
-                       void *calldata)
-@@ -134,19 +172,24 @@ xwl_property_callback(CallbackListPtr *pcbl, void *closure,
++
+ struct xwl_output *
+ xwl_screen_get_fixed_or_first_output(struct xwl_screen *xwl_screen)
+ {
+@@ -144,19 +183,24 @@ xwl_property_callback(CallbackListPtr *pcbl, void *closure,
      ScreenPtr screen = closure;
      PropertyStateRec *rec = calldata;
      struct xwl_screen *xwl_screen;
@@ -357,6 +347,7 @@ index bb18e5c94fbc7134c801e4e1979e8184079d352e..4ec2de7d123dd36315df07a1e95b1f41
      xwl_screen = xwl_screen_get(screen);
  
 -    if (rec->prop->propertyName == xwl_screen->allow_commits_prop)
+-        xwl_window_update_property(xwl_window, rec);
 +    if (rec->prop->propertyName == xwl_screen->allow_commits_prop) {
 +        struct xwl_window *xwl_window;
 +
@@ -364,15 +355,15 @@ index bb18e5c94fbc7134c801e4e1979e8184079d352e..4ec2de7d123dd36315df07a1e95b1f41
 +        if (!xwl_window)
 +            return;
 +
-         xwl_window_update_property(xwl_window, rec);
++         xwl_window_update_property(xwl_window, rec);
 +    }
 +    else if (rec->prop->propertyName == xwl_screen->global_output_scale_prop) {
 +        xwl_screen_update_property(xwl_screen, rec);
 +    }
  }
  
- Bool
-@@ -521,8 +564,14 @@ void xwl_surface_damage(struct xwl_screen *xwl_screen,
+ static void
+@@ -638,8 +682,14 @@ void xwl_surface_damage(struct xwl_screen *xwl_screen,
  {
      if (wl_surface_get_version(surface) >= WL_SURFACE_DAMAGE_BUFFER_SINCE_VERSION)
          wl_surface_damage_buffer(surface, x, y, width, height);
@@ -388,7 +379,7 @@ index bb18e5c94fbc7134c801e4e1979e8184079d352e..4ec2de7d123dd36315df07a1e95b1f41
  }
  
  void
-@@ -538,10 +587,34 @@ xwl_screen_roundtrip(struct xwl_screen *xwl_screen)
+@@ -655,6 +705,30 @@ xwl_screen_roundtrip(struct xwl_screen *xwl_screen)
          xwl_give_up("could not connect to wayland server\n");
  }
  
@@ -415,7 +406,11 @@ index bb18e5c94fbc7134c801e4e1979e8184079d352e..4ec2de7d123dd36315df07a1e95b1f41
 +    }
 +}
 +
- Bool
++
+ static int
+ xwl_server_grab(ClientPtr client)
+ {
+@@ -712,6 +786,7 @@ Bool
  xwl_screen_init(ScreenPtr pScreen, int argc, char **argv)
  {
      static const char allow_commits[] = "_XWAYLAND_ALLOW_COMMITS";
@@ -423,7 +418,7 @@ index bb18e5c94fbc7134c801e4e1979e8184079d352e..4ec2de7d123dd36315df07a1e95b1f41
      struct xwl_screen *xwl_screen;
      Pixel red_mask, blue_mask, green_mask;
      int ret, bpc, green_bpc, i;
-@@ -573,6 +646,7 @@ xwl_screen_init(ScreenPtr pScreen, int argc, char **argv)
+@@ -746,6 +821,7 @@ xwl_screen_init(ScreenPtr pScreen, int argc, char **argv)
  #ifdef XWL_HAS_GLAMOR
      xwl_screen->glamor = 1;
  #endif
@@ -431,7 +426,7 @@ index bb18e5c94fbc7134c801e4e1979e8184079d352e..4ec2de7d123dd36315df07a1e95b1f41
  
      for (i = 1; i < argc; i++) {
          if (strcmp(argv[i], "-rootless") == 0) {
-@@ -743,6 +817,12 @@ xwl_screen_init(ScreenPtr pScreen, int argc, char **argv)
+@@ -988,6 +1064,13 @@ xwl_screen_init(ScreenPtr pScreen, int argc, char **argv)
      if (xwl_screen->allow_commits_prop == BAD_RESOURCE)
          return FALSE;
  
@@ -440,24 +435,24 @@ index bb18e5c94fbc7134c801e4e1979e8184079d352e..4ec2de7d123dd36315df07a1e95b1f41
 +                                                    TRUE);
 +    if (xwl_screen->global_output_scale_prop == BAD_RESOURCE)
 +        return FALSE;
++
 +
      AddCallback(&PropertyStateCallback, xwl_property_callback, pScreen);
+     AddCallback(&RootWindowFinalizeCallback, xwl_root_window_finalized_callback, pScreen);
  
-     xwl_screen_roundtrip(xwl_screen);
 diff --git a/hw/xwayland/xwayland-screen.h b/hw/xwayland/xwayland-screen.h
-index b965dddd7f964b1d100bbb9d10da1c35ab39810e..7446829d098fbe235e605084a016daff1a8eaea2 100644
+index fadd0526e..2ce6ce5ab 100644
 --- a/hw/xwayland/xwayland-screen.h
 +++ b/hw/xwayland/xwayland-screen.h
-@@ -72,6 +72,8 @@ struct xwl_screen {
+@@ -87,6 +87,7 @@ struct xwl_screen {
      struct xorg_list damage_window_list;
      struct xorg_list window_list;
  
 +    int32_t global_output_scale;
-+
      int wayland_fd;
      struct wl_display *display;
      struct wl_registry *registry;
-@@ -107,6 +109,7 @@ struct xwl_screen {
+@@ -134,6 +135,7 @@ struct xwl_screen {
      struct glamor_context *glamor_ctx;
  
      Atom allow_commits_prop;
@@ -465,29 +460,30 @@ index b965dddd7f964b1d100bbb9d10da1c35ab39810e..7446829d098fbe235e605084a016daff
  
      /* The preferred GLVND vendor. If NULL, "mesa" is assumed. */
      const char *glvnd_vendor;
-@@ -134,5 +137,7 @@ void xwl_screen_roundtrip (struct xwl_screen *xwl_screen);
+@@ -166,6 +168,8 @@ void xwl_screen_roundtrip (struct xwl_screen *xwl_screen);
  void xwl_surface_damage(struct xwl_screen *xwl_screen,
                          struct wl_surface *surface,
                          int32_t x, int32_t y, int32_t width, int32_t height);
 +int xwl_scale_to(struct xwl_screen *xwl_screen, int value);
 +void xwl_screen_set_global_scale(struct xwl_screen *xwl_screen, int32_t scale);
+ int xwl_screen_get_next_output_serial(struct xwl_screen * xwl_screen);
  
  #endif /* XWAYLAND_SCREEN_H */
 diff --git a/hw/xwayland/xwayland-window.c b/hw/xwayland/xwayland-window.c
-index 00f161eda084e335ac07471a2198176d75d9fcf0..ed3903853f0dab1dad390cd8429639541546157d 100644
+index 6b7f38605..2f1e0dee1 100644
 --- a/hw/xwayland/xwayland-window.c
 +++ b/hw/xwayland/xwayland-window.c
-@@ -470,7 +470,8 @@ ensure_surface_for_window(WindowPtr window)
-         }
- 
-         wl_region_add(region, 0, 0,
--                      window->drawable.width, window->drawable.height);
-+                      xwl_scale_to(xwl_screen, window->drawable.width),
-+                      xwl_scale_to(xwl_screen, window->drawable.height));
-         wl_surface_set_opaque_region(xwl_window->surface, region);
-         wl_region_destroy(region);
+@@ -788,7 +788,8 @@ xwl_create_root_surface(struct xwl_window *xwl_window)
      }
-@@ -820,6 +821,7 @@ xwl_window_post_damage(struct xwl_window *xwl_window)
+ 
+     wl_region_add(region, 0, 0,
+-                  window->drawable.width, window->drawable.height);
++                 xwl_scale_to(xwl_screen, window->drawable.width),
++                 xwl_scale_to(xwl_screen, window->drawable.height));
+     wl_surface_set_opaque_region(xwl_window->surface, region);
+     wl_region_destroy(region);
+ 
+@@ -1322,6 +1323,7 @@ xwl_window_post_damage(struct xwl_window *xwl_window)
  #endif
  
      wl_surface_attach(xwl_window->surface, buffer, 0, 0);
@@ -495,4 +491,3 @@ index 00f161eda084e335ac07471a2198176d75d9fcf0..ed3903853f0dab1dad390cd842963954
  
      /* Arbitrary limit to try to avoid flooding the Wayland
       * connection. If we flood it too much anyway, this could
-

props.json

@@ -0,0 +1,3 @@
+{
+    "version": "0.24.0"
+}

protocols/meson.build

@@ -21,9 +21,12 @@ wayland_scanner = find_program(
 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, 'staging/fractional-scale/fractional-scale-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'],
   ['ext-workspace-unstable-v1.xml'],
   ['pointer-constraints-unstable-v1.xml'],
   ['tablet-unstable-v2.xml'],

src/Compositor.hpp

@@ -16,13 +16,22 @@
 #include "managers/AnimationManager.hpp"
 #include "managers/EventManager.hpp"
 #include "managers/ProtocolManager.hpp"
+#include "managers/SessionLockManager.hpp"
+#include "managers/HookSystemManager.hpp"
 #include "debug/HyprDebugOverlay.hpp"
+#include "debug/HyprNotificationOverlay.hpp"
 #include "helpers/Monitor.hpp"
 #include "helpers/Workspace.hpp"
 #include "Window.hpp"
 #include "render/Renderer.hpp"
 #include "render/OpenGL.hpp"
 #include "hyprerror/HyprError.hpp"
+#include "plugins/PluginSystem.hpp"
+
+enum eManagersInitStage {
+    STAGE_PRIORITY = 0,
+    STAGE_LATE
+};
 
 class CCompositor {
   public:
@@ -73,6 +82,7 @@ class CCompositor {
     wlr_xdg_activation_v1*                     m_sWLRActivation;
     wlr_linux_dmabuf_v1*                       m_sWLRLinuxDMABuf;
     wlr_backend*                               m_sWLRHeadlessBackend;
+    wlr_session_lock_manager_v1*               m_sWLRSessionLockMgr;
     // ------------------------------------------------- //
 
     std::string                               m_szWLDisplaySocket   = "";
@@ -82,13 +92,13 @@ class CCompositor {
     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::deque<std::unique_ptr<CWindow>>      m_dUnmanagedX11Windows;
     std::vector<std::unique_ptr<SXDGPopup>>   m_vXDGPopups;
     std::vector<std::unique_ptr<CWorkspace>>  m_vWorkspaces;
     std::vector<std::unique_ptr<SSubsurface>> m_vSubsurfaces;
     std::vector<CWindow*>                     m_vWindowsFadingOut;
     std::vector<SLayerSurface*>               m_vSurfacesFadingOut;
 
+    void                                      initServer();
     void                                      startCompositor();
     void                                      cleanup();
 
@@ -96,6 +106,8 @@ class CCompositor {
     CWindow*                                  m_pLastWindow  = nullptr;
     CMonitor*                                 m_pLastMonitor = nullptr;
 
+    std::vector<CWindow*>                     m_vWindowFocusHistory; // first element is the most recently focused.
+
     SSeat                                     m_sSeat;
 
     bool                                      m_bReadyToProcess = false;
@@ -103,7 +115,6 @@ class CCompositor {
     bool                                      m_bDPMSStateON    = true;
     bool                                      m_bUnsafeState    = false; // unsafe state is when there is no monitors.
     bool                                      m_bIsShuttingDown = false;
-    std::deque<uint64_t>                      m_dProcessPIDsOnShutdown; // stores PIDs of apps to kill later when shutting down
 
     // ------------------------------------------------- //
 
@@ -135,6 +146,8 @@ class CCompositor {
     void           sanityCheckWorkspaces();
     void           updateWorkspaceWindowDecos(const int&);
     int            getWindowsOnWorkspace(const int&);
+    CWindow*       getUrgentWindow();
+    bool           hasUrgentWindowOnWorkspace(const int&);
     CWindow*       getFirstWindowOnWorkspace(const int&);
     CWindow*       getFullscreenWindowOnWorkspace(const int&);
     bool           doesSeatAcceptInput(wlr_surface*);
@@ -157,13 +170,12 @@ class CCompositor {
     CMonitor*      getMonitorFromString(const std::string&);
     bool           workspaceIDOutOfBounds(const int&);
     void           setWindowFullscreen(CWindow*, bool, eFullscreenMode);
-    void           moveUnmanagedX11ToWindows(CWindow*);
     CWindow*       getX11Parent(CWindow*);
     void           scheduleFrameForMonitor(CMonitor*);
     void           addToFadingOutSafe(SLayerSurface*);
     void           addToFadingOutSafe(CWindow*);
     CWindow*       getWindowByRegex(const std::string&);
-    void           warpCursorTo(const Vector2D&);
+    void           warpCursorTo(const Vector2D&, bool force = false);
     SLayerSurface* getLayerSurfaceFromWlr(wlr_layer_surface_v1*);
     SLayerSurface* getLayerSurfaceFromSurface(wlr_surface*);
     void           closeWindow(CWindow*);
@@ -171,15 +183,18 @@ class CCompositor {
     void           forceReportSizesToWindowsOnWorkspace(const int&);
     bool           cursorOnReservedArea();
     CWorkspace*    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();
 
     std::string    explicitConfigPath;
 
   private:
     void     initAllSignals();
     void     setRandomSplash();
+    void     initManagers(eManagersInitStage stage);
 
     uint64_t m_iHyprlandPID = 0;
 };

src/SharedDefs.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+enum eIcons
+{
+    ICON_WARNING = 0,
+    ICON_INFO,
+    ICON_HINT,
+    ICON_ERROR,
+    ICON_CONFUSED,
+    ICON_OK,
+    ICON_NONE
+};

src/Window.cpp

@@ -5,7 +5,8 @@
 CWindow::CWindow() {
     m_vRealPosition.create(AVARTYPE_VECTOR, g_pConfigManager->getAnimationPropertyConfig("windowsIn"), (void*)this, AVARDAMAGE_ENTIRE);
     m_vRealSize.create(AVARTYPE_VECTOR, g_pConfigManager->getAnimationPropertyConfig("windowsIn"), (void*)this, AVARDAMAGE_ENTIRE);
-    m_fBorderAnimationProgress.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("border"), (void*)this, AVARDAMAGE_BORDER);
+    m_fBorderFadeAnimationProgress.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("border"), (void*)this, AVARDAMAGE_BORDER);
+    m_fBorderAngleAnimationProgress.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("borderangle"), (void*)this, AVARDAMAGE_BORDER);
     m_fAlpha.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), (void*)this, AVARDAMAGE_ENTIRE);
     m_fActiveInactiveAlpha.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("fadeSwitch"), (void*)this, AVARDAMAGE_ENTIRE);
     m_cRealShadowColor.create(AVARTYPE_COLOR, g_pConfigManager->getAnimationPropertyConfig("fadeShadow"), (void*)this, AVARDAMAGE_SHADOW);
@@ -87,6 +88,59 @@ wlr_box CWindow::getWindowIdealBoundingBoxIgnoreReserved() {
     return wlr_box{(int)POS.x, (int)POS.y, (int)SIZE.x, (int)SIZE.y};
 }
 
+wlr_box CWindow::getWindowInputBox() {
+    static auto* const PBORDERSIZE = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
+
+    if (m_sAdditionalConfigData.dimAround) {
+        const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+        return {PMONITOR->vecPosition.x, PMONITOR->vecPosition.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y};
+    }
+
+    SWindowDecorationExtents maxExtents = {{*PBORDERSIZE + 2, *PBORDERSIZE + 2}, {*PBORDERSIZE + 2, *PBORDERSIZE + 2}};
+
+    for (auto& wd : m_dWindowDecorations) {
+
+        if (!wd->allowsInput())
+            continue;
+
+        const auto EXTENTS = wd->getWindowDecorationExtents();
+
+        if (EXTENTS.topLeft.x > maxExtents.topLeft.x)
+            maxExtents.topLeft.x = EXTENTS.topLeft.x;
+
+        if (EXTENTS.topLeft.y > maxExtents.topLeft.y)
+            maxExtents.topLeft.y = EXTENTS.topLeft.y;
+
+        if (EXTENTS.bottomRight.x > maxExtents.bottomRight.x)
+            maxExtents.bottomRight.x = EXTENTS.bottomRight.x;
+
+        if (EXTENTS.bottomRight.y > maxExtents.bottomRight.y)
+            maxExtents.bottomRight.y = EXTENTS.bottomRight.y;
+    }
+
+    // Add extents to the real base BB and return
+    wlr_box finalBox = {m_vRealPosition.vec().x - maxExtents.topLeft.x, m_vRealPosition.vec().y - maxExtents.topLeft.y,
+                        m_vRealSize.vec().x + maxExtents.topLeft.x + maxExtents.bottomRight.x, m_vRealSize.vec().y + maxExtents.topLeft.y + maxExtents.bottomRight.y};
+
+    return finalBox;
+}
+
+SWindowDecorationExtents CWindow::getFullWindowReservedArea() {
+    SWindowDecorationExtents extents;
+
+    for (auto& wd : m_dWindowDecorations) {
+        const auto RESERVED = wd->getWindowDecorationReservedArea();
+
+        if (RESERVED.bottomRight == Vector2D{} && RESERVED.topLeft == Vector2D{})
+            continue;
+
+        extents.topLeft     = extents.topLeft + RESERVED.topLeft;
+        extents.bottomRight = extents.bottomRight + RESERVED.bottomRight;
+    }
+
+    return extents;
+}
+
 void CWindow::updateWindowDecos() {
     for (auto& wd : m_dWindowDecorations)
         wd->updateWindow(this);
@@ -107,6 +161,10 @@ void CWindow::updateWindowDecos() {
 pid_t CWindow::getPID() {
     pid_t PID = -1;
     if (!m_bIsX11) {
+
+        if (!m_bIsMapped)
+            return -1;
+
         wl_client_get_credentials(wl_resource_get_client(m_uSurface.xdg->resource), &PID, nullptr, nullptr);
     } else {
         PID = m_uSurface.xwayland->pid;
@@ -207,19 +265,32 @@ void CWindow::updateSurfaceOutputs() {
     const auto PNEWMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
 
     if (PLASTMONITOR && PLASTMONITOR->m_bEnabled)
-        wlr_surface_for_each_surface(g_pXWaylandManager->getWindowSurface(this), sendLeaveIter, PLASTMONITOR->output);
+        wlr_surface_for_each_surface(m_pWLSurface.wlr(), sendLeaveIter, PLASTMONITOR->output);
 
-    wlr_surface_for_each_surface(g_pXWaylandManager->getWindowSurface(this), sendEnterIter, PNEWMONITOR->output);
+    wlr_surface_for_each_surface(m_pWLSurface.wlr(), sendEnterIter, PNEWMONITOR->output);
 }
 
 void CWindow::moveToWorkspace(int workspaceID) {
-    if (m_iWorkspaceID != workspaceID) {
-        m_iWorkspaceID = workspaceID;
+    if (m_iWorkspaceID == workspaceID)
+        return;
 
-        if (const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(m_iWorkspaceID); PWORKSPACE) {
-            g_pEventManager->postEvent(SHyprIPCEvent{"movewindow", getFormat("%x,%s", this, PWORKSPACE->m_szName.c_str())});
-        }
+    m_iWorkspaceID = workspaceID;
+
+    const auto PMONITOR   = g_pCompositor->getMonitorFromID(m_iMonitorID);
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(m_iWorkspaceID);
+
+    if (PWORKSPACE) {
+        g_pEventManager->postEvent(SHyprIPCEvent{"movewindow", getFormat("%x,%s", this, PWORKSPACE->m_szName.c_str())});
+        EMIT_HOOK_EVENT("moveWindow", (std::vector<void*>{this, PWORKSPACE}));
     }
+
+    if (m_pSwallowed) {
+        m_pSwallowed->moveToWorkspace(workspaceID);
+        m_pSwallowed->m_iMonitorID = m_iMonitorID;
+    }
+
+    if (PMONITOR)
+        g_pProtocolManager->m_pFractionalScaleProtocolManager->setPreferredScaleForSurface(m_pWLSurface.wlr(), PMONITOR->scale);
 }
 
 CWindow* CWindow::X11TransientFor() {
@@ -260,21 +331,31 @@ void CWindow::onUnmap() {
 
     m_vRealPosition.setCallbackOnEnd(unregisterVar);
     m_vRealSize.setCallbackOnEnd(unregisterVar);
-    m_fBorderAnimationProgress.setCallbackOnEnd(unregisterVar);
+    m_fBorderFadeAnimationProgress.setCallbackOnEnd(unregisterVar);
+    m_fBorderAngleAnimationProgress.setCallbackOnEnd(unregisterVar);
     m_fActiveInactiveAlpha.setCallbackOnEnd(unregisterVar);
     m_fAlpha.setCallbackOnEnd(unregisterVar);
     m_cRealShadowColor.setCallbackOnEnd(unregisterVar);
     m_fDimPercent.setCallbackOnEnd(unregisterVar);
 
     m_vRealSize.setCallbackOnBegin(nullptr);
+
+    std::erase_if(g_pCompositor->m_vWindowFocusHistory, [&](const auto& other) { return other == this; });
+
+    m_pWLSurface.unassign();
+
+    hyprListener_unmapWindow.removeCallback();
 }
 
 void CWindow::onMap() {
 
+    m_pWLSurface.assign(g_pXWaylandManager->getWindowSurface(this));
+
     // JIC, reset the callbacks. If any are set, we'll make sure they are cleared so we don't accidentally unset them. (In case a window got remapped)
     m_vRealPosition.resetAllCallbacks();
     m_vRealSize.resetAllCallbacks();
-    m_fBorderAnimationProgress.resetAllCallbacks();
+    m_fBorderFadeAnimationProgress.resetAllCallbacks();
+    m_fBorderAngleAnimationProgress.resetAllCallbacks();
     m_fActiveInactiveAlpha.resetAllCallbacks();
     m_fAlpha.resetAllCallbacks();
     m_cRealShadowColor.resetAllCallbacks();
@@ -282,14 +363,37 @@ void CWindow::onMap() {
 
     m_vRealPosition.registerVar();
     m_vRealSize.registerVar();
-    m_fBorderAnimationProgress.registerVar();
+    m_fBorderFadeAnimationProgress.registerVar();
+    m_fBorderAngleAnimationProgress.registerVar();
     m_fActiveInactiveAlpha.registerVar();
     m_fAlpha.registerVar();
     m_cRealShadowColor.registerVar();
     m_fDimPercent.registerVar();
 
-    m_vRealSize.setCallbackOnEnd([&](void* ptr) { g_pHyprOpenGL->onWindowResizeEnd(this); }, false);
-    m_vRealSize.setCallbackOnBegin([&](void* ptr) { g_pHyprOpenGL->onWindowResizeStart(this); }, false);
+    m_fBorderAngleAnimationProgress.setCallbackOnEnd([&](void* ptr) { onBorderAngleAnimEnd(ptr); }, false);
+
+    m_fBorderAngleAnimationProgress.setValueAndWarp(0.f);
+    m_fBorderAngleAnimationProgress = 1.f;
+
+    g_pCompositor->m_vWindowFocusHistory.push_back(this);
+
+    hyprListener_unmapWindow.initCallback(m_bIsX11 ? &m_uSurface.xwayland->events.unmap : &m_uSurface.xdg->events.unmap, &Events::listener_unmapWindow, this, "CWindow");
+}
+
+void CWindow::onBorderAngleAnimEnd(void* ptr) {
+    const auto        PANIMVAR = (CAnimatedVariable*)ptr;
+
+    const std::string STYLE = PANIMVAR->getConfig()->pValues->internalStyle;
+
+    if (STYLE != "loop" || !PANIMVAR->getConfig()->pValues->internalEnabled)
+        return;
+
+    PANIMVAR->setCallbackOnEnd(nullptr); // we remove the callback here because otherwise setvalueandwarp will recurse this
+
+    PANIMVAR->setValueAndWarp(0);
+    *PANIMVAR = 1.f;
+
+    PANIMVAR->setCallbackOnEnd([&](void* ptr) { onBorderAngleAnimEnd(ptr); }, false);
 }
 
 void CWindow::setHidden(bool hidden) {
@@ -311,8 +415,10 @@ void CWindow::applyDynamicRule(const SWindowRule& r) {
         m_sAdditionalConfigData.forceNoBorder = true;
     } else if (r.szRule == "noshadow") {
         m_sAdditionalConfigData.forceNoShadow = true;
+    } else if (r.szRule == "forcergbx") {
+        m_sAdditionalConfigData.forceRGBX = true;
     } else if (r.szRule == "opaque") {
-        if (!m_sAdditionalConfigData.forceOpaqueOverriden)
+        if (!m_sAdditionalConfigData.forceOpaqueOverridden)
             m_sAdditionalConfigData.forceOpaque = true;
     } else if (r.szRule.find("rounding") == 0) {
         try {
@@ -369,15 +475,181 @@ void CWindow::updateDynamicRules() {
     m_sAdditionalConfigData.forceNoBlur      = false;
     m_sAdditionalConfigData.forceNoBorder    = false;
     m_sAdditionalConfigData.forceNoShadow    = false;
-    if (!m_sAdditionalConfigData.forceOpaqueOverriden)
+    if (!m_sAdditionalConfigData.forceOpaqueOverridden)
         m_sAdditionalConfigData.forceOpaque = false;
     m_sAdditionalConfigData.forceNoAnims   = false;
-    m_sAdditionalConfigData.animationStyle = "";
+    m_sAdditionalConfigData.animationStyle = std::string("");
     m_sAdditionalConfigData.rounding       = -1;
     m_sAdditionalConfigData.dimAround      = false;
+    m_sAdditionalConfigData.forceRGBX      = false;
 
     const auto WINDOWRULES = g_pConfigManager->getMatchingRules(this);
     for (auto& r : WINDOWRULES) {
         applyDynamicRule(r);
     }
 }
+
+// check if the point is "hidden" under a rounded corner of the window
+// it is assumed that the point is within the real window box (m_vRealPosition, m_vRealSize)
+// otherwise behaviour is undefined
+bool CWindow::isInCurvedCorner(double x, double y) {
+    static auto* const ROUNDING   = &g_pConfigManager->getConfigValuePtr("decoration:rounding")->intValue;
+    static auto* const BORDERSIZE = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
+
+    if (BORDERSIZE >= ROUNDING || ROUNDING == 0)
+        return false;
+
+    // (x0, y0), (x0, y1), ... are the center point of rounding at each corner
+    double x0 = m_vRealPosition.vec().x + *ROUNDING;
+    double y0 = m_vRealPosition.vec().y + *ROUNDING;
+    double x1 = m_vRealPosition.vec().x + m_vRealSize.vec().x - *ROUNDING;
+    double y1 = m_vRealPosition.vec().y + m_vRealSize.vec().y - *ROUNDING;
+
+    if (x < x0 && y < y0) {
+        return Vector2D{x0, y0}.distance(Vector2D{x, y}) > (double)*ROUNDING;
+    }
+    if (x > x1 && y < y0) {
+        return Vector2D{x1, y0}.distance(Vector2D{x, y}) > (double)*ROUNDING;
+    }
+    if (x < x0 && y > y1) {
+        return Vector2D{x0, y1}.distance(Vector2D{x, y}) > (double)*ROUNDING;
+    }
+    if (x > x1 && y > y1) {
+        return Vector2D{x1, y1}.distance(Vector2D{x, y}) > (double)*ROUNDING;
+    }
+
+    return false;
+}
+
+void findExtensionForVector2D(wlr_surface* surface, int x, int y, void* data) {
+    const auto DATA = (SExtensionFindingData*)data;
+
+    wlr_box    box = {DATA->origin.x + x, DATA->origin.y + y, surface->current.width, surface->current.height};
+
+    if (wlr_box_contains_point(&box, DATA->vec.x, DATA->vec.y))
+        *DATA->found = surface;
+}
+
+// checks if the wayland window has a popup at pos
+bool CWindow::hasPopupAt(const Vector2D& pos) {
+    if (m_bIsX11)
+        return false;
+
+    wlr_surface*          resultSurf = nullptr;
+    Vector2D              origin     = m_vRealPosition.vec();
+    SExtensionFindingData data       = {origin, pos, &resultSurf};
+    wlr_xdg_surface_for_each_popup_surface(m_uSurface.xdg, findExtensionForVector2D, &data);
+
+    return resultSurf;
+}
+
+CWindow* CWindow::getGroupHead() {
+    CWindow* curr = this;
+    while (!curr->m_sGroupData.head)
+        curr = curr->m_sGroupData.pNextWindow;
+    return curr;
+}
+
+CWindow* CWindow::getGroupTail() {
+    CWindow* curr = this;
+    while (!curr->m_sGroupData.pNextWindow->m_sGroupData.head)
+        curr = curr->m_sGroupData.pNextWindow;
+    return curr;
+}
+
+CWindow* CWindow::getGroupCurrent() {
+    CWindow* curr = this;
+    while (curr->isHidden())
+        curr = curr->m_sGroupData.pNextWindow;
+    return curr;
+}
+
+void CWindow::setGroupCurrent(CWindow* pWindow) {
+    CWindow* curr     = this->m_sGroupData.pNextWindow;
+    bool     isMember = false;
+    while (curr != this) {
+        if (curr == pWindow) {
+            isMember = true;
+            break;
+        }
+        curr = curr->m_sGroupData.pNextWindow;
+    }
+
+    if (!isMember && pWindow != this)
+        return;
+
+    const auto PCURRENT   = getGroupCurrent();
+    const bool FULLSCREEN = PCURRENT->m_bIsFullscreen;
+    const auto WORKSPACE  = g_pCompositor->getWorkspaceByID(PCURRENT->m_iWorkspaceID);
+
+    const auto PWINDOWSIZE = PCURRENT->m_vRealSize.goalv();
+    const auto PWINDOWPOS  = PCURRENT->m_vRealPosition.goalv();
+
+    const auto CURRENTISFOCUS = PCURRENT == g_pCompositor->m_pLastWindow;
+
+    if (FULLSCREEN)
+        g_pCompositor->setWindowFullscreen(PCURRENT, false, WORKSPACE->m_efFullscreenMode);
+
+    PCURRENT->setHidden(true);
+    pWindow->setHidden(false);
+
+    g_pLayoutManager->getCurrentLayout()->replaceWindowDataWith(PCURRENT, pWindow);
+
+    if (PCURRENT->m_bIsFloating) {
+        pWindow->m_vRealPosition.setValueAndWarp(PWINDOWPOS);
+        pWindow->m_vRealSize.setValueAndWarp(PWINDOWSIZE);
+    }
+
+    g_pCompositor->updateAllWindowsAnimatedDecorationValues();
+
+    if (CURRENTISFOCUS)
+        g_pCompositor->focusWindow(pWindow);
+
+    if (FULLSCREEN)
+        g_pCompositor->setWindowFullscreen(pWindow, true, WORKSPACE->m_efFullscreenMode);
+}
+
+void CWindow::insertWindowToGroup(CWindow* pWindow) {
+    const auto PHEAD = getGroupHead();
+    const auto PTAIL = getGroupTail();
+
+    if (pWindow->m_sGroupData.pNextWindow) {
+        std::vector<CWindow*> members;
+        CWindow*              curr = pWindow;
+        do {
+            const auto PLAST = curr;
+            members.push_back(curr);
+            curr                            = curr->m_sGroupData.pNextWindow;
+            PLAST->m_sGroupData.pNextWindow = nullptr;
+            PLAST->m_sGroupData.head        = false;
+        } while (curr != pWindow);
+
+        for (auto& w : members) {
+            insertWindowToGroup(w);
+        }
+
+        return;
+    }
+
+    PTAIL->m_sGroupData.pNextWindow   = pWindow;
+    pWindow->m_sGroupData.pNextWindow = PHEAD;
+
+    setGroupCurrent(pWindow);
+}
+
+void CWindow::updateGroupOutputs() {
+    if (!m_sGroupData.pNextWindow)
+        return;
+
+    CWindow* curr = m_sGroupData.pNextWindow;
+
+    while (curr != this) {
+        curr->m_iMonitorID = m_iMonitorID;
+        curr->moveToWorkspace(m_iWorkspaceID);
+
+        curr->m_vRealPosition = m_vRealPosition.goalv();
+        curr->m_vRealSize     = m_vRealSize.goalv();
+
+        curr = curr->m_sGroupData.pNextWindow;
+    }
+}

src/Window.hpp

@@ -7,22 +7,98 @@
 #include "render/decorations/IHyprWindowDecoration.hpp"
 #include <deque>
 #include "config/ConfigDataValues.hpp"
+#include "helpers/Vector2D.hpp"
+#include "helpers/WLSurface.hpp"
 
-enum eIdleInhibitMode {
+enum eIdleInhibitMode
+{
     IDLEINHIBIT_NONE = 0,
     IDLEINHIBIT_ALWAYS,
     IDLEINHIBIT_FULLSCREEN,
     IDLEINHIBIT_FOCUS
 };
 
-struct SWindowSpecialRenderData {
-    bool    alphaOverride         = false;
-    float   alpha                 = 1.f;
-    bool    alphaInactiveOverride = false;
-    float   alphaInactive         = -1.f; // -1 means unset
+template <typename T>
+class CWindowOverridableVar {
+  public:
+    CWindowOverridableVar(T val) {
+        value = val;
+    }
 
-    int64_t activeBorderColor   = -1; // -1 means unset
-    int64_t inactiveBorderColor = -1; // -1 means unset
+    ~CWindowOverridableVar() = default;
+
+    CWindowOverridableVar<T>& operator=(CWindowOverridableVar<T> other) {
+        if (locked)
+            return *this;
+
+        locked = other.locked;
+        value  = other.value;
+
+        return *this;
+    }
+
+    T operator=(T& other) {
+        if (locked)
+            return value;
+        value = other;
+        return other;
+    }
+
+    void forceSetIgnoreLocked(T val, bool lock = false) {
+        value  = val;
+        locked = lock;
+    }
+
+    T operator*(T& other) {
+        return value * other;
+    }
+
+    T operator+(T& other) {
+        return value + other;
+    }
+
+    bool operator==(T& other) {
+        return other == value;
+    }
+
+    bool operator>=(T& other) {
+        return value >= other;
+    }
+
+    bool operator<=(T& other) {
+        return value <= other;
+    }
+
+    bool operator>(T& other) {
+        return value > other;
+    }
+
+    bool operator<(T& other) {
+        return value < other;
+    }
+
+    explicit operator bool() {
+        return static_cast<bool>(value);
+    }
+
+    T toUnderlying() {
+        return value;
+    }
+
+    bool locked = false;
+
+  private:
+    T value;
+};
+
+struct SWindowSpecialRenderData {
+    CWindowOverridableVar<bool>    alphaOverride         = false;
+    CWindowOverridableVar<float>   alpha                 = 1.f;
+    CWindowOverridableVar<bool>    alphaInactiveOverride = false;
+    CWindowOverridableVar<float>   alphaInactive         = -1.f; // -1 means unset
+
+    CWindowOverridableVar<int64_t> activeBorderColor   = -1; // -1 means unset
+    CWindowOverridableVar<int64_t> inactiveBorderColor = -1; // -1 means unset
 
     // set by the layout
     bool rounding = true;
@@ -31,18 +107,19 @@ struct SWindowSpecialRenderData {
 };
 
 struct SWindowAdditionalConfigData {
-    std::string animationStyle       = "";
-    int         rounding             = -1; // -1 means no
-    bool        forceNoBlur          = false;
-    bool        forceOpaque          = false;
-    bool        forceOpaqueOverriden = false; // if true, a rule will not change the forceOpaque state. This is for the force opaque dispatcher.
-    bool        forceAllowsInput     = false;
-    bool        forceNoAnims         = false;
-    bool        forceNoBorder        = false;
-    bool        forceNoShadow        = false;
-    bool        windowDanceCompat    = false;
-    bool        noMaxSize            = false;
-    bool        dimAround            = false;
+    std::string                 animationStyle        = std::string("");
+    CWindowOverridableVar<int>  rounding              = -1; // -1 means no
+    CWindowOverridableVar<bool> forceNoBlur           = false;
+    CWindowOverridableVar<bool> forceOpaque           = false;
+    CWindowOverridableVar<bool> forceOpaqueOverridden = false; // if true, a rule will not change the forceOpaque state. This is for the force opaque dispatcher.
+    CWindowOverridableVar<bool> forceAllowsInput      = false;
+    CWindowOverridableVar<bool> forceNoAnims          = false;
+    CWindowOverridableVar<bool> forceNoBorder         = false;
+    CWindowOverridableVar<bool> forceNoShadow         = false;
+    CWindowOverridableVar<bool> windowDanceCompat     = false;
+    CWindowOverridableVar<bool> noMaxSize             = false;
+    CWindowOverridableVar<bool> dimAround             = false;
+    CWindowOverridableVar<bool> forceRGBX             = false;
 };
 
 struct SWindowRule {
@@ -80,8 +157,12 @@ class CWindow {
     DYNLISTENER(toplevelClose);
     DYNLISTENER(toplevelActivate);
     DYNLISTENER(toplevelFullscreen);
+    DYNLISTENER(setOverrideRedirect);
     // DYNLISTENER(newSubsurfaceWindow);
 
+    CWLSurface            m_pWLSurface;
+    std::list<CWLSurface> m_lPopupSurfaces;
+
     union {
         wlr_xdg_surface*      xdg;
         wlr_xwayland_surface* xwayland;
@@ -111,8 +192,11 @@ class CWindow {
     bool        m_bIsFloating    = false;
     bool        m_bDraggingTiled = false; // for dragging around tiled windows
     bool        m_bIsFullscreen  = false;
+    bool        m_bWasMaximized  = false;
     uint64_t    m_iMonitorID     = -1;
     std::string m_szTitle        = "";
+    std::string m_szInitialTitle = "";
+    std::string m_szInitialClass = "";
     int         m_iWorkspaceID   = -1;
 
     bool        m_bIsMapped = false;
@@ -145,7 +229,8 @@ class CWindow {
     // Animated border
     CGradientValueData m_cRealBorderColor         = {0};
     CGradientValueData m_cRealBorderColorPrevious = {0};
-    CAnimatedVariable  m_fBorderAnimationProgress;
+    CAnimatedVariable  m_fBorderFadeAnimationProgress;
+    CAnimatedVariable  m_fBorderAngleAnimationProgress;
 
     // Fade in-out
     CAnimatedVariable m_fAlpha;
@@ -157,8 +242,11 @@ class CWindow {
     // For pinned (sticky) windows
     bool m_bPinned = false;
 
+    // urgency hint
+    bool m_bIsUrgent = false;
+
     // fakefullscreen
-    bool m_bInFullscreenReported = false;
+    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;
@@ -193,6 +281,12 @@ class CWindow {
     // for idle inhibiting windows
     eIdleInhibitMode m_eIdleInhibitMode = IDLEINHIBIT_NONE;
 
+    // for groups
+    struct SGroupData {
+        CWindow* pNextWindow = nullptr; // nullptr means no grouping. Self means single group.
+        bool     head        = false;
+    } m_sGroupData;
+
     // 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 &&
@@ -200,24 +294,37 @@ class CWindow {
     }
 
     // methods
-    wlr_box                getFullWindowBoundingBox();
-    wlr_box                getWindowIdealBoundingBoxIgnoreReserved();
-    void                   updateWindowDecos();
-    pid_t                  getPID();
-    IHyprWindowDecoration* getDecorationByType(eDecorationType);
-    void                   removeDecorationByType(eDecorationType);
-    void                   createToplevelHandle();
-    void                   destroyToplevelHandle();
-    void                   updateToplevel();
-    void                   updateSurfaceOutputs();
-    void                   moveToWorkspace(int);
-    CWindow*               X11TransientFor();
-    void                   onUnmap();
-    void                   onMap();
-    void                   setHidden(bool hidden);
-    bool                   isHidden();
-    void                   applyDynamicRule(const SWindowRule& r);
-    void                   updateDynamicRules();
+    wlr_box                  getFullWindowBoundingBox();
+    wlr_box                  getWindowInputBox();
+    wlr_box                  getWindowIdealBoundingBoxIgnoreReserved();
+    void                     updateWindowDecos();
+    pid_t                    getPID();
+    IHyprWindowDecoration*   getDecorationByType(eDecorationType);
+    void                     removeDecorationByType(eDecorationType);
+    void                     createToplevelHandle();
+    void                     destroyToplevelHandle();
+    void                     updateToplevel();
+    void                     updateSurfaceOutputs();
+    void                     moveToWorkspace(int);
+    CWindow*                 X11TransientFor();
+    void                     onUnmap();
+    void                     onMap();
+    void                     setHidden(bool hidden);
+    bool                     isHidden();
+    void                     applyDynamicRule(const SWindowRule& r);
+    void                     updateDynamicRules();
+    SWindowDecorationExtents getFullWindowReservedArea();
+
+    void                     onBorderAngleAnimEnd(void* ptr);
+    bool                     isInCurvedCorner(double x, double y);
+    bool                     hasPopupAt(const Vector2D& pos);
+
+    CWindow*                 getGroupHead();
+    CWindow*                 getGroupTail();
+    CWindow*                 getGroupCurrent();
+    void                     setGroupCurrent(CWindow* pWindow);
+    void                     insertWindowToGroup(CWindow* pWindow);
+    void                     updateGroupOutputs();
 
   private:
     // For hidden windows and stuff

src/config/ConfigDataValues.hpp

@@ -2,7 +2,8 @@
 #include "../defines.hpp"
 #include <vector>
 
-enum eConfigValueDataTypes {
+enum eConfigValueDataTypes
+{
     CVD_TYPE_INVALID  = -1,
     CVD_TYPE_GRADIENT = 0
 };
@@ -38,7 +39,7 @@ class CGradientValueData : public ICustomConfigValueData {
     float m_fAngle = 0;
 
     bool  operator==(const CGradientValueData& other) {
-         if (other.m_vColors.size() != m_vColors.size() || m_fAngle != other.m_fAngle)
+        if (other.m_vColors.size() != m_vColors.size() || m_fAngle != other.m_fAngle)
             return false;
 
         for (size_t i = 0; i < m_vColors.size(); ++i)
@@ -47,4 +48,4 @@ class CGradientValueData : public ICustomConfigValueData {
 
         return true;
     }
-};
+};

src/config/ConfigManager.cpp

@@ -10,11 +10,13 @@
 #include <fstream>
 #include <iostream>
 
+extern "C" char** environ;
+
 CConfigManager::CConfigManager() {
     configValues["general:col.active_border"].data       = std::make_shared<CGradientValueData>(0xffffffff);
     configValues["general:col.inactive_border"].data     = std::make_shared<CGradientValueData>(0xff444444);
-    configValues["dwindle:col.group_border"].data        = std::make_shared<CGradientValueData>(0x66777700);
-    configValues["dwindle:col.group_border_active"].data = std::make_shared<CGradientValueData>(0x66ffff00);
+    configValues["general:col.group_border"].data        = std::make_shared<CGradientValueData>(0x66777700);
+    configValues["general:col.group_border_active"].data = std::make_shared<CGradientValueData>(0x66ffff00);
 
     setDefaultVars();
     setDefaultAnimationVars();
@@ -31,44 +33,71 @@ CConfigManager::CConfigManager() {
 
     Debug::disableLogs = &configValues["debug:disable_logs"].intValue;
     Debug::disableTime = &configValues["debug:disable_time"].intValue;
+
+    populateEnvironment();
+}
+
+void CConfigManager::populateEnvironment() {
+    environmentVariables.clear();
+    for (char** env = environ; *env; ++env) {
+        const std::string ENVVAR   = *env;
+        const auto        VARIABLE = ENVVAR.substr(0, ENVVAR.find_first_of('='));
+        const auto        VALUE    = ENVVAR.substr(ENVVAR.find_first_of('=') + 1);
+        environmentVariables.emplace_back(std::make_pair<>(VARIABLE, VALUE));
+    }
+
+    std::sort(environmentVariables.begin(), environmentVariables.end(), [&](const auto& a, const auto& b) { return a.first.length() > b.first.length(); });
 }
 
 void CConfigManager::setDefaultVars() {
-    configValues["general:max_fps"].intValue           = 60;
-    configValues["general:sensitivity"].floatValue     = 1.0f;
-    configValues["general:apply_sens_to_raw"].intValue = 0;
-
+    configValues["general:max_fps"].intValue               = 60;
+    configValues["general:sensitivity"].floatValue         = 1.0f;
+    configValues["general:apply_sens_to_raw"].intValue     = 0;
     configValues["general:border_size"].intValue           = 1;
     configValues["general:no_border_on_floating"].intValue = 0;
     configValues["general:gaps_in"].intValue               = 5;
     configValues["general:gaps_out"].intValue              = 20;
     ((CGradientValueData*)configValues["general:col.active_border"].data.get())->reset(0xffffffff);
     ((CGradientValueData*)configValues["general:col.inactive_border"].data.get())->reset(0xff444444);
+    ((CGradientValueData*)configValues["general:col.group_border"].data.get())->reset(0x66777700);
+    ((CGradientValueData*)configValues["general:col.group_border_active"].data.get())->reset(0x66ffff00);
     configValues["general:cursor_inactive_timeout"].intValue = 0;
     configValues["general:no_cursor_warps"].intValue         = 0;
+    configValues["general:resize_on_border"].intValue        = 0;
+    configValues["general:extend_border_grab_area"].intValue = 15;
+    configValues["general:hover_icon_on_border"].intValue    = 1;
+    configValues["general:layout"].strValue                  = "dwindle";
 
-    configValues["general:layout"].strValue = "dwindle";
+    configValues["misc:disable_hyprland_logo"].intValue        = 0;
+    configValues["misc:disable_splash_rendering"].intValue     = 0;
+    configValues["misc:vfr"].intValue                          = 1;
+    configValues["misc:vrr"].intValue                          = 0;
+    configValues["misc:mouse_move_enables_dpms"].intValue      = 0;
+    configValues["misc:key_press_enables_dpms"].intValue       = 0;
+    configValues["misc:always_follow_on_dnd"].intValue         = 1;
+    configValues["misc:layers_hog_keyboard_focus"].intValue    = 1;
+    configValues["misc:animate_manual_resizes"].intValue       = 0;
+    configValues["misc:animate_mouse_windowdragging"].intValue = 0;
+    configValues["misc:disable_autoreload"].intValue           = 0;
+    configValues["misc:enable_swallow"].intValue               = 0;
+    configValues["misc:swallow_regex"].strValue                = STRVAL_EMPTY;
+    configValues["misc:focus_on_activate"].intValue            = 0;
+    configValues["misc:no_direct_scanout"].intValue            = 1;
+    configValues["misc:hide_cursor_on_touch"].intValue         = 1;
+    configValues["misc:mouse_move_focuses_monitor"].intValue   = 1;
+    configValues["misc:suppress_portal_warnings"].intValue     = 0;
+    configValues["misc:render_ahead_of_time"].intValue         = 0;
+    configValues["misc:render_ahead_safezone"].intValue        = 1;
 
-    configValues["misc:disable_hyprland_logo"].intValue     = 0;
-    configValues["misc:disable_splash_rendering"].intValue  = 0;
-    configValues["misc:no_vfr"].intValue                    = 1;
-    configValues["misc:mouse_move_enables_dpms"].intValue   = 0;
-    configValues["misc:always_follow_on_dnd"].intValue      = 1;
-    configValues["misc:layers_hog_keyboard_focus"].intValue = 1;
-    configValues["misc:animate_manual_resizes"].intValue    = 0;
-    configValues["misc:disable_autoreload"].intValue        = 0;
-    configValues["misc:enable_swallow"].intValue            = 0;
-    configValues["misc:swallow_regex"].strValue             = STRVAL_EMPTY;
-    configValues["misc:focus_on_activate"].intValue         = 0;
-    configValues["misc:no_direct_scanout"].intValue         = 0;
-
-    configValues["debug:int"].intValue             = 0;
-    configValues["debug:log_damage"].intValue      = 0;
-    configValues["debug:overlay"].intValue         = 0;
-    configValues["debug:damage_blink"].intValue    = 0;
-    configValues["debug:disable_logs"].intValue    = 0;
-    configValues["debug:disable_time"].intValue    = 1;
-    configValues["debug:damage_tracking"].intValue = DAMAGE_TRACKING_FULL;
+    configValues["debug:int"].intValue                = 0;
+    configValues["debug:log_damage"].intValue         = 0;
+    configValues["debug:overlay"].intValue            = 0;
+    configValues["debug:damage_blink"].intValue       = 0;
+    configValues["debug:disable_logs"].intValue       = 0;
+    configValues["debug:disable_time"].intValue       = 1;
+    configValues["debug:enable_stdout_logs"].intValue = 0;
+    configValues["debug:damage_tracking"].intValue    = DAMAGE_TRACKING_FULL;
+    configValues["debug:manual_crash"].intValue       = 0;
 
     configValues["decoration:rounding"].intValue               = 0;
     configValues["decoration:blur"].intValue                   = 1;
@@ -96,8 +125,6 @@ void CConfigManager::setDefaultVars() {
     configValues["decoration:dim_around"].floatValue           = 0.4f;
     configValues["decoration:screen_shader"].strValue          = STRVAL_EMPTY;
 
-    ((CGradientValueData*)configValues["dwindle:col.group_border"].data.get())->reset(0x66777700);
-    ((CGradientValueData*)configValues["dwindle:col.group_border_active"].data.get())->reset(0x66ffff00);
     configValues["dwindle:pseudotile"].intValue               = 0;
     configValues["dwindle:force_split"].intValue              = 0;
     configValues["dwindle:preserve_split"].intValue           = 0;
@@ -105,34 +132,20 @@ void CConfigManager::setDefaultVars() {
     configValues["dwindle:split_width_multiplier"].floatValue = 1.0f;
     configValues["dwindle:no_gaps_when_only"].intValue        = 0;
     configValues["dwindle:use_active_for_splits"].intValue    = 1;
+    configValues["dwindle:default_split_ratio"].floatValue    = 1.f;
 
     configValues["master:special_scale_factor"].floatValue = 0.8f;
+    configValues["master:mfact"].floatValue                = 0.55f;
     configValues["master:new_is_master"].intValue          = 1;
+    configValues["master:always_center_master"].intValue   = 0;
     configValues["master:new_on_top"].intValue             = 0;
     configValues["master:no_gaps_when_only"].intValue      = 0;
     configValues["master:orientation"].strValue            = "left";
     configValues["master:inherit_fullscreen"].intValue     = 1;
 
-    configValues["animations:enabled"].intValue            = 1;
-    configValues["animations:speed"].floatValue            = 7.f;
-    configValues["animations:curve"].strValue              = "default";
-    configValues["animations:windows_style"].strValue      = STRVAL_EMPTY;
-    configValues["animations:windows_curve"].strValue      = "[[f]]";
-    configValues["animations:windows_speed"].floatValue    = 0.f;
-    configValues["animations:windows"].intValue            = 1;
-    configValues["animations:borders_style"].strValue      = STRVAL_EMPTY;
-    configValues["animations:borders_curve"].strValue      = "[[f]]";
-    configValues["animations:borders_speed"].floatValue    = 0.f;
-    configValues["animations:borders"].intValue            = 1;
-    configValues["animations:fadein_style"].strValue       = STRVAL_EMPTY;
-    configValues["animations:fadein_curve"].strValue       = "[[f]]";
-    configValues["animations:fadein_speed"].floatValue     = 0.f;
-    configValues["animations:fadein"].intValue             = 1;
-    configValues["animations:workspaces_style"].strValue   = STRVAL_EMPTY;
-    configValues["animations:workspaces_curve"].strValue   = "[[f]]";
-    configValues["animations:workspaces_speed"].floatValue = 0.f;
-    configValues["animations:workspaces"].intValue         = 1;
+    configValues["animations:enabled"].intValue = 1;
 
+    configValues["input:follow_mouse"].intValue                     = 1;
     configValues["input:sensitivity"].floatValue                    = 0.f;
     configValues["input:accel_profile"].strValue                    = STRVAL_EMPTY;
     configValues["input:kb_file"].strValue                          = STRVAL_EMPTY;
@@ -153,6 +166,7 @@ void CConfigManager::setDefaultVars() {
     configValues["input:touchpad:natural_scroll"].intValue          = 0;
     configValues["input:touchpad:disable_while_typing"].intValue    = 1;
     configValues["input:touchpad:clickfinger_behavior"].intValue    = 0;
+    configValues["input:touchpad:tap_button_map"].strValue          = STRVAL_EMPTY;
     configValues["input:touchpad:middle_button_emulation"].intValue = 0;
     configValues["input:touchpad:tap-to-click"].intValue            = 1;
     configValues["input:touchpad:tap-and-drag"].intValue            = 1;
@@ -160,11 +174,14 @@ void CConfigManager::setDefaultVars() {
     configValues["input:touchpad:scroll_factor"].floatValue         = 1.f;
     configValues["input:touchdevice:transform"].intValue            = 0;
     configValues["input:touchdevice:output"].strValue               = STRVAL_EMPTY;
+    configValues["input:tablet:transform"].intValue                 = 0;
+    configValues["input:tablet:output"].strValue                    = STRVAL_EMPTY;
 
     configValues["binds:pass_mouse_when_bound"].intValue    = 0;
     configValues["binds:scroll_event_delay"].intValue       = 300;
     configValues["binds:workspace_back_and_forth"].intValue = 0;
     configValues["binds:allow_workspace_cycles"].intValue   = 0;
+    configValues["binds:focus_preferred_method"].intValue   = 0;
 
     configValues["gestures:workspace_swipe"].intValue                    = 0;
     configValues["gestures:workspace_swipe_fingers"].intValue            = 3;
@@ -176,8 +193,6 @@ void CConfigManager::setDefaultVars() {
     configValues["gestures:workspace_swipe_forever"].intValue            = 0;
     configValues["gestures:workspace_swipe_numbered"].intValue           = 0;
 
-    configValues["input:follow_mouse"].intValue = 1;
-
     configValues["autogenerated"].intValue = 0;
 }
 
@@ -195,6 +210,7 @@ void CConfigManager::setDeviceDefaultVars(const std::string& dev) {
     cfgValues["repeat_rate"].intValue             = 25;
     cfgValues["repeat_delay"].intValue            = 600;
     cfgValues["natural_scroll"].intValue          = 0;
+    cfgValues["tap_button_map"].strValue          = STRVAL_EMPTY;
     cfgValues["numlock_by_default"].intValue      = 0;
     cfgValues["disable_while_typing"].intValue    = 1;
     cfgValues["clickfinger_behavior"].intValue    = 0;
@@ -216,6 +232,7 @@ void CConfigManager::setDefaultAnimationVars() {
         INITANIMCFG("windows");
         INITANIMCFG("fade");
         INITANIMCFG("border");
+        INITANIMCFG("borderangle");
         INITANIMCFG("workspaces");
 
         // windows
@@ -242,6 +259,7 @@ void CConfigManager::setDefaultAnimationVars() {
     CREATEANIMCFG("windows", "global");
     CREATEANIMCFG("fade", "global");
     CREATEANIMCFG("border", "global");
+    CREATEANIMCFG("borderangle", "global");
     CREATEANIMCFG("workspaces", "global");
 
     CREATEANIMCFG("windowsIn", "windows");
@@ -278,11 +296,13 @@ void CConfigManager::init() {
 
 void CConfigManager::configSetValueSafe(const std::string& COMMAND, const std::string& VALUE) {
     if (configValues.find(COMMAND) == configValues.end()) {
-        if (COMMAND.find("device:") != 0 /* devices parsed later */) {
+        if (COMMAND.find("device:") != 0 /* devices parsed later */ && COMMAND.find("plugin:") != 0 /* plugins parsed later */) {
             if (COMMAND[0] == '$') {
                 // register a dynamic var
                 Debug::log(LOG, "Registered dynamic var \"%s\" -> %s", COMMAND.c_str(), VALUE.c_str());
-                configDynamicVars[COMMAND.substr(1)] = VALUE;
+                configDynamicVars.emplace_back(std::make_pair<>(COMMAND.substr(1), VALUE));
+
+                std::sort(configDynamicVars.begin(), configDynamicVars.end(), [&](const auto& a, const auto& b) { return a.first.length() > b.first.length(); });
             } else {
                 parseError = "Error setting value <" + VALUE + "> for field <" + COMMAND + ">: No such field.";
             }
@@ -313,6 +333,18 @@ void CConfigManager::configSetValueSafe(const std::string& COMMAND, const std::s
         }
 
         CONFIGENTRY = &it->second.at(CONFIGVAR);
+    } else if (COMMAND.find("plugin:") == 0) {
+        for (auto& [handle, pMap] : pluginConfigs) {
+            auto it = std::find_if(pMap->begin(), pMap->end(), [&](const auto& other) { return other.first == COMMAND; });
+            if (it == pMap->end()) {
+                continue; // May be in another plugin
+            }
+
+            CONFIGENTRY = &it->second;
+        }
+
+        if (!CONFIGENTRY)
+            return; // silent ignore
     } else {
         CONFIGENTRY = &configValues.at(COMMAND);
     }
@@ -443,6 +475,13 @@ void CConfigManager::handleMonitor(const std::string& command, const std::string
         if (ARGS[1] == "disable" || ARGS[1] == "disabled")
             newrule.disabled = true;
         else if (ARGS[1] == "transform") {
+            const auto TSF = std::stoi(ARGS[2]);
+            if (std::clamp(TSF, 0, 7) != TSF) {
+                Debug::log(ERR, "invalid transform %i in monitor", TSF);
+                parseError = "invalid transform";
+                return;
+            }
+
             wl_output_transform transform = (wl_output_transform)std::stoi(ARGS[2]);
 
             // overwrite if exists
@@ -524,6 +563,12 @@ void CConfigManager::handleMonitor(const std::string& command, const std::string
         } else if (ARGS[argno] == "bitdepth") {
             newrule.enable10bit = ARGS[argno + 1] == "10";
             argno++;
+        } else if (ARGS[argno] == "transform") {
+            newrule.transform = (wl_output_transform)std::stoi(ARGS[argno + 1]);
+            argno++;
+        } else if (ARGS[argno] == "workspace") {
+            m_mDefaultWorkspaces[newrule.name] = ARGS[argno + 1];
+            argno++;
         } else {
             Debug::log(ERR, "Config error: invalid monitor syntax");
             parseError = "invalid syntax at \"" + ARGS[argno] + "\"";
@@ -567,8 +612,8 @@ void CConfigManager::handleBezier(const std::string& command, const std::string&
 
 void CConfigManager::setAnimForChildren(SAnimationPropertyConfig* const ANIM) {
     for (auto& [name, anim] : animationConfig) {
-        if (anim.pParentAnimation == ANIM && !anim.overriden) {
-            // if a child isnt overriden, set the values of the parent
+        if (anim.pParentAnimation == ANIM && !anim.overridden) {
+            // if a child isnt overridden, set the values of the parent
             anim.pValues = ANIM->pValues;
 
             setAnimForChildren(&anim);
@@ -591,8 +636,8 @@ void CConfigManager::handleAnimation(const std::string& command, const std::stri
         return;
     }
 
-    PANIM->second.overriden = true;
-    PANIM->second.pValues   = &PANIM->second;
+    PANIM->second.overridden = true;
+    PANIM->second.pValues    = &PANIM->second;
 
     // on/off
     PANIM->second.internalEnabled = ARGS[1] == "1";
@@ -711,14 +756,11 @@ void CConfigManager::handleBind(const std::string& command, const std::string& v
         return;
     }
 
-    if (KEY == "exclam" || KEY == "asciicircum" || KEY == "at") { // just some
-        parseError = "Your config contains (probably) wrong keys. The SHIFT keysym behavior has changed after v0.10.3beta. Please consult the wiki (Advanced configuring -> binds)";
-        return;
-    }
-
     if (KEY != "") {
         if (isNumber(KEY) && std::stoi(KEY) > 9)
             g_pKeybindManager->addKeybind(SKeybind{"", std::stoi(KEY), MOD, HANDLER, COMMAND, locked, m_szCurrentSubmap, release, repeat, mouse});
+        else if (KEY.find("code:") == 0 && isNumber(KEY.substr(5)))
+            g_pKeybindManager->addKeybind(SKeybind{"", std::stoi(KEY.substr(5)), MOD, HANDLER, COMMAND, locked, m_szCurrentSubmap, release, repeat, mouse});
         else
             g_pKeybindManager->addKeybind(SKeybind{KEY, -1, MOD, HANDLER, COMMAND, locked, m_szCurrentSubmap, release, repeat, mouse});
     }
@@ -739,7 +781,11 @@ bool windowRuleValid(const std::string& RULE) {
              RULE.find("maxsize") != 0 && RULE.find("pseudo") != 0 && RULE.find("monitor") != 0 && RULE.find("idleinhibit") != 0 && RULE != "nofocus" && RULE != "noblur" &&
              RULE != "noshadow" && RULE != "noborder" && RULE != "center" && RULE != "opaque" && RULE != "forceinput" && RULE != "fullscreen" && RULE != "nofullscreenrequest" &&
              RULE != "nomaxsize" && RULE != "pin" && RULE != "noanim" && RULE != "dimaround" && RULE != "windowdance" && RULE != "maximize" && RULE.find("animation") != 0 &&
-             RULE.find("rounding") != 0 && RULE.find("workspace") != 0 && RULE.find("bordercolor") != 0);
+             RULE.find("rounding") != 0 && RULE.find("workspace") != 0 && RULE.find("bordercolor") != 0 && RULE != "forcergbx");
+}
+
+bool layerRuleValid(const std::string& RULE) {
+    return !(RULE != "noanim" && RULE != "blur" && RULE != "ignorezero");
 }
 
 void CConfigManager::handleWindowRule(const std::string& command, const std::string& value) {
@@ -766,6 +812,33 @@ void CConfigManager::handleWindowRule(const std::string& command, const std::str
     m_dWindowRules.push_back({RULE, VALUE});
 }
 
+void CConfigManager::handleLayerRule(const std::string& command, const std::string& value) {
+    const auto RULE  = removeBeginEndSpacesTabs(value.substr(0, value.find_first_of(',')));
+    const auto VALUE = removeBeginEndSpacesTabs(value.substr(value.find_first_of(',') + 1));
+
+    // check rule and value
+    if (RULE == "" || VALUE == "")
+        return;
+
+    if (RULE == "unset") {
+        std::erase_if(m_dLayerRules, [&](const SLayerRule& other) { return other.targetNamespace == VALUE; });
+        return;
+    }
+
+    if (!layerRuleValid(RULE)) {
+        Debug::log(ERR, "Invalid rule found: %s", RULE.c_str());
+        parseError = "Invalid rule found: " + RULE;
+        return;
+    }
+
+    m_dLayerRules.push_back({VALUE, RULE});
+
+    for (auto& m : g_pCompositor->m_vMonitors)
+        for (auto& lsl : m->m_aLayerSurfaceLayers)
+            for (auto& ls : lsl)
+                ls->applyRules();
+}
+
 void CConfigManager::handleWindowRuleV2(const std::string& command, const std::string& value) {
     const auto RULE  = value.substr(0, value.find_first_of(','));
     const auto VALUE = value.substr(value.find_first_of(',') + 1);
@@ -886,25 +959,43 @@ void CConfigManager::handleWindowRuleV2(const std::string& command, const std::s
     m_dWindowRules.push_back(rule);
 }
 
+void CConfigManager::updateBlurredLS(const std::string& name, const bool forceBlur) {
+    const bool  BYADDRESS = name.find("address:") == 0;
+    std::string matchName = name;
+
+    if (BYADDRESS) {
+        matchName = matchName.substr(8);
+    }
+
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        for (auto& lsl : m->m_aLayerSurfaceLayers) {
+            for (auto& ls : lsl) {
+                if (BYADDRESS) {
+                    if (getFormat("0x%x", ls.get()) == matchName)
+                        ls->forceBlur = forceBlur;
+                } else if (ls->szNamespace == matchName)
+                    ls->forceBlur = forceBlur;
+            }
+        }
+    }
+}
+
 void CConfigManager::handleBlurLS(const std::string& command, const std::string& value) {
     if (value.find("remove,") == 0) {
         const auto TOREMOVE = removeBeginEndSpacesTabs(value.substr(7));
-        std::erase_if(m_dBlurLSNamespaces, [&](const auto& other) { return other == TOREMOVE; });
+        if (std::erase_if(m_dBlurLSNamespaces, [&](const auto& other) { return other == TOREMOVE; }))
+            updateBlurredLS(TOREMOVE, false);
         return;
     }
 
     m_dBlurLSNamespaces.emplace_back(value);
+    updateBlurredLS(value, true);
 }
 
 void CConfigManager::handleDefaultWorkspace(const std::string& command, const std::string& value) {
     const auto ARGS = CVarList(value);
 
-    for (auto& mr : m_dMonitorRules) {
-        if (mr.name == ARGS[0]) {
-            mr.defaultWorkspace = ARGS[1];
-            break;
-        }
-    }
+    m_mDefaultWorkspaces[ARGS[0]] = ARGS[1];
 }
 
 void CConfigManager::handleSubmap(const std::string& command, const std::string& submap) {
@@ -981,6 +1072,29 @@ void CConfigManager::handleBindWS(const std::string& command, const std::string&
     boundWorkspaces.push_back({ARGS[0], ARGS[1]});
 }
 
+void CConfigManager::handleEnv(const std::string& command, const std::string& value) {
+    if (!isFirstLaunch)
+        return;
+
+    const auto ARGS = CVarList(value, 2);
+
+    if (ARGS[0].empty()) {
+        parseError = "env empty";
+        return;
+    }
+
+    setenv(ARGS[0].c_str(), ARGS[1].c_str(), 1);
+
+    if (command.back() == 'd') {
+        // dbus
+        const auto CMD = "systemctl --user import-environment " + ARGS[0] +
+            " && hash dbus-update-activation-environment 2>/dev/null && "
+            "dbus-update-activation-environment --systemd " +
+            ARGS[0];
+        handleRawExec("", CMD.c_str());
+    }
+}
+
 std::string CConfigManager::parseKeyword(const std::string& COMMAND, const std::string& VALUE, bool dynamic) {
     if (dynamic) {
         parseError      = "";
@@ -1011,6 +1125,8 @@ std::string CConfigManager::parseKeyword(const std::string& COMMAND, const std::
         handleWindowRule(COMMAND, VALUE);
     else if (COMMAND == "windowrulev2")
         handleWindowRuleV2(COMMAND, VALUE);
+    else if (COMMAND == "layerrule")
+        handleLayerRule(COMMAND, VALUE);
     else if (COMMAND == "bezier")
         handleBezier(COMMAND, VALUE);
     else if (COMMAND == "animation")
@@ -1023,6 +1139,8 @@ std::string CConfigManager::parseKeyword(const std::string& COMMAND, const std::
         handleBlurLS(COMMAND, VALUE);
     else if (COMMAND == "wsbind")
         handleBindWS(COMMAND, VALUE);
+    else if (COMMAND.find("env") == 0)
+        handleEnv(COMMAND, VALUE);
     else {
         configSetValueSafe(currentCategory + (currentCategory == "" ? "" : ":") + COMMAND, VALUE);
         needsLayoutRecalc = 2;
@@ -1043,6 +1161,18 @@ std::string CConfigManager::parseKeyword(const std::string& COMMAND, const std::
         // Update window border colors
         g_pCompositor->updateAllWindowsAnimatedDecorationValues();
 
+        // manual crash
+        if (configValues["debug:manual_crash"].intValue && !m_bManualCrashInitiated) {
+            m_bManualCrashInitiated = true;
+            if (g_pHyprNotificationOverlay) {
+                g_pHyprNotificationOverlay->addNotification("Manual crash has been set up. Set debug:manual_crash back to 0 in order to crash the compositor.", CColor(0), 5000,
+                                                            ICON_INFO);
+            }
+        } else if (m_bManualCrashInitiated && !configValues["debug:manual_crash"].intValue) {
+            // cowabunga it is
+            g_pHyprRenderer->initiateManualCrash();
+        }
+
         return retval;
     }
 
@@ -1055,13 +1185,25 @@ void CConfigManager::applyUserDefinedVars(std::string& line, const size_t equals
     while (dollarPlace != std::string::npos) {
 
         const auto STRAFTERDOLLAR = line.substr(dollarPlace + 1);
+        bool       found          = false;
         for (auto& [var, value] : configDynamicVars) {
             if (STRAFTERDOLLAR.find(var) == 0) {
                 line.replace(dollarPlace, var.length() + 1, value);
+                found = true;
                 break;
             }
         }
 
+        if (!found) {
+            // maybe env?
+            for (auto& [var, value] : environmentVariables) {
+                if (STRAFTERDOLLAR.find(var) == 0) {
+                    line.replace(dollarPlace, var.length() + 1, value);
+                    break;
+                }
+            }
+        }
+
         dollarPlace = line.find_first_of('$', dollarPlace + 1);
     }
 }
@@ -1089,10 +1231,7 @@ void CConfigManager::parseLine(std::string& line) {
         startPos++;
     }
 
-    // remove shit at the beginning
-    while (line[0] == ' ' || line[0] == '\t') {
-        line = line.substr(1);
-    }
+    line = removeBeginEndSpacesTabs(line);
 
     if (line.contains(" {")) {
         auto cat = line.substr(0, line.find(" {"));
@@ -1261,7 +1400,7 @@ void CConfigManager::loadConfigLoadVars() {
     if (!isFirstLaunch && !m_bNoMonitorReload) {
         // check
         performMonitorReload();
-        ensureDPMS();
+        ensureMonitorStatus();
         ensureVRR();
     }
 
@@ -1271,6 +1410,17 @@ void CConfigManager::loadConfigLoadVars() {
     // update layout
     g_pLayoutManager->switchToLayout(configValues["general:layout"].strValue);
 
+    // manual crash
+    if (configValues["debug:manual_crash"].intValue && !m_bManualCrashInitiated) {
+        m_bManualCrashInitiated = true;
+        g_pHyprNotificationOverlay->addNotification("Manual crash has been set up. Set debug:manual_crash back to 0 in order to crash the compositor.", CColor(0), 5000, ICON_INFO);
+    } else if (m_bManualCrashInitiated && !configValues["debug:manual_crash"].intValue) {
+        // cowabunga it is
+        g_pHyprRenderer->initiateManualCrash();
+    }
+
+    Debug::disableStdout = !configValues["debug:enable_stdout_logs"].intValue;
+
     for (auto& m : g_pCompositor->m_vMonitors) {
         // mark blur dirty
         g_pHyprOpenGL->markBlurDirtyForMonitor(m.get());
@@ -1284,9 +1434,13 @@ void CConfigManager::loadConfigLoadVars() {
 }
 
 void CConfigManager::tick() {
-    static const char* const ENVHOME = getenv("HOME");
-
-    const std::string        CONFIGPATH = ENVHOME + (ISDEBUG ? (std::string) "/.config/hypr/hyprlandd.conf" : (std::string) "/.config/hypr/hyprland.conf");
+    std::string CONFIGPATH;
+    if (g_pCompositor->explicitConfigPath.empty()) {
+        static const char* const ENVHOME = getenv("HOME");
+        CONFIGPATH                       = ENVHOME + (ISDEBUG ? (std::string) "/.config/hypr/hyprlandd.conf" : (std::string) "/.config/hypr/hyprland.conf");
+    } else {
+        CONFIGPATH = g_pCompositor->explicitConfigPath;
+    }
 
     if (!std::filesystem::exists(CONFIGPATH)) {
         Debug::log(ERR, "Config doesn't exist??");
@@ -1345,7 +1499,8 @@ SConfigValue CConfigManager::getConfigValueSafeDevice(const std::string& dev, co
             if (foundIt == std::string::npos)
                 continue;
 
-            if (cv.first == "input:" + val || cv.first == "input:touchpad:" + cv.first || cv.first == "input:touchdevice:" + val) {
+            if (cv.first == "input:" + val || cv.first == "input:touchpad:" + cv.first || cv.first == "input:touchdevice:" + val || cv.first == "input:tablet:" + cv.first ||
+                cv.first == "input:tablet:" + val) {
                 copy = cv.second;
             }
         }
@@ -1526,10 +1681,44 @@ std::vector<SWindowRule> CConfigManager::getMatchingRules(CWindow* pWindow) {
     return returns;
 }
 
+std::vector<SLayerRule> CConfigManager::getMatchingRules(SLayerSurface* pLS) {
+    std::vector<SLayerRule> returns;
+
+    if (!pLS->layerSurface || pLS->fadingOut)
+        return returns;
+
+    for (auto& lr : m_dLayerRules) {
+        if (lr.targetNamespace.find("address:0x") == 0) {
+            if (getFormat("address:0x%x", pLS) != lr.targetNamespace)
+                continue;
+        } else {
+            std::regex NSCHECK(lr.targetNamespace);
+
+            if (!pLS->layerSurface->_namespace || !std::regex_search(pLS->layerSurface->_namespace, NSCHECK))
+                continue;
+        }
+
+        // hit
+        returns.push_back(lr);
+    }
+
+    if (pLS->layerSurface->_namespace && shouldBlurLS(pLS->layerSurface->_namespace))
+        returns.push_back({pLS->layerSurface->_namespace, "blur"});
+
+    return returns;
+}
+
 void CConfigManager::dispatchExecOnce() {
     if (firstExecDispatched || isFirstLaunch)
         return;
 
+    // update dbus env
+    if (g_pCompositor->m_sWLRSession)
+        handleRawExec(
+            "",
+            "systemctl --user import-environment DISPLAY WAYLAND_DISPLAY HYPRLAND_INSTANCE_SIGNATURE XDG_CURRENT_DESKTOP && hash dbus-update-activation-environment 2>/dev/null && "
+            "dbus-update-activation-environment --systemd WAYLAND_DISPLAY XDG_CURRENT_DESKTOP HYPRLAND_INSTANCE_SIGNATURE");
+
     firstExecDispatched = true;
 
     for (auto& c : firstExecRequests) {
@@ -1548,6 +1737,9 @@ void CConfigManager::dispatchExecOnce() {
     for (auto& ws : g_pCompositor->m_vWorkspaces) {
         wlr_ext_workspace_handle_v1_set_name(ws->m_pWlrHandle, ws->m_szName.c_str());
     }
+
+    // check for user's possible errors with their setup and notify them if needed
+    g_pCompositor->performUserChecks();
 }
 
 void CConfigManager::performMonitorReload() {
@@ -1555,6 +1747,9 @@ void CConfigManager::performMonitorReload() {
     bool overAgain = false;
 
     for (auto& m : g_pCompositor->m_vRealMonitors) {
+        if (!m->output)
+            continue;
+
         auto rule = getMonitorRuleFor(m->szName, m->output->description ? m->output->description : "");
 
         if (!g_pHyprRenderer->applyMonitorRule(m.get(), &rule)) {
@@ -1584,8 +1779,17 @@ SConfigValue* CConfigManager::getConfigValuePtr(const std::string& val) {
 SConfigValue* CConfigManager::getConfigValuePtrSafe(const std::string& val) {
     const auto IT = configValues.find(val);
 
-    if (IT == configValues.end())
+    if (IT == configValues.end()) {
+        // maybe plugin
+        for (auto& [pl, pMap] : pluginConfigs) {
+            const auto PLIT = pMap->find(val);
+
+            if (PLIT != pMap->end())
+                return &PLIT->second;
+        }
+
         return nullptr;
+    }
 
     return &(IT->second);
 }
@@ -1609,8 +1813,11 @@ bool CConfigManager::shouldBlurLS(const std::string& ns) {
     return false;
 }
 
-void CConfigManager::ensureDPMS() {
+void CConfigManager::ensureMonitorStatus() {
     for (auto& rm : g_pCompositor->m_vRealMonitors) {
+        if (!rm->output)
+            continue;
+
         auto rule = getMonitorRuleFor(rm->szName, rm->output->description ? rm->output->description : "");
 
         if (rule.disabled == rm->m_bEnabled) {
@@ -1621,35 +1828,64 @@ void CConfigManager::ensureDPMS() {
 }
 
 void CConfigManager::ensureVRR(CMonitor* pMonitor) {
-    static auto* const PNOVRR = &getConfigValuePtr("misc:no_vfr")->intValue;
+    static auto* const PVRR = &getConfigValuePtr("misc:vrr")->intValue;
 
-    auto               ensureVRRForDisplay = [&](CMonitor* m) -> void {
-        if (!*PNOVRR && !m->vrrActive) {
-            // Adaptive sync (VRR)
-            wlr_output_enable_adaptive_sync(m->output, 1);
+    static auto        ensureVRRForDisplay = [&](CMonitor* m) -> void {
+        if (!m->output)
+            return;
 
-            if (!wlr_output_test(m->output)) {
-                Debug::log(LOG, "Pending output %s does not accept VRR.", m->output->name);
+        if (*PVRR == 0) {
+            if (m->vrrActive) {
                 wlr_output_enable_adaptive_sync(m->output, 0);
-            }
 
-            if (!wlr_output_commit(m->output)) {
-                Debug::log(ERR, "Couldn't commit output %s in ensureVRR -> true", m->output->name);
+                if (!wlr_output_commit(m->output)) {
+                    Debug::log(ERR, "Couldn't commit output %s in ensureVRR -> false", m->output->name);
+                }
             }
+            m->vrrActive = false;
+            return;
+        } else if (*PVRR == 1) {
+            if (!m->vrrActive) {
+                wlr_output_enable_adaptive_sync(m->output, 1);
 
+                if (!wlr_output_test(m->output)) {
+                    Debug::log(LOG, "Pending output %s does not accept VRR.", m->output->name);
+                    wlr_output_enable_adaptive_sync(m->output, 0);
+                }
+
+                if (!wlr_output_commit(m->output)) {
+                    Debug::log(ERR, "Couldn't commit output %s in ensureVRR -> true", m->output->name);
+                }
+            }
+            m->vrrActive = true;
+            return;
+        } else if (*PVRR == 2) {
+            /* fullscreen */
             m->vrrActive = true;
 
-            Debug::log(LOG, "VRR ensured on %s -> true", m->output->name);
-        } else if (*PNOVRR && m->vrrActive) {
-            wlr_output_enable_adaptive_sync(m->output, 0);
+            const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(m->activeWorkspace);
 
-            if (!wlr_output_commit(m->output)) {
-                Debug::log(ERR, "Couldn't commit output %s in ensureVRR -> false", m->output->name);
+            if (!PWORKSPACE)
+                return; // ???
+
+            if (PWORKSPACE->m_bHasFullscreenWindow && m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_DISABLED) {
+                wlr_output_enable_adaptive_sync(m->output, 1);
+
+                if (!wlr_output_test(m->output)) {
+                    Debug::log(LOG, "Pending output %s does not accept VRR.", m->output->name);
+                    wlr_output_enable_adaptive_sync(m->output, 0);
+                }
+
+                if (!wlr_output_commit(m->output)) {
+                    Debug::log(ERR, "Couldn't commit output %s in ensureVRR -> true", m->output->name);
+                }
+            } else if (!PWORKSPACE->m_bHasFullscreenWindow && m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED) {
+                wlr_output_enable_adaptive_sync(m->output, 0);
+
+                if (!wlr_output_commit(m->output)) {
+                    Debug::log(ERR, "Couldn't commit output %s in ensureVRR -> false", m->output->name);
+                }
             }
-
-            m->vrrActive = false;
-
-            Debug::log(LOG, "VRR ensured on %s -> false", m->output->name);
         }
     };
 
@@ -1705,3 +1941,30 @@ void CConfigManager::addExecRule(const SExecRequestedRule& rule) {
 ICustomConfigValueData::~ICustomConfigValueData() {
     ; // empty
 }
+
+std::unordered_map<std::string, SAnimationPropertyConfig> CConfigManager::getAnimationConfig() {
+    return animationConfig;
+}
+
+void CConfigManager::addPluginConfigVar(HANDLE handle, const std::string& name, const SConfigValue& value) {
+    auto CONFIGMAPIT = std::find_if(pluginConfigs.begin(), pluginConfigs.end(), [&](const auto& other) { return other.first == handle; });
+
+    if (CONFIGMAPIT == pluginConfigs.end()) {
+        pluginConfigs.emplace(
+            std::pair<HANDLE, std::unique_ptr<std::unordered_map<std::string, SConfigValue>>>(handle, std::make_unique<std::unordered_map<std::string, SConfigValue>>()));
+        CONFIGMAPIT = std::find_if(pluginConfigs.begin(), pluginConfigs.end(), [&](const auto& other) { return other.first == handle; });
+    }
+
+    (*CONFIGMAPIT->second)[name] = value;
+}
+
+void CConfigManager::removePluginConfig(HANDLE handle) {
+    std::erase_if(pluginConfigs, [&](const auto& other) { return other.first == handle; });
+}
+
+std::string CConfigManager::getDefaultWorkspaceFor(const std::string& name) {
+    const auto IT = std::find_if(m_mDefaultWorkspaces.begin(), m_mDefaultWorkspaces.end(), [&](const auto& other) { return other.first == name; });
+    if (IT == m_mDefaultWorkspaces.end())
+        return "";
+    return IT->second;
+}

src/config/ConfigManager.hpp

@@ -11,6 +11,7 @@
 #include <algorithm>
 #include <regex>
 #include "../Window.hpp"
+#include "../helpers/WLClasses.hpp"
 
 #include "defaultConfig.hpp"
 #include "ConfigDataValues.hpp"
@@ -20,6 +21,8 @@
 #define INITANIMCFG(name)           animationConfig[name] = {}
 #define CREATEANIMCFG(name, parent) animationConfig[name] = {false, "", "", 0.f, -1, &animationConfig["global"], &animationConfig[parent]}
 
+#define HANDLE void*
+
 struct SConfigValue {
     int64_t                                 intValue   = -INT64_MAX;
     float                                   floatValue = -__FLT_MAX__;
@@ -31,16 +34,15 @@ struct SConfigValue {
 };
 
 struct SMonitorRule {
-    std::string         name             = "";
-    Vector2D            resolution       = Vector2D(1280, 720);
-    Vector2D            offset           = Vector2D(0, 0);
-    float               scale            = 1;
-    float               refreshRate      = 60;
-    std::string         defaultWorkspace = "";
-    bool                disabled         = false;
-    wl_output_transform transform        = WL_OUTPUT_TRANSFORM_NORMAL;
-    std::string         mirrorOf         = "";
-    bool                enable10bit      = false;
+    std::string         name        = "";
+    Vector2D            resolution  = Vector2D(1280, 720);
+    Vector2D            offset      = Vector2D(0, 0);
+    float               scale       = 1;
+    float               refreshRate = 60;
+    bool                disabled    = false;
+    wl_output_transform transform   = WL_OUTPUT_TRANSFORM_NORMAL;
+    std::string         mirrorOf    = "";
+    bool                enable10bit = false;
 };
 
 struct SMonitorAdditionalReservedArea {
@@ -51,7 +53,7 @@ struct SMonitorAdditionalReservedArea {
 };
 
 struct SAnimationPropertyConfig {
-    bool                      overriden = true;
+    bool                      overridden = true;
 
     std::string               internalBezier  = "";
     std::string               internalStyle   = "";
@@ -147,14 +149,21 @@ class CConfigManager {
     SConfigValue*                                                   getConfigValuePtrSafe(const std::string&);
 
     SMonitorRule                                                    getMonitorRuleFor(const std::string&, const std::string& displayName = "");
+    std::string                                                     getDefaultWorkspaceFor(const std::string&);
 
     CMonitor*                                                       getBoundMonitorForWS(const std::string&);
     std::string                                                     getBoundMonitorStringForWS(const std::string&);
 
     std::vector<SWindowRule>                                        getMatchingRules(CWindow*);
+    std::vector<SLayerRule>                                         getMatchingRules(SLayerSurface*);
 
     std::unordered_map<std::string, SMonitorAdditionalReservedArea> m_mAdditionalReservedAreas;
 
+    std::unordered_map<std::string, SAnimationPropertyConfig>       getAnimationConfig();
+
+    void                                                            addPluginConfigVar(HANDLE handle, const std::string& name, const SConfigValue& value);
+    void                                                            removePluginConfig(HANDLE handle);
+
     // no-op when done.
     void                      dispatchExecOnce();
 
@@ -162,7 +171,7 @@ class CConfigManager {
     bool                      m_bWantsMonitorReload = false;
     bool                      m_bForceReload        = false;
     bool                      m_bNoMonitorReload    = false;
-    void                      ensureDPMS();
+    void                      ensureMonitorStatus();
     void                      ensureVRR(CMonitor* pMonitor = nullptr);
 
     std::string               parseKeyword(const std::string&, const std::string&, bool dynamic = false);
@@ -176,39 +185,48 @@ class CConfigManager {
     std::string               configCurrentPath;
 
   private:
-    std::deque<std::string>                                                        configPaths;       // stores all the config paths
-    std::unordered_map<std::string, time_t>                                        configModifyTimes; // stores modify times
-    std::unordered_map<std::string, std::string>                                   configDynamicVars; // stores dynamic vars declared by the user
-    std::unordered_map<std::string, SConfigValue>                                  configValues;
-    std::unordered_map<std::string, std::unordered_map<std::string, SConfigValue>> deviceConfigs; // stores device configs
+    std::deque<std::string>                                                                    configPaths;       // stores all the config paths
+    std::unordered_map<std::string, time_t>                                                    configModifyTimes; // stores modify times
+    std::vector<std::pair<std::string, std::string>>                                           configDynamicVars; // stores dynamic vars declared by the user
+    std::unordered_map<std::string, SConfigValue>                                              configValues;
+    std::unordered_map<std::string, std::unordered_map<std::string, SConfigValue>>             deviceConfigs; // stores device configs
 
-    std::unordered_map<std::string, SAnimationPropertyConfig>                      animationConfig; // stores all the animations with their set values
+    std::unordered_map<std::string, SAnimationPropertyConfig>                                  animationConfig; // stores all the animations with their set values
 
-    std::string                                                                    currentCategory = ""; // For storing the category of the current item
+    std::string                                                                                currentCategory = ""; // For storing the category of the current item
 
-    std::string                                                                    parseError = ""; // For storing a parse error to display later
+    std::string                                                                                parseError = ""; // For storing a parse error to display later
 
-    std::string                                                                    m_szCurrentSubmap = ""; // For storing the current keybind submap
+    std::string                                                                                m_szCurrentSubmap = ""; // For storing the current keybind submap
 
-    std::vector<std::pair<std::string, std::string>>                               boundWorkspaces;
+    std::vector<std::pair<std::string, std::string>>                                           boundWorkspaces;
 
-    std::vector<SExecRequestedRule>                                                execRequestedRules; // rules requested with exec, e.g. [workspace 2] kitty
+    std::vector<SExecRequestedRule>                                                            execRequestedRules; // rules requested with exec, e.g. [workspace 2] kitty
 
-    bool                                                                           isFirstLaunch = true; // For exec-once
+    std::unordered_map<HANDLE, std::unique_ptr<std::unordered_map<std::string, SConfigValue>>> pluginConfigs; // stores plugin configs
 
-    std::deque<SMonitorRule>                                                       m_dMonitorRules;
-    std::deque<SWindowRule>                                                        m_dWindowRules;
-    std::deque<std::string>                                                        m_dBlurLSNamespaces;
+    bool                                                                                       isFirstLaunch = true; // For exec-once
 
-    bool                                                                           firstExecDispatched = false;
-    std::deque<std::string>                                                        firstExecRequests;
+    std::deque<SMonitorRule>                                                                   m_dMonitorRules;
+    std::unordered_map<std::string, std::string>                                               m_mDefaultWorkspaces;
+    std::deque<SWindowRule>                                                                    m_dWindowRules;
+    std::deque<SLayerRule>                                                                     m_dLayerRules;
+    std::deque<std::string>                                                                    m_dBlurLSNamespaces;
+
+    bool                                                                                       firstExecDispatched     = false;
+    bool                                                                                       m_bManualCrashInitiated = false;
+    std::deque<std::string>                                                                    firstExecRequests;
+
+    std::vector<std::pair<std::string, std::string>>                                           environmentVariables;
 
     // internal methods
     void         setDefaultVars();
     void         setDefaultAnimationVars();
     void         setDeviceDefaultVars(const std::string&);
+    void         populateEnvironment();
 
     void         setAnimForChildren(SAnimationPropertyConfig* const);
+    void         updateBlurredLS(const std::string&, const bool);
 
     void         applyUserDefinedVars(std::string&, const size_t);
     void         loadConfigLoadVars();
@@ -222,6 +240,7 @@ class CConfigManager {
     void         handleBind(const std::string&, const std::string&);
     void         handleUnbind(const std::string&, const std::string&);
     void         handleWindowRule(const std::string&, const std::string&);
+    void         handleLayerRule(const std::string&, const std::string&);
     void         handleWindowRuleV2(const std::string&, const std::string&);
     void         handleDefaultWorkspace(const std::string&, const std::string&);
     void         handleBezier(const std::string&, const std::string&);
@@ -230,6 +249,7 @@ class CConfigManager {
     void         handleSubmap(const std::string&, const std::string&);
     void         handleBlurLS(const std::string&, const std::string&);
     void         handleBindWS(const std::string&, const std::string&);
+    void         handleEnv(const std::string&, const std::string&);
 };
 
 inline std::unique_ptr<CConfigManager> g_pConfigManager;

src/config/defaultConfig.hpp

@@ -28,6 +28,9 @@ monitor=,preferred,auto,auto
 # Source a file (multi-file configs)
 # source = ~/.config/hypr/myColors.conf
 
+# Some default env vars.
+env = XCURSOR_SIZE,24
+
 # For all categories, see https://wiki.hyprland.org/Configuring/Variables/
 input {
     kb_layout = us
@@ -82,6 +85,7 @@ animations {
     animation = windows, 1, 7, myBezier
     animation = windowsOut, 1, 7, default, popin 80%
     animation = border, 1, 10, default
+    animation = borderangle, 1, 8, default
     animation = fade, 1, 7, default
     animation = workspaces, 1, 6, default
 }
@@ -104,7 +108,7 @@ gestures {
 
 # Example per-device config
 # See https://wiki.hyprland.org/Configuring/Keywords/#executing for more
-device:epic mouse V1 {
+device:epic-mouse-v1 {
     sensitivity = -0.5
 }
 

src/debug/CrashReporter.cpp

@@ -0,0 +1,160 @@
+#include "CrashReporter.hpp"
+#include <random>
+#include <sys/utsname.h>
+#include <execinfo.h>
+#include <fstream>
+#include <signal.h>
+
+#include "../plugins/PluginSystem.hpp"
+
+#if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__)
+#include <sys/sysctl.h>
+#endif
+
+std::string getRandomMessage() {
+
+    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."};
+
+    std::random_device              dev;
+    std::mt19937                    engine(dev());
+    std::uniform_int_distribution<> distribution(0, MESSAGES.size() - 1);
+
+    return MESSAGES[distribution(engine)];
+}
+
+void CrashReporter::createAndSaveCrash(int sig) {
+
+    // get the backtrace
+    const int   PID = getpid();
+
+    std::string finalCrashReport = "";
+
+    finalCrashReport += "--------------------------------------------\n   Hyprland Crash Report\n--------------------------------------------\n";
+    finalCrashReport += getRandomMessage() + "\n\n";
+
+    finalCrashReport += getFormat("Hyprland received signal %d (%s)\n\n", sig, strsignal(sig));
+
+    finalCrashReport += getFormat("Version: %s\n\n", GIT_COMMIT_HASH);
+
+    if (!g_pPluginSystem->getAllPlugins().empty()) {
+        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 += getFormat("\t%s (%s) %s\n", p->name.c_str(), p->author.c_str(), p->version.c_str());
+        }
+
+        finalCrashReport += "\n\n";
+    }
+
+    finalCrashReport += "System info:\n";
+
+    struct utsname unameInfo;
+    uname(&unameInfo);
+
+    finalCrashReport +=
+        getFormat("\tSystem name: %s\n\tNode name: %s\n\tRelease: %s\n\tVersion: %s\n\n", unameInfo.sysname, unameInfo.nodename, unameInfo.release, unameInfo.version);
+
+#if defined(__DragonFly__) || defined(__FreeBSD__)
+    const std::string GPUINFO = execAndGet("pciconf -lv | fgrep -A4 vga");
+#else
+    const std::string GPUINFO = execAndGet("lspci -vnn | grep VGA");
+#endif
+
+    finalCrashReport += "GPU:\n\t" + GPUINFO;
+
+    finalCrashReport += getFormat("\n\nos-release:\n\t%s\n\n\n", replaceInString(execAndGet("cat /etc/os-release"), "\n", "\n\t").c_str());
+
+    finalCrashReport += "Backtrace:\n";
+
+    void*  bt[1024];
+    size_t btSize;
+    char** btSymbols;
+
+    btSize    = backtrace(bt, 1024);
+    btSymbols = backtrace_symbols(bt, btSize);
+
+#if defined(KERN_PROC_PATHNAME)
+    int mib[] = {
+        CTL_KERN,
+#if defined(__NetBSD__)
+        KERN_PROC_ARGS,
+        -1,
+        KERN_PROC_PATHNAME,
+#else
+        KERN_PROC,
+        KERN_PROC_PATHNAME,
+        -1,
+#endif
+    };
+    u_int  miblen        = sizeof(mib) / sizeof(mib[0]);
+    char   exe[PATH_MAX] = "";
+    size_t sz            = sizeof(exe);
+    sysctl(mib, miblen, &exe, &sz, NULL, 0);
+    const auto FPATH = std::filesystem::canonical(exe);
+#elif defined(__OpenBSD__)
+    // Neither KERN_PROC_PATHNAME nor /proc are supported
+    const auto FPATH = std::filesystem::canonical("/usr/local/bin/Hyprland");
+#else
+    const auto FPATH = std::filesystem::canonical("/proc/self/exe");
+#endif
+
+    for (size_t i = 0; i < btSize; ++i) {
+        finalCrashReport += getFormat("\t#%i | %s\n", i, btSymbols[i]);
+
+#ifdef __clang__
+        const auto CMD = getFormat("llvm-addr2line -e %s -f 0x%lx", FPATH.c_str(), (uint64_t)bt[i]);
+#else
+        const auto CMD = getFormat("addr2line -e %s -f 0x%lx", FPATH.c_str(), (uint64_t)bt[i]);
+#endif
+        const auto ADDR2LINE = replaceInString(execAndGet(CMD.c_str()), "\n", "\n\t\t");
+        finalCrashReport += "\t\t" + ADDR2LINE.substr(0, ADDR2LINE.length() - 2);
+    }
+
+    free(btSymbols);
+
+    finalCrashReport += "\n\nLog tail:\n";
+
+    finalCrashReport += execAndGet(("cat \"" + Debug::logFile + "\" | tail -n 50").c_str());
+
+    const auto HOME = getenv("HOME");
+    const auto CACHE_HOME = getenv("XDG_CACHE_HOME");
+
+    if (!HOME)
+        return;
+
+    std::ofstream ofs;
+    if (!CACHE_HOME) {
+        if (!std::filesystem::exists(std::string(HOME) + "/.hyprland")) {
+            std::filesystem::create_directory(std::string(HOME) + "/.hyprland");
+            std::filesystem::permissions(std::string(HOME) + "/.hyprland", std::filesystem::perms::all, std::filesystem::perm_options::replace);
+        }
+
+        ofs.open(std::string(HOME) + "/.hyprland/hyprlandCrashReport" + std::to_string(PID) + ".txt", std::ios::trunc);
+
+    } else if (CACHE_HOME) {
+        if (!std::filesystem::exists(std::string(CACHE_HOME) + "/hyprland")) {
+            std::filesystem::create_directory(std::string(CACHE_HOME) + "/hyprland");
+            std::filesystem::permissions(std::string(CACHE_HOME) + "/hyprland", std::filesystem::perms::all, std::filesystem::perm_options::replace);
+        }
+
+        ofs.open(std::string(CACHE_HOME) + "/hyprland/hyprlandCrashReport" + std::to_string(PID) + ".txt", std::ios::trunc);
+    } else {
+        return;
+    }
+
+    ofs << finalCrashReport;
+
+    ofs.close();
+}

src/debug/CrashReporter.hpp

@@ -0,0 +1,7 @@
+#pragma once
+
+#include "../defines.hpp"
+
+namespace CrashReporter {
+    void createAndSaveCrash(int sig);
+};

src/debug/HyprCtl.cpp

@@ -11,6 +11,7 @@
 #include <unistd.h>
 #include <errno.h>
 
+#include <sstream>
 #include <string>
 
 std::string monitorsRequest(HyprCtl::eHyprCtlOutputFormat format) {
@@ -19,11 +20,17 @@ std::string monitorsRequest(HyprCtl::eHyprCtlOutputFormat format) {
         result += "[";
 
         for (auto& m : g_pCompositor->m_vMonitors) {
+            if (!m->output)
+                continue;
+
             result += getFormat(
                 R"#({
     "id": %i,
     "name": "%s",
     "description": "%s",
+    "make": "%s",
+    "model": "%s",
+    "serial": "%s",
     "width": %i,
     "height": %i,
     "refreshRate": %f,
@@ -37,13 +44,15 @@ std::string monitorsRequest(HyprCtl::eHyprCtlOutputFormat format) {
     "scale": %.2f,
     "transform": %i,
     "focused": %s,
-    "dpmsStatus": %s
+    "dpmsStatus": %s,
+    "vrr": %s
 },)#",
-                m->ID, escapeJSONStrings(m->szName).c_str(), escapeJSONStrings(m->output->description ? m->output->description : "").c_str(), (int)m->vecPixelSize.x,
+                m->ID, escapeJSONStrings(m->szName).c_str(), escapeJSONStrings(m->output->description ? m->output->description : "").c_str(),
+                (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->activeWorkspace,
                 escapeJSONStrings(g_pCompositor->getWorkspaceByID(m->activeWorkspace)->m_szName).c_str(), (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->dpmsStatus ? "true" : "false"), (m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED ? "true" : "false"));
         }
 
         // remove trailing comma
@@ -52,12 +61,18 @@ std::string monitorsRequest(HyprCtl::eHyprCtlOutputFormat format) {
         result += "]";
     } else {
         for (auto& m : g_pCompositor->m_vMonitors) {
-            result += getFormat("Monitor %s (ID %i):\n\t%ix%i@%f at %ix%i\n\tdescription: %s\n\tactive workspace: %i (%s)\n\treserved: %i %i %i %i\n\tscale: %.2f\n\ttransform: "
-                                "%i\n\tfocused: %s\n\tdpmsStatus: %i\n\n",
+            if (!m->output)
+                continue;
+
+            result += getFormat("Monitor %s (ID %i):\n\t%ix%i@%f at %ix%i\n\tdescription: %s\n\tmake: %s\n\tmodel: %s\n\tserial: %s\n\tactive workspace: %i (%s)\n\treserved: %i "
+                                "%i %i %i\n\tscale: %.2f\n\ttransform: "
+                                "%i\n\tfocused: %s\n\tdpmsStatus: %i\n\tvrr: %i\n\n",
                                 m->szName.c_str(), m->ID, (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y,
-                                (m->output->description ? m->output->description : ""), m->activeWorkspace, g_pCompositor->getWorkspaceByID(m->activeWorkspace)->m_szName.c_str(),
+                                (m->output->description ? m->output->description : ""), (m->output->make ? m->output->make : ""), (m->output->model ? m->output->model : ""),
+                                (m->output->serial ? m->output->serial : ""), m->activeWorkspace, g_pCompositor->getWorkspaceByID(m->activeWorkspace)->m_szName.c_str(),
                                 (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 ? "yes" : "no"), (int)m->dpmsStatus);
+                                (int)m->transform, (m.get() == g_pCompositor->m_pLastMonitor ? "yes" : "no"), (int)m->dpmsStatus,
+                                (int)(m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED));
         }
     }
 
@@ -66,14 +81,16 @@ std::string monitorsRequest(HyprCtl::eHyprCtlOutputFormat format) {
 
 static std::string getGroupedData(CWindow* w, HyprCtl::eHyprCtlOutputFormat format) {
     const bool isJson = format == HyprCtl::FORMAT_JSON;
-    if (g_pLayoutManager->getCurrentLayout()->getLayoutName() != "dwindle")
+    if (!w->m_sGroupData.pNextWindow)
         return isJson ? "" : "0";
 
-    SLayoutMessageHeader header;
-    header.pWindow          = w;
-    const auto groupMembers = std::any_cast<std::deque<CWindow*>>(g_pLayoutManager->getCurrentLayout()->layoutMessage(header, "groupinfo"));
-    if (groupMembers.empty())
-        return isJson ? "" : "0";
+    std::vector<CWindow*> groupMembers;
+
+    CWindow*              curr = w;
+    do {
+        groupMembers.push_back(curr);
+        curr = curr->m_sGroupData.pNextWindow;
+    } while (curr != w);
 
     const auto         comma = isJson ? ", " : ",";
     const auto         fmt   = isJson ? "\"0x%x\"" : "%x";
@@ -97,6 +114,8 @@ static std::string getWindowData(CWindow* w, HyprCtl::eHyprCtlOutputFormat forma
         return getFormat(
             R"#({
     "address": "0x%x",
+    "mapped": %s,
+    "hidden": %s,
     "at": [%i, %i],
     "size": [%i, %i],
     "workspace": {
@@ -107,37 +126,43 @@ static std::string getWindowData(CWindow* w, HyprCtl::eHyprCtlOutputFormat forma
     "monitor": %i,
     "class": "%s",
     "title": "%s",
+    "initialClass": "%s",
+    "initialTitle": "%s",
     "pid": %i,
     "xwayland": %s,
     "pinned": %s,
     "fullscreen": %s,
     "fullscreenMode": %i,
+    "fakeFullscreen": %s,
     "grouped": [%s],
     "swallowing": %s
 },)#",
-            w, (int)w->m_vRealPosition.goalv().x, (int)w->m_vRealPosition.goalv().y, (int)w->m_vRealSize.goalv().x, (int)w->m_vRealSize.goalv().y, w->m_iWorkspaceID,
+            w, (w->m_bIsMapped ? "true" : "false"), (w->isHidden() ? "true" : "false"), (int)w->m_vRealPosition.goalv().x, (int)w->m_vRealPosition.goalv().y,
+            (int)w->m_vRealSize.goalv().x, (int)w->m_vRealSize.goalv().y, w->m_iWorkspaceID,
             escapeJSONStrings(w->m_iWorkspaceID == -1                                ? "" :
                                   g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_szName :
                                                                                        std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID)))
                 .c_str(),
             ((int)w->m_bIsFloating == 1 ? "true" : "false"), w->m_iMonitorID, escapeJSONStrings(g_pXWaylandManager->getAppIDClass(w)).c_str(),
-            escapeJSONStrings(g_pXWaylandManager->getTitle(w)).c_str(), w->getPID(), ((int)w->m_bIsX11 == 1 ? "true" : "false"), (w->m_bPinned ? "true" : "false"),
-            (w->m_bIsFullscreen ? "true" : "false"),
+            escapeJSONStrings(g_pXWaylandManager->getTitle(w)).c_str(), escapeJSONStrings(w->m_szInitialClass).c_str(), escapeJSONStrings(w->m_szInitialTitle).c_str(), w->getPID(),
+            ((int)w->m_bIsX11 == 1 ? "true" : "false"), (w->m_bPinned ? "true" : "false"), (w->m_bIsFullscreen ? "true" : "false"),
             (w->m_bIsFullscreen ? (g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_efFullscreenMode : 0) : 0),
-            getGroupedData(w, format).c_str(), (w->m_pSwallowed ? getFormat("\"0x%x\"", w->m_pSwallowed).c_str() : "null"));
+            w->m_bFakeFullscreenState ? "true" : "false", getGroupedData(w, format).c_str(), (w->m_pSwallowed ? getFormat("\"0x%x\"", w->m_pSwallowed).c_str() : "null"));
     } else {
         return getFormat(
-            "Window %x -> %s:\n\tat: %i,%i\n\tsize: %i,%i\n\tworkspace: %i (%s)\n\tfloating: %i\n\tmonitor: %i\n\tclass: %s\n\ttitle: %s\n\tpid: %i\n\txwayland: %i\n\tpinned: "
-            "%i\n\tfullscreen: %i\n\tfullscreenmode: %i\n\tgrouped: %s\n\tswallowing: %x\n\n",
-            w, w->m_szTitle.c_str(), (int)w->m_vRealPosition.goalv().x, (int)w->m_vRealPosition.goalv().y, (int)w->m_vRealSize.goalv().x, (int)w->m_vRealSize.goalv().y,
-            w->m_iWorkspaceID,
+            "Window %x -> %s:\n\tmapped: %i\n\thidden: %i\n\tat: %i,%i\n\tsize: %i,%i\n\tworkspace: %i (%s)\n\tfloating: %i\n\tmonitor: %i\n\tclass: %s\n\ttitle: "
+            "%s\n\tinitialClass: %s\n\tinitialTitle: %s\n\tpid: "
+            "%i\n\txwayland: %i\n\tpinned: "
+            "%i\n\tfullscreen: %i\n\tfullscreenmode: %i\n\tfakefullscreen: %i\n\tgrouped: %s\n\tswallowing: %x\n\n",
+            w, w->m_szTitle.c_str(), (int)w->m_bIsMapped, (int)w->isHidden(), (int)w->m_vRealPosition.goalv().x, (int)w->m_vRealPosition.goalv().y, (int)w->m_vRealSize.goalv().x,
+            (int)w->m_vRealSize.goalv().y, w->m_iWorkspaceID,
             (w->m_iWorkspaceID == -1                                ? "" :
                  g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_szName.c_str() :
                                                                       std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID)).c_str()),
-            (int)w->m_bIsFloating, w->m_iMonitorID, g_pXWaylandManager->getAppIDClass(w).c_str(), g_pXWaylandManager->getTitle(w).c_str(), w->getPID(), (int)w->m_bIsX11,
-            (int)w->m_bPinned, (int)w->m_bIsFullscreen,
+            (int)w->m_bIsFloating, w->m_iMonitorID, g_pXWaylandManager->getAppIDClass(w).c_str(), g_pXWaylandManager->getTitle(w).c_str(), w->m_szInitialClass.c_str(),
+            w->m_szInitialTitle.c_str(), w->getPID(), (int)w->m_bIsX11, (int)w->m_bPinned, (int)w->m_bIsFullscreen,
             (w->m_bIsFullscreen ? (g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_efFullscreenMode : 0) : 0),
-            getGroupedData(w, format).c_str(), w->m_pSwallowed);
+            (int)w->m_bFakeFullscreenState, getGroupedData(w, format).c_str(), w->m_pSwallowed);
     }
 }
 
@@ -147,9 +172,7 @@ std::string clientsRequest(HyprCtl::eHyprCtlOutputFormat format) {
         result += "[";
 
         for (auto& w : g_pCompositor->m_vWindows) {
-            if (w->m_bIsMapped) {
-                result += getWindowData(w.get(), format);
-            }
+            result += getWindowData(w.get(), format);
         }
 
         // remove trailing comma
@@ -159,9 +182,7 @@ std::string clientsRequest(HyprCtl::eHyprCtlOutputFormat format) {
         result += "]";
     } else {
         for (auto& w : g_pCompositor->m_vWindows) {
-            if (w->m_bIsMapped) {
-                result += getWindowData(w.get(), format);
-            }
+            result += getWindowData(w.get(), format);
         }
     }
     return result;
@@ -233,7 +254,7 @@ std::string layersRequest(HyprCtl::eHyprCtlOutputFormat format) {
                 escapeJSONStrings(mon->szName).c_str());
 
             int layerLevel = 0;
-            for (auto& level : mon->m_aLayerSurfaceLists) {
+            for (auto& level : mon->m_aLayerSurfaceLayers) {
                 result += getFormat(
                     R"#(
         "%i": [
@@ -277,9 +298,10 @@ std::string layersRequest(HyprCtl::eHyprCtlOutputFormat format) {
     } else {
         for (auto& mon : g_pCompositor->m_vMonitors) {
             result += getFormat("Monitor %s:\n", mon->szName.c_str());
-            int layerLevel = 0;
-            for (auto& level : mon->m_aLayerSurfaceLists) {
-                result += getFormat("\tLayer level %i:\n", layerLevel);
+            int                                     layerLevel = 0;
+            static const std::array<std::string, 4> levelNames = {"background", "bottom", "top", "overlay"};
+            for (auto& level : mon->m_aLayerSurfaceLayers) {
+                result += getFormat("\tLayer level %i (%s):\n", layerLevel, levelNames[layerLevel].c_str());
 
                 for (auto& layer : level) {
                     result += getFormat("\t\tLayer %x: xywh: %i %i %i %i, namespace: %s\n", layer.get(), layer->geometry.x, layer->geometry.y, layer->geometry.width,
@@ -461,6 +483,104 @@ std::string devicesRequest(HyprCtl::eHyprCtlOutputFormat format) {
     return result;
 }
 
+std::string animationsRequest(HyprCtl::eHyprCtlOutputFormat format) {
+    std::string ret = "";
+    if (format == HyprCtl::eHyprCtlOutputFormat::FORMAT_NORMAL) {
+        ret += "animations:\n";
+
+        for (auto& ac : g_pConfigManager->getAnimationConfig()) {
+            ret += getFormat("\n\tname: %s\n\t\toverriden: %i\n\t\tbezier: %s\n\t\tenabled: %i\n\t\tspeed: %.2f\n\t\tstyle: %s\n", ac.first.c_str(), (int)ac.second.overridden,
+                             ac.second.internalBezier.c_str(), ac.second.internalEnabled, ac.second.internalSpeed, ac.second.internalStyle.c_str());
+        }
+
+        ret += "beziers:\n";
+
+        for (auto& bz : g_pAnimationManager->getAllBeziers()) {
+            ret += getFormat("\n\tname: %s\n", bz.first.c_str());
+        }
+    } else {
+        // json
+
+        ret += "[[";
+        for (auto& ac : g_pConfigManager->getAnimationConfig()) {
+            ret += getFormat(R"#(
+{
+    "name": "%s",
+    "overridden": %s,
+    "bezier": "%s",
+    "enabled": %s,
+    "speed": %.2f,
+    "style": "%s"
+},)#",
+                             ac.first.c_str(), ac.second.overridden ? "true" : "false", ac.second.internalBezier.c_str(), ac.second.internalEnabled ? "true" : "false",
+                             ac.second.internalSpeed, ac.second.internalStyle.c_str());
+        }
+
+        ret[ret.length() - 1] = ']';
+
+        ret += ",\n[";
+
+        for (auto& bz : g_pAnimationManager->getAllBeziers()) {
+            ret += getFormat(R"#(
+{
+    "name": "%s"
+},)#",
+                             bz.first.c_str());
+        }
+
+        ret.pop_back();
+
+        ret += "]]";
+    }
+
+    return ret;
+}
+
+std::string bindsRequest(HyprCtl::eHyprCtlOutputFormat format) {
+    std::string ret = "";
+    if (format == HyprCtl::eHyprCtlOutputFormat::FORMAT_NORMAL) {
+        for (auto& kb : g_pKeybindManager->m_lKeybinds) {
+            ret += "bind";
+            if (kb.locked)
+                ret += "l";
+            if (kb.mouse)
+                ret += "m";
+            if (kb.release)
+                ret += "r";
+            if (kb.repeat)
+                ret += "e";
+
+            ret += getFormat("\n\tmodmask: %u\n\tsubmap: %s\n\tkey: %s\n\tkeycode: %d\n\tdispatcher: %s\n\targ: %s\n\n", kb.modmask, kb.submap.c_str(), kb.key.c_str(), kb.keycode,
+                             kb.handler.c_str(), kb.arg.c_str());
+        }
+    } else {
+        // json
+        ret += "[";
+        for (auto& kb : g_pKeybindManager->m_lKeybinds) {
+            ret += getFormat(
+                R"#(
+{
+    "locked": %s,
+    "mouse": %s,
+    "release": %s,
+    "repeat": %s,
+    "modmask": %u,
+    "submap": "%s",
+    "key": "%s",
+    "keycode": %i,
+    "dispatcher": "%s",
+    "arg": "%s"
+},)#",
+                kb.locked ? "true" : "false", kb.mouse ? "true" : "false", kb.release ? "true" : "false", kb.repeat ? "true" : "false", kb.modmask,
+                escapeJSONStrings(kb.submap).c_str(), escapeJSONStrings(kb.key).c_str(), kb.keycode, escapeJSONStrings(kb.handler).c_str(), escapeJSONStrings(kb.arg).c_str());
+        }
+        ret.pop_back();
+        ret += "]";
+    }
+
+    return ret;
+}
+
 std::string versionRequest(HyprCtl::eHyprCtlOutputFormat format) {
 
     if (format == HyprCtl::eHyprCtlOutputFormat::FORMAT_NORMAL) {
@@ -566,6 +686,14 @@ std::string dispatchKeyword(std::string in) {
         }
     }
 
+    // decorations will probably need a repaint
+    if (COMMAND.contains("decoration:") || COMMAND.contains("border")) {
+        for (auto& m : g_pCompositor->m_vMonitors) {
+            g_pHyprRenderer->damageMonitor(m.get());
+            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
+        }
+    }
+
     Debug::log(LOG, "Hyprctl: keyword %s : %s", COMMAND.c_str(), VALUE.c_str());
 
     if (retval == "")
@@ -747,6 +875,106 @@ std::string switchXKBLayoutRequest(const std::string& request) {
     return "ok";
 }
 
+std::string dispatchSeterror(std::string request) {
+    CVarList    vars(request, 0, ' ');
+
+    std::string errorMessage = "";
+
+    if (vars.size() < 3) {
+        g_pHyprError->destroy();
+
+        if (vars.size() == 2 && !vars[1].find("dis"))
+            return "var 1 not color or disable";
+
+        return "ok";
+    }
+
+    const CColor COLOR = configStringToInt(vars[1]);
+
+    for (size_t i = 2; i < vars.size(); ++i)
+        errorMessage += vars[i] + ' ';
+
+    if (errorMessage.empty()) {
+        g_pHyprError->destroy();
+    } else {
+        errorMessage.pop_back(); // pop last space
+        g_pHyprError->queueCreate(errorMessage, COLOR);
+    }
+
+    return "ok";
+}
+
+std::string dispatchSetProp(std::string request) {
+    CVarList vars(request, 0, ' ');
+
+    if (vars.size() < 4)
+        return "not enough args";
+
+    const auto PWINDOW = g_pCompositor->getWindowByRegex(vars[1]);
+
+    if (!PWINDOW)
+        return "window not found";
+
+    const auto PROP = vars[2];
+    const auto VAL  = vars[3];
+
+    bool       lock = false;
+
+    if (vars.size() > 4) {
+        if (vars[4].find("lock") == 0) {
+            lock = true;
+        }
+    }
+
+    try {
+        if (PROP == "animationstyle") {
+            PWINDOW->m_sAdditionalConfigData.animationStyle = VAL;
+        } else if (PROP == "rounding") {
+            PWINDOW->m_sAdditionalConfigData.rounding.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "forcenoblur") {
+            PWINDOW->m_sAdditionalConfigData.forceNoBlur.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "forceopaque") {
+            PWINDOW->m_sAdditionalConfigData.forceOpaque.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "forceopaqueoverriden") {
+            PWINDOW->m_sAdditionalConfigData.forceOpaqueOverridden.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "forceallowsinput") {
+            PWINDOW->m_sAdditionalConfigData.forceAllowsInput.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "forcenoanims") {
+            PWINDOW->m_sAdditionalConfigData.forceNoAnims.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "forcenoborder") {
+            PWINDOW->m_sAdditionalConfigData.forceNoBorder.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "forcenoshadow") {
+            PWINDOW->m_sAdditionalConfigData.forceNoShadow.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "windowdancecompat") {
+            PWINDOW->m_sAdditionalConfigData.windowDanceCompat.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "nomaxsize") {
+            PWINDOW->m_sAdditionalConfigData.noMaxSize.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "dimaround") {
+            PWINDOW->m_sAdditionalConfigData.dimAround.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "alphaoverride") {
+            PWINDOW->m_sSpecialRenderData.alphaOverride.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "alpha") {
+            PWINDOW->m_sSpecialRenderData.alpha.forceSetIgnoreLocked(std::stof(VAL), lock);
+        } else if (PROP == "alphainactiveoverride") {
+            PWINDOW->m_sSpecialRenderData.alphaInactiveOverride.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "alphainactive") {
+            PWINDOW->m_sSpecialRenderData.alphaInactive.forceSetIgnoreLocked(std::stof(VAL), lock);
+        } else if (PROP == "activebordercolor") {
+            PWINDOW->m_sSpecialRenderData.activeBorderColor.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "inactivebordercolor") {
+            PWINDOW->m_sSpecialRenderData.inactiveBorderColor.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "forcergbx") {
+            PWINDOW->m_sAdditionalConfigData.forceRGBX.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else {
+            return "prop not found";
+        }
+    } catch (std::exception& e) { return "error in parsing prop value: " + std::string(e.what()); }
+
+    g_pCompositor->updateAllWindowsAnimatedDecorationValues();
+
+    return "ok";
+}
+
 std::string dispatchGetOption(std::string request, HyprCtl::eHyprCtlOutputFormat format) {
     std::string curitem = "";
 
@@ -870,6 +1098,91 @@ std::string dispatchOutput(std::string request) {
     return "ok";
 }
 
+std::string dispatchPlugin(std::string request) {
+    CVarList vars(request, 0, ' ');
+
+    if (vars.size() < 2)
+        return "not enough args";
+
+    const auto OPERATION = vars[1];
+    const auto PATH      = vars[2];
+
+    if (OPERATION == "load") {
+        if (vars.size() < 3)
+            return "not enough args";
+
+        const auto PLUGIN = g_pPluginSystem->loadPlugin(PATH);
+
+        if (!PLUGIN)
+            return "error in loading plugin";
+    } else if (OPERATION == "unload") {
+        if (vars.size() < 3)
+            return "not enough args";
+
+        const auto PLUGIN = g_pPluginSystem->getPluginByPath(PATH);
+
+        if (!PLUGIN)
+            return "plugin not loaded";
+
+        g_pPluginSystem->unloadPlugin(PLUGIN);
+    } else if (OPERATION == "list") {
+        const auto  PLUGINS = g_pPluginSystem->getAllPlugins();
+
+        std::string list = "";
+        for (auto& p : PLUGINS) {
+            list += getFormat("\nPlugin %s by %s:\n\tHandle: %lx\n\tVersion: %s\n\tDescription: %s\n", p->name.c_str(), p->author.c_str(), p->m_pHandle, p->version.c_str(),
+                              p->description.c_str());
+        }
+
+        return list;
+    } else {
+        return "unknown opt";
+    }
+
+    return "ok";
+}
+
+std::string dispatchNotify(std::string request) {
+    CVarList vars(request, 0, ' ');
+
+    if (vars.size() < 5)
+        return "not enough args";
+
+    const auto ICON = vars[1];
+
+    if (!isNumber(ICON))
+        return "invalid arg 1";
+
+    int icon = -1;
+    try {
+        icon = std::stoi(ICON);
+    } catch (std::exception& e) { return "invalid arg 1"; }
+
+    if (icon == -1 || icon > ICON_NONE) {
+        icon = ICON_NONE;
+    }
+
+    const auto TIME = vars[2];
+    int        time = 0;
+    try {
+        time = std::stoi(TIME);
+    } catch (std::exception& e) { return "invalid arg 2"; }
+
+    CColor      color = configStringToInt(vars[3]);
+
+    std::string message = "";
+
+    for (size_t i = 4; i < vars.size(); ++i) {
+        message += vars[i] + " ";
+    }
+
+    message.pop_back();
+
+    g_pHyprNotificationOverlay->addNotification(message, color, time, (eIcons)icon);
+
+    return "ok";
+}
+
 std::string getReply(std::string request) {
     auto format = HyprCtl::FORMAT_NORMAL;
 
@@ -913,6 +1226,18 @@ std::string getReply(std::string request) {
         return splashRequest();
     else if (request == "cursorpos")
         return cursorPosRequest(format);
+    else if (request == "binds")
+        return bindsRequest(format);
+    else if (request == "animations")
+        return animationsRequest(format);
+    else if (request.find("plugin") == 0)
+        return dispatchPlugin(request);
+    else if (request.find("notify") == 0)
+        return dispatchNotify(request);
+    else if (request.find("setprop") == 0)
+        return dispatchSetProp(request);
+    else if (request.find("seterror") == 0)
+        return dispatchSeterror(request);
     else if (request.find("switchxkblayout") == 0)
         return switchXKBLayoutRequest(request);
     else if (request.find("output") == 0)
@@ -931,6 +1256,10 @@ std::string getReply(std::string request) {
     return "unknown request";
 }
 
+std::string HyprCtl::makeDynamicCall(const std::string& input) {
+    return getReply(input);
+}
+
 int hyprCtlFDTick(int fd, uint32_t mask, void* data) {
     if (mask & WL_EVENT_ERROR || mask & WL_EVENT_HANGUP)
         return 0;
@@ -961,7 +1290,7 @@ int hyprCtlFDTick(int fd, uint32_t mask, void* data) {
     close(ACCEPTEDCONNECTION);
 
     if (g_pConfigManager->m_bWantsMonitorReload) {
-        g_pConfigManager->ensureDPMS();
+        g_pConfigManager->ensureMonitorStatus();
     }
 
     return 0;

src/debug/HyprCtl.hpp

@@ -5,7 +5,8 @@
 #include "../helpers/MiscFunctions.hpp"
 
 namespace HyprCtl {
-    void startHyprCtlSocket();
+    void        startHyprCtlSocket();
+    std::string makeDynamicCall(const std::string& input);
 
     // very simple thread-safe request method
     inline bool             requestMade  = false;
@@ -18,8 +19,7 @@ namespace HyprCtl {
 
     inline int              iSocketFD = -1;
 
-    enum eHyprCtlOutputFormat
-    {
+    enum eHyprCtlOutputFormat {
         FORMAT_NORMAL = 0,
         FORMAT_JSON
     };

src/debug/HyprDebugOverlay.cpp

@@ -31,6 +31,15 @@ void CHyprMonitorDebugOverlay::frameData(CMonitor* pMonitor) {
 
     if (!m_pMonitor)
         m_pMonitor = pMonitor;
+
+    // anim data too
+    const auto PMONITORFORTICKS = g_pHyprRenderer->m_pMostHzMonitor ? g_pHyprRenderer->m_pMostHzMonitor : g_pCompositor->m_pLastMonitor;
+    if (PMONITORFORTICKS) {
+        if (m_dLastAnimationTicks.size() > (long unsigned int)PMONITORFORTICKS->refreshRate)
+            m_dLastAnimationTicks.pop_front();
+
+        m_dLastAnimationTicks.push_back(g_pAnimationManager->m_fLastTickTime);
+    }
 }
 
 int CHyprMonitorDebugOverlay::draw(int offset) {
@@ -45,27 +54,61 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
 
     // get avg fps
     float avgFrametime = 0;
+    float maxFrametime = 0;
+    float minFrametime = 9999;
     for (auto& ft : m_dLastFrametimes) {
+        if (ft > maxFrametime)
+            maxFrametime = ft;
+        if (ft < minFrametime)
+            minFrametime = ft;
         avgFrametime += ft;
     }
+    float varFrametime = maxFrametime - minFrametime;
     avgFrametime /= m_dLastFrametimes.size() == 0 ? 1 : m_dLastFrametimes.size();
 
     float avgRenderTime = 0;
+    float maxRenderTime = 0;
+    float minRenderTime = 9999;
     for (auto& rt : m_dLastRenderTimes) {
+        if (rt > maxRenderTime)
+            maxRenderTime = rt;
+        if (rt < minRenderTime)
+            minRenderTime = rt;
         avgRenderTime += rt;
     }
+    float varRenderTime = maxRenderTime - minRenderTime;
     avgRenderTime /= m_dLastRenderTimes.size() == 0 ? 1 : m_dLastRenderTimes.size();
 
     float avgRenderTimeNoOverlay = 0;
+    float maxRenderTimeNoOverlay = 0;
+    float minRenderTimeNoOverlay = 9999;
     for (auto& rt : m_dLastRenderTimesNoOverlay) {
+        if (rt > maxRenderTimeNoOverlay)
+            maxRenderTimeNoOverlay = rt;
+        if (rt < minRenderTimeNoOverlay)
+            minRenderTimeNoOverlay = rt;
         avgRenderTimeNoOverlay += rt;
     }
+    float varRenderTimeNoOverlay = maxRenderTimeNoOverlay - minRenderTimeNoOverlay;
     avgRenderTimeNoOverlay /= m_dLastRenderTimes.size() == 0 ? 1 : m_dLastRenderTimes.size();
 
+    float avgAnimMgrTick = 0;
+    float maxAnimMgrTick = 0;
+    float minAnimMgrTick = 9999;
+    for (auto& at : m_dLastAnimationTicks) {
+        if (at > maxAnimMgrTick)
+            maxAnimMgrTick = at;
+        if (at < minAnimMgrTick)
+            minAnimMgrTick = at;
+        avgAnimMgrTick += at;
+    }
+    float varAnimMgrTick = maxAnimMgrTick - minAnimMgrTick;
+    avgAnimMgrTick /= m_dLastAnimationTicks.size() == 0 ? 1 : m_dLastAnimationTicks.size();
+
     const float FPS      = 1.f / (avgFrametime / 1000.f); // frametimes are in ms
     const float idealFPS = m_dLastFrametimes.size();
 
-    cairo_select_font_face(g_pDebugOverlay->m_pCairo, "Noto Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+    cairo_select_font_face(g_pDebugOverlay->m_pCairo, "Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
 
     cairo_set_font_size(g_pDebugOverlay->m_pCairo, 10);
     cairo_set_source_rgba(g_pDebugOverlay->m_pCairo, 1.f, 1.f, 1.f, 1.f);
@@ -89,7 +132,7 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
 
     yOffset += 17;
     cairo_move_to(g_pDebugOverlay->m_pCairo, 0, yOffset);
-    text = std::string(std::to_string((int)FPS) + " FPS");
+    text = std::string(getFormat("%i FPS", (int)FPS));
     cairo_show_text(g_pDebugOverlay->m_pCairo, text.c_str());
     cairo_text_extents(g_pDebugOverlay->m_pCairo, text.c_str(), &cairoExtents);
     if (cairoExtents.width > maxX)
@@ -100,7 +143,7 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
 
     yOffset += 11;
     cairo_move_to(g_pDebugOverlay->m_pCairo, 0, yOffset);
-    text = std::string("Avg Frametime: " + std::to_string((int)avgFrametime) + "." + std::to_string((int)(avgFrametime * 10.f) % 10) + "ms");
+    text = std::string(getFormat("Avg Frametime: %.2fms (var %.2fms)", avgFrametime, varFrametime));
     cairo_show_text(g_pDebugOverlay->m_pCairo, text.c_str());
     cairo_text_extents(g_pDebugOverlay->m_pCairo, text.c_str(), &cairoExtents);
     if (cairoExtents.width > maxX)
@@ -108,7 +151,7 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
 
     yOffset += 11;
     cairo_move_to(g_pDebugOverlay->m_pCairo, 0, yOffset);
-    text = std::string("Avg Rendertime: " + std::to_string((int)avgRenderTime) + "." + std::to_string((int)(avgRenderTime * 10.f) % 10) + "ms");
+    text = std::string(getFormat("Avg Rendertime: %.2fms (var %.2fms)", avgRenderTime, varRenderTime));
     cairo_show_text(g_pDebugOverlay->m_pCairo, text.c_str());
     cairo_text_extents(g_pDebugOverlay->m_pCairo, text.c_str(), &cairoExtents);
     if (cairoExtents.width > maxX)
@@ -116,7 +159,15 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
 
     yOffset += 11;
     cairo_move_to(g_pDebugOverlay->m_pCairo, 0, yOffset);
-    text = std::string("Avg Rendertime (no overlay): " + std::to_string((int)avgRenderTimeNoOverlay) + "." + std::to_string((int)(avgRenderTimeNoOverlay * 10.f) % 10) + "ms");
+    text = std::string(getFormat("Avg Rendertime (No Overlay): %.2fms (var %.2fms)", avgRenderTimeNoOverlay, varRenderTimeNoOverlay));
+    cairo_show_text(g_pDebugOverlay->m_pCairo, text.c_str());
+    cairo_text_extents(g_pDebugOverlay->m_pCairo, text.c_str(), &cairoExtents);
+    if (cairoExtents.width > maxX)
+        maxX = cairoExtents.width;
+
+    yOffset += 11;
+    cairo_move_to(g_pDebugOverlay->m_pCairo, 0, yOffset);
+    text = std::string(getFormat("Avg Anim Tick: %.2fms (var %.2fms) (%.2f TPS)", avgAnimMgrTick, varAnimMgrTick, 1.0 / (avgAnimMgrTick / 1000.0)));
     cairo_show_text(g_pDebugOverlay->m_pCairo, text.c_str());
     cairo_text_extents(g_pDebugOverlay->m_pCairo, text.c_str(), &cairoExtents);
     if (cairoExtents.width > maxX)
@@ -149,7 +200,7 @@ void CHyprDebugOverlay::draw() {
     const auto PMONITOR = g_pCompositor->m_vMonitors.front().get();
 
     if (!m_pCairoSurface || !m_pCairo) {
-        m_pCairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->vecSize.x, PMONITOR->vecSize.y);
+        m_pCairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
         m_pCairo        = cairo_create(m_pCairoSurface);
     }
 
@@ -180,7 +231,7 @@ void CHyprDebugOverlay::draw() {
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
 #endif
 
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->vecSize.x, PMONITOR->vecSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
 
     wlr_box pMonBox = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
     g_pHyprOpenGL->renderTexture(m_tTexture, &pMonBox, 1.f);

src/debug/HyprDebugOverlay.hpp

@@ -7,6 +7,8 @@
 #include <cairo/cairo.h>
 #include <unordered_map>
 
+class CHyprRenderer;
+
 class CHyprMonitorDebugOverlay {
   public:
     int  draw(int offset);
@@ -19,9 +21,12 @@ class CHyprMonitorDebugOverlay {
     std::deque<float>                              m_dLastFrametimes;
     std::deque<float>                              m_dLastRenderTimes;
     std::deque<float>                              m_dLastRenderTimesNoOverlay;
+    std::deque<float>                              m_dLastAnimationTicks;
     std::chrono::high_resolution_clock::time_point m_tpLastFrame;
     CMonitor*                                      m_pMonitor = nullptr;
     wlr_box                                        m_wbLastDrawnBox;
+
+    friend class CHyprRenderer;
 };
 
 class CHyprDebugOverlay {
@@ -40,6 +45,7 @@ class CHyprDebugOverlay {
     CTexture                                                m_tTexture;
 
     friend class CHyprMonitorDebugOverlay;
+    friend class CHyprRenderer;
 };
 
 inline std::unique_ptr<CHyprDebugOverlay> g_pDebugOverlay;

src/debug/HyprNotificationOverlay.cpp

@@ -0,0 +1,225 @@
+#include "HyprNotificationOverlay.hpp"
+#include "../Compositor.hpp"
+#include <pango/pangocairo.h>
+
+CHyprNotificationOverlay::CHyprNotificationOverlay() {
+    g_pHookSystem->hookDynamic("focusedMon", [&](void* self, std::any param) {
+        if (m_dNotifications.size() == 0)
+            return;
+
+        g_pHyprRenderer->damageBox(&m_bLastDamage);
+    });
+
+    // check for the icon backend
+    std::string fonts      = execAndGet("fc-list");
+    std::string fontsLower = fonts;
+    std::transform(fontsLower.begin(), fontsLower.end(), fontsLower.begin(), [&](char& i) { return std::tolower(i); });
+
+    size_t index = 0;
+
+    if (index = fontsLower.find("nerd"); index != std::string::npos) {
+        m_eIconBackend = ICONS_BACKEND_NF;
+    } else if (index = fontsLower.find("font awesome"); index != std::string::npos) {
+        m_eIconBackend = ICONS_BACKEND_FA;
+    } else if (index = fontsLower.find("fontawesome"); index != std::string::npos) {
+        m_eIconBackend = ICONS_BACKEND_FA;
+    } else {
+        return;
+    }
+
+    const auto LASTNEWLINE = fonts.find_last_of('\n', index);
+    const auto COLON       = fonts.find(':', LASTNEWLINE);
+    const auto COMMA       = fonts.find(',', COLON);
+    const auto NEWLINE     = fonts.find('\n', COLON);
+    const auto LASTCHAR    = COMMA < NEWLINE ? COMMA : NEWLINE;
+
+    m_szIconFontName = fonts.substr(COLON + 2, LASTCHAR - (COLON + 2));
+}
+
+void CHyprNotificationOverlay::addNotification(const std::string& text, const CColor& color, const float timeMs, const eIcons icon) {
+    const auto PNOTIF = m_dNotifications.emplace_back(std::make_unique<SNotification>()).get();
+
+    PNOTIF->text  = text;
+    PNOTIF->color = color == CColor(0) ? ICONS_COLORS[icon] : color;
+    PNOTIF->started.reset();
+    PNOTIF->timeMs = timeMs;
+    PNOTIF->icon   = icon;
+}
+
+wlr_box CHyprNotificationOverlay::drawNotifications(CMonitor* pMonitor) {
+    static constexpr auto ANIM_DURATION_MS   = 600.0;
+    static constexpr auto ANIM_LAG_MS        = 100.0;
+    static constexpr auto NOTIF_LEFTBAR_SIZE = 5.0;
+    static constexpr auto ICON_PAD           = 3.0;
+    static constexpr auto ICON_SCALE         = 0.9;
+    static constexpr auto GRADIENT_SIZE      = 60.0;
+
+    float                 offsetY  = 10;
+    float                 maxWidth = 0;
+
+    const auto            SCALE    = pMonitor->scale;
+    const auto            FONTSIZE = std::clamp((int)(13.f * ((pMonitor->vecPixelSize.x * SCALE) / 1920.f)), 8, 40);
+
+    const auto            MONSIZE = pMonitor->vecPixelSize;
+
+    cairo_text_extents_t  cairoExtents;
+    int                   iconW = 0, iconH = 0;
+
+    PangoLayout*          pangoLayout;
+    PangoFontDescription* pangoFD;
+
+    pangoLayout = pango_cairo_create_layout(m_pCairo);
+    pangoFD     = pango_font_description_from_string(("Sans " + std::to_string(FONTSIZE * ICON_SCALE)).c_str());
+    pango_layout_set_font_description(pangoLayout, pangoFD);
+
+    cairo_select_font_face(m_pCairo, "Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+    cairo_set_font_size(m_pCairo, FONTSIZE);
+
+    const auto PBEZIER = g_pAnimationManager->getBezier("default");
+
+    for (auto& notif : m_dNotifications) {
+        const auto ICONPADFORNOTIF = notif->icon == ICON_NONE ? 0 : ICON_PAD;
+
+        // first rect (bg, col)
+        const float FIRSTRECTANIMP =
+            (notif->started.getMillis() > (ANIM_DURATION_MS - ANIM_LAG_MS) ?
+                 (notif->started.getMillis() > notif->timeMs - (ANIM_DURATION_MS - ANIM_LAG_MS) ? notif->timeMs - notif->started.getMillis() : (ANIM_DURATION_MS - ANIM_LAG_MS)) :
+                 notif->started.getMillis()) /
+            (ANIM_DURATION_MS - ANIM_LAG_MS);
+
+        const float FIRSTRECTPERC = FIRSTRECTANIMP >= 0.99f ? 1.f : PBEZIER->getYForPoint(FIRSTRECTANIMP);
+
+        // second rect (fg, black)
+        const float SECONDRECTANIMP = (notif->started.getMillis() > ANIM_DURATION_MS ?
+                                           (notif->started.getMillis() > notif->timeMs - ANIM_DURATION_MS ? notif->timeMs - notif->started.getMillis() : ANIM_DURATION_MS) :
+                                           notif->started.getMillis()) /
+            ANIM_DURATION_MS;
+
+        const float SECONDRECTPERC = SECONDRECTANIMP >= 0.99f ? 1.f : PBEZIER->getYForPoint(SECONDRECTANIMP);
+
+        // third rect (horiz, col)
+        const float THIRDRECTPERC = notif->started.getMillis() / notif->timeMs;
+
+        // get text size
+        cairo_text_extents(m_pCairo, notif->text.c_str(), &cairoExtents);
+        const auto ICON      = ICONS_ARRAY[m_eIconBackend][notif->icon];
+        const auto ICONCOLOR = ICONS_COLORS[notif->icon];
+        pango_layout_set_text(pangoLayout, ICON.c_str(), -1);
+        pango_layout_set_font_description(pangoLayout, pangoFD);
+        pango_cairo_update_layout(m_pCairo, pangoLayout);
+        pango_layout_get_size(pangoLayout, &iconW, &iconH);
+        iconW /= PANGO_SCALE;
+        iconH /= PANGO_SCALE;
+
+        cairo_set_source_rgba(m_pCairo, notif->color.r, notif->color.g, notif->color.b, notif->color.a);
+
+        const auto NOTIFSIZE = Vector2D{cairoExtents.width + 20 + iconW + 2 * ICONPADFORNOTIF, cairoExtents.height + 10};
+
+        // draw rects
+        cairo_rectangle(m_pCairo, MONSIZE.x - (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC, offsetY, (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC, NOTIFSIZE.y);
+        cairo_fill(m_pCairo);
+
+        cairo_set_source_rgb(m_pCairo, 0.f, 0.f, 0.f);
+
+        cairo_rectangle(m_pCairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC, offsetY, NOTIFSIZE.x * SECONDRECTPERC, NOTIFSIZE.y);
+        cairo_fill(m_pCairo);
+
+        cairo_set_source_rgba(m_pCairo, notif->color.r, notif->color.g, notif->color.b, notif->color.a);
+
+        cairo_rectangle(m_pCairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC + 3, offsetY + NOTIFSIZE.y - 4, THIRDRECTPERC * (NOTIFSIZE.x - 6), 2);
+        cairo_fill(m_pCairo);
+
+        // draw gradient
+        if (notif->icon != ICON_NONE) {
+            cairo_pattern_t* pattern;
+            pattern = cairo_pattern_create_linear(MONSIZE.x - (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC, offsetY,
+                                                  MONSIZE.x - (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC + GRADIENT_SIZE, offsetY);
+            cairo_pattern_add_color_stop_rgba(pattern, 0, ICONCOLOR.r, ICONCOLOR.g, ICONCOLOR.b, ICONCOLOR.a / 3.0);
+            cairo_pattern_add_color_stop_rgba(pattern, 1, ICONCOLOR.r, ICONCOLOR.g, ICONCOLOR.b, 0);
+            cairo_rectangle(m_pCairo, MONSIZE.x - (NOTIFSIZE.x + NOTIF_LEFTBAR_SIZE) * FIRSTRECTPERC, offsetY, GRADIENT_SIZE, NOTIFSIZE.y);
+            cairo_set_source(m_pCairo, pattern);
+            cairo_fill(m_pCairo);
+            cairo_pattern_destroy(pattern);
+
+            // draw icon
+            cairo_set_source_rgb(m_pCairo, 1.f, 1.f, 1.f);
+            cairo_move_to(m_pCairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC + NOTIF_LEFTBAR_SIZE + ICONPADFORNOTIF - 1, offsetY + std::round((NOTIFSIZE.y - iconH - 4) / 2.0));
+            pango_cairo_show_layout(m_pCairo, pangoLayout);
+        }
+
+        // draw text
+        cairo_set_font_size(m_pCairo, FONTSIZE);
+        cairo_set_source_rgb(m_pCairo, 1.f, 1.f, 1.f);
+        cairo_move_to(m_pCairo, MONSIZE.x - NOTIFSIZE.x * SECONDRECTPERC + NOTIF_LEFTBAR_SIZE + iconW + 2 * ICONPADFORNOTIF, offsetY + FONTSIZE + (FONTSIZE / 10.0));
+        cairo_show_text(m_pCairo, notif->text.c_str());
+
+        // adjust offset and move on
+        offsetY += NOTIFSIZE.y + 10;
+
+        if (maxWidth < NOTIFSIZE.x)
+            maxWidth = NOTIFSIZE.x;
+    }
+
+    pango_font_description_free(pangoFD);
+    g_object_unref(pangoLayout);
+
+    // cleanup notifs
+    std::erase_if(m_dNotifications, [](const auto& notif) { return notif->started.getMillis() > notif->timeMs; });
+
+    return wlr_box{(int)(pMonitor->vecPosition.x + pMonitor->vecSize.x - maxWidth - 20), (int)pMonitor->vecPosition.y, (int)maxWidth + 20, (int)offsetY + 10};
+}
+
+void CHyprNotificationOverlay::draw(CMonitor* pMonitor) {
+
+    if (m_pLastMonitor != pMonitor || !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_pCairo        = cairo_create(m_pCairoSurface);
+        m_pLastMonitor  = pMonitor;
+    }
+
+    // Draw the notifications
+    if (m_dNotifications.size() == 0)
+        return;
+
+    // Render to the monitor
+
+    // clear the pixmap
+    cairo_save(m_pCairo);
+    cairo_set_operator(m_pCairo, CAIRO_OPERATOR_CLEAR);
+    cairo_paint(m_pCairo);
+    cairo_restore(m_pCairo);
+
+    cairo_surface_flush(m_pCairoSurface);
+
+    wlr_box damage = drawNotifications(pMonitor);
+
+    g_pHyprRenderer->damageBox(&damage);
+    g_pHyprRenderer->damageBox(&m_bLastDamage);
+
+    g_pCompositor->scheduleFrameForMonitor(pMonitor);
+
+    m_bLastDamage = damage;
+
+    // copy the data to an OpenGL texture we have
+    const auto DATA = cairo_image_surface_get_data(m_pCairoSurface);
+    m_tTexture.allocate();
+    glBindTexture(GL_TEXTURE_2D, m_tTexture.m_iTexID);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+
+#ifndef GLES2
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
+    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);
+
+    wlr_box pMonBox = {0, 0, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y};
+    g_pHyprOpenGL->renderTexture(m_tTexture, &pMonBox, 1.f);
+}

src/debug/HyprNotificationOverlay.hpp

@@ -0,0 +1,63 @@
+#pragma once
+
+#include "../defines.hpp"
+#include "../helpers/Timer.hpp"
+#include "../helpers/Monitor.hpp"
+#include "../render/Texture.hpp"
+#include "../SharedDefs.hpp"
+
+#include <deque>
+
+#include <cairo/cairo.h>
+
+enum eIconBackend
+{
+    ICONS_BACKEND_NONE = 0,
+    ICONS_BACKEND_NF,
+    ICONS_BACKEND_FA
+};
+
+static const std::array<std::array<std::string, ICON_NONE + 1>, 3 /* backends */> ICONS_ARRAY = {
+    std::array<std::string, ICON_NONE + 1>{"[!]", "[i]", "[Hint]", "[Err]", "[?]", "[ok]", ""}, std::array<std::string, ICON_NONE + 1>{"", "", "", "", "", "󰸞", ""},
+    std::array<std::string, ICON_NONE + 1>{"", "", "", "", "", ""}};
+static const std::array<CColor, ICON_NONE + 1> ICONS_COLORS = {CColor{255.0 / 255.0, 204 / 255.0, 102 / 255.0, 1.0},
+                                                               CColor{128 / 255.0, 255 / 255.0, 255 / 255.0, 1.0},
+                                                               CColor{179 / 255.0, 255 / 255.0, 204 / 255.0, 1.0},
+                                                               CColor{255 / 255.0, 77 / 255.0, 77 / 255.0, 1.0},
+                                                               CColor{255 / 255.0, 204 / 255.0, 153 / 255.0, 1.0},
+                                                               CColor{128 / 255.0, 255 / 255.0, 128 / 255.0, 1.0},
+                                                               CColor{0, 0, 0, 1.0}};
+
+struct SNotification {
+    std::string text = "";
+    CColor      color;
+    CTimer      started;
+    float       timeMs = 0;
+    eIcons      icon   = ICON_NONE;
+};
+
+class CHyprNotificationOverlay {
+  public:
+    CHyprNotificationOverlay();
+
+    void draw(CMonitor* pMonitor);
+    void addNotification(const std::string& text, const CColor& color, const float timeMs, const eIcons icon = ICON_NONE);
+
+  private:
+    wlr_box                                    drawNotifications(CMonitor* pMonitor);
+    wlr_box                                    m_bLastDamage;
+
+    std::deque<std::unique_ptr<SNotification>> m_dNotifications;
+
+    cairo_surface_t*                           m_pCairoSurface = nullptr;
+    cairo_t*                                   m_pCairo        = nullptr;
+
+    CMonitor*                                  m_pLastMonitor = nullptr;
+
+    CTexture                                   m_tTexture;
+
+    eIconBackend                               m_eIconBackend   = ICONS_BACKEND_NONE;
+    std::string                                m_szIconFontName = "Sans";
+};
+
+inline std::unique_ptr<CHyprNotificationOverlay> g_pHyprNotificationOverlay;

src/debug/Log.cpp

@@ -23,6 +23,9 @@ void Debug::wlrLog(wlr_log_importance level, const char* fmt, va_list args) {
     ofs << "[wlr] " << output << "\n";
 
     ofs.close();
+
+    if (!disableStdout)
+        std::cout << output << "\n";
 }
 
 void Debug::log(LogLevel level, const char* fmt, ...) {
@@ -75,5 +78,6 @@ void Debug::log(LogLevel level, const char* fmt, ...) {
     ofs.close();
 
     // log it to the stdout too.
-    std::cout << output << "\n";
+    if (!disableStdout)
+        std::cout << output << "\n";
 }

src/debug/Log.hpp

@@ -20,6 +20,7 @@ namespace Debug {
     void               wlrLog(wlr_log_importance level, const char* fmt, va_list args);
 
     inline std::string logFile;
-    inline int64_t*    disableLogs = nullptr;
-    inline int64_t*    disableTime = nullptr;
+    inline int64_t*    disableLogs   = nullptr;
+    inline int64_t*    disableTime   = nullptr;
+    inline bool        disableStdout = false;
 };

src/defines.hpp

@@ -89,4 +89,4 @@
 
 #define SPECIAL_WORKSPACE_START (-99)
 
-#define PI 3.14159265358979
+#define PI 3.14159265358979

src/events/Devices.cpp

@@ -109,10 +109,8 @@ void Events::listener_newConstraint(wl_listener* listener, void* data) {
     if (g_pCompositor->m_pLastFocus == PCONSTRAINT->surface) {
         g_pInputManager->constrainMouse(CONSTRAINT->pMouse, PCONSTRAINT);
 
-        if (!CONSTRAINT->hintSet) {
-            const auto PWINDOW       = g_pCompositor->getConstraintWindow(g_pCompositor->m_sSeat.mouse);
-            CONSTRAINT->positionHint = g_pInputManager->getMouseCoordsInternal() - PWINDOW->m_vRealPosition.goalv();
-        }
+        if (!CONSTRAINT->hintSet)
+            CONSTRAINT->positionHint = Vector2D{-1, -1};
     }
 }
 
@@ -124,7 +122,7 @@ void Events::listener_destroyConstraint(void* owner, void* data) {
 
         const auto PWINDOW = g_pCompositor->getConstraintWindow(g_pCompositor->m_sSeat.mouse);
 
-        if (PWINDOW) {
+        if (PWINDOW && PCONSTRAINT->positionHint != Vector2D{-1, -1}) {
             if (PWINDOW->m_bIsX11) {
                 wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, PCONSTRAINT->positionHint.x + PWINDOW->m_uSurface.xwayland->x,
                                 PWINDOW->m_uSurface.xwayland->y + PCONSTRAINT->positionHint.y);

src/events/Events.hpp

@@ -58,6 +58,7 @@ namespace Events {
     DYNLISTENFUNC(requestResize);
     DYNLISTENFUNC(requestMinimize);
     DYNLISTENFUNC(requestMaximize);
+    DYNLISTENFUNC(setOverrideRedirect);
 
     // Window subsurfaces
     // LISTENER(newSubsurfaceWindow);
@@ -97,6 +98,8 @@ namespace Events {
     DYNLISTENFUNC(monitorFrame);
     DYNLISTENFUNC(monitorDestroy);
     DYNLISTENFUNC(monitorStateRequest);
+    DYNLISTENFUNC(monitorDamage);
+    DYNLISTENFUNC(monitorNeedsFrame);
 
     // XWayland
     LISTENER(readyXWayland);
@@ -157,4 +160,7 @@ namespace Events {
 
     LISTENER(holdBegin);
     LISTENER(holdEnd);
+
+    // Session Lock
+    LISTENER(newSessionLock);
 };

src/events/Layers.cpp

@@ -38,7 +38,7 @@ void Events::listener_newLayerSurface(wl_listener* listener, void* data) {
         WLRLAYERSURFACE->output = PMONITOR->output; // TODO: current mon
     }
 
-    SLayerSurface* layerSurface = PMONITOR->m_aLayerSurfaceLists[WLRLAYERSURFACE->pending.layer].emplace_back(std::make_unique<SLayerSurface>()).get();
+    SLayerSurface* layerSurface = PMONITOR->m_aLayerSurfaceLayers[WLRLAYERSURFACE->pending.layer].emplace_back(std::make_unique<SLayerSurface>()).get();
 
     layerSurface->szNamespace = WLRLAYERSURFACE->_namespace;
 
@@ -112,6 +112,8 @@ void Events::listener_mapLayerSurface(void* owner, void* data) {
     layersurface->layerSurface->mapped = true;
     layersurface->mapped               = true;
 
+    layersurface->surface = layersurface->layerSurface->surface;
+
     // anim
     layersurface->alpha.setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeIn"));
 
@@ -121,12 +123,14 @@ void Events::listener_mapLayerSurface(void* owner, void* data) {
     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_aLayerSurfaceLists[layersurface->layer].begin(); it != POLDMON->m_aLayerSurfaceLists[layersurface->layer].end(); it++) {
+        for (auto it = POLDMON->m_aLayerSurfaceLayers[layersurface->layer].begin(); it != POLDMON->m_aLayerSurfaceLayers[layersurface->layer].end(); it++) {
             if (it->get() == layersurface) {
-                PMONITOR->m_aLayerSurfaceLists[layersurface->layer].emplace_back(std::move(*it));
-                POLDMON->m_aLayerSurfaceLists[layersurface->layer].erase(it);
+                PMONITOR->m_aLayerSurfaceLayers[layersurface->layer].emplace_back(std::move(*it));
+                POLDMON->m_aLayerSurfaceLayers[layersurface->layer].erase(it);
                 break;
             }
         }
@@ -161,6 +165,9 @@ void Events::listener_mapLayerSurface(void* owner, void* data) {
     layersurface->fadingOut     = false;
 
     g_pEventManager->postEvent(SHyprIPCEvent{"openlayer", std::string(layersurface->layerSurface->_namespace ? layersurface->layerSurface->_namespace : "")});
+    EMIT_HOOK_EVENT("openLayer", layersurface);
+
+    g_pProtocolManager->m_pFractionalScaleProtocolManager->setPreferredScaleForSurface(layersurface->layerSurface->surface, PMONITOR->scale);
 }
 
 void Events::listener_unmapLayerSurface(void* owner, void* data) {
@@ -169,6 +176,7 @@ void Events::listener_unmapLayerSurface(void* owner, void* data) {
     Debug::log(LOG, "LayerSurface %x unmapped", layersurface->layerSurface);
 
     g_pEventManager->postEvent(SHyprIPCEvent{"closelayer", std::string(layersurface->layerSurface->_namespace ? layersurface->layerSurface->_namespace : "")});
+    EMIT_HOOK_EVENT("closeLayer", layersurface);
 
     if (!g_pCompositor->getMonitorFromID(layersurface->monitorID) || g_pCompositor->m_bUnsafeState) {
         Debug::log(WARN, "Layersurface unmapping on invalid monitor (removed?) ignoring.");
@@ -201,11 +209,16 @@ void Events::listener_unmapLayerSurface(void* owner, void* data) {
 
     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 (layersurface->layerSurface->surface == g_pCompositor->m_pLastFocus) {
+    if (WASLASTFOCUS) {
+        g_pInputManager->releaseAllMouseButtons();
 
         Vector2D       surfaceCoords;
         SLayerSurface* pFoundLayerSurface = nullptr;
@@ -214,11 +227,11 @@ void Events::listener_unmapLayerSurface(void* owner, void* data) {
         g_pCompositor->m_pLastFocus = nullptr;
 
         // find LS-es to focus
-        foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
+        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_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
+            foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
                                                                &surfaceCoords, &pFoundLayerSurface);
 
         if (!foundSurface) {
@@ -239,10 +252,6 @@ void Events::listener_unmapLayerSurface(void* owner, void* data) {
     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);
-
-    geomFixed              = {layersurface->geometry.x, layersurface->geometry.y, (int)layersurface->layerSurface->surface->current.width,
-                              (int)layersurface->layerSurface->surface->current.height};
-    layersurface->geometry = geomFixed; // because the surface can overflow... for some reason?
 }
 
 void Events::listener_commitLayerSurface(void* owner, void* data) {
@@ -266,10 +275,10 @@ void Events::listener_commitLayerSurface(void* owner, void* data) {
     if ((uint64_t)layersurface->monitorID != PMONITOR->ID) {
         const auto POLDMON = g_pCompositor->getMonitorFromID(layersurface->monitorID);
 
-        for (auto it = POLDMON->m_aLayerSurfaceLists[layersurface->layer].begin(); it != POLDMON->m_aLayerSurfaceLists[layersurface->layer].end(); it++) {
+        for (auto it = POLDMON->m_aLayerSurfaceLayers[layersurface->layer].begin(); it != POLDMON->m_aLayerSurfaceLayers[layersurface->layer].end(); it++) {
             if (it->get() == layersurface) {
-                PMONITOR->m_aLayerSurfaceLists[layersurface->layer].emplace_back(std::move(*it));
-                POLDMON->m_aLayerSurfaceLists[layersurface->layer].erase(it);
+                PMONITOR->m_aLayerSurfaceLayers[layersurface->layer].emplace_back(std::move(*it));
+                POLDMON->m_aLayerSurfaceLayers[layersurface->layer].erase(it);
                 break;
             }
         }
@@ -282,10 +291,10 @@ void Events::listener_commitLayerSurface(void* owner, void* data) {
     if (layersurface->layerSurface->current.committed != 0) {
         if (layersurface->layer != layersurface->layerSurface->current.layer) {
 
-            for (auto it = PMONITOR->m_aLayerSurfaceLists[layersurface->layer].begin(); it != PMONITOR->m_aLayerSurfaceLists[layersurface->layer].end(); it++) {
+            for (auto it = PMONITOR->m_aLayerSurfaceLayers[layersurface->layer].begin(); it != PMONITOR->m_aLayerSurfaceLayers[layersurface->layer].end(); it++) {
                 if (it->get() == layersurface) {
-                    PMONITOR->m_aLayerSurfaceLists[layersurface->layerSurface->current.layer].emplace_back(std::move(*it));
-                    PMONITOR->m_aLayerSurfaceLists[layersurface->layer].erase(it);
+                    PMONITOR->m_aLayerSurfaceLayers[layersurface->layerSurface->current.layer].emplace_back(std::move(*it));
+                    PMONITOR->m_aLayerSurfaceLayers[layersurface->layer].erase(it);
                     break;
                 }
             }
@@ -299,13 +308,22 @@ void Events::listener_commitLayerSurface(void* owner, void* data) {
         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};
+        }
     }
 
-    layersurface->position = Vector2D(layersurface->geometry.x, layersurface->geometry.y);
-
-    // update geom if it changed
-    layersurface->geometry = {layersurface->geometry.x, layersurface->geometry.y, layersurface->layerSurface->surface->current.width,
-                              layersurface->layerSurface->surface->current.height};
-
     g_pHyprRenderer->damageSurface(layersurface->layerSurface->surface, layersurface->position.x, layersurface->position.y);
+
+    g_pProtocolManager->m_pFractionalScaleProtocolManager->setPreferredScaleForSurface(layersurface->layerSurface->surface, PMONITOR->scale);
 }

src/events/Misc.cpp

@@ -116,20 +116,11 @@ void Events::listener_startDrag(wl_listener* listener, void* data) {
         g_pInputManager->m_sDrag.hyprListener_commitIcon.initCallback(&wlrDrag->icon->surface->events.commit, &Events::listener_commitDragIcon, &g_pInputManager->m_sDrag,
                                                                       "DragIcon");
     }
-
-    static auto* const PFOLLOWONDND = &g_pConfigManager->getConfigValuePtr("misc:always_follow_on_dnd")->intValue;
-
-    if (*PFOLLOWONDND)
-        g_pInputManager->m_pFollowOnDnDBegin = g_pCompositor->m_pLastWindow;
-    else
-        g_pInputManager->m_pFollowOnDnDBegin = nullptr;
 }
 
 void Events::listener_destroyDrag(void* owner, void* data) {
     Debug::log(LOG, "Drag destroyed.");
 
-    static auto* const PFOLLOWMOUSE = &g_pConfigManager->getConfigValuePtr("input:follow_mouse")->intValue;
-
     if (g_pInputManager->m_sDrag.drag && g_pInputManager->m_sDrag.dragIcon && g_pInputManager->m_sDrag.dragIcon->surface)
         g_pHyprRenderer->damageBox(g_pInputManager->m_sDrag.pos.x - 2, g_pInputManager->m_sDrag.pos.y - 2, g_pInputManager->m_sDrag.dragIcon->surface->current.width + 4,
                                    g_pInputManager->m_sDrag.dragIcon->surface->current.height + 4);
@@ -137,13 +128,6 @@ void Events::listener_destroyDrag(void* owner, void* data) {
     g_pInputManager->m_sDrag.drag     = nullptr;
     g_pInputManager->m_sDrag.dragIcon = nullptr;
     g_pInputManager->m_sDrag.hyprListener_destroy.removeCallback();
-
-    g_pInputManager->refocus();
-
-    if (g_pInputManager->m_pFollowOnDnDBegin && *PFOLLOWMOUSE != 1)
-        g_pCompositor->focusWindow(g_pInputManager->m_pFollowOnDnDBegin);
-
-    g_pInputManager->m_pFollowOnDnDBegin = nullptr;
 }
 
 void Events::listener_mapDragIcon(void* owner, void* data) {
@@ -224,3 +208,9 @@ void Events::listener_newTextInput(wl_listener* listener, void* data) {
 
     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);
+}

src/events/Monitors.cpp

@@ -20,6 +20,9 @@ void Events::listener_change(wl_listener* listener, void* data) {
     const auto CONFIG = wlr_output_configuration_v1_create();
 
     for (auto& m : g_pCompositor->m_vMonitors) {
+        if (!m->output)
+            continue;
+
         const auto CONFIGHEAD = wlr_output_configuration_head_v1_create(CONFIG, m->output);
 
         // TODO: clients off of disabled
@@ -41,9 +44,12 @@ void Events::listener_change(wl_listener* listener, void* data) {
 }
 
 void Events::listener_newOutput(wl_listener* listener, void* data) {
-    // new monitor added, let's accomodate for that.
+    // 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;
@@ -89,6 +95,20 @@ 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->vecPosition + PNEWMONITOR->vecSize / 2.f;
+        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->updateSurfaceOutputs();
+            }
+        }
+    }
 }
 
 void Events::listener_monitorFrame(void* owner, void* data) {
@@ -96,221 +116,47 @@ void Events::listener_monitorFrame(void* owner, void* data) {
 
     if ((g_pCompositor->m_sWLRSession && !g_pCompositor->m_sWLRSession->active) || !g_pCompositor->m_bSessionActive || g_pCompositor->m_bUnsafeState) {
         Debug::log(WARN, "Attempted to render frame on inactive session!");
+
+        if (g_pCompositor->m_bUnsafeState)
+            g_pConfigManager->performMonitorReload();
+
         return; // cannot draw on session inactive (different tty)
     }
 
     if (!PMONITOR->m_bEnabled)
         return;
 
-    static std::chrono::high_resolution_clock::time_point startRender        = std::chrono::high_resolution_clock::now();
-    static std::chrono::high_resolution_clock::time_point startRenderOverlay = std::chrono::high_resolution_clock::now();
-    static std::chrono::high_resolution_clock::time_point endRenderOverlay   = std::chrono::high_resolution_clock::now();
+    static auto* const PENABLERAT = &g_pConfigManager->getConfigValuePtr("misc:render_ahead_of_time")->intValue;
+    static auto* const PRATSAFE   = &g_pConfigManager->getConfigValuePtr("misc:render_ahead_safezone")->intValue;
 
-    static auto* const                                    PDEBUGOVERLAY       = &g_pConfigManager->getConfigValuePtr("debug:overlay")->intValue;
-    static auto* const                                    PDAMAGETRACKINGMODE = &g_pConfigManager->getConfigValuePtr("debug:damage_tracking")->intValue;
-    static auto* const                                    PDAMAGEBLINK        = &g_pConfigManager->getConfigValuePtr("debug:damage_blink")->intValue;
-    static auto* const                                    PNOVFR              = &g_pConfigManager->getConfigValuePtr("misc:no_vfr")->intValue;
-    static auto* const                                    PNODIRECTSCANOUT    = &g_pConfigManager->getConfigValuePtr("misc:no_direct_scanout")->intValue;
+    PMONITOR->lastPresentationTimer.reset();
 
-    static int                                            damageBlinkCleanup = 0; // because double-buffered
-
-    if (!*PDAMAGEBLINK)
-        damageBlinkCleanup = 0;
-
-    if (*PDEBUGOVERLAY == 1) {
-        startRender = std::chrono::high_resolution_clock::now();
-        g_pDebugOverlay->frameData(PMONITOR);
-    }
-
-    if (PMONITOR->framesToSkip > 0) {
-        PMONITOR->framesToSkip -= 1;
-
-        if (!PMONITOR->noFrameSchedule)
-            g_pCompositor->scheduleFrameForMonitor(PMONITOR);
-        else {
-            Debug::log(LOG, "NoFrameSchedule hit for %s.", PMONITOR->szName.c_str());
+    if (*PENABLERAT) {
+        if (!PMONITOR->RATScheduled) {
+            // render
+            g_pHyprRenderer->renderMonitor(PMONITOR);
         }
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMONITOR->ID);
 
-        if (PMONITOR->framesToSkip > 10)
-            PMONITOR->framesToSkip = 0;
-        return;
-    }
+        PMONITOR->RATScheduled = false;
 
-    // checks //
-    if (PMONITOR->ID == g_pHyprRenderer->m_pMostHzMonitor->ID ||
-        !*PNOVFR) { // unfortunately with VFR we don't have the guarantee mostHz is going to be updated all the time, so we have to ignore that
-        g_pCompositor->sanityCheckWorkspaces();
-        g_pAnimationManager->tick();
+        const auto& [avg, max, min] = g_pHyprRenderer->getRenderTimes(PMONITOR);
 
-        g_pConfigManager->dispatchExecOnce(); // We exec-once when at least one monitor starts refreshing, meaning stuff has init'd
-
-        if (g_pConfigManager->m_bWantsMonitorReload)
-            g_pConfigManager->performMonitorReload();
-
-        g_pHyprRenderer->ensureCursorRenderingMode(); // so that the cursor gets hidden/shown if the user requested timeouts
-    }
-    //       //
-
-    if (PMONITOR->scheduledRecalc) {
-        PMONITOR->scheduledRecalc = false;
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMONITOR->ID);
-    }
-
-    // Direct scanout first
-    if (!*PNODIRECTSCANOUT) {
-        if (g_pHyprRenderer->attemptDirectScanout(PMONITOR)) {
+        if (max + *PRATSAFE > 1000.0 / PMONITOR->refreshRate)
             return;
-        } else if (g_pHyprRenderer->m_pLastScanout) {
-            Debug::log(LOG, "Left a direct scanout.");
-            g_pHyprRenderer->m_pLastScanout = nullptr;
-        }
-    }
 
-    timespec now;
-    clock_gettime(CLOCK_MONOTONIC, &now);
+        const auto MSLEFT = 1000.0 / PMONITOR->refreshRate - PMONITOR->lastPresentationTimer.getMillis();
 
-    // check the damage
-    pixman_region32_t damage;
-    bool              hasChanged;
-    pixman_region32_init(&damage);
+        PMONITOR->RATScheduled = true;
 
-    if (*PDAMAGETRACKINGMODE == -1) {
-        Debug::log(CRIT, "Damage tracking mode -1 ????");
-        return;
-    }
+        const auto ESTRENDERTIME = std::ceil(avg + *PRATSAFE);
+        const auto TIMETOSLEEP   = std::floor(MSLEFT - ESTRENDERTIME);
 
-    g_pHyprOpenGL->preRender(PMONITOR);
-
-    if (!wlr_output_damage_attach_render(PMONITOR->damage, &hasChanged, &damage)) {
-        Debug::log(ERR, "Couldn't attach render to display %s ???", PMONITOR->szName.c_str());
-        return;
-    }
-
-    // we need to cleanup fading out when rendering the appropriate context
-    g_pCompositor->cleanupFadingOut(PMONITOR->ID);
-
-    if (!hasChanged && *PDAMAGETRACKINGMODE != DAMAGE_TRACKING_NONE && PMONITOR->forceFullFrames == 0 && damageBlinkCleanup == 0) {
-        pixman_region32_fini(&damage);
-        wlr_output_rollback(PMONITOR->output);
-
-        if (*PDAMAGEBLINK || *PNOVFR)
-            g_pCompositor->scheduleFrameForMonitor(PMONITOR);
-
-        return;
-    }
-
-    // if we have no tracking or full tracking, invalidate the entire monitor
-    if (*PDAMAGETRACKINGMODE == DAMAGE_TRACKING_NONE || *PDAMAGETRACKINGMODE == DAMAGE_TRACKING_MONITOR || PMONITOR->forceFullFrames > 0 || damageBlinkCleanup > 0 ||
-        PMONITOR->isMirror() /* why??? */) {
-        pixman_region32_union_rect(&damage, &damage, 0, 0, (int)PMONITOR->vecTransformedSize.x * 10, (int)PMONITOR->vecTransformedSize.y * 10); // wot?
-
-        pixman_region32_copy(&g_pHyprOpenGL->m_rOriginalDamageRegion, &damage);
+        if (MSLEFT < 1 || MSLEFT < ESTRENDERTIME || TIMETOSLEEP < 1)
+            g_pHyprRenderer->renderMonitor(PMONITOR);
+        else
+            wl_event_source_timer_update(PMONITOR->renderTimer, TIMETOSLEEP);
     } else {
-        static auto* const PBLURENABLED = &g_pConfigManager->getConfigValuePtr("decoration:blur")->intValue;
-
-        // if we use blur we need to expand the damage for proper blurring
-        if (*PBLURENABLED == 1) {
-            // TODO: can this be optimized?
-            static auto* const PBLURSIZE   = &g_pConfigManager->getConfigValuePtr("decoration:blur_size")->intValue;
-            static auto* const PBLURPASSES = &g_pConfigManager->getConfigValuePtr("decoration:blur_passes")->intValue;
-            const auto         BLURRADIUS  = *PBLURSIZE * pow(2, *PBLURPASSES); // is this 2^pass? I don't know but it works... I think.
-
-            pixman_region32_copy(&g_pHyprOpenGL->m_rOriginalDamageRegion, &damage);
-
-            // now, prep the damage, get the extended damage region
-            wlr_region_expand(&damage, &damage, BLURRADIUS); // expand for proper blurring
-        } else {
-            pixman_region32_copy(&g_pHyprOpenGL->m_rOriginalDamageRegion, &damage);
-        }
-    }
-
-    if (PMONITOR->forceFullFrames > 0) {
-        PMONITOR->forceFullFrames -= 1;
-        if (PMONITOR->forceFullFrames > 10)
-            PMONITOR->forceFullFrames = 0;
-    }
-
-    // TODO: this is getting called with extents being 0,0,0,0 should it be?
-    // potentially can save on resources.
-
-    g_pHyprOpenGL->begin(PMONITOR, &damage);
-
-    if (PMONITOR->isMirror()) {
-        g_pHyprOpenGL->renderMirrored();
-    } else {
-        g_pHyprOpenGL->clear(CColor(17.0 / 255.0, 17.0 / 255.0, 17.0 / 255.0, 1.0));
-        g_pHyprOpenGL->clearWithTex(); // will apply the hypr "wallpaper"
-
-        g_pHyprRenderer->renderAllClientsForMonitor(PMONITOR->ID, &now);
-
-        // if correct monitor draw hyprerror
-        if (PMONITOR == g_pCompositor->m_vMonitors.front().get())
-            g_pHyprError->draw();
-
-        // for drawing the debug overlay
-        if (PMONITOR == g_pCompositor->m_vMonitors.front().get() && *PDEBUGOVERLAY == 1) {
-            startRenderOverlay = std::chrono::high_resolution_clock::now();
-            g_pDebugOverlay->draw();
-            endRenderOverlay = std::chrono::high_resolution_clock::now();
-        }
-
-        if (*PDAMAGEBLINK && damageBlinkCleanup == 0) {
-            wlr_box monrect = {0, 0, PMONITOR->vecTransformedSize.x, PMONITOR->vecTransformedSize.y};
-            g_pHyprOpenGL->renderRect(&monrect, CColor(1.0, 0.0, 1.0, 100.0 / 255.0), 0);
-            damageBlinkCleanup = 1;
-        } else if (*PDAMAGEBLINK) {
-            damageBlinkCleanup++;
-            if (damageBlinkCleanup > 3)
-                damageBlinkCleanup = 0;
-        }
-
-        if (wlr_renderer_begin(g_pCompositor->m_sWLRRenderer, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y)) {
-            wlr_output_render_software_cursors(PMONITOR->output, NULL);
-            wlr_renderer_end(g_pCompositor->m_sWLRRenderer);
-        }
-    }
-
-    g_pHyprOpenGL->end();
-
-    g_pProtocolManager->m_pToplevelExportProtocolManager->onMonitorRender(PMONITOR); // dispatch any toplevel sharing
-
-    // calc frame damage
-    pixman_region32_t frameDamage;
-    pixman_region32_init(&frameDamage);
-
-    const auto TRANSFORM = wlr_output_transform_invert(PMONITOR->output->transform);
-    wlr_region_transform(&frameDamage, &PMONITOR->damage->current, TRANSFORM, (int)PMONITOR->vecTransformedSize.x, (int)PMONITOR->vecTransformedSize.y);
-
-    if (*PDAMAGETRACKINGMODE == DAMAGE_TRACKING_NONE || *PDAMAGETRACKINGMODE == DAMAGE_TRACKING_MONITOR)
-        pixman_region32_union_rect(&frameDamage, &frameDamage, 0, 0, (int)PMONITOR->vecTransformedSize.x, (int)PMONITOR->vecTransformedSize.y);
-
-    if (*PDAMAGEBLINK)
-        pixman_region32_union(&frameDamage, &frameDamage, &damage);
-
-    wlr_output_set_damage(PMONITOR->output, &frameDamage);
-
-    if (!PMONITOR->mirrors.empty())
-        g_pHyprRenderer->damageMirrorsWith(PMONITOR, &frameDamage);
-
-    pixman_region32_fini(&frameDamage);
-    pixman_region32_fini(&damage);
-
-    if (!wlr_output_commit(PMONITOR->output))
-        return;
-
-    if (*PDAMAGEBLINK || *PNOVFR)
-        g_pCompositor->scheduleFrameForMonitor(PMONITOR);
-
-    if (*PDEBUGOVERLAY == 1) {
-        const float µs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - startRender).count() / 1000.f;
-        g_pDebugOverlay->renderData(PMONITOR, µs);
-        if (PMONITOR == g_pCompositor->m_vMonitors.front().get()) {
-            const float µsNoOverlay = µs - std::chrono::duration_cast<std::chrono::nanoseconds>(endRenderOverlay - startRenderOverlay).count() / 1000.f;
-            g_pDebugOverlay->renderDataNoOverlay(PMONITOR, µsNoOverlay);
-        } else {
-            g_pDebugOverlay->renderDataNoOverlay(PMONITOR, µs);
-        }
+        g_pHyprRenderer->renderMonitor(PMONITOR);
     }
 }
 
@@ -333,9 +179,12 @@ void Events::listener_monitorDestroy(void* owner, void* data) {
 
     pMonitor->onDisconnect();
 
+    pMonitor->output                 = nullptr;
+    pMonitor->m_bRenderingInitPassed = false;
+
     // cleanup if not unsafe
     if (!g_pCompositor->m_bUnsafeState) {
-        Debug::log(LOG, "Removing monitor %s from realMonitors", pMonitor->output->name);
+        Debug::log(LOG, "Removing monitor %s from realMonitors", pMonitor->szName.c_str());
 
         std::erase_if(g_pCompositor->m_vRealMonitors, [&](std::shared_ptr<CMonitor>& el) { return el.get() == pMonitor; });
     }
@@ -347,3 +196,16 @@ void Events::listener_monitorStateRequest(void* owner, void* data) {
 
     wlr_output_commit_state(PMONITOR->output, E->state);
 }
+
+void Events::listener_monitorDamage(void* owner, void* data) {
+    const auto PMONITOR = (CMonitor*)owner;
+    const auto E        = (wlr_output_event_damage*)data;
+
+    PMONITOR->addDamage(E->damage);
+}
+
+void Events::listener_monitorNeedsFrame(void* owner, void* data) {
+    const auto PMONITOR = (CMonitor*)owner;
+
+    g_pCompositor->scheduleFrameForMonitor(PMONITOR);
+}

src/events/Popups.cpp

@@ -86,10 +86,11 @@ void Events::listener_newPopup(void* owner, void* data) {
 
     const auto PMONITOR = g_pCompositor->getMonitorFromID(layersurface->monitorID);
 
-    PNEWPOPUP->popup   = WLRPOPUP;
-    PNEWPOPUP->lx      = layersurface->position.x;
-    PNEWPOPUP->ly      = layersurface->position.y;
-    PNEWPOPUP->monitor = PMONITOR;
+    PNEWPOPUP->popup    = WLRPOPUP;
+    PNEWPOPUP->lx       = layersurface->position.x;
+    PNEWPOPUP->ly       = layersurface->position.y;
+    PNEWPOPUP->monitor  = PMONITOR;
+    PNEWPOPUP->parentLS = layersurface;
     createNewPopup(WLRPOPUP, PNEWPOPUP);
 }
 
@@ -148,6 +149,11 @@ void Events::listener_mapPopupXDG(void* owner, void* data) {
 
     Debug::log(LOG, "New XDG Popup mapped at %d %d", (int)PPOPUP->lx, (int)PPOPUP->ly);
 
+    if (PPOPUP->parentWindow)
+        PPOPUP->parentWindow->m_lPopupSurfaces.emplace_back(PPOPUP->popup->base->surface);
+    else if (PPOPUP->parentLS)
+        PPOPUP->parentLS->popupSurfaces.emplace_back(PPOPUP->popup->base->surface);
+
     PPOPUP->pSurfaceTree = SubsurfaceTree::createTreeRoot(PPOPUP->popup->base->surface, addPopupGlobalCoords, PPOPUP, PPOPUP->parentWindow);
 
     int lx = 0, ly = 0;
@@ -167,6 +173,9 @@ void Events::listener_unmapPopupXDG(void* owner, void* data) {
 
     ASSERT(PPOPUP);
 
+    if (PPOPUP->popup->base->surface == g_pCompositor->m_pLastFocus)
+        g_pInputManager->releaseAllMouseButtons();
+
     SubsurfaceTree::destroySurfaceTree(PPOPUP->pSurfaceTree);
 
     int lx = 0, ly = 0;
@@ -177,7 +186,14 @@ void Events::listener_unmapPopupXDG(void* owner, void* data) {
 
     g_pHyprRenderer->damageBox(lx - extents.x, ly - extents.y, extents.width + 2, extents.height + 2);
 
+    if (PPOPUP->parentWindow)
+        std::erase(PPOPUP->parentWindow->m_lPopupSurfaces, PPOPUP->popup->base->surface);
+    else if (PPOPUP->parentLS)
+        std::erase(PPOPUP->parentLS->popupSurfaces, PPOPUP->popup->base->surface);
+
     PPOPUP->pSurfaceTree = nullptr;
+
+    g_pInputManager->simulateMouseMovement(); // to focus and return back to an appropriate surface
 }
 
 void Events::listener_commitPopupXDG(void* owner, void* data) {

src/events/Windows.cpp

@@ -56,9 +56,10 @@ void Events::listener_mapWindow(void* owner, void* data) {
     PWINDOW->m_bReadyToDelete = false;
     PWINDOW->m_bFadingOut     = false;
     PWINDOW->m_szTitle        = g_pXWaylandManager->getTitle(PWINDOW);
+    PWINDOW->m_iX11Type       = PWINDOW->m_bIsX11 ? (PWINDOW->m_uSurface.xwayland->override_redirect ? 2 : 1) : 1;
 
-    if (PWINDOW->m_iX11Type == 2)
-        g_pCompositor->moveUnmanagedX11ToWindows(PWINDOW);
+    if (g_pInputManager->m_bLastFocusOnLS) // waybar fix
+        g_pInputManager->releaseAllMouseButtons();
 
     // Set all windows tiled regardless of anything
     g_pXWaylandManager->setWindowStyleTiled(PWINDOW, WLR_EDGE_LEFT | WLR_EDGE_RIGHT | WLR_EDGE_TOP | WLR_EDGE_BOTTOM);
@@ -66,13 +67,13 @@ void Events::listener_mapWindow(void* owner, void* data) {
     // Foreign Toplevel
     PWINDOW->createToplevelHandle();
 
-    // checks if the window wants borders and sets the appriopriate flag
+    // checks if the window wants borders and sets the appropriate flag
     g_pXWaylandManager->checkBorders(PWINDOW);
 
     // registers the animated vars and stuff
     PWINDOW->onMap();
 
-    const auto PWINDOWSURFACE = g_pXWaylandManager->getWindowSurface(PWINDOW);
+    const auto PWINDOWSURFACE = PWINDOW->m_pWLSurface.wlr();
 
     if (!PWINDOWSURFACE) {
         g_pCompositor->removeWindowFromVectorSafe(PWINDOW);
@@ -84,7 +85,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PWINDOW->m_bRequestsFloat = true;
     }
 
-    PWINDOW->m_bX11ShouldntFocus = PWINDOW->m_bX11ShouldntFocus || (PWINDOW->m_bIsX11 && PWINDOW->m_iX11Type == 2);
+    PWINDOW->m_bX11ShouldntFocus =
+        PWINDOW->m_bX11ShouldntFocus || (PWINDOW->m_bIsX11 && PWINDOW->m_iX11Type == 2 && !wlr_xwayland_or_surface_wants_focus(PWINDOW->m_uSurface.xwayland));
 
     if (PWORKSPACE->m_bDefaultFloating)
         PWINDOW->m_bIsFloating = true;
@@ -115,6 +117,9 @@ void Events::listener_mapWindow(void* owner, void* data) {
     bool shouldFocus      = true;
     bool workspaceSpecial = false;
 
+    PWINDOW->m_szInitialTitle = g_pXWaylandManager->getTitle(PWINDOW);
+    PWINDOW->m_szInitialClass = g_pXWaylandManager->getAppIDClass(PWINDOW);
+
     for (auto& r : WINDOWRULES) {
         if (r.szRule.find("monitor") == 0) {
             try {
@@ -123,11 +128,21 @@ void Events::listener_mapWindow(void* owner, void* data) {
                 if (MONITORSTR == "unset") {
                     PWINDOW->m_iMonitorID = PMONITOR->ID;
                 } else {
-                    const long int MONITOR = std::stoi(MONITORSTR);
-                    if (!g_pCompositor->getMonitorFromID(MONITOR))
-                        PWINDOW->m_iMonitorID = 0;
-                    else
-                        PWINDOW->m_iMonitorID = MONITOR;
+                    if (isNumber(MONITORSTR)) {
+                        const long int MONITOR = std::stoi(MONITORSTR);
+                        if (!g_pCompositor->getMonitorFromID(MONITOR))
+                            PWINDOW->m_iMonitorID = 0;
+                        else
+                            PWINDOW->m_iMonitorID = MONITOR;
+                    } else {
+                        const auto PMONITOR = g_pCompositor->getMonitorFromName(MONITORSTR);
+                        if (PMONITOR)
+                            PWINDOW->m_iMonitorID = PMONITOR->ID;
+                        else {
+                            Debug::log(ERR, "No monitor in monitor %s rule", MONITORSTR.c_str());
+                            continue;
+                        }
+                    }
                 }
 
                 PWINDOW->m_iWorkspaceID = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID)->activeWorkspace;
@@ -413,7 +428,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
     if (PLSFROMFOCUS && PLSFROMFOCUS->layerSurface->current.keyboard_interactive)
         PWINDOW->m_bNoInitialFocus = true;
 
-    if (!PWINDOW->m_bNoFocus && !PWINDOW->m_bNoInitialFocus && PWINDOW->m_iX11Type != 2 && !workspaceSilent) {
+    if (!PWINDOW->m_bNoFocus && !PWINDOW->m_bNoInitialFocus &&
+        (PWINDOW->m_iX11Type != 2 || (PWINDOW->m_bIsX11 && wlr_xwayland_or_surface_wants_focus(PWINDOW->m_uSurface.xwayland))) && !workspaceSilent) {
         g_pCompositor->focusWindow(PWINDOW);
         PWINDOW->m_fActiveInactiveAlpha.setValueAndWarp(*PACTIVEALPHA);
         PWINDOW->m_fDimPercent.setValueAndWarp(*PDIMSTRENGTH);
@@ -440,7 +456,6 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PWINDOW->hyprListener_fullscreenWindow.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_fullscreen, &Events::listener_fullscreenWindow, PWINDOW,
                                                             "XWayland Window Late");
         PWINDOW->hyprListener_activateX11.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_activate, &Events::listener_activateX11, PWINDOW, "XWayland Window Late");
-        PWINDOW->hyprListener_configureX11.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_configure, &Events::listener_configureX11, 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,
                                                            "Xwayland Window Late");
@@ -480,7 +495,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
     // recheck idle inhibitors
     g_pInputManager->recheckIdleInhibitorStatus();
 
-    PWINDOW->m_pSurfaceTree = SubsurfaceTree::createTreeRoot(g_pXWaylandManager->getWindowSurface(PWINDOW), addViewCoords, PWINDOW, PWINDOW);
+    PWINDOW->m_pSurfaceTree = SubsurfaceTree::createTreeRoot(PWINDOW->m_pWLSurface.wlr(), addViewCoords, PWINDOW, PWINDOW);
 
     PWINDOW->updateToplevel();
 
@@ -558,9 +573,12 @@ void Events::listener_mapWindow(void* owner, void* data) {
     auto workspaceID = requestedWorkspace != "" ? requestedWorkspace : PWORKSPACE->m_szName;
     g_pEventManager->postEvent(
         SHyprIPCEvent{"openwindow", getFormat("%x,%s,%s,%s", PWINDOW, workspaceID.c_str(), g_pXWaylandManager->getAppIDClass(PWINDOW).c_str(), PWINDOW->m_szTitle.c_str())});
+    EMIT_HOOK_EVENT("openWindow", PWINDOW);
 
     // recalc the values for this window
     g_pCompositor->updateWindowAnimatedDecorationValues(PWINDOW);
+
+    g_pProtocolManager->m_pFractionalScaleProtocolManager->setPreferredScaleForSurface(PWINDOW->m_pWLSurface.wlr(), PMONITOR->scale);
 }
 
 void Events::listener_unmapWindow(void* owner, void* data) {
@@ -568,7 +586,14 @@ void Events::listener_unmapWindow(void* owner, void* data) {
 
     Debug::log(LOG, "Window %x unmapped (class %s)", PWINDOW, g_pXWaylandManager->getAppIDClass(PWINDOW).c_str());
 
+    if (!PWINDOW->m_pWLSurface.exists() || !PWINDOW->m_bIsMapped) {
+        Debug::log(WARN, "Window %x unmapped without being mapped??", PWINDOW);
+        PWINDOW->m_bFadingOut = false;
+        return;
+    }
+
     g_pEventManager->postEvent(SHyprIPCEvent{"closewindow", getFormat("%x", PWINDOW)});
+    EMIT_HOOK_EVENT("closeWindow", PWINDOW);
 
     g_pProtocolManager->m_pToplevelExportProtocolManager->onWindowUnmap(PWINDOW);
 
@@ -586,7 +611,6 @@ void Events::listener_unmapWindow(void* owner, void* data) {
         Debug::log(LOG, "Unregistered late callbacks XWL");
         PWINDOW->hyprListener_fullscreenWindow.removeCallback();
         PWINDOW->hyprListener_activateX11.removeCallback();
-        PWINDOW->hyprListener_configureX11.removeCallback();
         PWINDOW->hyprListener_setTitleWindow.removeCallback();
         PWINDOW->hyprListener_setGeometryX11U.removeCallback();
         PWINDOW->hyprListener_requestMaximize.removeCallback();
@@ -613,6 +637,8 @@ void Events::listener_unmapWindow(void* owner, void* data) {
         wasLastWindow                = true;
         g_pCompositor->m_pLastWindow = nullptr;
         g_pCompositor->m_pLastFocus  = nullptr;
+
+        g_pInputManager->releaseAllMouseButtons();
     }
 
     PWINDOW->m_bMappedX11 = false;
@@ -660,8 +686,10 @@ void Events::listener_unmapWindow(void* owner, void* data) {
     const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
 
     // do the animation thing
-    PWINDOW->m_vOriginalClosedPos  = PWINDOW->m_vRealPosition.vec() - PMONITOR->vecPosition;
-    PWINDOW->m_vOriginalClosedSize = PWINDOW->m_vRealSize.vec();
+    if (PMONITOR) {
+        PWINDOW->m_vOriginalClosedPos  = PWINDOW->m_vRealPosition.vec() - PMONITOR->vecPosition;
+        PWINDOW->m_vOriginalClosedSize = PWINDOW->m_vRealSize.vec();
+    }
 
     if (!PWINDOW->m_bX11DoesntWantBorders)                                                  // don't animate out if they weren't animated in.
         PWINDOW->m_vRealPosition = PWINDOW->m_vRealPosition.vec() + Vector2D(0.01f, 0.01f); // it has to be animated, otherwise onWindowPostCreateClose will ignore it
@@ -689,7 +717,9 @@ void Events::listener_commitWindow(void* owner, void* data) {
     if (!PWINDOW->m_bMappedX11 || PWINDOW->isHidden() || (PWINDOW->m_bIsX11 && !PWINDOW->m_bMappedX11))
         return;
 
-    g_pHyprRenderer->damageSurface(g_pXWaylandManager->getWindowSurface(PWINDOW), PWINDOW->m_vRealPosition.goalv().x, PWINDOW->m_vRealPosition.goalv().y);
+    PWINDOW->updateSurfaceOutputs();
+
+    g_pHyprRenderer->damageSurface(PWINDOW->m_pWLSurface.wlr(), PWINDOW->m_vRealPosition.goalv().x, PWINDOW->m_vRealPosition.goalv().y);
 
     // Debug::log(LOG, "Window %x committed", PWINDOW); // SPAM!
 }
@@ -710,6 +740,8 @@ void Events::listener_destroyWindow(void* owner, void* data) {
     PWINDOW->hyprListener_mapWindow.removeCallback();
     PWINDOW->hyprListener_unmapWindow.removeCallback();
     PWINDOW->hyprListener_destroyWindow.removeCallback();
+    PWINDOW->hyprListener_configureX11.removeCallback();
+    PWINDOW->hyprListener_setOverrideRedirect.removeCallback();
 
     g_pLayoutManager->getCurrentLayout()->onWindowRemoved(PWINDOW);
 
@@ -735,8 +767,11 @@ void Events::listener_setTitleWindow(void* owner, void* data) {
 
     PWINDOW->m_szTitle = g_pXWaylandManager->getTitle(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) { // 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", getFormat("%x", PWINDOW)});
+        EMIT_HOOK_EVENT("activeWindow", PWINDOW);
+    }
 
     PWINDOW->updateDynamicRules();
     g_pCompositor->updateWindowAnimatedDecorationValues(PWINDOW);
@@ -756,18 +791,47 @@ void Events::listener_fullscreenWindow(void* owner, void* data) {
     if (PWINDOW->isHidden() || PWINDOW->m_bNoFullscreenRequest)
         return;
 
+    bool requestedFullState = false;
+
     if (!PWINDOW->m_bIsX11) {
         const auto REQUESTED = &PWINDOW->m_uSurface.xdg->toplevel->requested;
 
-        if (REQUESTED->fullscreen != PWINDOW->m_bIsFullscreen)
+        if (REQUESTED->fullscreen && PWINDOW->m_bIsFullscreen) {
+            const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID);
+            if (PWORKSPACE->m_efFullscreenMode != FULLSCREEN_FULL) {
+                // Store that we were maximized
+                PWINDOW->m_bWasMaximized = true;
+                g_pCompositor->setWindowFullscreen(PWINDOW, false, FULLSCREEN_MAXIMIZED);
+                g_pCompositor->setWindowFullscreen(PWINDOW, true, FULLSCREEN_FULL);
+            } else
+                PWINDOW->m_bWasMaximized = false;
+        } else if (REQUESTED->fullscreen != PWINDOW->m_bIsFullscreen && !PWINDOW->m_bFakeFullscreenState) {
             g_pCompositor->setWindowFullscreen(PWINDOW, REQUESTED->fullscreen, FULLSCREEN_FULL);
+            if (PWINDOW->m_bWasMaximized && !REQUESTED->fullscreen) {
+                // Was maximized before the fullscreen request, return now back to maximized instead of normal
+                g_pCompositor->setWindowFullscreen(PWINDOW, true, FULLSCREEN_MAXIMIZED);
+            }
+        }
+
+        // Disable the maximize flag when we receive a de-fullscreen request
+        PWINDOW->m_bWasMaximized &= REQUESTED->fullscreen;
+
+        requestedFullState = REQUESTED->fullscreen;
 
         wlr_xdg_surface_schedule_configure(PWINDOW->m_uSurface.xdg);
     } else {
         if (!PWINDOW->m_uSurface.xwayland->mapped)
             return;
 
-        g_pCompositor->setWindowFullscreen(PWINDOW, PWINDOW->m_uSurface.xwayland->fullscreen, FULLSCREEN_FULL);
+        if (!PWINDOW->m_bFakeFullscreenState)
+            g_pCompositor->setWindowFullscreen(PWINDOW, PWINDOW->m_uSurface.xwayland->fullscreen, FULLSCREEN_FULL);
+
+        requestedFullState = PWINDOW->m_uSurface.xwayland->fullscreen;
+    }
+
+    if (!requestedFullState && PWINDOW->m_bFakeFullscreenState) {
+        g_pXWaylandManager->setWindowFullscreen(PWINDOW, false); // fixes for apps expecting a de-fullscreen (e.g. ff)
+        g_pXWaylandManager->setWindowFullscreen(PWINDOW, true);
     }
 
     PWINDOW->updateToplevel();
@@ -782,7 +846,7 @@ void Events::listener_activateXDG(wl_listener* listener, void* data) {
 
     Debug::log(LOG, "Activate request for surface at %x", E->surface);
 
-    if (!*PFOCUSONACTIVATE || !wlr_surface_is_xdg_surface(E->surface))
+    if (!wlr_xdg_surface_try_from_wlr_surface(E->surface))
         return;
 
     const auto PWINDOW = g_pCompositor->getWindowFromSurface(E->surface);
@@ -790,6 +854,22 @@ void Events::listener_activateXDG(wl_listener* listener, void* data) {
     if (!PWINDOW || PWINDOW == g_pCompositor->m_pLastWindow)
         return;
 
+    g_pEventManager->postEvent(SHyprIPCEvent{"urgent", getFormat("%x", PWINDOW)});
+    EMIT_HOOK_EVENT("urgent", PWINDOW);
+
+    PWINDOW->m_bIsUrgent = true;
+
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID);
+    if (PWORKSPACE->m_pWlrHandle) {
+        wlr_ext_workspace_handle_v1_set_urgent(PWORKSPACE->m_pWlrHandle, 1);
+    }
+
+    if (!*PFOCUSONACTIVATE)
+        return;
+
+    if (PWINDOW->m_bIsFloating)
+        g_pCompositor->moveWindowToTop(PWINDOW);
+
     g_pCompositor->focusWindow(PWINDOW);
     Vector2D middle = PWINDOW->m_vRealPosition.goalv() + PWINDOW->m_vRealSize.goalv() / 2.f;
     g_pCompositor->warpCursorTo(middle);
@@ -802,8 +882,28 @@ void Events::listener_activateX11(void* owner, void* data) {
 
     Debug::log(LOG, "X11 Activate request for window %x", PWINDOW);
 
-    if (!*PFOCUSONACTIVATE || PWINDOW->m_iX11Type != 1 || PWINDOW == g_pCompositor->m_pLastWindow)
+    if (PWINDOW->m_iX11Type == 2) {
+
+        Debug::log(LOG, "Unmanaged X11 %x requests activate", PWINDOW);
+
+        if (g_pCompositor->m_pLastWindow && g_pCompositor->m_pLastWindow->getPID() != PWINDOW->getPID())
+            return;
+
+        g_pCompositor->focusWindow(PWINDOW);
         return;
+    }
+
+    if (PWINDOW == g_pCompositor->m_pLastWindow)
+        return;
+
+    g_pEventManager->postEvent(SHyprIPCEvent{"urgent", getFormat("%x", PWINDOW)});
+    EMIT_HOOK_EVENT("urgent", PWINDOW);
+
+    if (!*PFOCUSONACTIVATE)
+        return;
+
+    if (PWINDOW->m_bIsFloating)
+        g_pCompositor->moveWindowToTop(PWINDOW);
 
     g_pCompositor->focusWindow(PWINDOW);
     Vector2D middle = PWINDOW->m_vRealPosition.goalv() + PWINDOW->m_vRealSize.goalv() / 2.f;
@@ -811,26 +911,24 @@ void Events::listener_activateX11(void* owner, void* data) {
 }
 
 void Events::listener_configureX11(void* owner, void* data) {
-    CWindow* PWINDOW = (CWindow*)owner;
-
-    if (!g_pCompositor->windowValidMapped(PWINDOW))
-        return;
+    CWindow*   PWINDOW = (CWindow*)owner;
 
     const auto E = (wlr_xwayland_surface_configure_event*)data;
-    g_pHyprRenderer->damageWindow(PWINDOW);
-
-    if (!PWINDOW->m_bIsFloating || PWINDOW->m_bIsFullscreen) {
-        g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv(), true);
-        g_pInputManager->refocus();
-        g_pHyprRenderer->damageWindow(PWINDOW);
-        return;
-    }
 
     if (!PWINDOW->m_uSurface.xwayland->mapped || !PWINDOW->m_bMappedX11) {
         wlr_xwayland_surface_configure(PWINDOW->m_uSurface.xwayland, E->x, E->y, E->width, E->height);
         return;
     }
 
+    g_pHyprRenderer->damageWindow(PWINDOW);
+
+    if (!PWINDOW->m_bIsFloating || PWINDOW->m_bIsFullscreen || g_pInputManager->currentlyDraggedWindow == PWINDOW) {
+        g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv(), true);
+        g_pInputManager->refocus();
+        g_pHyprRenderer->damageWindow(PWINDOW);
+        return;
+    }
+
     if (E->width > 1 && E->height > 1)
         PWINDOW->setHidden(false);
     else
@@ -896,6 +994,14 @@ void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
     }
 }
 
+void Events::listener_setOverrideRedirect(void* owner, void* data) {
+    // const auto PWINDOW = (CWindow*)owner;
+
+    //if (!PWINDOW->m_bIsMapped && PWINDOW->m_uSurface.xwayland->mapped) {
+    //    Events::listener_mapWindow(PWINDOW, nullptr);
+    //}
+}
+
 void Events::listener_surfaceXWayland(wl_listener* listener, void* data) {
     const auto XWSURFACE = (wlr_xwayland_surface*)data;
 
@@ -903,8 +1009,7 @@ void Events::listener_surfaceXWayland(wl_listener* listener, void* data) {
     if (XWSURFACE->parent)
         Debug::log(LOG, "Window parent data: %s at %x", XWSURFACE->parent->_class, XWSURFACE->parent);
 
-    const auto PNEWWINDOW = XWSURFACE->override_redirect ? g_pCompositor->m_dUnmanagedX11Windows.emplace_back(std::make_unique<CWindow>()).get() :
-                                                           g_pCompositor->m_vWindows.emplace_back(std::make_unique<CWindow>()).get();
+    const auto PNEWWINDOW = (CWindow*)g_pCompositor->m_vWindows.emplace_back(std::make_unique<CWindow>()).get();
 
     PNEWWINDOW->m_uSurface.xwayland = XWSURFACE;
     PNEWWINDOW->m_iX11Type          = XWSURFACE->override_redirect ? 2 : 1;
@@ -913,8 +1018,9 @@ void Events::listener_surfaceXWayland(wl_listener* listener, void* data) {
     PNEWWINDOW->m_pX11Parent = g_pCompositor->getX11Parent(PNEWWINDOW);
 
     PNEWWINDOW->hyprListener_mapWindow.initCallback(&XWSURFACE->events.map, &Events::listener_mapWindow, PNEWWINDOW, "XWayland Window");
-    PNEWWINDOW->hyprListener_unmapWindow.initCallback(&XWSURFACE->events.unmap, &Events::listener_unmapWindow, 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");
 }
 
 void Events::listener_newXDGSurface(wl_listener* listener, void* data) {
@@ -930,7 +1036,6 @@ void Events::listener_newXDGSurface(wl_listener* listener, void* data) {
     PNEWWINDOW->m_uSurface.xdg = XDGSURFACE;
 
     PNEWWINDOW->hyprListener_mapWindow.initCallback(&XDGSURFACE->events.map, &Events::listener_mapWindow, PNEWWINDOW, "XDG Window");
-    PNEWWINDOW->hyprListener_unmapWindow.initCallback(&XDGSURFACE->events.unmap, &Events::listener_unmapWindow, PNEWWINDOW, "XDG Window");
     PNEWWINDOW->hyprListener_destroyWindow.initCallback(&XDGSURFACE->events.destroy, &Events::listener_destroyWindow, PNEWWINDOW, "XDG Window");
 }
 
@@ -972,7 +1077,14 @@ void Events::listener_requestMinimize(void* owner, void* data) {
 
         const auto E = (wlr_xwayland_minimize_event*)data;
 
+        g_pEventManager->postEvent({"minimize", getFormat("%x,%i", PWINDOW, (int)E->minimize)});
+        EMIT_HOOK_EVENT("minimize", (std::vector<void*>{PWINDOW, (void*)E->minimize}));
+
         wlr_xwayland_surface_set_minimized(PWINDOW->m_uSurface.xwayland, E->minimize && g_pCompositor->m_pLastWindow != PWINDOW); // fucking DXVK
+    } else {
+        const auto E = (wlr_foreign_toplevel_handle_v1_minimized_event*)data;
+        g_pEventManager->postEvent({"minimize", getFormat("%x,%i", PWINDOW, E ? (int)E->minimized : 1)});
+        EMIT_HOOK_EVENT("minimize", (std::vector<void*>{PWINDOW, (void*)(E ? (uint64_t)E->minimized : 1)}));
     }
 }
 

src/helpers/AnimatedVariable.hpp

@@ -11,8 +11,8 @@ enum ANIMATEDVARTYPE {
 };
 
 enum AVARDAMAGEPOLICY {
-    AVARDAMAGE_INVALID = -1,
-    AVARDAMAGE_ENTIRE  = 0,
+    AVARDAMAGE_NONE   = -1,
+    AVARDAMAGE_ENTIRE = 0,
     AVARDAMAGE_BORDER,
     AVARDAMAGE_SHADOW
 };
@@ -243,7 +243,7 @@ class CAnimatedVariable {
     std::chrono::system_clock::time_point animationBegin;
 
     ANIMATEDVARTYPE                       m_eVarType      = AVARTYPE_INVALID;
-    AVARDAMAGEPOLICY                      m_eDamagePolicy = AVARDAMAGE_INVALID;
+    AVARDAMAGEPOLICY                      m_eDamagePolicy = AVARDAMAGE_NONE;
 
     bool                                  m_bRemoveEndAfterRan   = true;
     bool                                  m_bRemoveBeginAfterRan = true;

src/helpers/BezierCurve.cpp

@@ -1,5 +1,7 @@
 #include "BezierCurve.hpp"
 
+#include <algorithm>
+
 void CBezierCurve::setup(std::vector<Vector2D>* pVec) {
     m_dPoints.clear();
 
@@ -43,29 +45,32 @@ float CBezierCurve::getXForT(float t) {
 
 // Todo: this probably can be done better and faster
 float CBezierCurve::getYForPoint(float x) {
-    // binary search for the range UPDOWN X
-    float upperT = 1;
-    float lowerT = 0;
-    float mid    = 0.5;
+    if (x >= 1.0)
+        return 1.0;
 
-    while (std::abs(upperT - lowerT) > INVBAKEDPOINTS) {
-        if (m_aPointsBaked[((int)(mid * (float)BAKEDPOINTS))].x > x) {
+    // binary search for the range UPDOWN X
+    int upperT = BAKEDPOINTS - 1;
+    int lowerT = 0;
+    int mid    = upperT / 2;
+
+    while (std::abs(upperT - lowerT) > 1) {
+        if (m_aPointsBaked[mid].x > x) {
             upperT = mid;
         } else {
             lowerT = mid;
         }
 
-        mid = (upperT + lowerT) / 2.f;
+        mid = (upperT + lowerT) / 2;
     }
 
     // in the name of performance i shall make a hack
-    const auto LOWERPOINT = &m_aPointsBaked[std::clamp((int)((float)BAKEDPOINTS * lowerT), 0, 199)];
-    const auto UPPERPOINT = &m_aPointsBaked[std::clamp((int)((float)BAKEDPOINTS * upperT), 0, 199)];
+    const auto LOWERPOINT = &m_aPointsBaked[std::clamp(lowerT, 0, BAKEDPOINTS - 1)];
+    const auto UPPERPOINT = &m_aPointsBaked[std::clamp(upperT, 0, BAKEDPOINTS - 1)];
 
     const auto PERCINDELTA = (x - LOWERPOINT->x) / (UPPERPOINT->x - LOWERPOINT->x);
 
     if (std::isnan(PERCINDELTA) || std::isinf(PERCINDELTA)) // can sometimes happen for VERY small x
         return 0.f;
 
-    return LOWERPOINT->y + (UPPERPOINT->y - UPPERPOINT->y) * PERCINDELTA;
+    return LOWERPOINT->y + (UPPERPOINT->y - LOWERPOINT->y) * PERCINDELTA;
 }

src/helpers/BezierCurve.hpp

@@ -3,7 +3,7 @@
 #include "../defines.hpp"
 #include <deque>
 
-constexpr int   BAKEDPOINTS    = 200;
+constexpr int   BAKEDPOINTS    = 255;
 constexpr float INVBAKEDPOINTS = 1.f / BAKEDPOINTS;
 
 // an implementation of a cubic bezier curve

src/helpers/Color.cpp

@@ -4,7 +4,6 @@
 CColor::CColor() {}
 
 CColor::CColor(float r, float g, float b, float a) {
-    RASSERT(r <= 1.f && g <= 1.f && b <= 1.f && a <= 1.f, "un-normalized color assignment");
     this->r = r;
     this->g = g;
     this->b = b;

src/helpers/Color.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../includes.hpp"
+#include <cstdint>
 
 class CColor {
   public:
@@ -13,7 +13,7 @@ class CColor {
     uint64_t getAsHex();
 
     CColor   operator-(const CColor& c2) const {
-          return CColor(r - c2.r, g - c2.g, b - c2.b, a - c2.a);
+        return CColor(r - c2.r, g - c2.g, b - c2.b, a - c2.a);
     }
 
     CColor operator+(const CColor& c2) const {

src/helpers/MiscFunctions.cpp

@@ -4,12 +4,13 @@
 #include "../Compositor.hpp"
 #include <sys/utsname.h>
 #include <iomanip>
+#include <sstream>
 
-#if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__)
+#if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
 #include <sys/sysctl.h>
 #if defined(__DragonFly__)
 #include <sys/kinfo.h> // struct kinfo_proc
-#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+#elif defined(__FreeBSD__)
 #include <sys/user.h> // struct kinfo_proc
 #endif
 
@@ -22,45 +23,101 @@
 #endif
 #if defined(__DragonFly__)
 #define KP_PPID(kp) kp.kp_ppid
-#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+#elif defined(__FreeBSD__)
 #define KP_PPID(kp) kp.ki_ppid
 #else
 #define KP_PPID(kp) kp.p_ppid
 #endif
 #endif
 
-static const float transforms[][9] = {{
-        1.0f, 0.0f, 0.0f,
-        0.0f, 1.0f, 0.0f,
-        0.0f, 0.0f, 1.0f,
-    },{
-        0.0f, 1.0f, 0.0f,
-        -1.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 1.0f,
-    },{
-        -1.0f, 0.0f, 0.0f,
-        0.0f, -1.0f, 0.0f,
-        0.0f, 0.0f, 1.0f,
-    },{
-        0.0f, -1.0f, 0.0f,
-        1.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 1.0f,
-    },{
-        -1.0f, 0.0f, 0.0f,
-        0.0f, 1.0f, 0.0f,
-        0.0f, 0.0f, 1.0f,
-    },{
-        0.0f, 1.0f, 0.0f,
-        1.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 1.0f,
-    },{
-        1.0f, 0.0f, 0.0f,
-        0.0f, -1.0f, 0.0f,
-        0.0f, 0.0f, 1.0f,
-    },{
-        0.0f, -1.0f, 0.0f,
-        -1.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 1.0f,
+static const float transforms[][9] = {
+    {
+        1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+    },
+    {
+        0.0f,
+        1.0f,
+        0.0f,
+        -1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+    },
+    {
+        -1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        -1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+    },
+    {
+        0.0f,
+        -1.0f,
+        0.0f,
+        1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+    },
+    {
+        -1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+    },
+    {
+        0.0f,
+        1.0f,
+        0.0f,
+        1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+    },
+    {
+        1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        -1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+    },
+    {
+        0.0f,
+        -1.0f,
+        0.0f,
+        -1.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        0.0f,
+        1.0f,
     },
 };
 
@@ -152,7 +209,7 @@ std::string removeBeginEndSpacesTabs(std::string str) {
     }
 
     int countAfter = 0;
-    while (str.length() != 0 && (str[str.length() - countAfter - 1] == ' ' || str[str.length() - 1 - countAfter] == '\t')) {
+    while ((int)str.length() - countAfter - 1 >= 0 && (str[str.length() - countAfter - 1] == ' ' || str[str.length() - 1 - countAfter] == '\t')) {
         countAfter++;
     }
 
@@ -231,6 +288,22 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
             if (!PWORKSPACE || (g_pCompositor->getWindowsOnWorkspace(id) == 0))
                 return id;
         }
+    } else if (in.find("prev") == 0) {
+        if (!g_pCompositor->m_pLastMonitor)
+            return INT_MAX;
+
+        const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->activeWorkspace);
+
+        if (!PWORKSPACE)
+            return INT_MAX;
+
+        const auto PLASTWORKSPACE = g_pCompositor->getWorkspaceByID(PWORKSPACE->m_sPrevWorkspace.iID);
+
+        if (!PLASTWORKSPACE)
+            return INT_MAX;
+
+        outName = PLASTWORKSPACE->m_szName;
+        return PLASTWORKSPACE->m_iID;
     } else {
         if ((in[0] == 'm' || in[0] == 'e') && (in[1] == '-' || in[1] == '+') && isNumber(in.substr(2))) {
             bool onAllMonitors = in[0] == 'e';
@@ -339,7 +412,11 @@ void logSystemInfo() {
 
     Debug::log(NONE, "\n");
 
+#if defined(__DragonFly__) || defined(__FreeBSD__)
+    const std::string GPUINFO = execAndGet("pciconf -lv | fgrep -A4 vga");
+#else
     const std::string GPUINFO = execAndGet("lspci -vnn | grep VGA");
+#endif
     Debug::log(LOG, "GPU information:\n%s\n", GPUINFO.c_str());
 
     if (GPUINFO.contains("NVIDIA")) {
@@ -393,8 +470,8 @@ int64_t getPPIDof(int64_t pid) {
 
     return 0;
 #else
-    std::string dir = "/proc/" + std::to_string(pid) + "/status";
-    FILE*       infile;
+    std::string       dir     = "/proc/" + std::to_string(pid) + "/status";
+    FILE*             infile;
 
     infile = fopen(dir.c_str(), "r");
     if (!infile)
@@ -459,5 +536,30 @@ int64_t configStringToInt(const std::string& VALUE) {
     } else if (VALUE.find("false") == 0 || VALUE.find("off") == 0 || VALUE.find("no") == 0) {
         return 0;
     }
-    return stol(VALUE);
+    return std::stoll(VALUE);
+}
+
+double normalizeAngleRad(double ang) {
+    if (ang > M_PI * 2) {
+        while (ang > M_PI * 2)
+            ang -= M_PI * 2;
+        return ang;
+    }
+
+    if (ang < 0.0) {
+        while (ang < 0.0)
+            ang += M_PI * 2;
+        return ang;
+    }
+
+    return ang;
+}
+
+std::string replaceInString(std::string subject, const std::string& search, const std::string& replace) {
+    size_t pos = 0;
+    while ((pos = subject.find(search, pos)) != std::string::npos) {
+        subject.replace(pos, search.length(), replace);
+        pos += replace.length();
+    }
+    return subject;
 }

src/helpers/MiscFunctions.hpp

@@ -16,7 +16,7 @@ void        logSystemInfo();
 std::string execAndGet(const char*);
 int64_t     getPPIDof(int64_t pid);
 int64_t     configStringToInt(const std::string&);
-
 float       getPlusMinusKeywordResult(std::string in, float relative);
-
 void        matrixProjection(float mat[9], int w, int h, wl_output_transform tr);
+double      normalizeAngleRad(double ang);
+std::string replaceInString(std::string subject, const std::string& search, const std::string& replace);

src/helpers/Monitor.cpp

@@ -2,13 +2,31 @@
 
 #include "../Compositor.hpp"
 
+int ratHandler(void* data) {
+    g_pHyprRenderer->renderMonitor((CMonitor*)data);
+
+    return 1;
+}
+
+CMonitor::CMonitor() {
+    wlr_damage_ring_init(&damage);
+}
+
+CMonitor::~CMonitor() {
+    wlr_damage_ring_finish(&damage);
+}
+
 void CMonitor::onConnect(bool noRule) {
     hyprListener_monitorDestroy.removeCallback();
     hyprListener_monitorFrame.removeCallback();
     hyprListener_monitorStateRequest.removeCallback();
+    hyprListener_monitorDamage.removeCallback();
+    hyprListener_monitorNeedsFrame.removeCallback();
     hyprListener_monitorFrame.initCallback(&output->events.frame, &Events::listener_monitorFrame, this);
     hyprListener_monitorDestroy.initCallback(&output->events.destroy, &Events::listener_monitorDestroy, this);
     hyprListener_monitorStateRequest.initCallback(&output->events.request_state, &Events::listener_monitorStateRequest, this);
+    hyprListener_monitorDamage.initCallback(&output->events.damage, &Events::listener_monitorDamage, this);
+    hyprListener_monitorNeedsFrame.initCallback(&output->events.needs_frame, &Events::listener_monitorNeedsFrame, this);
 
     if (m_bEnabled) {
         wlr_output_enable(output, 1);
@@ -108,13 +126,13 @@ void CMonitor::onConnect(bool noRule) {
     if (!noRule)
         g_pHyprRenderer->applyMonitorRule(this, &monitorRule, true);
 
+    wlr_damage_ring_set_bounds(&damage, vecTransformedSize.x, vecTransformedSize.y);
+
     wlr_xcursor_manager_load(g_pCompositor->m_sWLRXCursorMgr, scale);
 
     Debug::log(LOG, "Added new monitor with name %s at %i,%i with size %ix%i, pointer %x", output->name, (int)vecPosition.x, (int)vecPosition.y, (int)vecPixelSize.x,
                (int)vecPixelSize.y, output);
 
-    damage = wlr_output_damage_create(output);
-
     // add a WLR workspace group
     if (!pWLRWorkspaceGroupHandle) {
         pWLRWorkspaceGroupHandle = wlr_ext_workspace_group_handle_v1_create(g_pCompositor->m_sWLREXTWorkspaceMgr);
@@ -125,6 +143,8 @@ void CMonitor::onConnect(bool noRule) {
     setupDefaultWS(monitorRule);
 
     scale = monitorRule.scale;
+    if (scale < 0.1)
+        scale = getDefaultScale();
 
     m_pThisWrap = nullptr;
 
@@ -132,6 +152,7 @@ void CMonitor::onConnect(bool noRule) {
     //
 
     g_pEventManager->postEvent(SHyprIPCEvent{"monitoradded", szName});
+    EMIT_HOOK_EVENT("monitorAdded", this);
 
     if (!g_pCompositor->m_pLastMonitor) // set the last monitor if it isnt set yet
         g_pCompositor->setActiveMonitor(this);
@@ -155,10 +176,17 @@ void CMonitor::onConnect(bool noRule) {
 
     if (!found)
         g_pCompositor->setActiveMonitor(this);
+
+    renderTimer = wl_event_loop_add_timer(g_pCompositor->m_sWLEventLoop, ratHandler, this);
 }
 
 void CMonitor::onDisconnect() {
 
+    if (renderTimer) {
+        wl_event_source_remove(renderTimer);
+        renderTimer = nullptr;
+    }
+
     if (!m_bEnabled || g_pCompositor->m_bIsShuttingDown)
         return;
 
@@ -191,13 +219,22 @@ void CMonitor::onDisconnect() {
     m_bRenderingInitPassed = false;
 
     hyprListener_monitorFrame.removeCallback();
+    hyprListener_monitorDamage.removeCallback();
+    hyprListener_monitorNeedsFrame.removeCallback();
 
     for (size_t i = 0; i < 4; ++i) {
-        for (auto& ls : m_aLayerSurfaceLists[i]) {
-            wlr_layer_surface_v1_destroy(ls->layerSurface);
+        for (auto& ls : m_aLayerSurfaceLayers[i]) {
+            if (ls->layerSurface && !ls->fadingOut)
+                wlr_layer_surface_v1_destroy(ls->layerSurface);
         }
+        m_aLayerSurfaceLayers[i].clear();
     }
 
+    Debug::log(LOG, "Removed monitor %s!", szName.c_str());
+
+    g_pEventManager->postEvent(SHyprIPCEvent{"monitorremoved", szName});
+    EMIT_HOOK_EVENT("monitorRemoved", this);
+
     if (!BACKUPMON) {
         Debug::log(WARN, "Unplugged last monitor, entering an unsafe state. Good luck my friend.");
 
@@ -206,6 +243,8 @@ void CMonitor::onDisconnect() {
 
         g_pCompositor->m_bUnsafeState = true;
 
+        std::erase_if(g_pCompositor->m_vMonitors, [&](std::shared_ptr<CMonitor>& el) { return el.get() == this; });
+
         return;
     }
 
@@ -228,8 +267,6 @@ void CMonitor::onDisconnect() {
 
     activeWorkspace = -1;
 
-    wlr_output_damage_destroy(damage);
-
     wlr_output_layout_remove(g_pCompositor->m_sWLROutputLayout, output);
 
     wlr_output_enable(output, false);
@@ -238,10 +275,6 @@ void CMonitor::onDisconnect() {
 
     std::erase_if(g_pCompositor->m_vWorkspaces, [&](std::unique_ptr<CWorkspace>& el) { return el->m_iMonitorID == ID; });
 
-    Debug::log(LOG, "Removed monitor %s!", szName.c_str());
-
-    g_pEventManager->postEvent(SHyprIPCEvent{"monitorremoved", szName});
-
     if (g_pCompositor->m_pLastMonitor == this)
         g_pCompositor->setActiveMonitor(BACKUPMON);
 
@@ -262,12 +295,14 @@ void CMonitor::onDisconnect() {
     std::erase_if(g_pCompositor->m_vMonitors, [&](std::shared_ptr<CMonitor>& el) { return el.get() == this; });
 }
 
-void CMonitor::addDamage(pixman_region32_t* rg) {
-    wlr_output_damage_add(damage, rg);
+void CMonitor::addDamage(const pixman_region32_t* rg) {
+    if (wlr_damage_ring_add(&damage, rg))
+        g_pCompositor->scheduleFrameForMonitor(this);
 }
 
-void CMonitor::addDamage(wlr_box* box) {
-    wlr_output_damage_add_box(damage, box);
+void CMonitor::addDamage(const wlr_box* box) {
+    if (wlr_damage_ring_add_box(&damage, box))
+        g_pCompositor->scheduleFrameForMonitor(this);
 }
 
 bool CMonitor::isMirror() {
@@ -291,13 +326,15 @@ int CMonitor::findAvailableDefaultWS() {
 void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
     // Workspace
     std::string newDefaultWorkspaceName = "";
-    int64_t     WORKSPACEID = monitorRule.defaultWorkspace == "" ? findAvailableDefaultWS() : getWorkspaceIDFromString(monitorRule.defaultWorkspace, newDefaultWorkspaceName);
+    int64_t     WORKSPACEID             = g_pConfigManager->getDefaultWorkspaceFor(szName).empty() ?
+                        findAvailableDefaultWS() :
+                        getWorkspaceIDFromString(g_pConfigManager->getDefaultWorkspaceFor(szName), newDefaultWorkspaceName);
 
     if (WORKSPACEID == INT_MAX || (WORKSPACEID >= SPECIAL_WORKSPACE_START && WORKSPACEID <= -2)) {
         WORKSPACEID             = g_pCompositor->m_vWorkspaces.size() + 1;
         newDefaultWorkspaceName = std::to_string(WORKSPACEID);
 
-        Debug::log(LOG, "Invalid workspace= directive name in monitor parsing, workspace name \"%s\" is invalid.", monitorRule.defaultWorkspace.c_str());
+        Debug::log(LOG, "Invalid workspace= directive name in monitor parsing, workspace name \"%s\" is invalid.", g_pConfigManager->getDefaultWorkspaceFor(szName).c_str());
     }
 
     auto PNEWWORKSPACE = g_pCompositor->getWorkspaceByID(WORKSPACEID);
@@ -403,7 +440,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
 
         wlr_output_layout_remove(g_pCompositor->m_sWLROutputLayout, output);
 
-        vecPosition = Vector2D(-1337420, -1337420);
+        vecPosition = PMIRRORMON->vecPosition;
 
         pMirrorOf = PMIRRORMON;
 

src/helpers/Monitor.hpp

@@ -6,11 +6,15 @@
 #include <vector>
 #include <array>
 #include <memory>
+#include "Timer.hpp"
 
 struct SMonitorRule;
 
 class CMonitor {
   public:
+    CMonitor();
+    ~CMonitor();
+
     Vector2D    vecPosition        = Vector2D(-1, -1); // means unset
     Vector2D    vecSize            = Vector2D(0, 0);
     Vector2D    vecPixelSize       = Vector2D(0, 0);
@@ -28,9 +32,9 @@ class CMonitor {
     Vector2D    vecReservedBottomRight = Vector2D(0, 0);
 
     // WLR stuff
+    wlr_damage_ring     damage;
     wlr_output*         output          = nullptr;
     float               refreshRate     = 60;
-    wlr_output_damage*  damage          = nullptr;
     int                 framesToSkip    = 0;
     int                 forceFullFrames = 0;
     bool                noFrameSchedule = false;
@@ -42,21 +46,27 @@ class CMonitor {
     bool                enabled10bit  = false; // as above, this can be TRUE even if 10 bit failed.
     bool                createdByUser = false;
 
+    bool                pendingFrame    = false; // if we schedule a frame during rendering, reschedule it after
+    bool                renderingActive = false;
+
+    wl_event_source*    renderTimer  = nullptr; // for RAT
+    bool                RATScheduled = false;
+    CTimer              lastPresentationTimer;
+
     // mirroring
     CMonitor*              pMirrorOf = nullptr;
     std::vector<CMonitor*> mirrors;
 
     // for the special workspace. 0 means not open.
-    int specialWorkspaceID = 0;
+    int                                                        specialWorkspaceID = 0;
 
-    // Double-linked list because we need to have constant mem addresses for signals
-    // We have to store pointers and use raw new/delete because they might be moved between them
-    // and I am lazy
-    std::array<std::vector<std::unique_ptr<SLayerSurface>>, 4> m_aLayerSurfaceLists;
+    std::array<std::vector<std::unique_ptr<SLayerSurface>>, 4> m_aLayerSurfaceLayers;
 
     DYNLISTENER(monitorFrame);
     DYNLISTENER(monitorDestroy);
     DYNLISTENER(monitorStateRequest);
+    DYNLISTENER(monitorDamage);
+    DYNLISTENER(monitorNeedsFrame);
 
     // hack: a group = workspaces on a monitor.
     // I don't really care lol :P
@@ -65,8 +75,8 @@ class CMonitor {
     // methods
     void                       onConnect(bool noRule);
     void                       onDisconnect();
-    void                       addDamage(pixman_region32_t* rg);
-    void                       addDamage(wlr_box* box);
+    void                       addDamage(const pixman_region32_t* rg);
+    void                       addDamage(const wlr_box* box);
     void                       setMirror(const std::string&);
     bool                       isMirror();
     float                      getDefaultScale();

src/helpers/SubsurfaceTree.cpp

@@ -3,8 +3,11 @@
 #include "../Compositor.hpp"
 
 void addSurfaceGlobalOffset(SSurfaceTreeNode* node, int* lx, int* ly) {
-    *lx += node->pSurface->current.dx;
-    *ly += node->pSurface->current.dy;
+    if (!node->pSurface || !node->pSurface->exists())
+        return;
+
+    *lx += node->pSurface->wlr()->current.dx;
+    *ly += node->pSurface->wlr()->current.dy;
 
     if (node->offsetfn) {
         // This is the root node
@@ -23,7 +26,13 @@ void addSurfaceGlobalOffset(SSurfaceTreeNode* node, int* lx, int* ly) {
 SSurfaceTreeNode* createTree(wlr_surface* pSurface, CWindow* pWindow) {
     const auto PNODE = &SubsurfaceTree::surfaceTreeNodes.emplace_back();
 
-    PNODE->pSurface     = pSurface;
+    if (pSurface->data)
+        PNODE->pSurface = (CWLSurface*)pSurface->data;
+    else {
+        PNODE->pInternalSurface = pSurface;
+        PNODE->pSurface         = &PNODE->pInternalSurface;
+    }
+
     PNODE->pWindowOwner = pWindow;
 
     PNODE->hyprListener_newSubsurface.initCallback(&pSurface->events.new_subsurface, &Events::listener_newSubsurfaceNode, PNODE, "SurfaceTreeNode");
@@ -88,9 +97,9 @@ void SubsurfaceTree::destroySurfaceTree(SSurfaceTreeNode* pNode) {
     pNode->hyprListener_newSubsurface.removeCallback();
 
     // damage
-    if (pNode->pSurface) {
+    if (pNode->pSurface && pNode->pSurface->exists()) {
         wlr_box extents = {};
-        wlr_surface_get_extends(pNode->pSurface, &extents);
+        wlr_surface_get_extends(pNode->pSurface->wlr(), &extents);
 
         int lx = 0, ly = 0;
         addSurfaceGlobalOffset(pNode, &lx, &ly);
@@ -175,6 +184,9 @@ void Events::listener_unmapSubsurface(void* owner, void* data) {
 
     Debug::log(LOG, "Subsurface %x unmapped", subsurface);
 
+    if (subsurface->pSubsurface->surface == g_pCompositor->m_pLastFocus)
+        g_pInputManager->releaseAllMouseButtons();
+
     if (subsurface->pChild) {
         const auto PNODE = subsurface->pChild;
 
@@ -182,13 +194,14 @@ void Events::listener_unmapSubsurface(void* owner, void* data) {
             std::find_if(SubsurfaceTree::surfaceTreeNodes.begin(), SubsurfaceTree::surfaceTreeNodes.end(), [&](const SSurfaceTreeNode& other) { return &other == PNODE; });
 
         if (IT != SubsurfaceTree::surfaceTreeNodes.end()) {
-            int lx = 0, ly = 0;
-            addSurfaceGlobalOffset(PNODE, &lx, &ly);
+            if (PNODE->pSurface && PNODE->pSurface->exists()) {
+                int lx = 0, ly = 0;
+                addSurfaceGlobalOffset(PNODE, &lx, &ly);
 
-            wlr_box extents = {lx, ly, 0, 0};
-            if (PNODE->pSurface) {
-                extents.width  = PNODE->pSurface->current.width;
-                extents.height = PNODE->pSurface->current.height;
+                wlr_box extents = {lx, ly, 0, 0};
+
+                extents.width  = PNODE->pSurface->wlr()->current.width;
+                extents.height = PNODE->pSurface->wlr()->current.height;
 
                 g_pHyprRenderer->damageBox(&extents);
             }
@@ -197,6 +210,8 @@ void Events::listener_unmapSubsurface(void* owner, void* data) {
             // subsurface->pChild = nullptr;
         }
     }
+
+    g_pInputManager->simulateMouseMovement(); // to focus and return back to an appropriate surface
 }
 
 void Events::listener_commitSubsurface(void* owner, void* data) {
@@ -226,7 +241,8 @@ void Events::listener_commitSubsurface(void* owner, void* data) {
             }
         }
 
-    g_pHyprRenderer->damageSurface(pNode->pSurface, lx, ly);
+    if (pNode->pSurface && pNode->pSurface->exists())
+        g_pHyprRenderer->damageSurface(pNode->pSurface->wlr(), lx, ly);
 }
 
 void Events::listener_destroySubsurface(void* owner, void* data) {

src/helpers/SubsurfaceTree.hpp

@@ -2,6 +2,7 @@
 
 #include "../defines.hpp"
 #include <list>
+#include "WLSurface.hpp"
 
 struct SSubsurface;
 class CWindow;
@@ -9,7 +10,8 @@ class CWindow;
 typedef void (*applyGlobalOffsetFn)(void*, int*, int*);
 
 struct SSurfaceTreeNode {
-    wlr_surface* pSurface = nullptr;
+    CWLSurface* pSurface = nullptr; // actual surface
+    CWLSurface  pInternalSurface;   // not present for head nodes to not dupe wlr_surface ownership
 
     DYNLISTENER(newSubsurface);
     DYNLISTENER(commit);
@@ -24,7 +26,7 @@ struct SSurfaceTreeNode {
     void*                  globalOffsetData;
     CWindow*               pWindowOwner = nullptr;
 
-    bool                   operator==(const SSurfaceTreeNode& rhs) {
+    bool                   operator==(const SSurfaceTreeNode& rhs) const {
         return pSurface == rhs.pSurface;
     }
 };
@@ -41,7 +43,7 @@ struct SSubsurface {
 
     CWindow* pWindowOwner = nullptr;
 
-    bool     operator==(const SSubsurface& rhs) {
+    bool     operator==(const SSubsurface& rhs) const {
         return pSubsurface == rhs.pSubsurface;
     }
 };

src/helpers/Vector2D.cpp

@@ -1,5 +1,6 @@
 #include "Vector2D.hpp"
 #include <algorithm>
+#include <cmath>
 
 Vector2D::Vector2D(double xx, double yy) {
     x = xx;
@@ -29,4 +30,10 @@ Vector2D Vector2D::floor() {
 
 Vector2D Vector2D::clamp(const Vector2D& min, const Vector2D& max) {
     return Vector2D(std::clamp(this->x, min.x, max.x == 0 ? INFINITY : max.x), std::clamp(this->y, min.y, max.y == 0 ? INFINITY : max.y));
-}
+}
+
+double Vector2D::distance(const Vector2D& other) {
+    double dx = x - other.x;
+    double dy = y - other.y;
+    return std::sqrt(dx * dx + dy * dy);
+}

src/helpers/Vector2D.hpp

@@ -39,7 +39,13 @@ class Vector2D {
         return Vector2D(this->x * a.x, this->y * a.y);
     }
 
+    Vector2D operator/(const Vector2D& a) const {
+        return Vector2D(this->x / a.x, this->y / a.y);
+    }
+    
+    double   distance(const Vector2D& other);
+
     Vector2D clamp(const Vector2D& min, const Vector2D& max = Vector2D());
 
     Vector2D floor();
-};
+};

src/helpers/WLClasses.cpp

@@ -5,4 +5,19 @@ SLayerSurface::SLayerSurface() {
     alpha.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), nullptr, AVARDAMAGE_ENTIRE);
     alpha.m_pLayer = this;
     alpha.registerVar();
+}
+
+void SLayerSurface::applyRules() {
+    noAnimations = false;
+    forceBlur    = false;
+    ignoreZero   = false;
+
+    for (auto& rule : g_pConfigManager->getMatchingRules(this)) {
+        if (rule.rule == "noanim")
+            noAnimations = true;
+        else if (rule.rule == "blur")
+            forceBlur = true;
+        else if (rule.rule == "ignorezero")
+            ignoreZero = true;
+    }
 }

src/helpers/WLClasses.hpp

@@ -6,13 +6,24 @@
 #include "../Window.hpp"
 #include "SubsurfaceTree.hpp"
 #include "AnimatedVariable.hpp"
+#include "WLSurface.hpp"
+
+struct SLayerRule {
+    std::string targetNamespace = "";
+    std::string rule            = "";
+};
 
 struct SLayerSurface {
     SLayerSurface();
 
+    void                  applyRules();
+
     wlr_layer_surface_v1* layerSurface;
     wl_list               link;
 
+    CWLSurface            surface;
+    std::list<CWLSurface> popupSurfaces;
+
     DYNLISTENER(destroyLayerSurface);
     DYNLISTENER(mapLayerSurface);
     DYNLISTENER(unmapLayerSurface);
@@ -33,25 +44,28 @@ struct SLayerSurface {
     bool                      fadingOut     = false;
     bool                      readyToDelete = false;
     bool                      noProcess     = false;
+    bool                      noAnimations  = false;
 
-    bool                      forceBlur = false;
+    bool                      forceBlur  = false;
+    bool                      ignoreZero = false;
 
     // For the list lookup
-    bool operator==(const SLayerSurface& rhs) {
+    bool operator==(const SLayerSurface& rhs) const {
         return layerSurface == rhs.layerSurface && monitorID == rhs.monitorID;
     }
 };
 
+class CMonitor;
+
 struct SRenderData {
-    wlr_output* output;
-    timespec*   when;
-    int         x, y;
+    CMonitor* pMonitor;
+    timespec* when;
+    int       x, y;
 
     // for iters
     void*        data    = nullptr;
     wlr_surface* surface = nullptr;
     int          w, h;
-    void*        pMonitor = nullptr;
 
     // for rounding
     bool dontRound = true;
@@ -116,7 +130,7 @@ struct SKeyboard {
     int                numlockOn   = -1;
 
     // For the list lookup
-    bool operator==(const SKeyboard& rhs) {
+    bool operator==(const SKeyboard& rhs) const {
         return keyboard == rhs.keyboard;
     }
 };
@@ -138,7 +152,7 @@ struct SMouse {
     DYNLISTENER(commitConstraint);
     DYNLISTENER(destroyMouse);
 
-    bool operator==(const SMouse& b) {
+    bool operator==(const SMouse& b) const {
         return mouse == b.mouse;
     }
 };
@@ -153,7 +167,7 @@ struct SConstraint {
     DYNLISTENER(setConstraintRegion);
     DYNLISTENER(destroyConstraint);
 
-    bool operator==(const SConstraint& b) {
+    bool operator==(const SConstraint& b) const {
         return constraint == b.constraint;
     }
 };
@@ -162,6 +176,7 @@ class CMonitor;
 
 struct SXDGPopup {
     CWindow*       parentWindow = nullptr;
+    SLayerSurface* parentLS     = nullptr;
     SXDGPopup*     parentPopup  = nullptr;
     wlr_xdg_popup* popup        = nullptr;
     CMonitor*      monitor      = nullptr;
@@ -178,7 +193,7 @@ struct SXDGPopup {
     SSurfaceTreeNode* pSurfaceTree = nullptr;
 
     // For the list lookup
-    bool operator==(const SXDGPopup& rhs) {
+    bool operator==(const SXDGPopup& rhs) const {
         return popup == rhs.popup;
     }
 };
@@ -222,7 +237,7 @@ struct STablet {
 
     std::string           name = "";
 
-    bool                  operator==(const STablet& b) {
+    bool                  operator==(const STablet& b) const {
         return wlrDevice == b.wlrDevice;
     }
 };
@@ -245,7 +260,7 @@ struct STabletTool {
     DYNLISTENER(TabletToolDestroy);
     DYNLISTENER(TabletToolSetCursor);
 
-    bool operator==(const STabletTool& b) {
+    bool operator==(const STabletTool& b) const {
         return wlrTabletTool == b.wlrTabletTool;
     }
 };
@@ -263,7 +278,7 @@ struct STabletPad {
     DYNLISTENER(Ring);
     DYNLISTENER(Destroy);
 
-    bool operator==(const STabletPad& b) {
+    bool operator==(const STabletPad& b) const {
         return wlrTabletPadV2 == b.wlrTabletPadV2;
     }
 };
@@ -274,7 +289,7 @@ struct SIdleInhibitor {
 
     DYNLISTENER(Destroy);
 
-    bool operator==(const SIdleInhibitor& b) {
+    bool operator==(const SIdleInhibitor& b) const {
         return pWlrInhibitor == b.pWlrInhibitor;
     }
 };
@@ -290,8 +305,11 @@ struct SSwipeGesture {
     CMonitor*   pMonitor = nullptr;
 };
 
+struct STextInputV1;
+
 struct STextInput {
     wlr_text_input_v3* pWlrInput = nullptr;
+    STextInputV1*      pV1Input  = nullptr;
 
     wlr_surface*       pPendingSurface = nullptr;
 
@@ -326,7 +344,7 @@ struct SIMEPopup {
 
     DYNLISTENER(focusedSurfaceUnmap);
 
-    bool operator==(const SIMEPopup& other) {
+    bool operator==(const SIMEPopup& other) const {
         return pSurface == other.pSurface;
     }
 };
@@ -340,7 +358,7 @@ struct STouchDevice {
 
     DYNLISTENER(destroy);
 
-    bool operator==(const STouchDevice& other) {
+    bool operator==(const STouchDevice& other) const {
         return pWlrDevice == other.pWlrDevice;
     }
 };
@@ -348,10 +366,12 @@ struct STouchDevice {
 struct SSwitchDevice {
     wlr_input_device* pWlrDevice = nullptr;
 
+    int               status = -1; // uninitialized
+
     DYNLISTENER(destroy);
     DYNLISTENER(toggle);
 
-    bool operator==(const SSwitchDevice& other) {
+    bool operator==(const SSwitchDevice& other) const {
         return pWlrDevice == other.pWlrDevice;
     }
 };

src/helpers/WLSurface.cpp

@@ -0,0 +1,57 @@
+#include "WLSurface.hpp"
+#include "../Compositor.hpp"
+
+CWLSurface::CWLSurface(wlr_surface* pSurface) {
+    m_pWLRSurface = pSurface;
+    init();
+}
+
+void CWLSurface::assign(wlr_surface* pSurface) {
+    m_pWLRSurface = pSurface;
+    init();
+}
+
+void CWLSurface::unassign() {
+    destroy();
+}
+
+CWLSurface::~CWLSurface() {
+    destroy();
+}
+
+bool CWLSurface::exists() const {
+    return m_pWLRSurface;
+}
+
+wlr_surface* CWLSurface::wlr() const {
+    return m_pWLRSurface;
+}
+
+void CWLSurface::destroy() {
+    if (!m_pWLRSurface)
+        return;
+
+    hyprListener_destroy.removeCallback();
+    m_pWLRSurface->data = nullptr;
+
+    if (g_pCompositor->m_pLastFocus == m_pWLRSurface)
+        g_pCompositor->m_pLastFocus = nullptr;
+
+    m_pWLRSurface = nullptr;
+
+    Debug::log(LOG, "CWLSurface %x called destroy()", this);
+}
+
+void CWLSurface::init() {
+    if (!m_pWLRSurface)
+        return;
+
+    RASSERT(!m_pWLRSurface->data, "Attempted to duplicate CWLSurface ownership!");
+
+    m_pWLRSurface->data = this;
+
+    hyprListener_destroy.initCallback(
+        &m_pWLRSurface->events.destroy, [&](void* owner, void* data) { destroy(); }, this, "CWLSurface");
+
+    Debug::log(LOG, "CWLSurface %x called init()", this);
+}

src/helpers/WLSurface.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "../defines.hpp"
+
+class CWLSurface {
+  public:
+    CWLSurface() = default;
+    CWLSurface(wlr_surface* pSurface);
+    ~CWLSurface();
+
+    void assign(wlr_surface* pSurface);
+    void unassign();
+
+    CWLSurface(const CWLSurface&) = delete;
+    CWLSurface(CWLSurface&&)      = delete;
+    CWLSurface&  operator=(const CWLSurface&) = delete;
+    CWLSurface&  operator=(CWLSurface&&) = delete;
+
+    wlr_surface* wlr() const;
+    bool         exists() const;
+
+    CWLSurface&  operator=(wlr_surface* pSurface) {
+        destroy();
+        m_pWLRSurface = pSurface;
+        init();
+
+        return *this;
+    }
+
+    bool operator==(const CWLSurface& other) const {
+        return other.wlr() == wlr();
+    }
+
+    bool operator==(const wlr_surface* other) const {
+        return other == wlr();
+    }
+
+    explicit operator bool() const {
+        return exists();
+    }
+
+  private:
+    wlr_surface* m_pWLRSurface = nullptr;
+
+    void         destroy();
+    void         init();
+
+    DYNLISTENER(destroy);
+};

src/helpers/Workspace.cpp

@@ -37,6 +37,7 @@ CWorkspace::CWorkspace(int monitorID, std::string name, bool special) {
     m_fAlpha.registerVar();
 
     g_pEventManager->postEvent({"createworkspace", m_szName}, true);
+    EMIT_HOOK_EVENT("createWorkspace", this);
 }
 
 CWorkspace::~CWorkspace() {
@@ -51,6 +52,7 @@ CWorkspace::~CWorkspace() {
     }
 
     g_pEventManager->postEvent({"destroyworkspace", m_szName}, true);
+    EMIT_HOOK_EVENT("destroyWorkspace", this);
 }
 
 void CWorkspace::startAnim(bool in, bool left, bool instant) {
@@ -100,7 +102,7 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
     // check LS-es
     if (in && !m_bIsSpecialWorkspace) {
         const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
-        for (auto& ls : PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
+        for (auto& ls : PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
             if (!ls->fadingOut)
                 ls->alpha = m_bHasFullscreenWindow && m_efFullscreenMode == FULLSCREEN_FULL ? 0.f : 1.f;
         }

src/helpers/Workspace.hpp

@@ -23,7 +23,11 @@ class CWorkspace {
     uint64_t    m_iMonitorID = -1;
     // Previous workspace ID is stored during a workspace change, allowing travel
     // to the previous workspace.
-    int                          m_iPrevWorkspaceID     = -1;
+    struct SPrevWorkspaceData {
+        int         iID  = -1;
+        std::string name = "";
+    } m_sPrevWorkspace;
+
     bool                         m_bHasFullscreenWindow = false;
     eFullscreenMode              m_efFullscreenMode     = FULLSCREEN_FULL;
 

src/helpers/X11Stubs.hpp

@@ -0,0 +1,7 @@
+#pragma once
+
+inline bool wlr_backend_is_x11(void*) {
+    return false;
+}
+
+inline void wlr_x11_output_create(void*) {}

src/helpers/XWaylandStubs.hpp

@@ -155,14 +155,16 @@ inline wlr_xwayland_surface* wlr_xwayland_surface_from_wlr_surface(void*) {
     return nullptr;
 }
 
-inline void wlr_xwayland_surface_close(wlr_xwayland_surface*) {}
+inline void                  wlr_xwayland_surface_close(wlr_xwayland_surface*) {}
 
-inline void wlr_xwayland_surface_set_fullscreen(wlr_xwayland_surface*, bool) {}
+inline void                  wlr_xwayland_surface_set_fullscreen(wlr_xwayland_surface*, bool) {}
 
-inline void wlr_xwayland_surface_set_minimized(wlr_xwayland_surface*, bool) {}
+inline void                  wlr_xwayland_surface_set_minimized(wlr_xwayland_surface*, bool) {}
 
-inline bool wlr_backend_is_x11(void*) {
-    return false;
+inline wlr_xwayland_surface* wlr_xwayland_surface_try_from_wlr_surface(wlr_surface*) {
+    return nullptr;
 }
 
-inline void wlr_x11_output_create(void*) {}
+inline bool wlr_xwayland_or_surface_wants_focus(const wlr_xwayland_surface*) {
+    return false;
+}

src/hyprerror/HyprError.cpp

@@ -1,6 +1,31 @@
 #include "HyprError.hpp"
 #include "../Compositor.hpp"
 
+CHyprError::CHyprError() {
+    m_fFadeOpacity.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), nullptr, AVARDAMAGE_NONE);
+    m_fFadeOpacity.registerVar();
+
+    g_pHookSystem->hookDynamic("focusedMon", [&](void* self, std::any param) {
+        if (!m_bIsCreated)
+            return;
+
+        g_pHyprRenderer->damageMonitor(g_pCompositor->m_pLastMonitor);
+        m_bMonitorChanged = true;
+    });
+
+    g_pHookSystem->hookDynamic("preRender", [&](void* self, std::any param) {
+        if (!m_bIsCreated)
+            return;
+
+        if (m_fFadeOpacity.isBeingAnimated() || m_bMonitorChanged)
+            g_pHyprRenderer->damageBox(&m_bDamageBox);
+    });
+}
+
+CHyprError::~CHyprError() {
+    m_fFadeOpacity.unregister();
+}
+
 void CHyprError::queueCreate(std::string message, const CColor& color) {
     m_szQueued = message;
     m_cQueued  = color;
@@ -12,9 +37,16 @@ void CHyprError::createQueued() {
         m_tTexture.destroyTexture();
     }
 
+    m_fFadeOpacity.setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeIn"));
+
+    m_fFadeOpacity.setValueAndWarp(0.f);
+    m_fFadeOpacity = 1.f;
+
     const auto PMONITOR = g_pCompositor->m_vMonitors.front().get();
 
-    const auto FONTSIZE = std::clamp((int)(10.f * (PMONITOR->vecPixelSize.x / 1920.f)), 8, 40);
+    const auto SCALE = PMONITOR->scale;
+
+    const auto FONTSIZE = std::clamp((int)(10.f * ((PMONITOR->vecPixelSize.x * SCALE) / 1920.f)), 8, 40);
 
     const auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
 
@@ -26,22 +58,37 @@ void CHyprError::createQueued() {
     cairo_paint(CAIRO);
     cairo_restore(CAIRO);
 
-    const auto LINECOUNT = 1 + std::count(m_szQueued.begin(), m_szQueued.end(), '\n');
+    const auto   LINECOUNT = 1 + std::count(m_szQueued.begin(), m_szQueued.end(), '\n');
+
+    const double DEGREES = M_PI / 180.0;
+
+    const double PAD = 10 * SCALE;
+
+    const double X      = PAD;
+    const double Y      = PAD;
+    const double WIDTH  = PMONITOR->vecPixelSize.x - PAD * 2;
+    const double HEIGHT = (FONTSIZE + 2 * (FONTSIZE / 10.0)) * LINECOUNT + 3;
+    const double RADIUS = PAD > HEIGHT / 2 ? HEIGHT / 2 - 1 : PAD;
+
+    m_bDamageBox = {0, 0, (int)PMONITOR->vecPixelSize.x, (int)HEIGHT + (int)PAD * 2};
+
+    cairo_new_sub_path(CAIRO);
+    cairo_arc(CAIRO, X + WIDTH - RADIUS, Y + RADIUS, RADIUS, -90 * DEGREES, 0 * DEGREES);
+    cairo_arc(CAIRO, X + WIDTH - RADIUS, Y + HEIGHT - RADIUS, RADIUS, 0 * DEGREES, 90 * DEGREES);
+    cairo_arc(CAIRO, X + RADIUS, Y + HEIGHT - RADIUS, RADIUS, 90 * DEGREES, 180 * DEGREES);
+    cairo_arc(CAIRO, X + RADIUS, Y + RADIUS, RADIUS, 180 * DEGREES, 270 * DEGREES);
+    cairo_close_path(CAIRO);
 
     cairo_set_source_rgba(CAIRO, m_cQueued.r, m_cQueued.g, m_cQueued.b, m_cQueued.a);
-    cairo_rectangle(CAIRO, 0, 0, PMONITOR->vecPixelSize.x, (FONTSIZE + 2 * (FONTSIZE / 10.f)) * LINECOUNT);
-
-    // outline
-    cairo_rectangle(CAIRO, 0, 0, 1, PMONITOR->vecPixelSize.y);                                                   // left
-    cairo_rectangle(CAIRO, PMONITOR->vecPixelSize.x - 1, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y); // right
-    cairo_rectangle(CAIRO, 0, PMONITOR->vecPixelSize.y - 1, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y); // bottom
-
-    cairo_fill(CAIRO);
+    cairo_fill_preserve(CAIRO);
+    cairo_set_source_rgba(CAIRO, 0, 0, 0, 1);
+    cairo_set_line_width(CAIRO, 2);
+    cairo_stroke(CAIRO);
 
     // draw the text with a common font
-    const CColor textColor = m_cQueued.r * m_cQueued.g * m_cQueued.b < 0.5f ? CColor(1.0, 1.0, 1.0, 1.0) : CColor(0, 0, 0, 1.0);
+    const CColor textColor = m_cQueued.r + m_cQueued.g + m_cQueued.b < 0.2f ? CColor(1.0, 1.0, 1.0, 1.0) : CColor(0, 0, 0, 1.0);
 
-    cairo_select_font_face(CAIRO, "Noto Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+    cairo_select_font_face(CAIRO, "Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
     cairo_set_font_size(CAIRO, FONTSIZE);
     cairo_set_source_rgba(CAIRO, textColor.r, textColor.g, textColor.b, textColor.a);
 
@@ -52,7 +99,7 @@ void CHyprError::createQueued() {
             m_szQueued = m_szQueued.substr(NEWLPOS + 1);
         else
             m_szQueued = "";
-        cairo_move_to(CAIRO, 0, yoffset);
+        cairo_move_to(CAIRO, PAD + 1 + RADIUS, yoffset + PAD + 1);
         cairo_show_text(CAIRO, current.c_str());
         yoffset += FONTSIZE + (FONTSIZE / 10.f);
     }
@@ -92,22 +139,33 @@ void CHyprError::draw() {
     }
 
     if (m_bQueuedDestroy) {
-        m_bQueuedDestroy = false;
-        m_tTexture.destroyTexture();
-        m_bIsCreated = false;
-        m_szQueued   = "";
-        g_pHyprRenderer->damageMonitor(g_pCompositor->m_vMonitors.front().get());
-        return;
+        if (!m_fFadeOpacity.isBeingAnimated()) {
+            if (m_fFadeOpacity.fl() == 0.f) {
+                m_bQueuedDestroy = false;
+                m_tTexture.destroyTexture();
+                m_bIsCreated = false;
+                m_szQueued   = "";
+                return;
+            } else {
+                m_fFadeOpacity.setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeOut"));
+                m_fFadeOpacity = 0.f;
+            }
+        }
     }
 
-    const auto PMONITOR = g_pCompositor->m_vMonitors.front().get();
+    const auto PMONITOR = g_pHyprOpenGL->m_RenderData.pMonitor;
 
-    if (g_pHyprOpenGL->m_RenderData.pMonitor != PMONITOR)
-        return; // wrong mon
+    wlr_box    monbox = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
 
-    wlr_box windowBox = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
+    m_bDamageBox.x = (int)PMONITOR->vecPosition.x;
+    m_bDamageBox.y = (int)PMONITOR->vecPosition.y;
 
-    g_pHyprOpenGL->renderTexture(m_tTexture, &windowBox, 1.f, 0);
+    if (m_fFadeOpacity.isBeingAnimated() || m_bMonitorChanged)
+        g_pHyprRenderer->damageBox(&m_bDamageBox);
+
+    m_bMonitorChanged = false;
+
+    g_pHyprOpenGL->renderTexture(m_tTexture, &monbox, m_fFadeOpacity.fl(), 0);
 }
 
 void CHyprError::destroy() {

src/hyprerror/HyprError.hpp

@@ -2,22 +2,30 @@
 
 #include "../defines.hpp"
 #include "../render/Texture.hpp"
+#include "../helpers/AnimatedVariable.hpp"
 
 #include <cairo/cairo.h>
 
 class CHyprError {
   public:
+    CHyprError();
+    ~CHyprError();
+
     void queueCreate(std::string message, const CColor& color);
     void draw();
     void destroy();
 
   private:
-    void        createQueued();
-    std::string m_szQueued = "";
-    CColor      m_cQueued;
-    bool        m_bQueuedDestroy = false;
-    bool        m_bIsCreated     = false;
-    CTexture    m_tTexture;
+    void              createQueued();
+    std::string       m_szQueued = "";
+    CColor            m_cQueued;
+    bool              m_bQueuedDestroy = false;
+    bool              m_bIsCreated     = false;
+    CTexture          m_tTexture;
+    CAnimatedVariable m_fFadeOpacity;
+    wlr_box           m_bDamageBox = {0, 0, 0, 0};
+
+    bool              m_bMonitorChanged = false;
 };
 
 inline std::unique_ptr<CHyprError> g_pHyprError; // This is a full-screen error. Treat it with respect, and there can only be one at a time.

src/includes.hpp

@@ -102,11 +102,16 @@ extern "C" {
 #include <wlr/backend/headless.h>
 #include <wlr/backend/multi.h>
 #include <wlr/backend/wayland.h>
+#include <wlr/types/wlr_session_lock_v1.h>
+#include <wlr/types/wlr_single_pixel_buffer_v1.h>
 
 #include <drm_fourcc.h>
 
-#ifndef NO_XWAYLAND
+#if WLR_HAS_X11_BACKEND
 #include <wlr/backend/x11.h>
+#endif
+
+#ifndef NO_XWAYLAND
 #include <wlr/xwayland.h>
 #endif
 }
@@ -127,6 +132,10 @@ extern "C" {
 #include <GLES3/gl3ext.h>
 #endif
 
+#if !WLR_HAS_X11_BACKEND
+#include "helpers/X11Stubs.hpp"
+#endif
+
 #ifdef NO_XWAYLAND
 #define XWAYLAND false
 #include "helpers/XWaylandStubs.hpp"

src/layout/DwindleLayout.cpp

@@ -45,64 +45,6 @@ void SDwindleNodeData::getAllChildrenRecursive(std::deque<SDwindleNodeData*>* pD
     }
 }
 
-bool SDwindleNodeData::isGroupMember() {
-    return pNextGroupMember && pNextGroupMember != this;
-}
-
-SDwindleNodeData* SDwindleNodeData::getGroupHead() {
-    SDwindleNodeData* current = this->pNextGroupMember;
-
-    while (current != this) {
-        if (current->groupHead) {
-            return current;
-        }
-
-        current = current->pNextGroupMember;
-    }
-
-    this->groupHead = true;
-
-    return this;
-}
-
-SDwindleNodeData* SDwindleNodeData::getGroupVisible() {
-    SDwindleNodeData* current = this->pNextGroupMember;
-
-    while (current != this) {
-        if (!current->pWindow->isHidden()) {
-            return current;
-        }
-
-        current = current->pNextGroupMember;
-    }
-
-    return this;
-}
-
-void SDwindleNodeData::setGroupFocusedNode(SDwindleNodeData* pMember) {
-    SDwindleNodeData* current = this->pNextGroupMember;
-
-    while (current != this) {
-        current->pWindow->setHidden(current != pMember);
-        current = current->pNextGroupMember;
-    }
-
-    this->pWindow->setHidden(pMember != this);
-}
-
-int SDwindleNodeData::getGroupMemberCount() {
-    SDwindleNodeData* current = this->pNextGroupMember;
-
-    int               no = 1;
-
-    while (current != this) {
-        current = current->pNextGroupMember;
-        no++;
-    }
-
-    return no;
-}
-
 int CHyprDwindleLayout::getNodesOnWorkspace(const int& id) {
     int no = 0;
     for (auto& n : m_lDwindleNodesData) {
@@ -189,8 +131,7 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for
     const auto         NODESONWORKSPACE = getNodesOnWorkspace(PWINDOW->m_iWorkspaceID);
 
     if (*PNOGAPSWHENONLY && !g_pCompositor->isWorkspaceSpecial(PWINDOW->m_iWorkspaceID) &&
-        (NODESONWORKSPACE == 1 || (pNode->isGroupMember() && pNode->getGroupMemberCount() == NODESONWORKSPACE) ||
-         (PWINDOW->m_bIsFullscreen && g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID)->m_efFullscreenMode == FULLSCREEN_MAXIMIZED))) {
+        (NODESONWORKSPACE == 1 || (PWINDOW->m_bIsFullscreen && g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID)->m_efFullscreenMode == FULLSCREEN_MAXIMIZED))) {
         PWINDOW->m_vRealPosition = calcPos - Vector2D(*PBORDERSIZE, *PBORDERSIZE);
         PWINDOW->m_vRealSize     = calcSize + Vector2D(2 * *PBORDERSIZE, 2 * *PBORDERSIZE);
 
@@ -238,6 +179,10 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for
         }
     }
 
+    const auto RESERVED = PWINDOW->getFullWindowReservedArea();
+    calcPos             = calcPos + RESERVED.topLeft;
+    calcSize            = calcSize - (RESERVED.topLeft + RESERVED.bottomRight);
+
     if (g_pCompositor->isWorkspaceSpecial(PWINDOW->m_iWorkspaceID)) {
         // if special, we adjust the coords a bit
         static auto* const PSCALEFACTOR = &g_pConfigManager->getConfigValuePtr("dwindle:special_scale_factor")->floatValue;
@@ -262,14 +207,6 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for
         g_pHyprRenderer->damageWindow(PWINDOW);
     }
 
-    if (pNode->isGroupMember() && pNode->groupHead) {
-        // update visible node
-        const auto PVISNODE = pNode->getGroupVisible();
-
-        PVISNODE->pWindow->m_vRealSize     = PWINDOW->m_vRealSize.goalv();
-        PVISNODE->pWindow->m_vRealPosition = PWINDOW->m_vRealPosition.goalv();
-    }
-
     PWINDOW->updateWindowDecos();
 }
 
@@ -282,7 +219,8 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
 
     const auto         PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
 
-    static auto* const PUSEACTIVE = &g_pConfigManager->getConfigValuePtr("dwindle:use_active_for_splits")->intValue;
+    static auto* const PUSEACTIVE    = &g_pConfigManager->getConfigValuePtr("dwindle:use_active_for_splits")->intValue;
+    static auto* const PDEFAULTSPLIT = &g_pConfigManager->getConfigValuePtr("dwindle:default_split_ratio")->floatValue;
 
     // Populate the node with our window's data
     PNODE->workspaceID = pWindow->m_iWorkspaceID;
@@ -359,23 +297,10 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
     }
 
     // if it's a group, add the window
-    if (OPENINGON->isGroupMember()) {
-        const auto PHEAD = OPENINGON->getGroupHead();
+    if (OPENINGON->pWindow->m_sGroupData.pNextWindow && !g_pKeybindManager->m_bGroupsLocked) {
+        m_lDwindleNodesData.remove(*PNODE);
 
-        const auto PTAIL = PHEAD->pPreviousGroupMember;
-
-        PHEAD->pPreviousGroupMember = PNODE;
-        PTAIL->pNextGroupMember     = PNODE;
-
-        PNODE->pNextGroupMember     = PHEAD;
-        PNODE->pPreviousGroupMember = PTAIL;
-
-        PHEAD->setGroupFocusedNode(PNODE);
-
-        PNODE->position = PHEAD->position;
-        PNODE->size     = PHEAD->size;
-
-        applyNodeDataToWindow(PNODE);
+        OPENINGON->pWindow->insertWindowToGroup(pWindow);
 
         pWindow->m_dWindowDecorations.emplace_back(std::make_unique<CHyprGroupBarDecoration>(pWindow));
 
@@ -393,6 +318,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
     NEWPARENT->workspaceID = OPENINGON->workspaceID;
     NEWPARENT->pParent     = OPENINGON->pParent;
     NEWPARENT->isNode      = true; // it is a node
+    NEWPARENT->splitRatio  = std::clamp(*PDEFAULTSPLIT, 0.1f, 1.9f);
 
     const auto PWIDTHMULTIPLIER = &g_pConfigManager->getConfigValuePtr("dwindle:split_width_multiplier")->floatValue;
 
@@ -479,51 +405,6 @@ void CHyprDwindleLayout::onWindowRemovedTiling(CWindow* pWindow) {
     if (pWindow->m_bIsFullscreen)
         g_pCompositor->setWindowFullscreen(pWindow, false, FULLSCREEN_FULL);
 
-    // check if it was grouped
-    if (PNODE->isGroupMember()) {
-        // get shit
-        const auto PPREV = PNODE->pPreviousGroupMember;
-        const auto PNEXT = PNODE->pNextGroupMember;
-
-        PPREV->pNextGroupMember     = PNEXT;
-        PNEXT->pPreviousGroupMember = PPREV;
-
-        if (PNODE->groupHead) {
-            PNEXT->groupHead = true;
-            PNEXT->pParent   = PNODE->pParent;
-
-            if (PNODE->pParent) {
-                if (PNODE->pParent->children[0] == PNODE) {
-                    PNODE->pParent->children[0] = PNEXT;
-                } else {
-                    PNODE->pParent->children[1] = PNEXT;
-                }
-            }
-
-            PNEXT->position = PNODE->position;
-            PNEXT->size     = PNODE->size;
-        } else {
-            const auto PHEAD = PNODE->getGroupHead();
-
-            PNEXT->position = PHEAD->position;
-            PNEXT->size     = PHEAD->size;
-        }
-
-        PNEXT->setGroupFocusedNode(PNEXT);
-        PNEXT->pWindow->setHidden(false);
-
-        m_lDwindleNodesData.remove(*PNODE);
-
-        applyNodeDataToWindow(PNEXT);
-
-        if (!PNEXT->isGroupMember()) {
-            // means we dissolved the group
-            recalculateMonitor(PNEXT->pWindow->m_iMonitorID);
-        }
-
-        return;
-    }
-
     const auto PPARENT = PNODE->pParent;
 
     if (!PPARENT) {
@@ -538,17 +419,6 @@ void CHyprDwindleLayout::onWindowRemovedTiling(CWindow* pWindow) {
     PSIBLING->size     = PPARENT->size;
     PSIBLING->pParent  = PPARENT->pParent;
 
-    if (PSIBLING->isGroupMember()) {
-        // apply to all group members
-        SDwindleNodeData* current = PSIBLING->pNextGroupMember;
-
-        while (current != PSIBLING) {
-            current->position = PPARENT->position;
-            current->size     = PPARENT->size;
-            current           = current->pNextGroupMember;
-        }
-    }
-
     if (PPARENT->pParent != nullptr) {
         if (PPARENT->pParent->children[0] == PPARENT) {
             PPARENT->pParent->children[0] = PSIBLING;
@@ -592,17 +462,14 @@ void CHyprDwindleLayout::recalculateMonitor(const int& monid) {
         }
     }
 
-    // Ignore any recalc events if we have a fullscreen window, but process if fullscreen mode 2
     if (PWORKSPACE->m_bHasFullscreenWindow) {
-        if (PWORKSPACE->m_efFullscreenMode == FULLSCREEN_FULL)
-            return;
-
         // massive hack from the fullscreen func
         const auto PFULLWINDOW = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
 
-        if (!PFULLWINDOW) { // ????
-            PWORKSPACE->m_bHasFullscreenWindow = false;
-        } else {
+        if (PWORKSPACE->m_efFullscreenMode == FULLSCREEN_FULL) {
+            PFULLWINDOW->m_vRealPosition = PMONITOR->vecPosition;
+            PFULLWINDOW->m_vRealSize     = PMONITOR->vecSize;
+        } else if (PWORKSPACE->m_efFullscreenMode == FULLSCREEN_MAXIMIZED) {
             SDwindleNodeData fakeNode;
             fakeNode.pWindow         = PFULLWINDOW;
             fakeNode.position        = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
@@ -612,9 +479,9 @@ void CHyprDwindleLayout::recalculateMonitor(const int& monid) {
             PFULLWINDOW->m_vSize     = fakeNode.size;
 
             applyNodeDataToWindow(&fakeNode);
-
-            return;
         }
+
+        return;
     }
 
     const auto TOPNODE = getMasterNodeOnWorkspace(PMONITOR->activeWorkspace);
@@ -741,6 +608,7 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscree
     PWORKSPACE->m_bHasFullscreenWindow = !PWORKSPACE->m_bHasFullscreenWindow;
 
     g_pEventManager->postEvent(SHyprIPCEvent{"fullscreen", std::to_string((int)on)});
+    EMIT_HOOK_EVENT("fullscreen", pWindow);
 
     if (!pWindow->m_bIsFullscreen) {
         // if it got its fullscreen disabled, set back its node if it had one
@@ -751,6 +619,10 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscree
             // get back its' dimensions from position and size
             pWindow->m_vRealPosition = pWindow->m_vLastFloatingPosition;
             pWindow->m_vRealSize     = pWindow->m_vLastFloatingSize;
+
+            pWindow->m_sSpecialRenderData.rounding = true;
+            pWindow->m_sSpecialRenderData.border   = true;
+            pWindow->m_sSpecialRenderData.decorate = true;
         }
     } else {
         // if it now got fullscreen, make it fullscreen
@@ -814,252 +686,14 @@ void addToDequeRecursive(std::deque<SDwindleNodeData*>* pDeque, std::deque<SDwin
     }
 }
 
-void CHyprDwindleLayout::toggleWindowGroup(CWindow* pWindow) {
-    if (!g_pCompositor->windowValidMapped(pWindow))
-        return;
-
-    // get the node
-    const auto PNODE = getNodeFromWindow(pWindow);
-
-    if (!PNODE) {
-        Debug::log(LOG, "Rejecting to group a floating window");
-        return;
-    }
-
-    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PNODE->workspaceID);
-
-    if (PWORKSPACE->m_bHasFullscreenWindow && !PNODE->isGroupMember()) {
-        Debug::log(ERR, "Cannot enable group on a fullscreen window");
-        return;
-    }
-
-    if (PNODE->isGroupMember()) {
-        // dissolve group
-        const auto        PHEAD = PNODE->getGroupHead();
-
-        SDwindleNodeData* current = PNODE->pNextGroupMember;
-
-        PNODE->pWindow->m_bIsFloating = PHEAD->pWindow->m_bIsFloating;
-
-        std::deque<CWindow*> toAddWindows;
-
-        const auto           PWINDOWNODE = PNODE->pWindow;
-        toAddWindows.push_back(PWINDOWNODE);
-
-        while (current != PNODE) {
-            const auto PWINDOW = current->pWindow;
-            current            = current->pNextGroupMember;
-
-            toAddWindows.push_back(PWINDOW);
-
-            PWINDOW->setHidden(false);
-        }
-
-        if (PHEAD->pPreviousGroupMember)
-            PHEAD->pPreviousGroupMember->pNextGroupMember = PHEAD->pNextGroupMember;
-
-        if (PHEAD->pNextGroupMember)
-            PHEAD->pNextGroupMember->pPreviousGroupMember = PHEAD->pPreviousGroupMember;
-
-        PHEAD->pPreviousGroupMember = nullptr;
-        PHEAD->pNextGroupMember     = nullptr;
-
-        onWindowRemoved(PHEAD->pWindow);
-
-        for (auto& pw : toAddWindows) {
-            const auto PNODE = getNodeFromWindow(pw);
-            if (PNODE)
-                m_lDwindleNodesData.remove(*PNODE);
-
-            pw->m_vPosition = Vector2D(-1000000, -1000000);
-        }
-
-        for (auto& pw : toAddWindows) {
-            onWindowCreated(pw);
-            pw->removeDecorationByType(DECORATION_GROUPBAR);
-        }
-
-        recalculateMonitor(PWORKSPACE->m_iMonitorID);
-    } else {
-        // create group
-
-        if (!PNODE->pParent) {
-            Debug::log(LOG, "Rejecting to group a solitary window");
-            return;
-        }
-
-        PNODE->groupHead = true;
-
-        std::deque<SDwindleNodeData*> newGroupMembers;
-        std::deque<SDwindleNodeData*> nodesToRemove;
-
-        newGroupMembers.emplace_back(PNODE);
-
-        addToDequeRecursive(&newGroupMembers, &nodesToRemove, PNODE->pParent->children[0] == PNODE ? PNODE->pParent->children[1] : PNODE->pParent->children[0]);
-
-        for (auto& n : newGroupMembers) {
-            if (n->isGroupMember()) {
-                Debug::log(LOG, "Rejecting to nest groups");
-                return;
-            }
-        }
-
-        for (auto& nd : nodesToRemove) {
-            m_lDwindleNodesData.remove(*nd);
-        }
-
-        PNODE->position = PNODE->pParent->position;
-        PNODE->size     = PNODE->pParent->size;
-
-        applyNodeDataToWindow(PNODE);
-
-        if (PNODE->pParent->pParent) {
-            if (PNODE->pParent->pParent->children[0] == PNODE->pParent) {
-                PNODE->pParent->pParent->children[0] = PNODE;
-            } else {
-                PNODE->pParent->pParent->children[1] = PNODE;
-            }
-        }
-
-        const auto PPARENT2 = PNODE->pParent->pParent;
-
-        m_lDwindleNodesData.remove(*PNODE->pParent);
-
-        PNODE->pParent = PPARENT2;
-
-        // now remove everyone but head from tree
-        // and set order
-        for (int i = 0; i < (int)newGroupMembers.size(); ++i) {
-            if (i != 0) {
-                newGroupMembers[i]->groupHead = false;
-                newGroupMembers[i]->pParent   = PNODE->pParent;
-            }
-
-            const auto PREVMEMBER = i == 0 ? newGroupMembers[newGroupMembers.size() - 1] : newGroupMembers[i - 1];
-            const auto NEXTMEMBER = i == (int)newGroupMembers.size() - 1 ? newGroupMembers[0] : newGroupMembers[i + 1];
-
-            newGroupMembers[i]->pPreviousGroupMember = PREVMEMBER;
-            newGroupMembers[i]->pNextGroupMember     = NEXTMEMBER;
-
-            // add the deco
-            newGroupMembers[i]->pWindow->m_dWindowDecorations.emplace_back(std::make_unique<CHyprGroupBarDecoration>(newGroupMembers[i]->pWindow));
-        }
-
-        // focus
-        PNODE->setGroupFocusedNode(PNODE);
-
-        // required for no_gaps_when_only to work
-        applyNodeDataToWindow(PNODE);
-    }
-
-    g_pCompositor->updateAllWindowsAnimatedDecorationValues();
-
-    g_pInputManager->refocus();
-}
-
-std::deque<CWindow*> CHyprDwindleLayout::getGroupMembers(CWindow* pWindow) {
-
-    std::deque<CWindow*> result;
-
-    if (!g_pCompositor->windowExists(pWindow))
-        return result; // reject with empty
-
-    // get the node
-    const auto PNODE = getNodeFromWindow(pWindow);
-
-    if (!PNODE || !PNODE->isGroupMember())
-        return result; // reject with empty
-
-    const auto        HEAD    = PNODE->getGroupHead();
-    SDwindleNodeData* current = HEAD->pNextGroupMember;
-
-    result.push_back(HEAD->pWindow);
-
-    while (current != HEAD) {
-        result.push_back(current->pWindow);
-        current = current->pNextGroupMember;
-    }
-
-    return result;
-}
-
-void CHyprDwindleLayout::switchGroupWindow(CWindow* pWindow, bool forward, CWindow* forceTo) {
-    if (!g_pCompositor->windowValidMapped(pWindow))
-        return; // reject
-
-    const auto PNODE = getNodeFromWindow(pWindow);
-
-    if (!PNODE || !PNODE->isGroupMember())
-        return; // reject
-
-    const auto        PWORKSPACE = g_pCompositor->getWorkspaceByID(PNODE->workspaceID);
-
-    SDwindleNodeData* pNewNode;
-
-    if (forward)
-        pNewNode = PNODE->pNextGroupMember;
-    else
-        pNewNode = PNODE->pPreviousGroupMember;
-
-    if (forceTo) {
-        const auto NODETO = getNodeFromWindow(forceTo);
-
-        if (NODETO)
-            pNewNode = NODETO;
-    }
-
-    PNODE->setGroupFocusedNode(pNewNode);
-
-    pNewNode->position    = PNODE->position;
-    pNewNode->size        = PNODE->size;
-    pNewNode->workspaceID = PNODE->workspaceID;
-
-    applyNodeDataToWindow(pNewNode);
-
-    pNewNode->pWindow->m_vRealSize.warp();
-    pNewNode->pWindow->m_vRealPosition.warp();
-
-    g_pCompositor->focusWindow(pNewNode->pWindow);
-
-    pNewNode->pWindow->m_bIsFloating = PNODE->pWindow->m_bIsFloating;
-
-    if (PNODE->pWindow->m_bIsFullscreen) {
-        PNODE->pWindow->setHidden(false);
-        g_pCompositor->setWindowFullscreen(PNODE->pWindow, false, PWORKSPACE->m_efFullscreenMode);
-        PNODE->pWindow->setHidden(true);
-        g_pCompositor->setWindowFullscreen(pNewNode->pWindow, true, PWORKSPACE->m_efFullscreenMode);
-
-        pNewNode->pWindow->m_vRealSize.warp();
-        pNewNode->pWindow->m_vRealPosition.warp();
-    }
-
-    pNewNode->pWindow->updateWindowDecos();
-    PNODE->pWindow->updateWindowDecos();
-
-    g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID));
-}
-
 SWindowRenderLayoutHints CHyprDwindleLayout::requestRenderHints(CWindow* pWindow) {
     // window should be valid, insallah
-
     SWindowRenderLayoutHints hints;
 
-    static auto* const       PGROUPCOLACTIVE   = &g_pConfigManager->getConfigValuePtr("dwindle:col.group_border_active")->data;
-    static auto* const       PGROUPCOLINACTIVE = &g_pConfigManager->getConfigValuePtr("dwindle:col.group_border")->data;
-
     const auto               PNODE = getNodeFromWindow(pWindow);
     if (!PNODE)
         return hints; // left for the future, maybe floating funkiness
 
-    if (PNODE->isGroupMember()) {
-        hints.isBorderGradient = true;
-
-        if (pWindow == g_pCompositor->m_pLastWindow)
-            hints.borderGradient = (CGradientValueData*)PGROUPCOLACTIVE->get();
-        else
-            hints.borderGradient = (CGradientValueData*)PGROUPCOLINACTIVE->get();
-    }
-
     return hints;
 }
 
@@ -1076,65 +710,9 @@ void CHyprDwindleLayout::switchWindows(CWindow* pWindow, CWindow* pWindow2) {
     SDwindleNodeData* ACTIVE1 = nullptr;
     SDwindleNodeData* ACTIVE2 = nullptr;
 
-    if (PNODE2->isGroupMember() || PNODE->isGroupMember()) {
-
-        if (PNODE->workspaceID != PNODE2->workspaceID) {
-            Debug::log(ERR, "Groups are confined to a monitor");
-            return;
-        }
-
-        if (PNODE->isGroupMember()) {
-            ACTIVE1 = PNODE;
-            PNODE   = PNODE->getGroupHead();
-        }
-
-        if (PNODE2->isGroupMember()) {
-            ACTIVE2 = PNODE2;
-            PNODE2  = PNODE2->getGroupHead();
-        }
-
-        if (PNODE2->pParent == PNODE->pParent) {
-            const auto PPARENT = PNODE->pParent;
-
-            if (PPARENT->children[0] == PNODE) {
-                PPARENT->children[0] = PNODE2;
-                PPARENT->children[1] = PNODE;
-            } else {
-                PPARENT->children[0] = PNODE;
-                PPARENT->children[1] = PNODE2;
-            }
-        } else {
-            if (PNODE->pParent) {
-                const auto PPARENT = PNODE->pParent;
-
-                if (PPARENT->children[0] == PNODE) {
-                    PPARENT->children[0] = PNODE2;
-                } else {
-                    PPARENT->children[1] = PNODE2;
-                }
-            }
-
-            if (PNODE2->pParent) {
-                const auto PPARENT = PNODE2->pParent;
-
-                if (PPARENT->children[0] == PNODE2) {
-                    PPARENT->children[0] = PNODE;
-                } else {
-                    PPARENT->children[1] = PNODE;
-                }
-            }
-        }
-
-        const auto PPARENTNODE2 = PNODE2->pParent;
-        PNODE2->pParent         = PNODE->pParent;
-        PNODE->pParent          = PPARENTNODE2;
-
-        std::swap(PNODE2->workspaceID, PNODE->workspaceID);
-    } else {
-        // swap the windows and recalc
-        PNODE2->pWindow = pWindow;
-        PNODE->pWindow  = pWindow2;
-    }
+    // swap the windows and recalc
+    PNODE2->pWindow = pWindow;
+    PNODE->pWindow  = pWindow2;
 
     if (PNODE->workspaceID != PNODE2->workspaceID) {
         std::swap(pWindow2->m_iMonitorID, pWindow->m_iMonitorID);
@@ -1171,7 +749,7 @@ void CHyprDwindleLayout::alterSplitRatio(CWindow* pWindow, float ratio, bool exa
 
     const auto PNODE = getNodeFromWindow(pWindow);
 
-    if (!PNODE || !PNODE->pParent || (PNODE->isGroupMember() && PNODE->getGroupMemberCount() == g_pCompositor->getWindowsOnWorkspace(PNODE->workspaceID)))
+    if (!PNODE || !PNODE->pParent)
         return;
 
     float newRatio             = exact ? ratio : PNODE->pParent->splitRatio + ratio;
@@ -1181,18 +759,8 @@ void CHyprDwindleLayout::alterSplitRatio(CWindow* pWindow, float ratio, bool exa
 }
 
 std::any CHyprDwindleLayout::layoutMessage(SLayoutMessageHeader header, std::string message) {
-    if (message == "togglegroup")
-        toggleWindowGroup(header.pWindow);
-    else if (message == "changegroupactivef")
-        switchGroupWindow(header.pWindow, true);
-    else if (message == "changegroupactiveb")
-        switchGroupWindow(header.pWindow, false);
-    else if (message == "togglesplit")
+    if (message == "togglesplit")
         toggleSplit(header.pWindow);
-    else if (message == "groupinfo") {
-        auto res = getGroupMembers(header.pWindow ? header.pWindow : g_pCompositor->m_pLastWindow);
-        return res;
-    }
 
     return "";
 }
@@ -1208,6 +776,17 @@ void CHyprDwindleLayout::toggleSplit(CWindow* pWindow) {
     PNODE->pParent->recalcSizePosRecursive();
 }
 
+void CHyprDwindleLayout::replaceWindowDataWith(CWindow* from, CWindow* to) {
+    const auto PNODE = getNodeFromWindow(from);
+
+    if (!PNODE)
+        return;
+
+    PNODE->pWindow = to;
+
+    applyNodeDataToWindow(PNODE, true);
+}
+
 std::string CHyprDwindleLayout::getLayoutName() {
     return "dwindle";
 }

src/layout/DwindleLayout.hpp

@@ -19,10 +19,6 @@ struct SDwindleNodeData {
 
     bool                             splitTop = false; // for preserve_split
 
-    bool                             groupHead            = false;
-    SDwindleNodeData*                pNextGroupMember     = nullptr;
-    SDwindleNodeData*                pPreviousGroupMember = nullptr;
-
     Vector2D                         position;
     Vector2D                         size;
 
@@ -33,18 +29,13 @@ struct SDwindleNodeData {
     bool                             valid = true;
 
     // For list lookup
-    bool operator==(const SDwindleNodeData& rhs) {
+    bool operator==(const SDwindleNodeData& rhs) const {
         return pWindow == rhs.pWindow && workspaceID == rhs.workspaceID && position == rhs.position && size == rhs.size && pParent == rhs.pParent &&
             children[0] == rhs.children[0] && children[1] == rhs.children[1];
     }
 
     void                recalcSizePosRecursive(bool force = false);
     void                getAllChildrenRecursive(std::deque<SDwindleNodeData*>*);
-    bool                isGroupMember();
-    SDwindleNodeData*   getGroupHead();
-    SDwindleNodeData*   getGroupVisible();
-    int                 getGroupMemberCount();
-    void                setGroupFocusedNode(SDwindleNodeData*);
     CHyprDwindleLayout* layout = nullptr;
 };
 
@@ -62,6 +53,7 @@ class CHyprDwindleLayout : public IHyprLayout {
     virtual void                     switchWindows(CWindow*, CWindow*);
     virtual void                     alterSplitRatio(CWindow*, float, bool);
     virtual std::string              getLayoutName();
+    virtual void                     replaceWindowDataWith(CWindow* from, CWindow* to);
 
     virtual void                     onEnable();
     virtual void                     onDisable();
@@ -75,10 +67,7 @@ class CHyprDwindleLayout : public IHyprLayout {
     SDwindleNodeData*           getFirstNodeOnWorkspace(const int&);
     SDwindleNodeData*           getMasterNodeOnWorkspace(const int&);
 
-    void                        toggleWindowGroup(CWindow*);
-    void                        switchGroupWindow(CWindow*, bool forward, CWindow* to = nullptr);
     void                        toggleSplit(CWindow*);
-    std::deque<CWindow*>        getGroupMembers(CWindow*);
 
     friend struct SDwindleNodeData;
 };

src/layout/IHyprLayout.cpp

@@ -24,6 +24,38 @@ void IHyprLayout::onWindowRemoved(CWindow* pWindow) {
     if (pWindow->m_bIsFullscreen)
         g_pCompositor->setWindowFullscreen(pWindow, false, FULLSCREEN_FULL);
 
+    if (pWindow->m_sGroupData.pNextWindow) {
+        if (pWindow->m_sGroupData.pNextWindow == pWindow)
+            pWindow->m_sGroupData.pNextWindow = nullptr;
+        else {
+            // find last window and update
+            CWindow*   curr           = pWindow;
+            const auto CURRWASVISIBLE = curr->getGroupCurrent() == curr;
+
+            while (curr->m_sGroupData.pNextWindow != pWindow)
+                curr = curr->m_sGroupData.pNextWindow;
+
+            if (CURRWASVISIBLE)
+                curr->setGroupCurrent(curr);
+
+            curr->m_sGroupData.pNextWindow = pWindow->m_sGroupData.pNextWindow;
+
+            pWindow->m_sGroupData.pNextWindow = nullptr;
+
+            if (pWindow->m_sGroupData.head) {
+                pWindow->m_sGroupData.head = false;
+                curr->m_sGroupData.head    = true;
+            }
+
+            if (pWindow == m_pLastTiledWindow)
+                m_pLastTiledWindow = nullptr;
+
+            pWindow->setHidden(false);
+
+            return;
+        }
+    }
+
     if (pWindow->m_bIsFloating) {
         onWindowRemovedFloating(pWindow);
     } else {
@@ -49,7 +81,7 @@ void IHyprLayout::onWindowCreatedFloating(CWindow* pWindow) {
     }
 
     if (desiredGeometry.width <= 5 || desiredGeometry.height <= 5) {
-        const auto PWINDOWSURFACE = g_pXWaylandManager->getWindowSurface(pWindow);
+        const auto PWINDOWSURFACE = pWindow->m_pWLSurface.wlr();
         pWindow->m_vRealSize      = Vector2D(PWINDOWSURFACE->current.width, PWINDOWSURFACE->current.height);
 
         if ((desiredGeometry.width <= 1 || desiredGeometry.height <= 1) && pWindow->m_bIsX11 &&
@@ -63,8 +95,17 @@ void IHyprLayout::onWindowCreatedFloating(CWindow* pWindow) {
             pWindow->m_vRealSize = PMONITOR->vecSize / 2.f;
         }
 
-        pWindow->m_vRealPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_vRealSize.goalv().x) / 2.f,
-                                            PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_vRealSize.goalv().y) / 2.f);
+        if (pWindow->m_bIsX11 && pWindow->m_uSurface.xwayland->override_redirect) {
+
+            if (pWindow->m_uSurface.xwayland->x != 0 && pWindow->m_uSurface.xwayland->y != 0)
+                pWindow->m_vRealPosition = Vector2D{pWindow->m_uSurface.xwayland->x, pWindow->m_uSurface.xwayland->y};
+            else
+                pWindow->m_vRealPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_vRealSize.goalv().x) / 2.f,
+                                                    PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_vRealSize.goalv().y) / 2.f);
+        } else {
+            pWindow->m_vRealPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_vRealSize.goalv().x) / 2.f,
+                                                PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_vRealSize.goalv().y) / 2.f);
+        }
     } else {
         // we respect the size.
         pWindow->m_vRealSize = Vector2D(desiredGeometry.width, desiredGeometry.height);
@@ -108,7 +149,7 @@ void IHyprLayout::onWindowCreatedFloating(CWindow* pWindow) {
         }
     }
 
-    if (pWindow->m_bX11DoesntWantBorders) {
+    if (pWindow->m_bX11DoesntWantBorders || (pWindow->m_bIsX11 && pWindow->m_uSurface.xwayland->override_redirect)) {
         pWindow->m_vRealPosition.setValue(pWindow->m_vRealPosition.goalv());
         pWindow->m_vRealSize.setValue(pWindow->m_vRealSize.goalv());
     }
@@ -128,11 +169,13 @@ void IHyprLayout::onBeginDragWindow() {
     // Window will be floating. Let's check if it's valid. It should be, but I don't like crashing.
     if (!g_pCompositor->windowValidMapped(DRAGGINGWINDOW)) {
         Debug::log(ERR, "Dragging attempted on an invalid window!");
+        g_pInputManager->currentlyDraggedWindow = nullptr;
         return;
     }
 
     if (DRAGGINGWINDOW->m_bIsFullscreen) {
         Debug::log(LOG, "Rejecting drag on a fullscreen window.");
+        g_pInputManager->currentlyDraggedWindow = nullptr;
         return;
     }
 
@@ -140,11 +183,10 @@ void IHyprLayout::onBeginDragWindow() {
 
     if (PWORKSPACE->m_bHasFullscreenWindow && (!DRAGGINGWINDOW->m_bCreatedOverFullscreen || !DRAGGINGWINDOW->m_bIsFloating)) {
         Debug::log(LOG, "Rejecting drag on a fullscreen workspace. (window under fullscreen)");
+        g_pInputManager->currentlyDraggedWindow = nullptr;
         return;
     }
 
-    g_pInputManager->setCursorImageUntilUnset("hand1");
-
     DRAGGINGWINDOW->m_bDraggingTiled = false;
 
     if (!DRAGGINGWINDOW->m_bIsFloating) {
@@ -164,19 +206,26 @@ void IHyprLayout::onBeginDragWindow() {
 
     // get the grab corner
     if (m_vBeginDragXY.x < m_vBeginDragPositionXY.x + m_vBeginDragSizeXY.x / 2.0) {
-        // left
-        if (m_vBeginDragXY.y < m_vBeginDragPositionXY.y + m_vBeginDragSizeXY.y / 2.0)
-            m_iGrabbedCorner = 0;
-        else
-            m_iGrabbedCorner = 4;
+        if (m_vBeginDragXY.y < m_vBeginDragPositionXY.y + m_vBeginDragSizeXY.y / 2.0) {
+            m_eGrabbedCorner = CORNER_TOPLEFT;
+            g_pInputManager->setCursorImageUntilUnset("nw-resize");
+        } else {
+            m_eGrabbedCorner = CORNER_BOTTOMLEFT;
+            g_pInputManager->setCursorImageUntilUnset("sw-resize");
+        }
     } else {
-        // right
-        if (m_vBeginDragXY.y < m_vBeginDragPositionXY.y + m_vBeginDragSizeXY.y / 2.0)
-            m_iGrabbedCorner = 1;
-        else
-            m_iGrabbedCorner = 3;
+        if (m_vBeginDragXY.y < m_vBeginDragPositionXY.y + m_vBeginDragSizeXY.y / 2.0) {
+            m_eGrabbedCorner = CORNER_TOPRIGHT;
+            g_pInputManager->setCursorImageUntilUnset("ne-resize");
+        } else {
+            m_eGrabbedCorner = CORNER_BOTTOMRIGHT;
+            g_pInputManager->setCursorImageUntilUnset("se-resize");
+        }
     }
 
+    if (g_pInputManager->dragMode != MBIND_RESIZE)
+        g_pInputManager->setCursorImageUntilUnset("grab");
+
     g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
 
     g_pKeybindManager->shadowKeybinds();
@@ -185,10 +234,15 @@ void IHyprLayout::onBeginDragWindow() {
 void IHyprLayout::onEndDragWindow() {
     const auto DRAGGINGWINDOW = g_pInputManager->currentlyDraggedWindow;
 
-    g_pInputManager->unsetCursorImage();
-
-    if (!g_pCompositor->windowValidMapped(DRAGGINGWINDOW))
+    if (!g_pCompositor->windowValidMapped(DRAGGINGWINDOW)) {
+        if (DRAGGINGWINDOW) {
+            g_pInputManager->unsetCursorImage();
+            g_pInputManager->currentlyDraggedWindow = nullptr;
+        }
         return;
+    }
+
+    g_pInputManager->unsetCursorImage();
 
     g_pInputManager->currentlyDraggedWindow = nullptr;
 
@@ -213,23 +267,30 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
         return;
     }
 
-    const auto SPECIAL = g_pCompositor->isWorkspaceSpecial(DRAGGINGWINDOW->m_iWorkspaceID);
+    static auto TIMER = std::chrono::high_resolution_clock::now();
 
-    const auto DELTA     = Vector2D(mousePos.x - m_vBeginDragXY.x, mousePos.y - m_vBeginDragXY.y);
-    const auto TICKDELTA = Vector2D(mousePos.x - m_vLastDragXY.x, mousePos.y - m_vLastDragXY.y);
+    const auto  SPECIAL = g_pCompositor->isWorkspaceSpecial(DRAGGINGWINDOW->m_iWorkspaceID);
 
-    const auto PANIMATE = &g_pConfigManager->getConfigValuePtr("misc:animate_manual_resizes")->intValue;
+    const auto  DELTA     = Vector2D(mousePos.x - m_vBeginDragXY.x, mousePos.y - m_vBeginDragXY.y);
+    const auto  TICKDELTA = Vector2D(mousePos.x - m_vLastDragXY.x, mousePos.y - m_vLastDragXY.y);
 
-    if (abs(TICKDELTA.x) < 1.f && abs(TICKDELTA.y) < 1.f)
+    const auto  PANIMATEMOUSE = &g_pConfigManager->getConfigValuePtr("misc:animate_mouse_windowdragging")->intValue;
+    const auto  PANIMATE      = &g_pConfigManager->getConfigValuePtr("misc:animate_manual_resizes")->intValue;
+
+    if ((abs(TICKDELTA.x) < 1.f && abs(TICKDELTA.y) < 1.f) ||
+        (std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - TIMER).count() <
+         1000.0 / g_pHyprRenderer->m_pMostHzMonitor->refreshRate))
         return;
 
+    TIMER = std::chrono::high_resolution_clock::now();
+
     m_vLastDragXY = mousePos;
 
     g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
 
     if (g_pInputManager->dragMode == MBIND_MOVE) {
 
-        if (*PANIMATE) {
+        if (*PANIMATEMOUSE) {
             DRAGGINGWINDOW->m_vRealPosition = m_vBeginDragPositionXY + DELTA;
         } else {
             DRAGGINGWINDOW->m_vRealPosition.setValueAndWarp(m_vBeginDragPositionXY + DELTA);
@@ -246,21 +307,19 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
             Vector2D newSize = m_vBeginDragSizeXY;
             Vector2D newPos  = m_vBeginDragPositionXY;
 
-            if (m_iGrabbedCorner == 3) {
-                newSize = newSize + DELTA;
-            } else if (m_iGrabbedCorner == 0) {
-                newSize = newSize - DELTA;
-                newPos  = newPos + DELTA;
-            } else if (m_iGrabbedCorner == 1) {
-                newSize = newSize + Vector2D(DELTA.x, -DELTA.y);
-                newPos  = newPos + Vector2D(0, DELTA.y);
-            } else if (m_iGrabbedCorner == 4) {
-                newSize = newSize + Vector2D(-DELTA.x, DELTA.y);
-                newPos  = newPos + Vector2D(DELTA.x, 0);
+            if (m_eGrabbedCorner == CORNER_BOTTOMRIGHT) {
+                newSize = (newSize + DELTA).clamp(Vector2D(20, 20), MAXSIZE);
+            } else if (m_eGrabbedCorner == CORNER_TOPLEFT) {
+                newSize = (newSize - DELTA).clamp(Vector2D(20, 20), MAXSIZE);
+                newPos  = newPos - newSize + m_vBeginDragSizeXY;
+            } else if (m_eGrabbedCorner == CORNER_TOPRIGHT) {
+                newSize = (newSize + Vector2D(DELTA.x, -DELTA.y)).clamp(Vector2D(20, 20), MAXSIZE);
+                newPos  = newPos + Vector2D(0, (m_vBeginDragSizeXY - newSize).y);
+            } else if (m_eGrabbedCorner == CORNER_BOTTOMLEFT) {
+                newSize = (newSize + Vector2D(-DELTA.x, DELTA.y)).clamp(Vector2D(20, 20), MAXSIZE);
+                newPos  = newPos + Vector2D((m_vBeginDragSizeXY - newSize).x, 0);
             }
 
-            newSize = newSize.clamp(Vector2D(20, 20), MAXSIZE);
-
             if (*PANIMATE) {
                 DRAGGINGWINDOW->m_vRealSize     = newSize;
                 DRAGGINGWINDOW->m_vRealPosition = newPos;
@@ -284,6 +343,7 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
     if (PMONITOR && !SPECIAL) {
         DRAGGINGWINDOW->m_iMonitorID = PMONITOR->ID;
         DRAGGINGWINDOW->moveToWorkspace(PMONITOR->activeWorkspace);
+        DRAGGINGWINDOW->updateGroupOutputs();
 
         DRAGGINGWINDOW->updateToplevel();
     }
@@ -309,11 +369,13 @@ void IHyprLayout::changeWindowFloatingMode(CWindow* pWindow) {
 
     // event
     g_pEventManager->postEvent(SHyprIPCEvent{"changefloatingmode", getFormat("%x,%d", pWindow, (int)TILED)});
+    EMIT_HOOK_EVENT("changeFloatingMode", pWindow);
 
     if (!TILED) {
         const auto PNEWMON    = g_pCompositor->getMonitorFromVector(pWindow->m_vRealPosition.vec() + pWindow->m_vRealSize.vec() / 2.f);
         pWindow->m_iMonitorID = PNEWMON->ID;
         pWindow->moveToWorkspace(PNEWMON->activeWorkspace);
+        pWindow->updateGroupOutputs();
 
         // save real pos cuz the func applies the default 5,5 mid
         const auto PSAVEDPOS  = pWindow->m_vRealPosition.goalv();
@@ -342,6 +404,11 @@ void IHyprLayout::changeWindowFloatingMode(CWindow* pWindow) {
 
         g_pCompositor->moveWindowToTop(pWindow);
 
+        if (DELTALESSTHAN(pWindow->m_vRealSize.vec().x, pWindow->m_vLastFloatingSize.x, 10) && DELTALESSTHAN(pWindow->m_vRealSize.vec().y, pWindow->m_vLastFloatingSize.y, 10)) {
+            pWindow->m_vRealPosition = pWindow->m_vRealPosition.goalv() + (pWindow->m_vRealSize.goalv() - pWindow->m_vLastFloatingSize) / 2.f + Vector2D{10, 10};
+            pWindow->m_vRealSize     = pWindow->m_vLastFloatingSize - Vector2D{20, 20};
+        }
+
         pWindow->m_vRealPosition = pWindow->m_vRealPosition.goalv() + (pWindow->m_vRealSize.goalv() - pWindow->m_vLastFloatingSize) / 2.f;
         pWindow->m_vRealSize     = pWindow->m_vLastFloatingSize;
 
@@ -351,6 +418,8 @@ void IHyprLayout::changeWindowFloatingMode(CWindow* pWindow) {
         g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID));
 
         pWindow->m_sSpecialRenderData.rounding = true;
+        pWindow->m_sSpecialRenderData.border   = true;
+        pWindow->m_sSpecialRenderData.decorate = true;
 
         if (pWindow == m_pLastTiledWindow)
             m_pLastTiledWindow = nullptr;

src/layout/IHyprLayout.hpp

@@ -15,6 +15,14 @@ struct SLayoutMessageHeader {
 
 enum eFullscreenMode : uint8_t;
 
+enum eRectCorner
+{
+    CORNER_TOPLEFT = 0,
+    CORNER_TOPRIGHT,
+    CORNER_BOTTOMRIGHT,
+    CORNER_BOTTOMLEFT
+};
+
 interface IHyprLayout {
   public:
     virtual ~IHyprLayout()   = 0;
@@ -135,12 +143,17 @@ interface IHyprLayout {
     */
     virtual void onWindowFocusChange(CWindow*);
 
-  private:
-    Vector2D m_vBeginDragXY;
-    Vector2D m_vLastDragXY;
-    Vector2D m_vBeginDragPositionXY;
-    Vector2D m_vBeginDragSizeXY;
-    int      m_iGrabbedCorner = 0;
+    /*
+        Called for replacing any data a layout has for a new window
+    */
+    virtual void replaceWindowDataWith(CWindow * from, CWindow * to) = 0;
 
-    CWindow* m_pLastTiledWindow = nullptr;
+  private:
+    Vector2D    m_vBeginDragXY;
+    Vector2D    m_vLastDragXY;
+    Vector2D    m_vBeginDragPositionXY;
+    Vector2D    m_vBeginDragSizeXY;
+    eRectCorner m_eGrabbedCorner = CORNER_TOPLEFT;
+
+    CWindow*    m_pLastTiledWindow = nullptr;
 };

src/layout/MasterLayout.cpp

@@ -1,5 +1,6 @@
 #include "MasterLayout.hpp"
 #include "../Compositor.hpp"
+#include <ranges>
 
 SMasterNodeData* CHyprMasterLayout::getNodeFromWindow(CWindow* pWindow) {
     for (auto& nd : m_lMasterNodesData) {
@@ -46,8 +47,10 @@ SMasterWorkspaceData* CHyprMasterLayout::getMasterWorkspaceData(const int& ws) {
         PWORKSPACEDATA->orientation = ORIENTATION_RIGHT;
     } else if (*orientation == "bottom") {
         PWORKSPACEDATA->orientation = ORIENTATION_BOTTOM;
-    } else {
+    } else if (*orientation == "left") {
         PWORKSPACEDATA->orientation = ORIENTATION_LEFT;
+    } else {
+        PWORKSPACEDATA->orientation = ORIENTATION_CENTER;
     }
     return PWORKSPACEDATA;
 }
@@ -81,7 +84,22 @@ void CHyprMasterLayout::onWindowCreatedTiling(CWindow* pWindow) {
     static auto* const PNEWISMASTER = &g_pConfigManager->getConfigValuePtr("master:new_is_master")->intValue;
 
     const auto         WINDOWSONWORKSPACE = getNodesOnWorkspace(PNODE->workspaceID);
-    float              lastSplitPercent   = 0.5f;
+    static auto* const PMFACT             = &g_pConfigManager->getConfigValuePtr("master:mfact")->floatValue;
+    float              lastSplitPercent   = *PMFACT;
+
+    auto               OPENINGON = isWindowTiled(g_pCompositor->m_pLastWindow) && g_pCompositor->m_pLastWindow->m_iWorkspaceID == pWindow->m_iWorkspaceID ?
+                      getNodeFromWindow(g_pCompositor->m_pLastWindow) :
+                      getMasterNodeOnWorkspace(pWindow->m_iWorkspaceID);
+
+    if (OPENINGON && OPENINGON->pWindow->m_sGroupData.pNextWindow && OPENINGON != PNODE && !g_pKeybindManager->m_bGroupsLocked) {
+        m_lMasterNodesData.remove(*PNODE);
+
+        OPENINGON->pWindow->insertWindowToGroup(pWindow);
+
+        pWindow->m_dWindowDecorations.emplace_back(std::make_unique<CHyprGroupBarDecoration>(pWindow));
+
+        return;
+    }
 
     if (*PNEWISMASTER || WINDOWSONWORKSPACE == 1) {
         for (auto& nd : m_lMasterNodesData) {
@@ -104,7 +122,8 @@ void CHyprMasterLayout::onWindowCreatedTiling(CWindow* pWindow) {
             return;
         }
     } else {
-        PNODE->isMaster = false;
+        PNODE->isMaster   = false;
+        PNODE->percMaster = lastSplitPercent;
 
         // first, check if it isn't too big.
         if (const auto MAXSIZE = g_pXWaylandManager->getMaxSizeForWindow(pWindow);
@@ -159,9 +178,9 @@ void CHyprMasterLayout::onWindowRemovedTiling(CWindow* pWindow) {
     m_lMasterNodesData.remove(*PNODE);
 
     if (getMastersOnWorkspace(WORKSPACEID) == getNodesOnWorkspace(WORKSPACEID) && MASTERSLEFT > 1) {
-        for (auto it = m_lMasterNodesData.rbegin(); it != m_lMasterNodesData.rend(); it++) {
-            if (it->workspaceID == WORKSPACEID) {
-                it->isMaster = false;
+        for (auto& nd : m_lMasterNodesData | std::views::reverse) {
+            if (nd.workspaceID == WORKSPACEID) {
+                nd.isMaster = false;
                 break;
             }
         }
@@ -184,21 +203,23 @@ void CHyprMasterLayout::recalculateMonitor(const int& monid) {
     }
 
     if (PWORKSPACE->m_bHasFullscreenWindow) {
-        if (PWORKSPACE->m_efFullscreenMode == FULLSCREEN_FULL)
-            return;
-
         // massive hack from the fullscreen func
-        const auto      PFULLWINDOW = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
+        const auto PFULLWINDOW = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
 
-        SMasterNodeData fakeNode;
-        fakeNode.pWindow         = PFULLWINDOW;
-        fakeNode.position        = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
-        fakeNode.size            = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight;
-        fakeNode.workspaceID     = PWORKSPACE->m_iID;
-        PFULLWINDOW->m_vPosition = fakeNode.position;
-        PFULLWINDOW->m_vSize     = fakeNode.size;
+        if (PWORKSPACE->m_efFullscreenMode == FULLSCREEN_FULL) {
+            PFULLWINDOW->m_vRealPosition = PMONITOR->vecPosition;
+            PFULLWINDOW->m_vRealSize     = PMONITOR->vecSize;
+        } else if (PWORKSPACE->m_efFullscreenMode == FULLSCREEN_MAXIMIZED) {
+            SMasterNodeData fakeNode;
+            fakeNode.pWindow         = PFULLWINDOW;
+            fakeNode.position        = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
+            fakeNode.size            = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight;
+            fakeNode.workspaceID     = PWORKSPACE->m_iID;
+            PFULLWINDOW->m_vPosition = fakeNode.position;
+            PFULLWINDOW->m_vSize     = fakeNode.size;
 
-        applyNodeDataToWindow(&fakeNode);
+            applyNodeDataToWindow(&fakeNode);
+        }
 
         return;
     }
@@ -222,16 +243,27 @@ void CHyprMasterLayout::calculateWorkspace(const int& ws) {
     if (!PMASTERNODE)
         return;
 
+    eOrientation       orientation        = PWORKSPACEDATA->orientation;
+    bool               centerMasterWindow = false;
+    static auto* const ALWAYSCENTER       = &g_pConfigManager->getConfigValuePtr("master:always_center_master")->intValue;
+    if (orientation == ORIENTATION_CENTER) {
+        if (getNodesOnWorkspace(PWORKSPACE->m_iID) > 2 || (*ALWAYSCENTER == 1)) {
+            centerMasterWindow = true;
+        } else {
+            orientation = ORIENTATION_LEFT;
+        }
+    }
+
     const auto MASTERS = getMastersOnWorkspace(PWORKSPACE->m_iID);
 
     //compute placement of master window(s)
-    if (getNodesOnWorkspace(PWORKSPACE->m_iID) < 2) {
+    if (getNodesOnWorkspace(PWORKSPACE->m_iID) < 2 && !centerMasterWindow) {
         PMASTERNODE->position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition;
         PMASTERNODE->size     = Vector2D(PMONITOR->vecSize.x - PMONITOR->vecReservedTopLeft.x - PMONITOR->vecReservedBottomRight.x,
                                          PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y);
         applyNodeDataToWindow(PMASTERNODE);
         return;
-    } else if (PWORKSPACEDATA->orientation == ORIENTATION_LEFT || PWORKSPACEDATA->orientation == ORIENTATION_RIGHT) {
+    } else if (orientation == ORIENTATION_LEFT || orientation == ORIENTATION_RIGHT) {
         float       heightLeft = PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y;
         int         nodesLeft  = MASTERS;
         float       nextY      = 0;
@@ -239,7 +271,7 @@ void CHyprMasterLayout::calculateWorkspace(const int& ws) {
 
         for (auto& n : m_lMasterNodesData) {
             if (n.workspaceID == PWORKSPACE->m_iID && n.isMaster) {
-                if (PWORKSPACEDATA->orientation == ORIENTATION_RIGHT) {
+                if (orientation == ORIENTATION_RIGHT) {
                     n.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition +
                         Vector2D(PMONITOR->vecSize.x - WIDTH - PMONITOR->vecReservedBottomRight.x - PMONITOR->vecReservedTopLeft.x, nextY);
                 } else {
@@ -257,7 +289,7 @@ void CHyprMasterLayout::calculateWorkspace(const int& ws) {
                 applyNodeDataToWindow(&n);
             }
         }
-    } else if (PWORKSPACEDATA->orientation == ORIENTATION_TOP || PWORKSPACEDATA->orientation == ORIENTATION_BOTTOM) {
+    } else if (orientation == ORIENTATION_TOP || orientation == ORIENTATION_BOTTOM) {
         float       widthLeft = PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PMONITOR->vecReservedTopLeft.x;
         int         nodesLeft = MASTERS;
         float       nextX     = 0;
@@ -265,7 +297,7 @@ void CHyprMasterLayout::calculateWorkspace(const int& ws) {
 
         for (auto& n : m_lMasterNodesData) {
             if (n.workspaceID == PWORKSPACE->m_iID && n.isMaster) {
-                if (PWORKSPACEDATA->orientation == ORIENTATION_BOTTOM) {
+                if (orientation == ORIENTATION_BOTTOM) {
                     n.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition +
                         Vector2D(nextX, PMONITOR->vecSize.y - HEIGHT - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y);
                 } else {
@@ -280,6 +312,28 @@ void CHyprMasterLayout::calculateWorkspace(const int& ws) {
                 widthLeft -= WIDTH;
                 nextX += WIDTH;
 
+                applyNodeDataToWindow(&n);
+            }
+        }
+    } else if (orientation == ORIENTATION_CENTER) {
+        float       heightLeft = PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y;
+        int         nodesLeft  = MASTERS;
+        float       nextY      = 0;
+        const float WIDTH      = (PMONITOR->vecSize.x - PMONITOR->vecReservedTopLeft.x - PMONITOR->vecReservedBottomRight.x) * PMASTERNODE->percMaster;
+
+        for (auto& n : m_lMasterNodesData) {
+            if (n.workspaceID == PWORKSPACE->m_iID && n.isMaster) {
+                float CENTER_OFFSET = (PMONITOR->vecSize.x - WIDTH) / 2;
+                n.position          = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition + Vector2D(CENTER_OFFSET, nextY);
+                float HEIGHT        = nodesLeft > 1 ? heightLeft / nodesLeft * n.percSize : heightLeft;
+                if (HEIGHT > heightLeft * 0.9f && nodesLeft > 1)
+                    HEIGHT = heightLeft * 0.9f;
+                n.size = Vector2D(WIDTH, HEIGHT);
+
+                nodesLeft--;
+                heightLeft -= HEIGHT;
+                nextY += HEIGHT;
+
                 applyNodeDataToWindow(&n);
             }
         }
@@ -287,7 +341,7 @@ void CHyprMasterLayout::calculateWorkspace(const int& ws) {
 
     //compute placement of slave window(s)
     int slavesLeft = getNodesOnWorkspace(PWORKSPACE->m_iID) - MASTERS;
-    if (PWORKSPACEDATA->orientation == ORIENTATION_LEFT || PWORKSPACEDATA->orientation == ORIENTATION_RIGHT) {
+    if (orientation == ORIENTATION_LEFT || orientation == ORIENTATION_RIGHT) {
         float       heightLeft = PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y;
         float       nextY      = 0;
         const float WIDTH      = PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PMONITOR->vecReservedTopLeft.x - PMASTERNODE->size.x;
@@ -296,7 +350,7 @@ void CHyprMasterLayout::calculateWorkspace(const int& ws) {
             if (nd.workspaceID != PWORKSPACE->m_iID || nd.isMaster)
                 continue;
 
-            if (PWORKSPACEDATA->orientation == ORIENTATION_LEFT) {
+            if (orientation == ORIENTATION_LEFT) {
                 nd.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition +
                     Vector2D(PMASTERNODE->percMaster * (PMONITOR->vecSize.x - PMONITOR->vecReservedTopLeft.x - PMONITOR->vecReservedBottomRight.x), nextY);
             } else {
@@ -313,7 +367,7 @@ void CHyprMasterLayout::calculateWorkspace(const int& ws) {
 
             applyNodeDataToWindow(&nd);
         }
-    } else if (PWORKSPACEDATA->orientation == ORIENTATION_TOP || PWORKSPACEDATA->orientation == ORIENTATION_BOTTOM) {
+    } else if (orientation == ORIENTATION_TOP || orientation == ORIENTATION_BOTTOM) {
         float       widthLeft = PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PMONITOR->vecReservedTopLeft.x;
         float       nextX     = 0;
         const float HEIGHT    = PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y - PMASTERNODE->size.y;
@@ -321,7 +375,7 @@ void CHyprMasterLayout::calculateWorkspace(const int& ws) {
         for (auto& nd : m_lMasterNodesData) {
             if (nd.workspaceID != PWORKSPACE->m_iID || nd.isMaster)
                 continue;
-            if (PWORKSPACEDATA->orientation == ORIENTATION_TOP) {
+            if (orientation == ORIENTATION_TOP) {
                 nd.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition +
                     Vector2D(nextX, PMASTERNODE->percMaster * (PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y));
             } else {
@@ -338,6 +392,49 @@ void CHyprMasterLayout::calculateWorkspace(const int& ws) {
 
             applyNodeDataToWindow(&nd);
         }
+    } else if (orientation == ORIENTATION_CENTER) {
+        float       heightLeftL = PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y;
+        float       heightLeftR = heightLeftL;
+        float       heightLeft  = 0;
+        float       nextYL      = 0;
+        float       nextYR      = 0;
+        const float WIDTH       = (PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PMONITOR->vecReservedTopLeft.x - PMASTERNODE->size.x) / 2.0;
+        bool        on_left     = true;
+
+        int         slavesLeftL = 1 + (slavesLeft - 1) / 2;
+        int         slavesLeftR = slavesLeft - slavesLeftL;
+
+        for (auto& nd : m_lMasterNodesData) {
+            if (nd.workspaceID != PWORKSPACE->m_iID || nd.isMaster)
+                continue;
+
+            if (on_left) {
+                nd.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition + Vector2D(0, nextYL);
+                heightLeft  = heightLeftL;
+                slavesLeft  = slavesLeftL;
+            } else {
+                nd.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition + Vector2D(WIDTH + PMASTERNODE->size.x, nextYR);
+                heightLeft  = heightLeftR;
+                slavesLeft  = slavesLeftR;
+            }
+            float HEIGHT = slavesLeft > 1 ? heightLeft / slavesLeft * nd.percSize : heightLeft;
+            if (HEIGHT > heightLeft * 0.9f && slavesLeft > 1)
+                HEIGHT = heightLeft * 0.9f;
+            nd.size = Vector2D(WIDTH, HEIGHT);
+
+            if (on_left) {
+                heightLeftL -= HEIGHT;
+                nextYL += HEIGHT;
+                slavesLeftL--;
+            } else {
+                heightLeftR -= HEIGHT;
+                nextYR += HEIGHT;
+                slavesLeftR--;
+            }
+
+            applyNodeDataToWindow(&nd);
+            on_left = !on_left;
+        }
     }
 }
 
@@ -411,6 +508,10 @@ void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) {
     calcPos  = calcPos + OFFSETTOPLEFT;
     calcSize = calcSize - OFFSETTOPLEFT - OFFSETBOTTOMRIGHT;
 
+    const auto RESERVED = PWINDOW->getFullWindowReservedArea();
+    calcPos             = calcPos + RESERVED.topLeft;
+    calcSize            = calcSize - (RESERVED.topLeft + RESERVED.bottomRight);
+
     if (g_pCompositor->isWorkspaceSpecial(PWINDOW->m_iWorkspaceID)) {
         static auto* const PSCALEFACTOR = &g_pConfigManager->getConfigValuePtr("master:special_scale_factor")->floatValue;
 
@@ -472,6 +573,7 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, CWindow* p
         case ORIENTATION_RIGHT: delta = -pixResize.x / PMONITOR->vecSize.x; break;
         case ORIENTATION_BOTTOM: delta = -pixResize.y / PMONITOR->vecSize.y; break;
         case ORIENTATION_TOP: delta = pixResize.y / PMONITOR->vecSize.y; break;
+        case ORIENTATION_CENTER: delta = pixResize.x / PMONITOR->vecSize.x; break;
         default: UNREACHABLE();
     }
 
@@ -524,6 +626,7 @@ void CHyprMasterLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscreen
     PWORKSPACE->m_bHasFullscreenWindow = !PWORKSPACE->m_bHasFullscreenWindow;
 
     g_pEventManager->postEvent(SHyprIPCEvent{"fullscreen", std::to_string((int)on)});
+    EMIT_HOOK_EVENT("fullscreen", pWindow);
 
     if (!pWindow->m_bIsFullscreen) {
         // if it got its fullscreen disabled, set back its node if it had one
@@ -532,8 +635,12 @@ void CHyprMasterLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscreen
             applyNodeDataToWindow(PNODE);
         else {
             // get back its' dimensions from position and size
-            pWindow->m_vRealPosition = pWindow->m_vPosition;
-            pWindow->m_vRealSize     = pWindow->m_vSize;
+            pWindow->m_vRealPosition = pWindow->m_vLastFloatingPosition;
+            pWindow->m_vRealSize     = pWindow->m_vLastFloatingSize;
+
+            pWindow->m_sSpecialRenderData.rounding = true;
+            pWindow->m_sSpecialRenderData.border   = true;
+            pWindow->m_sSpecialRenderData.decorate = true;
         }
     } else {
         // if it now got fullscreen, make it fullscreen
@@ -542,8 +649,10 @@ void CHyprMasterLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscreen
 
         // save position and size if floating
         if (pWindow->m_bIsFloating) {
-            pWindow->m_vPosition = pWindow->m_vRealPosition.vec();
-            pWindow->m_vSize     = pWindow->m_vRealSize.vec();
+            pWindow->m_vLastFloatingSize     = pWindow->m_vRealSize.goalv();
+            pWindow->m_vLastFloatingPosition = pWindow->m_vRealPosition.goalv();
+            pWindow->m_vPosition             = pWindow->m_vRealPosition.goalv();
+            pWindow->m_vSize                 = pWindow->m_vRealSize.goalv();
         }
 
         // apply new pos and size being monitors' box
@@ -645,67 +754,20 @@ CWindow* CHyprMasterLayout::getNextWindow(CWindow* pWindow, bool next) {
 
     const auto PNODE = getNodeFromWindow(pWindow);
 
-    if (next) {
-        if (PNODE->isMaster) {
-            // focus the first non master
-            for (auto n : m_lMasterNodesData) {
-                if (n.pWindow != pWindow && n.workspaceID == pWindow->m_iWorkspaceID) {
-                    return n.pWindow;
-                }
-            }
-        } else {
-            // focus next
-            bool reached = false;
-            bool found   = false;
-            for (auto n : m_lMasterNodesData) {
-                if (n.pWindow == pWindow) {
-                    reached = true;
-                    continue;
-                }
+    auto       nodes = m_lMasterNodesData;
+    if (!next)
+        std::reverse(nodes.begin(), nodes.end());
 
-                if (n.workspaceID == pWindow->m_iWorkspaceID && reached) {
-                    return n.pWindow;
-                }
-            }
-            if (!found) {
-                const auto PMASTER = getMasterNodeOnWorkspace(pWindow->m_iWorkspaceID);
+    const auto NODEIT = std::find(nodes.begin(), nodes.end(), *PNODE);
 
-                if (PMASTER)
-                    return PMASTER->pWindow;
-            }
-        }
-    } else {
-        if (PNODE->isMaster) {
-            // focus the last non master
-            for (auto it = m_lMasterNodesData.rbegin(); it != m_lMasterNodesData.rend(); it++) {
-                if (it->pWindow != pWindow && it->workspaceID == pWindow->m_iWorkspaceID) {
-                    return it->pWindow;
-                }
-            }
-        } else {
-            // focus previous
-            bool reached = false;
-            bool found   = false;
-            for (auto it = m_lMasterNodesData.rbegin(); it != m_lMasterNodesData.rend(); it++) {
-                if (it->pWindow == pWindow) {
-                    reached = true;
-                    continue;
-                }
+    const bool ISMASTER = PNODE->isMaster;
 
-                if (it->workspaceID == pWindow->m_iWorkspaceID && reached) {
-                    return it->pWindow;
-                }
-            }
-            if (!found) {
-                const auto PMASTER = getMasterNodeOnWorkspace(pWindow->m_iWorkspaceID);
+    auto CANDIDATE = std::find_if(NODEIT, nodes.end(), [&](const auto& other) { return other != *PNODE && ISMASTER == other.isMaster && other.workspaceID == PNODE->workspaceID; });
+    if (CANDIDATE == nodes.end())
+        CANDIDATE =
+            std::find_if(nodes.begin(), nodes.end(), [&](const auto& other) { return other != *PNODE && ISMASTER != other.isMaster && other.workspaceID == PNODE->workspaceID; });
 
-                if (PMASTER)
-                    return PMASTER->pWindow;
-            }
-        }
-    }
-
-    return nullptr;
+    return CANDIDATE == nodes.end() ? nullptr : CANDIDATE->pWindow;
 }
 
 bool CHyprMasterLayout::prepareLoseFocus(CWindow* pWindow) {
@@ -727,7 +789,7 @@ void CHyprMasterLayout::prepareNewFocus(CWindow* pWindow, bool inheritFullscreen
         return;
 
     if (inheritFullscreen)
-        g_pCompositor->setWindowFullscreen(pWindow, true, FULLSCREEN_MAXIMIZED);
+        g_pCompositor->setWindowFullscreen(pWindow, true, g_pCompositor->getWorkspaceByID(pWindow->m_iWorkspaceID)->m_efFullscreenMode);
 }
 
 std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::string message) {
@@ -739,7 +801,21 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
         g_pCompositor->warpCursorTo(PWINDOWTOCHANGETO->m_vRealPosition.goalv() + PWINDOWTOCHANGETO->m_vRealSize.goalv() / 2.f);
     };
 
-    if (message == "swapwithmaster") {
+    CVarList vars(message, 0, ' ');
+
+    if (vars.size() < 1 || vars[0].empty()) {
+        Debug::log(ERR, "layoutmsg called without params");
+        return 0;
+    }
+
+    auto command = vars[0];
+
+    // swapwithmaster <master | child | auto>
+    // first message argument can have the following values:
+    // * master - keep the focus at the new master
+    // * child - keep the focus at the new child
+    // * auto (default) - swap the focus (keep the focus of the previously selected window)
+    if (command == "swapwithmaster") {
         const auto PWINDOW = header.pWindow;
 
         if (!PWINDOW)
@@ -753,21 +829,38 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
         if (!PMASTER)
             return 0;
 
+        const auto NEWCHILD = PMASTER->pWindow;
+
         if (PMASTER->pWindow != PWINDOW) {
-            switchWindows(PWINDOW, PMASTER->pWindow);
-            switchToWindow(PWINDOW);
+            const auto NEWMASTER         = PWINDOW;
+            const bool newFocusToChild   = vars.size() >= 2 && vars[1] == "child";
+            const bool inheritFullscreen = prepareLoseFocus(NEWMASTER);
+            switchWindows(NEWMASTER, NEWCHILD);
+            const auto NEWFOCUS = newFocusToChild ? NEWCHILD : NEWMASTER;
+            switchToWindow(NEWFOCUS);
+            prepareNewFocus(NEWFOCUS, inheritFullscreen);
         } else {
             for (auto& n : m_lMasterNodesData) {
                 if (n.workspaceID == PMASTER->workspaceID && !n.isMaster) {
-                    switchWindows(n.pWindow, PMASTER->pWindow);
-                    switchToWindow(n.pWindow);
+                    const auto NEWMASTER         = n.pWindow;
+                    const bool inheritFullscreen = prepareLoseFocus(NEWCHILD);
+                    switchWindows(NEWMASTER, NEWCHILD);
+                    const bool newFocusToMaster = vars.size() >= 2 && vars[1] == "master";
+                    const auto NEWFOCUS         = newFocusToMaster ? NEWMASTER : NEWCHILD;
+                    switchToWindow(NEWFOCUS);
+                    prepareNewFocus(NEWFOCUS, inheritFullscreen);
                     break;
                 }
             }
         }
 
         return 0;
-    } else if (message == "focusmaster") {
+    }
+    // focusmaster <master | auto>
+    // first message argument can have the following values:
+    // * master - keep the focus at the new master, even if it was focused before
+    // * auto (default) - swap the focus with the first child, if the current focus was master, otherwise focus master
+    else if (command == "focusmaster") {
         const auto PWINDOW = header.pWindow;
 
         if (!PWINDOW)
@@ -783,7 +876,10 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
         if (PMASTER->pWindow != PWINDOW) {
             switchToWindow(PMASTER->pWindow);
             prepareNewFocus(PMASTER->pWindow, inheritFullscreen);
+        } else if (vars.size() >= 2 && vars[1] == "master") {
+            return 0;
         } else {
+            // if master is focused keep master focused (don't do anything)
             for (auto& n : m_lMasterNodesData) {
                 if (n.workspaceID == PMASTER->workspaceID && !n.isMaster) {
                     switchToWindow(n.pWindow);
@@ -794,7 +890,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
         }
 
         return 0;
-    } else if (message == "cyclenext") {
+    } else if (command == "cyclenext") {
         const auto PWINDOW = header.pWindow;
 
         if (!PWINDOW)
@@ -805,7 +901,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
         const auto PNEXTWINDOW = getNextWindow(PWINDOW, true);
         switchToWindow(PNEXTWINDOW);
         prepareNewFocus(PNEXTWINDOW, inheritFullscreen);
-    } else if (message == "cycleprev") {
+    } else if (command == "cycleprev") {
         const auto PWINDOW = header.pWindow;
 
         if (!PWINDOW)
@@ -816,7 +912,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
         const auto PPREVWINDOW = getNextWindow(PWINDOW, false);
         switchToWindow(PPREVWINDOW);
         prepareNewFocus(PPREVWINDOW, inheritFullscreen);
-    } else if (message == "swapnext") {
+    } else if (command == "swapnext") {
         if (!g_pCompositor->windowValidMapped(header.pWindow))
             return 0;
 
@@ -832,7 +928,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
             switchWindows(header.pWindow, PWINDOWTOSWAPWITH);
             g_pCompositor->focusWindow(header.pWindow);
         }
-    } else if (message == "swapprev") {
+    } else if (command == "swapprev") {
         if (!g_pCompositor->windowValidMapped(header.pWindow))
             return 0;
 
@@ -848,7 +944,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
             switchWindows(header.pWindow, PWINDOWTOSWAPWITH);
             g_pCompositor->focusWindow(header.pWindow);
         }
-    } else if (message == "addmaster") {
+    } else if (command == "addmaster") {
         if (!g_pCompositor->windowValidMapped(header.pWindow))
             return 0;
 
@@ -879,7 +975,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
 
         recalculateMonitor(header.pWindow->m_iMonitorID);
 
-    } else if (message == "removemaster") {
+    } else if (command == "removemaster") {
 
         if (!g_pCompositor->windowValidMapped(header.pWindow))
             return 0;
@@ -899,9 +995,9 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
 
         if (!PNODE || !PNODE->isMaster) {
             // first non-master node
-            for (auto it = m_lMasterNodesData.rbegin(); it != m_lMasterNodesData.rend(); it++) {
-                if (it->workspaceID == header.pWindow->m_iWorkspaceID && it->isMaster) {
-                    it->isMaster = false;
+            for (auto& nd : m_lMasterNodesData | std::views::reverse) {
+                if (nd.workspaceID == header.pWindow->m_iWorkspaceID && nd.isMaster) {
+                    nd.isMaster = false;
                     break;
                 }
             }
@@ -910,7 +1006,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
         }
 
         recalculateMonitor(header.pWindow->m_iMonitorID);
-    } else if (message == "orientationleft" || message == "orientationright" || message == "orientationtop" || message == "orientationbottom") {
+    } else if (command == "orientationleft" || command == "orientationright" || command == "orientationtop" || command == "orientationbottom" || command == "orientationcenter") {
         const auto PWINDOW = header.pWindow;
 
         if (!PWINDOW)
@@ -920,18 +1016,20 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
 
         const auto PWORKSPACEDATA = getMasterWorkspaceData(PWINDOW->m_iWorkspaceID);
 
-        if (message == "orientationleft")
+        if (command == "orientationleft")
             PWORKSPACEDATA->orientation = ORIENTATION_LEFT;
-        else if (message == "orientationright")
+        else if (command == "orientationright")
             PWORKSPACEDATA->orientation = ORIENTATION_RIGHT;
-        else if (message == "orientationtop")
+        else if (command == "orientationtop")
             PWORKSPACEDATA->orientation = ORIENTATION_TOP;
-        else if (message == "orientationbottom")
+        else if (command == "orientationbottom")
             PWORKSPACEDATA->orientation = ORIENTATION_BOTTOM;
+        else if (command == "orientationcenter")
+            PWORKSPACEDATA->orientation = ORIENTATION_CENTER;
 
         recalculateMonitor(header.pWindow->m_iMonitorID);
 
-    } else if (message == "orientationnext") {
+    } else if (command == "orientationnext") {
         const auto PWINDOW = header.pWindow;
 
         if (!PWINDOW)
@@ -941,14 +1039,14 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
 
         const auto PWORKSPACEDATA = getMasterWorkspaceData(PWINDOW->m_iWorkspaceID);
 
-        if (PWORKSPACEDATA->orientation == ORIENTATION_BOTTOM) {
+        if (PWORKSPACEDATA->orientation == ORIENTATION_CENTER) {
             PWORKSPACEDATA->orientation = ORIENTATION_LEFT;
         } else {
             PWORKSPACEDATA->orientation = (eOrientation)(PWORKSPACEDATA->orientation + 1);
         }
 
         recalculateMonitor(header.pWindow->m_iMonitorID);
-    } else if (message == "orientationprev") {
+    } else if (command == "orientationprev") {
         const auto PWINDOW = header.pWindow;
 
         if (!PWINDOW)
@@ -959,7 +1057,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
         const auto PWORKSPACEDATA = getMasterWorkspaceData(PWINDOW->m_iWorkspaceID);
 
         if (PWORKSPACEDATA->orientation == ORIENTATION_LEFT) {
-            PWORKSPACEDATA->orientation = ORIENTATION_BOTTOM;
+            PWORKSPACEDATA->orientation = ORIENTATION_CENTER;
         } else {
             PWORKSPACEDATA->orientation = (eOrientation)(PWORKSPACEDATA->orientation - 1);
         }
@@ -970,6 +1068,17 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
     return 0;
 }
 
+void CHyprMasterLayout::replaceWindowDataWith(CWindow* from, CWindow* to) {
+    const auto PNODE = getNodeFromWindow(from);
+
+    if (!PNODE)
+        return;
+
+    PNODE->pWindow = to;
+
+    applyNodeDataToWindow(PNODE);
+}
+
 void CHyprMasterLayout::onEnable() {
     for (auto& w : g_pCompositor->m_vWindows) {
         if (w->m_bIsFloating || !w->m_bMappedX11 || !w->m_bIsMapped || w->isHidden())

src/layout/MasterLayout.hpp

@@ -14,7 +14,8 @@ enum eOrientation : uint8_t
     ORIENTATION_LEFT = 0,
     ORIENTATION_TOP,
     ORIENTATION_RIGHT,
-    ORIENTATION_BOTTOM
+    ORIENTATION_BOTTOM,
+    ORIENTATION_CENTER
 };
 
 struct SMasterNodeData {
@@ -30,7 +31,7 @@ struct SMasterNodeData {
 
     int      workspaceID = -1;
 
-    bool     operator==(const SMasterNodeData& rhs) {
+    bool     operator==(const SMasterNodeData& rhs) const {
         return pWindow == rhs.pWindow;
     }
 };
@@ -39,7 +40,7 @@ struct SMasterWorkspaceData {
     int          workspaceID = -1;
     eOrientation orientation = ORIENTATION_LEFT;
 
-    bool         operator==(const SMasterWorkspaceData& rhs) {
+    bool         operator==(const SMasterWorkspaceData& rhs) const {
         return workspaceID == rhs.workspaceID;
     }
 };
@@ -58,6 +59,7 @@ class CHyprMasterLayout : public IHyprLayout {
     virtual void                     switchWindows(CWindow*, CWindow*);
     virtual void                     alterSplitRatio(CWindow*, float, bool);
     virtual std::string              getLayoutName();
+    virtual void                     replaceWindowDataWith(CWindow* from, CWindow* to);
 
     virtual void                     onEnable();
     virtual void                     onDisable();

src/main.cpp

@@ -3,11 +3,26 @@
 #include "Compositor.hpp"
 #include "config/ConfigManager.hpp"
 #include "init/initHelpers.hpp"
+
 #include <iostream>
+#include <iterator>
+#include <vector>
+#include <stdexcept>
+#include <string>
+#include <filesystem>
+
 #ifdef USES_SYSTEMD
 #include <systemd/sd-daemon.h> // for sd_notify
 #endif
 
+void help() {
+    std::cout << "usage: Hyprland [arg [...]].\n";
+    std::cout << "\nArguments:\n";
+    std::cout << "  --help              -h       - Show this message again\n";
+    std::cout << "  --config FILE       -c FILE  - Specify config file to use\n";
+    std::cout << "  --i-am-really-stupid         - Omits root user privileges check (why would you do that?)\n";
+}
+
 int main(int argc, char** argv) {
 
     if (!getenv("XDG_RUNTIME_DIR"))
@@ -17,50 +32,64 @@ int main(int argc, char** argv) {
     std::string cmd = "";
     for (auto i = 0; i < argc; ++i)
         cmd += std::string(i == 0 ? "" : " ") + argv[i];
+
     setenv("HYPRLAND_CMD", cmd.c_str(), 1);
     setenv("XDG_BACKEND", "wayland", 1);
-    setenv("_JAVA_AWT_WM_NONREPARENTING", "1", 0);
+    setenv("_JAVA_AWT_WM_NONREPARENTING", "1", 1);
+    setenv("MOZ_ENABLE_WAYLAND", "1", 1);
+    setenv("XDG_CURRENT_DESKTOP", "Hyprland", 1);
 
     // parse some args
-    std::string configPath;
-    bool        ignoreSudo = false;
-    for (int i = 1; i < argc; ++i) {
-        if (!strcmp(argv[i], "--i-am-really-stupid"))
+    std::string              configPath;
+    bool                     ignoreSudo = false;
+
+    std::vector<std::string> args{argv + 1, argv + argc};
+
+    for (auto it = args.begin(); it != args.end(); it++) {
+        if (it->compare("--i-am-really-stupid") == 0 && !ignoreSudo) {
+            std::cout << "[ WARNING ] Running Hyprland with superuser privileges might damage your system\n";
+
             ignoreSudo = true;
-        else if ((!strcmp(argv[i], "-c") || !strcmp(argv[i], "--config")) && argc >= i + 2) {
-            configPath = std::string(argv[++i]);
-            Debug::log(LOG, "Using config location %s.", configPath.c_str());
-        } else {
-            std::cout << "Hyprland usage: Hyprland [arg [...]].\n\nArguments:\n"
-                      << "--help         -h | Show this help message\n"
-                      << "--config       -c | Specify config file to use\n";
-            return 1;
+        }
+
+        else if (it->compare("-c") == 0 || it->compare("--config") == 0) {
+            if (std::next(it)->c_str() == nullptr) {
+                help();
+                return 1;
+            }
+            std::string next_arg = std::next(it)->c_str();
+
+            if (!std::filesystem::exists(next_arg)) {
+                std::cerr << "[ ERROR ] Config path '" << next_arg << "' doesn't exist!\n";
+                help();
+
+                return 1;
+            }
+
+            configPath = next_arg;
+            Debug::log(LOG, "User-specified config location: '%s'", configPath.c_str());
+            continue;
         }
     }
 
-    system("mkdir -p /tmp/hypr");
+    if (!ignoreSudo && Init::isSudo()) {
+        std::cerr << "[ ERROR ] Hyprland was launched with superuser priveleges, but the privileges check is not omitted.\n";
+        std::cerr << "          Hint: Use the --i-am-really-stupid flag to omit that check.\n";
 
-    if (!ignoreSudo) {
-        if (Init::isSudo()) {
-            std::cout << "Hyprland shall not be run as the root user. If you really want to, use the --i-am-really-stupid flag.\n";
-            return 1;
-        }
-    } else {
-        std::cout << "Running with ignored root checks, I surely hope you know what you're doing.\n";
-        sleep(1);
+        return 1;
+    } else if (ignoreSudo && Init::isSudo()) {
+        std::cout << "Superuser privileges check is omitted. I hope you know what you're doing.\n";
     }
 
     std::cout << "Welcome to Hyprland!\n";
 
-    const auto LOGWLR = getenv("HYPRLAND_LOG_WLR");
-    if (LOGWLR && std::string(LOGWLR) == "1")
-        wlr_log_init(WLR_DEBUG, Debug::wlrLog);
-
     // let's init the compositor.
     // it initializes basic Wayland stuff in the constructor.
     g_pCompositor                     = std::make_unique<CCompositor>();
     g_pCompositor->explicitConfigPath = configPath;
 
+    g_pCompositor->initServer();
+
     Debug::log(LOG, "Hyprland init finished.");
 
     // If all's good to go, start.
@@ -72,16 +101,14 @@ int main(int argc, char** argv) {
 #ifdef USES_SYSTEMD
     // tell systemd it destroy bound/related units
     if (sd_booted() > 0)
-       sd_notify(0, "STOPPING=1");
+        sd_notify(0, "STOPPING=1");
 #endif
 
-    wl_display_destroy_clients(g_pCompositor->m_sWLDisplay);
+    if (g_pCompositor->m_sWLDisplay)
+        wl_display_destroy_clients(g_pCompositor->m_sWLDisplay);
 
-    // kill all clients
-    for (auto& c : g_pCompositor->m_dProcessPIDsOnShutdown)
-        kill(c, SIGKILL);
-
-    wl_display_destroy(g_pCompositor->m_sWLDisplay);
+    if (g_pCompositor->m_sWLDisplay)
+        wl_display_destroy(g_pCompositor->m_sWLDisplay);
 
     return EXIT_SUCCESS;
 }

src/managers/AnimationManager.cpp

@@ -1,9 +1,23 @@
 #include "AnimationManager.hpp"
 #include "../Compositor.hpp"
 
+int wlTick(void* data) {
+
+    float refreshRate = g_pHyprRenderer->m_pMostHzMonitor ? g_pHyprRenderer->m_pMostHzMonitor->refreshRate : 60.f;
+
+    wl_event_source_timer_update(g_pAnimationManager->m_pAnimationTick, 1000 / refreshRate);
+
+    g_pAnimationManager->tick();
+
+    return 0;
+}
+
 CAnimationManager::CAnimationManager() {
     std::vector<Vector2D> points = {Vector2D(0, 0.75f), Vector2D(0.15f, 1.f)};
     m_mBezierCurves["default"].setup(&points);
+
+    m_pAnimationTick = wl_event_loop_add_timer(g_pCompositor->m_sWLEventLoop, &wlTick, nullptr);
+    wl_event_source_timer_update(m_pAnimationTick, 1);
 }
 
 void CAnimationManager::removeAllBeziers() {
@@ -21,6 +35,10 @@ void CAnimationManager::addBezierWithName(std::string name, const Vector2D& p1,
 
 void CAnimationManager::tick() {
 
+    static std::chrono::time_point lastTick = std::chrono::high_resolution_clock::now();
+    m_fLastTickTime                         = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - lastTick).count() / 1000.0;
+    lastTick                                = std::chrono::high_resolution_clock::now();
+
     bool               animGlobalDisabled = false;
 
     static auto* const PANIMENABLED = &g_pConfigManager->getConfigValuePtr("animations:enabled")->intValue;
@@ -67,8 +85,11 @@ void CAnimationManager::tick() {
         } else if (PLAYER) {
             WLRBOXPREV = PLAYER->geometry;
             PMONITOR   = g_pCompositor->getMonitorFromVector(Vector2D(PLAYER->geometry.x, PLAYER->geometry.y) + Vector2D(PLAYER->geometry.width, PLAYER->geometry.height) / 2.f);
+            animationsDisabled = animationsDisabled || PLAYER->noAnimations;
         }
 
+        const bool VISIBLE = PWINDOW ? g_pCompositor->isWorkspaceVisible(PWINDOW->m_iWorkspaceID) : true;
+
         // beziers are with a switch unforto
         // TODO: maybe do something cleaner
 
@@ -141,7 +162,18 @@ void CAnimationManager::tick() {
             }
         }
 
-        // damage the window with the damage policy
+        // set size and pos if valid, but only if damage policy entire (dont if border for example)
+        if (g_pCompositor->windowValidMapped(PWINDOW) && av->m_eDamagePolicy == AVARDAMAGE_ENTIRE && PWINDOW->m_iX11Type != 2)
+            g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
+
+        // check if we did not finish animating. If so, trigger onAnimationEnd.
+        if (!av->isBeingAnimated())
+            animationEndedVars.push_back(av);
+
+        // lastly, handle damage, but only if whatever we are animating is visible.
+        if (!VISIBLE)
+            continue;
+
         switch (av->m_eDamagePolicy) {
             case AVARDAMAGE_ENTIRE: {
                 g_pHyprRenderer->damageBox(&WLRBOXPREV);
@@ -177,8 +209,9 @@ void CAnimationManager::tick() {
                 g_pHyprRenderer->damageBox(WLRBOXPREV.x - BORDERSIZE, WLRBOXPREV.y - BORDERSIZE, WLRBOXPREV.width + 2 * BORDERSIZE, BORDERSIZE + ROUNDINGSIZE);  // top
                 g_pHyprRenderer->damageBox(WLRBOXPREV.x - BORDERSIZE, WLRBOXPREV.y - BORDERSIZE, BORDERSIZE + ROUNDINGSIZE, WLRBOXPREV.height + 2 * BORDERSIZE); // left
                 g_pHyprRenderer->damageBox(WLRBOXPREV.x + WLRBOXPREV.width - ROUNDINGSIZE, WLRBOXPREV.y - BORDERSIZE, BORDERSIZE + ROUNDINGSIZE,
-                                           WLRBOXPREV.height + 2 * BORDERSIZE);                                                                                          // right
-                g_pHyprRenderer->damageBox(WLRBOXPREV.x, WLRBOXPREV.y + WLRBOXPREV.height - ROUNDINGSIZE, WLRBOXPREV.width + 2 * BORDERSIZE, BORDERSIZE + ROUNDINGSIZE); // bottom
+                                           WLRBOXPREV.height + 2 * BORDERSIZE); // right
+                g_pHyprRenderer->damageBox(WLRBOXPREV.x, WLRBOXPREV.y + WLRBOXPREV.height - ROUNDINGSIZE, WLRBOXPREV.width + 2 * BORDERSIZE,
+                                           BORDERSIZE + ROUNDINGSIZE); // bottom
 
                 // damage for new box
                 const wlr_box WLRBOXNEW = {PWINDOW->m_vRealPosition.vec().x, PWINDOW->m_vRealPosition.vec().y, PWINDOW->m_vRealSize.vec().x, PWINDOW->m_vRealSize.vec().y};
@@ -201,8 +234,8 @@ void CAnimationManager::tick() {
                     const auto EXTENTS = PDECO->getWindowDecorationExtents();
 
                     wlr_box    dmg = {PWINDOW->m_vRealPosition.vec().x - EXTENTS.topLeft.x, PWINDOW->m_vRealPosition.vec().y - EXTENTS.topLeft.y,
-                                      PWINDOW->m_vRealSize.vec().x + EXTENTS.topLeft.x + EXTENTS.bottomRight.x,
-                                      PWINDOW->m_vRealSize.vec().y + EXTENTS.topLeft.y + EXTENTS.bottomRight.y};
+                                   PWINDOW->m_vRealSize.vec().x + EXTENTS.topLeft.x + EXTENTS.bottomRight.x,
+                                   PWINDOW->m_vRealSize.vec().y + EXTENTS.topLeft.y + EXTENTS.bottomRight.y};
 
                     if (!*PSHADOWIGNOREWINDOW) {
                         // easy, damage the entire box
@@ -223,21 +256,13 @@ void CAnimationManager::tick() {
                 break;
             }
             default: {
-                Debug::log(ERR, "av has damage policy INVALID???");
                 break;
             }
         }
 
-        // set size and pos if valid, but only if damage policy entire (dont if border for example)
-        if (g_pCompositor->windowValidMapped(PWINDOW) && av->m_eDamagePolicy == AVARDAMAGE_ENTIRE && PWINDOW->m_iX11Type != 2)
-            g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
-
         // manually schedule a frame
-        g_pCompositor->scheduleFrameForMonitor(PMONITOR);
-
-        // check if we did not finish animating. If so, trigger onAnimationEnd.
-        if (!av->isBeingAnimated())
-            animationEndedVars.push_back(av);
+        if (PMONITOR)
+            g_pCompositor->scheduleFrameForMonitor(PMONITOR);
     }
 
     // do it here, because if this alters the animation vars deque we would be in trouble above.
@@ -452,6 +477,10 @@ std::string CAnimationManager::styleValidInConfigVar(const std::string& config,
             return "";
 
         return "unknown style";
+    } else if (config == "borderangle") {
+        if (style == "loop" || style == "once")
+            return "";
+        return "unknown style";
     } else {
         return "animation has no styles";
     }
@@ -463,4 +492,8 @@ CBezierCurve* CAnimationManager::getBezier(const std::string& name) {
     const auto BEZIER = std::find_if(m_mBezierCurves.begin(), m_mBezierCurves.end(), [&](const auto& other) { return other.first == name; });
 
     return BEZIER == m_mBezierCurves.end() ? &m_mBezierCurves["default"] : &BEZIER->second;
-}
+}
+
+std::unordered_map<std::string, CBezierCurve> CAnimationManager::getAllBeziers() {
+    return m_mBezierCurves;
+}

src/managers/AnimationManager.hpp

@@ -6,23 +6,30 @@
 #include "../helpers/AnimatedVariable.hpp"
 #include "../helpers/BezierCurve.hpp"
 #include "../Window.hpp"
+#include "../helpers/Timer.hpp"
 
 class CAnimationManager {
   public:
     CAnimationManager();
 
-    void                          tick();
-    void                          addBezierWithName(std::string, const Vector2D&, const Vector2D&);
-    void                          removeAllBeziers();
+    void                                          tick();
+    void                                          addBezierWithName(std::string, const Vector2D&, const Vector2D&);
+    void                                          removeAllBeziers();
 
-    void                          onWindowPostCreateClose(CWindow*, bool close = false);
+    void                                          onWindowPostCreateClose(CWindow*, bool close = false);
 
-    bool                          bezierExists(const std::string&);
-    CBezierCurve*                 getBezier(const std::string&);
+    bool                                          bezierExists(const std::string&);
+    CBezierCurve*                                 getBezier(const std::string&);
 
-    std::string                   styleValidInConfigVar(const std::string&, const std::string&);
+    std::string                                   styleValidInConfigVar(const std::string&, const std::string&);
 
-    std::list<CAnimatedVariable*> m_lAnimatedVariables;
+    std::unordered_map<std::string, CBezierCurve> getAllBeziers();
+
+    std::list<CAnimatedVariable*>                 m_lAnimatedVariables;
+
+    wl_event_source*                              m_pAnimationTick;
+
+    float                                         m_fLastTickTime; // in ms
 
   private:
     bool                                          deltaSmallToFlip(const Vector2D& a, const Vector2D& b);

src/managers/HookSystemManager.cpp

@@ -0,0 +1,79 @@
+#include "HookSystemManager.hpp"
+
+#include "../plugins/PluginSystem.hpp"
+
+CHookSystemManager::CHookSystemManager() {
+    ; //
+}
+
+// returns the pointer to the function
+HOOK_CALLBACK_FN* CHookSystemManager::hookDynamic(const std::string& event, HOOK_CALLBACK_FN fn, HANDLE handle) {
+    const auto PVEC = getVecForEvent(event);
+    const auto PFN  = &m_lCallbackFunctions.emplace_back(fn);
+    PVEC->emplace_back(SCallbackFNPtr{PFN, handle});
+    return PFN;
+}
+
+void CHookSystemManager::hookStatic(const std::string& event, HOOK_CALLBACK_FN* fn, HANDLE handle) {
+    const auto PVEC = getVecForEvent(event);
+    PVEC->emplace_back(SCallbackFNPtr{fn, handle});
+}
+
+void CHookSystemManager::unhook(HOOK_CALLBACK_FN* fn) {
+    std::erase_if(m_lCallbackFunctions, [&](const auto& other) { return &other == fn; });
+    for (auto& [k, v] : m_lpRegisteredHooks) {
+        std::erase_if(v, [&](const auto& other) { return other.fn == fn; });
+    }
+}
+
+void CHookSystemManager::emit(const std::vector<SCallbackFNPtr>* callbacks, std::any data) {
+    if (callbacks->empty())
+        return;
+
+    std::vector<HANDLE> faultyHandles;
+
+    for (auto& cb : *callbacks) {
+
+        m_bCurrentEventPlugin = false;
+
+        if (!cb.handle) {
+            // we don't guard hl hooks
+            (*cb.fn)(cb.fn, data);
+            continue;
+        }
+
+        m_bCurrentEventPlugin = true;
+
+        if (std::find(faultyHandles.begin(), faultyHandles.end(), cb.handle) != faultyHandles.end())
+            continue;
+
+        try {
+            if (!setjmp(m_jbHookFaultJumpBuf))
+                (*cb.fn)(cb.fn, data);
+            else {
+                // this module crashed.
+                throw std::exception();
+            }
+        } catch (std::exception& e) {
+            // TODO: this works only once...?
+            faultyHandles.push_back(cb.handle);
+            Debug::log(ERR, " [hookSystem] Hook from plugin %lx caused a SIGSEGV, queueing for unloading.", cb.handle);
+        }
+    }
+
+    if (!faultyHandles.empty()) {
+        for (auto& h : faultyHandles)
+            g_pPluginSystem->unloadPlugin(g_pPluginSystem->getPluginByHandle(h), true);
+    }
+}
+
+std::vector<SCallbackFNPtr>* CHookSystemManager::getVecForEvent(const std::string& event) {
+    auto IT = std::find_if(m_lpRegisteredHooks.begin(), m_lpRegisteredHooks.end(), [&](const auto& other) { return other.first == event; });
+
+    if (IT != m_lpRegisteredHooks.end())
+        return &IT->second;
+
+    Debug::log(LOG, " [hookSystem] New hook event registered: %s", event.c_str());
+
+    return &m_lpRegisteredHooks.emplace_back(std::make_pair<>(event, std::vector<SCallbackFNPtr>{})).second;
+}

src/managers/HookSystemManager.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "../defines.hpp"
+
+#include <unordered_map>
+#include <any>
+#include <array>
+#include <list>
+
+#include <csetjmp>
+
+#include "../plugins/PluginAPI.hpp"
+
+// global typedef for hooked functions. Passes itself as a ptr when called, and `data` additionally.
+typedef std::function<void(void*, std::any)> HOOK_CALLBACK_FN;
+
+struct SCallbackFNPtr {
+    HOOK_CALLBACK_FN* fn     = nullptr;
+    HANDLE            handle = nullptr;
+};
+
+#define EMIT_HOOK_EVENT(name, param)                                                                                                                                               \
+    {                                                                                                                                                                              \
+        static auto* const PEVENTVEC = g_pHookSystem->getVecForEvent(name);                                                                                                        \
+        g_pHookSystem->emit(PEVENTVEC, param);                                                                                                                                     \
+    }
+
+class CHookSystemManager {
+  public:
+    CHookSystemManager();
+
+    // returns the pointer to the function
+    HOOK_CALLBACK_FN*            hookDynamic(const std::string& event, HOOK_CALLBACK_FN fn, HANDLE handle = nullptr);
+    void                         hookStatic(const std::string& event, HOOK_CALLBACK_FN* fn, HANDLE handle = nullptr);
+    void                         unhook(HOOK_CALLBACK_FN* fn);
+
+    void                         emit(const std::vector<SCallbackFNPtr>* callbacks, std::any data = 0);
+    std::vector<SCallbackFNPtr>* getVecForEvent(const std::string& event);
+
+    bool                         m_bCurrentEventPlugin = false;
+    jmp_buf                      m_jbHookFaultJumpBuf;
+
+  private:
+    // todo: this is slow. Maybe static ptrs should be somehow allowed. unique ptr for vec?
+    std::list<std::pair<std::string, std::vector<SCallbackFNPtr>>> m_lpRegisteredHooks;
+    std::list<HOOK_CALLBACK_FN>                                    m_lCallbackFunctions;
+};
+
+inline std::unique_ptr<CHookSystemManager> g_pHookSystem;

src/managers/KeybindManager.cpp

@@ -2,14 +2,25 @@
 
 #include <regex>
 
+#include <sys/ioctl.h>
+#if defined(__linux__)
+#include <linux/vt.h>
+#elif defined(__NetBSD__) || defined(__OpenBSD__)
+#include <dev/wscons/wsdisplay_usl_io.h>
+#elif defined(__DragonFly__) || defined(__FreeBSD__)
+#include <sys/consio.h>
+#endif
+
 CKeybindManager::CKeybindManager() {
     // initialize all dispatchers
 
     m_mDispatchers["exec"]                          = spawn;
+    m_mDispatchers["execr"]                         = spawnRaw;
     m_mDispatchers["killactive"]                    = killActive;
     m_mDispatchers["closewindow"]                   = kill;
     m_mDispatchers["togglefloating"]                = toggleActiveFloating;
     m_mDispatchers["workspace"]                     = changeworkspace;
+    m_mDispatchers["renameworkspace"]               = renameWorkspace;
     m_mDispatchers["fullscreen"]                    = fullscreenActive;
     m_mDispatchers["fakefullscreen"]                = fakeFullscreenActive;
     m_mDispatchers["movetoworkspace"]               = moveActiveToWorkspace;
@@ -47,6 +58,11 @@ CKeybindManager::CKeybindManager() {
     m_mDispatchers["pin"]                           = pinActive;
     m_mDispatchers["mouse"]                         = mouse;
     m_mDispatchers["bringactivetotop"]              = bringActiveToTop;
+    m_mDispatchers["focusurgentorlast"]             = focusUrgentOrLast;
+    m_mDispatchers["focuscurrentorlast"]            = focusCurrentOrLast;
+    m_mDispatchers["lockgroups"]                    = lockGroups;
+    m_mDispatchers["moveintogroup"]                 = moveIntoGroup;
+    m_mDispatchers["moveoutofgroup"]                = moveOutOfGroup;
 
     m_tScrollTimer.reset();
 }
@@ -87,7 +103,7 @@ uint32_t CKeybindManager::stringToModMask(std::string mods) {
         modMask |= WLR_MODIFIER_CAPS;
     if (mods.contains("CTRL") || mods.contains("CONTROL"))
         modMask |= WLR_MODIFIER_CTRL;
-    if (mods.contains("ALT"))
+    if (mods.contains("ALT") || mods.contains("MOD1"))
         modMask |= WLR_MODIFIER_ALT;
     if (mods.contains("MOD2"))
         modMask |= WLR_MODIFIER_MOD2;
@@ -244,16 +260,20 @@ bool CKeybindManager::onAxisEvent(wlr_pointer_axis_event* e) {
 
     bool found = false;
     if (e->source == WLR_AXIS_SOURCE_WHEEL && e->orientation == WLR_AXIS_ORIENTATION_VERTICAL) {
-        if (e->delta < 0) {
+        if (e->delta < 0)
             found = handleKeybinds(MODS, "mouse_down", 0, 0, true, 0);
-        } else {
+        else
             found = handleKeybinds(MODS, "mouse_up", 0, 0, true, 0);
-        }
-
-        if (found)
-            shadowKeybinds();
+    } else if (e->source == WLR_AXIS_SOURCE_WHEEL && e->orientation == WLR_AXIS_ORIENTATION_HORIZONTAL) {
+        if (e->delta < 0)
+            found = handleKeybinds(MODS, "mouse_left", 0, 0, true, 0);
+        else
+            found = handleKeybinds(MODS, "mouse_right", 0, 0, true, 0);
     }
 
+    if (found)
+        shadowKeybinds();
+
     return !found;
 }
 
@@ -282,10 +302,26 @@ bool CKeybindManager::onMouseEvent(wlr_pointer_button_event* e) {
     return !found && !mouseBindWasActive;
 }
 
+void CKeybindManager::resizeWithBorder(wlr_pointer_button_event* e) {
+    if (e->state == WLR_BUTTON_PRESSED) {
+        mouse("1resizewindow");
+    } else {
+        mouse("0resizewindow");
+    }
+}
+
 void CKeybindManager::onSwitchEvent(const std::string& switchName) {
     handleKeybinds(0, "switch:" + switchName, 0, 0, true, 0);
 }
 
+void CKeybindManager::onSwitchOnEvent(const std::string& switchName) {
+    handleKeybinds(0, "switch:on:" + switchName, 0, 0, true, 0);
+}
+
+void CKeybindManager::onSwitchOffEvent(const std::string& switchName) {
+    handleKeybinds(0, "switch:off:" + switchName, 0, 0, true, 0);
+}
+
 int repeatKeyHandler(void* data) {
     SKeybind** ppActiveKeybind = (SKeybind**)data;
 
@@ -349,7 +385,7 @@ bool CKeybindManager::handleKeybinds(const uint32_t& modmask, const std::string&
 
         // Should never happen, as we check in the ConfigManager, but oh well
         if (DISPATCHER == m_mDispatchers.end()) {
-            Debug::log(ERR, "Inavlid handler in a keybind! (handler %s does not exist)", k.handler.c_str());
+            Debug::log(ERR, "Invalid handler in a keybind! (handler %s does not exist)", k.handler.c_str());
         } else {
             // call the dispatcher
             Debug::log(LOG, "Keybind triggered, calling dispatcher (%d, %s, %d)", modmask, key.c_str(), keysym);
@@ -432,13 +468,16 @@ bool CKeybindManager::handleVT(xkb_keysym_t keysym) {
         const unsigned int TTY = keysym - XKB_KEY_XF86Switch_VT_1 + 1;
 
         // vtnr is bugged for some reason.
-        const std::string TTYSTR = execAndGet("head -n 1 /sys/devices/virtual/tty/tty0/active").substr(3);
-        unsigned int      ttynum = 0;
-        try {
-            ttynum = std::stoll(TTYSTR);
-        } catch (std::exception& e) {
-            ; // oops?
-        }
+        unsigned int ttynum = 0;
+#if defined(VT_GETSTATE)
+        struct vt_stat st;
+        if (!ioctl(0, VT_GETSTATE, &st))
+            ttynum = st.v_active;
+#elif defined(VT_GETACTIVE)
+        int vt;
+        if (!ioctl(0, VT_GETACTIVE, &vt))
+            ttynum = vt;
+#endif
 
         if (ttynum == TTY)
             return true;
@@ -499,6 +538,20 @@ void CKeybindManager::spawn(std::string args) {
     else
         args = "WAYLAND_DISPLAY=" + std::string(g_pCompositor->m_szWLDisplaySocket) + " " + args;
 
+    const uint64_t PROC = spawnRaw(args);
+
+    if (!RULES.empty()) {
+        const auto RULESLIST = CVarList(RULES, 0, ';');
+
+        for (auto& r : RULESLIST) {
+            g_pConfigManager->addExecRule({r, (unsigned long)PROC});
+        }
+
+        Debug::log(LOG, "Applied %i rule arguments for exec.", RULESLIST.size());
+    }
+}
+
+uint64_t CKeybindManager::spawnRaw(std::string args) {
     Debug::log(LOG, "Executing %s", args.c_str());
 
     int socket[2];
@@ -512,7 +565,7 @@ void CKeybindManager::spawn(std::string args) {
         close(socket[0]);
         close(socket[1]);
         Debug::log(LOG, "Fail to create the first fork");
-        return;
+        return 0;
     }
     if (child == 0) {
         // run in child
@@ -544,20 +597,12 @@ void CKeybindManager::spawn(std::string args) {
     waitpid(child, NULL, 0);
     if (child < 0) {
         Debug::log(LOG, "Fail to create the second fork");
-        return;
+        return 0;
     }
 
     Debug::log(LOG, "Process Created with pid %d", grandchild);
 
-    if (!RULES.empty()) {
-        const auto RULESLIST = CVarList(RULES, 0, ';');
-
-        for (auto& r : RULESLIST) {
-            g_pConfigManager->addExecRule({r, (unsigned long)grandchild});
-        }
-
-        Debug::log(LOG, "Applied %i rule arguments for exec.", RULESLIST.size());
-    }
+    return grandchild;
 }
 
 void CKeybindManager::killActive(std::string args) {
@@ -597,11 +642,25 @@ void CKeybindManager::toggleActiveFloating(std::string args) {
     if (g_pCompositor->isWorkspaceSpecial(PWINDOW->m_iWorkspaceID))
         return;
 
-    PWINDOW->m_bIsFloating = !PWINDOW->m_bIsFloating;
+    if (PWINDOW->m_sGroupData.pNextWindow && PWINDOW->m_sGroupData.pNextWindow != PWINDOW) {
 
-    PWINDOW->updateDynamicRules();
+        const auto PCURRENT     = PWINDOW->getGroupCurrent();
+        PCURRENT->m_bIsFloating = !PCURRENT->m_bIsFloating;
+        g_pLayoutManager->getCurrentLayout()->changeWindowFloatingMode(PCURRENT);
 
-    g_pLayoutManager->getCurrentLayout()->changeWindowFloatingMode(PWINDOW);
+        CWindow* curr = PCURRENT->m_sGroupData.pNextWindow;
+        while (curr != PCURRENT) {
+            curr->m_bIsFloating = PCURRENT->m_bIsFloating;
+            curr->updateDynamicRules();
+            curr = curr->m_sGroupData.pNextWindow;
+        }
+    } else {
+        PWINDOW->m_bIsFloating = !PWINDOW->m_bIsFloating;
+
+        PWINDOW->updateDynamicRules();
+
+        g_pLayoutManager->getCurrentLayout()->changeWindowFloatingMode(PWINDOW);
+    }
 }
 
 void CKeybindManager::centerWindow(std::string args) {
@@ -649,24 +708,24 @@ void CKeybindManager::changeworkspace(std::string args) {
         const auto PCURRENTWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->activeWorkspace);
 
         // Do nothing if there's no previous workspace, otherwise switch to it.
-        if (PCURRENTWORKSPACE->m_iPrevWorkspaceID == -1) {
+        if (PCURRENTWORKSPACE->m_sPrevWorkspace.iID == -1) {
             Debug::log(LOG, "No previous workspace to change to");
             return;
         } else {
-            workspaceToChangeTo = PCURRENTWORKSPACE->m_iPrevWorkspaceID;
+            workspaceToChangeTo = PCURRENTWORKSPACE->m_sPrevWorkspace.iID;
 
             if (const auto PWORKSPACETOCHANGETO = g_pCompositor->getWorkspaceByID(workspaceToChangeTo); PWORKSPACETOCHANGETO)
                 workspaceName = PWORKSPACETOCHANGETO->m_szName;
             else
-                workspaceName = std::to_string(workspaceToChangeTo);
-
-            isSwitchingToPrevious = true;
+                workspaceName = PCURRENTWORKSPACE->m_sPrevWorkspace.name.empty() ? std::to_string(workspaceToChangeTo) : PCURRENTWORKSPACE->m_sPrevWorkspace.name;
 
             // If the previous workspace ID isn't reset, cycles can form when continually going
             // to the previous workspace again and again.
             static auto* const PALLOWWORKSPACECYCLES = &g_pConfigManager->getConfigValuePtr("binds:allow_workspace_cycles")->intValue;
             if (!*PALLOWWORKSPACECYCLES)
-                PCURRENTWORKSPACE->m_iPrevWorkspaceID = -1;
+                PCURRENTWORKSPACE->m_sPrevWorkspace = {-1, ""};
+            else
+                isSwitchingToPrevious = true;
         }
     } else {
         workspaceToChangeTo = getWorkspaceIDFromString(args, workspaceName);
@@ -682,24 +741,24 @@ void CKeybindManager::changeworkspace(std::string args) {
     const auto         PCURRENTWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->activeWorkspace);
     static auto* const PBACKANDFORTH     = &g_pConfigManager->getConfigValuePtr("binds:workspace_back_and_forth")->intValue;
 
-    if (*PBACKANDFORTH && PCURRENTWORKSPACE && PCURRENTWORKSPACE->m_iID == workspaceToChangeTo && PCURRENTWORKSPACE->m_iPrevWorkspaceID != -1 && !internal) {
+    if (*PBACKANDFORTH && PCURRENTWORKSPACE && PCURRENTWORKSPACE->m_iID == workspaceToChangeTo && PCURRENTWORKSPACE->m_sPrevWorkspace.iID != -1 && !internal) {
 
-        const auto PPREVWORKSPACE = g_pCompositor->getWorkspaceByID(PCURRENTWORKSPACE->m_iPrevWorkspaceID);
+        const auto PPREVWORKSPACE = g_pCompositor->getWorkspaceByID(PCURRENTWORKSPACE->m_sPrevWorkspace.iID);
 
-        workspaceToChangeTo = PCURRENTWORKSPACE->m_iPrevWorkspaceID;
+        workspaceToChangeTo = PCURRENTWORKSPACE->m_sPrevWorkspace.iID;
 
         if (PPREVWORKSPACE)
             workspaceName = PPREVWORKSPACE->m_szName;
         else
-            workspaceName = std::to_string(workspaceToChangeTo);
-
-        isSwitchingToPrevious = true;
+            workspaceName = PCURRENTWORKSPACE->m_sPrevWorkspace.name.empty() ? std::to_string(workspaceToChangeTo) : PCURRENTWORKSPACE->m_sPrevWorkspace.name;
 
         // If the previous workspace ID isn't reset, cycles can form when continually going
         // to the previous workspace again and again.
         static auto* const PALLOWWORKSPACECYCLES = &g_pConfigManager->getConfigValuePtr("binds:allow_workspace_cycles")->intValue;
         if (!*PALLOWWORKSPACECYCLES)
-            PCURRENTWORKSPACE->m_iPrevWorkspaceID = -1;
+            PCURRENTWORKSPACE->m_sPrevWorkspace = {-1, ""};
+        else
+            isSwitchingToPrevious = true;
 
     } else if (PCURRENTWORKSPACE && PCURRENTWORKSPACE->m_iID == workspaceToChangeTo && !internal)
         return;
@@ -719,9 +778,11 @@ void CKeybindManager::changeworkspace(std::string args) {
 
         const auto PWORKSPACETOCHANGETO = g_pCompositor->getWorkspaceByID(workspaceToChangeTo);
 
-        if (!isSwitchingToPrevious && !internal)
+        if (!isSwitchingToPrevious && !internal) {
             // Remember previous workspace.
-            PWORKSPACETOCHANGETO->m_iPrevWorkspaceID = g_pCompositor->m_pLastMonitor->activeWorkspace;
+            PWORKSPACETOCHANGETO->m_sPrevWorkspace.iID  = g_pCompositor->m_pLastMonitor->activeWorkspace;
+            PWORKSPACETOCHANGETO->m_sPrevWorkspace.name = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->activeWorkspace)->m_szName;
+        }
 
         if (g_pCompositor->isWorkspaceSpecial(workspaceToChangeTo))
             PWORKSPACETOCHANGETO->m_iMonitorID = PMONITOR->ID;
@@ -754,6 +815,7 @@ void CKeybindManager::changeworkspace(std::string args) {
             PWORKSPACETOCHANGETO->startAnim(true, ANIMTOLEFT);
 
             g_pEventManager->postEvent(SHyprIPCEvent{"workspace", PWORKSPACETOCHANGETO->m_szName});
+            EMIT_HOOK_EVENT("workspace", PWORKSPACETOCHANGETO);
         }
 
         // If the monitor is not the one our cursor's at, warp to it.
@@ -776,7 +838,7 @@ void CKeybindManager::changeworkspace(std::string args) {
             if (anotherMonitor)
                 g_pCompositor->warpCursorTo(PWINDOW->m_vRealPosition.vec() + PWINDOW->m_vRealSize.vec() / 2.f);
 
-            g_pCompositor->focusWindow(PWINDOW, g_pXWaylandManager->getWindowSurface(PWINDOW));
+            g_pCompositor->focusWindow(PWINDOW, PWINDOW->m_pWLSurface.wlr());
 
             if (g_pCompositor->cursorOnReservedArea()) // fix focus on bars etc
                 g_pInputManager->refocus();
@@ -814,9 +876,12 @@ void CKeybindManager::changeworkspace(std::string args) {
 
     const bool ANOTHERMONITOR = PMONITOR != g_pCompositor->m_pLastMonitor;
 
-    if (!isSwitchingToPrevious)
+    if (!isSwitchingToPrevious) {
         // Remember previous workspace.
-        PWORKSPACE->m_iPrevWorkspaceID = OLDWORKSPACE;
+        PWORKSPACE->m_sPrevWorkspace.iID = OLDWORKSPACE;
+        if (const auto POLDWORKSPACE = g_pCompositor->getWorkspaceByID(OLDWORKSPACE); POLDWORKSPACE)
+            PWORKSPACE->m_sPrevWorkspace.name = POLDWORKSPACE->m_szName;
+    }
 
     // start anim on new workspace
     PWORKSPACE->startAnim(true, ANIMTOLEFT);
@@ -847,6 +912,7 @@ void CKeybindManager::changeworkspace(std::string args) {
         g_pCompositor->warpCursorTo(PMONITOR->vecPosition + PMONITOR->vecSize / 2.f);
 
     g_pEventManager->postEvent(SHyprIPCEvent{"workspace", PWORKSPACE->m_szName});
+    EMIT_HOOK_EVENT("workspace", PWORKSPACE);
 
     g_pCompositor->setActiveMonitor(PMONITOR);
 
@@ -920,8 +986,9 @@ void CKeybindManager::moveActiveToWorkspace(std::string args) {
         PWORKSPACE = g_pCompositor->createNewWorkspace(WORKSPACEID, OLDWORKSPACE->m_iMonitorID, workspaceName);
     }
 
-    PWINDOW->moveToWorkspace(PWORKSPACE->m_iID);
     PWINDOW->m_iMonitorID = PWORKSPACE->m_iMonitorID;
+    PWINDOW->moveToWorkspace(PWORKSPACE->m_iID);
+    PWINDOW->updateGroupOutputs();
 
     if (PWORKSPACE->m_bHasFullscreenWindow) {
         g_pCompositor->setWindowFullscreen(g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID), false, FULLSCREEN_FULL);
@@ -952,6 +1019,8 @@ void CKeybindManager::moveActiveToWorkspace(std::string args) {
     }
 
     PWINDOW->updateToplevel();
+
+    g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID));
 }
 
 void CKeybindManager::moveActiveToWorkspaceSilent(std::string args) {
@@ -1026,6 +1095,7 @@ void CKeybindManager::moveActiveToWorkspaceSilent(std::string args) {
 
     // manually post event cuz it got ignored above
     g_pEventManager->postEvent(SHyprIPCEvent{"movewindow", getFormat("%x,%s", PWINDOW, PWORKSPACE->m_szName.c_str())});
+    EMIT_HOOK_EVENT("moveWindow", (std::vector<void*>{PWINDOW, PWORKSPACE}));
 
     PWINDOW->m_iWorkspaceID   = OLDWORKSPACEIDRETURN;
     const auto PNEXTCANDIDATE = g_pLayoutManager->getCurrentLayout()->getNextWindowCandidate(PWINDOW);
@@ -1069,14 +1139,19 @@ void CKeybindManager::moveFocusTo(std::string args) {
 
             if (PLASTWINDOW->m_iMonitorID != PWINDOWTOCHANGETO->m_iMonitorID) {
                 // event
-                const auto PNEWMON = g_pCompositor->getMonitorFromID(PWINDOWTOCHANGETO->m_iMonitorID);
+                const auto PNEWMON       = g_pCompositor->getMonitorFromID(PWINDOWTOCHANGETO->m_iMonitorID);
+                const auto PNEWWORKSPACE = g_pCompositor->getWorkspaceByID(PWINDOWTOCHANGETO->m_iWorkspaceID);
 
                 g_pCompositor->setActiveMonitor(PNEWMON);
+
+                g_pCompositor->deactivateAllWLRWorkspaces(PNEWWORKSPACE->m_pWlrHandle);
+                PNEWWORKSPACE->setActive(true);
             }
         }
     };
 
-    const auto PWINDOWTOCHANGETO = g_pCompositor->getWindowInDirection(PLASTWINDOW, arg);
+    const auto PWINDOWTOCHANGETO = PLASTWINDOW->m_bIsFullscreen ? g_pCompositor->getNextWindowOnWorkspace(PLASTWINDOW, arg == 'u' || arg == 't' || arg == 'r') :
+                                                                  g_pCompositor->getWindowInDirection(PLASTWINDOW, arg);
 
     if (PWINDOWTOCHANGETO) {
         switchToWindow(PWINDOWTOCHANGETO);
@@ -1088,6 +1163,77 @@ void CKeybindManager::moveFocusTo(std::string args) {
     }
 }
 
+void CKeybindManager::focusUrgentOrLast(std::string args) {
+    const auto PWINDOWURGENT = g_pCompositor->getUrgentWindow();
+    const auto PWINDOWPREV   = g_pCompositor->m_pLastWindow ? (g_pCompositor->m_vWindowFocusHistory.size() < 2 ? nullptr : g_pCompositor->m_vWindowFocusHistory[1]) :
+                                                              (g_pCompositor->m_vWindowFocusHistory.empty() ? nullptr : g_pCompositor->m_vWindowFocusHistory[0]);
+
+    if (!PWINDOWURGENT && !PWINDOWPREV)
+        return;
+
+    // remove constraints
+    g_pInputManager->unconstrainMouse();
+
+    auto switchToWindow = [&](CWindow* PWINDOWTOCHANGETO) {
+        if (PWINDOWTOCHANGETO == g_pCompositor->m_pLastWindow || !PWINDOWTOCHANGETO)
+            return;
+
+        if (g_pCompositor->m_pLastWindow && g_pCompositor->m_pLastWindow->m_iWorkspaceID == PWINDOWTOCHANGETO->m_iWorkspaceID && g_pCompositor->m_pLastWindow->m_bIsFullscreen) {
+            const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastWindow->m_iWorkspaceID);
+            const auto FSMODE     = PWORKSPACE->m_efFullscreenMode;
+
+            if (!PWINDOWTOCHANGETO->m_bPinned)
+                g_pCompositor->setWindowFullscreen(g_pCompositor->m_pLastWindow, false, FULLSCREEN_FULL);
+
+            g_pCompositor->focusWindow(PWINDOWTOCHANGETO);
+
+            if (!PWINDOWTOCHANGETO->m_bPinned)
+                g_pCompositor->setWindowFullscreen(PWINDOWTOCHANGETO, true, FSMODE);
+        } else {
+            g_pCompositor->focusWindow(PWINDOWTOCHANGETO);
+            Vector2D middle = PWINDOWTOCHANGETO->m_vRealPosition.goalv() + PWINDOWTOCHANGETO->m_vRealSize.goalv() / 2.f;
+            g_pCompositor->warpCursorTo(middle);
+        }
+    };
+
+    switchToWindow(PWINDOWURGENT ? PWINDOWURGENT : PWINDOWPREV);
+}
+
+void CKeybindManager::focusCurrentOrLast(std::string args) {
+    const auto PWINDOWPREV = g_pCompositor->m_pLastWindow ? (g_pCompositor->m_vWindowFocusHistory.size() < 2 ? nullptr : g_pCompositor->m_vWindowFocusHistory[1]) :
+                                                            (g_pCompositor->m_vWindowFocusHistory.empty() ? nullptr : g_pCompositor->m_vWindowFocusHistory[0]);
+
+    if (!PWINDOWPREV)
+        return;
+
+    // remove constraints
+    g_pInputManager->unconstrainMouse();
+
+    auto switchToWindow = [&](CWindow* PWINDOWTOCHANGETO) {
+        if (PWINDOWTOCHANGETO == g_pCompositor->m_pLastWindow || !PWINDOWTOCHANGETO)
+            return;
+
+        if (g_pCompositor->m_pLastWindow && g_pCompositor->m_pLastWindow->m_iWorkspaceID == PWINDOWTOCHANGETO->m_iWorkspaceID && g_pCompositor->m_pLastWindow->m_bIsFullscreen) {
+            const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastWindow->m_iWorkspaceID);
+            const auto FSMODE     = PWORKSPACE->m_efFullscreenMode;
+
+            if (!PWINDOWTOCHANGETO->m_bPinned)
+                g_pCompositor->setWindowFullscreen(g_pCompositor->m_pLastWindow, false, FULLSCREEN_FULL);
+
+            g_pCompositor->focusWindow(PWINDOWTOCHANGETO);
+
+            if (!PWINDOWTOCHANGETO->m_bPinned)
+                g_pCompositor->setWindowFullscreen(PWINDOWTOCHANGETO, true, FSMODE);
+        } else {
+            g_pCompositor->focusWindow(PWINDOWTOCHANGETO);
+            Vector2D middle = PWINDOWTOCHANGETO->m_vRealPosition.goalv() + PWINDOWTOCHANGETO->m_vRealSize.goalv() / 2.f;
+            g_pCompositor->warpCursorTo(middle);
+        }
+    };
+
+    switchToWindow(PWINDOWPREV);
+}
+
 void CKeybindManager::moveActiveTo(std::string args) {
     char       arg = args[0];
 
@@ -1129,26 +1275,89 @@ void CKeybindManager::moveActiveTo(std::string args) {
         return;
 
     g_pLayoutManager->getCurrentLayout()->switchWindows(PLASTWINDOW, PWINDOWTOCHANGETO);
+
+    g_pCompositor->warpCursorTo(PLASTWINDOW->m_vRealPosition.vec() + PLASTWINDOW->m_vRealSize.vec() / 2.0);
 }
 
 void CKeybindManager::toggleGroup(std::string args) {
-    SLayoutMessageHeader header;
-    header.pWindow = g_pCompositor->m_pLastWindow;
-    g_pLayoutManager->getCurrentLayout()->layoutMessage(header, "togglegroup");
+    const auto PWINDOW = g_pCompositor->m_pLastWindow;
+
+    if (!PWINDOW)
+        return;
+
+    if (!PWINDOW->m_sGroupData.pNextWindow) {
+        PWINDOW->m_sGroupData.pNextWindow = PWINDOW;
+        PWINDOW->m_sGroupData.head        = true;
+
+        PWINDOW->m_dWindowDecorations.emplace_back(std::make_unique<CHyprGroupBarDecoration>(PWINDOW));
+
+        PWINDOW->updateWindowDecos();
+    } else {
+        if (PWINDOW->m_sGroupData.pNextWindow == PWINDOW) {
+            PWINDOW->m_sGroupData.pNextWindow = nullptr;
+            PWINDOW->updateWindowDecos();
+        } else {
+            // enum all windows, remove their group state, readd to layout.
+            CWindow*              curr = PWINDOW;
+            std::vector<CWindow*> members;
+            do {
+                const auto PLASTWIN                = curr;
+                curr                               = curr->m_sGroupData.pNextWindow;
+                PLASTWIN->m_sGroupData.pNextWindow = nullptr;
+                curr->setHidden(false);
+                members.push_back(curr);
+            } while (curr != PWINDOW);
+
+            for (auto& w : members) {
+                if (w->m_sGroupData.head)
+                    g_pLayoutManager->getCurrentLayout()->onWindowRemoved(curr);
+                w->m_sGroupData.head = false;
+            }
+
+            for (auto& w : members) {
+                g_pLayoutManager->getCurrentLayout()->onWindowCreated(w);
+                w->updateWindowDecos();
+            }
+        }
+    }
+
+    g_pCompositor->updateAllWindowsAnimatedDecorationValues();
 }
 
 void CKeybindManager::changeGroupActive(std::string args) {
-    SLayoutMessageHeader header;
-    header.pWindow = g_pCompositor->m_pLastWindow;
-    if (args == "b")
-        g_pLayoutManager->getCurrentLayout()->layoutMessage(header, "changegroupactiveb");
-    else
-        g_pLayoutManager->getCurrentLayout()->layoutMessage(header, "changegroupactivef");
+    const auto PWINDOW = g_pCompositor->m_pLastWindow;
+
+    if (!PWINDOW)
+        return;
+
+    if (!PWINDOW->m_sGroupData.pNextWindow)
+        return;
+
+    if (PWINDOW->m_sGroupData.pNextWindow == PWINDOW)
+        return;
+
+    if (args != "b" && args != "prev") {
+        PWINDOW->setGroupCurrent(PWINDOW->m_sGroupData.pNextWindow);
+    } else {
+        CWindow* curr = PWINDOW->m_sGroupData.pNextWindow;
+        while (curr->m_sGroupData.pNextWindow != PWINDOW)
+            curr = curr->m_sGroupData.pNextWindow;
+        PWINDOW->setGroupCurrent(curr);
+    }
 }
 
 void CKeybindManager::toggleSplit(std::string args) {
     SLayoutMessageHeader header;
     header.pWindow = g_pCompositor->m_pLastWindow;
+
+    if (!header.pWindow)
+        return;
+
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(header.pWindow->m_iWorkspaceID);
+
+    if (PWORKSPACE->m_bHasFullscreenWindow)
+        return;
+
     g_pLayoutManager->getCurrentLayout()->layoutMessage(header, "togglesplit");
 }
 
@@ -1189,7 +1398,18 @@ void CKeybindManager::focusMonitor(std::string arg) {
     if (!PMONITOR || PMONITOR == g_pCompositor->m_pLastMonitor)
         return;
 
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->activeWorkspace);
+
     changeworkspace("[internal]" + std::to_string(PMONITOR->activeWorkspace));
+
+    // remember last workspace (internal calls don't preserve it)
+
+    const auto PNEWWORKSPACE = g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
+    if (PNEWWORKSPACE == PWORKSPACE)
+        return;
+
+    PNEWWORKSPACE->m_sPrevWorkspace.iID  = PWORKSPACE->m_iID;
+    PNEWWORKSPACE->m_sPrevWorkspace.name = PWORKSPACE->m_szName;
 }
 
 void CKeybindManager::moveCursorToCorner(std::string arg) {
@@ -1261,7 +1481,7 @@ void CKeybindManager::workspaceOpt(std::string args) {
             ptrs.push_back(w.get());
 
         for (auto& w : ptrs) {
-            if (!w->m_bIsMapped || w->m_iWorkspaceID != PWORKSPACE->m_iID)
+            if (!w->m_bIsMapped || w->m_iWorkspaceID != PWORKSPACE->m_iID || w->isHidden())
                 continue;
 
             if (!w->m_bRequestsFloat && w->m_bIsFloating != PWORKSPACE->m_bDefaultFloating) {
@@ -1289,6 +1509,21 @@ void CKeybindManager::workspaceOpt(std::string args) {
     g_pLayoutManager->getCurrentLayout()->recalculateMonitor(g_pCompositor->m_pLastMonitor->ID);
 }
 
+void CKeybindManager::renameWorkspace(std::string args) {
+    try {
+        const auto FIRSTSPACEPOS = args.find_first_of(' ');
+        if (FIRSTSPACEPOS != std::string::npos) {
+            int         workspace = std::stoi(args.substr(0, FIRSTSPACEPOS));
+            std::string name      = args.substr(FIRSTSPACEPOS + 1);
+            g_pCompositor->renameWorkspace(workspace, name);
+        } else {
+            g_pCompositor->renameWorkspace(std::stoi(args), "");
+        }
+    } catch (std::exception& e) {
+        Debug::log(ERR, "Invalid arg in renameWorkspace, expected numeric id only or a numeric id and string name. \"%s\": \"%s\"", args.c_str(), e.what());
+    }
+}
+
 void CKeybindManager::exitHyprland(std::string argz) {
     g_pCompositor->cleanup();
 }
@@ -1441,6 +1676,9 @@ void CKeybindManager::forceRendererReload(std::string args) {
     bool overAgain = false;
 
     for (auto& m : g_pCompositor->m_vMonitors) {
+        if (!m->output)
+            continue;
+
         auto rule = g_pConfigManager->getMonitorRuleFor(m->szName, m->output->description ? m->output->description : "");
         if (!g_pHyprRenderer->applyMonitorRule(m.get(), &rule, true)) {
             overAgain = true;
@@ -1542,7 +1780,7 @@ void CKeybindManager::circleNext(std::string arg) {
     if (!g_pCompositor->m_pLastWindow) {
         // if we have a clear focus, find the first window and get the next focusable.
         if (g_pCompositor->getWindowsOnWorkspace(g_pCompositor->m_pLastMonitor->activeWorkspace) > 0) {
-            const auto PWINDOW = g_pCompositor->getNextWindowOnWorkspace(g_pCompositor->getFirstWindowOnWorkspace(g_pCompositor->m_pLastMonitor->activeWorkspace), true);
+            const auto PWINDOW = g_pCompositor->getFirstWindowOnWorkspace(g_pCompositor->m_pLastMonitor->activeWorkspace);
 
             switchToWindow(PWINDOW);
         }
@@ -1564,6 +1802,11 @@ void CKeybindManager::focusWindow(std::string regexp) {
 
     Debug::log(LOG, "Focusing to window name: %s", PWINDOW->m_szTitle.c_str());
 
+    if (PWINDOW->isHidden() && PWINDOW->m_sGroupData.pNextWindow) {
+        // grouped, change the current to us
+        PWINDOW->setGroupCurrent(PWINDOW);
+    }
+
     g_pCompositor->focusWindow(PWINDOW);
 
     const auto MIDPOINT = PWINDOW->m_vRealPosition.goalv() + PWINDOW->m_vRealSize.goalv() / 2.f;
@@ -1576,6 +1819,7 @@ void CKeybindManager::setSubmap(std::string submap) {
         m_szCurrentSelectedSubmap = "";
         Debug::log(LOG, "Reset active submap to the default one.");
         g_pEventManager->postEvent(SHyprIPCEvent{"submap", ""});
+        EMIT_HOOK_EVENT("submap", m_szCurrentSelectedSubmap);
         return;
     }
 
@@ -1584,6 +1828,7 @@ void CKeybindManager::setSubmap(std::string submap) {
             m_szCurrentSelectedSubmap = submap;
             Debug::log(LOG, "Changed keybind submap to %s", submap.c_str());
             g_pEventManager->postEvent(SHyprIPCEvent{"submap", submap});
+            EMIT_HOOK_EVENT("submap", m_szCurrentSelectedSubmap);
             return;
         }
     }
@@ -1616,9 +1861,9 @@ void CKeybindManager::pass(std::string regexp) {
     // pass all mf shit
     if (!XWTOXW) {
         if (g_pKeybindManager->m_uLastCode != 0)
-            wlr_seat_keyboard_enter(g_pCompositor->m_sSeat.seat, g_pXWaylandManager->getWindowSurface(PWINDOW), KEYBOARD->keycodes, KEYBOARD->num_keycodes, &KEYBOARD->modifiers);
+            wlr_seat_keyboard_enter(g_pCompositor->m_sSeat.seat, PWINDOW->m_pWLSurface.wlr(), KEYBOARD->keycodes, KEYBOARD->num_keycodes, &KEYBOARD->modifiers);
         else
-            wlr_seat_pointer_enter(g_pCompositor->m_sSeat.seat, g_pXWaylandManager->getWindowSurface(PWINDOW), 1, 1);
+            wlr_seat_pointer_enter(g_pCompositor->m_sSeat.seat, PWINDOW->m_pWLSurface.wlr(), 1, 1);
     }
 
     wlr_keyboard_modifiers kbmods = {g_pInputManager->accumulateModsFromAllKBs(), 0, 0, 0};
@@ -1664,7 +1909,7 @@ void CKeybindManager::pass(std::string regexp) {
     if (g_pKeybindManager->m_uLastCode != 0)
         wlr_seat_keyboard_enter(g_pCompositor->m_sSeat.seat, PLASTSRF, KEYBOARD->keycodes, KEYBOARD->num_keycodes, &KEYBOARD->modifiers);
     else
-        wlr_seat_pointer_enter(g_pCompositor->m_sSeat.seat, g_pXWaylandManager->getWindowSurface(PWINDOW), SL.x, SL.y);
+        wlr_seat_pointer_enter(g_pCompositor->m_sSeat.seat, PWINDOW->m_pWLSurface.wlr(), SL.x, SL.y);
 }
 
 void CKeybindManager::layoutmsg(std::string msg) {
@@ -1679,7 +1924,7 @@ void CKeybindManager::toggleOpaque(std::string unused) {
         return;
 
     PWINDOW->m_sAdditionalConfigData.forceOpaque          = !PWINDOW->m_sAdditionalConfigData.forceOpaque;
-    PWINDOW->m_sAdditionalConfigData.forceOpaqueOverriden = true;
+    PWINDOW->m_sAdditionalConfigData.forceOpaqueOverridden = true;
 
     g_pHyprRenderer->damageWindow(PWINDOW);
 }
@@ -1760,16 +2005,30 @@ void CKeybindManager::swapActiveWorkspaces(std::string args) {
 }
 
 void CKeybindManager::pinActive(std::string args) {
-    if (!g_pCompositor->m_pLastWindow || !g_pCompositor->m_pLastWindow->m_bIsFloating || g_pCompositor->m_pLastWindow->m_bIsFullscreen)
+
+    CWindow* PWINDOW = nullptr;
+
+    if (args != "" && args != "active" && args.length() > 1) {
+        PWINDOW = g_pCompositor->getWindowByRegex(args);
+    } else {
+        PWINDOW = g_pCompositor->m_pLastWindow;
+    }
+
+    if (!PWINDOW) {
+        Debug::log(ERR, "pin: window not found");
+        return;
+    }
+
+    if (!PWINDOW->m_bIsFloating || PWINDOW->m_bIsFullscreen)
         return;
 
-    g_pCompositor->m_pLastWindow->m_bPinned      = !g_pCompositor->m_pLastWindow->m_bPinned;
-    g_pCompositor->m_pLastWindow->m_iWorkspaceID = g_pCompositor->getMonitorFromID(g_pCompositor->m_pLastWindow->m_iMonitorID)->activeWorkspace;
+    PWINDOW->m_bPinned      = !PWINDOW->m_bPinned;
+    PWINDOW->m_iWorkspaceID = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID)->activeWorkspace;
 
-    g_pCompositor->m_pLastWindow->updateDynamicRules();
-    g_pCompositor->updateWindowAnimatedDecorationValues(g_pCompositor->m_pLastWindow);
+    PWINDOW->updateDynamicRules();
+    g_pCompositor->updateWindowAnimatedDecorationValues(PWINDOW);
 
-    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastWindow->m_iWorkspaceID);
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID);
 
     PWORKSPACE->m_pLastFocusedWindow = g_pCompositor->vectorToWindowTiled(g_pInputManager->getMouseCoordsInternal());
 }
@@ -1823,6 +2082,60 @@ void CKeybindManager::bringActiveToTop(std::string args) {
 void CKeybindManager::fakeFullscreenActive(std::string args) {
     if (g_pCompositor->m_pLastWindow) {
         // will also set the flag
-        g_pXWaylandManager->setWindowFullscreen(g_pCompositor->m_pLastWindow, !g_pCompositor->m_pLastWindow->m_bInFullscreenReported);
+        g_pCompositor->m_pLastWindow->m_bFakeFullscreenState = !g_pCompositor->m_pLastWindow->m_bFakeFullscreenState;
+        g_pXWaylandManager->setWindowFullscreen(g_pCompositor->m_pLastWindow,
+                                                g_pCompositor->m_pLastWindow->m_bFakeFullscreenState || g_pCompositor->m_pLastWindow->m_bIsFullscreen);
     }
 }
+
+void CKeybindManager::lockGroups(std::string args) {
+    if (args == "lock" || args.empty() || args == "lockgroups") {
+        g_pKeybindManager->m_bGroupsLocked = true;
+    } else if (args == "toggle") {
+        g_pKeybindManager->m_bGroupsLocked = !g_pKeybindManager->m_bGroupsLocked;
+    } else {
+        g_pKeybindManager->m_bGroupsLocked = false;
+    }
+}
+
+void CKeybindManager::moveIntoGroup(std::string args) {
+    char arg = args[0];
+
+    if (!isDirection(args)) {
+        Debug::log(ERR, "Cannot move into group in direction %c, unsupported direction. Supported: l,r,u/t,d/b", arg);
+        return;
+    }
+
+    const auto PWINDOW = g_pCompositor->m_pLastWindow;
+
+    if (!PWINDOW || PWINDOW->m_bIsFloating)
+        return;
+
+    const auto PWINDOWINDIR = g_pCompositor->getWindowInDirection(PWINDOW, arg);
+
+    if (!PWINDOWINDIR || !PWINDOWINDIR->m_sGroupData.pNextWindow)
+        return;
+
+    g_pLayoutManager->getCurrentLayout()->onWindowRemoved(PWINDOW);
+
+    PWINDOWINDIR->insertWindowToGroup(PWINDOW);
+
+    PWINDOW->m_dWindowDecorations.emplace_back(std::make_unique<CHyprGroupBarDecoration>(PWINDOW));
+}
+
+void CKeybindManager::moveOutOfGroup(std::string args) {
+    const auto PWINDOW = g_pCompositor->m_pLastWindow;
+
+    if (!PWINDOW || !PWINDOW->m_sGroupData.pNextWindow)
+        return;
+
+    g_pLayoutManager->getCurrentLayout()->onWindowRemoved(PWINDOW);
+
+    const auto GROUPSLOCKEDPREV = g_pKeybindManager->m_bGroupsLocked;
+
+    g_pKeybindManager->m_bGroupsLocked = true;
+
+    g_pLayoutManager->getCurrentLayout()->onWindowCreated(PWINDOW);
+
+    g_pKeybindManager->m_bGroupsLocked = GROUPSLOCKEDPREV;
+}

src/managers/KeybindManager.hpp

@@ -8,6 +8,7 @@
 
 class CInputManager;
 class CConfigManager;
+class CPluginSystem;
 
 struct SKeybind {
     std::string key     = "";
@@ -25,7 +26,8 @@ struct SKeybind {
     bool shadowed = false;
 };
 
-enum eFocusWindowMode {
+enum eFocusWindowMode
+{
     MODE_CLASS_REGEX = 0,
     MODE_TITLE_REGEX,
     MODE_ADDRESS,
@@ -39,7 +41,10 @@ class CKeybindManager {
     bool                                                              onKeyEvent(wlr_keyboard_key_event*, SKeyboard*);
     bool                                                              onAxisEvent(wlr_pointer_axis_event*);
     bool                                                              onMouseEvent(wlr_pointer_button_event*);
+    void                                                              resizeWithBorder(wlr_pointer_button_event*);
     void                                                              onSwitchEvent(const std::string&);
+    void                                                              onSwitchOnEvent(const std::string&);
+    void                                                              onSwitchOffEvent(const std::string&);
 
     void                                                              addKeybind(SKeybind);
     void                                                              removeKeybind(uint32_t, const std::string&);
@@ -51,8 +56,11 @@ class CKeybindManager {
 
     wl_event_source*                                                  m_pActiveKeybindEventSource = nullptr;
 
+    bool                                                              m_bGroupsLocked = false;
+
+    std::list<SKeybind>                                               m_lKeybinds;
+
   private:
-    std::list<SKeybind>       m_lKeybinds;
     std::deque<xkb_keysym_t>  m_dPressedKeysyms;
     std::deque<int>           m_dPressedKeycodes;
 
@@ -83,47 +91,54 @@ class CKeybindManager {
     bool                      ensureMouseBindState();
 
     // -------------- Dispatchers -------------- //
-    static void killActive(std::string);
-    static void kill(std::string);
-    static void spawn(std::string);
-    static void toggleActiveFloating(std::string);
-    static void toggleActivePseudo(std::string);
-    static void changeworkspace(std::string);
-    static void fullscreenActive(std::string);
-    static void fakeFullscreenActive(std::string);
-    static void moveActiveToWorkspace(std::string);
-    static void moveActiveToWorkspaceSilent(std::string);
-    static void moveFocusTo(std::string);
-    static void centerWindow(std::string);
-    static void moveActiveTo(std::string);
-    static void toggleGroup(std::string);
-    static void changeGroupActive(std::string);
-    static void alterSplitRatio(std::string);
-    static void focusMonitor(std::string);
-    static void toggleSplit(std::string);
-    static void moveCursorToCorner(std::string);
-    static void workspaceOpt(std::string);
-    static void exitHyprland(std::string);
-    static void moveCurrentWorkspaceToMonitor(std::string);
-    static void moveWorkspaceToMonitor(std::string);
-    static void toggleSpecialWorkspace(std::string);
-    static void forceRendererReload(std::string);
-    static void resizeActive(std::string);
-    static void moveActive(std::string);
-    static void moveWindow(std::string);
-    static void resizeWindow(std::string);
-    static void circleNext(std::string);
-    static void focusWindow(std::string);
-    static void setSubmap(std::string);
-    static void pass(std::string);
-    static void layoutmsg(std::string);
-    static void toggleOpaque(std::string);
-    static void dpms(std::string);
-    static void swapnext(std::string);
-    static void swapActiveWorkspaces(std::string);
-    static void pinActive(std::string);
-    static void mouse(std::string);
-    static void bringActiveToTop(std::string);
+    static void     killActive(std::string);
+    static void     kill(std::string);
+    static void     spawn(std::string);
+    static uint64_t spawnRaw(std::string);
+    static void     toggleActiveFloating(std::string);
+    static void     toggleActivePseudo(std::string);
+    static void     changeworkspace(std::string);
+    static void     fullscreenActive(std::string);
+    static void     fakeFullscreenActive(std::string);
+    static void     moveActiveToWorkspace(std::string);
+    static void     moveActiveToWorkspaceSilent(std::string);
+    static void     moveFocusTo(std::string);
+    static void     focusUrgentOrLast(std::string);
+    static void     focusCurrentOrLast(std::string);
+    static void     centerWindow(std::string);
+    static void     moveActiveTo(std::string);
+    static void     toggleGroup(std::string);
+    static void     changeGroupActive(std::string);
+    static void     alterSplitRatio(std::string);
+    static void     focusMonitor(std::string);
+    static void     toggleSplit(std::string);
+    static void     moveCursorToCorner(std::string);
+    static void     workspaceOpt(std::string);
+    static void     renameWorkspace(std::string);
+    static void     exitHyprland(std::string);
+    static void     moveCurrentWorkspaceToMonitor(std::string);
+    static void     moveWorkspaceToMonitor(std::string);
+    static void     toggleSpecialWorkspace(std::string);
+    static void     forceRendererReload(std::string);
+    static void     resizeActive(std::string);
+    static void     moveActive(std::string);
+    static void     moveWindow(std::string);
+    static void     resizeWindow(std::string);
+    static void     circleNext(std::string);
+    static void     focusWindow(std::string);
+    static void     setSubmap(std::string);
+    static void     pass(std::string);
+    static void     layoutmsg(std::string);
+    static void     toggleOpaque(std::string);
+    static void     dpms(std::string);
+    static void     swapnext(std::string);
+    static void     swapActiveWorkspaces(std::string);
+    static void     pinActive(std::string);
+    static void     mouse(std::string);
+    static void     bringActiveToTop(std::string);
+    static void     lockGroups(std::string);
+    static void     moveIntoGroup(std::string);
+    static void     moveOutOfGroup(std::string);
 
     friend class CCompositor;
     friend class CInputManager;