do updates on every mon update if VFR is enabled

Fixes #298

.github/FUNDING.yml

@@ -0,0 +1 @@
+ko_fi: vaxry

.github/ISSUE_TEMPLATE/bug_report.md

@@ -3,13 +3,10 @@ name: Bug report
 about: Found a bug? Report it here!
 title: ''
 labels: bug
+assignees: ''
 
 ---
 
-**Describe the bug**
-
-
-**Images/videos/anything that would help**
-
-
-Please attach a log (it's in /tmp/hypr/hyprland.log) and, if crashing, a crashdump (coredumpctl, then coredumpctl info <pid>)
+Please consult the issue guidelines at
+https://github.com/vaxerski/Hyprland/blob/main/docs/ISSUE_GUIDELINES.md
+BEFORE submitting.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -3,7 +3,10 @@ name: Feature request
 about: Suggest a feature/change/idea
 title: ''
 labels: enhancement
+assignees: ''
 
 ---
 
-**Describe in detail your idea.**
+Please consult the issue guidelines at
+https://github.com/vaxerski/Hyprland/blob/main/docs/ISSUE_GUIDELINES.md
+BEFORE submitting.

.github/pull_request_template.md

@@ -1,9 +1,9 @@
-Describe your PR, what does it fix/add?
+#### Describe your PR, what does it fix/add?
 
 
-Is there anything you want to mention? (unchecked code, possible bugs, found problems, breaking compatibility, etc.)
+#### Is there anything you want to mention? (unchecked code, possible bugs, found problems, breaking compatibility, etc.)
 
 
-Is it ready for merging, or does it need work?
+#### Is it ready for merging, or does it need work?
 
 

.github/workflows/ci.yaml

@@ -13,29 +13,73 @@ jobs:
            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
-
       - 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
         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 .."
-
       - name: Fix permissions for git
         run: |
           git config --global --add safe.directory /__w/Hyprland/Hyprland
-
       - name: Checkout Hyprland
         uses: actions/checkout@v3
-
-      - name: Build Hyprland With default settings
+        with:
+          submodules: recursive
+      - name: Build Hyprland
         run: |
           git submodule sync --recursive && git submodule update --init --force --recursive
           make all
-
-      - name: Build Hyprland with LEGACY_RENDERER
+      - name: Compress and package artifacts
         run: |
-          make legacyrenderer
+          mkdir x86_64-pc-linux-gnu
+          mkdir hyprland
+          mkdir hyprland/example
+          mkdir hyprland/assets
+          cp ./LICENSE hyprland/
+          cp build/Hyprland hyprland/
+          cp hyprctl/hyprctl hyprland/
+          cp subprojects/wlroots/build/libwlroots.so.11032 hyprland/
+          cp build/Hyprland hyprland/
+          cp -r example/ hyprland/
+          cp -r assets/ hyprland/
+          tar -cvf Hyprland.tar.xz hyprland
+      - name: Release
+        uses: actions/upload-artifact@v3
+        with:
+          name: Build archive
+          path: Hyprland.tar.xz
+
+  meson:
+    name: "Build Hyprland with Meson (Arch)"
+    runs-on: ubuntu-latest
+    container:
+      image: archlinux
+    steps:
+      - name: Download dependencies
+        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 go clang lld libc++ pkgconf meson ninja wayland wayland-protocols libinput libxkbcommon pixman glm libdrm libglvnd cairo pango systemd scdoc base-devel seatd
+      - name: Checkout Hyprland
+        uses: actions/checkout@v3
+        with:
+          submodules: true
+      - name: Configure
+        run: |
+          meson obj-x86_64-pc-linux-gnu \
+            -Ddefault_library=static
+      - name: Compile
+        run: ninja -C obj-x86_64-pc-linux-gnu
+#       - name: Compress artifacts
+#         run: |
+#           mkdir x86_64-pc-linux-gnu
+#           DESTDIR=$PWD/x86_64-pc-linux-gnu meson install -C obj-x86_64-pc-linux-gnu --tags runtime
+#           tar -cvf x86_64-pc-linux-gnu.tar.xz x86_64-pc-linux-gnu
+#       - name: Upload artifacts
+#         uses: actions/upload-artifact@v3
+#         with:
+#           name: Build artifacts (x86_64-pc-linux-gnu)
+#           path: x86_64-pc-linux-gnu.tar.xz

.github/workflows/nix-build.yaml

@@ -8,6 +8,8 @@ jobs:
     steps:
     - name: Clone repository
       uses: actions/checkout@v3
+      with:
+        submodules: recursive
     - name: Install nix
       uses: cachix/install-nix-action@v17
       with:

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

@@ -0,0 +1,26 @@
+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

@@ -1,9 +1,6 @@
 name: "Nix: update lockfile"
 
-on:
-  schedule:
-    - cron: '0 0 */14 * *'
-  workflow_dispatch:
+on: [push, workflow_dispatch]
 
 jobs:
   update:
@@ -19,7 +16,7 @@ jobs:
           auto-optimise-store = true
           experimental-features = nix-command flakes
     - name: Update lockfile
-      run: nix flake update
+      run: nix/update-inputs.sh
     - uses: stefanzweifel/git-auto-commit-action@v4
       with:
         commit_message: "[gha] bump flake inputs"

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "wlroots"]
+	path = subprojects/wlroots
+	url = https://gitlab.freedesktop.org/wlroots/wlroots.git

CMakeLists.txt

@@ -35,13 +35,14 @@ execute_process(
 #
 #
 
-include_directories(.)
+include_directories(. PRIVATE "subprojects/wlroots/include/")
+include_directories(. PRIVATE "subprojects/wlroots/build/include/")
 add_compile_options(-std=c++20 -DWLR_USE_UNSTABLE )
 add_compile_options(-Wall -Wextra -Wno-unused-parameter -Wno-unused-value -Wno-missing-field-initializers -Wno-narrowing)
 find_package(Threads REQUIRED)
 
 find_package(PkgConfig REQUIRED)
-pkg_check_modules(deps REQUIRED IMPORTED_TARGET wayland-server wayland-client wayland-cursor wayland-protocols cairo pango pangocairo libdrm egl xkbcommon wlroots libinput xcb)
+pkg_check_modules(deps REQUIRED IMPORTED_TARGET wayland-server wayland-client wayland-cursor wayland-protocols cairo pango pangocairo libdrm egl xkbcommon libinput xcb) # we do not check for wlroots, as we provide it ourselves
 
 file(GLOB_RECURSE SRCFILES "src/*.cpp")
 
@@ -59,8 +60,9 @@ ENDIF(NO_XWAYLAND MATCHES true)
 
 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) # may crash for some
+    add_compile_options( -O3 )
     message(STATUS "Configuring Hyprland in Release with CMake!")
 ENDIF(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
 
@@ -78,7 +80,7 @@ include(CPack)
 target_link_libraries(Hyprland PkgConfig::deps)
 
 target_link_libraries(Hyprland
-        wlroots
+        ${CMAKE_SOURCE_DIR}/subprojects/wlroots/build/libwlroots.so.11032 # wlroots is provided by us
         pixman-1
         OpenGL
         GLESv2

Makefile

@@ -59,6 +59,16 @@ pointer-constraints-unstable-v1-protocol.c:
 
 pointer-constraints-unstable-v1-protocol.o: pointer-constraints-unstable-v1-protocol.h
 
+tablet-unstable-v2-protocol.h:
+	$(WAYLAND_SCANNER) server-header \
+		protocols/tablet-unstable-v2.xml $@
+
+tablet-unstable-v2-protocol.c:
+	$(WAYLAND_SCANNER) private-code \
+		protocols/tablet-unstable-v2.xml $@
+
+tablet-unstable-v2-protocol.o: tablet-unstable-v2-protocol.h
+
 idle-protocol.h:
 	$(WAYLAND_SCANNER) server-header \
 		protocols/idle.xml $@
@@ -89,6 +99,7 @@ clear:
 	rm -rf build
 	rm -f *.o *-protocol.h *-protocol.c
 	rm -f ./hyprctl/hyprctl
+	rm -rf ./subprojects/wlroots/build
 
 all:
 	make config
@@ -96,6 +107,10 @@ all:
 	cd ./hyprctl && make all && cd ..
 
 install:
+	[ ! -d /usr/include/wlr ] || mv /usr/include/wlr /usr/include/wlrBackup
+	[ ! -f /usr/lib/libwlroots.so ] || mv /usr/lib/libwlroots.so /usr/lib/libwlroots.so.backup
+	[ ! -f /usr/lib/pkgconfig/wlroots.pc ] || mv /usr/lib/pkgconfig/wlroots.pc /usr/lib/pkgconfig/wlroots.pc.backup
+
 	make all
 	mkdir -p ${PREFIX}/share/wayland-sessions
 	cp ./example/hyprland.desktop ${PREFIX}/share/wayland-sessions/
@@ -107,10 +122,33 @@ install:
 	cp ./assets/wall_4K.png ${PREFIX}/share/hyprland
 	cp ./assets/wall_8K.png ${PREFIX}/share/hyprland
 
+	rm -rf /usr/include/wlr
+	rm -f /usr/lib/libwlroots.so
+	rm -f /usr/lib/pkgconfig/wlroots.pc
+	[ ! -d /usr/include/wlrBackup ] || mv /usr/include/wlrBackup /usr/include/wlr
+	[ ! -f /usr/lib/libwlroots.so.backup ] || mv -f /usr/lib/libwlroots.so.backup /usr/lib/libwlroots.so
+	[ ! -f /usr/lib/pkgconfig/wlroots.pc.backup ] || mv -f /usr/lib/pkgconfig/wlroots.pc.backup /usr/lib/pkgconfig/wlroots.pc
+
 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.11032
 	rm -rf ${PREFIX}/share/hyprland
 
-config: 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
+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
+
+fixwlr:
+	sed -i -E 's/(soversion = 11)([^032]|$$)/soversion = 11032/g' subprojects/wlroots/meson.build
+
+	rm -rf ./subprojects/wlroots/build
+
+config:
+	make protocols
+
+	make fixwlr
+
+	cd subprojects/wlroots && meson ./build --prefix=/usr --buildtype=release
+	cd subprojects/wlroots && ninja -C build/
+
+	cd subprojects/wlroots && ninja -C build/ install

README.md

@@ -1,6 +1,6 @@
 <div align = center>
 
-![Banner]
+<img src="https://raw.githubusercontent.com/vaxerski/Hyprland/main/assets/header.svg" width="1000" height="500" alt="banner">
 
 <br>
 
@@ -19,6 +19,7 @@ Hyprland is a dynamic tiling Wayland compositor based on wlroots that doesn't sa
 
 For Hyprland without the `land` part, see [Hypr], the Xorg window manager.
 
+Please note, especially for folks moving from Hypr, that Hyprland and Hypr share a very different feature set and are not 1:1 experiences.
 <br>
 <br>
 
@@ -37,10 +38,9 @@ For Hyprland without the `land` part, see [Hypr], the Xorg window manager.
  
 # Notice
 
-This project is still in its early development, expect bugs.
-
-Once you get it working though, it's pretty stable.<br/>
+Hyprland is still in pretty early development compared to some other Wayland compositors.
 
+Although Hyprland is pretty stable, it may have some bugs.
 
 ### Help Wanted
 
@@ -51,18 +51,24 @@ Try it out and report bugs / suggestions!
 
 - Easily expandable and readable codebase
 - Config reloaded instantly upon saving
-- Bezier-curve window animations
 - Custom bezier curve based animations
-- Workspaces protocol support
+- `wlr_ext` workspaces protocol support
 - Dual Kawase blur
-- Window fade in / out
-- Tiling / floating / fullscreen windows
-- Window / monitor rules
+- Drop shadows
+- Fully dynamic workspaces
+- Closely follows `wlroots-git`
+- Bundled wlroots
+- Window/layer fade in/out
+- Tiling/pseudotiling/floating/fullscreen windows
+- Switching workspaces between window modes on the fly
+- Special workspace (scratchpad)
+- Window/monitor rules
 - Socket-based IPC
+- Event system for bash scripts
 - Rounded corners
-- Damage tracking ( *Experimental* )
-- Moving / resizing
+- Full damage tracking
 - Docks support
+- Drawing tablet support
 
 <br>
 <br>
@@ -125,7 +131,7 @@ Try it out and report bugs / suggestions!
 [Issues]: https://github.com/vaxerski/Hyprland/issues
 [Todo]: https://github.com/vaxerski/Hyprland/projects?type=beta
 
-[Contribute]: docs/Contribute.md
+[Contribute]: https://github.com/vaxerski/Hyprland/wiki/Contributing-&-Debugging
 [Install]: https://github.com/vaxerski/Hyprland/wiki/Installation
 [Quick Start]: https://github.com/vaxerski/Hyprland/wiki/Quick-start
 [License]: LICENSE
@@ -146,7 +152,6 @@ Try it out and report bugs / suggestions!
 [Preview A]: https://i.imgur.com/NbrTnZH.png
 [Preview B]: https://i.imgur.com/ZA4Fa8R.png
 [Preview C]: https://i.imgur.com/BpXxM8H.png
-[Banner]: https://raw.githubusercontent.com/vaxerski/Hyprland/main/assets/hyprland.png
 
 
 <!----------------------------------{ Badges }--------------------------------->

assets/meson.build

@@ -0,0 +1,5 @@
+wallpapers = ['wall_2K.png', 'wall_4K.png', 'wall_8K.png']
+
+foreach wallpaper : wallpapers
+  install_data(wallpapers, install_dir: join_paths(get_option('datadir'), 'hyprland'), install_tag: 'runtime')
+endforeach

aur/PKGBUILD

@@ -1,32 +0,0 @@
-# Maintainer: ThatOneCalculator <kainoa@t1c.dev>
-
-_pkgname="hyprland"
-pkgname="${_pkgname}"
-pkgver="0.1.1beta"
-pkgrel=2
-pkgdesc="Hyprland is a dynamic tiling Wayland compositor based on wlroots that doesn't sacrifice on its looks."
-arch=(any)
-url="https://github.com/vaxerski/Hyprland"
-license=('BSD')
-depends=(libxcb xcb-proto xcb-util xcb-util-keysyms libxfixes libx11 libxcomposite xorg-xinput libxrender pixman wayland-protocols wlroots-git cairo pango)
-makedepends=(git cmake ninja gcc gdb)
-source=("${pkgname}-${pkgver}.tar.gz::https://github.com/vaxerski/hyprland/archive/v${pkgver}.tar.gz")
-sha256sums=('SKIP')
-options=(!makeflags !buildflags)
-
-build() {
-	cd "$srcdir/Hyprland-$pkgver"
-	make all
-}
-
-package() {
-	cd "$srcdir/Hyprland-$pkgver"
-	mkdir -p "${pkgdir}/usr/share/wayland-sessions"
-	mkdir -p "${pkgdir}/usr/share/hyprland"
-	install -Dm755 build/Hyprland -t "${pkgdir}/usr/bin"
-	install -Dm755 hyprctl/hyprctl -t "${pkgdir}/usr/bin"
-	install -Dm644 assets/*.png -t "${pkgdir}/usr/share/hyprland"
-	install -Dm644 example/hyprland.desktop -t "${pkgdir}/usr/share/wayland-sessions"
-	install -Dm644 example/hyprland.conf -t "${pkgdir}/usr/share/hyprland"
-	install -Dm644 LICENSE -t "${pkgdir}/usr/share/licenses/${_pkgname}"
-}

aur/PKGBUILD-git

@@ -1,40 +0,0 @@
-# Maintainer: ThatOneCalculator <kainoa@t1c.dev>, Sander van Kasteel <info@sandervankasteel.nl>
-
-_pkgname="hyprland"
-pkgname="${_pkgname}-git"
-pkgver=r568.g632d00c
-pkgrel=1
-pkgdesc="Hyprland is a dynamic tiling Wayland compositor based on wlroots that doesn't sacrifice on its looks."
-arch=(any)
-url="https://github.com/vaxerski/Hyprland"
-license=('BSD')
-depends=(libxcb xcb-proto xcb-util xcb-util-keysyms libxfixes libx11 libxcomposite xorg-xinput libxrender pixman wayland-protocols wlroots-git cairo pango)
-makedepends=(git cmake ninja gcc gdb)
-source=("${_pkgname}::git+https://github.com/vaxerski/Hyprland.git")
-sha256sums=('SKIP')
-options=(!makeflags !buildflags)
-
-pkgver() {
-  cd "$_pkgname"
-  ( set -o pipefail
-    git describe --long 2>/dev/null | sed 's/\([^-]*-g\)/r\1/;s/-/./g' ||
-    printf "r%s.%s" "$(git rev-list --count HEAD)" "$(git rev-parse --short HEAD)"
-  )
-}
-
-build() {
-	cd "${srcdir}/${_pkgname}"
-	make all
-}
-
-package() {
-	cd "${srcdir}/${_pkgname}"
-	mkdir -p "${pkgdir}/usr/share/wayland-sessions"
-	mkdir -p "${pkgdir}/usr/share/hyprland"
-	install -Dm755 build/Hyprland -t "${pkgdir}/usr/bin"
-	install -Dm755 hyprctl/hyprctl -t "${pkgdir}/usr/bin"
-	install -Dm644 assets/*.png -t "${pkgdir}/usr/share/hyprland"
-	install -Dm644 example/hyprland.desktop -t "${pkgdir}/usr/share/wayland-sessions"
-	install -Dm644 example/hyprland.conf -t "${pkgdir}/usr/share/hyprland"
-	install -Dm644 LICENSE -t "${pkgdir}/usr/share/licenses/${_pkgname}"
-}

docs/Contribute.md

@@ -1,32 +0,0 @@
-
-# Contributing
-
-*Thank you for considering contributing to Hyprland.*
-
-## Development
-
-Check the [Wiki] for debugging instructions.
-
-Afterwards, pick yourself an [Issue] or implement your own suggestion.
-
-An good place to search for things to contribute is the [Projects Page]
-
-*As Hyprland is still in its early stages of development, I'd recommend you stick to bug fixes first.*
-
-## Pull Requests
-
-- Please follow the code style
-
-- Code must be readable
-
-- Features should be useful
-
-- Test your changes!
-
-  *Run it on bare metal and check if everything works.*
-
-<!----------------------------------------------------------------------------->
-
-[Issue]: https://github.com/vaxerski/Hyprland/issues
-[Wiki]: https://github.com/vaxerski/Hyprland/wiki/Contributing-&-Debugging
-[Projects page]: https://github.com/vaxerski/Hyprland/projects?type=beta

docs/ISSUE_GUIDELINES.md

@@ -0,0 +1,58 @@
+# Issue Guidelines
+
+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)
+
+<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.
+
+<br/>
+
+# Reporting bugs
+
+All bug reports should have the following:
+- Steps to reproduce
+- Expected outcome
+- Noted outcome
+
+If your bug is one that doesn't crash Hyprland, but feels like invalid behavior, that's all you need to say.
+
+If your bug crashes Hyprland, append additionally:
+- The Hyprland log
+- Coredump / Coredump analysis (with a stacktrace)
+
+**Important**: Please do NOT use any package for reporting bugs! Clone and compile from source.
+
+## Obtaining the Hyprland log
+If you are in a TTY, and the hyprland session that crashed was the last one you launched, the log will be printed with
+```
+cat /tmp/hypr/$(ls -t /tmp/hypr/ | head -n 1)/hyprland.log
+```
+feel free to send it to a file, save, copy, etc.
+
+if you are in a Hyprland session, and you want the log of the last session, use
+```
+cat /tmp/hypr/$(ls -t /tmp/hypr/ | head -n 2 | tail -n 1)/hyprland.log
+```
+
+basically, directories in /tmp/hypr are your sessions.
+
+## Obtaining the Hyprland coredump
+If you are on systemd, you can simply use
+```
+coredumpctl
+```
+then go to the end (press END on your keyboard) and remember the PID of the last `Hyprland` occurrence. It's the first number after the time, for example `2891`.
+
+exit coredumpctl (ctrl+c) and use
+```
+coredumpctl info [PID]
+```
+where `[PID]` is the PID you remembered.
+

docs/Install.md

@@ -1,35 +0,0 @@
-
-# Installation
-
-## Packages
-
-*I do not maintain any packages, but some kind people have made them for me.*
-
-**If I missed any, please let me know.**
-
-## Notice
-
-Since I am not the maintainer, I cannot guarantee that those packages will always work and be up to date.
-
-***Use at your own disclosure.*** <br>
-*If they don't work, try building manually.*
-
-#### Arch ( AUR / -git )
-
-```sh
-yay -S hyprland-git
-```
-
----
-
-
-## Building / No XWayland / other
-
-If your distro doesn't have **Hyprland** in its repositories, you want to modify it, or use custom build flags, please refer to the **[Wiki Page][Install]** for the installation instructions.
-
-
-<!----------------------------------------------------------------------------->
-
-[Install]: https://github.com/vaxerski/Hyprland/wiki/Installation
-
-

example/hyprland.conf

@@ -17,8 +17,7 @@ input {
 }
 
 general {
-    max_fps=60 # deprecated, unused
-    sensitivity=0.25
+    sensitivity=1.0 # for mouse cursor
     main_mod=SUPER
 
     gaps_in=5
@@ -27,7 +26,9 @@ general {
     col.active_border=0x66ee1111
     col.inactive_border=0x66333333
 
-    damage_tracking=full # experimental, monitor is 100% fine, but full might have some minor bugs, especially with high blur settings!
+    apply_sens_to_raw=0 # whether to apply the sensitivity to raw input (e.g. used by games where you aim using your mouse)
+
+    damage_tracking=full # leave it on full unless you hate your GPU and want to make it suffer
 }
 
 decoration {
@@ -95,4 +96,4 @@ bind=ALT,6,movetoworkspace,6
 bind=ALT,7,movetoworkspace,7
 bind=ALT,8,movetoworkspace,8
 bind=ALT,9,movetoworkspace,9
-bind=ALT,0,movetoworkspace,10
+bind=ALT,0,movetoworkspace,10

example/meson.build

@@ -0,0 +1,2 @@
+install_data('hyprland.conf', install_dir: join_paths(get_option('datadir'), 'hyprland'), install_tag: 'runtime')
+install_data('hyprland.desktop', install_dir: join_paths(get_option('datadir'), 'wayland-sessions'), install_tag: 'runtime')

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1653581809,
-        "narHash": "sha256-Uvka0V5MTGbeOfWte25+tfRL3moECDh1VwokWSZUdoY=",
+        "lastModified": 1656239181,
+        "narHash": "sha256-wW1xRFBn376yGloXZ4QzBE4hjipMawpV18Lshd9QSPw=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "83658b28fe638a170a19b8933aa008b30640fbd1",
+        "rev": "f2537a505d45c31fe5d9c27ea9829b6f4c4e6ac5",
         "type": "github"
       },
       "original": {
@@ -26,11 +26,11 @@
       "flake": false,
       "locked": {
         "host": "gitlab.freedesktop.org",
-        "lastModified": 1653733431,
-        "narHash": "sha256-0JwNH2E9XlMVa7ZCsqxazpKwpZ2rW5QQjbk0DdZxa48=",
+        "lastModified": 1655824477,
+        "narHash": "sha256-1kskHOLsnisR3kqIL5IHrQbQG/4xoXxeEf1ExMV6/RU=",
         "owner": "wlroots",
         "repo": "wlroots",
-        "rev": "93ee4c7684050807e959bb3b6d57826a72fba8c2",
+        "rev": "5c4384a1330faedf975c8b8644881d50390f3613",
         "type": "gitlab"
       },
       "original": {

flake.nix

@@ -16,40 +16,41 @@
   }: let
     inherit (nixpkgs) lib;
     genSystems = lib.genAttrs [
+      # Add more systems if they are supported
       "x86_64-linux"
     ];
     pkgsFor = nixpkgs.legacyPackages;
-    # https://github.com/NixOS/rfcs/pull/107
-    mkVersion = longDate:
-      lib.concatStrings [
-        "0.pre"
-        "+date="
-        (lib.concatStringsSep "-" [
-          (__substring 0 4 longDate)
-          (__substring 4 2 longDate)
-          (__substring 6 2 longDate)
-        ])
-      ];
+    mkDate = longDate: (lib.concatStringsSep "-" [
+      (__substring 0 4 longDate)
+      (__substring 4 2 longDate)
+      (__substring 6 2 longDate)
+    ]);
   in {
-    packages = genSystems (system: {
-      wlroots = pkgsFor.${system}.wlroots.overrideAttrs (prev: {
-        version = mkVersion inputs.wlroots.lastModifiedDate;
+    overlays.default = _: prev: rec {
+      wlroots-hyprland = prev.wlroots.overrideAttrs (__: {
+        version = mkDate (inputs.wlroots.lastModifiedDate or "19700101");
         src = inputs.wlroots;
       });
-      default = pkgsFor.${system}.callPackage ./default.nix {
-        version = mkVersion self.lastModifiedDate;
-        inherit (self.packages.${system}) wlroots;
+      hyprland = prev.callPackage ./nix/default.nix {
+        version = "0.6.2beta" + "+date=" + (mkDate (self.lastModifiedDate or "19700101"));
+        wlroots = wlroots-hyprland;
       };
-    });
+      hyprland-debug = hyprland.override {debug = true;};
+      waybar-hyprland = prev.waybar.overrideAttrs (oldAttrs: {
+        mesonFlags = oldAttrs.mesonFlags ++ ["-Dexperimental=true"];
+      });
+    };
+
+    packages = genSystems (system:
+      (self.overlays.default null pkgsFor.${system})
+      // {
+        default = self.packages.${system}.hyprland;
+      });
 
     formatter = genSystems (system: pkgsFor.${system}.alejandra);
 
-    nixosModules.default = import ./module.nix self;
+    nixosModules.default = import ./nix/module.nix self;
 
-    # Deprecated
-    overlays.default = _: prev: {
-      hyprland = self.packages.${prev.system}.default;
-    };
-    overlay = self.overlays.default;
+    overlay = throw "Hyprland: .overlay output is deprecated, please use the .overlays.default output";
   };
 }

hyprctl/Makefile

@@ -1,4 +1,4 @@
-clean:
-	rm -rf ./hyprctl ./hyprctl
 all:
-	g++ -std=c++20 ./main.cpp -o ./hyprctl
+	g++ -std=c++20 ./main.cpp -o ./hyprctl
+clean:
+	rm ./hyprctl

hyprctl/main.cpp

@@ -15,19 +15,20 @@
 #include <fstream>
 #include <string>
 
-const std::string USAGE = R"#(
-usage: hyprctl [command] [(opt)args]
+const std::string USAGE = R"#(usage: hyprctl [command] [(opt)args]
     
     monitors
     workspaces
     clients
     activewindow
     layers
+    devices
     dispatch
     keyword
     version
-    reload
-)#";
+    kill
+    hyprpaper
+    reload)#";
 
 void request(std::string arg) {
     const auto SERVERSOCKET = socket(AF_UNIX, SOCK_STREAM, 0);
@@ -44,12 +45,25 @@ void request(std::string arg) {
         return;
     }
 
+    // get the instance signature
+    auto instanceSig = getenv("HYPRLAND_INSTANCE_SIGNATURE");
+
+    if (!instanceSig) {
+        std::cout << "HYPRLAND_INSTANCE_SIGNATURE was not set! (Is Hyprland running?)";
+        return;
+    }
+
+    std::string instanceSigStr = std::string(instanceSig);
+
     sockaddr_un serverAddress = {0};
     serverAddress.sun_family = AF_UNIX;
-    strcpy(serverAddress.sun_path, "/tmp/hypr/.socket.sock");
+
+    std::string socketPath = "/tmp/hypr/" + instanceSigStr + "/.socket.sock";
+
+    strcpy(serverAddress.sun_path, socketPath.c_str());
 
     if (connect(SERVERSOCKET, (sockaddr*)&serverAddress, SUN_LEN(&serverAddress)) < 0) {
-        std::cout << "Couldn't connect to /tmp/hypr/.socket.sock. (3) Is Hyprland running?";
+        std::cout << "Couldn't connect to " << socketPath << ". (3)";
         return;
     }
 
@@ -62,7 +76,65 @@ void request(std::string arg) {
 
     char buffer[8192] = {0};
 
-    sizeWritten = read(SERVERSOCKET,buffer, 8192);
+    sizeWritten = read(SERVERSOCKET, buffer, 8192);
+
+    if (sizeWritten < 0) {
+        std::cout << "Couldn't read (5)";
+        return;
+    }
+
+    close(SERVERSOCKET);
+
+    std::cout << std::string(buffer);
+}
+
+void requestHyprpaper(std::string arg) {
+    const auto SERVERSOCKET = socket(AF_UNIX, SOCK_STREAM, 0);
+
+    if (SERVERSOCKET < 0) {
+        std::cout << "Couldn't open a socket (1)";
+        return;
+    }
+
+    const auto SERVER = gethostbyname("localhost");
+
+    if (!SERVER) {
+        std::cout << "Couldn't get host (2)";
+        return;
+    }
+
+    // get the instance signature
+    auto instanceSig = getenv("HYPRLAND_INSTANCE_SIGNATURE");
+
+    if (!instanceSig) {
+        std::cout << "HYPRLAND_INSTANCE_SIGNATURE was not set! (Is Hyprland running?)";
+        return;
+    }
+
+    std::string instanceSigStr = std::string(instanceSig);
+
+    sockaddr_un serverAddress = {0};
+    serverAddress.sun_family = AF_UNIX;
+
+    std::string socketPath = "/tmp/hypr/" + instanceSigStr + "/.hyprpaper.sock";
+
+    strcpy(serverAddress.sun_path, socketPath.c_str());
+
+    if (connect(SERVERSOCKET, (sockaddr*)&serverAddress, SUN_LEN(&serverAddress)) < 0) {
+        std::cout << "Couldn't connect to " << socketPath << ". (3)";
+        return;
+    }
+
+    auto sizeWritten = write(SERVERSOCKET, arg.c_str(), arg.length());
+
+    if (sizeWritten < 0) {
+        std::cout << "Couldn't write (4)";
+        return;
+    }
+
+    char buffer[8192] = {0};
+
+    sizeWritten = read(SERVERSOCKET, buffer, 8192);
 
     if (sizeWritten < 0) {
         std::cout << "Couldn't read (5)";
@@ -97,6 +169,17 @@ void keywordRequest(int argc, char** argv) {
     request(rq);
 }
 
+void hyprpaperRequest(int argc, char** argv) {
+    if (argc < 4) {
+        std::cout << "hyprpaper requires 2 params";
+        return;
+    }
+
+    std::string rq = std::string(argv[2]) + " " + std::string(argv[3]);
+
+    requestHyprpaper(rq);
+}
+
 void batchRequest(int argc, char** argv) {
     std::string rq = "[[BATCH]]" + std::string(argv[2]);
     
@@ -107,7 +190,7 @@ int main(int argc, char** argv) {
     int bflag = 0, sflag = 0, index, c;
 
     if (argc < 2) {
-        printf("%s", USAGE.c_str());
+        printf("%s\n", USAGE.c_str());
         return 1;
     }
 
@@ -117,14 +200,19 @@ int main(int argc, char** argv) {
     else if (!strcmp(argv[1], "activewindow")) request("activewindow");
     else if (!strcmp(argv[1], "layers")) request("layers");
     else if (!strcmp(argv[1], "version")) request("version");
+    else if (!strcmp(argv[1], "kill")) request("kill");
+    else if (!strcmp(argv[1], "devices")) request("devices");
     else if (!strcmp(argv[1], "reload")) request("reload");
     else if (!strcmp(argv[1], "dispatch")) dispatchRequest(argc, argv);
     else if (!strcmp(argv[1], "keyword")) keywordRequest(argc, argv);
+    else if (!strcmp(argv[1], "hyprpaper")) hyprpaperRequest(argc, argv);
     else if (!strcmp(argv[1], "--batch")) batchRequest(argc, argv);
+    else if (!strcmp(argv[1], "--help")) printf("%s", USAGE.c_str());
     else {
-        printf("%s", USAGE.c_str());
+        printf("%s\n", USAGE.c_str());
         return 1;
     }
 
+    printf("\n");
     return 0;
-}
+}

hyprctl/meson.build

@@ -0,0 +1,3 @@
+executable('hyprctl', 'main.cpp',
+  install: true
+)

meson.build

@@ -0,0 +1,35 @@
+project('Hyprland', 'cpp', 'c',
+  version : '0.6.2beta',
+  default_options : ['warning_level=2', 'cpp_std=c++20', 'default_library=static', 'optimization=3'])
+
+add_project_arguments(
+  [
+    '-Wno-unused-parameter',
+    '-Wno-unused-value',
+    '-Wno-missing-field-initializers',
+    '-Wno-narrowing',
+  ],
+  language: 'cpp')
+
+wlroots = subproject('wlroots', default_options: ['examples=false'])
+have_xwlr = wlroots.get_variable('features').get('xwayland')
+xcb_dep = dependency('xcb', required: get_option('xwayland'))
+
+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')
+endif
+
+if get_option('buildtype') == 'debug'
+  add_project_arguments('-DHYPRLAND_DEBUG', language: 'cpp')
+endif
+
+subdir('protocols')
+subdir('src')
+subdir('hyprctl')
+subdir('assets')
+subdir('example')

meson_options.txt

@@ -0,0 +1 @@
+option('xwayland', type: 'feature', value: 'auto', description: 'Enable support for X11 applications')

nix/default.nix

@@ -3,7 +3,7 @@
   stdenv,
   fetchFromGitHub,
   pkg-config,
-  cmake,
+  meson,
   ninja,
   libdrm,
   libinput,
@@ -20,14 +20,15 @@
   xwayland,
   enableXWayland ? true,
   version ? "git",
+  debug ? false,
 }:
 stdenv.mkDerivation {
-  pname = "hyprland";
+  pname = "hyprland" + lib.optionalString debug "-debug";
   inherit version;
-  src = ./.;
+  src = ../.;
 
   nativeBuildInputs = [
-    cmake
+    meson
     ninja
     pkg-config
   ];
@@ -48,29 +49,17 @@ stdenv.mkDerivation {
     ]
     ++ lib.optional enableXWayland xwayland;
 
-  cmakeFlags =
-    ["-DCMAKE_BUILD_TYPE=Release"]
-    ++ lib.optional (!enableXWayland) "-DNO_XWAYLAND=true";
+  mesonBuildType =
+    if debug
+    then "debug"
+    else "release";
 
-  prePatch = ''
-    make config
-  '';
+  mesonFlags = lib.optional (!enableXWayland) "-DNO_XWAYLAND=true";
 
-  postBuild = ''
-    pushd ../hyprctl
-    make all
-    popd
-  '';
-
-  installPhase = ''
-    pushd ..
-    install -Dm644 ./example/hyprland.desktop -t $out/share/wayland-sessions
-    install -Dm755 ./build/Hyprland -t $out/bin
-    install -Dm755 ./hyprctl/hyprctl -t $out/bin
-    install -Dm644 ./assets/* -t $out/share/hyprland
-    install -Dm644 ./example/hyprland.conf -t $out/share/hyprland
-    popd
-  '';
+  patches = [
+    # make meson use the provided wlroots instead of the git submodule
+    ./meson-build.patch
+  ];
 
   passthru.providedSessions = ["hyprland"];
 

nix/meson-build.patch

@@ -0,0 +1,36 @@
+diff --git a/meson.build b/meson.build
+index 22ee4bf..5528613 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'])
+
+-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'))
+
+-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')
+ endif
+
+diff --git a/src/meson.build b/src/meson.build
+index 5d64188..a676333 100644
+--- a/src/meson.build
++++ b/src/meson.build
+@@ -7,7 +7,7 @@ executable('Hyprland', src,
+     server_protos,
+     dependency('wayland-server'),
+     dependency('wayland-client'),
+-    wlroots.get_variable('wlroots'),
++    wlroots,
+     dependency('cairo'),
+     dependency('pango'),
+     dependency('pangocairo'),

nix/update-inputs.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env -S nix shell nixpkgs#gawk nixpkgs#git nixpkgs#moreutils nixpkgs#jq -c bash
+
+# get wlroots revision from submodule
+SUB_REV=$(git submodule status | awk '{ print substr($1,2)}')
+# and from lockfile
+CRT_REV=$(jq < flake.lock '.nodes.wlroots.locked.rev' -r)
+
+if [ $SUB_REV != $CRT_REV ]; then
+  # update nixpkgs to latest version
+  nix flake lock --update-input nixpkgs
+
+  # update wlroots to submodule revision
+  nix flake lock --override-input wlroots "gitlab:wlroots/wlroots/$SUB_REV?host=gitlab.freedesktop.org"
+
+  # remove "dirty" mark from lockfile
+  jq < flake.lock 'del(.nodes.wlroots.original.rev)' | sponge flake.lock
+else
+  echo "wlroots is up to date!"
+fi

protocols/meson.build

@@ -0,0 +1,51 @@
+wayland_protos = dependency('wayland-protocols',
+	version: '>=1.25',
+	fallback: 'wayland-protocols',
+	default_options: ['tests=false'],
+)
+wl_protocol_dir = wayland_protos.get_variable('pkgdatadir')
+
+wayland_scanner_dep = dependency('wayland-scanner', native: true)
+wayland_scanner = find_program(
+	wayland_scanner_dep.get_variable('wayland_scanner'),
+	native: true,
+)
+
+protocols = [
+  [wl_protocol_dir, 'stable/xdg-shell/xdg-shell.xml'],
+  ['wlr-layer-shell-unstable-v1.xml'],
+  ['ext-workspace-unstable-v1.xml'],
+  ['pointer-constraints-unstable-v1.xml'],
+  ['tablet-unstable-v2.xml'],
+  ['idle.xml']
+]
+wl_protos_src = []
+wl_protos_headers = []
+foreach p : protocols
+	xml = join_paths(p)
+	wl_protos_src += custom_target(
+		xml.underscorify() + '_server_c',
+		input: xml,
+		output: '@BASENAME@-protocol.c',
+		command: [wayland_scanner, 'private-code', '@INPUT@', '@OUTPUT@'],
+	)
+	wl_protos_headers += custom_target(
+		xml.underscorify() + '_server_h',
+		input: xml,
+		output: '@BASENAME@-protocol.h',
+		command: [wayland_scanner, 'server-header', '@INPUT@', '@OUTPUT@'],
+	)
+endforeach
+
+wayland_server = dependency('wayland-server', version: '>=1.20.0')
+
+lib_server_protos = static_library(
+	'server_protos',
+	wl_protos_src + wl_protos_headers,
+	dependencies: wayland_server.partial_dependency(compile_args: true),
+)
+
+server_protos = declare_dependency(
+	link_with: lib_server_protos,
+	sources: wl_protos_headers,
+)

src/Compositor.cpp

@@ -1,11 +1,26 @@
 #include "Compositor.hpp"
 
 CCompositor::CCompositor() {
-    unlink("/tmp/hypr/hyprland.log");
-    unlink("/tmp/hypr/hyprlandd.log");
-    unlink("/tmp/hypr/.hyprlandrq");
+    m_szInstanceSignature = GIT_COMMIT_HASH + std::string("_") + std::to_string(time(NULL));
 
-    system("mkdir -p /tmp/hypr");
+    setenv("HYPRLAND_INSTANCE_SIGNATURE", m_szInstanceSignature.c_str(), true);
+
+    const auto INSTANCEPATH = "/tmp/hypr/" + m_szInstanceSignature;
+    mkdir(INSTANCEPATH.c_str(), S_IRWXU | S_IRWXG);
+
+    Debug::init(m_szInstanceSignature);
+
+    Debug::log(LOG, "Instance Signature: %s", m_szInstanceSignature.c_str());
+
+    Debug::log(LOG, "===== SYSTEM INFO: =====");
+
+    logSystemInfo();
+
+    Debug::log(LOG, "========================");
+
+    Debug::log(NONE, "\n\n"); // pad
+
+    Debug::log(INFO, "If you are crashing, or encounter any bugs, please consult https://github.com/hyprwm/Hyprland/wiki/Crashing-and-bugs\n\n");
 
     m_sWLDisplay = wl_display_create();
 
@@ -104,6 +119,13 @@ CCompositor::CCompositor() {
     m_sWLRVirtPtrMgr = wlr_virtual_pointer_manager_v1_create(m_sWLDisplay);
 
     m_sWLRToplevelMgr = wlr_foreign_toplevel_manager_v1_create(m_sWLDisplay);
+
+    m_sWLRTabletManager = wlr_tablet_v2_create(m_sWLDisplay);
+
+    m_sWLRForeignRegistry = wlr_xdg_foreign_registry_create(m_sWLDisplay);
+
+    wlr_xdg_foreign_v1_create(m_sWLDisplay, m_sWLRForeignRegistry);
+    wlr_xdg_foreign_v2_create(m_sWLDisplay, m_sWLRForeignRegistry);
 }
 
 CCompositor::~CCompositor() {
@@ -137,6 +159,7 @@ void CCompositor::initAllSignals() {
     addWLSignal(&m_sWLRPointerConstraints->events.new_constraint, &Events::listen_newConstraint, m_sWLRPointerConstraints, "PointerConstraints");
     addWLSignal(&m_sWLRXDGDecoMgr->events.new_toplevel_decoration, &Events::listen_NewXDGDeco, m_sWLRXDGDecoMgr, "XDGDecoMgr");
     addWLSignal(&m_sWLRVirtPtrMgr->events.new_virtual_pointer, &Events::listen_newVirtPtr, m_sWLRVirtPtrMgr, "VirtPtrMgr");
+    addWLSignal(&m_sWLRRenderer->events.destroy, &Events::listen_RendererDestroy, m_sWLRRenderer, "WLRRenderer");
 
     signal(SIGINT, handleCritSignal);
     signal(SIGTERM, handleCritSignal);
@@ -149,8 +172,8 @@ void CCompositor::cleanupExit() {
     m_pLastFocus = nullptr;
     m_pLastWindow = nullptr;
 
-    m_lWorkspaces.clear();
-    m_lWindows.clear();
+    m_vWorkspaces.clear();
+    m_vWindows.clear();
 
     if (g_pXWaylandManager->m_sWLRXWayland) {
         wlr_xwayland_destroy(g_pXWaylandManager->m_sWLRXWayland);
@@ -246,9 +269,9 @@ void CCompositor::startCompositor() {
 }
 
 SMonitor* CCompositor::getMonitorFromID(const int& id) {
-    for (auto& m : m_lMonitors) {
-        if (m.ID == (uint64_t)id) {
-            return &m;
+    for (auto& m : m_vMonitors) {
+        if (m->ID == (uint64_t)id) {
+            return m.get();
         }
     }
 
@@ -256,9 +279,9 @@ SMonitor* CCompositor::getMonitorFromID(const int& id) {
 }
 
 SMonitor* CCompositor::getMonitorFromName(const std::string& name) {
-    for (auto& m : m_lMonitors) {
-        if (m.szName == name) {
-            return &m;
+    for (auto& m : m_vMonitors) {
+        if (m->szName == name) {
+            return m.get();
         }
     }
 
@@ -278,18 +301,18 @@ SMonitor* CCompositor::getMonitorFromVector(const Vector2D& point) {
         float bestDistance = 0.f;
         SMonitor* pBestMon = nullptr;
 
-        for (auto& m : m_lMonitors) {
-            float dist = vecToRectDistanceSquared(point, m.vecPosition, m.vecPosition + m.vecSize);
+        for (auto& m : m_vMonitors) {
+            float dist = vecToRectDistanceSquared(point, m->vecPosition, m->vecPosition + m->vecSize);
 
             if (dist < bestDistance || !pBestMon) {
                 bestDistance = dist;
-                pBestMon = &m;
+                pBestMon = m.get();
             }
         }
 
         if (!pBestMon) { // ?????
             Debug::log(WARN, "getMonitorFromVector no close mon???");
-            return &m_lMonitors.front();
+            return m_vMonitors.front().get();
         }
 
         return pBestMon;
@@ -299,13 +322,35 @@ SMonitor* CCompositor::getMonitorFromVector(const Vector2D& point) {
 }
 
 void CCompositor::removeWindowFromVectorSafe(CWindow* pWindow) {
-    if (windowExists(pWindow) && !pWindow->m_bFadingOut)
-        m_lWindows.remove(*pWindow);
+    if (windowExists(pWindow) && !pWindow->m_bFadingOut){
+        if (pWindow->m_bIsX11 && pWindow->m_iX11Type == 2) {
+            m_dUnmanagedX11Windows.erase(std::remove_if(m_dUnmanagedX11Windows.begin(), m_dUnmanagedX11Windows.end(), [&](std::unique_ptr<CWindow>& el) { return el.get() == pWindow; }));
+        }
+
+        // if X11, also check its children
+        // and delete any needed
+        if (pWindow->m_bIsX11) {
+            for (auto& w : m_vWindows) {
+                if (!w->m_bIsX11)
+                    continue;
+
+                if (w->m_pX11Parent == pWindow)
+                    m_vWindows.erase(std::remove_if(m_vWindows.begin(), m_vWindows.end(), [&](std::unique_ptr<CWindow>& el) { return el.get() == w.get(); }));
+            }
+
+            for (auto& w : m_dUnmanagedX11Windows) {
+                if (w->m_pX11Parent == pWindow)
+                    m_dUnmanagedX11Windows.erase(std::remove_if(m_dUnmanagedX11Windows.begin(), m_dUnmanagedX11Windows.end(), [&](std::unique_ptr<CWindow>& el) { return el.get() == w.get(); }));
+            }
+        }
+
+        m_vWindows.erase(std::remove_if(m_vWindows.begin(), m_vWindows.end(), [&](std::unique_ptr<CWindow>& el) { return el.get() == pWindow; }));
+    }
 }
 
 bool CCompositor::windowExists(CWindow* pWindow) {
-    for (auto& w : m_lWindows) {
-        if (&w == pWindow)
+    for (auto& w : m_vWindows) {
+        if (w.get() == pWindow)
             return true;
     }
 
@@ -314,17 +359,26 @@ bool CCompositor::windowExists(CWindow* pWindow) {
 
 CWindow* CCompositor::vectorToWindow(const Vector2D& pos) {
     const auto PMONITOR = getMonitorFromVector(pos);
-    // first loop over floating cuz they're above, m_lWindows should be sorted bottom->top, for tiled it doesn't matter.
-    for (auto w = m_lWindows.rbegin(); w != m_lWindows.rend(); w++) {
-        wlr_box box = {w->m_vRealPosition.vec().x, w->m_vRealPosition.vec().y, w->m_vRealSize.vec().x, w->m_vRealSize.vec().y};
-        if (wlr_box_contains_point(&box, pos.x, pos.y) && w->m_bIsMapped && w->m_bIsFloating && isWorkspaceVisible(w->m_iWorkspaceID) && !w->m_bHidden)
-            return &(*w);
+
+    if (PMONITOR->specialWorkspaceOpen) {
+        for (auto& w : m_vWindows) {
+            wlr_box box = {w->m_vRealPosition.vec().x, w->m_vRealPosition.vec().y, w->m_vRealSize.vec().x, w->m_vRealSize.vec().y};
+            if (w->m_iWorkspaceID == SPECIAL_WORKSPACE_ID && wlr_box_contains_point(&box, pos.x, pos.y) && w->m_bIsMapped && !w->m_bIsFloating && !w->m_bHidden)
+                return w.get();
+        }
     }
 
-    for (auto& w : m_lWindows) {
-        wlr_box box = {w.m_vRealPosition.vec().x, w.m_vRealPosition.vec().y, w.m_vRealSize.vec().x, w.m_vRealSize.vec().y};
-        if (wlr_box_contains_point(&box, pos.x, pos.y) && w.m_bIsMapped && !w.m_bIsFloating && PMONITOR->activeWorkspace == w.m_iWorkspaceID && !w.m_bHidden)
-            return &w;
+    // first loop over floating cuz they're above, m_vWindows should be sorted bottom->top, for tiled it doesn't matter.
+    for (auto w = m_vWindows.rbegin(); w != m_vWindows.rend(); w++) {
+        wlr_box box = {(*w)->m_vRealPosition.vec().x, (*w)->m_vRealPosition.vec().y, (*w)->m_vRealSize.vec().x, (*w)->m_vRealSize.vec().y};
+        if (wlr_box_contains_point(&box, pos.x, pos.y) && (*w)->m_bIsMapped && (*w)->m_bIsFloating && isWorkspaceVisible((*w)->m_iWorkspaceID) && !(*w)->m_bHidden)
+            return w->get();
+    }
+
+    for (auto& w : m_vWindows) {
+        wlr_box box = {w->m_vRealPosition.vec().x, w->m_vRealPosition.vec().y, w->m_vRealSize.vec().x, w->m_vRealSize.vec().y};
+        if (wlr_box_contains_point(&box, pos.x, pos.y) && w->m_bIsMapped && !w->m_bIsFloating && PMONITOR->activeWorkspace == w->m_iWorkspaceID && !w->m_bHidden)
+            return w.get();
     }
 
     return nullptr;
@@ -332,10 +386,19 @@ CWindow* CCompositor::vectorToWindow(const Vector2D& pos) {
 
 CWindow* CCompositor::vectorToWindowTiled(const Vector2D& pos) {
     const auto PMONITOR = getMonitorFromVector(pos);
-    for (auto& w : m_lWindows) {
-        wlr_box box = {w.m_vPosition.x, w.m_vPosition.y, w.m_vSize.x, w.m_vSize.y};
-        if (w.m_bIsMapped && wlr_box_contains_point(&box, pos.x, pos.y) && w.m_iWorkspaceID == PMONITOR->activeWorkspace && !w.m_bIsFloating && !w.m_bHidden)
-            return &w;
+
+    if (PMONITOR->specialWorkspaceOpen) {
+        for (auto& w : m_vWindows) {
+            wlr_box box = {w->m_vPosition.x, w->m_vPosition.y, w->m_vSize.x, w->m_vSize.y};
+            if (w->m_iWorkspaceID == SPECIAL_WORKSPACE_ID && wlr_box_contains_point(&box, pos.x, pos.y) && !w->m_bIsFloating && !w->m_bHidden)
+                return w.get();
+        }
+    }
+
+    for (auto& w : m_vWindows) {
+        wlr_box box = {w->m_vPosition.x, w->m_vPosition.y, w->m_vSize.x, w->m_vSize.y};
+        if (w->m_bIsMapped && wlr_box_contains_point(&box, pos.x, pos.y) && w->m_iWorkspaceID == PMONITOR->activeWorkspace && !w->m_bIsFloating && !w->m_bHidden)
+            return w.get();
     }
 
     return nullptr;
@@ -343,17 +406,27 @@ CWindow* CCompositor::vectorToWindowTiled(const Vector2D& pos) {
 
 CWindow* CCompositor::vectorToWindowIdeal(const Vector2D& pos) {
     const auto PMONITOR = getMonitorFromVector(pos);
-    // first loop over floating cuz they're above, m_lWindows should be sorted bottom->top, for tiled it doesn't matter.
-    for (auto w = m_lWindows.rbegin(); w != m_lWindows.rend(); w++) {
-        wlr_box box = {w->m_vRealPosition.vec().x, w->m_vRealPosition.vec().y, w->m_vRealSize.vec().x, w->m_vRealSize.vec().y};
-        if (w->m_bIsFloating && w->m_bIsMapped && wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && isWorkspaceVisible(w->m_iWorkspaceID) && !w->m_bHidden)
-            return &(*w);
+
+    // special workspace
+    if (PMONITOR->specialWorkspaceOpen) {
+        for (auto& w : m_vWindows) {
+            wlr_box box = {w->m_vPosition.x, w->m_vPosition.y, w->m_vSize.x, w->m_vSize.y};
+            if (w->m_iWorkspaceID == SPECIAL_WORKSPACE_ID && w->m_bIsMapped && wlr_box_contains_point(&box, pos.x, pos.y) && !w->m_bHidden)
+                return w.get();
+        }
     }
 
-    for (auto& w : m_lWindows) {
-        wlr_box box = {w.m_vPosition.x, w.m_vPosition.y, w.m_vSize.x, w.m_vSize.y};
-        if (!w.m_bIsFloating && w.m_bIsMapped && wlr_box_contains_point(&box, pos.x, pos.y) && w.m_iWorkspaceID == PMONITOR->activeWorkspace && !w.m_bHidden)
-            return &w;
+    // first loop over floating cuz they're above, m_lWindows should be sorted bottom->top, for tiled it doesn't matter.
+    for (auto w = m_vWindows.rbegin(); w != m_vWindows.rend(); w++) {
+        wlr_box box = {(*w)->m_vRealPosition.vec().x, (*w)->m_vRealPosition.vec().y, (*w)->m_vRealSize.vec().x, (*w)->m_vRealSize.vec().y};
+        if ((*w)->m_bIsFloating && (*w)->m_bIsMapped && wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && isWorkspaceVisible((*w)->m_iWorkspaceID) && !(*w)->m_bHidden)
+            return w->get();
+    }
+
+    for (auto& w : m_vWindows) {
+        wlr_box box = {w->m_vPosition.x, w->m_vPosition.y, w->m_vSize.x, w->m_vSize.y};
+        if (!w->m_bIsFloating && w->m_bIsMapped && wlr_box_contains_point(&box, pos.x, pos.y) && w->m_iWorkspaceID == PMONITOR->activeWorkspace && !w->m_bHidden)
+            return w.get();
     }
 
     return nullptr;
@@ -362,27 +435,35 @@ CWindow* CCompositor::vectorToWindowIdeal(const Vector2D& pos) {
 CWindow* CCompositor::windowFromCursor() {
     const auto PMONITOR = getMonitorFromCursor();
 
-    // first loop over floating cuz they're above, m_lWindows should be sorted bottom->top, for tiled it doesn't matter.
-    for (auto w = m_lWindows.rbegin(); w != m_lWindows.rend(); w++) {
-        wlr_box box = {w->m_vRealPosition.vec().x, w->m_vRealPosition.vec().y, w->m_vRealSize.vec().x, w->m_vRealSize.vec().y};
-        if (wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && w->m_bIsMapped && w->m_bIsFloating && isWorkspaceVisible(w->m_iWorkspaceID))
-            return &(*w);
+    if (PMONITOR->specialWorkspaceOpen) {
+        for (auto& w : m_vWindows) {
+            wlr_box box = {w->m_vPosition.x, w->m_vPosition.y, w->m_vSize.x, w->m_vSize.y};
+            if (w->m_iWorkspaceID == SPECIAL_WORKSPACE_ID && wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && w->m_bIsMapped)
+                return w.get();
+        }
     }
 
-    for (auto& w : m_lWindows) {
-        wlr_box box = {w.m_vPosition.x, w.m_vPosition.y, w.m_vSize.x, w.m_vSize.y};
-        if (wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && w.m_bIsMapped && w.m_iWorkspaceID == PMONITOR->activeWorkspace)
-            return &w;
+    // first loop over floating cuz they're above, m_lWindows should be sorted bottom->top, for tiled it doesn't matter.
+    for (auto w = m_vWindows.rbegin(); w != m_vWindows.rend(); w++) {
+        wlr_box box = {(*w)->m_vRealPosition.vec().x, (*w)->m_vRealPosition.vec().y, (*w)->m_vRealSize.vec().x, (*w)->m_vRealSize.vec().y};
+        if (wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && (*w)->m_bIsMapped && (*w)->m_bIsFloating && isWorkspaceVisible((*w)->m_iWorkspaceID))
+            return w->get();
+    }
+
+    for (auto& w : m_vWindows) {
+        wlr_box box = {w->m_vPosition.x, w->m_vPosition.y, w->m_vSize.x, w->m_vSize.y};
+        if (wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && w->m_bIsMapped && w->m_iWorkspaceID == PMONITOR->activeWorkspace)
+            return w.get();
     }
 
     return nullptr;
 }
 
 CWindow* CCompositor::windowFloatingFromCursor() {
-    for (auto w = m_lWindows.rbegin(); w != m_lWindows.rend(); w++) {
-        wlr_box box = {w->m_vRealPosition.vec().x, w->m_vRealPosition.vec().y, w->m_vRealSize.vec().x, w->m_vRealSize.vec().y};
-        if (wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && w->m_bIsMapped && w->m_bIsFloating && isWorkspaceVisible(w->m_iWorkspaceID) && !w->m_bHidden)
-            return &(*w);
+    for (auto w = m_vWindows.rbegin(); w != m_vWindows.rend(); w++) {
+        wlr_box box = {(*w)->m_vRealPosition.vec().x, (*w)->m_vRealPosition.vec().y, (*w)->m_vRealSize.vec().x, (*w)->m_vRealSize.vec().y};
+        if (wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && (*w)->m_bIsMapped && (*w)->m_bIsFloating && isWorkspaceVisible((*w)->m_iWorkspaceID) && !(*w)->m_bHidden)
+            return w->get();
     }
 
     return nullptr;
@@ -399,7 +480,11 @@ wlr_surface* CCompositor::vectorWindowToSurface(const Vector2D& pos, CWindow* pW
     
     double subx, suby;
 
-    const auto PFOUND = wlr_xdg_surface_surface_at(PSURFACE, pos.x - pWindow->m_vRealPosition.vec().x, pos.y - pWindow->m_vRealPosition.vec().y, &subx, &suby);
+    // calc for oversized windows... fucking bullshit, again.
+    wlr_box geom;
+    wlr_xdg_surface_get_geometry(pWindow->m_uSurface.xdg, &geom);
+
+    const auto PFOUND = wlr_xdg_surface_surface_at(PSURFACE, pos.x - pWindow->m_vRealPosition.vec().x + geom.x, pos.y - pWindow->m_vRealPosition.vec().y + geom.y, &subx, &suby);
 
     if (PFOUND) {
         sl.x = subx;
@@ -410,13 +495,16 @@ wlr_surface* CCompositor::vectorWindowToSurface(const Vector2D& pos, CWindow* pW
     sl.x = pos.x - pWindow->m_vRealPosition.vec().x;
     sl.y = pos.y - pWindow->m_vRealPosition.vec().y;
 
+    sl.x += geom.x;
+    sl.y += geom.y;
+
     return PSURFACE->surface;
 }
 
 SMonitor* CCompositor::getMonitorFromOutput(wlr_output* out) {
-    for (auto& m : m_lMonitors) {
-        if (m.output == out) {
-            return &m;
+    for (auto& m : m_vMonitors) {
+        if (m->output == out) {
+            return m.get();
         }
     }
 
@@ -525,56 +613,58 @@ bool CCompositor::windowValidMapped(CWindow* pWindow) {
     if (pWindow->m_bHidden)
         return false;
 
-    if (!g_pXWaylandManager->getWindowSurface(pWindow))
-        return false;
-
     return true;
 }
 
 CWindow* CCompositor::getWindowForPopup(wlr_xdg_popup* popup) {
-    for (auto& p : m_lXDGPopups) {
-        if (p.popup == popup)
-            return p.parentWindow;
+    for (auto& p : m_vXDGPopups) {
+        if (p->popup == popup)
+            return p->parentWindow;
     }
 
     return nullptr;
 }
 
-wlr_surface* CCompositor::vectorToLayerSurface(const Vector2D& pos, std::list<SLayerSurface*>* layerSurfaces, Vector2D* sCoords) {
-    for (auto& l : *layerSurfaces) {
-        if (l->fadingOut || (l->layerSurface && !l->layerSurface->mapped))
+wlr_surface* CCompositor::vectorToLayerSurface(const Vector2D& pos, std::list<SLayerSurface*>* layerSurfaces, Vector2D* sCoords, SLayerSurface** ppLayerSurfaceFound) {
+    for (auto it = layerSurfaces->rbegin(); it != layerSurfaces->rend(); it++) {
+        if ((*it)->fadingOut || !(*it)->layerSurface || ((*it)->layerSurface && !(*it)->layerSurface->mapped))
             continue;
 
-        const auto SURFACEAT = wlr_layer_surface_v1_surface_at(l->layerSurface, pos.x - l->geometry.x, pos.y - l->geometry.y, &sCoords->x, &sCoords->y);
+        const auto SURFACEAT = wlr_layer_surface_v1_surface_at((*it)->layerSurface, pos.x - (*it)->geometry.x, pos.y - (*it)->geometry.y, &sCoords->x, &sCoords->y);
 
-        if (SURFACEAT)
+        if (SURFACEAT) {
+            *ppLayerSurfaceFound = *it;
             return SURFACEAT;
+        }
     }
 
     return nullptr;
 }
 
 CWindow* CCompositor::getWindowFromSurface(wlr_surface* pSurface) {
-    for (auto& w : m_lWindows) {
-        if (g_pXWaylandManager->getWindowSurface(&w) == pSurface)
-            return &w;
+    for (auto& w : m_vWindows) {
+        if (g_pXWaylandManager->getWindowSurface(w.get()) == pSurface)
+            return w.get();
     }
 
     return nullptr;
 }
 
 CWindow* CCompositor::getFullscreenWindowOnWorkspace(const int& ID) {
-    for (auto& w : m_lWindows) {
-        if (w.m_iWorkspaceID == ID && w.m_bIsFullscreen)
-            return &w;
+    for (auto& w : m_vWindows) {
+        if (w->m_iWorkspaceID == ID && w->m_bIsFullscreen)
+            return w.get();
     }
 
     return nullptr;
 }
 
 bool CCompositor::isWorkspaceVisible(const int& w) {
-    for (auto& m : m_lMonitors) {
-        if (m.activeWorkspace == w)
+    for (auto& m : m_vMonitors) {
+        if (m->activeWorkspace == w)
+            return true;
+        
+        if (m->specialWorkspaceOpen && w == SPECIAL_WORKSPACE_ID)
             return true;
     }
 
@@ -582,26 +672,42 @@ bool CCompositor::isWorkspaceVisible(const int& w) {
 }
 
 CWorkspace* CCompositor::getWorkspaceByID(const int& id) {
-    for (auto& w : m_lWorkspaces) {
-        if (w.m_iID == id)
-            return &w;
+    for (auto& w : m_vWorkspaces) {
+        if (w->m_iID == id)
+            return w.get();
     }
 
     return nullptr;
 }
 
 void CCompositor::sanityCheckWorkspaces() {
-    for (auto it = m_lWorkspaces.begin(); it != m_lWorkspaces.end(); ++it) {
-        if (getWindowsOnWorkspace(it->m_iID) == 0 && !isWorkspaceVisible(it->m_iID)) {
-            it = m_lWorkspaces.erase(it);
+    for (auto it = m_vWorkspaces.begin(); it != m_vWorkspaces.end(); ++it) {
+        const auto WINDOWSONWORKSPACE = getWindowsOnWorkspace((*it)->m_iID);
+
+        if ((WINDOWSONWORKSPACE == 0 && !isWorkspaceVisible((*it)->m_iID))) {
+            it = m_vWorkspaces.erase(it);
+
+            if (it == m_vWorkspaces.end())
+                break;
+        }
+
+        if ((*it)->m_iID == SPECIAL_WORKSPACE_ID && WINDOWSONWORKSPACE == 0) {
+            for (auto& m : m_vMonitors) {
+                m->specialWorkspaceOpen = false;
+            }
+
+            it = m_vWorkspaces.erase(it);
+
+            if (it == m_vWorkspaces.end())
+                break;
         }
     }
 }
 
 int CCompositor::getWindowsOnWorkspace(const int& id) {
     int no = 0;
-    for (auto& w : m_lWindows) {
-        if (w.m_iWorkspaceID == id && w.m_bIsMapped)
+    for (auto& w : m_vWindows) {
+        if (w->m_iWorkspaceID == id && w->m_bIsMapped)
             no++;
     }
 
@@ -609,9 +715,9 @@ int CCompositor::getWindowsOnWorkspace(const int& id) {
 }
 
 CWindow* CCompositor::getFirstWindowOnWorkspace(const int& id) {
-    for (auto& w : m_lWindows) {
-        if (w.m_iWorkspaceID == id)
-            return &w;
+    for (auto& w : m_vWindows) {
+        if (w->m_iWorkspaceID == id)
+            return w.get();
     }
 
     return nullptr;
@@ -622,16 +728,19 @@ void CCompositor::fixXWaylandWindowsOnWorkspace(const int& id) {
 
     const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(id);
 
-    for (auto& w : m_lWindows) {
-        if (w.m_iWorkspaceID == id) {
+    if (!PWORKSPACE)
+        return;
+
+    for (auto& w : m_vWindows) {
+        if (w->m_iWorkspaceID == id) {
 
             // moveXWaylandWindow only moves XWayland windows
             // so there is no need to check here
             // if the window is XWayland or not.
-            if (ISVISIBLE && (!PWORKSPACE->m_bHasFullscreenWindow || w.m_bIsFullscreen))
-                g_pXWaylandManager->moveXWaylandWindow(&w, w.m_vRealPosition.vec());
+            if (ISVISIBLE && (!PWORKSPACE->m_bHasFullscreenWindow || w->m_bIsFullscreen))
+                g_pXWaylandManager->moveXWaylandWindow(w.get(), w->m_vRealPosition.vec());
             else 
-                g_pXWaylandManager->moveXWaylandWindow(&w, Vector2D(42069,42069));
+                g_pXWaylandManager->moveXWaylandWindow(w.get(), Vector2D(42069,42069));
         }
     }
 }
@@ -656,37 +765,37 @@ void CCompositor::moveWindowToTop(CWindow* pWindow) {
     if (!windowValidMapped(pWindow))
         return;
 
-    for (auto it = m_lWindows.begin(); it != m_lWindows.end(); ++it) {
-        if (&(*it) == pWindow) {
-            m_lWindows.splice(m_lWindows.end(), m_lWindows, it);
+    for (auto it = m_vWindows.begin(); it != m_vWindows.end(); ++it) {
+        if (it->get() == pWindow) {
+            std::rotate(it, it + 1, m_vWindows.end());
             break;
         }
     }
 }
 
 void CCompositor::cleanupFadingOut() {
-    for (auto& w : m_lWindowsFadingOut) {
+    for (auto& w : m_vWindowsFadingOut) {
 
         bool valid = windowExists(w);
-        
+
         if (!valid || !w->m_bFadingOut || w->m_fAlpha.fl() == 0.f) {
             if (valid && !w->m_bReadyToDelete)
                 continue;
 
             g_pHyprOpenGL->m_mWindowFramebuffers[w].release();
             g_pHyprOpenGL->m_mWindowFramebuffers.erase(w);
-            m_lWindows.remove(*w);
-            m_lWindowsFadingOut.remove(w);
+            removeWindowFromVectorSafe(w);
+            m_vWindowsFadingOut.erase(std::remove(m_vWindowsFadingOut.begin(), m_vWindowsFadingOut.end(), w));
 
             Debug::log(LOG, "Cleanup: destroyed a window");
             return;
         }
     }
 
-    for (auto& ls : m_lSurfacesFadingOut) {
+    for (auto& ls : m_vSurfacesFadingOut) {
         if (ls->fadingOut && ls->readyToDelete && !ls->alpha.isBeingAnimated()) {
-            for (auto& m : m_lMonitors) {
-                for (auto& lsl : m.m_aLayerSurfaceLists) {
+            for (auto& m : m_vMonitors) {
+                for (auto& lsl : m->m_aLayerSurfaceLists) {
                     lsl.remove(ls);
                 }
             }
@@ -695,7 +804,7 @@ void CCompositor::cleanupFadingOut() {
             g_pHyprOpenGL->m_mLayerFramebuffers.erase(ls);
             
             delete ls;
-            m_lSurfacesFadingOut.remove(ls);
+            m_vSurfacesFadingOut.erase(std::remove(m_vSurfacesFadingOut.begin(), m_vSurfacesFadingOut.end(), ls));
 
             Debug::log(LOG, "Cleanup: destroyed a layersurface");
 
@@ -705,25 +814,31 @@ void CCompositor::cleanupFadingOut() {
 }
 
 CWindow* CCompositor::getWindowInDirection(CWindow* pWindow, char dir) {
-    const auto POSA = pWindow->m_vPosition;
-    const auto SIZEA = pWindow->m_vSize;
+
+    const auto WINDOWIDEALBB = pWindow->getWindowIdealBoundingBoxIgnoreReserved();
+
+    const auto POSA = Vector2D(WINDOWIDEALBB.x, WINDOWIDEALBB.y);
+    const auto SIZEA = Vector2D(WINDOWIDEALBB.width, WINDOWIDEALBB.height);
 
     auto longestIntersect = -1;
     CWindow* longestIntersectWindow = nullptr;
 
-    for (auto& w : m_lWindows) {
-        if (&w == pWindow || !windowValidMapped(&w) || w.m_bIsFloating || w.m_iWorkspaceID != pWindow->m_iWorkspaceID)
+    for (auto& w : m_vWindows) {
+        if (w.get() == pWindow || !w->m_bIsMapped || w->m_bHidden || w->m_bIsFloating || !isWorkspaceVisible(w->m_iWorkspaceID))
             continue;
 
-        const auto POSB = w.m_vPosition;
-        const auto SIZEB = w.m_vSize;
+        const auto BWINDOWIDEALBB = w->getWindowIdealBoundingBoxIgnoreReserved();
+
+        const auto POSB = Vector2D(BWINDOWIDEALBB.x, BWINDOWIDEALBB.y);
+        const auto SIZEB = Vector2D(BWINDOWIDEALBB.width, BWINDOWIDEALBB.height);
+
         switch (dir) {
             case 'l':
                 if (STICKS(POSA.x, POSB.x + SIZEB.x)) {
                     const auto INTERSECTLEN = std::max((double)0, std::min(POSA.y + SIZEA.y, POSB.y + SIZEB.y) - std::max(POSA.y, POSB.y));
                     if (INTERSECTLEN > longestIntersect) {
                         longestIntersect = INTERSECTLEN;
-                        longestIntersectWindow = &w;
+                        longestIntersectWindow = w.get();
                     }
                 }
                 break;
@@ -732,7 +847,7 @@ CWindow* CCompositor::getWindowInDirection(CWindow* pWindow, char dir) {
                     const auto INTERSECTLEN = std::max((double)0, std::min(POSA.y + SIZEA.y, POSB.y + SIZEB.y) - std::max(POSA.y, POSB.y));
                     if (INTERSECTLEN > longestIntersect) {
                         longestIntersect = INTERSECTLEN;
-                        longestIntersectWindow = &w;
+                        longestIntersectWindow = w.get();
                     }
                 }
                 break;
@@ -742,7 +857,7 @@ CWindow* CCompositor::getWindowInDirection(CWindow* pWindow, char dir) {
                     const auto INTERSECTLEN = std::max((double)0, std::min(POSA.x + SIZEA.x, POSB.x + SIZEB.x) - std::max(POSA.x, POSB.x));
                     if (INTERSECTLEN > longestIntersect) {
                         longestIntersect = INTERSECTLEN;
-                        longestIntersectWindow = &w;
+                        longestIntersectWindow = w.get();
                     }
                 }
                 break;
@@ -752,7 +867,7 @@ CWindow* CCompositor::getWindowInDirection(CWindow* pWindow, char dir) {
                     const auto INTERSECTLEN = std::max((double)0, std::min(POSA.x + SIZEA.x, POSB.x + SIZEB.x) - std::max(POSA.x, POSB.x));
                     if (INTERSECTLEN > longestIntersect) {
                         longestIntersect = INTERSECTLEN;
-                        longestIntersectWindow = &w;
+                        longestIntersectWindow = w.get();
                     }
                 }
                 break;
@@ -766,30 +881,30 @@ CWindow* CCompositor::getWindowInDirection(CWindow* pWindow, char dir) {
 }
 
 void CCompositor::deactivateAllWLRWorkspaces(wlr_ext_workspace_handle_v1* exclude) {
-    for (auto& w : m_lWorkspaces) {
-        if (w.m_pWlrHandle && w.m_pWlrHandle != exclude)
-            w.setActive(false);
+    for (auto& w : m_vWorkspaces) {
+        if (w->m_pWlrHandle && w->m_pWlrHandle != exclude)
+            w->setActive(false);
     }
 }
 
 CWindow* CCompositor::getNextWindowOnWorkspace(CWindow* pWindow) {
     bool gotToWindow = false;
-    for (auto& w : m_lWindows) {
-        if (&w != pWindow && !gotToWindow)
+    for (auto& w : m_vWindows) {
+        if (w.get() != pWindow && !gotToWindow)
             continue;
 
-        if (&w == pWindow) {
+        if (w.get() == pWindow) {
             gotToWindow = true;
             continue;
         }
 
-        if (w.m_iWorkspaceID == pWindow->m_iWorkspaceID && windowValidMapped(&w))
-            return &w;
+        if (w->m_iWorkspaceID == pWindow->m_iWorkspaceID && w->m_bIsMapped && !w->m_bHidden)
+            return w.get();
     }
 
-    for (auto& w : m_lWindows) {
-        if (&w != pWindow && w.m_iWorkspaceID == pWindow->m_iWorkspaceID && windowValidMapped(&w))
-            return &w;
+    for (auto& w : m_vWindows) {
+        if (w.get() != pWindow && w->m_iWorkspaceID == pWindow->m_iWorkspaceID && w->m_bIsMapped && !w->m_bHidden)
+            return w.get();
     }
 
     return nullptr;
@@ -797,18 +912,18 @@ CWindow* CCompositor::getNextWindowOnWorkspace(CWindow* pWindow) {
 
 int CCompositor::getNextAvailableNamedWorkspace() {
     int lowest = -1337 + 1;
-    for (auto& w : m_lWorkspaces) {
-        if (w.m_iID < -1 && w.m_iID < lowest)
-            lowest = w.m_iID;
+    for (auto& w : m_vWorkspaces) {
+        if (w->m_iID < -1 && w->m_iID < lowest)
+            lowest = w->m_iID;
     }
 
     return lowest - 1;
 }
 
 CWorkspace* CCompositor::getWorkspaceByName(const std::string& name) {
-    for (auto& w : m_lWorkspaces) {
-        if (w.m_szName == name)
-            return &w;
+    for (auto& w : m_vWorkspaces) {
+        if (w->m_szName == name)
+            return w.get();
     }
 
     return nullptr;
@@ -820,8 +935,8 @@ CWorkspace* CCompositor::getWorkspaceByString(const std::string& str) {
     }
 
     try {
-        int id = std::stoi(str);
-        return getWorkspaceByID(id);
+        std::string name = "";
+        return getWorkspaceByID(getWorkspaceIDFromString(str, name));
     } catch (std::exception& e) {
         Debug::log(ERR, "Error in getWorkspaceByString, invalid id");
     }
@@ -830,8 +945,8 @@ CWorkspace* CCompositor::getWorkspaceByString(const std::string& str) {
 }
 
 bool CCompositor::isPointOnAnyMonitor(const Vector2D& point) {
-    for (auto& m : m_lMonitors) {
-        if (VECINRECT(point, m.vecPosition.x, m.vecPosition.y, m.vecSize.x + m.vecPosition.x, m.vecSize.y + m.vecPosition.y))
+    for (auto& m : m_vMonitors) {
+        if (VECINRECT(point, m->vecPosition.x, m->vecPosition.y, m->vecSize.x + m->vecPosition.x, m->vecSize.y + m->vecPosition.y))
             return true;
     }
 
@@ -844,12 +959,12 @@ CWindow* CCompositor::getConstraintWindow(SMouse* pMouse) {
 
     const auto PSURFACE = pMouse->currentConstraint->surface;
 
-    for (auto& w : m_lWindows) {
-        if (PSURFACE == g_pXWaylandManager->getWindowSurface(&w)) {
-            if (!w.m_bIsX11 && !windowValidMapped(&w))
+    for (auto& w : m_vWindows) {
+        if (PSURFACE == g_pXWaylandManager->getWindowSurface(w.get())) {
+            if (!w->m_bIsX11 && w->m_bIsMapped && !w->m_bHidden)
                 continue;
 
-            return &w;
+            return w.get();
         }
     }
 
@@ -863,19 +978,19 @@ SMonitor* CCompositor::getMonitorInDirection(const char& dir) {
     auto longestIntersect = -1;
     SMonitor* longestIntersectMonitor = nullptr;
 
-    for (auto& m : m_lMonitors) {
-        if (&m == m_pLastMonitor)
+    for (auto& m : m_vMonitors) {
+        if (m.get() == m_pLastMonitor)
             continue;
 
-        const auto POSB = m.vecPosition;
-        const auto SIZEB = m.vecSize;
+        const auto POSB = m->vecPosition;
+        const auto SIZEB = m->vecSize;
         switch (dir) {
             case 'l':
                 if (STICKS(POSA.x, POSB.x + SIZEB.x)) {
                     const auto INTERSECTLEN = std::max((double)0, std::min(POSA.y + SIZEA.y, POSB.y + SIZEB.y) - std::max(POSA.y, POSB.y));
                     if (INTERSECTLEN > longestIntersect) {
                         longestIntersect = INTERSECTLEN;
-                        longestIntersectMonitor = &m;
+                        longestIntersectMonitor = m.get();
                     }
                 }
                 break;
@@ -884,7 +999,7 @@ SMonitor* CCompositor::getMonitorInDirection(const char& dir) {
                     const auto INTERSECTLEN = std::max((double)0, std::min(POSA.y + SIZEA.y, POSB.y + SIZEB.y) - std::max(POSA.y, POSB.y));
                     if (INTERSECTLEN > longestIntersect) {
                         longestIntersect = INTERSECTLEN;
-                        longestIntersectMonitor = &m;
+                        longestIntersectMonitor = m.get();
                     }
                 }
                 break;
@@ -894,7 +1009,7 @@ SMonitor* CCompositor::getMonitorInDirection(const char& dir) {
                     const auto INTERSECTLEN = std::max((double)0, std::min(POSA.x + SIZEA.x, POSB.x + SIZEB.x) - std::max(POSA.x, POSB.x));
                     if (INTERSECTLEN > longestIntersect) {
                         longestIntersect = INTERSECTLEN;
-                        longestIntersectMonitor = &m;
+                        longestIntersectMonitor = m.get();
                     }
                 }
                 break;
@@ -904,7 +1019,7 @@ SMonitor* CCompositor::getMonitorInDirection(const char& dir) {
                     const auto INTERSECTLEN = std::max((double)0, std::min(POSA.x + SIZEA.x, POSB.x + SIZEB.x) - std::max(POSA.x, POSB.x));
                     if (INTERSECTLEN > longestIntersect) {
                         longestIntersect = INTERSECTLEN;
-                        longestIntersectMonitor = &m;
+                        longestIntersectMonitor = m.get();
                     }
                 }
                 break;
@@ -918,11 +1033,11 @@ SMonitor* CCompositor::getMonitorInDirection(const char& dir) {
 }
 
 void CCompositor::updateAllWindowsBorders() {
-    for (auto& w : m_lWindows) {
-        if (!w.m_bIsMapped)
+    for (auto& w : m_vWindows) {
+        if (!w->m_bIsMapped)
             continue;
 
-        updateWindowBorderColor(&w);
+        updateWindowBorderColor(w.get());
     }
 }
 
@@ -936,4 +1051,141 @@ void CCompositor::updateWindowBorderColor(CWindow* pWindow) {
         pWindow->m_cRealBorderColor = RENDERDATA.borderColor;
     else
         pWindow->m_cRealBorderColor = CColor(pWindow == m_pLastWindow ? *ACTIVECOL : *INACTIVECOL);
+}
+
+void CCompositor::moveWindowToWorkspace(CWindow* pWindow, const std::string& work) {
+    m_pLastWindow = pWindow;
+    g_pKeybindManager->moveActiveToWorkspace(work);
+
+    g_pInputManager->refocus();
+}
+
+int CCompositor::getNextAvailableMonitorID() {
+    int64_t topID = -1;
+    for (auto& m : m_vMonitors) {
+        if ((int64_t)m->ID > topID)
+            topID = m->ID;
+    }
+
+    return topID + 1;
+}
+
+void CCompositor::moveWorkspaceToMonitor(CWorkspace* pWorkspace, SMonitor* pMonitor) {
+
+    // We trust the workspace and monitor to be correct.
+
+    if (pWorkspace->m_iMonitorID == pMonitor->ID)
+        return;
+
+    Debug::log(LOG, "moveWorkspaceToMonitor: Moving %d to monitor %d", pWorkspace->m_iID, pMonitor->ID);
+
+    const auto POLDMON = getMonitorFromID(pWorkspace->m_iMonitorID);
+
+    const bool SWITCHINGISACTIVE = POLDMON->activeWorkspace == pWorkspace->m_iID;
+
+    // fix old mon
+    int nextWorkspaceOnMonitorID = -1;
+    for (auto& w : m_vWorkspaces) {
+        if (w->m_iMonitorID == POLDMON->ID && w->m_iID != pWorkspace->m_iID) {
+            nextWorkspaceOnMonitorID = w->m_iID;
+            break;
+        }
+    }
+
+    if (nextWorkspaceOnMonitorID == -1) {
+        nextWorkspaceOnMonitorID = 1;
+
+        while (getWorkspaceByID(nextWorkspaceOnMonitorID))
+            nextWorkspaceOnMonitorID++;
+
+        Debug::log(LOG, "moveWorkspaceToMonitor: Plugging gap with new %d", nextWorkspaceOnMonitorID);
+    }
+
+    Debug::log(LOG, "moveWorkspaceToMonitor: Plugging gap with existing %d", nextWorkspaceOnMonitorID);
+
+    g_pKeybindManager->focusMonitor(std::to_string(POLDMON->ID));
+    g_pKeybindManager->changeworkspace(std::to_string(nextWorkspaceOnMonitorID));
+
+    // move the workspace
+
+    pWorkspace->m_iMonitorID = pMonitor->ID;
+    pWorkspace->moveToMonitor(pMonitor->ID);
+
+    for (auto& w : m_vWindows) {
+        if (w->m_iWorkspaceID == pWorkspace->m_iID)
+            w->m_iMonitorID = pMonitor->ID;
+    }
+
+    if (SWITCHINGISACTIVE) { // if it was active, preserve its' status. If it wasn't, don't.
+        Debug::log(LOG, "moveWorkspaceToMonitor: SWITCHINGISACTIVE, active %d -> %d", pMonitor->activeWorkspace, pWorkspace->m_iID);
+
+        if (const auto PWORKSPACE = getWorkspaceByID(pMonitor->activeWorkspace); PWORKSPACE)
+            getWorkspaceByID(pMonitor->activeWorkspace)->startAnim(false, false);
+
+        pMonitor->activeWorkspace = pWorkspace->m_iID;
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitor->ID);
+
+        pWorkspace->startAnim(true, true, true);
+
+        wlr_cursor_warp(m_sWLRCursor, m_sSeat.mouse->mouse, pMonitor->vecPosition.x + pMonitor->vecTransformedSize.x / 2, pMonitor->vecPosition.y + pMonitor->vecTransformedSize.y / 2);
+    }
+
+    // finalize
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(POLDMON->ID);
+
+    g_pInputManager->refocus();
+}
+
+bool CCompositor::workspaceIDOutOfBounds(const int& id) {
+    int lowestID = 99999;
+    int highestID = -99999;
+
+    for (auto& w : m_vWorkspaces) {
+        if (w->m_iID < lowestID)
+            lowestID = w->m_iID;
+        
+        if (w->m_iID > highestID)
+            highestID = w->m_iID;
+    }
+
+    return std::clamp(id, lowestID, highestID) != id;
+}
+
+void CCompositor::setWindowFullscreen(CWindow* pWindow, bool on, eFullscreenMode mode) {
+    if (!windowValidMapped(pWindow))
+        return;
+
+    g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(pWindow, mode, on);
+
+    g_pXWaylandManager->setWindowFullscreen(pWindow, pWindow->m_bIsFullscreen && mode == FULLSCREEN_FULL);
+    // make all windows on the same workspace under the fullscreen window
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (w->m_iWorkspaceID == pWindow->m_iWorkspaceID)
+            w->m_bCreatedOverFullscreen = false;
+    }
+}
+
+void CCompositor::moveUnmanagedX11ToWindows(CWindow* pWindow) {
+    for (auto it = m_dUnmanagedX11Windows.begin(); it != m_dUnmanagedX11Windows.end(); it++) {
+        if (it->get() == pWindow) {
+            m_vWindows.emplace_back(std::move(*it));
+            m_dUnmanagedX11Windows.erase(it);
+            return;
+        }
+    }
+}
+
+CWindow* CCompositor::getX11Parent(CWindow* pWindow) {
+    if (!pWindow->m_bIsX11)
+        return nullptr;
+
+    for (auto& w : m_vWindows) {
+        if (!w->m_bIsX11)
+            continue;
+
+        if (w->m_uSurface.xwayland == pWindow->m_uSurface.xwayland->parent)
+            return w.get();
+    }
+    
+    return nullptr;
 }

src/Compositor.hpp

@@ -10,7 +10,7 @@
 #include "config/ConfigManager.hpp"
 #include "managers/ThreadManager.hpp"
 #include "managers/XWaylandManager.hpp"
-#include "managers/InputManager.hpp"
+#include "managers/input/InputManager.hpp"
 #include "managers/LayoutManager.hpp"
 #include "managers/KeybindManager.hpp"
 #include "managers/AnimationManager.hpp"
@@ -59,18 +59,22 @@ public:
     wlr_xdg_decoration_manager_v1*   m_sWLRXDGDecoMgr;
     wlr_virtual_pointer_manager_v1*  m_sWLRVirtPtrMgr;
     wlr_foreign_toplevel_manager_v1* m_sWLRToplevelMgr;
+    wlr_tablet_manager_v2*           m_sWLRTabletManager;
+    wlr_xdg_foreign_registry*        m_sWLRForeignRegistry;
     // ------------------------------------------------- //
 
 
     const char*             m_szWLDisplaySocket;
+    std::string             m_szInstanceSignature = "";
 
-    std::list<SMonitor>     m_lMonitors;
-    std::list<CWindow>      m_lWindows;
-    std::list<SXDGPopup>    m_lXDGPopups;
-    std::list<CWorkspace>   m_lWorkspaces;
-    std::list<SSubsurface>  m_lSubsurfaces;
-    std::list<CWindow*>     m_lWindowsFadingOut;
-    std::list<SLayerSurface*> m_lSurfacesFadingOut;
+    std::vector<std::unique_ptr<SMonitor>>      m_vMonitors;
+    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                    startCompositor(); 
     void                    cleanupExit();
@@ -97,7 +101,7 @@ public:
     CWindow*                vectorToWindow(const Vector2D&);
     CWindow*                vectorToWindowIdeal(const Vector2D&);
     CWindow*                vectorToWindowTiled(const Vector2D&);
-    wlr_surface*            vectorToLayerSurface(const Vector2D&, std::list<SLayerSurface*>*, Vector2D*);
+    wlr_surface*            vectorToLayerSurface(const Vector2D&, std::list<SLayerSurface*>*, Vector2D*, SLayerSurface**);
     wlr_surface*            vectorWindowToSurface(const Vector2D&, CWindow*, Vector2D& sl);
     CWindow*                windowFromCursor();
     CWindow*                windowFloatingFromCursor();
@@ -126,6 +130,13 @@ public:
     SMonitor*               getMonitorInDirection(const char&);
     void                    updateAllWindowsBorders();
     void                    updateWindowBorderColor(CWindow*);
+    void                    moveWindowToWorkspace(CWindow*, const std::string&);
+    int                     getNextAvailableMonitorID();
+    void                    moveWorkspaceToMonitor(CWorkspace*, SMonitor*);
+    bool                    workspaceIDOutOfBounds(const int&);
+    void                    setWindowFullscreen(CWindow*, bool, eFullscreenMode);
+    void                    moveUnmanagedX11ToWindows(CWindow*);
+    CWindow*                getX11Parent(CWindow*);
 
 private:
     void                    initAllSignals();

src/Window.cpp

@@ -1,11 +1,14 @@
 #include "Window.hpp"
 #include "Compositor.hpp"
+#include "render/decorations/CHyprDropShadowDecoration.hpp"
 
 CWindow::CWindow() {
     m_vRealPosition.create(AVARTYPE_VECTOR, &g_pConfigManager->getConfigValuePtr("animations:windows_speed")->floatValue, &g_pConfigManager->getConfigValuePtr("animations:windows")->intValue, &g_pConfigManager->getConfigValuePtr("animations:windows_curve")->strValue, (void*) this, AVARDAMAGE_ENTIRE);
     m_vRealSize.create(AVARTYPE_VECTOR, &g_pConfigManager->getConfigValuePtr("animations:windows_speed")->floatValue, &g_pConfigManager->getConfigValuePtr("animations:windows")->intValue, &g_pConfigManager->getConfigValuePtr("animations:windows_curve")->strValue, (void*)this, AVARDAMAGE_ENTIRE);
     m_cRealBorderColor.create(AVARTYPE_COLOR, &g_pConfigManager->getConfigValuePtr("animations:borders_speed")->floatValue, &g_pConfigManager->getConfigValuePtr("animations:borders")->intValue, &g_pConfigManager->getConfigValuePtr("animations:borders_curve")->strValue, (void*)this, AVARDAMAGE_BORDER);
     m_fAlpha.create(AVARTYPE_FLOAT, &g_pConfigManager->getConfigValuePtr("animations:fadein_speed")->floatValue, &g_pConfigManager->getConfigValuePtr("animations:fadein")->intValue, &g_pConfigManager->getConfigValuePtr("animations:fadein_curve")->strValue, (void*)this, AVARDAMAGE_ENTIRE);
+
+    m_dWindowDecorations.emplace_back(std::make_unique<CHyprDropShadowDecoration>(this)); // put the shadow so it's the first deco (has to be rendered first)
 }
 
 CWindow::~CWindow() {
@@ -13,4 +16,89 @@ CWindow::~CWindow() {
         g_pCompositor->m_pLastFocus = nullptr;
         g_pCompositor->m_pLastWindow = nullptr;
     }
-}
+}
+
+wlr_box CWindow::getFullWindowBoundingBox() {
+    static auto* const PBORDERSIZE = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
+
+    SWindowDecorationExtents maxExtents = {{*PBORDERSIZE + 1, *PBORDERSIZE + 1}, {*PBORDERSIZE + 1, *PBORDERSIZE + 1}};
+
+    for (auto& wd : m_dWindowDecorations) {
+
+        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;
+}
+
+wlr_box CWindow::getWindowIdealBoundingBoxIgnoreReserved() {
+
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+
+    auto POS = m_vPosition;
+    auto SIZE = m_vSize;
+
+    if (DELTALESSTHAN(POS.y - PMONITOR->vecPosition.y, PMONITOR->vecReservedTopLeft.y, 1)) {
+        POS.y = PMONITOR->vecPosition.y;
+        SIZE.y += PMONITOR->vecReservedTopLeft.y;
+    }
+    if (DELTALESSTHAN(POS.x - PMONITOR->vecPosition.x, PMONITOR->vecReservedTopLeft.x, 1)) {
+        POS.x = PMONITOR->vecPosition.x;
+        SIZE.x += PMONITOR->vecReservedTopLeft.x;
+    }
+    if (DELTALESSTHAN(POS.x + SIZE.x - PMONITOR->vecPosition.x, PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x, 1)) {
+        SIZE.x += PMONITOR->vecReservedBottomRight.x;
+    }
+    if (DELTALESSTHAN(POS.y + SIZE.y - PMONITOR->vecPosition.y, PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y, 1)) {
+        SIZE.y += PMONITOR->vecReservedBottomRight.y;
+    }
+
+    return wlr_box{(int)POS.x, (int)POS.y, (int)SIZE.x, (int)SIZE.y};
+}
+
+void CWindow::updateWindowDecos() {
+    for (auto& wd : m_dWindowDecorations)
+        wd->updateWindow(this);
+
+    for (auto& wd : m_vDecosToRemove) {
+        for (auto it = m_dWindowDecorations.begin(); it != m_dWindowDecorations.end(); it++) {
+            if (it->get() == wd) {
+                it = m_dWindowDecorations.erase(it);
+                if (it == m_dWindowDecorations.end())
+                    break;
+            }
+        }
+    }
+
+    m_vDecosToRemove.clear();
+}
+
+pid_t CWindow::getPID() {
+    pid_t PID = -1;
+    if (!m_bIsX11) {
+        const auto CLIENT = wl_resource_get_client(m_uSurface.xdg->resource);
+        wl_client_get_credentials(CLIENT, &PID, nullptr, nullptr);
+    } else {
+        PID = m_uSurface.xwayland->pid;
+    }
+
+    return PID;
+}

src/Window.hpp

@@ -9,11 +9,13 @@
 
 struct SWindowSpecialRenderData {
     float alpha = 1.f;
+    float alphaInactive = -1.f; // -1 means unset
 };  
 
 struct SWindowAdditionalConfigData {
     std::string animationStyle = "";
     int rounding = -1; // -1 means no
+    bool forceNoBlur = false;
 };
 
 class CWindow {
@@ -65,6 +67,7 @@ public:
     // XWayland stuff
     bool            m_bIsX11 = false;
     bool            m_bMappedX11 = false;
+    CWindow*        m_pX11Parent = nullptr;
     uint64_t        m_iX11Type = 0;
     bool            m_bIsModal = false;
     bool            m_bX11DoesntWantBorders = false;
@@ -74,6 +77,7 @@ public:
 
     // For nofocus
     bool            m_bNoFocus = false;
+    bool            m_bNoInitialFocus = false;
 
     SSurfaceTreeNode* m_pSurfaceTree = nullptr;
 
@@ -95,6 +99,7 @@ public:
 
     // Window decorations
     std::deque<std::unique_ptr<IHyprWindowDecoration>> m_dWindowDecorations;
+    std::vector<IHyprWindowDecoration*> m_vDecosToRemove;
 
     // Special render data, rules, etc
     SWindowSpecialRenderData m_sSpecialRenderData;
@@ -105,4 +110,10 @@ public:
         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 && m_bFadingOut == rhs.m_bFadingOut;
     }
 
-};
+    // methods
+    wlr_box         getFullWindowBoundingBox();
+    wlr_box         getWindowIdealBoundingBoxIgnoreReserved();
+    void            updateWindowDecos();
+    pid_t           getPID();
+
+};

src/config/ConfigManager.cpp

@@ -15,27 +15,35 @@ CConfigManager::CConfigManager() {
     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");
     configPaths.emplace_back(CONFIGPATH);
+
+    Debug::disableLogs = &configValues["debug:disable_logs"].intValue;
 }
 
 void CConfigManager::setDefaultVars() {
-    configValues["general:max_fps"].intValue = 240;
-    configValues["general:sensitivity"].floatValue = 0.25f;
-    configValues["general:apply_sens_to_raw"].intValue = 1;
+    configValues["general:max_fps"].intValue = 60;
+    configValues["general:sensitivity"].floatValue = 1.0f;
+    configValues["general:apply_sens_to_raw"].intValue = 0;
     configValues["general:main_mod"].strValue = "SUPER";                                               // exposed to the user for easier configuring
     configValues["general:main_mod_internal"].intValue = g_pKeybindManager->stringToModMask("SUPER");  // actually used and automatically calculated
 
-    configValues["general:damage_tracking"].strValue = "none";
-    configValues["general:damage_tracking_internal"].intValue = DAMAGE_TRACKING_NONE;
+    configValues["general:damage_tracking"].strValue = "full";
+    configValues["general:damage_tracking_internal"].intValue = DAMAGE_TRACKING_FULL;
 
     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;
     configValues["general:col.active_border"].intValue = 0xffffffff;
     configValues["general:col.inactive_border"].intValue = 0xff444444;
+    configValues["general:cursor_inactive_timeout"].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["experimental:vfr"].intValue = 0;
 
     configValues["decoration:rounding"].intValue = 1;
     configValues["decoration:blur"].intValue = 1;
@@ -45,12 +53,21 @@ void CConfigManager::setDefaultVars() {
     configValues["decoration:active_opacity"].floatValue = 1;
     configValues["decoration:inactive_opacity"].floatValue = 1;
     configValues["decoration:fullscreen_opacity"].floatValue = 1;
+    configValues["decoration:multisample_edges"].intValue = 1;
+    configValues["decoration:no_blur_on_oversized"].intValue = 1;
+    configValues["decoration:drop_shadow"].intValue = 1;
+    configValues["decoration:shadow_range"].intValue = 4;
+    configValues["decoration:shadow_render_power"].intValue = 3;
+    configValues["decoration:shadow_ignore_window"].intValue = 1;
+    configValues["decoration:shadow_offset"].strValue = "0 0";
+    configValues["decoration:col.shadow"].intValue = 0xee1a1a1a;
 
     configValues["dwindle:pseudotile"].intValue = 0;
     configValues["dwindle:col.group_border"].intValue = 0x66777700;
     configValues["dwindle:col.group_border_active"].intValue = 0x66ffff00;
     configValues["dwindle:force_split"].intValue = 0;
     configValues["dwindle:preserve_split"].intValue = 0;
+    configValues["dwindle:special_scale_factor"].floatValue = 0.8f;
 
     configValues["animations:enabled"].intValue = 1;
     configValues["animations:speed"].floatValue = 7.f;
@@ -72,7 +89,7 @@ void CConfigManager::setDefaultVars() {
     configValues["animations:workspaces_speed"].floatValue = 0.f;
     configValues["animations:workspaces"].intValue = 1;
 
-    configValues["input:kb_layout"].strValue = "en";
+    configValues["input:kb_layout"].strValue = "us";
     configValues["input:kb_variant"].strValue = STRVAL_EMPTY;
     configValues["input:kb_options"].strValue = STRVAL_EMPTY;
     configValues["input:kb_rules"].strValue = STRVAL_EMPTY;
@@ -80,13 +97,37 @@ void CConfigManager::setDefaultVars() {
     configValues["input:repeat_rate"].intValue = 25;
     configValues["input:repeat_delay"].intValue = 600;
     configValues["input:natural_scroll"].intValue = 0;
+    configValues["input:numlock_by_default"].intValue = 0;
+    configValues["input:force_no_accel"].intValue = 0;
+    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:middle_button_emulation"].intValue = 0;
+    configValues["input:touchpad:tap-to-click"].intValue = 1;
 
     configValues["input:follow_mouse"].intValue = 1;
 
     configValues["autogenerated"].intValue = 0;
 }
 
+void CConfigManager::setDeviceDefaultVars(const std::string& dev) {
+    auto& cfgValues = deviceConfigs[dev];
+
+    cfgValues["kb_layout"].strValue = "us";
+    cfgValues["kb_variant"].strValue = STRVAL_EMPTY;
+    cfgValues["kb_options"].strValue = STRVAL_EMPTY;
+    cfgValues["kb_rules"].strValue = STRVAL_EMPTY;
+    cfgValues["kb_model"].strValue = STRVAL_EMPTY;
+    cfgValues["repeat_rate"].intValue = 25;
+    cfgValues["repeat_delay"].intValue = 600;
+    cfgValues["natural_scroll"].intValue = 0;
+    cfgValues["numlock_by_default"].intValue = 0;
+    cfgValues["disable_while_typing"].intValue = 1;
+    cfgValues["clickfinger_behavior"].intValue = 0;
+    cfgValues["middle_button_emulation"].intValue = 0;
+    cfgValues["tap-to-click"].intValue = 1;
+}
+
 void CConfigManager::init() {
     
     loadConfigLoadVars();
@@ -116,33 +157,58 @@ void CConfigManager::configSetValueSafe(const std::string& COMMAND, const std::s
             parseError = "Error setting value <" + VALUE + "> for field <" + COMMAND + ">: No such field.";
         }
 
-        return;
+        if (COMMAND.find("device:") == 0 /* devices parsed later */) {
+            parseError = "";
+        } else {
+            return;
+        }
     }
 
+    SConfigValue* CONFIGENTRY = nullptr;
 
-    auto& CONFIGENTRY = configValues.at(COMMAND);
-    if (CONFIGENTRY.intValue != -1) {
+    if (COMMAND.find("device:") == 0) {
+        const auto DEVICE = COMMAND.substr(7).substr(0, COMMAND.find_last_of(':') - 7);
+        const auto CONFIGVAR = COMMAND.substr(COMMAND.find_last_of(':') + 1);
+
+        if (!deviceConfigExists(DEVICE))
+            setDeviceDefaultVars(DEVICE);
+
+        auto it = deviceConfigs.find(DEVICE);
+
+        if (it->second.find(CONFIGVAR) == it->second.end()) {
+            parseError = "Error setting value <" + VALUE + "> for field <" + COMMAND + ">: No such field.";
+            return;
+        }
+
+        CONFIGENTRY = &it->second.at(CONFIGVAR);
+    } else {
+        CONFIGENTRY = &configValues.at(COMMAND);
+    }
+
+    CONFIGENTRY->set = true;
+
+    if (CONFIGENTRY->intValue != -1) {
         try {
             if (VALUE.find("0x") == 0) {
                 // Values with 0x are hex
                 const auto VALUEWITHOUTHEX = VALUE.substr(2);
-                CONFIGENTRY.intValue = stol(VALUEWITHOUTHEX, nullptr, 16);
+                CONFIGENTRY->intValue = stol(VALUEWITHOUTHEX, nullptr, 16);
             } else
-                CONFIGENTRY.intValue = stol(VALUE);
+                CONFIGENTRY->intValue = stol(VALUE);
         } catch (...) {
             Debug::log(WARN, "Error reading value of %s", COMMAND.c_str());
             parseError = "Error setting value <" + VALUE + "> for field <" + COMMAND + ">.";
         }
-    } else if (CONFIGENTRY.floatValue != -1) {
+    } else if (CONFIGENTRY->floatValue != -1) {
         try {
-            CONFIGENTRY.floatValue = stof(VALUE);
+            CONFIGENTRY->floatValue = stof(VALUE);
         } catch (...) {
             Debug::log(WARN, "Error reading value of %s", COMMAND.c_str());
             parseError = "Error setting value <" + VALUE + "> for field <" + COMMAND + ">.";
         }
-    } else if (CONFIGENTRY.strValue != "") {
+    } else if (CONFIGENTRY->strValue != "") {
         try {
-            CONFIGENTRY.strValue = VALUE;
+            CONFIGENTRY->strValue = VALUE;
         } catch (...) {
             Debug::log(WARN, "Error reading value of %s", COMMAND.c_str());
             parseError = "Error setting value <" + VALUE + "> for field <" + COMMAND + ">.";
@@ -152,11 +218,57 @@ void CConfigManager::configSetValueSafe(const std::string& COMMAND, const std::s
 
 void CConfigManager::handleRawExec(const std::string& command, const std::string& args) {
     // Exec in the background dont wait for it.
-    if (fork() == 0) {
-        execl("/bin/sh", "/bin/sh", "-c", args.c_str(), nullptr);
 
+    std::string toExec = args;
+
+    if (g_pXWaylandManager->m_sWLRXWayland)
+        toExec = std::string("WAYLAND_DISPLAY=") + std::string(g_pCompositor->m_szWLDisplaySocket) + " DISPLAY=" + std::string(g_pXWaylandManager->m_sWLRXWayland->display_name) + " " + toExec;
+    else
+        toExec = std::string("WAYLAND_DISPLAY=") + std::string(g_pCompositor->m_szWLDisplaySocket) + " " + toExec;
+
+    Debug::log(LOG, "Config executing %s", toExec.c_str());
+
+    int socket[2];
+    if (pipe(socket) != 0) {
+        Debug::log(LOG, "Unable to create pipe for fork");
+    }
+
+    pid_t child, grandchild;
+    child = fork();
+    if (child < 0) {
+        close(socket[0]);
+        close(socket[1]);
+        Debug::log(LOG, "Fail to create the first fork");
+        return;
+    }
+    if (child == 0) {
+        // run in child
+        grandchild = fork();
+        if (grandchild == 0) {
+            // run in grandchild
+            close(socket[0]);
+            close(socket[1]);
+            execl("/bin/sh", "/bin/sh", "-c", args.c_str(), nullptr);
+            // exit grandchild
+            _exit(0);
+        }
+        close(socket[0]);
+        write(socket[1], &grandchild, sizeof(grandchild));
+        close(socket[1]);
+        // exit child
         _exit(0);
     }
+    // run in parent
+    close(socket[1]);
+    read(socket[0], &grandchild, sizeof(grandchild));
+    close(socket[0]);
+    // clear child and leave child to init
+    waitpid(child, NULL, 0);
+    if (child < 0) {
+        Debug::log(LOG, "Fail to create the second fork");
+        return;
+    }
+    Debug::log(LOG, "Process created with pid %d", grandchild);
 }
 
 void CConfigManager::handleMonitor(const std::string& command, const std::string& args) {
@@ -361,7 +473,7 @@ void CConfigManager::handleAnimation(const std::string& command, const std::stri
     configSetValueSafe("animations:" + ANIMNAME + "_style", curitem);
 }
 
-void CConfigManager::handleBind(const std::string& command, const std::string& value) {
+void CConfigManager::handleBind(const std::string& command, const std::string& value, bool locked) {
     // example:
     // bind=SUPER,G,exec,dmenu_run <args>
 
@@ -394,7 +506,7 @@ void CConfigManager::handleBind(const std::string& command, const std::string& v
     }
 
     if (KEY != "")
-        g_pKeybindManager->addKeybind(SKeybind{KEY, MOD, HANDLER, COMMAND});
+        g_pKeybindManager->addKeybind(SKeybind{KEY, MOD, HANDLER, COMMAND, locked, m_szCurrentSubmap});
 }
 
 void CConfigManager::handleUnbind(const std::string& command, const std::string& value) {
@@ -425,7 +537,9 @@ void CConfigManager::handleWindowRule(const std::string& command, const std::str
         && RULE.find("size") != 0
         && RULE.find("pseudo") != 0
         && RULE.find("monitor") != 0
-        && RULE.find("nofocus") != 0
+        && RULE != "nofocus"
+        && RULE != "noblur"
+        && RULE != "fullscreen"
         && RULE.find("animation") != 0
         && RULE.find("rounding") != 0
         && RULE.find("workspace") != 0) {
@@ -441,16 +555,23 @@ void CConfigManager::handleWindowRule(const std::string& command, const std::str
 void CConfigManager::handleDefaultWorkspace(const std::string& command, const std::string& value) {
 
     const auto DISPLAY = value.substr(0, value.find_first_of(','));
-    const auto WORKSPACEID = stoi(value.substr(value.find_first_of(',') + 1));
+    const auto WORKSPACE = value.substr(value.find_first_of(',') + 1);
 
     for (auto& mr : m_dMonitorRules) {
         if (mr.name == DISPLAY) {
-            mr.defaultWorkspaceID = WORKSPACEID;
+            mr.defaultWorkspace = WORKSPACE;
             break;
         }
     }
 }
 
+void CConfigManager::handleSubmap(const std::string& command, const std::string& submap) {
+    if (submap == "reset") 
+        m_szCurrentSubmap = "";
+    else
+        m_szCurrentSubmap = submap;
+}
+
 void CConfigManager::handleSource(const std::string& command, const std::string& rawpath) {
     static const char* const ENVHOME = getenv("HOME");
 
@@ -524,12 +645,14 @@ std::string CConfigManager::parseKeyword(const std::string& COMMAND, const std::
     }
     else if (COMMAND == "monitor") handleMonitor(COMMAND, VALUE);
     else if (COMMAND == "bind") handleBind(COMMAND, VALUE);
+    else if (COMMAND == "bindl") handleBind(COMMAND, VALUE, true);
     else if (COMMAND == "unbind") handleUnbind(COMMAND, VALUE);
     else if (COMMAND == "workspace") handleDefaultWorkspace(COMMAND, VALUE);
     else if (COMMAND == "windowrule") handleWindowRule(COMMAND, VALUE);
     else if (COMMAND == "bezier") handleBezier(COMMAND, VALUE);
     else if (COMMAND == "animation") handleAnimation(COMMAND, VALUE);
     else if (COMMAND == "source") handleSource(COMMAND, VALUE);
+    else if (COMMAND == "submap") handleSubmap(COMMAND, VALUE);
     else
         configSetValueSafe(currentCategory + (currentCategory == "" ? "" : ":") + COMMAND, VALUE);
 
@@ -538,8 +661,8 @@ std::string CConfigManager::parseKeyword(const std::string& COMMAND, const std::
         parseError = "";
 
         // invalidate layouts jic
-        for (auto& m : g_pCompositor->m_lMonitors)
-            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m.ID);
+        for (auto& m : g_pCompositor->m_vMonitors)
+            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
 
         // Update window border colors
         g_pCompositor->updateAllWindowsBorders();
@@ -631,12 +754,14 @@ void CConfigManager::loadConfigLoadVars() {
     g_pAnimationManager->removeAllBeziers();
     m_mAdditionalReservedAreas.clear();
     configDynamicVars.clear();
+    deviceConfigs.clear();
 
     // paths
     configPaths.clear();
 
     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");
+    const std::string CONFIGPARENTPATH = ENVHOME + (std::string) "/.config/hypr/";
+    const std::string CONFIGPATH = CONFIGPARENTPATH + (ISDEBUG ? "hyprlandd.conf" : "hyprland.conf");
 
     configPaths.push_back(CONFIGPATH);
 
@@ -649,6 +774,15 @@ void CConfigManager::loadConfigLoadVars() {
             std::filesystem::rename(CONFIGPATH, CONFIGPATH + ".backup");
         } catch(...) { /* Probably doesn't exist */}
 
+        try {
+            if (!std::filesystem::is_directory(CONFIGPARENTPATH))
+                std::filesystem::create_directories(CONFIGPARENTPATH);
+        }
+        catch (...) {
+            parseError = "Broken config file! (Could not create directory)";
+            return;
+        }
+
         std::ofstream ofs;
         ofs.open(CONFIGPATH, std::ios::trunc);
 
@@ -689,8 +823,8 @@ void CConfigManager::loadConfigLoadVars() {
         ifs.close();
     }
 
-    for (auto& m : g_pCompositor->m_lMonitors)
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m.ID);
+    for (auto& m : g_pCompositor->m_vMonitors)
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
 
     // Update the keyboard layout to the cfg'd one if this is not the first launch
     if (!isFirstLaunch)
@@ -723,6 +857,10 @@ void CConfigManager::loadConfigLoadVars() {
 
     // Update window border colors
     g_pCompositor->updateAllWindowsBorders();
+
+    // Force the compositor to fully re-render all monitors
+    for (auto& m : g_pCompositor->m_vMonitors)
+        m->forceFullFrames = 2;
 }
 
 void CConfigManager::tick() {
@@ -760,7 +898,7 @@ void CConfigManager::tick() {
 }
 
 std::mutex configmtx;
-SConfigValue CConfigManager::getConfigValueSafe(std::string val) {
+SConfigValue CConfigManager::getConfigValueSafe(const std::string& val) {
     std::lock_guard<std::mutex> lg(configmtx);
 
     SConfigValue copy = configValues[val];
@@ -768,15 +906,38 @@ SConfigValue CConfigManager::getConfigValueSafe(std::string val) {
     return copy;
 }
 
-int CConfigManager::getInt(std::string v) {
+SConfigValue CConfigManager::getConfigValueSafeDevice(const std::string& dev, const std::string& val) {
+    std::lock_guard<std::mutex> lg(configmtx);
+
+    const auto it = deviceConfigs.find(dev);
+
+    if (it == deviceConfigs.end()) {
+        return SConfigValue();
+    }
+
+    SConfigValue copy = it->second[val];
+
+    // fallback if not set explicitly
+    if (!copy.set) {
+        for (auto& cv : configValues) {
+            if (cv.first.find(val) == cv.first.length() - val.length()) {
+                copy = cv.second;
+            }
+        }
+    }
+
+    return copy;
+}
+
+int CConfigManager::getInt(const std::string& v) {
     return getConfigValueSafe(v).intValue;
 }
 
-float CConfigManager::getFloat(std::string v) {
+float CConfigManager::getFloat(const std::string& v) {
     return getConfigValueSafe(v).floatValue;
 }
 
-std::string CConfigManager::getString(std::string v) {
+std::string CConfigManager::getString(const std::string& v) {
     const auto VAL = getConfigValueSafe(v).strValue;
 
     if (VAL == STRVAL_EMPTY)
@@ -785,6 +946,23 @@ std::string CConfigManager::getString(std::string v) {
     return VAL;
 }
 
+int CConfigManager::getDeviceInt(const std::string& dev, const std::string& v) {
+    return getConfigValueSafeDevice(dev, v).intValue;
+}
+
+float CConfigManager::getDeviceFloat(const std::string& dev, const std::string& v) {
+    return getConfigValueSafeDevice(dev, v).floatValue;
+}
+
+std::string CConfigManager::getDeviceString(const std::string& dev, const std::string& v) {
+    const auto VAL = getConfigValueSafeDevice(dev, v).strValue;
+
+    if (VAL == STRVAL_EMPTY)
+        return "";
+
+    return VAL;
+}
+
 void CConfigManager::setInt(std::string v, int val) {
     configValues[v].intValue = val;
 }
@@ -836,15 +1014,26 @@ std::vector<SWindowRule> CConfigManager::getMatchingRules(CWindow* pWindow) {
     std::string title = g_pXWaylandManager->getTitle(pWindow);
     std::string appidclass = g_pXWaylandManager->getAppIDClass(pWindow);
 
+    Debug::log(LOG, "Searching for matching rules for %s (title: %s)", appidclass.c_str(), title.c_str());
+
     for (auto& rule : m_dWindowRules) {
         // check if we have a matching rule
         try {
-            std::regex classCheck(rule.szValue);
+            if (rule.szValue.find("title:") == 0) {
+                // we have a title rule.
+                std::regex RULECHECK(rule.szValue.substr(6));
 
-            if (!std::regex_search(title, classCheck) && !std::regex_search(appidclass, classCheck))
-                continue;
+                if (!std::regex_search(title, RULECHECK))
+                    continue;
+            } else {
+                std::regex classCheck(rule.szValue);
+
+                if (!std::regex_search(appidclass, classCheck))
+                    continue;
+            }
         } catch (...) {
             Debug::log(ERR, "Regex error at %s", rule.szValue.c_str());
+            continue;
         }
 
         // applies. Read the rule and behave accordingly
@@ -870,14 +1059,30 @@ void CConfigManager::dispatchExecOnce() {
 }
 
 void CConfigManager::performMonitorReload() {
-    for (auto& m : g_pCompositor->m_lMonitors) {
-        auto rule = getMonitorRuleFor(m.szName);
-        g_pHyprRenderer->applyMonitorRule(&m, &rule);
+
+    bool overAgain = false;
+
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        auto rule = getMonitorRuleFor(m->szName);
+        if (!g_pHyprRenderer->applyMonitorRule(m.get(), &rule)) {
+            overAgain = true;
+            break;
+        }
     }
 
+    if (overAgain)
+        performMonitorReload();
+
     m_bWantsMonitorReload = false;
 }
 
 SConfigValue* CConfigManager::getConfigValuePtr(std::string val) {
     return &configValues[val];
 }
+
+bool CConfigManager::deviceConfigExists(const std::string& dev) {
+    const auto it = deviceConfigs.find(dev);
+
+    return it != deviceConfigs.end();
+}
+

src/config/ConfigManager.hpp

@@ -20,6 +20,8 @@ struct SConfigValue {
     int64_t intValue = -1;
     float floatValue = -1;
     std::string strValue = "";
+
+    bool set = false; // used for device configs
 };
 
 struct SMonitorRule {
@@ -28,7 +30,7 @@ struct SMonitorRule {
     Vector2D    offset = Vector2D(0,0);
     float       scale = 1;
     float       refreshRate = 60;
-    int         defaultWorkspaceID = -1;
+    std::string defaultWorkspace = "";
     bool        disabled = false;
     wl_output_transform transform = WL_OUTPUT_TRANSFORM_NORMAL;
 };
@@ -52,13 +54,18 @@ public:
     void                tick();
     void                init();
 
-    int                 getInt(std::string);
-    float               getFloat(std::string);
-    std::string         getString(std::string);
+    int                 getInt(const std::string&);
+    float               getFloat(const std::string&);
+    std::string         getString(const std::string&);
     void                setFloat(std::string, float);
     void                setInt(std::string, int);
     void                setString(std::string, std::string);
 
+    int                 getDeviceInt(const std::string&, const std::string&);
+    float               getDeviceFloat(const std::string&, const std::string&);
+    std::string         getDeviceString(const std::string&, const std::string&);
+    bool                deviceConfigExists(const std::string&);
+
     SConfigValue*       getConfigValuePtr(std::string);
 
     SMonitorRule        getMonitorRuleFor(std::string);
@@ -81,6 +88,7 @@ private:
     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::string                                   configCurrentPath;
 
@@ -88,6 +96,8 @@ private:
 
     std::string parseError = "";  // For storing a parse error to display later
 
+    std::string m_szCurrentSubmap = ""; // For storing the current keybind submap
+
     bool isFirstLaunch = true;  // For exec-once
 
     std::deque<SMonitorRule> m_dMonitorRules;
@@ -98,21 +108,25 @@ private:
 
     // internal methods
     void                setDefaultVars();
+    void                setDeviceDefaultVars(const std::string&);
 
     void                applyUserDefinedVars(std::string&, const size_t);
     void                loadConfigLoadVars();
-    SConfigValue        getConfigValueSafe(std::string);
+    SConfigValue        getConfigValueSafe(const std::string&);
+    SConfigValue        getConfigValueSafeDevice(const std::string&, const std::string&);
     void                parseLine(std::string&);
     void                configSetValueSafe(const std::string&, const std::string&);
+    void                handleDeviceConfig(const std::string&, const std::string&);
     void                handleRawExec(const std::string&, const std::string&);
     void                handleMonitor(const std::string&, const std::string&);
-    void                handleBind(const std::string&, const std::string&);
+    void                handleBind(const std::string&, const std::string&, bool locked = false);
     void                handleUnbind(const std::string&, const std::string&);
     void                handleWindowRule(const std::string&, const std::string&);
     void                handleDefaultWorkspace(const std::string&, const std::string&);
     void                handleBezier(const std::string&, const std::string&);
     void                handleAnimation(const std::string&, const std::string&);
     void                handleSource(const std::string&, const std::string&);
+    void                handleSubmap(const std::string&, const std::string&);
 };
 
 inline std::unique_ptr<CConfigManager> g_pConfigManager;

src/config/defaultConfig.hpp

@@ -24,8 +24,7 @@ input {
 }
 
 general {
-    max_fps=60 # deprecated, unused
-    sensitivity=0.25
+    sensitivity=1.0 # for mouse cursor
     main_mod=SUPER
 
     gaps_in=5
@@ -34,7 +33,9 @@ general {
     col.active_border=0x66ee1111
     col.inactive_border=0x66333333
 
-    damage_tracking=full # experimental, monitor is 100% fine, but full might have some minor bugs, especially with high blur settings!
+    apply_sens_to_raw=0 # whether to apply the sensitivity to raw input (e.g. used by games where you aim using your mouse)
+
+    damage_tracking=full # leave it on full unless you hate your GPU and want to make it suffer
 }
 
 decoration {
@@ -70,6 +71,7 @@ dwindle {
 
 # example binds
 bind=SUPER,Q,exec,kitty
+bind=SUPER,RETURN,exec,alacritty
 bind=SUPER,C,killactive,
 bind=SUPER,M,exit,
 bind=SUPER,E,exec,dolphin

src/debug/HyprCtl.cpp

@@ -15,9 +15,9 @@
 
 std::string monitorsRequest() {
     std::string result = "";
-    for (auto& m : g_pCompositor->m_lMonitors) {
-        result += getFormat("Monitor %s (ID %i):\n\t%ix%i@%f at %ix%i\n\tactive workspace: %i (%s)\n\treserved: %i %i %i %i\n\n",
-                            m.szName.c_str(), m.ID, (int)m.vecSize.x, (int)m.vecSize.y, m.refreshRate, (int)m.vecPosition.x, (int)m.vecPosition.y, 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);
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        result += getFormat("Monitor %s (ID %i):\n\t%ix%i@%f at %ix%i\n\tactive workspace: %i (%s)\n\treserved: %i %i %i %i\n\tscale: %.2f\n\ttransform: %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->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);
     }
 
     return result;
@@ -25,18 +25,21 @@ std::string monitorsRequest() {
 
 std::string clientsRequest() {
     std::string result = "";
-    for (auto& w : g_pCompositor->m_lWindows) {
-        result += getFormat("Window %x -> %s:\n\tat: %i,%i\n\tsize: %i, %i\n\tworkspace: %i (%s)\n\tfloating: %i\n\n",
-                            &w, w.m_szTitle.c_str(), (int)w.m_vRealPosition.vec().x, (int)w.m_vRealPosition.vec().y, (int)w.m_vRealSize.vec().x, (int)w.m_vRealSize.vec().y, w.m_iWorkspaceID, (w.m_iWorkspaceID == -1 ? "" : g_pCompositor->getWorkspaceByID(w.m_iWorkspaceID)->m_szName.c_str()), (int)w.m_bIsFloating);
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (w->m_bIsMapped) {
+            result += 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\n",
+                            &w, w->m_szTitle.c_str(), (int)w->m_vRealPosition.vec().x, (int)w->m_vRealPosition.vec().y, (int)w->m_vRealSize.vec().x, (int)w->m_vRealSize.vec().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.get()).c_str(), g_pXWaylandManager->getTitle(w.get()).c_str(), w->getPID());
+    
+        }
     }
     return result;
 }
 
 std::string workspacesRequest() {
     std::string result = "";
-    for (auto& w : g_pCompositor->m_lWorkspaces) {
+    for (auto& w : g_pCompositor->m_vWorkspaces) {
         result += getFormat("workspace ID %i (%s) on monitor %s:\n\twindows: %i\n\thasfullscreen: %i\n\n",
-                            w.m_iID, w.m_szName.c_str(), g_pCompositor->getMonitorFromID(w.m_iMonitorID)->szName.c_str(), g_pCompositor->getWindowsOnWorkspace(w.m_iID), (int)w.m_bHasFullscreenWindow);
+                            w->m_iID, w->m_szName.c_str(), g_pCompositor->getMonitorFromID(w->m_iMonitorID)->szName.c_str(), g_pCompositor->getWindowsOnWorkspace(w->m_iID), (int)w->m_bHasFullscreenWindow);
     }
     return result;
 }
@@ -47,17 +50,17 @@ std::string activeWindowRequest() {
     if (!g_pCompositor->windowValidMapped(PWINDOW))
         return "Invalid";
 
-    return getFormat("Window %x -> %s:\n\tat: %i,%i\n\tsize: %i, %i\n\tworkspace: %i (%s)\n\tfloating: %i\n\n",
-                        PWINDOW, PWINDOW->m_szTitle.c_str(), (int)PWINDOW->m_vRealPosition.vec().x, (int)PWINDOW->m_vRealPosition.vec().y, (int)PWINDOW->m_vRealSize.vec().x, (int)PWINDOW->m_vRealSize.vec().y, PWINDOW->m_iWorkspaceID, (PWINDOW->m_iWorkspaceID == -1 ? "" : g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID)->m_szName.c_str()), (int)PWINDOW->m_bIsFloating);
+    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\n",
+                        PWINDOW, PWINDOW->m_szTitle.c_str(), (int)PWINDOW->m_vRealPosition.vec().x, (int)PWINDOW->m_vRealPosition.vec().y, (int)PWINDOW->m_vRealSize.vec().x, (int)PWINDOW->m_vRealSize.vec().y, PWINDOW->m_iWorkspaceID, (PWINDOW->m_iWorkspaceID == -1 ? "" : g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID)->m_szName.c_str()), (int)PWINDOW->m_bIsFloating, (int)PWINDOW->m_iMonitorID, g_pXWaylandManager->getAppIDClass(PWINDOW).c_str(), g_pXWaylandManager->getTitle(PWINDOW).c_str(), PWINDOW->getPID());
 }
 
 std::string layersRequest() {
     std::string result = "";
 
-    for (auto& mon : g_pCompositor->m_lMonitors) {
+    for (auto& mon : g_pCompositor->m_vMonitors) {
         result += getFormat("Monitor %s:\n");
         int layerLevel = 0;
-        for (auto& level : mon.m_aLayerSurfaceLists) {
+        for (auto& level : mon->m_aLayerSurfaceLists) {
             result += getFormat("\tLayer level %i:\n", layerLevel);
 
             for (auto& layer : level) {
@@ -72,6 +75,38 @@ std::string layersRequest() {
     return result;
 }
 
+std::string devicesRequest() {
+    std::string result = "";
+
+    result += "mice:\n";
+
+    for (auto& m : g_pInputManager->m_lMice) {
+        result += getFormat("\tMouse at %x:\n\t\t%s\n", &m, m.mouse->name);
+    }
+
+    result += "\n\nKeyboards:\n";
+
+    for (auto& k : g_pInputManager->m_lKeyboards) {
+        result += getFormat("\tKeyboard at %x:\n\t\t%s\n", &k, k.keyboard->name);
+    }
+
+    result += "\n\nTablets:\n";
+
+    for (auto& d : g_pInputManager->m_lTabletPads) {
+        result += getFormat("\tTablet Pad at %x (belongs to %x -> %s)\n", &d, d.pTabletParent, d.pTabletParent ? d.pTabletParent->wlrDevice ? d.pTabletParent->wlrDevice->name : "" : "");
+    }
+
+    for (auto& d : g_pInputManager->m_lTablets) {
+        result += getFormat("\tTablet at %x:\n\t\t%s\n", &d, d.wlrDevice ? d.wlrDevice->name : "");
+    }
+
+    for (auto& d : g_pInputManager->m_lTabletTools) {
+        result += getFormat("\tTablet Tool at %x (belongs to %x)\n", &d, d.wlrTabletTool ? d.wlrTabletTool->data : 0);
+    }
+
+    return result;
+}
+
 std::string versionRequest() {
     std::string result = "Hyprland, built from branch " + std::string(GIT_BRANCH) + " at commit " + GIT_COMMIT_HASH + GIT_DIRTY + " (" + GIT_COMMIT_MESSAGE + ").\nflags: (if any)\n";
 
@@ -81,6 +116,9 @@ std::string versionRequest() {
 #ifndef NDEBUG
     result += "debug\n";
 #endif
+#ifdef HYPRLAND_DEBUG
+	result += "debug\n";
+#endif
 #ifdef NO_XWAYLAND
     result += "no xwayland\n";
 #endif
@@ -137,6 +175,12 @@ std::string reloadRequest() {
     return "ok";
 }
 
+std::string killRequest() {
+    g_pInputManager->setClickMode(CLICKMODE_KILL);
+
+    return "ok";
+}
+
 std::string getReply(std::string);
 
 std::string dispatchBatch(std::string request) {
@@ -178,6 +222,8 @@ std::string getReply(std::string request) {
         return workspacesRequest();
     else if (request == "clients")
         return clientsRequest();
+    else if (request == "kill")
+        return killRequest();
     else if (request == "activewindow")
         return activeWindowRequest();
     else if (request == "layers")
@@ -186,6 +232,8 @@ std::string getReply(std::string request) {
         return versionRequest();
     else if (request == "reload")
         return reloadRequest();
+    else if (request == "devices")
+        return devicesRequest();
     else if (request.find("dispatch") == 0)
         return dispatchRequest(request);
     else if (request.find("keyword") == 0)
@@ -216,6 +264,14 @@ void HyprCtl::tickHyprCtl() {
 }
 
 std::string getRequestFromThread(std::string rq) {
+    // we need to do something to wake hyprland up if VFR is enabled
+    static auto *const VFRENABLED = &g_pConfigManager->getConfigValuePtr("experimental:vfr")->intValue;
+    if (*VFRENABLED) {
+        // TODO: is this safe...?
+        // this might be a race condition
+        wlr_output_schedule_frame(g_pCompositor->m_vMonitors.front()->output);
+    }
+
     while (HyprCtl::request != "" || HyprCtl::requestMade || HyprCtl::requestReady) {
         std::this_thread::sleep_for(std::chrono::milliseconds(5));
     }
@@ -246,11 +302,11 @@ void HyprCtl::startHyprCtlSocket() {
             return;
         }
 
-        unlink("/tmp/hypr/.socket.sock");
-
         sockaddr_un SERVERADDRESS = {.sun_family = AF_UNIX};
 
-        strcpy(SERVERADDRESS.sun_path, "/tmp/hypr/.socket.sock");
+        std::string socketPath = "/tmp/hypr/" + g_pCompositor->m_szInstanceSignature + "/.socket.sock";
+
+        strcpy(SERVERADDRESS.sun_path, socketPath.c_str());
 
         bind(SOCKET, (sockaddr*)&SERVERADDRESS, SUN_LEN(&SERVERADDRESS));
 
@@ -262,7 +318,7 @@ void HyprCtl::startHyprCtlSocket() {
 
         char readBuffer[1024] = {0};
 
-        Debug::log(LOG, "Hypr socket started.");
+        Debug::log(LOG, "Hypr socket started at %s", socketPath.c_str());
 
         while(1) {
             const auto ACCEPTEDCONNECTION = accept(SOCKET, (sockaddr*)&clientAddress, &clientSize);

src/debug/HyprDebugOverlay.cpp

@@ -120,7 +120,7 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
     yOffset += 11;
 
     g_pHyprRenderer->damageBox(&m_wbLastDrawnBox);
-    m_wbLastDrawnBox = {(int)g_pCompositor->m_lMonitors.front().vecPosition.x, (int)g_pCompositor->m_lMonitors.front().vecPosition.y + offset - 1, (int)maxX + 2, yOffset - offset + 2};
+    m_wbLastDrawnBox = {(int)g_pCompositor->m_vMonitors.front()->vecPosition.x, (int)g_pCompositor->m_vMonitors.front()->vecPosition.y + offset - 1, (int)maxX + 2, yOffset - offset + 2};
     g_pHyprRenderer->damageBox(&m_wbLastDrawnBox);
 
     return yOffset - offset;
@@ -140,7 +140,7 @@ void CHyprDebugOverlay::frameData(SMonitor* pMonitor) {
 
 void CHyprDebugOverlay::draw() {
 
-    const auto PMONITOR = &g_pCompositor->m_lMonitors.front();
+    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);
@@ -155,8 +155,8 @@ void CHyprDebugOverlay::draw() {
 
     // draw the things
     int offsetY = 0;
-    for (auto& m : g_pCompositor->m_lMonitors) {
-        offsetY += m_mMonitorOverlays[&m].draw(offsetY);
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        offsetY += m_mMonitorOverlays[m.get()].draw(offsetY);
         offsetY += 5; // for padding between mons
     }
 

src/debug/Log.cpp

@@ -1,15 +1,25 @@
 #include "Log.hpp"
 #include "../defines.hpp"
+#include "../Compositor.hpp"
 
 #include <fstream>
 #include <iostream>
 
+void Debug::init(std::string IS) {
+    if (ISDEBUG)
+        logFile = "/tmp/hypr/" + IS + "/hyprlandd.log";
+    else
+        logFile = "/tmp/hypr/" + IS + "/hyprland.log";
+}
+
 void Debug::log(LogLevel level, const char* fmt, ...) {
 
+    if (disableLogs && *disableLogs)
+        return;
+
     // log to a file
-    const std::string DEBUGPATH = ISDEBUG ? "/tmp/hypr/hyprlandd.log" : "/tmp/hypr/hyprland.log";
     std::ofstream ofs;
-    ofs.open(DEBUGPATH, std::ios::out | std::ios::app);
+    ofs.open(logFile, std::ios::out | std::ios::app);
 
     switch (level) {
         case LOG:
@@ -24,6 +34,9 @@ void Debug::log(LogLevel level, const char* fmt, ...) {
         case CRIT:
             ofs << "[CRITICAL] ";
             break;
+        case INFO:
+            ofs << "[INFO] ";
+            break;
         default:
             break;
     }

src/debug/Log.hpp

@@ -8,9 +8,14 @@ enum LogLevel {
     LOG = 0,
     WARN,
     ERR,
-    CRIT
+    CRIT,
+    INFO
 };
 
 namespace Debug {
+    void init(std::string IS);
     void log(LogLevel level, const char* fmt, ...);
+
+    inline std::string logFile;
+    inline int64_t* disableLogs = nullptr;
 };

src/defines.hpp

@@ -7,10 +7,14 @@
 #include "wlrunstable/wlr_ext_workspace_v1.hpp"
 
 #ifndef NDEBUG
+#ifdef HYPRLAND_DEBUG
 #define ISDEBUG true
 #else
 #define ISDEBUG false
 #endif
+#else
+#define ISDEBUG false
+#endif
 
 #define RIP(format, ... ) { fprintf(stderr, format "\n", ##__VA_ARGS__); exit(EXIT_FAILURE); }
 
@@ -64,4 +68,6 @@
 #endif
 #ifndef GIT_DIRTY
 #define GIT_DIRTY "?"
-#endif
+#endif
+
+#define SPECIAL_WORKSPACE_ID -99

src/events/Devices.cpp

@@ -2,7 +2,7 @@
 
 #include "../Compositor.hpp"
 #include "../helpers/WLClasses.hpp"
-#include "../managers/InputManager.hpp"
+#include "../managers/input/InputManager.hpp"
 #include "../render/Renderer.hpp"
 
 // ---------------------------------------------------- //
@@ -56,9 +56,8 @@ void Events::listener_mouseAxis(wl_listener* listener, void* data) {
 
 void Events::listener_requestMouse(wl_listener* listener, void* data) {
     const auto EVENT = (wlr_seat_pointer_request_set_cursor_event*)data;
-    
-    if (EVENT->seat_client == g_pCompositor->m_sSeat.seat->pointer_state.focused_client)
-        wlr_cursor_set_surface(g_pCompositor->m_sWLRCursor, EVENT->surface, EVENT->hotspot_x, EVENT->hotspot_y);
+
+    g_pInputManager->processMouseRequest(EVENT);
 }
 
 void Events::listener_newInput(wl_listener* listener, void* data) {
@@ -73,13 +72,25 @@ void Events::listener_newInput(wl_listener* listener, void* data) {
             Debug::log(LOG, "Attached a mouse with name %s", DEVICE->name);
             g_pInputManager->newMouse(DEVICE);
             break;
+        case WLR_INPUT_DEVICE_TOUCH:
+            Debug::log(LOG, "Attached a touch device with name %s", DEVICE->name);
+            Debug::log(WARN, "!!!! Hyprland does not directly support touchscreens, bugs may occur !!!!");
+            wlr_cursor_attach_input_device(g_pCompositor->m_sWLRCursor, DEVICE);
+            break;
+        case WLR_INPUT_DEVICE_TABLET_TOOL:
+            Debug::log(LOG, "Attached a tablet tool with name %s", DEVICE->name);
+            g_pInputManager->newTabletTool(DEVICE);
+            break;
+        case WLR_INPUT_DEVICE_TABLET_PAD:
+            Debug::log(LOG, "Attached a tablet pad with name %s", DEVICE->name);
+            g_pInputManager->newTabletPad(DEVICE);
+            break;
         default:
+            Debug::log(WARN, "Unrecognized input device plugged in: %s", DEVICE->name);
             break;
     }
 
-    uint32_t capabilities = WL_SEAT_CAPABILITY_POINTER | WL_SEAT_CAPABILITY_KEYBOARD;
-
-    wlr_seat_set_capabilities(g_pCompositor->m_sSeat.seat, capabilities);
+    g_pInputManager->updateCapabilities(DEVICE);
 }
 
 void Events::listener_newConstraint(wl_listener* listener, void* data) {

src/events/Events.hpp

@@ -109,4 +109,7 @@ namespace Events {
 
     // Deco XDG
     LISTENER(NewXDGDeco);
+
+    // Renderer destroy
+    LISTENER(RendererDestroy);
 };

src/events/Layers.cpp

@@ -1,6 +1,6 @@
 #include "../Compositor.hpp"
 #include "../helpers/WLClasses.hpp"
-#include "../managers/InputManager.hpp"
+#include "../managers/input/InputManager.hpp"
 #include "../render/Renderer.hpp"
 #include "Events.hpp"
 
@@ -26,7 +26,7 @@ void Events::listener_newLayerSurface(wl_listener* listener, void* data) {
             return;
         }
 
-        Debug::log(LOG, "New LayerSurface has no preferred monitor. Assigning Monitor %s", PMONITOR->szName);
+        Debug::log(LOG, "New LayerSurface has no preferred monitor. Assigning Monitor %s", PMONITOR->szName.c_str());
 
         WLRLAYERSURFACE->output = PMONITOR->output;
     }
@@ -36,7 +36,7 @@ void Events::listener_newLayerSurface(wl_listener* listener, void* data) {
     SLayerSurface* layerSurface = PMONITOR->m_aLayerSurfaceLists[WLRLAYERSURFACE->pending.layer].back();
 
     if (!WLRLAYERSURFACE->output) {
-        WLRLAYERSURFACE->output = g_pCompositor->m_lMonitors.front().output;  // TODO: current mon
+        WLRLAYERSURFACE->output = g_pCompositor->m_vMonitors.front()->output;  // TODO: current mon
     }
 
     layerSurface->hyprListener_commitLayerSurface.initCallback(&WLRLAYERSURFACE->surface->events.commit, &Events::listener_commitLayerSurface, layerSurface, "layerSurface");
@@ -58,7 +58,12 @@ void Events::listener_destroyLayerSurface(void* owner, void* data) {
 
     Debug::log(LOG, "LayerSurface %x destroyed", layersurface->layerSurface);
 
-    if (!layersurface->fadingOut) {
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(layersurface->monitorID);
+
+    if (!g_pCompositor->getMonitorFromID(layersurface->monitorID))
+        Debug::log(WARN, "Layersurface destroyed on an invalid monitor (removed?)");
+
+    if (!layersurface->fadingOut && PMONITOR) {
         Debug::log(LOG, "Removing LayerSurface that wasn't mapped.");
         layersurface->alpha.setValueAndWarp(0.f);
         layersurface->fadingOut = true;
@@ -70,8 +75,6 @@ void Events::listener_destroyLayerSurface(void* owner, void* data) {
     layersurface->hyprListener_unmapLayerSurface.removeCallback();
     layersurface->hyprListener_newPopup.removeCallback();
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(layersurface->monitorID);
-
     // rearrange to fix the reserved areas
     if (PMONITOR) {
         g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
@@ -131,13 +134,18 @@ void Events::listener_unmapLayerSurface(void* owner, void* data) {
 
     Debug::log(LOG, "LayerSurface %x unmapped", layersurface->layerSurface);
 
+    if (!g_pCompositor->getMonitorFromID(layersurface->monitorID)) {
+        Debug::log(WARN, "Layersurface unmapping on invalid monitor (removed?) ignoring.");
+        return;
+    }
+
     // make a snapshot and start fade
     g_pHyprOpenGL->makeLayerSnapshot(layersurface);
     layersurface->alpha = 0.f;
 
     layersurface->fadingOut = true;
 
-    g_pCompositor->m_lSurfacesFadingOut.push_back(layersurface);
+    g_pCompositor->m_vSurfacesFadingOut.push_back(layersurface);
 
     if (layersurface->layerSurface->mapped)
         layersurface->layerSurface->mapped = false;
@@ -152,6 +160,12 @@ void Events::listener_unmapLayerSurface(void* owner, void* data) {
 
     wlr_box geomFixed = {layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y, layersurface->geometry.width, layersurface->geometry.height};
     g_pHyprRenderer->damageBox(&geomFixed);
+
+    geomFixed = {layersurface->geometry.x + (int)PMONITOR->vecPosition.x, layersurface->geometry.y + (int)PMONITOR->vecPosition.y, (int)layersurface->layerSurface->surface->current.width, (int)layersurface->layerSurface->surface->current.height};
+    g_pHyprRenderer->damageBox(&geomFixed);
+
+    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) {
@@ -165,7 +179,7 @@ void Events::listener_commitLayerSurface(void* owner, void* data) {
     if (!PMONITOR)
         return;
 
-    wlr_box geomFixed = {layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y, layersurface->geometry.width, layersurface->geometry.height};
+    wlr_box geomFixed = {layersurface->geometry.x, layersurface->geometry.y, layersurface->geometry.width, layersurface->geometry.height};
     g_pHyprRenderer->damageBox(&geomFixed);
 
     // fix if it changed its mon
@@ -192,6 +206,5 @@ void Events::listener_commitLayerSurface(void* owner, void* data) {
 
     layersurface->position = Vector2D(layersurface->geometry.x, layersurface->geometry.y);
 
-    // TODO: optimize this. This does NOT need to be here but it prevents some issues with full DT.
-    g_pHyprRenderer->damageMonitor(PMONITOR);
+    g_pHyprRenderer->damageSurface(layersurface->layerSurface->surface, layersurface->position.x, layersurface->position.y);
 }

src/events/Misc.cpp

@@ -2,7 +2,7 @@
 
 #include "../Compositor.hpp"
 #include "../helpers/WLClasses.hpp"
-#include "../managers/InputManager.hpp"
+#include "../managers/input/InputManager.hpp"
 #include "../render/Renderer.hpp"
 
 // ------------------------------ //
@@ -153,4 +153,8 @@ void Events::listener_InhibitDeactivate(wl_listener* listener, void* data) {
 
     g_pCompositor->m_sSeat.exclusiveClient = nullptr;
     g_pInputManager->refocus();
+}
+
+void Events::listener_RendererDestroy(wl_listener* listener, void* data) {
+    Debug::log(LOG, "!!Renderer destroyed!!");
 }

src/events/Monitors.cpp

@@ -1,6 +1,6 @@
 #include "../Compositor.hpp"
 #include "../helpers/WLClasses.hpp"
-#include "../managers/InputManager.hpp"
+#include "../managers/input/InputManager.hpp"
 #include "../render/Renderer.hpp"
 #include "Events.hpp"
 #include "../debug/HyprCtl.hpp"
@@ -21,24 +21,24 @@ void Events::listener_change(wl_listener* listener, void* data) {
     // layout got changed, let's update monitors.
     const auto CONFIG = wlr_output_configuration_v1_create();
 
-    for (auto& m : g_pCompositor->m_lMonitors) {
-        const auto CONFIGHEAD = wlr_output_configuration_head_v1_create(CONFIG, m.output);
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        const auto CONFIGHEAD = wlr_output_configuration_head_v1_create(CONFIG, m->output);
 
         // TODO: clients off of disabled
         wlr_box BOX;
-        wlr_output_layout_get_box(g_pCompositor->m_sWLROutputLayout, m.output, &BOX);
+        wlr_output_layout_get_box(g_pCompositor->m_sWLROutputLayout, m->output, &BOX);
 
-        //m.vecSize.x = BOX.width;
-       // m.vecSize.y = BOX.height;
-        m.vecPosition.x = BOX.x;
-        m.vecPosition.y = BOX.y;
+        //m->vecSize.x = BOX.width;
+       // m->vecSize.y = BOX.height;
+        m->vecPosition.x = BOX.x;
+        m->vecPosition.y = BOX.y;
 
-        CONFIGHEAD->state.enabled = m.output->enabled;
-        CONFIGHEAD->state.mode = m.output->current_mode;
-        CONFIGHEAD->state.x = m.vecPosition.x;
-        CONFIGHEAD->state.y = m.vecPosition.y;
+        CONFIGHEAD->state.enabled = m->output->enabled;
+        CONFIGHEAD->state.mode = m->output->current_mode;
+        CONFIGHEAD->state.x = m->vecPosition.x;
+        CONFIGHEAD->state.y = m->vecPosition.y;
 
-        wlr_output_set_custom_mode(m.output, m.vecPixelSize.x, m.vecPixelSize.y, (int)(round(m.refreshRate * 1000)));
+        wlr_output_set_custom_mode(m->output, m->vecPixelSize.x, m->vecPixelSize.y, (int)(round(m->refreshRate * 1000)));
     }
 
     wlr_output_manager_v1_set_configuration(g_pCompositor->m_sWLROutputMgr, CONFIG);
@@ -65,12 +65,16 @@ void Events::listener_newOutput(wl_listener* listener, void* data) {
     if (monitorRule.disabled) {
         wlr_output_enable(OUTPUT, 0);
         wlr_output_commit(OUTPUT);
+
+        if (const auto PMONITOR = g_pCompositor->getMonitorFromName(std::string(OUTPUT->name)); PMONITOR) {
+            listener_monitorDestroy(nullptr, PMONITOR->output);
+        }
         return;
     }
 
     SMonitor newMonitor;
     newMonitor.output = OUTPUT;
-    newMonitor.ID = g_pCompositor->m_lMonitors.size();
+    newMonitor.ID = g_pCompositor->getNextAvailableMonitorID();
     newMonitor.szName = OUTPUT->name;
 
     wlr_output_init_render(OUTPUT, g_pCompositor->m_sWLRAllocator, g_pCompositor->m_sWLRRenderer);
@@ -86,8 +90,7 @@ void Events::listener_newOutput(wl_listener* listener, void* data) {
     newMonitor.vecSize = monitorRule.resolution;
     newMonitor.refreshRate = monitorRule.refreshRate;
 
-    g_pCompositor->m_lMonitors.push_back(newMonitor);
-    const auto PNEWMONITOR = &g_pCompositor->m_lMonitors.back();
+    const auto PNEWMONITOR = g_pCompositor->m_vMonitors.emplace_back(std::make_unique<SMonitor>(newMonitor)).get();
 
     PNEWMONITOR->hyprListener_monitorFrame.initCallback(&OUTPUT->events.frame, &Events::listener_monitorFrame, PNEWMONITOR);
     PNEWMONITOR->hyprListener_monitorDestroy.initCallback(&OUTPUT->events.destroy, &Events::listener_monitorDestroy, PNEWMONITOR);
@@ -110,20 +113,40 @@ void Events::listener_newOutput(wl_listener* listener, void* data) {
     wlr_ext_workspace_group_handle_v1_output_enter(PNEWMONITOR->pWLRWorkspaceGroupHandle, PNEWMONITOR->output);
 
     // Workspace
-    const auto WORKSPACEID = monitorRule.defaultWorkspaceID == -1 ? g_pCompositor->m_lWorkspaces.size() + 1 /* Cuz workspaces doesnt have the new one yet and we start with 1 */ : monitorRule.defaultWorkspaceID;
-    g_pCompositor->m_lWorkspaces.emplace_back(newMonitor.ID);
-    const auto PNEWWORKSPACE = &g_pCompositor->m_lWorkspaces.back();
+    std::string newDefaultWorkspaceName = "";
+    auto WORKSPACEID = monitorRule.defaultWorkspace == "" ? g_pCompositor->m_vWorkspaces.size() + 1 : getWorkspaceIDFromString(monitorRule.defaultWorkspace, newDefaultWorkspaceName);
+    
+    if (WORKSPACEID == INT_MAX || WORKSPACEID == (long unsigned int)SPECIAL_WORKSPACE_ID) {
+        WORKSPACEID = g_pCompositor->m_vWorkspaces.size() + 1;
+        newDefaultWorkspaceName = std::to_string(WORKSPACEID);
 
-    // We are required to set the name here immediately
-    wlr_ext_workspace_handle_v1_set_name(PNEWWORKSPACE->m_pWlrHandle, std::to_string(WORKSPACEID).c_str());
+        Debug::log(LOG, "Invalid workspace= directive name in monitor parsing, workspace name \"%s\" is invalid.", monitorRule.defaultWorkspace);
+    }
 
-    PNEWWORKSPACE->m_iID = WORKSPACEID;
-    PNEWWORKSPACE->m_szName = std::to_string(WORKSPACEID);
+    auto PNEWWORKSPACE = g_pCompositor->getWorkspaceByID(WORKSPACEID);
+
+    Debug::log(LOG, "New monitor: WORKSPACEID %d, exists: %d", WORKSPACEID, (int)(PNEWWORKSPACE != nullptr));
+
+    if (PNEWWORKSPACE) {
+        // workspace exists, move it to the newly connected monitor
+        g_pCompositor->moveWorkspaceToMonitor(PNEWWORKSPACE, PNEWMONITOR);
+        PNEWMONITOR->activeWorkspace = PNEWWORKSPACE->m_iID;
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PNEWMONITOR->ID);
+        PNEWWORKSPACE->startAnim(true,true,true);
+    } else {
+        PNEWWORKSPACE = g_pCompositor->m_vWorkspaces.emplace_back(std::make_unique<CWorkspace>(newMonitor.ID, newDefaultWorkspaceName)).get();
+
+        // We are required to set the name here immediately
+        wlr_ext_workspace_handle_v1_set_name(PNEWWORKSPACE->m_pWlrHandle, newDefaultWorkspaceName.c_str());
+
+        PNEWWORKSPACE->m_iID = WORKSPACEID;
+    }
 
     PNEWMONITOR->activeWorkspace = PNEWWORKSPACE->m_iID;
-
     PNEWMONITOR->scale = monitorRule.scale;
 
+    PNEWMONITOR->forceFullFrames = 3; // force 3 full frames to make sure there is no blinking due to double-buffering.
+
     g_pCompositor->deactivateAllWLRWorkspaces(PNEWWORKSPACE->m_pWlrHandle);
     PNEWWORKSPACE->setActive(true);
 
@@ -132,7 +155,9 @@ void Events::listener_newOutput(wl_listener* listener, void* data) {
     //
 
     if (!g_pCompositor->m_pLastMonitor) // set the last monitor if it isnt set yet
-        g_pCompositor->m_pLastMonitor = PNEWMONITOR; 
+        g_pCompositor->m_pLastMonitor = PNEWMONITOR;
+
+    g_pEventManager->postEvent(SHyprIPCEvent("monitoradded", PNEWMONITOR->szName));
 
     // ready to process cuz we have a monitor
     g_pCompositor->m_bReadyToProcess = true;
@@ -145,14 +170,21 @@ void Events::listener_monitorFrame(void* owner, void* data) {
     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();
 
-    if (g_pConfigManager->getInt("debug:overlay") == 1) {
+    static auto *const PDEBUGOVERLAY = &g_pConfigManager->getConfigValuePtr("debug:overlay")->intValue;
+    static auto *const PDAMAGETRACKINGMODE = &g_pConfigManager->getConfigValuePtr("general:damage_tracking_internal")->intValue;
+    static auto *const PDAMAGEBLINK = &g_pConfigManager->getConfigValuePtr("debug:damage_blink")->intValue;
+    static auto *const VFRENABLED = &g_pConfigManager->getConfigValuePtr("experimental:vfr")->intValue;
+
+    static int damageBlinkCleanup = 0; // because double-buffered
+
+    if (*PDEBUGOVERLAY == 1) {
         startRender = std::chrono::high_resolution_clock::now();
         g_pDebugOverlay->frameData(PMONITOR);
     }
 
     // Hack: only check when monitor with top hz refreshes, saves a bit of resources.
     // This is for stuff that should be run every frame
-    if (PMONITOR->ID == pMostHzMonitor->ID) {
+    if (PMONITOR->ID == pMostHzMonitor->ID || *VFRENABLED) { // 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();
         g_pCompositor->cleanupFadingOut();
@@ -163,11 +195,18 @@ void Events::listener_monitorFrame(void* owner, void* data) {
 
         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->needsFrameSkip) {
-        PMONITOR->needsFrameSkip = false;
-        wlr_output_schedule_frame(PMONITOR->output);
+    if (PMONITOR->framesToSkip > 0) {
+        PMONITOR->framesToSkip -= 1;
+
+        if (!PMONITOR->noFrameSchedule)
+            wlr_output_schedule_frame(PMONITOR->output);
+        else {
+            Debug::log(LOG, "NoFrameSchedule hit for %s.", PMONITOR->szName.c_str());
+        }
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMONITOR->ID);
         return;
     }
@@ -180,9 +219,7 @@ void Events::listener_monitorFrame(void* owner, void* data) {
     bool hasChanged;
     pixman_region32_init(&damage);
 
-    const auto DTMODE = g_pConfigManager->getInt("general:damage_tracking_internal");
-
-    if (DTMODE == -1) {
+    if (*PDAMAGETRACKINGMODE == -1) {
         Debug::log(CRIT, "Damage tracking mode -1 ????");
         return;
     }
@@ -192,27 +229,30 @@ void Events::listener_monitorFrame(void* owner, void* data) {
         return;
     }
 
-    if (!hasChanged && DTMODE != DAMAGE_TRACKING_NONE) {
+    if (!hasChanged && *PDAMAGETRACKINGMODE != DAMAGE_TRACKING_NONE && PMONITOR->forceFullFrames == 0 && damageBlinkCleanup == 0) {
         pixman_region32_fini(&damage);
         wlr_output_rollback(PMONITOR->output);
-        wlr_output_schedule_frame(PMONITOR->output); // we update shit at the monitor's Hz so we need to schedule frames because rollback wont
+
+        if (!*VFRENABLED)
+            wlr_output_schedule_frame(PMONITOR->output);
+
         return;
     }
 
     // if we have no tracking or full tracking, invalidate the entire monitor
-    if (DTMODE == DAMAGE_TRACKING_NONE || DTMODE == DAMAGE_TRACKING_MONITOR) {
+    if (*PDAMAGETRACKINGMODE == DAMAGE_TRACKING_NONE || *PDAMAGETRACKINGMODE == DAMAGE_TRACKING_MONITOR || PMONITOR->forceFullFrames > 0 || damageBlinkCleanup > 0) {
         pixman_region32_union_rect(&damage, &damage, 0, 0, (int)PMONITOR->vecTransformedSize.x, (int)PMONITOR->vecTransformedSize.y);
 
         pixman_region32_copy(&g_pHyprOpenGL->m_rOriginalDamageRegion, &damage);
     } 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 (g_pConfigManager->getInt("decoration:blur") == 1) {
+        if (*PBLURENABLED == 1) {
             // TODO: can this be optimized?
-            const auto BLURSIZE = g_pConfigManager->getInt("decoration:blur_size");
-            const auto BLURPASSES = g_pConfigManager->getInt("decoration:blur_passes");
-
-            const auto BLURRADIUS = BLURSIZE * pow(2, BLURPASSES); // is this 2^pass? I don't know but it works... I think.
+            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);
 
@@ -223,6 +263,9 @@ void Events::listener_monitorFrame(void* owner, void* data) {
         }
     }
 
+    if (PMONITOR->forceFullFrames > 0)
+        PMONITOR->forceFullFrames -= 1;
+
     // TODO: this is getting called with extents being 0,0,0,0 should it be?
     // potentially can save on resources.
 
@@ -237,12 +280,22 @@ void Events::listener_monitorFrame(void* owner, void* data) {
         g_pHyprError->draw();
 
     // for drawing the debug overlay
-    if (PMONITOR->ID == 0 && g_pConfigManager->getInt("debug:overlay") == 1) {
+    if (PMONITOR->ID == 0 && *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->vecPixelSize.x, PMONITOR->vecPixelSize.y};
+        g_pHyprOpenGL->renderRect(&monrect, CColor(255,0,255,100), 0);
+        damageBlinkCleanup = 1;
+    } else if (*PDAMAGEBLINK) {
+        damageBlinkCleanup++;
+        if (damageBlinkCleanup > 3)
+            damageBlinkCleanup = 0;
+    }
+
     wlr_renderer_begin(g_pCompositor->m_sWLRRenderer, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
 
     wlr_output_render_software_cursors(PMONITOR->output, NULL);
@@ -258,18 +311,22 @@ void Events::listener_monitorFrame(void* owner, void* data) {
     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 (DTMODE == DAMAGE_TRACKING_NONE || DTMODE == DAMAGE_TRACKING_MONITOR)
+    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);
     pixman_region32_fini(&frameDamage);
     pixman_region32_fini(&damage);
 
     wlr_output_commit(PMONITOR->output);
 
-    wlr_output_schedule_frame(PMONITOR->output);
+    if (!*VFRENABLED)
+        wlr_output_schedule_frame(PMONITOR->output);
 
-    if (g_pConfigManager->getInt("debug:overlay") == 1) {
+    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->ID == 0) {
@@ -286,9 +343,9 @@ void Events::listener_monitorDestroy(void* owner, void* data) {
 
     SMonitor* pMonitor = nullptr;
 
-    for (auto& m : g_pCompositor->m_lMonitors) {
-        if (m.szName == OUTPUT->name) {
-            pMonitor = &m;
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        if (m->szName == OUTPUT->name) {
+            pMonitor = m.get();
             break;
         }
     }
@@ -296,7 +353,56 @@ void Events::listener_monitorDestroy(void* owner, void* data) {
     if (!pMonitor)
         return;
 
-    g_pCompositor->m_lMonitors.remove(*pMonitor);
+    // Cleanup everything. Move windows back, snap cursor, shit.
+    const auto BACKUPMON = g_pCompositor->m_vMonitors.front().get();
 
-    // TODO: cleanup windows
+    if (!BACKUPMON) {
+        Debug::log(CRIT, "No monitors! Unplugged last! Exiting.");
+        g_pCompositor->cleanupExit();
+        exit(1);
+        return;
+    }
+
+    const auto BACKUPWORKSPACE = BACKUPMON->activeWorkspace > 0 ? std::to_string(BACKUPMON->activeWorkspace) : "name:" + g_pCompositor->getWorkspaceByID(BACKUPMON->activeWorkspace)->m_szName;
+
+    // snap cursor
+    wlr_cursor_warp(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, BACKUPMON->vecPosition.x + BACKUPMON->vecTransformedSize.x / 2.f, BACKUPMON->vecPosition.y + BACKUPMON->vecTransformedSize.y / 2.f);
+
+    // move workspaces
+    std::deque<CWorkspace*> wspToMove;
+    for (auto& w : g_pCompositor->m_vWorkspaces) {
+        if (w->m_iMonitorID == pMonitor->ID) {
+            wspToMove.push_back(w.get());
+        }
+    }
+
+    for (auto& w : wspToMove) {
+        g_pCompositor->moveWorkspaceToMonitor(w, BACKUPMON);
+        w->startAnim(true, true, true);
+    }
+
+    pMonitor->activeWorkspace = -1;
+
+    g_pCompositor->m_vWorkspaces.erase(std::remove_if(g_pCompositor->m_vWorkspaces.begin(), g_pCompositor->m_vWorkspaces.end(), [&](std::unique_ptr<CWorkspace>& el) { return el->m_iMonitorID == pMonitor->ID; }));
+
+    Debug::log(LOG, "Removed monitor %s!", pMonitor->szName.c_str());
+
+    g_pEventManager->postEvent(SHyprIPCEvent("monitorremoved", pMonitor->szName));
+
+    g_pCompositor->m_vMonitors.erase(std::remove_if(g_pCompositor->m_vMonitors.begin(), g_pCompositor->m_vMonitors.end(), [&](std::unique_ptr<SMonitor>& el) { return el.get() == pMonitor; }));
+
+    // update the pMostHzMonitor
+    if (pMostHzMonitor == pMonitor) {
+        int mostHz = 0;
+        SMonitor* pMonitorMostHz = nullptr;
+
+        for (auto& m : g_pCompositor->m_vMonitors) {
+            if (m->refreshRate > mostHz) {
+                pMonitorMostHz = m.get();
+                mostHz = m->refreshRate;
+            }
+        }
+
+        pMostHzMonitor = pMonitorMostHz;
+    }
 }

src/events/Popups.cpp

@@ -2,7 +2,7 @@
 
 #include "../Compositor.hpp"
 #include "../helpers/WLClasses.hpp"
-#include "../managers/InputManager.hpp"
+#include "../managers/input/InputManager.hpp"
 #include "../render/Renderer.hpp"
 
 // --------------------------------------------- //
@@ -26,6 +26,14 @@ void addPopupGlobalCoords(void* pPopup, int* x, int* y) {
         px += curPopup->popup->current.geometry.x;
         py += curPopup->popup->current.geometry.y;
 
+        // fix oversized fucking popups 
+        // kill me
+        if (curPopup->pSurfaceTree && curPopup->pSurfaceTree->pSurface && !curPopup->parentPopup) {
+            const auto EXTENTSSURFACE = pixman_region32_extents(&curPopup->pSurfaceTree->pSurface->input_region);
+            px -= EXTENTSSURFACE->x1;
+            py -= EXTENTSSURFACE->y1;
+        }
+
         if (curPopup->parentPopup) {
             curPopup = curPopup->parentPopup;
         } else {
@@ -68,8 +76,7 @@ void Events::listener_newPopup(void* owner, void* data) {
 
     const auto WLRPOPUP = (wlr_xdg_popup*)data;
 
-    g_pCompositor->m_lXDGPopups.push_back(SXDGPopup());
-    const auto PNEWPOPUP = &g_pCompositor->m_lXDGPopups.back();
+    const auto PNEWPOPUP = g_pCompositor->m_vXDGPopups.emplace_back(std::make_unique<SXDGPopup>()).get();
 
     const auto PMONITOR = g_pCompositor->getMonitorFromID(layersurface->monitorID);
 
@@ -89,8 +96,7 @@ void Events::listener_newPopupXDG(void* owner, void* data) {
 
     const auto WLRPOPUP = (wlr_xdg_popup*)data;
 
-    g_pCompositor->m_lXDGPopups.push_back(SXDGPopup());
-    const auto PNEWPOPUP = &g_pCompositor->m_lXDGPopups.back();
+    const auto PNEWPOPUP = g_pCompositor->m_vXDGPopups.emplace_back(std::make_unique<SXDGPopup>()).get();
 
     const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
 
@@ -114,8 +120,7 @@ void Events::listener_newPopupFromPopupXDG(void* owner, void* data) {
 
     const auto WLRPOPUP = (wlr_xdg_popup*)data;
 
-    g_pCompositor->m_lXDGPopups.push_back(SXDGPopup());
-    const auto PNEWPOPUP = &g_pCompositor->m_lXDGPopups.back();
+    const auto PNEWPOPUP = g_pCompositor->m_vXDGPopups.emplace_back(std::make_unique<SXDGPopup>()).get();
 
     PNEWPOPUP->popup = WLRPOPUP;
     PNEWPOPUP->parentPopup = PPOPUP;
@@ -134,7 +139,7 @@ void Events::listener_mapPopupXDG(void* owner, void* data) {
 
     Debug::log(LOG, "New XDG Popup mapped at %d %d", (int)PPOPUP->lx, (int)PPOPUP->ly);
 
-    PPOPUP->pSurfaceTree = SubsurfaceTree::createTreeRoot(PPOPUP->popup->base->surface, addPopupGlobalCoords, PPOPUP);
+    PPOPUP->pSurfaceTree = SubsurfaceTree::createTreeRoot(PPOPUP->popup->base->surface, addPopupGlobalCoords, PPOPUP, PPOPUP->parentWindow);
 
     Debug::log(LOG, "XDG Popup got assigned a surfaceTreeNode %x", PPOPUP->pSurfaceTree);
 }
@@ -162,5 +167,5 @@ void Events::listener_destroyPopupXDG(void* owner, void* data) {
         PPOPUP->pSurfaceTree = nullptr;
     }
 
-    g_pCompositor->m_lXDGPopups.remove(*PPOPUP);
+    g_pCompositor->m_vXDGPopups.erase(std::remove_if(g_pCompositor->m_vXDGPopups.begin(), g_pCompositor->m_vXDGPopups.end(), [&](std::unique_ptr<SXDGPopup>& el) { return el.get() == PPOPUP; }));
 }

src/events/Windows.cpp

@@ -2,7 +2,7 @@
 
 #include "../Compositor.hpp"
 #include "../helpers/WLClasses.hpp"
-#include "../managers/InputManager.hpp"
+#include "../managers/input/InputManager.hpp"
 #include "../render/Renderer.hpp"
 
 // ------------------------------------------------------------ //
@@ -19,22 +19,36 @@ void addViewCoords(void* pWindow, int* x, int* y) {
     const auto PWINDOW = (CWindow*)pWindow;
     *x += PWINDOW->m_vRealPosition.goalv().x;
     *y += PWINDOW->m_vRealPosition.goalv().y;
+
+    if (!PWINDOW->m_bIsX11) {
+        wlr_box geom;
+        wlr_xdg_surface_get_geometry(PWINDOW->m_uSurface.xdg, &geom);
+
+        *x -= geom.x;
+        *y -= geom.y;
+    }
 }
 
 void Events::listener_mapWindow(void* owner, void* data) {
     CWindow* PWINDOW = (CWindow*)owner;
 
     const auto PMONITOR = g_pCompositor->getMonitorFromCursor();
-    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
+    const auto PWORKSPACE = PMONITOR->specialWorkspaceOpen ? g_pCompositor->getWorkspaceByID(SPECIAL_WORKSPACE_ID) : g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
     PWINDOW->m_iMonitorID = PMONITOR->ID;
     PWINDOW->m_bMappedX11 = true;
-    PWINDOW->m_iWorkspaceID = PMONITOR->activeWorkspace;
+    PWINDOW->m_iWorkspaceID = PMONITOR->specialWorkspaceOpen ? SPECIAL_WORKSPACE_ID : PMONITOR->activeWorkspace;
     PWINDOW->m_bIsMapped = true;
     PWINDOW->m_bReadyToDelete = false;
     PWINDOW->m_bFadingOut = false;
     PWINDOW->m_szTitle = g_pXWaylandManager->getTitle(PWINDOW);
     PWINDOW->m_fAlpha = 255.f;
 
+    if (PWINDOW->m_iX11Type == 2)
+        g_pCompositor->moveUnmanagedX11ToWindows(PWINDOW);
+
+    // Set all windows tiled regardless of anything
+    g_pXWaylandManager->setWindowStyleTiled(PWINDOW, WLR_EDGE_LEFT | WLR_EDGE_RIGHT | WLR_EDGE_TOP | WLR_EDGE_BOTTOM);
+
     // Foreign Toplevel
     PWINDOW->m_phForeignToplevel = wlr_foreign_toplevel_handle_v1_create(g_pCompositor->m_sWLRToplevelMgr);
     // TODO: handle foreign events (requests)
@@ -46,7 +60,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
     const auto PWINDOWSURFACE = g_pXWaylandManager->getWindowSurface(PWINDOW);
 
     if (!PWINDOWSURFACE) {
-        g_pCompositor->m_lWindows.remove(*PWINDOW);
+        g_pCompositor->removeWindowFromVectorSafe(PWINDOW);
         return;
     }
 
@@ -67,22 +81,30 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
     if (PWORKSPACE->m_bHasFullscreenWindow && !PWINDOW->m_bIsFloating) {
         const auto PFULLWINDOW = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
-        g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(PFULLWINDOW, FULLSCREEN_FULL);
+        g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(PFULLWINDOW, FULLSCREEN_FULL, false);
         g_pXWaylandManager->setWindowFullscreen(PFULLWINDOW, PFULLWINDOW->m_bIsFullscreen);
     }
 
     // window rules
     const auto WINDOWRULES = g_pConfigManager->getMatchingRules(PWINDOW);
+    std::string requestedWorkspace = "";
+    bool workspaceSilent = false;
+    bool requestsFullscreen = false;
 
     for (auto& r : WINDOWRULES) {
         if (r.szRule.find("monitor") == 0) {
             try {
-                const long int MONITOR = std::stoi(r.szRule.substr(r.szRule.find(" ")));
+                const auto MONITORSTR = r.szRule.substr(r.szRule.find(" "));
 
-                if (MONITOR >= (long int)g_pCompositor->m_lMonitors.size() || MONITOR < (long int)0)
-                    PWINDOW->m_iMonitorID = 0;
-                else
-                    PWINDOW->m_iMonitorID = MONITOR;
+                if (MONITORSTR == "unset") {
+                    PWINDOW->m_iMonitorID = PMONITOR->ID;
+                } else {
+                    const long int MONITOR = std::stoi(MONITORSTR);
+                    if (MONITOR >= (long int)g_pCompositor->m_vMonitors.size() || MONITOR < (long int)0)
+                        PWINDOW->m_iMonitorID = 0;
+                    else
+                        PWINDOW->m_iMonitorID = MONITOR;
+                }
 
                 PWINDOW->m_iWorkspaceID = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID)->activeWorkspace;
 
@@ -91,11 +113,21 @@ void Events::listener_mapWindow(void* owner, void* data) {
                 Debug::log(ERR, "Rule monitor failed, rule: %s -> %s | err: %s", r.szRule.c_str(), r.szValue.c_str(), e.what());
             }
         } else if (r.szRule.find("workspace") == 0) {
-            // switch to workspace
-            g_pKeybindManager->m_mDispatchers["workspace"](r.szRule.substr(r.szRule.find_first_of(' ') + 1));
+            // check if it isnt unset
+            const auto WORKSPACERQ = r.szRule.substr(r.szRule.find_first_of(' ') + 1);
 
-            PWINDOW->m_iMonitorID = g_pCompositor->m_pLastMonitor->ID;
-            PWINDOW->m_iWorkspaceID = g_pCompositor->m_pLastMonitor->activeWorkspace;
+            if (WORKSPACERQ == "unset") {
+                requestedWorkspace = "";
+            } else {
+                requestedWorkspace = WORKSPACERQ;
+            }
+
+            if (requestedWorkspace == "special") {
+                requestedWorkspace = "";
+                workspaceSilent = false;
+                Debug::log(LOG, "windowrule=workspace special is not allowed!");
+                continue;
+            }
 
             Debug::log(LOG, "Rule workspace matched by window %x, %s applied.", PWINDOW, r.szValue.c_str());
         } else if (r.szRule.find("float") == 0) {
@@ -106,6 +138,10 @@ void Events::listener_mapWindow(void* owner, void* data) {
             PWINDOW->m_bIsPseudotiled = true;
         } else if (r.szRule.find("nofocus") == 0) {
             PWINDOW->m_bNoFocus = true;
+        } else if (r.szRule == "noblur") {
+            PWINDOW->m_sAdditionalConfigData.forceNoBlur = true;
+        } else if (r.szRule == "fullscreen") {
+            requestsFullscreen = true;
         } else if (r.szRule.find("rounding") == 0) {
             try {
                 PWINDOW->m_sAdditionalConfigData.rounding = std::stoi(r.szRule.substr(r.szRule.find_first_of(' ') + 1));
@@ -114,7 +150,15 @@ void Events::listener_mapWindow(void* owner, void* data) {
             }
         } else if (r.szRule.find("opacity") == 0) {
             try {
-                PWINDOW->m_sSpecialRenderData.alpha = std::stof(r.szRule.substr(r.szRule.find_first_of(' ') + 1));
+                std::string alphaPart = r.szRule.substr(r.szRule.find_first_of(' ') + 1);
+
+                if (alphaPart.find_first_of(' ') != std::string::npos) {
+                    // we have a comma, 2 values
+                    PWINDOW->m_sSpecialRenderData.alpha = std::stof(alphaPart.substr(0, alphaPart.find_first_of(' ')));
+                    PWINDOW->m_sSpecialRenderData.alphaInactive = std::stof(alphaPart.substr(alphaPart.find_first_of(' ') + 1));
+                } else {
+                    PWINDOW->m_sSpecialRenderData.alpha = std::stof(alphaPart);
+                }
             } catch(std::exception& e) {
                 Debug::log(ERR, "Opacity rule \"%s\" failed with: %s", r.szRule.c_str(), e.what());
             }
@@ -124,6 +168,25 @@ void Events::listener_mapWindow(void* owner, void* data) {
         }
     }
 
+    if (requestedWorkspace != "") {
+        // process requested workspace
+        if (requestedWorkspace.find_first_of(' ') != std::string::npos) {
+            // check for silent
+            if (requestedWorkspace.find("silent") != std::string::npos) {
+                workspaceSilent = true;
+            }
+
+            requestedWorkspace = requestedWorkspace.substr(0, requestedWorkspace.find_first_of(' '));
+        }
+
+        if (!workspaceSilent) {
+            g_pKeybindManager->m_mDispatchers["workspace"](requestedWorkspace);
+
+            PWINDOW->m_iMonitorID = g_pCompositor->m_pLastMonitor->ID;
+            PWINDOW->m_iWorkspaceID = g_pCompositor->m_pLastMonitor->activeWorkspace;
+        }
+    }
+
     if (PWINDOW->m_bIsFloating) {
         g_pLayoutManager->getCurrentLayout()->onWindowCreatedFloating(PWINDOW);
         PWINDOW->m_bCreatedOverFullscreen = true;
@@ -175,11 +238,9 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PWINDOW->m_vPseudoSize = PWINDOW->m_vRealSize.goalv() - Vector2D(10,10);
     }
 
-    if (!PWINDOW->m_bNoFocus)
+    if (!PWINDOW->m_bNoFocus && !PWINDOW->m_bNoInitialFocus)
         g_pCompositor->focusWindow(PWINDOW);
 
-    PWINDOW->m_pSurfaceTree = SubsurfaceTree::createTreeRoot(g_pXWaylandManager->getWindowSurface(PWINDOW), addViewCoords, PWINDOW);
-
     Debug::log(LOG, "Window got assigned a surfaceTreeNode %x", PWINDOW->m_pSurfaceTree);
 
     if (!PWINDOW->m_bIsX11) {
@@ -197,13 +258,41 @@ void Events::listener_mapWindow(void* owner, void* data) {
     // do the animation thing
     g_pAnimationManager->onWindowPostCreateClose(PWINDOW, false);
 
+    if (workspaceSilent) {
+        // move the window
+        if (g_pCompositor->m_pLastWindow == PWINDOW) {
+            if (requestedWorkspace != "special")
+                g_pKeybindManager->m_mDispatchers["movetoworkspacesilent"](requestedWorkspace);
+            else
+                g_pKeybindManager->m_mDispatchers["movetoworkspace"]("special");
+        } else {
+            Debug::log(ERR, "Tried to set workspace silent rule to a nofocus window!");
+        }
+    }
+
+    if (requestsFullscreen) {
+        // fix fullscreen on requested (basically do a switcheroo)
+        if (PWORKSPACE->m_bHasFullscreenWindow) {
+            const auto PFULLWINDOW = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
+            g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(PFULLWINDOW, FULLSCREEN_FULL, false);
+            g_pXWaylandManager->setWindowFullscreen(PFULLWINDOW, PFULLWINDOW->m_bIsFullscreen);
+        }
+
+        PWINDOW->m_vRealPosition.warp();
+        PWINDOW->m_vRealSize.warp();
+
+        g_pCompositor->setWindowFullscreen(PWINDOW, true, FULLSCREEN_FULL);
+    }
+
+    PWINDOW->m_pSurfaceTree = SubsurfaceTree::createTreeRoot(g_pXWaylandManager->getWindowSurface(PWINDOW), addViewCoords, PWINDOW, PWINDOW);
+
     Debug::log(LOG, "Map request dispatched, monitor %s, xywh: %f %f %f %f", PMONITOR->szName.c_str(), PWINDOW->m_vRealPosition.goalv().x, PWINDOW->m_vRealPosition.goalv().y, PWINDOW->m_vRealSize.goalv().x, PWINDOW->m_vRealSize.goalv().y);
 }
 
 void Events::listener_unmapWindow(void* owner, void* data) {
     CWindow* PWINDOW = (CWindow*)owner;
 
-    Debug::log(LOG, "Window %x unmapped", PWINDOW);
+    Debug::log(LOG, "Window %x unmapped (class %s)", PWINDOW, g_pXWaylandManager->getAppIDClass(PWINDOW).c_str());
 
     if (!PWINDOW->m_bIsX11) {
         Debug::log(LOG, "Unregistered late callbacks XDG: %x %x %x %x", &PWINDOW->hyprListener_commitWindow.m_sListener.link, &PWINDOW->hyprListener_setTitleWindow.m_sListener.link, &PWINDOW->hyprListener_fullscreenWindow.m_sListener.link, &PWINDOW->hyprListener_newPopupXDG.m_sListener.link);
@@ -219,6 +308,11 @@ void Events::listener_unmapWindow(void* owner, void* data) {
         PWINDOW->hyprListener_setTitleWindow.removeCallback();
     }
 
+    if (PWINDOW->m_bIsFullscreen) {
+        g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(PWINDOW, FULLSCREEN_FULL, false);
+        g_pXWaylandManager->setWindowFullscreen(PWINDOW, PWINDOW->m_bIsFullscreen);
+    }
+
     // Allow the renderer to catch the last frame.
     g_pHyprOpenGL->makeWindowSnapshot(PWINDOW);
 
@@ -252,12 +346,14 @@ void Events::listener_unmapWindow(void* owner, void* data) {
 
     PWINDOW->m_bFadingOut = true;
 
-    g_pCompositor->m_lWindowsFadingOut.push_back(PWINDOW);
+    g_pCompositor->m_vWindowsFadingOut.emplace_back(PWINDOW);
 
     g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID));
 
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+
     // do the animation thing
-    PWINDOW->m_vOriginalClosedPos = PWINDOW->m_vRealPosition.vec();
+    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.
@@ -275,13 +371,18 @@ void Events::listener_commitWindow(void* owner, void* data) {
     if (!g_pCompositor->windowValidMapped(PWINDOW))
         return;
 
+    g_pHyprRenderer->damageSurface(g_pXWaylandManager->getWindowSurface(PWINDOW), PWINDOW->m_vRealPosition.goalv().x, PWINDOW->m_vRealPosition.goalv().y);        
+
     // Debug::log(LOG, "Window %x committed", PWINDOW); // SPAM!
 }
 
 void Events::listener_destroyWindow(void* owner, void* data) {
     CWindow* PWINDOW = (CWindow*)owner;
 
-    Debug::log(LOG, "Window %x destroyed, queueing.", PWINDOW);
+    Debug::log(LOG, "Window %x destroyed, queueing. (class %s)", PWINDOW, g_pXWaylandManager->getAppIDClass(PWINDOW).c_str());
+
+    if (PWINDOW->m_bIsX11)
+        Debug::log(LOG, "XWayland class raw: %s", PWINDOW->m_uSurface.xwayland->_class);
 
     if (PWINDOW == g_pCompositor->m_pLastWindow) {
         g_pCompositor->m_pLastWindow = nullptr;
@@ -327,9 +428,9 @@ void Events::listener_fullscreenWindow(void* owner, void* data) {
         const auto REQUESTED = &PWINDOW->m_uSurface.xdg->toplevel->requested;
 
         if (REQUESTED->fullscreen != PWINDOW->m_bIsFullscreen)
-            g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(PWINDOW, FULLSCREEN_FULL);
+            g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(PWINDOW, FULLSCREEN_FULL, REQUESTED->fullscreen);
     } else {
-        g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(PWINDOW, FULLSCREEN_FULL);
+        g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(PWINDOW, FULLSCREEN_FULL, !PWINDOW->m_bIsFullscreen);
     }
 
     Debug::log(LOG, "Window %x fullscreen to %i", PWINDOW, PWINDOW->m_bIsFullscreen);
@@ -389,15 +490,18 @@ void Events::listener_configureX11(void* owner, void* data) {
 void Events::listener_surfaceXWayland(wl_listener* listener, void* data) {
     const auto XWSURFACE = (wlr_xwayland_surface*)data;
 
-    Debug::log(LOG, "New XWayland Surface created.");
+    Debug::log(LOG, "New XWayland Surface created (class %s).", XWSURFACE->_class);
+    if (XWSURFACE->parent)
+        Debug::log(LOG, "Window parent data: %s at %x", XWSURFACE->parent->_class, XWSURFACE->parent);
 
-    g_pCompositor->m_lWindows.emplace_back();
-    const auto PNEWWINDOW = &g_pCompositor->m_lWindows.back();
+    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();
 
     PNEWWINDOW->m_uSurface.xwayland = XWSURFACE;
     PNEWWINDOW->m_iX11Type = XWSURFACE->override_redirect ? 2 : 1;
     PNEWWINDOW->m_bIsX11 = true;
 
+    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");
@@ -407,13 +511,12 @@ void Events::listener_newXDGSurface(wl_listener* listener, void* data) {
     // A window got opened
     const auto XDGSURFACE = (wlr_xdg_surface*)data;
 
-    Debug::log(LOG, "New XDG Surface created. (%ix%i at %i %i)", XDGSURFACE->current.geometry.width, XDGSURFACE->current.geometry.height, XDGSURFACE->current.geometry.x, XDGSURFACE->current.geometry.y);
+    Debug::log(LOG, "New XDG Surface created. (class: %s)", XDGSURFACE->toplevel->app_id);
 
     if (XDGSURFACE->role != WLR_XDG_SURFACE_ROLE_TOPLEVEL)
         return;  // TODO: handle?
 
-    g_pCompositor->m_lWindows.emplace_back();
-    const auto PNEWWINDOW = &g_pCompositor->m_lWindows.back();
+    const auto PNEWWINDOW = g_pCompositor->m_vWindows.emplace_back(std::make_unique<CWindow>()).get();
     PNEWWINDOW->m_uSurface.xdg = XDGSURFACE;
 
     PNEWWINDOW->hyprListener_mapWindow.initCallback(&XDGSURFACE->events.map, &Events::listener_mapWindow, PNEWWINDOW, "XDG Window");

src/helpers/AnimatedVariable.hpp

@@ -33,56 +33,47 @@ public:
 
     // gets the current vector value (real time)
     const Vector2D& vec() const {
-        RASSERT(m_eVarType == AVARTYPE_VECTOR, "Tried to access vec() of AVARTYPE %i!", m_eVarType);
         return m_vValue;
     }
 
     // gets the current float value (real time)
     const float& fl() const {
-        RASSERT(m_eVarType == AVARTYPE_FLOAT, "Tried to access fl() of AVARTYPE %i!", m_eVarType);
         return m_fValue;
     }
 
     // gets the current color value (real time)
     const CColor& col() const {
-        RASSERT(m_eVarType == AVARTYPE_COLOR, "Tried to access col() of AVARTYPE %i!", m_eVarType);
         return m_cValue;
     }
 
     // gets the goal vector value
     const Vector2D& goalv() const {
-        RASSERT(m_eVarType == AVARTYPE_VECTOR, "Tried to access goalv() of AVARTYPE %i!", m_eVarType);
         return m_vGoal;
     }
 
     // gets the goal float value
     const float& goalf() const {
-        RASSERT(m_eVarType == AVARTYPE_FLOAT, "Tried to access goalf() of AVARTYPE %i!", m_eVarType);
         return m_fGoal;
     }
 
     // gets the goal color value
     const CColor& goalc() const {
-        RASSERT(m_eVarType == AVARTYPE_COLOR, "Tried to access goalc() of AVARTYPE %i!", m_eVarType);
         return m_cGoal;
     }
 
     void operator=(const Vector2D& v) {
-        RASSERT(m_eVarType == AVARTYPE_VECTOR, "Tried to access =v of AVARTYPE %i!", m_eVarType);
         m_vGoal = v;
         animationBegin = std::chrono::system_clock::now();
         m_vBegun = m_vValue;
     }
 
     void operator=(const float& v) {
-        RASSERT(m_eVarType == AVARTYPE_FLOAT, "Tried to access =f of AVARTYPE %i!", m_eVarType);
         m_fGoal = v;
         animationBegin = std::chrono::system_clock::now();
         m_fBegun = m_fValue;
     }
 
     void operator=(const CColor& v) {
-        RASSERT(m_eVarType == AVARTYPE_COLOR, "Tried to access =c of AVARTYPE %i!", m_eVarType);
         m_cGoal = v;
         animationBegin = std::chrono::system_clock::now();
         m_cBegun = m_cValue;
@@ -90,7 +81,6 @@ public:
 
     // Sets the actual stored value, without affecting the goal, but resets the timer
     void setValue(const Vector2D& v) {
-        RASSERT(m_eVarType == AVARTYPE_VECTOR, "Tried to access setValue(v) of AVARTYPE %i!", m_eVarType);
         m_vValue = v;
         animationBegin = std::chrono::system_clock::now();
         m_vBegun = m_vValue;
@@ -98,7 +88,6 @@ public:
 
     // Sets the actual stored value, without affecting the goal, but resets the timer
     void setValue(const float& v) {
-        RASSERT(m_eVarType == AVARTYPE_FLOAT, "Tried to access setValue(f) of AVARTYPE %i!", m_eVarType);
         m_fValue = v;
         animationBegin = std::chrono::system_clock::now();
         m_vBegun = m_vValue;
@@ -106,7 +95,6 @@ public:
 
     // Sets the actual stored value, without affecting the goal, but resets the timer
     void setValue(const CColor& v) {
-        RASSERT(m_eVarType == AVARTYPE_COLOR, "Tried to access setValue(c) of AVARTYPE %i!", m_eVarType);
         m_cValue = v;
         animationBegin = std::chrono::system_clock::now();
         m_vBegun = m_vValue;
@@ -114,21 +102,18 @@ public:
 
     // Sets the actual value and goal
     void setValueAndWarp(const Vector2D& v) {
-        RASSERT(m_eVarType == AVARTYPE_VECTOR, "Tried to access setValueAndWarp(v) of AVARTYPE %i!", m_eVarType);
         m_vGoal = v;
         warp();
     }
 
     // Sets the actual value and goal
     void setValueAndWarp(const float& v) {
-        RASSERT(m_eVarType == AVARTYPE_FLOAT, "Tried to access setValueAndWarp(f) of AVARTYPE %i!", m_eVarType);
         m_fGoal = v;
         warp();
     }
 
     // Sets the actual value and goal
     void setValueAndWarp(const CColor& v) {
-        RASSERT(m_eVarType == AVARTYPE_COLOR, "Tried to access setValueAndWarp(c) of AVARTYPE %i!", m_eVarType);
         m_cGoal = v;
         warp();
     }
@@ -149,8 +134,6 @@ public:
         return false; // unreachable
     }
 
-private:
-
     void warp() {
         switch (m_eVarType) {
             case AVARTYPE_FLOAT: {
@@ -170,6 +153,8 @@ private:
         }
     }
 
+private:
+
     Vector2D        m_vValue = Vector2D(0,0);
     float           m_fValue = 0;
     CColor          m_cValue;

src/helpers/MiscFunctions.cpp

@@ -2,6 +2,42 @@
 #include "../defines.hpp"
 #include <algorithm>
 #include "../Compositor.hpp"
+#include <sys/utsname.h>
+
+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,
+	},
+};
 
 void addWLSignal(wl_signal* pSignal, wl_listener* pListener, void* pOwner, std::string ownerString) {
     ASSERT(pSignal);
@@ -46,21 +82,40 @@ void wlr_signal_emit_safe(struct wl_signal *signal, void *data) {
 }
 
 std::string getFormat(const char *fmt, ...) {
-    char buf[2048] = "";
+    char buf[LOGMESSAGESIZE] = "";
+    char* outputStr;
+    int logLen;
 
     va_list args;
     va_start(args, fmt);
-
-    vsprintf(buf, fmt, args);
-
+    logLen = vsnprintf(buf, sizeof buf, fmt, args);
     va_end(args);
 
-    return std::string(buf);
+    if ((long unsigned int)logLen < sizeof buf) {
+        outputStr = strdup(buf);
+    } else {
+        outputStr = (char*)malloc(logLen + 1);
+
+        if (!outputStr) {
+            printf("CRITICAL: Cannot alloc size %d for log! (Out of memory?)", logLen + 1);
+            return "";
+        }
+
+        va_start(args, fmt);
+        vsnprintf(outputStr, logLen + 1U, fmt, args);
+        va_end(args);
+    }
+
+    std::string output = std::string(outputStr);
+
+    free(outputStr);
+
+    return output;
 }
 
 void scaleBox(wlr_box* box, float scale) {
-    box->width = std::round((box->x + box->width) * scale) - std::round(box->x * scale);
-    box->height = std::round((box->y + box->height) * scale) - std::round(box->y * scale);
+    box->width = std::round(box->width * scale);
+    box->height = std::round(box->height * scale);
     box->x = std::round(box->x * scale);
     box->y = std::round(box->y * scale);
 }
@@ -115,8 +170,8 @@ float getPlusMinusKeywordResult(std::string source, float relative) {
     return result;
 }
 
-bool isNumber(const std::string& str) {
-    return std::ranges::all_of(str.begin(), str.end(), [](char c) { return isdigit(c) != 0; });
+bool isNumber(const std::string& str, bool allowfloat) {
+    return std::ranges::all_of(str.begin(), str.end(), [&](char c) { return isdigit(c) != 0 || c == '-' || (allowfloat && c == '.'); });
 }
 
 bool isDirection(const std::string& arg) {
@@ -125,7 +180,10 @@ bool isDirection(const std::string& arg) {
 
 int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
     int result = INT_MAX;
-    if (in.find("name:") == 0) {
+    if (in.find("special") == 0) {
+        outName = "special";
+        return SPECIAL_WORKSPACE_ID;
+    } else if (in.find("name:") == 0) {
         const auto WORKSPACENAME = in.substr(in.find_first_of(':') + 1);
         const auto WORKSPACE = g_pCompositor->getWorkspaceByName(WORKSPACENAME);
         if (!WORKSPACE) {
@@ -135,8 +193,72 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
         }
         outName = WORKSPACENAME;
     } else {
-        result = std::clamp((int)getPlusMinusKeywordResult(in, g_pCompositor->m_pLastMonitor->activeWorkspace), 1, INT_MAX);
-        outName = std::to_string(result);
+        if (in[0] == 'm') {
+            if (!g_pCompositor->m_pLastMonitor) {
+                Debug::log(ERR, "Relative monitor workspace on monitor null!");
+                result = INT_MAX;
+                return result;
+            }
+
+            // monitor relative
+            result = (int)getPlusMinusKeywordResult(in.substr(1), 0);
+
+            // result now has +/- what we should move on mon
+            int remains = (int)result;
+            int currentID = g_pCompositor->m_pLastMonitor->activeWorkspace;
+            int searchID = currentID;
+
+            while (remains != 0) {
+                if (remains < 0)
+                    searchID--;
+                else 
+                    searchID++;
+                
+                if (g_pCompositor->workspaceIDOutOfBounds(searchID)){
+                    // means we need to wrap around
+                    int lowestID = 99999;
+                    int highestID = -99999;
+
+                    for (auto& w : g_pCompositor->m_vWorkspaces) {
+                        if (w->m_iID < lowestID)
+                            lowestID = w->m_iID;
+
+                        if (w->m_iID > highestID)
+                            highestID = w->m_iID;
+                    }
+
+                    if (remains < 0)
+                        searchID = highestID;
+                    else 
+                        searchID = lowestID;
+                }
+
+                if (const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(searchID); PWORKSPACE && PWORKSPACE->m_iID != SPECIAL_WORKSPACE_ID) {
+                    if (PWORKSPACE->m_iMonitorID == g_pCompositor->m_pLastMonitor->ID) {
+                        currentID = PWORKSPACE->m_iID;
+
+                        if (remains < 0)
+                            remains++;
+                        else
+                            remains--;
+                    }
+                }
+            }
+
+            result = currentID;
+            outName = g_pCompositor->getWorkspaceByID(currentID)->m_szName;
+
+        } else {
+            if (g_pCompositor->m_pLastMonitor)
+                result = std::clamp((int)getPlusMinusKeywordResult(in, g_pCompositor->m_pLastMonitor->activeWorkspace), 1, INT_MAX);
+            else if (isNumber(in))
+                result = std::clamp(std::stoi(in), 1, INT_MAX);
+            else {
+                Debug::log(ERR, "Relative workspace on no mon!");
+                result = INT_MAX;
+            }
+            outName = std::to_string(result);
+        }        
     }
 
     return result;
@@ -146,4 +268,56 @@ float vecToRectDistanceSquared(const Vector2D& vec, const Vector2D& p1, const Ve
     const float DX = std::max((double)0, std::max(p1.x - vec.x, vec.x - p2.x));
     const float DY = std::max((double)0, std::max(p1.y - vec.y, vec.y - p2.y));
     return DX * DX + DY * DY;
-}
+}
+
+// Execute a shell command and get the output
+std::string execAndGet(const char* cmd) {
+    std::array<char, 128> buffer;
+    std::string result;
+    const std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(cmd, "r"), pclose);
+    if (!pipe) {
+        Debug::log(ERR, "execAndGet: failed in pipe");
+        return "";
+    }
+    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
+        result += buffer.data();
+    }
+    return result;
+}
+
+void logSystemInfo() {
+    struct utsname unameInfo;
+
+    uname(&unameInfo);
+
+    Debug::log(LOG, "System name: %s", unameInfo.sysname);
+    Debug::log(LOG, "Node name: %s", unameInfo.nodename);
+    Debug::log(LOG, "Release: %s", unameInfo.release);
+    Debug::log(LOG, "Version: %s", unameInfo.version);
+
+    // log etc
+    Debug::log(LOG, "os-release:");
+
+    Debug::log(NONE, "%s", execAndGet("cat /etc/os-release").c_str());
+}
+
+void matrixProjection(float mat[9], int w, int h, wl_output_transform tr) {
+    memset(mat, 0, sizeof(*mat) * 9);
+
+    const float* t = transforms[tr];
+    float x = 2.0f / w;
+    float y = 2.0f / h;
+
+    // Rotation + reflection
+    mat[0] = x * t[0];
+    mat[1] = x * t[1];
+    mat[3] = y * -t[3];
+    mat[4] = y * -t[4];
+
+    // Translation
+    mat[2] = -copysign(1.0f, mat[0] + mat[1]);
+    mat[5] = -copysign(1.0f, mat[3] + mat[4]);
+
+    // Identity
+    mat[8] = 1.0f;
+}

src/helpers/MiscFunctions.hpp

@@ -7,9 +7,13 @@ void wlr_signal_emit_safe(struct wl_signal *signal, void *data);
 std::string getFormat(const char *fmt, ...); // Basically Debug::log to a string
 void scaleBox(wlr_box*, float);
 std::string removeBeginEndSpacesTabs(std::string);
-bool isNumber(const std::string&);
+bool isNumber(const std::string&, bool allowfloat = false);
 bool isDirection(const std::string&);
 int getWorkspaceIDFromString(const std::string&, std::string&);
 float vecToRectDistanceSquared(const Vector2D& vec, const Vector2D& p1, const Vector2D& p2);
+void logSystemInfo();
+std::string execAndGet(const char*);
 
-float getPlusMinusKeywordResult(std::string in, float relative);
+float getPlusMinusKeywordResult(std::string in, float relative);
+
+void matrixProjection(float mat[9], int w, int h, wl_output_transform tr);

src/helpers/Monitor.hpp

@@ -27,8 +27,13 @@ struct SMonitor {
     wlr_output* output          = nullptr;
     float       refreshRate     = 60;
     wlr_output_damage* damage   = nullptr;
-    bool        needsFrameSkip  = false;
+    int         framesToSkip    = 0;
+    int         forceFullFrames = 0;
+    bool        noFrameSchedule = false;
     wl_output_transform transform = WL_OUTPUT_TRANSFORM_NORMAL;
+
+    // for the special workspace
+    bool        specialWorkspaceOpen = false;
     
     // 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

src/helpers/SubsurfaceTree.cpp

@@ -20,12 +20,13 @@ void addSurfaceGlobalOffset(SSurfaceTreeNode* node, int* lx, int* ly) {
     }
 }
 
-SSurfaceTreeNode* createTree(wlr_surface* pSurface) {
+SSurfaceTreeNode* createTree(wlr_surface* pSurface, CWindow* pWindow) {
     SubsurfaceTree::surfaceTreeNodes.push_back(SSurfaceTreeNode());
 
     const auto PNODE = &SubsurfaceTree::surfaceTreeNodes.back();
 
     PNODE->pSurface = pSurface;
+    PNODE->pWindowOwner = pWindow;
 
     PNODE->hyprListener_newSubsurface.initCallback(&pSurface->events.new_subsurface, &Events::listener_newSubsurfaceNode, PNODE, "SurfaceTreeNode");
     PNODE->hyprListener_commit.initCallback(&pSurface->events.commit, &Events::listener_commitSubsurface, PNODE, "SurfaceTreeNode");
@@ -42,16 +43,21 @@ SSurfaceTreeNode* createTree(wlr_surface* pSurface) {
     return PNODE;
 }
 
-SSurfaceTreeNode* createSubsurfaceNode(SSurfaceTreeNode* pParent, SSubsurface* pSubsurface, wlr_surface* surface) {
-    const auto PNODE = createTree(surface);
+SSurfaceTreeNode* createSubsurfaceNode(SSurfaceTreeNode* pParent, SSubsurface* pSubsurface, wlr_surface* surface, CWindow* pWindow) {
+    const auto PNODE = createTree(surface, pWindow);
     PNODE->pParent = pParent;
     PNODE->pSubsurface = pSubsurface;
 
+    Debug::log(LOG, "Creating a subsurface Node! (pWindow: %x)", pWindow);
+
     return PNODE;
 }
 
-SSurfaceTreeNode* SubsurfaceTree::createTreeRoot(wlr_surface* pSurface, applyGlobalOffsetFn fn, void* data) {
-    const auto PNODE = createTree(pSurface);
+SSurfaceTreeNode* SubsurfaceTree::createTreeRoot(wlr_surface* pSurface, applyGlobalOffsetFn fn, void* data, CWindow* pWindow) {
+    const auto PNODE = createTree(pSurface, pWindow);
+
+    Debug::log(LOG, "Creating a surfaceTree Root! (pWindow: %x)", pWindow);
+
     PNODE->offsetfn = fn;
     PNODE->globalOffsetData = data;
 
@@ -83,6 +89,20 @@ void SubsurfaceTree::destroySurfaceTree(SSurfaceTreeNode* pNode) {
     pNode->hyprListener_destroy.removeCallback();
     pNode->hyprListener_newSubsurface.removeCallback();
 
+    // damage
+    if (pNode->pSurface) {
+        wlr_box extents = {};
+        wlr_surface_get_extends(pNode->pSurface, &extents);
+
+        int lx = 0, ly = 0;
+        addSurfaceGlobalOffset(pNode, &lx, &ly);
+
+        extents.x += lx;
+        extents.y += ly;
+
+        g_pHyprRenderer->damageBox(&extents);
+    }
+
     surfaceTreeNodes.remove(*pNode);
 
     Debug::log(LOG, "SurfaceTree Node removed");
@@ -120,6 +140,8 @@ void Events::listener_newSubsurfaceNode(void* owner, void* data) {
     PNEWSUBSURFACE->hyprListener_unmap.initCallback(&PSUBSURFACE->events.unmap, &Events::listener_unmapSubsurface, PNEWSUBSURFACE, "Subsurface");
     PNEWSUBSURFACE->hyprListener_destroy.initCallback(&PSUBSURFACE->events.destroy, &Events::listener_destroySubsurface, PNEWSUBSURFACE, "Subsurface");
 
+    PNEWSUBSURFACE->pWindowOwner = pNode->pWindowOwner;
+
     wlr_subsurface* existingWlrSubsurface;
     wl_list_for_each(existingWlrSubsurface, &PSUBSURFACE->surface->current.subsurfaces_below, current.link) {
         listener_newSubsurfaceNode(pNode, existingWlrSubsurface);
@@ -134,7 +156,7 @@ void Events::listener_mapSubsurface(void* owner, void* data) {
 
     Debug::log(LOG, "Subsurface %x mapped", subsurface->pSubsurface);
 
-    subsurface->pChild = createSubsurfaceNode(subsurface->pParent, subsurface, subsurface->pSubsurface->surface);
+    subsurface->pChild = createSubsurfaceNode(subsurface->pParent, subsurface, subsurface->pSubsurface->surface, subsurface->pWindowOwner);
 }
 
 void Events::listener_unmapSubsurface(void* owner, void* data) {
@@ -154,6 +176,8 @@ void Events::listener_unmapSubsurface(void* owner, void* data) {
         extents.x += lx;
         extents.y += ly;
 
+        g_pHyprRenderer->damageBox(&extents);
+
         SubsurfaceTree::destroySurfaceTree(subsurface->pChild);
         subsurface->pChild = nullptr;
     }
@@ -162,10 +186,29 @@ void Events::listener_unmapSubsurface(void* owner, void* data) {
 void Events::listener_commitSubsurface(void* owner, void* data) {
     SSurfaceTreeNode* pNode = (SSurfaceTreeNode*)owner;
 
+    // no damaging if it's not visible
+    if (!g_pHyprRenderer->shouldRenderWindow(pNode->pWindowOwner)) {
+        static auto* const PLOGDAMAGE = &g_pConfigManager->getConfigValuePtr("debug:log_damage")->intValue;
+        if (*PLOGDAMAGE)
+            Debug::log(LOG, "Refusing to commit damage from %x because it's invisible.", pNode->pWindowOwner);
+        return;
+    }
+
     int lx = 0, ly = 0;
 
     addSurfaceGlobalOffset(pNode, &lx, &ly);
 
+    // I do not think this is correct, but it solves a lot of issues with some apps (e.g. firefox)
+    // What this does is that basically, if the pNode is a child of some other node, on commit,
+    // it will also damage (check & damage if needed) all its siblings.
+    if (pNode->pParent) for (auto& cs : pNode->pParent->childSubsurfaces) {
+        const auto NODECOORDS = pNode->pSubsurface ? Vector2D(pNode->pSubsurface->pSubsurface->current.x, pNode->pSubsurface->pSubsurface->current.y) : Vector2D();
+
+        if (&cs != pNode->pSubsurface && cs.pSubsurface) {
+            g_pHyprRenderer->damageSurface(cs.pSubsurface->surface, lx - NODECOORDS.x + cs.pSubsurface->current.x, ly - NODECOORDS.y + cs.pSubsurface->current.y);
+        }
+    }
+
     g_pHyprRenderer->damageSurface(pNode->pSurface, lx, ly);
 }
 

src/helpers/SubsurfaceTree.hpp

@@ -4,6 +4,7 @@
 #include <list>
 
 struct SSubsurface;
+class CWindow;
 
 typedef void (*applyGlobalOffsetFn)(void *, int *, int *);
 
@@ -21,6 +22,7 @@ struct SSurfaceTreeNode {
 
     applyGlobalOffsetFn offsetfn;
     void *globalOffsetData;
+    CWindow*            pWindowOwner = nullptr;
 
     bool operator==(const SSurfaceTreeNode& rhs) {
         return pSurface == rhs.pSurface;
@@ -37,13 +39,15 @@ struct SSubsurface {
     DYNLISTENER(unmap);
     DYNLISTENER(destroy);
 
+    CWindow*            pWindowOwner = nullptr;
+
     bool operator==(const SSubsurface& rhs) {
         return pSubsurface == rhs.pSubsurface;
     }
 };
 
 namespace SubsurfaceTree {
-    SSurfaceTreeNode* createTreeRoot(wlr_surface*, applyGlobalOffsetFn, void*);
+    SSurfaceTreeNode* createTreeRoot(wlr_surface*, applyGlobalOffsetFn, void*, CWindow* pWindow = nullptr);
     void destroySurfaceTree(SSurfaceTreeNode*);
 
     inline std::list<SSurfaceTreeNode> surfaceTreeNodes;

src/helpers/Timer.cpp

@@ -0,0 +1,17 @@
+#include "Timer.hpp"
+
+void CTimer::reset() {
+    m_tpLastReset = std::chrono::system_clock::now();
+}
+
+std::chrono::system_clock::duration CTimer::getDuration() {
+    return std::chrono::system_clock::now() - m_tpLastReset;
+}
+
+int CTimer::getMillis() {
+    return std::chrono::duration_cast<std::chrono::milliseconds>(getDuration()).count();
+}
+
+float CTimer::getSeconds() {
+    return std::chrono::duration_cast<std::chrono::milliseconds>(getDuration()).count() / 1000.f;
+}

src/helpers/Timer.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "../defines.hpp"
+
+class CTimer {
+public:
+    void        reset();
+    float       getSeconds();
+    int         getMillis();
+
+private:
+    std::chrono::system_clock::time_point m_tpLastReset;
+
+    std::chrono::system_clock::duration getDuration();
+};

src/helpers/Vector2D.cpp

@@ -1,4 +1,5 @@
 #include "Vector2D.hpp"
+#include <algorithm>
 
 Vector2D::Vector2D(double xx, double yy) {
     x = xx;
@@ -20,4 +21,11 @@ double Vector2D::normalize() {
 
 Vector2D Vector2D::floor() {
     return Vector2D((int)x, (int)y);
+}
+
+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)
+    );
 }

src/helpers/Vector2D.hpp

@@ -35,5 +35,7 @@ class Vector2D {
         return a.x != x || a.y != y;
     }
 
+    Vector2D clamp(const Vector2D& min, const Vector2D& max = Vector2D());
+
     Vector2D floor();
 };

src/helpers/WLClasses.hpp

@@ -2,7 +2,7 @@
 
 #include "../events/Events.hpp"
 #include "../defines.hpp"
-#include "../../wlr-layer-shell-unstable-v1-protocol.h"
+#include "wlr-layer-shell-unstable-v1-protocol.h"
 #include "../Window.hpp"
 #include "SubsurfaceTree.hpp"
 #include "AnimatedVariable.hpp"
@@ -69,6 +69,15 @@ struct SKeyboard {
     DYNLISTENER(keyboardKey);
     DYNLISTENER(keyboardDestroy);
 
+    bool active = false;
+
+    std::string name = "";
+
+    xkb_rule_names currentRules = {0};
+    int repeatRate = 0;
+    int repeatDelay = 0;
+    int numlockOn = -1;
+
     // For the list lookup
     bool operator==(const SKeyboard& rhs) {
         return keyboard == rhs.keyboard;
@@ -83,6 +92,8 @@ struct SMouse {
 
     pixman_region32_t confinedTo;
 
+    std::string name = "";
+
     DYNLISTENER(commitConstraint);
     DYNLISTENER(destroyMouse);
 
@@ -151,4 +162,62 @@ struct SDrag {
     DYNLISTENER(mapIcon);
     DYNLISTENER(unmapIcon);
     DYNLISTENER(commitIcon);
-};
+};
+
+struct STablet {
+    DYNLISTENER(Tip);
+    DYNLISTENER(Axis);
+    DYNLISTENER(Button);
+    DYNLISTENER(Proximity);
+    DYNLISTENER(Destroy);
+
+    wlr_tablet* wlrTablet = nullptr;
+    wlr_tablet_v2_tablet* wlrTabletV2 = nullptr;
+    wlr_input_device* wlrDevice = nullptr;
+
+    std::string name = "";
+
+    bool operator==(const STablet& b) {
+        return wlrDevice == b.wlrDevice;
+    }
+};
+
+struct STabletTool {
+    wlr_tablet_tool* wlrTabletTool = nullptr;
+    wlr_tablet_v2_tablet_tool* wlrTabletToolV2 = nullptr;
+
+    wlr_tablet_v2_tablet* wlrTabletOwnerV2 = nullptr;
+
+    wlr_surface* pSurface = nullptr;
+
+    double tiltX = 0;
+    double tiltY = 0;
+
+    bool active = true;
+
+    std::string name = "";
+
+    DYNLISTENER(TabletToolDestroy);
+    DYNLISTENER(TabletToolSetCursor);
+
+    bool operator==(const STabletTool& b) {
+        return wlrTabletTool == b.wlrTabletTool;
+    }
+};
+
+struct STabletPad {
+    wlr_tablet_v2_tablet_pad* wlrTabletPadV2 = nullptr;
+    STablet* pTabletParent = nullptr;
+
+    std::string name = "";
+
+    DYNLISTENER(Attach);
+    DYNLISTENER(Button);
+    DYNLISTENER(Strip);
+    DYNLISTENER(Ring);
+    DYNLISTENER(Destroy);
+
+    bool operator==(const STabletPad& b) {
+        return wlrTabletPadV2 == b.wlrTabletPadV2;
+    }
+};

src/helpers/Workspace.cpp

@@ -1,7 +1,7 @@
 #include "Workspace.hpp"
 #include "../Compositor.hpp"
 
-CWorkspace::CWorkspace(int monitorID) {
+CWorkspace::CWorkspace(int monitorID, std::string name, bool special) {
     const auto PMONITOR = g_pCompositor->getMonitorFromID(monitorID);
 
     if (!PMONITOR) {
@@ -10,35 +10,45 @@ CWorkspace::CWorkspace(int monitorID) {
     }
 
     m_iMonitorID = monitorID;
+    m_szName = name;
+    m_bIsSpecialWorkspace = special;
     
-    m_pWlrHandle = wlr_ext_workspace_handle_v1_create(PMONITOR->pWLRWorkspaceGroupHandle);
+    if (!special) {
+        m_pWlrHandle = wlr_ext_workspace_handle_v1_create(PMONITOR->pWLRWorkspaceGroupHandle);
 
-    // set geometry here cuz we can
-    wl_array_init(&m_wlrCoordinateArr);
-    *reinterpret_cast<int*>(wl_array_add(&m_wlrCoordinateArr, sizeof(int))) = (int)PMONITOR->vecPosition.x;
-    *reinterpret_cast<int*>(wl_array_add(&m_wlrCoordinateArr, sizeof(int))) = (int)PMONITOR->vecPosition.y;
-    wlr_ext_workspace_handle_v1_set_coordinates(m_pWlrHandle, &m_wlrCoordinateArr);
-    wlr_ext_workspace_handle_v1_set_hidden(m_pWlrHandle, false);
-    wlr_ext_workspace_handle_v1_set_urgent(m_pWlrHandle, false);
+        // set geometry here cuz we can
+        wl_array_init(&m_wlrCoordinateArr);
+        *reinterpret_cast<int*>(wl_array_add(&m_wlrCoordinateArr, sizeof(int))) = (int)PMONITOR->vecPosition.x;
+        *reinterpret_cast<int*>(wl_array_add(&m_wlrCoordinateArr, sizeof(int))) = (int)PMONITOR->vecPosition.y;
+        wlr_ext_workspace_handle_v1_set_coordinates(m_pWlrHandle, &m_wlrCoordinateArr);
+        wlr_ext_workspace_handle_v1_set_hidden(m_pWlrHandle, false);
+        wlr_ext_workspace_handle_v1_set_urgent(m_pWlrHandle, false);
+    }
 
     m_vRenderOffset.m_pWorkspace = this;
     m_vRenderOffset.create(AVARTYPE_VECTOR, &g_pConfigManager->getConfigValuePtr("animations:workspaces_speed")->floatValue, &g_pConfigManager->getConfigValuePtr("animations:workspaces")->intValue, &g_pConfigManager->getConfigValuePtr("animations:workspaces_curve")->strValue, nullptr, AVARDAMAGE_ENTIRE);
     m_fAlpha.m_pWorkspace = this;
     m_fAlpha.create(AVARTYPE_FLOAT, &g_pConfigManager->getConfigValuePtr("animations:workspaces_speed")->floatValue, &g_pConfigManager->getConfigValuePtr("animations:workspaces")->intValue, &g_pConfigManager->getConfigValuePtr("animations:workspaces_curve")->strValue, nullptr, AVARDAMAGE_ENTIRE);
     m_fAlpha.setValueAndWarp(255.f);
+
+    g_pEventManager->postEvent({"createworkspace", m_szName}, true);
 }
 
 CWorkspace::~CWorkspace() {
     m_vRenderOffset.unregister();
 
+    Debug::log(LOG, "Destroying workspace ID %d", m_iID);
+
     if (m_pWlrHandle) {
         wlr_ext_workspace_handle_v1_set_active(m_pWlrHandle, false);
         wlr_ext_workspace_handle_v1_destroy(m_pWlrHandle);
         m_pWlrHandle = nullptr;
     }
+
+    g_pEventManager->postEvent({"destroyworkspace", m_szName}, true);
 }
 
-void CWorkspace::startAnim(bool in, bool left) {
+void CWorkspace::startAnim(bool in, bool left, bool instant) {
     const auto ANIMSTYLE = g_pConfigManager->getString("animations:workspaces_style");
 
     if (ANIMSTYLE == "fade") {
@@ -51,6 +61,18 @@ void CWorkspace::startAnim(bool in, bool left) {
             m_fAlpha.setValueAndWarp(255.f);
             m_fAlpha = 0.f;
         }
+    } else if (ANIMSTYLE == "slidevert") {
+        // fallback is slide
+        const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+
+        m_fAlpha.setValueAndWarp(255.f);  // fix a bug, if switching from fade -> slide.
+
+        if (in) {
+            m_vRenderOffset.setValueAndWarp(Vector2D(0, left ? PMONITOR->vecSize.y : -PMONITOR->vecSize.y));
+            m_vRenderOffset = Vector2D(0, 0);
+        } else {
+            m_vRenderOffset = Vector2D(0, left ? -PMONITOR->vecSize.y : PMONITOR->vecSize.y);
+        }
     } else {
         // fallback is slide
         const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
@@ -64,10 +86,37 @@ void CWorkspace::startAnim(bool in, bool left) {
             m_vRenderOffset = Vector2D(left ? -PMONITOR->vecSize.x : PMONITOR->vecSize.x, 0);
         }
     }
+
+    if (instant) {
+        m_vRenderOffset.warp();
+        m_fAlpha.warp();
+    }
 }
 
 void CWorkspace::setActive(bool on) {
     if (m_pWlrHandle) {
         wlr_ext_workspace_handle_v1_set_active(m_pWlrHandle, on);
     }
+}
+
+void CWorkspace::moveToMonitor(const int& id) {
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(id);
+
+    if (!PMONITOR || m_bIsSpecialWorkspace)
+        return;
+
+    wlr_ext_workspace_handle_v1_set_active(m_pWlrHandle, false);
+    wlr_ext_workspace_handle_v1_destroy(m_pWlrHandle);
+
+    m_pWlrHandle = wlr_ext_workspace_handle_v1_create(PMONITOR->pWLRWorkspaceGroupHandle);
+
+    // set geometry here cuz we can
+    wl_array_init(&m_wlrCoordinateArr);
+    *reinterpret_cast<int*>(wl_array_add(&m_wlrCoordinateArr, sizeof(int))) = (int)PMONITOR->vecPosition.x;
+    *reinterpret_cast<int*>(wl_array_add(&m_wlrCoordinateArr, sizeof(int))) = (int)PMONITOR->vecPosition.y;
+    wlr_ext_workspace_handle_v1_set_coordinates(m_pWlrHandle, &m_wlrCoordinateArr);
+    wlr_ext_workspace_handle_v1_set_hidden(m_pWlrHandle, false);
+    wlr_ext_workspace_handle_v1_set_urgent(m_pWlrHandle, false);
+
+    wlr_ext_workspace_handle_v1_set_name(m_pWlrHandle, m_szName.c_str());
 }

src/helpers/Workspace.hpp

@@ -10,7 +10,7 @@ enum eFullscreenMode : uint8_t {
 
 class CWorkspace {
 public:
-    CWorkspace(int monitorID);
+    CWorkspace(int monitorID, std::string name, bool special = false);
     ~CWorkspace();
 
     // Workspaces ID-based have IDs > 0
@@ -29,10 +29,15 @@ public:
     CAnimatedVariable m_vRenderOffset;
     CAnimatedVariable m_fAlpha;
 
+    // "scratchpad"
+    bool            m_bIsSpecialWorkspace = false;
+
     // user-set
     bool            m_bDefaultFloating = false;
     bool            m_bDefaultPseudo = false;
 
-    void            startAnim(bool in, bool left);
+    void            startAnim(bool in, bool left, bool instant = false);
     void            setActive(bool on);
+
+    void            moveToMonitor(const int&);
 };

src/hyprerror/HyprError.cpp

@@ -12,7 +12,7 @@ void CHyprError::createQueued() {
         m_tTexture.destroyTexture();
     }
 
-    const auto PMONITOR = &g_pCompositor->m_lMonitors.front();
+    const auto PMONITOR = g_pCompositor->m_vMonitors.front().get();
 
     const auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->vecSize.x, PMONITOR->vecSize.y);
 
@@ -95,11 +95,11 @@ void CHyprError::draw() {
         m_tTexture.destroyTexture();
         m_bIsCreated = false;
         m_szQueued = "";
-        g_pHyprRenderer->damageMonitor(&g_pCompositor->m_lMonitors.front());
+        g_pHyprRenderer->damageMonitor(g_pCompositor->m_vMonitors.front().get());
         return;
     }
 
-    const auto PMONITOR = &g_pCompositor->m_lMonitors.front();
+    const auto PMONITOR = g_pCompositor->m_vMonitors.front().get();
 
     if (g_pHyprOpenGL->m_RenderData.pMonitor != PMONITOR)
         return; // wrong mon

src/includes.hpp

@@ -77,6 +77,9 @@ extern "C" {
 #include <wlr/util/log.h>
 #include <wlr/xwayland.h>
 #include <wlr/util/region.h>
+#include <wlr/types/wlr_tablet_pad.h>
+#include <wlr/types/wlr_tablet_tool.h>
+#include <wlr/types/wlr_tablet_v2.h>
 #include <xkbcommon/xkbcommon.h>
 #include <X11/Xproto.h>
 #include <wlr/render/egl.h>
@@ -84,6 +87,10 @@ extern "C" {
 #include <wlr/render/wlr_texture.h>
 #include <wlr/types/wlr_pointer_constraints_v1.h>
 #include <wlr/types/wlr_relative_pointer_v1.h>
+#include <wlr/interfaces/wlr_keyboard.h>
+#include <wlr/types/wlr_xdg_foreign_registry.h>
+#include <wlr/types/wlr_xdg_foreign_v1.h>
+#include <wlr/types/wlr_xdg_foreign_v2.h>
 }
 
 #undef class
@@ -109,4 +116,6 @@ extern "C" {
 
 #include "helpers/Vector2D.hpp"
 
-#include "../ext-workspace-unstable-v1-protocol.h"
+#include "ext-workspace-unstable-v1-protocol.h"
+
+#include <algorithm>

src/layout/DwindleLayout.cpp

@@ -93,17 +93,28 @@ SDwindleNodeData* CHyprDwindleLayout::getMasterNodeOnWorkspace(const int& id) {
 }
 
 void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode) {
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(g_pCompositor->getWorkspaceByID(pNode->workspaceID)->m_iMonitorID);
-
-    if (!PMONITOR){
-        Debug::log(ERR, "Orphaned Node %x (workspace ID: %i)!!", pNode, pNode->workspaceID);
-        return;
-    }
-
     // Don't set nodes, only windows.
     if (pNode->isNode) 
         return;
 
+    SMonitor* PMONITOR = nullptr;
+
+    if (pNode->workspaceID == SPECIAL_WORKSPACE_ID) {
+        for (auto& m : g_pCompositor->m_vMonitors) {
+            if (m->specialWorkspaceOpen) {
+                PMONITOR = m.get();
+                break;
+            }
+        }
+    } else {
+        PMONITOR = g_pCompositor->getMonitorFromID(g_pCompositor->getWorkspaceByID(pNode->workspaceID)->m_iMonitorID);
+    }
+
+    if (!PMONITOR) {
+        Debug::log(ERR, "Orphaned Node %x (workspace ID: %i)!!", pNode, pNode->workspaceID);
+        return;
+    }
+
     // for gaps outer
     const bool DISPLAYLEFT          = STICKS(pNode->position.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x);
     const bool DISPLAYRIGHT         = STICKS(pNode->position.x + pNode->size.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x);
@@ -160,13 +171,25 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode) {
         }
     }
 
-    PWINDOW->m_vRealSize = calcSize;
-    PWINDOW->m_vRealPosition = calcPos;
+    if (PWINDOW->m_iWorkspaceID == SPECIAL_WORKSPACE_ID) {
+        // if special, we adjust the coords a bit
+        static auto *const PSCALEFACTOR = &g_pConfigManager->getConfigValuePtr("dwindle:special_scale_factor")->floatValue;
 
-    g_pXWaylandManager->setWindowSize(PWINDOW, calcSize);
+        PWINDOW->m_vRealPosition = calcPos + (calcSize - calcSize * *PSCALEFACTOR) / 2.f;
+        PWINDOW->m_vRealSize = calcSize * *PSCALEFACTOR;
+
+        g_pXWaylandManager->setWindowSize(PWINDOW, calcSize * *PSCALEFACTOR);
+    } else {
+        PWINDOW->m_vRealSize = calcSize;
+        PWINDOW->m_vRealPosition = calcPos;
+
+        g_pXWaylandManager->setWindowSize(PWINDOW, calcSize);
+    }
+
+    PWINDOW->updateWindowDecos();
 }
 
-void CHyprDwindleLayout::onWindowCreated(CWindow* pWindow) {
+void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
     if (pWindow->m_bIsFloating)
         return;
 
@@ -184,7 +207,7 @@ void CHyprDwindleLayout::onWindowCreated(CWindow* pWindow) {
     SDwindleNodeData* OPENINGON;
     const auto MONFROMCURSOR = g_pCompositor->getMonitorFromCursor();
 
-    if (PMONITOR->ID == MONFROMCURSOR->ID && PNODE->workspaceID == PMONITOR->activeWorkspace) {
+    if (PMONITOR->ID == MONFROMCURSOR->ID && (PNODE->workspaceID == PMONITOR->activeWorkspace || (PNODE->workspaceID == SPECIAL_WORKSPACE_ID && PMONITOR->specialWorkspaceOpen))) {
         OPENINGON = getNodeFromWindow(g_pCompositor->vectorToWindowTiled(g_pInputManager->getMouseCoordsInternal()));
 
         // happens on reserved area
@@ -196,6 +219,11 @@ void CHyprDwindleLayout::onWindowCreated(CWindow* pWindow) {
 
     Debug::log(LOG, "OPENINGON: %x, Workspace: %i, Monitor: %i", OPENINGON, PNODE->workspaceID, PMONITOR->ID);
 
+    if (OPENINGON && OPENINGON->workspaceID != PNODE->workspaceID) {
+        // special workspace handling
+        OPENINGON = getFirstNodeOnWorkspace(PNODE->workspaceID);
+    }
+
     // if it's the first, it's easy. Make it fullscreen.
     if (!OPENINGON || OPENINGON->pWindow == pWindow) {
         PNODE->position = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
@@ -292,7 +320,7 @@ void CHyprDwindleLayout::onWindowCreated(CWindow* pWindow) {
     }
 }
 
-void CHyprDwindleLayout::onWindowRemoved(CWindow* pWindow) {
+void CHyprDwindleLayout::onWindowRemovedTiling(CWindow* pWindow) {
 
     const auto PNODE = getNodeFromWindow(pWindow);
 
@@ -356,6 +384,19 @@ void CHyprDwindleLayout::recalculateMonitor(const int& monid) {
     const auto PMONITOR = g_pCompositor->getMonitorFromID(monid);
     const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
 
+    if (!PWORKSPACE)
+        return;
+
+    if (PMONITOR->specialWorkspaceOpen) {
+        const auto TOPNODE = getMasterNodeOnWorkspace(SPECIAL_WORKSPACE_ID);
+
+        if (TOPNODE && PMONITOR) {
+            TOPNODE->position = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
+            TOPNODE->size = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight;
+            TOPNODE->recalcSizePosRecursive();
+        }
+    }
+
     // Ignore any recalc events if we have a fullscreen window.
     if (PWORKSPACE->m_bHasFullscreenWindow)
         return;
@@ -369,272 +410,116 @@ void CHyprDwindleLayout::recalculateMonitor(const int& monid) {
     }
 }
 
-void CHyprDwindleLayout::changeWindowFloatingMode(CWindow* pWindow) {
+bool CHyprDwindleLayout::isWindowTiled(CWindow* pWindow) {
+    return getNodeFromWindow(pWindow) != nullptr;
+}
 
-    if (pWindow->m_bIsFullscreen) {
-        Debug::log(LOG, "Rejecting a change float order because window is fullscreen.");
+void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, CWindow* pWindow) {
 
-        // restore its' floating mode
-        pWindow->m_bIsFloating = !pWindow->m_bIsFloating;
+    const auto PWINDOW = pWindow ? pWindow : g_pCompositor->m_pLastWindow;
+
+    if (!g_pCompositor->windowValidMapped(PWINDOW))
         return;
-    }
 
-    const auto PNODE = getNodeFromWindow(pWindow);
+    const auto PNODE = getNodeFromWindow(PWINDOW);
 
     if (!PNODE) {
-        const auto PNEWMON = g_pCompositor->getMonitorFromVector(pWindow->m_vRealPosition.vec() + pWindow->m_vRealSize.vec() / 2.f);
-        pWindow->m_iMonitorID = PNEWMON->ID;
-        pWindow->m_iWorkspaceID = PNEWMON->activeWorkspace;
-
-        // save real pos cuz the func applies the default 5,5 mid
-        const auto PSAVEDPOS = pWindow->m_vRealPosition.vec();
-        const auto PSAVEDSIZE = pWindow->m_vRealSize.vec();
-
-        // if the window is pseudo, update its size
-        pWindow->m_vPseudoSize = pWindow->m_vRealSize.vec();
-
-        onWindowCreated(pWindow);
-
-        pWindow->m_vRealPosition.setValue(PSAVEDPOS);
-        pWindow->m_vRealSize.setValue(PSAVEDSIZE);
-
-        // fix pseudo leaving artifacts
-        g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID));
-    } else {
-        onWindowRemoved(pWindow);
-
-        g_pCompositor->moveWindowToTop(pWindow);
-    }
-}
-
-void CHyprDwindleLayout::onBeginDragWindow() {
-
-    const auto DRAGGINGWINDOW = g_pInputManager->currentlyDraggedWindow;
-
-    m_vBeginDragSizeXY = Vector2D();
-
-    // 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!");
+        PWINDOW->m_vRealSize = Vector2D(std::clamp((PWINDOW->m_vRealSize.goalv() + pixResize).x, (double)20, (double)999999), std::clamp((PWINDOW->m_vRealSize.goalv() + pixResize).y, (double)20, (double)999999));
+        PWINDOW->updateWindowDecos();
         return;
     }
 
-    if (DRAGGINGWINDOW->m_bIsFullscreen) {
-	    Debug::log(LOG, "Rejecting drag on a fullscreen window.");
-	    return;
-    }
+    // get some data about our window
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+    const bool DISPLAYLEFT = STICKS(PWINDOW->m_vPosition.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x);
+    const bool DISPLAYRIGHT = STICKS(PWINDOW->m_vPosition.x + PWINDOW->m_vSize.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x);
+    const bool DISPLAYTOP = STICKS(PWINDOW->m_vPosition.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y);
+    const bool DISPLAYBOTTOM = STICKS(PWINDOW->m_vPosition.y + PWINDOW->m_vSize.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y);
 
-    DRAGGINGWINDOW->m_bDraggingTiled = false;
+    // construct allowed movement
+    Vector2D allowedMovement = pixResize;
+    if (DISPLAYLEFT && DISPLAYRIGHT)
+        allowedMovement.x = 0;
 
-    if (!DRAGGINGWINDOW->m_bIsFloating) {
-        if (g_pInputManager->dragButton == BTN_LEFT) {
-            changeWindowFloatingMode(DRAGGINGWINDOW);
-            DRAGGINGWINDOW->m_bIsFloating = true;
-            DRAGGINGWINDOW->m_bDraggingTiled = true;
-        }
-    }
+    if (DISPLAYBOTTOM && DISPLAYTOP)
+        allowedMovement.y = 0;
 
-    m_vBeginDragXY = g_pInputManager->getMouseCoordsInternal();
-    m_vBeginDragPositionXY = DRAGGINGWINDOW->m_vRealPosition.vec();
-    m_vBeginDragSizeXY = DRAGGINGWINDOW->m_vRealSize.vec();
-    m_vLastDragXY = m_vBeginDragXY;
+    // get the correct containers to apply splitratio to
+    const auto PPARENT = PNODE->pParent;
 
-    g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
-}
+    if (!PPARENT)
+        return;  // the only window on a workspace, ignore
 
-void CHyprDwindleLayout::onEndDragWindow() {
-    const auto DRAGGINGWINDOW = g_pInputManager->currentlyDraggedWindow;
+    const bool PARENTSIDEBYSIDE = !PPARENT->splitTop;
 
-    if (DRAGGINGWINDOW->m_bDraggingTiled) {
-        DRAGGINGWINDOW->m_bIsFloating = false;
-        changeWindowFloatingMode(DRAGGINGWINDOW);
-    }
-        
-    g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
-}
+    // Get the parent's parent
+    auto PPARENT2 = PPARENT->pParent;
 
-void CHyprDwindleLayout::onMouseMove(const Vector2D& mousePos) {
-    const auto DRAGGINGWINDOW = g_pInputManager->currentlyDraggedWindow;
-
-    // Window invalid or drag begin size 0,0 meaning we rejected it.
-    if (!g_pCompositor->windowValidMapped(DRAGGINGWINDOW) || m_vBeginDragSizeXY == Vector2D())
-        return;
-        
-    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)
-        return;
-
-    m_vLastDragXY = mousePos;
-
-    g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
-
-    if (g_pInputManager->dragButton == BTN_LEFT) {
-        DRAGGINGWINDOW->m_vRealPosition.setValueAndWarp(m_vBeginDragPositionXY + DELTA);
-        g_pXWaylandManager->setWindowSize(DRAGGINGWINDOW, DRAGGINGWINDOW->m_vRealSize.goalv());
-    } else {
-        if (DRAGGINGWINDOW->m_bIsFloating) {
-            DRAGGINGWINDOW->m_vRealSize.setValueAndWarp(m_vBeginDragSizeXY + DELTA);
-            DRAGGINGWINDOW->m_vRealSize.setValueAndWarp(Vector2D(std::clamp(DRAGGINGWINDOW->m_vRealSize.vec().x, (double)20, (double)999999), std::clamp(DRAGGINGWINDOW->m_vRealSize.vec().y, (double)20, (double)999999)));
-
-            g_pXWaylandManager->setWindowSize(DRAGGINGWINDOW, DRAGGINGWINDOW->m_vRealSize.goalv());
+    // No parent means we have only 2 windows, and thus one axis of freedom
+    if (!PPARENT2) {
+        if (PARENTSIDEBYSIDE) {
+            allowedMovement.x *= 2.f / PPARENT->size.x;
+            PPARENT->splitRatio = std::clamp(PPARENT->splitRatio + allowedMovement.x, (double)0.1f, (double)1.9f);
+            PPARENT->recalcSizePosRecursive();
         } else {
-            // we need to adjust the splitratio
-
-            // get some data about our window
-            const auto PNODE            = getNodeFromWindow(DRAGGINGWINDOW);
-            const auto PMONITOR         = g_pCompositor->getMonitorFromID(DRAGGINGWINDOW->m_iMonitorID);
-            const bool DISPLAYLEFT      = STICKS(DRAGGINGWINDOW->m_vPosition.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x);
-            const bool DISPLAYRIGHT     = STICKS(DRAGGINGWINDOW->m_vPosition.x + DRAGGINGWINDOW->m_vSize.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x);
-            const bool DISPLAYTOP       = STICKS(DRAGGINGWINDOW->m_vPosition.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y);
-            const bool DISPLAYBOTTOM    = STICKS(DRAGGINGWINDOW->m_vPosition.y + DRAGGINGWINDOW->m_vSize.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y);
-
-            // construct allowed movement
-            Vector2D allowedMovement = TICKDELTA;
-            if (DISPLAYLEFT && DISPLAYRIGHT)
-                allowedMovement.x = 0;
-
-            if (DISPLAYBOTTOM && DISPLAYTOP)
-                allowedMovement.y = 0;
-
-            // get the correct containers to apply splitratio to
-            const auto PPARENT = PNODE->pParent;
-
-            if (!PPARENT)
-                return; // the only window on a workspace, ignore
-
-            const bool PARENTSIDEBYSIDE = !PPARENT->splitTop;
-
-            // Get the parent's parent
-            auto PPARENT2 = PPARENT->pParent;
-
-            // No parent means we have only 2 windows, and thus one axis of freedom
-            if (!PPARENT2) {
-                if (PARENTSIDEBYSIDE) {
-                    allowedMovement.x *= 2.f / PPARENT->size.x;
-                    PPARENT->splitRatio = std::clamp(PPARENT->splitRatio + allowedMovement.x, (double)0.1f, (double)1.9f);
-                    PPARENT->recalcSizePosRecursive();
-                } else {
-                    allowedMovement.y *= 2.f / PPARENT->size.y;
-                    PPARENT->splitRatio = std::clamp(PPARENT->splitRatio + allowedMovement.y, (double)0.1f, (double)1.9f);
-                    PPARENT->recalcSizePosRecursive();
-                }
-
-                return;
-            }
-
-            // Get first parent with other split
-            while(PPARENT2 && PPARENT2->splitTop == !PARENTSIDEBYSIDE)
-                PPARENT2 = PPARENT2->pParent;
-
-            // no parent, one axis of freedom
-            if (!PPARENT2) {
-                if (PARENTSIDEBYSIDE) {
-                    allowedMovement.x *= 2.f / PPARENT->size.x;
-                    PPARENT->splitRatio = std::clamp(PPARENT->splitRatio + allowedMovement.x, (double)0.1f, (double)1.9f);
-                    PPARENT->recalcSizePosRecursive();
-                } else {
-                    allowedMovement.y *= 2.f / PPARENT->size.y;
-                    PPARENT->splitRatio = std::clamp(PPARENT->splitRatio + allowedMovement.y, (double)0.1f, (double)1.9f);
-                    PPARENT->recalcSizePosRecursive();
-                }
-
-                return;
-            }
-
-            // 2 axes of freedom
-            const auto SIDECONTAINER = PARENTSIDEBYSIDE ? PPARENT : PPARENT2;
-            const auto TOPCONTAINER = PARENTSIDEBYSIDE ? PPARENT2 : PPARENT;
-
-            allowedMovement.x *= 2.f / SIDECONTAINER->size.x;
-            allowedMovement.y *= 2.f / TOPCONTAINER->size.y;
-
-            SIDECONTAINER->splitRatio = std::clamp(SIDECONTAINER->splitRatio + allowedMovement.x, (double)0.1f, (double)1.9f);
-            TOPCONTAINER->splitRatio = std::clamp(TOPCONTAINER->splitRatio + allowedMovement.y, (double)0.1f, (double)1.9f);
-            SIDECONTAINER->recalcSizePosRecursive();
-            TOPCONTAINER->recalcSizePosRecursive();
+            allowedMovement.y *= 2.f / PPARENT->size.y;
+            PPARENT->splitRatio = std::clamp(PPARENT->splitRatio + allowedMovement.y, (double)0.1f, (double)1.9f);
+            PPARENT->recalcSizePosRecursive();
         }
-    }
 
-    // get middle point
-    Vector2D middle = DRAGGINGWINDOW->m_vRealPosition.vec() + DRAGGINGWINDOW->m_vRealSize.vec() / 2.f;
-
-    // and check its monitor
-    const auto PMONITOR = g_pCompositor->getMonitorFromVector(middle);
-
-    if (PMONITOR) {
-        DRAGGINGWINDOW->m_iMonitorID = PMONITOR->ID;
-        DRAGGINGWINDOW->m_iWorkspaceID = PMONITOR->activeWorkspace;
-    }
-
-    g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
-}
-
-void CHyprDwindleLayout::onWindowCreatedFloating(CWindow* pWindow) {
-    wlr_box desiredGeometry = {0};
-    g_pXWaylandManager->getGeometryForWindow(pWindow, &desiredGeometry);
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
-
-    if (!PMONITOR){
-        Debug::log(ERR, "Window %x (%s) has an invalid monitor in onWindowCreatedFloating!!!", pWindow, pWindow->m_szTitle.c_str());
         return;
     }
 
-    if (desiredGeometry.width <= 0 || desiredGeometry.height <= 0) {
-        const auto PWINDOWSURFACE = g_pXWaylandManager->getWindowSurface(pWindow);
-        pWindow->m_vRealSize = Vector2D(PWINDOWSURFACE->current.width, PWINDOWSURFACE->current.height);
-        pWindow->m_vRealPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_vRealSize.vec().x) / 2.f, PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_vRealSize.vec().y) / 2.f);
+    // Get first parent with other split
+    while (PPARENT2 && PPARENT2->splitTop == !PARENTSIDEBYSIDE)
+        PPARENT2 = PPARENT2->pParent;
 
-    } else {
-        // we respect the size.
-        pWindow->m_vRealSize = Vector2D(desiredGeometry.width, desiredGeometry.height);
-
-        // check if it's on the correct monitor!
-        Vector2D middlePoint = Vector2D(desiredGeometry.x, desiredGeometry.y) + Vector2D(desiredGeometry.width, desiredGeometry.height) / 2.f;
-
-         // TODO: detect a popup in a more consistent way.
-        if (!g_pCompositor->isPointOnAnyMonitor(middlePoint) || (desiredGeometry.x == 0 && desiredGeometry.y == 0)) {
-            // if it's not, fall back to the center placement
-            pWindow->m_vRealPosition = PMONITOR->vecPosition + Vector2D((PMONITOR->vecSize.x - desiredGeometry.width) / 2.f, (PMONITOR->vecSize.y - desiredGeometry.height) / 2.f);
+    // no parent, one axis of freedom
+    if (!PPARENT2) {
+        if (PARENTSIDEBYSIDE) {
+            allowedMovement.x *= 2.f / PPARENT->size.x;
+            PPARENT->splitRatio = std::clamp(PPARENT->splitRatio + allowedMovement.x, (double)0.1f, (double)1.9f);
+            PPARENT->recalcSizePosRecursive();
         } else {
-            // if it is, we respect where it wants to put itself, but apply monitor offset if outside
-            // most of these are popups
-
-            if (const auto POPENMON = g_pCompositor->getMonitorFromVector(middlePoint); POPENMON->ID != PMONITOR->ID) {
-                pWindow->m_vRealPosition = Vector2D(desiredGeometry.x, desiredGeometry.y) - POPENMON->vecPosition + PMONITOR->vecPosition;
-            } else {
-                pWindow->m_vRealPosition = Vector2D(desiredGeometry.x, desiredGeometry.y);
-            }
+            allowedMovement.y *= 2.f / PPARENT->size.y;
+            PPARENT->splitRatio = std::clamp(PPARENT->splitRatio + allowedMovement.y, (double)0.1f, (double)1.9f);
+            PPARENT->recalcSizePosRecursive();
         }
+
+        return;
     }
 
-    if (pWindow->m_bX11DoesntWantBorders) {
-        pWindow->m_vRealPosition.setValue(pWindow->m_vRealPosition.goalv());
-        pWindow->m_vRealSize.setValue(pWindow->m_vRealSize.goalv());
-    }
+    // 2 axes of freedom
+    const auto SIDECONTAINER = PARENTSIDEBYSIDE ? PPARENT : PPARENT2;
+    const auto TOPCONTAINER = PARENTSIDEBYSIDE ? PPARENT2 : PPARENT;
 
-    g_pXWaylandManager->setWindowSize(pWindow, pWindow->m_vRealSize.goalv());
-    g_pCompositor->fixXWaylandWindowsOnWorkspace(PMONITOR->activeWorkspace);
+    allowedMovement.x *= 2.f / SIDECONTAINER->size.x;
+    allowedMovement.y *= 2.f / TOPCONTAINER->size.y;
 
-    g_pCompositor->moveWindowToTop(pWindow);
+    SIDECONTAINER->splitRatio = std::clamp(SIDECONTAINER->splitRatio + allowedMovement.x, (double)0.1f, (double)1.9f);
+    TOPCONTAINER->splitRatio = std::clamp(TOPCONTAINER->splitRatio + allowedMovement.y, (double)0.1f, (double)1.9f);
+    SIDECONTAINER->recalcSizePosRecursive();
+    TOPCONTAINER->recalcSizePosRecursive();
 }
 
-void CHyprDwindleLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscreenMode fullscreenMode) {
+void CHyprDwindleLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscreenMode fullscreenMode, bool on) {
     if (!g_pCompositor->windowValidMapped(pWindow))
         return;
 
+    if (on == pWindow->m_bIsFullscreen)
+        return; // ignore
+
     const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
     const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(pWindow->m_iWorkspaceID);
 
-    if (PWORKSPACE->m_bHasFullscreenWindow && !pWindow->m_bIsFullscreen) {
+    if (PWORKSPACE->m_bHasFullscreenWindow && on) {
         // if the window wants to be fullscreen but there already is one,
         // ignore the request.
         return;
     }
 
     // otherwise, accept it.
-    pWindow->m_bIsFullscreen = !pWindow->m_bIsFullscreen;
+    pWindow->m_bIsFullscreen = on;
     PWORKSPACE->m_bHasFullscreenWindow = !PWORKSPACE->m_bHasFullscreenWindow;
 
     if (!pWindow->m_bIsFullscreen) {
@@ -672,6 +557,8 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscree
             fakeNode.position = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
             fakeNode.size = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight;
             fakeNode.workspaceID = pWindow->m_iWorkspaceID;
+            pWindow->m_vPosition = fakeNode.position;
+            pWindow->m_vSize = fakeNode.size;
 
             applyNodeDataToWindow(&fakeNode);
         }
@@ -851,6 +738,11 @@ void CHyprDwindleLayout::switchWindows(CWindow* pWindow, CWindow* pWindow2) {
     if (!PNODE2 || !PNODE)
         return;
 
+    if (PNODE->workspaceID != PNODE2->workspaceID) {
+        Debug::log(ERR, "Dwindle: Rejecting a swap between workspaces");
+        return;
+    }
+
     // we will not delete the nodes, just fix the tree
     if (PNODE2->pParent == PNODE->pParent) {
         const auto PPARENT = PNODE->pParent;

src/layout/DwindleLayout.hpp

@@ -42,31 +42,23 @@ struct SDwindleNodeData {
 
 class CHyprDwindleLayout : public IHyprLayout {
 public:
-    virtual void        onWindowCreated(CWindow*);
-    virtual void        onWindowRemoved(CWindow*);
+    virtual void        onWindowCreatedTiling(CWindow*);
+    virtual void        onWindowRemovedTiling(CWindow*);
+    virtual bool        isWindowTiled(CWindow*);
     virtual void        recalculateMonitor(const int&);
     virtual void        recalculateWindow(CWindow*);
-    virtual void        changeWindowFloatingMode(CWindow*);
-    virtual void        onBeginDragWindow();
-    virtual void        onEndDragWindow();
-    virtual void        onMouseMove(const Vector2D&);
-    virtual void        onWindowCreatedFloating(CWindow*);
-    virtual void        fullscreenRequestForWindow(CWindow*, eFullscreenMode);
+    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        alterSplitRatioBy(CWindow*, float);
     virtual std::string getLayoutName();
 
-   private:
+private:
 
     std::list<SDwindleNodeData>     m_lDwindleNodesData;
 
-    Vector2D                        m_vBeginDragXY;
-    Vector2D                        m_vLastDragXY;
-    Vector2D                        m_vBeginDragPositionXY;
-    Vector2D                        m_vBeginDragSizeXY;
-
     int                 getNodesOnWorkspace(const int&);
     void                applyNodeDataToWindow(SDwindleNodeData*);
     SDwindleNodeData*   getNodeFromWindow(CWindow*);

src/layout/IHyprLayout.cpp

@@ -0,0 +1,233 @@
+#include "IHyprLayout.hpp"
+#include "../defines.hpp"
+#include "../Compositor.hpp"
+
+void IHyprLayout::onWindowCreated(CWindow* pWindow) {
+    if (pWindow->m_bIsFloating) {
+        onWindowCreatedFloating(pWindow);
+    } else {
+        onWindowCreatedTiling(pWindow);
+    }
+}
+
+void IHyprLayout::onWindowRemoved(CWindow* pWindow) {
+    if (pWindow->m_bIsFloating) {
+        onWindowRemovedFloating(pWindow);
+    } else {
+        onWindowRemovedTiling(pWindow);
+    }
+}
+
+void IHyprLayout::onWindowRemovedFloating(CWindow* pWindow) {
+    return; // no-op
+}
+
+void IHyprLayout::onWindowCreatedFloating(CWindow* pWindow) {
+    wlr_box desiredGeometry = {0};
+    g_pXWaylandManager->getGeometryForWindow(pWindow, &desiredGeometry);
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+
+    if (!PMONITOR) {
+        Debug::log(ERR, "Window %x (%s) has an invalid monitor in onWindowCreatedFloating!!!", pWindow, pWindow->m_szTitle.c_str());
+        return;
+    }
+
+    if (desiredGeometry.width <= 0 || desiredGeometry.height <= 0) {
+        const auto PWINDOWSURFACE = g_pXWaylandManager->getWindowSurface(pWindow);
+        pWindow->m_vRealSize = Vector2D(PWINDOWSURFACE->current.width, PWINDOWSURFACE->current.height);
+        pWindow->m_vRealPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_vRealSize.vec().x) / 2.f, PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_vRealSize.vec().y) / 2.f);
+
+    } else {
+        // we respect the size.
+        pWindow->m_vRealSize = Vector2D(desiredGeometry.width, desiredGeometry.height);
+
+        // check if it's on the correct monitor!
+        Vector2D middlePoint = Vector2D(desiredGeometry.x, desiredGeometry.y) + Vector2D(desiredGeometry.width, desiredGeometry.height) / 2.f;
+
+        // TODO: detect a popup in a more consistent way.
+        if (!g_pCompositor->isPointOnAnyMonitor(middlePoint) || (desiredGeometry.x == 0 && desiredGeometry.y == 0)) {
+            // if it's not, fall back to the center placement
+            pWindow->m_vRealPosition = PMONITOR->vecPosition + Vector2D((PMONITOR->vecSize.x - desiredGeometry.width) / 2.f, (PMONITOR->vecSize.y - desiredGeometry.height) / 2.f);
+        } else {
+            // if it is, we respect where it wants to put itself, but apply monitor offset if outside
+            // most of these are popups
+
+            if (const auto POPENMON = g_pCompositor->getMonitorFromVector(middlePoint); POPENMON->ID != PMONITOR->ID) {
+                pWindow->m_vRealPosition = Vector2D(desiredGeometry.x, desiredGeometry.y) - POPENMON->vecPosition + PMONITOR->vecPosition;
+            } else {
+                pWindow->m_vRealPosition = Vector2D(desiredGeometry.x, desiredGeometry.y);
+            }
+        }
+    }
+
+    if (pWindow->m_bX11DoesntWantBorders) {
+        pWindow->m_vRealPosition.setValue(pWindow->m_vRealPosition.goalv());
+        pWindow->m_vRealSize.setValue(pWindow->m_vRealSize.goalv());
+    }
+
+    g_pXWaylandManager->setWindowSize(pWindow, pWindow->m_vRealSize.goalv());
+    g_pCompositor->fixXWaylandWindowsOnWorkspace(PMONITOR->activeWorkspace);
+
+    g_pCompositor->moveWindowToTop(pWindow);
+}
+
+void IHyprLayout::onBeginDragWindow() {
+    const auto DRAGGINGWINDOW = g_pInputManager->currentlyDraggedWindow;
+
+    m_vBeginDragSizeXY = Vector2D();
+
+    // 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!");
+        return;
+    }
+
+    if (DRAGGINGWINDOW->m_bIsFullscreen) {
+        Debug::log(LOG, "Rejecting drag on a fullscreen window.");
+        return;
+    }
+
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(DRAGGINGWINDOW->m_iWorkspaceID);
+
+    if (PWORKSPACE->m_bHasFullscreenWindow) {
+        Debug::log(LOG, "Rejecting drag on a fullscreen workspace.");
+        return;
+    }
+
+    DRAGGINGWINDOW->m_bDraggingTiled = false;
+
+    if (!DRAGGINGWINDOW->m_bIsFloating) {
+        if (g_pInputManager->dragButton == BTN_LEFT) {
+            changeWindowFloatingMode(DRAGGINGWINDOW);
+            DRAGGINGWINDOW->m_bIsFloating = true;
+            DRAGGINGWINDOW->m_bDraggingTiled = true;
+        }
+    }
+
+    m_vBeginDragXY = g_pInputManager->getMouseCoordsInternal();
+    m_vBeginDragPositionXY = DRAGGINGWINDOW->m_vRealPosition.vec();
+    m_vBeginDragSizeXY = DRAGGINGWINDOW->m_vRealSize.vec();
+    m_vLastDragXY = m_vBeginDragXY;
+
+    g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
+}
+
+void IHyprLayout::onEndDragWindow() {
+    const auto DRAGGINGWINDOW = g_pInputManager->currentlyDraggedWindow;
+
+    if (!g_pCompositor->windowValidMapped(DRAGGINGWINDOW))
+        return;
+
+    if (DRAGGINGWINDOW->m_bDraggingTiled) {
+        DRAGGINGWINDOW->m_bIsFloating = false;
+        changeWindowFloatingMode(DRAGGINGWINDOW);
+    }
+
+    g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
+}
+
+void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
+    const auto DRAGGINGWINDOW = g_pInputManager->currentlyDraggedWindow;
+
+    // Window invalid or drag begin size 0,0 meaning we rejected it.
+    if (!g_pCompositor->windowValidMapped(DRAGGINGWINDOW) || m_vBeginDragSizeXY == Vector2D()) {
+        g_pInputManager->currentlyDraggedWindow = nullptr;
+        return;
+    }
+
+    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)
+        return;
+
+    m_vLastDragXY = mousePos;
+
+    g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
+
+    if (g_pInputManager->dragButton == BTN_LEFT) {
+        DRAGGINGWINDOW->m_vRealPosition.setValueAndWarp(m_vBeginDragPositionXY + DELTA);
+
+        DRAGGINGWINDOW->updateWindowDecos();
+
+        g_pXWaylandManager->setWindowSize(DRAGGINGWINDOW, DRAGGINGWINDOW->m_vRealSize.goalv());
+    } else {
+        if (DRAGGINGWINDOW->m_bIsFloating) {
+            DRAGGINGWINDOW->m_vRealSize.setValueAndWarp(m_vBeginDragSizeXY + DELTA);
+            DRAGGINGWINDOW->m_vRealSize.setValueAndWarp(Vector2D(std::clamp(DRAGGINGWINDOW->m_vRealSize.vec().x, (double)20, (double)999999), std::clamp(DRAGGINGWINDOW->m_vRealSize.vec().y, (double)20, (double)999999)));
+
+            DRAGGINGWINDOW->updateWindowDecos();
+
+            g_pXWaylandManager->setWindowSize(DRAGGINGWINDOW, DRAGGINGWINDOW->m_vRealSize.goalv());
+        } else {
+            resizeActiveWindow(TICKDELTA, DRAGGINGWINDOW);
+        }
+    }
+
+    // get middle point
+    Vector2D middle = DRAGGINGWINDOW->m_vRealPosition.vec() + DRAGGINGWINDOW->m_vRealSize.vec() / 2.f;
+
+    // and check its monitor
+    const auto PMONITOR = g_pCompositor->getMonitorFromVector(middle);
+
+    if (PMONITOR) {
+        DRAGGINGWINDOW->m_iMonitorID = PMONITOR->ID;
+        DRAGGINGWINDOW->m_iWorkspaceID = PMONITOR->activeWorkspace;
+    }
+
+    g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
+}
+
+void IHyprLayout::changeWindowFloatingMode(CWindow* pWindow) {
+
+    if (pWindow->m_bIsFullscreen) {
+        Debug::log(LOG, "Rejecting a change float order because window is fullscreen.");
+
+        // restore its' floating mode
+        pWindow->m_bIsFloating = !pWindow->m_bIsFloating;
+        return;
+    }
+
+    const auto TILED = isWindowTiled(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->m_iWorkspaceID = PNEWMON->activeWorkspace;
+
+        // save real pos cuz the func applies the default 5,5 mid
+        const auto PSAVEDPOS = pWindow->m_vRealPosition.vec();
+        const auto PSAVEDSIZE = pWindow->m_vRealSize.vec();
+
+        // if the window is pseudo, update its size
+        pWindow->m_vPseudoSize = pWindow->m_vRealSize.vec();
+
+        onWindowCreatedTiling(pWindow);
+
+        pWindow->m_vRealPosition.setValue(PSAVEDPOS);
+        pWindow->m_vRealSize.setValue(PSAVEDSIZE);
+
+        // fix pseudo leaving artifacts
+        g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID));
+    } else {
+        onWindowRemovedTiling(pWindow);
+
+        g_pCompositor->moveWindowToTop(pWindow);
+    }
+}
+
+void IHyprLayout::moveActiveWindow(const Vector2D& delta, CWindow* pWindow) {
+    const auto PWINDOW = pWindow ? pWindow : g_pCompositor->m_pLastWindow;
+
+    if (!g_pCompositor->windowValidMapped(PWINDOW))
+        return;
+
+    if (!PWINDOW->m_bIsFloating) {
+        Debug::log(LOG, "Dwindle cannot move a tiled window in moveActiveWindow!");
+        return;
+    }
+
+    PWINDOW->m_vRealPosition = PWINDOW->m_vRealPosition.goalv() + delta;
+
+    g_pHyprRenderer->damageWindow(PWINDOW);
+}

src/layout/IHyprLayout.hpp

@@ -22,11 +22,21 @@ public:
         The layout HAS TO set the goal pos and size (anim mgr will use it)
         If !animationinprogress, then the anim mgr will not apply an anim.
     */
-    virtual void        onWindowCreated(CWindow*)           = 0;
+    virtual void        onWindowCreated(CWindow*);
+    virtual void        onWindowCreatedTiling(CWindow*) = 0;
+    virtual void        onWindowCreatedFloating(CWindow*);
+
+    /*
+        Return tiled status
+    */
+    virtual bool        isWindowTiled(CWindow*) = 0;
+
     /*
         Called when a window is removed (unmapped)
     */
-    virtual void        onWindowRemoved(CWindow*)           = 0;
+    virtual void        onWindowRemoved(CWindow*);
+    virtual void        onWindowRemovedTiling(CWindow*)           = 0;
+    virtual void        onWindowRemovedFloating(CWindow*);
     /*
         Called when the monitor requires a layout recalculation
         this usually means reserved area changes
@@ -42,37 +52,43 @@ public:
     /*
         Called when a window is requested to be floated
     */
-    virtual void        changeWindowFloatingMode(CWindow*)  = 0;
+    virtual void        changeWindowFloatingMode(CWindow*);
     /*
         Called when a window is clicked on, beginning a drag
         this might be a resize, move, whatever the layout defines it
         as.
     */
-    virtual void        onBeginDragWindow()                 = 0;
+    virtual void        onBeginDragWindow();
+    /*
+        Called when a user requests a resize of the current window by a vec
+        Vector2D holds pixel values
+        Optional pWindow for a specific window
+    */
+    virtual void        resizeActiveWindow(const Vector2D&, CWindow* pWindow = nullptr) = 0;
+    /*
+        Called when a user requests a move of the current window by a vec
+        Vector2D holds pixel values
+        Optional pWindow for a specific window
+    */
+    virtual void        moveActiveWindow(const Vector2D&, CWindow* pWindow = nullptr);
     /*
         Called when a window is ended being dragged
         (mouse up)
     */
-    virtual void        onEndDragWindow()                   = 0;
+    virtual void        onEndDragWindow();
     /*
         Called whenever the mouse moves, should the layout want to 
         do anything with it.
         Useful for dragging.
     */
-    virtual void        onMouseMove(const Vector2D&)        = 0;
-    /*
-        Called when a window is created, but is requesting to be floated.
-        Warning: this also includes stuff like popups, incorrect handling
-        of which can result in a crash!
-    */
-    virtual void        onWindowCreatedFloating(CWindow*)   = 0;
+    virtual void        onMouseMove(const Vector2D&);
 
     /*
         Called when a window / the user requests to toggle the fullscreen state of a window
         The layout sets all the fullscreen flags.
         It can either accept or ignore.
     */
-    virtual void        fullscreenRequestForWindow(CWindow*, eFullscreenMode)    = 0;
+    virtual void        fullscreenRequestForWindow(CWindow*, eFullscreenMode, bool)    = 0;
 
     /*
         Called when a dispatcher requests a custom message
@@ -104,4 +120,10 @@ public:
         Called when something wants the current layout's name
     */
     virtual std::string  getLayoutName() = 0;
+
+private:
+    Vector2D                        m_vBeginDragXY;
+    Vector2D                        m_vLastDragXY;
+    Vector2D                        m_vBeginDragPositionXY;
+    Vector2D                        m_vBeginDragSizeXY;
 };

src/main.cpp

@@ -3,6 +3,7 @@
 #include "Compositor.hpp"
 #include "config/ConfigManager.hpp"
 #include "init/initHelpers.hpp"
+#include <iostream>
 
 // I am a bad bad boy and have used some global vars here,
 // just for this file
@@ -19,17 +20,19 @@ int main(int argc, char** argv) {
             ignoreSudo = true;
     }
 
+    system("mkdir -p /tmp/hypr");
+
     if (!ignoreSudo) {
         if (Init::isSudo()) {
-            Debug::log(CRIT, "Hyprland shall not be run as the root user. If you really want to, use the --i-am-really-stupid flag.");
-    	    return 1;
+            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 {
-        Debug::log(WARN, "Running with ignored root checks, I surely hope you know what you're doing.");
+        std::cout << "Running with ignored root checks, I surely hope you know what you're doing.\n";
         sleep(1);
     }
 
-    Debug::log(LOG, "Welcome to Hyprland!");
+    std::cout << "Welcome to Hyprland!\n";
 
     // let's init the compositor.
     // it initializes basic Wayland stuff in the constructor.

src/managers/AnimationManager.cpp

@@ -23,111 +23,115 @@ void CAnimationManager::tick() {
 
     bool animationsDisabled = false;
 
-    if (!g_pConfigManager->getInt("animations:enabled"))
+    static auto *const PANIMENABLED = &g_pConfigManager->getConfigValuePtr("animations:enabled")->intValue;
+
+    if (!*PANIMENABLED)
         animationsDisabled = true;
 
-    const float ANIMSPEED       = g_pConfigManager->getFloat("animations:speed");
-    const auto BORDERSIZE       = g_pConfigManager->getInt("general:border_size");
-    const auto BEZIERSTR        = g_pConfigManager->getString("animations:curve");
+    static auto *const  PANIMSPEED        = &g_pConfigManager->getConfigValuePtr("animations:speed")->floatValue;
+    static auto *const  PBORDERSIZE       = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
+    static auto *const  BEZIERSTR         = &g_pConfigManager->getConfigValuePtr("animations:curve")->strValue;
 
-    auto DEFAULTBEZIER = m_mBezierCurves.find(BEZIERSTR);
+    auto DEFAULTBEZIER = m_mBezierCurves.find(*BEZIERSTR);
     if (DEFAULTBEZIER == m_mBezierCurves.end())
         DEFAULTBEZIER = m_mBezierCurves.find("default");
 
     for (auto& av : m_lAnimatedVariables) {
-        // get speed
-        const auto SPEED = *av->m_pSpeed == 0 ? ANIMSPEED : *av->m_pSpeed;
-
-        // window stuff
-        const auto PWINDOW = (CWindow*)av->m_pWindow;
-        const auto PWORKSPACE = (CWorkspace*)av->m_pWorkspace;
-        const auto PLAYER = (SLayerSurface*)av->m_pLayer;
-
-        wlr_box WLRBOXPREV = {0,0,0,0};
-        if (PWINDOW) {
-            WLRBOXPREV = {(int)PWINDOW->m_vRealPosition.vec().x - BORDERSIZE - 1, (int)PWINDOW->m_vRealPosition.vec().y - BORDERSIZE - 1, (int)PWINDOW->m_vRealSize.vec().x + 2 * BORDERSIZE + 2, (int)PWINDOW->m_vRealSize.vec().y + 2 * BORDERSIZE + 2};
-        } else if (PWORKSPACE) {
-            const auto PMONITOR = g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID);
-            WLRBOXPREV = {(int)PMONITOR->vecPosition.x, (int)PMONITOR->vecPosition.y, (int)PMONITOR->vecSize.x, (int)PMONITOR->vecSize.y};
-        } else if (PLAYER) {
-            WLRBOXPREV = PLAYER->geometry;
-        }
-        
-        // check if it's disabled, if so, warp
-        if (av->m_pEnabled == 0 || animationsDisabled) {
-            av->warp();
-            g_pHyprRenderer->damageBox(&WLRBOXPREV);
-
-            if (PWINDOW) {
-                g_pHyprRenderer->damageWindow(PWINDOW);
-                // set size and pos if valid
-                if (g_pCompositor->windowValidMapped(PWINDOW))
-                    g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
-            }
 
+        // first of all, check if we need to update it at all
+        if (!av->isBeingAnimated())
             continue;
-        }
 
-        // beziers are with a switch unforto
-        // TODO: maybe do something cleaner
+        // get speed
+        const auto SPEED = *av->m_pSpeed == 0 ? *PANIMSPEED : *av->m_pSpeed;
 
         // get the spent % (0 - 1)
         const auto DURATIONPASSED = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - av->animationBegin).count();
         const float SPENT = std::clamp((DURATIONPASSED / 100.f) / SPEED, 0.f, 1.f);
 
+        // window stuff
+        const auto PWINDOW = (CWindow*)av->m_pWindow;
+        const auto PWORKSPACE = (CWorkspace*)av->m_pWorkspace;
+        const auto PLAYER = (SLayerSurface*)av->m_pLayer;
+        SMonitor* PMONITOR = nullptr;
+
+        wlr_box WLRBOXPREV = {0,0,0,0};
+        if (PWINDOW) {
+            WLRBOXPREV = PWINDOW->getFullWindowBoundingBox();
+            PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+        } else if (PWORKSPACE) {
+            PMONITOR = g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID);
+            WLRBOXPREV = {(int)PMONITOR->vecPosition.x, (int)PMONITOR->vecPosition.y, (int)PMONITOR->vecSize.x, (int)PMONITOR->vecSize.y};
+        } 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);
+        }
+
+        // beziers are with a switch unforto
+        // TODO: maybe do something cleaner
+
         switch (av->m_eVarType) {
             case AVARTYPE_FLOAT: {
-                if (!deltazero(av->m_fValue, av->m_fGoal)) {
-                    const auto DELTA = av->m_fGoal - av->m_fBegun;
-                    const auto BEZIER = m_mBezierCurves.find(*av->m_pBezier);
-
-                    if (BEZIER != m_mBezierCurves.end())
-                        av->m_fValue = av->m_fBegun + BEZIER->second.getYForPoint(SPENT) * DELTA;
-                    else
-                        av->m_fValue = av->m_fBegun + DEFAULTBEZIER->second.getYForPoint(SPENT) * DELTA;
-
-                    if (SPENT >= 1.f) {
-                        av->warp();
-                    }
-                } else {
-                    continue; // dont process
+                // for disabled anims just warp
+                if (*av->m_pEnabled == 0 || animationsDisabled) {
+                    av->warp();
+                    break;
                 }
+
+                if (SPENT >= 1.f) {
+                    av->warp();
+                    break;
+                }
+
+                const auto DELTA = av->m_fGoal - av->m_fBegun;
+                const auto BEZIER = m_mBezierCurves.find(*av->m_pBezier);
+
+                if (BEZIER != m_mBezierCurves.end())
+                    av->m_fValue = av->m_fBegun + BEZIER->second.getYForPoint(SPENT) * DELTA;
+                else
+                    av->m_fValue = av->m_fBegun + DEFAULTBEZIER->second.getYForPoint(SPENT) * DELTA;
                 break;
             }
             case AVARTYPE_VECTOR: {
-                if (!deltazero(av->m_vValue, av->m_vGoal)) {
-                    const auto DELTA = av->m_vGoal - av->m_vBegun;
-                    const auto BEZIER = m_mBezierCurves.find(*av->m_pBezier);
-
-                    if (BEZIER != m_mBezierCurves.end())
-                        av->m_vValue = av->m_vBegun + DELTA * BEZIER->second.getYForPoint(SPENT);
-                    else
-                        av->m_vValue = av->m_vBegun + DELTA * DEFAULTBEZIER->second.getYForPoint(SPENT);
-
-                    if (SPENT >= 1.f) {
-                        av->warp();
-                    }
-                } else {
-                    continue;  // dont process
+                // for disabled anims just warp
+                if (*av->m_pEnabled == 0 || animationsDisabled) {
+                    av->warp();
+                    break;
                 }
+
+                if (SPENT >= 1.f) {
+                    av->warp();
+                    break;
+                }
+
+                const auto DELTA = av->m_vGoal - av->m_vBegun;
+                const auto BEZIER = m_mBezierCurves.find(*av->m_pBezier);
+
+                if (BEZIER != m_mBezierCurves.end())
+                    av->m_vValue = av->m_vBegun + DELTA * BEZIER->second.getYForPoint(SPENT);
+                else
+                    av->m_vValue = av->m_vBegun + DELTA * DEFAULTBEZIER->second.getYForPoint(SPENT);
                 break;
             }
             case AVARTYPE_COLOR: {
-                if (!deltazero(av->m_cValue, av->m_cGoal)) {
-                    const auto DELTA = av->m_cGoal - av->m_cBegun;
-                    const auto BEZIER = m_mBezierCurves.find(*av->m_pBezier);
-
-                    if (BEZIER != m_mBezierCurves.end())
-                        av->m_cValue = av->m_cBegun + DELTA * BEZIER->second.getYForPoint(SPENT);
-                    else
-                        av->m_cValue = av->m_cBegun + DELTA * DEFAULTBEZIER->second.getYForPoint(SPENT);
-
-                    if (SPENT >= 1.f) {
-                        av->warp();
-                    }
-                } else {
-                    continue;  // dont process
+                // for disabled anims just warp
+                if (*av->m_pEnabled == 0 || animationsDisabled) {
+                    av->warp();
+                    break;
                 }
+
+                if (SPENT >= 1.f) {
+                    av->warp();
+                    break;
+                }
+
+                const auto DELTA = av->m_cGoal - av->m_cBegun;
+                const auto BEZIER = m_mBezierCurves.find(*av->m_pBezier);
+
+                if (BEZIER != m_mBezierCurves.end())
+                    av->m_cValue = av->m_cBegun + DELTA * BEZIER->second.getYForPoint(SPENT);
+                else
+                    av->m_cValue = av->m_cBegun + DELTA * DEFAULTBEZIER->second.getYForPoint(SPENT);
                 break;
             }
             default: {
@@ -142,8 +146,16 @@ void CAnimationManager::tick() {
 
                 if (PWINDOW) {
                     g_pHyprRenderer->damageWindow(PWINDOW);
-                    for (auto& wd : PWINDOW->m_dWindowDecorations) {
-                        wd->updateWindow(PWINDOW);
+                    PWINDOW->updateWindowDecos();
+                } else if (PWORKSPACE) {
+                    for (auto& w : g_pCompositor->m_vWindows) {
+                        if (!w->m_bIsMapped || w->m_bHidden)
+                            continue;
+
+                        if (w->m_iWorkspaceID != PWORKSPACE->m_iID)
+                            continue;
+
+                        w->updateWindowDecos();
                     }
                 }
                 break;
@@ -152,8 +164,9 @@ void CAnimationManager::tick() {
                 RASSERT(PWINDOW, "Tried to AVARDAMAGE_BORDER a non-window AVAR!");
                 
                 // damage only the border.
-                const auto BORDERSIZE = g_pConfigManager->getInt("general:border_size") + 1; // +1 for padding and shit
-                const auto ROUNDINGSIZE = g_pConfigManager->getInt("decoration:rounding") + 1;
+                static auto *const PROUNDING = &g_pConfigManager->getConfigValuePtr("decoration:rounding")->intValue;
+                const auto ROUNDINGSIZE = *PROUNDING + 1;
+                const auto BORDERSIZE = *PBORDERSIZE;
 
                 // damage for old box
                 g_pHyprRenderer->damageBox(WLRBOXPREV.x - BORDERSIZE, WLRBOXPREV.y - BORDERSIZE, WLRBOXPREV.width + 2 * BORDERSIZE, BORDERSIZE + ROUNDINGSIZE);                              // top
@@ -180,6 +193,9 @@ void CAnimationManager::tick() {
         // 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)
             g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
+
+        // manually schedule a frame
+        wlr_output_schedule_frame(PMONITOR->output);
     }
 }
 

src/managers/EventManager.cpp

@@ -1,4 +1,5 @@
 #include "EventManager.hpp"
+#include "../Compositor.hpp"
 
 #include <errno.h>
 #include <fcntl.h>
@@ -26,10 +27,9 @@ void CEventManager::startThread() {
             return;
         }
 
-        unlink("/tmp/hypr/.socket2.sock");
-
         sockaddr_un SERVERADDRESS = {.sun_family = AF_UNIX};
-        strcpy(SERVERADDRESS.sun_path, "/tmp/hypr/.socket2.sock");
+        std::string socketPath = "/tmp/hypr/" + g_pCompositor->m_szInstanceSignature + "/.socket2.sock";
+        strcpy(SERVERADDRESS.sun_path, socketPath.c_str());
 
         bind(SOCKET, (sockaddr*)&SERVERADDRESS, SUN_LEN(&SERVERADDRESS));
 
@@ -41,7 +41,7 @@ void CEventManager::startThread() {
         sockaddr_in clientAddress;
         socklen_t clientSize = sizeof(clientAddress);
 
-        Debug::log(LOG, "Hypr socket 2 started.");
+        Debug::log(LOG, "Hypr socket 2 started at %s", socketPath.c_str());
 
         // set the socket nonblock
         int flags = fcntl(SOCKET, F_GETFL, 0);
@@ -87,7 +87,7 @@ void CEventManager::startThread() {
 
             // write all queued events
             for (auto& ev : m_dQueuedEvents) {
-                std::string eventString = ev.event + ">>" + ev.data + "\n";
+                std::string eventString = (ev.event + ">>" + ev.data).substr(0, 1022) + "\n";
                 for (auto& fd : m_dAcceptedSocketFDs) {
                     write(fd, eventString.c_str(), eventString.length());
                 }
@@ -104,10 +104,16 @@ void CEventManager::startThread() {
     }).detach();
 }
 
-void CEventManager::postEvent(const SHyprIPCEvent event) {
+void CEventManager::postEvent(const SHyprIPCEvent event, bool force) {
+
+    if (m_bIgnoreEvents && !force) {
+        Debug::log(WARN, "Suppressed (ignoreevents true) event of type %s, content: %s",event.event.c_str(), event.data.c_str());
+        return;
+    }
+
     std::thread([&](const SHyprIPCEvent ev) {
         eventQueueMutex.lock();
         m_dQueuedEvents.push_back(ev);
         eventQueueMutex.unlock();
     }, event).detach();
-}
+}

src/managers/EventManager.hpp

@@ -15,10 +15,12 @@ class CEventManager {
 public:
     CEventManager();
 
-    void postEvent(const SHyprIPCEvent event);
+    void postEvent(const SHyprIPCEvent event, bool force = false);
 
     void startThread();
 
+    bool m_bIgnoreEvents = false;
+
 private:
 
     std::mutex eventQueueMutex;

src/managers/InputManager.hpp

@@ -1,49 +0,0 @@
-#pragma once
-
-#include "../defines.hpp"
-#include <list>
-#include "../helpers/WLClasses.hpp"
-#include "../Window.hpp"
-
-class CInputManager {
-public:
-
-    void            onMouseMoved(wlr_pointer_motion_event*);
-    void            onMouseWarp(wlr_pointer_motion_absolute_event*);
-    void            onMouseButton(wlr_pointer_button_event*);
-    void            onKeyboardKey(wlr_keyboard_key_event*, SKeyboard*);
-    void            onKeyboardMod(void*, SKeyboard*);
-
-    void            newKeyboard(wlr_input_device*);
-    void            newMouse(wlr_input_device*);
-    void            destroyKeyboard(SKeyboard*);
-    void            destroyMouse(wlr_input_device*);
-
-    void            constrainMouse(SMouse*, wlr_pointer_constraint_v1*);
-    void            recheckConstraint(SMouse*);
-
-    Vector2D        getMouseCoordsInternal();
-    void            refocus();
-
-    void            setKeyboardLayout();
-
-    void            updateDragIcon();
-
-
-    // for dragging floating windows
-    CWindow*        currentlyDraggedWindow = nullptr;
-    int             dragButton = -1;
-
-    SDrag           m_sDrag;
-
-    std::list<SConstraint> m_lConstraints;
-
-private:
-
-    std::list<SKeyboard> m_lKeyboards;
-    std::list<SMouse>    m_lMice;
-
-    void            mouseMoveUnified(uint32_t, bool refocus = false);
-};
-
-inline std::unique_ptr<CInputManager> g_pInputManager;

src/managers/KeybindManager.cpp

@@ -1,5 +1,7 @@
 #include "KeybindManager.hpp"
 
+#include <regex>
+
 CKeybindManager::CKeybindManager() {
     // initialize all dispatchers
 
@@ -21,6 +23,16 @@ CKeybindManager::CKeybindManager() {
     m_mDispatchers["movecursortocorner"]        = moveCursorToCorner;
     m_mDispatchers["workspaceopt"]              = workspaceOpt;
     m_mDispatchers["exit"]                      = exitHyprland;
+    m_mDispatchers["movecurrentworkspacetomonitor"] = moveCurrentWorkspaceToMonitor;
+    m_mDispatchers["moveworkspacetomonitor"]    = moveWorkspaceToMonitor;
+    m_mDispatchers["togglespecialworkspace"]    = toggleSpecialWorkspace;
+    m_mDispatchers["forcerendererreload"]       = forceRendererReload;
+    m_mDispatchers["resizeactive"]              = resizeActive;
+    m_mDispatchers["moveactive"]                = moveActive;
+    m_mDispatchers["cyclenext"]                 = circleNext;
+    m_mDispatchers["focuswindowbyclass"]        = focusWindow;
+    m_mDispatchers["focuswindow"]               = focusWindow;
+    m_mDispatchers["submap"]                    = setSubmap;
 }
 
 void CKeybindManager::addKeybind(SKeybind kb) {
@@ -63,13 +75,11 @@ bool CKeybindManager::handleKeybinds(const uint32_t& modmask, const xkb_keysym_t
     if (handleInternalKeybinds(key))
         return true;
 
-    if (g_pCompositor->m_sSeat.exclusiveClient){
-        Debug::log(LOG, "Not handling keybinds due to there being an exclusive inhibited client.");
-        return false;
-    }
+    if (g_pCompositor->m_sSeat.exclusiveClient)
+        Debug::log(LOG, "Keybind handling only locked (inhibitor)");
 
     for (auto& k : m_lKeybinds) {
-        if (modmask != k.modmask) 
+        if (modmask != k.modmask || (g_pCompositor->m_sSeat.exclusiveClient && !k.locked) || k.submap != m_szCurrentSelectedSubmap)
             continue;
 
         // oMg such performance hit!!11!
@@ -89,7 +99,7 @@ bool CKeybindManager::handleKeybinds(const uint32_t& modmask, const xkb_keysym_t
             Debug::log(ERR, "Inavlid 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)", modmask, KBKEYUPPER);
+            Debug::log(LOG, "Keybind triggered, calling dispatcher (%d, %d)", modmask, KBKEYUPPER);
             DISPATCHER->second(k.arg);
         }
 
@@ -99,21 +109,47 @@ bool CKeybindManager::handleKeybinds(const uint32_t& modmask, const xkb_keysym_t
     return found;
 }
 
-bool CKeybindManager::handleInternalKeybinds(xkb_keysym_t keysym) {
+bool CKeybindManager::handleVT(xkb_keysym_t keysym) {
     // Handles the CTRL+ALT+FX TTY keybinds
     if (!(keysym >= XKB_KEY_XF86Switch_VT_1 && keysym <= XKB_KEY_XF86Switch_VT_12))
         return false;
 
     const auto PSESSION = wlr_backend_get_session(g_pCompositor->m_sWLRBackend);
     if (PSESSION) {
-        const auto TTY = keysym - XKB_KEY_XF86Switch_VT_1 + 1;
+        const int TTY = keysym - XKB_KEY_XF86Switch_VT_1 + 1;
         wlr_session_change_vt(PSESSION, TTY);
+
+        for (auto& m : g_pCompositor->m_vMonitors) {
+            g_pHyprOpenGL->destroyMonitorResources(m.get());  // mark resources as unusable anymore
+            m->noFrameSchedule = true;
+            m->framesToSkip = 2;
+        }
+
+        Debug::log(LOG, "Switched to VT %i, destroyed all render data, frames to skip for each: 2", TTY);
+
         return true;
     }
 
     return false;
 }
 
+bool CKeybindManager::handleInternalKeybinds(xkb_keysym_t keysym) {
+    if (handleVT(keysym))
+        return true;
+
+    // handle ESC while in kill mode
+    if (g_pInputManager->getClickMode() == CLICKMODE_KILL) {
+        const auto KBKEY = xkb_keysym_from_name("ESCAPE", XKB_KEYSYM_CASE_INSENSITIVE);
+
+        if (keysym == KBKEY) {
+            g_pInputManager->setClickMode(CLICKMODE_DEFAULT);
+            return true;
+        }
+    }
+
+    return false;
+}
+
 // Dispatchers
 
 void CKeybindManager::spawn(std::string args) {
@@ -123,11 +159,48 @@ void CKeybindManager::spawn(std::string args) {
         args = "WAYLAND_DISPLAY=" + std::string(g_pCompositor->m_szWLDisplaySocket) + " " + args;
 
     Debug::log(LOG, "Executing %s", args.c_str());
-    if (fork() == 0) {
-        execl("/bin/sh", "/bin/sh", "-c", args.c_str(), nullptr);
 
+    int socket[2];
+    if (pipe(socket) != 0) {
+        Debug::log(LOG, "Unable to create pipe for fork");
+    }
+
+    pid_t child, grandchild;
+    child = fork();
+    if (child < 0) {
+        close(socket[0]);
+        close(socket[1]);
+        Debug::log(LOG, "Fail to create the first fork");
+        return;
+    }
+    if (child == 0) {
+        // run in child
+        grandchild = fork();
+        if (grandchild == 0) {
+            // run in grandchild
+            close(socket[0]);
+            close(socket[1]);
+            execl("/bin/sh", "/bin/sh", "-c", args.c_str(), nullptr);
+            // exit grandchild
+            _exit(0);
+        }
+        close(socket[0]);
+        write(socket[1], &grandchild, sizeof(grandchild));
+        close(socket[1]);
+        // exit child
         _exit(0);
     }
+    // run in parent
+    close(socket[1]);
+    read(socket[0], &grandchild, sizeof(grandchild));
+    close(socket[0]);
+    // clear child and leave child to init
+    waitpid(child, NULL, 0);
+    if (child < 0) {
+        Debug::log(LOG, "Fail to create the second fork");
+        return;
+    }
+    Debug::log(LOG, "Process Created with pid %d", grandchild);
 }
 
 void CKeybindManager::killActive(std::string args) {
@@ -149,8 +222,15 @@ void CKeybindManager::toggleActiveFloating(std::string args) {
     const auto ACTIVEWINDOW = g_pCompositor->m_pLastWindow;
 
     if (g_pCompositor->windowValidMapped(ACTIVEWINDOW)) {
+        // remove drag status
+        g_pInputManager->currentlyDraggedWindow = nullptr;
+
         ACTIVEWINDOW->m_bIsFloating = !ACTIVEWINDOW->m_bIsFloating;
 
+        if (ACTIVEWINDOW->m_iWorkspaceID == SPECIAL_WORKSPACE_ID) {
+            moveActiveToWorkspace(std::to_string(g_pCompositor->getMonitorFromID(ACTIVEWINDOW->m_iMonitorID)->activeWorkspace));
+        }
+
         ACTIVEWINDOW->m_vRealPosition.setValue(ACTIVEWINDOW->m_vRealPosition.vec() + Vector2D(5, 5));
         ACTIVEWINDOW->m_vSize = ACTIVEWINDOW->m_vRealPosition.vec() - Vector2D(10, 10);
 
@@ -189,12 +269,20 @@ void CKeybindManager::changeworkspace(std::string args) {
 
         const auto PWORKSPACETOCHANGETO = g_pCompositor->getWorkspaceByID(workspaceToChangeTo);
 
+        if (workspaceToChangeTo == SPECIAL_WORKSPACE_ID)
+            PWORKSPACETOCHANGETO->m_iMonitorID = PMONITOR->ID;
+
         // if it's not visible, make it visible.
         if (!g_pCompositor->isWorkspaceVisible(workspaceToChangeTo)) {
             const auto OLDWORKSPACEID = PMONITOR->activeWorkspace;
 
             // change it
-            PMONITOR->activeWorkspace = workspaceToChangeTo;
+            PMONITOR->specialWorkspaceOpen = false;
+
+            if (workspaceToChangeTo != SPECIAL_WORKSPACE_ID)
+                PMONITOR->activeWorkspace = workspaceToChangeTo;
+            else
+                PMONITOR->specialWorkspaceOpen = true;
 
             // we need to move XWayland windows to narnia or otherwise they will still process our cursor and shit
             // and that'd be annoying as hell
@@ -213,11 +301,8 @@ void CKeybindManager::changeworkspace(std::string args) {
             // start anim on new workspace
             PWORKSPACETOCHANGETO->startAnim(true, ANIMTOLEFT);
 
-            // Event ONLY if workspace is actually "changed" and we arent just focusing
-            if (!m_bSuppressWorkspaceChangeEvents)
-                g_pEventManager->postEvent(SHyprIPCEvent("workspace", PWORKSPACETOCHANGETO->m_szName));
+            g_pEventManager->postEvent(SHyprIPCEvent("workspace", PWORKSPACETOCHANGETO->m_szName));
         }
-           
 
         // If the monitor is not the one our cursor's at, warp to it.
         if (PMONITOR != g_pCompositor->getMonitorFromCursor()) {
@@ -225,13 +310,13 @@ void CKeybindManager::changeworkspace(std::string args) {
             wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, middle.x, middle.y);
         }
 
-        // focus the first window
-        g_pCompositor->focusWindow(g_pCompositor->getFirstWindowOnWorkspace(workspaceToChangeTo));
-
         // set active and deactivate all other in wlr
         g_pCompositor->deactivateAllWLRWorkspaces(PWORKSPACETOCHANGETO->m_pWlrHandle);
         PWORKSPACETOCHANGETO->setActive(true);
 
+        // recalc layout
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PWORKSPACETOCHANGETO->m_iMonitorID);
+
         Debug::log(LOG, "Changed to workspace %i", workspaceToChangeTo);
 
         // focus
@@ -252,22 +337,27 @@ void CKeybindManager::changeworkspace(std::string args) {
     const auto ANIMTOLEFT = workspaceToChangeTo > OLDWORKSPACE;
 
     // start anim on old workspace
-    g_pCompositor->getWorkspaceByID(OLDWORKSPACE)->startAnim(false, ANIMTOLEFT);
+    if (const auto POLDWORKSPACE = g_pCompositor->getWorkspaceByID(OLDWORKSPACE); POLDWORKSPACE)
+        POLDWORKSPACE->startAnim(false, ANIMTOLEFT);
 
-    g_pCompositor->m_lWorkspaces.emplace_back(PMONITOR->ID);
-    const auto PWORKSPACE = &g_pCompositor->m_lWorkspaces.back();
+    const auto PWORKSPACE = g_pCompositor->m_vWorkspaces.emplace_back(std::make_unique<CWorkspace>(PMONITOR->ID, workspaceName, workspaceToChangeTo == SPECIAL_WORKSPACE_ID)).get();
 
     // start anim on new workspace
     PWORKSPACE->startAnim(true, ANIMTOLEFT);
 
     // We are required to set the name here immediately
-    wlr_ext_workspace_handle_v1_set_name(PWORKSPACE->m_pWlrHandle, workspaceName.c_str());
+    if (workspaceToChangeTo != SPECIAL_WORKSPACE_ID)
+        wlr_ext_workspace_handle_v1_set_name(PWORKSPACE->m_pWlrHandle, workspaceName.c_str());
 
     PWORKSPACE->m_iID = workspaceToChangeTo;
     PWORKSPACE->m_iMonitorID = PMONITOR->ID;
-    PWORKSPACE->m_szName = workspaceName;
-    
-    PMONITOR->activeWorkspace = workspaceToChangeTo;
+
+    PMONITOR->specialWorkspaceOpen = false;
+
+    if (workspaceToChangeTo != SPECIAL_WORKSPACE_ID)
+        PMONITOR->activeWorkspace = workspaceToChangeTo;
+    else
+        PMONITOR->specialWorkspaceOpen = true;
 
     // we need to move XWayland windows to narnia or otherwise they will still process our cursor and shit
     // and that'd be annoying as hell
@@ -284,8 +374,7 @@ void CKeybindManager::changeworkspace(std::string args) {
     g_pInputManager->refocus();
 
     // Event
-    if (!m_bSuppressWorkspaceChangeEvents)
-        g_pEventManager->postEvent(SHyprIPCEvent("workspace", PWORKSPACE->m_szName));
+    g_pEventManager->postEvent(SHyprIPCEvent("workspace", PWORKSPACE->m_szName));
 
     Debug::log(LOG, "Changed to workspace %i", workspaceToChangeTo);
 }
@@ -296,15 +385,7 @@ void CKeybindManager::fullscreenActive(std::string args) {
     if (!g_pCompositor->windowValidMapped(PWINDOW))
         return;
 
-    g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(PWINDOW, args == "1" ? eFullscreenMode::FULLSCREEN_MAXIMIZED : eFullscreenMode::FULLSCREEN_FULL);
-
-    g_pXWaylandManager->setWindowFullscreen(PWINDOW, PWINDOW->m_bIsFullscreen && args == "0");
-
-    // make all windows on the same workspace under the fullscreen window
-    for (auto& w : g_pCompositor->m_lWindows) {
-        if (w.m_iWorkspaceID == PWINDOW->m_iWorkspaceID)
-            w.m_bCreatedOverFullscreen = false;
-    }
+    g_pCompositor->setWindowFullscreen(PWINDOW, !PWINDOW->m_bIsFullscreen, args == "1" ? FULLSCREEN_MAXIMIZED : FULLSCREEN_FULL);
 }
 
 void CKeybindManager::moveActiveToWorkspace(std::string args) {
@@ -313,20 +394,33 @@ void CKeybindManager::moveActiveToWorkspace(std::string args) {
     if (!g_pCompositor->windowValidMapped(PWINDOW))
         return;
 
-    g_pLayoutManager->getCurrentLayout()->onWindowRemoved(PWINDOW);
-
     const auto OLDWORKSPACE = g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID);
 
     // hack
+    std::string unusedName;
+    const auto WORKSPACEID = getWorkspaceIDFromString(args, unusedName);
+
+    if (WORKSPACEID == PWINDOW->m_iWorkspaceID) {
+        Debug::log(LOG, "Not moving to workspace because it didn't change.");
+        return;
+    }
+
+    g_pLayoutManager->getCurrentLayout()->onWindowRemoved(PWINDOW);
+
     g_pKeybindManager->changeworkspace(args);
 
-    const auto PWORKSPACE = g_pCompositor->getWorkspaceByString(args);
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(WORKSPACEID);
 
     if (PWORKSPACE == OLDWORKSPACE) {
         Debug::log(LOG, "Not moving to workspace because it didn't change.");
         return;
     }
 
+    if (!PWORKSPACE) {
+        Debug::log(ERR, "Workspace null in moveActiveToWorkspace?");
+        return;
+    }
+
     OLDWORKSPACE->m_bHasFullscreenWindow = false;
 
     PWINDOW->m_iWorkspaceID = PWORKSPACE->m_iID;
@@ -354,6 +448,19 @@ void CKeybindManager::moveActiveToWorkspace(std::string args) {
         PWINDOW->m_vRealPosition.setValue(PWINDOW->m_vRealPosition.vec() + g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID)->vecPosition);
         PWINDOW->m_vPosition = PWINDOW->m_vRealPosition.vec();
     }
+
+    // undo the damage if we are moving to the special workspace
+    if (WORKSPACEID == SPECIAL_WORKSPACE_ID) {
+        changeworkspace(std::to_string(OLDWORKSPACE->m_iID));
+        OLDWORKSPACE->startAnim(true, true, true);
+        toggleSpecialWorkspace("");
+        g_pCompositor->getWorkspaceByID(SPECIAL_WORKSPACE_ID)->startAnim(false, false, true);
+
+        for (auto& m : g_pCompositor->m_vMonitors)
+            m->specialWorkspaceOpen = false;
+    }
+
+    g_pInputManager->refocus();
 }
 
 void CKeybindManager::moveActiveToWorkspaceSilent(std::string args) {
@@ -390,7 +497,7 @@ void CKeybindManager::moveActiveToWorkspaceSilent(std::string args) {
     const auto POLDWORKSPACEONMON = g_pCompositor->getWorkspaceByID(OLDWORKSPACEIDONMONITOR);
     const auto POLDWORKSPACEIDRETURN = g_pCompositor->getWorkspaceByID(OLDWORKSPACEIDRETURN);
 
-    m_bSuppressWorkspaceChangeEvents = true;
+    g_pEventManager->m_bIgnoreEvents = true;
 
     moveActiveToWorkspace(args);
 
@@ -409,7 +516,9 @@ void CKeybindManager::moveActiveToWorkspaceSilent(std::string args) {
     POLDWORKSPACEONMON->m_vRenderOffset.setValueAndWarp(Vector2D(0, 0));
     POLDWORKSPACEONMON->m_fAlpha.setValueAndWarp(255.f);
 
-    m_bSuppressWorkspaceChangeEvents = false;
+    g_pEventManager->m_bIgnoreEvents = false;
+
+    g_pInputManager->refocus();
 }
 
 void CKeybindManager::moveFocusTo(std::string args) {
@@ -553,7 +662,7 @@ void CKeybindManager::focusMonitor(std::string arg) {
             Debug::log(ERR, "Error in focusMonitor: invalid num");
         }
 
-        if (monID > -1 && monID < (int)g_pCompositor->m_lMonitors.size()) {
+        if (monID > -1 && monID < (int)g_pCompositor->m_vMonitors.size()) {
             changeworkspace(std::to_string(g_pCompositor->getMonitorFromID(monID)->activeWorkspace));
         } else {
             Debug::log(ERR, "Error in focusMonitor: invalid arg 1");
@@ -572,9 +681,9 @@ void CKeybindManager::focusMonitor(std::string arg) {
                 return;
             }
         } else {
-            for (auto& m : g_pCompositor->m_lMonitors) {
-                if (m.szName == arg) {
-                    changeworkspace(std::to_string(m.activeWorkspace));
+            for (auto& m : g_pCompositor->m_vMonitors) {
+                if (m->szName == arg) {
+                    changeworkspace(std::to_string(m->activeWorkspace));
                     return;
                 }
             }
@@ -634,11 +743,11 @@ void CKeybindManager::workspaceOpt(std::string args) {
         PWORKSPACE->m_bDefaultPseudo = !PWORKSPACE->m_bDefaultPseudo;
 
         // apply
-        for (auto& w : g_pCompositor->m_lWindows) {
-            if (!w.m_bIsMapped || w.m_iWorkspaceID != PWORKSPACE->m_iID)
+        for (auto& w : g_pCompositor->m_vWindows) {
+            if (!w->m_bIsMapped || w->m_iWorkspaceID != PWORKSPACE->m_iID)
                 continue;
 
-            w.m_bIsPseudotiled = PWORKSPACE->m_bDefaultPseudo;
+            w->m_bIsPseudotiled = PWORKSPACE->m_bDefaultPseudo;
         }
     } else if (args == "allfloat") {
         PWORKSPACE->m_bDefaultFloating = !PWORKSPACE->m_bDefaultFloating;
@@ -646,8 +755,8 @@ void CKeybindManager::workspaceOpt(std::string args) {
 
         // we make a copy because changeWindowFloatingMode might invalidate the iterator
         std::deque<CWindow*> ptrs;
-        for (auto& w : g_pCompositor->m_lWindows)
-            ptrs.push_back(&w);
+        for (auto& w : g_pCompositor->m_vWindows)
+            ptrs.push_back(w.get());
 
         for (auto& w : ptrs) {
             if (!w->m_bIsMapped || w->m_iWorkspaceID != PWORKSPACE->m_iID)
@@ -681,4 +790,293 @@ void CKeybindManager::workspaceOpt(std::string args) {
 void CKeybindManager::exitHyprland(std::string argz) {
     g_pCompositor->cleanupExit();
     exit(0);
-}
+}
+
+void CKeybindManager::moveCurrentWorkspaceToMonitor(std::string args) {
+    SMonitor* PMONITOR = nullptr;
+
+    try {
+        if (!isNumber(args) && !isDirection(args)) {
+            PMONITOR = g_pCompositor->getMonitorFromName(args);
+        } else {
+            PMONITOR = isDirection(args) ? g_pCompositor->getMonitorInDirection(args[0]) : g_pCompositor->getMonitorFromID(std::stoi(args));
+        }
+    } catch (std::exception& e) {
+        Debug::log(LOG, "moveCurrentWorkspaceToMonitor: caught exception in monitor", e.what());
+        return;
+    }
+
+    // get the current workspace
+    const auto PCURRENTWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->activeWorkspace);
+
+    if (!PCURRENTWORKSPACE)
+        return;
+
+    g_pCompositor->moveWorkspaceToMonitor(PCURRENTWORKSPACE, PMONITOR);
+}
+
+void CKeybindManager::moveWorkspaceToMonitor(std::string args) {
+    if (args.find_first_of(' ') == std::string::npos)
+        return;
+
+    std::string workspace = args.substr(0, args.find_first_of(' '));
+    std::string monitor = args.substr(args.find_first_of(' ') + 1);
+
+    SMonitor* PMONITOR = nullptr;
+
+    try {
+        if (!isNumber(monitor) && !isDirection(monitor)) {
+            PMONITOR = g_pCompositor->getMonitorFromName(monitor);
+        } else {
+            PMONITOR = isDirection(monitor) ? g_pCompositor->getMonitorInDirection(monitor[0]) : g_pCompositor->getMonitorFromID(std::stoi(monitor));
+        }
+    } catch (std::exception& e) {
+        Debug::log(LOG, "moveWorkspaceToMonitor: caught exception in monitor", e.what());
+        return;
+    }
+    
+
+    if (!PMONITOR){
+        Debug::log(ERR, "Ignoring moveWorkspaceToMonitor: monitor doesnt exist");
+        return;
+    }
+
+    std::string workspaceName;
+    const int WORKSPACEID = getWorkspaceIDFromString(workspace, workspaceName);
+
+    if (WORKSPACEID == INT_MAX) {
+        Debug::log(ERR, "moveWorkspaceToMonitor invalid workspace!");
+        return;
+    }
+
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(WORKSPACEID);
+
+    if (!PWORKSPACE) {
+        Debug::log(ERR, "moveWorkspaceToMonitor workspace doesn't exist!");
+        return;
+    }
+
+    g_pCompositor->moveWorkspaceToMonitor(PWORKSPACE, PMONITOR);
+}
+
+void CKeybindManager::toggleSpecialWorkspace(std::string args) {
+
+    if (g_pCompositor->getWindowsOnWorkspace(SPECIAL_WORKSPACE_ID) == 0) {
+        Debug::log(LOG, "Can't open empty special workspace!");
+        return;
+    }
+
+    bool open = false;
+
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        if (m->specialWorkspaceOpen) {
+            open = true;
+            break;
+        }
+    }
+
+    if (open)
+        Debug::log(LOG, "Toggling special workspace to closed");
+    else
+        Debug::log(LOG, "Toggling special workspace to open");
+
+    if (open) {
+        for (auto& m : g_pCompositor->m_vMonitors) {
+            if (m->specialWorkspaceOpen != !open) {
+                m->specialWorkspaceOpen = !open;
+                g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
+
+                g_pCompositor->getWorkspaceByID(SPECIAL_WORKSPACE_ID)->startAnim(false, false);
+            }
+        }
+    } else {
+        auto PSPECIALWORKSPACE = g_pCompositor->getWorkspaceByID(SPECIAL_WORKSPACE_ID);
+        
+        g_pCompositor->m_pLastMonitor->specialWorkspaceOpen = true;
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(g_pCompositor->m_pLastMonitor->ID);
+
+        PSPECIALWORKSPACE->startAnim(true, true);
+        PSPECIALWORKSPACE->m_iMonitorID = g_pCompositor->m_pLastMonitor->ID;
+    }
+
+    g_pInputManager->refocus();
+}
+
+void CKeybindManager::forceRendererReload(std::string args) {
+    bool overAgain = false;
+
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        auto rule = g_pConfigManager->getMonitorRuleFor(m->szName);
+        if (!g_pHyprRenderer->applyMonitorRule(m.get(), &rule, true)) {
+            overAgain = true;
+            break;
+        }
+    }
+
+    if (overAgain)
+        forceRendererReload(args);
+}
+
+void CKeybindManager::resizeActive(std::string args) {
+    if (args.find_first_of(' ') == std::string::npos)
+        return;
+
+    std::string x = args.substr(0, args.find_first_of(' '));
+    std::string y = args.substr(args.find_first_of(' ') + 1);
+
+    if (x == "exact") {
+        std::string newX = y.substr(0, y.find_first_of(' '));
+        std::string newY = y.substr(y.find_first_of(' ') + 1);
+
+        if (!isNumber(newX) || !isNumber(newY)) {
+            Debug::log(ERR, "resizeTiledWindow: exact args not numbers");
+            return;
+        }
+
+        const int X = std::stoi(newX);
+        const int Y = std::stoi(newY);
+
+        if (X < 10 || Y < 10) {
+            Debug::log(ERR, "resizeTiledWindow: exact args cannot be < 10");
+            return;
+        }
+
+        // calc the delta
+        if (!g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow))
+            return; // ignore
+
+        const auto PWINDOW = g_pCompositor->m_pLastWindow;
+
+        const int DX = X - PWINDOW->m_vRealSize.goalv().x;
+        const int DY = Y - PWINDOW->m_vRealSize.goalv().y;
+
+        g_pLayoutManager->getCurrentLayout()->resizeActiveWindow(Vector2D(DX, DY));
+
+        return;
+    }
+
+    if (!isNumber(x) || !isNumber(y)) {
+        Debug::log(ERR, "resizeTiledWindow: args not numbers");
+        return;
+    }
+
+    const int X = std::stoi(x);
+    const int Y = std::stoi(y);
+
+    g_pLayoutManager->getCurrentLayout()->resizeActiveWindow(Vector2D(X, Y));
+}
+
+void CKeybindManager::moveActive(std::string args) {
+    if (args.find_first_of(' ') == std::string::npos)
+        return;
+
+    std::string x = args.substr(0, args.find_first_of(' '));
+    std::string y = args.substr(args.find_first_of(' ') + 1);
+
+    if (x == "exact") {
+        std::string newX = y.substr(0, y.find_first_of(' '));
+        std::string newY = y.substr(y.find_first_of(' ') + 1);
+
+        if (!isNumber(newX) || !isNumber(newY)) {
+            Debug::log(ERR, "moveActive: exact args not numbers");
+            return;
+        }
+
+        const int X = std::stoi(newX);
+        const int Y = std::stoi(newY);
+
+        if (X < 0 || Y < 0) {
+            Debug::log(ERR, "moveActive: exact args cannot be < 0");
+            return;
+        }
+
+        // calc the delta
+        if (!g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow))
+            return;  // ignore
+
+        const auto PWINDOW = g_pCompositor->m_pLastWindow;
+
+        const int DX = X - PWINDOW->m_vRealPosition.goalv().x;
+        const int DY = Y - PWINDOW->m_vRealPosition.goalv().y;
+
+        g_pLayoutManager->getCurrentLayout()->moveActiveWindow(Vector2D(DX, DY));
+
+        return;
+    }
+
+    if (!isNumber(x) || !isNumber(y)) {
+        Debug::log(ERR, "moveActive: args not numbers");
+        return;
+    }
+
+    const int X = std::stoi(x);
+    const int Y = std::stoi(y);
+
+    g_pLayoutManager->getCurrentLayout()->moveActiveWindow(Vector2D(X, Y));
+}
+
+void CKeybindManager::circleNext(std::string) {
+    if (!g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow))
+        return;
+
+    g_pCompositor->focusWindow(g_pCompositor->getNextWindowOnWorkspace(g_pCompositor->m_pLastWindow));
+
+    const auto MIDPOINT = g_pCompositor->m_pLastWindow->m_vRealPosition.goalv() + g_pCompositor->m_pLastWindow->m_vRealSize.goalv() / 2.f;
+
+    wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, MIDPOINT.x, MIDPOINT.y);
+}
+
+void CKeybindManager::focusWindow(std::string regexp) {
+    bool titleRegex = false;
+    std::regex regexCheck(regexp);
+    if (regexp.find("title:") == 0) {
+        titleRegex = true;
+        regexCheck = std::regex(regexp.substr(6));
+    }
+
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (!w->m_bIsMapped || w->m_bHidden)
+            continue;
+
+        if (titleRegex) {
+            const auto windowTitle = g_pXWaylandManager->getTitle(w.get());
+            if (!std::regex_search(windowTitle, regexCheck))
+                continue;
+        }
+        else {
+            const auto windowClass = g_pXWaylandManager->getAppIDClass(w.get());
+            if (!std::regex_search(windowClass, regexCheck))
+                continue;
+        }
+
+        Debug::log(LOG, "Focusing to window name: %s", w->m_szTitle.c_str());
+
+        changeworkspace(std::to_string(w->m_iWorkspaceID));
+
+        g_pCompositor->focusWindow(w.get());
+
+        const auto MIDPOINT = w->m_vRealPosition.goalv() + w->m_vRealSize.goalv() / 2.f;
+
+        wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, MIDPOINT.x, MIDPOINT.y);
+
+        break;
+    }
+}
+
+void CKeybindManager::setSubmap(std::string submap) {
+    if (submap == "reset" || submap == "") {
+        m_szCurrentSelectedSubmap = "";
+        Debug::log(LOG, "Reset active submap to the default one.");
+        return;
+    }
+
+    for (auto& k : g_pKeybindManager->m_lKeybinds) {
+        if (k.submap == submap) {
+            m_szCurrentSelectedSubmap = submap;
+            Debug::log(LOG, "Changed keybind submap to %s", submap.c_str());
+            return;
+        }
+    }
+
+    Debug::log(ERR, "Cannot set submap %s, submap doesn't exist (wasn't registered!)", submap.c_str());
+}

src/managers/KeybindManager.hpp

@@ -11,6 +11,8 @@ struct SKeybind {
     uint32_t          modmask = 0;
     std::string       handler = "";
     std::string       arg = "";
+    bool              locked = false;
+    std::string       submap = "";
 };
 
 class CKeybindManager {
@@ -28,9 +30,10 @@ public:
 private:
     std::list<SKeybind> m_lKeybinds;
 
-    bool                handleInternalKeybinds(xkb_keysym_t);
+    inline static std::string m_szCurrentSelectedSubmap = "";
 
-    inline static bool  m_bSuppressWorkspaceChangeEvents = false;
+    bool                handleInternalKeybinds(xkb_keysym_t);
+    bool                handleVT(xkb_keysym_t);
 
     // -------------- Dispatchers -------------- //
     static void         killActive(std::string);
@@ -51,6 +54,17 @@ private:
     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         circleNext(std::string);
+    static void         focusWindow(std::string);
+    static void         setSubmap(std::string);
+
+    friend class CCompositor;
 };
 
 inline std::unique_ptr<CKeybindManager> g_pKeybindManager;

src/managers/XWaylandManager.cpp

@@ -42,9 +42,6 @@ void CHyprXWaylandManager::activateSurface(wlr_surface* pSurface, bool activate)
 }
 
 void CHyprXWaylandManager::activateWindow(CWindow* pWindow, bool activate) {
-    if (pWindow == g_pCompositor->m_pLastWindow)
-        return;
-
     if (pWindow->m_bIsX11) {
         if (pWindow->m_uSurface.xwayland->minimized)
             wlr_xwayland_surface_set_minimized(pWindow->m_uSurface.xwayland, false);
@@ -94,6 +91,9 @@ std::string CHyprXWaylandManager::getAppIDClass(CWindow* pWindow) {
     try {
         if (pWindow->m_bIsX11) {
             if (pWindow->m_uSurface.xwayland) {
+                if (!pWindow->m_bMappedX11 || !pWindow->m_bIsMapped)
+                    return "unmanaged X11";
+
                 return std::string(pWindow->m_uSurface.xwayland->_class);
             }
         } else if (pWindow->m_uSurface.xdg) {
@@ -121,13 +121,8 @@ void CHyprXWaylandManager::sendCloseWindow(CWindow* pWindow) {
 void CHyprXWaylandManager::setWindowSize(CWindow* pWindow, const Vector2D& size) {
     if (pWindow->m_bIsX11)
         wlr_xwayland_surface_configure(pWindow->m_uSurface.xwayland, pWindow->m_vRealPosition.vec().x, pWindow->m_vRealPosition.vec().y, size.x, size.y);
-    else {
-        // I don't know if this is fucking correct, but the fucking idea of putting shadows into a window's surface is borderline criminal.
-        const auto XDELTA = pWindow->m_uSurface.xdg->surface->current.width - pWindow->m_uSurface.xdg->current.geometry.width;
-        const auto YDELTA = pWindow->m_uSurface.xdg->surface->current.height - pWindow->m_uSurface.xdg->current.geometry.height;
-        
-        wlr_xdg_toplevel_set_size(pWindow->m_uSurface.xdg->toplevel, size.x - XDELTA, size.y - YDELTA);
-    }
+    else
+        wlr_xdg_toplevel_set_size(pWindow->m_uSurface.xdg->toplevel, size.x, size.y);
 }
 
 void CHyprXWaylandManager::setWindowStyleTiled(CWindow* pWindow, uint32_t edgez) {
@@ -148,8 +143,10 @@ bool CHyprXWaylandManager::shouldBeFloated(CWindow* pWindow) {
             if (pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_DIALOG"] || pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_SPLASH"] ||
                 pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_TOOLBAR"] || pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_UTILITY"] ||
                 pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_TOOLTIP"] || pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_POPUP_MENU"] ||
-                pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_DOCK"] || pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"])
+                pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_DOCK"] || pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"] ||
+                pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_MENU"])
                     {
+                pWindow->m_bNoInitialFocus = true;
                 return true;
                     }
 

src/managers/input/InputManager.cpp

@@ -1,24 +1,29 @@
 #include "InputManager.hpp"
-#include "../Compositor.hpp"
+#include "../../Compositor.hpp"
 
 void CInputManager::onMouseMoved(wlr_pointer_motion_event* e) {
-
     float sensitivity = g_pConfigManager->getFloat("general:sensitivity");
 
-    if (g_pConfigManager->getInt("general:apply_sens_to_raw") == 1)
-        wlr_relative_pointer_manager_v1_send_relative_motion(g_pCompositor->m_sWLRRelPointerMgr, g_pCompositor->m_sSeat.seat, (uint64_t)e->time_msec * 1000, e->delta_x * sensitivity, e->delta_y * sensitivity, e->unaccel_dx * sensitivity, e->unaccel_dy * sensitivity);
-    else
-        wlr_relative_pointer_manager_v1_send_relative_motion(g_pCompositor->m_sWLRRelPointerMgr, g_pCompositor->m_sSeat.seat, (uint64_t)e->time_msec * 1000, e->delta_x, e->delta_y, e->unaccel_dx, e->unaccel_dy);
+    const auto DELTA = g_pConfigManager->getInt("input:force_no_accel") == 1 ? Vector2D(e->unaccel_dx, e->unaccel_dy) : Vector2D(e->delta_x, e->delta_y);
 
-    wlr_cursor_move(g_pCompositor->m_sWLRCursor, &e->pointer->base, e->delta_x * sensitivity, e->delta_y * sensitivity);
+    if (g_pConfigManager->getInt("general:apply_sens_to_raw") == 1)
+        wlr_relative_pointer_manager_v1_send_relative_motion(g_pCompositor->m_sWLRRelPointerMgr, g_pCompositor->m_sSeat.seat, (uint64_t)e->time_msec * 1000, DELTA.x * sensitivity, DELTA.y * sensitivity, e->unaccel_dx * sensitivity, e->unaccel_dy * sensitivity);
+    else
+        wlr_relative_pointer_manager_v1_send_relative_motion(g_pCompositor->m_sWLRRelPointerMgr, g_pCompositor->m_sSeat.seat, (uint64_t)e->time_msec * 1000, DELTA.x, DELTA.y, e->unaccel_dx, e->unaccel_dy);
+
+    wlr_cursor_move(g_pCompositor->m_sWLRCursor, &e->pointer->base, DELTA.x * sensitivity, DELTA.y * sensitivity);
 
     mouseMoveUnified(e->time_msec);
+
+    m_tmrLastCursorMovement.reset();
 }
 
 void CInputManager::onMouseWarp(wlr_pointer_motion_absolute_event* e) {
     wlr_cursor_warp_absolute(g_pCompositor->m_sWLRCursor, &e->pointer->base, e->x, e->y);
 
     mouseMoveUnified(e->time_msec);
+
+    m_tmrLastCursorMovement.reset();
 }
 
 void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
@@ -32,8 +37,17 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
     }
 
     Vector2D mouseCoords = getMouseCoordsInternal();
+    const auto MOUSECOORDSFLOORED = mouseCoords.floor();
+
+    if (MOUSECOORDSFLOORED == m_vLastCursorPosFloored && !refocus)
+        return;
+
+    m_vLastCursorPosFloored = MOUSECOORDSFLOORED;
+
     const auto PMONITOR = g_pCompositor->getMonitorFromCursor();
 
+    bool didConstraintOnCursor = false;
+
     // constraints
     // All constraints TODO: multiple mice?
     if (g_pCompositor->m_sSeat.mouse->currentConstraint) {
@@ -49,27 +63,30 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
             const auto CONSTRAINTPOS = CONSTRAINTWINDOW->m_bIsX11 ? Vector2D(CONSTRAINTWINDOW->m_uSurface.xwayland->x, CONSTRAINTWINDOW->m_uSurface.xwayland->y) : CONSTRAINTWINDOW->m_vRealPosition.vec();
             const auto CONSTRAINTSIZE = CONSTRAINTWINDOW->m_bIsX11 ? Vector2D(CONSTRAINTWINDOW->m_uSurface.xwayland->width, CONSTRAINTWINDOW->m_uSurface.xwayland->height) : CONSTRAINTWINDOW->m_vRealSize.vec();
 
-            if (!VECINRECT(mouseCoords, CONSTRAINTPOS.x, CONSTRAINTPOS.y, CONSTRAINTPOS.x + CONSTRAINTSIZE.x, CONSTRAINTPOS.y + CONSTRAINTSIZE.y)) {
+            if (!VECINRECT(mouseCoords, CONSTRAINTPOS.x, CONSTRAINTPOS.y, CONSTRAINTPOS.x + CONSTRAINTSIZE.x - 1.0, CONSTRAINTPOS.y + CONSTRAINTSIZE.y - 1.0)) {
                 if (g_pCompositor->m_sSeat.mouse->constraintActive) {
-                    Vector2D deltaToFit;
+                    Vector2D newConstrainedCoords = mouseCoords;
 
                     if (mouseCoords.x < CONSTRAINTPOS.x)
-                        deltaToFit.x = CONSTRAINTPOS.x - mouseCoords.x;
-                    else if (mouseCoords.x > CONSTRAINTPOS.x + CONSTRAINTSIZE.x)
-                        deltaToFit.x = CONSTRAINTPOS.x + CONSTRAINTSIZE.x - mouseCoords.x;
+                        newConstrainedCoords.x = CONSTRAINTPOS.x;
+                    else if (mouseCoords.x >= CONSTRAINTPOS.x + CONSTRAINTSIZE.x)
+                        newConstrainedCoords.x = CONSTRAINTPOS.x + CONSTRAINTSIZE.x - 1.0;
 
                     if (mouseCoords.y < CONSTRAINTPOS.y)
-                        deltaToFit.y = CONSTRAINTPOS.y - mouseCoords.y;
-                    else if (mouseCoords.y > CONSTRAINTPOS.y + CONSTRAINTSIZE.y)
-                        deltaToFit.y = CONSTRAINTPOS.y + CONSTRAINTSIZE.y - mouseCoords.y;
+                        newConstrainedCoords.y = CONSTRAINTPOS.y;
+                    else if (mouseCoords.y >= CONSTRAINTPOS.y + CONSTRAINTSIZE.y)
+                        newConstrainedCoords.y = CONSTRAINTPOS.y + CONSTRAINTSIZE.y - 1.0;
 
-                    wlr_cursor_move(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, deltaToFit.x, deltaToFit.y);
+                    wlr_cursor_warp_closest(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, newConstrainedCoords.x, newConstrainedCoords.y);
 
-                    mouseCoords = mouseCoords + deltaToFit;
+                    mouseCoords = newConstrainedCoords;
+
+                    didConstraintOnCursor = true;
                 }
             } else {
                 if ((!CONSTRAINTWINDOW->m_bIsX11 && PMONITOR && CONSTRAINTWINDOW->m_iWorkspaceID == PMONITOR->activeWorkspace) || (CONSTRAINTWINDOW->m_bIsX11)) {
                     g_pCompositor->m_sSeat.mouse->constraintActive = true;
+                    didConstraintOnCursor = true;
                 }
             }
         }
@@ -83,6 +100,9 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
     // focus
     wlr_surface* foundSurface = nullptr;
 
+    if (didConstraintOnCursor)
+        return; // don't process when cursor constrained
+
     if (PMONITOR && PMONITOR != g_pCompositor->m_pLastMonitor) {
         g_pCompositor->m_pLastMonitor = PMONITOR;
 
@@ -98,24 +118,25 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
     Vector2D surfaceCoords;
     Vector2D surfacePos = Vector2D(-1337, -1337);
     CWindow* pFoundWindow = nullptr;
+    SLayerSurface* pFoundLayerSurface = nullptr;
 
     // overlay is above fullscreen
     if (!foundSurface)
-        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], &surfaceCoords);
+        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], &surfaceCoords, &pFoundLayerSurface);
 
     // then, we check if the workspace doesnt have a fullscreen window
     const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
-    if (PWORKSPACE->m_bHasFullscreenWindow && !foundSurface) {
+    if (PWORKSPACE->m_bHasFullscreenWindow && !foundSurface && PWORKSPACE->m_efFullscreenMode == FULLSCREEN_FULL) {
         pFoundWindow = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
         foundSurface = g_pXWaylandManager->getWindowSurface(pFoundWindow);
         surfacePos = pFoundWindow->m_vRealPosition.vec();
 
         // only check floating because tiled cant be over fullscreen
-        for (auto w = g_pCompositor->m_lWindows.rbegin(); w != g_pCompositor->m_lWindows.rend(); w++) {
-            wlr_box box = {w->m_vRealPosition.vec().x, w->m_vRealPosition.vec().y, w->m_vRealSize.vec().x, w->m_vRealSize.vec().y};
-            if (w->m_bIsFloating && w->m_bIsMapped && w->m_bCreatedOverFullscreen && wlr_box_contains_point(&box, mouseCoords.x, mouseCoords.y) && g_pCompositor->isWorkspaceVisible(w->m_iWorkspaceID) && !w->m_bHidden) {
-                pFoundWindow = &(*w);
-                
+        for (auto w = g_pCompositor->m_vWindows.rbegin(); w != g_pCompositor->m_vWindows.rend(); w++) {
+            wlr_box box = {(*w)->m_vRealPosition.vec().x, (*w)->m_vRealPosition.vec().y, (*w)->m_vRealSize.vec().x, (*w)->m_vRealSize.vec().y};
+            if ((((*w)->m_bIsFloating && (*w)->m_bIsMapped && (*w)->m_bCreatedOverFullscreen) || ((*w)->m_iWorkspaceID == SPECIAL_WORKSPACE_ID && PMONITOR->specialWorkspaceOpen)) && wlr_box_contains_point(&box, mouseCoords.x, mouseCoords.y) && g_pCompositor->isWorkspaceVisible((*w)->m_iWorkspaceID) && !(*w)->m_bHidden) {
+                pFoundWindow = (*w).get();
+
                 if (!pFoundWindow->m_bIsX11) {
                     foundSurface = g_pCompositor->vectorWindowToSurface(mouseCoords, pFoundWindow, surfaceCoords);
                 } else {
@@ -129,11 +150,15 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
     }
 
     if (!foundSurface)
-        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_TOP], &surfaceCoords);
+        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_TOP], &surfaceCoords, &pFoundLayerSurface);
 
     // then windows
     if (!foundSurface) {
-        pFoundWindow = g_pCompositor->vectorToWindowIdeal(mouseCoords);
+        if (PWORKSPACE->m_bHasFullscreenWindow && PWORKSPACE->m_efFullscreenMode == FULLSCREEN_MAXIMIZED)
+            pFoundWindow = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
+        else
+            pFoundWindow = g_pCompositor->vectorToWindowIdeal(mouseCoords);
+
         if (pFoundWindow) {
             if (!pFoundWindow->m_bIsX11) {
                 foundSurface = g_pCompositor->vectorWindowToSurface(mouseCoords, pFoundWindow, surfaceCoords);
@@ -146,14 +171,16 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
 
     // then surfaces below
     if (!foundSurface)
-        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], &surfaceCoords);
+        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], &surfaceCoords, &pFoundLayerSurface);
 
     if (!foundSurface)
-        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND], &surfaceCoords);
-
+        foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND], &surfaceCoords, &pFoundLayerSurface);
 
     if (!foundSurface) {
-        wlr_xcursor_manager_set_cursor_image(g_pCompositor->m_sWLRXCursorMgr, "left_ptr", g_pCompositor->m_sWLRCursor);
+        if (m_ecbClickBehavior == CLICKMODE_KILL)
+            wlr_xcursor_manager_set_cursor_image(g_pCompositor->m_sWLRXCursorMgr, "crosshair", g_pCompositor->m_sWLRCursor);
+        else
+            wlr_xcursor_manager_set_cursor_image(g_pCompositor->m_sWLRXCursorMgr, "left_ptr", g_pCompositor->m_sWLRCursor);
 
         wlr_seat_pointer_clear_focus(g_pCompositor->m_sSeat.seat);
 
@@ -165,20 +192,30 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
 
     Vector2D surfaceLocal = surfacePos == Vector2D(-1337, -1337) ? surfaceCoords : mouseCoords - surfacePos;
 
+    if (pFoundWindow && !pFoundWindow->m_bIsX11 && surfacePos != Vector2D(-1337, -1337)) {
+        // calc for oversized windows... fucking bullshit.
+        wlr_box geom;
+        wlr_xdg_surface_get_geometry(pFoundWindow->m_uSurface.xdg, &geom);
+
+        surfaceLocal = mouseCoords - surfacePos + Vector2D(geom.x, geom.y);
+    }
+
     if (pFoundWindow) {
-        if (g_pConfigManager->getInt("input:follow_mouse") == 0 && !refocus) {
+        static auto *const PFOLLOWMOUSE = &g_pConfigManager->getConfigValuePtr("input:follow_mouse")->intValue;
+        if (*PFOLLOWMOUSE != 1 && !refocus) {
             if (pFoundWindow != g_pCompositor->m_pLastWindow && g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow) && (g_pCompositor->m_pLastWindow->m_bIsFloating != pFoundWindow->m_bIsFloating)) {
                 // enter if change floating style
                 g_pCompositor->focusWindow(pFoundWindow, foundSurface);
                 wlr_seat_pointer_notify_enter(g_pCompositor->m_sSeat.seat, foundSurface, surfaceLocal.x, surfaceLocal.y);
+            } else if (*PFOLLOWMOUSE == 2) {
+                wlr_seat_pointer_notify_enter(g_pCompositor->m_sSeat.seat, foundSurface, surfaceLocal.x, surfaceLocal.y);
             }
             wlr_seat_pointer_notify_motion(g_pCompositor->m_sSeat.seat, time, surfaceLocal.x, surfaceLocal.y);
-            return; // don't enter any new surfaces
+            return;  // don't enter any new surfaces
         } else {
             g_pCompositor->focusWindow(pFoundWindow, foundSurface);
         }
-    }
-    else
+    } else if (pFoundLayerSurface && pFoundLayerSurface->layerSurface->current.keyboard_interactive)
         g_pCompositor->focusSurface(foundSurface);
 
     wlr_seat_pointer_notify_enter(g_pCompositor->m_sSeat.seat, foundSurface, surfaceLocal.x, surfaceLocal.y);
@@ -188,8 +225,75 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
 void CInputManager::onMouseButton(wlr_pointer_button_event* e) {
     wlr_idle_notify_activity(g_pCompositor->m_sWLRIdle, g_pCompositor->m_sSeat.seat);
 
+    m_tmrLastCursorMovement.reset();
+
+    switch (m_ecbClickBehavior) {
+        case CLICKMODE_DEFAULT:
+            processMouseDownNormal(e);
+            break;
+        case CLICKMODE_KILL:
+            processMouseDownKill(e);
+            break;
+        default:
+            break;
+    }
+}
+
+void CInputManager::processMouseRequest(wlr_seat_pointer_request_set_cursor_event* e) {
+    if (!g_pHyprRenderer->shouldRenderCursor())
+        return;
+
+    if (!e->surface) {
+        g_pHyprRenderer->m_bWindowRequestedCursorHide = true;
+    } else {
+        g_pHyprRenderer->m_bWindowRequestedCursorHide = false;
+    }
+
+    if (m_ecbClickBehavior == CLICKMODE_KILL) {
+        wlr_xcursor_manager_set_cursor_image(g_pCompositor->m_sWLRXCursorMgr, "crosshair", g_pCompositor->m_sWLRCursor);
+        return;
+    }
+
+    if (e->seat_client == g_pCompositor->m_sSeat.seat->pointer_state.focused_client)
+        wlr_cursor_set_surface(g_pCompositor->m_sWLRCursor, e->surface, e->hotspot_x, e->hotspot_y);
+}
+
+eClickBehaviorMode CInputManager::getClickMode() {
+    return m_ecbClickBehavior;
+}
+
+void CInputManager::setClickMode(eClickBehaviorMode mode) {
+    switch (mode) {
+        case CLICKMODE_DEFAULT:
+            Debug::log(LOG, "SetClickMode: DEFAULT");
+            m_ecbClickBehavior = CLICKMODE_DEFAULT;
+            wlr_xcursor_manager_set_cursor_image(g_pCompositor->m_sWLRXCursorMgr, "left_ptr", g_pCompositor->m_sWLRCursor);
+            break;
+
+        case CLICKMODE_KILL:
+            Debug::log(LOG, "SetClickMode: KILL");
+            m_ecbClickBehavior = CLICKMODE_KILL;
+
+            // remove constraints
+            g_pCompositor->m_sSeat.mouse->constraintActive = false;
+            refocus();
+
+            // set cursor
+            wlr_xcursor_manager_set_cursor_image(g_pCompositor->m_sWLRXCursorMgr, "crosshair", g_pCompositor->m_sWLRCursor);
+            break;
+        default:
+            break;
+    } 
+}
+
+void CInputManager::processMouseDownNormal(wlr_pointer_button_event* e) {
     const auto PKEYBOARD = wlr_seat_get_keyboard(g_pCompositor->m_sSeat.seat);
 
+    if (!PKEYBOARD) {  // ???
+        Debug::log(ERR, "No active keyboard in processMouseDownNormal??");
+        return;
+    }
+
     switch (e->state) {
         case WLR_BUTTON_PRESSED:
             if (!g_pCompositor->m_sSeat.mouse->currentConstraint)
@@ -214,7 +318,7 @@ void CInputManager::onMouseButton(wlr_pointer_button_event* e) {
                 currentlyDraggedWindow = nullptr;
                 dragButton = -1;
             }
-            
+
             break;
     }
 
@@ -222,7 +326,30 @@ void CInputManager::onMouseButton(wlr_pointer_button_event* e) {
     if (g_pCompositor->doesSeatAcceptInput(g_pCompositor->m_pLastFocus)) {
         wlr_seat_pointer_notify_button(g_pCompositor->m_sSeat.seat, e->time_msec, e->button, e->state);
     }
-        
+}
+
+void CInputManager::processMouseDownKill(wlr_pointer_button_event* e) {
+    switch (e->state) {
+        case WLR_BUTTON_PRESSED: {
+            const auto PWINDOW = g_pCompositor->m_pLastWindow;
+
+            if (!g_pCompositor->windowValidMapped(PWINDOW)){
+                Debug::log(ERR, "Cannot kill invalid window!");
+                break;
+            }
+
+            // kill the mf
+            kill(PWINDOW->getPID(), SIGKILL);
+            break;
+        }
+        case WLR_BUTTON_RELEASED:
+            break;
+        default:
+            break;
+    }
+
+    // reset click behavior mode
+    m_ecbClickBehavior = CLICKMODE_DEFAULT;
 }
 
 Vector2D CInputManager::getMouseCoordsInternal() {
@@ -230,88 +357,165 @@ Vector2D CInputManager::getMouseCoordsInternal() {
 }
 
 void CInputManager::newKeyboard(wlr_input_device* keyboard) {
-    m_lKeyboards.push_back(SKeyboard());
-
-    const auto PNEWKEYBOARD = &m_lKeyboards.back();
+    const auto PNEWKEYBOARD = &m_lKeyboards.emplace_back();
 
     PNEWKEYBOARD->keyboard = keyboard;
 
-    xkb_rule_names rules;
-
-    const auto CONTEXT = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
-    const auto KEYMAP = xkb_keymap_new_from_names(CONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
-
-    const auto REPEATRATE = g_pConfigManager->getInt("input:repeat_rate");
-    const auto REPEATDELAY = g_pConfigManager->getInt("input:repeat_delay");
-
-    wlr_keyboard_set_keymap(keyboard->keyboard, KEYMAP);
-    xkb_keymap_unref(KEYMAP);
-    xkb_context_unref(CONTEXT);
-    wlr_keyboard_set_repeat_info(keyboard->keyboard, std::max(0, REPEATRATE), std::max(0, REPEATDELAY));
+    try {
+        PNEWKEYBOARD->name = std::string(keyboard->name);
+    } catch (std::exception& e) {
+        Debug::log(ERR, "Keyboard had no name???");  // logic error
+    }
 
     PNEWKEYBOARD->hyprListener_keyboardMod.initCallback(&keyboard->keyboard->events.modifiers, &Events::listener_keyboardMod, PNEWKEYBOARD, "Keyboard");
     PNEWKEYBOARD->hyprListener_keyboardKey.initCallback(&keyboard->keyboard->events.key, &Events::listener_keyboardKey, PNEWKEYBOARD, "Keyboard");
     PNEWKEYBOARD->hyprListener_keyboardDestroy.initCallback(&keyboard->events.destroy, &Events::listener_keyboardDestroy, PNEWKEYBOARD, "Keyboard");
 
+    if (m_pActiveKeyboard)
+        m_pActiveKeyboard->active = false;
+    m_pActiveKeyboard = PNEWKEYBOARD;
+
+    applyConfigToKeyboard(PNEWKEYBOARD);
+
     wlr_seat_set_keyboard(g_pCompositor->m_sSeat.seat, keyboard->keyboard);
 
     Debug::log(LOG, "New keyboard created, pointers Hypr: %x and WLR: %x", PNEWKEYBOARD, keyboard);
-
-    setKeyboardLayout();
 }
 
 void CInputManager::setKeyboardLayout() {
+    for (auto& k : m_lKeyboards)
+        applyConfigToKeyboard(&k);
+}
 
-    const auto RULES    = g_pConfigManager->getString("input:kb_rules");
-    const auto MODEL    = g_pConfigManager->getString("input:kb_model");
-    const auto LAYOUT   = g_pConfigManager->getString("input:kb_layout");
-    const auto VARIANT  = g_pConfigManager->getString("input:kb_variant");
-    const auto OPTIONS  = g_pConfigManager->getString("input:kb_options");
+void CInputManager::applyConfigToKeyboard(SKeyboard* pKeyboard) {
+    const auto HASCONFIG = g_pConfigManager->deviceConfigExists(pKeyboard->name);
+
+    ASSERT(pKeyboard);
+
+    if (!pKeyboard->keyboard->keyboard)
+        return;
+
+    const auto REPEATRATE = HASCONFIG ? g_pConfigManager->getDeviceInt(pKeyboard->name, "repeat_rate") : g_pConfigManager->getInt("input:repeat_rate");
+    const auto REPEATDELAY = HASCONFIG ? g_pConfigManager->getDeviceInt(pKeyboard->name, "repeat_delay") : g_pConfigManager->getInt("input:repeat_delay");
+
+    const auto NUMLOCKON = HASCONFIG ? g_pConfigManager->getDeviceInt(pKeyboard->name, "numlock_by_default") : g_pConfigManager->getInt("input:numlock_by_default");
+
+    const auto RULES = HASCONFIG ? g_pConfigManager->getDeviceString(pKeyboard->name, "kb_rules") : g_pConfigManager->getString("input:kb_rules");
+    const auto MODEL = HASCONFIG ? g_pConfigManager->getDeviceString(pKeyboard->name, "kb_model") : g_pConfigManager->getString("input:kb_model");
+    const auto LAYOUT = HASCONFIG ? g_pConfigManager->getDeviceString(pKeyboard->name, "kb_layout") : g_pConfigManager->getString("input:kb_layout");
+    const auto VARIANT = HASCONFIG ? g_pConfigManager->getDeviceString(pKeyboard->name, "kb_variant") : g_pConfigManager->getString("input:kb_variant");
+    const auto OPTIONS = HASCONFIG ? g_pConfigManager->getDeviceString(pKeyboard->name, "kb_options") : g_pConfigManager->getString("input:kb_options");
+
+    try {
+        if (NUMLOCKON == pKeyboard->numlockOn && REPEATDELAY == pKeyboard->repeatDelay && REPEATRATE == pKeyboard->repeatRate && RULES != "" && RULES == std::string(pKeyboard->currentRules.rules) && MODEL == std::string(pKeyboard->currentRules.model) && LAYOUT == std::string(pKeyboard->currentRules.layout) && VARIANT == std::string(pKeyboard->currentRules.variant) && OPTIONS == std::string(pKeyboard->currentRules.options)) {
+            Debug::log(LOG, "Not applying config to keyboard, it did not change.");
+            return;
+        }
+    } catch (std::exception& e) {
+        // can be libc errors for null std::string
+        // we can ignore those and just apply
+    }
+
+    wlr_keyboard_set_repeat_info(pKeyboard->keyboard->keyboard, std::max(0, REPEATRATE), std::max(0, REPEATDELAY));
+
+    pKeyboard->repeatDelay = REPEATDELAY;
+    pKeyboard->repeatRate = REPEATRATE;
+    pKeyboard->numlockOn = NUMLOCKON;
 
     xkb_rule_names rules = {
         .rules = RULES.c_str(),
         .model = MODEL.c_str(),
         .layout = LAYOUT.c_str(),
         .variant = VARIANT.c_str(),
-        .options = OPTIONS.c_str()
-    };
+        .options = OPTIONS.c_str()};
+
+    pKeyboard->currentRules = rules;
 
     const auto CONTEXT = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
-    const auto KEYMAP = xkb_keymap_new_from_names(CONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
 
-    if (!KEYMAP) {
-        Debug::log(ERR, "Keyboard layout %s with variant %s (rules: %s, model: %s, options: %s) couldn't have been loaded.", rules.layout, rules.variant, rules.rules, rules.model, rules.options);
-        xkb_context_unref(CONTEXT);
+    if (!CONTEXT) {
+        Debug::log(ERR, "applyConfigToKeyboard: CONTEXT null??");
         return;
     }
 
-    // TODO: configure devices one by one
-    for (auto& k : m_lKeyboards)
-        wlr_keyboard_set_keymap(k.keyboard->keyboard, KEYMAP);
+    Debug::log(LOG, "Attempting to create a keymap for layout %s with variant %s (rules: %s, model: %s, options: %s)", rules.layout, rules.variant, rules.rules, rules.model, rules.options);
+
+    auto KEYMAP = xkb_keymap_new_from_names(CONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
+
+    if (!KEYMAP) {
+        Debug::log(ERR, "Keyboard layout %s with variant %s (rules: %s, model: %s, options: %s) couldn't have been loaded.", rules.layout, rules.variant, rules.rules, rules.model, rules.options);
+        memset(&rules, 0, sizeof(rules));
+
+        pKeyboard->currentRules = rules;
+
+        KEYMAP = xkb_keymap_new_from_names(CONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
+    }
+
+    wlr_keyboard_set_keymap(pKeyboard->keyboard->keyboard, KEYMAP);
+
+    wlr_keyboard_modifiers wlrMods = {0};
+
+    if (NUMLOCKON == 1) {
+        // lock numlock
+        const auto IDX = xkb_map_mod_get_index(KEYMAP, XKB_MOD_NAME_NUM);
+
+        if (IDX != XKB_MOD_INVALID)
+            wlrMods.locked |= (uint32_t)1 << IDX;
+    }
+
+    if (wlrMods.locked != 0) {
+        wlr_keyboard_notify_modifiers(pKeyboard->keyboard->keyboard, 0, 0, wlrMods.locked, 0);
+    }
 
     xkb_keymap_unref(KEYMAP);
     xkb_context_unref(CONTEXT);
 
-    Debug::log(LOG, "Set the keyboard layout to %s and variant to %s", rules.layout, rules.variant);
-}
+    Debug::log(LOG, "Set the keyboard layout to %s and variant to %s for keyboard \"%s\"", rules.layout, rules.variant, pKeyboard->keyboard->name);
+} 
 
 void CInputManager::newMouse(wlr_input_device* mouse) {
     m_lMice.emplace_back();
     const auto PMOUSE = &m_lMice.back();
 
     PMOUSE->mouse = mouse;
+    try {
+        PMOUSE->name = std::string(mouse->name);
+    } catch(std::exception& e) {
+        Debug::log(ERR, "Mouse had no name???"); // logic error
+    }
+
+    const auto HASCONFIG = g_pConfigManager->deviceConfigExists(PMOUSE->name);
 
     if (wlr_input_device_is_libinput(mouse)) {
         const auto LIBINPUTDEV = (libinput_device*)wlr_libinput_get_device_handle(mouse);
 
-        if (libinput_device_config_tap_get_finger_count(LIBINPUTDEV))  // this is for tapping (like on a laptop)
-            libinput_device_config_tap_set_enabled(LIBINPUTDEV, LIBINPUT_CONFIG_TAP_ENABLED);
+        if ((HASCONFIG ? g_pConfigManager->getDeviceInt(PMOUSE->name, "clickfinger_behavior") : g_pConfigManager->getInt("input:touchpad:clickfinger_behavior")) == 0) // toggle software buttons or clickfinger
+            libinput_device_config_click_set_method(LIBINPUTDEV, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
+        else
+            libinput_device_config_click_set_method(LIBINPUTDEV, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
+        
+        if (libinput_device_config_middle_emulation_is_available(LIBINPUTDEV)) { // middleclick on r+l mouse button pressed
+            if ((HASCONFIG ? g_pConfigManager->getDeviceInt(PMOUSE->name, "middle_button_emulation") : g_pConfigManager->getInt("input:touchpad:middle_button_emulation")) == 1)
+                libinput_device_config_middle_emulation_set_enabled(LIBINPUTDEV, LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
+            else
+                libinput_device_config_middle_emulation_set_enabled(LIBINPUTDEV, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+        }
 
-        if (libinput_device_config_scroll_has_natural_scroll(LIBINPUTDEV))
-            libinput_device_config_scroll_set_natural_scroll_enabled(LIBINPUTDEV, g_pConfigManager->getInt("input:natural_scroll"));
+        if (libinput_device_config_tap_get_finger_count(LIBINPUTDEV))  // this is for tapping (like on a laptop)
+            if ((HASCONFIG ? g_pConfigManager->getDeviceInt(PMOUSE->name, "tap-to-click") : g_pConfigManager->getInt("input:touchpad:tap-to-click")) == 1)
+                libinput_device_config_tap_set_enabled(LIBINPUTDEV, LIBINPUT_CONFIG_TAP_ENABLED);
+
+        if (libinput_device_config_scroll_has_natural_scroll(LIBINPUTDEV)) {
+            double w = 0, h = 0;
+
+            if (libinput_device_has_capability(LIBINPUTDEV, LIBINPUT_DEVICE_CAP_POINTER) && libinput_device_get_size(LIBINPUTDEV, &w, &h) == 0) // pointer with size is a touchpad
+                libinput_device_config_scroll_set_natural_scroll_enabled(LIBINPUTDEV, (HASCONFIG ? g_pConfigManager->getDeviceInt(PMOUSE->name, "natural_scroll") : g_pConfigManager->getInt("input:touchpad:natural_scroll")));
+            else
+                libinput_device_config_scroll_set_natural_scroll_enabled(LIBINPUTDEV, (HASCONFIG ? g_pConfigManager->getDeviceInt(PMOUSE->name, "natural_scroll") : g_pConfigManager->getInt("input:natural_scroll")));
+        }
         
         if (libinput_device_config_dwt_is_available(LIBINPUTDEV)) {
-            const auto DWT = static_cast<enum libinput_config_dwt_state>(g_pConfigManager->getInt("input:touchpad:disable_while_typing") != 0);
+            const auto DWT = static_cast<enum libinput_config_dwt_state>((HASCONFIG ? g_pConfigManager->getDeviceInt(PMOUSE->name, "disable_while_typing") : g_pConfigManager->getInt("input:touchpad:disable_while_typing")) != 0);
             libinput_device_config_dwt_set_enabled(LIBINPUTDEV, DWT);
         }
     }
@@ -322,6 +526,8 @@ void CInputManager::newMouse(wlr_input_device* mouse) {
 
     g_pCompositor->m_sSeat.mouse = PMOUSE;
 
+    m_tmrLastCursorMovement.reset();
+
     Debug::log(LOG, "New mouse created, pointer WLR: %x", mouse);
 }
 
@@ -330,6 +536,17 @@ void CInputManager::destroyKeyboard(SKeyboard* pKeyboard) {
     pKeyboard->hyprListener_keyboardMod.removeCallback();
     pKeyboard->hyprListener_keyboardKey.removeCallback();
 
+    if (pKeyboard->active) {
+        m_lKeyboards.remove(*pKeyboard);
+
+        if (m_lKeyboards.size() > 0) {
+            m_pActiveKeyboard = &m_lKeyboards.back();
+            m_pActiveKeyboard->active = true;
+        } else {
+            m_pActiveKeyboard = nullptr;
+        }
+    }
+
     m_lKeyboards.remove(*pKeyboard);
 }
 
@@ -387,9 +604,12 @@ void CInputManager::updateDragIcon() {
     switch (g_pInputManager->m_sDrag.dragIcon->drag->grab_type) {
         case WLR_DRAG_GRAB_KEYBOARD:
             break;
-        case WLR_DRAG_GRAB_KEYBOARD_POINTER:
+        case WLR_DRAG_GRAB_KEYBOARD_POINTER: {
+            wlr_box box = {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};
+            g_pHyprRenderer->damageBox(&box);
             g_pInputManager->m_sDrag.pos = g_pInputManager->getMouseCoordsInternal();
             break;
+        }
         default:
             break;
     }
@@ -469,3 +689,23 @@ void CInputManager::constrainMouse(SMouse* pMouse, wlr_pointer_constraint_v1* co
 void Events::listener_commitConstraint(void* owner, void* data) {
     //g_pInputManager->recheckConstraint((SMouse*)owner);
 }
+
+void CInputManager::updateCapabilities(wlr_input_device* pDev) {
+    // TODO: this is dumb
+
+    switch (pDev->type) {
+        case WLR_INPUT_DEVICE_KEYBOARD:
+            m_uiCapabilities |= WL_SEAT_CAPABILITY_KEYBOARD;
+            break;
+        case WLR_INPUT_DEVICE_POINTER:
+            m_uiCapabilities |= WL_SEAT_CAPABILITY_POINTER;
+            break;
+        case WLR_INPUT_DEVICE_TOUCH:
+            m_uiCapabilities |= WL_SEAT_CAPABILITY_TOUCH;
+            break;
+        default:
+            break;
+    }
+
+    wlr_seat_set_capabilities(g_pCompositor->m_sSeat.seat, m_uiCapabilities);
+}

src/managers/input/InputManager.hpp

@@ -0,0 +1,85 @@
+#pragma once
+
+#include "../../defines.hpp"
+#include <list>
+#include "../../helpers/WLClasses.hpp"
+#include "../../Window.hpp"
+#include "../../helpers/Timer.hpp"
+
+enum eClickBehaviorMode {
+    CLICKMODE_DEFAULT = 0,
+    CLICKMODE_KILL
+};
+
+class CInputManager {
+public:
+
+    void            onMouseMoved(wlr_pointer_motion_event*);
+    void            onMouseWarp(wlr_pointer_motion_absolute_event*);
+    void            onMouseButton(wlr_pointer_button_event*);
+    void            onKeyboardKey(wlr_keyboard_key_event*, SKeyboard*);
+    void            onKeyboardMod(void*, SKeyboard*);
+
+    void            newKeyboard(wlr_input_device*);
+    void            newMouse(wlr_input_device*);
+    void            destroyKeyboard(SKeyboard*);
+    void            destroyMouse(wlr_input_device*);
+
+    void            constrainMouse(SMouse*, wlr_pointer_constraint_v1*);
+    void            recheckConstraint(SMouse*);
+
+    Vector2D        getMouseCoordsInternal();
+    void            refocus();
+
+    void            setKeyboardLayout();
+
+    void            updateDragIcon();
+    void            updateCapabilities(wlr_input_device*);
+
+    void            setClickMode(eClickBehaviorMode);
+    eClickBehaviorMode getClickMode();
+    void            processMouseRequest(wlr_seat_pointer_request_set_cursor_event*);
+
+
+    // for dragging floating windows
+    CWindow*        currentlyDraggedWindow = nullptr;
+    int             dragButton = -1;
+
+    SDrag           m_sDrag;
+
+    std::list<SConstraint>  m_lConstraints;
+    std::list<SKeyboard>    m_lKeyboards;
+    std::list<SMouse>       m_lMice;
+
+    // tablets
+    std::list<STablet>      m_lTablets;
+    std::list<STabletTool>  m_lTabletTools;
+    std::list<STabletPad>   m_lTabletPads;
+
+    void            newTabletTool(wlr_input_device*);
+    void            newTabletPad(wlr_input_device*);
+    void            focusTablet(STablet*, wlr_tablet_tool*, bool motion = false);
+
+    SKeyboard*      m_pActiveKeyboard = nullptr;
+
+    CTimer          m_tmrLastCursorMovement;
+
+private:
+
+    // for click behavior override
+    eClickBehaviorMode m_ecbClickBehavior = CLICKMODE_DEFAULT;
+    Vector2D        m_vLastCursorPosFloored = Vector2D();
+
+    void            processMouseDownNormal(wlr_pointer_button_event* e);
+    void            processMouseDownKill(wlr_pointer_button_event* e);
+
+    uint32_t        m_uiCapabilities = 0;
+
+    void            mouseMoveUnified(uint32_t, bool refocus = false);
+
+    STabletTool*    ensureTabletToolPresent(wlr_tablet_tool*);
+
+    void            applyConfigToKeyboard(SKeyboard*);
+};
+
+inline std::unique_ptr<CInputManager> g_pInputManager;

src/managers/input/Tablets.cpp

@@ -0,0 +1,241 @@
+#include "InputManager.hpp"
+#include "../../Compositor.hpp"
+
+void CInputManager::newTabletTool(wlr_input_device* pDevice) {
+    const auto PNEWTABLET = &m_lTablets.emplace_back();
+
+    try {
+        PNEWTABLET->name = std::string(pDevice->name);
+    } catch (std::exception& e) {
+        Debug::log(ERR, "Tablet had no name???");  // logic error
+    }
+
+    PNEWTABLET->wlrTablet = pDevice->tablet;
+    PNEWTABLET->wlrDevice = pDevice;
+    PNEWTABLET->wlrTabletV2 = wlr_tablet_create(g_pCompositor->m_sWLRTabletManager, g_pCompositor->m_sSeat.seat, pDevice);
+    PNEWTABLET->wlrTablet->data = PNEWTABLET;
+
+    Debug::log(LOG, "Attaching tablet to cursor!");
+
+    wlr_cursor_attach_input_device(g_pCompositor->m_sWLRCursor, pDevice);
+
+    PNEWTABLET->hyprListener_Destroy.initCallback(&pDevice->events.destroy, [](void* owner, void* data) {
+        const auto PTAB = (STablet*)owner;
+
+        g_pInputManager->m_lTablets.remove(*PTAB);
+
+        Debug::log(LOG, "Removed a tablet");
+    }, PNEWTABLET, "Tablet");
+
+    PNEWTABLET->hyprListener_Axis.initCallback(&pDevice->tablet->events.axis, [](void* owner, void* data) {
+
+        const auto EVENT = (wlr_tablet_tool_axis_event*)data;
+        const auto PTAB = (STablet*)owner;
+
+        switch (EVENT->tool->type) {
+            case WLR_TABLET_TOOL_TYPE_MOUSE:
+                wlr_cursor_move(g_pCompositor->m_sWLRCursor, PTAB->wlrDevice, EVENT->dx, EVENT->dy);
+                g_pInputManager->refocus();
+                break;
+            default:
+                double x = (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_X) ? EVENT->x : NAN;
+                double y = (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_Y) ? EVENT->y : NAN;
+                wlr_cursor_warp_absolute(g_pCompositor->m_sWLRCursor, PTAB->wlrDevice, x, y);
+                g_pInputManager->refocus();
+                break;
+        }
+
+        const auto PTOOL = g_pInputManager->ensureTabletToolPresent(EVENT->tool);
+
+        // TODO: this might be wrong
+        if (PTOOL->active) {
+            g_pInputManager->refocus();
+
+            g_pInputManager->focusTablet(PTAB, EVENT->tool, true);
+        }
+
+        if (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_PRESSURE)
+            wlr_tablet_v2_tablet_tool_notify_pressure(PTOOL->wlrTabletToolV2, EVENT->pressure);
+
+        if (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_DISTANCE)
+            wlr_tablet_v2_tablet_tool_notify_distance(PTOOL->wlrTabletToolV2, EVENT->distance);
+
+        if (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_ROTATION)
+            wlr_tablet_v2_tablet_tool_notify_rotation(PTOOL->wlrTabletToolV2, EVENT->rotation);
+
+        if (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_SLIDER)
+            wlr_tablet_v2_tablet_tool_notify_slider(PTOOL->wlrTabletToolV2, EVENT->slider);
+
+        if (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_WHEEL) 
+            wlr_tablet_v2_tablet_tool_notify_wheel(PTOOL->wlrTabletToolV2, EVENT->wheel_delta, 0);
+
+        if (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_TILT_X)
+            PTOOL->tiltX = EVENT->tilt_x;
+
+        if (EVENT->updated_axes & WLR_TABLET_TOOL_AXIS_TILT_Y)
+            PTOOL->tiltY = EVENT->tilt_y;
+
+        if (EVENT->updated_axes & (WLR_TABLET_TOOL_AXIS_TILT_X | WLR_TABLET_TOOL_AXIS_TILT_Y))
+            wlr_tablet_v2_tablet_tool_notify_tilt(PTOOL->wlrTabletToolV2, PTOOL->tiltX, PTOOL->tiltY);
+
+    }, PNEWTABLET, "Tablet");
+
+    PNEWTABLET->hyprListener_Tip.initCallback(&pDevice->tablet->events.tip, [](void* owner, void* data) {
+        const auto EVENT = (wlr_tablet_tool_tip_event*)data;
+        const auto PTAB = (STablet*)owner;
+
+        const auto PTOOL = g_pInputManager->ensureTabletToolPresent(EVENT->tool);
+
+        // TODO: this might be wrong
+        if (EVENT->state == WLR_TABLET_TOOL_TIP_DOWN) {
+            g_pInputManager->refocus();
+            g_pInputManager->focusTablet(PTAB, EVENT->tool);
+            wlr_send_tablet_v2_tablet_tool_down(PTOOL->wlrTabletToolV2);
+        }
+        else {
+            wlr_send_tablet_v2_tablet_tool_up(PTOOL->wlrTabletToolV2);
+        }
+            
+    }, PNEWTABLET, "Tablet");
+
+    PNEWTABLET->hyprListener_Button.initCallback(&pDevice->tablet->events.button, [](void* owner, void* data) {
+        const auto EVENT = (wlr_tablet_tool_button_event*)data;
+
+        const auto PTOOL = g_pInputManager->ensureTabletToolPresent(EVENT->tool);
+
+        wlr_tablet_v2_tablet_tool_notify_button(PTOOL->wlrTabletToolV2, (zwp_tablet_pad_v2_button_state)EVENT->button, (zwp_tablet_pad_v2_button_state)EVENT->state);
+            
+    }, PNEWTABLET, "Tablet");
+
+    PNEWTABLET->hyprListener_Proximity.initCallback(&pDevice->tablet->events.proximity, [](void* owner, void* data) {
+        const auto EVENT = (wlr_tablet_tool_proximity_event*)data;
+        const auto PTAB = (STablet*)owner;
+
+        const auto PTOOL = g_pInputManager->ensureTabletToolPresent(EVENT->tool);
+
+        if (EVENT->state == WLR_TABLET_TOOL_PROXIMITY_OUT) {
+            PTOOL->active = false;
+
+            if (PTOOL->pSurface) {
+                wlr_tablet_v2_tablet_tool_notify_proximity_out(PTOOL->wlrTabletToolV2);
+                PTOOL->pSurface = nullptr;
+            }
+            
+        } else {
+            PTOOL->active = true;
+            g_pInputManager->refocus();
+            g_pInputManager->focusTablet(PTAB, EVENT->tool);
+        }
+            
+    }, PNEWTABLET, "Tablet");
+}
+
+STabletTool* CInputManager::ensureTabletToolPresent(wlr_tablet_tool* pTool) {
+    if (pTool->data == nullptr) {
+        const auto PTOOL = &m_lTabletTools.emplace_back();
+
+        Debug::log(LOG, "Creating tablet tool v2 for %x", pTool);
+
+        PTOOL->wlrTabletTool = pTool;
+        pTool->data = PTOOL;
+
+        PTOOL->wlrTabletToolV2 = wlr_tablet_tool_create(g_pCompositor->m_sWLRTabletManager, g_pCompositor->m_sSeat.seat, pTool);
+
+        PTOOL->hyprListener_TabletToolDestroy.initCallback(&pTool->events.destroy, [](void* owner, void* data) {
+            const auto PTOOL = (STabletTool*)owner;
+
+            PTOOL->wlrTabletTool->data = nullptr;
+            g_pInputManager->m_lTabletTools.remove(*PTOOL);
+        }, PTOOL, "Tablet Tool V1");
+
+        //TODO: set cursor request
+    }
+
+    return (STabletTool*)pTool->data;
+}
+
+void CInputManager::newTabletPad(wlr_input_device* pDevice) {
+    const auto PNEWPAD = &m_lTabletPads.emplace_back();
+
+    try {
+        PNEWPAD->name = std::string(pDevice->name);
+    } catch (std::exception& e) {
+        Debug::log(ERR, "Pad had no name???");  // logic error
+    }
+
+    PNEWPAD->wlrTabletPadV2 = wlr_tablet_pad_create(g_pCompositor->m_sWLRTabletManager, g_pCompositor->m_sSeat.seat, pDevice);
+
+    PNEWPAD->hyprListener_Button.initCallback(&pDevice->tablet_pad->events.button, [](void* owner, void* data) {
+
+        const auto EVENT = (wlr_tablet_pad_button_event*)data;
+        const auto PPAD = (STabletPad*)owner;
+
+        wlr_tablet_v2_tablet_pad_notify_mode(PPAD->wlrTabletPadV2, EVENT->group, EVENT->mode, EVENT->time_msec);
+        wlr_tablet_v2_tablet_pad_notify_button(PPAD->wlrTabletPadV2, EVENT->button, EVENT->time_msec, (zwp_tablet_pad_v2_button_state)EVENT->state);
+
+    }, PNEWPAD, "Tablet Pad");
+
+    PNEWPAD->hyprListener_Strip.initCallback(&pDevice->tablet_pad->events.strip, [](void* owner, void* data) {
+
+        const auto EVENT = (wlr_tablet_pad_strip_event*)data;
+        const auto PPAD = (STabletPad*)owner;
+
+        wlr_tablet_v2_tablet_pad_notify_strip(PPAD->wlrTabletPadV2, EVENT->strip, EVENT->position, EVENT->source == WLR_TABLET_PAD_STRIP_SOURCE_FINGER, EVENT->time_msec);
+
+    }, PNEWPAD, "Tablet Pad");
+
+    PNEWPAD->hyprListener_Ring.initCallback(&pDevice->tablet_pad->events.strip, [](void* owner, void* data) {
+
+        const auto EVENT = (wlr_tablet_pad_ring_event*)data;
+        const auto PPAD = (STabletPad*)owner;
+
+        wlr_tablet_v2_tablet_pad_notify_ring(PPAD->wlrTabletPadV2, EVENT->ring, EVENT->position, EVENT->source == WLR_TABLET_PAD_RING_SOURCE_FINGER, EVENT->time_msec);
+
+    }, PNEWPAD, "Tablet Pad");
+
+    PNEWPAD->hyprListener_Attach.initCallback(&pDevice->tablet_pad->events.strip, [](void* owner, void* data) {
+
+        const auto TABLET = (wlr_tablet_tool*)data;
+        const auto PPAD = (STabletPad*)owner;
+
+        PPAD->pTabletParent = (STablet*)TABLET->data;
+
+        if (!PPAD->pTabletParent)
+            Debug::log(ERR, "tabletpad got attached to a nullptr tablet!! this might be bad.");
+
+    }, PNEWPAD, "Tablet Pad");
+
+    PNEWPAD->hyprListener_Destroy.initCallback(&pDevice->events.destroy, [](void* owner, void* data) {
+
+        const auto PPAD = (STabletPad*)owner;
+
+        g_pInputManager->m_lTabletPads.remove(*PPAD);
+
+        Debug::log(LOG, "Removed a tablet pad");
+
+    }, PNEWPAD, "Tablet Pad");
+}
+
+void CInputManager::focusTablet(STablet* pTab, wlr_tablet_tool* pTool, bool motion) {
+    const auto PTOOL = g_pInputManager->ensureTabletToolPresent(pTool);
+
+    if (const auto PWINDOW = g_pCompositor->m_pLastWindow; g_pCompositor->windowValidMapped(PWINDOW)) {
+        const auto CURSORPOS = g_pInputManager->getMouseCoordsInternal();
+
+        const auto LOCAL = CURSORPOS - PWINDOW->m_vRealPosition.goalv();
+
+        if (PTOOL->pSurface != g_pCompositor->m_pLastFocus)
+            wlr_tablet_v2_tablet_tool_notify_proximity_out(PTOOL->wlrTabletToolV2);
+
+        if (g_pCompositor->m_pLastFocus) {
+            PTOOL->pSurface = g_pCompositor->m_pLastFocus;
+            wlr_tablet_v2_tablet_tool_notify_proximity_in(PTOOL->wlrTabletToolV2, pTab->wlrTabletV2, g_pCompositor->m_pLastFocus);
+        }
+
+        if (motion)
+            wlr_tablet_v2_tablet_tool_notify_motion(PTOOL->wlrTabletToolV2, LOCAL.x, LOCAL.y);
+    } else {
+        if (PTOOL->pSurface)
+            wlr_tablet_v2_tablet_tool_notify_proximity_out(PTOOL->wlrTabletToolV2);
+    }
+}

src/meson.build

@@ -0,0 +1,25 @@
+globber = run_command('find', '-name', '*.cpp', check: true)
+src = globber.stdout().strip().split('\n')
+
+executable('Hyprland', src,
+  cpp_args: ['-DWLR_USE_UNSTABLE'],
+  dependencies: [
+    server_protos,
+    dependency('wayland-server'),
+    dependency('wayland-client'),
+    wlroots.get_variable('wlroots'),
+    dependency('cairo'),
+    dependency('pango'),
+    dependency('pangocairo'),
+    dependency('libdrm'),
+    dependency('egl'),
+    dependency('xkbcommon'),
+    dependency('libinput'),
+    xcb_dep,
+
+    dependency('pixman-1'),
+    dependency('GL'),
+    dependency('threads')
+  ],
+  install : true
+)

src/render/OpenGL.cpp

@@ -75,6 +75,18 @@ CHyprOpenGLImpl::CHyprOpenGLImpl() {
     m_shBLUR2.posAttrib = glGetAttribLocation(prog, "pos");
     m_shBLUR2.texAttrib = glGetAttribLocation(prog, "texcoord");
 
+    prog = createProgram(QUADVERTSRC, FRAGSHADOW);
+    m_shSHADOW.program = prog;
+    m_shSHADOW.proj = glGetUniformLocation(prog, "proj");
+    m_shSHADOW.posAttrib = glGetAttribLocation(prog, "pos");
+    m_shSHADOW.texAttrib = glGetAttribLocation(prog, "texcoord");
+
+    prog = createProgram(QUADVERTSRC, FRAGBORDER1);
+    m_shBORDER1.program = prog;
+    m_shBORDER1.proj = glGetUniformLocation(prog, "proj");
+    m_shBORDER1.posAttrib = glGetAttribLocation(prog, "pos");
+    m_shBORDER1.texAttrib = glGetAttribLocation(prog, "texcoord");
+
     Debug::log(LOG, "Shaders initialized successfully.");
 
     // End shaders
@@ -132,7 +144,9 @@ void CHyprOpenGLImpl::begin(SMonitor* pMonitor, pixman_region32_t* pDamage, bool
 
     glViewport(0, 0, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y);
 
-    wlr_matrix_projection(m_RenderData.projection, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y, WL_OUTPUT_TRANSFORM_NORMAL);  // TODO: this is deprecated
+    matrixProjection(m_RenderData.projection, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y, WL_OUTPUT_TRANSFORM_NORMAL);
+
+    m_RenderData.pCurrentMonData = &m_mMonitorRenderResources[pMonitor];
 
     glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 
@@ -140,22 +154,22 @@ void CHyprOpenGLImpl::begin(SMonitor* pMonitor, pixman_region32_t* pDamage, bool
     m_iWLROutputFb = m_iCurrentOutputFb;
 
     // ensure a framebuffer for the monitor exists
-    if (m_mMonitorRenderResources.find(pMonitor) == m_mMonitorRenderResources.end() || m_mMonitorRenderResources[pMonitor].primaryFB.m_Size != pMonitor->vecPixelSize) {
-        m_mMonitorRenderResources[pMonitor].stencilTex.allocate();
+    if (m_mMonitorRenderResources.find(pMonitor) == m_mMonitorRenderResources.end() || m_RenderData.pCurrentMonData->primaryFB.m_Size != pMonitor->vecPixelSize) {
+        m_RenderData.pCurrentMonData->stencilTex.allocate();
 
-        m_mMonitorRenderResources[pMonitor].primaryFB.m_pStencilTex = &m_mMonitorRenderResources[pMonitor].stencilTex;
-        m_mMonitorRenderResources[pMonitor].mirrorFB.m_pStencilTex = &m_mMonitorRenderResources[pMonitor].stencilTex;
-        m_mMonitorRenderResources[pMonitor].mirrorSwapFB.m_pStencilTex = &m_mMonitorRenderResources[pMonitor].stencilTex;
+        m_RenderData.pCurrentMonData->primaryFB.m_pStencilTex = &m_RenderData.pCurrentMonData->stencilTex;
+        m_RenderData.pCurrentMonData->mirrorFB.m_pStencilTex = &m_RenderData.pCurrentMonData->stencilTex;
+        m_RenderData.pCurrentMonData->mirrorSwapFB.m_pStencilTex = &m_RenderData.pCurrentMonData->stencilTex;
 
-        m_mMonitorRenderResources[pMonitor].primaryFB.alloc(pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y);
-        m_mMonitorRenderResources[pMonitor].mirrorFB.alloc(pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y);
-        m_mMonitorRenderResources[pMonitor].mirrorSwapFB.alloc(pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y);
+        m_RenderData.pCurrentMonData->primaryFB.alloc(pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y);
+        m_RenderData.pCurrentMonData->mirrorFB.alloc(pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y);
+        m_RenderData.pCurrentMonData->mirrorSwapFB.alloc(pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y);
 
         createBGTextureForMonitor(pMonitor);
     }
 
     // bind the primary Hypr Framebuffer
-    m_mMonitorRenderResources[pMonitor].primaryFB.bind();
+    m_RenderData.pCurrentMonData->primaryFB.bind();
 
     m_RenderData.pDamage = pDamage;
 
@@ -174,7 +188,7 @@ void CHyprOpenGLImpl::end() {
 
         m_bEndFrame = true;
 
-        renderTexture(m_mMonitorRenderResources[m_RenderData.pMonitor].primaryFB.m_cTex, &monbox, 255.f, 0);
+        renderTexture(m_RenderData.pCurrentMonData->primaryFB.m_cTex, &monbox, 255.f, 0);
 
         m_bEndFrame = false;
     }
@@ -240,6 +254,10 @@ void CHyprOpenGLImpl::scissor(const int x, const int y, const int w, const int h
 }
 
 void CHyprOpenGLImpl::renderRect(wlr_box* box, const CColor& col, int round) {
+    renderRectWithDamage(box, col, m_RenderData.pDamage, round);
+}
+
+void CHyprOpenGLImpl::renderRectWithDamage(wlr_box* box, const CColor& col, pixman_region32_t* damage, int round) {
     RASSERT((box->width > 0 && box->height > 0), "Tried to render rect with width/height < 0!");
     RASSERT(m_RenderData.pMonitor, "Tried to render rect without begin()!");
 
@@ -264,11 +282,14 @@ void CHyprOpenGLImpl::renderRect(wlr_box* box, const CColor& col, int round) {
     const auto BOTTOMRIGHT = Vector2D(box->width - round, box->height - round);
     const auto FULLSIZE = Vector2D(box->width, box->height);
 
+    static auto *const PMULTISAMPLEEDGES = &g_pConfigManager->getConfigValuePtr("decoration:multisample_edges")->intValue;
+
     // Rounded corners
-    glUniform2f(glGetUniformLocation(m_shQUAD.program, "topLeft"), (float)TOPLEFT.x, (float)TOPLEFT.y);
-    glUniform2f(glGetUniformLocation(m_shQUAD.program, "bottomRight"), (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
-    glUniform2f(glGetUniformLocation(m_shQUAD.program, "fullSize"), (float)FULLSIZE.x, (float)FULLSIZE.y);
-    glUniform1f(glGetUniformLocation(m_shQUAD.program, "radius"), round);
+    glUniform2f(m_shQUAD.getUniformLocation("topLeft"), (float)TOPLEFT.x, (float)TOPLEFT.y);
+    glUniform2f(m_shQUAD.getUniformLocation("bottomRight"), (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
+    glUniform2f(m_shQUAD.getUniformLocation("fullSize"), (float)FULLSIZE.x, (float)FULLSIZE.y);
+    glUniform1f(m_shQUAD.getUniformLocation("radius"), round);
+    glUniform1i(m_shQUAD.getUniformLocation("primitiveMultisample"), (int)(*PMULTISAMPLEEDGES == 1 && round != 0));
 
     glVertexAttribPointer(m_shQUAD.posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
     glVertexAttribPointer(m_shQUAD.texAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
@@ -276,8 +297,8 @@ void CHyprOpenGLImpl::renderRect(wlr_box* box, const CColor& col, int round) {
     glEnableVertexAttribArray(m_shQUAD.posAttrib);
     glEnableVertexAttribArray(m_shQUAD.texAttrib);
 
-    if (pixman_region32_not_empty(m_RenderData.pDamage)) {
-        PIXMAN_DAMAGE_FOREACH(m_RenderData.pDamage) {
+    if (pixman_region32_not_empty(damage)) {
+        PIXMAN_DAMAGE_FOREACH(damage) {
             const auto RECT = RECTSARR[i];
             scissor(&RECT);
             glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
@@ -290,21 +311,21 @@ void CHyprOpenGLImpl::renderRect(wlr_box* box, const CColor& col, int round) {
     glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 }
 
-void CHyprOpenGLImpl::renderTexture(wlr_texture* tex, wlr_box* pBox, float alpha, int round) {
+void CHyprOpenGLImpl::renderTexture(wlr_texture* tex, wlr_box* pBox, float alpha, int round, bool allowCustomUV) {
     RASSERT(m_RenderData.pMonitor, "Tried to render texture without begin()!");
 
-    renderTexture(CTexture(tex), pBox, alpha, round);
+    renderTexture(CTexture(tex), pBox, alpha, round, false, allowCustomUV);
 }
 
-void CHyprOpenGLImpl::renderTexture(const CTexture& tex, wlr_box* pBox, float alpha, int round, bool discardopaque, bool border) {
+void CHyprOpenGLImpl::renderTexture(const CTexture& tex, wlr_box* pBox, float alpha, int round, bool discardopaque, bool allowCustomUV) {
     RASSERT(m_RenderData.pMonitor, "Tried to render texture without begin()!");
 
-    renderTextureInternalWithDamage(tex, pBox, alpha, m_RenderData.pDamage, round, discardopaque, border);
+    renderTextureInternalWithDamage(tex, pBox, alpha, m_RenderData.pDamage, round, discardopaque, false, allowCustomUV);
 
     scissor((wlr_box*)nullptr);
 }
 
-void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_box* pBox, float alpha, pixman_region32_t* damage, int round, bool discardOpaque, bool border) {
+void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_box* pBox, float alpha, pixman_region32_t* damage, int round, bool discardOpaque, bool noAA, bool allowCustomUV) {
     RASSERT(m_RenderData.pMonitor, "Tried to render texture without begin()!");
     RASSERT((tex.m_iTexID > 0), "Attempted to draw NULL texture!");
 
@@ -354,32 +375,35 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_b
     // so we need to do some maf
 
     const auto TOPLEFT = Vector2D(round, round);
-    const auto BOTTOMRIGHT = Vector2D(tex.m_vSize.x - round, tex.m_vSize.y - round);
-    const auto FULLSIZE = tex.m_vSize;
+    const auto BOTTOMRIGHT = Vector2D(pBox->width - round, pBox->height - round);
+    const auto FULLSIZE = Vector2D(pBox->width, pBox->height);
+    static auto *const PMULTISAMPLEEDGES = &g_pConfigManager->getConfigValuePtr("decoration:multisample_edges")->intValue;
 
     // Rounded corners
-    glUniform2f(glGetUniformLocation(shader->program, "topLeft"), (float)TOPLEFT.x, (float)TOPLEFT.y);
-    glUniform2f(glGetUniformLocation(shader->program, "bottomRight"), (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
-    glUniform2f(glGetUniformLocation(shader->program, "fullSize"), (float)FULLSIZE.x, (float)FULLSIZE.y);
-    glUniform1f(glGetUniformLocation(shader->program, "radius"), round);
+    glUniform2f(shader->getUniformLocation("topLeft"), (float)TOPLEFT.x, (float)TOPLEFT.y);
+    glUniform2f(shader->getUniformLocation("bottomRight"), (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
+    glUniform2f(shader->getUniformLocation("fullSize"), (float)FULLSIZE.x, (float)FULLSIZE.y);
+    glUniform1f(shader->getUniformLocation("radius"), round);
+    glUniform1i(shader->getUniformLocation("primitiveMultisample"), (int)(*PMULTISAMPLEEDGES == 1 && round != 0 && !noAA));
 
     glVertexAttribPointer(shader->posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
-    glVertexAttribPointer(shader->texAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
+
+    if (allowCustomUV && m_RenderData.primarySurfaceUVTopLeft != Vector2D(-1, -1)) {
+        const float verts[] = {
+            m_RenderData.primarySurfaceUVBottomRight.x, m_RenderData.primarySurfaceUVTopLeft.y,      // top right
+            m_RenderData.primarySurfaceUVTopLeft.x, m_RenderData.primarySurfaceUVTopLeft.y,          // top left
+            m_RenderData.primarySurfaceUVBottomRight.x, m_RenderData.primarySurfaceUVBottomRight.y,  // bottom right
+            m_RenderData.primarySurfaceUVTopLeft.x, m_RenderData.primarySurfaceUVBottomRight.y,      // bottom left
+        };
+
+        glVertexAttribPointer(shader->texAttrib, 2, GL_FLOAT, GL_FALSE, 0, verts);
+    } else {
+        glVertexAttribPointer(shader->texAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
+    }
 
     glEnableVertexAttribArray(shader->posAttrib);
     glEnableVertexAttribArray(shader->texAttrib);
 
-    // stencil for when we want a border
-    if (border) {
-        glClearStencil(0);
-        glClear(GL_STENCIL_BUFFER_BIT);
-
-        glEnable(GL_STENCIL_TEST);
-
-        glStencilFunc(GL_ALWAYS, 1, -1);
-        glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
-    }
-
     if (pixman_region32_not_empty(m_RenderData.pDamage)) {
         PIXMAN_DAMAGE_FOREACH(m_RenderData.pDamage) {
             const auto RECT = RECTSARR[i];
@@ -388,27 +412,10 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_b
         }
     }
 
-    if (border) {
-        glStencilFunc(GL_EQUAL, 1, -1);
-        glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
-    }
-
     glDisableVertexAttribArray(shader->posAttrib);
     glDisableVertexAttribArray(shader->texAttrib);
 
     glBindTexture(tex.m_iTarget, 0);
-
-    // if border draw
-    // we dont disable stencil here if we havent touched it. 
-    // some other func might be using it.
-    if (border) {
-        auto BORDERCOL = m_pCurrentWindow->m_cRealBorderColor.col();
-        BORDERCOL.a *= alpha / 255.f;
-        renderBorder(pBox, BORDERCOL, g_pConfigManager->getInt("general:border_size"), round);
-        glStencilMask(-1);
-        glStencilFunc(GL_ALWAYS, 1, 0xFF);
-        glDisable(GL_STENCIL_TEST);
-    }
 }
 
 // This probably isn't the fastest
@@ -432,20 +439,20 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, wlr_box* p
     wlr_matrix_transpose(glMatrix, glMatrix);
 
     // get the config settings
-    const auto BLURSIZE = g_pConfigManager->getInt("decoration:blur_size");
-    const auto BLURPASSES = g_pConfigManager->getInt("decoration:blur_passes");
+    static auto *const PBLURSIZE = &g_pConfigManager->getConfigValuePtr("decoration:blur_size")->intValue;
+    static auto *const PBLURPASSES = &g_pConfigManager->getConfigValuePtr("decoration:blur_passes")->intValue;
 
     // prep damage
     pixman_region32_t damage;
     pixman_region32_init(&damage);
     pixman_region32_copy(&damage, originalDamage);
-    wlr_region_expand(&damage, &damage, pow(2, BLURPASSES) * BLURSIZE);
+    wlr_region_expand(&damage, &damage, pow(2, *PBLURPASSES) * *PBLURSIZE);
 
     // helper
-    const auto PMIRRORFB = &m_mMonitorRenderResources[m_RenderData.pMonitor].mirrorFB;
-    const auto PMIRRORSWAPFB = &m_mMonitorRenderResources[m_RenderData.pMonitor].mirrorSwapFB;
+    const auto PMIRRORFB = &m_RenderData.pCurrentMonData->mirrorFB;
+    const auto PMIRRORSWAPFB = &m_RenderData.pCurrentMonData->mirrorSwapFB;
 
-    CFramebuffer* currentRenderToFB = &m_mMonitorRenderResources[m_RenderData.pMonitor].primaryFB;
+    CFramebuffer* currentRenderToFB = &m_RenderData.pCurrentMonData->primaryFB;
 
     // declare the draw func
     auto drawPass = [&](CShader* pShader, pixman_region32_t* pDamage) {
@@ -464,11 +471,11 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, wlr_box* p
 
         // prep two shaders
         glUniformMatrix3fv(pShader->proj, 1, GL_FALSE, glMatrix);
-        glUniform1f(glGetUniformLocation(pShader->program, "radius"), BLURSIZE * (a / 255.f));  // this makes the blursize change with a
+        glUniform1f(pShader->getUniformLocation("radius"), *PBLURSIZE * (a / 255.f));  // this makes the blursize change with a
         if (pShader == &m_shBLUR1)
-            glUniform2f(glGetUniformLocation(m_shBLUR1.program, "halfpixel"), 0.5f / (m_RenderData.pMonitor->vecPixelSize.x / 2.f), 0.5f / (m_RenderData.pMonitor->vecPixelSize.y / 2.f));
+            glUniform2f(m_shBLUR1.getUniformLocation("halfpixel"), 0.5f / (m_RenderData.pMonitor->vecPixelSize.x / 2.f), 0.5f / (m_RenderData.pMonitor->vecPixelSize.y / 2.f));
         else
-            glUniform2f(glGetUniformLocation(m_shBLUR2.program, "halfpixel"), 0.5f / (m_RenderData.pMonitor->vecPixelSize.x * 2.f), 0.5f / (m_RenderData.pMonitor->vecPixelSize.y * 2.f));
+            glUniform2f(m_shBLUR2.getUniformLocation("halfpixel"), 0.5f / (m_RenderData.pMonitor->vecPixelSize.x * 2.f), 0.5f / (m_RenderData.pMonitor->vecPixelSize.y * 2.f));
         glUniform1i(pShader->tex, 0);
 
         glVertexAttribPointer(pShader->posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
@@ -498,7 +505,7 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, wlr_box* p
     // draw the things.
     // first draw is prim -> mirr
     PMIRRORFB->bind();
-    glBindTexture(m_mMonitorRenderResources[m_RenderData.pMonitor].primaryFB.m_cTex.m_iTarget, m_mMonitorRenderResources[m_RenderData.pMonitor].primaryFB.m_cTex.m_iTexID);
+    glBindTexture(m_RenderData.pCurrentMonData->primaryFB.m_cTex.m_iTarget, m_RenderData.pCurrentMonData->primaryFB.m_cTex.m_iTexID);
 
     // damage region will be scaled, make a temp
     pixman_region32_t tempDamage;
@@ -508,12 +515,12 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, wlr_box* p
     drawPass(&m_shBLUR1, &tempDamage);
 
     // and draw
-    for (int i = 1; i < BLURPASSES; ++i) {
+    for (int i = 1; i < *PBLURPASSES; ++i) {
         wlr_region_scale(&tempDamage, &damage, 1.f / (1 << (i + 1)));
         drawPass(&m_shBLUR1, &tempDamage);  // down
     }
 
-    for (int i = BLURPASSES - 1; i >= 0; --i) {
+    for (int i = *PBLURPASSES - 1; i >= 0; --i) {
         wlr_region_scale(&tempDamage, &damage, 1.f / (1 << i));  // when upsampling we make the region twice as big
         drawPass(&m_shBLUR2, &tempDamage);  // up
     }
@@ -530,11 +537,14 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, wlr_box* p
     return currentRenderToFB;
 }
 
-void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox, float a, wlr_surface* pSurface, int round, bool border) {
+void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox, float a, wlr_surface* pSurface, int round) {
     RASSERT(m_RenderData.pMonitor, "Tried to render texture with blur without begin()!");
 
-    if (g_pConfigManager->getInt("decoration:blur") == 0) {
-        renderTexture(tex, pBox, a, round, false, border);
+    static auto *const PBLURENABLED = &g_pConfigManager->getConfigValuePtr("decoration:blur")->intValue;
+    static auto* const PNOBLUROVERSIZED = &g_pConfigManager->getConfigValuePtr("decoration:no_blur_on_oversized")->intValue;
+
+    if (*PBLURENABLED == 0 || (*PNOBLUROVERSIZED && m_RenderData.primarySurfaceUVTopLeft != Vector2D(-1, -1)) || (m_pCurrentWindow && m_pCurrentWindow->m_sAdditionalConfigData.forceNoBlur)) {
+        renderTexture(tex, pBox, a, round, false, true);
         return;
     }
 
@@ -556,8 +566,10 @@ void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox,
         pixman_region32_copy(&inverseOpaque, &damage);
     }
 
-    if (!pixman_region32_not_empty(&damage))
-        return; // if its empty, reject.
+    if (!pixman_region32_not_empty(&inverseOpaque)) {
+        renderTexture(tex, pBox, a, round, false); // reject blurring a fully opaque window
+        return;
+    }
 
     // blur the main FB, it will be rendered onto the mirror
     const auto POUTFB = blurMainFramebufferWithDamage(a, pBox, &inverseOpaque);
@@ -565,7 +577,7 @@ void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox,
     pixman_region32_fini(&inverseOpaque);
 
     // bind primary
-    m_mMonitorRenderResources[m_RenderData.pMonitor].primaryFB.bind();
+    m_RenderData.pCurrentMonData->primaryFB.bind();
 
     // make a stencil for rounded corners to work with blur
     scissor((wlr_box*)nullptr);  // allow the entire window and stencil to render
@@ -588,34 +600,20 @@ void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox,
     wlr_box MONITORBOX = {0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y};
     if (pixman_region32_not_empty(&damage)) {
         // render our great blurred FB
-        renderTextureInternalWithDamage(POUTFB->m_cTex, &MONITORBOX, g_pConfigManager->getInt("decoration:blur_ignore_opacity") ? 255.f : a, &damage);
+        static auto *const PBLURIGNOREOPACITY = &g_pConfigManager->getConfigValuePtr("decoration:blur_ignore_opacity")->intValue;
+        renderTextureInternalWithDamage(POUTFB->m_cTex, &MONITORBOX, *PBLURIGNOREOPACITY ? 255.f : a, &damage, 0, false, false, true);
 
         // render the window, but clear stencil
         glClearStencil(0);
         glClear(GL_STENCIL_BUFFER_BIT);
 
-        // and write to it
-        glStencilFunc(GL_ALWAYS, 1, -1);
-        glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
-
-        renderTextureInternalWithDamage(tex, pBox, a, &damage, round);
-
-        // then stop
-        glStencilFunc(GL_EQUAL, 1, -1);
-        glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+        // draw window
+        glDisable(GL_STENCIL_TEST);
+        renderTextureInternalWithDamage(tex, pBox, a, &damage, round, false, false, true);
     }
 
-    // disable the stencil (if no border), finalize everything
-    if (!border) {
-        glStencilMask(-1);
-        glStencilFunc(GL_ALWAYS, 1, 0xFF);
-    } else {
-        auto BORDERCOL = m_pCurrentWindow->m_cRealBorderColor.col();
-        BORDERCOL.a *= a / 255.f;
-        renderBorder(pBox, BORDERCOL, g_pConfigManager->getInt("general:border_size"), round);
-    }
-    
-    glDisable(GL_STENCIL_TEST);
+    glStencilMask(-1);
+    glStencilFunc(GL_ALWAYS, 1, 0xFF);
     pixman_region32_fini(&damage);
     scissor((wlr_box*)nullptr);
 }
@@ -627,23 +625,67 @@ void pushVert2D(float x, float y, float* arr, int& counter, wlr_box* box) {
     counter++;
 }
 
-void CHyprOpenGLImpl::renderBorder(wlr_box* box, const CColor& col, int thick, int round) {
+void CHyprOpenGLImpl::renderBorder(wlr_box* box, const CColor& col, int round) {
     RASSERT((box->width > 0 && box->height > 0), "Tried to render rect with width/height < 0!");
     RASSERT(m_RenderData.pMonitor, "Tried to render rect without begin()!");
 
-    // this method assumes a set stencil and scaled box
-    box->x -= thick;
-    box->y -= thick;
-    box->width += 2 * thick;
-    box->height += 2 * thick;
+    static auto *const PBORDERSIZE = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
+    static auto *const PMULTISAMPLE = &g_pConfigManager->getConfigValuePtr("decoration:multisample_edges")->intValue;
 
-    round += thick; // cuz yeah
+    // adjust box
+    box->x -= *PBORDERSIZE;
+    box->y -= *PBORDERSIZE;
+    box->width += 2 * *PBORDERSIZE;
+    box->height += 2 * *PBORDERSIZE;
 
-    // only draw on non-stencild.
-    glStencilFunc(GL_NOTEQUAL, 1, -1);
+    round += *PBORDERSIZE;
 
-    // draw a rounded rect
-    renderRect(box, col, round);
+    float matrix[9];
+    wlr_matrix_project_box(matrix, box, wlr_output_transform_invert(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform), 0, m_RenderData.pMonitor->output->transform_matrix);  // TODO: write own, don't use WLR here
+
+    float glMatrix[9];
+    wlr_matrix_multiply(glMatrix, m_RenderData.projection, matrix);
+    wlr_matrix_multiply(glMatrix, matrixFlip180, glMatrix);
+
+    wlr_matrix_transpose(glMatrix, glMatrix);
+
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    glUseProgram(m_shBORDER1.program);
+
+    glUniformMatrix3fv(m_shBORDER1.proj, 1, GL_FALSE, glMatrix);
+    glUniform4f(m_shBORDER1.getUniformLocation("color"), col.r / 255.f, col.g / 255.f, col.b / 255.f, col.a / 255.f);
+
+    const auto TOPLEFT = Vector2D(round, round);
+    const auto BOTTOMRIGHT = Vector2D(box->width - round, box->height - round);
+    const auto FULLSIZE = Vector2D(box->width, box->height);
+
+    glUniform2f(m_shBORDER1.getUniformLocation("topLeft"), (float)TOPLEFT.x, (float)TOPLEFT.y);
+    glUniform2f(m_shBORDER1.getUniformLocation("bottomRight"), (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
+    glUniform2f(m_shBORDER1.getUniformLocation("fullSize"), (float)FULLSIZE.x, (float)FULLSIZE.y);
+    glUniform1f(m_shBORDER1.getUniformLocation("radius"), round);
+    glUniform1f(m_shBORDER1.getUniformLocation("thick"), *PBORDERSIZE);
+    glUniform1i(m_shBORDER1.getUniformLocation("primitiveMultisample"), *PMULTISAMPLE);
+
+    glVertexAttribPointer(m_shBORDER1.posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
+    glVertexAttribPointer(m_shBORDER1.texAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
+
+    glEnableVertexAttribArray(m_shBORDER1.posAttrib);
+    glEnableVertexAttribArray(m_shBORDER1.texAttrib);
+
+    if (pixman_region32_not_empty(m_RenderData.pDamage)) {
+        PIXMAN_DAMAGE_FOREACH(m_RenderData.pDamage) {
+            const auto RECT = RECTSARR[i];
+            scissor(&RECT);
+            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+        }
+    }
+
+    glDisableVertexAttribArray(m_shBORDER1.posAttrib);
+    glDisableVertexAttribArray(m_shBORDER1.texAttrib);
+
+    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 }
 
 void CHyprOpenGLImpl::makeWindowSnapshot(CWindow* pWindow) {
@@ -692,7 +734,7 @@ void CHyprOpenGLImpl::makeWindowSnapshot(CWindow* pWindow) {
     clear(CColor(0, 0, 0, 0));  // JIC
 
     wlr_box fullMonBox = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
-    renderTexture(m_mMonitorRenderResources[m_RenderData.pMonitor].primaryFB.m_cTex, &fullMonBox, 255.f, 0);
+    renderTexture(m_RenderData.pCurrentMonData->primaryFB.m_cTex, &fullMonBox, 255.f, 0);
 
     // restore original fb
     #ifndef GLES2
@@ -771,12 +813,13 @@ void CHyprOpenGLImpl::renderSnapshot(CWindow** pWindow) {
 
     wlr_box windowBox;
     // some mafs to figure out the correct box
-    Vector2D scaleXY = Vector2D((PWINDOW->m_vRealSize.vec().x / PWINDOW->m_vOriginalClosedSize.x), (PWINDOW->m_vRealSize.vec().y / PWINDOW->m_vOriginalClosedSize.y));
+    // the originalClosedPos is relative to the monitor's pos
+    Vector2D scaleXY = Vector2D((PMONITOR->scale * PWINDOW->m_vRealSize.vec().x / (PWINDOW->m_vOriginalClosedSize.x * PMONITOR->scale)), (PMONITOR->scale * PWINDOW->m_vRealSize.vec().y / (PWINDOW->m_vOriginalClosedSize.y * PMONITOR->scale)));
 
     windowBox.width = PMONITOR->vecPixelSize.x * scaleXY.x;
     windowBox.height = PMONITOR->vecPixelSize.y * scaleXY.y;
-    windowBox.x = (PWINDOW->m_vRealPosition.vec().x - PMONITOR->vecPosition.x) - ((PWINDOW->m_vOriginalClosedPos.x - PMONITOR->vecPosition.x) * scaleXY.x);
-    windowBox.y = (PWINDOW->m_vRealPosition.vec().y - PMONITOR->vecPosition.y) - ((PWINDOW->m_vOriginalClosedPos.y - PMONITOR->vecPosition.y) * scaleXY.y);
+    windowBox.x = ((PWINDOW->m_vRealPosition.vec().x - PMONITOR->vecPosition.x) * PMONITOR->scale) - ((PWINDOW->m_vOriginalClosedPos.x * PMONITOR->scale) * scaleXY.x);
+    windowBox.y = ((PWINDOW->m_vRealPosition.vec().y - PMONITOR->vecPosition.y) * PMONITOR->scale) - ((PWINDOW->m_vOriginalClosedPos.y * PMONITOR->scale) * scaleXY.y);
 
     pixman_region32_t fakeDamage;
     pixman_region32_init_rect(&fakeDamage, 0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
@@ -812,6 +855,66 @@ void CHyprOpenGLImpl::renderSnapshot(SLayerSurface** pLayer) {
     pixman_region32_fini(&fakeDamage);
 }
 
+void CHyprOpenGLImpl::renderRoundedShadow(wlr_box* box, int round, int range, float a) {
+    RASSERT(m_RenderData.pMonitor, "Tried to render shadow without begin()!");
+    RASSERT((box->width > 0 && box->height > 0), "Tried to render shadow with width/height < 0!");
+
+    static auto *const PSHADOWCOL = &g_pConfigManager->getConfigValuePtr("decoration:col.shadow")->intValue;
+    static auto *const PSHADOWPOWER = &g_pConfigManager->getConfigValuePtr("decoration:shadow_render_power")->intValue;
+
+    const auto SHADOWPOWER = std::clamp((int)*PSHADOWPOWER, 1, 4);
+
+    const auto col = CColor(*PSHADOWCOL);
+
+    float matrix[9];
+    wlr_matrix_project_box(matrix, box, wlr_output_transform_invert(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform), 0, m_RenderData.pMonitor->output->transform_matrix);  // TODO: write own, don't use WLR here
+
+    float glMatrix[9];
+    wlr_matrix_multiply(glMatrix, m_RenderData.projection, matrix);
+    wlr_matrix_multiply(glMatrix, matrixFlip180, glMatrix);
+
+    wlr_matrix_transpose(glMatrix, glMatrix);
+
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    glUseProgram(m_shSHADOW.program);
+
+    glUniformMatrix3fv(m_shSHADOW.proj, 1, GL_FALSE, glMatrix);
+    glUniform4f(m_shSHADOW.getUniformLocation("color"), col.r / 255.f, col.g / 255.f, col.b / 255.f, col.a / 255.f * a);
+
+    const auto TOPLEFT = Vector2D(range + round, range + round);
+    const auto BOTTOMRIGHT = Vector2D(box->width - (range + round), box->height - (range + round));
+    const auto FULLSIZE = Vector2D(box->width, box->height);
+
+    // Rounded corners
+    glUniform2f(m_shSHADOW.getUniformLocation("topLeft"), (float)TOPLEFT.x, (float)TOPLEFT.y);
+    glUniform2f(m_shSHADOW.getUniformLocation("bottomRight"), (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
+    glUniform2f(m_shSHADOW.getUniformLocation("fullSize"), (float)FULLSIZE.x, (float)FULLSIZE.y);
+    glUniform1f(m_shSHADOW.getUniformLocation("radius"), range + round);
+    glUniform1f(m_shSHADOW.getUniformLocation("range"), range);
+    glUniform1f(m_shSHADOW.getUniformLocation("shadowPower"), SHADOWPOWER);
+
+    glVertexAttribPointer(m_shSHADOW.posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
+    glVertexAttribPointer(m_shSHADOW.texAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
+
+    glEnableVertexAttribArray(m_shSHADOW.posAttrib);
+    glEnableVertexAttribArray(m_shSHADOW.texAttrib);
+
+    if (pixman_region32_not_empty(m_RenderData.pDamage)) {
+        PIXMAN_DAMAGE_FOREACH(m_RenderData.pDamage) {
+            const auto RECT = RECTSARR[i];
+            scissor(&RECT);
+            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+        }
+    }
+
+    glDisableVertexAttribArray(m_shSHADOW.posAttrib);
+    glDisableVertexAttribArray(m_shSHADOW.texAttrib);
+
+    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+}
+
 void CHyprOpenGLImpl::createBGTextureForMonitor(SMonitor* pMonitor) {
     RASSERT(m_RenderData.pMonitor, "Tried to createBGTex without begin()!");
 

src/render/OpenGL.hpp

@@ -29,13 +29,6 @@ inline const float fanVertsFull[] = {
     -1.0f, 1.0f
 };
 
-struct SCurrentRenderData {
-    SMonitor*   pMonitor = nullptr;
-    float       projection[9];
-
-    pixman_region32_t* pDamage = nullptr;
-};
-
 struct SMonitorRenderData {
     CFramebuffer primaryFB;
     CFramebuffer mirrorFB;
@@ -44,6 +37,18 @@ struct SMonitorRenderData {
     CTexture     stencilTex;
 };
 
+struct SCurrentRenderData {
+    SMonitor*   pMonitor = nullptr;
+    float       projection[9];
+
+    SMonitorRenderData* pCurrentMonData = nullptr;
+
+    pixman_region32_t* pDamage = nullptr;
+
+    Vector2D    primarySurfaceUVTopLeft = Vector2D(-1, -1);
+    Vector2D    primarySurfaceUVBottomRight = Vector2D(-1, -1);
+};
+
 class CHyprOpenGLImpl {
 public:
 
@@ -53,9 +58,12 @@ public:
     void    end();
 
     void    renderRect(wlr_box*, const CColor&, int round = 0);
-    void    renderTexture(wlr_texture*, wlr_box*, float a, int round = 0);
-    void    renderTexture(const CTexture&, wlr_box*, float a, int round = 0, bool discardOpaque = false, bool border = false);
-    void    renderTextureWithBlur(const CTexture&, wlr_box*, float a, wlr_surface* pSurface, int round = 0, bool border = false);
+    void    renderRectWithDamage(wlr_box*, const CColor&, pixman_region32_t* damage, int round = 0);
+    void    renderTexture(wlr_texture*, wlr_box*, float a, int round = 0, bool allowCustomUV = false);
+    void    renderTexture(const CTexture&, wlr_box*, float a, int round = 0, bool discardOpaque = false, bool allowCustomUV = false);
+    void    renderTextureWithBlur(const CTexture&, wlr_box*, float a, wlr_surface* pSurface, int round = 0);
+    void    renderRoundedShadow(wlr_box*, int round, int range, float a = 1.0);
+    void    renderBorder(wlr_box*, const CColor&, int round);
 
     void    makeWindowSnapshot(CWindow*);
     void    makeLayerSnapshot(SLayerSurface*);
@@ -95,12 +103,14 @@ private:
     bool                    m_bEndFrame = false;
 
     // Shaders
-    SQuad                   m_shQUAD;
+    CShader                 m_shQUAD;
     CShader                 m_shRGBA;
     CShader                 m_shRGBX;
     CShader                 m_shEXT;
     CShader                 m_shBLUR1;
     CShader                 m_shBLUR2;
+    CShader                 m_shSHADOW;
+    CShader                 m_shBORDER1;
     //
 
     GLuint                  createProgram(const std::string&, const std::string&);
@@ -110,8 +120,7 @@ private:
     // returns the out FB, can be either Mirror or MirrorSwap
     CFramebuffer*           blurMainFramebufferWithDamage(float a, wlr_box* pBox, pixman_region32_t* damage);
 
-    void                    renderTextureInternalWithDamage(const CTexture&, wlr_box* pBox, float a, pixman_region32_t* damage, int round = 0, bool discardOpaque = false, bool border = false);
-    void                    renderBorder(wlr_box*, const CColor&, int thick = 1, int round = 0);
+    void                    renderTextureInternalWithDamage(const CTexture&, wlr_box* pBox, float a, pixman_region32_t* damage, int round = 0, bool discardOpaque = false, bool noAA = false, bool allowCustomUV = false);
 };
 
 inline std::unique_ptr<CHyprOpenGLImpl> g_pHyprOpenGL;

src/render/Renderer.cpp

@@ -12,27 +12,45 @@ void renderSurface(struct wlr_surface* surface, int x, int y, void* data) {
     wlr_output_layout_output_coords(g_pCompositor->m_sWLROutputLayout, RDATA->output, &outputX, &outputY);
 
     wlr_box windowBox;
-    if (RDATA->surface && surface == RDATA->surface) {
+    if (RDATA->surface && surface == RDATA->surface)
         windowBox = {(int)outputX + RDATA->x + x, (int)outputY + RDATA->y + y, RDATA->w, RDATA->h};
-    } else {                                                                                                //  here we clamp to 2, these might be some tiny specks
+    else                                                                                              //  here we clamp to 2, these might be some tiny specks
         windowBox = {(int)outputX + RDATA->x + x, (int)outputY + RDATA->y + y, std::clamp(surface->current.width, 2, 1337420), std::clamp(surface->current.height, 2, 1337420)};
-    }
     scaleBox(&windowBox, RDATA->output->scale);
 
-    float rounding = RDATA->dontRound ? 0 : RDATA->rounding == -1 ? g_pConfigManager->getInt("decoration:rounding") : RDATA->rounding;
+    static auto *const PROUNDING = &g_pConfigManager->getConfigValuePtr("decoration:rounding")->intValue;
 
-    if (RDATA->surface && surface == RDATA->surface)
-        g_pHyprOpenGL->renderTextureWithBlur(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, surface, rounding, RDATA->decorate);
-    else
-        g_pHyprOpenGL->renderTexture(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, rounding, false, false);
+    float rounding = RDATA->dontRound ? 0 : RDATA->rounding == -1 ? *PROUNDING : RDATA->rounding;
+
+    if (RDATA->surface && surface == RDATA->surface) {
+        g_pHyprOpenGL->renderTextureWithBlur(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, surface, rounding);
+
+        if (RDATA->decorate) {
+            auto col = g_pHyprOpenGL->m_pCurrentWindow->m_cRealBorderColor.col();
+            col.a *= RDATA->fadeAlpha * RDATA->alpha / 255.f;
+            g_pHyprOpenGL->renderBorder(&windowBox, col, rounding);
+        }
+    }
+    else {
+        if (RDATA->surface && wlr_surface_is_xdg_surface(RDATA->surface)) {
+            wlr_box geo;
+            wlr_xdg_surface_get_geometry(wlr_xdg_surface_from_wlr_surface(RDATA->surface), &geo);
+
+            windowBox.x -= geo.x;
+            windowBox.y -= geo.y;
+        }
+
+        g_pHyprOpenGL->renderTexture(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, rounding, false);
+    }
+        
 
     wlr_surface_send_frame_done(surface, RDATA->when);
 
     wlr_presentation_surface_sampled_on_output(g_pCompositor->m_sWLRPresentation, surface, RDATA->output);
 }
 
-bool shouldRenderWindow(CWindow* pWindow, SMonitor* pMonitor) {
-    wlr_box geometry = {pWindow->m_vRealPosition.vec().x, pWindow->m_vRealPosition.vec().y, pWindow->m_vRealSize.vec().x, pWindow->m_vRealSize.vec().y};
+bool CHyprRenderer::shouldRenderWindow(CWindow* pWindow, SMonitor* pMonitor) {
+    wlr_box geometry = pWindow->getFullWindowBoundingBox();
 
     if (!wlr_output_layout_intersects(g_pCompositor->m_sWLROutputLayout, pMonitor->output, &geometry))
         return false;
@@ -46,28 +64,67 @@ bool shouldRenderWindow(CWindow* pWindow, SMonitor* pMonitor) {
     if (g_pCompositor->isWorkspaceVisible(pWindow->m_iWorkspaceID) || (PWORKSPACE && PWORKSPACE->m_iMonitorID == pMonitor->ID && (PWORKSPACE->m_vRenderOffset.isBeingAnimated() || PWORKSPACE->m_fAlpha.isBeingAnimated())))
         return true;
 
+    if (pMonitor->specialWorkspaceOpen && pWindow->m_iWorkspaceID == SPECIAL_WORKSPACE_ID)
+        return true;
+
+    return false;
+}
+
+bool CHyprRenderer::shouldRenderWindow(CWindow* pWindow) {
+
+    if (!g_pCompositor->windowValidMapped(pWindow))
+        return false;
+
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(pWindow->m_iWorkspaceID);
+
+    if (g_pCompositor->isWorkspaceVisible(pWindow->m_iWorkspaceID))
+        return true;
+
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        if (PWORKSPACE && PWORKSPACE->m_iMonitorID == m->ID && (PWORKSPACE->m_vRenderOffset.isBeingAnimated() || PWORKSPACE->m_fAlpha.isBeingAnimated()))
+            return true;
+
+        if (m->specialWorkspaceOpen && pWindow->m_iWorkspaceID == SPECIAL_WORKSPACE_ID)
+            return true;
+    }
+
     return false;
 }
 
 void CHyprRenderer::renderWorkspaceWithFullscreenWindow(SMonitor* pMonitor, CWorkspace* pWorkspace, timespec* time) {
     CWindow* pWorkspaceWindow = nullptr;
 
-    for (auto& w : g_pCompositor->m_lWindows) {
-        if (w.m_iWorkspaceID != pWorkspace->m_iID || !w.m_bIsFullscreen)
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (w->m_iWorkspaceID != pWorkspace->m_iID || !w->m_bIsFullscreen)
             continue;
 
         // found it!
-        renderWindow(&w, pMonitor, time, pWorkspace->m_efFullscreenMode != FULLSCREEN_FULL);
+        renderWindow(w.get(), pMonitor, time, pWorkspace->m_efFullscreenMode != FULLSCREEN_FULL);
 
-        pWorkspaceWindow = &w;
+        pWorkspaceWindow = w.get();
     }
 
     // then render windows over fullscreen
-    for (auto& w : g_pCompositor->m_lWindows) {
-        if (w.m_iWorkspaceID != pWorkspaceWindow->m_iWorkspaceID || !w.m_bCreatedOverFullscreen || !w.m_bIsMapped)
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (w->m_iWorkspaceID != pWorkspaceWindow->m_iWorkspaceID || !w->m_bCreatedOverFullscreen || !w->m_bIsMapped)
             continue;
 
-        renderWindow(&w, pMonitor, time, true);
+        renderWindow(w.get(), pMonitor, time, true);
+    }
+
+    // and then special windows
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (!g_pCompositor->windowValidMapped(w.get()) && !w->m_bFadingOut)
+            continue;
+
+        if (w->m_iWorkspaceID != SPECIAL_WORKSPACE_ID)
+            continue;
+
+        if (!shouldRenderWindow(w.get(), pMonitor))
+            continue;
+
+        // render the bad boy
+        renderWindow(w.get(), pMonitor, time, true);
     }
 
     // and the overlay layers
@@ -85,7 +142,7 @@ void CHyprRenderer::renderWorkspaceWithFullscreenWindow(SMonitor* pMonitor, CWor
     renderDragIcon(pMonitor, time);
 
     // if correct monitor draw hyprerror
-    if (pMonitor == &g_pCompositor->m_lMonitors.front())
+    if (pMonitor == g_pCompositor->m_vMonitors.front().get())
         g_pHyprError->draw();
 }
 
@@ -101,6 +158,8 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, SMonitor* pMonitor, timespec*
     
     const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(pWindow->m_iWorkspaceID);
     const auto REALPOS = pWindow->m_vRealPosition.vec() + PWORKSPACE->m_vRenderOffset.vec();
+    static const auto PNOFLOATINGBORDERS = &g_pConfigManager->getConfigValuePtr("general:no_border_on_floating")->intValue;
+
     SRenderData renderdata = {pMonitor->output, time, REALPOS.x, REALPOS.y};
     renderdata.surface = g_pXWaylandManager->getWindowSurface(pWindow);
     renderdata.w = std::clamp(pWindow->m_vRealSize.vec().x, (double)5, (double)1337420); // clamp the size to min 5,
@@ -108,26 +167,44 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, SMonitor* pMonitor, timespec*
     renderdata.dontRound = pWindow->m_bIsFullscreen && PWORKSPACE->m_efFullscreenMode == FULLSCREEN_FULL;
     renderdata.fadeAlpha = pWindow->m_fAlpha.fl() * (PWORKSPACE->m_fAlpha.fl() / 255.f);
     renderdata.alpha = pWindow->m_bIsFullscreen ? g_pConfigManager->getFloat("decoration:fullscreen_opacity") : pWindow == g_pCompositor->m_pLastWindow ? g_pConfigManager->getFloat("decoration:active_opacity") : g_pConfigManager->getFloat("decoration:inactive_opacity");
-    renderdata.decorate = decorate && !pWindow->m_bX11DoesntWantBorders;
+    renderdata.decorate = decorate && !pWindow->m_bX11DoesntWantBorders && (pWindow->m_bIsFloating ? *PNOFLOATINGBORDERS == 0 : true) && (!pWindow->m_bIsFullscreen || PWORKSPACE->m_efFullscreenMode != FULLSCREEN_FULL);
     renderdata.rounding = pWindow->m_sAdditionalConfigData.rounding;
 
     // apply window special data
-    renderdata.alpha *= pWindow->m_sSpecialRenderData.alpha;
+    if (pWindow->m_sSpecialRenderData.alphaInactive == -1)
+        renderdata.alpha *= pWindow->m_sSpecialRenderData.alpha;
+    else
+        renderdata.alpha *= pWindow == g_pCompositor->m_pLastWindow ? pWindow->m_sSpecialRenderData.alpha : pWindow->m_sSpecialRenderData.alphaInactive;
 
     g_pHyprOpenGL->m_pCurrentWindow = pWindow;
 
-    // render window decorations first
-    for (auto& wd : pWindow->m_dWindowDecorations)
-        wd->draw(pMonitor);
+    // render window decorations first, if not fullscreen full
+    if (!pWindow->m_bIsFullscreen || PWORKSPACE->m_efFullscreenMode != FULLSCREEN_FULL) for (auto& wd : pWindow->m_dWindowDecorations)
+        wd->draw(pMonitor, renderdata.alpha * renderdata.fadeAlpha / 255.f);
+
+    if (!pWindow->m_bIsX11) {
+        wlr_box geom;
+        wlr_xdg_surface_get_geometry(pWindow->m_uSurface.xdg, &geom);
+
+        g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = Vector2D((double)geom.x / (double)pWindow->m_uSurface.xdg->surface->current.width, (double)geom.y / (double)pWindow->m_uSurface.xdg->surface->current.height);
+        g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = Vector2D((double)(geom.width + geom.x) / (double)pWindow->m_uSurface.xdg->surface->current.width, (double)(geom.y + geom.height) / (double)pWindow->m_uSurface.xdg->surface->current.height);
+        
+        if (g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft == Vector2D() && g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight == Vector2D(1, 1)) {
+            // No special UV mods needed
+            g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
+            g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
+        }
+    } else {
+        g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
+        g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
+    }
 
     wlr_surface_for_each_surface(g_pXWaylandManager->getWindowSurface(pWindow), renderSurface, &renderdata);
 
-    if (pWindow->m_bIsX11) {
-        if (pWindow->m_uSurface.xwayland->surface) {
-            wlr_surface_for_each_surface(pWindow->m_uSurface.xwayland->surface, renderSurface, &renderdata);
-        }
-    }
-    else {
+    g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
+    g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
+
+    if (!pWindow->m_bIsX11) {
         renderdata.dontRound = false; // restore dontround
         renderdata.pMonitor = pMonitor;
         wlr_xdg_surface_for_each_popup_surface(pWindow->m_uSurface.xdg, renderSurface, &renderdata);
@@ -171,33 +248,54 @@ void CHyprRenderer::renderAllClientsForMonitor(const int& ID, timespec* time) {
     }
 
     // Non-floating
-    for (auto& w : g_pCompositor->m_lWindows) {
-        if (!g_pCompositor->windowValidMapped(&w) && !w.m_bFadingOut)
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (w->m_bHidden && !w->m_bIsMapped && !w->m_bFadingOut)
             continue;
 
-        if (w.m_bIsFloating)
-            continue;  // floating are in second pass
+        if (w->m_bIsFloating)
+            continue;  // floating are in the second pass
 
-        if (!shouldRenderWindow(&w, PMONITOR))
+        if (w->m_iWorkspaceID == SPECIAL_WORKSPACE_ID)
+            continue; // special are in the third pass
+
+        if (!shouldRenderWindow(w.get(), PMONITOR))
             continue;
 
         // render the bad boy
-        renderWindow(&w, PMONITOR, time, true);
+        renderWindow(w.get(), PMONITOR, time, true);
     }
 
     // floating on top
-    for (auto& w : g_pCompositor->m_lWindows) {
-        if (!g_pCompositor->windowValidMapped(&w) && !w.m_bFadingOut)
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (w->m_bHidden && !w->m_bIsMapped && !w->m_bFadingOut)
             continue;
 
-        if (!w.m_bIsFloating)
+        if (!w->m_bIsFloating)
             continue;
 
-        if (!shouldRenderWindow(&w, PMONITOR))
+        if (w->m_iWorkspaceID == SPECIAL_WORKSPACE_ID)
+            continue;
+
+        if (!shouldRenderWindow(w.get(), PMONITOR))
             continue;
 
         // render the bad boy
-        renderWindow(&w, PMONITOR, time, true);
+        renderWindow(w.get(), PMONITOR, time, true);
+    }
+
+    // and then special
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (w->m_bHidden && !w->m_bIsMapped && !w->m_bFadingOut)
+            continue;
+            
+        if (w->m_iWorkspaceID != SPECIAL_WORKSPACE_ID)
+            continue;
+
+        if (!shouldRenderWindow(w.get(), PMONITOR))
+            continue;
+
+        // render the bad boy
+        renderWindow(w.get(), PMONITOR, time, true);
     }
 
     // Render surfaces above windows for monitor
@@ -334,7 +432,7 @@ void CHyprRenderer::arrangeLayerArray(SMonitor* pMonitor, const std::list<SLayer
     wlr_box full_area = {pMonitor->vecPosition.x, pMonitor->vecPosition.y, pMonitor->vecSize.x, pMonitor->vecSize.y};
 
     for (auto& ls : layerSurfaces) {
-        if (ls->fadingOut || ls->readyToDelete)
+        if (ls->fadingOut || ls->readyToDelete || !ls->layerSurface)
             continue;
 
         const auto PLAYER = ls->layerSurface;
@@ -457,72 +555,69 @@ void CHyprRenderer::damageSurface(wlr_surface* pSurface, double x, double y) {
     pixman_region32_init(&damageBox);
     wlr_surface_get_effective_damage(pSurface, &damageBox);
 
+    // schedule frame events
+    if (!wl_list_empty(&pSurface->current.frame_callback_list)) {
+        wlr_output_schedule_frame(g_pCompositor->getMonitorFromVector(Vector2D(x, y))->output);
+    }
+
+    if (!pixman_region32_not_empty(&damageBox)) {
+        pixman_region32_fini(&damageBox);
+        return;
+    }
+
     pixman_region32_translate(&damageBox, x, y);
 
-    for (auto& m : g_pCompositor->m_lMonitors) {
+    for (auto& m : g_pCompositor->m_vMonitors) {
         double lx = 0, ly = 0;
-        wlr_output_layout_output_coords(g_pCompositor->m_sWLROutputLayout, m.output, &lx, &ly);
+        wlr_output_layout_output_coords(g_pCompositor->m_sWLROutputLayout, m->output, &lx, &ly);
         pixman_region32_translate(&damageBox, lx, ly);
-        wlr_region_scale(&damageBox, &damageBox, m.scale);
-        wlr_output_damage_add(m.damage, &damageBox);
+        wlr_region_scale(&damageBox, &damageBox, m->scale);
+        wlr_output_damage_add(m->damage, &damageBox);
         pixman_region32_translate(&damageBox, -lx, -ly);
     }
 
     pixman_region32_fini(&damageBox);
 
-    if (g_pConfigManager->getInt("debug:log_damage"))
+    static auto *const PLOGDAMAGE = &g_pConfigManager->getConfigValuePtr("debug:log_damage")->intValue;
+
+    if (*PLOGDAMAGE)
         Debug::log(LOG, "Damage: Surface (extents): xy: %d, %d wh: %d, %d", damageBox.extents.x1, damageBox.extents.y1, damageBox.extents.x2 - damageBox.extents.x1, damageBox.extents.y2 - damageBox.extents.y1);
 }
 
 void CHyprRenderer::damageWindow(CWindow* pWindow) {
-    if (!pWindow->m_bIsFloating) {
-        // damage by size & pos
-        // TODO TEMP: revise when added shadows/etc
-
-        wlr_box damageBox = {pWindow->m_vRealPosition.vec().x, pWindow->m_vRealPosition.vec().y, pWindow->m_vRealSize.vec().x, pWindow->m_vRealSize.vec().y};
-        for (auto& m : g_pCompositor->m_lMonitors) {
-            wlr_box fixedDamageBox = damageBox;
-            fixedDamageBox.x -= m.vecPosition.x;
-            fixedDamageBox.y -= m.vecPosition.y;
-            scaleBox(&fixedDamageBox, m.scale);
-            wlr_output_damage_add_box(m.damage, &fixedDamageBox);
-        }
-
-        if (g_pConfigManager->getInt("debug:log_damage"))
-            Debug::log(LOG, "Damage: Window floated (%s): xy: %d, %d wh: %d, %d", pWindow->m_szTitle.c_str(), damageBox.x, damageBox.y, damageBox.width, damageBox.height);
-    } else {
-        // damage by real size & pos + border size * 2 (JIC)
-        const auto BORDERSIZE = g_pConfigManager->getInt("general:border_size");
-        wlr_box damageBox = { pWindow->m_vRealPosition.vec().x - BORDERSIZE - 1, pWindow->m_vRealPosition.vec().y - BORDERSIZE - 1, pWindow->m_vRealSize.vec().x + 2 * BORDERSIZE + 2, pWindow->m_vRealSize.vec().y + 2 * BORDERSIZE + 2};
-        for (auto& m : g_pCompositor->m_lMonitors) {
-            wlr_box fixedDamageBox = damageBox;
-            fixedDamageBox.x -= m.vecPosition.x;
-            fixedDamageBox.y -= m.vecPosition.y;
-            scaleBox(&fixedDamageBox, m.scale);
-            wlr_output_damage_add_box(m.damage, &fixedDamageBox);
-        }
-
-        if (g_pConfigManager->getInt("debug:log_damage"))
-            Debug::log(LOG, "Damage: Window tiled (%s): xy: %d, %d wh: %d, %d", pWindow->m_szTitle.c_str(), damageBox.x, damageBox.y, damageBox.width, damageBox.height);
+    wlr_box damageBox = pWindow->getFullWindowBoundingBox();
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        wlr_box fixedDamageBox = {damageBox.x - m->vecPosition.x, damageBox.y - m->vecPosition.y, damageBox.width, damageBox.height};
+        scaleBox(&fixedDamageBox, m->scale);
+        wlr_output_damage_add_box(m->damage, &fixedDamageBox);
     }
+
+    static auto* const PLOGDAMAGE = &g_pConfigManager->getConfigValuePtr("debug:log_damage")->intValue;
+
+    if (*PLOGDAMAGE)
+        Debug::log(LOG, "Damage: Window (%s): xy: %d, %d wh: %d, %d", pWindow->m_szTitle.c_str(), damageBox.x, damageBox.y, damageBox.width, damageBox.height);
 }
 
 void CHyprRenderer::damageMonitor(SMonitor* pMonitor) {
     wlr_box damageBox = {0, 0, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y};
     wlr_output_damage_add_box(pMonitor->damage, &damageBox);
 
-    if (g_pConfigManager->getInt("debug:log_damage"))
+    static auto *const PLOGDAMAGE = &g_pConfigManager->getConfigValuePtr("debug:log_damage")->intValue;
+
+    if (*PLOGDAMAGE)
         Debug::log(LOG, "Damage: Monitor %s", pMonitor->szName.c_str());
 }
 
 void CHyprRenderer::damageBox(wlr_box* pBox) {
-    for (auto& m : g_pCompositor->m_lMonitors) {
-        wlr_box damageBox = {pBox->x - m.vecPosition.x, pBox->y - m.vecPosition.y, pBox->width, pBox->height};
-        scaleBox(&damageBox, m.scale);
-        wlr_output_damage_add_box(m.damage, &damageBox);
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        wlr_box damageBox = {pBox->x - m->vecPosition.x, pBox->y - m->vecPosition.y, pBox->width, pBox->height};
+        scaleBox(&damageBox, m->scale);
+        wlr_output_damage_add_box(m->damage, &damageBox);
     }
 
-    if (g_pConfigManager->getInt("debug:log_damage"))
+    static auto *const PLOGDAMAGE = &g_pConfigManager->getConfigValuePtr("debug:log_damage")->intValue;
+
+    if (*PLOGDAMAGE)
         Debug::log(LOG, "Damage: Box: xy: %d, %d wh: %d, %d", pBox->x, pBox->y, pBox->width, pBox->height);
 }
 
@@ -541,6 +636,9 @@ void CHyprRenderer::renderDragIcon(SMonitor* pMonitor, timespec* time) {
     renderdata.h = g_pInputManager->m_sDrag.dragIcon->surface->current.height;
 
     wlr_surface_for_each_surface(g_pInputManager->m_sDrag.dragIcon->surface, renderSurface, &renderdata);
+
+    wlr_box box = {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};
+    g_pHyprRenderer->damageBox(&box);
 }
 
 DAMAGETRACKINGMODES CHyprRenderer::damageTrackingModeFromStr(const std::string& mode) {
@@ -554,14 +652,23 @@ DAMAGETRACKINGMODES CHyprRenderer::damageTrackingModeFromStr(const std::string&
     return DAMAGE_TRACKING_INVALID;
 }
 
-void CHyprRenderer::applyMonitorRule(SMonitor* pMonitor, SMonitorRule* pMonitorRule, bool force) {
+bool CHyprRenderer::applyMonitorRule(SMonitor* pMonitor, SMonitorRule* pMonitorRule, bool force) {
 
     Debug::log(LOG, "Applying monitor rule for %s", pMonitor->szName.c_str());
 
+    // if it's disabled, disable and ignore
+    if (pMonitorRule->disabled) {
+        wlr_output_enable(pMonitor->output, 0);
+        wlr_output_commit(pMonitor->output);
+
+        Events::listener_monitorDestroy(nullptr, pMonitor->output);
+        return false;
+    }
+
     // Check if the rule isn't already applied
     if (!force && DELTALESSTHAN(pMonitor->vecPixelSize.x, pMonitorRule->resolution.x, 1) && DELTALESSTHAN(pMonitor->vecPixelSize.y, pMonitorRule->resolution.y, 1) && DELTALESSTHAN(pMonitor->refreshRate, pMonitorRule->refreshRate, 1) && pMonitor->scale == pMonitorRule->scale && DELTALESSTHAN(pMonitor->vecPosition.x, pMonitorRule->offset.x, 1) && DELTALESSTHAN(pMonitor->vecPosition.y, pMonitorRule->offset.y, 1) && pMonitor->transform == pMonitorRule->transform) {
         Debug::log(LOG, "Not applying a new rule to %s because it's already applied!", pMonitor->szName.c_str());
-        return;
+        return true;
     }
 
     wlr_output_set_scale(pMonitor->output, pMonitorRule->scale);
@@ -600,23 +707,32 @@ void CHyprRenderer::applyMonitorRule(SMonitor* pMonitor, SMonitorRule* pMonitorR
         }
 
         if (!found) {
-            const auto PREFERREDMODE = wlr_output_preferred_mode(pMonitor->output);
+            wlr_output_set_custom_mode(pMonitor->output, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (int)pMonitorRule->refreshRate * 1000);
+            pMonitor->vecSize = pMonitorRule->resolution;
 
-            if (!PREFERREDMODE) {
-                Debug::log(ERR, "Monitor %s has NO PREFERRED MODE, and an INVALID one was requested: %ix%i@%2f",
-                           (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate);
-                return;
+            if (!wlr_output_test(pMonitor->output)) {
+                Debug::log(ERR, "Custom resolution FAILED, falling back to preferred");
+
+                const auto PREFERREDMODE = wlr_output_preferred_mode(pMonitor->output);
+
+                if (!PREFERREDMODE) {
+                    Debug::log(ERR, "Monitor %s has NO PREFERRED MODE, and an INVALID one was requested: %ix%i@%2f",
+                               (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate);
+                    return true;
+                }
+
+                // Preferred is valid
+                wlr_output_set_mode(pMonitor->output, PREFERREDMODE);
+
+                Debug::log(ERR, "Monitor %s got an invalid requested mode: %ix%i@%2f, using the preferred one instead: %ix%i@%2f",
+                           pMonitor->output->name, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate,
+                           PREFERREDMODE->width, PREFERREDMODE->height, PREFERREDMODE->refresh / 1000.f);
+
+                pMonitor->refreshRate = PREFERREDMODE->refresh / 1000.f;
+                pMonitor->vecSize = Vector2D(PREFERREDMODE->width, PREFERREDMODE->height);
+            } else {
+                Debug::log(LOG, "Set a custom mode %ix%i@%2f (mode not found in monitor modes)", (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate);
             }
-
-            // Preferred is valid
-            wlr_output_set_mode(pMonitor->output, PREFERREDMODE);
-
-            Debug::log(ERR, "Monitor %s got an invalid requested mode: %ix%i@%2f, using the preferred one instead: %ix%i@%2f",
-                       pMonitor->output->name, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate,
-                       PREFERREDMODE->width, PREFERREDMODE->height, PREFERREDMODE->refresh / 1000.f);
-
-            pMonitor->refreshRate = PREFERREDMODE->refresh / 1000.f;
-            pMonitor->vecSize = Vector2D(PREFERREDMODE->width, PREFERREDMODE->height);
         }
     } else {
         wlr_output_set_custom_mode(pMonitor->output, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (int)pMonitorRule->refreshRate * 1000);
@@ -633,7 +749,7 @@ void CHyprRenderer::applyMonitorRule(SMonitor* pMonitor, SMonitorRule* pMonitorR
 
     if (!wlr_output_commit(pMonitor->output)) {
         Debug::log(ERR, "Couldn't commit output named %s", pMonitor->output->name);
-        return;
+        return true;
     }
 
     int x, y;
@@ -654,5 +770,42 @@ void CHyprRenderer::applyMonitorRule(SMonitor* pMonitor, SMonitorRule* pMonitorR
     arrangeLayersForMonitor(pMonitor->ID);
 
     // frame skip
-    pMonitor->needsFrameSkip = true;
+    pMonitor->framesToSkip = 1;
+
+    return true;
 }
+
+void CHyprRenderer::ensureCursorRenderingMode() {
+    static auto *const PCURSORTIMEOUT = &g_pConfigManager->getConfigValuePtr("general:cursor_inactive_timeout")->intValue;
+
+    const auto PASSEDCURSORSECONDS = g_pInputManager->m_tmrLastCursorMovement.getSeconds();
+
+    if (*PCURSORTIMEOUT > 0) {
+        if (*PCURSORTIMEOUT < PASSEDCURSORSECONDS && m_bHasARenderedCursor) {
+            m_bHasARenderedCursor = false;
+
+            wlr_cursor_set_surface(g_pCompositor->m_sWLRCursor, nullptr, 0, 0); // hide
+
+            Debug::log(LOG, "Hiding the cursor (timeout)");
+
+            for (auto& m : g_pCompositor->m_vMonitors)
+                g_pHyprRenderer->damageMonitor(m.get());  // TODO: maybe just damage the cursor area?
+        } else if (*PCURSORTIMEOUT > PASSEDCURSORSECONDS && !m_bHasARenderedCursor) {
+            m_bHasARenderedCursor = true;
+
+            if (!m_bWindowRequestedCursorHide)
+                wlr_xcursor_manager_set_cursor_image(g_pCompositor->m_sWLRXCursorMgr, "left_ptr", g_pCompositor->m_sWLRCursor);
+
+            Debug::log(LOG, "Showing the cursor (timeout)");
+
+            for (auto& m : g_pCompositor->m_vMonitors)
+                g_pHyprRenderer->damageMonitor(m.get());  // TODO: maybe just damage the cursor area?
+        }
+    } else {
+        m_bHasARenderedCursor = true;
+    }
+}
+
+bool CHyprRenderer::shouldRenderCursor() {
+    return m_bHasARenderedCursor;
+}

src/render/Renderer.hpp

@@ -28,7 +28,13 @@ public:
     void                damageBox(wlr_box*);
     void                damageBox(const int& x, const int& y, const int& w, const int& h);
     void                damageMonitor(SMonitor*);
-    void                applyMonitorRule(SMonitor*, SMonitorRule*, bool force = false);
+    bool                applyMonitorRule(SMonitor*, SMonitorRule*, bool force = false);
+    bool                shouldRenderWindow(CWindow*, SMonitor*);
+    bool                shouldRenderWindow(CWindow*);
+    void                ensureCursorRenderingMode();
+    bool                shouldRenderCursor();
+
+    bool                m_bWindowRequestedCursorHide = false;
 
     DAMAGETRACKINGMODES damageTrackingModeFromStr(const std::string&);
 
@@ -39,6 +45,8 @@ private:
     void                renderLayer(SLayerSurface*, SMonitor*, timespec*);
     void                renderDragIcon(SMonitor*, timespec*);
 
+    bool                m_bHasARenderedCursor = true;
+
 
     friend class CHyprOpenGLImpl;
 };

src/render/Shader.cpp

@@ -0,0 +1,13 @@
+#include "Shader.hpp"
+
+GLint CShader::getUniformLocation(const std::string& unif) {
+    const auto itpos = m_muUniforms.find(unif);
+
+    if (itpos == m_muUniforms.end()) {
+        const auto unifLoc = glGetUniformLocation(program, unif.c_str());
+        m_muUniforms[unif] = unifLoc;
+        return unifLoc;
+    }
+
+    return itpos->second;
+}

src/render/Shader.hpp

@@ -1,22 +1,21 @@
 #pragma once
 
 #include "../defines.hpp"
-
-struct SQuad {
-    GLuint program;
-    GLint proj;
-    GLint color;
-    GLint posAttrib;
-    GLint texAttrib;
-};
+#include <unordered_map>
 
 class CShader {
 public:
     GLuint program;
     GLint proj;
+    GLint color;
     GLint tex;
     GLint alpha;
     GLint posAttrib;
     GLint texAttrib;
     GLint discardOpaque;
+
+    GLint getUniformLocation(const std::string&);
+
+private:
+    std::unordered_map<std::string, GLint> m_muUniforms;
 };

src/render/Shaders.hpp

@@ -1,309 +1,5 @@
 #pragma once
 
-#include <string>
-
-inline const std::string QUADVERTSRC = R"#(
-uniform mat3 proj;
-uniform vec4 color;
-attribute vec2 pos;
-attribute vec2 texcoord;
-varying vec4 v_color;
-varying vec2 v_texcoord;
-
-void main() {
-    gl_Position = vec4(proj * vec3(pos, 1.0), 1.0);
-    v_color = color;
-    v_texcoord = texcoord;
-})#";
-
-inline const std::string QUADFRAGSRC = R"#(
-precision mediump float;
-varying vec4 v_color;
-varying vec2 v_texcoord;
-
-uniform vec2 topLeft;
-uniform vec2 bottomRight;
-uniform vec2 fullSize;
-uniform float radius;
-
-void main() {
-	if (radius == 0.0) {
-		gl_FragColor = v_color;
-		return;
-	}
-
-    vec2 pixCoord = fullSize * v_texcoord;
-
-	if (pixCoord[0] < topLeft[0]) {
-		// we're close left
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-			if (distance(topLeft, pixCoord) > radius) {
-				discard;
-				return;
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-			if (distance(vec2(topLeft[0], bottomRight[1]), pixCoord) > radius) {
-				discard;
-				return;
-			}
-		}
-	}
-	else if (pixCoord[0] > bottomRight[0]) {
-		// we're close right
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-			if (distance(vec2(bottomRight[0], topLeft[1]), pixCoord) > radius) {
-				discard;
-				return;
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-			if (distance(bottomRight, pixCoord) > radius) {
-				discard;
-				return;
-			}
-		}
-	}
-
-	gl_FragColor = v_color;
-})#";
-
-inline const std::string TEXVERTSRC = R"#(
-uniform mat3 proj;
-attribute vec2 pos;
-attribute vec2 texcoord;
-varying vec2 v_texcoord;
-
-void main() {
-	gl_Position = vec4(proj * vec3(pos, 1.0), 1.0);
-	v_texcoord = texcoord;
-})#";
-
-inline const std::string TEXFRAGSRCRGBA = R"#(
-precision mediump float;
-varying vec2 v_texcoord; // is in 0-1
-uniform sampler2D tex;
-uniform float alpha;
-
-uniform vec2 topLeft;
-uniform vec2 bottomRight;
-uniform vec2 fullSize;
-uniform float radius;
-
-uniform int discardOpaque;
-
-void main() {
-
-	vec4 pixColor = texture2D(tex, v_texcoord);
-
-	if (discardOpaque == 1 && pixColor[3] * alpha == 1.0) {
-		discard;
-		return;
-	}
-
-	vec2 pixCoord = fullSize * v_texcoord;
-
-	if (pixCoord[0] < topLeft[0]) {
-		// we're close left
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-			if (distance(topLeft, pixCoord) > radius) {
-				discard;
-				return;
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-			if (distance(vec2(topLeft[0], bottomRight[1]), pixCoord) > radius) {
-				discard;
-				return;
-			}
-		}
-	}
-	else if (pixCoord[0] > bottomRight[0]) {
-		// we're close right
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-			if (distance(vec2(bottomRight[0], topLeft[1]), pixCoord) > radius) {
-				discard;
-				return;
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-			if (distance(bottomRight, pixCoord) > radius) {
-				discard;
-				return;
-			}
-		}
-	}
-
-	gl_FragColor = pixColor * alpha;
-})#";
-
-inline const std::string TEXFRAGSRCRGBX = R"#(
-precision mediump float;
-varying vec2 v_texcoord;
-uniform sampler2D tex;
-uniform float alpha;
-
-uniform vec2 topLeft;
-uniform vec2 bottomRight;
-uniform vec2 fullSize;
-uniform float radius;
-
-uniform int discardOpaque;
-
-void main() {
-
-	if (discardOpaque == 1 && alpha == 1.0) {
-		discard;
-		return;
-	}
-	
-	vec2 pixCoord = fullSize * v_texcoord;
-
-	if (pixCoord[0] < topLeft[0]) {
-		// we're close left
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-			if (distance(topLeft, pixCoord) > radius) {
-				discard;
-				return;
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-			if (distance(vec2(topLeft[0], bottomRight[1]), pixCoord) > radius) {
-				discard;
-				return;
-			}
-		}
-	}
-	else if (pixCoord[0] > bottomRight[0]) {
-		// we're close right
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-			if (distance(vec2(bottomRight[0], topLeft[1]), pixCoord) > radius) {
-				discard;
-				return;
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-			if (distance(bottomRight, pixCoord) > radius) {
-				discard;
-				return;
-			}
-		}
-	}
-
-	gl_FragColor = vec4(texture2D(tex, v_texcoord).rgb, 1.0) * alpha;
-})#";
-
-inline const std::string FRAGBLUR1 = R"#(
-#version 100
-precision mediump float;
-varying mediump vec2 v_texcoord; // is in 0-1
-uniform sampler2D tex;
-
-uniform float radius;
-uniform vec2 halfpixel;
-
-void main() {
-	vec2 uv = v_texcoord * 2.0;
-
-    vec4 sum = texture2D(tex, uv) * 4.0;
-    sum += texture2D(tex, uv - halfpixel.xy * radius);
-    sum += texture2D(tex, uv + halfpixel.xy * radius);
-    sum += texture2D(tex, uv + vec2(halfpixel.x, -halfpixel.y) * radius);
-    sum += texture2D(tex, uv - vec2(halfpixel.x, -halfpixel.y) * radius);
-    gl_FragColor = sum / 8.0;
-}
-)#";
-
-inline const std::string FRAGBLUR2 = R"#(
-#version 100
-precision mediump float;
-varying mediump vec2 v_texcoord; // is in 0-1
-uniform sampler2D tex;
-
-uniform float radius;
-uniform vec2 halfpixel;
-
-void main() {
-	vec2 uv = v_texcoord / 2.0;
-
-    vec4 sum = texture2D(tex, uv + vec2(-halfpixel.x * 2.0, 0.0) * radius);
-    
-    sum += texture2D(tex, uv + vec2(-halfpixel.x, halfpixel.y) * radius) * 2.0;
-    sum += texture2D(tex, uv + vec2(0.0, halfpixel.y * 2.0) * radius);
-    sum += texture2D(tex, uv + vec2(halfpixel.x, halfpixel.y) * radius) * 2.0;
-    sum += texture2D(tex, uv + vec2(halfpixel.x * 2.0, 0.0) * radius);
-    sum += texture2D(tex, uv + vec2(halfpixel.x, -halfpixel.y) * radius) * 2.0;
-    sum += texture2D(tex, uv + vec2(0.0, -halfpixel.y * 2.0) * radius);
-    sum += texture2D(tex, uv + vec2(-halfpixel.x, -halfpixel.y) * radius) * 2.0;
-
-    gl_FragColor = sum / 12.0;
-}
-)#";
-
-inline const std::string TEXFRAGSRCEXT = R"#(
-#extension GL_OES_EGL_image_external : require
-
-precision mediump float;
-varying vec2 v_texcoord;
-uniform samplerExternalOES texture0;
-uniform float alpha;
-
-uniform vec2 topLeft;
-uniform vec2 bottomRight;
-uniform vec2 fullSize;
-uniform float radius;
-
-uniform int discardOpaque;
-
-void main() {
-
-	vec4 pixColor = texture2D(texture0, v_texcoord);
-
-	if (discardOpaque == 1 && pixColor[3] * alpha == 1.0) {
-		discard;
-		return;
-	}
-
-	vec2 pixCoord = fullSize * v_texcoord;
-
-	if (pixCoord[0] < topLeft[0]) {
-		// we're close left
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-			if (distance(topLeft, pixCoord) > radius) {
-				discard;
-				return;
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-			if (distance(vec2(topLeft[0], bottomRight[1]), pixCoord) > radius) {
-				discard;
-				return;
-			}
-		}
-	}
-	else if (pixCoord[0] > bottomRight[0]) {
-		// we're close right
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-			if (distance(vec2(bottomRight[0], topLeft[1]), pixCoord) > radius) {
-				discard;
-				return;
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-			if (distance(bottomRight, pixCoord) > radius) {
-				discard;
-				return;
-			}
-		}
-	}
-
-	gl_FragColor = pixColor * alpha;
-})#";
+#include "shaders/Textures.hpp"
+#include "shaders/Shadow.hpp"
+#include "shaders/Border.hpp"

src/render/decorations/CHyprDropShadowDecoration.cpp

@@ -0,0 +1,125 @@
+#include "CHyprDropShadowDecoration.hpp"
+
+#include "../../Compositor.hpp"
+
+CHyprDropShadowDecoration::CHyprDropShadowDecoration(CWindow* pWindow) {
+    m_pWindow = pWindow;
+}
+
+CHyprDropShadowDecoration::~CHyprDropShadowDecoration() {
+    updateWindow(m_pWindow);
+}
+
+SWindowDecorationExtents CHyprDropShadowDecoration::getWindowDecorationExtents() {
+    static auto *const PSHADOWS = &g_pConfigManager->getConfigValuePtr("decoration:drop_shadow")->intValue;
+
+    if (*PSHADOWS != 1)
+        return {{}, {}};
+
+    return m_seExtents;
+}
+
+eDecorationType CHyprDropShadowDecoration::getDecorationType() {
+    return DECORATION_SHADOW;
+}
+
+void CHyprDropShadowDecoration::damageEntire() {
+    static auto *const PSHADOWS = &g_pConfigManager->getConfigValuePtr("decoration:drop_shadow")->intValue;
+
+    if (*PSHADOWS != 1)
+        return; // disabled
+
+    wlr_box dm = {m_vLastWindowPos.x - m_seExtents.topLeft.x, m_vLastWindowPos.y - m_seExtents.topLeft.y, m_vLastWindowSize.x + m_seExtents.topLeft.x + m_seExtents.bottomRight.x, m_vLastWindowSize.y + m_seExtents.topLeft.y + m_seExtents.bottomRight.y};
+    g_pHyprRenderer->damageBox(&dm);
+}
+
+void CHyprDropShadowDecoration::updateWindow(CWindow* pWindow) {
+    damageEntire();
+
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(pWindow->m_iWorkspaceID);
+
+    const auto WORKSPACEOFFSET = PWORKSPACE ? PWORKSPACE->m_vRenderOffset.vec() : Vector2D();
+
+    if (pWindow->m_vRealPosition.vec() + WORKSPACEOFFSET != m_vLastWindowPos || pWindow->m_vRealSize.vec() != m_vLastWindowSize) {
+        m_vLastWindowPos = pWindow->m_vRealPosition.vec() + WORKSPACEOFFSET;
+        m_vLastWindowSize = pWindow->m_vRealSize.vec();
+
+        damageEntire();
+    }
+}
+
+void CHyprDropShadowDecoration::draw(SMonitor* pMonitor, float a) {
+
+    if (!g_pCompositor->windowValidMapped(m_pWindow))
+        return;
+
+    static auto *const PSHADOWS = &g_pConfigManager->getConfigValuePtr("decoration:drop_shadow")->intValue;
+    static auto *const PSHADOWSIZE = &g_pConfigManager->getConfigValuePtr("decoration:shadow_range")->intValue;
+    static auto *const PROUNDING = &g_pConfigManager->getConfigValuePtr("decoration:rounding")->intValue;
+    static auto *const PSHADOWIGNOREWINDOW = &g_pConfigManager->getConfigValuePtr("decoration:shadow_ignore_window")->intValue;
+    static auto *const PSHADOWOFFSET = &g_pConfigManager->getConfigValuePtr("decoration:shadow_offset")->strValue;
+
+    if (*PSHADOWS != 1)
+        return; // disabled
+
+    // get the real offset
+    Vector2D offset;
+    try {
+        if (const auto SPACEPOS = PSHADOWOFFSET->find(' '); SPACEPOS != std::string::npos) {
+            const auto X = PSHADOWOFFSET->substr(0, SPACEPOS);
+            const auto Y = PSHADOWOFFSET->substr(SPACEPOS + 1);
+
+            if (isNumber(X, true) && isNumber(Y, true)) {
+                offset = Vector2D(std::stof(X), std::stof(Y));
+            }
+        }
+    } catch (std::exception& e) {
+        return; // cannot parse
+    }
+
+    // update the extents
+    m_seExtents = {{*PSHADOWSIZE + 2 - offset.x, *PSHADOWSIZE + 2 - offset.y}, {*PSHADOWSIZE + 2 + offset.x, *PSHADOWSIZE + 2 + offset.y}};
+
+    // draw the shadow
+    wlr_box fullBox = {m_vLastWindowPos.x - m_seExtents.topLeft.x + 2, m_vLastWindowPos.y - m_seExtents.topLeft.y + 2, m_vLastWindowSize.x + m_seExtents.topLeft.x + m_seExtents.bottomRight.x - 4, m_vLastWindowSize.y + m_seExtents.topLeft.y + m_seExtents.bottomRight.y - 4};
+    
+    fullBox.x -= pMonitor->vecPosition.x;
+    fullBox.y -= pMonitor->vecPosition.y;
+
+    if (fullBox.width < 1 || fullBox.height < 1)
+        return; // don't draw invisible shadows
+
+    if (*PSHADOWIGNOREWINDOW) {
+        glClearStencil(0);
+        glClear(GL_STENCIL_BUFFER_BIT);
+
+        glEnable(GL_STENCIL_TEST);
+
+        glStencilFunc(GL_ALWAYS, 1, -1);
+        glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+
+        wlr_box windowBox = {m_vLastWindowPos.x - pMonitor->vecPosition.x, m_vLastWindowPos.y - pMonitor->vecPosition.y, m_vLastWindowSize.x, m_vLastWindowSize.y};
+
+        scaleBox(&windowBox, pMonitor->scale);
+        
+        if (windowBox.width < 1 || windowBox.height < 1) {
+		    glDisable(GL_STENCIL_TEST);
+		    return; // prevent assert failed
+        }
+	
+        g_pHyprOpenGL->renderRect(&windowBox, CColor(0,0,0,0), *PROUNDING);
+
+        glStencilFunc(GL_NOTEQUAL, 1, -1);
+        glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+    }
+
+    scaleBox(&fullBox, pMonitor->scale);
+    g_pHyprOpenGL->renderRoundedShadow(&fullBox, *PROUNDING, *PSHADOWSIZE, a);
+
+    if (*PSHADOWIGNOREWINDOW) {
+        // cleanup
+        glClearStencil(0);
+        glClear(GL_STENCIL_BUFFER_BIT);
+        glDisable(GL_STENCIL_TEST);
+    }
+}

src/render/decorations/CHyprDropShadowDecoration.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "IHyprWindowDecoration.hpp"
+
+class CHyprDropShadowDecoration : public IHyprWindowDecoration {
+public:
+    CHyprDropShadowDecoration(CWindow*);
+    virtual ~CHyprDropShadowDecoration();
+
+    virtual SWindowDecorationExtents getWindowDecorationExtents();
+
+    virtual void draw(SMonitor*, float a);
+
+    virtual eDecorationType getDecorationType();
+
+    virtual void updateWindow(CWindow*);
+
+    virtual void damageEntire();
+
+private:
+    SWindowDecorationExtents    m_seExtents;
+
+    CWindow*                    m_pWindow = nullptr;
+
+    Vector2D                    m_vLastWindowPos;
+    Vector2D                    m_vLastWindowSize;
+};

src/render/decorations/CHyprGroupBarDecoration.cpp

@@ -21,14 +21,18 @@ eDecorationType CHyprGroupBarDecoration::getDecorationType() {
 void CHyprGroupBarDecoration::updateWindow(CWindow* pWindow) {
     damageEntire();
 
-    if (pWindow->m_vRealPosition.vec() != m_vLastWindowPos || pWindow->m_vRealSize.vec() != m_vLastWindowSize) {
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(pWindow->m_iWorkspaceID);
+
+    const auto WORKSPACEOFFSET = PWORKSPACE ? PWORKSPACE->m_vRenderOffset.vec() : Vector2D();
+
+    if (pWindow->m_vRealPosition.vec() + WORKSPACEOFFSET != m_vLastWindowPos || pWindow->m_vRealSize.vec() != m_vLastWindowSize) {
         // we draw 3px above the window's border with 3px
         const auto BORDERSIZE = g_pConfigManager->getInt("general:border_size");
 
         m_seExtents.topLeft = Vector2D(0, BORDERSIZE + 3 + 3);
         m_seExtents.bottomRight = Vector2D();
 
-        m_vLastWindowPos = pWindow->m_vRealPosition.vec();
+        m_vLastWindowPos = pWindow->m_vRealPosition.vec() + WORKSPACEOFFSET;
         m_vLastWindowSize = pWindow->m_vRealSize.vec();
     }
 
@@ -36,12 +40,8 @@ void CHyprGroupBarDecoration::updateWindow(CWindow* pWindow) {
 
     if (g_pLayoutManager->getCurrentLayout()->getLayoutName() != "dwindle") {
         // ????
-        for (auto it = pWindow->m_dWindowDecorations.begin(); it != pWindow->m_dWindowDecorations.end(); it++) {
-            if (it->get() == this) {
-                pWindow->m_dWindowDecorations.erase(it);
-                return;
-            }
-        }
+        m_pWindow->m_vDecosToRemove.push_back(this);
+        return;
     }
 
     // get the group info
@@ -54,12 +54,8 @@ void CHyprGroupBarDecoration::updateWindow(CWindow* pWindow) {
 
     if (m_dwGroupMembers.size() == 0) {
         // remove
-        for (auto it = pWindow->m_dWindowDecorations.begin(); it != pWindow->m_dWindowDecorations.end(); it++) {
-            if (it->get() == this) {
-                pWindow->m_dWindowDecorations.erase(it);
-                return;
-            }
-        }
+        m_pWindow->m_vDecosToRemove.push_back(this);
+        return;
     }
 }
 
@@ -68,7 +64,7 @@ void CHyprGroupBarDecoration::damageEntire() {
     g_pHyprRenderer->damageBox(&dm);
 }
 
-void CHyprGroupBarDecoration::draw(SMonitor* pMonitor) {
+void CHyprGroupBarDecoration::draw(SMonitor* pMonitor, float a) {
     // get how many bars we will draw
     int barsToDraw = m_dwGroupMembers.size();
 
@@ -88,6 +84,7 @@ void CHyprGroupBarDecoration::draw(SMonitor* pMonitor) {
             break;
 
         CColor color = m_dwGroupMembers[i] == g_pCompositor->m_pLastWindow ? CColor(g_pConfigManager->getInt("dwindle:col.group_border_active")) : CColor(g_pConfigManager->getInt("dwindle:col.group_border"));
+        color.a *= a;
         g_pHyprOpenGL->renderRect(&rect, color);
 
         xoff += PAD + BARW;

src/render/decorations/CHyprGroupBarDecoration.hpp

@@ -10,7 +10,7 @@ public:
 
     virtual SWindowDecorationExtents getWindowDecorationExtents();
 
-    virtual void draw(SMonitor*);
+    virtual void draw(SMonitor*, float a);
 
     virtual eDecorationType getDecorationType();
 

src/render/decorations/IHyprWindowDecoration.hpp

@@ -4,7 +4,8 @@
 
 enum eDecorationType {
     DECORATION_NONE = -1,
-    DECORATION_GROUPBAR
+    DECORATION_GROUPBAR,
+    DECORATION_SHADOW
 };
 
 struct SWindowDecorationExtents {
@@ -15,13 +16,13 @@ struct SWindowDecorationExtents {
 class CWindow;
 struct SMonitor;
 
-class IHyprWindowDecoration {
+interface IHyprWindowDecoration {
 public:
     virtual ~IHyprWindowDecoration() = 0;
 
     virtual SWindowDecorationExtents getWindowDecorationExtents() = 0;
 
-    virtual void draw(SMonitor*) = 0;
+    virtual void draw(SMonitor*, float a) = 0;
 
     virtual eDecorationType getDecorationType() = 0;
 

src/render/shaders/Border.hpp

@@ -0,0 +1,91 @@
+#pragma once
+
+#include <string>
+
+// makes a stencil without corners
+inline const std::string FRAGBORDER1 = R"#(
+precision mediump float;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+uniform vec2 topLeft;
+uniform vec2 bottomRight;
+uniform vec2 fullSize;
+uniform float radius;
+uniform float thick;
+uniform int primitiveMultisample;
+
+float getOpacityForPixAndCorner(vec2 pix, vec2 corner) {
+
+    if (primitiveMultisample == 0) {
+        float dis = distance(pix + vec2(0.5, 0.5), corner);
+        return dis < radius && dis > radius - thick ? 1.0 : 0.0;
+    }
+
+    float distance1 = distance(pix + vec2(0.25, 0.25), corner);
+    float distance2 = distance(pix + vec2(0.75, 0.25), corner);
+    float distance3 = distance(pix + vec2(0.25, 0.75), corner);
+    float distance4 = distance(pix + vec2(0.75, 0.75), corner);
+
+    float v1 = distance1 < radius && distance1 > radius - thick ? 1.0 : 0.0;
+    float v2 = distance2 < radius && distance2 > radius - thick ? 1.0 : 0.0;
+    float v3 = distance3 < radius && distance3 > radius - thick ? 1.0 : 0.0;
+    float v4 = distance4 < radius && distance4 > radius - thick ? 1.0 : 0.0;
+
+    return (v1 + v2 + v3 + v4) / 4.0;
+}
+
+void main() {
+
+    vec2 pixCoord = fullSize * v_texcoord;
+
+    vec4 pixColor = v_color;
+
+    bool done = false;
+    
+    // check for edges
+    if (pixCoord[0] < topLeft[0]) {
+        if (pixCoord[1] < topLeft[1]) {
+            // top left
+            pixColor[3] = pixColor[3] * getOpacityForPixAndCorner(pixCoord, topLeft + vec2(1,1));
+            done = true;
+        } else if (pixCoord[1] > bottomRight[1]) {
+            // bottom left
+            pixColor[3] = pixColor[3] * getOpacityForPixAndCorner(pixCoord, vec2(topLeft[0] + 1.0, bottomRight[1]));
+            done = true;
+        }
+    } else if (pixCoord[0] > bottomRight[0]) {
+        if (pixCoord[1] < topLeft[1]) {
+            // top right
+            pixColor[3] = pixColor[3] * getOpacityForPixAndCorner(pixCoord, vec2(bottomRight[0], topLeft[1] + 1.0));
+            done = true;
+        } else if (pixCoord[1] > bottomRight[1]) {
+            // bottom right
+            pixColor[3] = pixColor[3] * getOpacityForPixAndCorner(pixCoord, bottomRight);
+            done = true;
+        }
+    }
+
+    // now check for other shit
+    if (!done) {
+        // distance to all straight bb borders
+        float distanceT = pixCoord[1];
+        float distanceB = fullSize[1] - pixCoord[1];
+        float distanceL = pixCoord[0];
+        float distanceR = fullSize[0] - pixCoord[0];
+
+        // get the smallest
+        float smallest = min(min(distanceT, distanceB), min(distanceL, distanceR));
+
+        if (smallest > thick) {
+            discard; return;
+        }
+    }
+
+    if (pixColor[3] == 0.0) {
+        discard; return;
+    }
+
+    gl_FragColor = pixColor;
+}
+)#";

src/render/shaders/Shadow.hpp

@@ -0,0 +1,82 @@
+#pragma once
+
+#include <string>
+
+inline const std::string FRAGSHADOW = R"#(
+precision mediump float;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+uniform vec2 topLeft;
+uniform vec2 bottomRight;
+uniform vec2 fullSize;
+uniform float radius;
+uniform float range;
+uniform float shadowPower;
+
+float pixAlphaRoundedDistance(float distanceToCorner) {
+     if (distanceToCorner > radius) {
+        return 0.0;
+    }
+
+    if (distanceToCorner > radius - range) {
+        return pow((range - (distanceToCorner - radius + range)) / range, shadowPower); // i think?
+    }
+
+    return 1.0;
+}
+
+void main() {
+
+	vec4 pixColor = v_color;
+    float originalAlpha = pixColor[3];
+
+    bool done = false;
+
+	vec2 pixCoord = fullSize * v_texcoord;
+
+    // ok, now we check the distance to a border.
+
+    if (pixCoord[0] < topLeft[0]) {
+        if (pixCoord[1] < topLeft[1]) {
+            // top left
+            pixColor[3] = pixColor[3] * pixAlphaRoundedDistance(distance(pixCoord, topLeft));
+            done = true;
+        } else if (pixCoord[1] > bottomRight[1]) {
+            // bottom left
+            pixColor[3] = pixColor[3] * pixAlphaRoundedDistance(distance(pixCoord, vec2(topLeft[0], bottomRight[1])));
+            done = true;
+        }
+    } else if (pixCoord[0] > bottomRight[0]) {
+        if (pixCoord[1] < topLeft[1]) {
+            // top right
+            pixColor[3] = pixColor[3] * pixAlphaRoundedDistance(distance(pixCoord, vec2(bottomRight[0], topLeft[1])));
+            done = true;
+        } else if (pixCoord[1] > bottomRight[1]) {
+            // bottom right
+            pixColor[3] = pixColor[3] * pixAlphaRoundedDistance(distance(pixCoord, bottomRight));
+            done = true;
+        }
+    }
+
+    if (!done) {  
+        // distance to all straight bb borders
+        float distanceT = pixCoord[1];
+        float distanceB = fullSize[1] - pixCoord[1];
+        float distanceL = pixCoord[0];
+        float distanceR = fullSize[0] - pixCoord[0];
+
+        // get the smallest
+        float smallest = min(min(distanceT, distanceB), min(distanceL, distanceR));
+
+        if (smallest < range) {
+            pixColor[3] = pixColor[3] * pow((smallest / range), shadowPower);
+        }
+    }
+
+    if (pixColor[3] == 0.0) {
+        discard; return;
+    }
+
+	gl_FragColor = pixColor;
+})#";

src/render/shaders/Textures.hpp

@@ -0,0 +1,341 @@
+#pragma once
+
+#include <string>
+
+inline static constexpr auto ROUNDED_SHADER_FUNC = [](const std::string colorVarName) -> std::string {
+    return R"#(
+		if (pixCoord[0] < topLeft[0]) {
+		// we're close left
+		if (pixCoord[1] < topLeft[1]) {
+			// top
+
+			if (ignoreCorners == 1) {
+				discard;
+				return;
+			}
+
+			float topLeftDistance = distance(topLeft, pixCoord);
+
+			if (topLeftDistance > radius - 1.0) {
+				if (primitiveMultisample == 0 && topLeftDistance > radius) {
+					discard;
+					return;
+				} else if (primitiveMultisample == 1) {
+					float distances = 0.0;
+					if (distance(topLeft, pixCoord + vec2(0.25, 0.25)) < radius) { distances = distances + 1.0; }
+					if (distance(topLeft, pixCoord + vec2(0.75, 0.25)) < radius) { distances = distances + 1.0; }
+					if (distance(topLeft, pixCoord + vec2(0.25, 0.75)) < radius) { distances = distances + 1.0; }
+					if (distance(topLeft, pixCoord + vec2(0.75, 0.75)) < radius) { distances = distances + 1.0; }
+
+					if (distances == 0.0) {
+						discard;
+						return;
+					}
+
+					distances = distances / 4.0;
+
+					gl_FragColor = )#" + colorVarName + R"#( * distances;
+					return;
+				}
+			}
+		} else if (pixCoord[1] > bottomRight[1]) {
+			// bottom
+
+			if (ignoreCorners == 1) {
+				discard;
+				return;
+			}
+
+			float topLeftDistance = distance(vec2(topLeft[0], bottomRight[1]), pixCoord);
+
+			if (topLeftDistance > radius - 1.0) {
+				if (primitiveMultisample == 0 && topLeftDistance > radius) {
+					discard;
+					return;
+				} else if (primitiveMultisample == 1) {
+					float distances = 0.0;
+					if (distance(vec2(topLeft[0], bottomRight[1]), pixCoord + vec2(0.25, 0.25)) < radius) { distances = distances + 1.0; }
+					if (distance(vec2(topLeft[0], bottomRight[1]), pixCoord + vec2(0.75, 0.25)) < radius) { distances = distances + 1.0; }
+					if (distance(vec2(topLeft[0], bottomRight[1]), pixCoord + vec2(0.25, 0.75)) < radius) { distances = distances + 1.0; }
+					if (distance(vec2(topLeft[0], bottomRight[1]), pixCoord + vec2(0.75, 0.75)) < radius) { distances = distances + 1.0; }
+
+					if (distances == 0.0) {
+						discard;
+						return;
+					}
+
+					distances = distances / 4.0;
+
+					gl_FragColor = )#" + colorVarName + R"#( * distances;
+					return;
+				}
+			}
+		}
+	}
+	else if (pixCoord[0] > bottomRight[0]) {
+		// we're close right
+		if (pixCoord[1] < topLeft[1]) {
+			// top
+
+			if (ignoreCorners == 1) {
+				discard;
+				return;
+			}
+
+			float topLeftDistance = distance(vec2(bottomRight[0], topLeft[1]), pixCoord);
+
+			if (topLeftDistance > radius - 1.0) {
+				if (primitiveMultisample == 0 && topLeftDistance > radius) {
+					discard;
+					return;
+				} else if (primitiveMultisample == 1) {
+					float distances = 0.0;
+					if (distance(vec2(bottomRight[0], topLeft[1]), pixCoord + vec2(0.25, 0.25)) < radius) { distances = distances + 1.0; }
+					if (distance(vec2(bottomRight[0], topLeft[1]), pixCoord + vec2(0.75, 0.25)) < radius) { distances = distances + 1.0; }
+					if (distance(vec2(bottomRight[0], topLeft[1]), pixCoord + vec2(0.25, 0.75)) < radius) { distances = distances + 1.0; }
+					if (distance(vec2(bottomRight[0], topLeft[1]), pixCoord + vec2(0.75, 0.75)) < radius) { distances = distances + 1.0; }
+
+					if (distances == 0.0) {
+						discard;
+						return;
+					}
+
+					distances = distances / 4.0;
+
+					gl_FragColor = )#" + colorVarName + R"#( * distances;
+					return;
+				}
+			}
+		} else if (pixCoord[1] > bottomRight[1]) {
+			// bottom
+
+			if (ignoreCorners == 1) {
+				discard;
+				return;
+			}
+
+			float topLeftDistance = distance(bottomRight, pixCoord);
+
+			if (topLeftDistance > radius - 1.0) {
+				if (primitiveMultisample == 0 && topLeftDistance > radius) {
+					discard;
+					return;
+				} else if (primitiveMultisample == 1) {
+					float distances = 0.0;
+					if (distance(bottomRight, pixCoord + vec2(0.25, 0.25)) < radius) { distances = distances + 1.0; }
+					if (distance(bottomRight, pixCoord + vec2(0.75, 0.25)) < radius) { distances = distances + 1.0; }
+					if (distance(bottomRight, pixCoord + vec2(0.25, 0.75)) < radius) { distances = distances + 1.0; }
+					if (distance(bottomRight, pixCoord + vec2(0.75, 0.75)) < radius) { distances = distances + 1.0; }
+
+					if (distances == 0.0) {
+						discard;
+						return;
+					}
+
+					distances = distances / 4.0;
+
+					gl_FragColor = )#" + colorVarName + R"#( * distances;
+					return;
+				}
+			}
+		}
+	}
+	)#";
+};
+
+inline const std::string QUADVERTSRC = R"#(
+uniform mat3 proj;
+uniform vec4 color;
+attribute vec2 pos;
+attribute vec2 texcoord;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+void main() {
+    gl_Position = vec4(proj * vec3(pos, 1.0), 1.0);
+    v_color = color;
+    v_texcoord = texcoord;
+})#";
+
+inline const std::string QUADFRAGSRC = R"#(
+precision mediump float;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+uniform vec2 topLeft;
+uniform vec2 bottomRight;
+uniform vec2 fullSize;
+uniform float radius;
+
+uniform int primitiveMultisample;
+uniform int ignoreCorners;
+
+void main() {
+	if (radius == 0.0) {
+		gl_FragColor = v_color;
+		return;
+	}
+
+    vec2 pixCoord = fullSize * v_texcoord;
+
+	)#" + ROUNDED_SHADER_FUNC("v_color") + R"#(
+
+	gl_FragColor = v_color;
+})#";
+
+inline const std::string TEXVERTSRC = R"#(
+uniform mat3 proj;
+attribute vec2 pos;
+attribute vec2 texcoord;
+varying vec2 v_texcoord;
+
+void main() {
+	gl_Position = vec4(proj * vec3(pos, 1.0), 1.0);
+	v_texcoord = texcoord;
+})#";
+
+inline const std::string TEXFRAGSRCRGBA = R"#(
+precision mediump float;
+varying vec2 v_texcoord; // is in 0-1
+uniform sampler2D tex;
+uniform float alpha;
+
+uniform vec2 topLeft;
+uniform vec2 bottomRight;
+uniform vec2 fullSize;
+uniform float radius;
+
+uniform int discardOpaque;
+
+uniform int primitiveMultisample;
+uniform int ignoreCorners;
+
+void main() {
+
+	vec4 pixColor = texture2D(tex, v_texcoord);
+
+	if (discardOpaque == 1 && pixColor[3] * alpha == 1.0) {
+		discard;
+		return;
+	}
+
+	vec2 pixCoord = fullSize * v_texcoord;
+
+	)#" + ROUNDED_SHADER_FUNC("pixColor") +
+                                          R"#(
+
+	gl_FragColor = pixColor * alpha;
+})#";
+
+inline const std::string TEXFRAGSRCRGBX = R"#(
+precision mediump float;
+varying vec2 v_texcoord;
+uniform sampler2D tex;
+uniform float alpha;
+
+uniform vec2 topLeft;
+uniform vec2 bottomRight;
+uniform vec2 fullSize;
+uniform float radius;
+
+uniform int discardOpaque;
+
+uniform int primitiveMultisample;
+uniform int ignoreCorners;
+
+void main() {
+
+	if (discardOpaque == 1 && alpha == 1.0) {
+		discard;
+		return;
+	}
+
+	vec4 pixColor = vec4(texture2D(tex, v_texcoord).rgb, 1.0);
+	
+	vec2 pixCoord = fullSize * v_texcoord;
+
+	)#" + ROUNDED_SHADER_FUNC("pixColor") + R"#(
+
+	gl_FragColor = pixColor * alpha;
+})#";
+
+inline const std::string FRAGBLUR1 = R"#(
+#version 100
+precision mediump float;
+varying mediump vec2 v_texcoord; // is in 0-1
+uniform sampler2D tex;
+
+uniform float radius;
+uniform vec2 halfpixel;
+
+void main() {
+	vec2 uv = v_texcoord * 2.0;
+
+    vec4 sum = texture2D(tex, uv) * 4.0;
+    sum += texture2D(tex, uv - halfpixel.xy * radius);
+    sum += texture2D(tex, uv + halfpixel.xy * radius);
+    sum += texture2D(tex, uv + vec2(halfpixel.x, -halfpixel.y) * radius);
+    sum += texture2D(tex, uv - vec2(halfpixel.x, -halfpixel.y) * radius);
+    gl_FragColor = sum / 8.0;
+}
+)#";
+
+inline const std::string FRAGBLUR2 = R"#(
+#version 100
+precision mediump float;
+varying mediump vec2 v_texcoord; // is in 0-1
+uniform sampler2D tex;
+
+uniform float radius;
+uniform vec2 halfpixel;
+
+void main() {
+	vec2 uv = v_texcoord / 2.0;
+
+    vec4 sum = texture2D(tex, uv + vec2(-halfpixel.x * 2.0, 0.0) * radius);
+    
+    sum += texture2D(tex, uv + vec2(-halfpixel.x, halfpixel.y) * radius) * 2.0;
+    sum += texture2D(tex, uv + vec2(0.0, halfpixel.y * 2.0) * radius);
+    sum += texture2D(tex, uv + vec2(halfpixel.x, halfpixel.y) * radius) * 2.0;
+    sum += texture2D(tex, uv + vec2(halfpixel.x * 2.0, 0.0) * radius);
+    sum += texture2D(tex, uv + vec2(halfpixel.x, -halfpixel.y) * radius) * 2.0;
+    sum += texture2D(tex, uv + vec2(0.0, -halfpixel.y * 2.0) * radius);
+    sum += texture2D(tex, uv + vec2(-halfpixel.x, -halfpixel.y) * radius) * 2.0;
+
+    gl_FragColor = sum / 12.0;
+}
+)#";
+
+inline const std::string TEXFRAGSRCEXT = R"#(
+#extension GL_OES_EGL_image_external : require
+
+precision mediump float;
+varying vec2 v_texcoord;
+uniform samplerExternalOES texture0;
+uniform float alpha;
+
+uniform vec2 topLeft;
+uniform vec2 bottomRight;
+uniform vec2 fullSize;
+uniform float radius;
+
+uniform int discardOpaque;
+
+uniform int primitiveMultisample;
+uniform int ignoreCorners;
+
+void main() {
+
+	vec4 pixColor = texture2D(texture0, v_texcoord);
+
+	if (discardOpaque == 1 && pixColor[3] * alpha == 1.0) {
+		discard;
+		return;
+	}
+
+	vec2 pixCoord = fullSize * v_texcoord;
+
+	)#" + ROUNDED_SHADER_FUNC("pixColor") + R"#(
+
+	gl_FragColor = pixColor * alpha;
+})#";

src/wlrunstable/wlr_ext_workspace_v1.cpp

@@ -2,7 +2,7 @@
 
 #include "../includes.hpp"
 #include "../helpers/MiscFunctions.hpp"
-#include "../../ext-workspace-unstable-v1-protocol.h"
+#include "ext-workspace-unstable-v1-protocol.h"
 
 #include <assert.h>
 #include <string.h>