:finnadie:

https://www.youtube.com/watch?v=_asNhzXq72w

.github/ISSUE_TEMPLATE/bug_report.md

@@ -7,12 +7,6 @@ assignees: ''
 
 ---
 
-**Describe the bug**
-
-
-**Images/videos/anything that would help**
-
-
-Please attach a log (it's in /tmp/hypr/[INSTANCE SIGNATURE]/hyprland.log, if you are unsure of the instance signature, grab the one thats the most recently modified) and, if crashing, a crashdump (coredumpctl, then coredumpctl info <pid>)
-
-*Please do NOT attach coredumps from any packaged version of Hyprland (AUR, etc.). Compile manually, and THEN attach a coredump of that.*
+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

@@ -7,4 +7,6 @@ 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/workflows/ci.yaml

@@ -13,31 +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
         with:
           submodules: recursive
-
-      - name: Build Hyprland With default settings
+      - 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/version-update.sh

@@ -0,0 +1,26 @@
+name: "Nix & Meson: update version"
+
+on: [push, 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"

.gitmodules

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

CMakeLists.txt

@@ -35,7 +35,7 @@ execute_process(
 #
 #
 
-include_directories(.)
+include_directories(. PRIVATE "subprojects/wlroots/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)
@@ -59,6 +59,7 @@ 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
     message(STATUS "Configuring Hyprland in Release with CMake!")

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 $@
@@ -114,16 +124,16 @@ uninstall:
 	rm -f ${PREFIX}/bin/hyprctl
 	rm -rf ${PREFIX}/share/hyprland
 
-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
+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
 
 config:
 	make protocols
 
-	sed -i -E 's/(soversion = 11)([^032]|$$)/soversion = 11032/g' ./wlroots/meson.build
+	sed -i -E 's/(soversion = 11)([^032]|$$)/soversion = 11032/g' subprojects/wlroots/meson.build
 
-	rm -rf ./wlroots/build
+	rm -rf ./subprojects/wlroots/build
 
-	cd wlroots && meson ./build --prefix=/usr --buildtype=release
-	cd wlroots && ninja -C build/
+	cd subprojects/wlroots && meson ./build --prefix=/usr --buildtype=release
+	cd subprojects/wlroots && ninja -C build/
 
-	cd wlroots && sudo ninja -C build/ install
+	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>
 
@@ -51,20 +52,22 @@ Try it out and report bugs / suggestions!
 - Easily expandable and readable codebase
 - Config reloaded instantly upon saving
 - Custom bezier curve based animations
-- wlr_ext workspaces protocol support
+- `wlr_ext` workspaces protocol support
 - Dual Kawase blur
 - Fully dynamic workspaces
-- Closely follows wlroots-git
+- Closely follows `wlroots-git`
 - Bundled wlroots
-- Window / layer fade in / out
-- Tiling / floating / fullscreen windows
-- Special Workspace (Scratchpad)
-- Window / monitor rules
+- 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
+- Event system for bash scripts
 - Rounded corners
-- Full Damage tracking
+- Full damage tracking
 - Docks support
+- Drawing tablet support
 
 <br>
 <br>
@@ -127,7 +130,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
@@ -148,7 +151,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,71 +0,0 @@
-# Maintainer: ThatOneCalculator <kainoa@t1c.dev>
-
-_pkgname="hyprland"
-pkgname="${_pkgname}"
-pkgver="0.2.2beta"
-pkgrel=3
-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
-	cairo
-	pango
-	polkit
-	glslang
-	libinput
-	libxcb
-	libxkbcommon
-	opengl-driver
-	pixman
-	wayland
-	xcb-util-errors
-	xcb-util-renderutil
-	xcb-util-wm
-	seatd
-	vulkan-icd-loader
-	vulkan-validation-layers
-	xorg-xwayland)
-makedepends=(
-	git
-	cmake
-	ninja
-	gcc
-	gdb
-	meson
-	vulkan-headers
-	wayland-protocols
-	xorgproto)
-source=("${pkgname}-${pkgver}.tar.gz::https://github.com/vaxerski/hyprland/archive/v${pkgver}.tar.gz")
-sha256sums=('SKIP')
-conflicts=("${_pkgname}-git" "${_pkgname}" "${_pkgname}-bin")
-options=(!makeflags !buildflags)
-
-build() {
-	cd "$srcdir/Hyprland-$pkgver"
-	git submodule update --init
-	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-bin

@@ -1,55 +0,0 @@
-# Maintainer: ThatOneCalculator <kainoa@t1c.dev>
-
-_pkgname="hyprland"
-pkgname="${_pkgname}-bin"
-pkgver="0.2.2beta"
-pkgrel=3
-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
-	cairo
-	pango
-	polkit
-	glslang
-	libinput
-	libxcb
-	libxkbcommon
-	opengl-driver
-	pixman
-	wayland
-	xcb-util-errors
-	xcb-util-renderutil
-	xcb-util-wm
-	seatd
-	vulkan-icd-loader
-	vulkan-validation-layers
-	xorg-xwayland)
-source=("${pkgname}-${pkgver}.tar.gz::https://github.com/vaxerski/Hyprland/releases/download/v${pkgver}/v${pkgver}.tar.gz")
-sha256sums=('SKIP')
-conflicts=("${_pkgname}-git" "${_pkgname}" "${_pkgname}-bin")
-
-package() {
-	cd "$srcdir/Hyprland-$pkgver"
-	mkdir -p "${pkgdir}/usr/share/wayland-sessions"
-	mkdir -p "${pkgdir}/usr/share/hyprland"
-	install -Dm755 ./Hyprland -t "${pkgdir}/usr/bin"
-	install -Dm755 ./hyprctl -t "${pkgdir}/usr/bin"
-	install -Dm755 ./libwlroots.so.11032 -t "${pkgdir}/usr/lib"
-	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,79 +0,0 @@
-# Maintainer: ThatOneCalculator <kainoa@t1c.dev>, Sander van Kasteel <info@sandervankasteel.nl>
-
-_pkgname="hyprland"
-pkgname="${_pkgname}-git"
-pkgver=r615.g119e776
-pkgrel=4
-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
-	cairo
-	pango
-	polkit
-	glslang
-	libinput
-	libxcb
-	libxkbcommon
-	opengl-driver
-	pixman
-	wayland
-	xcb-util-errors
-	xcb-util-renderutil
-	xcb-util-wm
-	seatd
-	vulkan-icd-loader
-	vulkan-validation-layers
-	xorg-xwayland)
-makedepends=(
-	git
-	cmake
-	ninja
-	gcc
-	gdb
-	meson
-	vulkan-headers
-	wayland-protocols
-	xorgproto)
-source=("${_pkgname}::git+https://github.com/vaxerski/Hyprland.git")
-conflicts=("${_pkgname}-git" "${_pkgname}" "${_pkgname}-bin")
-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}"
-	git submodule update --init
-	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

@@ -27,6 +27,8 @@ general {
     col.active_border=0x66ee1111
     col.inactive_border=0x66333333
 
+    apply_sens_to_raw=0 # do not apply the sensitivity to raw input (e.g. used by games where you aim)
+
     damage_tracking=full # leave it on full unless you hate your GPU and want to make it suffer
 }
 

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": 1653931853,
-        "narHash": "sha256-O3wncIouj9x7gBPntzHeK/Hkmm9M1SGlYq7JI7saTAE=",
+        "lastModified": 1655807518,
+        "narHash": "sha256-5YV29Ry/DpAJc/0Hc/+ISVBAjwHpJvAkeKkcUG5lWsc=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "f1c167688a6f81f4a51ab542e5f476c8c595e457",
+        "rev": "a72d7811be1162dd6804c4e36e5402d76fb6e921",
         "type": "github"
       },
       "original": {
@@ -26,11 +26,11 @@
       "flake": false,
       "locked": {
         "host": "gitlab.freedesktop.org",
-        "lastModified": 1653658290,
-        "narHash": "sha256-zZaona39DOZNL93A1KG3zAi8vDttJBirxacq24hWCn4=",
+        "lastModified": 1654618691,
+        "narHash": "sha256-8y3u8CoigjoZOVbA2wCWBHlDNEakv0AVxU46/cOC00s=",
         "owner": "wlroots",
         "repo": "wlroots",
-        "rev": "75d31509db8c28e8379fe9570118ef8c82284581",
+        "rev": "b89ed9015c3fbe8d339e9d65cf70fdca6e5645bc",
         "type": "gitlab"
       },
       "original": {

flake.nix

@@ -16,40 +16,37 @@
   }: 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 ./nix/default.nix {
-        version = mkVersion self.lastModifiedDate;
-        inherit (self.packages.${system}) wlroots;
+      hyprland = prev.callPackage ./nix/default.nix {
+        version = "0.5.0beta" + "+date=" + (mkDate (self.lastModifiedDate or "19700101"));
+        wlroots = wlroots-hyprland;
       };
-    });
+    };
+
+    packages = genSystems (system:
+      (self.overlays.default null pkgsFor.${system})
+      // {
+        default = self.packages.${system}.hyprland;
+      });
 
     formatter = genSystems (system: pkgsFor.${system}.alejandra);
 
     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,8 +15,7 @@
 #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
