[gha] bump flake inputs

add input:kb_file option to use a .xkb file.

.github/workflows/nix-build.yaml

@@ -13,9 +13,13 @@ jobs:
     - name: Install nix
       uses: cachix/install-nix-action@v17
       with:
-        install_url: https://releases.nixos.org/nix/nix-2.8.0/install
+        install_url: https://releases.nixos.org/nix/nix-2.10.3/install
         extra_nix_config: |
           auto-optimise-store = true
           experimental-features = nix-command flakes
-    - name: Build HyprLand with default settings
+    - uses: cachix/cachix-action@v10
+      with:
+        name: hyprland
+        authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
+    - name: Build Hyprland with default settings
       run: nix build --print-build-logs

.github/workflows/release.yaml

@@ -0,0 +1,38 @@
+name: Release artifacts
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  source-tarball:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Hyprland
+        id: checkout
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      - name: Create tarball with submodules
+        id: tar
+        run: tar -czv --owner=0 --group=0 --no-same-owner --no-same-permissions -f source.tar.gz *
+
+      - id: whatrelease
+        name: Get latest release
+        uses: pozetroninc/github-action-get-latest-release@master
+        with:
+          owner: hyprwm
+          repo: Hyprland
+          excludes: prerelease, draft
+
+      - name: Upload to release
+        id: upload
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: source.tar.gz
+          asset_name: source-${{ steps.whatrelease.outputs.release }}.tar.gz
+          tag: ${{ steps.whatrelease.outputs.release }}
+          overwrite: true

.gitignore

@@ -12,6 +12,8 @@ _deps
 build/
 result
 /.vscode/
+.envrc
+.cache
 
 *.o
 *-protocol.c

CMakeLists.txt

@@ -37,7 +37,7 @@ execute_process(
 
 include_directories(. PRIVATE "subprojects/wlroots/include/")
 include_directories(. PRIVATE "subprojects/wlroots/build/include/")
-add_compile_options(-std=c++20 -DWLR_USE_UNSTABLE )
+add_compile_options(-std=c++23 -DWLR_USE_UNSTABLE )
 add_compile_options(-Wall -Wextra -Wno-unused-parameter -Wno-unused-value -Wno-missing-field-initializers -Wno-narrowing)
 find_package(Threads REQUIRED)
 

Makefile

@@ -9,6 +9,8 @@ PKGS = wlroots wayland-server xcb xkbcommon libinput
 CFLAGS += $(foreach p,$(PKGS),$(shell pkg-config --cflags $(p)))
 LDLIBS += $(foreach p,$(PKGS),$(shell pkg-config --libs $(p)))
 
+DATE=$(shell date "+%d %b %Y")
+
 xdg-shell-protocol.h:
 	$(WAYLAND_SCANNER) server-header \
 		$(WAYLAND_PROTOCOLS)/stable/xdg-shell/xdg-shell.xml $@
@@ -79,21 +81,31 @@ idle-protocol.c:
 
 idle-protocol.o: idle-protocol.h
 
+wlr-output-power-management-unstable-v1-protocol.h:
+	$(WAYLAND_SCANNER) server-header \
+		protocols/wlr-output-power-management-unstable-v1.xml $@
+
+wlr-output-power-management-unstable-v1-protocol.c:
+	$(WAYLAND_SCANNER) private-code \
+		protocols/wlr-output-power-management-unstable-v1.xml $@
+
+wlr-output-power-management-unstable-v1-protocol.o: wlr-output-power-management-unstable-v1-protocol.h
+
 legacyrenderer:
 	mkdir -p build && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DLEGACY_RENDERER:STRING=true -H./ -B./build -G Ninja
-	cmake --build ./build --config Release --target all -j 10
+	cmake --build ./build --config Release --target all -j $(nproc)
 
 legacyrendererdebug:
 	mkdir -p build && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Debug -DLEGACY_RENDERER:STRING=true -H./ -B./build -G Ninja
-	cmake --build ./build --config Release --target all -j 10
+	cmake --build ./build --config Release --target all -j $(nproc)
 
 release:
 	mkdir -p build && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -H./ -B./build -G Ninja
-	cmake --build ./build --config Release --target all -j 10
+	cmake --build ./build --config Release --target all -j $(nproc)
 
 debug:
 	mkdir -p build && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Debug -H./ -B./build -G Ninja
-	cmake --build ./build --config Debug --target all -j 10
+	cmake --build ./build --config Debug --target all -j $(nproc)
 
 clear:
 	rm -rf build
@@ -107,11 +119,13 @@ all:
 	cd ./hyprctl && make all && cd ..
 
 install:
-	[ ! -d /usr/include/wlr ] || mv /usr/include/wlr /usr/include/wlrBackup
-	[ ! -f /usr/lib/libwlroots.so ] || mv /usr/lib/libwlroots.so /usr/lib/libwlroots.so.backup
-	[ ! -f /usr/lib/pkgconfig/wlroots.pc ] || mv /usr/lib/pkgconfig/wlroots.pc /usr/lib/pkgconfig/wlroots.pc.backup
+	make clear
+	make fixwlr
+	cd ./subprojects/wlroots && meson build/ --buildtype=release && ninja -C build/ && cp ./build/libwlroots.so.11032 /usr/lib/ && cd ../..
+	make protocols
+	make release
+	cd hyprctl && make all && cd ..
 
-	make all
 	mkdir -p ${PREFIX}/share/wayland-sessions
 	cp ./example/hyprland.desktop ${PREFIX}/share/wayland-sessions/
 	mkdir -p ${PREFIX}/bin
@@ -122,13 +136,6 @@ install:
 	cp ./assets/wall_4K.png ${PREFIX}/share/hyprland
 	cp ./assets/wall_8K.png ${PREFIX}/share/hyprland
 
-	rm -rf /usr/include/wlr
-	rm -f /usr/lib/libwlroots.so
-	rm -f /usr/lib/pkgconfig/wlroots.pc
-	[ ! -d /usr/include/wlrBackup ] || mv /usr/include/wlrBackup /usr/include/wlr
-	[ ! -f /usr/lib/libwlroots.so.backup ] || mv -f /usr/lib/libwlroots.so.backup /usr/lib/libwlroots.so
-	[ ! -f /usr/lib/pkgconfig/wlroots.pc.backup ] || mv -f /usr/lib/pkgconfig/wlroots.pc.backup /usr/lib/pkgconfig/wlroots.pc
-
 uninstall:
 	rm -f ${PREFIX}/share/wayland-sessions/hyprland.desktop
 	rm -f ${PREFIX}/bin/Hyprland
@@ -136,7 +143,7 @@ uninstall:
 	rm -f /usr/lib/libwlroots.so.11032
 	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 tablet-unstable-v2-protocol.o
+protocols: xdg-shell-protocol.o wlr-layer-shell-unstable-v1-protocol.o wlr-screencopy-unstable-v1-protocol.o idle-protocol.o ext-workspace-unstable-v1-protocol.o pointer-constraints-unstable-v1-protocol.o tablet-unstable-v2-protocol.o wlr-output-power-management-unstable-v1-protocol.o
 
 fixwlr:
 	sed -i -E 's/(soversion = 11)([^032]|$$)/soversion = 11032/g' subprojects/wlroots/meson.build
@@ -152,3 +159,20 @@ config:
 	cd subprojects/wlroots && ninja -C build/
 
 	cd subprojects/wlroots && ninja -C build/ install
+
+man:
+	pandoc ./docs/Hyprland.1.rst \
+		--standalone \
+		--variable=header:"Hyprland User Manual" \
+		--variable=date:"${DATE}" \
+		--variable=section:1 \
+		--from rst \
+		--to man | gzip -c > /usr/share/man/man1/Hyprland.1.gz
+
+	pandoc ./docs/hyprctl.1.rst \
+		--standalone \
+		--variable=header:"hyprctl User Manual" \
+		--variable=date:"${DATE}" \
+		--variable=section:1 \
+		--from rst \
+		--to man | gzip -c > /usr/share/man/man1/hyprctl.1.gz

README.md

@@ -1,6 +1,6 @@
 <div align = center>
 
-<img src="https://raw.githubusercontent.com/vaxerski/Hyprland/main/assets/header.svg" width="1000" height="500" alt="banner">
+<img src="https://raw.githubusercontent.com/vaxerski/Hyprland/main/assets/header.svg" width="750" height="300" alt="banner">
 
 <br>
 
@@ -17,9 +17,7 @@
 
 Hyprland is a dynamic tiling Wayland compositor based on wlroots that doesn't sacrifice on its looks.
 
-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.
+It supports multiple layouts, fancy effects, has a very flexible IPC model allowing for a lot of customization, and more.
 <br>
 <br>
 
@@ -57,6 +55,7 @@ Try it out and report bugs / suggestions!
 - Drop shadows
 - Fully dynamic workspaces
 - Closely follows `wlroots-git`
+- Global keybinds passed to your apps of choice
 - Bundled wlroots
 - Window/layer fade in/out
 - Tiling/pseudotiling/floating/fullscreen windows
@@ -69,6 +68,8 @@ Try it out and report bugs / suggestions!
 - Full damage tracking
 - Docks support
 - Drawing tablet support
+- Native IME + Input panels support
+- and much more...
 
 <br>
 <br>
@@ -122,18 +123,18 @@ Try it out and report bugs / suggestions!
 
 <!----------------------------------------------------------------------------->
 
-[Configure]: https://github.com/vaxerski/Hyprland/wiki/Configuring-Hyprland
+[Configure]: https://wiki.hyprland.org/Configuring/Configuring-Hyprland/
 [Discord]: https://discord.gg/hQ9XvMUjjr
-[Stars]: https://starchart.cc/vaxerski/Hyprland
-[Hypr]: https://github.com/vaxerski/Hypr
+[Stars]: https://starchart.cc/hyprwm/Hyprland
+[Hypr]: https://github.com/hyprwm/Hypr
 
-[Pull Requests]: https://github.com/vaxerski/Hyprland/pulls
-[Issues]: https://github.com/vaxerski/Hyprland/issues
-[Todo]: https://github.com/vaxerski/Hyprland/projects?type=beta
+[Pull Requests]: https://github.com/hyprwm/Hyprland/pulls
+[Issues]: https://github.com/hyprwm/Hyprland/issues
+[Todo]: https://github.com/hyprwm/Hyprland/projects?type=beta
 
-[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
+[Contribute]: https://wiki.hyprland.org/Contributing-and-Debugging/
+[Install]: https://wiki.hyprland.org/Getting-Started/Installation/
+[Quick Start]: https://wiki.hyprland.org/Getting-Started/Quick-start/
 [License]: LICENSE
 
 
@@ -149,19 +150,19 @@ Try it out and report bugs / suggestions!
 <!----------------------------------{ Images }--------------------------------->
 
 [Stars Preview]: https://starchart.cc/vaxerski/Hyprland.svg
-[Preview A]: https://i.imgur.com/NbrTnZH.png
-[Preview B]: https://i.imgur.com/ZA4Fa8R.png
-[Preview C]: https://i.imgur.com/BpXxM8H.png
+[Preview A]: https://i.imgur.com/sCafdKQ.png
+[Preview B]: https://i.imgur.com/NbrTnZH.png
+[Preview C]: https://i.imgur.com/ZA4Fa8R.png
 
 
 <!----------------------------------{ Badges }--------------------------------->
 
-[Badge Workflow]: https://github.com/vaxerski/Hyprland/actions/workflows/ci.yaml/badge.svg
+[Badge Workflow]: https://github.com/hyprwm/Hyprland/actions/workflows/ci.yaml/badge.svg
 
 [Badge Discord]: https://img.shields.io/badge/Join%20the-Discord%20server-6666ff
-[Badge Issues]: https://img.shields.io/github/issues/vaxerski/Hyprland
-[Badge Pull Requests]: https://img.shields.io/github/issues-pr/vaxerski/Hyprland
-[Badge Language]: https://img.shields.io/github/languages/top/vaxerski/Hyprland
-[Badge License]: https://img.shields.io/github/license/vaxerski/Hyprland
-[Badge Lines]: https://img.shields.io/tokei/lines/github/vaxerski/Hyprland
+[Badge Issues]: https://img.shields.io/github/issues/hyprwm/Hyprland
+[Badge Pull Requests]: https://img.shields.io/github/issues-pr/hyprwm/Hyprland
+[Badge Language]: https://img.shields.io/github/languages/top/hyprwm/Hyprland
+[Badge License]: https://img.shields.io/github/license/hyprwm/Hyprland
+[Badge Lines]: https://img.shields.io/tokei/lines/github/hyprwm/Hyprland
 [Badge Hi Mom]: https://img.shields.io/badge/Hi-mom!-ff69b4

docs/Hyprland.1.rst

@@ -0,0 +1,58 @@
+:title: Hyprland
+:author: Vaxerski <*https://github.com/vaxerski*>
+
+NAME
+====
+
+Hyprland - Dynamic tiling Wayland compositor
+
+SYNOPSIS
+========
+
+**Hyprland** [*arg [...]*].
+
+DESCRIPTION
+===========
+
+**Hyprland** is a dynamic tiling Wayland compositor based on
+wlroots that doesn't sacrifice on its looks.
+
+You can launch Hyprland by either going into a TTY and
+executing **Hyprland**, or with a login manager.
+
+NOTICE
+======
+
+Hyprland is still in pretty early development compared to some other Wayland compositors.
+
+Although Hyprland is pretty stable, it may have some bugs.
+
+CONFIGURATION
+=============
+
+For configuration information please see <*https://github.com/hyprwm/Hyprland/wiki*>.
+
+OPTIONS
+=======
+
+**-h**, **--help**
+    Show command usage.
+
+**-c**, **--config**
+    Specify config file to use.
+
+BUGS
+====
+
+Submit bug reports and request features online at:
+    <*https://github.com/hyprwm/Hyprland/issues*>
+
+SEE ALSO
+========
+
+Sources at: <*https://github.com/hyprwm/Hyprland*>
+
+COPYRIGHT
+=========
+
+Copyright (c) 2022, vaxerski

docs/ISSUE_GUIDELINES.md

@@ -26,6 +26,7 @@ If your bug is one that doesn't crash Hyprland, but feels like invalid behavior,
 If your bug crashes Hyprland, append additionally:
 - The Hyprland log
 - Coredump / Coredump analysis (with a stacktrace)
+- Your config
 
 **Important**: Please do NOT use any package for reporting bugs! Clone and compile from source.
 

docs/hyprctl.1.rst

@@ -0,0 +1,121 @@
+:title: hyprctl(1)
+:author: Vaxerski <*https://github.com/vaxerski*>
+
+NAME
+====
+
+hyprctl - Utility for controlling parts of Hyprland from a CLI or a script
+
+SYNOPSIS
+========
+
+**hyprctl** [*(opt)flags*] [**command**] [*(opt)args*]
+
+DESCRIPTION
+===========
+
+**hyprctl** is a utility for controlling some parts of the compositor from a CLI or a script.
+
+CONTROL COMMANDS
+================
+
+**dispatch**
+
+    Call a dispatcher with an argument.
+
+    An argument must be present.
+    For dispatchers without parameters it can be anything.
+
+    Returns: *ok* on success, and an error message on failure.
+
+    Examples:
+        **hyprctl** *dispatch exec kitty*
+
+        **hyprctl** *dispatch pseudo x*
+
+**keyword**
+
+    Set a config keyword dynamically.
+
+    Returns: *ok* on success, and an error message on failure.
+
+    Examples:
+        **hyprctl** *keyword bind SUPER,0,pseudo*
+
+        **hyprctl** *keyword general:border_size 10*
+
+**reload**
+
+    Force a reload of the config file.
+
+**kill**
+
+    Enter kill mode, where you can kill an app by clicking on it.
+    You can exit by pressing ESCAPE.
+
+INFO COMMANDS
+=============
+
+**version**
+
+    Prints the Hyprland version, flags, commit and branch of build.
+
+**monitors**
+
+    Lists all the outputs with their properties.
+
+**workspaces**
+
+    Lists all workspaces with their properties.
+
+**clients**
+
+    Lists all windows with their properties.
+
+**devices**
+
+    Lists all connected input devices.
+
+**activewindow**
+
+    Returns the active window name.
+
+**layers**
+
+    Lists all the layers.
+
+**splash**
+
+    Returns the current random splash.
+
+OPTIONS
+=======
+
+**--batch**
+
+    Specify a batch of commands to execute.
+
+    Example:
+        **hyprctl** *--batch "keyword general:border_size 2 ; keyword general:gaps_out 20"*
+
+        *;* separates the commands.
+
+**-j**
+
+    Outputs information in JSON.
+
+BUGS
+====
+
+Submit bug reports and request features online at:
+    <*https://github.com/hyprwm/Hyprland/issues*>
+
+SEE ALSO
+========
+
+Sources at: <*https://github.com/hyprwm/Hyprland*>
+
+COPYRIGHT
+=========
+
+Copyright (c) 2022, vaxerski

example/hyprland.conf

@@ -3,10 +3,16 @@
 #
 # Refer to the wiki for more information.
 
-monitor=,1280x720@60,0x0,1
+#
+# Please note not all available settings / options are set here.
+# For a full list, see the wiki (basic and advanced configuring)
+#
+
+monitor=,preferred,auto,1
 workspace=DP-1,1
 
 input {
+    kb_file=
     kb_layout=
     kb_variant=
     kb_model=
@@ -14,6 +20,10 @@ input {
     kb_rules=
 
     follow_mouse=1
+
+    touchpad {
+        natural_scroll=no
+    }
 }
 
 general {
@@ -44,8 +54,8 @@ decoration {
 animations {
     enabled=1
     animation=windows,1,7,default
-    animation=borders,1,10,default
-    animation=fadein,1,10,default
+    animation=border,1,10,default
+    animation=fade,1,10,default
     animation=workspaces,1,6,default
 }
 
@@ -53,6 +63,10 @@ dwindle {
     pseudotile=0 # enable pseudotiling on dwindle
 }
 
+gestures {
+    workspace_swipe=no
+}
+
 # example window rules
 # for windows named/classed as abc and xyz
 #windowrule=move 69 420,abc
@@ -97,3 +111,6 @@ bind=ALT,7,movetoworkspace,7
 bind=ALT,8,movetoworkspace,8
 bind=ALT,9,movetoworkspace,9
 bind=ALT,0,movetoworkspace,10
+
+bind=SUPER,mouse_down,workspace,e+1
+bind=SUPER,mouse_up,workspace,e-1

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1656239181,
-        "narHash": "sha256-wW1xRFBn376yGloXZ4QzBE4hjipMawpV18Lshd9QSPw=",
+        "lastModified": 1660908602,
+        "narHash": "sha256-SwZ85IPWvC4NxxFhWhRMTJpApSHbY1u4YK2UFWEBWvY=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "f2537a505d45c31fe5d9c27ea9829b6f4c4e6ac5",
+        "rev": "495b19d5b3e62b4ec7e846bdfb6ef3d9c3b83492",
         "type": "github"
       },
       "original": {
@@ -26,11 +26,11 @@
       "flake": false,
       "locked": {
         "host": "gitlab.freedesktop.org",
-        "lastModified": 1655824477,
-        "narHash": "sha256-1kskHOLsnisR3kqIL5IHrQbQG/4xoXxeEf1ExMV6/RU=",
+        "lastModified": 1660930713,
+        "narHash": "sha256-bY7q1NqG/sjCUAWPn/Ne9NCigLlPlH5Lk1WCMqv3rTU=",
         "owner": "wlroots",
         "repo": "wlroots",
-        "rev": "5c4384a1330faedf975c8b8644881d50390f3613",
+        "rev": "7c575922c05e4d5fd9a403c2aa631a54c7531d44",
         "type": "gitlab"
       },
       "original": {

flake.nix

@@ -17,6 +17,7 @@
     inherit (nixpkgs) lib;
     genSystems = lib.genAttrs [
       # Add more systems if they are supported
+      "aarch64-linux"
       "x86_64-linux"
     ];
     pkgsFor = nixpkgs.legacyPackages;
@@ -32,7 +33,8 @@
         src = inputs.wlroots;
       });
       hyprland = prev.callPackage ./nix/default.nix {
-        version = "0.6.2beta" + "+date=" + (mkDate (self.lastModifiedDate or "19700101"));
+        stdenv = prev.gcc12Stdenv;
+        version = "0.10.0beta" + "+date=" + (mkDate (self.lastModifiedDate or "19700101"));
         wlroots = wlroots-hyprland;
       };
       hyprland-debug = hyprland.override {debug = true;};
@@ -47,9 +49,20 @@
         default = self.packages.${system}.hyprland;
       });
 
+    devShells = genSystems (system: {
+      default = pkgsFor.${system}.mkShell.override {stdenv = pkgsFor.${system}.gcc12Stdenv;} {
+        name = "hyprland-shell";
+        inputsFrom = [
+          self.packages.${system}.wlroots-hyprland
+          self.packages.${system}.hyprland
+        ];
+      };
+    });
+
     formatter = genSystems (system: pkgsFor.${system}.alejandra);
 
     nixosModules.default = import ./nix/module.nix self;
+    homeManagerModules.default = import ./nix/hm-module.nix self;
 
     overlay = throw "Hyprland: .overlay output is deprecated, please use the .overlays.default output";
   };

hyprctl/Makefile

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

hyprctl/main.cpp

@@ -9,14 +9,18 @@
 #include <sys/types.h>
 #include <sys/un.h>
 #include <unistd.h>
+#include <ranges>
+#include <algorithm>
 
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <string>
+#include <deque>
 
-const std::string USAGE = R"#(usage: hyprctl [command] [(opt)args]
+const std::string USAGE = R"#(usage: hyprctl [(opt)flags] [command] [(opt)args]
     
+commands:
     monitors
     workspaces
     clients
@@ -27,8 +31,16 @@ const std::string USAGE = R"#(usage: hyprctl [command] [(opt)args]
     keyword
     version
     kill
+    splash
     hyprpaper
-    reload)#";
+    reload
+    setcursor
+    getoption
+    
+flags:
+    -j -> output in JSON
+    --batch -> execute a batch of commands, separated by ';'
+)#";
 
 void request(std::string arg) {
     const auto SERVERSOCKET = socket(AF_UNIX, SOCK_STREAM, 0);
@@ -96,13 +108,6 @@ void requestHyprpaper(std::string arg) {
         return;
     }
 
-    const auto SERVER = gethostbyname("localhost");
-
-    if (!SERVER) {
-        std::cout << "Couldn't get host (2)";
-        return;
-    }
-
     // get the instance signature
     auto instanceSig = getenv("HYPRLAND_INSTANCE_SIGNATURE");
 
@@ -153,7 +158,7 @@ void dispatchRequest(int argc, char** argv) {
         return;
     }
 
-    std::string rq = "dispatch " + std::string(argv[2]) + " " + std::string(argv[3]);
+    std::string rq = "/dispatch " + std::string(argv[2]) + " " + std::string(argv[3]);
 
     request(rq);
 }
@@ -180,12 +185,36 @@ void hyprpaperRequest(int argc, char** argv) {
     requestHyprpaper(rq);
 }
 
-void batchRequest(int argc, char** argv) {
-    std::string rq = "[[BATCH]]" + std::string(argv[2]);
+void setcursorRequest(int argc, char** argv) {
+    if (argc < 4) {
+        std::cout << "setcursor requires 2 params";
+        return;
+    }
+
+    std::string rq = "setcursor " + std::string(argv[2]) + " " + std::string(argv[3]);
+
+    request(rq);
+}
+
+void batchRequest(std::string arg) {
+    std::string rq = "[[BATCH]]" + arg.substr(arg.find_first_of(" ") + 1);
     
     request(rq);
 }
 
+std::deque<std::string> splitArgs(int argc, char** argv) {
+    std::deque<std::string> result;
+
+    for (auto i = 1 /* skip the executable */; i < argc; ++i)
+        result.push_back(std::string(argv[i]));
+
+    return result;
+}
+
+bool isNumber(const std::string& str, bool allowfloat) {
+    return std::ranges::all_of(str.begin(), str.end(), [&](char c) { return isdigit(c) != 0 || c == '-' || (allowfloat && c == '.'); });
+}
+
 int main(int argc, char** argv) {
     int bflag = 0, sflag = 0, index, c;
 
@@ -194,20 +223,54 @@ int main(int argc, char** argv) {
         return 1;
     }
 
-    if (!strcmp(argv[1], "monitors")) request("monitors");
-    else if (!strcmp(argv[1], "clients")) request("clients");
-    else if (!strcmp(argv[1], "workspaces")) request("workspaces");
-    else if (!strcmp(argv[1], "activewindow")) request("activewindow");
-    else if (!strcmp(argv[1], "layers")) request("layers");
-    else if (!strcmp(argv[1], "version")) request("version");
-    else if (!strcmp(argv[1], "kill")) request("kill");
-    else if (!strcmp(argv[1], "devices")) request("devices");
-    else if (!strcmp(argv[1], "reload")) request("reload");
-    else if (!strcmp(argv[1], "dispatch")) dispatchRequest(argc, argv);
-    else if (!strcmp(argv[1], "keyword")) keywordRequest(argc, argv);
-    else if (!strcmp(argv[1], "hyprpaper")) hyprpaperRequest(argc, argv);
-    else if (!strcmp(argv[1], "--batch")) batchRequest(argc, argv);
-    else if (!strcmp(argv[1], "--help")) printf("%s", USAGE.c_str());
+    std::string fullRequest = "";
+    std::string fullArgs = "";
+    const auto ARGS = splitArgs(argc, argv);
+
+    for (auto i = 0; i < ARGS.size(); ++i) {
+        if (ARGS[i][0] == '-' && !isNumber(ARGS[i], true) /* For stuff like -2 */) {
+            // parse
+            if (ARGS[i] == "-j" && !fullArgs.contains("j")) {
+                fullArgs += "j";
+            } else if (ARGS[i] == "--batch") {
+                fullRequest = "--batch ";
+            } else {
+                printf("%s\n", USAGE.c_str());
+                return 1;
+            }
+
+            continue;
+        }
+
+        fullRequest += ARGS[i] + " ";
+    }
+
+    if (fullRequest.empty()) {
+        printf("%s\n", USAGE.c_str());
+        return 1;
+    }
+
+    fullRequest.pop_back(); // remove trailing space
+
+    fullRequest = fullArgs + "/" + fullRequest;
+
+    if (fullRequest.contains("/--batch")) batchRequest(fullRequest);
+    else if (fullRequest.contains("/monitors")) request(fullRequest);
+    else if (fullRequest.contains("/clients")) request(fullRequest);
+    else if (fullRequest.contains("/workspaces")) request(fullRequest);
+    else if (fullRequest.contains("/activewindow")) request(fullRequest);
+    else if (fullRequest.contains("/layers")) request(fullRequest);
+    else if (fullRequest.contains("/version")) request(fullRequest);
+    else if (fullRequest.contains("/kill")) request(fullRequest);
+    else if (fullRequest.contains("/splash")) request(fullRequest);
+    else if (fullRequest.contains("/devices")) request(fullRequest);
+    else if (fullRequest.contains("/reload")) request(fullRequest);
+    else if (fullRequest.contains("/getoption")) request(fullRequest);
+    else if (fullRequest.contains("/setcursor")) setcursorRequest(argc, argv);
+    else if (fullRequest.contains("/dispatch")) dispatchRequest(argc, argv);
+    else if (fullRequest.contains("/keyword")) keywordRequest(argc, argv);
+    else if (fullRequest.contains("/hyprpaper")) hyprpaperRequest(argc, argv);
+    else if (fullRequest.contains("/--help")) printf("%s", USAGE.c_str());
     else {
         printf("%s\n", USAGE.c_str());
         return 1;

meson.build

@@ -1,6 +1,27 @@
 project('Hyprland', 'cpp', 'c',
-  version : '0.6.2beta',
-  default_options : ['warning_level=2', 'cpp_std=c++20', 'default_library=static', 'optimization=3'])
+  version : '0.10.0beta',
+  default_options : [
+    'warning_level=2',
+    'default_library=static',
+    'optimization=3',
+    # 'cpp_std=c++23' # not yet supported by meson, as of version 0.63.0
+    ])
+
+# clang v14.0.6 uses C++2b instead of C++23, so we've gotta account for that
+# replace the following with a project default option once meson gets support for C++23
+cpp_compiler = meson.get_compiler('cpp')
+if cpp_compiler.has_argument('-std=c++23')
+  add_global_arguments('-std=c++23', language: 'cpp')
+elif cpp_compiler.has_argument('-std=c++2b')
+  add_global_arguments('-std=c++2b', language: 'cpp')
+else
+  error('Could not configure current C++ compiler (' + cpp_compiler.get_id() + ' ' + cpp_compiler.get_version() + ') with required C++ standard (C++23)')
+endif
+
+GIT_BRANCH = run_command('git', 'rev-parse', '--abbrev-ref', 'HEAD', check: false).stdout().strip()
+GIT_COMMIT_HASH = run_command('git', 'rev-parse', 'HEAD', check: false).stdout().strip()
+GIT_COMMIT_MESSAGE = run_command('bash', '-c', 'git show | head -n 5 | tail -n 1', check: false).stdout().strip()
+GIT_DIRTY = run_command('bash', '-c', 'git diff-index --quiet HEAD -- || echo "dirty"', check: false).stdout().strip()
 
 add_project_arguments(
   [
@@ -8,6 +29,11 @@ add_project_arguments(
     '-Wno-unused-value',
     '-Wno-missing-field-initializers',
     '-Wno-narrowing',
+
+    f'-DGIT_BRANCH="@GIT_BRANCH@"',
+    f'-DGIT_COMMIT_HASH="@GIT_COMMIT_HASH@"',
+    f'-DGIT_COMMIT_MESSAGE="@GIT_COMMIT_MESSAGE@"',
+    f'-DGIT_DIRTY="@GIT_DIRTY@"',
   ],
   language: 'cpp')
 

nix/default.nix

@@ -5,6 +5,7 @@
   pkg-config,
   meson,
   ninja,
+  git,
   libdrm,
   libinput,
   libxcb,
@@ -18,14 +19,24 @@
   wlroots,
   xcbutilwm,
   xwayland,
-  enableXWayland ? true,
-  version ? "git",
   debug ? false,
+  enableXWayland ? true,
+  legacyRenderer ? false,
+  version ? "git",
 }:
 stdenv.mkDerivation {
   pname = "hyprland" + lib.optionalString debug "-debug";
   inherit version;
-  src = ../.;
+
+  src = lib.cleanSourceWith {
+    filter = name: type: let
+      baseName = baseNameOf (toString name);
+    in
+      ! (
+        lib.hasSuffix ".nix" baseName
+      );
+    src = lib.cleanSource ../.;
+  };
 
   nativeBuildInputs = [
     meson
@@ -35,6 +46,7 @@ stdenv.mkDerivation {
 
   buildInputs =
     [
+      git
       libdrm
       libinput
       libxcb
@@ -54,13 +66,21 @@ stdenv.mkDerivation {
     then "debug"
     else "release";
 
-  mesonFlags = lib.optional (!enableXWayland) "-DNO_XWAYLAND=true";
+  mesonFlags = builtins.concatLists [
+    (lib.optional (!enableXWayland) "-DNO_XWAYLAND=true")
+    (lib.optional legacyRenderer "-DLEGACY_RENDERER:STRING=true")
+  ];
 
   patches = [
     # make meson use the provided wlroots instead of the git submodule
     ./meson-build.patch
   ];
 
+  # Fix hardcoded paths to /usr installation
+  postPatch = ''
+    sed -i "s#/usr#$out#" src/render/OpenGL.cpp
+  '';
+
   passthru.providedSessions = ["hyprland"];
 
   meta = with lib; {

nix/hm-module.nix

@@ -0,0 +1,100 @@
+self: {
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  cfg = config.wayland.windowManager.hyprland;
+  defaultHyprlandPackage = self.packages.${pkgs.system}.default.override {
+    enableXWayland = cfg.xwayland;
+  };
+in {
+  options.wayland.windowManager.hyprland = {
+    enable = lib.mkEnableOption "hyprland wayland compositor";
+    package = lib.mkOption {
+      type = with lib.types; nullOr package;
+      default = defaultHyprlandPackage;
+      description = ''
+        Hyprland package to use. Will override the 'xwayland' option.
+
+        Defaults to the one provided by the flake. Set it to
+        <literal>pkgs.hyprland</literal> to use the one provided by nixpkgs or
+        if you have an overlay.
+
+        Set to null to not add any Hyprland package to your path. This should
+        be done if you want to use the NixOS module to install Hyprland.
+      '';
+    };
+    systemdIntegration = lib.mkOption {
+      type = lib.types.bool;
+      default = pkgs.stdenv.isLinux;
+      description = ''
+        Whether to enable <filename>hyprland-session.target</filename> on
+        hyprland startup. This links to <filename>graphical-session.target</filename>.
+        Some important environment variables will be imported to systemd
+        and dbus user environment before reaching the target, including
+        <itemizedlist>
+          <listitem><para><literal>DISPLAY</literal></para></listitem>
+          <listitem><para><literal>WAYLAND_DISPLAY</literal></para></listitem>
+          <listitem><para><literal>HYPRLAND_INSTANCE_SIGNATURE</literal></para></listitem>
+          <listitem><para><literal>XDG_CURRENT_DESKTOP</literal></para></listitem>
+        </itemizedlist>
+      '';
+    };
+    xwayland = lib.mkOption {
+      type = lib.types.bool;
+      default = true;
+      description = ''
+        Enable xwayland.
+      '';
+    };
+
+    extraConfig = lib.mkOption {
+      type = lib.types.lines;
+      default = "";
+      description = ''
+        Extra configuration lines to add to ~/.config/hypr/hyprland.conf.
+      '';
+    };
+  };
+
+  config = lib.mkIf cfg.enable {
+    home.packages =
+      lib.optional (cfg.package != null) cfg.package
+      ++ lib.optional cfg.xwayland pkgs.xwayland;
+
+    xdg.configFile."hypr/hyprland.conf" = {
+      text =
+        (lib.optionalString cfg.systemdIntegration ''
+            exec-once=export XDG_SESSION_TYPE=wayland
+            exec-once=${pkgs.dbus}/bin/dbus-update-activation-environment --systemd DISPLAY WAYLAND_DISPLAY HYPRLAND_INSTANCE_SIGNATURE XDG_CURRENT_DESKTOP
+            exec-once=systemctl --user start hyprland-session.target
+          '')
+        + cfg.extraConfig;
+
+      onChange = let
+        hyprlandPackage =
+          if cfg.package == null
+          then defaultHyprlandPackage
+          else cfg.package;
+      in "HYPRLAND_INSTANCE_SIGNATURE=$(ls -w 1 /tmp/hypr | tail -1) ${hyprlandPackage}/bin/hyprctl reload config-only";
+    };
+
+    systemd.user.targets.hyprland-session = lib.mkIf cfg.systemdIntegration {
+      Unit = {
+        Description = "hyprland compositor session";
+        Documentation = ["man:systemd.special(7)"];
+        BindsTo = ["graphical-session.target"];
+        Wants = ["graphical-session-pre.target"];
+        After = ["graphical-session-pre.target"];
+      };
+    };
+
+    systemd.user.targets.tray = {
+      Unit = {
+        Description = "Home Manager System Tray";
+        Requires = ["graphical-session-pre.target"];
+      };
+    };
+  };
+}

nix/module.nix

@@ -18,7 +18,7 @@ in {
     '';
 
     package = mkOption {
-      type = types.package;
+      type = types.nullOr types.package;
       default = self.packages.${pkgs.system}.default;
       defaultText = literalExpression "<Hyprland flake>.packages.<system>.default";
       example = literalExpression "<Hyprland flake>.packages.<system>.default.override { }";
@@ -27,34 +27,18 @@ in {
       '';
     };
 
-    extraPackages = mkOption {
-      type = with types; listOf package;
-      default = with pkgs; [
-        kitty
-        wofi
-        swaybg
-      ];
-      defaultText = literalExpression ''
-        with pkgs; [ kitty wofi swaybg ];
-      '';
-      example = literalExpression ''
-        with pkgs; [
-          alacritty wofi
-        ]
-      '';
-      description = ''
-        Extra packages to be installed system wide.
-      '';
-    };
+    imports = [
+      (mkRemovedOptionModule ["programs" "hyprland" "extraPackages"] "extraPackages has been removed. Use environment.systemPackages instead.")
+    ];
   };
 
   config = mkIf cfg.enable {
-    environment.systemPackages = [cfg.package] ++ cfg.extraPackages;
+    environment.systemPackages = lib.optional (cfg.package != null) cfg.package;
     security.polkit.enable = true;
     hardware.opengl.enable = mkDefault true;
     fonts.enableDefaultFonts = mkDefault true;
     programs.dconf.enable = mkDefault true;
-    services.xserver.displayManager.sessionPackages = [cfg.package];
+    services.xserver.displayManager.sessionPackages = lib.optional (cfg.package != null) cfg.package;
     programs.xwayland.enable = mkDefault true;
     xdg.portal.enable = mkDefault true;
     xdg.portal.extraPortals = [pkgs.xdg-desktop-portal-wlr];

protocols/meson.build

@@ -14,6 +14,7 @@ wayland_scanner = find_program(
 protocols = [
   [wl_protocol_dir, 'stable/xdg-shell/xdg-shell.xml'],
   ['wlr-layer-shell-unstable-v1.xml'],
+  ['wlr-output-power-management-unstable-v1.xml'],
   ['ext-workspace-unstable-v1.xml'],
   ['pointer-constraints-unstable-v1.xml'],
   ['tablet-unstable-v2.xml'],

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

@@ -0,0 +1,128 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="wlr_output_power_management_unstable_v1">
+  <copyright>
+    Copyright © 2019 Purism SPC
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+  </copyright>
+
+  <description summary="Control power management modes of outputs">
+    This protocol allows clients to control power management modes
+    of outputs that are currently part of the compositor space. The
+    intent is to allow special clients like desktop shells to power
+    down outputs when the system is idle.
+
+    To modify outputs not currently part of the compositor space see
+    wlr-output-management.
+
+    Warning! The protocol described in this file is experimental and
+    backward incompatible changes may be made. Backward compatible changes
+    may be added together with the corresponding interface version bump.
+    Backward incompatible changes are done by bumping the version number in
+    the protocol and interface names and resetting the interface version.
+    Once the protocol is to be declared stable, the 'z' prefix and the
+    version number in the protocol and interface names are removed and the
+    interface version number is reset.
+  </description>
+
+  <interface name="zwlr_output_power_manager_v1" version="1">
+    <description summary="manager to create per-output power management">
+      This interface is a manager that allows creating per-output power
+      management mode controls.
+    </description>
+
+    <request name="get_output_power">
+      <description summary="get a power management for an output">
+        Create a output power management mode control that can be used to
+        adjust the power management mode for a given output.
+      </description>
+      <arg name="id" type="new_id" interface="zwlr_output_power_v1"/>
+      <arg name="output" type="object" interface="wl_output"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the manager">
+        All objects created by the manager will still remain valid, until their
+        appropriate destroy request has been called.
+      </description>
+    </request>
+  </interface>
+
+  <interface name="zwlr_output_power_v1" version="1">
+    <description summary="adjust power management mode for an output">
+      This object offers requests to set the power management mode of
+      an output.
+    </description>
+
+    <enum name="mode">
+      <entry name="off" value="0"
+             summary="Output is turned off."/>
+      <entry name="on" value="1"
+             summary="Output is turned on, no power saving"/>
+    </enum>
+
+    <enum name="error">
+      <entry name="invalid_mode" value="1" summary="inexistent power save mode"/>
+    </enum>
+
+    <request name="set_mode">
+      <description summary="Set an outputs power save mode">
+        Set an output's power save mode to the given mode. The mode change
+        is effective immediately. If the output does not support the given
+        mode a failed event is sent.
+      </description>
+      <arg name="mode" type="uint" enum="mode" summary="the power save mode to set"/>
+    </request>
+
+    <event name="mode">
+      <description summary="Report a power management mode change">
+        Report the power management mode change of an output.
+
+        The mode event is sent after an output changed its power
+        management mode. The reason can be a client using set_mode or the
+        compositor deciding to change an output's mode.
+        This event is also sent immediately when the object is created
+        so the client is informed about the current power management mode.
+      </description>
+      <arg name="mode" type="uint" enum="mode"
+           summary="the output's new power management mode"/>
+    </event>
+
+    <event name="failed">
+      <description summary="object no longer valid">
+        This event indicates that the output power management mode control
+        is no longer valid. This can happen for a number of reasons,
+        including:
+        - The output doesn't support power management
+        - Another client already has exclusive power management mode control
+          for this output
+        - The output disappeared
+
+        Upon receiving this event, the client should destroy this object.
+      </description>
+    </event>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy this power management">
+        Destroys the output power management mode control object.
+      </description>
+    </request>
+  </interface>
+</protocol>

src/Compositor.hpp

@@ -30,7 +30,9 @@ public:
 
     // ------------------ WLR BASICS ------------------ //
     wl_display*                      m_sWLDisplay;
+    wl_event_loop*                   m_sWLEventLoop;
     wlr_backend*                     m_sWLRBackend;
+    wlr_session*                     m_sWLRSession;
     wlr_renderer*                    m_sWLRRenderer;
     wlr_allocator*                   m_sWLRAllocator;
     wlr_compositor*                  m_sWLRCompositor;
@@ -61,13 +63,20 @@ public:
     wlr_foreign_toplevel_manager_v1* m_sWLRToplevelMgr;
     wlr_tablet_manager_v2*           m_sWLRTabletManager;
     wlr_xdg_foreign_registry*        m_sWLRForeignRegistry;
+    wlr_idle_inhibit_manager_v1*     m_sWLRIdleInhibitMgr;
+    wlr_pointer_gestures_v1*         m_sWLRPointerGestures;
+    wlr_output_power_manager_v1*     m_sWLROutputPowerMgr;
+    wlr_input_method_manager_v2*     m_sWLRIMEMgr;
+    wlr_text_input_manager_v3*       m_sWLRTextInputMgr;
     // ------------------------------------------------- //
 
 
     const char*             m_szWLDisplaySocket;
     std::string             m_szInstanceSignature = "";
+    std::string             m_szCurrentSplash = "error";
 
-    std::vector<std::unique_ptr<SMonitor>>      m_vMonitors;
+    std::vector<std::shared_ptr<CMonitor>>      m_vMonitors;
+    std::vector<std::shared_ptr<CMonitor>>      m_vRealMonitors; // for all monitors, even those turned off
     std::vector<std::unique_ptr<CWindow>>       m_vWindows;
     std::deque<std::unique_ptr<CWindow>>        m_dUnmanagedX11Windows;
     std::vector<std::unique_ptr<SXDGPopup>>     m_vXDGPopups;
@@ -77,35 +86,38 @@ public:
     std::vector<SLayerSurface*>                 m_vSurfacesFadingOut;
 
     void                    startCompositor(); 
-    void                    cleanupExit();
+    void                    cleanup();
 
     wlr_surface*            m_pLastFocus = nullptr;
     CWindow*                m_pLastWindow = nullptr;
-    SMonitor*               m_pLastMonitor = nullptr;
+    CMonitor*               m_pLastMonitor = nullptr;
     
     SSeat                   m_sSeat;
 
     bool                    m_bReadyToProcess = false;
+    bool                    m_bSessionActive = true;
+    bool                    m_bDPMSStateON = true;
+    bool                    m_bUnsafeState = false; // unsafe state is when there is no monitors.
 
     // ------------------------------------------------- //
 
-    SMonitor*               getMonitorFromID(const int&);
-    SMonitor*               getMonitorFromName(const std::string&);
-    SMonitor*               getMonitorFromCursor();
-    SMonitor*               getMonitorFromVector(const Vector2D&);
+    CMonitor*               getMonitorFromID(const int&);
+    CMonitor*               getMonitorFromName(const std::string&);
+    CMonitor*               getMonitorFromCursor();
+    CMonitor*               getMonitorFromVector(const Vector2D&);
     void                    removeWindowFromVectorSafe(CWindow*);
     void                    focusWindow(CWindow*, wlr_surface* pSurface = nullptr);
     void                    focusSurface(wlr_surface*, CWindow* pWindowOwner = nullptr);
     bool                    windowExists(CWindow*);
     bool                    windowValidMapped(CWindow*);
     CWindow*                vectorToWindow(const Vector2D&);
-    CWindow*                vectorToWindowIdeal(const Vector2D&);
+    CWindow*                vectorToWindowIdeal(const Vector2D&); // used only for finding a window to focus on, basically a "findFocusableWindow"
     CWindow*                vectorToWindowTiled(const Vector2D&);
-    wlr_surface*            vectorToLayerSurface(const Vector2D&, std::list<SLayerSurface*>*, Vector2D*, SLayerSurface**);
+    wlr_surface*            vectorToLayerSurface(const Vector2D&, std::vector<std::unique_ptr<SLayerSurface>>*, Vector2D*, SLayerSurface**);
     wlr_surface*            vectorWindowToSurface(const Vector2D&, CWindow*, Vector2D& sl);
     CWindow*                windowFromCursor();
     CWindow*                windowFloatingFromCursor();
-    SMonitor*               getMonitorFromOutput(wlr_output*);
+    CMonitor*               getMonitorFromOutput(wlr_output*);
     CWindow*                getWindowForPopup(wlr_xdg_popup*);
     CWindow*                getWindowFromSurface(wlr_surface*);
     bool                    isWorkspaceVisible(const int&);
@@ -113,33 +125,49 @@ public:
     CWorkspace*             getWorkspaceByName(const std::string&);
     CWorkspace*             getWorkspaceByString(const std::string&);
     void                    sanityCheckWorkspaces();
+    void                    updateWorkspaceWindowDecos(const int&);
     int                     getWindowsOnWorkspace(const int&);
     CWindow*                getFirstWindowOnWorkspace(const int&);
-    void                    fixXWaylandWindowsOnWorkspace(const int&);
     CWindow*                getFullscreenWindowOnWorkspace(const int&);
     bool                    doesSeatAcceptInput(wlr_surface*);
     bool                    isWindowActive(CWindow*);
     void                    moveWindowToTop(CWindow*);
-    void                    cleanupFadingOut();
+    void                    cleanupFadingOut(const int& monid);
     CWindow*                getWindowInDirection(CWindow*, char);
     void                    deactivateAllWLRWorkspaces(wlr_ext_workspace_handle_v1* exclude = nullptr);
     CWindow*                getNextWindowOnWorkspace(CWindow*);
+    CWindow*                getPrevWindowOnWorkspace(CWindow*);
     int                     getNextAvailableNamedWorkspace();
     bool                    isPointOnAnyMonitor(const Vector2D&);
     CWindow*                getConstraintWindow(SMouse*);
-    SMonitor*               getMonitorInDirection(const char&);
-    void                    updateAllWindowsBorders();
-    void                    updateWindowBorderColor(CWindow*);
+    CMonitor*               getMonitorInDirection(const char&);
+    void                    updateAllWindowsAnimatedDecorationValues();
+    void                    updateWindowAnimatedDecorationValues(CWindow*);
     void                    moveWindowToWorkspace(CWindow*, const std::string&);
     int                     getNextAvailableMonitorID();
-    void                    moveWorkspaceToMonitor(CWorkspace*, SMonitor*);
+    void                    moveWorkspaceToMonitor(CWorkspace*, CMonitor*);
     bool                    workspaceIDOutOfBounds(const int&);
     void                    setWindowFullscreen(CWindow*, bool, eFullscreenMode);
     void                    moveUnmanagedX11ToWindows(CWindow*);
     CWindow*                getX11Parent(CWindow*);
+    void                    scheduleFrameForMonitor(CMonitor*);
+    void                    addToFadingOutSafe(SLayerSurface*);
+    void                    addToFadingOutSafe(CWindow*);
+    CWindow*                getWindowByRegex(const std::string&);
+    void                    warpCursorTo(const Vector2D&);
+    SLayerSurface*          getLayerSurfaceFromWlr(wlr_layer_surface_v1*);
+    SLayerSurface*          getLayerSurfaceFromSurface(wlr_surface*);
+    void                    closeWindow(CWindow*);
+    Vector2D                parseWindowVectorArgsRelative(const std::string&, const Vector2D&);
+    
+
+    std::string             explicitConfigPath;
+
+    void                    startHyprCtlTick();
 
 private:
     void                    initAllSignals();
+    void                    setRandomSplash();    
 };
 
 

src/Window.cpp

@@ -3,10 +3,12 @@
 #include "render/decorations/CHyprDropShadowDecoration.hpp"
 
 CWindow::CWindow() {
-    m_vRealPosition.create(AVARTYPE_VECTOR, &g_pConfigManager->getConfigValuePtr("animations:windows_speed")->floatValue, &g_pConfigManager->getConfigValuePtr("animations:windows")->intValue, &g_pConfigManager->getConfigValuePtr("animations:windows_curve")->strValue, (void*) this, AVARDAMAGE_ENTIRE);
-    m_vRealSize.create(AVARTYPE_VECTOR, &g_pConfigManager->getConfigValuePtr("animations:windows_speed")->floatValue, &g_pConfigManager->getConfigValuePtr("animations:windows")->intValue, &g_pConfigManager->getConfigValuePtr("animations:windows_curve")->strValue, (void*)this, AVARDAMAGE_ENTIRE);
-    m_cRealBorderColor.create(AVARTYPE_COLOR, &g_pConfigManager->getConfigValuePtr("animations:borders_speed")->floatValue, &g_pConfigManager->getConfigValuePtr("animations:borders")->intValue, &g_pConfigManager->getConfigValuePtr("animations:borders_curve")->strValue, (void*)this, AVARDAMAGE_BORDER);
-    m_fAlpha.create(AVARTYPE_FLOAT, &g_pConfigManager->getConfigValuePtr("animations:fadein_speed")->floatValue, &g_pConfigManager->getConfigValuePtr("animations:fadein")->intValue, &g_pConfigManager->getConfigValuePtr("animations:fadein_curve")->strValue, (void*)this, AVARDAMAGE_ENTIRE);
+    m_vRealPosition.create(AVARTYPE_VECTOR, g_pConfigManager->getAnimationPropertyConfig("windowsIn"), (void*) this, AVARDAMAGE_ENTIRE);
+    m_vRealSize.create(AVARTYPE_VECTOR, g_pConfigManager->getAnimationPropertyConfig("windowsIn"), (void*)this, AVARDAMAGE_ENTIRE);
+    m_cRealBorderColor.create(AVARTYPE_COLOR, g_pConfigManager->getAnimationPropertyConfig("border"), (void*)this, AVARDAMAGE_BORDER);
+    m_fAlpha.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), (void*)this, AVARDAMAGE_ENTIRE);
+    m_fActiveInactiveAlpha.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("fadeSwitch"), (void*)this, AVARDAMAGE_ENTIRE);
+    m_cRealShadowColor.create(AVARTYPE_COLOR, g_pConfigManager->getAnimationPropertyConfig("fadeShadow"), (void*)this, AVARDAMAGE_SHADOW);
 
     m_dWindowDecorations.emplace_back(std::make_unique<CHyprDropShadowDecoration>(this)); // put the shadow so it's the first deco (has to be rendered first)
 }
@@ -102,3 +104,105 @@ pid_t CWindow::getPID() {
 
     return PID;
 }
+
+IHyprWindowDecoration* CWindow::getDecorationByType(eDecorationType type) {
+    for (auto& wd : m_dWindowDecorations) {
+        if (wd->getDecorationType() == type)
+            return wd.get();
+    }
+
+    return nullptr;
+}
+
+void CWindow::createToplevelHandle() {
+    if (m_bIsX11 && (m_bX11DoesntWantBorders || m_iX11Type == 2))
+        return; // don't create a toplevel
+
+    m_phForeignToplevel = wlr_foreign_toplevel_handle_v1_create(g_pCompositor->m_sWLRToplevelMgr);
+    
+    wlr_foreign_toplevel_handle_v1_set_app_id(m_phForeignToplevel, g_pXWaylandManager->getAppIDClass(this).c_str());
+    wlr_foreign_toplevel_handle_v1_output_enter(m_phForeignToplevel, g_pCompositor->getMonitorFromID(m_iMonitorID)->output);
+    wlr_foreign_toplevel_handle_v1_set_title(m_phForeignToplevel, m_szTitle.c_str());
+    wlr_foreign_toplevel_handle_v1_set_maximized(m_phForeignToplevel, false);
+    wlr_foreign_toplevel_handle_v1_set_minimized(m_phForeignToplevel, false);
+    wlr_foreign_toplevel_handle_v1_set_fullscreen(m_phForeignToplevel, false);
+
+    // handle events
+    hyprListener_toplevelActivate.initCallback(&m_phForeignToplevel->events.request_activate, [&](void* owner, void* data) {
+
+        g_pCompositor->focusWindow(this);
+
+    }, this, "Toplevel");
+
+    hyprListener_toplevelFullscreen.initCallback(&m_phForeignToplevel->events.request_fullscreen, [&](void* owner, void* data) {
+
+        const auto EV = (wlr_foreign_toplevel_handle_v1_fullscreen_event*)data;
+
+        g_pCompositor->setWindowFullscreen(this, EV->fullscreen, FULLSCREEN_FULL);
+
+    }, this, "Toplevel");
+
+    hyprListener_toplevelClose.initCallback(&m_phForeignToplevel->events.request_close, [&](void* owner, void* data) {
+
+        g_pCompositor->closeWindow(this);
+
+    }, this, "Toplevel");
+
+    m_iLastToplevelMonitorID = m_iMonitorID;
+}
+
+void CWindow::destroyToplevelHandle() {
+    if (!m_phForeignToplevel)
+        return;
+
+    hyprListener_toplevelActivate.removeCallback();
+    hyprListener_toplevelClose.removeCallback();
+    hyprListener_toplevelFullscreen.removeCallback();
+
+    wlr_foreign_toplevel_handle_v1_destroy(m_phForeignToplevel);
+    m_phForeignToplevel = nullptr;
+}
+
+void CWindow::updateToplevel() {
+    updateSurfaceOutputs();
+
+    if (!m_phForeignToplevel)
+        return;
+
+    wlr_foreign_toplevel_handle_v1_set_title(m_phForeignToplevel, m_szTitle.c_str());
+    wlr_foreign_toplevel_handle_v1_set_fullscreen(m_phForeignToplevel, m_bIsFullscreen);
+
+    if (m_iLastToplevelMonitorID != m_iMonitorID) {
+        if (const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iLastToplevelMonitorID); PMONITOR && PMONITOR->m_bEnabled)
+            wlr_foreign_toplevel_handle_v1_output_leave(m_phForeignToplevel, PMONITOR->output);
+        wlr_foreign_toplevel_handle_v1_output_enter(m_phForeignToplevel, g_pCompositor->getMonitorFromID(m_iMonitorID)->output);
+
+        m_iLastToplevelMonitorID = m_iMonitorID;
+    }
+}
+
+void sendEnterIter(wlr_surface* pSurface, int x, int y, void* data) {
+    const auto OUTPUT = (wlr_output*)data;
+    wlr_surface_send_enter(pSurface, OUTPUT);
+}
+
+void sendLeaveIter(wlr_surface* pSurface, int x, int y, void* data) {
+    const auto OUTPUT = (wlr_output*)data;
+    wlr_surface_send_leave(pSurface, OUTPUT);
+}
+
+void CWindow::updateSurfaceOutputs() {
+    if (m_iLastSurfaceMonitorID == m_iMonitorID || !m_bIsMapped || m_bHidden || !m_bMappedX11)
+        return;
+
+    const auto PLASTMONITOR = g_pCompositor->getMonitorFromID(m_iLastSurfaceMonitorID);
+
+    m_iLastSurfaceMonitorID = m_iMonitorID;
+
+    const auto PNEWMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+
+    if (PLASTMONITOR && PLASTMONITOR->m_bEnabled)
+        wlr_surface_for_each_surface(g_pXWaylandManager->getWindowSurface(this), sendLeaveIter, PLASTMONITOR->output);
+
+    wlr_surface_for_each_surface(g_pXWaylandManager->getWindowSurface(this), sendEnterIter, PNEWMONITOR->output);
+}

src/Window.hpp

@@ -10,12 +10,17 @@
 struct SWindowSpecialRenderData {
     float alpha = 1.f;
     float alphaInactive = -1.f; // -1 means unset
+
+    // set by the layout
+    bool rounding = true;
+    bool border = true;
 };  
 
 struct SWindowAdditionalConfigData {
     std::string animationStyle = "";
     int rounding = -1; // -1 means no
     bool forceNoBlur = false;
+    bool forceOpaque = false;
 };
 
 class CWindow {
@@ -28,8 +33,18 @@ public:
     DYNLISTENER(unmapWindow);
     DYNLISTENER(destroyWindow);
     DYNLISTENER(setTitleWindow);
+    DYNLISTENER(setGeometryX11U);
     DYNLISTENER(fullscreenWindow);
     DYNLISTENER(newPopupXDG);
+    DYNLISTENER(requestMove);
+    DYNLISTENER(requestMinimize);
+    DYNLISTENER(requestMaximize);
+    DYNLISTENER(requestResize);
+    DYNLISTENER(activateX11);
+    DYNLISTENER(configureX11);
+    DYNLISTENER(toplevelClose);
+    DYNLISTENER(toplevelActivate);
+    DYNLISTENER(toplevelFullscreen);
    // DYNLISTENER(newSubsurfaceWindow);
 
     union {
@@ -45,6 +60,13 @@ public:
     CAnimatedVariable m_vRealPosition;
     CAnimatedVariable m_vRealSize;
 
+    // for not spamming the protocols
+    Vector2D            m_vReportedPosition;
+    Vector2D            m_vReportedSize;
+
+    // for restoring floating statuses
+    Vector2D            m_vLastFloatingSize;
+
     // this is used for pseudotiling
     bool                m_bIsPseudotiled = false;
     Vector2D            m_vPseudoSize = Vector2D(0,0);
@@ -71,8 +93,7 @@ public:
     uint64_t        m_iX11Type = 0;
     bool            m_bIsModal = false;
     bool            m_bX11DoesntWantBorders = false;
-    DYNLISTENER(activateX11);
-    DYNLISTENER(configureX11);
+    bool            m_bX11ShouldntFocus = false;
     //
 
     // For nofocus
@@ -105,6 +126,16 @@ public:
     SWindowSpecialRenderData m_sSpecialRenderData;
     SWindowAdditionalConfigData m_sAdditionalConfigData;
 
+    // for alpha
+    CAnimatedVariable m_fActiveInactiveAlpha;
+
+    // animated shadow color
+    CAnimatedVariable m_cRealShadowColor;
+
+    // for toplevel monitor events
+    uint64_t          m_iLastToplevelMonitorID = -1;
+    uint64_t          m_iLastSurfaceMonitorID = -1;
+
     // For the list lookup
     bool operator==(const CWindow& rhs) {
         return m_uSurface.xdg == rhs.m_uSurface.xdg && m_uSurface.xwayland == rhs.m_uSurface.xwayland && m_vPosition == rhs.m_vPosition && m_vSize == rhs.m_vSize && m_bFadingOut == rhs.m_bFadingOut;
@@ -115,5 +146,9 @@ public:
     wlr_box         getWindowIdealBoundingBoxIgnoreReserved();
     void            updateWindowDecos();
     pid_t           getPID();
-
+    IHyprWindowDecoration* getDecorationByType(eDecorationType);
+    void            createToplevelHandle();
+    void            destroyToplevelHandle();
+    void            updateToplevel();
+    void            updateSurfaceOutputs();
 };

src/config/ConfigManager.cpp

@@ -12,11 +12,20 @@
 
 CConfigManager::CConfigManager() {
     setDefaultVars();
-    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");
+    setDefaultAnimationVars();
+
+    std::string CONFIGPATH;
+    if (g_pCompositor->explicitConfigPath == "") {
+        static const char* const ENVHOME = getenv("HOME");
+        CONFIGPATH = ENVHOME + (ISDEBUG ? (std::string) "/.config/hypr/hyprlandd.conf" : (std::string) "/.config/hypr/hyprland.conf");
+    } else {
+        CONFIGPATH = g_pCompositor->explicitConfigPath;
+    }
+
     configPaths.emplace_back(CONFIGPATH);
 
     Debug::disableLogs = &configValues["debug:disable_logs"].intValue;
+    Debug::disableTime = &configValues["debug:disable_time"].intValue;
 }
 
 void CConfigManager::setDefaultVars() {
@@ -36,31 +45,44 @@ void CConfigManager::setDefaultVars() {
     configValues["general:col.active_border"].intValue = 0xffffffff;
     configValues["general:col.inactive_border"].intValue = 0xff444444;
     configValues["general:cursor_inactive_timeout"].intValue = 0;
+    configValues["general:no_cursor_warps"].intValue = 0;
+
+    configValues["general:layout"].strValue = "dwindle";
+    
+    configValues["misc:disable_hyprland_logo"].intValue = 0;
+    configValues["misc:disable_splash_rendering"].intValue = 0;
+    configValues["misc:no_vfr"].intValue = 1;
+    configValues["misc:damage_entire_on_snapshot"].intValue = 0;
+    configValues["misc:mouse_move_enables_dpms"].intValue = 0;
+    configValues["misc:always_follow_on_dnd"].intValue = 1;
+    configValues["misc:layers_hog_keyboard_focus"].intValue = 1;
+    configValues["misc:animate_manual_resizes"].intValue = 0;
 
     configValues["debug:int"].intValue = 0;
     configValues["debug:log_damage"].intValue = 0;
     configValues["debug:overlay"].intValue = 0;
     configValues["debug:damage_blink"].intValue = 0;
     configValues["debug:disable_logs"].intValue = 0;
-
-    configValues["experimental:vfr"].intValue = 0;
+    configValues["debug:disable_time"].intValue = 1;
 
     configValues["decoration:rounding"].intValue = 1;
     configValues["decoration:blur"].intValue = 1;
     configValues["decoration:blur_size"].intValue = 8;
     configValues["decoration:blur_passes"].intValue = 1;
     configValues["decoration:blur_ignore_opacity"].intValue = 0;
+    configValues["decoration:blur_new_optimizations"].intValue = 0;
     configValues["decoration:active_opacity"].floatValue = 1;
     configValues["decoration:inactive_opacity"].floatValue = 1;
     configValues["decoration:fullscreen_opacity"].floatValue = 1;
     configValues["decoration:multisample_edges"].intValue = 1;
-    configValues["decoration:no_blur_on_oversized"].intValue = 1;
+    configValues["decoration:no_blur_on_oversized"].intValue = 0;
     configValues["decoration:drop_shadow"].intValue = 1;
     configValues["decoration:shadow_range"].intValue = 4;
     configValues["decoration:shadow_render_power"].intValue = 3;
     configValues["decoration:shadow_ignore_window"].intValue = 1;
     configValues["decoration:shadow_offset"].strValue = "0 0";
     configValues["decoration:col.shadow"].intValue = 0xee1a1a1a;
+    configValues["decoration:col.shadow_inactive"].intValue = INT_MAX;
 
     configValues["dwindle:pseudotile"].intValue = 0;
     configValues["dwindle:col.group_border"].intValue = 0x66777700;
@@ -68,6 +90,14 @@ void CConfigManager::setDefaultVars() {
     configValues["dwindle:force_split"].intValue = 0;
     configValues["dwindle:preserve_split"].intValue = 0;
     configValues["dwindle:special_scale_factor"].floatValue = 0.8f;
+    configValues["dwindle:split_width_multiplier"].floatValue = 1.0f;
+    configValues["dwindle:no_gaps_when_only"].intValue = 0;
+    configValues["dwindle:use_active_for_splits"].intValue = 1;
+
+    configValues["master:special_scale_factor"].floatValue = 0.8f;
+    configValues["master:new_is_master"].intValue = 1;
+    configValues["master:new_on_top"].intValue = 0;
+    configValues["master:no_gaps_when_only"].intValue = 0;
 
     configValues["animations:enabled"].intValue = 1;
     configValues["animations:speed"].floatValue = 7.f;
@@ -89,6 +119,8 @@ void CConfigManager::setDefaultVars() {
     configValues["animations:workspaces_speed"].floatValue = 0.f;
     configValues["animations:workspaces"].intValue = 1;
 
+    configValues["input:sensitivity"].floatValue = 0.f;
+    configValues["input:kb_file"].strValue = STRVAL_EMPTY;
     configValues["input:kb_layout"].strValue = "us";
     configValues["input:kb_variant"].strValue = STRVAL_EMPTY;
     configValues["input:kb_options"].strValue = STRVAL_EMPTY;
@@ -104,6 +136,17 @@ void CConfigManager::setDefaultVars() {
     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:touchpad:drag_lock"].intValue = 0;
+
+    configValues["binds:pass_mouse_when_bound"].intValue = 1;
+    configValues["binds:scroll_event_delay"].intValue = 300;
+
+    configValues["gestures:workspace_swipe"].intValue = 0;
+    configValues["gestures:workspace_swipe_fingers"].intValue = 3;
+    configValues["gestures:workspace_swipe_distance"].intValue = 300;
+    configValues["gestures:workspace_swipe_invert"].intValue = 1;
+    configValues["gestures:workspace_swipe_min_speed_to_force"].intValue = 30;
+    configValues["gestures:workspace_swipe_cancel_ratio"].floatValue = 0.5f;
 
     configValues["input:follow_mouse"].intValue = 1;
 
@@ -113,6 +156,8 @@ void CConfigManager::setDefaultVars() {
 void CConfigManager::setDeviceDefaultVars(const std::string& dev) {
     auto& cfgValues = deviceConfigs[dev];
 
+    cfgValues["sensitivity"].floatValue = 0.f;
+    cfgValues["kb_file"].strValue = STRVAL_EMPTY;
     cfgValues["kb_layout"].strValue = "us";
     cfgValues["kb_variant"].strValue = STRVAL_EMPTY;
     cfgValues["kb_options"].strValue = STRVAL_EMPTY;
@@ -126,6 +171,57 @@ void CConfigManager::setDeviceDefaultVars(const std::string& dev) {
     cfgValues["clickfinger_behavior"].intValue = 0;
     cfgValues["middle_button_emulation"].intValue = 0;
     cfgValues["tap-to-click"].intValue = 1;
+    cfgValues["drag_lock"].intValue = 0;
+}
+
+void CConfigManager::setDefaultAnimationVars() {
+    if (isFirstLaunch) {
+        INITANIMCFG("global");
+        INITANIMCFG("windows");
+        INITANIMCFG("fade");
+        INITANIMCFG("border");
+        INITANIMCFG("workspaces");
+
+        // windows
+        INITANIMCFG("windowsIn");
+        INITANIMCFG("windowsOut");
+        INITANIMCFG("windowsMove");
+
+        // fade
+        INITANIMCFG("fadeIn");
+        INITANIMCFG("fadeOut");
+        INITANIMCFG("fadeSwitch");
+        INITANIMCFG("fadeShadow");
+
+        // border
+
+        // workspaces
+    }
+    
+    // init the values
+    animationConfig["global"] = {
+        false,
+        "default",
+        "",
+        8.f,
+        1,
+        &animationConfig["general"],
+        nullptr
+    };
+
+    CREATEANIMCFG("windows", "global");
+    CREATEANIMCFG("fade", "global");
+    CREATEANIMCFG("border", "global");
+    CREATEANIMCFG("workspaces", "global");
+
+    CREATEANIMCFG("windowsIn", "windows");
+    CREATEANIMCFG("windowsOut", "windows");
+    CREATEANIMCFG("windowsMove", "windows");
+
+    CREATEANIMCFG("fadeIn", "fade");
+    CREATEANIMCFG("fadeOut", "fade");
+    CREATEANIMCFG("fadeSwitch", "fade");
+    CREATEANIMCFG("fadeShadow", "fade");
 }
 
 void CConfigManager::init() {
@@ -149,17 +245,15 @@ void CConfigManager::init() {
 
 void CConfigManager::configSetValueSafe(const std::string& COMMAND, const std::string& VALUE) {
     if (configValues.find(COMMAND) == configValues.end()) {
-        if (COMMAND[0] == '$') {
-            // register a dynamic var
-            Debug::log(LOG, "Registered dynamic var \"%s\" -> %s", COMMAND.c_str(), VALUE.c_str());
-            configDynamicVars[COMMAND.substr(1)] = VALUE;
-        } else {
-            parseError = "Error setting value <" + VALUE + "> for field <" + COMMAND + ">: No such field.";
-        }
+        if (COMMAND.find("device:") != 0 /* devices parsed later */) {
+            if (COMMAND[0] == '$') {
+                // register a dynamic var
+                Debug::log(LOG, "Registered dynamic var \"%s\" -> %s", COMMAND.c_str(), VALUE.c_str());
+                configDynamicVars[COMMAND.substr(1)] = VALUE;
+            } else {
+                parseError = "Error setting value <" + VALUE + "> for field <" + COMMAND + ">: No such field.";
+            }
 
-        if (COMMAND.find("device:") == 0 /* devices parsed later */) {
-            parseError = "";
-        } else {
             return;
         }
     }
@@ -193,7 +287,12 @@ void CConfigManager::configSetValueSafe(const std::string& COMMAND, const std::s
                 // Values with 0x are hex
                 const auto VALUEWITHOUTHEX = VALUE.substr(2);
                 CONFIGENTRY->intValue = stol(VALUEWITHOUTHEX, nullptr, 16);
-            } else
+            } else if (VALUE.find("true") == 0 || VALUE.find("on") == 0 || VALUE.find("yes") == 0) {
+                CONFIGENTRY->intValue = 1;
+            } else if (VALUE.find("false") == 0 || VALUE.find("off") == 0 || VALUE.find("no") == 0) {
+                CONFIGENTRY->intValue = 0;
+            }
+            else
                 CONFIGENTRY->intValue = stol(VALUE);
         } catch (...) {
             Debug::log(WARN, "Error reading value of %s", COMMAND.c_str());
@@ -340,34 +439,47 @@ void CConfigManager::handleMonitor(const std::string& command, const std::string
             return;
         }
 
-        // overwrite if exists
-        for (auto& r : m_dMonitorRules) {
-            if (r.name == newrule.name) {
-                r = newrule;
-                return;
-            }
-        }
+        if (std::find_if(m_dMonitorRules.begin(), m_dMonitorRules.end(), [&](const auto& other) { return other.name == newrule.name; }) != m_dMonitorRules.end()) 
+            m_dMonitorRules.erase(std::remove_if(m_dMonitorRules.begin(), m_dMonitorRules.end(), [&](const auto& other) { return other.name == newrule.name; }));
 
         m_dMonitorRules.push_back(newrule);
 
         return;
     }
 
-    newrule.resolution.x = stoi(curitem.substr(0, curitem.find_first_of('x')));
-    newrule.resolution.y = stoi(curitem.substr(curitem.find_first_of('x') + 1, curitem.find_first_of('@')));
+    if (curitem.find("pref") == 0) {
+        newrule.resolution = Vector2D();
+    } else {
+        newrule.resolution.x = stoi(curitem.substr(0, curitem.find_first_of('x')));
+        newrule.resolution.y = stoi(curitem.substr(curitem.find_first_of('x') + 1, curitem.find_first_of('@')));
 
-    if (curitem.find_first_of('@') != std::string::npos)
-        newrule.refreshRate = stof(curitem.substr(curitem.find_first_of('@') + 1));
+        if (curitem.contains("@"))
+            newrule.refreshRate = stof(curitem.substr(curitem.find_first_of('@') + 1));
+    }
 
     nextItem();
 
-    newrule.offset.x = stoi(curitem.substr(0, curitem.find_first_of('x')));
-    newrule.offset.y = stoi(curitem.substr(curitem.find_first_of('x') + 1));
+    if (curitem.find("auto") == 0) {
+        newrule.offset = Vector2D(-1, -1);
+    } else {
+        newrule.offset.x = stoi(curitem.substr(0, curitem.find_first_of('x')));
+        newrule.offset.y = stoi(curitem.substr(curitem.find_first_of('x') + 1));
+
+        if (newrule.offset.x < 0 || newrule.offset.y < 0) {
+            parseError = "invalid offset. Offset cannot be negative.";
+            newrule.offset = Vector2D();
+        }
+    }
 
     nextItem();
 
     newrule.scale = stof(curitem);
 
+    if (newrule.scale < 0.25f) {
+        parseError = "not a valid scale.";
+        newrule.scale = 1;
+    }
+
     nextItem();
 
     if (curitem != "") {
@@ -377,13 +489,8 @@ void CConfigManager::handleMonitor(const std::string& command, const std::string
         return;
     }
 
-    // overwrite if exists
-    for (auto& r : m_dMonitorRules) {
-        if (r.name == newrule.name) {
-            r = newrule;
-            return;
-        }
-    }
+    if (std::find_if(m_dMonitorRules.begin(), m_dMonitorRules.end(), [&](const auto& other) { return other.name == newrule.name; }) != m_dMonitorRules.end())
+        m_dMonitorRules.erase(std::remove_if(m_dMonitorRules.begin(), m_dMonitorRules.end(), [&](const auto& other) { return other.name == newrule.name; }));
 
     m_dMonitorRules.push_back(newrule);
 }
@@ -410,17 +517,39 @@ void CConfigManager::handleBezier(const std::string& command, const std::string&
     std::string bezierName = curitem;
 
     nextItem();
+    if (curitem == "")
+        parseError = "too few arguments";
     float p1x = std::stof(curitem);
     nextItem();
+    if (curitem == "")
+        parseError = "too few arguments";
     float p1y = std::stof(curitem);
     nextItem();
+    if (curitem == "")
+        parseError = "too few arguments";
     float p2x = std::stof(curitem);
     nextItem();
+    if (curitem == "")
+        parseError = "too few arguments";
     float p2y = std::stof(curitem);
+    nextItem();
+    if (curitem != "")
+        parseError = "too many arguments";
 
     g_pAnimationManager->addBezierWithName(bezierName, Vector2D(p1x, p1y), Vector2D(p2x, p2y));
 }
 
+void CConfigManager::setAnimForChildren(SAnimationPropertyConfig *const ANIM) {
+    for (auto& [name, anim] : animationConfig) {
+        if (anim.pParentAnimation == ANIM && !anim.overriden) {
+            // if a child isnt overriden, set the values of the parent
+            anim.pValues = ANIM->pValues;
+
+            setAnimForChildren(&anim);
+        }
+    }
+};
+
 void CConfigManager::handleAnimation(const std::string& command, const std::string& args) {
     std::string curitem = "";
 
@@ -444,38 +573,94 @@ void CConfigManager::handleAnimation(const std::string& command, const std::stri
 
     // anim name
     const auto ANIMNAME = curitem;
-    const auto ANIMMASTERSETTING = configValues.find("animations:" + ANIMNAME);
+    
+    const auto PANIM = animationConfig.find(ANIMNAME);
 
-    if (ANIMMASTERSETTING == configValues.end()) {
-        Debug::log(ERR, "Anim %s doesnt exist", ANIMNAME.c_str());
-        parseError = "Animation " + ANIMNAME + " does not exist";
+    if (PANIM == animationConfig.end()) {
+        parseError = "no such animation";
         return;
     }
 
+    PANIM->second.overriden = true;
+    PANIM->second.pValues = &PANIM->second;
+
     nextItem();
 
     // on/off
-    configSetValueSafe("animations:" + ANIMNAME, curitem);
+    PANIM->second.internalEnabled = curitem == "1";
+
+    if (curitem != "0" && curitem != "1") {
+        parseError = "invalid animation on/off state";
+    }
 
     nextItem();
 
-    // Speed
-    configSetValueSafe("animations:" + ANIMNAME + "_speed", curitem);
+    // speed
+    if (isNumber(curitem, true)) {
+        PANIM->second.internalSpeed = std::stof(curitem);
+
+        if (PANIM->second.internalSpeed <= 0) {
+            parseError = "invalid speed";
+            PANIM->second.internalSpeed = 1.f;
+        }
+    } else {
+        PANIM->second.internalSpeed = 10.f;
+        parseError = "invalid speed";
+    }
 
     nextItem();
 
     // curve
-    configSetValueSafe("animations:" + ANIMNAME + "_curve", curitem);
+    PANIM->second.internalBezier = curitem;
+
+    if (!g_pAnimationManager->bezierExists(curitem)) {
+        parseError = "no such bezier";
+        PANIM->second.internalBezier = "default";
+    }
 
     nextItem();
 
     // style
-    configSetValueSafe("animations:" + ANIMNAME + "_style", curitem);
+    PANIM->second.internalStyle = curitem;
+
+    if (curitem != "") {
+        const auto ERR = g_pAnimationManager->styleValidInConfigVar(ANIMNAME, curitem);
+
+        if (ERR != "")
+            parseError = ERR;
+    }
+
+    // now, check for children, recursively
+    setAnimForChildren(&PANIM->second);
 }
 
-void CConfigManager::handleBind(const std::string& command, const std::string& value, bool locked) {
+void CConfigManager::handleBind(const std::string& command, const std::string& value) {
     // example:
-    // bind=SUPER,G,exec,dmenu_run <args>
+    // bind[fl]=SUPER,G,exec,dmenu_run <args>
+
+    // flags
+    bool locked = false;
+    bool release = false;
+    bool repeat = false;
+    const auto ARGS = command.substr(4);
+
+    for (auto& arg : ARGS) {
+        if (arg == 'l') {
+            locked = true;
+        } else if (arg == 'r') {
+            release = true;
+        } else if (arg == 'e') {
+            repeat = true;
+        } else {
+            parseError = "bind: invalid flag";
+            return;
+        }
+    }
+
+    if (release && repeat) {
+        parseError = "flags r and e are mutually exclusive";
+        return;
+    }
 
     auto valueCopy = value;
 
@@ -505,8 +690,13 @@ void CConfigManager::handleBind(const std::string& command, const std::string& v
         return;
     }
 
-    if (KEY != "")
-        g_pKeybindManager->addKeybind(SKeybind{KEY, MOD, HANDLER, COMMAND, locked, m_szCurrentSubmap});
+    if (KEY != "") {
+        if (isNumber(KEY) && std::stoi(KEY) > 9)
+            g_pKeybindManager->addKeybind(SKeybind{"", std::stoi(KEY), MOD, HANDLER, COMMAND, locked, m_szCurrentSubmap, release, repeat});
+        else
+            g_pKeybindManager->addKeybind(SKeybind{KEY, -1, MOD, HANDLER, COMMAND, locked, m_szCurrentSubmap, release, repeat});
+    }
+        
 }
 
 void CConfigManager::handleUnbind(const std::string& command, const std::string& value) {
@@ -539,6 +729,8 @@ void CConfigManager::handleWindowRule(const std::string& command, const std::str
         && RULE.find("monitor") != 0
         && RULE != "nofocus"
         && RULE != "noblur"
+        && RULE != "center"
+        && RULE != "opaque"
         && RULE != "fullscreen"
         && RULE.find("animation") != 0
         && RULE.find("rounding") != 0
@@ -552,6 +744,16 @@ void CConfigManager::handleWindowRule(const std::string& command, const std::str
 
 }
 
+void CConfigManager::handleBlurLS(const std::string& command, const std::string& value) {
+    if (value.find("remove,") == 0) {
+        const auto TOREMOVE = value.substr(7);
+        m_dBlurLSNamespaces.erase(std::remove(m_dBlurLSNamespaces.begin(), m_dBlurLSNamespaces.end(), TOREMOVE));
+        return;
+    }
+
+    m_dBlurLSNamespaces.emplace_back(value);
+}
+
 void CConfigManager::handleDefaultWorkspace(const std::string& command, const std::string& value) {
 
     const auto DISPLAY = value.substr(0, value.find_first_of(','));
@@ -575,12 +777,14 @@ void CConfigManager::handleSubmap(const std::string& command, const std::string&
 void CConfigManager::handleSource(const std::string& command, const std::string& rawpath) {
     static const char* const ENVHOME = getenv("HOME");
 
-    auto value = rawpath;
-
-    if (value[0] == '~') {
-        value.replace(0, 1, std::string(ENVHOME));
+    if (rawpath.length() < 2) {
+        Debug::log(ERR, "source= path garbage");
+        parseError = "source path " + rawpath + " bogus!";
+        return;
     }
 
+    auto value = absolutePath(rawpath, configCurrentPath);
+
     if (!std::filesystem::exists(value)) {
         Debug::log(ERR, "source= file doesnt exist");
         parseError = "source file " + value + " doesn't exist!";
@@ -644,8 +848,7 @@ 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.find("bind") == 0) handleBind(COMMAND, VALUE);
     else if (COMMAND == "unbind") handleUnbind(COMMAND, VALUE);
     else if (COMMAND == "workspace") handleDefaultWorkspace(COMMAND, VALUE);
     else if (COMMAND == "windowrule") handleWindowRule(COMMAND, VALUE);
@@ -653,6 +856,7 @@ std::string CConfigManager::parseKeyword(const std::string& COMMAND, const std::
     else if (COMMAND == "animation") handleAnimation(COMMAND, VALUE);
     else if (COMMAND == "source") handleSource(COMMAND, VALUE);
     else if (COMMAND == "submap") handleSubmap(COMMAND, VALUE);
+    else if (COMMAND == "blurls") handleBlurLS(COMMAND, VALUE);
     else
         configSetValueSafe(currentCategory + (currentCategory == "" ? "" : ":") + COMMAND, VALUE);
 
@@ -665,7 +869,7 @@ std::string CConfigManager::parseKeyword(const std::string& COMMAND, const std::
             g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
 
         // Update window border colors
-        g_pCompositor->updateAllWindowsBorders();
+        g_pCompositor->updateAllWindowsAnimatedDecorationValues();
 
         return retval;
     }
@@ -705,9 +909,10 @@ void CConfigManager::parseLine(std::string& line) {
         line = line.substr(1);
     }
 
-    if (line.find(" {") != std::string::npos) {
+    if (line.contains(" {")) {
         auto cat = line.substr(0, line.find(" {"));
         transform(cat.begin(), cat.end(), cat.begin(), ::tolower);
+        std::replace(cat.begin(), cat.end(), ' ', '-');
         if (currentCategory.length() != 0) {
             currentCategory.push_back(':');
             currentCategory.append(cat);
@@ -719,7 +924,7 @@ void CConfigManager::parseLine(std::string& line) {
         return;
     }
 
-    if (line.find("}") != std::string::npos && currentCategory != "") {
+    if (line.contains("}") && currentCategory != "") {
         currentCategory = "";
         return;
     }
@@ -755,32 +960,43 @@ void CConfigManager::loadConfigLoadVars() {
     m_mAdditionalReservedAreas.clear();
     configDynamicVars.clear();
     deviceConfigs.clear();
+    m_dBlurLSNamespaces.clear();
+    setDefaultAnimationVars(); // reset anims
 
     // paths
     configPaths.clear();
 
+    std::string CONFIGPATH;
+
     static const char* const ENVHOME = getenv("HOME");
     const std::string CONFIGPARENTPATH = ENVHOME + (std::string) "/.config/hypr/";
-    const std::string CONFIGPATH = CONFIGPARENTPATH + (ISDEBUG ? "hyprlandd.conf" : "hyprland.conf");
+
+    if (g_pCompositor->explicitConfigPath == "") {
+        CONFIGPATH = CONFIGPARENTPATH + (ISDEBUG ? "hyprlandd.conf" : "hyprland.conf");
+    } else {
+        CONFIGPATH = g_pCompositor->explicitConfigPath;
+    }
 
     configPaths.push_back(CONFIGPATH);
-
+ 
     std::ifstream ifs;
     ifs.open(CONFIGPATH);
 
     if (!ifs.good()) {
-        Debug::log(WARN, "Config reading error. (No file? Attempting to generate, backing up old one if exists)");
-        try {
-            std::filesystem::rename(CONFIGPATH, CONFIGPATH + ".backup");
-        } catch(...) { /* Probably doesn't exist */}
+        if(g_pCompositor->explicitConfigPath == "") {
+            Debug::log(WARN, "Config reading error. (No file? Attempting to generate, backing up old one if exists)");
+            try {
+                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;
+            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;
@@ -827,8 +1043,10 @@ void CConfigManager::loadConfigLoadVars() {
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
 
     // Update the keyboard layout to the cfg'd one if this is not the first launch
-    if (!isFirstLaunch)
+    if (!isFirstLaunch) {
         g_pInputManager->setKeyboardLayout();
+        g_pInputManager->setMouseConfigs();
+    }
 
     // Calculate the internal vars
     configValues["general:main_mod_internal"].intValue = g_pKeybindManager->stringToModMask(configValues["general:main_mod"].strValue);
@@ -844,23 +1062,37 @@ void CConfigManager::loadConfigLoadVars() {
     if (parseError != "")
         g_pHyprError->queueCreate(parseError + "\nHyprland may not work correctly.", CColor(255, 50, 50, 255));
     else if (configValues["autogenerated"].intValue == 1)
-        g_pHyprError->queueCreate("Warning: You're using an autogenerated config! (config file: " + CONFIGPATH + " )\nSUPER+Enter -> kitty\nSUPER+T -> Alacritty\nSUPER+M -> exit Hyprland", CColor(255, 255, 70, 255));
+        g_pHyprError->queueCreate("Warning: You're using an autogenerated config! (config file: " + CONFIGPATH + " )\nSUPER+Q -> kitty\nSUPER+M -> exit Hyprland", CColor(255, 255, 70, 255));
     else
         g_pHyprError->destroy();
 
     // Set the modes for all monitors as we configured them
     // not on first launch because monitors might not exist yet
     // and they'll be taken care of in the newMonitor event
-    if (!isFirstLaunch) {
+    // ignore if nomonitorreload is set
+    if (!isFirstLaunch && !m_bNoMonitorReload) {
         m_bWantsMonitorReload = true;
+
+        // check
+        ensureDPMS();
     }
 
     // Update window border colors
-    g_pCompositor->updateAllWindowsBorders();
+    g_pCompositor->updateAllWindowsAnimatedDecorationValues();
+
+    // update layout
+    g_pLayoutManager->switchToLayout(configValues["general:layout"].strValue);
+
+    // mark blur dirty
+    for (auto& m : g_pCompositor->m_vMonitors)
+        g_pHyprOpenGL->markBlurDirtyForMonitor(m.get());
 
     // Force the compositor to fully re-render all monitors
     for (auto& m : g_pCompositor->m_vMonitors)
         m->forceFullFrames = 2;
+    
+    // Reset no monitor reload
+    m_bNoMonitorReload = false;
 }
 
 void CConfigManager::tick() {
@@ -909,9 +1141,13 @@ SConfigValue CConfigManager::getConfigValueSafe(const std::string& val) {
 SConfigValue CConfigManager::getConfigValueSafeDevice(const std::string& dev, const std::string& val) {
     std::lock_guard<std::mutex> lg(configmtx);
 
-    const auto it = deviceConfigs.find(dev);
+    auto devcopy = dev;
+    std::replace(devcopy.begin(), devcopy.end(), ' ', '-');
+
+    const auto it = deviceConfigs.find(devcopy);
 
     if (it == deviceConfigs.end()) {
+        Debug::log(ERR, "getConfigValueSafeDevice: No device config for %s found???", devcopy.c_str());
         return SConfigValue();
     }
 
@@ -920,7 +1156,11 @@ SConfigValue CConfigManager::getConfigValueSafeDevice(const std::string& dev, co
     // fallback if not set explicitly
     if (!copy.set) {
         for (auto& cv : configValues) {
-            if (cv.first.find(val) == cv.first.length() - val.length()) {
+            auto foundIt = cv.first.find(val);
+            if (foundIt == std::string::npos)
+                continue;
+
+            if (cv.first == "input:" + val || cv.first == "input:touchpad:" + cv.first) {
                 copy = cv.second;
             }
         }
@@ -1002,7 +1242,7 @@ SMonitorRule CConfigManager::getMonitorRuleFor(std::string name) {
 
     Debug::log(WARN, "No rules configured. Using the default hardcoded one.");
 
-    return SMonitorRule{.name = "", .resolution = Vector2D(1280, 720), .offset = Vector2D(0, 0), .scale = 1};
+    return SMonitorRule{.name = "", .resolution = Vector2D(0, 0), .offset = Vector2D(-1, -1), .scale = 1}; // 0, 0 is preferred and -1, -1 is auto
 }
 
 std::vector<SWindowRule> CConfigManager::getMatchingRules(CWindow* pWindow) {
@@ -1056,13 +1296,22 @@ void CConfigManager::dispatchExecOnce() {
     }
 
     firstExecRequests.clear(); // free some kb of memory :P
+
+    // set input, fixes some certain issues
+    g_pInputManager->setKeyboardLayout();
+    g_pInputManager->setMouseConfigs();
+
+    // set ws names again
+    for (auto& ws : g_pCompositor->m_vWorkspaces) {
+        wlr_ext_workspace_handle_v1_set_name(ws->m_pWlrHandle, ws->m_szName.c_str());
+    }
 }
 
 void CConfigManager::performMonitorReload() {
 
     bool overAgain = false;
 
-    for (auto& m : g_pCompositor->m_vMonitors) {
+    for (auto& m : g_pCompositor->m_vRealMonitors) {
         auto rule = getMonitorRuleFor(m->szName);
         if (!g_pHyprRenderer->applyMonitorRule(m.get(), &rule)) {
             overAgain = true;
@@ -1080,9 +1329,50 @@ SConfigValue* CConfigManager::getConfigValuePtr(std::string val) {
     return &configValues[val];
 }
 
+SConfigValue* CConfigManager::getConfigValuePtrSafe(std::string val) {
+    const auto IT = configValues.find(val);
+
+    if (IT == configValues.end())
+        return nullptr;
+
+    return &(IT->second);
+}
+
 bool CConfigManager::deviceConfigExists(const std::string& dev) {
-    const auto it = deviceConfigs.find(dev);
+    auto copy = dev;
+    std::replace(copy.begin(), copy.end(), ' ', '-');
+
+    const auto it = deviceConfigs.find(copy);
 
     return it != deviceConfigs.end();
 }
 
+bool CConfigManager::shouldBlurLS(const std::string& ns) {
+    for (auto& bls : m_dBlurLSNamespaces) {
+        if (bls == ns) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void CConfigManager::ensureDPMS() {
+    for (auto& rm : g_pCompositor->m_vRealMonitors) {
+        auto rule = getMonitorRuleFor(rm->szName);
+
+        if (rule.disabled == rm->m_bEnabled) {
+	        rm->m_pThisWrap = &rm;
+            g_pHyprRenderer->applyMonitorRule(rm.get(), &rule);
+        }
+    }
+}
+
+SAnimationPropertyConfig* CConfigManager::getAnimationPropertyConfig(const std::string& name) {
+    return &animationConfig[name];
+}
+
+void CConfigManager::addParseError(const std::string& err) {
+    if (parseError == "")
+        parseError = err;
+}

src/config/ConfigManager.hpp

@@ -16,6 +16,9 @@
 
 #define STRVAL_EMPTY "[[EMPTY]]"
 
+#define INITANIMCFG(name)  animationConfig[name] = {}
+#define CREATEANIMCFG(name, parent) animationConfig[name] = {false, "", "", 0.f, -1, &animationConfig["global"], &animationConfig[parent]}
+
 struct SConfigValue {
     int64_t intValue = -1;
     float floatValue = -1;
@@ -47,6 +50,18 @@ struct SWindowRule {
     std::string szValue;
 };
 
+struct SAnimationPropertyConfig {
+    bool            overriden = true;
+
+    std::string     internalBezier = "";
+    std::string     internalStyle = "";
+    float           internalSpeed = 0.f;
+    int             internalEnabled = -1;
+
+    SAnimationPropertyConfig* pValues = nullptr;
+    SAnimationPropertyConfig* pParentAnimation = nullptr;
+};
+
 class CConfigManager {
 public:
     CConfigManager();
@@ -65,8 +80,10 @@ public:
     float               getDeviceFloat(const std::string&, const std::string&);
     std::string         getDeviceString(const std::string&, const std::string&);
     bool                deviceConfigExists(const std::string&);
+    bool                shouldBlurLS(const std::string&);
 
     SConfigValue*       getConfigValuePtr(std::string);
+    SConfigValue*       getConfigValuePtrSafe(std::string);
 
     SMonitorRule        getMonitorRuleFor(std::string);
 
@@ -80,9 +97,17 @@ public:
     void                performMonitorReload();
     bool                m_bWantsMonitorReload = false;
     bool                m_bForceReload = false;
+    bool                m_bNoMonitorReload = false;
+    void                ensureDPMS();
 
     std::string         parseKeyword(const std::string&, const std::string&, bool dynamic = false);
 
+    void                addParseError(const std::string&);
+
+    SAnimationPropertyConfig* getAnimationPropertyConfig(const std::string&);
+
+    std::string                                   configCurrentPath;
+
 private:
     std::deque<std::string>                       configPaths; // stores all the config paths
     std::unordered_map<std::string, time_t>       configModifyTimes; // stores modify times
@@ -90,7 +115,7 @@ private:
     std::unordered_map<std::string, SConfigValue> configValues;
     std::unordered_map<std::string, std::unordered_map<std::string, SConfigValue>> deviceConfigs; // stores device configs
 
-    std::string                                   configCurrentPath;
+    std::unordered_map<std::string, SAnimationPropertyConfig> animationConfig; // stores all the animations with their set values
 
     std::string currentCategory = "";  // For storing the category of the current item
 
@@ -102,14 +127,18 @@ private:
 
     std::deque<SMonitorRule> m_dMonitorRules;
     std::deque<SWindowRule> m_dWindowRules;
+    std::deque<std::string> m_dBlurLSNamespaces;
 
     bool firstExecDispatched = false;
     std::deque<std::string> firstExecRequests;
 
     // internal methods
     void                setDefaultVars();
+    void                setDefaultAnimationVars();
     void                setDeviceDefaultVars(const std::string&);
 
+    void                setAnimForChildren(SAnimationPropertyConfig *const);
+
     void                applyUserDefinedVars(std::string&, const size_t);
     void                loadConfigLoadVars();
     SConfigValue        getConfigValueSafe(const std::string&);
@@ -119,7 +148,7 @@ private:
     void                handleDeviceConfig(const std::string&, const std::string&);
     void                handleRawExec(const std::string&, const std::string&);
     void                handleMonitor(const std::string&, const std::string&);
-    void                handleBind(const std::string&, const std::string&, bool locked = false);
+    void                handleBind(const std::string&, const std::string&);
     void                handleUnbind(const std::string&, const std::string&);
     void                handleWindowRule(const std::string&, const std::string&);
     void                handleDefaultWorkspace(const std::string&, const std::string&);
@@ -127,6 +156,7 @@ private:
     void                handleAnimation(const std::string&, const std::string&);
     void                handleSource(const std::string&, const std::string&);
     void                handleSubmap(const std::string&, const std::string&);
+    void                handleBlurLS(const std::string&, const std::string&);
 };
 
-inline std::unique_ptr<CConfigManager> g_pConfigManager;
+inline std::unique_ptr<CConfigManager> g_pConfigManager;

src/config/defaultConfig.hpp

@@ -9,11 +9,18 @@ PLEASE USE THE CONFIG PROVIDED IN THE GIT REPO /examples/hypr.conf AND EDIT IT,
 OR EDIT THIS ONE ACCORDING TO THE WIKI INSTRUCTIONS.
 ########################################################################################
 
+
+#
+# Please note not all available settings / options are set here.
+# For a full list, see the wiki (basic and advanced configuring)
+#
+
 autogenerated=1 # remove this line to get rid of the warning on top.
 
-monitor=,1920x1080@60,0x0,1
+monitor=,preferred,auto,1
 
 input {
+    kb_file=
     kb_layout=
     kb_variant=
     kb_model=
@@ -21,6 +28,10 @@ input {
     kb_rules=
 
     follow_mouse=1
+
+    touchpad {
+        natural_scroll=no
+    }
 }
 
 general {
@@ -51,8 +62,8 @@ decoration {
 animations {
     enabled=1
     animation=windows,1,7,default
-    animation=borders,1,10,default
-    animation=fadein,1,10,default
+    animation=border,1,10,default
+    animation=fade,1,10,default
     animation=workspaces,1,6,default
 }
 
@@ -60,6 +71,10 @@ dwindle {
     pseudotile=0 # enable pseudotiling on dwindle
 }
 
+gestures {
+    workspace_swipe=no
+}
+
 # example window rules
 # for windows named/classed as abc and xyz
 #windowrule=move 69 420,abc
@@ -105,4 +120,7 @@ bind=ALT,7,movetoworkspace,7
 bind=ALT,8,movetoworkspace,8
 bind=ALT,9,movetoworkspace,9
 bind=ALT,0,movetoworkspace,10
-)#";
+
+bind=SUPER,mouse_down,workspace,e+1
+bind=SUPER,mouse_up,workspace,e-1
+)#";

src/debug/HyprCtl.cpp

@@ -13,117 +13,452 @@
 
 #include <string>
 
-std::string monitorsRequest() {
+std::string monitorsRequest(HyprCtl::eHyprCtlOutputFormat format) {
     std::string result = "";
-    for (auto& m : g_pCompositor->m_vMonitors) {
-        result += getFormat("Monitor %s (ID %i):\n\t%ix%i@%f at %ix%i\n\tactive workspace: %i (%s)\n\treserved: %i %i %i %i\n\tscale: %.2f\n\ttransform: %i\n\n",
-                            m->szName.c_str(), m->ID, (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y, m->activeWorkspace, g_pCompositor->getWorkspaceByID(m->activeWorkspace)->m_szName.c_str(), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform);
+    if (format == HyprCtl::FORMAT_JSON) {
+        result += "[";
+        
+        for (auto& m : g_pCompositor->m_vMonitors) {
+            result += getFormat(
+R"#({
+    "id": %i,
+    "name": "%s",
+    "width": %i,
+    "height": %i,
+    "refreshRate": %f,
+    "x": %i,
+    "y": %i,
+    "activeWorkspace": {
+        "id": %i,
+        "name": "%s"
+    },
+    "reserved": [%i, %i, %i, %i],
+    "scale": %.2f,
+    "transform": %i,
+    "focused": %s
+},)#",
+                m->ID,
+                escapeJSONStrings(m->szName).c_str(),
+                (int)m->vecPixelSize.x, (int)m->vecPixelSize.y,
+                m->refreshRate,
+                (int)m->vecPosition.x, (int)m->vecPosition.y,
+                m->activeWorkspace, escapeJSONStrings(g_pCompositor->getWorkspaceByID(m->activeWorkspace)->m_szName).c_str(),
+                (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y,
+                m->scale,
+                (int)m->transform,
+                (m.get() == g_pCompositor->m_pLastMonitor ? "true" : "false")
+            );
+        }
+
+        // remove trailing comma
+        result.pop_back();
+
+        result += "]";
+    } else {
+        for (auto& m : g_pCompositor->m_vMonitors) {
+            result += getFormat("Monitor %s (ID %i):\n\t%ix%i@%f at %ix%i\n\tactive workspace: %i (%s)\n\treserved: %i %i %i %i\n\tscale: %.2f\n\ttransform: %i\n\tfocused: %s\n\n",
+                                m->szName.c_str(), m->ID, (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y, m->activeWorkspace, g_pCompositor->getWorkspaceByID(m->activeWorkspace)->m_szName.c_str(), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m.get() == g_pCompositor->m_pLastMonitor ? "yes" : "no"));
+        }
     }
 
     return result;
 }
 
-std::string clientsRequest() {
+std::string clientsRequest(HyprCtl::eHyprCtlOutputFormat format) {
     std::string result = "";
-    for (auto& w : g_pCompositor->m_vWindows) {
-        if (w->m_bIsMapped) {
-            result += getFormat("Window %x -> %s:\n\tat: %i,%i\n\tsize: %i,%i\n\tworkspace: %i (%s)\n\tfloating: %i\n\tmonitor: %i\n\tclass: %s\n\ttitle: %s\n\tpid: %i\n\n",
-                            &w, w->m_szTitle.c_str(), (int)w->m_vRealPosition.vec().x, (int)w->m_vRealPosition.vec().y, (int)w->m_vRealSize.vec().x, (int)w->m_vRealSize.vec().y, w->m_iWorkspaceID, (w->m_iWorkspaceID == -1 ? "" : g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_szName.c_str() : std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID)).c_str()), (int)w->m_bIsFloating, w->m_iMonitorID, g_pXWaylandManager->getAppIDClass(w.get()).c_str(), g_pXWaylandManager->getTitle(w.get()).c_str(), w->getPID());
-    
+    if (format == HyprCtl::FORMAT_JSON) {
+        result += "[";
+
+        for (auto& w : g_pCompositor->m_vWindows) {
+            if (w->m_bIsMapped) {
+                result += getFormat(
+R"#({
+    "address": "0x%x",
+    "at": [%i, %i],
+    "size": [%i, %i],
+    "workspace": {
+        "id": %i,
+        "name": "%s"
+    },
+    "floating": %s,
+    "monitor": %i,
+    "class": "%s",
+    "title": "%s",
+    "pid": %i,
+    "xwayland": %s
+},)#",
+                    w.get(),
+                    (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, escapeJSONStrings(w->m_iWorkspaceID == -1 ? "" : g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_szName : std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID))).c_str(),
+                    ((int)w->m_bIsFloating == 1 ? "true" : "false"),
+                    w->m_iMonitorID,
+                    escapeJSONStrings(g_pXWaylandManager->getAppIDClass(w.get())).c_str(),
+                    escapeJSONStrings(g_pXWaylandManager->getTitle(w.get())).c_str(),
+                    w->getPID(),
+                    ((int)w->m_bIsX11 == 1 ? "true" : "false")
+                );
+            }
+        }
+
+        // remove trailing comma
+        if (result != "[")
+          result.pop_back();
+
+        result += "]";
+    } else {
+        for (auto& w : g_pCompositor->m_vWindows) {
+            if (w->m_bIsMapped) {
+                result += getFormat("Window %x -> %s:\n\tat: %i,%i\n\tsize: %i,%i\n\tworkspace: %i (%s)\n\tfloating: %i\n\tmonitor: %i\n\tclass: %s\n\ttitle: %s\n\tpid: %i\n\txwayland: %i\n\n",
+                                w.get(), w->m_szTitle.c_str(), (int)w->m_vRealPosition.vec().x, (int)w->m_vRealPosition.vec().y, (int)w->m_vRealSize.vec().x, (int)w->m_vRealSize.vec().y, w->m_iWorkspaceID, (w->m_iWorkspaceID == -1 ? "" : g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_szName.c_str() : std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID)).c_str()), (int)w->m_bIsFloating, w->m_iMonitorID, g_pXWaylandManager->getAppIDClass(w.get()).c_str(), g_pXWaylandManager->getTitle(w.get()).c_str(), w->getPID(), (int)w->m_bIsX11);
+        
+            }
         }
     }
     return result;
 }
 
-std::string workspacesRequest() {
+std::string workspacesRequest(HyprCtl::eHyprCtlOutputFormat format) {
     std::string result = "";
-    for (auto& w : g_pCompositor->m_vWorkspaces) {
-        result += getFormat("workspace ID %i (%s) on monitor %s:\n\twindows: %i\n\thasfullscreen: %i\n\n",
-                            w->m_iID, w->m_szName.c_str(), g_pCompositor->getMonitorFromID(w->m_iMonitorID)->szName.c_str(), g_pCompositor->getWindowsOnWorkspace(w->m_iID), (int)w->m_bHasFullscreenWindow);
+    if (format == HyprCtl::FORMAT_JSON) {
+        result += "[";
+
+        for (auto& w : g_pCompositor->m_vWorkspaces) {
+            result += getFormat(
+R"#({
+    "id": %i,
+    "name": "%s",
+    "monitor": "%s",
+    "windows": %i,
+    "hasfullscreen": %s
+},)#",
+                w->m_iID,
+                escapeJSONStrings(w->m_szName).c_str(),
+                escapeJSONStrings(g_pCompositor->getMonitorFromID(w->m_iMonitorID)->szName).c_str(),
+                g_pCompositor->getWindowsOnWorkspace(w->m_iID),
+                ((int)w->m_bHasFullscreenWindow == 1 ? "true" : "false")
+            );
+        }
+
+        // remove trailing comma
+        result.pop_back();
+
+        result += "]";
+    } else {
+        for (auto& w : g_pCompositor->m_vWorkspaces) {
+            result += getFormat("workspace ID %i (%s) on monitor %s:\n\twindows: %i\n\thasfullscreen: %i\n\n",
+                                w->m_iID, w->m_szName.c_str(), g_pCompositor->getMonitorFromID(w->m_iMonitorID)->szName.c_str(), g_pCompositor->getWindowsOnWorkspace(w->m_iID), (int)w->m_bHasFullscreenWindow);
+        }
     }
     return result;
 }
 
-std::string activeWindowRequest() {
+std::string activeWindowRequest(HyprCtl::eHyprCtlOutputFormat format) {
     const auto PWINDOW = g_pCompositor->m_pLastWindow;
 
     if (!g_pCompositor->windowValidMapped(PWINDOW))
-        return "Invalid";
+        return format == HyprCtl::FORMAT_JSON ? "{}" : "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\tclass: %s\n\ttitle: %s\n\tpid: %i\n\n",
-                        PWINDOW, PWINDOW->m_szTitle.c_str(), (int)PWINDOW->m_vRealPosition.vec().x, (int)PWINDOW->m_vRealPosition.vec().y, (int)PWINDOW->m_vRealSize.vec().x, (int)PWINDOW->m_vRealSize.vec().y, PWINDOW->m_iWorkspaceID, (PWINDOW->m_iWorkspaceID == -1 ? "" : g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID)->m_szName.c_str()), (int)PWINDOW->m_bIsFloating, (int)PWINDOW->m_iMonitorID, g_pXWaylandManager->getAppIDClass(PWINDOW).c_str(), g_pXWaylandManager->getTitle(PWINDOW).c_str(), PWINDOW->getPID());
+    if (format == HyprCtl::FORMAT_JSON) {
+        return getFormat(
+R"#({
+    "address": "0x%x",
+    "at": [%i, %i],
+    "size": [%i, %i],
+    "workspace": {
+        "id": %i,
+        "name": "%s"
+    },
+    "floating": %s,
+    "monitor": %i,
+    "class": "%s",
+    "title": "%s",
+    "pid": %i,
+    "xwayland": %s
+})#",
+            PWINDOW,
+            (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, escapeJSONStrings(PWINDOW->m_iWorkspaceID == -1 ? "" : g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID)->m_szName).c_str(),
+            ((int)PWINDOW->m_bIsFloating == 1 ? "true" : "false"),
+            PWINDOW->m_iMonitorID,
+            escapeJSONStrings(g_pXWaylandManager->getAppIDClass(PWINDOW)).c_str(),
+            escapeJSONStrings(g_pXWaylandManager->getTitle(PWINDOW)).c_str(),
+            PWINDOW->getPID(),
+            ((int)PWINDOW->m_bIsX11 == 1 ? "true" : "false")
+        );
+    } else {
+        return getFormat("Window %x -> %s:\n\tat: %i,%i\n\tsize: %i,%i\n\tworkspace: %i (%s)\n\tfloating: %i\n\tmonitor: %i\n\tclass: %s\n\ttitle: %s\n\tpid: %i\n\txwayland: %i\n\n",
+                            PWINDOW, PWINDOW->m_szTitle.c_str(), (int)PWINDOW->m_vRealPosition.vec().x, (int)PWINDOW->m_vRealPosition.vec().y, (int)PWINDOW->m_vRealSize.vec().x, (int)PWINDOW->m_vRealSize.vec().y, PWINDOW->m_iWorkspaceID, (PWINDOW->m_iWorkspaceID == -1 ? "" : g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID)->m_szName.c_str()), (int)PWINDOW->m_bIsFloating, (int)PWINDOW->m_iMonitorID, g_pXWaylandManager->getAppIDClass(PWINDOW).c_str(), g_pXWaylandManager->getTitle(PWINDOW).c_str(), PWINDOW->getPID(), (int)PWINDOW->m_bIsX11);
+    }
 }
 
-std::string layersRequest() {
+std::string layersRequest(HyprCtl::eHyprCtlOutputFormat format) {
     std::string result = "";
 
-    for (auto& mon : g_pCompositor->m_vMonitors) {
-        result += getFormat("Monitor %s:\n");
-        int layerLevel = 0;
-        for (auto& level : mon->m_aLayerSurfaceLists) {
-            result += getFormat("\tLayer level %i:\n", layerLevel);
+    if (format == HyprCtl::FORMAT_JSON) {
+        result += "{\n";
 
-            for (auto& layer : level) {
-                result += getFormat("\t\tLayer %x: xywh: %i %i %i %i\n", layer, layer->geometry.x, layer->geometry.y, layer->geometry.width, layer->geometry.height);
+        for (auto& mon : g_pCompositor->m_vMonitors) {
+            result += getFormat(
+R"#("%s": {
+    "levels": {
+)#",
+                escapeJSONStrings(mon->szName).c_str()
+            ); 
+
+            int layerLevel = 0;
+            for (auto& level : mon->m_aLayerSurfaceLists) {
+                result += getFormat(
+R"#(        
+        "%i": [
+)#",
+                    layerLevel
+                );
+                for (auto& layer : level) {
+                    result += getFormat(
+R"#(                {
+                    "address": "0x%x",
+                    "x": %i,
+                    "y": %i,
+                    "w": %i,
+                    "h": %i,
+                    "namespace": "%s"
+                },)#",
+					layer.get(),
+                    layer->geometry.x,
+                    layer->geometry.y,
+                    layer->geometry.width,
+                    layer->geometry.height,
+                    escapeJSONStrings(layer->szNamespace).c_str()
+                    );
+                }
+
+                // remove trailing comma
+                result.pop_back();
+
+                if (level.size() > 0)
+                    result += "\n        ";
+
+                result += "],";
+
+                layerLevel++;
             }
 
-            layerLevel++;
+            // remove trailing comma
+            result.pop_back();
+
+            result += "\n    }\n},";
+        }
+
+        // remove trailing comma
+        result.pop_back();
+
+        result += "\n}\n";
+        
+    } else {
+        for (auto& mon : g_pCompositor->m_vMonitors) {
+            result += getFormat("Monitor %s:\n", mon->szName.c_str());
+            int layerLevel = 0;
+            for (auto& level : mon->m_aLayerSurfaceLists) {
+                result += getFormat("\tLayer level %i:\n", layerLevel);
+
+                for (auto& layer : level) {
+                    result += getFormat("\t\tLayer %x: xywh: %i %i %i %i, namespace: %s\n", layer.get(), layer->geometry.x, layer->geometry.y, layer->geometry.width, layer->geometry.height, layer->szNamespace.c_str());
+                }
+
+                layerLevel++;
+            }
+            result += "\n\n";
         }
-        result += "\n\n";
     }
 
     return result;
 }
 
-std::string devicesRequest() {
+std::string devicesRequest(HyprCtl::eHyprCtlOutputFormat format) {
     std::string result = "";
 
-    result += "mice:\n";
+    if (format == HyprCtl::FORMAT_JSON) {
+        result += "{\n";
+        result += "\"mice\": [\n";
 
-    for (auto& m : g_pInputManager->m_lMice) {
-        result += getFormat("\tMouse at %x:\n\t\t%s\n", &m, m.mouse->name);
-    }
+        for (auto& m : g_pInputManager->m_lMice) {
+            result += getFormat(
+R"#(    {
+        "address": "0x%x",
+        "name": "%s"
+    },)#",
+                &m,
+                escapeJSONStrings(m.mouse->name).c_str()
+            );
+        }
 
-    result += "\n\nKeyboards:\n";
+        // remove trailing comma
+        result.pop_back();
+        result += "\n],\n";
 
-    for (auto& k : g_pInputManager->m_lKeyboards) {
-        result += getFormat("\tKeyboard at %x:\n\t\t%s\n", &k, k.keyboard->name);
-    }
+        result += "\"keyboards\": [\n";
+        for (auto& k : g_pInputManager->m_lKeyboards) {
+            const auto KM = g_pInputManager->getActiveLayoutForKeyboard(&k);
+            result += getFormat(
+R"#(    {
+        "address": "0x%x",
+        "name": "%s",
+        "rules": "%s",
+        "model": "%s",
+        "layout": "%s",
+        "variant": "%s",
+        "options": "%s",
+        "active_keymap": "%s",
+        "main": %s
+    },)#",
+                &k,
+                escapeJSONStrings(k.keyboard->name).c_str(),
+                escapeJSONStrings(k.currentRules.rules).c_str(),
+                escapeJSONStrings(k.currentRules.model).c_str(),
+                escapeJSONStrings(k.currentRules.layout).c_str(),
+                escapeJSONStrings(k.currentRules.variant).c_str(),
+                escapeJSONStrings(k.currentRules.options).c_str(),
+                escapeJSONStrings(KM).c_str(),
+                (k.active ? "true" : "false")
+            );
+        }
 
-    result += "\n\nTablets:\n";
+        // remove trailing comma
+        result.pop_back();
+        result += "\n],\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 : "" : "");
-    }
+        result += "\"tablets\": [\n";
 
-    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_lTabletPads) {
+            result += getFormat(
+R"#(    {
+        "address": "0x%x",
+        "type": "tabletPad",
+        "belongsTo": {
+            "address": "0x%x",
+            "name": "%s"
+        }
+    },)#",
+                &d,
+                d.pTabletParent,
+                escapeJSONStrings(d.pTabletParent ? d.pTabletParent->wlrDevice ? d.pTabletParent->wlrDevice->name : "" : "").c_str()
+            );
+        }
 
-    for (auto& d : g_pInputManager->m_lTabletTools) {
-        result += getFormat("\tTablet Tool at %x (belongs to %x)\n", &d, d.wlrTabletTool ? d.wlrTabletTool->data : 0);
+        for (auto& d : g_pInputManager->m_lTablets) {
+            result += getFormat(
+R"#(    {
+        "address": "0x%x",
+        "name": "%s"
+    },)#",
+                &d,
+                escapeJSONStrings(d.wlrDevice ? d.wlrDevice->name : "").c_str()
+            );
+        }
+
+        for (auto& d : g_pInputManager->m_lTabletTools) {
+            result += getFormat(
+R"#(    {
+        "address": "0x%x",
+        "type": "tabletTool",
+        "belongsTo": "0x%x"
+    },)#",
+                &d,
+                d.wlrTabletTool ? d.wlrTabletTool->data : 0
+            );
+        }
+
+        // remove trailing comma
+        if (result[result.size() - 1] == ',')
+            result.pop_back();
+        result += "\n]\n";
+
+        result += "}\n";
+
+    } else {
+        result += "mice:\n";
+
+        for (auto& m : g_pInputManager->m_lMice) {
+            result += getFormat("\tMouse at %x:\n\t\t%s\n", &m, m.mouse->name);
+        }
+
+        result += "\n\nKeyboards:\n";
+
+        for (auto& k : g_pInputManager->m_lKeyboards) {
+            const auto KM = g_pInputManager->getActiveLayoutForKeyboard(&k);
+            result += getFormat("\tKeyboard at %x:\n\t\t%s\n\t\t\trules: r \"%s\", m \"%s\", l \"%s\", v \"%s\", o \"%s\"\n\t\t\tactive keymap: %s\n\t\t\tmain: %s\n", &k, k.keyboard->name, k.currentRules.rules.c_str(), k.currentRules.model.c_str(), k.currentRules.layout.c_str(), k.currentRules.variant.c_str(), k.currentRules.options.c_str(), KM.c_str(), (k.active ? "yes" : "no"));
+        }
+
+        result += "\n\nTablets:\n";
+
+        for (auto& d : g_pInputManager->m_lTabletPads) {
+            result += getFormat("\tTablet Pad at %x (belongs to %x -> %s)\n", &d, d.pTabletParent, d.pTabletParent ? d.pTabletParent->wlrDevice ? d.pTabletParent->wlrDevice->name : "" : "");
+        }
+
+        for (auto& d : g_pInputManager->m_lTablets) {
+            result += getFormat("\tTablet at %x:\n\t\t%s\n", &d, d.wlrDevice ? d.wlrDevice->name : "");
+        }
+
+        for (auto& d : g_pInputManager->m_lTabletTools) {
+            result += getFormat("\tTablet Tool at %x (belongs to %x)\n", &d, d.wlrTabletTool ? d.wlrTabletTool->data : 0);
+        }
     }
 
     return result;
 }
 
-std::string versionRequest() {
-    std::string result = "Hyprland, built from branch " + std::string(GIT_BRANCH) + " at commit " + GIT_COMMIT_HASH + GIT_DIRTY + " (" + GIT_COMMIT_MESSAGE + ").\nflags: (if any)\n";
+std::string versionRequest(HyprCtl::eHyprCtlOutputFormat format) {
+
+    if (format == HyprCtl::eHyprCtlOutputFormat::FORMAT_NORMAL) {
+        std::string result = "Hyprland, built from branch " + std::string(GIT_BRANCH) + " at commit " + GIT_COMMIT_HASH + GIT_DIRTY + " (" + removeBeginEndSpacesTabs(GIT_COMMIT_MESSAGE).c_str() + ").\nflags: (if any)\n";
 
 #ifdef LEGACY_RENDERER
-    result += "legacyrenderer\n";
+        result += "legacyrenderer\n";
 #endif
 #ifndef NDEBUG
-    result += "debug\n";
+        result += "debug\n";
 #endif
 #ifdef HYPRLAND_DEBUG
-	result += "debug\n";
+	    result += "debug\n";
 #endif
 #ifdef NO_XWAYLAND
-    result += "no xwayland\n";
+        result += "no xwayland\n";
 #endif
 
-    return result;
+        return result;
+    } else {
+        std::string result = getFormat(
+R"#({
+    "branch": "%s",
+    "commit": "%s",
+    "dirty": %s
+    "commit_message": "%s",
+    "flags": [)#", GIT_BRANCH, GIT_COMMIT_HASH, (strcmp(GIT_DIRTY, "dirty") == 0 ? "true" : "false"), removeBeginEndSpacesTabs(GIT_COMMIT_MESSAGE).c_str());
+
+#ifdef LEGACY_RENDERER
+        result += "\"legacyrenderer\",";
+#endif
+#ifndef NDEBUG
+        result += "\"debug\",";
+#endif
+#ifdef HYPRLAND_DEBUG
+	    result += "\"debug\",";
+#endif
+#ifdef NO_XWAYLAND
+        result += "\"no xwayland\",";
+#endif
+
+        if (result[result.length() - 1] == ',')
+            result.pop_back();
+
+        result += "]\n}";
+
+        return result;
+    }
+
+    return ""; // make the compiler happy
 }
 
 std::string dispatchRequest(std::string in) {
@@ -158,8 +493,13 @@ std::string dispatchKeyword(std::string in) {
     if (COMMAND == "monitor")
         g_pConfigManager->m_bWantsMonitorReload = true; // for monitor keywords
 
-    if (COMMAND.find("input") != std::string::npos)
+    if (COMMAND.contains("input") || COMMAND.contains("device:")) {
         g_pInputManager->setKeyboardLayout(); // update kb layout
+        g_pInputManager->setMouseConfigs(); // update mouse cfgs
+    }
+
+    if (COMMAND.contains("general:layout"))
+        g_pLayoutManager->switchToLayout(g_pConfigManager->getString("general:layout"));  // update layout
 
     Debug::log(LOG, "Hyprctl: keyword %s : %s", COMMAND.c_str(), VALUE.c_str());
 
@@ -169,9 +509,16 @@ std::string dispatchKeyword(std::string in) {
     return retval;
 }
 
-std::string reloadRequest() {
+std::string reloadRequest(std::string request) {
+    
+    const auto REQMODE = request.substr(request.find_last_of(' ') + 1);
+
     g_pConfigManager->m_bForceReload = true;
 
+    if (REQMODE == "config-only") {
+        g_pConfigManager->m_bNoMonitorReload = true;
+    }
+
     return "ok";
 }
 
@@ -181,6 +528,10 @@ std::string killRequest() {
     return "ok";
 }
 
+std::string splashRequest() {
+    return g_pCompositor->m_szCurrentSplash;
+}
+
 std::string getReply(std::string);
 
 std::string dispatchBatch(std::string request) {
@@ -215,29 +566,146 @@ std::string dispatchBatch(std::string request) {
     return reply;
 }
 
+std::string dispatchSetCursor(std::string request) {
+    std::string curitem = "";
+
+    auto nextItem = [&]() {
+        auto idx = request.find_first_of(' ');
+
+        if (idx != std::string::npos) {
+            curitem = request.substr(0, idx);
+            request = request.substr(idx + 1);
+        } else {
+            curitem = request;
+            request = "";
+        }
+
+        curitem = removeBeginEndSpacesTabs(curitem);
+    };
+
+    nextItem();
+    nextItem();
+
+    const auto THEME = curitem;
+
+    nextItem();
+
+    const auto SIZE = curitem;
+
+    if (!isNumber(SIZE)) {
+        return "size not int";
+    }
+
+    const auto SIZEINT = std::stoi(SIZE);
+
+    if (SIZEINT < 1) {
+        return "size must be positive";
+    }
+
+    wlr_xcursor_manager_destroy(g_pCompositor->m_sWLRXCursorMgr);
+
+    g_pCompositor->m_sWLRXCursorMgr = wlr_xcursor_manager_create(THEME.c_str(), SIZEINT);
+
+    setenv("XCURSOR_SIZE", SIZE.c_str(), true);
+    setenv("XCURSOR_THEME", THEME.c_str(), true);
+
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        wlr_xcursor_manager_load(g_pCompositor->m_sWLRXCursorMgr, m->scale);
+    }
+
+    return "ok";
+}
+
+std::string dispatchGetOption(std::string request, HyprCtl::eHyprCtlOutputFormat format) {
+    std::string curitem = "";
+
+    auto nextItem = [&]() {
+        auto idx = request.find_first_of(' ');
+
+        if (idx != std::string::npos) {
+            curitem = request.substr(0, idx);
+            request = request.substr(idx + 1);
+        } else {
+            curitem = request;
+            request = "";
+        }
+
+        curitem = removeBeginEndSpacesTabs(curitem);
+    };
+
+    nextItem();
+    nextItem();
+
+    const auto PCFGOPT = g_pConfigManager->getConfigValuePtrSafe(curitem);
+
+    if (!PCFGOPT)
+        return "no such option";
+
+    if (format == HyprCtl::eHyprCtlOutputFormat::FORMAT_NORMAL)
+        return getFormat("option %s\n\tint: %i\n\tfloat: %f\n\tstr: \"%s\"", curitem.c_str(), PCFGOPT->intValue, PCFGOPT->floatValue, PCFGOPT->strValue.c_str());
+    else {
+        return getFormat(
+R"#(
+{
+    "option": "%s",
+    "int": %i,
+    "float": %f,
+    "str": "%s"
+}
+)#", curitem.c_str(), PCFGOPT->intValue, PCFGOPT->floatValue, PCFGOPT->strValue.c_str()
+        );
+    }
+}
+
 std::string getReply(std::string request) {
+    auto format = HyprCtl::FORMAT_NORMAL;
+
+    // process flags for non-batch requests
+    if (!request.contains("[[BATCH]]") && request.contains("/")) {
+        long unsigned int sepIndex = 0;
+        for (const auto& c : request) {
+            if (c == '/') { // stop at separator
+                break;
+            }
+
+            sepIndex++;
+            
+            if (c == 'j')
+                format = HyprCtl::FORMAT_JSON;
+        }
+
+        if (sepIndex < request.size())
+            request = request.substr(sepIndex + 1); // remove flags and separator so we can compare the rest of the string
+    }
+
     if (request == "monitors")
-        return monitorsRequest();
+        return monitorsRequest(format);
     else if (request == "workspaces")
-        return workspacesRequest();
+        return workspacesRequest(format);
     else if (request == "clients")
-        return clientsRequest();
+        return clientsRequest(format);
     else if (request == "kill")
         return killRequest();
     else if (request == "activewindow")
-        return activeWindowRequest();
+        return activeWindowRequest(format);
     else if (request == "layers")
-        return layersRequest();
+        return layersRequest(format);
     else if (request == "version")
-        return versionRequest();
-    else if (request == "reload")
-        return reloadRequest();
+        return versionRequest(format);
+    else if (request.find("reload") == 0)
+        return reloadRequest(request);
     else if (request == "devices")
-        return devicesRequest();
+        return devicesRequest(format);
+    else if (request == "splash")
+        return splashRequest();
     else if (request.find("dispatch") == 0)
         return dispatchRequest(request);
     else if (request.find("keyword") == 0)
         return dispatchKeyword(request);
+    else if (request.find("setcursor") == 0)
+        return dispatchSetCursor(request);
+    else if (request.find("getoption") == 0)
+        return dispatchGetOption(request, format);
     else if (request.find("[[BATCH]]") == 0)
         return dispatchBatch(request);
 
@@ -261,17 +729,14 @@ void HyprCtl::tickHyprCtl() {
 
     requestMade = false;
     requestReady = true;
+
+    if (g_pConfigManager->m_bWantsMonitorReload) {
+        g_pConfigManager->ensureDPMS();
+    }
 }
 
 std::string getRequestFromThread(std::string rq) {
-    // we need to do something to wake hyprland up if VFR is enabled
-    static auto *const VFRENABLED = &g_pConfigManager->getConfigValuePtr("experimental:vfr")->intValue;
-    if (*VFRENABLED) {
-        // TODO: is this safe...?
-        // this might be a race condition
-        wlr_output_schedule_frame(g_pCompositor->m_vMonitors.front()->output);
-    }
-
+    
     while (HyprCtl::request != "" || HyprCtl::requestMade || HyprCtl::requestReady) {
         std::this_thread::sleep_for(std::chrono::milliseconds(5));
     }
@@ -342,4 +807,4 @@ void HyprCtl::startHyprCtlSocket() {
 
         close(SOCKET);
     }).detach();
-}
+}

src/debug/HyprCtl.hpp

@@ -14,4 +14,9 @@ namespace HyprCtl {
     inline  std::string request = "";
 
     inline std::ifstream requestStream;
+
+    enum eHyprCtlOutputFormat {
+        FORMAT_NORMAL = 0,
+        FORMAT_JSON
+    };
 };

src/debug/HyprDebugOverlay.cpp

@@ -1,7 +1,7 @@
 #include "HyprDebugOverlay.hpp"
 #include "../Compositor.hpp"
 
-void CHyprMonitorDebugOverlay::renderData(SMonitor* pMonitor, float µs) {
+void CHyprMonitorDebugOverlay::renderData(CMonitor* pMonitor, float µs) {
     m_dLastRenderTimes.push_back(µs / 1000.f);
 
     if (m_dLastRenderTimes.size() > (long unsigned int)pMonitor->refreshRate)
@@ -11,7 +11,7 @@ void CHyprMonitorDebugOverlay::renderData(SMonitor* pMonitor, float µs) {
         m_pMonitor = pMonitor;
 }
 
-void CHyprMonitorDebugOverlay::renderDataNoOverlay(SMonitor* pMonitor, float µs) {
+void CHyprMonitorDebugOverlay::renderDataNoOverlay(CMonitor* pMonitor, float µs) {
     m_dLastRenderTimesNoOverlay.push_back(µs / 1000.f);
 
     if (m_dLastRenderTimesNoOverlay.size() > (long unsigned int)pMonitor->refreshRate)
@@ -21,7 +21,7 @@ void CHyprMonitorDebugOverlay::renderDataNoOverlay(SMonitor* pMonitor, float µs
         m_pMonitor = pMonitor;
 }
 
-void CHyprMonitorDebugOverlay::frameData(SMonitor* pMonitor) {
+void CHyprMonitorDebugOverlay::frameData(CMonitor* pMonitor) {
     m_dLastFrametimes.push_back(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - m_tpLastFrame).count() / 1000.f);
 
     if (m_dLastFrametimes.size() > (long unsigned int)pMonitor->refreshRate)
@@ -126,15 +126,15 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
     return yOffset - offset;
 }
 
-void CHyprDebugOverlay::renderData(SMonitor* pMonitor, float µs) {
+void CHyprDebugOverlay::renderData(CMonitor* pMonitor, float µs) {
     m_mMonitorOverlays[pMonitor].renderData(pMonitor, µs);
 }
 
-void CHyprDebugOverlay::renderDataNoOverlay(SMonitor* pMonitor, float µs) {
+void CHyprDebugOverlay::renderDataNoOverlay(CMonitor* pMonitor, float µs) {
     m_mMonitorOverlays[pMonitor].renderDataNoOverlay(pMonitor, µs);
 }
 
-void CHyprDebugOverlay::frameData(SMonitor* pMonitor) {
+void CHyprDebugOverlay::frameData(CMonitor* pMonitor) {
     m_mMonitorOverlays[pMonitor].frameData(pMonitor);
 }
 

src/debug/HyprDebugOverlay.hpp

@@ -11,16 +11,16 @@ class CHyprMonitorDebugOverlay {
 public:
     int draw(int offset);
 
-    void renderData(SMonitor* pMonitor, float µs);
-    void renderDataNoOverlay(SMonitor* pMonitor, float µs);
-    void frameData(SMonitor* pMonitor);
+    void renderData(CMonitor* pMonitor, float µs);
+    void renderDataNoOverlay(CMonitor* pMonitor, float µs);
+    void frameData(CMonitor* pMonitor);
 
 private:
     std::deque<float> m_dLastFrametimes;
     std::deque<float> m_dLastRenderTimes;
     std::deque<float> m_dLastRenderTimesNoOverlay;
     std::chrono::high_resolution_clock::time_point m_tpLastFrame;
-    SMonitor* m_pMonitor = nullptr;
+    CMonitor* m_pMonitor = nullptr;
     wlr_box m_wbLastDrawnBox;
 };
 
@@ -28,13 +28,13 @@ class CHyprDebugOverlay {
 public:
 
     void draw();
-    void renderData(SMonitor*, float µs);
-    void renderDataNoOverlay(SMonitor*, float µs);
-    void frameData(SMonitor*);
+    void renderData(CMonitor*, float µs);
+    void renderDataNoOverlay(CMonitor*, float µs);
+    void frameData(CMonitor*);
 
 private:
 
-    std::unordered_map<SMonitor*, CHyprMonitorDebugOverlay> m_mMonitorOverlays;
+    std::unordered_map<CMonitor*, CHyprMonitorDebugOverlay> m_mMonitorOverlays;
 
     cairo_surface_t* m_pCairoSurface = nullptr;
     cairo_t* m_pCairo = nullptr;

src/debug/Log.cpp

@@ -41,37 +41,37 @@ void Debug::log(LogLevel level, const char* fmt, ...) {
             break;
     }
 
-    char buf[LOGMESSAGESIZE] = "";
-    char* outputStr;
-    int logLen;
+    // print date and time to the ofs
+    if (disableTime && !*disableTime) {
+        auto timet = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
+        const auto MILLIS = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() % 1000;
+        
+        ofs << std::put_time(std::localtime(&timet), "[%H:%M:%S:");
+
+        if (MILLIS > 99)
+            ofs << MILLIS;
+        else if (MILLIS > 9)
+            ofs << "0" << MILLIS;
+        else
+            ofs << "00" << MILLIS;
+
+        ofs << "] ";
+    }
+
+    char* outputStr = nullptr;
 
     va_list args;
     va_start(args, fmt);
-    logLen = vsnprintf(buf, sizeof buf, fmt, args);
+    vasprintf(&outputStr, fmt, args);
     va_end(args);
 
-    if ((long unsigned int)logLen < sizeof buf) {
-        outputStr = strdup(buf);
-    } else {
-        outputStr = (char*)malloc(logLen + 1);
+    std::string output = std::string(outputStr);
+    free(outputStr);
 
-        if (!outputStr) {
-            printf("CRITICAL: Cannot alloc size %d for log! (Out of memory?)", logLen + 1);
-            return;
-        }
-
-        va_start(args, fmt);
-        vsnprintf(outputStr, logLen + 1U, fmt, args);
-        va_end(args);
-    }
-
-    ofs << outputStr << "\n";
+    ofs << output << "\n";
 
     ofs.close();
 
     // log it to the stdout too.
-    std::cout << outputStr << "\n";
-
-    // free the log
-    free(outputStr);
+    std::cout << output << "\n";
 }

src/debug/Log.hpp

@@ -18,4 +18,5 @@ namespace Debug {
 
     inline std::string logFile;
     inline int64_t* disableLogs = nullptr;
+    inline int64_t* disableTime = nullptr;
 };

src/defines.hpp

@@ -16,8 +16,6 @@
 #define ISDEBUG false
 #endif
 
-#define RIP(format, ... ) { fprintf(stderr, format "\n", ##__VA_ARGS__); exit(EXIT_FAILURE); }
-
 #define LISTENER(name) void listener_##name(wl_listener*, void*); inline wl_listener listen_##name = { .notify = listener_##name };
 #define DYNLISTENFUNC(name) void listener_##name(void*, void*);
 #define DYNLISTENER(name) CHyprWLListener hyprListener_##name;
@@ -56,6 +54,12 @@
 
 #define ASSERT(expr) RASSERT(expr, "?")
 
+#if ISDEBUG
+#define UNREACHABLE() { Debug::log(CRIT, "\n\nMEMORY CORRUPTED: Unreachable failed! (Reached an unreachable position, memory corruption!!!)"); *((int*)nullptr) = 1; }
+#else
+#define UNREACHABLE() std::unreachable();
+#endif
+
 // git stuff
 #ifndef GIT_COMMIT_HASH
 #define GIT_COMMIT_HASH "?"

src/events/Devices.cpp

@@ -49,9 +49,7 @@ void Events::listener_mouseButton(wl_listener* listener, void* data) {
 }
 
 void Events::listener_mouseAxis(wl_listener* listener, void* data) {
-    const auto E = (wlr_pointer_axis_event*)data;
-
-    wlr_seat_pointer_notify_axis(g_pCompositor->m_sSeat.seat, E->time_msec, E->orientation, E->delta, E->delta_discrete, E->source);
+    g_pInputManager->onMouseWheel((wlr_pointer_axis_event*)data);
 }
 
 void Events::listener_requestMouse(wl_listener* listener, void* data) {
@@ -74,7 +72,6 @@ void Events::listener_newInput(wl_listener* listener, void* data) {
             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:
@@ -151,11 +148,62 @@ void Events::listener_newVirtPtr(wl_listener* listener, void* data) {
     const auto POINTER = EV->new_pointer;
     const auto DEVICE = &POINTER->pointer.base;
 
-    g_pInputManager->newMouse(DEVICE);
+    g_pInputManager->newMouse(DEVICE, true);
 }
 
 void Events::listener_destroyMouse(void* owner, void* data) {
     const auto PMOUSE = (SMouse*)owner;
 
     g_pInputManager->destroyMouse(PMOUSE->mouse);
+}
+
+void Events::listener_swipeBegin(wl_listener* listener, void* data) {
+    const auto EVENT = (wlr_pointer_swipe_begin_event*)data;
+
+    g_pInputManager->onSwipeBegin(EVENT);
+}
+
+void Events::listener_swipeUpdate(wl_listener* listener, void* data) {
+    const auto EVENT = (wlr_pointer_swipe_update_event*)data;
+
+    g_pInputManager->onSwipeUpdate(EVENT);
+}
+
+void Events::listener_swipeEnd(wl_listener* listener, void* data) {
+    const auto EVENT = (wlr_pointer_swipe_end_event*)data;
+
+    g_pInputManager->onSwipeEnd(EVENT);
+}
+
+void Events::listener_pinchBegin(wl_listener* listener, void* data) {
+    const auto EV = (wlr_pointer_pinch_begin_event*)data;
+    wlr_pointer_gestures_v1_send_pinch_begin(g_pCompositor->m_sWLRPointerGestures, g_pCompositor->m_sSeat.seat, EV->time_msec, EV->fingers);
+}
+
+void Events::listener_pinchUpdate(wl_listener* listener, void* data) {
+    const auto EV = (wlr_pointer_pinch_update_event*)data;
+    wlr_pointer_gestures_v1_send_pinch_update(g_pCompositor->m_sWLRPointerGestures, g_pCompositor->m_sSeat.seat, EV->time_msec, EV->dx, EV->dy, EV->scale, EV->rotation);
+}
+
+void Events::listener_pinchEnd(wl_listener* listener, void* data) {
+    const auto EV = (wlr_pointer_pinch_end_event*)data;
+    wlr_pointer_gestures_v1_send_pinch_end(g_pCompositor->m_sWLRPointerGestures, g_pCompositor->m_sSeat.seat, EV->time_msec, EV->cancelled);
+}
+
+void Events::listener_newVirtualKeyboard(wl_listener* listener, void* data) {
+    const auto WLRKB = (wlr_virtual_keyboard_v1*)data;
+
+    g_pInputManager->newVirtualKeyboard(&WLRKB->keyboard.base);
+}
+
+void Events::listener_touchBegin(wl_listener* listener, void* data) {
+    g_pInputManager->onTouchDown((wlr_touch_down_event*)data);
+}
+
+void Events::listener_touchEnd(wl_listener* listener, void* data) {
+    g_pInputManager->onTouchUp((wlr_touch_up_event*)data);
+}
+
+void Events::listener_touchUpdate(wl_listener* listener, void* data) {
+    g_pInputManager->onTouchMove((wlr_touch_motion_event*)data);
 }

src/events/Events.hpp

@@ -49,6 +49,11 @@ namespace Events {
     DYNLISTENFUNC(fullscreenWindow);
     DYNLISTENFUNC(activateX11);
     DYNLISTENFUNC(configureX11);
+    DYNLISTENFUNC(unmanagedSetGeometry);
+    DYNLISTENFUNC(requestMove);
+    DYNLISTENFUNC(requestResize);
+    DYNLISTENFUNC(requestMinimize);
+    DYNLISTENFUNC(requestMaximize);
 
     // Window subsurfaces
    // LISTENER(newSubsurfaceWindow);
@@ -112,4 +117,36 @@ namespace Events {
 
     // Renderer destroy
     LISTENER(RendererDestroy);
+
+    LISTENER(newIdleInhibitor);
+
+    // session
+    LISTENER(sessionActive);
+
+    // Touchpad shit
+    LISTENER(swipeBegin);
+    LISTENER(swipeEnd);
+    LISTENER(swipeUpdate);
+    LISTENER(pinchBegin);
+    LISTENER(pinchUpdate);
+    LISTENER(pinchEnd);
+
+    // Power
+    LISTENER(powerMgrSetMode);
+
+    // IME
+    LISTENER(newIME);
+    LISTENER(newTextInput);
+    LISTENER(newVirtualKeyboard);
+
+    // IME Popups
+    DYNLISTENFUNC(mapInputPopup);
+    DYNLISTENFUNC(unmapInputPopup);
+    DYNLISTENFUNC(commitInputPopup);
+    DYNLISTENFUNC(destroyInputPopup);
+
+    // Touch
+    LISTENER(touchBegin);
+    LISTENER(touchEnd);
+    LISTENER(touchUpdate);
 };

src/events/Layers.cpp

@@ -31,16 +31,17 @@ void Events::listener_newLayerSurface(wl_listener* listener, void* data) {
         WLRLAYERSURFACE->output = PMONITOR->output;
     }
 
-    const auto PMONITOR = (SMonitor*)g_pCompositor->getMonitorFromOutput(WLRLAYERSURFACE->output);
-    PMONITOR->m_aLayerSurfaceLists[WLRLAYERSURFACE->pending.layer].push_back(new SLayerSurface());
-    SLayerSurface* layerSurface = PMONITOR->m_aLayerSurfaceLists[WLRLAYERSURFACE->pending.layer].back();
+    const auto PMONITOR = (CMonitor*)g_pCompositor->getMonitorFromOutput(WLRLAYERSURFACE->output);
+    SLayerSurface* layerSurface = PMONITOR->m_aLayerSurfaceLists[WLRLAYERSURFACE->pending.layer].emplace_back(std::make_unique<SLayerSurface>()).get();
+
+    layerSurface->szNamespace = WLRLAYERSURFACE->_namespace;
 
     if (!WLRLAYERSURFACE->output) {
         WLRLAYERSURFACE->output = g_pCompositor->m_vMonitors.front()->output;  // TODO: current mon
     }
 
     layerSurface->hyprListener_commitLayerSurface.initCallback(&WLRLAYERSURFACE->surface->events.commit, &Events::listener_commitLayerSurface, layerSurface, "layerSurface");
-    layerSurface->hyprListener_destroyLayerSurface.initCallback(&WLRLAYERSURFACE->surface->events.destroy, &Events::listener_destroyLayerSurface, layerSurface, "layerSurface");
+    layerSurface->hyprListener_destroyLayerSurface.initCallback(&WLRLAYERSURFACE->events.destroy, &Events::listener_destroyLayerSurface, layerSurface, "layerSurface");
     layerSurface->hyprListener_mapLayerSurface.initCallback(&WLRLAYERSURFACE->events.map, &Events::listener_mapLayerSurface, layerSurface, "layerSurface");
     layerSurface->hyprListener_unmapLayerSurface.initCallback(&WLRLAYERSURFACE->events.unmap, &Events::listener_unmapLayerSurface, layerSurface, "layerSurface");
     layerSurface->hyprListener_newPopup.initCallback(&WLRLAYERSURFACE->events.new_popup, &Events::listener_newPopup, layerSurface, "layerSurface");
@@ -50,6 +51,8 @@ void Events::listener_newLayerSurface(wl_listener* listener, void* data) {
     WLRLAYERSURFACE->data = layerSurface;
     layerSurface->monitorID = PMONITOR->ID;
 
+    layerSurface->forceBlur = g_pConfigManager->shouldBlurLS(layerSurface->szNamespace);
+
     Debug::log(LOG, "LayerSurface %x (namespace %s layer %d) created on monitor %s", layerSurface->layerSurface, layerSurface->layerSurface->_namespace, layerSurface->layer, PMONITOR->szName.c_str());
 }
 
@@ -63,12 +66,20 @@ void Events::listener_destroyLayerSurface(void* owner, void* data) {
     if (!g_pCompositor->getMonitorFromID(layersurface->monitorID))
         Debug::log(WARN, "Layersurface destroyed on an invalid monitor (removed?)");
 
-    if (!layersurface->fadingOut && PMONITOR) {
-        Debug::log(LOG, "Removing LayerSurface that wasn't mapped.");
-        layersurface->alpha.setValueAndWarp(0.f);
-        layersurface->fadingOut = true;
+    if (!layersurface->fadingOut) {
+        if (layersurface->mapped) {
+            Debug::log(LOG, "Forcing an unmap of a LS that did a straight destroy!");
+            listener_unmapLayerSurface(layersurface, nullptr);
+        } else {
+            Debug::log(LOG, "Removing LayerSurface that wasn't mapped.");
+            layersurface->alpha.setValueAndWarp(0.f);
+            layersurface->fadingOut = true;
+            g_pCompositor->addToFadingOutSafe(layersurface);
+        }
     }
 
+    layersurface->noProcess = true;
+
     layersurface->hyprListener_commitLayerSurface.removeCallback();
     layersurface->hyprListener_destroyLayerSurface.removeCallback();
     layersurface->hyprListener_mapLayerSurface.removeCallback();
@@ -78,7 +89,7 @@ void Events::listener_destroyLayerSurface(void* owner, void* data) {
     // rearrange to fix the reserved areas
     if (PMONITOR) {
         g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMONITOR->ID);
+        PMONITOR->scheduledRecalc = true;
 
         // and damage
         wlr_box geomFixed = {layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y, layersurface->geometry.width, layersurface->geometry.height};
@@ -95,8 +106,10 @@ void Events::listener_mapLayerSurface(void* owner, void* data) {
     Debug::log(LOG, "LayerSurface %x mapped", layersurface->layerSurface);
 
     layersurface->layerSurface->mapped = true;
+    layersurface->mapped = true;
 
-    wlr_surface_send_enter(layersurface->layerSurface->surface, layersurface->layerSurface->output);
+    // anim
+    layersurface->alpha.setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeIn"));
 
     // fix if it changed its mon
     const auto PMONITOR = g_pCompositor->getMonitorFromOutput(layersurface->layerSurface->output);
@@ -106,18 +119,29 @@ void Events::listener_mapLayerSurface(void* owner, void* data) {
 
     if ((uint64_t)layersurface->monitorID != PMONITOR->ID) {
         const auto POLDMON = g_pCompositor->getMonitorFromID(layersurface->monitorID);
-        POLDMON->m_aLayerSurfaceLists[layersurface->layer].remove(layersurface);
-        PMONITOR->m_aLayerSurfaceLists[layersurface->layer].push_back(layersurface);
+        for (auto it = POLDMON->m_aLayerSurfaceLists[layersurface->layer].begin(); it != POLDMON->m_aLayerSurfaceLists[layersurface->layer].end(); it++) {
+            if (it->get() == layersurface) {
+                PMONITOR->m_aLayerSurfaceLists[layersurface->layer].emplace_back(std::move(*it));
+                POLDMON->m_aLayerSurfaceLists[layersurface->layer].erase(it);
+                break;
+            }
+        }
         layersurface->monitorID = PMONITOR->ID;
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(POLDMON->ID);
+        PMONITOR->scheduledRecalc = true;
         g_pHyprRenderer->arrangeLayersForMonitor(POLDMON->ID);
     }
 
     g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
 
-    if (layersurface->layerSurface->current.keyboard_interactive)
+    if (layersurface->layerSurface->current.keyboard_interactive && (!g_pCompositor->m_sSeat.mouse || !g_pCompositor->m_sSeat.mouse->currentConstraint)) { // don't focus if constrained
+        wlr_surface_send_enter(layersurface->layerSurface->surface, layersurface->layerSurface->output);
         g_pCompositor->focusSurface(layersurface->layerSurface->surface);
 
+        const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y);
+        wlr_seat_pointer_notify_enter(g_pCompositor->m_sSeat.seat, layersurface->layerSurface->surface, LOCAL.x, LOCAL.y);
+        wlr_seat_pointer_notify_motion(g_pCompositor->m_sSeat.seat, 0, LOCAL.x, LOCAL.y);
+    }
+
     layersurface->position = Vector2D(layersurface->geometry.x, layersurface->geometry.y);
 
     wlr_box geomFixed = {layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y, layersurface->geometry.width, layersurface->geometry.height};
@@ -136,28 +160,44 @@ void Events::listener_unmapLayerSurface(void* owner, void* data) {
 
     if (!g_pCompositor->getMonitorFromID(layersurface->monitorID)) {
         Debug::log(WARN, "Layersurface unmapping on invalid monitor (removed?) ignoring.");
+
+        g_pCompositor->addToFadingOutSafe(layersurface);
+
+        layersurface->mapped = false;
+
+        layersurface->fadingOut = true;
+
+        layersurface->alpha.setValueAndWarp(0.f);
         return;
     }
 
+    // anim
+    layersurface->alpha.setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeOut"));
+
     // make a snapshot and start fade
     g_pHyprOpenGL->makeLayerSnapshot(layersurface);
     layersurface->alpha = 0.f;
 
+    layersurface->mapped = false;
+
     layersurface->fadingOut = true;
 
-    g_pCompositor->m_vSurfacesFadingOut.push_back(layersurface);
+    g_pCompositor->addToFadingOutSafe(layersurface);
 
     if (layersurface->layerSurface->mapped)
         layersurface->layerSurface->mapped = false;
 
-    if (layersurface->layerSurface->surface == g_pCompositor->m_pLastFocus)
-        g_pCompositor->m_pLastFocus = nullptr;
-
     const auto PMONITOR = g_pCompositor->getMonitorFromOutput(layersurface->layerSurface->output);
 
     if (!PMONITOR)
         return;
 
+    // refocus if needed
+    if (layersurface->layerSurface->surface == g_pCompositor->m_pLastFocus) {
+        g_pCompositor->m_pLastFocus = nullptr;
+        g_pInputManager->refocus();
+    }
+
     wlr_box geomFixed = {layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y, layersurface->geometry.width, layersurface->geometry.height};
     g_pHyprRenderer->damageBox(&geomFixed);
 
@@ -179,32 +219,55 @@ void Events::listener_commitLayerSurface(void* owner, void* data) {
     if (!PMONITOR)
         return;
 
+    if (layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND || layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM)
+        g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR);  // so that blur is recalc'd
+
     wlr_box geomFixed = {layersurface->geometry.x, layersurface->geometry.y, layersurface->geometry.width, layersurface->geometry.height};
     g_pHyprRenderer->damageBox(&geomFixed);
 
     // fix if it changed its mon
     if ((uint64_t)layersurface->monitorID != PMONITOR->ID) {
         const auto POLDMON = g_pCompositor->getMonitorFromID(layersurface->monitorID);
-        POLDMON->m_aLayerSurfaceLists[layersurface->layer].remove(layersurface);
-        PMONITOR->m_aLayerSurfaceLists[layersurface->layer].push_back(layersurface);
+
+        for (auto it = POLDMON->m_aLayerSurfaceLists[layersurface->layer].begin(); it != POLDMON->m_aLayerSurfaceLists[layersurface->layer].end(); it++) {
+            if (it->get() == layersurface) {
+                PMONITOR->m_aLayerSurfaceLists[layersurface->layer].emplace_back(std::move(*it));
+                POLDMON->m_aLayerSurfaceLists[layersurface->layer].erase(it);
+                break;
+            }
+        }
+
         layersurface->monitorID = PMONITOR->ID;
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(POLDMON->ID);
+        PMONITOR->scheduledRecalc = true;
         g_pHyprRenderer->arrangeLayersForMonitor(POLDMON->ID);
     }
 
     if (layersurface->layerSurface->current.committed != 0) {
-        g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
-
         if (layersurface->layer != layersurface->layerSurface->current.layer) {
-            PMONITOR->m_aLayerSurfaceLists[layersurface->layer].remove(layersurface);
-            PMONITOR->m_aLayerSurfaceLists[layersurface->layerSurface->current.layer].push_back(layersurface);
+            
+            for (auto it = PMONITOR->m_aLayerSurfaceLists[layersurface->layer].begin(); it != PMONITOR->m_aLayerSurfaceLists[layersurface->layer].end(); it++) {
+                if (it->get() == layersurface) {
+                    PMONITOR->m_aLayerSurfaceLists[layersurface->layerSurface->current.layer].emplace_back(std::move(*it));
+                    PMONITOR->m_aLayerSurfaceLists[layersurface->layer].erase(it);
+                    break;
+                }
+            }
+
             layersurface->layer = layersurface->layerSurface->current.layer;
+
+            if (layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND || layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM)
+                g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR);  // so that blur is recalc'd
         }
 
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMONITOR->ID);
+        g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
+
+        PMONITOR->scheduledRecalc = true;
     }
 
     layersurface->position = Vector2D(layersurface->geometry.x, layersurface->geometry.y);
 
+    // update geom if it changed
+    layersurface->geometry = {layersurface->geometry.x, layersurface->geometry.y, layersurface->layerSurface->surface->current.width, layersurface->layerSurface->surface->current.height};
+
     g_pHyprRenderer->damageSurface(layersurface->layerSurface->surface, layersurface->position.x, layersurface->position.y);
 }

src/events/Misc.cpp

@@ -103,6 +103,13 @@ void Events::listener_startDrag(wl_listener* listener, void* data) {
         g_pInputManager->m_sDrag.hyprListener_destroyIcon.initCallback(&wlrDrag->icon->events.destroy, &Events::listener_destroyDragIcon, &g_pInputManager->m_sDrag, "DragIcon");
         g_pInputManager->m_sDrag.hyprListener_commitIcon.initCallback(&wlrDrag->icon->surface->events.commit, &Events::listener_commitDragIcon, &g_pInputManager->m_sDrag, "DragIcon");
     }
+
+    static auto *const PFOLLOWONDND = &g_pConfigManager->getConfigValuePtr("misc:always_follow_on_dnd")->intValue;
+
+    if (*PFOLLOWONDND)
+        g_pInputManager->m_pFollowOnDnDBegin = g_pCompositor->m_pLastWindow;
+    else
+        g_pInputManager->m_pFollowOnDnDBegin = nullptr;
 }
 
 void Events::listener_destroyDrag(void* owner, void* data) {
@@ -113,6 +120,11 @@ void Events::listener_destroyDrag(void* owner, void* data) {
     g_pInputManager->m_sDrag.hyprListener_destroy.removeCallback();
 
     g_pInputManager->refocus();
+
+    if (g_pInputManager->m_pFollowOnDnDBegin)
+        g_pCompositor->focusWindow(g_pInputManager->m_pFollowOnDnDBegin);
+
+    g_pInputManager->m_pFollowOnDnDBegin = nullptr;
 }
 
 void Events::listener_mapDragIcon(void* owner, void* data) {
@@ -157,4 +169,33 @@ void Events::listener_InhibitDeactivate(wl_listener* listener, void* data) {
 
 void Events::listener_RendererDestroy(wl_listener* listener, void* data) {
     Debug::log(LOG, "!!Renderer destroyed!!");
+}
+
+void Events::listener_sessionActive(wl_listener* listener, void* data) {
+    Debug::log(LOG, "Session got activated!");
+
+    g_pCompositor->m_bSessionActive = true;
+}
+
+void Events::listener_powerMgrSetMode(wl_listener* listener, void* data) {
+    Debug::log(LOG, "PowerMgr set mode!");
+
+    const auto EVENT = (wlr_output_power_v1_set_mode_event*)data;
+
+    wlr_output_enable(EVENT->output, EVENT->mode == 1);
+    
+    if (!wlr_output_commit(EVENT->output))
+        Debug::log(ERR, "Couldn't set power mode");
+}
+
+void Events::listener_newIME(wl_listener* listener, void* data) {
+    Debug::log(LOG, "New IME added!");
+
+    g_pInputManager->m_sIMERelay.onNewIME((wlr_input_method_v2*)data);
+}
+
+void Events::listener_newTextInput(wl_listener* listener, void* data) {
+    Debug::log(LOG, "New TextInput added!");
+
+    g_pInputManager->m_sIMERelay.onNewTextInput((wlr_text_input_v3*)data);
 }

src/events/Monitors.cpp

@@ -15,7 +15,7 @@
 //                                                           //
 // --------------------------------------------------------- //
 
-SMonitor* pMostHzMonitor = nullptr;
+CMonitor* pMostHzMonitor = nullptr;
 
 void Events::listener_change(wl_listener* listener, void* data) {
     // layout got changed, let's update monitors.
@@ -53,118 +53,55 @@ void Events::listener_newOutput(wl_listener* listener, void* data) {
         return;
     }
 
-    if (g_pCompositor->getMonitorFromName(std::string(OUTPUT->name))) {
-        Debug::log(WARN, "Monitor with name %s already exists, not adding as new!", OUTPUT->name);
-        return;
+    if (g_pCompositor->m_bUnsafeState) {
+        Debug::log(WARN, "Recovering from an unsafe state. May you be lucky.");
     }
 
-    // get monitor rule that matches
-    SMonitorRule monitorRule = g_pConfigManager->getMonitorRuleFor(OUTPUT->name);
+    // add it to real
+    std::shared_ptr<CMonitor>* PNEWMONITORWRAP = nullptr;
 
-    // if it's disabled, disable and ignore
-    if (monitorRule.disabled) {
-        wlr_output_enable(OUTPUT, 0);
-        wlr_output_commit(OUTPUT);
-
-        if (const auto PMONITOR = g_pCompositor->getMonitorFromName(std::string(OUTPUT->name)); PMONITOR) {
-            listener_monitorDestroy(nullptr, PMONITOR->output);
+    for (auto& rm : g_pCompositor->m_vRealMonitors) {
+        if (rm->szName == OUTPUT->name) {
+            PNEWMONITORWRAP = &rm;
+            Debug::log(LOG, "Recovering a removed monitor.");
+            break;
         }
-        return;
     }
 
-    SMonitor newMonitor;
-    newMonitor.output = OUTPUT;
-    newMonitor.ID = g_pCompositor->getNextAvailableMonitorID();
-    newMonitor.szName = OUTPUT->name;
+    if (!PNEWMONITORWRAP) {
+        Debug::log(LOG, "Adding completely new monitor.");
+        PNEWMONITORWRAP = &g_pCompositor->m_vRealMonitors.emplace_back(std::make_shared<CMonitor>());
 
-    wlr_output_init_render(OUTPUT, g_pCompositor->m_sWLRAllocator, g_pCompositor->m_sWLRRenderer);
-
-    wlr_output_set_scale(OUTPUT, monitorRule.scale);
-    wlr_xcursor_manager_load(g_pCompositor->m_sWLRXCursorMgr, monitorRule.scale);
-    wlr_output_set_transform(OUTPUT, WL_OUTPUT_TRANSFORM_NORMAL);  // TODO: support other transforms
-
-    wlr_output_enable_adaptive_sync(OUTPUT, 1);
-
-    // create it in the arr
-    newMonitor.vecPosition = monitorRule.offset;
-    newMonitor.vecSize = monitorRule.resolution;
-    newMonitor.refreshRate = monitorRule.refreshRate;
-
-    const auto PNEWMONITOR = g_pCompositor->m_vMonitors.emplace_back(std::make_unique<SMonitor>(newMonitor)).get();
-
-    PNEWMONITOR->hyprListener_monitorFrame.initCallback(&OUTPUT->events.frame, &Events::listener_monitorFrame, PNEWMONITOR);
-    PNEWMONITOR->hyprListener_monitorDestroy.initCallback(&OUTPUT->events.destroy, &Events::listener_monitorDestroy, PNEWMONITOR);
-
-    wlr_output_enable(OUTPUT, 1);
-
-    // TODO: this doesn't seem to set the X and Y correctly,
-    // wlr_output_layout_output_coords returns invalid values, I think...
-    wlr_output_layout_add(g_pCompositor->m_sWLROutputLayout, OUTPUT, monitorRule.offset.x, monitorRule.offset.y);
-
-    // set mode, also applies
-    g_pHyprRenderer->applyMonitorRule(PNEWMONITOR, &monitorRule, true);
-
-    Debug::log(LOG, "Added new monitor with name %s at %i,%i with size %ix%i, pointer %x", OUTPUT->name, (int)monitorRule.offset.x, (int)monitorRule.offset.y, (int)monitorRule.resolution.x, (int)monitorRule.resolution.y, OUTPUT);
-
-    PNEWMONITOR->damage = wlr_output_damage_create(PNEWMONITOR->output);
-
-    // add a WLR workspace group
-    PNEWMONITOR->pWLRWorkspaceGroupHandle = wlr_ext_workspace_group_handle_v1_create(g_pCompositor->m_sWLREXTWorkspaceMgr);
-    wlr_ext_workspace_group_handle_v1_output_enter(PNEWMONITOR->pWLRWorkspaceGroupHandle, PNEWMONITOR->output);
-
-    // Workspace
-    std::string newDefaultWorkspaceName = "";
-    auto WORKSPACEID = monitorRule.defaultWorkspace == "" ? g_pCompositor->m_vWorkspaces.size() + 1 : getWorkspaceIDFromString(monitorRule.defaultWorkspace, newDefaultWorkspaceName);
-    
-    if (WORKSPACEID == INT_MAX || WORKSPACEID == (long unsigned int)SPECIAL_WORKSPACE_ID) {
-        WORKSPACEID = g_pCompositor->m_vWorkspaces.size() + 1;
-        newDefaultWorkspaceName = std::to_string(WORKSPACEID);
-
-        Debug::log(LOG, "Invalid workspace= directive name in monitor parsing, workspace name \"%s\" is invalid.", monitorRule.defaultWorkspace);
+        (*PNEWMONITORWRAP)->ID = g_pCompositor->getNextAvailableMonitorID();
     }
 
-    auto PNEWWORKSPACE = g_pCompositor->getWorkspaceByID(WORKSPACEID);
+    const auto PNEWMONITOR = PNEWMONITORWRAP->get();
 
-    Debug::log(LOG, "New monitor: WORKSPACEID %d, exists: %d", WORKSPACEID, (int)(PNEWWORKSPACE != nullptr));
+    PNEWMONITOR->output = OUTPUT;
+    PNEWMONITOR->m_pThisWrap = PNEWMONITORWRAP;
 
-    if (PNEWWORKSPACE) {
-        // workspace exists, move it to the newly connected monitor
-        g_pCompositor->moveWorkspaceToMonitor(PNEWWORKSPACE, PNEWMONITOR);
-        PNEWMONITOR->activeWorkspace = PNEWWORKSPACE->m_iID;
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PNEWMONITOR->ID);
-        PNEWWORKSPACE->startAnim(true,true,true);
-    } else {
-        PNEWWORKSPACE = g_pCompositor->m_vWorkspaces.emplace_back(std::make_unique<CWorkspace>(newMonitor.ID, newDefaultWorkspaceName)).get();
+    PNEWMONITOR->onConnect(false);
 
-        // We are required to set the name here immediately
-        wlr_ext_workspace_handle_v1_set_name(PNEWWORKSPACE->m_pWlrHandle, newDefaultWorkspaceName.c_str());
-
-        PNEWWORKSPACE->m_iID = WORKSPACEID;
-    }
-
-    PNEWMONITOR->activeWorkspace = PNEWWORKSPACE->m_iID;
-    PNEWMONITOR->scale = monitorRule.scale;
-
-    PNEWMONITOR->forceFullFrames = 3; // force 3 full frames to make sure there is no blinking due to double-buffering.
-
-    g_pCompositor->deactivateAllWLRWorkspaces(PNEWWORKSPACE->m_pWlrHandle);
-    PNEWWORKSPACE->setActive(true);
-
-    if (!pMostHzMonitor || monitorRule.refreshRate > pMostHzMonitor->refreshRate)
+    if ((!pMostHzMonitor || PNEWMONITOR->refreshRate > pMostHzMonitor->refreshRate) && PNEWMONITOR->m_bEnabled)
         pMostHzMonitor = PNEWMONITOR;
-    //
-
-    if (!g_pCompositor->m_pLastMonitor) // set the last monitor if it isnt set yet
-        g_pCompositor->m_pLastMonitor = PNEWMONITOR;
-
-    g_pEventManager->postEvent(SHyprIPCEvent("monitoradded", PNEWMONITOR->szName));
 
     // ready to process cuz we have a monitor
-    g_pCompositor->m_bReadyToProcess = true;
+    if (PNEWMONITOR->m_bEnabled) {
+        g_pCompositor->m_bReadyToProcess = true;
+        g_pCompositor->m_bUnsafeState = false;
+    }
 }
 
 void Events::listener_monitorFrame(void* owner, void* data) {
-    SMonitor* const PMONITOR = (SMonitor*)owner;
+    CMonitor* const PMONITOR = (CMonitor*)owner;
+
+    if ((g_pCompositor->m_sWLRSession && !g_pCompositor->m_sWLRSession->active) || !g_pCompositor->m_bSessionActive || g_pCompositor->m_bUnsafeState) {
+        Debug::log(WARN, "Attempted to render frame on inactive session!");
+        return; // cannot draw on session inactive (different tty)
+    }
+    
+    if (!PMONITOR->m_bEnabled)
+        return;
 
     static std::chrono::high_resolution_clock::time_point startRender = std::chrono::high_resolution_clock::now();
     static std::chrono::high_resolution_clock::time_point startRenderOverlay = std::chrono::high_resolution_clock::now();
@@ -173,44 +110,52 @@ void Events::listener_monitorFrame(void* owner, void* data) {
     static auto *const PDEBUGOVERLAY = &g_pConfigManager->getConfigValuePtr("debug:overlay")->intValue;
     static auto *const PDAMAGETRACKINGMODE = &g_pConfigManager->getConfigValuePtr("general:damage_tracking_internal")->intValue;
     static auto *const PDAMAGEBLINK = &g_pConfigManager->getConfigValuePtr("debug:damage_blink")->intValue;
-    static auto *const VFRENABLED = &g_pConfigManager->getConfigValuePtr("experimental:vfr")->intValue;
+    static auto *const PNOVFR = &g_pConfigManager->getConfigValuePtr("misc:no_vfr")->intValue;
 
     static int damageBlinkCleanup = 0; // because double-buffered
 
+    if (!*PDAMAGEBLINK)
+        damageBlinkCleanup = 0;
+
     if (*PDEBUGOVERLAY == 1) {
         startRender = std::chrono::high_resolution_clock::now();
         g_pDebugOverlay->frameData(PMONITOR);
     }
 
-    // Hack: only check when monitor with top hz refreshes, saves a bit of resources.
-    // This is for stuff that should be run every frame
-    if (PMONITOR->ID == pMostHzMonitor->ID || *VFRENABLED) { // unfortunately with VFR we don't have the guarantee mostHz is going to be updated all the time, so we have to ignore that
-        g_pCompositor->sanityCheckWorkspaces();
-        g_pAnimationManager->tick();
-        g_pCompositor->cleanupFadingOut();
-
-        HyprCtl::tickHyprCtl(); // so that we dont get that race condition multithread bullshit
-
-        g_pConfigManager->dispatchExecOnce(); // We exec-once when at least one monitor starts refreshing, meaning stuff has init'd
-
-        if (g_pConfigManager->m_bWantsMonitorReload)
-            g_pConfigManager->performMonitorReload();
-
-        g_pHyprRenderer->ensureCursorRenderingMode(); // so that the cursor gets hidden/shown if the user requested timeouts
-    }
-
     if (PMONITOR->framesToSkip > 0) {
         PMONITOR->framesToSkip -= 1;
 
         if (!PMONITOR->noFrameSchedule)
-            wlr_output_schedule_frame(PMONITOR->output);
+            g_pCompositor->scheduleFrameForMonitor(PMONITOR);
         else {
             Debug::log(LOG, "NoFrameSchedule hit for %s.", PMONITOR->szName.c_str());
         }
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMONITOR->ID);
+
+        if (PMONITOR->framesToSkip > 10)
+            PMONITOR->framesToSkip = 0;
         return;
     }
 
+    // checks //
+    if (PMONITOR->ID == pMostHzMonitor->ID || !*PNOVFR) {  // unfortunately with VFR we don't have the guarantee mostHz is going to be updated all the time, so we have to ignore that
+        g_pCompositor->sanityCheckWorkspaces();
+        g_pAnimationManager->tick();
+
+        g_pConfigManager->dispatchExecOnce();  // We exec-once when at least one monitor starts refreshing, meaning stuff has init'd
+
+        if (g_pConfigManager->m_bWantsMonitorReload)
+            g_pConfigManager->performMonitorReload();
+
+        g_pHyprRenderer->ensureCursorRenderingMode();  // so that the cursor gets hidden/shown if the user requested timeouts
+    }
+    //       //
+
+    if (PMONITOR->scheduledRecalc) {
+        PMONITOR->scheduledRecalc = false;
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMONITOR->ID);
+    }
+
     timespec now;
     clock_gettime(CLOCK_MONOTONIC, &now);
 
@@ -224,17 +169,22 @@ void Events::listener_monitorFrame(void* owner, void* data) {
         return;
     }
 
+    g_pHyprOpenGL->preRender(PMONITOR);
+
     if (!wlr_output_damage_attach_render(PMONITOR->damage, &hasChanged, &damage)){
         Debug::log(ERR, "Couldn't attach render to display %s ???", PMONITOR->szName.c_str());
         return;
     }
 
+    // we need to cleanup fading out when rendering the appropriate context
+    g_pCompositor->cleanupFadingOut(PMONITOR->ID);
+
     if (!hasChanged && *PDAMAGETRACKINGMODE != DAMAGE_TRACKING_NONE && PMONITOR->forceFullFrames == 0 && damageBlinkCleanup == 0) {
         pixman_region32_fini(&damage);
         wlr_output_rollback(PMONITOR->output);
 
-        if (!*VFRENABLED)
-            wlr_output_schedule_frame(PMONITOR->output);
+        if (*PDAMAGEBLINK || *PNOVFR)
+            g_pCompositor->scheduleFrameForMonitor(PMONITOR);
 
         return;
     }
@@ -263,14 +213,18 @@ void Events::listener_monitorFrame(void* owner, void* data) {
         }
     }
 
-    if (PMONITOR->forceFullFrames > 0)
+    if (PMONITOR->forceFullFrames > 0) {
         PMONITOR->forceFullFrames -= 1;
+        if (PMONITOR->forceFullFrames > 10)
+            PMONITOR->forceFullFrames = 0;
+    }
+        
 
     // TODO: this is getting called with extents being 0,0,0,0 should it be?
     // potentially can save on resources.
 
     g_pHyprOpenGL->begin(PMONITOR, &damage);
-    g_pHyprOpenGL->clear(CColor(100, 11, 11, 255));
+    g_pHyprOpenGL->clear(CColor(17, 17, 17, 255));
     g_pHyprOpenGL->clearWithTex(); // will apply the hypr "wallpaper"
 
     g_pHyprRenderer->renderAllClientsForMonitor(PMONITOR->ID, &now);
@@ -323,8 +277,8 @@ void Events::listener_monitorFrame(void* owner, void* data) {
 
     wlr_output_commit(PMONITOR->output);
 
-    if (!*VFRENABLED)
-        wlr_output_schedule_frame(PMONITOR->output);
+    if (*PDAMAGEBLINK || *PNOVFR)
+        g_pCompositor->scheduleFrameForMonitor(PMONITOR);
 
     if (*PDEBUGOVERLAY == 1) {
         const float µs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - startRender).count() / 1000.f;
@@ -341,7 +295,7 @@ void Events::listener_monitorFrame(void* owner, void* data) {
 void Events::listener_monitorDestroy(void* owner, void* data) {
     const auto OUTPUT = (wlr_output*)data;
 
-    SMonitor* pMonitor = nullptr;
+    CMonitor* pMonitor = nullptr;
 
     for (auto& m : g_pCompositor->m_vMonitors) {
         if (m->szName == OUTPUT->name) {
@@ -353,56 +307,25 @@ void Events::listener_monitorDestroy(void* owner, void* data) {
     if (!pMonitor)
         return;
 
-    // Cleanup everything. Move windows back, snap cursor, shit.
-    const auto BACKUPMON = g_pCompositor->m_vMonitors.front().get();
+    pMonitor->onDisconnect();
 
-    if (!BACKUPMON) {
-        Debug::log(CRIT, "No monitors! Unplugged last! Exiting.");
-        g_pCompositor->cleanupExit();
-        exit(1);
-        return;
-    }
+    // cleanup if not unsafe
 
-    const auto BACKUPWORKSPACE = BACKUPMON->activeWorkspace > 0 ? std::to_string(BACKUPMON->activeWorkspace) : "name:" + g_pCompositor->getWorkspaceByID(BACKUPMON->activeWorkspace)->m_szName;
+    if (!g_pCompositor->m_bUnsafeState) {
+        g_pCompositor->m_vRealMonitors.erase(std::remove_if(g_pCompositor->m_vRealMonitors.begin(), g_pCompositor->m_vRealMonitors.end(), [&](std::shared_ptr<CMonitor>& el) { return el.get() == pMonitor; }));
 
-    // 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);
+        if (pMostHzMonitor == pMonitor) {
+            int mostHz = 0;
+            CMonitor* pMonitorMostHz = nullptr;
 
-    // move workspaces
-    std::deque<CWorkspace*> wspToMove;
-    for (auto& w : g_pCompositor->m_vWorkspaces) {
-        if (w->m_iMonitorID == pMonitor->ID) {
-            wspToMove.push_back(w.get());
-        }
-    }
-
-    for (auto& w : wspToMove) {
-        g_pCompositor->moveWorkspaceToMonitor(w, BACKUPMON);
-        w->startAnim(true, true, true);
-    }
-
-    pMonitor->activeWorkspace = -1;
-
-    g_pCompositor->m_vWorkspaces.erase(std::remove_if(g_pCompositor->m_vWorkspaces.begin(), g_pCompositor->m_vWorkspaces.end(), [&](std::unique_ptr<CWorkspace>& el) { return el->m_iMonitorID == pMonitor->ID; }));
-
-    Debug::log(LOG, "Removed monitor %s!", pMonitor->szName.c_str());
-
-    g_pEventManager->postEvent(SHyprIPCEvent("monitorremoved", pMonitor->szName));
-
-    g_pCompositor->m_vMonitors.erase(std::remove_if(g_pCompositor->m_vMonitors.begin(), g_pCompositor->m_vMonitors.end(), [&](std::unique_ptr<SMonitor>& el) { return el.get() == pMonitor; }));
-
-    // update the pMostHzMonitor
-    if (pMostHzMonitor == pMonitor) {
-        int mostHz = 0;
-        SMonitor* pMonitorMostHz = nullptr;
-
-        for (auto& m : g_pCompositor->m_vMonitors) {
-            if (m->refreshRate > mostHz) {
-                pMonitorMostHz = m.get();
-                mostHz = m->refreshRate;
+            for (auto& m : g_pCompositor->m_vMonitors) {
+                if (m->refreshRate > mostHz) {
+                    pMonitorMostHz = m.get();
+                    mostHz = m->refreshRate;
+                }
             }
-        }
 
-        pMostHzMonitor = pMonitorMostHz;
+            pMostHzMonitor = pMonitorMostHz;
+        }
     }
 }

src/events/Popups.cpp

@@ -51,10 +51,11 @@ void addPopupGlobalCoords(void* pPopup, int* x, int* y) {
 void createNewPopup(wlr_xdg_popup* popup, SXDGPopup* pHyprPopup) {
     pHyprPopup->popup = popup;
 
-    pHyprPopup->hyprListener_destroyPopupXDG.initCallback(&popup->base->surface->events.destroy, &Events::listener_destroyPopupXDG, pHyprPopup, "HyprPopup");
+    pHyprPopup->hyprListener_destroyPopupXDG.initCallback(&popup->base->events.destroy, &Events::listener_destroyPopupXDG, pHyprPopup, "HyprPopup");
     pHyprPopup->hyprListener_mapPopupXDG.initCallback(&popup->base->events.map, &Events::listener_mapPopupXDG, pHyprPopup, "HyprPopup");
     pHyprPopup->hyprListener_unmapPopupXDG.initCallback(&popup->base->events.unmap, &Events::listener_unmapPopupXDG, pHyprPopup, "HyprPopup");
     pHyprPopup->hyprListener_newPopupFromPopupXDG.initCallback(&popup->base->events.new_popup, &Events::listener_newPopupFromPopupXDG, pHyprPopup, "HyprPopup");
+    pHyprPopup->hyprListener_commitPopupXDG.initCallback(&popup->base->surface->events.commit, &Events::listener_commitPopupXDG, pHyprPopup, "HyprPopup");
 
     const auto PMONITOR = g_pCompositor->m_pLastMonitor;
 
@@ -92,6 +93,9 @@ void Events::listener_newPopupXDG(void* owner, void* data) {
 
     ASSERT(PWINDOW);
 
+    if (!PWINDOW->m_bIsMapped)
+        return;
+
     Debug::log(LOG, "New layer popup created from XDG window %x -> %s", PWINDOW, PWINDOW->m_szTitle.c_str());
 
     const auto WLRPOPUP = (wlr_xdg_popup*)data;
@@ -100,9 +104,12 @@ void Events::listener_newPopupXDG(void* owner, void* data) {
 
     const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
 
+    wlr_box geom;
+    wlr_xdg_surface_get_geometry(PWINDOW->m_uSurface.xdg, &geom);
+
     PNEWPOPUP->popup = WLRPOPUP;
-    PNEWPOPUP->lx = PWINDOW->m_vRealPosition.goalv().x;
-    PNEWPOPUP->ly = PWINDOW->m_vRealPosition.goalv().y;
+    PNEWPOPUP->lx = PWINDOW->m_vRealPosition.goalv().x - geom.x;
+    PNEWPOPUP->ly = PWINDOW->m_vRealPosition.goalv().y - geom.y;
     PNEWPOPUP->parentWindow = PWINDOW;
     PNEWPOPUP->monitor = PMONITOR;
     createNewPopup(WLRPOPUP, PNEWPOPUP);
@@ -141,6 +148,14 @@ void Events::listener_mapPopupXDG(void* owner, void* data) {
 
     PPOPUP->pSurfaceTree = SubsurfaceTree::createTreeRoot(PPOPUP->popup->base->surface, addPopupGlobalCoords, PPOPUP, PPOPUP->parentWindow);
 
+    int lx = 0, ly = 0;
+    addPopupGlobalCoords(PPOPUP, &lx, &ly);
+
+    wlr_box extents;
+    wlr_surface_get_extends(PPOPUP->popup->base->surface, &extents);
+
+    g_pHyprRenderer->damageBox(lx, ly, extents.width + 2, extents.height + 2);
+
     Debug::log(LOG, "XDG Popup got assigned a surfaceTreeNode %x", PPOPUP->pSurfaceTree);
 }
 
@@ -152,9 +167,26 @@ void Events::listener_unmapPopupXDG(void* owner, void* data) {
 
     SubsurfaceTree::destroySurfaceTree(PPOPUP->pSurfaceTree);
 
+    int lx = 0, ly = 0;
+    addPopupGlobalCoords(PPOPUP, &lx, &ly);
+
+    wlr_box extents;
+    wlr_surface_get_extends(PPOPUP->popup->base->surface, &extents);
+
+    g_pHyprRenderer->damageBox(lx, ly, extents.width + 2, extents.height + 2);
+
     PPOPUP->pSurfaceTree = nullptr;
 }
 
+void Events::listener_commitPopupXDG(void* owner, void* data) {
+    SXDGPopup* PPOPUP = (SXDGPopup*)owner;
+
+    int lx = 0, ly = 0;
+    addPopupGlobalCoords(PPOPUP, &lx, &ly);
+
+    g_pHyprRenderer->damageSurface(PPOPUP->popup->base->surface, lx, ly);
+}
+
 void Events::listener_destroyPopupXDG(void* owner, void* data) {
     SXDGPopup* PPOPUP = (SXDGPopup*)owner;
 

src/events/Windows.cpp

@@ -29,9 +29,26 @@ void addViewCoords(void* pWindow, int* x, int* y) {
     }
 }
 
+int setAnimToMove(void* data) {
+    const auto PWINDOW = (CWindow*)data;
+
+    auto *const PANIMCFG = g_pConfigManager->getAnimationPropertyConfig("windowsMove");
+
+    if (!g_pCompositor->windowValidMapped(PWINDOW))
+        return 0;
+
+    PWINDOW->m_vRealPosition.setConfig(PANIMCFG);
+    PWINDOW->m_vRealSize.setConfig(PANIMCFG);
+
+    return 0;
+}
+
 void Events::listener_mapWindow(void* owner, void* data) {
     CWindow* PWINDOW = (CWindow*)owner;
 
+    static auto *const PINACTIVEALPHA = &g_pConfigManager->getConfigValuePtr("decoration:inactive_opacity")->floatValue;
+    static auto *const PACTIVEALPHA = &g_pConfigManager->getConfigValuePtr("decoration:active_opacity")->floatValue;
+
     const auto PMONITOR = g_pCompositor->getMonitorFromCursor();
     const auto PWORKSPACE = PMONITOR->specialWorkspaceOpen ? g_pCompositor->getWorkspaceByID(SPECIAL_WORKSPACE_ID) : g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
     PWINDOW->m_iMonitorID = PMONITOR->ID;
@@ -41,18 +58,17 @@ void Events::listener_mapWindow(void* owner, void* data) {
     PWINDOW->m_bReadyToDelete = false;
     PWINDOW->m_bFadingOut = false;
     PWINDOW->m_szTitle = g_pXWaylandManager->getTitle(PWINDOW);
-    PWINDOW->m_fAlpha = 255.f;
 
     if (PWINDOW->m_iX11Type == 2)
         g_pCompositor->moveUnmanagedX11ToWindows(PWINDOW);
 
+    g_pCompositor->updateWindowAnimatedDecorationValues(PWINDOW);
+
     // Set all windows tiled regardless of anything
     g_pXWaylandManager->setWindowStyleTiled(PWINDOW, WLR_EDGE_LEFT | WLR_EDGE_RIGHT | WLR_EDGE_TOP | WLR_EDGE_BOTTOM);
 
     // Foreign Toplevel
-    PWINDOW->m_phForeignToplevel = wlr_foreign_toplevel_handle_v1_create(g_pCompositor->m_sWLRToplevelMgr);
-    // TODO: handle foreign events (requests)
-    wlr_foreign_toplevel_handle_v1_set_app_id(PWINDOW->m_phForeignToplevel, g_pXWaylandManager->getAppIDClass(PWINDOW).c_str());
+    PWINDOW->createToplevelHandle();
 
     // checks if the window wants borders and sets the appriopriate flag
     g_pXWaylandManager->checkBorders(PWINDOW);
@@ -69,6 +85,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PWINDOW->m_bRequestsFloat = true;
     }
 
+    PWINDOW->m_bX11ShouldntFocus = PWINDOW->m_bX11ShouldntFocus || (PWINDOW->m_bIsX11 && PWINDOW->m_iX11Type == 2);
+
     if (PWORKSPACE->m_bDefaultFloating)
         PWINDOW->m_bIsFloating = true;
 
@@ -100,13 +118,14 @@ void Events::listener_mapWindow(void* owner, void* data) {
                     PWINDOW->m_iMonitorID = PMONITOR->ID;
                 } else {
                     const long int MONITOR = std::stoi(MONITORSTR);
-                    if (MONITOR >= (long int)g_pCompositor->m_vMonitors.size() || MONITOR < (long int)0)
+                    if (!g_pCompositor->getMonitorFromID(MONITOR))
                         PWINDOW->m_iMonitorID = 0;
                     else
                         PWINDOW->m_iMonitorID = MONITOR;
                 }
 
                 PWINDOW->m_iWorkspaceID = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID)->activeWorkspace;
+                g_pKeybindManager->m_mDispatchers["focusmonitor"](std::to_string(PWINDOW->m_iMonitorID));
 
                 Debug::log(ERR, "Rule monitor, applying to window %x -> mon: %i, workspace: %i", PWINDOW, PWINDOW->m_iMonitorID, PWINDOW->m_iWorkspaceID);
             } catch (std::exception& e) {
@@ -122,13 +141,6 @@ void Events::listener_mapWindow(void* owner, void* data) {
                 requestedWorkspace = WORKSPACERQ;
             }
 
-            if (requestedWorkspace == "special") {
-                requestedWorkspace = "";
-                workspaceSilent = false;
-                Debug::log(LOG, "windowrule=workspace special is not allowed!");
-                continue;
-            }
-
             Debug::log(LOG, "Rule workspace matched by window %x, %s applied.", PWINDOW, r.szValue.c_str());
         } else if (r.szRule.find("float") == 0) {
             PWINDOW->m_bIsFloating = true;
@@ -142,6 +154,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
             PWINDOW->m_sAdditionalConfigData.forceNoBlur = true;
         } else if (r.szRule == "fullscreen") {
             requestsFullscreen = true;
+        } else if (r.szRule == "opaque") {
+            PWINDOW->m_sAdditionalConfigData.forceOpaque = true;
         } else if (r.szRule.find("rounding") == 0) {
             try {
                 PWINDOW->m_sAdditionalConfigData.rounding = std::stoi(r.szRule.substr(r.szRule.find_first_of(' ') + 1));
@@ -152,7 +166,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
             try {
                 std::string alphaPart = r.szRule.substr(r.szRule.find_first_of(' ') + 1);
 
-                if (alphaPart.find_first_of(' ') != std::string::npos) {
+                if (alphaPart.contains(' ')) {
                     // we have a comma, 2 values
                     PWINDOW->m_sSpecialRenderData.alpha = std::stof(alphaPart.substr(0, alphaPart.find_first_of(' ')));
                     PWINDOW->m_sSpecialRenderData.alphaInactive = std::stof(alphaPart.substr(alphaPart.find_first_of(' ') + 1));
@@ -170,13 +184,17 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
     if (requestedWorkspace != "") {
         // process requested workspace
-        if (requestedWorkspace.find_first_of(' ') != std::string::npos) {
+        if (requestedWorkspace.contains(' ')) {
             // check for silent
-            if (requestedWorkspace.find("silent") != std::string::npos) {
+            if (requestedWorkspace.contains("silent")) {
                 workspaceSilent = true;
             }
 
             requestedWorkspace = requestedWorkspace.substr(0, requestedWorkspace.find_first_of(' '));
+
+            if (requestedWorkspace == "special") {
+                workspaceSilent = true;
+            }
         }
 
         if (!workspaceSilent) {
@@ -199,13 +217,15 @@ void Events::listener_mapWindow(void* owner, void* data) {
                     const auto SIZEXSTR = VALUE.substr(0, VALUE.find(" "));
                     const auto SIZEYSTR = VALUE.substr(VALUE.find(" ") + 1);
 
-                    const auto SIZEX = SIZEXSTR.find('%') == std::string::npos ? std::stoi(SIZEXSTR) : std::stoi(SIZEXSTR.substr(0, SIZEXSTR.length() - 1)) * 0.01f * PMONITOR->vecSize.x;
-                    const auto SIZEY = SIZEYSTR.find('%') == std::string::npos ? std::stoi(SIZEYSTR) : std::stoi(SIZEYSTR.substr(0, SIZEYSTR.length() - 1)) * 0.01f * PMONITOR->vecSize.y;
+                    const auto SIZEX = !SIZEXSTR.contains('%') ? std::stoi(SIZEXSTR) : std::stoi(SIZEXSTR.substr(0, SIZEXSTR.length() - 1)) * 0.01f * PMONITOR->vecSize.x;
+                    const auto SIZEY = !SIZEYSTR.contains('%') ? std::stoi(SIZEYSTR) : std::stoi(SIZEYSTR.substr(0, SIZEYSTR.length() - 1)) * 0.01f * PMONITOR->vecSize.y;
 
                     Debug::log(LOG, "Rule size, applying to window %x", PWINDOW);
 
                     PWINDOW->m_vRealSize = Vector2D(SIZEX, SIZEY);
                     g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
+
+                    PWINDOW->m_bHidden = false;
                 } catch (...) {
                     Debug::log(LOG, "Rule size failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str());
                 }
@@ -215,15 +235,19 @@ void Events::listener_mapWindow(void* owner, void* data) {
                     const auto POSXSTR = VALUE.substr(0, VALUE.find(" "));
                     const auto POSYSTR = VALUE.substr(VALUE.find(" ") + 1);
 
-                    const auto POSX = POSXSTR.find('%') == std::string::npos ? std::stoi(POSXSTR) : std::stoi(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01f * PMONITOR->vecSize.x;
-                    const auto POSY = POSYSTR.find('%') == std::string::npos ? std::stoi(POSYSTR) : std::stoi(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01f * PMONITOR->vecSize.y;
+                    const auto POSX = !POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stoi(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01f * PMONITOR->vecSize.x;
+                    const auto POSY = !POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stoi(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01f * PMONITOR->vecSize.y;
 
                     Debug::log(LOG, "Rule move, applying to window %x", PWINDOW);
 
                     PWINDOW->m_vRealPosition = Vector2D(POSX, POSY) + PMONITOR->vecPosition;
+
+                    PWINDOW->m_bHidden = false;
                 } catch (...) {
                     Debug::log(LOG, "Rule move failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str());
                 }
+            } else if (r.szRule == "center") {
+                PWINDOW->m_vRealPosition = PMONITOR->vecPosition + PMONITOR->vecSize / 2.f - PWINDOW->m_vRealSize.goalv() / 2.f;
             }
         }
 
@@ -238,8 +262,11 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PWINDOW->m_vPseudoSize = PWINDOW->m_vRealSize.goalv() - Vector2D(10,10);
     }
 
-    if (!PWINDOW->m_bNoFocus && !PWINDOW->m_bNoInitialFocus)
+    if (!PWINDOW->m_bNoFocus && !PWINDOW->m_bNoInitialFocus && PWINDOW->m_iX11Type != 2) {
         g_pCompositor->focusWindow(PWINDOW);
+        PWINDOW->m_fActiveInactiveAlpha.setValueAndWarp(*PACTIVEALPHA);
+    } else
+        PWINDOW->m_fActiveInactiveAlpha.setValueAndWarp(*PINACTIVEALPHA);
 
     Debug::log(LOG, "Window got assigned a surfaceTreeNode %x", PWINDOW->m_pSurfaceTree);
 
@@ -248,15 +275,27 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PWINDOW->hyprListener_setTitleWindow.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.set_title, &Events::listener_setTitleWindow, PWINDOW, "XDG Window Late");
         PWINDOW->hyprListener_fullscreenWindow.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_fullscreen, &Events::listener_fullscreenWindow, PWINDOW, "XDG Window Late");
         PWINDOW->hyprListener_newPopupXDG.initCallback(&PWINDOW->m_uSurface.xdg->events.new_popup, &Events::listener_newPopupXDG, PWINDOW, "XDG Window Late");
+        PWINDOW->hyprListener_requestMaximize.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_maximize, &Events::listener_requestMaximize, PWINDOW, "XDG Window Late");
+        PWINDOW->hyprListener_requestMinimize.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_minimize, &Events::listener_requestMinimize, PWINDOW, "XDG Window Late");
+        PWINDOW->hyprListener_requestMove.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_move, &Events::listener_requestMove, PWINDOW, "XDG Window Late");
+        PWINDOW->hyprListener_requestResize.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_resize, &Events::listener_requestResize, PWINDOW, "XDG Window Late");
     } else {
         PWINDOW->hyprListener_fullscreenWindow.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_fullscreen, &Events::listener_fullscreenWindow, PWINDOW, "XWayland Window Late");
         PWINDOW->hyprListener_activateX11.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_activate, &Events::listener_activateX11, PWINDOW, "XWayland Window Late");
         PWINDOW->hyprListener_configureX11.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_configure, &Events::listener_configureX11, PWINDOW, "XWayland Window Late");
         PWINDOW->hyprListener_setTitleWindow.initCallback(&PWINDOW->m_uSurface.xwayland->events.set_title, &Events::listener_setTitleWindow, PWINDOW, "XWayland Window Late");
+        
+        if (PWINDOW->m_iX11Type == 2)
+            PWINDOW->hyprListener_setGeometryX11U.initCallback(&PWINDOW->m_uSurface.xwayland->events.set_geometry, &Events::listener_unmanagedSetGeometry, PWINDOW, "XWayland Window Late");
     }
 
     // do the animation thing
     g_pAnimationManager->onWindowPostCreateClose(PWINDOW, false);
+    PWINDOW->m_fAlpha.setValueAndWarp(0.f);
+    PWINDOW->m_fAlpha = 255.f;
+
+    const auto TIMER = wl_event_loop_add_timer(g_pCompositor->m_sWLEventLoop, setAnimToMove, PWINDOW);
+    wl_event_source_timer_update(TIMER, PWINDOW->m_vRealPosition.getDurationLeftMs() + 5);
 
     if (workspaceSilent) {
         // move the window
@@ -284,8 +323,13 @@ void Events::listener_mapWindow(void* owner, void* data) {
         g_pCompositor->setWindowFullscreen(PWINDOW, true, FULLSCREEN_FULL);
     }
 
+    // recheck idle inhibitors
+    g_pInputManager->recheckIdleInhibitorStatus();
+
     PWINDOW->m_pSurfaceTree = SubsurfaceTree::createTreeRoot(g_pXWaylandManager->getWindowSurface(PWINDOW), addViewCoords, PWINDOW, PWINDOW);
 
+    PWINDOW->updateToplevel();
+
     Debug::log(LOG, "Map request dispatched, monitor %s, xywh: %f %f %f %f", PMONITOR->szName.c_str(), PWINDOW->m_vRealPosition.goalv().x, PWINDOW->m_vRealPosition.goalv().y, PWINDOW->m_vRealSize.goalv().x, PWINDOW->m_vRealSize.goalv().y);
 }
 
@@ -295,17 +339,22 @@ void Events::listener_unmapWindow(void* owner, void* data) {
     Debug::log(LOG, "Window %x unmapped (class %s)", PWINDOW, g_pXWaylandManager->getAppIDClass(PWINDOW).c_str());
 
     if (!PWINDOW->m_bIsX11) {
-        Debug::log(LOG, "Unregistered late callbacks XDG: %x %x %x %x", &PWINDOW->hyprListener_commitWindow.m_sListener.link, &PWINDOW->hyprListener_setTitleWindow.m_sListener.link, &PWINDOW->hyprListener_fullscreenWindow.m_sListener.link, &PWINDOW->hyprListener_newPopupXDG.m_sListener.link);
+        Debug::log(LOG, "Unregistered late callbacks XDG");
         PWINDOW->hyprListener_commitWindow.removeCallback();
         PWINDOW->hyprListener_setTitleWindow.removeCallback();
         PWINDOW->hyprListener_fullscreenWindow.removeCallback();
         PWINDOW->hyprListener_newPopupXDG.removeCallback();
+        PWINDOW->hyprListener_requestMaximize.removeCallback();
+        PWINDOW->hyprListener_requestMinimize.removeCallback();
+        PWINDOW->hyprListener_requestMove.removeCallback();
+        PWINDOW->hyprListener_requestResize.removeCallback();
     } else {
-        Debug::log(LOG, "Unregistered late callbacks XWL: %x %x %x %x", &PWINDOW->hyprListener_fullscreenWindow.m_sListener.link, &PWINDOW->hyprListener_activateX11.m_sListener.link, &PWINDOW->hyprListener_configureX11.m_sListener.link, &PWINDOW->hyprListener_setTitleWindow.m_sListener.link);
+        Debug::log(LOG, "Unregistered late callbacks XWL");
         PWINDOW->hyprListener_fullscreenWindow.removeCallback();
         PWINDOW->hyprListener_activateX11.removeCallback();
         PWINDOW->hyprListener_configureX11.removeCallback();
         PWINDOW->hyprListener_setTitleWindow.removeCallback();
+        PWINDOW->hyprListener_setGeometryX11U.removeCallback();
     }
 
     if (PWINDOW->m_bIsFullscreen) {
@@ -321,8 +370,6 @@ void Events::listener_unmapWindow(void* owner, void* data) {
         g_pCompositor->m_pLastFocus = nullptr;
     }
 
-    PWINDOW->m_fAlpha = 0.f;
-
     PWINDOW->m_bMappedX11 = false;
 
     // remove the fullscreen window status from workspace if we closed it
@@ -337,7 +384,17 @@ void Events::listener_unmapWindow(void* owner, void* data) {
     PWINDOW->m_bIsMapped = false;
 
     // refocus on a new window
-    g_pInputManager->refocus();
+    auto PWINDOWCANDIDATE = g_pCompositor->vectorToWindowIdeal(PWINDOW->m_vRealPosition.goalv() + PWINDOW->m_vRealSize.goalv() / 2.f);
+
+    if (!PWINDOWCANDIDATE)
+        PWINDOWCANDIDATE = g_pCompositor->getFirstWindowOnWorkspace(PWINDOW->m_iWorkspaceID);
+
+    if (!PWINDOWCANDIDATE || PWINDOW == PWINDOWCANDIDATE || !PWINDOWCANDIDATE->m_bIsMapped || PWINDOWCANDIDATE->m_bHidden || PWINDOWCANDIDATE->m_bX11ShouldntFocus || PWINDOWCANDIDATE->m_iX11Type == 2)
+        PWINDOWCANDIDATE = nullptr;
+
+    Debug::log(LOG, "On closed window, new focused candidate is %x", PWINDOWCANDIDATE);
+
+    g_pCompositor->focusWindow(PWINDOWCANDIDATE);
 
     Debug::log(LOG, "Destroying the SubSurface tree of unmapped window %x", PWINDOW);
     SubsurfaceTree::destroySurfaceTree(PWINDOW->m_pSurfaceTree);
@@ -346,7 +403,7 @@ void Events::listener_unmapWindow(void* owner, void* data) {
 
     PWINDOW->m_bFadingOut = true;
 
-    g_pCompositor->m_vWindowsFadingOut.emplace_back(PWINDOW);
+    g_pCompositor->addToFadingOutSafe(PWINDOW);
 
     g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID));
 
@@ -358,17 +415,22 @@ void Events::listener_unmapWindow(void* owner, void* data) {
 
     if (!PWINDOW->m_bX11DoesntWantBorders)   // don't animate out if they weren't animated in.
         PWINDOW->m_vRealPosition = PWINDOW->m_vRealPosition.vec() + Vector2D(0.01f, 0.01f);  // it has to be animated, otherwise onWindowPostCreateClose will ignore it
+    
+    // anims
     g_pAnimationManager->onWindowPostCreateClose(PWINDOW, true);
+    PWINDOW->m_fAlpha = 0.f;
 
     // Destroy Foreign Toplevel
-    wlr_foreign_toplevel_handle_v1_destroy(PWINDOW->m_phForeignToplevel);
-    PWINDOW->m_phForeignToplevel = nullptr;
+    PWINDOW->destroyToplevelHandle();
+
+    // recheck idle inhibitors
+    g_pInputManager->recheckIdleInhibitorStatus();
 }
 
 void Events::listener_commitWindow(void* owner, void* data) {
     CWindow* PWINDOW = (CWindow*)owner;
 
-    if (!g_pCompositor->windowValidMapped(PWINDOW))
+    if (!PWINDOW->m_bMappedX11 || PWINDOW->m_bHidden || (PWINDOW->m_bIsX11 && !PWINDOW->m_bMappedX11))
         return;
 
     g_pHyprRenderer->damageSurface(g_pXWaylandManager->getWindowSurface(PWINDOW), PWINDOW->m_vRealPosition.goalv().x, PWINDOW->m_vRealPosition.goalv().y);        
@@ -413,10 +475,9 @@ void Events::listener_setTitleWindow(void* owner, void* data) {
     PWINDOW->m_szTitle = g_pXWaylandManager->getTitle(PWINDOW);
 
     if (PWINDOW == g_pCompositor->m_pLastWindow) // if it's the active, let's post an event to update others
-        g_pEventManager->postEvent(SHyprIPCEvent("activewindow", g_pXWaylandManager->getAppIDClass(PWINDOW) + "," + PWINDOW->m_szTitle));
+        g_pEventManager->postEvent(SHyprIPCEvent{"activewindow", g_pXWaylandManager->getAppIDClass(PWINDOW) + "," + PWINDOW->m_szTitle});
 
-    if (PWINDOW->m_phForeignToplevel)
-        wlr_foreign_toplevel_handle_v1_set_title(PWINDOW->m_phForeignToplevel, PWINDOW->m_szTitle.c_str());
+    PWINDOW->updateToplevel();
 
     Debug::log(LOG, "Window %x set title to %s", PWINDOW, PWINDOW->m_szTitle.c_str());
 }
@@ -424,15 +485,22 @@ void Events::listener_setTitleWindow(void* owner, void* data) {
 void Events::listener_fullscreenWindow(void* owner, void* data) {
     CWindow* PWINDOW = (CWindow*)owner;
 
+    if (!PWINDOW->m_bIsMapped || PWINDOW->m_bHidden)
+        return;
+
     if (!PWINDOW->m_bIsX11) {
         const auto REQUESTED = &PWINDOW->m_uSurface.xdg->toplevel->requested;
 
         if (REQUESTED->fullscreen != PWINDOW->m_bIsFullscreen)
-            g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(PWINDOW, FULLSCREEN_FULL, REQUESTED->fullscreen);
+            g_pCompositor->setWindowFullscreen(PWINDOW, REQUESTED->fullscreen, FULLSCREEN_FULL);
+
+        wlr_xdg_surface_schedule_configure(PWINDOW->m_uSurface.xdg);
     } else {
-        g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(PWINDOW, FULLSCREEN_FULL, !PWINDOW->m_bIsFullscreen);
+        g_pCompositor->setWindowFullscreen(PWINDOW, !PWINDOW->m_bIsFullscreen, FULLSCREEN_FULL);
     }
 
+    PWINDOW->updateToplevel();
+
     Debug::log(LOG, "Window %x fullscreen to %i", PWINDOW, PWINDOW->m_bIsFullscreen);
     
     g_pXWaylandManager->setWindowFullscreen(PWINDOW, PWINDOW->m_bIsFullscreen);
@@ -459,7 +527,7 @@ void Events::listener_configureX11(void* owner, void* data) {
     const auto E = (wlr_xwayland_surface_configure_event*)data;
     g_pHyprRenderer->damageWindow(PWINDOW);
 
-    if (!PWINDOW->m_bIsFloating) {
+    if (!PWINDOW->m_bIsFloating || PWINDOW->m_bIsFullscreen) {
         g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.vec());
         g_pInputManager->refocus();
         g_pHyprRenderer->damageWindow(PWINDOW);
@@ -471,6 +539,11 @@ void Events::listener_configureX11(void* owner, void* data) {
         return;
     }
 
+    if (E->width > 1 && E->height > 1)
+        PWINDOW->m_bHidden = false;
+    else
+        PWINDOW->m_bHidden = true;
+
     PWINDOW->m_vRealPosition.setValueAndWarp(Vector2D(E->x, E->y));
     PWINDOW->m_vRealSize.setValueAndWarp(Vector2D(E->width, E->height));
     PWINDOW->m_vPosition = PWINDOW->m_vRealPosition.vec();
@@ -478,6 +551,8 @@ void Events::listener_configureX11(void* owner, void* data) {
 
     wlr_xwayland_surface_configure(PWINDOW->m_uSurface.xwayland, E->x, E->y, E->width, E->height);
 
+    PWINDOW->m_iWorkspaceID = g_pCompositor->getMonitorFromVector(PWINDOW->m_vRealPosition.vec() + PWINDOW->m_vRealSize.vec() / 2.f)->activeWorkspace;
+
     g_pCompositor->moveWindowToTop(PWINDOW);
 
     PWINDOW->m_bCreatedOverFullscreen = true;
@@ -485,6 +560,39 @@ void Events::listener_configureX11(void* owner, void* data) {
     g_pInputManager->refocus();
 
     g_pHyprRenderer->damageWindow(PWINDOW);
+
+    PWINDOW->updateWindowDecos();
+}
+
+void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
+    CWindow* PWINDOW = (CWindow*)owner;
+
+    if (!PWINDOW->m_bMappedX11 || PWINDOW->m_bHidden)
+        return;
+
+    const auto POS = PWINDOW->m_vRealPosition.goalv();
+    const auto SIZ = PWINDOW->m_vRealSize.goalv();
+
+    if (PWINDOW->m_uSurface.xwayland->width > 1 && PWINDOW->m_uSurface.xwayland->height > 1)
+        PWINDOW->m_bHidden = false;
+    else
+        PWINDOW->m_bHidden = true;
+
+    if (abs(std::floor(POS.x) - PWINDOW->m_uSurface.xwayland->x) > 2 || abs(std::floor(POS.y) - PWINDOW->m_uSurface.xwayland->y) > 2 || abs(std::floor(SIZ.x) - PWINDOW->m_uSurface.xwayland->width) > 2 || abs(std::floor(SIZ.y) - PWINDOW->m_uSurface.xwayland->height) > 2) {
+        Debug::log(LOG, "Unmanaged window %x requests geometry update to %i %i %i %i", PWINDOW, (int)PWINDOW->m_uSurface.xwayland->x, (int)PWINDOW->m_uSurface.xwayland->y, (int)PWINDOW->m_uSurface.xwayland->width, (int)PWINDOW->m_uSurface.xwayland->height);
+        
+        g_pHyprRenderer->damageWindow(PWINDOW);
+        PWINDOW->m_vRealPosition.setValueAndWarp(Vector2D(PWINDOW->m_uSurface.xwayland->x, PWINDOW->m_uSurface.xwayland->y));
+
+        if (abs(std::floor(SIZ.x) - PWINDOW->m_uSurface.xwayland->width) > 2 || abs(std::floor(SIZ.y) - PWINDOW->m_uSurface.xwayland->height) > 2)
+            PWINDOW->m_vRealSize.setValueAndWarp(Vector2D(PWINDOW->m_uSurface.xwayland->width, PWINDOW->m_uSurface.xwayland->height));
+
+        PWINDOW->m_iWorkspaceID = g_pCompositor->getMonitorFromVector(PWINDOW->m_vRealPosition.vec() + PWINDOW->m_vRealSize.vec() / 2.f)->activeWorkspace;
+
+        g_pCompositor->moveWindowToTop(PWINDOW);
+        PWINDOW->updateWindowDecos();
+        g_pHyprRenderer->damageWindow(PWINDOW);
+    }
 }
 
 void Events::listener_surfaceXWayland(wl_listener* listener, void* data) {
@@ -511,10 +619,10 @@ void Events::listener_newXDGSurface(wl_listener* listener, void* data) {
     // A window got opened
     const auto XDGSURFACE = (wlr_xdg_surface*)data;
 
-    Debug::log(LOG, "New XDG Surface created. (class: %s)", XDGSURFACE->toplevel->app_id);
-
     if (XDGSURFACE->role != WLR_XDG_SURFACE_ROLE_TOPLEVEL)
-        return;  // TODO: handle?
+        return;
+
+    Debug::log(LOG, "New XDG Surface created. (class: %s)", XDGSURFACE->toplevel->app_id);
 
     const auto PNEWWINDOW = g_pCompositor->m_vWindows.emplace_back(std::make_unique<CWindow>()).get();
     PNEWWINDOW->m_uSurface.xdg = XDGSURFACE;
@@ -528,3 +636,28 @@ void Events::listener_NewXDGDeco(wl_listener* listener, void* data) {
     const auto WLRDECO = (wlr_xdg_toplevel_decoration_v1*)data;
     wlr_xdg_toplevel_decoration_v1_set_mode(WLRDECO, WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
 }
+
+void Events::listener_requestMaximize(void* owner, void* data) {
+    const auto PWINDOW = (CWindow*)owner;
+
+    // ignore
+    wlr_xdg_surface_schedule_configure(PWINDOW->m_uSurface.xdg);
+}
+
+void Events::listener_requestMinimize(void* owner, void* data) {
+    // ignore
+}
+
+void Events::listener_requestMove(void* owner, void* data) {
+    const auto PWINDOW = (CWindow*)owner;
+
+    // ignore
+    wlr_xdg_surface_schedule_configure(PWINDOW->m_uSurface.xdg);
+}
+
+void Events::listener_requestResize(void* owner, void* data) {
+    const auto PWINDOW = (CWindow*)owner;
+
+    // ignore
+    wlr_xdg_surface_schedule_configure(PWINDOW->m_uSurface.xdg);
+}

src/helpers/AnimatedVariable.cpp

@@ -1,25 +1,24 @@
 #include "AnimatedVariable.hpp"
 #include "../managers/AnimationManager.hpp"
+#include "../config/ConfigManager.hpp"
 
 CAnimatedVariable::CAnimatedVariable() {
     ; // dummy var
 }
 
-void CAnimatedVariable::create(ANIMATEDVARTYPE type, float* speed, int64_t* enabled, std::string* pBezier, void* pWindow, AVARDAMAGEPOLICY policy) {
+void CAnimatedVariable::create(ANIMATEDVARTYPE type, SAnimationPropertyConfig* pAnimConfig, void* pWindow, AVARDAMAGEPOLICY policy) {
     m_eVarType = type;
     m_eDamagePolicy = policy;
-    m_pSpeed = speed;
-    m_pEnabled = enabled;
+    m_pConfig = pAnimConfig;
     m_pWindow = pWindow;
-    m_pBezier = pBezier;
 
     g_pAnimationManager->m_lAnimatedVariables.push_back(this);
 
     m_bDummy = false;
 }
 
-void CAnimatedVariable::create(ANIMATEDVARTYPE type, std::any val, float* speed, int64_t* enabled, std::string* pBezier, void* pWindow, AVARDAMAGEPOLICY policy) {
-    create(type, speed, enabled, pBezier, pWindow, policy);
+void CAnimatedVariable::create(ANIMATEDVARTYPE type, std::any val, SAnimationPropertyConfig* pAnimConfig, void* pWindow, AVARDAMAGEPOLICY policy) {
+    create(type, pAnimConfig, pWindow, policy);
 
     try {
         switch (type) {
@@ -57,4 +56,8 @@ CAnimatedVariable::~CAnimatedVariable() {
 
 void CAnimatedVariable::unregister() {
     g_pAnimationManager->m_lAnimatedVariables.remove(this);
-}
+}
+
+int CAnimatedVariable::getDurationLeftMs() {
+    return std::clamp((int)(m_pConfig->pValues->internalSpeed * 100) - (int)std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - animationBegin).count(), 0, INT_MAX);
+}

src/helpers/AnimatedVariable.hpp

@@ -13,19 +13,21 @@ enum ANIMATEDVARTYPE {
 enum AVARDAMAGEPOLICY {
     AVARDAMAGE_INVALID = -1,
     AVARDAMAGE_ENTIRE = 0,
-    AVARDAMAGE_BORDER
+    AVARDAMAGE_BORDER,
+    AVARDAMAGE_SHADOW
 };
 
 class CAnimationManager;
 class CWorkspace;
 struct SLayerSurface;
+struct SAnimationPropertyConfig;
 
 class CAnimatedVariable {
 public:
     CAnimatedVariable(); // dummy var
 
-    void create(ANIMATEDVARTYPE, float* speed, int64_t* enabled, std::string* pBezier, void* pWindow, AVARDAMAGEPOLICY);
-    void create(ANIMATEDVARTYPE, std::any val, float* speed, int64_t* enabled, std::string* pBezier, void* pWindow, AVARDAMAGEPOLICY);
+    void create(ANIMATEDVARTYPE, SAnimationPropertyConfig*, void* pWindow, AVARDAMAGEPOLICY);
+    void create(ANIMATEDVARTYPE, std::any val, SAnimationPropertyConfig*, void* pWindow, AVARDAMAGEPOLICY);
 
     ~CAnimatedVariable();
 
@@ -128,10 +130,12 @@ public:
             case AVARTYPE_COLOR:
                 return m_cValue != m_cGoal;
             default:
-                return false;
+                UNREACHABLE();
         }
 
-        return false; // unreachable
+        UNREACHABLE();
+
+        return false; // just so that the warning is suppressed
     }
 
     void warp() {
@@ -149,10 +153,20 @@ public:
                 break;
             }
             default:
-                break;
+                UNREACHABLE();
         }
     }
 
+    void setConfig(SAnimationPropertyConfig* pConfig) {
+        m_pConfig = pConfig;
+    }
+
+    SAnimationPropertyConfig* getConfig() {
+        return m_pConfig;
+    }
+
+    int getDurationLeftMs();
+
 private:
 
     Vector2D        m_vValue = Vector2D(0,0);
@@ -167,15 +181,12 @@ private:
     float           m_fBegun = 0;
     CColor          m_cBegun;
 
-    float*          m_pSpeed = nullptr;
-    int64_t*        m_pEnabled = nullptr;
-
     // owners
     void*           m_pWindow = nullptr;
     void*           m_pWorkspace = nullptr;
     void*           m_pLayer = nullptr;
 
-    std::string*    m_pBezier = nullptr;
+    SAnimationPropertyConfig* m_pConfig = nullptr;
 
     bool            m_bDummy = true;
 

src/helpers/MiscFunctions.cpp

@@ -3,6 +3,7 @@
 #include <algorithm>
 #include "../Compositor.hpp"
 #include <sys/utsname.h>
+#include <iomanip>
 
 static const float transforms[][9] = {{
 		1.0f, 0.0f, 0.0f,
@@ -39,6 +40,28 @@ static const float transforms[][9] = {{
 	},
 };
 
+std::string absolutePath(const std::string& rawpath, const std::string& currentPath) {
+    auto value = rawpath;
+
+    if (value[0] == '.') {
+        auto currentDir = currentPath.substr(0, currentPath.find_last_of('/'));
+
+        if (value[1] == '.') {
+            auto parentDir = currentDir.substr(0, currentDir.find_last_of('/'));
+            value.replace(0, 2, parentDir);
+        } else {
+            value.replace(0, 1, currentDir);
+        }
+    }
+
+    if (value[0] == '~') {
+        static const char* const ENVHOME = getenv("HOME");
+        value.replace(0, 1, std::string(ENVHOME));
+    }
+
+    return value;
+}
+
 void addWLSignal(wl_signal* pSignal, wl_listener* pListener, void* pOwner, std::string ownerString) {
     ASSERT(pSignal);
     ASSERT(pListener);
@@ -52,67 +75,43 @@ void handleNoop(struct wl_listener *listener, void *data) {
     // Do nothing
 }
 
-void wlr_signal_emit_safe(struct wl_signal *signal, void *data) {
-    struct wl_listener cursor;
-    struct wl_listener end;
-
-    /* Add two special markers: one cursor and one end marker. This way, we know
-	 * that we've already called listeners on the left of the cursor and that we
-	 * don't want to call listeners on the right of the end marker. The 'it'
-	 * function can remove any element it wants from the list without troubles.
-	 * wl_list_for_each_safe tries to be safe but it fails: it works fine
-	 * if the current item is removed, but not if the next one is. */
-    wl_list_insert(&signal->listener_list, &cursor.link);
-    cursor.notify = handleNoop;
-    wl_list_insert(signal->listener_list.prev, &end.link);
-    end.notify = handleNoop;
-
-    while (cursor.link.next != &end.link) {
-        struct wl_list *pos = cursor.link.next;
-        struct wl_listener *l = wl_container_of(pos, l, link);
-
-        wl_list_remove(&cursor.link);
-        wl_list_insert(pos, &cursor.link);
-
-        l->notify(l, data);
-    }
-
-    wl_list_remove(&cursor.link);
-    wl_list_remove(&end.link);
-}
-
 std::string getFormat(const char *fmt, ...) {
-    char buf[LOGMESSAGESIZE] = "";
-    char* outputStr;
-    int logLen;
+    char* outputStr = nullptr;
 
     va_list args;
     va_start(args, fmt);
-    logLen = vsnprintf(buf, sizeof buf, fmt, args);
+    vasprintf(&outputStr, fmt, args);
     va_end(args);
 
-    if ((long unsigned int)logLen < sizeof buf) {
-        outputStr = strdup(buf);
-    } else {
-        outputStr = (char*)malloc(logLen + 1);
-
-        if (!outputStr) {
-            printf("CRITICAL: Cannot alloc size %d for log! (Out of memory?)", logLen + 1);
-            return "";
-        }
-
-        va_start(args, fmt);
-        vsnprintf(outputStr, logLen + 1U, fmt, args);
-        va_end(args);
-    }
-
     std::string output = std::string(outputStr);
-
     free(outputStr);
 
     return output;
 }
 
+std::string escapeJSONStrings(const std::string& str) {
+    std::ostringstream oss;
+    for (auto &c : str) {
+        switch (c) {
+        case '"': oss << "\\\""; break;
+        case '\\': oss << "\\\\"; break;
+        case '\b': oss << "\\b"; break;
+        case '\f': oss << "\\f"; break;
+        case '\n': oss << "\\n"; break;
+        case '\r': oss << "\\r"; break;
+        case '\t': oss << "\\t"; break;
+        default:
+            if ('\x00' <= c && c <= '\x1f') {
+                oss << "\\u"
+                    << std::hex << std::setw(4) << std::setfill('0') << static_cast<int>(c);
+            } else {
+                oss << c;
+            }
+        }
+    }
+    return oss.str();
+}
+
 void scaleBox(wlr_box* box, float scale) {
     box->width = std::round(box->width * scale);
     box->height = std::round(box->height * scale);
@@ -137,7 +136,7 @@ float getPlusMinusKeywordResult(std::string source, float relative) {
 
     if (source.find_first_of("+") == 0) {
         try {
-            if (source.find('.') != std::string::npos)
+            if (source.contains("."))
                 result = relative + std::stof(source.substr(1));
             else
                 result = relative + std::stoi(source.substr(1));
@@ -147,7 +146,7 @@ float getPlusMinusKeywordResult(std::string source, float relative) {
         }
     } else if (source.find_first_of("-") == 0) {
         try {
-            if (source.find('.') != std::string::npos)
+            if (source.contains("."))
                 result = relative - std::stof(source.substr(1));
             else
                 result = relative - std::stoi(source.substr(1));
@@ -157,7 +156,7 @@ float getPlusMinusKeywordResult(std::string source, float relative) {
         }
     } else {
         try {
-            if (source.find('.') != std::string::npos)
+            if (source.contains("."))
                 result = stof(source);
             else
                 result = stoi(source);
@@ -193,7 +192,9 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
         }
         outName = WORKSPACENAME;
     } else {
-        if (in[0] == 'm') {
+        if (in[0] == 'm' || in[0] == 'e') {
+            bool onAllMonitors = in[0] == 'e';
+
             if (!g_pCompositor->m_pLastMonitor) {
                 Debug::log(ERR, "Relative monitor workspace on monitor null!");
                 result = INT_MAX;
@@ -234,7 +235,7 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
                 }
 
                 if (const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(searchID); PWORKSPACE && PWORKSPACE->m_iID != SPECIAL_WORKSPACE_ID) {
-                    if (PWORKSPACE->m_iMonitorID == g_pCompositor->m_pLastMonitor->ID) {
+                    if (onAllMonitors || PWORKSPACE->m_iMonitorID == g_pCompositor->m_pLastMonitor->ID) {
                         currentID = PWORKSPACE->m_iID;
 
                         if (remains < 0)

src/helpers/MiscFunctions.hpp

@@ -2,9 +2,10 @@
 
 #include "../includes.hpp"
 
+std::string absolutePath(const std::string&, const std::string&);
 void addWLSignal(wl_signal*, wl_listener*, void* pOwner, std::string ownerString);
-void wlr_signal_emit_safe(struct wl_signal *signal, void *data);
 std::string getFormat(const char *fmt, ...); // Basically Debug::log to a string
+std::string escapeJSONStrings(const std::string& str);
 void scaleBox(wlr_box*, float);
 std::string removeBeginEndSpacesTabs(std::string);
 bool isNumber(const std::string&, bool allowfloat = false);
@@ -16,4 +17,4 @@ std::string execAndGet(const char*);
 
 float getPlusMinusKeywordResult(std::string in, float relative);
 
-void matrixProjection(float mat[9], int w, int h, wl_output_transform tr);
+void matrixProjection(float mat[9], int w, int h, wl_output_transform tr);

src/helpers/Monitor.cpp

@@ -0,0 +1,234 @@
+#include "Monitor.hpp"
+
+#include "../Compositor.hpp"
+
+void CMonitor::onConnect(bool noRule) {
+    if (m_bEnabled)
+        return;
+
+    szName = output->name;
+
+    // get monitor rule that matches
+    SMonitorRule monitorRule = g_pConfigManager->getMonitorRuleFor(output->name);
+
+    hyprListener_monitorFrame.initCallback(&output->events.frame, &Events::listener_monitorFrame, this);
+    hyprListener_monitorDestroy.initCallback(&output->events.destroy, &Events::listener_monitorDestroy, this);
+
+    // if it's disabled, disable and ignore
+    if (monitorRule.disabled) {
+
+        wlr_output_enable_adaptive_sync(output, 1);
+        wlr_output_set_scale(output, 1);
+        wlr_output_set_transform(output, WL_OUTPUT_TRANSFORM_NORMAL);
+
+        auto PREFSTATE = wlr_output_preferred_mode(output);
+
+        if (!PREFSTATE) {
+            wlr_output_mode* mode;
+
+            wl_list_for_each(mode, &output->modes, link) {
+                wlr_output_set_mode(output, PREFSTATE);
+
+                if (!wlr_output_test(output))
+                    continue;
+                
+                PREFSTATE = mode;
+                break;
+            }
+        }
+
+        if (PREFSTATE)
+            wlr_output_set_mode(output, PREFSTATE);
+        else
+            Debug::log(WARN, "No mode found for disabled output %s", output->name);
+
+        wlr_output_enable(output, 0);
+        
+        if (!wlr_output_commit(output)) {
+            Debug::log(ERR, "Couldn't commit disabled state on output %s", output->name);
+        }
+
+        Events::listener_change(nullptr, nullptr);
+
+        m_bEnabled = false;
+
+        hyprListener_monitorFrame.removeCallback();
+        return;
+    }
+
+    if (!m_bRenderingInitPassed) {
+        wlr_output_init_render(output, g_pCompositor->m_sWLRAllocator, g_pCompositor->m_sWLRRenderer);
+        m_bRenderingInitPassed = true;
+    }
+
+    if (!m_pThisWrap) {
+
+        // find the wrap
+        for (auto& m : g_pCompositor->m_vRealMonitors) {
+            if (m->ID == ID) {
+                m_pThisWrap = &m;
+                break;
+            }
+        }
+    }
+
+    if (std::find_if(g_pCompositor->m_vMonitors.begin(), g_pCompositor->m_vMonitors.end(), [&](auto& other) { return other.get() == this; }) == g_pCompositor->m_vMonitors.end()){
+        g_pCompositor->m_vMonitors.push_back(*m_pThisWrap);
+    }
+    
+    m_bEnabled = true;
+
+    wlr_output_set_scale(output, monitorRule.scale);
+    wlr_xcursor_manager_load(g_pCompositor->m_sWLRXCursorMgr, monitorRule.scale);
+    wlr_output_set_transform(output, WL_OUTPUT_TRANSFORM_NORMAL);  // TODO: support other transforms
+
+    wlr_output_enable_adaptive_sync(output, 1);
+
+    // create it in the arr
+    vecPosition = monitorRule.offset;
+    vecSize = monitorRule.resolution;
+    refreshRate = monitorRule.refreshRate;
+
+    wlr_output_enable(output, 1);
+
+    // TODO: this doesn't seem to set the X and Y correctly,
+    // wlr_output_layout_output_coords returns invalid values, I think...
+    wlr_output_layout_add(g_pCompositor->m_sWLROutputLayout, output, monitorRule.offset.x, monitorRule.offset.y);
+
+    // set mode, also applies
+    if (!noRule)
+        g_pHyprRenderer->applyMonitorRule(this, &monitorRule, true);
+
+    Debug::log(LOG, "Added new monitor with name %s at %i,%i with size %ix%i, pointer %x", output->name, (int)vecPosition.x, (int)vecPosition.y, (int)vecPixelSize.x, (int)vecPixelSize.y, output);
+
+    damage = wlr_output_damage_create(output);
+
+    // add a WLR workspace group
+    if (!pWLRWorkspaceGroupHandle) {
+        pWLRWorkspaceGroupHandle = wlr_ext_workspace_group_handle_v1_create(g_pCompositor->m_sWLREXTWorkspaceMgr);
+    }
+    
+    wlr_ext_workspace_group_handle_v1_output_enter(pWLRWorkspaceGroupHandle, output);
+
+    // Workspace
+    std::string newDefaultWorkspaceName = "";
+    auto WORKSPACEID = monitorRule.defaultWorkspace == "" ? g_pCompositor->m_vWorkspaces.size() + 1 : getWorkspaceIDFromString(monitorRule.defaultWorkspace, newDefaultWorkspaceName);
+
+    if (WORKSPACEID == INT_MAX || WORKSPACEID == (long unsigned int)SPECIAL_WORKSPACE_ID) {
+        WORKSPACEID = g_pCompositor->m_vWorkspaces.size() + 1;
+        newDefaultWorkspaceName = std::to_string(WORKSPACEID);
+
+        Debug::log(LOG, "Invalid workspace= directive name in monitor parsing, workspace name \"%s\" is invalid.", monitorRule.defaultWorkspace.c_str());
+    }
+
+    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, this);
+        activeWorkspace = PNEWWORKSPACE->m_iID;
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
+        PNEWWORKSPACE->startAnim(true, true, true);
+    } else {
+
+        if (newDefaultWorkspaceName == "")
+            newDefaultWorkspaceName = std::to_string(WORKSPACEID);
+
+        PNEWWORKSPACE = g_pCompositor->m_vWorkspaces.emplace_back(std::make_unique<CWorkspace>(ID, newDefaultWorkspaceName)).get();
+
+        // We are required to set the name here immediately
+        wlr_ext_workspace_handle_v1_set_name(PNEWWORKSPACE->m_pWlrHandle, newDefaultWorkspaceName.c_str());
+
+        PNEWWORKSPACE->m_iID = WORKSPACEID;
+    }
+
+    activeWorkspace = PNEWWORKSPACE->m_iID;
+    scale = monitorRule.scale;
+
+    m_pThisWrap = nullptr;
+
+    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);
+    //
+
+    if (!g_pCompositor->m_pLastMonitor)  // set the last monitor if it isnt set yet
+        g_pCompositor->m_pLastMonitor = this;
+
+    wlr_xcursor_manager_load(g_pCompositor->m_sWLRXCursorMgr, scale);
+
+    g_pHyprRenderer->arrangeLayersForMonitor(ID);
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
+
+    g_pEventManager->postEvent(SHyprIPCEvent{"monitoradded", szName});
+}
+
+void CMonitor::onDisconnect() {
+
+    if (!m_bEnabled)
+        return;
+
+    // Cleanup everything. Move windows back, snap cursor, shit.
+    CMonitor* BACKUPMON = nullptr;
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        if (m.get() != this) {
+            BACKUPMON = m.get();
+            break;
+        }
+    }
+
+    m_bEnabled = false;
+    m_bRenderingInitPassed = false;
+
+    hyprListener_monitorFrame.removeCallback();
+
+    if (!BACKUPMON) {
+        Debug::log(WARN, "Unplugged last monitor, entering an unsafe state. Good luck my friend.");
+
+        hyprListener_monitorMode.removeCallback();
+        hyprListener_monitorDestroy.removeCallback();
+
+        g_pCompositor->m_bUnsafeState = true;
+
+        return;
+    }
+
+    const auto BACKUPWORKSPACE = BACKUPMON->activeWorkspace > 0 ? std::to_string(BACKUPMON->activeWorkspace) : "name:" + g_pCompositor->getWorkspaceByID(BACKUPMON->activeWorkspace)->m_szName;
+
+    // snap cursor
+    wlr_cursor_warp(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, BACKUPMON->vecPosition.x + BACKUPMON->vecTransformedSize.x / 2.f, BACKUPMON->vecPosition.y + BACKUPMON->vecTransformedSize.y / 2.f);
+
+    // move workspaces
+    std::deque<CWorkspace*> wspToMove;
+    for (auto& w : g_pCompositor->m_vWorkspaces) {
+        if (w->m_iMonitorID == ID) {
+            wspToMove.push_back(w.get());
+        }
+    }
+
+    for (auto& w : wspToMove) {
+        g_pCompositor->moveWorkspaceToMonitor(w, BACKUPMON);
+        w->startAnim(true, true, true);
+    }
+
+    activeWorkspace = -1;
+
+    wlr_output_damage_destroy(damage);
+
+    wlr_output_layout_remove(g_pCompositor->m_sWLROutputLayout, output);
+
+    wlr_output_enable(output, false);
+
+    wlr_output_commit(output);
+
+    g_pCompositor->m_vWorkspaces.erase(std::remove_if(g_pCompositor->m_vWorkspaces.begin(), g_pCompositor->m_vWorkspaces.end(), [&](std::unique_ptr<CWorkspace>& el) { return el->m_iMonitorID == ID; }));
+
+    Debug::log(LOG, "Removed monitor %s!", szName.c_str());
+
+    g_pEventManager->postEvent(SHyprIPCEvent{"monitorremoved", szName});
+
+    g_pCompositor->m_vMonitors.erase(std::remove_if(g_pCompositor->m_vMonitors.begin(), g_pCompositor->m_vMonitors.end(), [&](std::shared_ptr<CMonitor>& el) { return el.get() == this; }));
+}

src/helpers/Monitor.hpp

@@ -3,10 +3,12 @@
 #include "../defines.hpp"
 #include <deque>
 #include "WLClasses.hpp"
-#include <list>
+#include <vector>
 #include <array>
+#include <memory>
 
-struct SMonitor {
+class CMonitor {
+public:
     Vector2D    vecPosition         = Vector2D(0,0);
     Vector2D    vecSize             = Vector2D(0,0);
     Vector2D    vecPixelSize        = Vector2D(0,0);
@@ -30,6 +32,7 @@ struct SMonitor {
     int         framesToSkip    = 0;
     int         forceFullFrames = 0;
     bool        noFrameSchedule = false;
+    bool        scheduledRecalc = false;
     wl_output_transform transform = WL_OUTPUT_TRANSFORM_NORMAL;
 
     // for the special workspace
@@ -38,7 +41,7 @@ struct SMonitor {
     // Double-linked list because we need to have constant mem addresses for signals
     // We have to store pointers and use raw new/delete because they might be moved between them
     // and I am lazy
-    std::array<std::list<SLayerSurface*>, 4>   m_aLayerSurfaceLists;
+    std::array<std::vector<std::unique_ptr<SLayerSurface>>, 4>   m_aLayerSurfaceLists;
 
     DYNLISTENER(monitorFrame);
     DYNLISTENER(monitorDestroy);
@@ -49,9 +52,17 @@ struct SMonitor {
     wlr_ext_workspace_group_handle_v1* pWLRWorkspaceGroupHandle = nullptr;
 
 
+    // methods
+    void        onConnect(bool noRule);
+    void        onDisconnect();
+
+    std::shared_ptr<CMonitor>* m_pThisWrap = nullptr;
+    bool        m_bEnabled = false;
+    bool        m_bRenderingInitPassed = false;
+
     // For the list lookup
 
-    bool operator==(const SMonitor& rhs) {
+    bool operator==(const CMonitor& rhs) {
         return vecPosition == rhs.vecPosition && vecSize == rhs.vecSize && szName == rhs.szName;
     }
 };

src/helpers/Splashes.hpp

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <array>
+#include <string>
+
+inline const std::vector<std::string> SPLASHES = {
+    "Woo, animations!",
+    "It's like Hypr, but better.",
+    "Release 1.0 when?",
+    "It's not awesome, it's Hyprland!",
+    "\"I commit too often, people can't catch up lmao\" - Vaxry",
+    "This text is random.",
+    "\"There are reasons to not use rust.\" - Boga",
+    "Read the wiki.",
+    "\"Hello everyone this is YOUR daily dose of ‘read the wiki’\" - Vaxry",
+    "h",
+    "\"‘why no work’, bro I haven't hacked your pc to get live feeds yet\" - Vaxry",
+    "Compile, wait for 20 minutes, notice a new commit, compile again.",
+    "To rice, or not to rice, that is the question.",
+    "Now available on Fedora!",
+    // music reference / quote section
+    "J'remue le ciel, le jour, la nuit.",
+    "aezakmi, aezakmi, aezakmi, aezakmi, aezakmi, aezakmi, aezakmi!",
+    "Wir sind schon sehr lang zusammen...",
+    "I see a red door and I want it painted black.",
+    "Take on me, take me on...",
+    "You spin me right round baby right round",
+    "Stayin' alive, stayin' alive",
+    "Say no way, say no way ya, no way!",
+    "Ground control to Major Tom...",
+    "Alors on danse",
+    "And all that I can see, is just a yellow lemon tree.",
+    "Got a one-way ticket to the blues",
+    "Is this the real life, is this just fantasy",
+    "What's in your head, in your head?",
+    "We're all living in America, America, America.",
+    "I'm still standing, better than I ever did",
+    "Here comes the sun, bringing you love and shining on everyone",
+    "Two trailer park girls go round the outside",
+    "With the lights out, it's less dangerous",
+    "Here we go back, this is the moment, tonight is the night",
+    "Now you're just somebody that I used to know...",
+    "Black bird, black moon, black sky",
+    "Some legends are told, some turn to dust or to gold",
+    "Your brain gets smart, but your head gets dumb.",
+    "Save your mercy for someone who needs it more",
+    "You're gonna hear my voice when I shout it out loud",
+    "Ding ding pch n daa, bam-ba-ba-re-bam baram bom bom baba-bam-bam-bommm",
+    "Súbeme la radio que esta es mi canción",
+    "I'm beggin', beggin' you",
+    //
+    "Join the discord server!",
+    "Thanks ThatOneCalculator!",
+    "The AUR packages always work, except for the times they don't.",
+    "Funny animation compositor woo"
+};

src/helpers/SubsurfaceTree.cpp

@@ -21,9 +21,7 @@ void addSurfaceGlobalOffset(SSurfaceTreeNode* node, int* lx, int* ly) {
 }
 
 SSurfaceTreeNode* createTree(wlr_surface* pSurface, CWindow* pWindow) {
-    SubsurfaceTree::surfaceTreeNodes.push_back(SSurfaceTreeNode());
-
-    const auto PNODE = &SubsurfaceTree::surfaceTreeNodes.back();
+    const auto PNODE = &SubsurfaceTree::surfaceTreeNodes.emplace_back();
 
     PNODE->pSurface = pSurface;
     PNODE->pWindowOwner = pWindow;
@@ -128,8 +126,7 @@ void Events::listener_newSubsurfaceNode(void* owner, void* data) {
 
     const auto PSUBSURFACE = (wlr_subsurface*)data;
 
-    pNode->childSubsurfaces.push_back(SSubsurface());
-    const auto PNEWSUBSURFACE = &pNode->childSubsurfaces.back();
+    const auto PNEWSUBSURFACE = &pNode->childSubsurfaces.emplace_back();
 
     Debug::log(LOG, "Added a new subsurface %x", PSUBSURFACE);
 
@@ -171,12 +168,14 @@ void Events::listener_unmapSubsurface(void* owner, void* data) {
         addSurfaceGlobalOffset(PNODE, &lx, &ly);
 
         wlr_box extents = {0};
-        wlr_surface_get_extends(PNODE->pSurface, &extents);
+        if (PNODE->pSurface) {
+            wlr_surface_get_extends(PNODE->pSurface, &extents);
 
-        extents.x += lx;
-        extents.y += ly;
+            extents.x += lx;
+            extents.y += ly;
 
-        g_pHyprRenderer->damageBox(&extents);
+            g_pHyprRenderer->damageBox(&extents);
+        }
 
         SubsurfaceTree::destroySurfaceTree(subsurface->pChild);
         subsurface->pChild = nullptr;

src/helpers/WLClasses.cpp

@@ -2,6 +2,6 @@
 #include "../config/ConfigManager.hpp"
 
 SLayerSurface::SLayerSurface() {
-    alpha.create(AVARTYPE_FLOAT, &g_pConfigManager->getConfigValuePtr("animations:fadein_speed")->floatValue, &g_pConfigManager->getConfigValuePtr("animations:fadein")->intValue, &g_pConfigManager->getConfigValuePtr("animations:fadein_curve")->strValue, nullptr, AVARDAMAGE_ENTIRE);
+    alpha.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), nullptr, AVARDAMAGE_ENTIRE);
     alpha.m_pLayer = this;
 }

src/helpers/WLClasses.hpp

@@ -19,15 +19,22 @@ struct SLayerSurface {
     DYNLISTENER(commitLayerSurface);
     DYNLISTENER(newPopup);
 
-    wlr_box                 geometry;
+    wlr_box                 geometry = {0,0,0,0};
     Vector2D                position;
     zwlr_layer_shell_v1_layer layer;
 
+    bool                    mapped = false;
+
     int                     monitorID = -1;
 
+    std::string             szNamespace = "";
+
     CAnimatedVariable       alpha;
     bool                    fadingOut = false;
     bool                    readyToDelete = false;
+    bool                    noProcess = false;
+
+    bool                    forceBlur = false;
 
     // For the list lookup
     bool operator==(const SLayerSurface& rhs) {
@@ -60,6 +67,26 @@ struct SRenderData {
 
     // for custom round values
     int rounding = -1; // -1 means not set
+
+    // for blurring
+    bool blur = false;
+
+    // only for windows, not popups
+    bool squishOversized = true;
+};
+
+struct SExtensionFindingData {
+    Vector2D origin;
+    Vector2D vec;
+    wlr_surface** found;
+};
+
+struct SStringRuleNames {
+    std::string layout = "";
+    std::string model = "";
+    std::string variant = "";
+    std::string options = "";
+    std::string rules = "";
 };
 
 struct SKeyboard {
@@ -67,13 +94,18 @@ struct SKeyboard {
 
     DYNLISTENER(keyboardMod);
     DYNLISTENER(keyboardKey);
+    DYNLISTENER(keyboardKeymap);
     DYNLISTENER(keyboardDestroy);
 
+    bool isVirtual = false;
     bool active = false;
 
-    std::string name = "";
+    xkb_layout_index_t activeLayout = 0;
 
-    xkb_rule_names currentRules = {0};
+    std::string name = "";
+    std::string xkbFilePath = "";
+
+    SStringRuleNames currentRules;
     int repeatRate = 0;
     int repeatDelay = 0;
     int numlockOn = -1;
@@ -94,6 +126,8 @@ struct SMouse {
 
     std::string name = "";
 
+    bool        virt = false;
+
     DYNLISTENER(commitConstraint);
     DYNLISTENER(destroyMouse);
 
@@ -114,18 +148,19 @@ struct SConstraint {
     }
 };
 
-struct SMonitor;
+class CMonitor;
 
 struct SXDGPopup {
     CWindow*        parentWindow = nullptr;
     SXDGPopup*      parentPopup = nullptr;
     wlr_xdg_popup*  popup = nullptr;
-    SMonitor*       monitor = nullptr;
+    CMonitor*       monitor = nullptr;
 
     DYNLISTENER(newPopupFromPopupXDG);
     DYNLISTENER(destroyPopupXDG);
     DYNLISTENER(mapPopupXDG);
     DYNLISTENER(unmapPopupXDG);
+    DYNLISTENER(commitPopupXDG);
 
     double lx;
     double ly;
@@ -221,3 +256,65 @@ struct STabletPad {
         return wlrTabletPadV2 == b.wlrTabletPadV2;
     }
 };
+
+struct SIdleInhibitor {
+    wlr_idle_inhibitor_v1* pWlrInhibitor = nullptr;
+    CWindow* pWindow = nullptr;
+
+    DYNLISTENER(Destroy);
+
+    bool operator==(const SIdleInhibitor& b) {
+        return pWlrInhibitor == b.pWlrInhibitor;
+    }
+};
+
+struct SSwipeGesture {
+    CWorkspace*  pWorkspaceBegin = nullptr;
+
+    double       delta = 0;
+
+    float        avgSpeed = 0;
+    int          speedPoints = 0;
+
+    CMonitor*    pMonitor = nullptr;
+};
+
+struct STextInput {
+    wlr_text_input_v3* pWlrInput = nullptr;
+
+    wlr_surface* pPendingSurface = nullptr;
+
+    DYNLISTENER(textInputEnable);
+    DYNLISTENER(textInputDisable);
+    DYNLISTENER(textInputCommit);
+    DYNLISTENER(textInputDestroy);
+
+    DYNLISTENER(pendingSurfaceDestroy);
+};
+
+struct SIMEKbGrab {
+    wlr_input_method_keyboard_grab_v2* pWlrKbGrab = nullptr;
+
+    wlr_keyboard* pKeyboard = nullptr;
+
+    DYNLISTENER(grabDestroy);
+};
+
+struct SIMEPopup {
+    wlr_input_popup_surface_v2* pSurface = nullptr;
+
+    int x, y;
+    int realX, realY;
+    bool visible;
+
+    DYNLISTENER(mapPopup);
+    DYNLISTENER(unmapPopup);
+    DYNLISTENER(destroyPopup);
+    DYNLISTENER(commitPopup);
+
+    DYNLISTENER(focusedSurfaceUnmap);
+
+    bool operator==(const SIMEPopup& other) {
+        return pSurface == other.pSurface;
+    }
+};

src/helpers/WLListener.cpp

@@ -4,9 +4,9 @@
 #include "../debug/Log.hpp"
 
 void handleWrapped(wl_listener* listener, void* data) {
-    CHyprWLListener* pListener = wl_container_of(listener, pListener, m_sListener);
+    CHyprWLListener::SWrapper* pWrap = wl_container_of(listener, pWrap, m_sListener);
 
-    pListener->emit(data);
+    pWrap->m_pSelf->emit(data);
 }
 
 CHyprWLListener::CHyprWLListener(wl_signal* pSignal, std::function<void(void*, void*)> callback, void* pOwner) {
@@ -14,7 +14,9 @@ CHyprWLListener::CHyprWLListener(wl_signal* pSignal, std::function<void(void*, v
 }
 
 CHyprWLListener::CHyprWLListener() {
-    ; //
+    m_swWrapper.m_pSelf = this;
+    m_swWrapper.m_sListener.notify = &handleWrapped;
+    wl_list_init(&m_swWrapper.m_sListener.link);
 }
 
 CHyprWLListener::~CHyprWLListener() {
@@ -22,31 +24,28 @@ CHyprWLListener::~CHyprWLListener() {
 }
 
 void CHyprWLListener::removeCallback() {
-    if (m_bIsConnected) {
-        Debug::log(LOG, "Callback %x -> %x, %s removed.", m_pCallback, m_pOwner, m_szAuthor.c_str());
-        wl_list_remove(&m_sListener.link);
+    if (isConnected()) {
+        Debug::log(LOG, "Callback %x -> %x, %s removed.", &m_pCallback, &m_pOwner, m_szAuthor.c_str());
+        wl_list_remove(&m_swWrapper.m_sListener.link);
+        wl_list_init(&m_swWrapper.m_sListener.link);
     }
-
-    m_bIsConnected = false;
 }
 
 bool CHyprWLListener::isConnected() {
-    return m_bIsConnected;
+    return !wl_list_empty(&m_swWrapper.m_sListener.link);
 }
 
 void CHyprWLListener::initCallback(wl_signal* pSignal, std::function<void(void*, void*)> callback, void* pOwner, std::string author) {
-    if (m_bIsConnected)
-        removeCallback();
+    if (isConnected()) {
+        Debug::log(ERR, "Tried to connect a listener twice?!");
+        return;
+    }
 
     m_pOwner = pOwner;
     m_pCallback = callback;
     m_szAuthor = author;
 
-    m_sListener.notify = &handleWrapped;
-
-    m_bIsConnected = true;
-
-    addWLSignal(pSignal, &m_sListener, pOwner, m_szAuthor);
+    addWLSignal(pSignal, &m_swWrapper.m_sListener, pOwner, m_szAuthor);
 }
 
 void CHyprWLListener::emit(void* data) {

src/helpers/WLListener.hpp

@@ -9,18 +9,26 @@ public:
     CHyprWLListener();
     ~CHyprWLListener();
 
+    CHyprWLListener(const CHyprWLListener&) = delete;
+    CHyprWLListener(CHyprWLListener&&) = delete;
+    CHyprWLListener& operator=(const CHyprWLListener&) = delete;
+    CHyprWLListener& operator=(CHyprWLListener&&) = delete;
+
     void initCallback(wl_signal*, std::function<void(void*, void*)>, void* owner, std::string author = "");
 
     void removeCallback();
 
     bool isConnected();
 
-    wl_listener m_sListener;
+    struct SWrapper {
+        wl_listener m_sListener;
+        CHyprWLListener* m_pSelf;
+    };
 
     void emit(void*);
 
 private:
-    bool            m_bIsConnected = false;
+    SWrapper        m_swWrapper;
 
     void*           m_pOwner = nullptr;
 

src/helpers/Workspace.cpp

@@ -26,9 +26,9 @@ CWorkspace::CWorkspace(int monitorID, std::string name, bool special) {
     }
 
     m_vRenderOffset.m_pWorkspace = this;
-    m_vRenderOffset.create(AVARTYPE_VECTOR, &g_pConfigManager->getConfigValuePtr("animations:workspaces_speed")->floatValue, &g_pConfigManager->getConfigValuePtr("animations:workspaces")->intValue, &g_pConfigManager->getConfigValuePtr("animations:workspaces_curve")->strValue, nullptr, AVARDAMAGE_ENTIRE);
+    m_vRenderOffset.create(AVARTYPE_VECTOR, g_pConfigManager->getAnimationPropertyConfig("workspaces"), nullptr, AVARDAMAGE_ENTIRE);
     m_fAlpha.m_pWorkspace = this;
-    m_fAlpha.create(AVARTYPE_FLOAT, &g_pConfigManager->getConfigValuePtr("animations:workspaces_speed")->floatValue, &g_pConfigManager->getConfigValuePtr("animations:workspaces")->intValue, &g_pConfigManager->getConfigValuePtr("animations:workspaces_curve")->strValue, nullptr, AVARDAMAGE_ENTIRE);
+    m_fAlpha.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("workspaces"), nullptr, AVARDAMAGE_ENTIRE);
     m_fAlpha.setValueAndWarp(255.f);
 
     g_pEventManager->postEvent({"createworkspace", m_szName}, true);
@@ -49,7 +49,7 @@ CWorkspace::~CWorkspace() {
 }
 
 void CWorkspace::startAnim(bool in, bool left, bool instant) {
-    const auto ANIMSTYLE = g_pConfigManager->getString("animations:workspaces_style");
+    const auto ANIMSTYLE = m_fAlpha.m_pConfig->pValues->internalStyle;
 
     if (ANIMSTYLE == "fade") {
         m_vRenderOffset.setValueAndWarp(Vector2D(0, 0)); // fix a bug, if switching from slide -> fade.

src/helpers/Workspace.hpp

@@ -28,6 +28,7 @@ public:
     // for animations
     CAnimatedVariable m_vRenderOffset;
     CAnimatedVariable m_fAlpha;
+    bool              m_bForceRendering = false;
 
     // "scratchpad"
     bool            m_bIsSpecialWorkspace = false;

src/hyprerror/HyprError.cpp

@@ -14,7 +14,9 @@ void CHyprError::createQueued() {
 
     const auto PMONITOR = g_pCompositor->m_vMonitors.front().get();
 
-    const auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->vecSize.x, PMONITOR->vecSize.y);
+    const auto FONTSIZE = std::clamp((int)(10.f * (PMONITOR->vecPixelSize.x / 1920.f)), 8, 40);
+
+    const auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
 
     const auto CAIRO = cairo_create(CAIROSURFACE);
 
@@ -27,12 +29,12 @@ void CHyprError::createQueued() {
     const auto LINECOUNT = 1 + std::count(m_szQueued.begin(), m_szQueued.end(), '\n');
 
     cairo_set_source_rgba(CAIRO, m_cQueued.r / 255.f, m_cQueued.g / 255.f, m_cQueued.b / 255.f, m_cQueued.a / 255.f);
-    cairo_rectangle(CAIRO, 0, 0, PMONITOR->vecSize.x, 10 * LINECOUNT);
+    cairo_rectangle(CAIRO, 0, 0, PMONITOR->vecPixelSize.x, (FONTSIZE + 2 * (FONTSIZE / 10.f)) * LINECOUNT);
 
     // outline
-    cairo_rectangle(CAIRO, 0, 0, 1, PMONITOR->vecSize.y); // left
-    cairo_rectangle(CAIRO, PMONITOR->vecSize.x - 1, 0, PMONITOR->vecSize.x, PMONITOR->vecSize.y);  // right
-    cairo_rectangle(CAIRO, 0, PMONITOR->vecSize.y - 1, PMONITOR->vecSize.x, PMONITOR->vecSize.y);  // bottom
+    cairo_rectangle(CAIRO, 0, 0, 1, PMONITOR->vecPixelSize.y);                                     // left
+    cairo_rectangle(CAIRO, PMONITOR->vecPixelSize.x - 1, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);  // right
+    cairo_rectangle(CAIRO, 0, PMONITOR->vecPixelSize.y - 1, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);  // bottom
 
     cairo_fill(CAIRO);
 
@@ -40,10 +42,10 @@ void CHyprError::createQueued() {
     const CColor textColor = m_cQueued.r * m_cQueued.g * m_cQueued.b < 0.5f ? CColor(255, 255, 255, 255) : CColor(0, 0, 0, 255);
 
     cairo_select_font_face(CAIRO, "Noto Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
-    cairo_set_font_size(CAIRO, 8);
+    cairo_set_font_size(CAIRO, FONTSIZE);
     cairo_set_source_rgba(CAIRO, textColor.r / 255.f, textColor.g / 255.f, textColor.b / 255.f, textColor.a / 255.f);
 
-    float yoffset = 8;
+    float yoffset = FONTSIZE;
     while(m_szQueued != "") {
         std::string current = m_szQueued.substr(0, m_szQueued.find('\n'));
         if (const auto NEWLPOS = m_szQueued.find('\n'); NEWLPOS != std::string::npos)
@@ -52,7 +54,7 @@ void CHyprError::createQueued() {
             m_szQueued = "";
         cairo_move_to(CAIRO, 0, yoffset);
         cairo_show_text(CAIRO, current.c_str());
-        yoffset += 9;
+        yoffset += FONTSIZE + (FONTSIZE / 10.f);
     }
     
 
@@ -70,7 +72,7 @@ void CHyprError::createQueued() {
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
     #endif
     
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->vecSize.x, PMONITOR->vecSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
 
     // delete cairo
     cairo_destroy(CAIRO);
@@ -104,7 +106,7 @@ void CHyprError::draw() {
     if (g_pHyprOpenGL->m_RenderData.pMonitor != PMONITOR)
         return; // wrong mon
 
-    wlr_box windowBox = {0, 0, PMONITOR->vecSize.x, PMONITOR->vecSize.y};
+    wlr_box windowBox = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
 
     g_pHyprOpenGL->renderTexture(m_tTexture, &windowBox, 255.f, 0);
 }

src/includes.hpp

@@ -32,6 +32,7 @@
 #define class _class
 #define namespace _namespace
 #define static
+#define delete delete_
 
 extern "C" {
 #include <wlr/backend.h>
@@ -74,6 +75,7 @@ extern "C" {
 #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/types/wlr_idle_inhibit_v1.h>
 #include <wlr/util/log.h>
 #include <wlr/xwayland.h>
 #include <wlr/util/region.h>
@@ -91,8 +93,14 @@ extern "C" {
 #include <wlr/types/wlr_xdg_foreign_registry.h>
 #include <wlr/types/wlr_xdg_foreign_v1.h>
 #include <wlr/types/wlr_xdg_foreign_v2.h>
+#include <wlr/types/wlr_pointer_gestures_v1.h>
+#include <wlr/types/wlr_output_power_management_v1.h>
+#include <wlr/types/wlr_input_method_v2.h>
+#include <wlr/types/wlr_text_input_v3.h>
+#include <wlr/types/wlr_touch.h>
 }
 
+#undef delete
 #undef class
 #undef namespace
 #undef static
@@ -118,4 +126,5 @@ extern "C" {
 
 #include "ext-workspace-unstable-v1-protocol.h"
 
-#include <algorithm>
+#include <algorithm>
+#include <utility>

src/layout/DwindleLayout.cpp

@@ -1,51 +1,36 @@
 #include "DwindleLayout.hpp"
 #include "../Compositor.hpp"
 
-void SDwindleNodeData::recalcSizePosRecursive() {
-
-    // check the group, if we are in one and not active, ignore.
-    if (pGroupParent && pGroupParent->groupMembers[pGroupParent->groupMemberActive] != this) {
-        if (pWindow)
-            pWindow->m_bHidden = true;
-        return;
-    } else {
-        if (pWindow)
-            pWindow->m_bHidden = false;
-    }
-
-    if (pGroupParent) {
-        // means we are in a group and focused. let's just act like the full window in this
-        size = pGroupParent->size;
-        position = pGroupParent->position;
-    }
-
+void SDwindleNodeData::recalcSizePosRecursive(bool force) {
     if (children[0]) {
 
         const auto REVERSESPLITRATIO = 2.f - splitRatio;
 
-        if (g_pConfigManager->getInt("dwindle:preserve_split") == 0)
-            splitTop = size.y > size.x;
+        if (g_pConfigManager->getInt("dwindle:preserve_split") == 0) {
+            const auto WIDTHMULTIPLIER = g_pConfigManager->getFloat("dwindle:split_width_multiplier");
+            splitTop = size.y * WIDTHMULTIPLIER > size.x;
+        }
 
         const auto SPLITSIDE = !splitTop;
 
         if (SPLITSIDE) {
-            // split sidey
+            // split left/right
             children[0]->position = position;
             children[0]->size = Vector2D(size.x / 2.f * splitRatio, size.y);
             children[1]->position = Vector2D(position.x + size.x / 2.f * splitRatio, position.y);
             children[1]->size = Vector2D(size.x / 2.f * REVERSESPLITRATIO, size.y);
         } else {
-            // split toppy bottomy
+            // split top/bottom
             children[0]->position = position;
             children[0]->size = Vector2D(size.x, size.y / 2.f * splitRatio);
             children[1]->position = Vector2D(position.x, position.y + size.y / 2.f * splitRatio);
             children[1]->size = Vector2D(size.x, size.y / 2.f * REVERSESPLITRATIO);
         }
 
-        children[0]->recalcSizePosRecursive();
-        children[1]->recalcSizePosRecursive();
+        children[0]->recalcSizePosRecursive(force);
+        children[1]->recalcSizePosRecursive(force);
     } else {
-        layout->applyNodeDataToWindow(this);
+        layout->applyNodeDataToWindow(this, force);
     }
 }
 
@@ -58,10 +43,55 @@ void SDwindleNodeData::getAllChildrenRecursive(std::deque<SDwindleNodeData*>* pD
     }
 }
 
+bool SDwindleNodeData::isGroupMember() {
+    return pNextGroupMember && pNextGroupMember != this;
+}
+
+SDwindleNodeData* SDwindleNodeData::getGroupHead() {
+    SDwindleNodeData* current = this->pNextGroupMember;
+
+    while (current != this) {
+        if (current->groupHead) {
+            return current;
+        }
+
+        current = current->pNextGroupMember;
+    }
+
+    this->groupHead = true;
+
+    return this;
+}
+
+SDwindleNodeData* SDwindleNodeData::getGroupVisible() {
+    SDwindleNodeData* current = this->pNextGroupMember;
+
+    while (current != this) {
+        if (!current->pWindow->m_bHidden) {
+            return current;
+        }
+
+        current = current->pNextGroupMember;
+    }
+
+    return this;
+}
+
+void SDwindleNodeData::setGroupFocusedNode(SDwindleNodeData* pMember) {
+    SDwindleNodeData* current = this->pNextGroupMember;
+
+    while (current != this) {
+        current->pWindow->m_bHidden = current != pMember;
+        current = current->pNextGroupMember;
+    }
+
+    this->pWindow->m_bHidden = pMember != this;
+}
+
 int CHyprDwindleLayout::getNodesOnWorkspace(const int& id) {
     int no = 0;
     for (auto& n : m_lDwindleNodesData) {
-        if (n.workspaceID == id)
+        if (n.workspaceID == id && n.valid)
             ++no;
     }
     return no;
@@ -92,12 +122,12 @@ SDwindleNodeData* CHyprDwindleLayout::getMasterNodeOnWorkspace(const int& id) {
     return nullptr;
 }
 
-void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode) {
+void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool force) {
     // Don't set nodes, only windows.
     if (pNode->isNode) 
         return;
 
-    SMonitor* PMONITOR = nullptr;
+    CMonitor* PMONITOR = nullptr;
 
     if (pNode->workspaceID == SPECIAL_WORKSPACE_ID) {
         for (auto& m : g_pCompositor->m_vMonitors) {
@@ -127,7 +157,7 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode) {
 
     const auto PWINDOW = pNode->pWindow;
 
-    if (!g_pCompositor->windowValidMapped(PWINDOW)) {
+    if (!g_pCompositor->windowExists(PWINDOW) || !PWINDOW->m_bIsMapped) {
         Debug::log(ERR, "Node %x holding invalid window %x!!", pNode, PWINDOW);
         return;
     }
@@ -135,9 +165,26 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode) {
     PWINDOW->m_vSize = pNode->size;
     PWINDOW->m_vPosition = pNode->position;
 
+    static auto *const PNOGAPSWHENONLY = &g_pConfigManager->getConfigValuePtr("dwindle:no_gaps_when_only")->intValue;
+
     auto calcPos = PWINDOW->m_vPosition + Vector2D(BORDERSIZE, BORDERSIZE);
     auto calcSize = PWINDOW->m_vSize - Vector2D(2 * BORDERSIZE, 2 * BORDERSIZE);
 
+    if (*PNOGAPSWHENONLY && PWINDOW->m_iWorkspaceID != SPECIAL_WORKSPACE_ID && getNodesOnWorkspace(PWINDOW->m_iWorkspaceID) == 1) {
+        PWINDOW->m_vRealPosition = calcPos - Vector2D(BORDERSIZE, BORDERSIZE);
+        PWINDOW->m_vRealSize = calcSize + Vector2D(2 * BORDERSIZE, 2 * BORDERSIZE);
+
+        PWINDOW->updateWindowDecos();
+
+        PWINDOW->m_sSpecialRenderData.rounding = false;
+        PWINDOW->m_sSpecialRenderData.border = false;
+
+        return;
+    }
+
+    PWINDOW->m_sSpecialRenderData.rounding = true;
+    PWINDOW->m_sSpecialRenderData.border = true;
+
     const auto OFFSETTOPLEFT = Vector2D(DISPLAYLEFT ? GAPSOUT : GAPSIN,
                                         DISPLAYTOP ? GAPSOUT : GAPSIN);
 
@@ -186,6 +233,19 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode) {
         g_pXWaylandManager->setWindowSize(PWINDOW, calcSize);
     }
 
+    if (force) {
+        PWINDOW->m_vRealPosition.warp();
+        PWINDOW->m_vRealSize.warp();
+    }
+
+    if (pNode->isGroupMember() && pNode->groupHead) {
+        // update visible node
+        const auto PVISNODE = pNode->getGroupVisible();
+
+        PVISNODE->pWindow->m_vRealSize = PWINDOW->m_vRealSize.goalv();
+        PVISNODE->pWindow->m_vRealPosition = PWINDOW->m_vRealPosition.goalv();
+    }
+
     PWINDOW->updateWindowDecos();
 }
 
@@ -198,6 +258,8 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
 
     const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
 
+    static auto *const PUSEACTIVE = &g_pConfigManager->getConfigValuePtr("dwindle:use_active_for_splits")->intValue;
+
     // Populate the node with our window's data
     PNODE->workspaceID = pWindow->m_iWorkspaceID;
     PNODE->pWindow = pWindow;
@@ -207,15 +269,24 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
     SDwindleNodeData* OPENINGON;
     const auto MONFROMCURSOR = g_pCompositor->getMonitorFromCursor();
 
-    if (PMONITOR->ID == MONFROMCURSOR->ID && (PNODE->workspaceID == PMONITOR->activeWorkspace || (PNODE->workspaceID == SPECIAL_WORKSPACE_ID && PMONITOR->specialWorkspaceOpen))) {
+    if (PMONITOR->ID == MONFROMCURSOR->ID && (PNODE->workspaceID == PMONITOR->activeWorkspace || (PNODE->workspaceID == SPECIAL_WORKSPACE_ID && PMONITOR->specialWorkspaceOpen)) && !*PUSEACTIVE) {
         OPENINGON = getNodeFromWindow(g_pCompositor->vectorToWindowTiled(g_pInputManager->getMouseCoordsInternal()));
 
         // happens on reserved area
         if (!OPENINGON && g_pCompositor->getWindowsOnWorkspace(PNODE->workspaceID) > 0)
             OPENINGON = getFirstNodeOnWorkspace(PMONITOR->activeWorkspace);
             
+    } else if (*PUSEACTIVE) {
+        if (g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow) && !g_pCompositor->m_pLastWindow->m_bIsFloating && g_pCompositor->m_pLastWindow != pWindow && g_pCompositor->m_pLastWindow->m_iWorkspaceID == pWindow->m_iWorkspaceID && g_pCompositor->m_pLastWindow->m_bIsMapped) {
+            OPENINGON = getNodeFromWindow(g_pCompositor->m_pLastWindow);
+        } else {
+            OPENINGON = getNodeFromWindow(g_pCompositor->vectorToWindowTiled(g_pInputManager->getMouseCoordsInternal()));
+        }
+
+        if (!OPENINGON && g_pCompositor->getWindowsOnWorkspace(PNODE->workspaceID) > 0)
+            OPENINGON = getFirstNodeOnWorkspace(PMONITOR->activeWorkspace);
     } else
-        OPENINGON = getFirstNodeOnWorkspace(PMONITOR->activeWorkspace);
+        OPENINGON = getFirstNodeOnWorkspace(pWindow->m_iWorkspaceID);
 
     Debug::log(LOG, "OPENINGON: %x, Workspace: %i, Monitor: %i", OPENINGON, PNODE->workspaceID, PMONITOR->ID);
 
@@ -224,6 +295,16 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
         OPENINGON = getFirstNodeOnWorkspace(PNODE->workspaceID);
     }
 
+    // first, check if OPENINGON isn't too big.
+    const auto PREDSIZEMAX = OPENINGON ? Vector2D(OPENINGON->size.x, OPENINGON->size.y) : PMONITOR->vecSize;
+    if (const auto MAXSIZE = g_pXWaylandManager->getMaxSizeForWindow(pWindow); MAXSIZE.x < PREDSIZEMAX.x || MAXSIZE.y < PREDSIZEMAX.y) {
+        // we can't continue. make it floating.
+        pWindow->m_bIsFloating = true;
+        m_lDwindleNodesData.remove(*PNODE);
+        g_pLayoutManager->getCurrentLayout()->onWindowCreatedFloating(pWindow);
+        return;
+    }
+
     // if it's the first, it's easy. Make it fullscreen.
     if (!OPENINGON || OPENINGON->pWindow == pWindow) {
         PNODE->position = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
@@ -233,6 +314,28 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
 
         return;
     }
+
+    // if it's a group, add the window
+    if (OPENINGON->isGroupMember()) {
+        const auto PHEAD = OPENINGON->getGroupHead();
+
+        const auto PTAIL = PHEAD->pPreviousGroupMember;
+
+        PHEAD->pPreviousGroupMember = PNODE;
+        PTAIL->pNextGroupMember = PNODE;
+
+        PNODE->pNextGroupMember = PHEAD;
+        PNODE->pPreviousGroupMember = PTAIL;
+
+        PHEAD->setGroupFocusedNode(PNODE);
+
+        PNODE->position = PHEAD->position;
+        PNODE->size = PHEAD->size;
+
+        applyNodeDataToWindow(PNODE);
+
+        return;
+    }
     
     // If it's not, get the node under our cursor
 
@@ -246,16 +349,19 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
     NEWPARENT->pParent = OPENINGON->pParent;
     NEWPARENT->isNode = true; // it is a node
 
+    const auto WIDTHMULTIPLIER = g_pConfigManager->getFloat("dwindle:split_width_multiplier");
+
     // if cursor over first child, make it first, etc
-    const auto SIDEBYSIDE = NEWPARENT->size.x / NEWPARENT->size.y > 1.f;
+    const auto SIDEBYSIDE = NEWPARENT->size.x > NEWPARENT->size.y * WIDTHMULTIPLIER;
     NEWPARENT->splitTop = !SIDEBYSIDE;
+
     const auto MOUSECOORDS = g_pInputManager->getMouseCoordsInternal();
 
     const auto FORCESPLIT = g_pConfigManager->getInt("dwindle:force_split");
 
     if (FORCESPLIT == 0) {
-        if ((SIDEBYSIDE && VECINRECT(MOUSECOORDS, NEWPARENT->position.x, NEWPARENT->position.y, NEWPARENT->position.x + NEWPARENT->size.x / 2.f, NEWPARENT->position.y + NEWPARENT->size.y))
-        || (!SIDEBYSIDE && VECINRECT(MOUSECOORDS, NEWPARENT->position.x, NEWPARENT->position.y, NEWPARENT->position.x + NEWPARENT->size.x, NEWPARENT->position.y + NEWPARENT->size.y / 2.f))) {
+        if ((SIDEBYSIDE && VECINRECT(MOUSECOORDS, NEWPARENT->position.x, NEWPARENT->position.y / WIDTHMULTIPLIER, NEWPARENT->position.x + NEWPARENT->size.x / 2.f, NEWPARENT->position.y + NEWPARENT->size.y))
+        || (!SIDEBYSIDE && VECINRECT(MOUSECOORDS, NEWPARENT->position.x, NEWPARENT->position.y / WIDTHMULTIPLIER, NEWPARENT->position.x + NEWPARENT->size.x, NEWPARENT->position.y + NEWPARENT->size.y / 2.f))) {
             // we are hovering over the first node, make PNODE first.
             NEWPARENT->children[1] = OPENINGON;
             NEWPARENT->children[0] = PNODE;
@@ -284,14 +390,16 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
     }
 
     // Update the children
-    if (NEWPARENT->size.x > NEWPARENT->size.y) {
-        // split sidey
+    
+
+    if (NEWPARENT->size.x * WIDTHMULTIPLIER > NEWPARENT->size.y) {
+        // split left/right
         OPENINGON->position = NEWPARENT->position;
         OPENINGON->size = Vector2D(NEWPARENT->size.x / 2.f, NEWPARENT->size.y);
         PNODE->position = Vector2D(NEWPARENT->position.x + NEWPARENT->size.x / 2.f, NEWPARENT->position.y);
         PNODE->size = Vector2D(NEWPARENT->size.x / 2.f, NEWPARENT->size.y);
     } else {
-        // split toppy bottomy
+        // split top/bottom
         OPENINGON->position = NEWPARENT->position;
         OPENINGON->size = Vector2D(NEWPARENT->size.x, NEWPARENT->size.y / 2.f);
         PNODE->position = Vector2D(NEWPARENT->position.x, NEWPARENT->position.y + NEWPARENT->size.y / 2.f);
@@ -301,35 +409,66 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
     OPENINGON->pParent = NEWPARENT;
     PNODE->pParent = NEWPARENT;
 
-    if (OPENINGON->pGroupParent) {
-        // means we opened on a group
+    NEWPARENT->recalcSizePosRecursive();
 
-        // add the group deco
-        pWindow->m_dWindowDecorations.emplace_back(std::make_unique<CHyprGroupBarDecoration>(pWindow));
-
-        PNODE->pGroupParent = OPENINGON->pGroupParent;
-        PNODE->pGroupParent->groupMembers.push_back(PNODE);
-        PNODE->pGroupParent->groupMemberActive = PNODE->pGroupParent->groupMembers.size() - 1;
-
-        PNODE->pGroupParent->recalcSizePosRecursive();
-    } else {
-        NEWPARENT->recalcSizePosRecursive();
-
-        applyNodeDataToWindow(PNODE);
-        applyNodeDataToWindow(OPENINGON);
-    }
+    applyNodeDataToWindow(PNODE);
+    applyNodeDataToWindow(OPENINGON);
 }
 
 void CHyprDwindleLayout::onWindowRemovedTiling(CWindow* pWindow) {
 
     const auto PNODE = getNodeFromWindow(pWindow);
 
-    if (!PNODE)
+    if (!PNODE) {
+        Debug::log(ERR, "onWindowRemovedTiling node null?");
         return;
+    }
+
+    // check if it was grouped
+    if (PNODE->isGroupMember()) {
+        // get shit
+        const auto PPREV = PNODE->pPreviousGroupMember;
+        const auto PNEXT = PNODE->pNextGroupMember;
+
+        PPREV->pNextGroupMember = PNEXT;
+        PNEXT->pPreviousGroupMember = PPREV;
+
+        if (PNODE->groupHead) {
+            PNEXT->groupHead = true;
+            PNEXT->pParent = PNODE->pParent;
+            
+            if (PNODE->pParent) {
+                if (PNODE->pParent->children[0] == PNODE) {
+                    PNODE->pParent->children[0] = PNEXT;
+                } else {
+                    PNODE->pParent->children[1] = PNEXT;
+                }
+            }
+
+            PNEXT->position = PNODE->position;
+            PNEXT->size = PNODE->size;
+
+            applyNodeDataToWindow(PNEXT);
+        } else {
+            const auto PHEAD = PNODE->getGroupHead();
+
+            PNEXT->position = PHEAD->position;
+            PNEXT->size = PHEAD->size;
+
+            applyNodeDataToWindow(PNEXT);
+        }
+
+        PNEXT->setGroupFocusedNode(PNEXT);
+        PNEXT->pWindow->m_bHidden = false;
+
+        m_lDwindleNodesData.remove(*PNODE);
+        return;
+    }
 
     const auto PPARENT = PNODE->pParent;
 
     if (!PPARENT) {
+        Debug::log(LOG, "Removing last node (dwindle)");
         m_lDwindleNodesData.remove(*PNODE);
         return;
     }
@@ -348,28 +487,8 @@ void CHyprDwindleLayout::onWindowRemovedTiling(CWindow* pWindow) {
         }
     }
 
-    // check if it was grouped
-    if (PNODE->pGroupParent) {
-        PNODE->pGroupParent->groupMembers.erase(PNODE->pGroupParent->groupMembers.begin() + PNODE->pGroupParent->groupMemberActive);
-
-        if ((long unsigned int)PNODE->pGroupParent->groupMemberActive >= PNODE->pGroupParent->groupMembers.size())
-            PNODE->pGroupParent->groupMemberActive = 0;
-
-        if (PNODE->pGroupParent->groupMembers.size() <= 1) {
-            PNODE->pGroupParent->isGroup = false;
-            PSIBLING->pGroupParent = nullptr;
-            PNODE->pGroupParent->groupMembers.clear();
-
-            PSIBLING->recalcSizePosRecursive();
-        } else {
-            PNODE->pGroupParent->recalcSizePosRecursive();
-        }
-
-        // if the parent is to be removed, remove the group
-        if (PPARENT == PNODE->pGroupParent) {
-            toggleWindowGroup(PPARENT->groupMembers[PPARENT->groupMemberActive]->pWindow);
-        }
-    }
+    PPARENT->valid = false;
+    PNODE->valid = false;
 
     if (PSIBLING->pParent)
         PSIBLING->pParent->recalcSizePosRecursive();
@@ -382,11 +501,17 @@ void CHyprDwindleLayout::onWindowRemovedTiling(CWindow* pWindow) {
 
 void CHyprDwindleLayout::recalculateMonitor(const int& monid) {
     const auto PMONITOR = g_pCompositor->getMonitorFromID(monid);
+
+    if (!PMONITOR)
+        return; // ???
+
     const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
 
     if (!PWORKSPACE)
         return;
 
+    g_pHyprRenderer->damageMonitor(PMONITOR);
+
     if (PMONITOR->specialWorkspaceOpen) {
         const auto TOPNODE = getMasterNodeOnWorkspace(SPECIAL_WORKSPACE_ID);
 
@@ -397,9 +522,30 @@ void CHyprDwindleLayout::recalculateMonitor(const int& monid) {
         }
     }
 
-    // Ignore any recalc events if we have a fullscreen window.
-    if (PWORKSPACE->m_bHasFullscreenWindow)
-        return;
+    // Ignore any recalc events if we have a fullscreen window, but process if fullscreen mode 2
+    if (PWORKSPACE->m_bHasFullscreenWindow) {
+        if (PWORKSPACE->m_efFullscreenMode == FULLSCREEN_FULL)
+            return;
+
+        // massive hack from the fullscreen func
+        const auto PFULLWINDOW = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
+
+        if (!PFULLWINDOW) { // ????
+            PWORKSPACE->m_bHasFullscreenWindow = false;
+        } else {
+            SDwindleNodeData fakeNode;
+            fakeNode.pWindow = PFULLWINDOW;
+            fakeNode.position = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
+            fakeNode.size = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight;
+            fakeNode.workspaceID = PWORKSPACE->m_iID;
+            PFULLWINDOW->m_vPosition = fakeNode.position;
+            PFULLWINDOW->m_vSize = fakeNode.size;
+
+            applyNodeDataToWindow(&fakeNode);
+
+            return;
+        }
+    }
 
     const auto TOPNODE = getMasterNodeOnWorkspace(PMONITOR->activeWorkspace);
 
@@ -429,6 +575,8 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, CWindow*
         return;
     }
 
+    const auto PANIMATE = &g_pConfigManager->getConfigValuePtr("misc:animate_manual_resizes")->intValue;
+
     // 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);
@@ -460,11 +608,11 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, CWindow*
         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();
+            PPARENT->recalcSizePosRecursive(*PANIMATE == 0);
         } else {
             allowedMovement.y *= 2.f / PPARENT->size.y;
             PPARENT->splitRatio = std::clamp(PPARENT->splitRatio + allowedMovement.y, (double)0.1f, (double)1.9f);
-            PPARENT->recalcSizePosRecursive();
+            PPARENT->recalcSizePosRecursive(*PANIMATE == 0);
         }
 
         return;
@@ -479,11 +627,11 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, CWindow*
         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();
+            PPARENT->recalcSizePosRecursive(*PANIMATE == 0);
         } else {
             allowedMovement.y *= 2.f / PPARENT->size.y;
             PPARENT->splitRatio = std::clamp(PPARENT->splitRatio + allowedMovement.y, (double)0.1f, (double)1.9f);
-            PPARENT->recalcSizePosRecursive();
+            PPARENT->recalcSizePosRecursive(*PANIMATE == 0);
         }
 
         return;
@@ -498,14 +646,17 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, CWindow*
 
     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();
+    SIDECONTAINER->recalcSizePosRecursive(*PANIMATE == 0);
+    TOPCONTAINER->recalcSizePosRecursive(*PANIMATE == 0);
 }
 
 void CHyprDwindleLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscreenMode fullscreenMode, bool on) {
     if (!g_pCompositor->windowValidMapped(pWindow))
         return;
 
+    if (!g_pCompositor->isWorkspaceVisible(pWindow->m_iWorkspaceID))
+        return;
+
     if (on == pWindow->m_bIsFullscreen)
         return; // ignore
 
@@ -522,6 +673,8 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscree
     pWindow->m_bIsFullscreen = on;
     PWORKSPACE->m_bHasFullscreenWindow = !PWORKSPACE->m_bHasFullscreenWindow;
 
+    g_pEventManager->postEvent(SHyprIPCEvent{"fullscreen", std::to_string((int)on)});
+
     if (!pWindow->m_bIsFullscreen) {
         // if it got its fullscreen disabled, set back its node if it had one
         const auto PNODE = getNodeFromWindow(pWindow);
@@ -564,13 +717,13 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscree
         }
     }
 
+    g_pCompositor->updateWindowAnimatedDecorationValues(pWindow);
+
     g_pXWaylandManager->setWindowSize(pWindow, pWindow->m_vRealSize.goalv());
 
     g_pCompositor->moveWindowToTop(pWindow);
 
-    // we need to fix XWayland windows by sending them to NARNIA
-    // because otherwise they'd still be recieving mouse events
-    g_pCompositor->fixXWaylandWindowsOnWorkspace(PMONITOR->activeWorkspace);
+    recalculateMonitor(PMONITOR->ID);
 }
 
 void CHyprDwindleLayout::recalculateWindow(CWindow* pWindow) {
@@ -582,6 +735,16 @@ void CHyprDwindleLayout::recalculateWindow(CWindow* pWindow) {
     PNODE->recalcSizePosRecursive();
 }
 
+void addToDequeRecursive(std::deque<SDwindleNodeData*>* pDeque, std::deque<SDwindleNodeData*>* pParents, SDwindleNodeData* node) {
+    if (node->isNode) {
+        pParents->push_back(node);
+        addToDequeRecursive(pDeque, pParents, node->children[0]);
+        addToDequeRecursive(pDeque, pParents, node->children[1]);
+    } else {
+        pDeque->emplace_back(node);
+    }
+}
+
 void CHyprDwindleLayout::toggleWindowGroup(CWindow* pWindow) {
     if (!g_pCompositor->windowValidMapped(pWindow))
         return;
@@ -592,60 +755,116 @@ void CHyprDwindleLayout::toggleWindowGroup(CWindow* pWindow) {
     if (!PNODE)
         return; // reject
 
-    const auto PGROUPPARENT = PNODE->pGroupParent;
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PNODE->workspaceID);
 
-    if (PGROUPPARENT) {
-        // if there is a parent, release it
-        const auto INACTIVEBORDERCOL = CColor(g_pConfigManager->getInt("general:col.inactive_border"));
-        for (auto& node : PGROUPPARENT->groupMembers) {
-            node->pGroupParent = nullptr;
-            node->pWindow->m_cRealBorderColor.setValueAndWarp(INACTIVEBORDERCOL); // no anim here because they pop in
+    if (PWORKSPACE->m_bHasFullscreenWindow)
+        fullscreenRequestForWindow(g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID), FULLSCREEN_FULL, false);
 
-            for (auto& wd : node->pWindow->m_dWindowDecorations) {
-                wd->updateWindow(node->pWindow);
-            }
-        }   
+    if (PNODE->isGroupMember()) {
+        // dissolve group
+
+        const auto PHEAD = PNODE->getGroupHead();
+
+        SDwindleNodeData* current = PNODE->pNextGroupMember;
+
+        PNODE->pWindow->m_bIsFloating = PHEAD->pWindow->m_bIsFloating;
+
+        std::deque<CWindow*> toAddWindows;
         
-        PGROUPPARENT->groupMembers.clear();
+        const auto PWINDOWNODE = PNODE->pWindow;
+        toAddWindows.push_back(PWINDOWNODE);
 
-        PGROUPPARENT->isGroup = false;
+        while (current != PNODE) {
+            const auto PWINDOW = current->pWindow;
+            current = current->pNextGroupMember;
 
-        PGROUPPARENT->recalcSizePosRecursive();
+            toAddWindows.push_back(PWINDOW);
 
-        if (g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow))
-            g_pCompositor->m_pLastWindow->m_cRealBorderColor = CColor(g_pConfigManager->getInt("general:col.active_border"));
-    } else {
-        // if there is no parent, let's make one
-
-        const auto PPARENT = PNODE->pParent;
-
-        if (!PPARENT)
-            return; // reject making group on single window
-
-        
-        PPARENT->isGroup = true;
-        
-        // recursively get all members
-        std::deque<SDwindleNodeData*> allChildren;
-        PPARENT->getAllChildrenRecursive(&allChildren);
-
-        PPARENT->groupMembers = allChildren;
-
-        const auto GROUPINACTIVEBORDERCOL = CColor(g_pConfigManager->getInt("dwinle:col.group_border"));
-        for (auto& c : PPARENT->groupMembers) {
-            c->pGroupParent = PPARENT;
-            c->pWindow->m_cRealBorderColor = GROUPINACTIVEBORDERCOL;
-
-            c->pWindow->m_dWindowDecorations.push_back(std::make_unique<CHyprGroupBarDecoration>(c->pWindow));
-
-            if (c->pWindow == g_pCompositor->m_pLastWindow)
-                c->pWindow->m_cRealBorderColor = CColor(g_pConfigManager->getInt("dwindle:col.group_border_active"));
+            PWINDOW->m_bHidden = false;
         }
 
-        PPARENT->groupMemberActive = 0;
+        PHEAD->pPreviousGroupMember = nullptr;
+        PHEAD->pNextGroupMember = nullptr;
+        onWindowRemoved(PHEAD->pWindow);
 
-        PPARENT->recalcSizePosRecursive();
+        for (auto& pw : toAddWindows) {
+            const auto PNODE = getNodeFromWindow(pw);
+            if (PNODE)
+                m_lDwindleNodesData.remove(*PNODE);
+
+            pw->m_vPosition = Vector2D(-1000000, -1000000);
+        }
+
+        for (auto& pw : toAddWindows) {
+            onWindowCreated(pw);
+        }
+
+        recalculateMonitor(PWORKSPACE->m_iMonitorID);
+    } else {
+        // create group
+
+        if (!PNODE->pParent)
+            return;
+
+        PNODE->groupHead = true;
+
+        std::deque<SDwindleNodeData*> newGroupMembers;
+        std::deque<SDwindleNodeData*> nodesToRemove;
+
+        newGroupMembers.emplace_back(PNODE);
+
+        addToDequeRecursive(&newGroupMembers, &nodesToRemove, PNODE->pParent->children[0] == PNODE ? PNODE->pParent->children[1] : PNODE->pParent->children[0]);
+
+        for (auto& n : newGroupMembers) {
+            if (n->isGroupMember())
+                return; // reject nested groups
+        }
+
+        for (auto& nd : nodesToRemove) {
+            m_lDwindleNodesData.remove(*nd);
+        }
+
+        PNODE->position = PNODE->pParent->position;
+        PNODE->size = PNODE->pParent->size;
+
+        applyNodeDataToWindow(PNODE);
+
+        if (PNODE->pParent->pParent) {
+            if (PNODE->pParent->pParent->children[0] == PNODE->pParent) {
+                PNODE->pParent->pParent->children[0] = PNODE;
+            } else {
+                PNODE->pParent->pParent->children[1] = PNODE;
+            }
+        }
+
+        const auto PPARENT2 = PNODE->pParent->pParent;
+
+        m_lDwindleNodesData.remove(*PNODE->pParent);
+
+        PNODE->pParent = PPARENT2;
+
+        // now remove everyone but head from tree
+        // and set order
+        for (int i = 0; i < (int)newGroupMembers.size(); ++i) {
+            if (i != 0) {
+                newGroupMembers[i]->groupHead = false;
+                newGroupMembers[i]->pParent = PNODE->pParent;
+            }
+
+            const auto PREVMEMBER = i == 0 ? newGroupMembers[newGroupMembers.size() - 1] : newGroupMembers[i - 1];
+            const auto NEXTMEMBER = i == (int)newGroupMembers.size() - 1 ? newGroupMembers[0] : newGroupMembers[i + 1];
+
+            newGroupMembers[i]->pPreviousGroupMember = PREVMEMBER;
+            newGroupMembers[i]->pNextGroupMember = NEXTMEMBER;
+        }
+
+        // focus
+        PNODE->setGroupFocusedNode(PNODE);
     }
+
+    g_pCompositor->updateAllWindowsAnimatedDecorationValues();
+
+    g_pInputManager->refocus();
 }
 
 std::deque<CWindow*> CHyprDwindleLayout::getGroupMembers(CWindow* pWindow) {
@@ -661,13 +880,13 @@ std::deque<CWindow*> CHyprDwindleLayout::getGroupMembers(CWindow* pWindow) {
     if (!PNODE)
         return result;  // reject with empty
 
-    const auto PGROUPPARENT = PNODE->pGroupParent;
+    SDwindleNodeData* current = PNODE->pNextGroupMember;
 
-    if (!PGROUPPARENT)
-        return result;  // reject with empty
+    result.push_back(pWindow);
 
-    for (auto& node : PGROUPPARENT->groupMembers) {
-        result.push_back(node->pWindow);
+    while (current != PNODE) {
+        result.push_back(current->pWindow);
+        current = current->pNextGroupMember;
     }
 
     return result;
@@ -679,33 +898,41 @@ void CHyprDwindleLayout::switchGroupWindow(CWindow* pWindow, bool forward) {
 
     const auto PNODE = getNodeFromWindow(pWindow);
 
-    if (!PNODE)
+    if (!PNODE || !PNODE->isGroupMember())
         return; // reject
 
-    if (!PNODE->pGroupParent)
-        return; // reject
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PNODE->workspaceID);
+
+    SDwindleNodeData* pNewNode;
 
     if (forward)
-        PNODE->pGroupParent->groupMemberActive++;
+        pNewNode = PNODE->pNextGroupMember;
     else
-        PNODE->pGroupParent->groupMemberActive--;
+        pNewNode = PNODE->pPreviousGroupMember;
 
-    if (PNODE->pGroupParent->groupMemberActive < 0)
-        PNODE->pGroupParent->groupMemberActive = PNODE->pGroupParent->groupMembers.size() - 1;
+    PNODE->setGroupFocusedNode(pNewNode);
 
-    if ((long unsigned int)PNODE->pGroupParent->groupMemberActive >= PNODE->pGroupParent->groupMembers.size())
-        PNODE->pGroupParent->groupMemberActive = 0;
+    pNewNode->position = PNODE->position;
+    pNewNode->size = PNODE->size;
 
-    PNODE->pGroupParent->recalcSizePosRecursive();
+    applyNodeDataToWindow(pNewNode);
 
-    for (auto& gm : PNODE->pGroupParent->groupMembers) {
-        for (auto& deco : gm->pWindow->m_dWindowDecorations) {
-            deco->updateWindow(gm->pWindow);
-        }
+    pNewNode->pWindow->m_vRealSize.warp();
+    pNewNode->pWindow->m_vRealPosition.warp();
+
+    g_pCompositor->focusWindow(pNewNode->pWindow);
+
+    pNewNode->pWindow->m_bIsFloating = PNODE->pWindow->m_bIsFloating;
+    
+    if (PNODE->pWindow->m_bIsFullscreen) {
+        PNODE->pWindow->m_bHidden = false;
+        g_pCompositor->setWindowFullscreen(PNODE->pWindow, false, PWORKSPACE->m_efFullscreenMode);
+        PNODE->pWindow->m_bHidden = true;
+        g_pCompositor->setWindowFullscreen(pNewNode->pWindow, true, PWORKSPACE->m_efFullscreenMode);
+
+        pNewNode->pWindow->m_vRealSize.warp();
+        pNewNode->pWindow->m_vRealPosition.warp();
     }
-
-    // focus
-    g_pCompositor->focusWindow(PNODE->pGroupParent->groupMembers[PNODE->pGroupParent->groupMemberActive]->pWindow);
 }
 
 SWindowRenderLayoutHints CHyprDwindleLayout::requestRenderHints(CWindow* pWindow) {
@@ -717,7 +944,7 @@ SWindowRenderLayoutHints CHyprDwindleLayout::requestRenderHints(CWindow* pWindow
     if (!PNODE)
         return hints; // left for the future, maybe floating funkiness
 
-    if (PNODE->pGroupParent) {
+    if (PNODE->isGroupMember()) {
         hints.isBorderColor = true;
 
         if (pWindow == g_pCompositor->m_pLastWindow)
@@ -829,4 +1056,17 @@ void CHyprDwindleLayout::toggleSplit(CWindow* pWindow) {
 
 std::string CHyprDwindleLayout::getLayoutName() {
     return "dwindle";
-}
+}
+
+void CHyprDwindleLayout::onEnable() {
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (w->m_bIsFloating || !w->m_bMappedX11 || !w->m_bIsMapped || w->m_bHidden)
+            continue;
+
+        onWindowCreatedTiling(w.get());
+    }
+}
+
+void CHyprDwindleLayout::onDisable() {
+    m_lDwindleNodesData.clear();
+}

src/layout/DwindleLayout.hpp

@@ -18,10 +18,9 @@ struct SDwindleNodeData {
 
     bool            splitTop = false; // for preserve_split
 
-    bool            isGroup = false;
-    int             groupMemberActive = 0;
-    std::deque<SDwindleNodeData*> groupMembers;
-    SDwindleNodeData* pGroupParent = nullptr;
+    bool            groupHead = false;
+    SDwindleNodeData* pNextGroupMember = nullptr;
+    SDwindleNodeData* pPreviousGroupMember = nullptr;
 
     Vector2D        position;
     Vector2D        size;
@@ -30,13 +29,19 @@ struct SDwindleNodeData {
 
     float           splitRatio = 1.f;
 
+    bool            valid = true;
+
     // For list lookup
     bool operator==(const SDwindleNodeData& rhs) {
         return pWindow == rhs.pWindow && workspaceID == rhs.workspaceID && position == rhs.position && size == rhs.size && pParent == rhs.pParent && children[0] == rhs.children[0] && children[1] == rhs.children[1];
     }
 
-    void            recalcSizePosRecursive();
+    void            recalcSizePosRecursive(bool force = false);
     void            getAllChildrenRecursive(std::deque<SDwindleNodeData*>*);
+    bool            isGroupMember();
+    SDwindleNodeData* getGroupHead();
+    SDwindleNodeData* getGroupVisible();
+    void            setGroupFocusedNode(SDwindleNodeData*);
     CHyprDwindleLayout* layout = nullptr;
 };
 
@@ -55,12 +60,15 @@ public:
     virtual void        alterSplitRatioBy(CWindow*, float);
     virtual std::string getLayoutName();
 
+    virtual void        onEnable();
+    virtual void        onDisable();
+
 private:
 
     std::list<SDwindleNodeData>     m_lDwindleNodesData;
 
     int                 getNodesOnWorkspace(const int&);
-    void                applyNodeDataToWindow(SDwindleNodeData*);
+    void                applyNodeDataToWindow(SDwindleNodeData*, bool force = false);
     SDwindleNodeData*   getNodeFromWindow(CWindow*);
     SDwindleNodeData*   getFirstNodeOnWorkspace(const int&);
     SDwindleNodeData*   getMasterNodeOnWorkspace(const int&);

src/layout/IHyprLayout.cpp

@@ -6,6 +6,16 @@ void IHyprLayout::onWindowCreated(CWindow* pWindow) {
     if (pWindow->m_bIsFloating) {
         onWindowCreatedFloating(pWindow);
     } else {
+        wlr_box desiredGeometry = {0};
+        g_pXWaylandManager->getGeometryForWindow(pWindow, &desiredGeometry);
+
+        if (desiredGeometry.width <= 5 || desiredGeometry.height <= 5) {
+            const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+            pWindow->m_vLastFloatingSize = PMONITOR->vecSize / 2.f;
+        } else {
+            pWindow->m_vLastFloatingSize = Vector2D(desiredGeometry.width, desiredGeometry.height);
+        }
+
         onWindowCreatedTiling(pWindow);
     }
 }
@@ -32,11 +42,21 @@ void IHyprLayout::onWindowCreatedFloating(CWindow* pWindow) {
         return;
     }
 
-    if (desiredGeometry.width <= 0 || desiredGeometry.height <= 0) {
+    if (desiredGeometry.width <= 5 || desiredGeometry.height <= 5) {
         const auto PWINDOWSURFACE = g_pXWaylandManager->getWindowSurface(pWindow);
         pWindow->m_vRealSize = Vector2D(PWINDOWSURFACE->current.width, PWINDOWSURFACE->current.height);
-        pWindow->m_vRealPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_vRealSize.vec().x) / 2.f, PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_vRealSize.vec().y) / 2.f);
 
+        if ((desiredGeometry.width <= 1 || desiredGeometry.height <= 1) && pWindow->m_bIsX11 && pWindow->m_iX11Type == 2) { // XDG windows should be fine. TODO: check for weird atoms?
+            pWindow->m_bHidden = true;
+            return;
+        }
+        
+        // reject any windows with size <= 5x5
+        if (pWindow->m_vRealSize.goalv().x <= 5 || pWindow->m_vRealSize.goalv().y <= 5) {
+            pWindow->m_vRealSize = PMONITOR->vecSize / 2.f;
+        }
+
+        pWindow->m_vRealPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_vRealSize.goalv().x) / 2.f, PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_vRealSize.goalv().y) / 2.f);
     } else {
         // we respect the size.
         pWindow->m_vRealSize = Vector2D(desiredGeometry.width, desiredGeometry.height);
@@ -45,7 +65,7 @@ void IHyprLayout::onWindowCreatedFloating(CWindow* pWindow) {
         Vector2D middlePoint = Vector2D(desiredGeometry.x, desiredGeometry.y) + Vector2D(desiredGeometry.width, desiredGeometry.height) / 2.f;
 
         // TODO: detect a popup in a more consistent way.
-        if (!g_pCompositor->isPointOnAnyMonitor(middlePoint) || (desiredGeometry.x == 0 && desiredGeometry.y == 0)) {
+        if ((desiredGeometry.x == 0 && desiredGeometry.y == 0)) {
             // if it's not, fall back to the center placement
             pWindow->m_vRealPosition = PMONITOR->vecPosition + Vector2D((PMONITOR->vecSize.x - desiredGeometry.width) / 2.f, (PMONITOR->vecSize.y - desiredGeometry.height) / 2.f);
         } else {
@@ -65,10 +85,11 @@ void IHyprLayout::onWindowCreatedFloating(CWindow* pWindow) {
         pWindow->m_vRealSize.setValue(pWindow->m_vRealSize.goalv());
     }
 
-    g_pXWaylandManager->setWindowSize(pWindow, pWindow->m_vRealSize.goalv());
-    g_pCompositor->fixXWaylandWindowsOnWorkspace(PMONITOR->activeWorkspace);
+    if (pWindow->m_iX11Type != 2) {
+        g_pXWaylandManager->setWindowSize(pWindow, pWindow->m_vRealSize.goalv());
 
-    g_pCompositor->moveWindowToTop(pWindow);
+        g_pCompositor->moveWindowToTop(pWindow);
+    }
 }
 
 void IHyprLayout::onBeginDragWindow() {
@@ -94,6 +115,9 @@ void IHyprLayout::onBeginDragWindow() {
         return;
     }
 
+    DRAGGINGWINDOW->m_vRealPosition.setConfig(g_pConfigManager->getAnimationPropertyConfig("windowsMove"));
+    DRAGGINGWINDOW->m_vRealSize.setConfig(g_pConfigManager->getAnimationPropertyConfig("windowsMove"));
+
     DRAGGINGWINDOW->m_bDraggingTiled = false;
 
     if (!DRAGGINGWINDOW->m_bIsFloating) {
@@ -101,15 +125,20 @@ void IHyprLayout::onBeginDragWindow() {
             changeWindowFloatingMode(DRAGGINGWINDOW);
             DRAGGINGWINDOW->m_bIsFloating = true;
             DRAGGINGWINDOW->m_bDraggingTiled = true;
+
+            DRAGGINGWINDOW->m_vRealPosition = g_pInputManager->getMouseCoordsInternal() - DRAGGINGWINDOW->m_vRealSize.goalv() / 2.f;
         }
     }
 
     m_vBeginDragXY = g_pInputManager->getMouseCoordsInternal();
-    m_vBeginDragPositionXY = DRAGGINGWINDOW->m_vRealPosition.vec();
-    m_vBeginDragSizeXY = DRAGGINGWINDOW->m_vRealSize.vec();
+    m_vBeginDragPositionXY = DRAGGINGWINDOW->m_vRealPosition.goalv();
+    m_vBeginDragSizeXY = DRAGGINGWINDOW->m_vRealSize.goalv();
     m_vLastDragXY = m_vBeginDragXY;
 
     g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
+
+    // shadow to ignore any bound to MAIN_MOD
+    g_pKeybindManager->shadowKeybinds();
 }
 
 void IHyprLayout::onEndDragWindow() {
@@ -138,6 +167,8 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
     const auto DELTA = Vector2D(mousePos.x - m_vBeginDragXY.x, mousePos.y - m_vBeginDragXY.y);
     const auto TICKDELTA = Vector2D(mousePos.x - m_vLastDragXY.x, mousePos.y - m_vLastDragXY.y);
 
+    const auto PANIMATE = &g_pConfigManager->getConfigValuePtr("misc:animate_manual_resizes")->intValue;
+
     if (abs(TICKDELTA.x) < 1.f && abs(TICKDELTA.y) < 1.f)
         return;
 
@@ -148,16 +179,19 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
     if (g_pInputManager->dragButton == BTN_LEFT) {
         DRAGGINGWINDOW->m_vRealPosition.setValueAndWarp(m_vBeginDragPositionXY + DELTA);
 
-        DRAGGINGWINDOW->updateWindowDecos();
-
         g_pXWaylandManager->setWindowSize(DRAGGINGWINDOW, DRAGGINGWINDOW->m_vRealSize.goalv());
     } else {
         if (DRAGGINGWINDOW->m_bIsFloating) {
-            DRAGGINGWINDOW->m_vRealSize.setValueAndWarp(m_vBeginDragSizeXY + DELTA);
-            DRAGGINGWINDOW->m_vRealSize.setValueAndWarp(Vector2D(std::clamp(DRAGGINGWINDOW->m_vRealSize.vec().x, (double)20, (double)999999), std::clamp(DRAGGINGWINDOW->m_vRealSize.vec().y, (double)20, (double)999999)));
 
-            DRAGGINGWINDOW->updateWindowDecos();
+            const auto MAXSIZE = g_pXWaylandManager->getMaxSizeForWindow(DRAGGINGWINDOW);
 
+            if (*PANIMATE) {
+                DRAGGINGWINDOW->m_vRealSize = Vector2D(std::clamp(m_vBeginDragSizeXY.x + DELTA.x, (double)20, (double)MAXSIZE.x), std::clamp(m_vBeginDragSizeXY.y + DELTA.y, (double)20, (double)MAXSIZE.y));
+            } else {
+                DRAGGINGWINDOW->m_vRealSize.setValueAndWarp(m_vBeginDragSizeXY + DELTA);
+                DRAGGINGWINDOW->m_vRealSize.setValueAndWarp(Vector2D(std::clamp(DRAGGINGWINDOW->m_vRealSize.vec().x, (double)20, (double)MAXSIZE.x), std::clamp(DRAGGINGWINDOW->m_vRealSize.vec().y, (double)20, (double)MAXSIZE.y)));
+            }
+            
             g_pXWaylandManager->setWindowSize(DRAGGINGWINDOW, DRAGGINGWINDOW->m_vRealSize.goalv());
         } else {
             resizeActiveWindow(TICKDELTA, DRAGGINGWINDOW);
@@ -173,8 +207,12 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
     if (PMONITOR) {
         DRAGGINGWINDOW->m_iMonitorID = PMONITOR->ID;
         DRAGGINGWINDOW->m_iWorkspaceID = PMONITOR->activeWorkspace;
+
+        DRAGGINGWINDOW->updateToplevel();
     }
 
+    DRAGGINGWINDOW->updateWindowDecos();
+
     g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
 }
 
@@ -202,6 +240,8 @@ void IHyprLayout::changeWindowFloatingMode(CWindow* pWindow) {
         // if the window is pseudo, update its size
         pWindow->m_vPseudoSize = pWindow->m_vRealSize.vec();
 
+        pWindow->m_vLastFloatingSize = PSAVEDSIZE;
+
         onWindowCreatedTiling(pWindow);
 
         pWindow->m_vRealPosition.setValue(PSAVEDPOS);
@@ -210,10 +250,24 @@ void IHyprLayout::changeWindowFloatingMode(CWindow* pWindow) {
         // fix pseudo leaving artifacts
         g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID));
     } else {
+        pWindow->m_vSize = pWindow->m_vRealSize.vec();
+        pWindow->m_vPosition = pWindow->m_vRealPosition.vec();
+
         onWindowRemovedTiling(pWindow);
 
         g_pCompositor->moveWindowToTop(pWindow);
+
+        pWindow->m_vRealPosition = pWindow->m_vRealPosition.vec() + (pWindow->m_vRealSize.vec() - pWindow->m_vLastFloatingSize) / 2.f;
+        pWindow->m_vRealSize = pWindow->m_vLastFloatingSize;
+
+        g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID));
+
+        pWindow->m_sSpecialRenderData.rounding = true;
     }
+
+    g_pCompositor->updateWindowAnimatedDecorationValues(pWindow);
+
+    pWindow->updateToplevel();
 }
 
 void IHyprLayout::moveActiveWindow(const Vector2D& delta, CWindow* pWindow) {

src/layout/IHyprLayout.hpp

@@ -16,6 +16,8 @@ enum eFullscreenMode : uint8_t;
 
 interface IHyprLayout {
 public:
+    virtual void        onEnable() = 0;
+    virtual void        onDisable() = 0;
 
     /*
         Called when a window is created (mapped)

src/layout/MasterLayout.cpp

@@ -0,0 +1,569 @@
+#include "MasterLayout.hpp"
+#include "../Compositor.hpp"
+
+SMasterNodeData* CHyprMasterLayout::getNodeFromWindow(CWindow* pWindow) {
+    for (auto& nd : m_lMasterNodesData) {
+        if (nd.pWindow == pWindow)
+            return &nd;
+    }
+
+    return nullptr;
+}
+
+int CHyprMasterLayout::getNodesOnWorkspace(const int& ws) {
+    int no = 0;
+    for (auto& n : m_lMasterNodesData) {
+        if (n.workspaceID == ws)
+            no++;
+    }
+
+    return no;
+}
+
+std::string CHyprMasterLayout::getLayoutName() {
+    return "Master";
+}
+
+SMasterNodeData* CHyprMasterLayout::getMasterNodeOnWorkspace(const int& ws) {
+    for (auto& n : m_lMasterNodesData) {
+        if (n.isMaster && n.workspaceID == ws)
+            return &n;
+    }
+
+    return nullptr;
+}
+
+void CHyprMasterLayout::onWindowCreatedTiling(CWindow* pWindow) {
+    if (pWindow->m_bIsFloating)
+        return;
+
+    static auto *const PNEWTOP = &g_pConfigManager->getConfigValuePtr("master:new_on_top")->intValue;
+
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+
+    const auto PNODE = *PNEWTOP ? &m_lMasterNodesData.emplace_front() : &m_lMasterNodesData.emplace_back();
+
+    PNODE->workspaceID = pWindow->m_iWorkspaceID;
+    PNODE->pWindow = pWindow;
+
+    static auto *const PNEWISMASTER = &g_pConfigManager->getConfigValuePtr("master:new_is_master")->intValue;
+
+    const auto WINDOWSONWORKSPACE = getNodesOnWorkspace(PNODE->workspaceID);
+    float lastSplitPercent = 0.5f;
+
+    if (*PNEWISMASTER || WINDOWSONWORKSPACE == 1) {
+        for (auto& nd : m_lMasterNodesData) {
+            if (nd.isMaster && nd.workspaceID == PNODE->workspaceID) {
+                nd.isMaster = false;
+                lastSplitPercent = nd.percMaster;
+                break;
+            }
+        }
+
+        PNODE->isMaster = true;
+        PNODE->percMaster = lastSplitPercent;
+
+        // first, check if it isn't too big.
+        if (const auto MAXSIZE = g_pXWaylandManager->getMaxSizeForWindow(pWindow); MAXSIZE.x < PMONITOR->vecSize.x * lastSplitPercent || MAXSIZE.y < PMONITOR->vecSize.y) {
+            // we can't continue. make it floating.
+            pWindow->m_bIsFloating = true;
+            m_lMasterNodesData.remove(*PNODE);
+            g_pLayoutManager->getCurrentLayout()->onWindowCreatedFloating(pWindow);
+            return;
+        }
+    } else {
+        PNODE->isMaster = false;
+
+        // first, check if it isn't too big.
+        if (const auto MAXSIZE = g_pXWaylandManager->getMaxSizeForWindow(pWindow); MAXSIZE.x < PMONITOR->vecSize.x * (1 - lastSplitPercent) || MAXSIZE.y < PMONITOR->vecSize.y * (1.f / (WINDOWSONWORKSPACE - 1))) {
+            // we can't continue. make it floating.
+            pWindow->m_bIsFloating = true;
+            m_lMasterNodesData.remove(*PNODE);
+            g_pLayoutManager->getCurrentLayout()->onWindowCreatedFloating(pWindow);
+            return;
+        }
+    }
+
+    // recalc
+    recalculateMonitor(pWindow->m_iMonitorID);
+}
+
+void CHyprMasterLayout::onWindowRemovedTiling(CWindow* pWindow) {
+    const auto PNODE = getNodeFromWindow(pWindow);
+
+    if (!PNODE)
+        return;
+
+    if (PNODE->isMaster) {
+        // find new one
+        for (auto& nd : m_lMasterNodesData) {
+            if (!nd.isMaster) {
+                nd.isMaster = true;
+                break;
+            }
+        }
+    }
+
+    m_lMasterNodesData.remove(*PNODE);
+
+    recalculateMonitor(pWindow->m_iMonitorID);
+}
+
+void CHyprMasterLayout::recalculateMonitor(const int& monid) {
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(monid);
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
+
+    if (!PWORKSPACE)
+        return;
+
+    g_pHyprRenderer->damageMonitor(PMONITOR);
+
+    if (PMONITOR->specialWorkspaceOpen) {
+        calculateWorkspace(SPECIAL_WORKSPACE_ID);
+    }
+
+    if (PWORKSPACE->m_bHasFullscreenWindow) {
+        if (PWORKSPACE->m_efFullscreenMode == FULLSCREEN_FULL) 
+            return;
+
+        // massive hack from the fullscreen func
+        const auto PFULLWINDOW = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
+
+        SMasterNodeData fakeNode;
+        fakeNode.pWindow = PFULLWINDOW;
+        fakeNode.position = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
+        fakeNode.size = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight;
+        fakeNode.workspaceID = PWORKSPACE->m_iID;
+        PFULLWINDOW->m_vPosition = fakeNode.position;
+        PFULLWINDOW->m_vSize = fakeNode.size;
+
+        applyNodeDataToWindow(&fakeNode);
+
+        return;
+    }
+
+    // calc the WS
+    calculateWorkspace(PWORKSPACE->m_iID);
+}
+
+void CHyprMasterLayout::calculateWorkspace(const int& ws) {
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(ws);
+
+    if (!PWORKSPACE)
+        return;
+
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID);
+
+    const auto PMASTERNODE = getMasterNodeOnWorkspace(PWORKSPACE->m_iID);
+
+    if (!PMASTERNODE)
+        return;
+
+    if (getNodesOnWorkspace(PWORKSPACE->m_iID) < 2) {
+        PMASTERNODE->position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition;
+        PMASTERNODE->size = Vector2D(PMONITOR->vecSize.x - PMONITOR->vecReservedTopLeft.x - PMONITOR->vecReservedBottomRight.x, PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y);
+        applyNodeDataToWindow(PMASTERNODE);
+        return;
+    } else {
+        PMASTERNODE->position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition;
+        PMASTERNODE->size = Vector2D((PMONITOR->vecSize.x - PMONITOR->vecReservedTopLeft.x - PMONITOR->vecReservedBottomRight.x) * PMASTERNODE->percMaster, PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y);
+    }
+
+    const auto SLAVESIZE = 1.f / (getNodesOnWorkspace(PWORKSPACE->m_iID) - 1) * (PMASTERNODE->size.y);
+    int slavesDone = 0;
+
+    for (auto& nd : m_lMasterNodesData) {
+        if (nd.workspaceID != PWORKSPACE->m_iID)
+            continue;
+
+        if (nd == *PMASTERNODE) {
+            applyNodeDataToWindow(PMASTERNODE);
+            continue;
+        }
+
+        nd.position = Vector2D(PMASTERNODE->size.x + PMASTERNODE->position.x, slavesDone * SLAVESIZE + PMASTERNODE->position.y);
+        nd.size = Vector2D(PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PMONITOR->vecReservedTopLeft.x - PMASTERNODE->size.x, SLAVESIZE);
+
+        slavesDone++;
+
+        applyNodeDataToWindow(&nd);
+    }
+}
+
+void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) {
+    CMonitor* PMONITOR = nullptr;
+
+    if (pNode->workspaceID == SPECIAL_WORKSPACE_ID) {
+        for (auto& m : g_pCompositor->m_vMonitors) {
+            if (m->specialWorkspaceOpen) {
+                PMONITOR = m.get();
+                break;
+            }
+        }
+    } else {
+        PMONITOR = g_pCompositor->getMonitorFromID(g_pCompositor->getWorkspaceByID(pNode->workspaceID)->m_iMonitorID);
+    }
+
+    if (!PMONITOR) {
+        Debug::log(ERR, "Orphaned Node %x (workspace ID: %i)!!", pNode, pNode->workspaceID);
+        return;
+    }
+
+    // for gaps outer
+    const bool DISPLAYLEFT          = STICKS(pNode->position.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x);
+    const bool DISPLAYRIGHT         = STICKS(pNode->position.x + pNode->size.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x);
+    const bool DISPLAYTOP           = STICKS(pNode->position.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y);
+    const bool DISPLAYBOTTOM        = STICKS(pNode->position.y + pNode->size.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y);
+
+    const auto BORDERSIZE           = g_pConfigManager->getInt("general:border_size");
+    const auto GAPSIN               = g_pConfigManager->getInt("general:gaps_in");
+    const auto GAPSOUT              = g_pConfigManager->getInt("general:gaps_out");
+
+    const auto PWINDOW = pNode->pWindow;
+
+    if (!g_pCompositor->windowValidMapped(PWINDOW)) {
+        Debug::log(ERR, "Node %x holding invalid window %x!!", pNode, PWINDOW);
+        return;
+    }
+
+    static auto *const PNOGAPSWHENONLY = &g_pConfigManager->getConfigValuePtr("master:no_gaps_when_only")->intValue;
+
+    PWINDOW->m_vSize = pNode->size;
+    PWINDOW->m_vPosition = pNode->position;
+
+    auto calcPos = PWINDOW->m_vPosition + Vector2D(BORDERSIZE, BORDERSIZE);
+    auto calcSize = PWINDOW->m_vSize - Vector2D(2 * BORDERSIZE, 2 * BORDERSIZE);
+
+    if (*PNOGAPSWHENONLY && PWINDOW->m_iWorkspaceID != SPECIAL_WORKSPACE_ID && getNodesOnWorkspace(PWINDOW->m_iWorkspaceID) == 1) {
+        PWINDOW->m_vRealPosition = calcPos - Vector2D(BORDERSIZE, BORDERSIZE);
+        PWINDOW->m_vRealSize = calcSize + Vector2D(2 * BORDERSIZE, 2 * BORDERSIZE);
+
+        PWINDOW->updateWindowDecos();
+
+        PWINDOW->m_sSpecialRenderData.rounding = false;
+        PWINDOW->m_sSpecialRenderData.border = false;
+
+        return;
+    }
+
+    PWINDOW->m_sSpecialRenderData.rounding = true;
+    PWINDOW->m_sSpecialRenderData.border = true;
+
+    const auto OFFSETTOPLEFT = Vector2D(DISPLAYLEFT ? GAPSOUT : GAPSIN,
+                                        DISPLAYTOP ? GAPSOUT : GAPSIN);
+
+    const auto OFFSETBOTTOMRIGHT = Vector2D(DISPLAYRIGHT ? GAPSOUT : GAPSIN,
+                                            DISPLAYBOTTOM ? GAPSOUT : GAPSIN);
+
+    calcPos = calcPos + OFFSETTOPLEFT;
+    calcSize = calcSize - OFFSETTOPLEFT - OFFSETBOTTOMRIGHT;
+
+    if (PWINDOW->m_iWorkspaceID == SPECIAL_WORKSPACE_ID) {
+        static auto *const PSCALEFACTOR = &g_pConfigManager->getConfigValuePtr("master:special_scale_factor")->floatValue;
+
+        PWINDOW->m_vRealPosition = calcPos + (calcSize - calcSize * *PSCALEFACTOR) / 2.f;
+        PWINDOW->m_vRealSize = calcSize * *PSCALEFACTOR;
+
+        g_pXWaylandManager->setWindowSize(PWINDOW, calcSize * *PSCALEFACTOR);
+    } else {
+        PWINDOW->m_vRealSize = calcSize;
+        PWINDOW->m_vRealPosition = calcPos;
+
+        g_pXWaylandManager->setWindowSize(PWINDOW, calcSize);
+    }
+
+    if (m_bForceWarps) {
+        PWINDOW->m_vRealPosition.warp();
+        PWINDOW->m_vRealSize.warp();
+    }
+
+    PWINDOW->updateWindowDecos();
+}
+
+bool CHyprMasterLayout::isWindowTiled(CWindow* pWindow) {
+    return getNodeFromWindow(pWindow) != nullptr;
+}
+
+void CHyprMasterLayout::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 = Vector2D(std::clamp((PWINDOW->m_vRealSize.goalv() + pixResize).x, (double)20, (double)999999), std::clamp((PWINDOW->m_vRealSize.goalv() + pixResize).y, (double)20, (double)999999));
+        PWINDOW->updateWindowDecos();
+        return;
+    }
+
+    // get master
+    const auto PMASTER = getMasterNodeOnWorkspace(PWINDOW->m_iWorkspaceID);
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+
+    if (getNodesOnWorkspace(PWINDOW->m_iWorkspaceID) < 2)
+        return;
+
+    m_bForceWarps = true;
+
+    float delta = pixResize.x / PMONITOR->vecSize.x;
+
+    PMASTER->percMaster += delta;
+
+    std::clamp(PMASTER->percMaster, 0.05f, 0.95f);
+
+    recalculateMonitor(PMONITOR->ID);
+
+    m_bForceWarps = false;
+}
+
+void CHyprMasterLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscreenMode fullscreenMode, bool on) {
+    if (!g_pCompositor->windowValidMapped(pWindow))
+        return;
+
+    if (!g_pCompositor->isWorkspaceVisible(pWindow->m_iWorkspaceID))
+        return;
+
+    if (on == pWindow->m_bIsFullscreen)
+        return;  // ignore
+
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(pWindow->m_iWorkspaceID);
+
+    if (PWORKSPACE->m_bHasFullscreenWindow && on) {
+        // if the window wants to be fullscreen but there already is one,
+        // ignore the request.
+        return;
+    }
+
+    // otherwise, accept it.
+    pWindow->m_bIsFullscreen = on;
+    PWORKSPACE->m_bHasFullscreenWindow = !PWORKSPACE->m_bHasFullscreenWindow;
+
+    g_pEventManager->postEvent(SHyprIPCEvent{"fullscreen", std::to_string((int)on)});
+
+    if (!pWindow->m_bIsFullscreen) {
+        // if it got its fullscreen disabled, set back its node if it had one
+        const auto PNODE = getNodeFromWindow(pWindow);
+        if (PNODE)
+            applyNodeDataToWindow(PNODE);
+        else {
+            // get back its' dimensions from position and size
+            pWindow->m_vRealPosition = pWindow->m_vPosition;
+            pWindow->m_vRealSize = pWindow->m_vSize;
+        }
+    } else {
+        // if it now got fullscreen, make it fullscreen
+
+        PWORKSPACE->m_efFullscreenMode = fullscreenMode;
+
+        // save position and size if floating
+        if (pWindow->m_bIsFloating) {
+            pWindow->m_vPosition = pWindow->m_vRealPosition.vec();
+            pWindow->m_vSize = pWindow->m_vRealSize.vec();
+        }
+
+        // apply new pos and size being monitors' box
+        if (fullscreenMode == FULLSCREEN_FULL) {
+            pWindow->m_vRealPosition = PMONITOR->vecPosition;
+            pWindow->m_vRealSize = PMONITOR->vecSize;
+        } else {
+            // This is a massive hack.
+            // We make a fake "only" node and apply
+            // To keep consistent with the settings without C+P code
+
+            SMasterNodeData fakeNode;
+            fakeNode.pWindow = pWindow;
+            fakeNode.position = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
+            fakeNode.size = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight;
+            fakeNode.workspaceID = pWindow->m_iWorkspaceID;
+            pWindow->m_vPosition = fakeNode.position;
+            pWindow->m_vSize = fakeNode.size;
+
+            applyNodeDataToWindow(&fakeNode);
+        }
+    }
+
+    g_pCompositor->updateWindowAnimatedDecorationValues(pWindow);
+
+    g_pXWaylandManager->setWindowSize(pWindow, pWindow->m_vRealSize.goalv());
+
+    g_pCompositor->moveWindowToTop(pWindow);
+
+    recalculateMonitor(PMONITOR->ID);
+}
+
+void CHyprMasterLayout::recalculateWindow(CWindow* pWindow) {
+    const auto PNODE = getNodeFromWindow(pWindow);
+
+    if (!PNODE)
+        return;
+
+    recalculateMonitor(pWindow->m_iMonitorID);
+}
+
+SWindowRenderLayoutHints CHyprMasterLayout::requestRenderHints(CWindow* pWindow) {
+    // window should be valid, insallah
+
+    SWindowRenderLayoutHints hints;
+
+    return hints; // master doesnt have any hints
+}
+
+void CHyprMasterLayout::switchWindows(CWindow* pWindow, CWindow* pWindow2) {
+    // windows should be valid, insallah
+
+    const auto PNODE = getNodeFromWindow(pWindow);
+    const auto PNODE2 = getNodeFromWindow(pWindow2);
+
+    if (!PNODE2 || !PNODE)
+        return;
+
+    if (PNODE->workspaceID != PNODE2->workspaceID) {
+        Debug::log(ERR, "Master: Rejecting a swap between workspaces");
+        return;
+    }
+
+    // massive hack: just swap window pointers, lol
+    const auto PWINDOW1 = PNODE->pWindow;
+    PNODE->pWindow = PNODE2->pWindow;
+    PNODE2->pWindow = PWINDOW1;
+
+    recalculateMonitor(PWINDOW1->m_iMonitorID);
+}
+
+void CHyprMasterLayout::alterSplitRatioBy(CWindow* pWindow, float ratio) {
+    // window should be valid, insallah
+
+    const auto PNODE = getNodeFromWindow(pWindow);
+
+    if (!PNODE)
+        return;
+
+    const auto PMASTER = getMasterNodeOnWorkspace(pWindow->m_iWorkspaceID);
+
+    PMASTER->percMaster = std::clamp(PMASTER->percMaster + ratio, 0.05f, 0.95f);
+
+    recalculateMonitor(pWindow->m_iMonitorID);
+}
+
+std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::string message) {
+    auto switchToWindow = [&](CWindow* PWINDOWTOCHANGETO) {
+        g_pCompositor->focusWindow(PWINDOWTOCHANGETO);
+        Vector2D middle = PWINDOWTOCHANGETO->m_vRealPosition.goalv() + PWINDOWTOCHANGETO->m_vRealSize.goalv() / 2.f;
+        wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, middle.x, middle.y);
+    };
+
+    if (message == "swapwithmaster") {
+
+        const auto PWINDOW = header.pWindow;
+
+        if (!isWindowTiled(PWINDOW))
+            return 0;
+
+        const auto PMASTER = getMasterNodeOnWorkspace(PWINDOW->m_iWorkspaceID);
+
+        if (!PMASTER || PMASTER->pWindow == PWINDOW)
+            return 0;
+
+        switchWindows(PWINDOW, PMASTER->pWindow);
+
+        switchToWindow(PWINDOW);
+
+        return 0;
+    } else if (message == "cyclenext") {
+        const auto PWINDOW = header.pWindow;
+
+        if (!isWindowTiled(PWINDOW))
+            return 0;
+
+        const auto PNODE = getNodeFromWindow(PWINDOW);
+
+        if (PNODE->isMaster) {
+            // focus the first non master
+            for (auto n : m_lMasterNodesData) {
+                if (n.pWindow != PWINDOW && n.workspaceID == PWINDOW->m_iWorkspaceID) {
+                    switchToWindow(n.pWindow);
+                    break;
+                }
+            }
+        } else {
+            // focus next
+            bool reached = false;
+            bool found = false;
+            for (auto n : m_lMasterNodesData) {
+                if (n.pWindow == PWINDOW) {
+                    reached = true;
+                    continue;
+                }
+
+                if (n.workspaceID == PWINDOW->m_iWorkspaceID && reached) {
+                    switchToWindow(n.pWindow);
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                const auto PMASTER = getMasterNodeOnWorkspace(PWINDOW->m_iWorkspaceID);
+
+                if (PMASTER)
+                    switchToWindow(PMASTER->pWindow);
+            }
+        }
+    } else if (message == "cycleprev") {
+        const auto PWINDOW = header.pWindow;
+
+        if (!isWindowTiled(PWINDOW))
+            return 0;
+
+        const auto PNODE = getNodeFromWindow(PWINDOW);
+
+        if (PNODE->isMaster) {
+            // focus the first non master
+            for (auto it = m_lMasterNodesData.rbegin(); it != m_lMasterNodesData.rend(); it++) {
+                if (it->pWindow != PWINDOW && it->workspaceID == PWINDOW->m_iWorkspaceID) {
+                    switchToWindow(it->pWindow);
+                    break;
+                }
+            }
+        } else {
+            // focus next
+            bool reached = false;
+            bool found = false;
+            for (auto it = m_lMasterNodesData.rbegin(); it != m_lMasterNodesData.rend(); it++) {
+                if (it->pWindow == PWINDOW) {
+                    reached = true;
+                    continue;
+                }
+
+                if (it->workspaceID == PWINDOW->m_iWorkspaceID && reached) {
+                    switchToWindow(it->pWindow);
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                const auto PMASTER = getMasterNodeOnWorkspace(PWINDOW->m_iWorkspaceID);
+
+                if (PMASTER)
+                    switchToWindow(PMASTER->pWindow);
+            }
+        }
+    }
+
+    return 0;
+}
+
+void CHyprMasterLayout::onEnable() {
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (w->m_bIsFloating || !w->m_bMappedX11 || !w->m_bIsMapped || w->m_bHidden)
+            continue;
+
+        onWindowCreatedTiling(w.get());
+    }
+}
+
+void CHyprMasterLayout::onDisable() {
+    m_lMasterNodesData.clear();
+}

src/layout/MasterLayout.hpp

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "IHyprLayout.hpp"
+#include <list>
+#include <deque>
+
+enum eFullscreenMode : uint8_t;
+
+struct SMasterNodeData {
+    bool isMaster = false;
+    float percMaster = 0.5f;
+
+    CWindow* pWindow = nullptr;
+
+    Vector2D position;
+    Vector2D size;
+
+    int workspaceID = -1;
+
+    bool operator==(const SMasterNodeData& rhs) {
+        return pWindow == rhs.pWindow;
+    }
+};
+
+class CHyprMasterLayout : public IHyprLayout {
+public:
+    virtual void        onWindowCreatedTiling(CWindow*);
+    virtual void        onWindowRemovedTiling(CWindow*);
+    virtual bool        isWindowTiled(CWindow*);
+    virtual void        recalculateMonitor(const int&);
+    virtual void        recalculateWindow(CWindow*);
+    virtual void        resizeActiveWindow(const Vector2D&, CWindow* pWindow = nullptr);
+    virtual void        fullscreenRequestForWindow(CWindow*, eFullscreenMode, bool);
+    virtual std::any    layoutMessage(SLayoutMessageHeader, std::string);
+    virtual SWindowRenderLayoutHints requestRenderHints(CWindow*);
+    virtual void        switchWindows(CWindow*, CWindow*);
+    virtual void        alterSplitRatioBy(CWindow*, float);
+    virtual std::string getLayoutName();
+
+    virtual void        onEnable();
+    virtual void        onDisable();
+
+private:
+
+    std::list<SMasterNodeData>     m_lMasterNodesData;
+
+    bool                m_bForceWarps = false;
+
+    int                 getNodesOnWorkspace(const int&);
+    void                applyNodeDataToWindow(SMasterNodeData*);
+    SMasterNodeData*    getNodeFromWindow(CWindow*);
+    SMasterNodeData*    getMasterNodeOnWorkspace(const int&);
+    void                calculateWorkspace(const int&);
+
+    friend struct SMasterNodeData;
+};

src/main.cpp

@@ -12,12 +12,22 @@ bool ignoreSudo = false;
 int main(int argc, char** argv) {
 
     if (!getenv("XDG_RUNTIME_DIR"))
-        RIP("XDG_RUNTIME_DIR not set!");
+        throw std::runtime_error("XDG_RUNTIME_DIR is not set!");
 
     // parse some args
+    std::string configPath;
     for (int i = 1; i < argc; ++i) {
         if (!strcmp(argv[i], "--i-am-really-stupid"))
             ignoreSudo = true;
+        else if ((!strcmp(argv[i], "-c") || !strcmp(argv[i], "--config")) && argc >= i + 2) {
+            configPath = std::string(argv[++i]);
+            Debug::log(LOG, "Using config location %s.", configPath.c_str());
+        } else {
+            std::cout << "Hyprland usage: Hyprland [arg [...]].\n\nArguments:\n" <<
+                "--help         -h | Show this help message\n" <<
+                "--config       -c | Specify config file to use\n";
+            return 1;
+        }
     }
 
     system("mkdir -p /tmp/hypr");
@@ -37,6 +47,7 @@ int main(int argc, char** argv) {
     // let's init the compositor.
     // it initializes basic Wayland stuff in the constructor.
     g_pCompositor = std::make_unique<CCompositor>(); 
+    g_pCompositor->explicitConfigPath = configPath;
 
     Debug::log(LOG, "Hyprland init finished.");
 
@@ -46,7 +57,7 @@ int main(int argc, char** argv) {
     // If we are here it means we got yote.
     Debug::log(LOG, "Hyprland reached the end.");
 
-    g_pCompositor->cleanupExit();
+    g_pCompositor->cleanup();
 
     return EXIT_SUCCESS;
 }

src/managers/AnimationManager.cpp

@@ -28,13 +28,10 @@ void CAnimationManager::tick() {
     if (!*PANIMENABLED)
         animationsDisabled = true;
 
-    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;
+    static auto *const  PSHADOWSENABLED   = &g_pConfigManager->getConfigValuePtr("decoration:drop_shadow")->intValue;
 
-    auto DEFAULTBEZIER = m_mBezierCurves.find(*BEZIERSTR);
-    if (DEFAULTBEZIER == m_mBezierCurves.end())
-        DEFAULTBEZIER = m_mBezierCurves.find("default");
+    const auto DEFAULTBEZIER = m_mBezierCurves.find("default");
 
     for (auto& av : m_lAnimatedVariables) {
 
@@ -42,8 +39,13 @@ void CAnimationManager::tick() {
         if (!av->isBeingAnimated())
             continue;
 
+        if (av->m_eDamagePolicy == AVARDAMAGE_SHADOW && !*PSHADOWSENABLED) {
+            av->warp();
+            continue;
+        }
+
         // get speed
-        const auto SPEED = *av->m_pSpeed == 0 ? *PANIMSPEED : *av->m_pSpeed;
+        const auto SPEED = av->m_pConfig->pValues->internalSpeed;
 
         // get the spent % (0 - 1)
         const auto DURATIONPASSED = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - av->animationBegin).count();
@@ -53,7 +55,7 @@ void CAnimationManager::tick() {
         const auto PWINDOW = (CWindow*)av->m_pWindow;
         const auto PWORKSPACE = (CWorkspace*)av->m_pWorkspace;
         const auto PLAYER = (SLayerSurface*)av->m_pLayer;
-        SMonitor* PMONITOR = nullptr;
+        CMonitor* PMONITOR = nullptr;
 
         wlr_box WLRBOXPREV = {0,0,0,0};
         if (PWINDOW) {
@@ -73,7 +75,7 @@ void CAnimationManager::tick() {
         switch (av->m_eVarType) {
             case AVARTYPE_FLOAT: {
                 // for disabled anims just warp
-                if (*av->m_pEnabled == 0 || animationsDisabled) {
+                if (av->m_pConfig->pValues->internalEnabled == 0 || animationsDisabled) {
                     av->warp();
                     break;
                 }
@@ -84,7 +86,7 @@ void CAnimationManager::tick() {
                 }
 
                 const auto DELTA = av->m_fGoal - av->m_fBegun;
-                const auto BEZIER = m_mBezierCurves.find(*av->m_pBezier);
+                const auto BEZIER = m_mBezierCurves.find(av->m_pConfig->pValues->internalBezier);
 
                 if (BEZIER != m_mBezierCurves.end())
                     av->m_fValue = av->m_fBegun + BEZIER->second.getYForPoint(SPENT) * DELTA;
@@ -94,7 +96,7 @@ void CAnimationManager::tick() {
             }
             case AVARTYPE_VECTOR: {
                 // for disabled anims just warp
-                if (*av->m_pEnabled == 0 || animationsDisabled) {
+                if (av->m_pConfig->pValues->internalEnabled == 0 || animationsDisabled) {
                     av->warp();
                     break;
                 }
@@ -105,7 +107,7 @@ void CAnimationManager::tick() {
                 }
 
                 const auto DELTA = av->m_vGoal - av->m_vBegun;
-                const auto BEZIER = m_mBezierCurves.find(*av->m_pBezier);
+                const auto BEZIER = m_mBezierCurves.find(av->m_pConfig->pValues->internalBezier);
 
                 if (BEZIER != m_mBezierCurves.end())
                     av->m_vValue = av->m_vBegun + DELTA * BEZIER->second.getYForPoint(SPENT);
@@ -115,7 +117,7 @@ void CAnimationManager::tick() {
             }
             case AVARTYPE_COLOR: {
                 // for disabled anims just warp
-                if (*av->m_pEnabled == 0 || animationsDisabled) {
+                if (av->m_pConfig->pValues->internalEnabled == 0 || animationsDisabled) {
                     av->warp();
                     break;
                 }
@@ -126,7 +128,7 @@ void CAnimationManager::tick() {
                 }
 
                 const auto DELTA = av->m_cGoal - av->m_cBegun;
-                const auto BEZIER = m_mBezierCurves.find(*av->m_pBezier);
+                const auto BEZIER = m_mBezierCurves.find(av->m_pConfig->pValues->internalBezier);
 
                 if (BEZIER != m_mBezierCurves.end())
                     av->m_cValue = av->m_cBegun + DELTA * BEZIER->second.getYForPoint(SPENT);
@@ -145,8 +147,8 @@ void CAnimationManager::tick() {
                 g_pHyprRenderer->damageBox(&WLRBOXPREV);
 
                 if (PWINDOW) {
-                    g_pHyprRenderer->damageWindow(PWINDOW);
                     PWINDOW->updateWindowDecos();
+                    g_pHyprRenderer->damageWindow(PWINDOW);
                 } else if (PWORKSPACE) {
                     for (auto& w : g_pCompositor->m_vWindows) {
                         if (!w->m_bIsMapped || w->m_bHidden)
@@ -157,6 +159,9 @@ void CAnimationManager::tick() {
 
                         w->updateWindowDecos();
                     }
+                } else if (PLAYER) {
+                    if (PLAYER->layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND || PLAYER->layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM)
+                        g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR);
                 }
                 break;
             }
@@ -181,6 +186,35 @@ void CAnimationManager::tick() {
                 g_pHyprRenderer->damageBox(WLRBOXNEW.x + WLRBOXNEW.width - ROUNDINGSIZE, WLRBOXNEW.y - BORDERSIZE, BORDERSIZE + ROUNDINGSIZE, WLRBOXNEW.height + 2 * BORDERSIZE);           // right
                 g_pHyprRenderer->damageBox(WLRBOXNEW.x, WLRBOXNEW.y + WLRBOXNEW.height - ROUNDINGSIZE, WLRBOXNEW.width + 2 * BORDERSIZE, BORDERSIZE + ROUNDINGSIZE);                        // bottom
 
+                break;
+            } case AVARDAMAGE_SHADOW: {
+                RASSERT(PWINDOW, "Tried to AVARDAMAGE_SHADOW a non-window AVAR!");
+
+                static auto* const PSHADOWIGNOREWINDOW = &g_pConfigManager->getConfigValuePtr("decoration:shadow_ignore_window")->intValue;
+
+                const auto PDECO = PWINDOW->getDecorationByType(DECORATION_SHADOW);
+
+                if (PDECO) {
+                    const auto EXTENTS = PDECO->getWindowDecorationExtents();
+
+                    wlr_box dmg = {PWINDOW->m_vRealPosition.vec().x - EXTENTS.topLeft.x, PWINDOW->m_vRealPosition.vec().y - EXTENTS.topLeft.y,
+                                   PWINDOW->m_vRealSize.vec().x + EXTENTS.topLeft.x + EXTENTS.bottomRight.x, PWINDOW->m_vRealSize.vec().y + EXTENTS.topLeft.y + EXTENTS.bottomRight.y};
+
+                    if (!*PSHADOWIGNOREWINDOW) {
+                        // easy, damage the entire box
+                        g_pHyprRenderer->damageBox(&dmg);
+                    } else {
+                        pixman_region32_t rg;
+                        pixman_region32_init_rect(&rg, dmg.x, dmg.y, dmg.width, dmg.height);
+                        pixman_region32_t wb;
+                        pixman_region32_init_rect(&wb, PWINDOW->m_vRealPosition.vec().x, PWINDOW->m_vRealPosition.vec().y, PWINDOW->m_vRealSize.vec().x, PWINDOW->m_vRealSize.vec().y);
+                        pixman_region32_subtract(&rg, &rg, &wb);
+                        g_pHyprRenderer->damageRegion(&rg);
+                        pixman_region32_fini(&rg);
+                        pixman_region32_fini(&wb);
+                    }
+                }
+
                 break;
             }
             default: {
@@ -191,11 +225,11 @@ void CAnimationManager::tick() {
         
 
         // set size and pos if valid, but only if damage policy entire (dont if border for example)
-        if (g_pCompositor->windowValidMapped(PWINDOW) && av->m_eDamagePolicy == AVARDAMAGE_ENTIRE)
+        if (g_pCompositor->windowValidMapped(PWINDOW) && av->m_eDamagePolicy == AVARDAMAGE_ENTIRE && PWINDOW->m_iX11Type != 2)
             g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
 
         // manually schedule a frame
-        wlr_output_schedule_frame(PMONITOR->output);
+        g_pCompositor->scheduleFrameForMonitor(PMONITOR);
     }
 }
 
@@ -223,21 +257,30 @@ bool CAnimationManager::deltazero(const CColor& a, const CColor& b) {
     return a.r == b.r && a.g == b.g && a.b == b.b && a.a == b.a;
 }
 
+bool CAnimationManager::bezierExists(const std::string& bezier) {
+    for (auto&[bc, bz] : m_mBezierCurves) {
+        if (bc == bezier)
+            return true;
+    }
+
+    return false;
+}
+
 //
 // Anims
 //
 //
 
-void CAnimationManager::animationPopin(CWindow* pWindow, bool close) {
+void CAnimationManager::animationPopin(CWindow* pWindow, bool close, float minPerc) {
     const auto GOALPOS = pWindow->m_vRealPosition.goalv();
     const auto GOALSIZE = pWindow->m_vRealSize.goalv();
 
     if (!close) {
-        pWindow->m_vRealPosition.setValue(GOALPOS + GOALSIZE / 2.f);
-        pWindow->m_vRealSize.setValue(Vector2D(5, 5));
+        pWindow->m_vRealSize.setValue((GOALSIZE * minPerc).clamp({5, 5}, {GOALSIZE.x, GOALSIZE.y}));
+        pWindow->m_vRealPosition.setValue(GOALPOS + GOALSIZE / 2.f - pWindow->m_vRealSize.m_vValue / 2.f);
     } else {
-        pWindow->m_vRealPosition = GOALPOS + GOALSIZE / 2.f;
-        pWindow->m_vRealSize = Vector2D(5, 5);
+        pWindow->m_vRealSize = (GOALSIZE * minPerc).clamp({5, 5}, {GOALSIZE.x, GOALSIZE.y});
+        pWindow->m_vRealPosition = GOALPOS + GOALSIZE / 2.f - pWindow->m_vRealSize.m_vGoal / 2.f;
     }
 }
 
@@ -299,7 +342,17 @@ void CAnimationManager::animationSlide(CWindow* pWindow, std::string force, bool
 }
 
 void CAnimationManager::onWindowPostCreateClose(CWindow* pWindow, bool close) {
-    auto ANIMSTYLE = g_pConfigManager->getString("animations:windows_style");
+    if (!close) {
+        pWindow->m_vRealPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("windowsIn");
+        pWindow->m_vRealSize.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("windowsIn");
+        pWindow->m_fAlpha.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("fadeIn");
+    } else {
+        pWindow->m_vRealPosition.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("windowsOut");
+        pWindow->m_vRealSize.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("windowsOut");
+        pWindow->m_fAlpha.m_pConfig = g_pConfigManager->getAnimationPropertyConfig("fadeOut");
+    }
+
+    auto ANIMSTYLE = pWindow->m_vRealPosition.m_pConfig->pValues->internalStyle;
     transform(ANIMSTYLE.begin(), ANIMSTYLE.end(), ANIMSTYLE.begin(), ::tolower);
 
     // if the window is not being animated, that means the layout set a fixed size for it, don't animate.
@@ -309,7 +362,7 @@ void CAnimationManager::onWindowPostCreateClose(CWindow* pWindow, bool close) {
     if (pWindow->m_sAdditionalConfigData.animationStyle != "") {
         // the window has config'd special anim
         if (pWindow->m_sAdditionalConfigData.animationStyle.find("slide") == 0) {
-            if (pWindow->m_sAdditionalConfigData.animationStyle.find(' ') != std::string::npos) {
+            if (pWindow->m_sAdditionalConfigData.animationStyle.contains(' ')) {
                 // has a direction
                 animationSlide(pWindow, pWindow->m_sAdditionalConfigData.animationStyle.substr(pWindow->m_sAdditionalConfigData.animationStyle.find(' ') + 1), close);
             } else {
@@ -317,14 +370,72 @@ void CAnimationManager::onWindowPostCreateClose(CWindow* pWindow, bool close) {
             }
         } else {
             // anim popin, fallback
-            animationPopin(pWindow, close);
+
+            float minPerc = 0.f;
+            if (pWindow->m_sAdditionalConfigData.animationStyle.find("%") != std::string::npos) {
+                try {
+                    auto percstr = pWindow->m_sAdditionalConfigData.animationStyle.substr(pWindow->m_sAdditionalConfigData.animationStyle.find_last_of(' '));
+                    minPerc = std::stoi(percstr.substr(0, percstr.length() - 1));
+                } catch (std::exception& e) {
+                    ; // oops
+                }
+            }
+
+            animationPopin(pWindow, close, minPerc / 100.f);
         }
     } else {
         if (ANIMSTYLE == "slide") {
             animationSlide(pWindow, "", close);
         } else {
             // anim popin, fallback
-            animationPopin(pWindow, close);
+
+            float minPerc = 0.f;
+            if (ANIMSTYLE.find("%") != 0) {
+                try {
+                    auto percstr = ANIMSTYLE.substr(ANIMSTYLE.find_last_of(' '));
+                    minPerc = std::stoi(percstr.substr(0, percstr.length() - 1));
+                } catch (std::exception& e) {
+                    ; // oops
+                }
+            }
+
+            animationPopin(pWindow, close, minPerc / 100.f);
         }
     }
+}
+
+std::string CAnimationManager::styleValidInConfigVar(const std::string& config, const std::string& style) {
+    if (config.find("window") == 0) {
+        if (style == "slide") {
+            return "";
+        } else if (style.find("popin") == 0) {
+            // try parsing
+            float minPerc = 0.f;
+            if (style.find("%") != std::string::npos) {
+                try {
+                    auto percstr = style.substr(style.find_last_of(' '));
+                    minPerc = std::stoi(percstr.substr(0, percstr.length() - 1));
+                } catch (std::exception& e) {
+                    return "invalid minperc";
+                }
+
+                return "";
+            }
+
+            minPerc; // fix warning
+
+            return "";
+        }
+
+        return "unknown style";
+    } else if (config == "workspaces") {
+        if (style == "slide" || style == "slidevert" || style == "fade")
+            return "";
+
+        return "unknown style";
+    } else {
+        return "animation has no styles";
+    }
+
+    return "";
 }

src/managers/AnimationManager.hpp

@@ -18,6 +18,10 @@ public:
 
     void            onWindowPostCreateClose(CWindow*, bool close = false);
 
+    bool            bezierExists(const std::string&);
+
+    std::string     styleValidInConfigVar(const std::string&, const std::string&);
+
     std::list<CAnimatedVariable*> m_lAnimatedVariables;
 
 private:
@@ -31,7 +35,7 @@ private:
     std::unordered_map<std::string, CBezierCurve> m_mBezierCurves;
 
     // Anim stuff
-    void            animationPopin(CWindow*, bool close = false);
+    void            animationPopin(CWindow*, bool close = false, float minPerc = 0.f);
     void            animationSlide(CWindow*, std::string force = "", bool close = false);
 };
 

src/managers/EventManager.cpp

@@ -80,8 +80,8 @@ void CEventManager::startThread() {
             eventQueueMutex.lock();
 
             if (m_dQueuedEvents.empty()){ // if queue empty, sleep and ignore
-                std::this_thread::sleep_for(std::chrono::milliseconds(1));
                 eventQueueMutex.unlock();
+                std::this_thread::sleep_for(std::chrono::milliseconds(1));
                 continue;
             }
 

src/managers/KeybindManager.cpp

@@ -33,64 +33,225 @@ CKeybindManager::CKeybindManager() {
     m_mDispatchers["focuswindowbyclass"]        = focusWindow;
     m_mDispatchers["focuswindow"]               = focusWindow;
     m_mDispatchers["submap"]                    = setSubmap;
+    m_mDispatchers["pass"]                      = pass;
+    m_mDispatchers["layoutmsg"]                 = layoutmsg;
+    m_mDispatchers["toggleopaque"]              = toggleOpaque;
+    m_mDispatchers["dpms"]                      = dpms;
+    m_mDispatchers["movewindowpixel"]           = moveWindow;
+    m_mDispatchers["resizewindowpixel"]         = resizeWindow;
+
+    m_tScrollTimer.reset();
 }
 
 void CKeybindManager::addKeybind(SKeybind kb) {
     m_lKeybinds.push_back(kb);
+
+    m_pActiveKeybind = nullptr;
 }
 
 void CKeybindManager::removeKeybind(uint32_t mod, const std::string& key) {
     for (auto it = m_lKeybinds.begin(); it != m_lKeybinds.end(); ++it) {
-        if (it->modmask == mod && it->key == key) {
+        if (isNumber(key) && std::stoi(key) > 9) {
+            const auto KEYNUM = std::stoi(key);
+
+            if (it->modmask == mod && it->keycode == KEYNUM) {
+                it = m_lKeybinds.erase(it);
+
+                if (it == m_lKeybinds.end())
+                    break;
+            }
+        }
+        else if (it->modmask == mod && it->key == key) {
             it = m_lKeybinds.erase(it);
+
+            if (it == m_lKeybinds.end())
+                break;
         }
     }
+
+    m_pActiveKeybind = nullptr;
 }
 
 uint32_t CKeybindManager::stringToModMask(std::string mods) {
     uint32_t modMask = 0;
-    if (mods.find("SHIFT") != std::string::npos)
+    if (mods.contains("SHIFT"))
         modMask |= WLR_MODIFIER_SHIFT;
-    if (mods.find("CAPS") != std::string::npos)
+    if (mods.contains("CAPS"))
         modMask |= WLR_MODIFIER_CAPS;
-    if (mods.find("CTRL") != std::string::npos || mods.find("CONTROL") != std::string::npos)
+    if (mods.contains("CTRL") || mods.contains("CONTROL"))
         modMask |= WLR_MODIFIER_CTRL;
-    if (mods.find("ALT") != std::string::npos)
+    if (mods.contains("ALT"))
         modMask |= WLR_MODIFIER_ALT;
-    if (mods.find("MOD2") != std::string::npos)
+    if (mods.contains("MOD2"))
         modMask |= WLR_MODIFIER_MOD2;
-    if (mods.find("MOD3") != std::string::npos)
+    if (mods.contains("MOD3"))
         modMask |= WLR_MODIFIER_MOD3;
-    if (mods.find("SUPER") != std::string::npos || mods.find("WIN") != std::string::npos || mods.find("LOGO") != std::string::npos || mods.find("MOD4") != std::string::npos)
+    if (mods.contains("SUPER") || mods.contains("WIN") || mods.contains("LOGO") || mods.contains("MOD4"))
         modMask |= WLR_MODIFIER_LOGO;
-    if (mods.find("MOD5") != std::string::npos)
+    if (mods.contains("MOD5"))
         modMask |= WLR_MODIFIER_MOD5;
 
     return modMask;
 }
 
-bool CKeybindManager::handleKeybinds(const uint32_t& modmask, const xkb_keysym_t& key) {
+bool CKeybindManager::onKeyEvent(wlr_keyboard_key_event* e, SKeyboard* pKeyboard) {
+    if (pKeyboard->isVirtual)
+        return true;
+
+    const auto KEYCODE = e->keycode + 8;  // Because to xkbcommon it's +8 from libinput
+
+    const xkb_keysym_t keysym = xkb_state_key_get_one_sym(wlr_keyboard_from_input_device(pKeyboard->keyboard)->xkb_state, KEYCODE);
+
+    const auto MODS = g_pInputManager->accumulateModsFromAllKBs();
+
+    m_uTimeLastMs = e->time_msec;
+    m_uLastCode = KEYCODE;
+
+    bool found = false;
+    if (e->state == WL_KEYBOARD_KEY_STATE_PRESSED) {
+        // clean repeat
+        if (m_pActiveKeybindEventSource) {
+            wl_event_source_remove(m_pActiveKeybindEventSource);
+            m_pActiveKeybindEventSource = nullptr;
+            m_pActiveKeybind = nullptr;
+        }
+
+        m_dPressedKeycodes.push_back(KEYCODE);
+        m_dPressedKeysyms.push_back(keysym);
+
+        found = g_pKeybindManager->handleKeybinds(MODS, "", keysym, 0, true, e->time_msec) || found;
+
+        found = g_pKeybindManager->handleKeybinds(MODS, "", 0, KEYCODE, true, e->time_msec) || found;
+
+        if (found)
+            shadowKeybinds(keysym, KEYCODE);
+    } else if (e->state == WL_KEYBOARD_KEY_STATE_RELEASED) {
+        // clean repeat
+        if (m_pActiveKeybindEventSource) {
+            wl_event_source_remove(m_pActiveKeybindEventSource);
+            m_pActiveKeybindEventSource = nullptr;
+            m_pActiveKeybind = nullptr;
+        }
+
+        m_dPressedKeycodes.erase(std::remove(m_dPressedKeycodes.begin(), m_dPressedKeycodes.end(), KEYCODE));
+        m_dPressedKeysyms.erase(std::remove(m_dPressedKeysyms.begin(), m_dPressedKeysyms.end(), keysym));
+
+        found = g_pKeybindManager->handleKeybinds(MODS, "", keysym, 0, false, e->time_msec) || found;
+
+        found = g_pKeybindManager->handleKeybinds(MODS, "", 0, KEYCODE, false, e->time_msec) || found;
+
+        shadowKeybinds();
+    }
+
+    return !found;
+}
+
+bool CKeybindManager::onAxisEvent(wlr_pointer_axis_event* e) {
+    const auto MODS = g_pInputManager->accumulateModsFromAllKBs();
+
+    static auto *const PDELAY = &g_pConfigManager->getConfigValuePtr("binds:scroll_event_delay")->intValue;
+
+    if (m_tScrollTimer.getMillis() < *PDELAY) {
+        m_tScrollTimer.reset();
+        return true; // timer hasn't passed yet!
+    }
+
+    m_tScrollTimer.reset();
+
+    bool found = false;
+    if (e->source == WLR_AXIS_SOURCE_WHEEL && e->orientation == WLR_AXIS_ORIENTATION_VERTICAL) {
+        if (e->delta < 0) { 
+            found = g_pKeybindManager->handleKeybinds(MODS, "mouse_down", 0, 0, true, 0);
+        } else {
+            found = g_pKeybindManager->handleKeybinds(MODS, "mouse_up", 0, 0, true, 0);
+        }
+
+        if (found)
+            shadowKeybinds();
+    }
+
+    return !found;
+}
+
+bool CKeybindManager::onMouseEvent(wlr_pointer_button_event* e) {
+    const auto MODS = g_pInputManager->accumulateModsFromAllKBs();
+
     bool found = false;
 
-    if (handleInternalKeybinds(key))
+    if (e->state == WLR_BUTTON_PRESSED) {
+        found = g_pKeybindManager->handleKeybinds(MODS, "mouse:" + std::to_string(e->button), 0, 0, true, 0);
+
+        if (found)
+            shadowKeybinds();
+    } else {
+        found = g_pKeybindManager->handleKeybinds(MODS, "mouse:" + std::to_string(e->button), 0, 0, false, 0);
+
+        shadowKeybinds();
+    }
+
+    return !found;
+}
+
+int repeatKeyHandler(void* data) {
+    SKeybind** ppActiveKeybind = (SKeybind**)data;
+
+    if (!*ppActiveKeybind)
+        return 0;
+
+    const auto DISPATCHER = g_pKeybindManager->m_mDispatchers.find((*ppActiveKeybind)->handler);
+
+    Debug::log(LOG, "Keybind repeat triggered, calling dispatcher.");
+    DISPATCHER->second((*ppActiveKeybind)->arg);
+
+    wl_event_source_timer_update(g_pKeybindManager->m_pActiveKeybindEventSource, 1000 / g_pInputManager->m_pActiveKeyboard->repeatRate);
+
+    return 0;
+}
+
+bool CKeybindManager::handleKeybinds(const uint32_t& modmask, const std::string& key, const xkb_keysym_t& keysym, const int& keycode, bool pressed, uint32_t time) {
+    bool found = false;
+
+    if (handleInternalKeybinds(keysym))
         return true;
 
     if (g_pCompositor->m_sSeat.exclusiveClient)
         Debug::log(LOG, "Keybind handling only locked (inhibitor)");
 
+    if (pressed && m_kHeldBack) {
+        // release the held back event
+        wlr_seat_keyboard_notify_key(g_pCompositor->m_sSeat.seat, time, m_kHeldBack, WL_KEYBOARD_KEY_STATE_PRESSED);
+        m_kHeldBack = 0;
+    }
+
     for (auto& k : m_lKeybinds) {
-        if (modmask != k.modmask || (g_pCompositor->m_sSeat.exclusiveClient && !k.locked) || k.submap != m_szCurrentSelectedSubmap)
+        if (modmask != k.modmask || (g_pCompositor->m_sSeat.exclusiveClient && !k.locked) || k.submap != m_szCurrentSelectedSubmap || (!pressed && !k.release) || k.shadowed)
             continue;
 
-        // oMg such performance hit!!11!
-        // this little maneouver is gonna cost us 4µs
-        const auto KBKEY = xkb_keysym_from_name(k.key.c_str(), XKB_KEYSYM_CASE_INSENSITIVE);
-        const auto KBKEYUPPER = xkb_keysym_to_upper(KBKEY);
-        // small TODO: fix 0-9 keys and other modified ones with shift
-        
-        if (key != KBKEY && key != KBKEYUPPER)
-            continue;
+        if (!key.empty()) {
+            if (key != k.key)
+                continue;
+        } else if (k.keycode != -1) {
+            if (keycode != k.keycode)
+                continue;
+        } else {
+            if (keysym == 0)
+                continue;  // this is a keycode check run
 
+            // oMg such performance hit!!11!
+            // this little maneouver is gonna cost us 4µs
+            const auto KBKEY = xkb_keysym_from_name(k.key.c_str(), XKB_KEYSYM_CASE_INSENSITIVE);
+            const auto KBKEYUPPER = xkb_keysym_to_upper(KBKEY);
+            // small TODO: fix 0-9 keys and other modified ones with shift
+
+            if (keysym != KBKEY && keysym != KBKEYUPPER)
+                continue;
+        }
+
+        if (pressed && k.release) {
+            // suppress down event
+            m_kHeldBack = keysym;
+            return true;
+        }
 
         const auto DISPATCHER = m_mDispatchers.find(k.handler);
 
@@ -99,8 +260,22 @@ bool CKeybindManager::handleKeybinds(const uint32_t& modmask, const xkb_keysym_t
             Debug::log(ERR, "Inavlid handler in a keybind! (handler %s does not exist)", k.handler.c_str());
         } else {
             // call the dispatcher
-            Debug::log(LOG, "Keybind triggered, calling dispatcher (%d, %d)", modmask, KBKEYUPPER);
+            Debug::log(LOG, "Keybind triggered, calling dispatcher (%d, %s, %d)", modmask, key.c_str(), keysym);
             DISPATCHER->second(k.arg);
+
+            if (k.handler == "submap") {
+                found = true; // don't process keybinds on submap change.
+                break;
+            }
+        }
+
+        if (k.repeat) {
+            m_pActiveKeybind = &k;
+            m_pActiveKeybindEventSource = wl_event_loop_add_timer(g_pCompositor->m_sWLEventLoop, repeatKeyHandler, &m_pActiveKeybind);
+
+            const auto PACTIVEKEEB = g_pInputManager->m_pActiveKeyboard;
+
+            wl_event_source_timer_update(m_pActiveKeybindEventSource, PACTIVEKEEB->repeatDelay);
         }
 
         found = true;
@@ -109,6 +284,42 @@ bool CKeybindManager::handleKeybinds(const uint32_t& modmask, const xkb_keysym_t
     return found;
 }
 
+void CKeybindManager::shadowKeybinds(const xkb_keysym_t& doesntHave, const int& doesntHaveCode) {
+    // shadow disables keybinds after one has been triggered
+
+    for (auto& k : m_lKeybinds) {
+
+        bool shadow = false;
+
+        const auto KBKEY = xkb_keysym_from_name(k.key.c_str(), XKB_KEYSYM_CASE_INSENSITIVE);
+        const auto KBKEYUPPER = xkb_keysym_to_upper(KBKEY);
+
+        for (auto& pk : m_dPressedKeysyms) {
+            if ((pk == KBKEY || pk == KBKEYUPPER)) {
+                shadow = true;
+                
+                if (pk == doesntHave && doesntHave != 0) {
+                    shadow = false;
+                    break;
+                }
+            }
+        }
+
+        for (auto& pk : m_dPressedKeycodes) {
+            if (pk == k.keycode) {
+                shadow = true;
+
+                if (pk == doesntHaveCode && doesntHaveCode != 0 && doesntHaveCode != -1) {
+                    shadow = false;
+                    break;
+                }
+            }
+        }
+
+        k.shadowed = shadow;
+    }
+}
+
 bool CKeybindManager::handleVT(xkb_keysym_t keysym) {
     // Handles the CTRL+ALT+FX TTY keybinds
     if (!(keysym >= XKB_KEY_XF86Switch_VT_1 && keysym <= XKB_KEY_XF86Switch_VT_12))
@@ -118,11 +329,11 @@ bool CKeybindManager::handleVT(xkb_keysym_t keysym) {
     if (PSESSION) {
         const int TTY = keysym - XKB_KEY_XF86Switch_VT_1 + 1;
         wlr_session_change_vt(PSESSION, TTY);
+        g_pCompositor->m_bSessionActive = false;
 
         for (auto& m : g_pCompositor->m_vMonitors) {
-            g_pHyprOpenGL->destroyMonitorResources(m.get());  // mark resources as unusable anymore
             m->noFrameSchedule = true;
-            m->framesToSkip = 2;
+            m->framesToSkip = 1;
         }
 
         Debug::log(LOG, "Switched to VT %i, destroyed all render data, frames to skip for each: 2", TTY);
@@ -204,14 +415,7 @@ void CKeybindManager::spawn(std::string args) {
 }
 
 void CKeybindManager::killActive(std::string args) {
-    if (g_pCompositor->m_pLastWindow && g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow)) {
-        g_pXWaylandManager->sendCloseWindow(g_pCompositor->m_pLastWindow);
-        g_pCompositor->m_pLastFocus = nullptr;
-        g_pCompositor->m_pLastWindow = nullptr;
-        g_pEventManager->postEvent(SHyprIPCEvent("activewindow", ",")); // post an activewindow event to empty, as we are currently unfocused
-    }
-    
-    g_pCompositor->focusWindow(g_pCompositor->windowFromCursor());
+    g_pCompositor->closeWindow(g_pCompositor->m_pLastWindow);
 }
 
 void CKeybindManager::clearKeybinds() {
@@ -231,9 +435,6 @@ void CKeybindManager::toggleActiveFloating(std::string args) {
             moveActiveToWorkspace(std::to_string(g_pCompositor->getMonitorFromID(ACTIVEWINDOW->m_iMonitorID)->activeWorkspace));
         }
 
-        ACTIVEWINDOW->m_vRealPosition.setValue(ACTIVEWINDOW->m_vRealPosition.vec() + Vector2D(5, 5));
-        ACTIVEWINDOW->m_vSize = ACTIVEWINDOW->m_vRealPosition.vec() - Vector2D(10, 10);
-
         g_pLayoutManager->getCurrentLayout()->changeWindowFloatingMode(ACTIVEWINDOW);
     }
 }
@@ -253,7 +454,14 @@ void CKeybindManager::changeworkspace(std::string args) {
     int workspaceToChangeTo = 0;
     std::string workspaceName = "";
 
-    workspaceToChangeTo = getWorkspaceIDFromString(args, workspaceName);
+    if (args.find("[internal]") == 0) {
+        workspaceToChangeTo = std::stoi(args.substr(10));
+        const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(workspaceToChangeTo);
+        if (PWORKSPACE)
+            workspaceName = PWORKSPACE->m_szName;
+    } else {
+        workspaceToChangeTo = getWorkspaceIDFromString(args, workspaceName);
+    }
 
     if (workspaceToChangeTo == INT_MAX) {
         Debug::log(ERR, "Error in changeworkspace, invalid value");
@@ -261,7 +469,7 @@ void CKeybindManager::changeworkspace(std::string args) {
     }
 
     // remove constraints 
-    g_pCompositor->m_sSeat.mouse->constraintActive = false;
+    g_pInputManager->unconstrainMouse();
 
     // if it exists, we warp to it
     if (g_pCompositor->getWorkspaceByID(workspaceToChangeTo)) {
@@ -277,20 +485,11 @@ void CKeybindManager::changeworkspace(std::string args) {
             const auto OLDWORKSPACEID = PMONITOR->activeWorkspace;
 
             // change it
-            PMONITOR->specialWorkspaceOpen = false;
-
             if (workspaceToChangeTo != SPECIAL_WORKSPACE_ID)
                 PMONITOR->activeWorkspace = workspaceToChangeTo;
             else
                 PMONITOR->specialWorkspaceOpen = true;
 
-            // we need to move XWayland windows to narnia or otherwise they will still process our cursor and shit
-            // and that'd be annoying as hell
-            g_pCompositor->fixXWaylandWindowsOnWorkspace(OLDWORKSPACEID);
-
-            // and fix on the new workspace
-            g_pCompositor->fixXWaylandWindowsOnWorkspace(PMONITOR->activeWorkspace);
-
             // here and only here begin anim. we don't want to anim visible workspaces on other monitors.
             // check if anim left or right
             const auto ANIMTOLEFT = workspaceToChangeTo > OLDWORKSPACEID;
@@ -301,13 +500,13 @@ void CKeybindManager::changeworkspace(std::string args) {
             // start anim on new workspace
             PWORKSPACETOCHANGETO->startAnim(true, ANIMTOLEFT);
 
-            g_pEventManager->postEvent(SHyprIPCEvent("workspace", PWORKSPACETOCHANGETO->m_szName));
+            g_pEventManager->postEvent(SHyprIPCEvent{"workspace", PWORKSPACETOCHANGETO->m_szName});
         }
 
         // If the monitor is not the one our cursor's at, warp to it.
         if (PMONITOR != g_pCompositor->getMonitorFromCursor()) {
             Vector2D middle = PMONITOR->vecPosition + PMONITOR->vecSize / 2.f;
-            wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, middle.x, middle.y);
+            g_pCompositor->warpCursorTo(middle);
         }
 
         // set active and deactivate all other in wlr
@@ -359,10 +558,6 @@ void CKeybindManager::changeworkspace(std::string args) {
     else
         PMONITOR->specialWorkspaceOpen = true;
 
-    // we need to move XWayland windows to narnia or otherwise they will still process our cursor and shit
-    // and that'd be annoying as hell
-    g_pCompositor->fixXWaylandWindowsOnWorkspace(OLDWORKSPACE);
-
     // set active and deactivate all other
     g_pCompositor->deactivateAllWLRWorkspaces(PWORKSPACE->m_pWlrHandle);
     PWORKSPACE->setActive(true);
@@ -374,7 +569,7 @@ void CKeybindManager::changeworkspace(std::string args) {
     g_pInputManager->refocus();
 
     // Event
-    g_pEventManager->postEvent(SHyprIPCEvent("workspace", PWORKSPACE->m_szName));
+    g_pEventManager->postEvent(SHyprIPCEvent{"workspace", PWORKSPACE->m_szName});
 
     Debug::log(LOG, "Changed to workspace %i", workspaceToChangeTo);
 }
@@ -389,7 +584,15 @@ void CKeybindManager::fullscreenActive(std::string args) {
 }
 
 void CKeybindManager::moveActiveToWorkspace(std::string args) {
-    const auto PWINDOW = g_pCompositor->m_pLastWindow;
+
+    CWindow* PWINDOW = nullptr;
+
+    if (args.contains(',')) {
+        PWINDOW = g_pCompositor->getWindowByRegex(args.substr(args.find_last_of(',') + 1));
+        args = args.substr(0, args.find_last_of(','));
+    } else {
+        PWINDOW = g_pCompositor->m_pLastWindow;
+    }
 
     if (!g_pCompositor->windowValidMapped(PWINDOW))
         return;
@@ -405,6 +608,9 @@ void CKeybindManager::moveActiveToWorkspace(std::string args) {
         return;
     }
 
+    auto PSAVEDSIZE = PWINDOW->m_vRealSize.vec();
+    auto PSAVEDPOS = PWINDOW->m_vRealPosition.vec();
+
     g_pLayoutManager->getCurrentLayout()->onWindowRemoved(PWINDOW);
 
     g_pKeybindManager->changeworkspace(args);
@@ -432,26 +638,27 @@ void CKeybindManager::moveActiveToWorkspace(std::string args) {
         PWORKSPACE->m_bHasFullscreenWindow = false;
     }
 
+    if (PWINDOW->m_bIsFullscreen) {
+        PWINDOW->m_bIsFullscreen = false;
+        PSAVEDPOS = PSAVEDPOS + Vector2D(10, 10);
+        PSAVEDSIZE = PSAVEDSIZE - Vector2D(20, 20);
+    }
+
     // Hack: So that the layout doesnt find our window at the cursor
     PWINDOW->m_vPosition = Vector2D(-42069, -42069);
     
-    // Save the real position and size because the layout might set its own
-    const auto PSAVEDSIZE = PWINDOW->m_vRealSize.vec();
-    const auto PSAVEDPOS = PWINDOW->m_vRealPosition.vec();
     g_pLayoutManager->getCurrentLayout()->onWindowCreated(PWINDOW);
-    // and restore it
-    PWINDOW->m_vRealPosition.setValue(PSAVEDPOS);
-    PWINDOW->m_vRealSize.setValue(PSAVEDSIZE);
 
+    // and restore it
     if (PWINDOW->m_bIsFloating) {
-        PWINDOW->m_vRealPosition.setValue(PWINDOW->m_vRealPosition.vec() - g_pCompositor->getMonitorFromID(OLDWORKSPACE->m_iMonitorID)->vecPosition);
-        PWINDOW->m_vRealPosition.setValue(PWINDOW->m_vRealPosition.vec() + g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID)->vecPosition);
+        PWINDOW->m_vRealSize.setValue(PSAVEDSIZE);
+        PWINDOW->m_vRealPosition.setValueAndWarp(PSAVEDPOS - g_pCompositor->getMonitorFromID(OLDWORKSPACE->m_iMonitorID)->vecPosition + g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID)->vecPosition);
         PWINDOW->m_vPosition = PWINDOW->m_vRealPosition.vec();
     }
 
     // undo the damage if we are moving to the special workspace
     if (WORKSPACEID == SPECIAL_WORKSPACE_ID) {
-        changeworkspace(std::to_string(OLDWORKSPACE->m_iID));
+        changeworkspace("[internal]" + std::to_string(OLDWORKSPACE->m_iID));
         OLDWORKSPACE->startAnim(true, true, true);
         toggleSpecialWorkspace("");
         g_pCompositor->getWorkspaceByID(SPECIAL_WORKSPACE_ID)->startAnim(false, false, true);
@@ -461,11 +668,27 @@ void CKeybindManager::moveActiveToWorkspace(std::string args) {
     }
 
     g_pInputManager->refocus();
+
+    PWINDOW->updateToplevel();
 }
 
 void CKeybindManager::moveActiveToWorkspaceSilent(std::string args) {
     // hacky, but works lol
 
+    CWindow* PWINDOW = nullptr;
+
+    const auto ORIGINALARGS = args;
+
+    if (args.contains(',')) {
+        PWINDOW = g_pCompositor->getWindowByRegex(args.substr(args.find_last_of(',') + 1));
+        args = args.substr(0, args.find_last_of(','));
+    } else {
+        PWINDOW = g_pCompositor->m_pLastWindow;
+    }
+
+    if (!g_pCompositor->windowValidMapped(PWINDOW))
+        return;
+
     int workspaceToMoveTo = 0;
     std::string workspaceName = "";
 
@@ -476,14 +699,9 @@ void CKeybindManager::moveActiveToWorkspaceSilent(std::string args) {
         return;
     }
 
-    const auto PWINDOW = g_pCompositor->m_pLastWindow;
-
-    if (!g_pCompositor->windowValidMapped(PWINDOW))
-        return;
-
     const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
 
-    if (workspaceToMoveTo == PMONITOR->activeWorkspace)
+    if (workspaceToMoveTo == PWINDOW->m_iWorkspaceID)
         return;
 
     // may be null until later!
@@ -499,12 +717,12 @@ void CKeybindManager::moveActiveToWorkspaceSilent(std::string args) {
 
     g_pEventManager->m_bIgnoreEvents = true;
 
-    moveActiveToWorkspace(args);
+    moveActiveToWorkspace(ORIGINALARGS);
 
     PWORKSPACE = g_pCompositor->getWorkspaceByID(workspaceToMoveTo);
 
-    changeworkspace(std::to_string(OLDWORKSPACEIDONMONITOR));
-    changeworkspace(std::to_string(OLDWORKSPACEIDRETURN));
+    changeworkspace("[internal]" + std::to_string(OLDWORKSPACEIDONMONITOR));
+    changeworkspace("[internal]" + std::to_string(OLDWORKSPACEIDRETURN));
 
     // revert animations
     PWORKSPACE->m_vRenderOffset.setValueAndWarp(Vector2D(0,0));
@@ -531,13 +749,27 @@ void CKeybindManager::moveFocusTo(std::string args) {
 
     const auto PLASTWINDOW = g_pCompositor->m_pLastWindow;
 
+    if (!PLASTWINDOW)
+        return;
+
     // remove constraints
-    g_pCompositor->m_sSeat.mouse->constraintActive = false;
+    g_pInputManager->unconstrainMouse();
 
     auto switchToWindow = [&](CWindow* PWINDOWTOCHANGETO) {
-        g_pCompositor->focusWindow(PWINDOWTOCHANGETO);
-        Vector2D middle = PWINDOWTOCHANGETO->m_vRealPosition.goalv() + PWINDOWTOCHANGETO->m_vRealSize.goalv() / 2.f;
-        wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, middle.x, middle.y);
+
+        if (PLASTWINDOW->m_iWorkspaceID == PWINDOWTOCHANGETO->m_iWorkspaceID && PLASTWINDOW->m_bIsFullscreen) {
+            const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PLASTWINDOW->m_iWorkspaceID);
+            const auto FSMODE = PWORKSPACE->m_efFullscreenMode;
+            g_pCompositor->setWindowFullscreen(PLASTWINDOW, false, FULLSCREEN_FULL);
+
+            g_pCompositor->focusWindow(PWINDOWTOCHANGETO);
+
+            g_pCompositor->setWindowFullscreen(PWINDOWTOCHANGETO, true, FSMODE);
+        } else {
+            g_pCompositor->focusWindow(PWINDOWTOCHANGETO);
+            Vector2D middle = PWINDOWTOCHANGETO->m_vRealPosition.goalv() + PWINDOWTOCHANGETO->m_vRealSize.goalv() / 2.f;
+            g_pCompositor->warpCursorTo(middle);
+        }
     };
 
     if (!g_pCompositor->windowValidMapped(PLASTWINDOW)) {
@@ -594,7 +826,7 @@ void CKeybindManager::moveActiveTo(std::string args) {
 
     const auto PLASTWINDOW = g_pCompositor->m_pLastWindow;
 
-    if (!g_pCompositor->windowValidMapped(PLASTWINDOW))
+    if (!g_pCompositor->windowValidMapped(PLASTWINDOW) || PLASTWINDOW->m_bIsFullscreen)
         return;
 
     const auto PWINDOWTOCHANGETO = g_pCompositor->getWindowInDirection(PLASTWINDOW, arg);
@@ -663,7 +895,7 @@ void CKeybindManager::focusMonitor(std::string arg) {
         }
 
         if (monID > -1 && monID < (int)g_pCompositor->m_vMonitors.size()) {
-            changeworkspace(std::to_string(g_pCompositor->getMonitorFromID(monID)->activeWorkspace));
+            changeworkspace("[internal]" + std::to_string(g_pCompositor->getMonitorFromID(monID)->activeWorkspace));
         } else {
             Debug::log(ERR, "Error in focusMonitor: invalid arg 1");
         }
@@ -683,7 +915,7 @@ void CKeybindManager::focusMonitor(std::string arg) {
         } else {
             for (auto& m : g_pCompositor->m_vMonitors) {
                 if (m->szName == arg) {
-                    changeworkspace(std::to_string(m->activeWorkspace));
+                    changeworkspace("[internal]" + std::to_string(m->activeWorkspace));
                     return;
                 }
             }
@@ -788,12 +1020,11 @@ void CKeybindManager::workspaceOpt(std::string args) {
 }
 
 void CKeybindManager::exitHyprland(std::string argz) {
-    g_pCompositor->cleanupExit();
-    exit(0);
+    g_pCompositor->cleanup();
 }
 
 void CKeybindManager::moveCurrentWorkspaceToMonitor(std::string args) {
-    SMonitor* PMONITOR = nullptr;
+    CMonitor* PMONITOR = nullptr;
 
     try {
         if (!isNumber(args) && !isDirection(args)) {
@@ -806,6 +1037,9 @@ void CKeybindManager::moveCurrentWorkspaceToMonitor(std::string args) {
         return;
     }
 
+    if (!PMONITOR)
+        return;
+
     // get the current workspace
     const auto PCURRENTWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->activeWorkspace);
 
@@ -816,13 +1050,13 @@ void CKeybindManager::moveCurrentWorkspaceToMonitor(std::string args) {
 }
 
 void CKeybindManager::moveWorkspaceToMonitor(std::string args) {
-    if (args.find_first_of(' ') == std::string::npos)
+    if (!args.contains(' '))
         return;
 
     std::string workspace = args.substr(0, args.find_first_of(' '));
     std::string monitor = args.substr(args.find_first_of(' ') + 1);
 
-    SMonitor* PMONITOR = nullptr;
+    CMonitor* PMONITOR = nullptr;
 
     try {
         if (!isNumber(monitor) && !isDirection(monitor)) {
@@ -891,7 +1125,12 @@ void CKeybindManager::toggleSpecialWorkspace(std::string args) {
         }
     } else {
         auto PSPECIALWORKSPACE = g_pCompositor->getWorkspaceByID(SPECIAL_WORKSPACE_ID);
-        
+
+        if (!PSPECIALWORKSPACE) {
+            // ??? happens sometimes...?
+            PSPECIALWORKSPACE = g_pCompositor->m_vWorkspaces.emplace_back(std::make_unique<CWorkspace>(g_pCompositor->m_pLastMonitor->ID, "special", true)).get();
+        }
+
         g_pCompositor->m_pLastMonitor->specialWorkspaceOpen = true;
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(g_pCompositor->m_pLastMonitor->ID);
 
@@ -918,149 +1157,107 @@ void CKeybindManager::forceRendererReload(std::string args) {
 }
 
 void CKeybindManager::resizeActive(std::string args) {
-    if (args.find_first_of(' ') == std::string::npos)
-        return;
-
-    std::string x = args.substr(0, args.find_first_of(' '));
-    std::string y = args.substr(args.find_first_of(' ') + 1);
-
-    if (x == "exact") {
-        std::string newX = y.substr(0, y.find_first_of(' '));
-        std::string newY = y.substr(y.find_first_of(' ') + 1);
-
-        if (!isNumber(newX) || !isNumber(newY)) {
-            Debug::log(ERR, "resizeTiledWindow: exact args not numbers");
-            return;
-        }
-
-        const int X = std::stoi(newX);
-        const int Y = std::stoi(newY);
-
-        if (X < 10 || Y < 10) {
-            Debug::log(ERR, "resizeTiledWindow: exact args cannot be < 10");
-            return;
-        }
-
-        // calc the delta
-        if (!g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow))
-            return; // ignore
-
-        const auto PWINDOW = g_pCompositor->m_pLastWindow;
-
-        const int DX = X - PWINDOW->m_vRealSize.goalv().x;
-        const int DY = Y - PWINDOW->m_vRealSize.goalv().y;
-
-        g_pLayoutManager->getCurrentLayout()->resizeActiveWindow(Vector2D(DX, DY));
-
-        return;
-    }
-
-    if (!isNumber(x) || !isNumber(y)) {
-        Debug::log(ERR, "resizeTiledWindow: args not numbers");
-        return;
-    }
-
-    const int X = std::stoi(x);
-    const int Y = std::stoi(y);
-
-    g_pLayoutManager->getCurrentLayout()->resizeActiveWindow(Vector2D(X, Y));
-}
-
-void CKeybindManager::moveActive(std::string args) {
-    if (args.find_first_of(' ') == std::string::npos)
-        return;
-
-    std::string x = args.substr(0, args.find_first_of(' '));
-    std::string y = args.substr(args.find_first_of(' ') + 1);
-
-    if (x == "exact") {
-        std::string newX = y.substr(0, y.find_first_of(' '));
-        std::string newY = y.substr(y.find_first_of(' ') + 1);
-
-        if (!isNumber(newX) || !isNumber(newY)) {
-            Debug::log(ERR, "moveActive: exact args not numbers");
-            return;
-        }
-
-        const int X = std::stoi(newX);
-        const int Y = std::stoi(newY);
-
-        if (X < 0 || Y < 0) {
-            Debug::log(ERR, "moveActive: exact args cannot be < 0");
-            return;
-        }
-
-        // calc the delta
-        if (!g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow))
-            return;  // ignore
-
-        const auto PWINDOW = g_pCompositor->m_pLastWindow;
-
-        const int DX = X - PWINDOW->m_vRealPosition.goalv().x;
-        const int DY = Y - PWINDOW->m_vRealPosition.goalv().y;
-
-        g_pLayoutManager->getCurrentLayout()->moveActiveWindow(Vector2D(DX, DY));
-
-        return;
-    }
-
-    if (!isNumber(x) || !isNumber(y)) {
-        Debug::log(ERR, "moveActive: args not numbers");
-        return;
-    }
-
-    const int X = std::stoi(x);
-    const int Y = std::stoi(y);
-
-    g_pLayoutManager->getCurrentLayout()->moveActiveWindow(Vector2D(X, Y));
-}
-
-void CKeybindManager::circleNext(std::string) {
     if (!g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow))
         return;
 
-    g_pCompositor->focusWindow(g_pCompositor->getNextWindowOnWorkspace(g_pCompositor->m_pLastWindow));
+    const auto SIZ = g_pCompositor->parseWindowVectorArgsRelative(args, g_pCompositor->m_pLastWindow->m_vRealSize.goalv());
 
-    const auto MIDPOINT = g_pCompositor->m_pLastWindow->m_vRealPosition.goalv() + g_pCompositor->m_pLastWindow->m_vRealSize.goalv() / 2.f;
+    g_pLayoutManager->getCurrentLayout()->resizeActiveWindow(SIZ - g_pCompositor->m_pLastWindow->m_vRealSize.goalv());
 
-    wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, MIDPOINT.x, MIDPOINT.y);
+    if (g_pCompositor->m_pLastWindow->m_vRealSize.goalv().x > 1 && g_pCompositor->m_pLastWindow->m_vRealSize.goalv().y > 1)
+        g_pCompositor->m_pLastWindow->m_bHidden = false;
+}
+
+void CKeybindManager::moveActive(std::string args) {
+    if (!g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow))
+        return;
+
+    const auto POS = g_pCompositor->parseWindowVectorArgsRelative(args, g_pCompositor->m_pLastWindow->m_vRealPosition.goalv());
+
+    g_pLayoutManager->getCurrentLayout()->moveActiveWindow(POS - g_pCompositor->m_pLastWindow->m_vRealPosition.goalv());
+}
+
+void CKeybindManager::moveWindow(std::string args) {
+
+    const auto WINDOWREGEX = args.substr(args.find_first_of(',') + 1);
+    const auto MOVECMD = args.substr(0, args.find_first_of(','));
+
+    const auto PWINDOW = g_pCompositor->getWindowByRegex(WINDOWREGEX);
+
+    if (!PWINDOW) {
+        Debug::log(ERR, "moveWindow: no window");
+        return;
+    }
+
+    const auto POS = g_pCompositor->parseWindowVectorArgsRelative(MOVECMD, PWINDOW->m_vRealPosition.goalv());
+
+    g_pLayoutManager->getCurrentLayout()->moveActiveWindow(POS - PWINDOW->m_vRealPosition.goalv(), PWINDOW);
+}
+
+void CKeybindManager::resizeWindow(std::string args) {
+
+    const auto WINDOWREGEX = args.substr(args.find_first_of(',') + 1);
+    const auto MOVECMD = args.substr(0, args.find_first_of(','));
+
+    const auto PWINDOW = g_pCompositor->getWindowByRegex(WINDOWREGEX);
+
+    if (!PWINDOW) {
+        Debug::log(ERR, "resizeWindow: no window");
+        return;
+    }
+
+    const auto SIZ = g_pCompositor->parseWindowVectorArgsRelative(MOVECMD, PWINDOW->m_vRealSize.goalv());
+
+    g_pLayoutManager->getCurrentLayout()->resizeActiveWindow(SIZ - PWINDOW->m_vRealSize.goalv(), PWINDOW);
+
+    if (PWINDOW->m_vRealSize.goalv().x > 1 && PWINDOW->m_vRealSize.goalv().y > 1)
+        PWINDOW->m_bHidden = false;
+}
+
+void CKeybindManager::circleNext(std::string arg) {
+    if (!g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow))
+        return;
+
+    auto switchToWindow = [&](CWindow* PWINDOWTOCHANGETO) {
+        if (PWINDOWTOCHANGETO == g_pCompositor->m_pLastWindow || !PWINDOWTOCHANGETO)
+            return;
+
+        if (g_pCompositor->m_pLastWindow->m_iWorkspaceID == PWINDOWTOCHANGETO->m_iWorkspaceID && g_pCompositor->m_pLastWindow->m_bIsFullscreen) {
+            const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastWindow->m_iWorkspaceID);
+            const auto FSMODE = PWORKSPACE->m_efFullscreenMode;
+            g_pCompositor->setWindowFullscreen(g_pCompositor->m_pLastWindow, false, FULLSCREEN_FULL);
+
+            g_pCompositor->focusWindow(PWINDOWTOCHANGETO);
+
+            g_pCompositor->setWindowFullscreen(PWINDOWTOCHANGETO, true, FSMODE);
+        } else {
+            g_pCompositor->focusWindow(PWINDOWTOCHANGETO);
+            Vector2D middle = PWINDOWTOCHANGETO->m_vRealPosition.goalv() + PWINDOWTOCHANGETO->m_vRealSize.goalv() / 2.f;
+            g_pCompositor->warpCursorTo(middle);
+        }
+    };
+
+    if (arg == "last" || arg == "l" || arg == "prev" || arg == "p")
+        switchToWindow(g_pCompositor->getPrevWindowOnWorkspace(g_pCompositor->m_pLastWindow));
+    else
+        switchToWindow(g_pCompositor->getNextWindowOnWorkspace(g_pCompositor->m_pLastWindow));
 }
 
 void CKeybindManager::focusWindow(std::string regexp) {
-    bool titleRegex = false;
-    std::regex regexCheck(regexp);
-    if (regexp.find("title:") == 0) {
-        titleRegex = true;
-        regexCheck = std::regex(regexp.substr(6));
-    }
+    const auto PWINDOW = g_pCompositor->getWindowByRegex(regexp);
 
-    for (auto& w : g_pCompositor->m_vWindows) {
-        if (!w->m_bIsMapped || w->m_bHidden)
-            continue;
+    if (!PWINDOW)
+        return;
 
-        if (titleRegex) {
-            const auto windowTitle = g_pXWaylandManager->getTitle(w.get());
-            if (!std::regex_search(windowTitle, regexCheck))
-                continue;
-        }
-        else {
-            const auto windowClass = g_pXWaylandManager->getAppIDClass(w.get());
-            if (!std::regex_search(windowClass, regexCheck))
-                continue;
-        }
+    Debug::log(LOG, "Focusing to window name: %s", PWINDOW->m_szTitle.c_str());
 
-        Debug::log(LOG, "Focusing to window name: %s", w->m_szTitle.c_str());
+    changeworkspace("[internal]" + std::to_string(PWINDOW->m_iWorkspaceID));
 
-        changeworkspace(std::to_string(w->m_iWorkspaceID));
+    g_pCompositor->focusWindow(PWINDOW);
 
-        g_pCompositor->focusWindow(w.get());
+    const auto MIDPOINT = PWINDOW->m_vRealPosition.goalv() + PWINDOW->m_vRealSize.goalv() / 2.f;
 
-        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;
-    }
+    g_pCompositor->warpCursorTo(MIDPOINT);
 }
 
 void CKeybindManager::setSubmap(std::string submap) {
@@ -1080,3 +1277,67 @@ void CKeybindManager::setSubmap(std::string submap) {
 
     Debug::log(ERR, "Cannot set submap %s, submap doesn't exist (wasn't registered!)", submap.c_str());
 }
+
+void CKeybindManager::pass(std::string regexp) {
+
+    // find the first window passing the regex
+    const auto PWINDOW = g_pCompositor->getWindowByRegex(regexp);
+
+    if (!PWINDOW) {
+        Debug::log(ERR, "pass: window not found");
+        return;
+    }
+
+    const auto PLASTSRF = g_pCompositor->m_pLastFocus;
+
+    const auto KEYBOARD = wlr_seat_get_keyboard(g_pCompositor->m_sSeat.seat);
+
+    if (!KEYBOARD){
+        Debug::log(ERR, "No kb in pass?");
+        return;
+    }
+
+    // pass all mf shit
+    wlr_seat_keyboard_notify_enter(g_pCompositor->m_sSeat.seat, g_pXWaylandManager->getWindowSurface(PWINDOW), KEYBOARD->keycodes, KEYBOARD->num_keycodes, &KEYBOARD->modifiers);
+
+    wlr_keyboard_modifiers kbmods = {g_pInputManager->accumulateModsFromAllKBs(), 0, 0, 0};
+    wlr_seat_keyboard_notify_modifiers(g_pCompositor->m_sSeat.seat, &kbmods);
+
+    wlr_seat_keyboard_notify_key(g_pCompositor->m_sSeat.seat, g_pKeybindManager->m_uTimeLastMs, g_pKeybindManager->m_uLastCode - 8, WLR_BUTTON_PRESSED);
+    wlr_seat_keyboard_notify_key(g_pCompositor->m_sSeat.seat, g_pKeybindManager->m_uTimeLastMs, g_pKeybindManager->m_uLastCode - 8, WLR_BUTTON_RELEASED);
+
+    wlr_seat_keyboard_notify_enter(g_pCompositor->m_sSeat.seat, PLASTSRF, KEYBOARD->keycodes, KEYBOARD->num_keycodes, &KEYBOARD->modifiers);
+}
+
+void CKeybindManager::layoutmsg(std::string msg) {
+    SLayoutMessageHeader hd = {g_pCompositor->m_pLastWindow};
+    g_pLayoutManager->getCurrentLayout()->layoutMessage(hd, msg);
+}
+
+void CKeybindManager::toggleOpaque(std::string unused) {
+    const auto PWINDOW = g_pCompositor->m_pLastWindow;
+
+    if (!g_pCompositor->windowValidMapped(PWINDOW))
+        return;
+
+    PWINDOW->m_sAdditionalConfigData.forceOpaque = !PWINDOW->m_sAdditionalConfigData.forceOpaque;
+
+    g_pHyprRenderer->damageWindow(PWINDOW);
+}
+
+void CKeybindManager::dpms(std::string arg) {
+    bool enable = arg == "on";
+
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        wlr_output_enable(m->output, enable);
+        
+        if (!wlr_output_commit(m->output)) {
+            Debug::log(ERR, "Couldn't commit output %s", m->szName.c_str());
+        }
+
+        if (enable)
+            g_pHyprRenderer->damageMonitor(m.get());
+    }
+
+    g_pCompositor->m_bDPMSStateON = enable;
+}

src/managers/KeybindManager.hpp

@@ -6,32 +6,66 @@
 #include <unordered_map>
 #include <functional>
 
+class CInputManager;
+
 struct SKeybind {
-    std::string       key = 0;
+    std::string       key = "";
+    int               keycode = -1;
     uint32_t          modmask = 0;
     std::string       handler = "";
     std::string       arg = "";
     bool              locked = false;
     std::string       submap = "";
+    bool              release = false;
+    bool              repeat = false;
+
+    // DO NOT INITIALIZE
+    bool              shadowed = false;
+};
+
+enum eFocusWindowMode {
+    MODE_CLASS_REGEX = 0,
+    MODE_TITLE_REGEX,
+    MODE_ADDRESS,
+    MODE_PID
 };
 
 class CKeybindManager {
 public:
     CKeybindManager();
 
-    bool                handleKeybinds(const uint32_t&, const xkb_keysym_t&);
+    bool                onKeyEvent(wlr_keyboard_key_event*, SKeyboard*);
+    bool                onAxisEvent(wlr_pointer_axis_event*);
+    bool                onMouseEvent(wlr_pointer_button_event*);
+    
     void                addKeybind(SKeybind);
     void                removeKeybind(uint32_t, const std::string&);
     uint32_t            stringToModMask(std::string);
     void                clearKeybinds();
+    void                shadowKeybinds(const xkb_keysym_t& doesntHave = 0, const int& doesntHaveCode = 0);
 
     std::unordered_map<std::string, std::function<void(std::string)>> m_mDispatchers;
 
+    wl_event_source*    m_pActiveKeybindEventSource = nullptr;
+
 private:
     std::list<SKeybind> m_lKeybinds;
+    std::deque<xkb_keysym_t> m_dPressedKeysyms;
+    std::deque<int>     m_dPressedKeycodes;
 
     inline static std::string m_szCurrentSelectedSubmap = "";
 
+    xkb_keysym_t        m_kHeldBack = 0;
+
+    SKeybind*           m_pActiveKeybind = nullptr;
+
+    uint32_t            m_uTimeLastMs = 0;
+    uint32_t            m_uLastCode = 0;
+
+    CTimer              m_tScrollTimer;
+
+    bool                handleKeybinds(const uint32_t&, const std::string&, const xkb_keysym_t&, const int&, bool, uint32_t);
+
     bool                handleInternalKeybinds(xkb_keysym_t);
     bool                handleVT(xkb_keysym_t);
 
@@ -60,11 +94,18 @@ private:
     static void         forceRendererReload(std::string);
     static void         resizeActive(std::string);
     static void         moveActive(std::string);
+    static void         moveWindow(std::string);
+    static void         resizeWindow(std::string);
     static void         circleNext(std::string);
     static void         focusWindow(std::string);
     static void         setSubmap(std::string);
+    static void         pass(std::string);
+    static void         layoutmsg(std::string);
+    static void         toggleOpaque(std::string);
+    static void         dpms(std::string);
 
     friend class CCompositor;
+    friend class CInputManager;
 };
 
-inline std::unique_ptr<CKeybindManager> g_pKeybindManager;
+inline std::unique_ptr<CKeybindManager> g_pKeybindManager;

src/managers/LayoutManager.cpp

@@ -4,8 +4,28 @@ IHyprLayout* CLayoutManager::getCurrentLayout() {
     switch (m_iCurrentLayoutID) {
         case DWINDLE: 
             return &m_cDwindleLayout;
+        case MASTER:
+            return &m_cMasterLayout;
     }
 
     // fallback
     return &m_cDwindleLayout;
+}
+
+void CLayoutManager::switchToLayout(std::string layout) {
+    if (layout == "dwindle") {
+        if (m_iCurrentLayoutID != DWINDLE) {
+            getCurrentLayout()->onDisable();
+            m_iCurrentLayoutID = DWINDLE;
+            getCurrentLayout()->onEnable();
+        }
+    } else if (layout == "master") {
+        if (m_iCurrentLayoutID != MASTER) {
+            getCurrentLayout()->onDisable();
+            m_iCurrentLayoutID = MASTER;
+            getCurrentLayout()->onEnable();
+        }
+    } else {
+        Debug::log(ERR, "Unknown layout %s!", layout.c_str());
+    }
 }

src/managers/LayoutManager.hpp

@@ -1,20 +1,25 @@
 #pragma once
 
 #include "../layout/DwindleLayout.hpp"
+#include "../layout/MasterLayout.hpp"
 
 class CLayoutManager {
 public:
 
     IHyprLayout*    getCurrentLayout();
 
+    void            switchToLayout(std::string);
+
 private:
     enum HYPRLAYOUTS {
         DWINDLE = 0,
+        MASTER
     };
 
     HYPRLAYOUTS m_iCurrentLayoutID = DWINDLE;
 
     CHyprDwindleLayout m_cDwindleLayout;
+    CHyprMasterLayout  m_cMasterLayout;
 };
 
 inline std::unique_ptr<CLayoutManager> g_pLayoutManager;

src/managers/ThreadManager.cpp

@@ -1,34 +1,31 @@
 #include "ThreadManager.hpp"
 #include "../debug/HyprCtl.hpp"
-
-CThreadManager::CThreadManager() {
-    m_tMainThread = new std::thread([&]() {
-        // Call the handle method.
-        this->handle();
-    });
-
-    m_tMainThread->detach(); // detach and continue.
-}
-
-CThreadManager::~CThreadManager() {
-    //
-}
+#include "../Compositor.hpp"
 
 int slowUpdate = 0;
 
-void CThreadManager::handle() {
+int handleTimer(void* data) {
+    const auto PTM = (CThreadManager*)data;
 
+    g_pConfigManager->tick();
+
+    wl_event_source_timer_update(PTM->m_esConfigTimer, 1000);
+
+    return 0;
+}
+
+CThreadManager::CThreadManager() {
     g_pConfigManager->init();
 
     HyprCtl::startHyprCtlSocket();
 
-    while (3.1415f) {
-        slowUpdate++;
-        if (slowUpdate >= g_pConfigManager->getInt("general:max_fps")){
-            g_pConfigManager->tick();
-            slowUpdate = 0;
-        }
+    g_pCompositor->startHyprCtlTick();
 
-        std::this_thread::sleep_for(std::chrono::microseconds(1000000 / g_pConfigManager->getInt("general:max_fps")));
-    }
+    m_esConfigTimer = wl_event_loop_add_timer(g_pCompositor->m_sWLEventLoop, handleTimer, this);
+
+    wl_event_source_timer_update(m_esConfigTimer, 1000);
+}
+
+CThreadManager::~CThreadManager() {
+    //
 }

src/managers/ThreadManager.hpp

@@ -9,11 +9,9 @@ public:
     CThreadManager();
     ~CThreadManager();
 
-private:
+    wl_event_source* m_esConfigTimer;
 
-    void                handle();
-
-    std::thread*        m_tMainThread;
+   private:
 };
 
 inline std::unique_ptr<CThreadManager> g_pThreadManager;

src/managers/XWaylandManager.cpp

@@ -36,7 +36,9 @@ void CHyprXWaylandManager::activateSurface(wlr_surface* pSurface, bool activate)
         wlr_xdg_toplevel_set_activated(wlr_xdg_surface_from_wlr_surface(pSurface)->toplevel, activate);
     else if (wlr_surface_is_xwayland_surface(pSurface)) {
         wlr_xwayland_surface_activate(wlr_xwayland_surface_from_wlr_surface(pSurface), activate);
-        wlr_xwayland_surface_restack(wlr_xwayland_surface_from_wlr_surface(pSurface), NULL, XCB_STACK_MODE_ABOVE);
+
+        if (activate)
+            wlr_xwayland_surface_restack(wlr_xwayland_surface_from_wlr_surface(pSurface), NULL, XCB_STACK_MODE_ABOVE);
     }
         
 }
@@ -118,7 +120,14 @@ void CHyprXWaylandManager::sendCloseWindow(CWindow* pWindow) {
     }
 }
 
-void CHyprXWaylandManager::setWindowSize(CWindow* pWindow, const Vector2D& size) {
+void CHyprXWaylandManager::setWindowSize(CWindow* pWindow, const Vector2D& size, bool force) {
+
+    if (!force && ((pWindow->m_vReportedSize == size && pWindow->m_vRealPosition.vec() == pWindow->m_vReportedPosition) || (pWindow->m_vReportedSize == size && !pWindow->m_bIsX11)))
+        return;
+
+    pWindow->m_vReportedPosition = pWindow->m_vRealPosition.vec();
+    pWindow->m_vReportedSize = 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
@@ -146,14 +155,17 @@ bool CHyprXWaylandManager::shouldBeFloated(CWindow* pWindow) {
                 pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_DOCK"] || pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"] ||
                 pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_MENU"])
                     {
-                pWindow->m_bNoInitialFocus = true;
-                return true;
+                        if (pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"] || pWindow->m_uSurface.xwayland->window_type[i] == HYPRATOMS["_NET_WM_WINDOW_TYPE_MENU"])
+                            pWindow->m_bX11ShouldntFocus = true;
+                        
+                        pWindow->m_bNoInitialFocus = true;
+                        return true;
                     }
 
         if (pWindow->m_uSurface.xwayland->role) {
             try {
                 std::string winrole = std::string(pWindow->m_uSurface.xwayland->role);
-                if (winrole.find("pop-up") != std::string::npos || winrole.find("task_dialog") != std::string::npos) {
+                if (winrole.contains("pop-up") || winrole.contains("task_dialog")) {
                     return true;
                 }
             } catch (std::exception& e) {
@@ -221,6 +233,22 @@ void CHyprXWaylandManager::setWindowFullscreen(CWindow* pWindow, bool fullscreen
 
     if (pWindow->m_phForeignToplevel)
         wlr_foreign_toplevel_handle_v1_set_fullscreen(pWindow->m_phForeignToplevel, fullscreen);
+}
 
-    g_pEventManager->postEvent(SHyprIPCEvent("fullscreen", std::to_string((int)fullscreen)));
-}
+Vector2D CHyprXWaylandManager::getMaxSizeForWindow(CWindow* pWindow) {
+    if (!g_pCompositor->windowValidMapped(pWindow))
+        return Vector2D(99999, 99999);
+
+    if ((pWindow->m_bIsX11 && !pWindow->m_uSurface.xwayland->size_hints) || (!pWindow->m_bIsX11 && !pWindow->m_uSurface.xdg->toplevel))
+        return Vector2D(99999, 99999);
+
+    auto MAXSIZE = pWindow->m_bIsX11 ? Vector2D(pWindow->m_uSurface.xwayland->size_hints->max_width, pWindow->m_uSurface.xwayland->size_hints->max_height)
+                                     : Vector2D(pWindow->m_uSurface.xdg->toplevel->current.max_width, pWindow->m_uSurface.xdg->toplevel->current.max_height);
+
+    if (MAXSIZE.x < 5)
+        MAXSIZE.x = 99999;
+    if (MAXSIZE.y < 5)
+        MAXSIZE.y = 99999;
+
+    return MAXSIZE;
+}

src/managers/XWaylandManager.hpp

@@ -17,13 +17,14 @@ public:
     std::string         getTitle(CWindow*);
     std::string         getAppIDClass(CWindow*);
     void                sendCloseWindow(CWindow*);
-    void                setWindowSize(CWindow*, const Vector2D&);
+    void                setWindowSize(CWindow*, const Vector2D&, bool force = false);
     void                setWindowStyleTiled(CWindow*, uint32_t);
     void                setWindowFullscreen(CWindow*, bool);
     wlr_surface*        surfaceAt(CWindow*, const Vector2D&, Vector2D&);
     bool                shouldBeFloated(CWindow*);
     void                moveXWaylandWindow(CWindow*, const Vector2D&);
     void                checkBorders(CWindow*);
+    Vector2D            getMaxSizeForWindow(CWindow*);
 };
 
 inline std::unique_ptr<CHyprXWaylandManager> g_pXWaylandManager;

src/managers/input/IdleInhibitor.cpp

@@ -0,0 +1,54 @@
+#include "InputManager.hpp"
+#include "../../Compositor.hpp"
+
+void Events::listener_newIdleInhibitor(wl_listener* listener, void* data) {
+    const auto WLRIDLEINHIBITOR = (wlr_idle_inhibitor_v1*)data;
+
+    if (!WLRIDLEINHIBITOR)
+        return;
+
+    g_pInputManager->newIdleInhibitor(WLRIDLEINHIBITOR);
+}
+
+void CInputManager::newIdleInhibitor(wlr_idle_inhibitor_v1* pInhibitor) {
+    const auto PINHIBIT = &m_lIdleInhibitors.emplace_back();
+
+    Debug::log(LOG, "New idle inhibitor registered");
+
+    PINHIBIT->pWlrInhibitor = pInhibitor;
+
+    PINHIBIT->hyprListener_Destroy.initCallback(&pInhibitor->events.destroy, [](void* owner, void* data){
+
+        const auto PINH = (SIdleInhibitor*)owner;
+
+        g_pInputManager->m_lIdleInhibitors.remove(*PINH);
+
+        Debug::log(LOG, "Destroyed an idleinhibitor");
+
+        g_pInputManager->recheckIdleInhibitorStatus();
+
+    }, PINHIBIT, "IdleInhibitor");
+
+    PINHIBIT->pWindow = g_pCompositor->getWindowFromSurface(pInhibitor->surface);
+
+    if (PINHIBIT->pWindow)
+        Debug::log(LOG, "IdleInhibitor got window %x (%s)", PINHIBIT->pWindow, PINHIBIT->pWindow->m_szTitle.c_str());
+
+    recheckIdleInhibitorStatus();
+}
+
+void CInputManager::recheckIdleInhibitorStatus() {
+
+    for (auto& ii : m_lIdleInhibitors) {
+        if (!ii.pWindow) {
+            wlr_idle_set_enabled(g_pCompositor->m_sWLRIdle, g_pCompositor->m_sSeat.seat, false);
+            return;
+        } else if (g_pHyprRenderer->shouldRenderWindow(ii.pWindow)) {
+            wlr_idle_set_enabled(g_pCompositor->m_sWLRIdle, g_pCompositor->m_sSeat.seat, false);
+            return;
+        }
+    }
+
+    wlr_idle_set_enabled(g_pCompositor->m_sWLRIdle, g_pCompositor->m_sSeat.seat, true);
+    return;
+}

src/managers/input/InputManager.cpp

@@ -28,6 +28,11 @@ void CInputManager::onMouseWarp(wlr_pointer_motion_absolute_event* e) {
 
 void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
 
+    static auto *const PFOLLOWMOUSE = &g_pConfigManager->getConfigValuePtr("input:follow_mouse")->intValue;
+    static auto *const PMOUSEDPMS = &g_pConfigManager->getConfigValuePtr("misc:mouse_move_enables_dpms")->intValue;
+    static auto *const PFOLLOWONDND = &g_pConfigManager->getConfigValuePtr("misc:always_follow_on_dnd")->intValue;
+    static auto *const PHOGFOCUS = &g_pConfigManager->getConfigValuePtr("misc:layers_hog_keyboard_focus")->intValue;
+
     if (!g_pCompositor->m_bReadyToProcess)
         return;
 
@@ -36,6 +41,14 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
         return;
     }
 
+    if (g_pCompositor->m_sSeat.mouse->virt)
+        return; // don't refocus on virt
+
+    if (!g_pCompositor->m_bDPMSStateON && *PMOUSEDPMS) {
+        // enable dpms
+        g_pKeybindManager->dpms("on");
+    }
+
     Vector2D mouseCoords = getMouseCoordsInternal();
     const auto MOUSECOORDSFLOORED = mouseCoords.floor();
 
@@ -56,7 +69,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
         const auto CONSTRAINTWINDOW = g_pCompositor->getConstraintWindow(g_pCompositor->m_sSeat.mouse);
 
         if (!CONSTRAINTWINDOW) {
-            g_pCompositor->m_sSeat.mouse->currentConstraint = nullptr;
+            unconstrainMouse();
         } else {
             // Native Wayland apps know how 2 constrain themselves.
             // XWayland, we just have to accept them. Might cause issues, but thats XWayland for ya.
@@ -112,7 +125,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
         ACTIVEWORKSPACE->setActive(true);
 
         // event
-        g_pEventManager->postEvent(SHyprIPCEvent("activemon", PMONITOR->szName + "," + ACTIVEWORKSPACE->m_szName));
+        g_pEventManager->postEvent(SHyprIPCEvent{"focusedmon", PMONITOR->szName + "," + ACTIVEWORKSPACE->m_szName});
     }
 
     Vector2D surfaceCoords;
@@ -139,6 +152,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
 
                 if (!pFoundWindow->m_bIsX11) {
                     foundSurface = g_pCompositor->vectorWindowToSurface(mouseCoords, pFoundWindow, surfaceCoords);
+                    surfacePos = Vector2D(-1337, -1337);
                 } else {
                     foundSurface = g_pXWaylandManager->getWindowSurface(pFoundWindow);
                     surfacePos = pFoundWindow->m_vRealPosition.vec();
@@ -154,11 +168,29 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
 
     // then windows
     if (!foundSurface) {
-        if (PWORKSPACE->m_bHasFullscreenWindow && PWORKSPACE->m_efFullscreenMode == FULLSCREEN_MAXIMIZED)
-            pFoundWindow = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
-        else
+        if (PWORKSPACE->m_bHasFullscreenWindow && PWORKSPACE->m_efFullscreenMode == FULLSCREEN_MAXIMIZED) {
+
+            if (PMONITOR->specialWorkspaceOpen) {
+                pFoundWindow = g_pCompositor->vectorToWindowIdeal(mouseCoords);
+
+                if (pFoundWindow && pFoundWindow->m_iWorkspaceID != SPECIAL_WORKSPACE_ID) {
+                    pFoundWindow = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
+                }
+            } else {
+                pFoundWindow = g_pCompositor->vectorToWindowIdeal(mouseCoords);
+
+                if (!(pFoundWindow && pFoundWindow->m_bIsFloating && pFoundWindow->m_bCreatedOverFullscreen))
+                    pFoundWindow = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
+            }
+        } else {
             pFoundWindow = g_pCompositor->vectorToWindowIdeal(mouseCoords);
 
+            // TODO: this causes crashes, sometimes. ???
+           // if (refocus && !pFoundWindow) {
+           //     pFoundWindow = g_pCompositor->getFirstWindowOnWorkspace(PMONITOR->activeWorkspace);
+           // }
+        }
+
         if (pFoundWindow) {
             if (!pFoundWindow->m_bIsX11) {
                 foundSurface = g_pCompositor->vectorWindowToSurface(mouseCoords, pFoundWindow, surfaceCoords);
@@ -184,6 +216,10 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
 
         wlr_seat_pointer_clear_focus(g_pCompositor->m_sSeat.seat);
 
+        if (refocus) { // if we are forcing a refocus, and we don't find a surface, clear the kb focus too!
+            g_pCompositor->focusWindow(nullptr);
+        }
+
         return;
     }
 
@@ -200,23 +236,48 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
         surfaceLocal = mouseCoords - surfacePos + Vector2D(geom.x, geom.y);
     }
 
+    bool allowKeyboardRefocus = true;
+
+    if (*PHOGFOCUS && !refocus && g_pCompositor->m_pLastFocus) {
+        const auto PLS = g_pCompositor->getLayerSurfaceFromSurface(g_pCompositor->m_pLastFocus);
+
+        if (PLS && PLS->layerSurface->current.keyboard_interactive) {
+            allowKeyboardRefocus = false;
+        }
+    }
+
     if (pFoundWindow) {
-        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);
+                if (*PFOLLOWMOUSE != 3 && allowKeyboardRefocus)
+                    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);
             }
+
+            if (pFoundWindow == g_pCompositor->m_pLastWindow && foundSurface != g_pCompositor->m_pLastFocus) {
+                // we changed the subsurface
+                wlr_seat_pointer_notify_enter(g_pCompositor->m_sSeat.seat, foundSurface, surfaceLocal.x, surfaceLocal.y);
+            }
+
+            if (*PFOLLOWONDND && m_sDrag.dragIcon) {
+                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
         } else {
-            g_pCompositor->focusWindow(pFoundWindow, foundSurface);
+            if (*PFOLLOWMOUSE != 3 && allowKeyboardRefocus)
+                g_pCompositor->focusWindow(pFoundWindow, foundSurface);
         }
-    } else if (pFoundLayerSurface && pFoundLayerSurface->layerSurface->current.keyboard_interactive)
-        g_pCompositor->focusSurface(foundSurface);
+    } else {
+        if (pFoundLayerSurface && pFoundLayerSurface->layerSurface->current.keyboard_interactive && *PFOLLOWMOUSE != 3 && allowKeyboardRefocus) {
+            g_pCompositor->focusSurface(foundSurface);
+            g_pCompositor->m_pLastWindow = nullptr; // reset last window as we have a full focus on a LS
+        }
+    }
 
     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);
@@ -275,7 +336,7 @@ void CInputManager::setClickMode(eClickBehaviorMode mode) {
             m_ecbClickBehavior = CLICKMODE_KILL;
 
             // remove constraints
-            g_pCompositor->m_sSeat.mouse->constraintActive = false;
+            g_pInputManager->unconstrainMouse();
             refocus();
 
             // set cursor
@@ -294,6 +355,13 @@ void CInputManager::processMouseDownNormal(wlr_pointer_button_event* e) {
         return;
     }
 
+    // notify the keybind manager
+    static auto *const PPASSMOUSE = &g_pConfigManager->getConfigValuePtr("binds:pass_mouse_when_bound")->intValue;
+    const auto PASS = g_pKeybindManager->onMouseEvent(e);
+
+    if (!PASS && !*PPASSMOUSE)
+        return;
+
     switch (e->state) {
         case WLR_BUTTON_PRESSED:
             if (!g_pCompositor->m_sSeat.mouse->currentConstraint)
@@ -352,6 +420,16 @@ void CInputManager::processMouseDownKill(wlr_pointer_button_event* e) {
     m_ecbClickBehavior = CLICKMODE_DEFAULT;
 }
 
+void CInputManager::onMouseWheel(wlr_pointer_axis_event* e) {
+    bool passEvent = g_pKeybindManager->onAxisEvent(e);
+
+    wlr_idle_notify_activity(g_pCompositor->m_sWLRIdle, g_pCompositor->m_sSeat.seat);
+
+    if (passEvent) {
+        wlr_seat_pointer_notify_axis(g_pCompositor->m_sSeat.seat, e->time_msec, e->orientation, e->delta, e->delta_discrete, e->source);
+    }
+}
+
 Vector2D CInputManager::getMouseCoordsInternal() {
     return Vector2D(g_pCompositor->m_sWLRCursor->x, g_pCompositor->m_sWLRCursor->y);
 }
@@ -367,47 +445,97 @@ void CInputManager::newKeyboard(wlr_input_device* keyboard) {
         Debug::log(ERR, "Keyboard had no name???");  // logic error
     }
 
-    PNEWKEYBOARD->hyprListener_keyboardMod.initCallback(&keyboard->keyboard->events.modifiers, &Events::listener_keyboardMod, PNEWKEYBOARD, "Keyboard");
-    PNEWKEYBOARD->hyprListener_keyboardKey.initCallback(&keyboard->keyboard->events.key, &Events::listener_keyboardKey, PNEWKEYBOARD, "Keyboard");
+    PNEWKEYBOARD->hyprListener_keyboardMod.initCallback(&wlr_keyboard_from_input_device(keyboard)->events.modifiers, &Events::listener_keyboardMod, PNEWKEYBOARD, "Keyboard");
+    PNEWKEYBOARD->hyprListener_keyboardKey.initCallback(&wlr_keyboard_from_input_device(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;
+    PNEWKEYBOARD->hyprListener_keyboardKeymap.initCallback(&wlr_keyboard_from_input_device(keyboard)->events.keymap, [&](void* owner, void* data) {
+        const auto PKEYBOARD = (SKeyboard*)owner;
+
+        g_pEventManager->postEvent(SHyprIPCEvent{"activelayout", PKEYBOARD->name + "," +getActiveLayoutForKeyboard(PKEYBOARD)}, true); // force as this should ALWAYS be sent
+        
+    }, PNEWKEYBOARD, "Keyboard");
+
+    disableAllKeyboards(false);
+    
     m_pActiveKeyboard = PNEWKEYBOARD;
 
+    PNEWKEYBOARD->active = true;
+
     applyConfigToKeyboard(PNEWKEYBOARD);
 
-    wlr_seat_set_keyboard(g_pCompositor->m_sSeat.seat, keyboard->keyboard);
+    wlr_seat_set_keyboard(g_pCompositor->m_sSeat.seat, wlr_keyboard_from_input_device(keyboard));
 
     Debug::log(LOG, "New keyboard created, pointers Hypr: %x and WLR: %x", PNEWKEYBOARD, keyboard);
 }
 
+void CInputManager::newVirtualKeyboard(wlr_input_device* keyboard) {
+    const auto PNEWKEYBOARD = &m_lKeyboards.emplace_back();
+
+    PNEWKEYBOARD->keyboard = keyboard;
+    PNEWKEYBOARD->isVirtual = true;
+
+    try {
+        PNEWKEYBOARD->name = std::string(keyboard->name);
+    } catch (std::exception& e) {
+        Debug::log(ERR, "Keyboard had no name???");  // logic error
+    }
+
+    PNEWKEYBOARD->hyprListener_keyboardMod.initCallback(&wlr_keyboard_from_input_device(keyboard)->events.modifiers, &Events::listener_keyboardMod, PNEWKEYBOARD, "Keyboard");
+    PNEWKEYBOARD->hyprListener_keyboardKey.initCallback(&wlr_keyboard_from_input_device(keyboard)->events.key, &Events::listener_keyboardKey, PNEWKEYBOARD, "Keyboard");
+    PNEWKEYBOARD->hyprListener_keyboardDestroy.initCallback(&keyboard->events.destroy, &Events::listener_keyboardDestroy, PNEWKEYBOARD, "Keyboard");
+    PNEWKEYBOARD->hyprListener_keyboardKeymap.initCallback(&wlr_keyboard_from_input_device(keyboard)->events.keymap, [&](void* owner, void* data) {
+        const auto PKEYBOARD = (SKeyboard*)owner;
+
+        g_pEventManager->postEvent(SHyprIPCEvent{"activelayout", PKEYBOARD->name + "," +getActiveLayoutForKeyboard(PKEYBOARD)}, true); // force as this should ALWAYS be sent
+        
+    }, PNEWKEYBOARD, "Keyboard");
+
+    disableAllKeyboards(true);
+
+    m_pActiveKeyboard = PNEWKEYBOARD;
+
+    PNEWKEYBOARD->active = true;
+
+    applyConfigToKeyboard(PNEWKEYBOARD);
+
+    wlr_seat_set_keyboard(g_pCompositor->m_sSeat.seat, wlr_keyboard_from_input_device(keyboard));
+
+    Debug::log(LOG, "New virtual keyboard created, pointers Hypr: %x and WLR: %x", PNEWKEYBOARD, keyboard);
+}
+
 void CInputManager::setKeyboardLayout() {
     for (auto& k : m_lKeyboards)
         applyConfigToKeyboard(&k);
 }
 
 void CInputManager::applyConfigToKeyboard(SKeyboard* pKeyboard) {
-    const auto HASCONFIG = g_pConfigManager->deviceConfigExists(pKeyboard->name);
+    auto devname = pKeyboard->name;
+    transform(devname.begin(), devname.end(), devname.begin(), ::tolower);
+
+    const auto HASCONFIG = g_pConfigManager->deviceConfigExists(devname);
+
+    Debug::log(LOG, "ApplyConfigToKeyboard for \"%s\", hasconfig: %i", pKeyboard->name.c_str(), (int)HASCONFIG);
 
     ASSERT(pKeyboard);
 
-    if (!pKeyboard->keyboard->keyboard)
+    if (!wlr_keyboard_from_input_device(pKeyboard->keyboard))
         return;
 
-    const auto REPEATRATE = HASCONFIG ? g_pConfigManager->getDeviceInt(pKeyboard->name, "repeat_rate") : g_pConfigManager->getInt("input:repeat_rate");
-    const auto REPEATDELAY = HASCONFIG ? g_pConfigManager->getDeviceInt(pKeyboard->name, "repeat_delay") : g_pConfigManager->getInt("input:repeat_delay");
+    const auto REPEATRATE = HASCONFIG ? g_pConfigManager->getDeviceInt(devname, "repeat_rate") : g_pConfigManager->getInt("input:repeat_rate");
+    const auto REPEATDELAY = HASCONFIG ? g_pConfigManager->getDeviceInt(devname, "repeat_delay") : g_pConfigManager->getInt("input:repeat_delay");
 
-    const auto NUMLOCKON = HASCONFIG ? g_pConfigManager->getDeviceInt(pKeyboard->name, "numlock_by_default") : g_pConfigManager->getInt("input:numlock_by_default");
+    const auto NUMLOCKON = HASCONFIG ? g_pConfigManager->getDeviceInt(devname, "numlock_by_default") : g_pConfigManager->getInt("input:numlock_by_default");
 
-    const auto RULES = HASCONFIG ? g_pConfigManager->getDeviceString(pKeyboard->name, "kb_rules") : g_pConfigManager->getString("input:kb_rules");
-    const auto MODEL = HASCONFIG ? g_pConfigManager->getDeviceString(pKeyboard->name, "kb_model") : g_pConfigManager->getString("input:kb_model");
-    const auto LAYOUT = HASCONFIG ? g_pConfigManager->getDeviceString(pKeyboard->name, "kb_layout") : g_pConfigManager->getString("input:kb_layout");
-    const auto VARIANT = HASCONFIG ? g_pConfigManager->getDeviceString(pKeyboard->name, "kb_variant") : g_pConfigManager->getString("input:kb_variant");
-    const auto OPTIONS = HASCONFIG ? g_pConfigManager->getDeviceString(pKeyboard->name, "kb_options") : g_pConfigManager->getString("input:kb_options");
+    const auto FILEPATH = HASCONFIG ? g_pConfigManager->getDeviceString(devname, "kb_file") : g_pConfigManager->getString("input:kb_file");
+    const auto RULES = HASCONFIG ? g_pConfigManager->getDeviceString(devname, "kb_rules") : g_pConfigManager->getString("input:kb_rules");
+    const auto MODEL = HASCONFIG ? g_pConfigManager->getDeviceString(devname, "kb_model") : g_pConfigManager->getString("input:kb_model");
+    const auto LAYOUT = HASCONFIG ? g_pConfigManager->getDeviceString(devname, "kb_layout") : g_pConfigManager->getString("input:kb_layout");
+    const auto VARIANT = HASCONFIG ? g_pConfigManager->getDeviceString(devname, "kb_variant") : g_pConfigManager->getString("input:kb_variant");
+    const auto OPTIONS = HASCONFIG ? g_pConfigManager->getDeviceString(devname, "kb_options") : g_pConfigManager->getString("input:kb_options");
 
     try {
-        if (NUMLOCKON == pKeyboard->numlockOn && REPEATDELAY == pKeyboard->repeatDelay && REPEATRATE == pKeyboard->repeatRate && RULES != "" && RULES == std::string(pKeyboard->currentRules.rules) && MODEL == std::string(pKeyboard->currentRules.model) && LAYOUT == std::string(pKeyboard->currentRules.layout) && VARIANT == std::string(pKeyboard->currentRules.variant) && OPTIONS == std::string(pKeyboard->currentRules.options)) {
+        if (NUMLOCKON == pKeyboard->numlockOn && REPEATDELAY == pKeyboard->repeatDelay && REPEATRATE == pKeyboard->repeatRate && RULES != "" && RULES == pKeyboard->currentRules.rules && MODEL == pKeyboard->currentRules.model && LAYOUT == pKeyboard->currentRules.layout && VARIANT == pKeyboard->currentRules.variant && OPTIONS == pKeyboard->currentRules.options && FILEPATH == pKeyboard->xkbFilePath) {
             Debug::log(LOG, "Not applying config to keyboard, it did not change.");
             return;
         }
@@ -416,11 +544,12 @@ void CInputManager::applyConfigToKeyboard(SKeyboard* pKeyboard) {
         // we can ignore those and just apply
     }
 
-    wlr_keyboard_set_repeat_info(pKeyboard->keyboard->keyboard, std::max(0, REPEATRATE), std::max(0, REPEATDELAY));
+    wlr_keyboard_set_repeat_info(wlr_keyboard_from_input_device(pKeyboard->keyboard), std::max(0, REPEATRATE), std::max(0, REPEATDELAY));
 
     pKeyboard->repeatDelay = REPEATDELAY;
     pKeyboard->repeatRate = REPEATRATE;
     pKeyboard->numlockOn = NUMLOCKON;
+    pKeyboard->xkbFilePath = FILEPATH.c_str();
 
     xkb_rule_names rules = {
         .rules = RULES.c_str(),
@@ -429,7 +558,11 @@ void CInputManager::applyConfigToKeyboard(SKeyboard* pKeyboard) {
         .variant = VARIANT.c_str(),
         .options = OPTIONS.c_str()};
 
-    pKeyboard->currentRules = rules;
+    pKeyboard->currentRules.rules = RULES;
+    pKeyboard->currentRules.model = MODEL;
+    pKeyboard->currentRules.variant = VARIANT;
+    pKeyboard->currentRules.options = OPTIONS;
+    pKeyboard->currentRules.layout = LAYOUT;
 
     const auto CONTEXT = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
 
@@ -440,18 +573,38 @@ void CInputManager::applyConfigToKeyboard(SKeyboard* pKeyboard) {
 
     Debug::log(LOG, "Attempting to create a keymap for layout %s with variant %s (rules: %s, model: %s, options: %s)", rules.layout, rules.variant, rules.rules, rules.model, rules.options);
 
-    auto KEYMAP = xkb_keymap_new_from_names(CONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
+    xkb_keymap * KEYMAP = NULL;
+
+    if (!FILEPATH.empty()) {
+      auto path = absolutePath(FILEPATH, g_pConfigManager->configCurrentPath);
+
+      if (!std::filesystem::exists(path)) {
+          Debug::log(ERR, "input:kb_file= file doesnt exist");
+      } else {
+        KEYMAP = xkb_keymap_new_from_file(CONTEXT, fopen(path.c_str(), "r"), XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
+      }
+    } 
 
     if (!KEYMAP) {
+      KEYMAP = xkb_keymap_new_from_names(CONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
+    }
+
+    if (!KEYMAP) {
+        g_pConfigManager->addParseError("Invalid keyboard layout passed. ( rules: " + RULES + ", model: " + MODEL + ", variant: " + VARIANT + ", options: " + OPTIONS + ", layout: " + LAYOUT + " )");
+
         Debug::log(ERR, "Keyboard layout %s with variant %s (rules: %s, model: %s, options: %s) couldn't have been loaded.", rules.layout, rules.variant, rules.rules, rules.model, rules.options);
         memset(&rules, 0, sizeof(rules));
 
-        pKeyboard->currentRules = rules;
+        pKeyboard->currentRules.rules = "";
+        pKeyboard->currentRules.model = "";
+        pKeyboard->currentRules.variant = "";
+        pKeyboard->currentRules.options = "";
+        pKeyboard->currentRules.layout = "";
 
         KEYMAP = xkb_keymap_new_from_names(CONTEXT, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
     }
 
-    wlr_keyboard_set_keymap(pKeyboard->keyboard->keyboard, KEYMAP);
+    wlr_keyboard_set_keymap(wlr_keyboard_from_input_device(pKeyboard->keyboard), KEYMAP);
 
     wlr_keyboard_modifiers wlrMods = {0};
 
@@ -464,62 +617,37 @@ void CInputManager::applyConfigToKeyboard(SKeyboard* pKeyboard) {
     }
 
     if (wlrMods.locked != 0) {
-        wlr_keyboard_notify_modifiers(pKeyboard->keyboard->keyboard, 0, 0, wlrMods.locked, 0);
+        wlr_keyboard_notify_modifiers(wlr_keyboard_from_input_device(pKeyboard->keyboard), 0, 0, wlrMods.locked, 0);
     }
 
     xkb_keymap_unref(KEYMAP);
     xkb_context_unref(CONTEXT);
 
+    g_pEventManager->postEvent(SHyprIPCEvent{"activelayout", pKeyboard->name + "," +getActiveLayoutForKeyboard(pKeyboard)}, true); // force as this should ALWAYS be sent
+
     Debug::log(LOG, "Set the keyboard layout to %s and variant to %s for keyboard \"%s\"", rules.layout, rules.variant, pKeyboard->keyboard->name);
 } 
 
-void CInputManager::newMouse(wlr_input_device* mouse) {
+void CInputManager::newMouse(wlr_input_device* mouse, bool virt) {
     m_lMice.emplace_back();
     const auto PMOUSE = &m_lMice.back();
 
     PMOUSE->mouse = mouse;
+    PMOUSE->virt = virt;
     try {
         PMOUSE->name = std::string(mouse->name);
     } catch(std::exception& e) {
         Debug::log(ERR, "Mouse had no name???"); // logic error
     }
 
-    const auto HASCONFIG = g_pConfigManager->deviceConfigExists(PMOUSE->name);
-
     if (wlr_input_device_is_libinput(mouse)) {
         const auto LIBINPUTDEV = (libinput_device*)wlr_libinput_get_device_handle(mouse);
 
-        if ((HASCONFIG ? g_pConfigManager->getDeviceInt(PMOUSE->name, "clickfinger_behavior") : g_pConfigManager->getInt("input:touchpad:clickfinger_behavior")) == 0) // toggle software buttons or clickfinger
-            libinput_device_config_click_set_method(LIBINPUTDEV, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
-        else
-            libinput_device_config_click_set_method(LIBINPUTDEV, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
-        
-        if (libinput_device_config_middle_emulation_is_available(LIBINPUTDEV)) { // middleclick on r+l mouse button pressed
-            if ((HASCONFIG ? g_pConfigManager->getDeviceInt(PMOUSE->name, "middle_button_emulation") : g_pConfigManager->getInt("input:touchpad:middle_button_emulation")) == 1)
-                libinput_device_config_middle_emulation_set_enabled(LIBINPUTDEV, LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
-            else
-                libinput_device_config_middle_emulation_set_enabled(LIBINPUTDEV, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
-        }
-
-        if (libinput_device_config_tap_get_finger_count(LIBINPUTDEV))  // this is for tapping (like on a laptop)
-            if ((HASCONFIG ? g_pConfigManager->getDeviceInt(PMOUSE->name, "tap-to-click") : g_pConfigManager->getInt("input:touchpad:tap-to-click")) == 1)
-                libinput_device_config_tap_set_enabled(LIBINPUTDEV, LIBINPUT_CONFIG_TAP_ENABLED);
-
-        if (libinput_device_config_scroll_has_natural_scroll(LIBINPUTDEV)) {
-            double w = 0, h = 0;
-
-            if (libinput_device_has_capability(LIBINPUTDEV, LIBINPUT_DEVICE_CAP_POINTER) && libinput_device_get_size(LIBINPUTDEV, &w, &h) == 0) // pointer with size is a touchpad
-                libinput_device_config_scroll_set_natural_scroll_enabled(LIBINPUTDEV, (HASCONFIG ? g_pConfigManager->getDeviceInt(PMOUSE->name, "natural_scroll") : g_pConfigManager->getInt("input:touchpad:natural_scroll")));
-            else
-                libinput_device_config_scroll_set_natural_scroll_enabled(LIBINPUTDEV, (HASCONFIG ? g_pConfigManager->getDeviceInt(PMOUSE->name, "natural_scroll") : g_pConfigManager->getInt("input:natural_scroll")));
-        }
-        
-        if (libinput_device_config_dwt_is_available(LIBINPUTDEV)) {
-            const auto DWT = static_cast<enum libinput_config_dwt_state>((HASCONFIG ? g_pConfigManager->getDeviceInt(PMOUSE->name, "disable_while_typing") : g_pConfigManager->getInt("input:touchpad:disable_while_typing")) != 0);
-            libinput_device_config_dwt_set_enabled(LIBINPUTDEV, DWT);
-        }
+        Debug::log(LOG, "New mouse has libinput sens %.2f (%.2f) with accel profile %i (%i)", libinput_device_config_accel_get_speed(LIBINPUTDEV), libinput_device_config_accel_get_default_speed(LIBINPUTDEV), libinput_device_config_accel_get_profile(LIBINPUTDEV), libinput_device_config_accel_get_default_profile(LIBINPUTDEV));
     }
 
+    setMouseConfigs();
+
     PMOUSE->hyprListener_destroyMouse.initCallback(&mouse->events.destroy, &Events::listener_destroyMouse, PMOUSE, "Mouse");
 
     wlr_cursor_attach_input_device(g_pCompositor->m_sWLRCursor, mouse);
@@ -531,6 +659,63 @@ void CInputManager::newMouse(wlr_input_device* mouse) {
     Debug::log(LOG, "New mouse created, pointer WLR: %x", mouse);
 }
 
+void CInputManager::setMouseConfigs() {
+    for (auto& m : m_lMice) {
+        const auto PMOUSE = &m;
+
+        auto devname = PMOUSE->name;
+        transform(devname.begin(), devname.end(), devname.begin(), ::tolower);
+
+        const auto HASCONFIG = g_pConfigManager->deviceConfigExists(devname);
+
+        if (wlr_input_device_is_libinput(m.mouse)) {
+            const auto LIBINPUTDEV = (libinput_device*)wlr_libinput_get_device_handle(m.mouse);
+
+            if ((HASCONFIG ? g_pConfigManager->getDeviceInt(devname, "clickfinger_behavior") : g_pConfigManager->getInt("input:touchpad:clickfinger_behavior")) == 0)  // toggle software buttons or clickfinger
+                libinput_device_config_click_set_method(LIBINPUTDEV, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
+            else
+                libinput_device_config_click_set_method(LIBINPUTDEV, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
+
+            if (libinput_device_config_middle_emulation_is_available(LIBINPUTDEV)) {  // middleclick on r+l mouse button pressed
+                if ((HASCONFIG ? g_pConfigManager->getDeviceInt(devname, "middle_button_emulation") : g_pConfigManager->getInt("input:touchpad:middle_button_emulation")) == 1)
+                    libinput_device_config_middle_emulation_set_enabled(LIBINPUTDEV, LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
+                else
+                    libinput_device_config_middle_emulation_set_enabled(LIBINPUTDEV, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+            }
+
+            if ((HASCONFIG ? g_pConfigManager->getDeviceInt(devname, "drag_lock") : g_pConfigManager->getInt("input:touchpad:drag_lock")) == 0)
+                libinput_device_config_tap_set_drag_lock_enabled(LIBINPUTDEV, LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
+            else
+                libinput_device_config_tap_set_drag_lock_enabled(LIBINPUTDEV, LIBINPUT_CONFIG_DRAG_LOCK_ENABLED);
+
+            if (libinput_device_config_tap_get_finger_count(LIBINPUTDEV))  // this is for tapping (like on a laptop)
+                if ((HASCONFIG ? g_pConfigManager->getDeviceInt(devname, "tap-to-click") : g_pConfigManager->getInt("input:touchpad:tap-to-click")) == 1)
+                    libinput_device_config_tap_set_enabled(LIBINPUTDEV, LIBINPUT_CONFIG_TAP_ENABLED);
+
+            if (libinput_device_config_scroll_has_natural_scroll(LIBINPUTDEV)) {
+                double w = 0, h = 0;
+
+                if (libinput_device_has_capability(LIBINPUTDEV, LIBINPUT_DEVICE_CAP_POINTER) && libinput_device_get_size(LIBINPUTDEV, &w, &h) == 0)  // pointer with size is a touchpad
+                    libinput_device_config_scroll_set_natural_scroll_enabled(LIBINPUTDEV, (HASCONFIG ? g_pConfigManager->getDeviceInt(devname, "natural_scroll") : g_pConfigManager->getInt("input:touchpad:natural_scroll")));
+                else
+                    libinput_device_config_scroll_set_natural_scroll_enabled(LIBINPUTDEV, (HASCONFIG ? g_pConfigManager->getDeviceInt(devname, "natural_scroll") : g_pConfigManager->getInt("input:natural_scroll")));
+            }
+
+            if (libinput_device_config_dwt_is_available(LIBINPUTDEV)) {
+                const auto DWT = static_cast<enum libinput_config_dwt_state>((HASCONFIG ? g_pConfigManager->getDeviceInt(devname, "disable_while_typing") : g_pConfigManager->getInt("input:touchpad:disable_while_typing")) != 0);
+                libinput_device_config_dwt_set_enabled(LIBINPUTDEV, DWT);
+            }
+
+            const auto LIBINPUTSENS = std::clamp((HASCONFIG ? g_pConfigManager->getDeviceFloat(devname, "sensitivity") : g_pConfigManager->getFloat("input:sensitivity")), -1.f, 1.f);
+
+            libinput_device_config_accel_set_profile(LIBINPUTDEV, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
+            libinput_device_config_accel_set_speed(LIBINPUTDEV, LIBINPUTSENS);
+
+            Debug::log(LOG, "Applied config to mouse %s, sens %.2f", m.name.c_str(), LIBINPUTSENS);
+        }
+    }
+}
+
 void CInputManager::destroyKeyboard(SKeyboard* pKeyboard) {
     pKeyboard->hyprListener_keyboardDestroy.removeCallback();
     pKeyboard->hyprListener_keyboardMod.removeCallback();
@@ -561,36 +746,46 @@ void CInputManager::destroyMouse(wlr_input_device* mouse) {
     g_pCompositor->m_sSeat.mouse = m_lMice.size() > 0 ? &m_lMice.front() : nullptr;
 
     if (g_pCompositor->m_sSeat.mouse)
-        g_pCompositor->m_sSeat.mouse->currentConstraint = nullptr;
+        unconstrainMouse();
 }
 
 void CInputManager::onKeyboardKey(wlr_keyboard_key_event* e, SKeyboard* pKeyboard) {
-    const auto KEYCODE = e->keycode + 8; // Because to xkbcommon it's +8 from libinput
-
-    const xkb_keysym_t* keysyms;
-    int syms = xkb_state_key_get_syms(pKeyboard->keyboard->keyboard->xkb_state, KEYCODE, &keysyms);
-
-    const auto MODS = wlr_keyboard_get_modifiers(pKeyboard->keyboard->keyboard);
+    bool passEvent = g_pKeybindManager->onKeyEvent(e, pKeyboard);
 
     wlr_idle_notify_activity(g_pCompositor->m_sWLRIdle, g_pCompositor->m_sSeat.seat);
 
-    bool found = false;
-    if (e->state == WL_KEYBOARD_KEY_STATE_PRESSED) {
-        for (int i = 0; i < syms; ++i)
-            found = g_pKeybindManager->handleKeybinds(MODS, keysyms[i]) || found;
-    } else if (e->state == WL_KEYBOARD_KEY_STATE_RELEASED) {
-        // hee hee
-    }
+    if (passEvent) {
 
-    if (!found) {
-        wlr_seat_set_keyboard(g_pCompositor->m_sSeat.seat, pKeyboard->keyboard->keyboard);
-        wlr_seat_keyboard_notify_key(g_pCompositor->m_sSeat.seat, e->time_msec, e->keycode, e->state);
+        const auto PIMEGRAB = m_sIMERelay.getIMEKeyboardGrab(pKeyboard);
+
+        if (PIMEGRAB && PIMEGRAB->pWlrKbGrab && PIMEGRAB->pWlrKbGrab->input_method) {
+            wlr_input_method_keyboard_grab_v2_set_keyboard(PIMEGRAB->pWlrKbGrab, wlr_keyboard_from_input_device(pKeyboard->keyboard));
+            wlr_input_method_keyboard_grab_v2_send_key(PIMEGRAB->pWlrKbGrab, e->time_msec, e->keycode, e->state);
+        } else {
+            wlr_seat_set_keyboard(g_pCompositor->m_sSeat.seat, wlr_keyboard_from_input_device(pKeyboard->keyboard));
+            wlr_seat_keyboard_notify_key(g_pCompositor->m_sSeat.seat, e->time_msec, e->keycode, e->state);
+        }
     }
 }
 
 void CInputManager::onKeyboardMod(void* data, SKeyboard* pKeyboard) {
-    wlr_seat_set_keyboard(g_pCompositor->m_sSeat.seat, pKeyboard->keyboard->keyboard);
-    wlr_seat_keyboard_notify_modifiers(g_pCompositor->m_sSeat.seat, &pKeyboard->keyboard->keyboard->modifiers);
+    const auto PIMEGRAB = m_sIMERelay.getIMEKeyboardGrab(pKeyboard);
+
+    if (PIMEGRAB && PIMEGRAB->pWlrKbGrab && PIMEGRAB->pWlrKbGrab->input_method) {
+        wlr_input_method_keyboard_grab_v2_set_keyboard(PIMEGRAB->pWlrKbGrab, wlr_keyboard_from_input_device(pKeyboard->keyboard));
+        wlr_input_method_keyboard_grab_v2_send_modifiers(PIMEGRAB->pWlrKbGrab, &wlr_keyboard_from_input_device(pKeyboard->keyboard)->modifiers);
+    } else {
+        wlr_seat_set_keyboard(g_pCompositor->m_sSeat.seat, wlr_keyboard_from_input_device(pKeyboard->keyboard));
+        wlr_seat_keyboard_notify_modifiers(g_pCompositor->m_sSeat.seat, &wlr_keyboard_from_input_device(pKeyboard->keyboard)->modifiers);
+    }
+
+    const auto PWLRKB = wlr_keyboard_from_input_device(pKeyboard->keyboard);
+
+    if (PWLRKB->modifiers.group != pKeyboard->activeLayout) {
+		pKeyboard->activeLayout = PWLRKB->modifiers.group;
+
+        g_pEventManager->postEvent(SHyprIPCEvent{"activelayout", pKeyboard->name + "," + getActiveLayoutForKeyboard(pKeyboard)}, true); // force as this should ALWAYS be sent
+	}
 }
 
 void CInputManager::refocus() {
@@ -598,16 +793,16 @@ void CInputManager::refocus() {
 }
 
 void CInputManager::updateDragIcon() {
-    if (!g_pInputManager->m_sDrag.dragIcon)
+    if (!m_sDrag.dragIcon)
         return;
 
-    switch (g_pInputManager->m_sDrag.dragIcon->drag->grab_type) {
+    switch (m_sDrag.dragIcon->drag->grab_type) {
         case WLR_DRAG_GRAB_KEYBOARD:
             break;
         case WLR_DRAG_GRAB_KEYBOARD_POINTER: {
-            wlr_box box = {g_pInputManager->m_sDrag.pos.x - 2, g_pInputManager->m_sDrag.pos.y - 2, g_pInputManager->m_sDrag.dragIcon->surface->current.width + 4, g_pInputManager->m_sDrag.dragIcon->surface->current.height + 4};
+            wlr_box box = {m_sDrag.pos.x - 2, m_sDrag.pos.y - 2, m_sDrag.dragIcon->surface->current.width + 4, m_sDrag.dragIcon->surface->current.height + 4};
             g_pHyprRenderer->damageBox(&box);
-            g_pInputManager->m_sDrag.pos = g_pInputManager->getMouseCoordsInternal();
+            m_sDrag.pos = getMouseCoordsInternal();
             break;
         }
         default:
@@ -686,6 +881,29 @@ void CInputManager::constrainMouse(SMouse* pMouse, wlr_pointer_constraint_v1* co
     Debug::log(LOG, "Constrained mouse to %x", pMouse->currentConstraint);
 }
 
+void CInputManager::unconstrainMouse() {
+    if (!g_pCompositor->m_sSeat.mouse->currentConstraint)
+        return;
+
+    const auto CONSTRAINTWINDOW = g_pCompositor->getConstraintWindow(g_pCompositor->m_sSeat.mouse);
+
+    if (CONSTRAINTWINDOW) {
+        if (CONSTRAINTWINDOW->m_bIsX11) {
+            wlr_xwayland_surface_activate(CONSTRAINTWINDOW->m_uSurface.xwayland, false);
+        } else {
+            wlr_xdg_toplevel_set_activated(CONSTRAINTWINDOW->m_uSurface.xdg->toplevel, false);
+        }
+    }
+
+    wlr_pointer_constraint_v1_send_deactivated(g_pCompositor->m_sSeat.mouse->currentConstraint);
+    g_pCompositor->m_sSeat.mouse->constraintActive = false;
+
+    // TODO: its better to somehow detect the workspace...
+    g_pCompositor->m_sSeat.mouse->currentConstraint = nullptr;
+
+    g_pCompositor->m_sSeat.mouse->hyprListener_commitConstraint.removeCallback();
+}
+
 void Events::listener_commitConstraint(void* owner, void* data) {
     //g_pInputManager->recheckConstraint((SMouse*)owner);
 }
@@ -708,4 +926,44 @@ void CInputManager::updateCapabilities(wlr_input_device* pDev) {
     }
 
     wlr_seat_set_capabilities(g_pCompositor->m_sSeat.seat, m_uiCapabilities);
-}
+}
+
+uint32_t CInputManager::accumulateModsFromAllKBs() {
+
+    uint32_t finalMask = 0;
+
+    for (auto& kb : m_lKeyboards) {
+        finalMask |= wlr_keyboard_get_modifiers(wlr_keyboard_from_input_device(kb.keyboard));
+    }
+
+    return finalMask;
+}
+
+std::string CInputManager::getActiveLayoutForKeyboard(SKeyboard* pKeyboard) {
+    const auto WLRKB = wlr_keyboard_from_input_device(pKeyboard->keyboard);
+    const auto KEYMAP = WLRKB->keymap;
+    const auto STATE = WLRKB->xkb_state;
+    const auto LAYOUTSNUM = xkb_keymap_num_layouts(KEYMAP);
+
+    for (uint32_t i = 0; i < LAYOUTSNUM; ++i) {
+        if (xkb_state_layout_index_is_active(STATE, i, XKB_STATE_LAYOUT_EFFECTIVE)) {
+            const auto LAYOUTNAME = xkb_keymap_layout_get_name(KEYMAP, i);
+
+            if (LAYOUTNAME) 
+                return std::string(LAYOUTNAME);
+            return "error";
+        }
+    }
+
+    return "none";
+}
+
+void CInputManager::disableAllKeyboards(bool virt) {
+
+    for (auto& k : m_lKeyboards) {
+        if (k.isVirtual != virt)
+            continue;
+
+        k.active = false;
+    }
+}

src/managers/input/InputManager.hpp

@@ -5,33 +5,44 @@
 #include "../../helpers/WLClasses.hpp"
 #include "../../Window.hpp"
 #include "../../helpers/Timer.hpp"
+#include "InputMethodRelay.hpp"
 
 enum eClickBehaviorMode {
     CLICKMODE_DEFAULT = 0,
     CLICKMODE_KILL
 };
 
+struct STouchData {
+    CWindow* touchFocusWindow = nullptr;
+    Vector2D touchSurfaceOrigin;
+};
+
 class CInputManager {
 public:
 
     void            onMouseMoved(wlr_pointer_motion_event*);
     void            onMouseWarp(wlr_pointer_motion_absolute_event*);
     void            onMouseButton(wlr_pointer_button_event*);
+    void            onMouseWheel(wlr_pointer_axis_event*); 
     void            onKeyboardKey(wlr_keyboard_key_event*, SKeyboard*);
     void            onKeyboardMod(void*, SKeyboard*);
 
     void            newKeyboard(wlr_input_device*);
-    void            newMouse(wlr_input_device*);
+    void            newVirtualKeyboard(wlr_input_device*);
+    void            newMouse(wlr_input_device*, bool virt = false);
     void            destroyKeyboard(SKeyboard*);
     void            destroyMouse(wlr_input_device*);
 
     void            constrainMouse(SMouse*, wlr_pointer_constraint_v1*);
     void            recheckConstraint(SMouse*);
+    void            unconstrainMouse();
+    std::string     getActiveLayoutForKeyboard(SKeyboard*);
 
     Vector2D        getMouseCoordsInternal();
     void            refocus();
 
     void            setKeyboardLayout();
+    void            setMouseConfigs();
 
     void            updateDragIcon();
     void            updateCapabilities(wlr_input_device*);
@@ -40,6 +51,11 @@ public:
     eClickBehaviorMode getClickMode();
     void            processMouseRequest(wlr_seat_pointer_request_set_cursor_event*);
 
+    void            onTouchDown(wlr_touch_down_event*);
+    void            onTouchUp(wlr_touch_up_event*);
+    void            onTouchMove(wlr_touch_motion_event*);
+
+    STouchData      m_sTouchData;
 
     // for dragging floating windows
     CWindow*        currentlyDraggedWindow = nullptr;
@@ -56,14 +72,32 @@ public:
     std::list<STabletTool>  m_lTabletTools;
     std::list<STabletPad>   m_lTabletPads;
 
+    // idle inhibitors
+    std::list<SIdleInhibitor> m_lIdleInhibitors;
+
     void            newTabletTool(wlr_input_device*);
     void            newTabletPad(wlr_input_device*);
     void            focusTablet(STablet*, wlr_tablet_tool*, bool motion = false);
+    void            newIdleInhibitor(wlr_idle_inhibitor_v1*);
+    void            recheckIdleInhibitorStatus();
+
+    void            onSwipeBegin(wlr_pointer_swipe_begin_event*);
+    void            onSwipeEnd(wlr_pointer_swipe_end_event*);
+    void            onSwipeUpdate(wlr_pointer_swipe_update_event*);
+
+    SSwipeGesture   m_sActiveSwipe;
 
     SKeyboard*      m_pActiveKeyboard = nullptr;
 
     CTimer          m_tmrLastCursorMovement;
 
+    CInputMethodRelay m_sIMERelay;
+
+    // for shared mods
+    uint32_t        accumulateModsFromAllKBs();
+
+    CWindow*        m_pFollowOnDnDBegin = nullptr;
+
 private:
 
     // for click behavior override
@@ -73,6 +107,8 @@ private:
     void            processMouseDownNormal(wlr_pointer_button_event* e);
     void            processMouseDownKill(wlr_pointer_button_event* e);
 
+    void            disableAllKeyboards(bool virt = false);
+
     uint32_t        m_uiCapabilities = 0;
 
     void            mouseMoveUnified(uint32_t, bool refocus = false);

src/managers/input/InputMethodRelay.cpp

@@ -0,0 +1,447 @@
+#include "InputMethodRelay.hpp"
+#include "InputManager.hpp"
+#include "../../Compositor.hpp"
+
+CInputMethodRelay::CInputMethodRelay() {
+    
+}
+
+void CInputMethodRelay::onNewIME(wlr_input_method_v2* pIME) {
+    if (m_pWLRIME) {
+        Debug::log(ERR, "Cannot register 2 IMEs at once!");
+
+        wlr_input_method_v2_send_unavailable(pIME);
+
+        return;
+    }
+
+    m_pWLRIME = pIME;
+
+    hyprListener_IMECommit.initCallback(&m_pWLRIME->events.commit, [&](void* owner, void* data) {
+
+        const auto PTI = getFocusedTextInput();
+        const auto PIMR = (CInputMethodRelay*)owner;
+
+        if (!PTI) {
+            Debug::log(LOG, "No focused TextInput on IME Commit");
+            return;
+        }
+
+        if (PIMR->m_pWLRIME->current.preedit.text) {
+            wlr_text_input_v3_send_preedit_string(PTI->pWlrInput, PIMR->m_pWLRIME->current.preedit.text, PIMR->m_pWLRIME->current.preedit.cursor_begin, PIMR->m_pWLRIME->current.preedit.cursor_end);
+        }
+
+        if (PIMR->m_pWLRIME->current.commit_text) {
+            wlr_text_input_v3_send_commit_string(PTI->pWlrInput, PIMR->m_pWLRIME->current.commit_text);
+        }
+
+        if (PIMR->m_pWLRIME->current.delete_.before_length || PIMR->m_pWLRIME->current.delete_.after_length) {
+            wlr_text_input_v3_send_delete_surrounding_text(PTI->pWlrInput, PIMR->m_pWLRIME->current.delete_.before_length, PIMR->m_pWLRIME->current.delete_.after_length);
+        }
+
+        wlr_text_input_v3_send_done(PTI->pWlrInput);
+
+    }, this, "IMERelay");
+
+    hyprListener_IMEDestroy.initCallback(&m_pWLRIME->events.destroy, [&](void* owner, void* data) {
+
+        m_pWLRIME = nullptr;
+
+        hyprListener_IMEDestroy.removeCallback();
+        hyprListener_IMECommit.removeCallback();
+        hyprListener_IMEGrab.removeCallback();
+        hyprListener_IMENewPopup.removeCallback();
+
+        m_pKeyboardGrab.reset(nullptr);
+
+        const auto PTI = getFocusedTextInput();
+
+        Debug::log(LOG, "IME Destroy");
+
+        if (PTI) {
+            setPendingSurface(PTI, PTI->pWlrInput->focused_surface);
+
+            wlr_text_input_v3_send_leave(PTI->pWlrInput);
+        }
+
+    }, this, "IMERelay");
+
+    hyprListener_IMEGrab.initCallback(&m_pWLRIME->events.grab_keyboard, [&](void* owner, void* data) {
+
+        Debug::log(LOG, "IME TextInput Keyboard Grab new");
+
+        m_pKeyboardGrab.reset(nullptr);
+
+        m_pKeyboardGrab = std::make_unique<SIMEKbGrab>();
+
+        m_pKeyboardGrab->pKeyboard = wlr_seat_get_keyboard(g_pCompositor->m_sSeat.seat);
+
+        const auto PKBGRAB = (wlr_input_method_keyboard_grab_v2*)data;
+
+        m_pKeyboardGrab->pWlrKbGrab = PKBGRAB;
+
+        wlr_input_method_keyboard_grab_v2_set_keyboard(m_pKeyboardGrab->pWlrKbGrab, m_pKeyboardGrab->pKeyboard);
+
+        m_pKeyboardGrab->hyprListener_grabDestroy.initCallback(&PKBGRAB->events.destroy, [&](void* owner, void* data) {
+
+            m_pKeyboardGrab->hyprListener_grabDestroy.removeCallback();
+
+            Debug::log(LOG, "IME TextInput Keyboard Grab destroy");
+
+            if (m_pKeyboardGrab->pKeyboard) {
+                wlr_seat_keyboard_notify_modifiers(g_pCompositor->m_sSeat.seat, &m_pKeyboardGrab->pKeyboard->modifiers);
+            }
+
+            m_pKeyboardGrab.reset(nullptr);
+
+        }, m_pKeyboardGrab.get(), "IME Keyboard Grab");
+
+    }, this, "IMERelay");
+
+    hyprListener_IMENewPopup.initCallback(&m_pWLRIME->events.new_popup_surface, [&](void* owner, void* data) {
+        
+        const auto PNEWPOPUP = &m_lIMEPopups.emplace_back();
+
+        PNEWPOPUP->pSurface = (wlr_input_popup_surface_v2*)data;
+
+        PNEWPOPUP->hyprListener_commitPopup.initCallback(&PNEWPOPUP->pSurface->surface->events.commit, &Events::listener_commitInputPopup, PNEWPOPUP, "IME Popup");
+        PNEWPOPUP->hyprListener_mapPopup.initCallback(&PNEWPOPUP->pSurface->events.map, &Events::listener_mapInputPopup, PNEWPOPUP, "IME Popup");
+        PNEWPOPUP->hyprListener_unmapPopup.initCallback(&PNEWPOPUP->pSurface->events.unmap, &Events::listener_unmapInputPopup, PNEWPOPUP, "IME Popup");
+        PNEWPOPUP->hyprListener_destroyPopup.initCallback(&PNEWPOPUP->pSurface->events.destroy, &Events::listener_destroyInputPopup, PNEWPOPUP, "IME Popup");
+
+        Debug::log(LOG, "New input popup");
+
+    }, this, "IMERelay");
+
+    const auto PTI = getFocusableTextInput();
+
+    if (PTI) {
+        wlr_text_input_v3_send_enter(PTI->pWlrInput, PTI->pPendingSurface);
+        setPendingSurface(PTI, nullptr);
+    }
+}
+
+void CInputMethodRelay::updateInputPopup(SIMEPopup* pPopup) {
+    if (!pPopup->pSurface->mapped)  
+        return;
+
+    const auto PFOCUSEDTI = getFocusedTextInput();
+
+    if (!PFOCUSEDTI || !PFOCUSEDTI->pWlrInput->focused_surface)
+        return;
+
+    bool cursorRect = PFOCUSEDTI->pWlrInput->current.features & WLR_TEXT_INPUT_V3_FEATURE_CURSOR_RECTANGLE;
+    const auto PFOCUSEDSURFACE = PFOCUSEDTI->pWlrInput->focused_surface;
+    auto cursorBox = PFOCUSEDTI->pWlrInput->current.cursor_rectangle;
+
+    Vector2D parentPos;
+    Vector2D parentSize;
+
+    if (wlr_surface_is_layer_surface(PFOCUSEDSURFACE)) {
+        const auto PLS = g_pCompositor->getLayerSurfaceFromWlr(wlr_layer_surface_v1_from_wlr_surface(PFOCUSEDSURFACE));
+
+        if (PLS) {
+            parentPos = Vector2D(PLS->geometry.x, PLS->geometry.y) + g_pCompositor->getMonitorFromID(PLS->monitorID)->vecPosition;
+            parentSize = Vector2D(PLS->geometry.width, PLS->geometry.height);
+        }
+    } else {
+        const auto PWINDOW = g_pCompositor->getWindowFromSurface(PFOCUSEDSURFACE);
+
+        if (PWINDOW) {
+            parentPos = PWINDOW->m_vRealPosition.goalv();
+            parentSize = PWINDOW->m_vRealSize.goalv();
+        }
+    }
+
+    if (!cursorRect) {
+        cursorBox = {0, 0, (int)parentSize.x, (int)parentSize.y};
+    }
+
+    // todo: anti-overflow
+
+    wlr_box finalBox = cursorBox;
+
+    pPopup->x = finalBox.x;
+    pPopup->y = finalBox.y + finalBox.height;
+
+    pPopup->realX = finalBox.x + parentPos.x;
+    pPopup->realY = finalBox.y + parentPos.y + finalBox.height;
+
+    wlr_input_popup_surface_v2_send_text_input_rectangle(pPopup->pSurface, &finalBox);
+
+    damagePopup(pPopup);
+}
+
+void CInputMethodRelay::setIMEPopupFocus(SIMEPopup* pPopup, wlr_surface* pSurface) {
+    updateInputPopup(pPopup);
+}
+
+void Events::listener_mapInputPopup(void* owner, void* data) {
+    const auto PPOPUP = (SIMEPopup*)owner;
+
+    Debug::log(LOG, "Mapped an IME Popup");
+
+    g_pInputManager->m_sIMERelay.updateInputPopup(PPOPUP);
+}
+
+void Events::listener_unmapInputPopup(void* owner, void* data) {
+    const auto PPOPUP = (SIMEPopup*)owner;
+
+    Debug::log(LOG, "Unmapped an IME Popup");
+
+    g_pInputManager->m_sIMERelay.updateInputPopup(PPOPUP);
+}
+
+void Events::listener_destroyInputPopup(void* owner, void* data) {
+    const auto PPOPUP = (SIMEPopup*)owner;
+
+    Debug::log(LOG, "Removed an IME Popup");
+
+    PPOPUP->hyprListener_commitPopup.removeCallback();
+    PPOPUP->hyprListener_destroyPopup.removeCallback();
+    PPOPUP->hyprListener_focusedSurfaceUnmap.removeCallback();
+    PPOPUP->hyprListener_mapPopup.removeCallback();
+    PPOPUP->hyprListener_unmapPopup.removeCallback();
+
+    g_pInputManager->m_sIMERelay.removePopup(PPOPUP);
+}
+
+void Events::listener_commitInputPopup(void* owner, void* data) {
+    const auto PPOPUP = (SIMEPopup*)owner;
+
+    g_pInputManager->m_sIMERelay.updateInputPopup(PPOPUP);
+}
+
+void CInputMethodRelay::removePopup(SIMEPopup* pPopup) {
+    m_lIMEPopups.remove(*pPopup);
+}
+
+void CInputMethodRelay::damagePopup(SIMEPopup* pPopup) {
+    if (!pPopup->pSurface->mapped)
+        return;
+
+    const auto PFOCUSEDTI = getFocusedTextInput();
+
+    if (!PFOCUSEDTI || !PFOCUSEDTI->pWlrInput->focused_surface)
+        return;
+
+    Vector2D parentPos;
+
+    const auto PFOCUSEDSURFACE = PFOCUSEDTI->pWlrInput->focused_surface;
+
+    if (wlr_surface_is_layer_surface(PFOCUSEDSURFACE)) {
+        const auto PLS = g_pCompositor->getLayerSurfaceFromWlr(wlr_layer_surface_v1_from_wlr_surface(PFOCUSEDSURFACE));
+
+        if (PLS) {
+            parentPos = Vector2D(PLS->geometry.x, PLS->geometry.y) + g_pCompositor->getMonitorFromID(PLS->monitorID)->vecPosition;
+        }
+    } else {
+        const auto PWINDOW = g_pCompositor->getWindowFromSurface(PFOCUSEDSURFACE);
+
+        if (PWINDOW) {
+            parentPos = PWINDOW->m_vRealPosition.goalv();
+        }
+    }
+
+    g_pHyprRenderer->damageSurface(pPopup->pSurface->surface, parentPos.x + pPopup->x, parentPos.y + pPopup->y);
+}
+
+SIMEKbGrab* CInputMethodRelay::getIMEKeyboardGrab(SKeyboard* pKeyboard) {
+
+    if (!m_pWLRIME)
+        return nullptr;
+
+    if (!m_pKeyboardGrab.get())
+        return nullptr;
+
+    const auto VIRTKB = wlr_input_device_get_virtual_keyboard(pKeyboard->keyboard);
+
+    if (VIRTKB && (wl_resource_get_client(VIRTKB->resource) == wl_resource_get_client(m_pKeyboardGrab->pWlrKbGrab->resource)))
+        return nullptr;
+
+    if (wlr_keyboard_from_input_device(pKeyboard->keyboard) != m_pKeyboardGrab->pKeyboard)
+        return nullptr;
+
+    return m_pKeyboardGrab.get();
+}
+
+STextInput* CInputMethodRelay::getFocusedTextInput() {
+    for (auto& ti : m_lTextInputs) {
+        if (ti.pWlrInput->focused_surface) {
+            return &ti;
+        }
+    }
+
+    return nullptr;
+}
+
+STextInput* CInputMethodRelay::getFocusableTextInput() {
+    for (auto& ti : m_lTextInputs) {
+        if (ti.pPendingSurface) {
+            return &ti;
+        }
+    }
+
+    return nullptr;
+}
+
+void CInputMethodRelay::onNewTextInput(wlr_text_input_v3* pInput) {
+    createNewTextInput(pInput);
+}
+
+void CInputMethodRelay::createNewTextInput(wlr_text_input_v3* pInput) {
+    const auto PTEXTINPUT = &m_lTextInputs.emplace_back();
+
+    PTEXTINPUT->pWlrInput = pInput;
+
+    PTEXTINPUT->hyprListener_textInputEnable.initCallback(&pInput->events.enable, [](void* owner, void* data) {
+
+        const auto PINPUT = (STextInput*)owner;
+
+        if (!g_pInputManager->m_sIMERelay.m_pWLRIME) {
+            Debug::log(ERR, "Enabling TextInput on no IME!");
+            return;
+        }
+
+        Debug::log(LOG, "Enable TextInput");
+
+        wlr_input_method_v2_send_activate(g_pInputManager->m_sIMERelay.m_pWLRIME);
+        g_pInputManager->m_sIMERelay.commitIMEState(PINPUT->pWlrInput);
+
+    }, PTEXTINPUT, "textInput");
+
+    PTEXTINPUT->hyprListener_textInputCommit.initCallback(&pInput->events.commit, [](void* owner, void* data) {
+
+        const auto PINPUT = (STextInput*)owner;
+
+        if (!g_pInputManager->m_sIMERelay.m_pWLRIME) {
+            Debug::log(ERR, "Committing TextInput on no IME!");
+            return;
+        }
+
+        if (!PINPUT->pWlrInput->current_enabled) {
+            Debug::log(ERR, "Disabled TextInput commit?");
+            return;
+        }
+
+        g_pInputManager->m_sIMERelay.commitIMEState(PINPUT->pWlrInput);
+
+    }, PTEXTINPUT, "textInput");
+
+    PTEXTINPUT->hyprListener_textInputDisable.initCallback(&pInput->events.disable, [](void* owner, void* data) {
+
+        const auto PINPUT = (STextInput*)owner;
+
+        if (!g_pInputManager->m_sIMERelay.m_pWLRIME) {
+            Debug::log(ERR, "Disabling TextInput on no IME!");
+            return;
+        }
+
+        Debug::log(LOG, "Disable TextInput");
+
+        wlr_input_method_v2_send_deactivate(g_pInputManager->m_sIMERelay.m_pWLRIME);
+
+        g_pInputManager->m_sIMERelay.commitIMEState(PINPUT->pWlrInput);
+
+    }, PTEXTINPUT, "textInput");
+
+    PTEXTINPUT->hyprListener_textInputDestroy.initCallback(&pInput->events.destroy, [](void* owner, void* data) {
+
+        const auto PINPUT = (STextInput*)owner;
+
+        if (!g_pInputManager->m_sIMERelay.m_pWLRIME) {
+            Debug::log(ERR, "Disabling TextInput on no IME!");
+            return;
+        }
+
+        if (PINPUT->pWlrInput->current_enabled) {
+            wlr_input_method_v2_send_deactivate(g_pInputManager->m_sIMERelay.m_pWLRIME);
+
+            g_pInputManager->m_sIMERelay.commitIMEState(PINPUT->pWlrInput);
+        }
+
+        g_pInputManager->m_sIMERelay.setPendingSurface(PINPUT, nullptr);
+
+        PINPUT->hyprListener_textInputCommit.removeCallback();
+        PINPUT->hyprListener_textInputDestroy.removeCallback();
+        PINPUT->hyprListener_textInputDisable.removeCallback();
+        PINPUT->hyprListener_textInputEnable.removeCallback();
+
+        g_pInputManager->m_sIMERelay.removeTextInput(PINPUT->pWlrInput);
+
+    }, PTEXTINPUT, "textInput");
+}
+
+void CInputMethodRelay::removeTextInput(wlr_text_input_v3* pInput) {
+    m_lTextInputs.remove_if([&](const auto& other) { return other.pWlrInput == pInput; });
+}
+
+void CInputMethodRelay::commitIMEState(wlr_text_input_v3* pInput) {
+    if (!m_pWLRIME)
+        return;
+
+    if (pInput->active_features & WLR_TEXT_INPUT_V3_FEATURE_SURROUNDING_TEXT)
+        wlr_input_method_v2_send_surrounding_text(m_pWLRIME, pInput->current.surrounding.text, pInput->current.surrounding.cursor, pInput->current.surrounding.anchor);
+
+    wlr_input_method_v2_send_text_change_cause(m_pWLRIME, pInput->current.text_change_cause);
+
+    if (pInput->active_features & WLR_TEXT_INPUT_V3_FEATURE_CONTENT_TYPE)
+        wlr_input_method_v2_send_content_type(m_pWLRIME, pInput->current.content_type.hint, pInput->current.content_type.purpose);
+
+    for (auto& p : m_lIMEPopups) {
+        updateInputPopup(&p);
+    }
+
+    wlr_input_method_v2_send_done(m_pWLRIME);
+}
+
+void CInputMethodRelay::onKeyboardFocus(wlr_surface* pSurface) {
+    if (!m_pWLRIME)
+        return;
+
+    for (auto& ti : m_lTextInputs) {
+        if (ti.pPendingSurface) {
+
+            if (pSurface != ti.pPendingSurface) 
+                setPendingSurface(&ti, nullptr);
+
+        } else if (ti.pWlrInput->focused_surface) {
+
+            if (pSurface != ti.pWlrInput->focused_surface) {
+                wlr_input_method_v2_send_deactivate(m_pWLRIME);
+                commitIMEState(ti.pWlrInput);
+
+                wlr_text_input_v3_send_leave(ti.pWlrInput);
+            } else {
+                continue;
+            }
+
+        }
+
+        if (pSurface && wl_resource_get_client(ti.pWlrInput->resource) == wl_resource_get_client(pSurface->resource)) {
+
+            if (m_pWLRIME) {
+                wlr_text_input_v3_send_enter(ti.pWlrInput, pSurface);
+            } else {
+                setPendingSurface(&ti, pSurface);
+            }
+
+        }
+    }
+}
+
+void CInputMethodRelay::setPendingSurface(STextInput* pInput, wlr_surface* pSurface) {
+    pInput->pPendingSurface = pSurface;
+
+    if (pSurface) {
+        pInput->hyprListener_pendingSurfaceDestroy.initCallback(&pSurface->events.destroy, [](void* owner, void* data) {
+            const auto PINPUT = (STextInput*)owner;
+
+            PINPUT->pPendingSurface = nullptr;
+
+            PINPUT->hyprListener_pendingSurfaceDestroy.removeCallback();
+        }, pInput, "TextInput");
+    } else {
+        pInput->hyprListener_pendingSurfaceDestroy.removeCallback();
+    }
+}

src/managers/input/InputMethodRelay.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "../../defines.hpp"
+#include "../../helpers/WLClasses.hpp"
+
+class CInputMethodRelay {
+public:
+    CInputMethodRelay();
+
+    void        onNewIME(wlr_input_method_v2*);
+    void        onNewTextInput(wlr_text_input_v3*);
+
+    wlr_input_method_v2* m_pWLRIME = nullptr;
+
+    void        commitIMEState(wlr_text_input_v3*);
+    void        removeTextInput(wlr_text_input_v3*);
+
+    void        onKeyboardFocus(wlr_surface*);
+
+    STextInput* getFocusedTextInput();
+    STextInput* getFocusableTextInput();
+
+    void        setPendingSurface(STextInput*, wlr_surface*);
+
+    SIMEKbGrab* getIMEKeyboardGrab(SKeyboard*);
+
+    void        setIMEPopupFocus(SIMEPopup*, wlr_surface*);
+    void        updateInputPopup(SIMEPopup*);
+    void        damagePopup(SIMEPopup*);
+    void        removePopup(SIMEPopup*);
+
+private:
+
+    std::unique_ptr<SIMEKbGrab> m_pKeyboardGrab;
+
+    std::list<STextInput>   m_lTextInputs;
+    std::list<SIMEPopup>    m_lIMEPopups;
+
+    DYNLISTENER(textInputNew);
+    DYNLISTENER(IMECommit);
+    DYNLISTENER(IMEDestroy);
+    DYNLISTENER(IMEGrab);
+    DYNLISTENER(IMENewPopup);
+
+    void        createNewTextInput(wlr_text_input_v3*);
+
+    friend class CHyprRenderer;
+};

src/managers/input/Swipe.cpp

@@ -0,0 +1,186 @@
+#include "InputManager.hpp"
+#include "../../Compositor.hpp"
+
+void CInputManager::onSwipeBegin(wlr_pointer_swipe_begin_event* e) {
+
+    static auto *const PSWIPE = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe")->intValue;
+    static auto *const PSWIPEFINGERS = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_fingers")->intValue;
+
+    if (e->fingers != *PSWIPEFINGERS|| *PSWIPE == 0)
+        return;
+
+    int onMonitor = 0;
+    for (auto& w : g_pCompositor->m_vWorkspaces) {
+        if (w->m_iMonitorID == g_pCompositor->m_pLastMonitor->ID) {
+            onMonitor++;
+        }
+    }
+
+    if (onMonitor < 2)
+        return; // disallow swiping when there's 1 workspace on a monitor
+
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->activeWorkspace);
+
+    Debug::log(LOG, "Starting a swipe from %s", PWORKSPACE->m_szName.c_str());
+
+    m_sActiveSwipe.pWorkspaceBegin = PWORKSPACE;
+    m_sActiveSwipe.delta = 0;
+    m_sActiveSwipe.pMonitor = g_pCompositor->m_pLastMonitor;
+    m_sActiveSwipe.avgSpeed = 0;
+    m_sActiveSwipe.speedPoints = 0;
+}
+
+void CInputManager::onSwipeEnd(wlr_pointer_swipe_end_event* e) {
+
+    if (!m_sActiveSwipe.pWorkspaceBegin)
+        return; // no valid swipe
+
+    static auto *const PSWIPEPERC = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_cancel_ratio")->floatValue;
+    static auto *const PSWIPEDIST = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_distance")->intValue;
+    static auto *const PSWIPEFORC = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_min_speed_to_force")->intValue;
+
+    // commit
+    std::string wsname = "";
+    auto workspaceIDLeft = getWorkspaceIDFromString("m-1", wsname);
+    auto workspaceIDRight = getWorkspaceIDFromString("m+1", wsname);
+
+    const auto PWORKSPACER = g_pCompositor->getWorkspaceByID(workspaceIDRight);
+    const auto PWORKSPACEL = g_pCompositor->getWorkspaceByID(workspaceIDLeft);
+
+    const auto RENDEROFFSETMIDDLE = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.vec();
+
+    if ((abs(m_sActiveSwipe.delta) < *PSWIPEDIST * *PSWIPEPERC && (*PSWIPEFORC == 0 || (*PSWIPEFORC != 0 && m_sActiveSwipe.avgSpeed < *PSWIPEFORC))) || abs(m_sActiveSwipe.delta) < 2) {
+        // revert
+        if (abs(m_sActiveSwipe.delta) < 2) {
+            PWORKSPACEL->m_vRenderOffset.setValueAndWarp(Vector2D(0,0));
+            PWORKSPACER->m_vRenderOffset.setValueAndWarp(Vector2D(0,0));
+            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(0,0));
+        } else {
+            if (m_sActiveSwipe.delta < 0) {
+                // to left
+                PWORKSPACEL->m_vRenderOffset = Vector2D({-m_sActiveSwipe.pMonitor->vecSize.x, 0});
+            } else {
+                // to right
+                PWORKSPACER->m_vRenderOffset = Vector2D({m_sActiveSwipe.pMonitor->vecSize.x, 0});
+            }
+
+            m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D();
+        }
+    } else if (m_sActiveSwipe.delta < 0) {
+        // switch to left
+        const auto RENDEROFFSET = PWORKSPACEL->m_vRenderOffset.vec();
+
+        g_pKeybindManager->m_mDispatchers["workspace"]("[internal]" + std::to_string(workspaceIDLeft));
+
+        PWORKSPACEL->m_vRenderOffset.setValue(RENDEROFFSET);
+        PWORKSPACEL->m_fAlpha.setValueAndWarp(255.f);
+
+        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValue(RENDEROFFSETMIDDLE);
+        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(m_sActiveSwipe.pMonitor->vecSize.x, 0);
+        m_sActiveSwipe.pWorkspaceBegin->m_fAlpha.setValueAndWarp(255.f);
+
+        g_pInputManager->unconstrainMouse();
+
+        Debug::log(LOG, "Ended swipe to the left");
+    } else {
+        // switch to right
+        const auto RENDEROFFSET = PWORKSPACER->m_vRenderOffset.vec();
+
+        g_pKeybindManager->m_mDispatchers["workspace"]("[internal]" + std::to_string(workspaceIDRight));
+
+        PWORKSPACER->m_vRenderOffset.setValue(RENDEROFFSET);
+        PWORKSPACER->m_fAlpha.setValueAndWarp(255.f);
+
+        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValue(RENDEROFFSETMIDDLE);
+        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(-m_sActiveSwipe.pMonitor->vecSize.x, 0);
+        m_sActiveSwipe.pWorkspaceBegin->m_fAlpha.setValueAndWarp(255.f);
+
+        g_pInputManager->unconstrainMouse();
+
+        Debug::log(LOG, "Ended swipe to the right");
+    }
+
+    g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor);
+
+    PWORKSPACEL->m_bForceRendering = false;
+    PWORKSPACER->m_bForceRendering = false;
+    m_sActiveSwipe.pWorkspaceBegin->m_bForceRendering = false;
+
+    m_sActiveSwipe.pWorkspaceBegin = nullptr;
+
+    g_pInputManager->refocus();
+}
+
+void CInputManager::onSwipeUpdate(wlr_pointer_swipe_update_event* e) {
+    if (!m_sActiveSwipe.pWorkspaceBegin)
+        return;
+
+    static auto *const PSWIPEDIST = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_distance")->intValue;
+    static auto *const PSWIPEINVR = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_invert")->intValue;
+
+    m_sActiveSwipe.delta += *PSWIPEINVR ? -e->dx : e->dx;
+
+    m_sActiveSwipe.avgSpeed = (m_sActiveSwipe.avgSpeed * m_sActiveSwipe.speedPoints + abs(e->dx)) / (m_sActiveSwipe.speedPoints + 1);
+    m_sActiveSwipe.speedPoints++;
+
+    std::string wsname = "";
+    auto workspaceIDLeft = getWorkspaceIDFromString("m-1", wsname);
+    auto workspaceIDRight = getWorkspaceIDFromString("m+1", wsname);
+
+    if (workspaceIDLeft == INT_MAX || workspaceIDRight == INT_MAX || workspaceIDLeft == m_sActiveSwipe.pWorkspaceBegin->m_iID)
+        return;
+
+    m_sActiveSwipe.pWorkspaceBegin->m_bForceRendering = true;
+
+    m_sActiveSwipe.delta = std::clamp(m_sActiveSwipe.delta, (double)-*PSWIPEDIST, (double)*PSWIPEDIST);
+
+    if (m_sActiveSwipe.delta < 0) {
+        if (workspaceIDLeft > m_sActiveSwipe.pWorkspaceBegin->m_iID){
+            m_sActiveSwipe.delta = 0;
+            return;
+        }
+
+        const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(workspaceIDLeft);
+
+        PWORKSPACE->m_bForceRendering = true;
+        PWORKSPACE->m_fAlpha.setValueAndWarp(255.f);
+
+        if (workspaceIDLeft != workspaceIDRight) {
+            const auto PWORKSPACER = g_pCompositor->getWorkspaceByID(workspaceIDRight);
+
+            PWORKSPACER->m_bForceRendering = false;
+            PWORKSPACER->m_fAlpha.setValueAndWarp(0.f);
+        }
+
+        PWORKSPACE->m_vRenderOffset.setValueAndWarp(Vector2D(((- m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.x - m_sActiveSwipe.pMonitor->vecSize.x, 0));
+        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(((- m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.x, 0));
+
+        g_pCompositor->updateWorkspaceWindowDecos(workspaceIDLeft);
+    } else {
+        if (workspaceIDRight < m_sActiveSwipe.pWorkspaceBegin->m_iID){
+            m_sActiveSwipe.delta = 0;
+            return;
+        }
+
+        const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(workspaceIDRight);
+
+        PWORKSPACE->m_bForceRendering = true;
+        PWORKSPACE->m_fAlpha.setValueAndWarp(255.f);
+
+        if (workspaceIDLeft != workspaceIDRight) {
+            const auto PWORKSPACEL = g_pCompositor->getWorkspaceByID(workspaceIDLeft);
+
+            PWORKSPACEL->m_bForceRendering = false;
+            PWORKSPACEL->m_fAlpha.setValueAndWarp(0.f);
+        }
+
+        PWORKSPACE->m_vRenderOffset.setValueAndWarp(Vector2D(((- m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.x + m_sActiveSwipe.pMonitor->vecSize.x, 0));
+        m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(((- m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.x, 0));
+
+        g_pCompositor->updateWorkspaceWindowDecos(workspaceIDRight);
+    }
+
+    g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor);
+
+    g_pCompositor->updateWorkspaceWindowDecos(m_sActiveSwipe.pWorkspaceBegin->m_iID);
+}

src/managers/input/Tablets.cpp

@@ -10,7 +10,7 @@ void CInputManager::newTabletTool(wlr_input_device* pDevice) {
         Debug::log(ERR, "Tablet had no name???");  // logic error
     }
 
-    PNEWTABLET->wlrTablet = pDevice->tablet;
+    PNEWTABLET->wlrTablet = wlr_tablet_from_input_device(pDevice);
     PNEWTABLET->wlrDevice = pDevice;
     PNEWTABLET->wlrTabletV2 = wlr_tablet_create(g_pCompositor->m_sWLRTabletManager, g_pCompositor->m_sSeat.seat, pDevice);
     PNEWTABLET->wlrTablet->data = PNEWTABLET;
@@ -27,7 +27,7 @@ void CInputManager::newTabletTool(wlr_input_device* pDevice) {
         Debug::log(LOG, "Removed a tablet");
     }, PNEWTABLET, "Tablet");
 
-    PNEWTABLET->hyprListener_Axis.initCallback(&pDevice->tablet->events.axis, [](void* owner, void* data) {
+    PNEWTABLET->hyprListener_Axis.initCallback(&wlr_tablet_from_input_device(pDevice)->events.axis, [](void* owner, void* data) {
 
         const auto EVENT = (wlr_tablet_tool_axis_event*)data;
         const auto PTAB = (STablet*)owner;
@@ -80,7 +80,7 @@ void CInputManager::newTabletTool(wlr_input_device* pDevice) {
 
     }, PNEWTABLET, "Tablet");
 
-    PNEWTABLET->hyprListener_Tip.initCallback(&pDevice->tablet->events.tip, [](void* owner, void* data) {
+    PNEWTABLET->hyprListener_Tip.initCallback(&wlr_tablet_from_input_device(pDevice)->events.tip, [](void* owner, void* data) {
         const auto EVENT = (wlr_tablet_tool_tip_event*)data;
         const auto PTAB = (STablet*)owner;
 
@@ -98,7 +98,7 @@ void CInputManager::newTabletTool(wlr_input_device* pDevice) {
             
     }, PNEWTABLET, "Tablet");
 
-    PNEWTABLET->hyprListener_Button.initCallback(&pDevice->tablet->events.button, [](void* owner, void* data) {
+    PNEWTABLET->hyprListener_Button.initCallback(&wlr_tablet_from_input_device(pDevice)->events.button, [](void* owner, void* data) {
         const auto EVENT = (wlr_tablet_tool_button_event*)data;
 
         const auto PTOOL = g_pInputManager->ensureTabletToolPresent(EVENT->tool);
@@ -107,7 +107,7 @@ void CInputManager::newTabletTool(wlr_input_device* pDevice) {
             
     }, PNEWTABLET, "Tablet");
 
-    PNEWTABLET->hyprListener_Proximity.initCallback(&pDevice->tablet->events.proximity, [](void* owner, void* data) {
+    PNEWTABLET->hyprListener_Proximity.initCallback(&wlr_tablet_from_input_device(pDevice)->events.proximity, [](void* owner, void* data) {
         const auto EVENT = (wlr_tablet_tool_proximity_event*)data;
         const auto PTAB = (STablet*)owner;
 
@@ -165,7 +165,7 @@ void CInputManager::newTabletPad(wlr_input_device* pDevice) {
 
     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) {
+    PNEWPAD->hyprListener_Button.initCallback(&wlr_tablet_pad_from_input_device(pDevice)->events.button, [](void* owner, void* data) {
 
         const auto EVENT = (wlr_tablet_pad_button_event*)data;
         const auto PPAD = (STabletPad*)owner;
@@ -175,7 +175,7 @@ void CInputManager::newTabletPad(wlr_input_device* pDevice) {
 
     }, PNEWPAD, "Tablet Pad");
 
-    PNEWPAD->hyprListener_Strip.initCallback(&pDevice->tablet_pad->events.strip, [](void* owner, void* data) {
+    PNEWPAD->hyprListener_Strip.initCallback(&wlr_tablet_pad_from_input_device(pDevice)->events.strip, [](void* owner, void* data) {
 
         const auto EVENT = (wlr_tablet_pad_strip_event*)data;
         const auto PPAD = (STabletPad*)owner;
@@ -184,7 +184,7 @@ void CInputManager::newTabletPad(wlr_input_device* pDevice) {
 
     }, PNEWPAD, "Tablet Pad");
 
-    PNEWPAD->hyprListener_Ring.initCallback(&pDevice->tablet_pad->events.strip, [](void* owner, void* data) {
+    PNEWPAD->hyprListener_Ring.initCallback(&wlr_tablet_pad_from_input_device(pDevice)->events.strip, [](void* owner, void* data) {
 
         const auto EVENT = (wlr_tablet_pad_ring_event*)data;
         const auto PPAD = (STabletPad*)owner;
@@ -193,7 +193,7 @@ void CInputManager::newTabletPad(wlr_input_device* pDevice) {
 
     }, PNEWPAD, "Tablet Pad");
 
-    PNEWPAD->hyprListener_Attach.initCallback(&pDevice->tablet_pad->events.strip, [](void* owner, void* data) {
+    PNEWPAD->hyprListener_Attach.initCallback(&wlr_tablet_pad_from_input_device(pDevice)->events.strip, [](void* owner, void* data) {
 
         const auto TABLET = (wlr_tablet_tool*)data;
         const auto PPAD = (STabletPad*)owner;

src/managers/input/Touch.cpp

@@ -0,0 +1,45 @@
+#include "InputManager.hpp"
+#include "../../Compositor.hpp"
+
+void CInputManager::onTouchDown(wlr_touch_down_event* e) {
+
+    wlr_cursor_warp(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, g_pCompositor->m_pLastMonitor->vecPosition.x + e->x * g_pCompositor->m_pLastMonitor->vecSize.x, g_pCompositor->m_pLastMonitor->vecPosition.y + e->y * g_pCompositor->m_pLastMonitor->vecSize.y);
+
+    refocus();
+
+    m_sTouchData.touchFocusWindow = nullptr;
+
+    if (g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow)) {
+        Vector2D local;
+        if (g_pCompositor->m_pLastWindow->m_bIsX11) {
+            local = g_pInputManager->getMouseCoordsInternal() - g_pCompositor->m_pLastWindow->m_vRealPosition.goalv();
+        } else {
+            g_pCompositor->vectorWindowToSurface(g_pInputManager->getMouseCoordsInternal(), g_pCompositor->m_pLastWindow, local);
+        }
+
+        m_sTouchData.touchSurfaceOrigin = g_pInputManager->getMouseCoordsInternal() - local;
+
+        wlr_seat_touch_notify_down(g_pCompositor->m_sSeat.seat, g_pCompositor->m_pLastFocus, e->time_msec, e->touch_id, local.x, local.y);
+
+        m_sTouchData.touchFocusWindow = g_pCompositor->m_pLastWindow;
+    }
+}
+
+void CInputManager::onTouchUp(wlr_touch_up_event* e){
+    
+    if (m_sTouchData.touchFocusWindow) {
+        wlr_seat_touch_notify_up(g_pCompositor->m_sSeat.seat, e->time_msec, e->touch_id);
+    }
+}
+
+void CInputManager::onTouchMove(wlr_touch_motion_event* e){
+    if (g_pCompositor->windowValidMapped(m_sTouchData.touchFocusWindow)) {
+        const auto PMONITOR = g_pCompositor->getMonitorFromID(m_sTouchData.touchFocusWindow->m_iMonitorID);
+
+        wlr_cursor_warp(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, PMONITOR->vecPosition.x + e->x * PMONITOR->vecSize.x, PMONITOR->vecPosition.y + e->y * PMONITOR->vecSize.y);
+
+        const auto local = g_pInputManager->getMouseCoordsInternal() - m_sTouchData.touchSurfaceOrigin;
+
+        wlr_seat_touch_notify_motion(g_pCompositor->m_sSeat.seat, e->time_msec, e->touch_id, local.x, local.y);
+    }
+}

src/render/Framebuffer.cpp

@@ -2,15 +2,14 @@
 #include "OpenGL.hpp"
 
 bool CFramebuffer::alloc(int w, int h) {
-     bool firstAlloc = false;
-    if (m_iFb == (uint32_t)-1)
-    {
+    bool firstAlloc = false;
+    
+    if (m_iFb == (uint32_t)-1) {
         firstAlloc = true;
         glGenFramebuffers(1, &m_iFb);
     }
 
-    if (m_cTex.m_iTexID == 0)
-    {
+    if (m_cTex.m_iTexID == 0)  {
         firstAlloc = true;
         glGenTextures(1, &m_cTex.m_iTexID);
         glBindTexture(GL_TEXTURE_2D, m_cTex.m_iTexID);
@@ -20,13 +19,11 @@ bool CFramebuffer::alloc(int w, int h) {
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     }
 
-    if (firstAlloc || m_Size != Vector2D(w, h))
-    {
+    if (firstAlloc || m_Size != Vector2D(w, h)) {
         glBindTexture(GL_TEXTURE_2D, m_cTex.m_iTexID);
         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 
         glBindFramebuffer(GL_FRAMEBUFFER, m_iFb);
-        glBindTexture(GL_TEXTURE_2D, m_cTex.m_iTexID);
         glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_cTex.m_iTexID, 0);
 
 
@@ -37,7 +34,6 @@ bool CFramebuffer::alloc(int w, int h) {
             glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, w, h, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 0);
 
             glBindFramebuffer(GL_FRAMEBUFFER, m_iFb);
-            glBindTexture(GL_TEXTURE_2D, m_pStencilTex->m_iTexID);
 
             glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_pStencilTex->m_iTexID, 0);
         }
@@ -78,3 +74,7 @@ void CFramebuffer::release() {
     m_cTex.m_iTexID = 0;
     m_iFb = -1;
 }
+
+CFramebuffer::~CFramebuffer() {
+    release();
+}

src/render/Framebuffer.hpp

@@ -6,6 +6,8 @@
 class CFramebuffer {
 public:
 
+    ~CFramebuffer();
+
     bool alloc(int w, int h);
     void bind();
     void release();

src/render/OpenGL.cpp

@@ -23,72 +23,6 @@ CHyprOpenGLImpl::CHyprOpenGLImpl() {
     Debug::log(WARN, "!RENDERER: Using the legacy GLES2 renderer!");
     #endif
 
-    // Init shaders
-
-    GLuint prog = createProgram(QUADVERTSRC, QUADFRAGSRC);
-    m_shQUAD.program = prog;
-    m_shQUAD.proj = glGetUniformLocation(prog, "proj");
-    m_shQUAD.color = glGetUniformLocation(prog, "color");
-    m_shQUAD.posAttrib = glGetAttribLocation(prog, "pos");
-    m_shQUAD.texAttrib = glGetAttribLocation(prog, "texcoord");
-
-    prog = createProgram(TEXVERTSRC, TEXFRAGSRCRGBA);
-    m_shRGBA.program = prog;
-    m_shRGBA.proj = glGetUniformLocation(prog, "proj");
-    m_shRGBA.tex = glGetUniformLocation(prog, "tex");
-    m_shRGBA.alpha = glGetUniformLocation(prog, "alpha");
-    m_shRGBA.texAttrib = glGetAttribLocation(prog, "texcoord");
-    m_shRGBA.posAttrib = glGetAttribLocation(prog, "pos");
-    m_shRGBA.discardOpaque = glGetUniformLocation(prog, "discardOpaque");
-
-    prog = createProgram(TEXVERTSRC, TEXFRAGSRCRGBX);
-    m_shRGBX.program = prog;
-    m_shRGBX.tex = glGetUniformLocation(prog, "tex");
-    m_shRGBX.proj = glGetUniformLocation(prog, "proj");
-    m_shRGBX.alpha = glGetUniformLocation(prog, "alpha");
-    m_shRGBX.texAttrib = glGetAttribLocation(prog, "texcoord");
-    m_shRGBX.posAttrib = glGetAttribLocation(prog, "pos");
-    m_shRGBX.discardOpaque = glGetUniformLocation(prog, "discardOpaque");
-
-    prog = createProgram(TEXVERTSRC, TEXFRAGSRCEXT);
-    m_shEXT.program = prog;
-    m_shEXT.tex = glGetUniformLocation(prog, "tex");
-    m_shEXT.proj = glGetUniformLocation(prog, "proj");
-    m_shEXT.alpha = glGetUniformLocation(prog, "alpha");
-    m_shEXT.posAttrib = glGetAttribLocation(prog, "pos");
-    m_shEXT.texAttrib = glGetAttribLocation(prog, "texcoord");
-    m_shEXT.discardOpaque = glGetUniformLocation(prog, "discardOpaque");
-
-    prog = createProgram(TEXVERTSRC, FRAGBLUR1);
-    m_shBLUR1.program = prog;
-    m_shBLUR1.tex = glGetUniformLocation(prog, "tex");
-    m_shBLUR1.alpha = glGetUniformLocation(prog, "alpha");
-    m_shBLUR1.proj = glGetUniformLocation(prog, "proj");
-    m_shBLUR1.posAttrib = glGetAttribLocation(prog, "pos");
-    m_shBLUR1.texAttrib = glGetAttribLocation(prog, "texcoord");
-
-    prog = createProgram(TEXVERTSRC, FRAGBLUR2);
-    m_shBLUR2.program = prog;
-    m_shBLUR2.tex = glGetUniformLocation(prog, "tex");
-    m_shBLUR2.alpha = glGetUniformLocation(prog, "alpha");
-    m_shBLUR2.proj = glGetUniformLocation(prog, "proj");
-    m_shBLUR2.posAttrib = glGetAttribLocation(prog, "pos");
-    m_shBLUR2.texAttrib = glGetAttribLocation(prog, "texcoord");
-
-    prog = createProgram(QUADVERTSRC, FRAGSHADOW);
-    m_shSHADOW.program = prog;
-    m_shSHADOW.proj = glGetUniformLocation(prog, "proj");
-    m_shSHADOW.posAttrib = glGetAttribLocation(prog, "pos");
-    m_shSHADOW.texAttrib = glGetAttribLocation(prog, "texcoord");
-
-    prog = createProgram(QUADVERTSRC, FRAGBORDER1);
-    m_shBORDER1.program = prog;
-    m_shBORDER1.proj = glGetUniformLocation(prog, "proj");
-    m_shBORDER1.posAttrib = glGetAttribLocation(prog, "pos");
-    m_shBORDER1.texAttrib = glGetAttribLocation(prog, "texcoord");
-
-    Debug::log(LOG, "Shaders initialized successfully.");
-
     // End shaders
 
     pixman_region32_init(&m_rOriginalDamageRegion);
@@ -139,9 +73,13 @@ GLuint CHyprOpenGLImpl::compileShader(const GLuint& type, std::string src) {
     return shader;
 }
 
-void CHyprOpenGLImpl::begin(SMonitor* pMonitor, pixman_region32_t* pDamage, bool fake) {
+void CHyprOpenGLImpl::begin(CMonitor* pMonitor, pixman_region32_t* pDamage, bool fake) {
     m_RenderData.pMonitor = pMonitor;
 
+    if (eglGetCurrentContext() != wlr_egl_get_context(g_pCompositor->m_sWLREGL)) {
+        eglMakeCurrent(wlr_egl_get_display(g_pCompositor->m_sWLREGL), EGL_NO_SURFACE, EGL_NO_SURFACE, wlr_egl_get_context(g_pCompositor->m_sWLREGL));
+    }
+
     glViewport(0, 0, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y);
 
     matrixProjection(m_RenderData.projection, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y, WL_OUTPUT_TRANSFORM_NORMAL);
@@ -168,6 +106,9 @@ void CHyprOpenGLImpl::begin(SMonitor* pMonitor, pixman_region32_t* pDamage, bool
         createBGTextureForMonitor(pMonitor);
     }
 
+    if (!m_RenderData.pCurrentMonData->m_bShadersInitialized)
+        initShaders();
+
     // bind the primary Hypr Framebuffer
     m_RenderData.pCurrentMonData->primaryFB.bind();
 
@@ -198,6 +139,112 @@ void CHyprOpenGLImpl::end() {
     m_iWLROutputFb = 0;
 }
 
+void CHyprOpenGLImpl::initShaders() {
+    GLuint prog = createProgram(QUADVERTSRC, QUADFRAGSRC);
+    m_RenderData.pCurrentMonData->m_shQUAD.program = prog;
+    m_RenderData.pCurrentMonData->m_shQUAD.proj = glGetUniformLocation(prog, "proj");
+    m_RenderData.pCurrentMonData->m_shQUAD.color = glGetUniformLocation(prog, "color");
+    m_RenderData.pCurrentMonData->m_shQUAD.posAttrib = glGetAttribLocation(prog, "pos");
+    m_RenderData.pCurrentMonData->m_shQUAD.texAttrib = glGetAttribLocation(prog, "texcoord");
+    m_RenderData.pCurrentMonData->m_shQUAD.topLeft = glGetUniformLocation(prog, "topLeft");
+    m_RenderData.pCurrentMonData->m_shQUAD.bottomRight = glGetUniformLocation(prog, "bottomRight");
+    m_RenderData.pCurrentMonData->m_shQUAD.fullSize = glGetUniformLocation(prog, "fullSize");
+    m_RenderData.pCurrentMonData->m_shQUAD.radius = glGetUniformLocation(prog, "radius");
+    m_RenderData.pCurrentMonData->m_shQUAD.primitiveMultisample = glGetUniformLocation(prog, "primitiveMultisample");
+
+    prog = createProgram(TEXVERTSRC, TEXFRAGSRCRGBA);
+    m_RenderData.pCurrentMonData->m_shRGBA.program = prog;
+    m_RenderData.pCurrentMonData->m_shRGBA.proj = glGetUniformLocation(prog, "proj");
+    m_RenderData.pCurrentMonData->m_shRGBA.tex = glGetUniformLocation(prog, "tex");
+    m_RenderData.pCurrentMonData->m_shRGBA.alpha = glGetUniformLocation(prog, "alpha");
+    m_RenderData.pCurrentMonData->m_shRGBA.texAttrib = glGetAttribLocation(prog, "texcoord");
+    m_RenderData.pCurrentMonData->m_shRGBA.posAttrib = glGetAttribLocation(prog, "pos");
+    m_RenderData.pCurrentMonData->m_shRGBA.discardOpaque = glGetUniformLocation(prog, "discardOpaque");
+    m_RenderData.pCurrentMonData->m_shRGBA.topLeft = glGetUniformLocation(prog, "topLeft");
+    m_RenderData.pCurrentMonData->m_shRGBA.bottomRight = glGetUniformLocation(prog, "bottomRight");
+    m_RenderData.pCurrentMonData->m_shRGBA.fullSize = glGetUniformLocation(prog, "fullSize");
+    m_RenderData.pCurrentMonData->m_shRGBA.radius = glGetUniformLocation(prog, "radius");
+    m_RenderData.pCurrentMonData->m_shRGBA.primitiveMultisample = glGetUniformLocation(prog, "primitiveMultisample");
+
+    prog = createProgram(TEXVERTSRC, TEXFRAGSRCRGBX);
+    m_RenderData.pCurrentMonData->m_shRGBX.program = prog;
+    m_RenderData.pCurrentMonData->m_shRGBX.tex = glGetUniformLocation(prog, "tex");
+    m_RenderData.pCurrentMonData->m_shRGBX.proj = glGetUniformLocation(prog, "proj");
+    m_RenderData.pCurrentMonData->m_shRGBX.alpha = glGetUniformLocation(prog, "alpha");
+    m_RenderData.pCurrentMonData->m_shRGBX.texAttrib = glGetAttribLocation(prog, "texcoord");
+    m_RenderData.pCurrentMonData->m_shRGBX.posAttrib = glGetAttribLocation(prog, "pos");
+    m_RenderData.pCurrentMonData->m_shRGBX.discardOpaque = glGetUniformLocation(prog, "discardOpaque");
+    m_RenderData.pCurrentMonData->m_shRGBX.topLeft = glGetUniformLocation(prog, "topLeft");
+    m_RenderData.pCurrentMonData->m_shRGBX.bottomRight = glGetUniformLocation(prog, "bottomRight");
+    m_RenderData.pCurrentMonData->m_shRGBX.fullSize = glGetUniformLocation(prog, "fullSize");
+    m_RenderData.pCurrentMonData->m_shRGBX.radius = glGetUniformLocation(prog, "radius");
+    m_RenderData.pCurrentMonData->m_shRGBX.primitiveMultisample = glGetUniformLocation(prog, "primitiveMultisample");
+
+    prog = createProgram(TEXVERTSRC, TEXFRAGSRCEXT);
+    m_RenderData.pCurrentMonData->m_shEXT.program = prog;
+    m_RenderData.pCurrentMonData->m_shEXT.tex = glGetUniformLocation(prog, "tex");
+    m_RenderData.pCurrentMonData->m_shEXT.proj = glGetUniformLocation(prog, "proj");
+    m_RenderData.pCurrentMonData->m_shEXT.alpha = glGetUniformLocation(prog, "alpha");
+    m_RenderData.pCurrentMonData->m_shEXT.posAttrib = glGetAttribLocation(prog, "pos");
+    m_RenderData.pCurrentMonData->m_shEXT.texAttrib = glGetAttribLocation(prog, "texcoord");
+    m_RenderData.pCurrentMonData->m_shEXT.discardOpaque = glGetUniformLocation(prog, "discardOpaque");
+    m_RenderData.pCurrentMonData->m_shEXT.topLeft = glGetUniformLocation(prog, "topLeft");
+    m_RenderData.pCurrentMonData->m_shEXT.bottomRight = glGetUniformLocation(prog, "bottomRight");
+    m_RenderData.pCurrentMonData->m_shEXT.fullSize = glGetUniformLocation(prog, "fullSize");
+    m_RenderData.pCurrentMonData->m_shEXT.radius = glGetUniformLocation(prog, "radius");
+    m_RenderData.pCurrentMonData->m_shEXT.primitiveMultisample = glGetUniformLocation(prog, "primitiveMultisample");
+
+    prog = createProgram(TEXVERTSRC, FRAGBLUR1);
+    m_RenderData.pCurrentMonData->m_shBLUR1.program = prog;
+    m_RenderData.pCurrentMonData->m_shBLUR1.tex = glGetUniformLocation(prog, "tex");
+    m_RenderData.pCurrentMonData->m_shBLUR1.alpha = glGetUniformLocation(prog, "alpha");
+    m_RenderData.pCurrentMonData->m_shBLUR1.proj = glGetUniformLocation(prog, "proj");
+    m_RenderData.pCurrentMonData->m_shBLUR1.posAttrib = glGetAttribLocation(prog, "pos");
+    m_RenderData.pCurrentMonData->m_shBLUR1.texAttrib = glGetAttribLocation(prog, "texcoord");
+    m_RenderData.pCurrentMonData->m_shBLUR1.radius = glGetUniformLocation(prog, "radius");
+    m_RenderData.pCurrentMonData->m_shBLUR1.halfpixel = glGetUniformLocation(prog, "halfpixel");
+
+    prog = createProgram(TEXVERTSRC, FRAGBLUR2);
+    m_RenderData.pCurrentMonData->m_shBLUR2.program = prog;
+    m_RenderData.pCurrentMonData->m_shBLUR2.tex = glGetUniformLocation(prog, "tex");
+    m_RenderData.pCurrentMonData->m_shBLUR2.alpha = glGetUniformLocation(prog, "alpha");
+    m_RenderData.pCurrentMonData->m_shBLUR2.proj = glGetUniformLocation(prog, "proj");
+    m_RenderData.pCurrentMonData->m_shBLUR2.posAttrib = glGetAttribLocation(prog, "pos");
+    m_RenderData.pCurrentMonData->m_shBLUR2.texAttrib = glGetAttribLocation(prog, "texcoord");
+    m_RenderData.pCurrentMonData->m_shBLUR2.radius = glGetUniformLocation(prog, "radius");
+    m_RenderData.pCurrentMonData->m_shBLUR2.halfpixel = glGetUniformLocation(prog, "halfpixel");
+
+    prog = createProgram(QUADVERTSRC, FRAGSHADOW);
+    m_RenderData.pCurrentMonData->m_shSHADOW.program = prog;
+    m_RenderData.pCurrentMonData->m_shSHADOW.proj = glGetUniformLocation(prog, "proj");
+    m_RenderData.pCurrentMonData->m_shSHADOW.posAttrib = glGetAttribLocation(prog, "pos");
+    m_RenderData.pCurrentMonData->m_shSHADOW.texAttrib = glGetAttribLocation(prog, "texcoord");
+    m_RenderData.pCurrentMonData->m_shSHADOW.topLeft = glGetUniformLocation(prog, "topLeft");
+    m_RenderData.pCurrentMonData->m_shSHADOW.bottomRight = glGetUniformLocation(prog, "bottomRight");
+    m_RenderData.pCurrentMonData->m_shSHADOW.fullSize = glGetUniformLocation(prog, "fullSize");
+    m_RenderData.pCurrentMonData->m_shSHADOW.radius = glGetUniformLocation(prog, "radius");
+    m_RenderData.pCurrentMonData->m_shSHADOW.range = glGetUniformLocation(prog, "range");
+    m_RenderData.pCurrentMonData->m_shSHADOW.shadowPower = glGetUniformLocation(prog, "shadowPower");
+    m_RenderData.pCurrentMonData->m_shSHADOW.color = glGetUniformLocation(prog, "color");
+
+    prog = createProgram(QUADVERTSRC, FRAGBORDER1);
+    m_RenderData.pCurrentMonData->m_shBORDER1.program = prog;
+    m_RenderData.pCurrentMonData->m_shBORDER1.proj = glGetUniformLocation(prog, "proj");
+    m_RenderData.pCurrentMonData->m_shBORDER1.thick = glGetUniformLocation(prog, "thick");
+    m_RenderData.pCurrentMonData->m_shBORDER1.posAttrib = glGetAttribLocation(prog, "pos");
+    m_RenderData.pCurrentMonData->m_shBORDER1.texAttrib = glGetAttribLocation(prog, "texcoord");
+    m_RenderData.pCurrentMonData->m_shBORDER1.topLeft = glGetUniformLocation(prog, "topLeft");
+    m_RenderData.pCurrentMonData->m_shBORDER1.bottomRight = glGetUniformLocation(prog, "bottomRight");
+    m_RenderData.pCurrentMonData->m_shBORDER1.fullSize = glGetUniformLocation(prog, "fullSize");
+    m_RenderData.pCurrentMonData->m_shBORDER1.radius = glGetUniformLocation(prog, "radius");
+    m_RenderData.pCurrentMonData->m_shBORDER1.primitiveMultisample = glGetUniformLocation(prog, "primitiveMultisample");
+    m_RenderData.pCurrentMonData->m_shBORDER1.color = glGetUniformLocation(prog, "color");
+
+    m_RenderData.pCurrentMonData->m_bShadersInitialized = true;
+
+    Debug::log(LOG, "Shaders initialized successfully.");
+}
+
 void CHyprOpenGLImpl::clear(const CColor& color) {
     RASSERT(m_RenderData.pMonitor, "Tried to render without begin()!");
 
@@ -273,10 +320,10 @@ void CHyprOpenGLImpl::renderRectWithDamage(wlr_box* box, const CColor& col, pixm
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-    glUseProgram(m_shQUAD.program);
+    glUseProgram(m_RenderData.pCurrentMonData->m_shQUAD.program);
 
-    glUniformMatrix3fv(m_shQUAD.proj, 1, GL_FALSE, glMatrix);
-    glUniform4f(m_shQUAD.color, col.r / 255.f, col.g / 255.f, col.b / 255.f, col.a / 255.f);
+    glUniformMatrix3fv(m_RenderData.pCurrentMonData->m_shQUAD.proj, 1, GL_FALSE, glMatrix);
+    glUniform4f(m_RenderData.pCurrentMonData->m_shQUAD.color, col.r / 255.f, col.g / 255.f, col.b / 255.f, col.a / 255.f);
 
     const auto TOPLEFT = Vector2D(round, round);
     const auto BOTTOMRIGHT = Vector2D(box->width - round, box->height - round);
@@ -285,17 +332,17 @@ void CHyprOpenGLImpl::renderRectWithDamage(wlr_box* box, const CColor& col, pixm
     static auto *const PMULTISAMPLEEDGES = &g_pConfigManager->getConfigValuePtr("decoration:multisample_edges")->intValue;
 
     // Rounded corners
-    glUniform2f(m_shQUAD.getUniformLocation("topLeft"), (float)TOPLEFT.x, (float)TOPLEFT.y);
-    glUniform2f(m_shQUAD.getUniformLocation("bottomRight"), (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
-    glUniform2f(m_shQUAD.getUniformLocation("fullSize"), (float)FULLSIZE.x, (float)FULLSIZE.y);
-    glUniform1f(m_shQUAD.getUniformLocation("radius"), round);
-    glUniform1i(m_shQUAD.getUniformLocation("primitiveMultisample"), (int)(*PMULTISAMPLEEDGES == 1 && round != 0));
+    glUniform2f(m_RenderData.pCurrentMonData->m_shQUAD.topLeft, (float)TOPLEFT.x, (float)TOPLEFT.y);
+    glUniform2f(m_RenderData.pCurrentMonData->m_shQUAD.bottomRight, (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
+    glUniform2f(m_RenderData.pCurrentMonData->m_shQUAD.fullSize, (float)FULLSIZE.x, (float)FULLSIZE.y);
+    glUniform1f(m_RenderData.pCurrentMonData->m_shQUAD.radius, round);
+    glUniform1i(m_RenderData.pCurrentMonData->m_shQUAD.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);
+    glVertexAttribPointer(m_RenderData.pCurrentMonData->m_shQUAD.posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
+    glVertexAttribPointer(m_RenderData.pCurrentMonData->m_shQUAD.texAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
 
-    glEnableVertexAttribArray(m_shQUAD.posAttrib);
-    glEnableVertexAttribArray(m_shQUAD.texAttrib);
+    glEnableVertexAttribArray(m_RenderData.pCurrentMonData->m_shQUAD.posAttrib);
+    glEnableVertexAttribArray(m_RenderData.pCurrentMonData->m_shQUAD.texAttrib);
 
     if (pixman_region32_not_empty(damage)) {
         PIXMAN_DAMAGE_FOREACH(damage) {
@@ -305,8 +352,8 @@ void CHyprOpenGLImpl::renderRectWithDamage(wlr_box* box, const CColor& col, pixm
         }
     }
 
-    glDisableVertexAttribArray(m_shQUAD.posAttrib);
-    glDisableVertexAttribArray(m_shQUAD.texAttrib);
+    glDisableVertexAttribArray(m_RenderData.pCurrentMonData->m_shQUAD.posAttrib);
+    glDisableVertexAttribArray(m_RenderData.pCurrentMonData->m_shQUAD.texAttrib);
 
     glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 }
@@ -347,13 +394,13 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_b
 
     switch (tex.m_iType) {
         case TEXTURE_RGBA:
-            shader = &m_shRGBA;
+            shader = &m_RenderData.pCurrentMonData->m_shRGBA;
             break;
         case TEXTURE_RGBX:
-            shader = &m_shRGBX;
+            shader = &m_RenderData.pCurrentMonData->m_shRGBX;
             break;
         case TEXTURE_EXTERNAL:
-            shader = &m_shEXT;
+            shader = &m_RenderData.pCurrentMonData->m_shEXT;
             break;
         default:
             RASSERT(false, "tex.m_iTarget unsupported!");
@@ -380,22 +427,22 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_b
     static auto *const PMULTISAMPLEEDGES = &g_pConfigManager->getConfigValuePtr("decoration:multisample_edges")->intValue;
 
     // Rounded corners
-    glUniform2f(shader->getUniformLocation("topLeft"), (float)TOPLEFT.x, (float)TOPLEFT.y);
-    glUniform2f(shader->getUniformLocation("bottomRight"), (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
-    glUniform2f(shader->getUniformLocation("fullSize"), (float)FULLSIZE.x, (float)FULLSIZE.y);
-    glUniform1f(shader->getUniformLocation("radius"), round);
-    glUniform1i(shader->getUniformLocation("primitiveMultisample"), (int)(*PMULTISAMPLEEDGES == 1 && round != 0 && !noAA));
+    glUniform2f(shader->topLeft, (float)TOPLEFT.x, (float)TOPLEFT.y);
+    glUniform2f(shader->bottomRight, (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
+    glUniform2f(shader->fullSize, (float)FULLSIZE.x, (float)FULLSIZE.y);
+    glUniform1f(shader->radius, round);
+    glUniform1i(shader->primitiveMultisample, (int)(*PMULTISAMPLEEDGES == 1 && round != 0 && !noAA));
 
     glVertexAttribPointer(shader->posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
 
-    if (allowCustomUV && m_RenderData.primarySurfaceUVTopLeft != Vector2D(-1, -1)) {
-        const float verts[] = {
-            m_RenderData.primarySurfaceUVBottomRight.x, m_RenderData.primarySurfaceUVTopLeft.y,      // top right
-            m_RenderData.primarySurfaceUVTopLeft.x, m_RenderData.primarySurfaceUVTopLeft.y,          // top left
-            m_RenderData.primarySurfaceUVBottomRight.x, m_RenderData.primarySurfaceUVBottomRight.y,  // bottom right
-            m_RenderData.primarySurfaceUVTopLeft.x, m_RenderData.primarySurfaceUVBottomRight.y,      // bottom left
-        };
+    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
+    };
 
+    if (allowCustomUV && m_RenderData.primarySurfaceUVTopLeft != Vector2D(-1, -1)) {
         glVertexAttribPointer(shader->texAttrib, 2, GL_FLOAT, GL_FALSE, 0, verts);
     } else {
         glVertexAttribPointer(shader->texAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
@@ -471,11 +518,11 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, wlr_box* p
 
         // prep two shaders
         glUniformMatrix3fv(pShader->proj, 1, GL_FALSE, glMatrix);
-        glUniform1f(pShader->getUniformLocation("radius"), *PBLURSIZE * (a / 255.f));  // this makes the blursize change with a
-        if (pShader == &m_shBLUR1)
-            glUniform2f(m_shBLUR1.getUniformLocation("halfpixel"), 0.5f / (m_RenderData.pMonitor->vecPixelSize.x / 2.f), 0.5f / (m_RenderData.pMonitor->vecPixelSize.y / 2.f));
+        glUniform1f(pShader->radius, *PBLURSIZE * (a / 255.f));  // this makes the blursize change with a
+        if (pShader == &m_RenderData.pCurrentMonData->m_shBLUR1)
+            glUniform2f(m_RenderData.pCurrentMonData->m_shBLUR1.halfpixel, 0.5f / (m_RenderData.pMonitor->vecPixelSize.x / 2.f), 0.5f / (m_RenderData.pMonitor->vecPixelSize.y / 2.f));
         else
-            glUniform2f(m_shBLUR2.getUniformLocation("halfpixel"), 0.5f / (m_RenderData.pMonitor->vecPixelSize.x * 2.f), 0.5f / (m_RenderData.pMonitor->vecPixelSize.y * 2.f));
+            glUniform2f(m_RenderData.pCurrentMonData->m_shBLUR2.halfpixel, 0.5f / (m_RenderData.pMonitor->vecPixelSize.x * 2.f), 0.5f / (m_RenderData.pMonitor->vecPixelSize.y * 2.f));
         glUniform1i(pShader->tex, 0);
 
         glVertexAttribPointer(pShader->posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
@@ -512,17 +559,17 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, wlr_box* p
     pixman_region32_init(&tempDamage);
     wlr_region_scale(&tempDamage, &damage, 1.f / 2.f); // when DOWNscaling, we make the region twice as small because it's the TARGET
 
-    drawPass(&m_shBLUR1, &tempDamage);
+    drawPass(&m_RenderData.pCurrentMonData->m_shBLUR1, &tempDamage);
 
     // and draw
     for (int i = 1; i < *PBLURPASSES; ++i) {
         wlr_region_scale(&tempDamage, &damage, 1.f / (1 << (i + 1)));
-        drawPass(&m_shBLUR1, &tempDamage);  // down
+        drawPass(&m_RenderData.pCurrentMonData->m_shBLUR1, &tempDamage);  // down
     }
 
     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
+        drawPass(&m_RenderData.pCurrentMonData->m_shBLUR2, &tempDamage);  // up
     }
 
     // finish
@@ -537,11 +584,77 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, wlr_box* p
     return currentRenderToFB;
 }
 
+void CHyprOpenGLImpl::markBlurDirtyForMonitor(CMonitor* pMonitor) {
+    m_mMonitorRenderResources[pMonitor].blurFBDirty = true;
+}
+
+void CHyprOpenGLImpl::preRender(CMonitor* pMonitor) {
+    static auto *const PBLURNEWOPTIMIZE = &g_pConfigManager->getConfigValuePtr("decoration:blur_new_optimizations")->intValue;
+
+    if (!*PBLURNEWOPTIMIZE || !m_mMonitorRenderResources[pMonitor].blurFBDirty)
+        return;
+
+    bool has = false;
+
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (w->m_iWorkspaceID == pMonitor->activeWorkspace && w->m_bIsMapped && !w->m_bHidden && !w->m_bIsFloating) {
+            has = true;
+            break;
+        }
+    }
+
+    if (has)
+        g_pHyprRenderer->damageMonitor(pMonitor);
+}
+
+void CHyprOpenGLImpl::preBlurForCurrentMonitor() {
+
+    // make the fake dmg
+    pixman_region32_t fakeDamage;
+    pixman_region32_init_rect(&fakeDamage, 0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y);
+    wlr_box wholeMonitor = {0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y};
+    const auto POUTFB = blurMainFramebufferWithDamage(255, &wholeMonitor, &fakeDamage);
+
+    // render onto blurFB
+    m_RenderData.pCurrentMonData->blurFB.alloc(m_RenderData.pMonitor->vecPixelSize.x, m_RenderData.pMonitor->vecPixelSize.y);
+    m_RenderData.pCurrentMonData->blurFB.bind();
+
+    clear(CColor(0,0,0,0));
+
+    renderTextureInternalWithDamage(POUTFB->m_cTex, &wholeMonitor, 255, &fakeDamage, 0, false, true, false);
+
+    m_RenderData.pCurrentMonData->primaryFB.bind();
+
+    m_RenderData.pCurrentMonData->blurFBDirty = false;
+}
+
+void CHyprOpenGLImpl::preWindowPass() {
+    static auto* const PBLURNEWOPTIMIZE = &g_pConfigManager->getConfigValuePtr("decoration:blur_new_optimizations")->intValue;
+
+    if (!m_RenderData.pCurrentMonData->blurFBDirty || !*PBLURNEWOPTIMIZE)
+        return;
+
+    bool hasWindows = false;
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (w->m_iWorkspaceID == m_RenderData.pMonitor->activeWorkspace && !w->m_bHidden && w->m_bIsMapped && !w->m_bIsFloating) {
+            hasWindows = true;
+            break;  
+        }
+    }
+
+    if (!hasWindows)
+        return;
+
+    // blur the main FB, it will be rendered onto the mirror
+    preBlurForCurrentMonitor();
+}
+
 void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox, float a, wlr_surface* pSurface, int round) {
     RASSERT(m_RenderData.pMonitor, "Tried to render texture with blur without begin()!");
 
     static auto *const PBLURENABLED = &g_pConfigManager->getConfigValuePtr("decoration:blur")->intValue;
-    static auto* const PNOBLUROVERSIZED = &g_pConfigManager->getConfigValuePtr("decoration:no_blur_on_oversized")->intValue;
+    static auto *const PNOBLUROVERSIZED = &g_pConfigManager->getConfigValuePtr("decoration:no_blur_on_oversized")->intValue;
+    static auto* const PBLURNEWOPTIMIZE = &g_pConfigManager->getConfigValuePtr("decoration:blur_new_optimizations")->intValue;
 
     if (*PBLURENABLED == 0 || (*PNOBLUROVERSIZED && m_RenderData.primarySurfaceUVTopLeft != Vector2D(-1, -1)) || (m_pCurrentWindow && m_pCurrentWindow->m_sAdditionalConfigData.forceNoBlur)) {
         renderTexture(tex, pBox, a, round, false, true);
@@ -567,12 +680,14 @@ void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox,
     }
 
     if (!pixman_region32_not_empty(&inverseOpaque)) {
-        renderTexture(tex, pBox, a, round, false); // reject blurring a fully opaque window
+        renderTexture(tex, pBox, a, round, false, true); // 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);
+        //                                                                        vvv TODO: layered blur fbs?
+    const bool USENEWOPTIMIZE = (*PBLURNEWOPTIMIZE && m_pCurrentWindow && !m_pCurrentWindow->m_bIsFloating && m_RenderData.pCurrentMonData->blurFB.m_cTex.m_iTexID);
+
+    const auto POUTFB = USENEWOPTIMIZE ? &m_RenderData.pCurrentMonData->blurFB : blurMainFramebufferWithDamage(a, pBox, &inverseOpaque);
 
     pixman_region32_fini(&inverseOpaque);
 
@@ -590,7 +705,10 @@ void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox,
     glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
 
     glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
-    renderTexture(tex, pBox, a, round, true);  // discard opaque
+    if (USENEWOPTIMIZE)
+        renderRect(pBox, CColor(0,0,0,0), round);
+    else
+        renderTexture(tex, pBox, a, round, true, true);  // discard opaque
     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 
     glStencilFunc(GL_EQUAL, 1, -1);
@@ -601,7 +719,7 @@ void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox,
     if (pixman_region32_not_empty(&damage)) {
         // render our great blurred FB
         static auto *const PBLURIGNOREOPACITY = &g_pConfigManager->getConfigValuePtr("decoration:blur_ignore_opacity")->intValue;
-        renderTextureInternalWithDamage(POUTFB->m_cTex, &MONITORBOX, *PBLURIGNOREOPACITY ? 255.f : a, &damage, 0, false, false, true);
+        renderTextureInternalWithDamage(POUTFB->m_cTex, &MONITORBOX, *PBLURIGNOREOPACITY ? 255.f : a, &damage, 0, false, false, false);
 
         // render the window, but clear stencil
         glClearStencil(0);
@@ -632,6 +750,23 @@ void CHyprOpenGLImpl::renderBorder(wlr_box* box, const CColor& col, int round) {
     static auto *const PBORDERSIZE = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
     static auto *const PMULTISAMPLE = &g_pConfigManager->getConfigValuePtr("decoration:multisample_edges")->intValue;
 
+    if (*PBORDERSIZE < 1)
+        return;
+
+    if (round < 1) {
+        // zero rounding, just lines
+        wlr_box borderbox = {box->x - *PBORDERSIZE, box->y - *PBORDERSIZE, *PBORDERSIZE, box->height + 2 * *PBORDERSIZE};
+        renderRect(&borderbox, col, 0); // left
+        borderbox = {box->x, box->y - (int)*PBORDERSIZE, box->width + (int)*PBORDERSIZE, (int)*PBORDERSIZE};
+        renderRect(&borderbox, col, 0);  // top
+        borderbox = {box->x + box->width, box->y, (int)*PBORDERSIZE, box->height + (int)*PBORDERSIZE};
+        renderRect(&borderbox, col, 0);  // right
+        borderbox = {box->x, box->y + box->height, box->width, (int)*PBORDERSIZE};
+        renderRect(&borderbox, col, 0);  // bottom
+
+        return;
+    }
+
     // adjust box
     box->x -= *PBORDERSIZE;
     box->y -= *PBORDERSIZE;
@@ -652,27 +787,27 @@ void CHyprOpenGLImpl::renderBorder(wlr_box* box, const CColor& col, int round) {
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-    glUseProgram(m_shBORDER1.program);
+    glUseProgram(m_RenderData.pCurrentMonData->m_shBORDER1.program);
 
-    glUniformMatrix3fv(m_shBORDER1.proj, 1, GL_FALSE, glMatrix);
-    glUniform4f(m_shBORDER1.getUniformLocation("color"), col.r / 255.f, col.g / 255.f, col.b / 255.f, col.a / 255.f);
+    glUniformMatrix3fv(m_RenderData.pCurrentMonData->m_shBORDER1.proj, 1, GL_FALSE, glMatrix);
+    glUniform4f(m_RenderData.pCurrentMonData->m_shBORDER1.color, col.r / 255.f, col.g / 255.f, col.b / 255.f, col.a / 255.f);
 
     const auto TOPLEFT = Vector2D(round, round);
     const auto BOTTOMRIGHT = Vector2D(box->width - round, box->height - round);
     const auto FULLSIZE = Vector2D(box->width, box->height);
 
-    glUniform2f(m_shBORDER1.getUniformLocation("topLeft"), (float)TOPLEFT.x, (float)TOPLEFT.y);
-    glUniform2f(m_shBORDER1.getUniformLocation("bottomRight"), (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
-    glUniform2f(m_shBORDER1.getUniformLocation("fullSize"), (float)FULLSIZE.x, (float)FULLSIZE.y);
-    glUniform1f(m_shBORDER1.getUniformLocation("radius"), round);
-    glUniform1f(m_shBORDER1.getUniformLocation("thick"), *PBORDERSIZE);
-    glUniform1i(m_shBORDER1.getUniformLocation("primitiveMultisample"), *PMULTISAMPLE);
+    glUniform2f(m_RenderData.pCurrentMonData->m_shBORDER1.topLeft, (float)TOPLEFT.x, (float)TOPLEFT.y);
+    glUniform2f(m_RenderData.pCurrentMonData->m_shBORDER1.bottomRight, (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
+    glUniform2f(m_RenderData.pCurrentMonData->m_shBORDER1.fullSize, (float)FULLSIZE.x, (float)FULLSIZE.y);
+    glUniform1f(m_RenderData.pCurrentMonData->m_shBORDER1.radius, round);
+    glUniform1f(m_RenderData.pCurrentMonData->m_shBORDER1.thick, *PBORDERSIZE);
+    glUniform1i(m_RenderData.pCurrentMonData->m_shBORDER1.primitiveMultisample, *PMULTISAMPLE);
 
-    glVertexAttribPointer(m_shBORDER1.posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
-    glVertexAttribPointer(m_shBORDER1.texAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
+    glVertexAttribPointer(m_RenderData.pCurrentMonData->m_shBORDER1.posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
+    glVertexAttribPointer(m_RenderData.pCurrentMonData->m_shBORDER1.texAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
 
-    glEnableVertexAttribArray(m_shBORDER1.posAttrib);
-    glEnableVertexAttribArray(m_shBORDER1.texAttrib);
+    glEnableVertexAttribArray(m_RenderData.pCurrentMonData->m_shBORDER1.posAttrib);
+    glEnableVertexAttribArray(m_RenderData.pCurrentMonData->m_shBORDER1.texAttrib);
 
     if (pixman_region32_not_empty(m_RenderData.pDamage)) {
         PIXMAN_DAMAGE_FOREACH(m_RenderData.pDamage) {
@@ -682,8 +817,8 @@ void CHyprOpenGLImpl::renderBorder(wlr_box* box, const CColor& col, int round) {
         }
     }
 
-    glDisableVertexAttribArray(m_shBORDER1.posAttrib);
-    glDisableVertexAttribArray(m_shBORDER1.texAttrib);
+    glDisableVertexAttribArray(m_RenderData.pCurrentMonData->m_shBORDER1.posAttrib);
+    glDisableVertexAttribArray(m_RenderData.pCurrentMonData->m_shBORDER1.texAttrib);
 
     glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 }
@@ -698,12 +833,10 @@ void CHyprOpenGLImpl::makeWindowSnapshot(CWindow* pWindow) {
     // this is temporary, doesnt mess with the actual wlr damage
     pixman_region32_t fakeDamage;
     pixman_region32_init(&fakeDamage);
-    pixman_region32_union_rect(&fakeDamage, &fakeDamage, 0, 0, (int)PMONITOR->vecPixelSize.x, (int)PMONITOR->vecPixelSize.y);
+    pixman_region32_union_rect(&fakeDamage, &fakeDamage, 0, 0, (int)PMONITOR->vecTransformedSize.x, (int)PMONITOR->vecTransformedSize.y);
 
     begin(PMONITOR, &fakeDamage, true);
 
-    pixman_region32_fini(&fakeDamage);
-
     clear(CColor(0,0,0,0)); // JIC
 
     timespec now;
@@ -717,7 +850,9 @@ void CHyprOpenGLImpl::makeWindowSnapshot(CWindow* pWindow) {
     const auto BLURVAL = g_pConfigManager->getInt("decoration:blur");
     g_pConfigManager->setInt("decoration:blur", 0);
 
-    g_pHyprRenderer->renderWindow(pWindow, PMONITOR, &now, !pWindow->m_bX11DoesntWantBorders);
+    g_pHyprRenderer->renderWindow(pWindow, PMONITOR, &now, !pWindow->m_bX11DoesntWantBorders, RENDER_PASS_ALL);
+
+    m_bEndFrame = true;
 
     g_pConfigManager->setInt("decoration:blur", BLURVAL);
 
@@ -733,8 +868,10 @@ void CHyprOpenGLImpl::makeWindowSnapshot(CWindow* pWindow) {
 
     clear(CColor(0, 0, 0, 0));  // JIC
 
-    wlr_box fullMonBox = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
+    wlr_box fullMonBox = {0, 0, PMONITOR->vecTransformedSize.x, PMONITOR->vecTransformedSize.y};
+    
     renderTexture(m_RenderData.pCurrentMonData->primaryFB.m_cTex, &fullMonBox, 255.f, 0);
+    m_bEndFrame = false;
 
     // restore original fb
     #ifndef GLES2
@@ -742,9 +879,10 @@ void CHyprOpenGLImpl::makeWindowSnapshot(CWindow* pWindow) {
     #else
     glBindFramebuffer(GL_FRAMEBUFFER, m_iCurrentOutputFb);
     #endif
-
     end();
 
+    pixman_region32_fini(&fakeDamage);
+
     wlr_output_rollback(PMONITOR->output);
 }
 
@@ -762,8 +900,6 @@ void CHyprOpenGLImpl::makeLayerSnapshot(SLayerSurface* pLayer) {
 
     begin(PMONITOR, &fakeDamage, true);
 
-    pixman_region32_fini(&fakeDamage);
-
     const auto PFRAMEBUFFER = &m_mLayerFramebuffers[pLayer];
 
     glViewport(0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->vecPixelSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->vecPixelSize.y);
@@ -780,6 +916,8 @@ void CHyprOpenGLImpl::makeLayerSnapshot(SLayerSurface* pLayer) {
     // draw the layer
     g_pHyprRenderer->renderLayer(pLayer, PMONITOR, &now);
 
+    m_bEndFrame = false;
+
     // TODO: WARN:
     // revise if any stencil-requiring rendering is done to the layers.
 
@@ -792,6 +930,8 @@ void CHyprOpenGLImpl::makeLayerSnapshot(SLayerSurface* pLayer) {
 
     end();
 
+    pixman_region32_fini(&fakeDamage);
+
     wlr_output_rollback(PMONITOR->output);
 }
 
@@ -816,17 +956,24 @@ void CHyprOpenGLImpl::renderSnapshot(CWindow** pWindow) {
     // the originalClosedPos is relative to the monitor's pos
     Vector2D scaleXY = Vector2D((PMONITOR->scale * PWINDOW->m_vRealSize.vec().x / (PWINDOW->m_vOriginalClosedSize.x * PMONITOR->scale)), (PMONITOR->scale * PWINDOW->m_vRealSize.vec().y / (PWINDOW->m_vOriginalClosedSize.y * PMONITOR->scale)));
 
-    windowBox.width = PMONITOR->vecPixelSize.x * scaleXY.x;
-    windowBox.height = PMONITOR->vecPixelSize.y * scaleXY.y;
+    // TODO: this is wrong on scaled.
+
+    windowBox.width = PMONITOR->vecTransformedSize.x * scaleXY.x;
+    windowBox.height = PMONITOR->vecTransformedSize.y * scaleXY.y;
     windowBox.x = ((PWINDOW->m_vRealPosition.vec().x - PMONITOR->vecPosition.x) * PMONITOR->scale) - ((PWINDOW->m_vOriginalClosedPos.x * PMONITOR->scale) * scaleXY.x);
     windowBox.y = ((PWINDOW->m_vRealPosition.vec().y - PMONITOR->vecPosition.y) * PMONITOR->scale) - ((PWINDOW->m_vOriginalClosedPos.y * PMONITOR->scale) * scaleXY.y);
 
     pixman_region32_t fakeDamage;
-    pixman_region32_init_rect(&fakeDamage, 0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
+    pixman_region32_init_rect(&fakeDamage, 0, 0, PMONITOR->vecTransformedSize.x, PMONITOR->vecTransformedSize.y);
 
     renderTextureInternalWithDamage(it->second.m_cTex, &windowBox, PWINDOW->m_fAlpha.fl(), &fakeDamage, 0);
 
     pixman_region32_fini(&fakeDamage);
+
+    static auto *const PDAMAGEMON = &g_pConfigManager->getConfigValuePtr("misc:damage_entire_on_snapshot")->intValue;
+
+    if (*PDAMAGEMON)
+        PMONITOR->forceFullFrames += 1;
 }
 
 void CHyprOpenGLImpl::renderSnapshot(SLayerSurface** pLayer) {
@@ -845,26 +992,31 @@ void CHyprOpenGLImpl::renderSnapshot(SLayerSurface** pLayer) {
 
     const auto PMONITOR = g_pCompositor->getMonitorFromID(PLAYER->monitorID);
 
-    wlr_box windowBox = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y};
+    wlr_box windowBox = {0, 0, PMONITOR->vecTransformedSize.x, PMONITOR->vecTransformedSize.y};
 
     pixman_region32_t fakeDamage;
-    pixman_region32_init_rect(&fakeDamage, 0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
+    pixman_region32_init_rect(&fakeDamage, 0, 0, PMONITOR->vecTransformedSize.x, PMONITOR->vecTransformedSize.y);
 
     renderTextureInternalWithDamage(it->second.m_cTex, &windowBox, PLAYER->alpha.fl(), &fakeDamage, 0);
 
     pixman_region32_fini(&fakeDamage);
+
+    static auto *const PDAMAGEMON = &g_pConfigManager->getConfigValuePtr("misc:damage_entire_on_snapshot")->intValue;
+
+    if (*PDAMAGEMON)
+        PMONITOR->forceFullFrames += 1;
 }
 
 void CHyprOpenGLImpl::renderRoundedShadow(wlr_box* box, int round, int range, float a) {
     RASSERT(m_RenderData.pMonitor, "Tried to render shadow without begin()!");
     RASSERT((box->width > 0 && box->height > 0), "Tried to render shadow with width/height < 0!");
+    RASSERT(m_pCurrentWindow, "Tried to render shadow without a window!");
 
-    static auto *const PSHADOWCOL = &g_pConfigManager->getConfigValuePtr("decoration:col.shadow")->intValue;
     static auto *const PSHADOWPOWER = &g_pConfigManager->getConfigValuePtr("decoration:shadow_render_power")->intValue;
 
     const auto SHADOWPOWER = std::clamp((int)*PSHADOWPOWER, 1, 4);
 
-    const auto col = CColor(*PSHADOWCOL);
+    const auto col = m_pCurrentWindow->m_cRealShadowColor.col();
 
     float matrix[9];
     wlr_matrix_project_box(matrix, box, wlr_output_transform_invert(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform), 0, m_RenderData.pMonitor->output->transform_matrix);  // TODO: write own, don't use WLR here
@@ -878,28 +1030,28 @@ void CHyprOpenGLImpl::renderRoundedShadow(wlr_box* box, int round, int range, fl
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-    glUseProgram(m_shSHADOW.program);
+    glUseProgram(m_RenderData.pCurrentMonData->m_shSHADOW.program);
 
-    glUniformMatrix3fv(m_shSHADOW.proj, 1, GL_FALSE, glMatrix);
-    glUniform4f(m_shSHADOW.getUniformLocation("color"), col.r / 255.f, col.g / 255.f, col.b / 255.f, col.a / 255.f * a);
+    glUniformMatrix3fv(m_RenderData.pCurrentMonData->m_shSHADOW.proj, 1, GL_FALSE, glMatrix);
+    glUniform4f(m_RenderData.pCurrentMonData->m_shSHADOW.color, col.r / 255.f, col.g / 255.f, col.b / 255.f, col.a / 255.f * a);
 
     const auto TOPLEFT = Vector2D(range + round, range + round);
     const auto BOTTOMRIGHT = Vector2D(box->width - (range + round), box->height - (range + round));
     const auto FULLSIZE = Vector2D(box->width, box->height);
 
     // Rounded corners
-    glUniform2f(m_shSHADOW.getUniformLocation("topLeft"), (float)TOPLEFT.x, (float)TOPLEFT.y);
-    glUniform2f(m_shSHADOW.getUniformLocation("bottomRight"), (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
-    glUniform2f(m_shSHADOW.getUniformLocation("fullSize"), (float)FULLSIZE.x, (float)FULLSIZE.y);
-    glUniform1f(m_shSHADOW.getUniformLocation("radius"), range + round);
-    glUniform1f(m_shSHADOW.getUniformLocation("range"), range);
-    glUniform1f(m_shSHADOW.getUniformLocation("shadowPower"), SHADOWPOWER);
+    glUniform2f(m_RenderData.pCurrentMonData->m_shSHADOW.topLeft, (float)TOPLEFT.x, (float)TOPLEFT.y);
+    glUniform2f(m_RenderData.pCurrentMonData->m_shSHADOW.bottomRight, (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
+    glUniform2f(m_RenderData.pCurrentMonData->m_shSHADOW.fullSize, (float)FULLSIZE.x, (float)FULLSIZE.y);
+    glUniform1f(m_RenderData.pCurrentMonData->m_shSHADOW.radius, range + round);
+    glUniform1f(m_RenderData.pCurrentMonData->m_shSHADOW.range, range);
+    glUniform1f(m_RenderData.pCurrentMonData->m_shSHADOW.shadowPower, SHADOWPOWER);
 
-    glVertexAttribPointer(m_shSHADOW.posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
-    glVertexAttribPointer(m_shSHADOW.texAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
+    glVertexAttribPointer(m_RenderData.pCurrentMonData->m_shSHADOW.posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
+    glVertexAttribPointer(m_RenderData.pCurrentMonData->m_shSHADOW.texAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
 
-    glEnableVertexAttribArray(m_shSHADOW.posAttrib);
-    glEnableVertexAttribArray(m_shSHADOW.texAttrib);
+    glEnableVertexAttribArray(m_RenderData.pCurrentMonData->m_shSHADOW.posAttrib);
+    glEnableVertexAttribArray(m_RenderData.pCurrentMonData->m_shSHADOW.texAttrib);
 
     if (pixman_region32_not_empty(m_RenderData.pDamage)) {
         PIXMAN_DAMAGE_FOREACH(m_RenderData.pDamage) {
@@ -909,15 +1061,34 @@ void CHyprOpenGLImpl::renderRoundedShadow(wlr_box* box, int round, int range, fl
         }
     }
 
-    glDisableVertexAttribArray(m_shSHADOW.posAttrib);
-    glDisableVertexAttribArray(m_shSHADOW.texAttrib);
+    glDisableVertexAttribArray(m_RenderData.pCurrentMonData->m_shSHADOW.posAttrib);
+    glDisableVertexAttribArray(m_RenderData.pCurrentMonData->m_shSHADOW.texAttrib);
 
     glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 }
 
-void CHyprOpenGLImpl::createBGTextureForMonitor(SMonitor* pMonitor) {
+void CHyprOpenGLImpl::renderSplash(cairo_t *const CAIRO, cairo_surface_t *const CAIROSURFACE) {
+    cairo_select_font_face(CAIRO, "Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+
+    const auto FONTSIZE = (int)(m_RenderData.pMonitor->vecPixelSize.y / 76); 
+    cairo_set_font_size(CAIRO, FONTSIZE);
+
+    cairo_set_source_rgba(CAIRO, 1.f, 1.f, 1.f, 0.32f);
+
+    cairo_text_extents_t textExtents;
+    cairo_text_extents(CAIRO, g_pCompositor->m_szCurrentSplash.c_str(), &textExtents);
+
+    cairo_move_to(CAIRO, m_RenderData.pMonitor->vecTransformedSize.x / 2.f - textExtents.width / 2.f, m_RenderData.pMonitor->vecTransformedSize.y - textExtents.height - 1);
+    cairo_show_text(CAIRO, g_pCompositor->m_szCurrentSplash.c_str());
+
+    cairo_surface_flush(CAIROSURFACE);
+}
+
+void CHyprOpenGLImpl::createBGTextureForMonitor(CMonitor* pMonitor) {
     RASSERT(m_RenderData.pMonitor, "Tried to createBGTex without begin()!");
 
+    static auto *const PNOSPLASH = &g_pConfigManager->getConfigValuePtr("misc:disable_splash_rendering")->intValue;
+
     // release the last tex if exists
     const auto PTEX = &m_mMonitorBGTextures[pMonitor];
     PTEX->destroyTexture();
@@ -926,6 +1097,9 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(SMonitor* pMonitor) {
 
     Debug::log(LOG, "Allocated texture for BGTex");
 
+    // TODO: use relative paths to the installation
+    // or configure the paths at build time
+
     // check if wallpapers exist
     if (!std::filesystem::exists("/usr/share/hyprland/wall_8K.png"))
         return; // the texture will be empty, oh well. We'll clear with a solid color anyways.
@@ -933,10 +1107,10 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(SMonitor* pMonitor) {
     // get the adequate tex
     std::string texPath = "/usr/share/hyprland/wall_";
     Vector2D textureSize;
-    if (pMonitor->vecTransformedSize.x > 7000) {
+    if (pMonitor->vecTransformedSize.x > 3850) {
         textureSize = Vector2D(7680, 4320);
         texPath += "8K.png";
-    } else if (pMonitor->vecTransformedSize.x > 3000) {
+    } else if (pMonitor->vecTransformedSize.x > 1930) {
         textureSize = Vector2D(3840, 2160);
         texPath += "4K.png";
     } else {
@@ -944,16 +1118,21 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(SMonitor* pMonitor) {
         texPath += "2K.png";
     }
 
+    PTEX->m_vSize = textureSize;
+
     // create a new one with cairo
     const auto CAIROSURFACE = cairo_image_surface_create_from_png(texPath.c_str());
 
     const auto CAIRO = cairo_create(CAIROSURFACE);
 
+    if (!*PNOSPLASH)
+        renderSplash(CAIRO, CAIROSURFACE);
+
     // copy the data to an OpenGL texture we have
     const auto DATA = cairo_image_surface_get_data(CAIROSURFACE);
     glBindTexture(GL_TEXTURE_2D, PTEX->m_iTexID);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     #ifndef GLES2
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
@@ -963,18 +1142,42 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(SMonitor* pMonitor) {
     cairo_surface_destroy(CAIROSURFACE);
     cairo_destroy(CAIRO);
 
+    // calc the target box
+
+    const float MONRATIO = m_RenderData.pMonitor->vecTransformedSize.x / m_RenderData.pMonitor->vecTransformedSize.y;
+    const float WPRATIO = 1.77f;
+
+    Vector2D origin;
+    float scale;
+
+    if (MONRATIO > WPRATIO) {
+        scale = m_RenderData.pMonitor->vecTransformedSize.x / PTEX->m_vSize.x;
+
+        origin.y = -(PTEX->m_vSize.y * scale - m_RenderData.pMonitor->vecTransformedSize.y) / 2.f / scale;
+    } else {
+        scale = m_RenderData.pMonitor->vecTransformedSize.y / PTEX->m_vSize.y;
+
+        origin.x = -(PTEX->m_vSize.x * scale - m_RenderData.pMonitor->vecTransformedSize.x) / 2.f / scale;
+    }
+
+    wlr_box box = {origin.x * scale, origin.y * scale, PTEX->m_vSize.x * scale, PTEX->m_vSize.y * scale};
+
+    m_mMonitorRenderResources[pMonitor].backgroundTexBox = box;
+
     Debug::log(LOG, "Background created for monitor %s", pMonitor->szName.c_str());
 }
 
 void CHyprOpenGLImpl::clearWithTex() {
     RASSERT(m_RenderData.pMonitor, "Tried to render BGtex without begin()!");
 
-    wlr_box box = {0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y};
+    static auto *const PRENDERTEX = &g_pConfigManager->getConfigValuePtr("misc:disable_hyprland_logo")->intValue;
 
-    renderTexture(m_mMonitorBGTextures[m_RenderData.pMonitor], &box, 255, 0);
+    if (!*PRENDERTEX) {
+        renderTexture(m_mMonitorBGTextures[m_RenderData.pMonitor], &m_mMonitorRenderResources[m_RenderData.pMonitor].backgroundTexBox, 255, 0);
+    }
 }
 
-void CHyprOpenGLImpl::destroyMonitorResources(SMonitor* pMonitor) {
+void CHyprOpenGLImpl::destroyMonitorResources(CMonitor* pMonitor) {
     g_pHyprOpenGL->m_mMonitorRenderResources[pMonitor].mirrorFB.release();
     g_pHyprOpenGL->m_mMonitorRenderResources[pMonitor].primaryFB.release();
     g_pHyprOpenGL->m_mMonitorRenderResources[pMonitor].stencilTex.destroyTexture();

src/render/OpenGL.hpp

@@ -6,6 +6,8 @@
 #include <list>
 #include <unordered_map>
 
+#include <cairo/cairo.h>
+
 #include "Shaders.hpp"
 #include "Shader.hpp"
 #include "Texture.hpp"
@@ -35,10 +37,27 @@ struct SMonitorRenderData {
     CFramebuffer mirrorSwapFB;
 
     CTexture     stencilTex;
+
+    CFramebuffer blurFB;
+    bool         blurFBDirty = true;
+
+    wlr_box      backgroundTexBox;
+
+    // Shaders
+    bool                    m_bShadersInitialized = false;
+    CShader                 m_shQUAD;
+    CShader                 m_shRGBA;
+    CShader                 m_shRGBX;
+    CShader                 m_shEXT;
+    CShader                 m_shBLUR1;
+    CShader                 m_shBLUR2;
+    CShader                 m_shSHADOW;
+    CShader                 m_shBORDER1;
+    //
 };
 
 struct SCurrentRenderData {
-    SMonitor*   pMonitor = nullptr;
+    CMonitor*   pMonitor = nullptr;
     float       projection[9];
 
     SMonitorRenderData* pCurrentMonData = nullptr;
@@ -54,7 +73,7 @@ public:
 
     CHyprOpenGLImpl();
 
-    void    begin(SMonitor*, pixman_region32_t*, bool fake = false);
+    void    begin(CMonitor*, pixman_region32_t*, bool fake = false);
     void    end();
 
     void    renderRect(wlr_box*, const CColor&, int round = 0);
@@ -76,7 +95,12 @@ public:
     void    scissor(const pixman_box32*);
     void    scissor(const int x, const int y, const int w, const int h);
 
-    void    destroyMonitorResources(SMonitor*);
+    void    destroyMonitorResources(CMonitor*);
+
+    void    markBlurDirtyForMonitor(CMonitor*);
+
+    void    preWindowPass();
+    void    preRender(CMonitor*);
 
     SCurrentRenderData m_RenderData;
 
@@ -89,8 +113,8 @@ public:
 
     std::unordered_map<CWindow*, CFramebuffer> m_mWindowFramebuffers;
     std::unordered_map<SLayerSurface*, CFramebuffer> m_mLayerFramebuffers;
-    std::unordered_map<SMonitor*, SMonitorRenderData> m_mMonitorRenderResources;
-    std::unordered_map<SMonitor*, CTexture> m_mMonitorBGTextures;
+    std::unordered_map<CMonitor*, SMonitorRenderData> m_mMonitorRenderResources;
+    std::unordered_map<CMonitor*, CTexture> m_mMonitorBGTextures;
 
 private:
     std::list<GLuint>       m_lBuffers;
@@ -102,25 +126,19 @@ private:
     bool                    m_bFakeFrame = false;
     bool                    m_bEndFrame = false;
 
-    // Shaders
-    CShader                 m_shQUAD;
-    CShader                 m_shRGBA;
-    CShader                 m_shRGBX;
-    CShader                 m_shEXT;
-    CShader                 m_shBLUR1;
-    CShader                 m_shBLUR2;
-    CShader                 m_shSHADOW;
-    CShader                 m_shBORDER1;
-    //
-
     GLuint                  createProgram(const std::string&, const std::string&);
     GLuint                  compileShader(const GLuint&, std::string);
-    void                    createBGTextureForMonitor(SMonitor*);
+    void                    createBGTextureForMonitor(CMonitor*);
+    void                    initShaders();
 
     // 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 noAA = false, bool allowCustomUV = false);
+
+    void                    renderSplash(cairo_t *const, cairo_surface_t *const);
+
+    void                    preBlurForCurrentMonitor();
 };
 
 inline std::unique_ptr<CHyprOpenGLImpl> g_pHyprOpenGL;

src/render/Renderer.cpp

@@ -16,19 +16,34 @@ void renderSurface(struct wlr_surface* surface, int x, int y, void* data) {
         windowBox = {(int)outputX + RDATA->x + x, (int)outputY + RDATA->y + y, RDATA->w, RDATA->h};
     else                                                                                              //  here we clamp to 2, these might be some tiny specks
         windowBox = {(int)outputX + RDATA->x + x, (int)outputY + RDATA->y + y, std::clamp(surface->current.width, 2, 1337420), std::clamp(surface->current.height, 2, 1337420)};
+    
+    // squish all oversized but dont in some cases, jesus christ this is a mess
+    // TODO: this shouldn't be done this way. Custom UV here as well.
+    // this is fucking horrible
+    // Issue: will cause oversized apps with reserved area to overflow from the window box. (see chromium on ozone wayland)
+    const auto PRESQUISHSIZE = Vector2D(windowBox.width, windowBox.height);
+    if (RDATA->squishOversized) {
+        if (x + windowBox.width > RDATA->w)
+            windowBox.width = RDATA->w - x;
+        if (y + windowBox.height > RDATA->h)
+            windowBox.height = RDATA->h - y;
+    }
+    
     scaleBox(&windowBox, RDATA->output->scale);
 
     static auto *const PROUNDING = &g_pConfigManager->getConfigValuePtr("decoration:rounding")->intValue;
 
     float rounding = RDATA->dontRound ? 0 : RDATA->rounding == -1 ? *PROUNDING : RDATA->rounding;
+    rounding *= RDATA->output->scale;
 
     if (RDATA->surface && surface == RDATA->surface) {
-        g_pHyprOpenGL->renderTextureWithBlur(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, surface, rounding);
-
-        if (RDATA->decorate) {
-            auto col = g_pHyprOpenGL->m_pCurrentWindow->m_cRealBorderColor.col();
-            col.a *= RDATA->fadeAlpha * RDATA->alpha / 255.f;
-            g_pHyprOpenGL->renderBorder(&windowBox, col, rounding);
+        if (wlr_surface_is_xwayland_surface(surface) && !wlr_xwayland_surface_from_wlr_surface(surface)->has_alpha && RDATA->fadeAlpha * RDATA->alpha == 255.f) {
+            g_pHyprOpenGL->renderTexture(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, rounding, true);
+        } else {
+            if (RDATA->blur)
+                g_pHyprOpenGL->renderTextureWithBlur(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, surface, rounding);
+            else
+                g_pHyprOpenGL->renderTexture(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, rounding, true);
         }
     }
     else {
@@ -36,33 +51,50 @@ void renderSurface(struct wlr_surface* surface, int x, int y, void* data) {
             wlr_box geo;
             wlr_xdg_surface_get_geometry(wlr_xdg_surface_from_wlr_surface(RDATA->surface), &geo);
 
+            // TODO: continuation of the above madness.
+            if (geo.x != 0 || geo.y != 0) {
+                windowBox.width = PRESQUISHSIZE.x;
+                windowBox.height = PRESQUISHSIZE.y;
+            }
+
             windowBox.x -= geo.x;
             windowBox.y -= geo.y;
         }
 
         g_pHyprOpenGL->renderTexture(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, rounding, false);
     }
-        
 
     wlr_surface_send_frame_done(surface, RDATA->when);
 
     wlr_presentation_surface_sampled_on_output(g_pCompositor->m_sWLRPresentation, surface, RDATA->output);
 }
 
-bool CHyprRenderer::shouldRenderWindow(CWindow* pWindow, SMonitor* pMonitor) {
+bool CHyprRenderer::shouldRenderWindow(CWindow* pWindow, CMonitor* pMonitor) {
     wlr_box geometry = pWindow->getFullWindowBoundingBox();
 
     if (!wlr_output_layout_intersects(g_pCompositor->m_sWLROutputLayout, pMonitor->output, &geometry))
         return false;
 
     // now check if it has the same workspace
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(pWindow->m_iWorkspaceID);
+
+    if (PWORKSPACE && PWORKSPACE->m_iMonitorID == pMonitor->ID) {
+        if (PWORKSPACE->m_vRenderOffset.isBeingAnimated() || PWORKSPACE->m_fAlpha.isBeingAnimated()) {
+            return true;
+        } else {
+            if (!(!PWORKSPACE->m_bHasFullscreenWindow || pWindow->m_bIsFullscreen || (pWindow->m_bIsFloating && pWindow->m_bCreatedOverFullscreen)))
+                return false;
+        }
+    }
+
     if (pWindow->m_iWorkspaceID == pMonitor->activeWorkspace)
         return true;
 
-    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(pWindow->m_iWorkspaceID);
-    // if not, check if it maybe is active on a different monitor.                    vvv might be animation in progress
-    if (g_pCompositor->isWorkspaceVisible(pWindow->m_iWorkspaceID) || (PWORKSPACE && PWORKSPACE->m_iMonitorID == pMonitor->ID && (PWORKSPACE->m_vRenderOffset.isBeingAnimated() || PWORKSPACE->m_fAlpha.isBeingAnimated())))
-        return true;
+    // if not, check if it maybe is active on a different monitor.
+    if (g_pCompositor->isWorkspaceVisible(pWindow->m_iWorkspaceID) ||
+        (PWORKSPACE && PWORKSPACE->m_iMonitorID == pMonitor->ID && PWORKSPACE->m_bForceRendering) || // vvvv might be in animation progress vvvvv
+        (PWORKSPACE && PWORKSPACE->m_iMonitorID == pMonitor->ID && (PWORKSPACE->m_vRenderOffset.isBeingAnimated() || PWORKSPACE->m_fAlpha.isBeingAnimated())))
+        return !pWindow->m_bIsFullscreen; // Do not draw fullscreen windows on other monitors
 
     if (pMonitor->specialWorkspaceOpen && pWindow->m_iWorkspaceID == SPECIAL_WORKSPACE_ID)
         return true;
@@ -91,15 +123,24 @@ bool CHyprRenderer::shouldRenderWindow(CWindow* pWindow) {
     return false;
 }
 
-void CHyprRenderer::renderWorkspaceWithFullscreenWindow(SMonitor* pMonitor, CWorkspace* pWorkspace, timespec* time) {
+void CHyprRenderer::renderWorkspaceWithFullscreenWindow(CMonitor* pMonitor, CWorkspace* pWorkspace, timespec* time) {
     CWindow* pWorkspaceWindow = nullptr;
 
     for (auto& w : g_pCompositor->m_vWindows) {
-        if (w->m_iWorkspaceID != pWorkspace->m_iID || !w->m_bIsFullscreen)
+        const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID);
+
+        if (w->m_iWorkspaceID != pWorkspace->m_iID || !w->m_bIsFullscreen){
+            if (!(PWORKSPACE && (PWORKSPACE->m_vRenderOffset.isBeingAnimated() || PWORKSPACE->m_fAlpha.isBeingAnimated())))
+                continue;
+
+            if (w->m_iMonitorID != pMonitor->ID)
+                continue;
+        }
+
+        if (w->m_iWorkspaceID == pMonitor->activeWorkspace && !w->m_bIsFullscreen)
             continue;
 
-        // found it!
-        renderWindow(w.get(), pMonitor, time, pWorkspace->m_efFullscreenMode != FULLSCREEN_FULL);
+        renderWindow(w.get(), pMonitor, time, pWorkspace->m_efFullscreenMode != FULLSCREEN_FULL, RENDER_PASS_ALL);
 
         pWorkspaceWindow = w.get();
     }
@@ -109,7 +150,7 @@ void CHyprRenderer::renderWorkspaceWithFullscreenWindow(SMonitor* pMonitor, CWor
         if (w->m_iWorkspaceID != pWorkspaceWindow->m_iWorkspaceID || !w->m_bCreatedOverFullscreen || !w->m_bIsMapped)
             continue;
 
-        renderWindow(w.get(), pMonitor, time, true);
+        renderWindow(w.get(), pMonitor, time, true, RENDER_PASS_ALL);
     }
 
     // and then special windows
@@ -124,19 +165,19 @@ void CHyprRenderer::renderWorkspaceWithFullscreenWindow(SMonitor* pMonitor, CWor
             continue;
 
         // render the bad boy
-        renderWindow(w.get(), pMonitor, time, true);
+        renderWindow(w.get(), pMonitor, time, true, RENDER_PASS_ALL);
     }
 
     // and the overlay layers
     if (pWorkspace->m_efFullscreenMode != FULLSCREEN_FULL) {
         // on non-full we draw the bar and shit
         for (auto& ls : pMonitor->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
-            renderLayer(ls, pMonitor, time);
+            renderLayer(ls.get(), pMonitor, time);
         }
     }
 
     for (auto& ls : pMonitor->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]) {
-        renderLayer(ls, pMonitor, time);
+        renderLayer(ls.get(), pMonitor, time);
     }
 
     renderDragIcon(pMonitor, time);
@@ -146,7 +187,7 @@ void CHyprRenderer::renderWorkspaceWithFullscreenWindow(SMonitor* pMonitor, CWor
         g_pHyprError->draw();
 }
 
-void CHyprRenderer::renderWindow(CWindow* pWindow, SMonitor* pMonitor, timespec* time, bool decorate) {
+void CHyprRenderer::renderWindow(CWindow* pWindow, CMonitor* pMonitor, timespec* time, bool decorate, eRenderPassMode mode) {
     if (pWindow->m_bHidden)
         return;
 
@@ -164,11 +205,12 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, SMonitor* pMonitor, timespec*
     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,
     renderdata.h = std::clamp(pWindow->m_vRealSize.vec().y, (double)5, (double)1337420); // otherwise we'll have issues later with invalid boxes
-    renderdata.dontRound = pWindow->m_bIsFullscreen && PWORKSPACE->m_efFullscreenMode == FULLSCREEN_FULL;
+    renderdata.dontRound = (pWindow->m_bIsFullscreen && PWORKSPACE->m_efFullscreenMode == FULLSCREEN_FULL) || (!pWindow->m_sSpecialRenderData.rounding);
     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.alpha = pWindow->m_fActiveInactiveAlpha.fl();
     renderdata.decorate = decorate && !pWindow->m_bX11DoesntWantBorders && (pWindow->m_bIsFloating ? *PNOFLOATINGBORDERS == 0 : true) && (!pWindow->m_bIsFullscreen || PWORKSPACE->m_efFullscreenMode != FULLSCREEN_FULL);
     renderdata.rounding = pWindow->m_sAdditionalConfigData.rounding;
+    renderdata.blur = true; // if it shouldn't, it will be ignored later
 
     // apply window special data
     if (pWindow->m_sSpecialRenderData.alphaInactive == -1)
@@ -176,44 +218,85 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, SMonitor* pMonitor, timespec*
     else
         renderdata.alpha *= pWindow == g_pCompositor->m_pLastWindow ? pWindow->m_sSpecialRenderData.alpha : pWindow->m_sSpecialRenderData.alphaInactive;
 
+    // apply opaque
+    if (pWindow->m_sAdditionalConfigData.forceOpaque)
+        renderdata.alpha = 1.f;
+
     g_pHyprOpenGL->m_pCurrentWindow = pWindow;
 
     // render window decorations first, if not fullscreen full
-    if (!pWindow->m_bIsFullscreen || PWORKSPACE->m_efFullscreenMode != FULLSCREEN_FULL) for (auto& wd : pWindow->m_dWindowDecorations)
-        wd->draw(pMonitor, renderdata.alpha * renderdata.fadeAlpha / 255.f);
 
-    if (!pWindow->m_bIsX11) {
-        wlr_box geom;
-        wlr_xdg_surface_get_geometry(pWindow->m_uSurface.xdg, &geom);
+    if (mode == RENDER_PASS_ALL || mode == RENDER_PASS_MAIN) {
+        if (!pWindow->m_bIsFullscreen || PWORKSPACE->m_efFullscreenMode != FULLSCREEN_FULL) for (auto& wd : pWindow->m_dWindowDecorations)
+                wd->draw(pMonitor, renderdata.alpha * renderdata.fadeAlpha / 255.f);
 
-        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
+        if (!pWindow->m_bIsX11) {
+            wlr_box geom;
+            wlr_xdg_surface_get_geometry(pWindow->m_uSurface.xdg, &geom);
+
+            // first, check for poorly sized windows.
+
+            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);
+            }
+
+            // then, if the surface is too big, modify the pos UV
+            if (geom.width > renderdata.w + 1 || geom.height > renderdata.h + 1) {
+                const auto OFF = Vector2D(renderdata.w / (double)geom.width, renderdata.h / (double)geom.height);
+
+                if (g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft == Vector2D(-1, -1))
+                    g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = Vector2D(0, 0);
+
+                g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = Vector2D(
+                    g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight.x * ((double)renderdata.w / ((double)geom.width / g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight.x)),
+                    g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight.y * ((double)renderdata.h / ((double)geom.height / g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight.y))
+                );
+            }
+        } else {
             g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
             g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
         }
-    } else {
+
+        wlr_surface_for_each_surface(g_pXWaylandManager->getWindowSurface(pWindow), renderSurface, &renderdata);
+
+        if (renderdata.decorate && pWindow->m_sSpecialRenderData.border) {
+            static auto *const PROUNDING = &g_pConfigManager->getConfigValuePtr("decoration:rounding")->intValue;
+
+            float rounding = renderdata.dontRound ? 0 : renderdata.rounding == -1 ? *PROUNDING : renderdata.rounding;
+            rounding *= pMonitor->scale;
+
+            auto col = g_pHyprOpenGL->m_pCurrentWindow->m_cRealBorderColor.col();
+            col.a *= renderdata.fadeAlpha * renderdata.alpha / 255.f;
+
+            wlr_box windowBox = {renderdata.x - pMonitor->vecPosition.x, renderdata.y - pMonitor->vecPosition.y, renderdata.w, renderdata.h};
+
+            scaleBox(&windowBox, pMonitor->scale);
+
+            g_pHyprOpenGL->renderBorder(&windowBox, col, rounding);
+        }
+
         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) {
-        renderdata.dontRound = false; // restore dontround
-        renderdata.pMonitor = pMonitor;
-        wlr_xdg_surface_for_each_popup_surface(pWindow->m_uSurface.xdg, renderSurface, &renderdata);
+    if (mode == RENDER_PASS_ALL || mode == RENDER_PASS_POPUP) {
+        if (!pWindow->m_bIsX11) {
+            renderdata.dontRound = false;  // restore dontround
+            renderdata.pMonitor = pMonitor;
+            renderdata.squishOversized = false; // don't squish popups
+            wlr_xdg_surface_for_each_popup_surface(pWindow->m_uSurface.xdg, renderSurface, &renderdata);
+        }
     }
 
     g_pHyprOpenGL->m_pCurrentWindow = nullptr;
 }
 
-void CHyprRenderer::renderLayer(SLayerSurface* pLayer, SMonitor* pMonitor, timespec* time) {
+void CHyprRenderer::renderLayer(SLayerSurface* pLayer, CMonitor* pMonitor, timespec* time) {
     if (pLayer->fadingOut) {
         g_pHyprOpenGL->renderSnapshot(&pLayer);
         return;
@@ -221,7 +304,27 @@ void CHyprRenderer::renderLayer(SLayerSurface* pLayer, SMonitor* pMonitor, times
 
     SRenderData renderdata = {pMonitor->output, time, pLayer->geometry.x, pLayer->geometry.y};
     renderdata.fadeAlpha = pLayer->alpha.fl();
+    renderdata.blur = pLayer->forceBlur;
+    renderdata.surface = pLayer->layerSurface->surface;
+    renderdata.decorate = false;
+    renderdata.w = pLayer->layerSurface->surface->current.width;
+    renderdata.h = pLayer->layerSurface->surface->current.height;
     wlr_surface_for_each_surface(pLayer->layerSurface->surface, renderSurface, &renderdata);
+
+    renderdata.squishOversized = false;  // don't squish popups
+    wlr_layer_surface_v1_for_each_popup_surface(pLayer->layerSurface, renderSurface, &renderdata);
+}
+
+void CHyprRenderer::renderIMEPopup(SIMEPopup* pPopup, CMonitor* pMonitor, timespec* time) {
+    SRenderData renderdata = {pMonitor->output, time, pPopup->realX, pPopup->realY};
+
+    renderdata.blur = false;
+    renderdata.surface = pPopup->pSurface->surface;
+    renderdata.decorate = false;
+    renderdata.w = pPopup->pSurface->surface->current.width;
+    renderdata.h = pPopup->pSurface->surface->current.height;
+
+    wlr_surface_for_each_surface(pPopup->pSurface->surface, renderSurface, &renderdata);
 }
 
 void CHyprRenderer::renderAllClientsForMonitor(const int& ID, timespec* time) {
@@ -232,12 +335,15 @@ void CHyprRenderer::renderAllClientsForMonitor(const int& ID, timespec* time) {
 
     // Render layer surfaces below windows for monitor
     for (auto& ls : PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND]) {
-        renderLayer(ls, PMONITOR, time);
+        renderLayer(ls.get(), PMONITOR, time);
     }
     for (auto& ls : PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM]) {
-        renderLayer(ls, PMONITOR, time);
+        renderLayer(ls.get(), PMONITOR, time);
     }
 
+    // pre window pass
+    g_pHyprOpenGL->preWindowPass();
+
     // if there is a fullscreen window, render it and then do not render anymore.
     // fullscreen window will hide other windows and top layers
     const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
@@ -247,7 +353,25 @@ void CHyprRenderer::renderAllClientsForMonitor(const int& ID, timespec* time) {
         return;
     }
 
-    // Non-floating
+    // Non-floating main
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (w->m_bHidden && !w->m_bIsMapped && !w->m_bFadingOut)
+            continue;
+
+        if (w->m_bIsFloating)
+            continue;  // floating are in the second pass
+
+        if (w->m_iWorkspaceID == SPECIAL_WORKSPACE_ID)
+            continue;  // special are in the third pass
+
+        if (!shouldRenderWindow(w.get(), PMONITOR))
+            continue;
+
+        // render the bad boy
+        renderWindow(w.get(), PMONITOR, time, true, RENDER_PASS_MAIN);
+    }
+
+    // Non-floating popup
     for (auto& w : g_pCompositor->m_vWindows) {
         if (w->m_bHidden && !w->m_bIsMapped && !w->m_bFadingOut)
             continue;
@@ -262,7 +386,7 @@ void CHyprRenderer::renderAllClientsForMonitor(const int& ID, timespec* time) {
             continue;
 
         // render the bad boy
-        renderWindow(w.get(), PMONITOR, time, true);
+        renderWindow(w.get(), PMONITOR, time, true, RENDER_PASS_POPUP);
     }
 
     // floating on top
@@ -280,7 +404,7 @@ void CHyprRenderer::renderAllClientsForMonitor(const int& ID, timespec* time) {
             continue;
 
         // render the bad boy
-        renderWindow(w.get(), PMONITOR, time, true);
+        renderWindow(w.get(), PMONITOR, time, true, RENDER_PASS_ALL);
     }
 
     // and then special
@@ -295,15 +419,21 @@ void CHyprRenderer::renderAllClientsForMonitor(const int& ID, timespec* time) {
             continue;
 
         // render the bad boy
-        renderWindow(w.get(), PMONITOR, time, true);
+        renderWindow(w.get(), PMONITOR, time, true, RENDER_PASS_ALL);
     }
 
     // Render surfaces above windows for monitor
     for (auto& ls : PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
-        renderLayer(ls, PMONITOR, time);
+        renderLayer(ls.get(), PMONITOR, time);
     }
+
+    // Render IME popups
+    for (auto& imep : g_pInputManager->m_sIMERelay.m_lIMEPopups) {
+        renderIMEPopup(&imep, PMONITOR, time);
+    }
+
     for (auto& ls : PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]) {
-        renderLayer(ls, PMONITOR, time);
+        renderLayer(ls.get(), PMONITOR, time);
     }
 
     renderDragIcon(PMONITOR, time);
@@ -428,11 +558,11 @@ void apply_exclusive(struct wlr_box* usable_area, uint32_t anchor, int32_t exclu
     }
 }
 
-void CHyprRenderer::arrangeLayerArray(SMonitor* pMonitor, const std::list<SLayerSurface*>& layerSurfaces, bool exclusiveZone, wlr_box* usableArea) {
+void CHyprRenderer::arrangeLayerArray(CMonitor* pMonitor, const std::vector<std::unique_ptr<SLayerSurface>>& layerSurfaces, bool exclusiveZone, wlr_box* usableArea) {
     wlr_box full_area = {pMonitor->vecPosition.x, pMonitor->vecPosition.y, pMonitor->vecSize.x, pMonitor->vecSize.y};
 
     for (auto& ls : layerSurfaces) {
-        if (ls->fadingOut || ls->readyToDelete || !ls->layerSurface)
+        if (ls->fadingOut || ls->readyToDelete || !ls->layerSurface || ls->noProcess)
             continue;
 
         const auto PLAYER = ls->layerSurface;
@@ -501,7 +631,7 @@ void CHyprRenderer::arrangeLayerArray(SMonitor* pMonitor, const std::list<SLayer
             box.y -= PSTATE->margin.bottom;
         }
         if (box.width <= 0 || box.height <= 0) {
-            Debug::log(ERR, "LayerSurface %x has a negative/zero w/h???", ls);
+            Debug::log(ERR, "LayerSurface %x has a negative/zero w/h???", ls.get());
             continue;
         }
         // Apply
@@ -551,13 +681,16 @@ void CHyprRenderer::damageSurface(wlr_surface* pSurface, double x, double y) {
     if (!pSurface)
         return; // wut?
 
+    if (g_pCompositor->m_bUnsafeState)
+        return;
+
     pixman_region32_t damageBox;
     pixman_region32_init(&damageBox);
     wlr_surface_get_effective_damage(pSurface, &damageBox);
 
     // schedule frame events
     if (!wl_list_empty(&pSurface->current.frame_callback_list)) {
-        wlr_output_schedule_frame(g_pCompositor->getMonitorFromVector(Vector2D(x, y))->output);
+        g_pCompositor->scheduleFrameForMonitor(g_pCompositor->getMonitorFromVector(Vector2D(x, y)));
     }
 
     if (!pixman_region32_not_empty(&damageBox)) {
@@ -565,26 +698,35 @@ void CHyprRenderer::damageSurface(wlr_surface* pSurface, double x, double y) {
         return;
     }
 
-    pixman_region32_translate(&damageBox, x, y);
+    pixman_region32_t damageBoxForEach;
+    pixman_region32_init(&damageBoxForEach);
 
     for (auto& m : g_pCompositor->m_vMonitors) {
         double lx = 0, ly = 0;
         wlr_output_layout_output_coords(g_pCompositor->m_sWLROutputLayout, m->output, &lx, &ly);
-        pixman_region32_translate(&damageBox, lx, ly);
-        wlr_region_scale(&damageBox, &damageBox, m->scale);
-        wlr_output_damage_add(m->damage, &damageBox);
-        pixman_region32_translate(&damageBox, -lx, -ly);
+
+        pixman_region32_copy(&damageBoxForEach, &damageBox);
+        pixman_region32_translate(&damageBoxForEach, x - m->vecPosition.x, y - m->vecPosition.y);
+        wlr_region_scale(&damageBoxForEach, &damageBoxForEach, m->scale);
+        pixman_region32_translate(&damageBoxForEach, lx + m->vecPosition.x, ly + m->vecPosition.y);
+
+        wlr_output_damage_add(m->damage, &damageBoxForEach);
     }
 
-    pixman_region32_fini(&damageBox);
+    pixman_region32_fini(&damageBoxForEach);
 
     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);
+
+    pixman_region32_fini(&damageBox);
 }
 
 void CHyprRenderer::damageWindow(CWindow* pWindow) {
+    if (g_pCompositor->m_bUnsafeState)
+        return;
+
     wlr_box damageBox = pWindow->getFullWindowBoundingBox();
     for (auto& m : g_pCompositor->m_vMonitors) {
         wlr_box fixedDamageBox = {damageBox.x - m->vecPosition.x, damageBox.y - m->vecPosition.y, damageBox.width, damageBox.height};
@@ -598,7 +740,10 @@ void CHyprRenderer::damageWindow(CWindow* pWindow) {
         Debug::log(LOG, "Damage: Window (%s): xy: %d, %d wh: %d, %d", pWindow->m_szTitle.c_str(), damageBox.x, damageBox.y, damageBox.width, damageBox.height);
 }
 
-void CHyprRenderer::damageMonitor(SMonitor* pMonitor) {
+void CHyprRenderer::damageMonitor(CMonitor* pMonitor) {
+    if (g_pCompositor->m_bUnsafeState)
+        return;
+
     wlr_box damageBox = {0, 0, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y};
     wlr_output_damage_add_box(pMonitor->damage, &damageBox);
 
@@ -609,6 +754,9 @@ void CHyprRenderer::damageMonitor(SMonitor* pMonitor) {
 }
 
 void CHyprRenderer::damageBox(wlr_box* pBox) {
+    if (g_pCompositor->m_bUnsafeState)
+        return;
+
     for (auto& m : g_pCompositor->m_vMonitors) {
         wlr_box damageBox = {pBox->x - m->vecPosition.x, pBox->y - m->vecPosition.y, pBox->width, pBox->height};
         scaleBox(&damageBox, m->scale);
@@ -626,7 +774,14 @@ void CHyprRenderer::damageBox(const int& x, const int& y, const int& w, const in
     damageBox(&box);
 }
 
-void CHyprRenderer::renderDragIcon(SMonitor* pMonitor, timespec* time) {
+void CHyprRenderer::damageRegion(pixman_region32_t* rg) {
+    PIXMAN_DAMAGE_FOREACH(rg) {
+        const auto RECT = RECTSARR[i];
+        damageBox(RECT.x1, RECT.y1, RECT.x2 - RECT.x1, RECT.y2 - RECT.y1);
+    }
+}
+
+void CHyprRenderer::renderDragIcon(CMonitor* pMonitor, timespec* time) {
     if (!(g_pInputManager->m_sDrag.dragIcon && g_pInputManager->m_sDrag.iconMapped && g_pInputManager->m_sDrag.dragIcon->surface))
         return;
 
@@ -652,21 +807,33 @@ DAMAGETRACKINGMODES CHyprRenderer::damageTrackingModeFromStr(const std::string&
     return DAMAGE_TRACKING_INVALID;
 }
 
-bool CHyprRenderer::applyMonitorRule(SMonitor* pMonitor, SMonitorRule* pMonitorRule, bool force) {
+bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorRule, bool force) {
 
     Debug::log(LOG, "Applying monitor rule for %s", pMonitor->szName.c_str());
 
     // if it's disabled, disable and ignore
     if (pMonitorRule->disabled) {
-        wlr_output_enable(pMonitor->output, 0);
-        wlr_output_commit(pMonitor->output);
 
-        Events::listener_monitorDestroy(nullptr, pMonitor->output);
-        return false;
+        if (pMonitor->m_bEnabled)
+            pMonitor->onDisconnect();
+
+        return true;
+    }
+
+    if (!pMonitor->m_bEnabled) {
+        pMonitor->onConnect(true); // enable it.
+        force = true;
     }
 
     // Check if the rule isn't already applied
-    if (!force && DELTALESSTHAN(pMonitor->vecPixelSize.x, pMonitorRule->resolution.x, 1) && DELTALESSTHAN(pMonitor->vecPixelSize.y, pMonitorRule->resolution.y, 1) && DELTALESSTHAN(pMonitor->refreshRate, pMonitorRule->refreshRate, 1) && pMonitor->scale == pMonitorRule->scale && DELTALESSTHAN(pMonitor->vecPosition.x, pMonitorRule->offset.x, 1) && DELTALESSTHAN(pMonitor->vecPosition.y, pMonitorRule->offset.y, 1) && pMonitor->transform == pMonitorRule->transform) {
+    if (!force
+            && DELTALESSTHAN(pMonitor->vecPixelSize.x, pMonitorRule->resolution.x, 1)
+            && DELTALESSTHAN(pMonitor->vecPixelSize.y, pMonitorRule->resolution.y, 1)
+            && DELTALESSTHAN(pMonitor->refreshRate, pMonitorRule->refreshRate, 1)
+            && pMonitor->scale == pMonitorRule->scale
+            && ((DELTALESSTHAN(pMonitor->vecPosition.x, pMonitorRule->offset.x, 1) && DELTALESSTHAN(pMonitor->vecPosition.y, pMonitorRule->offset.y, 1)) || pMonitorRule->offset == Vector2D(-1, -1))
+            && pMonitor->transform == pMonitorRule->transform) {
+
         Debug::log(LOG, "Not applying a new rule to %s because it's already applied!", pMonitor->szName.c_str());
         return true;
     }
@@ -677,67 +844,111 @@ bool CHyprRenderer::applyMonitorRule(SMonitor* pMonitor, SMonitorRule* pMonitorR
     pMonitor->vecPosition = pMonitorRule->offset;
 
     // loop over modes and choose an appropriate one.
-    if (!wl_list_empty(&pMonitor->output->modes)) {
-        wlr_output_mode* mode;
-        bool found = false;
+    if (pMonitorRule->resolution != Vector2D()) {
+        if (!wl_list_empty(&pMonitor->output->modes)) {
+            wlr_output_mode* mode;
+            bool found = false;
 
-        wl_list_for_each(mode, &pMonitor->output->modes, link) {
-            // if delta of refresh rate, w and h chosen and mode is < 1 we accept it
-            if (DELTALESSTHAN(mode->width, pMonitorRule->resolution.x, 1) && DELTALESSTHAN(mode->height, pMonitorRule->resolution.y, 1) && DELTALESSTHAN(mode->refresh / 1000.f, pMonitorRule->refreshRate, 1)) {
-                wlr_output_set_mode(pMonitor->output, mode);
+            wl_list_for_each(mode, &pMonitor->output->modes, link) {
+                // if delta of refresh rate, w and h chosen and mode is < 1 we accept it
+                if (DELTALESSTHAN(mode->width, pMonitorRule->resolution.x, 1) && DELTALESSTHAN(mode->height, pMonitorRule->resolution.y, 1) && DELTALESSTHAN(mode->refresh / 1000.f, pMonitorRule->refreshRate, 1)) {
+                    wlr_output_set_mode(pMonitor->output, mode);
+
+                    if (!wlr_output_test(pMonitor->output)) {
+                        Debug::log(LOG, "Monitor %s: REJECTED available mode: %ix%i@%2f!",
+                                   pMonitor->output->name, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate,
+                                   mode->width, mode->height, mode->refresh / 1000.f);
+                        continue;
+                    }
+
+                    Debug::log(LOG, "Monitor %s: requested %ix%i@%2f, found available mode: %ix%i@%imHz, applying.",
+                               pMonitor->output->name, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate,
+                               mode->width, mode->height, mode->refresh);
+
+                    found = true;
+
+                    pMonitor->refreshRate = mode->refresh / 1000.f;
+                    pMonitor->vecSize = Vector2D(mode->width, mode->height);
+
+                    break;
+                }
+            }
+
+            if (!found) {
+                wlr_output_set_custom_mode(pMonitor->output, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (int)pMonitorRule->refreshRate * 1000);
+                pMonitor->vecSize = pMonitorRule->resolution;
 
                 if (!wlr_output_test(pMonitor->output)) {
-                    Debug::log(LOG, "Monitor %s: REJECTED available mode: %ix%i@%2f!",
+                    Debug::log(ERR, "Custom resolution FAILED, falling back to preferred");
+
+                    const auto PREFERREDMODE = wlr_output_preferred_mode(pMonitor->output);
+
+                    if (!PREFERREDMODE) {
+                        Debug::log(ERR, "Monitor %s has NO PREFERRED MODE, and an INVALID one was requested: %ix%i@%2f",
+                                   (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate);
+                        return true;
+                    }
+
+                    // Preferred is valid
+                    wlr_output_set_mode(pMonitor->output, PREFERREDMODE);
+
+                    Debug::log(ERR, "Monitor %s got an invalid requested mode: %ix%i@%2f, using the preferred one instead: %ix%i@%2f",
                                pMonitor->output->name, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate,
-                               mode->width, mode->height, mode->refresh / 1000.f);
-                    continue;
+                               PREFERREDMODE->width, PREFERREDMODE->height, PREFERREDMODE->refresh / 1000.f);
+
+                    pMonitor->refreshRate = PREFERREDMODE->refresh / 1000.f;
+                    pMonitor->vecSize = Vector2D(PREFERREDMODE->width, PREFERREDMODE->height);
+                } else {
+                    Debug::log(LOG, "Set a custom mode %ix%i@%2f (mode not found in monitor modes)", (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate);
                 }
-
-                Debug::log(LOG, "Monitor %s: requested %ix%i@%2f, found available mode: %ix%i@%imHz, applying.",
-                           pMonitor->output->name, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate,
-                           mode->width, mode->height, mode->refresh);
-
-                found = true;
-
-                pMonitor->refreshRate = mode->refresh / 1000.f;
-                pMonitor->vecSize = Vector2D(mode->width, mode->height);
-
-                break;
             }
-        }
-
-        if (!found) {
+        } else {
             wlr_output_set_custom_mode(pMonitor->output, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (int)pMonitorRule->refreshRate * 1000);
             pMonitor->vecSize = pMonitorRule->resolution;
 
-            if (!wlr_output_test(pMonitor->output)) {
-                Debug::log(ERR, "Custom resolution FAILED, falling back to preferred");
-
-                const auto PREFERREDMODE = wlr_output_preferred_mode(pMonitor->output);
-
-                if (!PREFERREDMODE) {
-                    Debug::log(ERR, "Monitor %s has NO PREFERRED MODE, and an INVALID one was requested: %ix%i@%2f",
-                               (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate);
-                    return true;
-                }
-
-                // Preferred is valid
-                wlr_output_set_mode(pMonitor->output, PREFERREDMODE);
-
-                Debug::log(ERR, "Monitor %s got an invalid requested mode: %ix%i@%2f, using the preferred one instead: %ix%i@%2f",
-                           pMonitor->output->name, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate,
-                           PREFERREDMODE->width, PREFERREDMODE->height, PREFERREDMODE->refresh / 1000.f);
-
-                pMonitor->refreshRate = PREFERREDMODE->refresh / 1000.f;
-                pMonitor->vecSize = Vector2D(PREFERREDMODE->width, PREFERREDMODE->height);
-            } else {
-                Debug::log(LOG, "Set a custom mode %ix%i@%2f (mode not found in monitor modes)", (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate);
-            }
+            Debug::log(LOG, "Setting custom mode for %s", pMonitor->output->name);
         }
     } else {
-        wlr_output_set_custom_mode(pMonitor->output, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (int)pMonitorRule->refreshRate * 1000);
-        pMonitor->vecSize = pMonitorRule->resolution;
+        const auto PREFERREDMODE = wlr_output_preferred_mode(pMonitor->output);
+
+        if (!PREFERREDMODE) {
+            Debug::log(ERR, "Monitor %s has NO PREFERRED MODE",
+                       (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate);
+
+            if (!wl_list_empty(&pMonitor->output->modes)) {
+                wlr_output_mode* mode;
+
+                wl_list_for_each(mode, &pMonitor->output->modes, link) {
+                    wlr_output_set_mode(pMonitor->output, mode);
+
+                    if (!wlr_output_test(pMonitor->output)) {
+                        Debug::log(LOG, "Monitor %s: REJECTED available mode: %ix%i@%2f!",
+                                   pMonitor->output->name, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate,
+                                   mode->width, mode->height, mode->refresh / 1000.f);
+                        continue;
+                    }
+
+                    Debug::log(LOG, "Monitor %s: requested %ix%i@%2f, found available mode: %ix%i@%imHz, applying.",
+                               pMonitor->output->name, (int)pMonitorRule->resolution.x, (int)pMonitorRule->resolution.y, (float)pMonitorRule->refreshRate,
+                               mode->width, mode->height, mode->refresh);
+
+                    pMonitor->refreshRate = mode->refresh / 1000.f;
+                    pMonitor->vecSize = Vector2D(mode->width, mode->height);
+
+                    break;
+                }
+            }
+        } else {
+            // Preferred is valid
+            wlr_output_set_mode(pMonitor->output, PREFERREDMODE);
+
+            pMonitor->vecSize = Vector2D(PREFERREDMODE->width, PREFERREDMODE->height);
+            pMonitor->refreshRate = PREFERREDMODE->refresh / 1000.f;
+
+            Debug::log(LOG, "Setting preferred mode for %s", pMonitor->output->name);
+        }
     }
+    
 
     wlr_output_set_transform(pMonitor->output, pMonitorRule->transform);
     pMonitor->transform = pMonitorRule->transform;
@@ -757,9 +968,23 @@ bool CHyprRenderer::applyMonitorRule(SMonitor* pMonitor, SMonitorRule* pMonitorR
     pMonitor->vecSize = (Vector2D(x, y) / pMonitor->scale).floor();
     pMonitor->vecTransformedSize = Vector2D(x,y);
 
-    wlr_output_layout_add(g_pCompositor->m_sWLROutputLayout, pMonitor->output, (int)pMonitorRule->offset.x, (int)pMonitorRule->offset.y);
+    if (pMonitorRule->offset == Vector2D(-1, -1)) {
+        // let's find manually a sensible position for it, to the right.
+        Vector2D finalPos;
 
-    //wlr_output_damage_add_whole(pMonitor->damage);
+        for (auto& m : g_pCompositor->m_vMonitors) {
+            if (m->ID == pMonitor->ID)
+                continue;
+
+            if (m->vecPosition.x + std::ceil(m->vecSize.x) > finalPos.x) {
+                finalPos.x = m->vecPosition.x + std::ceil(m->vecSize.x);
+            }
+        }
+
+        pMonitor->vecPosition = finalPos;
+    }
+
+    wlr_output_layout_add(g_pCompositor->m_sWLROutputLayout, pMonitor->output, (int)pMonitor->vecPosition.x, (int)pMonitor->vecPosition.y);
 
     wlr_output_enable(pMonitor->output, true);
 
@@ -808,4 +1033,4 @@ void CHyprRenderer::ensureCursorRenderingMode() {
 
 bool CHyprRenderer::shouldRenderCursor() {
     return m_bHasARenderedCursor;
-}
+}

src/render/Renderer.hpp

@@ -17,6 +17,12 @@ enum DAMAGETRACKINGMODES {
     DAMAGE_TRACKING_FULL
 };
 
+enum eRenderPassMode {
+    RENDER_PASS_ALL = 0,
+    RENDER_PASS_MAIN,
+    RENDER_PASS_POPUP
+};
+
 class CHyprRenderer {
 public:
 
@@ -27,9 +33,10 @@ public:
     void                damageWindow(CWindow*);
     void                damageBox(wlr_box*);
     void                damageBox(const int& x, const int& y, const int& w, const int& h);
-    void                damageMonitor(SMonitor*);
-    bool                applyMonitorRule(SMonitor*, SMonitorRule*, bool force = false);
-    bool                shouldRenderWindow(CWindow*, SMonitor*);
+    void                damageRegion(pixman_region32_t*);
+    void                damageMonitor(CMonitor*);
+    bool                applyMonitorRule(CMonitor*, SMonitorRule*, bool force = false);
+    bool                shouldRenderWindow(CWindow*, CMonitor*);
     bool                shouldRenderWindow(CWindow*);
     void                ensureCursorRenderingMode();
     bool                shouldRenderCursor();
@@ -39,11 +46,12 @@ public:
     DAMAGETRACKINGMODES damageTrackingModeFromStr(const std::string&);
 
 private:
-    void                arrangeLayerArray(SMonitor*, const std::list<SLayerSurface*>&, bool, wlr_box*);
-    void                renderWorkspaceWithFullscreenWindow(SMonitor*, CWorkspace*, timespec*);
-    void                renderWindow(CWindow*, SMonitor*, timespec*, bool);
-    void                renderLayer(SLayerSurface*, SMonitor*, timespec*);
-    void                renderDragIcon(SMonitor*, timespec*);
+    void                arrangeLayerArray(CMonitor*, const std::vector<std::unique_ptr<SLayerSurface>>&, bool, wlr_box*);
+    void                renderWorkspaceWithFullscreenWindow(CMonitor*, CWorkspace*, timespec*);
+    void                renderWindow(CWindow*, CMonitor*, timespec*, bool, eRenderPassMode);
+    void                renderLayer(SLayerSurface*, CMonitor*, timespec*);
+    void                renderDragIcon(CMonitor*, timespec*);
+    void                renderIMEPopup(SIMEPopup*, CMonitor*, timespec*);
 
     bool                m_bHasARenderedCursor = true;
 

src/render/Shader.cpp

@@ -10,4 +10,11 @@ GLint CShader::getUniformLocation(const std::string& unif) {
     }
 
     return itpos->second;
+}
+
+CShader::~CShader() {
+    // destroy shader
+    if (program != 0) {
+        glDeleteProgram(program);
+    }
 }

src/render/Shader.hpp

@@ -5,7 +5,9 @@
 
 class CShader {
 public:
-    GLuint program;
+    ~CShader();
+
+    GLuint program = 0;
     GLint proj;
     GLint color;
     GLint tex;
@@ -14,6 +16,19 @@ public:
     GLint texAttrib;
     GLint discardOpaque;
 
+    GLint topLeft;
+    GLint bottomRight;
+    GLint fullSize;
+    GLint radius;
+    GLint primitiveMultisample;
+
+    GLint thick;
+
+    GLint halfpixel;
+
+    GLint range;
+    GLint shadowPower;
+
     GLint getUniformLocation(const std::string&);
 
 private:

src/render/decorations/CHyprDropShadowDecoration.cpp

@@ -48,11 +48,14 @@ void CHyprDropShadowDecoration::updateWindow(CWindow* pWindow) {
     }
 }
 
-void CHyprDropShadowDecoration::draw(SMonitor* pMonitor, float a) {
+void CHyprDropShadowDecoration::draw(CMonitor* pMonitor, float a) {
 
     if (!g_pCompositor->windowValidMapped(m_pWindow))
         return;
 
+    if (m_pWindow->m_cRealShadowColor.col() == CColor(0, 0, 0, 0))
+        return; // don't draw invisible shadows
+
     static auto *const PSHADOWS = &g_pConfigManager->getConfigValuePtr("decoration:drop_shadow")->intValue;
     static auto *const PSHADOWSIZE = &g_pConfigManager->getConfigValuePtr("decoration:shadow_range")->intValue;
     static auto *const PROUNDING = &g_pConfigManager->getConfigValuePtr("decoration:rounding")->intValue;
@@ -77,6 +80,8 @@ void CHyprDropShadowDecoration::draw(SMonitor* pMonitor, float a) {
         return; // cannot parse
     }
 
+    const auto ROUNDING = !m_pWindow->m_sSpecialRenderData.rounding ? 0 : (m_pWindow->m_sAdditionalConfigData.rounding == -1 ? *PROUNDING : m_pWindow->m_sAdditionalConfigData.rounding);
+
     // update the extents
     m_seExtents = {{*PSHADOWSIZE + 2 - offset.x, *PSHADOWSIZE + 2 - offset.y}, {*PSHADOWSIZE + 2 + offset.x, *PSHADOWSIZE + 2 + offset.y}};
 
@@ -89,12 +94,14 @@ void CHyprDropShadowDecoration::draw(SMonitor* pMonitor, float a) {
     if (fullBox.width < 1 || fullBox.height < 1)
         return; // don't draw invisible shadows
 
+    g_pHyprOpenGL->scissor((wlr_box *)nullptr);
+
     if (*PSHADOWIGNOREWINDOW) {
+        glEnable(GL_STENCIL_TEST);
+
         glClearStencil(0);
         glClear(GL_STENCIL_BUFFER_BIT);
 
-        glEnable(GL_STENCIL_TEST);
-
         glStencilFunc(GL_ALWAYS, 1, -1);
         glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
 
@@ -103,18 +110,20 @@ void CHyprDropShadowDecoration::draw(SMonitor* pMonitor, float a) {
         scaleBox(&windowBox, pMonitor->scale);
         
         if (windowBox.width < 1 || windowBox.height < 1) {
-		    glDisable(GL_STENCIL_TEST);
-		    return; // prevent assert failed
+            glClearStencil(0);
+            glClear(GL_STENCIL_BUFFER_BIT);
+            glDisable(GL_STENCIL_TEST);
+            return;  // prevent assert failed
         }
-	
-        g_pHyprOpenGL->renderRect(&windowBox, CColor(0,0,0,0), *PROUNDING);
+
+        g_pHyprOpenGL->renderRect(&windowBox, CColor(0, 0, 0, 0), ROUNDING * pMonitor->scale);
 
         glStencilFunc(GL_NOTEQUAL, 1, -1);
         glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
     }
 
     scaleBox(&fullBox, pMonitor->scale);
-    g_pHyprOpenGL->renderRoundedShadow(&fullBox, *PROUNDING, *PSHADOWSIZE, a);
+    g_pHyprOpenGL->renderRoundedShadow(&fullBox, ROUNDING * pMonitor->scale, *PSHADOWSIZE * pMonitor->scale, a);
 
     if (*PSHADOWIGNOREWINDOW) {
         // cleanup

src/render/decorations/CHyprDropShadowDecoration.hpp

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

src/render/decorations/CHyprGroupBarDecoration.cpp

@@ -64,7 +64,7 @@ void CHyprGroupBarDecoration::damageEntire() {
     g_pHyprRenderer->damageBox(&dm);
 }
 
-void CHyprGroupBarDecoration::draw(SMonitor* pMonitor, float a) {
+void CHyprGroupBarDecoration::draw(CMonitor* pMonitor, float a) {
     // get how many bars we will draw
     int barsToDraw = m_dwGroupMembers.size();
 

src/render/decorations/CHyprGroupBarDecoration.hpp

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