internal: wrap wlr surfaces (#1822)

src/helpers/SubsurfaceTree.cpp

@@ -3,8 +3,8 @@
 #include "../Compositor.hpp"
 
 void addSurfaceGlobalOffset(SSurfaceTreeNode* node, int* lx, int* ly) {
-    *lx += node->pSurface->current.dx;
-    *ly += node->pSurface->current.dy;
+    *lx += node->pSurface->wlr()->current.dx;
+    *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) {
-                extents.width  = PNODE->pSurface->current.width;
-                extents.height = PNODE->pSurface->current.height;
+            if (PNODE->pSurface && PNODE->pSurface->exists()) {
+                extents.width  = PNODE->pSurface->wlr()->current.width;
+                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);
+};