@@ -27,8 +26,7 @@ usage: hyprctl [command] [(opt)args]
     dispatch
     keyword
     version
-    reload
-)#";
+    reload)#";
 
 void request(std::string arg) {
     const auto SERVERSOCKET = socket(AF_UNIX, SOCK_STREAM, 0);
@@ -121,7 +119,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;
     }
 
@@ -136,10 +134,12 @@ int main(int argc, char** argv) {
     else if (!strcmp(argv[1], "dispatch")) dispatchRequest(argc, argv);
     else if (!strcmp(argv[1], "keyword")) keywordRequest(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,26 @@
+project('Hyprland', 'cpp', 'c',
+  version : '0.5.0beta',
+  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')
+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,
@@ -27,7 +27,7 @@ stdenv.mkDerivation {
   src = ../.;
 
   nativeBuildInputs = [
-    cmake
+    meson
     ninja
     pkg-config
   ];
@@ -48,33 +48,14 @@ stdenv.mkDerivation {
     ]
     ++ lib.optional enableXWayland xwayland;
 
-  cmakeFlags =
-    ["-DCMAKE_BUILD_TYPE=Release"]
-    ++ lib.optional (!enableXWayland) "-DNO_XWAYLAND=true";
+  mesonBuildType = "release";
 
-  # enables building with nix-supplied wlroots instead of submodule
-  prePatch = ''
-    sed -Ei 's/"\.\.\/wlroots\/include\/([a-zA-Z0-9./_-]+)"/<\1>/g' src/includes.hpp
-  '';
-  postPatch = ''
-    make protocols
-  '';
+  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/module.nix

@@ -19,7 +19,7 @@ in {
 
     package = mkOption {
       type = types.package;
-      default = self.packages.${pkgs.system}.default;
+      default = pkgs.hyprland or self.packages.${pkgs.system}.default;
       defaultText = literalExpression "<Hyprland flake>.packages.<system>.default";
       example = literalExpression "<Hyprland flake>.packages.<system>.default.override { }";
       description = ''

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

@@ -109,6 +109,8 @@ 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);
 }
 
 CCompositor::~CCompositor() {
@@ -142,6 +144,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);
@@ -440,7 +443,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;
@@ -451,6 +458,9 @@ 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;
 }
 
@@ -582,11 +592,11 @@ CWindow* CCompositor::getWindowForPopup(wlr_xdg_popup* popup) {
 }
 
 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))
+    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)
             return SURFACEAT;

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,6 +59,7 @@ 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;
     // ------------------------------------------------- //
 
 

src/config/ConfigManager.cpp

@@ -20,7 +20,7 @@ CConfigManager::CConfigManager() {
 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: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
 
@@ -28,6 +28,7 @@ void CConfigManager::setDefaultVars() {
     configValues["general:damage_tracking_internal"].intValue = DAMAGE_TRACKING_NONE;
 
     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;
@@ -46,12 +47,14 @@ void CConfigManager::setDefaultVars() {
     configValues["decoration:inactive_opacity"].floatValue = 1;
     configValues["decoration:fullscreen_opacity"].floatValue = 1;
     configValues["decoration:multisample_edges"].intValue = 0;
+    configValues["decoration:no_blur_on_oversized"].intValue = 1;
 
     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;
@@ -82,7 +85,12 @@ void CConfigManager::setDefaultVars() {
     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;
 
@@ -154,11 +162,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) {
@@ -363,7 +417,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>
 
@@ -396,7 +450,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) {
@@ -443,16 +497,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");
 
@@ -526,12 +587,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);
 
@@ -638,7 +701,8 @@ void CConfigManager::loadConfigLoadVars() {
     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);
 
@@ -651,6 +715,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);
 

src/config/ConfigManager.hpp

@@ -28,7 +28,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;
 };
@@ -88,6 +88,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;
@@ -106,13 +108,14 @@ private:
     void                configSetValueSafe(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

@@ -34,6 +34,8 @@ general {
     col.active_border=0x66ee1111
     col.inactive_border=0x66333333
 
+    apply_sens_to_raw=0 # do not apply the sensitivity to raw input (e.g. used by games where you aim)
+
     damage_tracking=full # leave it on full unless you hate your GPU and want to make it suffer
 }
 

src/debug/HyprCtl.cpp

@@ -26,8 +26,9 @@ 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\tmonitor: %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, w.m_iMonitorID);
+        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\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).c_str());
     }
     return result;
 }
@@ -47,8 +48,8 @@ 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\tmonitor: %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);
+    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\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());
 }
 
 std::string layersRequest() {
@@ -87,6 +88,20 @@ std::string devicesRequest() {
         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;
 }
 
@@ -99,6 +114,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

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); }
 

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"
 
 // ---------------------------------------------------- //
