refactor a bunch of layout code

src/layout/DwindleLayout.cpp

@@ -180,7 +180,7 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode) {
     PWINDOW->updateWindowDecos();
 }
 
-void CHyprDwindleLayout::onWindowCreated(CWindow* pWindow) {
+void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
     if (pWindow->m_bIsFloating)
         return;
 
@@ -311,7 +311,7 @@ void CHyprDwindleLayout::onWindowCreated(CWindow* pWindow) {
     }
 }
 
-void CHyprDwindleLayout::onWindowRemoved(CWindow* pWindow) {
+void CHyprDwindleLayout::onWindowRemovedTiling(CWindow* pWindow) {
 
     const auto PNODE = getNodeFromWindow(pWindow);
 
@@ -401,150 +401,8 @@ void CHyprDwindleLayout::recalculateMonitor(const int& monid) {
     }
 }
 
-void CHyprDwindleLayout::changeWindowFloatingMode(CWindow* pWindow) {
+bool CHyprDwindleLayout::isWindowTiled(CWindow* pWindow) {
-
+    return getNodeFromWindow(pWindow) != nullptr;
-    if (pWindow->m_bIsFullscreen) {
-        Debug::log(LOG, "Rejecting a change float order because window is fullscreen.");
-
-        // restore its' floating mode
-        pWindow->m_bIsFloating = !pWindow->m_bIsFloating;
-        return;
-    }
-
-    const auto PNODE = getNodeFromWindow(pWindow);
-
-    if (!PNODE) {
-        const auto PNEWMON = g_pCompositor->getMonitorFromVector(pWindow->m_vRealPosition.vec() + pWindow->m_vRealSize.vec() / 2.f);
-        pWindow->m_iMonitorID = PNEWMON->ID;
-        pWindow->m_iWorkspaceID = PNEWMON->activeWorkspace;
-
-        // save real pos cuz the func applies the default 5,5 mid
-        const auto PSAVEDPOS = pWindow->m_vRealPosition.vec();
-        const auto PSAVEDSIZE = pWindow->m_vRealSize.vec();
-
-        // if the window is pseudo, update its size
-        pWindow->m_vPseudoSize = pWindow->m_vRealSize.vec();
-
-        onWindowCreated(pWindow);
-
-        pWindow->m_vRealPosition.setValue(PSAVEDPOS);
-        pWindow->m_vRealSize.setValue(PSAVEDSIZE);
-
-        // fix pseudo leaving artifacts
-        g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID));
-    } else {
-        onWindowRemoved(pWindow);
-
-        g_pCompositor->moveWindowToTop(pWindow);
-    }
-}
-
-void CHyprDwindleLayout::onBeginDragWindow() {
-
-    const auto DRAGGINGWINDOW = g_pInputManager->currentlyDraggedWindow;
-
-    m_vBeginDragSizeXY = Vector2D();
-
-    // Window will be floating. Let's check if it's valid. It should be, but I don't like crashing.
-    if (!g_pCompositor->windowValidMapped(DRAGGINGWINDOW)) {
-        Debug::log(ERR, "Dragging attempted on an invalid window!");
-        return;
-    }
-
-    if (DRAGGINGWINDOW->m_bIsFullscreen) {
-	    Debug::log(LOG, "Rejecting drag on a fullscreen window.");
-	    return;
-    }
-
-    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(DRAGGINGWINDOW->m_iWorkspaceID);
-
-    if (PWORKSPACE->m_bHasFullscreenWindow) {
-        Debug::log(LOG, "Rejecting drag on a fullscreen workspace.");
-        return;
-    }
-
-    DRAGGINGWINDOW->m_bDraggingTiled = false;
-
-    if (!DRAGGINGWINDOW->m_bIsFloating) {
-        if (g_pInputManager->dragButton == BTN_LEFT) {
-            changeWindowFloatingMode(DRAGGINGWINDOW);
-            DRAGGINGWINDOW->m_bIsFloating = true;
-            DRAGGINGWINDOW->m_bDraggingTiled = true;
-        }
-    }
-
-    m_vBeginDragXY = g_pInputManager->getMouseCoordsInternal();
-    m_vBeginDragPositionXY = DRAGGINGWINDOW->m_vRealPosition.vec();
-    m_vBeginDragSizeXY = DRAGGINGWINDOW->m_vRealSize.vec();
-    m_vLastDragXY = m_vBeginDragXY;
-
-    g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
-}
-
-void CHyprDwindleLayout::onEndDragWindow() {
-    const auto DRAGGINGWINDOW = g_pInputManager->currentlyDraggedWindow;
-
-    if (!g_pCompositor->windowValidMapped(DRAGGINGWINDOW))
-        return;
-
-    if (DRAGGINGWINDOW->m_bDraggingTiled) {
-        DRAGGINGWINDOW->m_bIsFloating = false;
-        changeWindowFloatingMode(DRAGGINGWINDOW);
-    }
-        
-    g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
-}
-
-void CHyprDwindleLayout::onMouseMove(const Vector2D& mousePos) {
-    const auto DRAGGINGWINDOW = g_pInputManager->currentlyDraggedWindow;
-
-    // Window invalid or drag begin size 0,0 meaning we rejected it.
-    if (!g_pCompositor->windowValidMapped(DRAGGINGWINDOW) || m_vBeginDragSizeXY == Vector2D()) {
-        g_pInputManager->currentlyDraggedWindow = nullptr;
-        return;
-    }
-        
-    const auto DELTA = Vector2D(mousePos.x - m_vBeginDragXY.x, mousePos.y - m_vBeginDragXY.y);
-    const auto TICKDELTA = Vector2D(mousePos.x - m_vLastDragXY.x, mousePos.y - m_vLastDragXY.y);
-
-    if (abs(TICKDELTA.x) < 1.f && abs(TICKDELTA.y) < 1.f)
-        return;
-
-    m_vLastDragXY = mousePos;
-
-    g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
-
-    if (g_pInputManager->dragButton == BTN_LEFT) {
-        DRAGGINGWINDOW->m_vRealPosition.setValueAndWarp(m_vBeginDragPositionXY + DELTA);
-
-        DRAGGINGWINDOW->updateWindowDecos();
-
-        g_pXWaylandManager->setWindowSize(DRAGGINGWINDOW, DRAGGINGWINDOW->m_vRealSize.goalv());
-    } else {
-        if (DRAGGINGWINDOW->m_bIsFloating) {
-            DRAGGINGWINDOW->m_vRealSize.setValueAndWarp(m_vBeginDragSizeXY + DELTA);
-            DRAGGINGWINDOW->m_vRealSize.setValueAndWarp(Vector2D(std::clamp(DRAGGINGWINDOW->m_vRealSize.vec().x, (double)20, (double)999999), std::clamp(DRAGGINGWINDOW->m_vRealSize.vec().y, (double)20, (double)999999)));
-
-            DRAGGINGWINDOW->updateWindowDecos();
-
-            g_pXWaylandManager->setWindowSize(DRAGGINGWINDOW, DRAGGINGWINDOW->m_vRealSize.goalv());
-        } else {
-            resizeActiveWindow(TICKDELTA, DRAGGINGWINDOW);
-        }
-    }
-
-    // get middle point
-    Vector2D middle = DRAGGINGWINDOW->m_vRealPosition.vec() + DRAGGINGWINDOW->m_vRealSize.vec() / 2.f;
-
-    // and check its monitor
-    const auto PMONITOR = g_pCompositor->getMonitorFromVector(middle);
-
-    if (PMONITOR) {
-        DRAGGINGWINDOW->m_iMonitorID = PMONITOR->ID;
-        DRAGGINGWINDOW->m_iWorkspaceID = PMONITOR->activeWorkspace;
-    }
-
-    g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
 }
 
 void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, CWindow* pWindow) {
@@ -635,55 +493,6 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, CWindow*
     TOPCONTAINER->recalcSizePosRecursive();
 }
 
