internal: wrap wlr surfaces (#1822)

src/Compositor.cpp

@@ -872,7 +872,7 @@ void CCompositor::focusWindow(CWindow* pWindow, wlr_surface* pSurface) {
 
     m_pLastWindow = PLASTWINDOW;
 
-    const auto PWINDOWSURFACE = pSurface ? pSurface : g_pXWaylandManager->getWindowSurface(pWindow);
+    const auto PWINDOWSURFACE = pSurface ? pSurface : pWindow->m_pWLSurface.wlr();
 
     focusSurface(PWINDOWSURFACE, pWindow);
 
@@ -926,8 +926,7 @@ void CCompositor::focusWindow(CWindow* pWindow, wlr_surface* pSurface) {
 
 void CCompositor::focusSurface(wlr_surface* pSurface, CWindow* pWindowOwner) {
 
-    if (m_sSeat.seat->keyboard_state.focused_surface == pSurface ||
+    if (m_sSeat.seat->keyboard_state.focused_surface == pSurface || (pWindowOwner && m_sSeat.seat->keyboard_state.focused_surface == pWindowOwner->m_pWLSurface.wlr()))
-        (pWindowOwner && m_sSeat.seat->keyboard_state.focused_surface == g_pXWaylandManager->getWindowSurface(pWindowOwner)))
         return; // Don't focus when already focused on this.
 
     if (g_pSessionLockManager->isSessionLocked()) {
@@ -1038,7 +1037,7 @@ CWindow* CCompositor::getWindowFromSurface(wlr_surface* pSurface) {
         if (!w->m_bIsMapped || w->m_bFadingOut || !w->m_bMappedX11)
             continue;
 
-        if (g_pXWaylandManager->getWindowSurface(w.get()) == pSurface)
+        if (w->m_pWLSurface.wlr() == pSurface)
             return w.get();
     }
 
@@ -1188,7 +1187,7 @@ bool CCompositor::isWindowActive(CWindow* pWindow) {
     if (!windowValidMapped(pWindow))
         return false;
 
-    const auto PSURFACE = g_pXWaylandManager->getWindowSurface(pWindow);
+    const auto PSURFACE = pWindow->m_pWLSurface.wlr();
 
     return PSURFACE == m_pLastFocus || pWindow == m_pLastWindow;
 }
@@ -1525,11 +1524,11 @@ CWindow* CCompositor::getConstraintWindow(SMouse* pMouse) {
     const auto PSURFACE = pMouse->currentConstraint->surface;
 
     for (auto& w : m_vWindows) {
-        if (w->isHidden() || !w->m_bMappedX11 || !w->m_bIsMapped || !g_pXWaylandManager->getWindowSurface(w.get()))
+        if (w->isHidden() || !w->m_bMappedX11 || !w->m_bIsMapped || !w->m_pWLSurface.exists())
             continue;
 
         if (w->m_bIsX11) {
-            if (PSURFACE == g_pXWaylandManager->getWindowSurface(w.get()))
+            if (PSURFACE == w->m_pWLSurface.wlr())
                 return w.get();
         } else {
             std::pair<wlr_surface*, bool> check = {PSURFACE, false};

src/Window.cpp

@@ -265,9 +265,9 @@ void CWindow::updateSurfaceOutputs() {
     const auto PNEWMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
 
     if (PLASTMONITOR && PLASTMONITOR->m_bEnabled)
-        wlr_surface_for_each_surface(g_pXWaylandManager->getWindowSurface(this), sendLeaveIter, PLASTMONITOR->output);
+        wlr_surface_for_each_surface(m_pWLSurface.wlr(), sendLeaveIter, PLASTMONITOR->output);
 
-    wlr_surface_for_each_surface(g_pXWaylandManager->getWindowSurface(this), sendEnterIter, PNEWMONITOR->output);
+    wlr_surface_for_each_surface(m_pWLSurface.wlr(), sendEnterIter, PNEWMONITOR->output);
 }
 
 void CWindow::moveToWorkspace(int workspaceID) {
@@ -285,7 +285,7 @@ void CWindow::moveToWorkspace(int workspaceID) {
     }
 
     if (PMONITOR)
-        g_pProtocolManager->m_pFractionalScaleProtocolManager->setPreferredScaleForSurface(g_pXWaylandManager->getWindowSurface(this), PMONITOR->scale);
+        g_pProtocolManager->m_pFractionalScaleProtocolManager->setPreferredScaleForSurface(m_pWLSurface.wlr(), PMONITOR->scale);
 }
 
 CWindow* CWindow::X11TransientFor() {
@@ -340,6 +340,8 @@ void CWindow::onUnmap() {
 
 void CWindow::onMap() {
 
+    m_pWLSurface.assign(g_pXWaylandManager->getWindowSurface(this));
+
     // JIC, reset the callbacks. If any are set, we'll make sure they are cleared so we don't accidentally unset them. (In case a window got remapped)
     m_vRealPosition.resetAllCallbacks();
     m_vRealSize.resetAllCallbacks();

src/Window.hpp

@@ -8,6 +8,7 @@
 #include <deque>
 #include "config/ConfigDataValues.hpp"
 #include "helpers/Vector2D.hpp"
+#include "helpers/WLSurface.hpp"
 
 enum eIdleInhibitMode
 {
@@ -158,6 +159,9 @@ class CWindow {
     DYNLISTENER(setOverrideRedirect);
     // DYNLISTENER(newSubsurfaceWindow);
 
+    CWLSurface            m_pWLSurface;
+    std::list<CWLSurface> m_lPopupSurfaces;
+
     union {
         wlr_xdg_surface*      xdg;
         wlr_xwayland_surface* xwayland;

src/events/Layers.cpp

@@ -112,6 +112,8 @@ void Events::listener_mapLayerSurface(void* owner, void* data) {
     layersurface->layerSurface->mapped = true;
     layersurface->mapped               = true;
 
+    layersurface->surface = layersurface->layerSurface->surface;
+
     // anim
     layersurface->alpha.setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeIn"));
 
@@ -207,12 +209,15 @@ void Events::listener_unmapLayerSurface(void* owner, void* data) {
 
     const auto PMONITOR = g_pCompositor->getMonitorFromOutput(layersurface->layerSurface->output);
 
+    const bool WASLASTFOCUS = g_pCompositor->m_pLastFocus == layersurface->layerSurface->surface;
+
+    layersurface->surface = nullptr;
+
     if (!PMONITOR)
         return;
 
     // refocus if needed
-    if (layersurface->layerSurface->surface == g_pCompositor->m_pLastFocus) {
+    if (WASLASTFOCUS) {
-
         Vector2D       surfaceCoords;
         SLayerSurface* pFoundLayerSurface = nullptr;
         wlr_surface*   foundSurface       = nullptr;

src/events/Popups.cpp

@@ -90,6 +90,7 @@ void Events::listener_newPopup(void* owner, void* data) {
     PNEWPOPUP->lx       = layersurface->position.x;
     PNEWPOPUP->ly       = layersurface->position.y;
     PNEWPOPUP->monitor  = PMONITOR;
+    PNEWPOPUP->parentLS = layersurface;
     createNewPopup(WLRPOPUP, PNEWPOPUP);
 }
 
@@ -148,6 +149,11 @@ void Events::listener_mapPopupXDG(void* owner, void* data) {
 
     Debug::log(LOG, "New XDG Popup mapped at %d %d", (int)PPOPUP->lx, (int)PPOPUP->ly);
 
+    if (PPOPUP->parentWindow)
+        PPOPUP->parentWindow->m_lPopupSurfaces.emplace_back(PPOPUP->popup->base->surface);
+    else if (PPOPUP->parentLS)
+        PPOPUP->parentLS->popupSurfaces.emplace_back(PPOPUP->popup->base->surface);
+
     PPOPUP->pSurfaceTree = SubsurfaceTree::createTreeRoot(PPOPUP->popup->base->surface, addPopupGlobalCoords, PPOPUP, PPOPUP->parentWindow);
 
     int lx = 0, ly = 0;
@@ -167,6 +173,11 @@ void Events::listener_unmapPopupXDG(void* owner, void* data) {
 
     ASSERT(PPOPUP);
 
+    if (PPOPUP->parentWindow)
+        std::erase(PPOPUP->parentWindow->m_lPopupSurfaces, PPOPUP->popup->base->surface);
+    else if (PPOPUP->parentLS)
+        std::erase(PPOPUP->parentLS->popupSurfaces, PPOPUP->popup->base->surface);
+
     SubsurfaceTree::destroySurfaceTree(PPOPUP->pSurfaceTree);
 
     int lx = 0, ly = 0;

src/events/Windows.cpp

@@ -73,7 +73,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
     // registers the animated vars and stuff
     PWINDOW->onMap();
 
-    const auto PWINDOWSURFACE = g_pXWaylandManager->getWindowSurface(PWINDOW);
+    const auto PWINDOWSURFACE = PWINDOW->m_pWLSurface.wlr();
 
     if (!PWINDOWSURFACE) {
         g_pCompositor->removeWindowFromVectorSafe(PWINDOW);
@@ -492,7 +492,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
     // recheck idle inhibitors
     g_pInputManager->recheckIdleInhibitorStatus();
 
-    PWINDOW->m_pSurfaceTree = SubsurfaceTree::createTreeRoot(g_pXWaylandManager->getWindowSurface(PWINDOW), addViewCoords, PWINDOW, PWINDOW);
+    PWINDOW->m_pSurfaceTree = SubsurfaceTree::createTreeRoot(PWINDOW->m_pWLSurface.wlr(), addViewCoords, PWINDOW, PWINDOW);
 
     PWINDOW->updateToplevel();
 
@@ -575,7 +575,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
     // recalc the values for this window
     g_pCompositor->updateWindowAnimatedDecorationValues(PWINDOW);
 
-    g_pProtocolManager->m_pFractionalScaleProtocolManager->setPreferredScaleForSurface(g_pXWaylandManager->getWindowSurface(PWINDOW), PMONITOR->scale);
+    g_pProtocolManager->m_pFractionalScaleProtocolManager->setPreferredScaleForSurface(PWINDOW->m_pWLSurface.wlr(), PMONITOR->scale);
 }
 
 void Events::listener_unmapWindow(void* owner, void* data) {
@@ -708,7 +708,7 @@ void Events::listener_commitWindow(void* owner, void* data) {
 
     PWINDOW->updateSurfaceOutputs();
 
-    g_pHyprRenderer->damageSurface(g_pXWaylandManager->getWindowSurface(PWINDOW), PWINDOW->m_vRealPosition.goalv().x, PWINDOW->m_vRealPosition.goalv().y);
+    g_pHyprRenderer->damageSurface(PWINDOW->m_pWLSurface.wlr(), PWINDOW->m_vRealPosition.goalv().x, PWINDOW->m_vRealPosition.goalv().y);
 
     // Debug::log(LOG, "Window %x committed", PWINDOW); // SPAM!
 }

src/helpers/SubsurfaceTree.cpp

@@ -3,8 +3,8 @@
 #include "../Compositor.hpp"
 
 void addSurfaceGlobalOffset(SSurfaceTreeNode* node, int* lx, int* ly) {
-    *lx += node->pSurface->current.dx;
+    *lx += node->pSurface->wlr()->current.dx;
-    *ly += node->pSurface->current.dy;
+    *ly += node->pSurface->wlr()->current.dy;
 
     if (node->offsetfn) {
         // This is the root node
@@ -23,7 +23,13 @@ void addSurfaceGlobalOffset(SSurfaceTreeNode* node, int* lx, int* ly) {
 SSurfaceTreeNode* createTree(wlr_surface* pSurface, CWindow* pWindow) {
     const auto PNODE = &SubsurfaceTree::surfaceTreeNodes.emplace_back();
 
-    PNODE->pSurface     = pSurface;
+    if (pSurface->data)
+        PNODE->pSurface = (CWLSurface*)pSurface->data;
+    else {
+        PNODE->pInternalSurface = pSurface;
+        PNODE->pSurface         = &PNODE->pInternalSurface;
+    }
+
     PNODE->pWindowOwner = pWindow;
 
     PNODE->hyprListener_newSubsurface.initCallback(&pSurface->events.new_subsurface, &Events::listener_newSubsurfaceNode, PNODE, "SurfaceTreeNode");
@@ -88,9 +94,9 @@ void SubsurfaceTree::destroySurfaceTree(SSurfaceTreeNode* pNode) {
     pNode->hyprListener_newSubsurface.removeCallback();
 
     // damage
-    if (pNode->pSurface) {
+    if (pNode->pSurface && pNode->pSurface->exists()) {
         wlr_box extents = {};
-        wlr_surface_get_extends(pNode->pSurface, &extents);
+        wlr_surface_get_extends(pNode->pSurface->wlr(), &extents);
 
         int lx = 0, ly = 0;
         addSurfaceGlobalOffset(pNode, &lx, &ly);
@@ -186,9 +192,9 @@ void Events::listener_unmapSubsurface(void* owner, void* data) {
             addSurfaceGlobalOffset(PNODE, &lx, &ly);
 
             wlr_box extents = {lx, ly, 0, 0};
-            if (PNODE->pSurface) {
+            if (PNODE->pSurface && PNODE->pSurface->exists()) {
-                extents.width  = PNODE->pSurface->current.width;
+                extents.width  = PNODE->pSurface->wlr()->current.width;
-                extents.height = PNODE->pSurface->current.height;
+                extents.height = PNODE->pSurface->wlr()->current.height;
 
                 g_pHyprRenderer->damageBox(&extents);
             }
@@ -228,7 +234,8 @@ void Events::listener_commitSubsurface(void* owner, void* data) {
             }
         }
 
-    g_pHyprRenderer->damageSurface(pNode->pSurface, lx, ly);
+    if (pNode->pSurface && pNode->pSurface->exists())
+        g_pHyprRenderer->damageSurface(pNode->pSurface->wlr(), lx, ly);
 }
 
 void Events::listener_destroySubsurface(void* owner, void* data) {

src/helpers/SubsurfaceTree.hpp

@@ -2,6 +2,7 @@
 
 #include "../defines.hpp"
 #include <list>
+#include "WLSurface.hpp"
 
 struct SSubsurface;
 class CWindow;
@@ -9,7 +10,8 @@ class CWindow;
 typedef void (*applyGlobalOffsetFn)(void*, int*, int*);
 
 struct SSurfaceTreeNode {
-    wlr_surface* pSurface = nullptr;
+    CWLSurface* pSurface = nullptr; // actual surface
+    CWLSurface  pInternalSurface;   // not present for head nodes to not dupe wlr_surface ownership
 
     DYNLISTENER(newSubsurface);
     DYNLISTENER(commit);

src/helpers/WLClasses.hpp

@@ -6,6 +6,7 @@
 #include "../Window.hpp"
 #include "SubsurfaceTree.hpp"
 #include "AnimatedVariable.hpp"
+#include "WLSurface.hpp"
 
 struct SLayerRule {
     std::string targetNamespace = "";
@@ -20,6 +21,9 @@ struct SLayerSurface {
     wlr_layer_surface_v1* layerSurface;
     wl_list               link;
 
+    CWLSurface            surface;
+    std::list<CWLSurface> popupSurfaces;
+
     DYNLISTENER(destroyLayerSurface);
     DYNLISTENER(mapLayerSurface);
     DYNLISTENER(unmapLayerSurface);
@@ -172,6 +176,7 @@ class CMonitor;
 
 struct SXDGPopup {
     CWindow*       parentWindow = nullptr;
+    SLayerSurface* parentLS     = nullptr;
     SXDGPopup*     parentPopup  = nullptr;
     wlr_xdg_popup* popup        = nullptr;
     CMonitor*      monitor      = nullptr;

src/helpers/WLSurface.cpp

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

src/helpers/WLSurface.hpp

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

src/layout/IHyprLayout.cpp

@@ -81,7 +81,7 @@ void IHyprLayout::onWindowCreatedFloating(CWindow* pWindow) {
     }
 
     if (desiredGeometry.width <= 5 || desiredGeometry.height <= 5) {
-        const auto PWINDOWSURFACE = g_pXWaylandManager->getWindowSurface(pWindow);
+        const auto PWINDOWSURFACE = pWindow->m_pWLSurface.wlr();
         pWindow->m_vRealSize      = Vector2D(PWINDOWSURFACE->current.width, PWINDOWSURFACE->current.height);
 
         if ((desiredGeometry.width <= 1 || desiredGeometry.height <= 1) && pWindow->m_bIsX11 &&

src/managers/KeybindManager.cpp

@@ -838,7 +838,7 @@ void CKeybindManager::changeworkspace(std::string args) {
             if (anotherMonitor)
                 g_pCompositor->warpCursorTo(PWINDOW->m_vRealPosition.vec() + PWINDOW->m_vRealSize.vec() / 2.f);
 
-            g_pCompositor->focusWindow(PWINDOW, g_pXWaylandManager->getWindowSurface(PWINDOW));
+            g_pCompositor->focusWindow(PWINDOW, PWINDOW->m_pWLSurface.wlr());
 
             if (g_pCompositor->cursorOnReservedArea()) // fix focus on bars etc
                 g_pInputManager->refocus();
@@ -1860,9 +1860,9 @@ void CKeybindManager::pass(std::string regexp) {
     // pass all mf shit
     if (!XWTOXW) {
         if (g_pKeybindManager->m_uLastCode != 0)
-            wlr_seat_keyboard_enter(g_pCompositor->m_sSeat.seat, g_pXWaylandManager->getWindowSurface(PWINDOW), KEYBOARD->keycodes, KEYBOARD->num_keycodes, &KEYBOARD->modifiers);
+            wlr_seat_keyboard_enter(g_pCompositor->m_sSeat.seat, PWINDOW->m_pWLSurface.wlr(), KEYBOARD->keycodes, KEYBOARD->num_keycodes, &KEYBOARD->modifiers);
         else
-            wlr_seat_pointer_enter(g_pCompositor->m_sSeat.seat, g_pXWaylandManager->getWindowSurface(PWINDOW), 1, 1);
+            wlr_seat_pointer_enter(g_pCompositor->m_sSeat.seat, PWINDOW->m_pWLSurface.wlr(), 1, 1);
     }
 
     wlr_keyboard_modifiers kbmods = {g_pInputManager->accumulateModsFromAllKBs(), 0, 0, 0};
@@ -1908,7 +1908,7 @@ void CKeybindManager::pass(std::string regexp) {
     if (g_pKeybindManager->m_uLastCode != 0)
         wlr_seat_keyboard_enter(g_pCompositor->m_sSeat.seat, PLASTSRF, KEYBOARD->keycodes, KEYBOARD->num_keycodes, &KEYBOARD->modifiers);
     else
-        wlr_seat_pointer_enter(g_pCompositor->m_sSeat.seat, g_pXWaylandManager->getWindowSurface(PWINDOW), SL.x, SL.y);
+        wlr_seat_pointer_enter(g_pCompositor->m_sSeat.seat, PWINDOW->m_pWLSurface.wlr(), SL.x, SL.y);
 }
 
 void CKeybindManager::layoutmsg(std::string msg) {

src/managers/input/InputManager.cpp

@@ -130,7 +130,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
             }
 
             if (CONSTRAINTWINDOW->m_bIsX11) {
-                foundSurface = g_pXWaylandManager->getWindowSurface(CONSTRAINTWINDOW);
+                foundSurface = CONSTRAINTWINDOW->m_pWLSurface.wlr();
                 surfacePos   = CONSTRAINTWINDOW->m_vRealPosition.vec();
             } else {
                 g_pCompositor->vectorWindowToSurface(mouseCoords, CONSTRAINTWINDOW, surfaceCoords);
@@ -198,7 +198,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
             foundSurface = g_pCompositor->vectorWindowToSurface(mouseCoords, pFoundWindow, surfaceCoords);
             surfacePos   = Vector2D(-1337, -1337);
         } else {
-            foundSurface = g_pXWaylandManager->getWindowSurface(pFoundWindow);
+            foundSurface = pFoundWindow->m_pWLSurface.wlr();
             surfacePos   = pFoundWindow->m_vRealPosition.vec();
         }
     }
@@ -232,7 +232,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
             if (!pFoundWindow->m_bIsX11) {
                 foundSurface = g_pCompositor->vectorWindowToSurface(mouseCoords, pFoundWindow, surfaceCoords);
             } else {
-                foundSurface = g_pXWaylandManager->getWindowSurface(pFoundWindow);
+                foundSurface = pFoundWindow->m_pWLSurface.wlr();
                 surfacePos   = pFoundWindow->m_vRealPosition.vec();
             }
         }
@@ -1127,7 +1127,7 @@ void CInputManager::unconstrainMouse() {
     const auto CONSTRAINTWINDOW = g_pCompositor->getConstraintWindow(g_pCompositor->m_sSeat.mouse);
 
     if (CONSTRAINTWINDOW) {
-        g_pXWaylandManager->activateSurface(g_pXWaylandManager->getWindowSurface(CONSTRAINTWINDOW), false);
+        g_pXWaylandManager->activateSurface(CONSTRAINTWINDOW->m_pWLSurface.wlr(), false);
     }
 
     wlr_pointer_constraint_v1_send_deactivated(g_pCompositor->m_sSeat.mouse->currentConstraint);

src/render/OpenGL.cpp

@@ -772,7 +772,7 @@ void CHyprOpenGLImpl::preRender(CMonitor* pMonitor) {
         if (pWindow->m_sAdditionalConfigData.forceNoBlur)
             return false;
 
-        const auto  PSURFACE = g_pXWaylandManager->getWindowSurface(pWindow);
+        const auto  PSURFACE = pWindow->m_pWLSurface.wlr();
 
         const auto  PWORKSPACE = g_pCompositor->getWorkspaceByID(pWindow->m_iWorkspaceID);
         const float A          = pWindow->m_fAlpha.fl() * pWindow->m_fActiveInactiveAlpha.fl() * PWORKSPACE->m_fAlpha.fl();

src/render/Renderer.cpp

@@ -250,7 +250,7 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, CMonitor* pMonitor, timespec*
     if (ignoreAllGeometry)
         decorate = false;
 
-    renderdata.surface   = g_pXWaylandManager->getWindowSurface(pWindow);
+    renderdata.surface   = pWindow->m_pWLSurface.wlr();
     renderdata.w         = std::max(pWindow->m_vRealSize.vec().x, 5.0); // clamp the size to min 5,
     renderdata.h         = std::max(pWindow->m_vRealSize.vec().y, 5.0); // otherwise we'll have issues later with invalid boxes
     renderdata.dontRound = (pWindow->m_bIsFullscreen && PWORKSPACE->m_efFullscreenMode == FULLSCREEN_FULL) || (!pWindow->m_sSpecialRenderData.rounding);
@@ -313,7 +313,7 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, CMonitor* pMonitor, timespec*
             for (auto& wd : pWindow->m_dWindowDecorations)
                 wd->draw(pMonitor, renderdata.alpha * renderdata.fadeAlpha, offset);
 
-        wlr_surface_for_each_surface(g_pXWaylandManager->getWindowSurface(pWindow), renderSurface, &renderdata);
+        wlr_surface_for_each_surface(pWindow->m_pWLSurface.wlr(), renderSurface, &renderdata);
 
         if (renderdata.decorate && pWindow->m_sSpecialRenderData.border) {
             static auto* const PROUNDING = &g_pConfigManager->getConfigValuePtr("decoration:rounding")->intValue;
@@ -710,7 +710,7 @@ bool CHyprRenderer::attemptDirectScanout(CMonitor* pMonitor) {
     if (surfaceCount != 1)
         return false;
 
-    const auto PSURFACE = g_pXWaylandManager->getWindowSurface(PCANDIDATE);
+    const auto PSURFACE = PCANDIDATE->m_pWLSurface.wlr();
 
     if (!PSURFACE || PSURFACE->current.scale != pMonitor->output->scale || PSURFACE->current.transform != pMonitor->output->transform)
         return false;
@@ -745,7 +745,7 @@ void CHyprRenderer::setWindowScanoutMode(CWindow* pWindow) {
         return;
 
     if (!pWindow->m_bIsFullscreen) {
-        wlr_linux_dmabuf_v1_set_surface_feedback(g_pCompositor->m_sWLRLinuxDMABuf, g_pXWaylandManager->getWindowSurface(pWindow), nullptr);
+        wlr_linux_dmabuf_v1_set_surface_feedback(g_pCompositor->m_sWLRLinuxDMABuf, pWindow->m_pWLSurface.wlr(), nullptr);
         Debug::log(LOG, "Scanout mode OFF set for %x", pWindow);
         return;
     }
@@ -762,7 +762,7 @@ void CHyprRenderer::setWindowScanoutMode(CWindow* pWindow) {
     if (!wlr_linux_dmabuf_feedback_v1_init_with_options(&feedback, &INIT_OPTIONS))
         return;
 
-    wlr_linux_dmabuf_v1_set_surface_feedback(g_pCompositor->m_sWLRLinuxDMABuf, g_pXWaylandManager->getWindowSurface(pWindow), &feedback);
+    wlr_linux_dmabuf_v1_set_surface_feedback(g_pCompositor->m_sWLRLinuxDMABuf, pWindow->m_pWLSurface.wlr(), &feedback);
     wlr_linux_dmabuf_feedback_v1_finish(&feedback);
 
     Debug::log(LOG, "Scanout mode ON set for %x", pWindow);