@@ -73,13 +73,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;
     }

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"
@@ -114,29 +114,41 @@ 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;
+    std::string newDefaultWorkspaceName = "";
+    auto WORKSPACEID = monitorRule.defaultWorkspace == "" ? g_pCompositor->m_lWorkspaces.size() + 1 : getWorkspaceIDFromString(monitorRule.defaultWorkspace, newDefaultWorkspaceName);
     
+    if (WORKSPACEID == INT_MAX || WORKSPACEID == (long unsigned int)SPECIAL_WORKSPACE_ID) {
+        WORKSPACEID = g_pCompositor->m_lWorkspaces.size() + 1;
+        newDefaultWorkspaceName = std::to_string(WORKSPACEID);
+
+        Debug::log(LOG, "Invalid workspace= directive name in monitor parsing, workspace name \"%s\" is invalid.", monitorRule.defaultWorkspace);
+    }
+
     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 {
-        g_pCompositor->m_lWorkspaces.emplace_back(newMonitor.ID);
-        PNEWWORKSPACE = &g_pCompositor->m_lWorkspaces.back();
+        PNEWWORKSPACE = &g_pCompositor->m_lWorkspaces.emplace_back(newMonitor.ID);
 
         // 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());
+        wlr_ext_workspace_handle_v1_set_name(PNEWWORKSPACE->m_pWlrHandle, newDefaultWorkspaceName.c_str());
 
         PNEWWORKSPACE->m_iID = WORKSPACEID;
-        PNEWWORKSPACE->m_szName = std::to_string(WORKSPACEID);
+        PNEWWORKSPACE->m_szName = newDefaultWorkspaceName;
     }
 
     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);
 
@@ -160,7 +172,10 @@ 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;
+
+    if (*PDEBUGOVERLAY == 1) {
         startRender = std::chrono::high_resolution_clock::now();
         g_pDebugOverlay->frameData(PMONITOR);
     }
@@ -180,9 +195,14 @@ void Events::listener_monitorFrame(void* owner, void* data) {
             g_pConfigManager->performMonitorReload();
     }
 
-    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;
     }
@@ -195,9 +215,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;
     }
@@ -207,7 +225,7 @@ void Events::listener_monitorFrame(void* owner, void* data) {
         return;
     }
 
-    if (!hasChanged && DTMODE != DAMAGE_TRACKING_NONE) {
+    if (!hasChanged && *PDAMAGETRACKINGMODE != DAMAGE_TRACKING_NONE && PMONITOR->forceFullFrames == 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
@@ -215,19 +233,19 @@ void Events::listener_monitorFrame(void* owner, void* data) {
     }
 
     // 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) {
         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);
 
@@ -238,6 +256,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.
 
@@ -252,7 +273,7 @@ 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();
@@ -273,7 +294,7 @@ 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);
 
     wlr_output_set_damage(PMONITOR->output, &frameDamage);
@@ -284,7 +305,7 @@ void Events::listener_monitorFrame(void* owner, void* data) {
 
     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) {
@@ -313,14 +334,16 @@ void Events::listener_monitorDestroy(void* owner, void* data) {
 
     // Cleanup everything. Move windows back, snap cursor, shit.
     const auto BACKUPMON = &g_pCompositor->m_lMonitors.front();
-    const auto BACKUPWORKSPACE = BACKUPMON->activeWorkspace > 0 ? std::to_string(BACKUPMON->activeWorkspace) : "name:" + g_pCompositor->getWorkspaceByID(BACKUPMON->activeWorkspace)->m_szName;
 
     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);
 

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"
 
 // --------------------------------------------- //

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,6 +19,14 @@ 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) {
@@ -35,6 +43,9 @@ void Events::listener_mapWindow(void* owner, void* data) {
     PWINDOW->m_szTitle = g_pXWaylandManager->getTitle(PWINDOW);
     PWINDOW->m_fAlpha = 255.f;
 
+    // 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)

src/helpers/MiscFunctions.cpp

@@ -135,7 +135,7 @@ float getPlusMinusKeywordResult(std::string source, float relative) {
 }
 
 bool isNumber(const std::string& str) {
-    return std::ranges::all_of(str.begin(), str.end(), [](char c) { return isdigit(c) != 0; });
+    return std::ranges::all_of(str.begin(), str.end(), [](char c) { return isdigit(c) != 0 || c == '-'; });
 }
 
 bool isDirection(const std::string& arg) {
@@ -158,6 +158,12 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
         outName = WORKSPACENAME;
     } else {
         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);
 
@@ -207,7 +213,14 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
             outName = g_pCompositor->getWorkspaceByID(currentID)->m_szName;
 
         } else {
-            result = std::clamp((int)getPlusMinusKeywordResult(in, g_pCompositor->m_pLastMonitor->activeWorkspace), 1, INT_MAX);
+            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);
         }        
     }

src/helpers/Monitor.hpp

@@ -27,7 +27,9 @@ 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

src/helpers/SubsurfaceTree.cpp