-void CHyprDwindleLayout::onWindowCreatedFloating(CWindow* pWindow) {
-    wlr_box desiredGeometry = {0};
-    g_pXWaylandManager->getGeometryForWindow(pWindow, &desiredGeometry);
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
-
-    if (!PMONITOR){
-        Debug::log(ERR, "Window %x (%s) has an invalid monitor in onWindowCreatedFloating!!!", pWindow, pWindow->m_szTitle.c_str());
-        return;
-    }
-
-    if (desiredGeometry.width <= 0 || desiredGeometry.height <= 0) {
-        const auto PWINDOWSURFACE = g_pXWaylandManager->getWindowSurface(pWindow);
-        pWindow->m_vRealSize = Vector2D(PWINDOWSURFACE->current.width, PWINDOWSURFACE->current.height);
-        pWindow->m_vRealPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_vRealSize.vec().x) / 2.f, PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_vRealSize.vec().y) / 2.f);
-
-    } else {
-        // we respect the size.
-        pWindow->m_vRealSize = Vector2D(desiredGeometry.width, desiredGeometry.height);
-
-        // check if it's on the correct monitor!
-        Vector2D middlePoint = Vector2D(desiredGeometry.x, desiredGeometry.y) + Vector2D(desiredGeometry.width, desiredGeometry.height) / 2.f;
-
-         // TODO: detect a popup in a more consistent way.
-        if (!g_pCompositor->isPointOnAnyMonitor(middlePoint) || (desiredGeometry.x == 0 && desiredGeometry.y == 0)) {
-            // if it's not, fall back to the center placement
-            pWindow->m_vRealPosition = PMONITOR->vecPosition + Vector2D((PMONITOR->vecSize.x - desiredGeometry.width) / 2.f, (PMONITOR->vecSize.y - desiredGeometry.height) / 2.f);
-        } else {
-            // if it is, we respect where it wants to put itself, but apply monitor offset if outside
-            // most of these are popups
-
-            if (const auto POPENMON = g_pCompositor->getMonitorFromVector(middlePoint); POPENMON->ID != PMONITOR->ID) {
-                pWindow->m_vRealPosition = Vector2D(desiredGeometry.x, desiredGeometry.y) - POPENMON->vecPosition + PMONITOR->vecPosition;
-            } else {
-                pWindow->m_vRealPosition = Vector2D(desiredGeometry.x, desiredGeometry.y);
-            }
-        }
-    }
-
-    if (pWindow->m_bX11DoesntWantBorders) {
-        pWindow->m_vRealPosition.setValue(pWindow->m_vRealPosition.goalv());
-        pWindow->m_vRealSize.setValue(pWindow->m_vRealSize.goalv());
-    }
-
-    g_pXWaylandManager->setWindowSize(pWindow, pWindow->m_vRealSize.goalv());
-    g_pCompositor->fixXWaylandWindowsOnWorkspace(PMONITOR->activeWorkspace);
-
-    g_pCompositor->moveWindowToTop(pWindow);
-}
-
 void CHyprDwindleLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscreenMode fullscreenMode, bool on) {
     if (!g_pCompositor->windowValidMapped(pWindow))
         return;
@@ -1011,20 +820,4 @@ void CHyprDwindleLayout::toggleSplit(CWindow* pWindow) {
 
 std::string CHyprDwindleLayout::getLayoutName() {
     return "dwindle";
-}
-
-void CHyprDwindleLayout::moveActiveWindow(const Vector2D& delta, CWindow* pWindow) {
-    const auto PWINDOW = pWindow ? pWindow : g_pCompositor->m_pLastWindow;
-
-    if (!g_pCompositor->windowValidMapped(PWINDOW))
-        return;
-
-    if (!PWINDOW->m_bIsFloating) {
-        Debug::log(LOG, "Dwindle cannot move a tiled window in moveActiveWindow!");
-        return;
-    }
-
-    PWINDOW->m_vRealPosition = PWINDOW->m_vRealPosition.goalv() + delta;
-
-    g_pHyprRenderer->damageWindow(PWINDOW);
 }

src/layout/DwindleLayout.hpp

@@ -42,17 +42,12 @@ struct SDwindleNodeData {
 
 class CHyprDwindleLayout : public IHyprLayout {
 public:
-    virtual void        onWindowCreated(CWindow*);
+    virtual void        onWindowCreatedTiling(CWindow*);
-    virtual void        onWindowRemoved(CWindow*);
+    virtual void        onWindowRemovedTiling(CWindow*);
+    virtual bool        isWindowTiled(CWindow*);
     virtual void        recalculateMonitor(const int&);
     virtual void        recalculateWindow(CWindow*);
-    virtual void        changeWindowFloatingMode(CWindow*);
-    virtual void        onBeginDragWindow();
     virtual void        resizeActiveWindow(const Vector2D&, CWindow* pWindow = nullptr);
-    virtual void        moveActiveWindow(const Vector2D&, CWindow* pWindow = nullptr);
-    virtual void        onEndDragWindow();
-    virtual void        onMouseMove(const Vector2D&);
-    virtual void        onWindowCreatedFloating(CWindow*);
     virtual void        fullscreenRequestForWindow(CWindow*, eFullscreenMode, bool);
     virtual std::any    layoutMessage(SLayoutMessageHeader, std::string);
     virtual SWindowRenderLayoutHints requestRenderHints(CWindow*);
@@ -60,15 +55,10 @@ public:
     virtual void        alterSplitRatioBy(CWindow*, float);
     virtual std::string getLayoutName();
 
-   private:
+private:
 
     std::list<SDwindleNodeData>     m_lDwindleNodesData;
 
-    Vector2D                        m_vBeginDragXY;
-    Vector2D                        m_vLastDragXY;
-    Vector2D                        m_vBeginDragPositionXY;
-    Vector2D                        m_vBeginDragSizeXY;
-
     int                 getNodesOnWorkspace(const int&);
     void                applyNodeDataToWindow(SDwindleNodeData*);
     SDwindleNodeData*   getNodeFromWindow(CWindow*);

src/layout/IHyprLayout.cpp

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

src/layout/IHyprLayout.hpp

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

src/managers/KeybindManager.cpp

@@ -221,6 +221,9 @@ void CKeybindManager::toggleActiveFloating(std::string args) {
     const auto ACTIVEWINDOW = g_pCompositor->m_pLastWindow;
 
     if (g_pCompositor->windowValidMapped(ACTIVEWINDOW)) {
+        // remove drag status
+        g_pInputManager->currentlyDraggedWindow = nullptr;
+
         ACTIVEWINDOW->m_bIsFloating = !ACTIVEWINDOW->m_bIsFloating;
 
         if (ACTIVEWINDOW->m_iWorkspaceID == SPECIAL_WORKSPACE_ID) {

src/render/decorations/IHyprWindowDecoration.hpp

@@ -16,7 +16,7 @@ struct SWindowDecorationExtents {
 class CWindow;
 struct SMonitor;
 
-class IHyprWindowDecoration {
+interface IHyprWindowDecoration {
 public:
     virtual ~IHyprWindowDecoration() = 0;