@@ -89,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");
@@ -162,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;
     }

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,8 @@ struct SKeyboard {
     DYNLISTENER(keyboardKey);
     DYNLISTENER(keyboardDestroy);
 
+    bool active = false;
+
     // For the list lookup
     bool operator==(const SKeyboard& rhs) {
         return keyboard == rhs.keyboard;
@@ -151,4 +153,56 @@ 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;
+
+    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;
+
+    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;
+
+    DYNLISTENER(Attach);
+    DYNLISTENER(Button);
+    DYNLISTENER(Strip);
+    DYNLISTENER(Ring);
+    DYNLISTENER(Destroy);
+
+    bool operator==(const STabletPad& b) {
+        return wlrTabletPadV2 == b.wlrTabletPadV2;
+    }
+};

src/includes.hpp

@@ -34,56 +34,60 @@
 #define static
 
 extern "C" {
-#include "../wlroots/include/wlr/backend.h"
-#include "../wlroots/include/wlr/backend/libinput.h"
-#include "../wlroots/include/wlr/render/allocator.h"
-#include "../wlroots/include/wlr/render/wlr_renderer.h"
-#include "../wlroots/include/wlr/types/wlr_compositor.h"
-#include "../wlroots/include/wlr/types/wlr_cursor.h"
-#include "../wlroots/include/wlr/types/wlr_data_control_v1.h"
-#include "../wlroots/include/wlr/types/wlr_data_device.h"
-#include "../wlroots/include/wlr/types/wlr_export_dmabuf_v1.h"
-#include "../wlroots/include/wlr/types/wlr_linux_dmabuf_v1.h"
-#include "../wlroots/include/wlr/types/wlr_gamma_control_v1.h"
-#include "../wlroots/include/wlr/types/wlr_idle.h"
-#include "../wlroots/include/wlr/types/wlr_input_device.h"
-#include "../wlroots/include/wlr/types/wlr_keyboard.h"
-#include "../wlroots/include/wlr/types/wlr_layer_shell_v1.h"
-#include "../wlroots/include/wlr/types/wlr_matrix.h"
-#include "../wlroots/include/wlr/types/wlr_output.h"
-#include "../wlroots/include/wlr/types/wlr_output_layout.h"
-#include "../wlroots/include/wlr/types/wlr_output_management_v1.h"
-#include "../wlroots/include/wlr/types/wlr_pointer.h"
-#include "../wlroots/include/wlr/types/wlr_presentation_time.h"
-#include "../wlroots/include/wlr/types/wlr_primary_selection.h"
-#include "../wlroots/include/wlr/types/wlr_primary_selection_v1.h"
-#include "../wlroots/include/wlr/types/wlr_screencopy_v1.h"
-#include "../wlroots/include/wlr/types/wlr_seat.h"
-#include "../wlroots/include/wlr/types/wlr_server_decoration.h"
-#include "../wlroots/include/wlr/types/wlr_viewporter.h"
-#include "../wlroots/include/wlr/types/wlr_virtual_keyboard_v1.h"
-#include "../wlroots/include/wlr/types/wlr_xcursor_manager.h"
-#include "../wlroots/include/wlr/types/wlr_xdg_activation_v1.h"
-#include "../wlroots/include/wlr/types/wlr_xdg_decoration_v1.h"
-#include "../wlroots/include/wlr/types/wlr_xdg_output_v1.h"
-#include "../wlroots/include/wlr/types/wlr_xdg_shell.h"
-#include "../wlroots/include/wlr/types/wlr_subcompositor.h"
-#include "../wlroots/include/wlr/types/wlr_scene.h"
-#include "../wlroots/include/wlr/types/wlr_output_damage.h"
-#include "../wlroots/include/wlr/types/wlr_input_inhibitor.h"
-#include "../wlroots/include/wlr/types/wlr_keyboard_shortcuts_inhibit_v1.h"
-#include "../wlroots/include/wlr/types/wlr_virtual_pointer_v1.h"
-#include "../wlroots/include/wlr/types/wlr_foreign_toplevel_management_v1.h"
-#include "../wlroots/include/wlr/util/log.h"
-#include "../wlroots/include/wlr/xwayland.h"
-#include "../wlroots/include/wlr/util/region.h"
+#include <wlr/backend.h>
+#include <wlr/backend/libinput.h>
+#include <wlr/render/allocator.h>
+#include <wlr/render/wlr_renderer.h>
+#include <wlr/types/wlr_compositor.h>
+#include <wlr/types/wlr_cursor.h>
+#include <wlr/types/wlr_data_control_v1.h>
+#include <wlr/types/wlr_data_device.h>
+#include <wlr/types/wlr_export_dmabuf_v1.h>
+#include <wlr/types/wlr_linux_dmabuf_v1.h>
+#include <wlr/types/wlr_gamma_control_v1.h>
+#include <wlr/types/wlr_idle.h>
+#include <wlr/types/wlr_input_device.h>
+#include <wlr/types/wlr_keyboard.h>
+#include <wlr/types/wlr_layer_shell_v1.h>
+#include <wlr/types/wlr_matrix.h>
+#include <wlr/types/wlr_output.h>
+#include <wlr/types/wlr_output_layout.h>
+#include <wlr/types/wlr_output_management_v1.h>
+#include <wlr/types/wlr_pointer.h>
+#include <wlr/types/wlr_presentation_time.h>
+#include <wlr/types/wlr_primary_selection.h>
+#include <wlr/types/wlr_primary_selection_v1.h>
+#include <wlr/types/wlr_screencopy_v1.h>
+#include <wlr/types/wlr_seat.h>
+#include <wlr/types/wlr_server_decoration.h>
+#include <wlr/types/wlr_viewporter.h>
+#include <wlr/types/wlr_virtual_keyboard_v1.h>
+#include <wlr/types/wlr_xcursor_manager.h>
+#include <wlr/types/wlr_xdg_activation_v1.h>
+#include <wlr/types/wlr_xdg_decoration_v1.h>
+#include <wlr/types/wlr_xdg_output_v1.h>
+#include <wlr/types/wlr_xdg_shell.h>
+#include <wlr/types/wlr_subcompositor.h>
+#include <wlr/types/wlr_scene.h>
+#include <wlr/types/wlr_output_damage.h>
+#include <wlr/types/wlr_input_inhibitor.h>
+#include <wlr/types/wlr_keyboard_shortcuts_inhibit_v1.h>
+#include <wlr/types/wlr_virtual_pointer_v1.h>
+#include <wlr/types/wlr_foreign_toplevel_management_v1.h>
+#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 "../wlroots/include/wlr/render/egl.h"
-#include "../wlroots/include/wlr/render/gles2.h"
-#include "../wlroots/include/wlr/render/wlr_texture.h"
-#include "../wlroots/include/wlr/types/wlr_pointer_constraints_v1.h"
-#include "../wlroots/include/wlr/types/wlr_relative_pointer_v1.h"
+#include <wlr/render/egl.h>
+#include <wlr/render/gles2.h>
+#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>
 }
 
 #undef class
@@ -109,4 +113,4 @@ extern "C" {
 
 #include "helpers/Vector2D.hpp"
 
-#include "../ext-workspace-unstable-v1-protocol.h"
+#include "ext-workspace-unstable-v1-protocol.h"

src/layout/DwindleLayout.cpp

@@ -164,10 +164,12 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode) {
 
     if (PWORKSPACE->m_bIsSpecialWorkspace) {
         // if special, we adjust the coords a bit
-        PWINDOW->m_vRealPosition = calcPos + (calcSize - calcSize * 0.8f) / 2.f;
-        PWINDOW->m_vRealSize = calcSize * 0.8f;
+        static auto *const PSCALEFACTOR = &g_pConfigManager->getConfigValuePtr("dwindle:special_scale_factor")->floatValue;
 
-        g_pXWaylandManager->setWindowSize(PWINDOW, calcSize * 0.8f);
+        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;
@@ -515,80 +517,7 @@ void CHyprDwindleLayout::onMouseMove(const Vector2D& mousePos) {
 
             g_pXWaylandManager->setWindowSize(DRAGGINGWINDOW, DRAGGINGWINDOW->m_vRealSize.goalv());
         } 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();
+            resizeActiveWindow(TICKDELTA, DRAGGINGWINDOW);
         }
     }
 
@@ -606,6 +535,97 @@ void CHyprDwindleLayout::onMouseMove(const Vector2D& mousePos) {
     g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
 }
 
+void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, CWindow* pWindow) {
+
+    const auto PWINDOW = pWindow ? pWindow : g_pCompositor->m_pLastWindow;
+
+    if (!g_pCompositor->windowValidMapped(PWINDOW))
+        return;
+
+    const auto PNODE = getNodeFromWindow(PWINDOW);
+
+    if (!PNODE) {
+        PWINDOW->m_vRealSize.setValueAndWarp(PWINDOW->m_vRealSize.goalv() + pixResize);
+        PWINDOW->m_vRealSize.setValueAndWarp(Vector2D(std::clamp(PWINDOW->m_vRealSize.vec().x, (double)20, (double)999999), std::clamp(PWINDOW->m_vRealSize.vec().y, (double)20, (double)999999)));
+
+        g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
+
+        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);
+
+    // construct allowed movement
+    Vector2D allowedMovement = pixResize;
+    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();
+}
+
 void CHyprDwindleLayout::onWindowCreatedFloating(CWindow* pWindow) {
     wlr_box desiredGeometry = {0};
     g_pXWaylandManager->getGeometryForWindow(pWindow, &desiredGeometry);

src/layout/DwindleLayout.hpp

@@ -48,6 +48,7 @@ public:
     virtual void        recalculateWindow(CWindow*);
     virtual void        changeWindowFloatingMode(CWindow*);
     virtual void        onBeginDragWindow();
+    virtual void        resizeActiveWindow(const Vector2D&, CWindow* pWindow = nullptr);
     virtual void        onEndDragWindow();
     virtual void        onMouseMove(const Vector2D&);
     virtual void        onWindowCreatedFloating(CWindow*);

src/layout/IHyprLayout.hpp

@@ -49,6 +49,12 @@ public:
         as.
     */
     virtual void        onBeginDragWindow()                 = 0;
+    /*
+        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 window is ended being dragged
         (mouse up)

src/managers/AnimationManager.cpp

@@ -23,20 +23,22 @@ 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;
+        const auto SPEED = *av->m_pSpeed == 0 ? *PANIMSPEED : *av->m_pSpeed;
 
         // window stuff
         const auto PWINDOW = (CWindow*)av->m_pWindow;
@@ -45,28 +47,13 @@ void CAnimationManager::tick() {
 
         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};
+            WLRBOXPREV = {(int)PWINDOW->m_vRealPosition.vec().x - (int)*PBORDERSIZE - 1, (int)PWINDOW->m_vRealPosition.vec().y - (int)*PBORDERSIZE - 1, (int)PWINDOW->m_vRealSize.vec().x + 2 * (int)*PBORDERSIZE + 2, (int)PWINDOW->m_vRealSize.vec().y + 2 * (int)*PBORDERSIZE + 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());
-            }
-
-            continue;
-        }
 
         // beziers are with a switch unforto
         // TODO: maybe do something cleaner
@@ -78,6 +65,13 @@ void CAnimationManager::tick() {
         switch (av->m_eVarType) {
             case AVARTYPE_FLOAT: {
                 if (!deltazero(av->m_fValue, av->m_fGoal)) {
+
+                    // for disabled anims just warp
+                    if (av->m_pEnabled == 0 || animationsDisabled) {
+                        av->warp();
+                        break;
+                    }
+
                     const auto DELTA = av->m_fGoal - av->m_fBegun;
                     const auto BEZIER = m_mBezierCurves.find(*av->m_pBezier);
 
@@ -96,6 +90,13 @@ void CAnimationManager::tick() {
             }
             case AVARTYPE_VECTOR: {
                 if (!deltazero(av->m_vValue, av->m_vGoal)) {
+
+                    // for disabled anims just warp
+                    if (av->m_pEnabled == 0 || animationsDisabled) {
+                        av->warp();
+                        break;
+                    }
+
                     const auto DELTA = av->m_vGoal - av->m_vBegun;
                     const auto BEZIER = m_mBezierCurves.find(*av->m_pBezier);
 
@@ -114,6 +115,13 @@ void CAnimationManager::tick() {
             }
             case AVARTYPE_COLOR: {
                 if (!deltazero(av->m_cValue, av->m_cGoal)) {
+
+                    // for disabled anims just warp
+                    if (av->m_pEnabled == 0 || animationsDisabled) {
+                        av->warp();
+                        break;
+                    }
+
                     const auto DELTA = av->m_cGoal - av->m_cBegun;
                     const auto BEZIER = m_mBezierCurves.find(*av->m_pBezier);
 
@@ -152,8 +160,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

src/managers/EventManager.cpp

@@ -105,9 +105,15 @@ void CEventManager::startThread() {
 }
 
 void CEventManager::postEvent(const SHyprIPCEvent event) {
+
+    if (m_bIgnoreEvents) {
+        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

@@ -19,6 +19,8 @@ public:
 
     void startThread();
 
+    bool m_bIgnoreEvents = false;
+
 private:
 
     std::mutex eventQueueMutex;

src/managers/KeybindManager.cpp

@@ -1,5 +1,7 @@
 #include "KeybindManager.hpp"
 
+#include <regex>
+
 CKeybindManager::CKeybindManager() {
     // initialize all dispatchers
 
@@ -24,6 +26,11 @@ CKeybindManager::CKeybindManager() {
     m_mDispatchers["movecurrentworkspacetomonitor"] = moveCurrentWorkspaceToMonitor;
     m_mDispatchers["moveworkspacetomonitor"]    = moveWorkspaceToMonitor;
     m_mDispatchers["togglespecialworkspace"]    = toggleSpecialWorkspace;
+    m_mDispatchers["forcerendererreload"]       = forceRendererReload;
+    m_mDispatchers["resizeactive"]              = resizeActive;
+    m_mDispatchers["cyclenext"]                 = circleNext;
+    m_mDispatchers["focuswindowbyclass"]        = focusWindowByClass;
+    m_mDispatchers["submap"]                    = setSubmap;
 }
 
 void CKeybindManager::addKeybind(SKeybind kb) {
@@ -66,13 +73,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!
@@ -109,8 +114,17 @@ bool CKeybindManager::handleInternalKeybinds(xkb_keysym_t keysym) {
 
     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_lMonitors) {
+            g_pHyprOpenGL->destroyMonitorResources(&m); // 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;
     }
 
@@ -126,11 +140,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) {
@@ -228,9 +279,7 @@ 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.
@@ -239,9 +288,6 @@ 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);
@@ -308,8 +354,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);
 }
@@ -322,8 +367,7 @@ void CKeybindManager::fullscreenActive(std::string args) {
 
     g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(PWINDOW, args == "1" ? eFullscreenMode::FULLSCREEN_MAXIMIZED : eFullscreenMode::FULLSCREEN_FULL);
 
-    g_pXWaylandManager->setWindowFullscreen(PWINDOW, PWINDOW->m_bIsFullscreen && args == "0");
-
+    g_pXWaylandManager->setWindowFullscreen(PWINDOW, PWINDOW->m_bIsFullscreen && (args == "0" || args == ""));
     // 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)
@@ -402,6 +446,8 @@ void CKeybindManager::moveActiveToWorkspace(std::string args) {
         for (auto& m : g_pCompositor->m_lMonitors)
             m.specialWorkspaceOpen = false;
     }
+
+    g_pInputManager->refocus();
 }
 
 void CKeybindManager::moveActiveToWorkspaceSilent(std::string args) {
@@ -438,7 +484,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);
 
@@ -457,7 +503,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) {
@@ -754,6 +802,8 @@ void CKeybindManager::moveCurrentWorkspaceToMonitor(std::string args) {
 }
 
 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);
@@ -826,4 +876,81 @@ void CKeybindManager::toggleSpecialWorkspace(std::string args) {
     }
 
     g_pInputManager->refocus();
-}
+}
+
+void CKeybindManager::forceRendererReload(std::string args) {
+    for (auto& m : g_pCompositor->m_lMonitors) {
+        auto rule = g_pConfigManager->getMonitorRuleFor(m.szName);
+        g_pHyprRenderer->applyMonitorRule(&m, &rule, true);
+    }
+}
+
+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 (!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::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::focusWindowByClass(std::string clazz) {
+    std::regex classCheck(clazz);
+
+    for (auto& w : g_pCompositor->m_lWindows) {
+        const auto windowClass = g_pXWaylandManager->getAppIDClass(&w);
+
+        if (!std::regex_search(windowClass, classCheck))
+            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);
+
+        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,9 @@ 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);
 
     // -------------- Dispatchers -------------- //
     static void         killActive(std::string);
@@ -54,6 +56,11 @@ private:
     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         circleNext(std::string);
+    static void         focusWindowByClass(std::string);
+    static void         setSubmap(std::string);
 
     friend class CCompositor;
 };

src/managers/XWaylandManager.cpp

@@ -94,6 +94,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 +124,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) {

src/managers/input/InputManager.cpp

@@ -1,16 +1,17 @@
 #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);
 }
@@ -34,6 +35,8 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
     Vector2D mouseCoords = getMouseCoordsInternal();
     const auto PMONITOR = g_pCompositor->getMonitorFromCursor();
 
+    bool didConstraintOnCursor = false;
+
     // constraints
     // All constraints TODO: multiple mice?
     if (g_pCompositor->m_sSeat.mouse->currentConstraint) {
@@ -49,23 +52,25 @@ 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)) {
@@ -83,6 +88,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;
 
@@ -115,7 +123,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
             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);
-                
+
                 if (!pFoundWindow->m_bIsX11) {
                     foundSurface = g_pCompositor->vectorWindowToSurface(mouseCoords, pFoundWindow, surfaceCoords);
                 } else {
@@ -151,7 +159,6 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
     if (!foundSurface)
         foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND], &surfaceCoords);
 
-
     if (!foundSurface) {
         wlr_xcursor_manager_set_cursor_image(g_pCompositor->m_sWLRXCursorMgr, "left_ptr", g_pCompositor->m_sWLRCursor);
 
@@ -165,20 +172,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
         g_pCompositor->focusSurface(foundSurface);
 
     wlr_seat_pointer_notify_enter(g_pCompositor->m_sSeat.seat, foundSurface, surfaceLocal.x, surfaceLocal.y);
@@ -236,28 +253,24 @@ void CInputManager::newKeyboard(wlr_input_device* keyboard) {
 
     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));
 
     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;
+
+    setKeyboardLayout();
+
     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() {
@@ -285,30 +298,31 @@ void CInputManager::setKeyboardLayout() {
         return;
     }
 
-    const auto PLASTKEEB = wlr_seat_get_keyboard(g_pCompositor->m_sSeat.seat);
+    const auto PLASTKEEB = m_pActiveKeyboard->keyboard->keyboard;
 
-    // TODO: configure devices one by one
-    for (auto& k : m_lKeyboards) {
-        wlr_keyboard_set_keymap(k.keyboard->keyboard, KEYMAP);
+    if (!PLASTKEEB) {
+        xkb_keymap_unref(KEYMAP);
+        xkb_context_unref(CONTEXT);
 
-        wlr_seat_set_keyboard(g_pCompositor->m_sSeat.seat, k.keyboard->keyboard);
-        
-        wlr_keyboard_modifiers wlrMods = {0};
-
-        if (g_pConfigManager->getInt("input:numlock_by_default") == 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_seat_keyboard_notify_modifiers(g_pCompositor->m_sSeat.seat, &wlrMods);
-        }
+        Debug::log(ERR, "No Seat Keyboard???");
+        return;
+    }
+
+    wlr_keyboard_set_keymap(PLASTKEEB, KEYMAP);
+
+    wlr_keyboard_modifiers wlrMods = {0};
+
+    if (g_pConfigManager->getInt("input:numlock_by_default") == 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(g_pInputManager->m_pActiveKeyboard->keyboard->keyboard, 0, 0, wlrMods.locked, 0);
     }
-        
-    wlr_seat_set_keyboard(g_pCompositor->m_sSeat.seat, PLASTKEEB);    
 
     xkb_keymap_unref(KEYMAP);
     xkb_context_unref(CONTEXT);
@@ -325,11 +339,30 @@ void CInputManager::newMouse(wlr_input_device* mouse) {
     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 (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 (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 (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, g_pConfigManager->getInt("input:touchpad:natural_scroll"));
+            else
+                libinput_device_config_scroll_set_natural_scroll_enabled(LIBINPUTDEV, 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);
@@ -351,6 +384,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);
 }
 
@@ -490,3 +534,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

@@ -1,9 +1,9 @@
 #pragma once
 
-#include "../defines.hpp"
+#include "../../defines.hpp"
 #include <list>
-#include "../helpers/WLClasses.hpp"
-#include "../Window.hpp"
+#include "../../helpers/WLClasses.hpp"
+#include "../../Window.hpp"
 
 class CInputManager {
 public:
@@ -28,6 +28,7 @@ public:
     void            setKeyboardLayout();
 
     void            updateDragIcon();
+    void            updateCapabilities(wlr_input_device*);
 
 
     // for dragging floating windows
@@ -40,9 +41,24 @@ public:
     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;
+
    private:
 
+    uint32_t        m_uiCapabilities = 0;
+
     void            mouseMoveUnified(uint32_t, bool refocus = false);
+
+    STabletTool*    ensureTabletToolPresent(wlr_tablet_tool*);
 };
 
 inline std::unique_ptr<CInputManager> g_pInputManager;

src/managers/input/Tablets.cpp

@@ -0,0 +1,229 @@
+#include "InputManager.hpp"
+#include "../../Compositor.hpp"
+
+void CInputManager::newTabletTool(wlr_input_device* pDevice) {
+    const auto PNEWTABLET = &m_lTablets.emplace_back();
+
+    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();
+
+    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

@@ -240,6 +240,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,12 +268,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);
-    glUniform1i(glGetUniformLocation(m_shQUAD.program, "primitiveMultisample"), (int)(g_pConfigManager->getInt("decoration:multisample_edges") == 1 && round != 0));
+    glUniform1i(glGetUniformLocation(m_shQUAD.program, "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);
@@ -277,8 +283,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);
@@ -297,15 +303,15 @@ void CHyprOpenGLImpl::renderTexture(wlr_texture* tex, wlr_box* pBox, float alpha
     renderTexture(CTexture(tex), pBox, alpha, round);
 }
 
-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 border, bool allowPrimary) {
     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, border, false, allowPrimary);
 
     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, bool noAA) {
+void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_box* pBox, float alpha, pixman_region32_t* damage, int round, bool discardOpaque, bool border, bool noAA, bool allowPrimary) {
     RASSERT(m_RenderData.pMonitor, "Tried to render texture without begin()!");
     RASSERT((tex.m_iTexID > 0), "Attempted to draw NULL texture!");
 
@@ -339,6 +345,23 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_b
             RASSERT(false, "tex.m_iTarget unsupported!");
     }
 
+    // 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);
+
+        // hacky fix to fix broken borders.
+        // TODO: this is kinda slow... question mark?
+        renderRect(pBox, CColor(0, 0, 0, 0), round);
+
+        glDisable(GL_STENCIL_TEST);
+    }
+
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(tex.m_iTarget, tex.m_iTexID);
 
@@ -357,31 +380,33 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_b
     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;
+    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);
-    glUniform1i(glGetUniformLocation(shader->program, "primitiveMultisample"), (int)(g_pConfigManager->getInt("decoration:multisample_edges") == 1 && round != 0 && !border && !noAA));
+    glUniform1i(glGetUniformLocation(shader->program, "primitiveMultisample"), (int)(*PMULTISAMPLEEDGES == 1 && round != 0 && !border && !noAA));
 
     glVertexAttribPointer(shader->posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
-    glVertexAttribPointer(shader->texAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
+
+    if (allowPrimary && m_RenderData.renderingPrimarySurface && 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];
@@ -391,6 +416,8 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_b
     }
 
     if (border) {
+        glEnable(GL_STENCIL_TEST);
+
         glStencilFunc(GL_EQUAL, 1, -1);
         glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
     }
@@ -405,8 +432,9 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_b
     // some other func might be using it.
     if (border) {
         auto BORDERCOL = m_pCurrentWindow->m_cRealBorderColor.col();
+        static auto *const PBORDERSIZE = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
         BORDERCOL.a *= alpha / 255.f;
-        renderBorder(pBox, BORDERCOL, g_pConfigManager->getInt("general:border_size"), round);
+        renderBorder(pBox, BORDERCOL, *PBORDERSIZE, round);
         glStencilMask(-1);
         glStencilFunc(GL_ALWAYS, 1, 0xFF);
         glDisable(GL_STENCIL_TEST);
@@ -434,14 +462,14 @@ 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;
@@ -466,7 +494,7 @@ 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(glGetUniformLocation(pShader->program, "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));
         else
@@ -510,12 +538,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
     }
@@ -535,8 +563,11 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, wlr_box* p
 void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox, float a, wlr_surface* pSurface, int round, bool border) {
     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))) {
+        renderTexture(tex, pBox, a, round, false, border, true);
         return;
     }
 
@@ -558,8 +589,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, border); // 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);
@@ -590,17 +623,27 @@ 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, false, true);
 
         // render the window, but clear stencil
         glClearStencil(0);
         glClear(GL_STENCIL_BUFFER_BIT);
 
-        // and write to it
+        // draw window
+        glDisable(GL_STENCIL_TEST);
+        renderTextureInternalWithDamage(tex, pBox, a, &damage, round, false, false, true, true);
+        glEnable(GL_STENCIL_TEST);
+
+        // prep stencil for border
         glStencilFunc(GL_ALWAYS, 1, -1);
         glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
 
-        renderTextureInternalWithDamage(tex, pBox, a, &damage, round, false, false, true);
+        if (border) {
+            // hacky fix to fix broken borders.
+            // TODO: this is kinda slow... question mark?
+            renderRectWithDamage(pBox, CColor(0,0,0,0), &damage, round);
+        }
 
         // then stop
         glStencilFunc(GL_EQUAL, 1, -1);
@@ -614,7 +657,8 @@ void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox,
     } else {
         auto BORDERCOL = m_pCurrentWindow->m_cRealBorderColor.col();
         BORDERCOL.a *= a / 255.f;
-        renderBorder(pBox, BORDERCOL, g_pConfigManager->getInt("general:border_size"), round);
+        static auto *const PBORDERSIZE = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
+        renderBorder(pBox, BORDERCOL, *PBORDERSIZE, round);
     }
     
     glDisable(GL_STENCIL_TEST);

src/render/OpenGL.hpp

@@ -34,6 +34,10 @@ struct SCurrentRenderData {
     float       projection[9];
 
     pixman_region32_t* pDamage = nullptr;
+
+    bool        renderingPrimarySurface = false;
+    Vector2D    primarySurfaceUVTopLeft = Vector2D(-1, -1);
+    Vector2D    primarySurfaceUVBottomRight = Vector2D(-1, -1);
 };
 
 struct SMonitorRenderData {
@@ -53,8 +57,9 @@ public:
     void    end();
 
     void    renderRect(wlr_box*, const CColor&, int round = 0);
+    void    renderRectWithDamage(wlr_box*, const CColor&, pixman_region32_t* damage, 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    renderTexture(const CTexture&, wlr_box*, float a, int round = 0, bool discardOpaque = false, bool border = false, bool allowPrimary = false);
     void    renderTextureWithBlur(const CTexture&, wlr_box*, float a, wlr_surface* pSurface, int round = 0, bool border = false);
 
     void    makeWindowSnapshot(CWindow*);
@@ -110,7 +115,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, bool noAA = false);
+    void                    renderTextureInternalWithDamage(const CTexture&, wlr_box* pBox, float a, pixman_region32_t* damage, int round = 0, bool discardOpaque = false, bool border = false, bool noAA = false, bool allowPrimary = false);
     void                    renderBorder(wlr_box*, const CColor&, int thick = 1, int round = 0);
 };
 

src/render/Renderer.cpp

@@ -19,10 +19,16 @@ void renderSurface(struct wlr_surface* surface, int x, int y, void* data) {
     }
     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)
+    float rounding = RDATA->dontRound ? 0 : RDATA->rounding == -1 ? *PROUNDING : RDATA->rounding;
+
+    g_pHyprOpenGL->m_RenderData.renderingPrimarySurface = false;
+
+    if (RDATA->surface && surface == RDATA->surface) {
+        g_pHyprOpenGL->m_RenderData.renderingPrimarySurface = true;
         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);
 
@@ -140,6 +146,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,
@@ -147,7 +155,7 @@ 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);
     renderdata.rounding = pWindow->m_sAdditionalConfigData.rounding;
 
     // apply window special data
@@ -162,8 +170,30 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, SMonitor* pMonitor, timespec*
     for (auto& wd : pWindow->m_dWindowDecorations)
         wd->draw(pMonitor);
 
+    if (!pWindow->m_bIsX11) {
+
+        // To everyone who makes apps with improperly aligned surfaces,
+        // For example chromium, or GTK devs who allow shadows on windows,
+        // a sincere FUCK YOU.
+
+        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);
+        }
+    }
+
     wlr_surface_for_each_surface(g_pXWaylandManager->getWindowSurface(pWindow), renderSurface, &renderdata);
 
+    g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
+    g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
+
     if (pWindow->m_bIsX11) {
         if (pWindow->m_uSurface.xwayland->surface) {
             wlr_surface_for_each_surface(pWindow->m_uSurface.xwayland->surface, renderSurface, &renderdata);
@@ -533,7 +563,9 @@ void CHyprRenderer::damageSurface(wlr_surface* pSurface, double x, double y) {
 
     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);
 }
 
@@ -551,12 +583,14 @@ void CHyprRenderer::damageWindow(CWindow* pWindow) {
             wlr_output_damage_add_box(m.damage, &fixedDamageBox);
         }
 
-        if (g_pConfigManager->getInt("debug:log_damage"))
+        static auto *const PLOGDAMAGE = &g_pConfigManager->getConfigValuePtr("debug:log_damage")->intValue;
+
+        if (*PLOGDAMAGE)
             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};
+        static auto *const PBORDERSIZE = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
+        wlr_box damageBox = { pWindow->m_vRealPosition.vec().x - *PBORDERSIZE - 1, pWindow->m_vRealPosition.vec().y - *PBORDERSIZE - 1, pWindow->m_vRealSize.vec().x + 2 * *PBORDERSIZE + 2, pWindow->m_vRealSize.vec().y + 2 * *PBORDERSIZE + 2};
         for (auto& m : g_pCompositor->m_lMonitors) {
             wlr_box fixedDamageBox = damageBox;
             fixedDamageBox.x -= m.vecPosition.x;
@@ -565,7 +599,9 @@ void CHyprRenderer::damageWindow(CWindow* pWindow) {
             wlr_output_damage_add_box(m.damage, &fixedDamageBox);
         }
 
-        if (g_pConfigManager->getInt("debug:log_damage"))
+        static auto *const PLOGDAMAGE = &g_pConfigManager->getConfigValuePtr("debug:log_damage")->intValue;
+
+        if (*PLOGDAMAGE)
             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);
     }
 }
@@ -574,7 +610,9 @@ 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());
 }
 
@@ -585,7 +623,9 @@ void CHyprRenderer::damageBox(wlr_box* pBox) {
         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);
 }
 
@@ -717,5 +757,5 @@ void CHyprRenderer::applyMonitorRule(SMonitor* pMonitor, SMonitorRule* pMonitorR
     arrangeLayersForMonitor(pMonitor->ID);
 
     // frame skip
-    pMonitor->needsFrameSkip = true;
+    pMonitor->framesToSkip = 1;
 }

src/render/Shaders.hpp

@@ -2,6 +2,147 @@
 
 #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;
@@ -27,6 +168,7 @@ uniform vec2 fullSize;
 uniform float radius;
 
 uniform int primitiveMultisample;
+uniform int ignoreCorners;
 
 void main() {
 	if (radius == 0.0) {
@@ -36,122 +178,7 @@ void main() {
 
     vec2 pixCoord = fullSize * v_texcoord;
 
-	if (pixCoord[0] < topLeft[0]) {
-		// we're close left
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-
-			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 = v_color * distances;
-					return;
-				}
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-
-			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 = v_color * distances;
-					return;
-				}
-			}
-		}
-	}
-	else if (pixCoord[0] > bottomRight[0]) {
-		// we're close right
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-
-			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 = v_color * distances;
-					return;
-				}
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-
-			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 = v_color * distances;
-					return;
-				}
-			}
-		}
-	}
+	)#" + ROUNDED_SHADER_FUNC("v_color") + R"#(
 
 	gl_FragColor = v_color;
 })#";
@@ -181,6 +208,7 @@ uniform float radius;
 uniform int discardOpaque;
 
 uniform int primitiveMultisample;
+uniform int ignoreCorners;
 
 void main() {
 
@@ -193,122 +221,8 @@ void main() {
 
 	vec2 pixCoord = fullSize * v_texcoord;
 
-	if (pixCoord[0] < topLeft[0]) {
-		// we're close left
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-
-			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 = pixColor * distances;
-					return;
-				}
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-
-			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 = pixColor * distances;
-					return;
-				}
-			}
-		}
-	}
-	else if (pixCoord[0] > bottomRight[0]) {
-		// we're close right
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-
-			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 = pixColor * distances;
-					return;
-				}
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-
-			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 = pixColor * distances;
-					return;
-				}
-			}
-		}
-	}
+	)#" + ROUNDED_SHADER_FUNC("pixColor") +
+                                          R"#(
 
 	gl_FragColor = pixColor * alpha;
 })#";
@@ -327,6 +241,7 @@ uniform float radius;
 uniform int discardOpaque;
 
 uniform int primitiveMultisample;
+uniform int ignoreCorners;
 
 void main() {
 
@@ -339,122 +254,7 @@ void main() {
 	
 	vec2 pixCoord = fullSize * v_texcoord;
 
-	if (pixCoord[0] < topLeft[0]) {
-		// we're close left
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-
-			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 = pixColor * distances;
-					return;
-				}
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-
-			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 = pixColor * distances;
-					return;
-				}
-			}
-		}
-	}
-	else if (pixCoord[0] > bottomRight[0]) {
-		// we're close right
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-
-			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 = pixColor * distances;
-					return;
-				}
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-
-			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 = pixColor * distances;
-					return;
-				}
-			}
-		}
-	}
+	)#" + ROUNDED_SHADER_FUNC("pixColor") + R"#(
 
 	gl_FragColor = pixColor * alpha;
 })#";
@@ -522,6 +322,7 @@ uniform float radius;
 uniform int discardOpaque;
 
 uniform int primitiveMultisample;
+uniform int ignoreCorners;
 
 void main() {
 
@@ -534,122 +335,7 @@ void main() {
 
 	vec2 pixCoord = fullSize * v_texcoord;
 
-	if (pixCoord[0] < topLeft[0]) {
-		// we're close left
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-
-			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 = pixColor * distances;
-					return;
-				}
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-
-			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 = pixColor * distances;
-					return;
-				}
-			}
-		}
-	}
-	else if (pixCoord[0] > bottomRight[0]) {
-		// we're close right
-		if (pixCoord[1] < topLeft[1]) {
-			// top
-
-			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 = pixColor * distances;
-					return;
-				}
-			}
-		} else if (pixCoord[1] > bottomRight[1]) {
-			// bottom
-
-			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 = pixColor * distances;
-					return;
-				}
-			}
-		}
-	}
+	)#" + 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>