protocols: refactor class member vars (u-z) (#10282)

* protocols: refactor class member vars (u-z)

* protocols: fix clang format

1 files changed, 308 insertions, 306 deletions

diff --git a/src/protocols/XDGShell.cpp b/src/protocols/XDGShell.cpp
index 6f58ef64..d3d5c18e 100644
--- a/src/protocols/XDGShell.cpp
+++ b/src/protocols/XDGShell.cpp
@@ -26,72 +26,72 @@ void SXDGPositionerState::setGravity(xdgPositionerGravity edges) {
 }
 
 CXDGPopupResource::CXDGPopupResource(SP<CXdgPopup> resource_, SP<CXDGSurfaceResource> owner_, SP<CXDGSurfaceResource> surface_, SP<CXDGPositionerResource> positioner) :
-    surface(surface_), parent(owner_), resource(resource_), positionerRules(positioner) {
+    m_surface(surface_), m_parent(owner_), m_resource(resource_), m_positionerRules(positioner) {
     if UNLIKELY (!good())
         return;
 
-    resource->setData(this);
+    m_resource->setData(this);
 
-    resource->setDestroy([this](CXdgPopup* r) {
-        if (surface && surface->mapped)
-            surface->events.unmap.emit();
-        PROTO::xdgShell->onPopupDestroy(self);
-        events.destroy.emit();
+    m_resource->setDestroy([this](CXdgPopup* r) {
+        if (m_surface && m_surface->m_mapped)
+            m_surface->m_events.unmap.emit();
+        PROTO::xdgShell->onPopupDestroy(m_self);
+        m_events.destroy.emit();
         PROTO::xdgShell->destroyResource(this);
     });
-    resource->setOnDestroy([this](CXdgPopup* r) {
-        if (surface && surface->mapped)
-            surface->events.unmap.emit();
-        PROTO::xdgShell->onPopupDestroy(self);
-        events.destroy.emit();
+    m_resource->setOnDestroy([this](CXdgPopup* r) {
+        if (m_surface && m_surface->m_mapped)
+            m_surface->m_events.unmap.emit();
+        PROTO::xdgShell->onPopupDestroy(m_self);
+        m_events.destroy.emit();
         PROTO::xdgShell->destroyResource(this);
     });
 
-    resource->setReposition([this](CXdgPopup* r, wl_resource* positionerRes, uint32_t token) {
+    m_resource->setReposition([this](CXdgPopup* r, wl_resource* positionerRes, uint32_t token) {
         LOGM(LOG, "Popup {:x} asks for reposition", (uintptr_t)this);
-        lastRepositionToken = token;
-        auto pos            = CXDGPositionerResource::fromResource(positionerRes);
+        m_lastRepositionToken = token;
+        auto pos              = CXDGPositionerResource::fromResource(positionerRes);
         if (!pos)
             return;
-        positionerRules = CXDGPositionerRules{pos};
-        events.reposition.emit();
+        m_positionerRules = CXDGPositionerRules{pos};
+        m_events.reposition.emit();
     });
 
-    resource->setGrab([this](CXdgPopup* r, wl_resource* seat, uint32_t serial) {
+    m_resource->setGrab([this](CXdgPopup* r, wl_resource* seat, uint32_t serial) {
         LOGM(LOG, "xdg_popup {:x} requests grab", (uintptr_t)this);
-        PROTO::xdgShell->addOrStartGrab(self.lock());
+        PROTO::xdgShell->addOrStartGrab(m_self.lock());
     });
 
-    if (parent)
-        taken = true;
+    if (m_parent)
+        m_taken = true;
 }
 
 CXDGPopupResource::~CXDGPopupResource() {
-    PROTO::xdgShell->onPopupDestroy(self);
-    events.destroy.emit();
+    PROTO::xdgShell->onPopupDestroy(m_self);
+    m_events.destroy.emit();
 }
 
 void CXDGPopupResource::applyPositioning(const CBox& box, const Vector2D& t1coord) {
-    CBox constraint = box.copy().translate(surface->pending.geometry.pos());
+    CBox constraint = box.copy().translate(m_surface->m_pending.geometry.pos());
 
-    geometry = positionerRules.getPosition(constraint, accumulateParentOffset() + t1coord);
+    m_geometry = m_positionerRules.getPosition(constraint, accumulateParentOffset() + t1coord);
 
-    LOGM(LOG, "Popup {:x} gets unconstrained to {} {}", (uintptr_t)this, geometry.pos(), geometry.size());
+    LOGM(LOG, "Popup {:x} gets unconstrained to {} {}", (uintptr_t)this, m_geometry.pos(), m_geometry.size());
 
-    configure(geometry);
+    configure(m_geometry);
 
-    if UNLIKELY (lastRepositionToken)
+    if UNLIKELY (m_lastRepositionToken)
         repositioned();
 }
 
 Vector2D CXDGPopupResource::accumulateParentOffset() {
-    SP<CXDGSurfaceResource> current = parent.lock();
+    SP<CXDGSurfaceResource> current = m_parent.lock();
     Vector2D                off;
     while (current) {
-        off += current->current.geometry.pos();
-        if (current->popup) {
-            off += current->popup->geometry.pos();
-            current = current->popup->parent.lock();
+        off += current->m_current.geometry.pos();
+        if (current->m_popup) {
+            off += current->m_popup->m_geometry.pos();
+            current = current->m_popup->m_parent.lock();
         } else
             break;
     }
@@ -100,399 +100,399 @@ Vector2D CXDGPopupResource::accumulateParentOffset() {
 
 SP<CXDGPopupResource> CXDGPopupResource::fromResource(wl_resource* res) {
     auto data = (CXDGPopupResource*)(((CXdgPopup*)wl_resource_get_user_data(res))->data());
-    return data ? data->self.lock() : nullptr;
+    return data ? data->m_self.lock() : nullptr;
 }
 
 bool CXDGPopupResource::good() {
-    return resource->resource();
+    return m_resource->resource();
 }
 
 void CXDGPopupResource::configure(const CBox& box) {
-    resource->sendConfigure(box.x, box.y, box.w, box.h);
-    if (surface)
-        surface->scheduleConfigure();
+    m_resource->sendConfigure(box.x, box.y, box.w, box.h);
+    if (m_surface)
+        m_surface->scheduleConfigure();
 }
 
 void CXDGPopupResource::done() {
-    events.dismissed.emit();
-    resource->sendPopupDone();
+    m_events.dismissed.emit();
+    m_resource->sendPopupDone();
 }
 
 void CXDGPopupResource::repositioned() {
-    if LIKELY (!lastRepositionToken)
+    if LIKELY (!m_lastRepositionToken)
         return;
 
-    LOGM(LOG, "repositioned: sending reposition token {}", lastRepositionToken);
+    LOGM(LOG, "repositioned: sending reposition token {}", m_lastRepositionToken);
 
-    resource->sendRepositioned(lastRepositionToken);
-    lastRepositionToken = 0;
+    m_resource->sendRepositioned(m_lastRepositionToken);
+    m_lastRepositionToken = 0;
 }
 
-CXDGToplevelResource::CXDGToplevelResource(SP<CXdgToplevel> resource_, SP<CXDGSurfaceResource> owner_) : owner(owner_), resource(resource_) {
+CXDGToplevelResource::CXDGToplevelResource(SP<CXdgToplevel> resource_, SP<CXDGSurfaceResource> owner_) : m_owner(owner_), m_resource(resource_) {
     if UNLIKELY (!good())
         return;
 
-    resource->setData(this);
+    m_resource->setData(this);
 
-    resource->setDestroy([this](CXdgToplevel* r) {
-        events.destroy.emit();
+    m_resource->setDestroy([this](CXdgToplevel* r) {
+        m_events.destroy.emit();
         PROTO::xdgShell->destroyResource(this);
     });
-    resource->setOnDestroy([this](CXdgToplevel* r) {
-        events.destroy.emit();
+    m_resource->setOnDestroy([this](CXdgToplevel* r) {
+        m_events.destroy.emit();
         PROTO::xdgShell->destroyResource(this);
     });
 
-    if (resource->version() >= 5) {
+    if (m_resource->version() >= 5) {
         wl_array arr;
         wl_array_init(&arr);
         auto p = (uint32_t*)wl_array_add(&arr, sizeof(uint32_t));
         *p     = XDG_TOPLEVEL_WM_CAPABILITIES_FULLSCREEN;
         p      = (uint32_t*)wl_array_add(&arr, sizeof(uint32_t));
         *p     = XDG_TOPLEVEL_WM_CAPABILITIES_MAXIMIZE;
-        resource->sendWmCapabilities(&arr);
+        m_resource->sendWmCapabilities(&arr);
         wl_array_release(&arr);
     }
 
-    if (resource->version() >= 2) {
-        pendingApply.states.push_back(XDG_TOPLEVEL_STATE_TILED_LEFT);
-        pendingApply.states.push_back(XDG_TOPLEVEL_STATE_TILED_RIGHT);
-        pendingApply.states.push_back(XDG_TOPLEVEL_STATE_TILED_TOP);
-        pendingApply.states.push_back(XDG_TOPLEVEL_STATE_TILED_BOTTOM);
+    if (m_resource->version() >= 2) {
+        m_pendingApply.states.push_back(XDG_TOPLEVEL_STATE_TILED_LEFT);
+        m_pendingApply.states.push_back(XDG_TOPLEVEL_STATE_TILED_RIGHT);
+        m_pendingApply.states.push_back(XDG_TOPLEVEL_STATE_TILED_TOP);
+        m_pendingApply.states.push_back(XDG_TOPLEVEL_STATE_TILED_BOTTOM);
     }
 
-    resource->setSetTitle([this](CXdgToplevel* r, const char* t) {
-        state.title = t;
-        events.metadataChanged.emit();
+    m_resource->setSetTitle([this](CXdgToplevel* r, const char* t) {
+        m_state.title = t;
+        m_events.metadataChanged.emit();
     });
 
-    resource->setSetAppId([this](CXdgToplevel* r, const char* id) {
-        state.appid = id;
-        events.metadataChanged.emit();
+    m_resource->setSetAppId([this](CXdgToplevel* r, const char* id) {
+        m_state.appid = id;
+        m_events.metadataChanged.emit();
     });
 
-    resource->setSetMaxSize([this](CXdgToplevel* r, int32_t x, int32_t y) {
-        pending.maxSize = {x, y};
-        events.sizeLimitsChanged.emit();
+    m_resource->setSetMaxSize([this](CXdgToplevel* r, int32_t x, int32_t y) {
+        m_pending.maxSize = {x, y};
+        m_events.sizeLimitsChanged.emit();
     });
 
-    resource->setSetMinSize([this](CXdgToplevel* r, int32_t x, int32_t y) {
-        pending.minSize = {x, y};
-        events.sizeLimitsChanged.emit();
+    m_resource->setSetMinSize([this](CXdgToplevel* r, int32_t x, int32_t y) {
+        m_pending.minSize = {x, y};
+        m_events.sizeLimitsChanged.emit();
     });
 
-    resource->setSetMaximized([this](CXdgToplevel* r) {
-        state.requestsMaximize = true;
-        events.stateChanged.emit();
-        state.requestsMaximize.reset();
+    m_resource->setSetMaximized([this](CXdgToplevel* r) {
+        m_state.requestsMaximize = true;
+        m_events.stateChanged.emit();
+        m_state.requestsMaximize.reset();
     });
 
-    resource->setUnsetMaximized([this](CXdgToplevel* r) {
-        state.requestsMaximize = false;
-        events.stateChanged.emit();
-        state.requestsMaximize.reset();
+    m_resource->setUnsetMaximized([this](CXdgToplevel* r) {
+        m_state.requestsMaximize = false;
+        m_events.stateChanged.emit();
+        m_state.requestsMaximize.reset();
     });
 
-    resource->setSetFullscreen([this](CXdgToplevel* r, wl_resource* output) {
+    m_resource->setSetFullscreen([this](CXdgToplevel* r, wl_resource* output) {
         if (output)
             if (const auto PM = CWLOutputResource::fromResource(output)->m_monitor; PM)
-                state.requestsFullscreenMonitor = PM->m_id;
+                m_state.requestsFullscreenMonitor = PM->m_id;
 
-        state.requestsFullscreen = true;
-        events.stateChanged.emit();
-        state.requestsFullscreen.reset();
-        state.requestsFullscreenMonitor.reset();
+        m_state.requestsFullscreen = true;
+        m_events.stateChanged.emit();
+        m_state.requestsFullscreen.reset();
+        m_state.requestsFullscreenMonitor.reset();
     });
 
-    resource->setUnsetFullscreen([this](CXdgToplevel* r) {
-        state.requestsFullscreen = false;
-        events.stateChanged.emit();
-        state.requestsFullscreen.reset();
+    m_resource->setUnsetFullscreen([this](CXdgToplevel* r) {
+        m_state.requestsFullscreen = false;
+        m_events.stateChanged.emit();
+        m_state.requestsFullscreen.reset();
     });
 
-    resource->setSetMinimized([this](CXdgToplevel* r) {
-        state.requestsMinimize = true;
-        events.stateChanged.emit();
-        state.requestsMinimize.reset();
+    m_resource->setSetMinimized([this](CXdgToplevel* r) {
+        m_state.requestsMinimize = true;
+        m_events.stateChanged.emit();
+        m_state.requestsMinimize.reset();
     });
 
-    resource->setSetParent([this](CXdgToplevel* r, wl_resource* parentR) {
-        auto oldParent = parent;
+    m_resource->setSetParent([this](CXdgToplevel* r, wl_resource* parentR) {
+        auto oldParent = m_parent;
 
-        if (parent)
-            std::erase(parent->children, self);
+        if (m_parent)
+            std::erase(m_parent->m_children, m_self);
 
         auto newp = parentR ? CXDGToplevelResource::fromResource(parentR) : nullptr;
-        parent    = newp;
+        m_parent  = newp;
 
-        if (parent)
-            parent->children.emplace_back(self);
+        if (m_parent)
+            m_parent->m_children.emplace_back(m_self);
 
         LOGM(LOG, "Toplevel {:x} sets parent to {:x}{}", (uintptr_t)this, (uintptr_t)newp.get(), (oldParent ? std::format(" (was {:x})", (uintptr_t)oldParent.get()) : ""));
     });
 }
 
 CXDGToplevelResource::~CXDGToplevelResource() {
-    events.destroy.emit();
-    if (parent)
-        std::erase_if(parent->children, [this](const auto& other) { return !other || other.get() == this; });
+    m_events.destroy.emit();
+    if (m_parent)
+        std::erase_if(m_parent->m_children, [this](const auto& other) { return !other || other.get() == this; });
 }
 
 SP<CXDGToplevelResource> CXDGToplevelResource::fromResource(wl_resource* res) {
     auto data = (CXDGToplevelResource*)(((CXdgToplevel*)wl_resource_get_user_data(res))->data());
-    return data ? data->self.lock() : nullptr;
+    return data ? data->m_self.lock() : nullptr;
 }
 
 bool CXDGToplevelResource::good() {
-    return resource->resource();
+    return m_resource->resource();
 }
 
 bool CXDGToplevelResource::anyChildModal() {
-    return std::ranges::any_of(children, [](const auto& child) { return child && child->dialog && child->dialog->modal; });
+    return std::ranges::any_of(m_children, [](const auto& child) { return child && child->m_dialog && child->m_dialog->modal; });
 }
 
 uint32_t CXDGToplevelResource::setSize(const Vector2D& size) {
-    pendingApply.size = size;
+    m_pendingApply.size = size;
     applyState();
-    return owner->scheduleConfigure();
+    return m_owner->scheduleConfigure();
 }
 
 uint32_t CXDGToplevelResource::setMaximized(bool maximized) {
-    bool set = std::find(pendingApply.states.begin(), pendingApply.states.end(), XDG_TOPLEVEL_STATE_MAXIMIZED) != pendingApply.states.end();
+    bool set = std::find(m_pendingApply.states.begin(), m_pendingApply.states.end(), XDG_TOPLEVEL_STATE_MAXIMIZED) != m_pendingApply.states.end();
 
     if (maximized == set)
-        return owner->scheduledSerial;
+        return m_owner->m_scheduledSerial;
 
     if (maximized && !set)
-        pendingApply.states.push_back(XDG_TOPLEVEL_STATE_MAXIMIZED);
+        m_pendingApply.states.push_back(XDG_TOPLEVEL_STATE_MAXIMIZED);
     else if (!maximized && set)
-        std::erase(pendingApply.states, XDG_TOPLEVEL_STATE_MAXIMIZED);
+        std::erase(m_pendingApply.states, XDG_TOPLEVEL_STATE_MAXIMIZED);
     applyState();
-    return owner->scheduleConfigure();
+    return m_owner->scheduleConfigure();
 }
 
 uint32_t CXDGToplevelResource::setFullscreen(bool fullscreen) {
-    bool set = std::find(pendingApply.states.begin(), pendingApply.states.end(), XDG_TOPLEVEL_STATE_FULLSCREEN) != pendingApply.states.end();
+    bool set = std::find(m_pendingApply.states.begin(), m_pendingApply.states.end(), XDG_TOPLEVEL_STATE_FULLSCREEN) != m_pendingApply.states.end();
 
     if (fullscreen == set)
-        return owner->scheduledSerial;
+        return m_owner->m_scheduledSerial;
 
     if (fullscreen && !set)
-        pendingApply.states.push_back(XDG_TOPLEVEL_STATE_FULLSCREEN);
+        m_pendingApply.states.push_back(XDG_TOPLEVEL_STATE_FULLSCREEN);
     else if (!fullscreen && set)
-        std::erase(pendingApply.states, XDG_TOPLEVEL_STATE_FULLSCREEN);
+        std::erase(m_pendingApply.states, XDG_TOPLEVEL_STATE_FULLSCREEN);
     applyState();
-    return owner->scheduleConfigure();
+    return m_owner->scheduleConfigure();
 }
 
 uint32_t CXDGToplevelResource::setActive(bool active) {
-    bool set = std::find(pendingApply.states.begin(), pendingApply.states.end(), XDG_TOPLEVEL_STATE_ACTIVATED) != pendingApply.states.end();
+    bool set = std::find(m_pendingApply.states.begin(), m_pendingApply.states.end(), XDG_TOPLEVEL_STATE_ACTIVATED) != m_pendingApply.states.end();
 
     if (active == set)
-        return owner->scheduledSerial;
+        return m_owner->m_scheduledSerial;
 
     if (active && !set)
-        pendingApply.states.push_back(XDG_TOPLEVEL_STATE_ACTIVATED);
+        m_pendingApply.states.push_back(XDG_TOPLEVEL_STATE_ACTIVATED);
     else if (!active && set)
-        std::erase(pendingApply.states, XDG_TOPLEVEL_STATE_ACTIVATED);
+        std::erase(m_pendingApply.states, XDG_TOPLEVEL_STATE_ACTIVATED);
     applyState();
-    return owner->scheduleConfigure();
+    return m_owner->scheduleConfigure();
 }
 
 uint32_t CXDGToplevelResource::setSuspeneded(bool sus) {
-    if (resource->version() < 6)
-        return owner->scheduleConfigure(); // SUSPENDED is since 6
+    if (m_resource->version() < 6)
+        return m_owner->scheduleConfigure(); // SUSPENDED is since 6
 
-    bool set = std::find(pendingApply.states.begin(), pendingApply.states.end(), XDG_TOPLEVEL_STATE_SUSPENDED) != pendingApply.states.end();
+    bool set = std::find(m_pendingApply.states.begin(), m_pendingApply.states.end(), XDG_TOPLEVEL_STATE_SUSPENDED) != m_pendingApply.states.end();
 
     if (sus == set)
-        return owner->scheduledSerial;
+        return m_owner->m_scheduledSerial;
 
     if (sus && !set)
-        pendingApply.states.push_back(XDG_TOPLEVEL_STATE_SUSPENDED);
+        m_pendingApply.states.push_back(XDG_TOPLEVEL_STATE_SUSPENDED);
     else if (!sus && set)
-        std::erase(pendingApply.states, XDG_TOPLEVEL_STATE_SUSPENDED);
+        std::erase(m_pendingApply.states, XDG_TOPLEVEL_STATE_SUSPENDED);
     applyState();
-    return owner->scheduleConfigure();
+    return m_owner->scheduleConfigure();
 }
 
 void CXDGToplevelResource::applyState() {
     wl_array arr;
     wl_array_init(&arr);
 
-    if (!pendingApply.states.empty()) {
-        wl_array_add(&arr, pendingApply.states.size() * sizeof(int));
-        memcpy(arr.data, pendingApply.states.data(), pendingApply.states.size() * sizeof(int));
+    if (!m_pendingApply.states.empty()) {
+        wl_array_add(&arr, m_pendingApply.states.size() * sizeof(int));
+        memcpy(arr.data, m_pendingApply.states.data(), m_pendingApply.states.size() * sizeof(int));
     }
 
-    resource->sendConfigure(pendingApply.size.x, pendingApply.size.y, &arr);
+    m_resource->sendConfigure(m_pendingApply.size.x, m_pendingApply.size.y, &arr);
 
     wl_array_release(&arr);
 }
 
 void CXDGToplevelResource::close() {
-    resource->sendClose();
+    m_resource->sendClose();
 }
 
 Vector2D CXDGToplevelResource::layoutMinSize() {
     Vector2D minSize;
-    if (current.minSize.x > 1)
-        minSize.x = owner ? current.minSize.x + owner->current.geometry.pos().x : current.minSize.x;
-    if (current.minSize.y > 1)
-        minSize.y = owner ? current.minSize.y + owner->current.geometry.pos().y : current.minSize.y;
+    if (m_current.minSize.x > 1)
+        minSize.x = m_owner ? m_current.minSize.x + m_owner->m_current.geometry.pos().x : m_current.minSize.x;
+    if (m_current.minSize.y > 1)
+        minSize.y = m_owner ? m_current.minSize.y + m_owner->m_current.geometry.pos().y : m_current.minSize.y;
     return minSize;
 }
 
 Vector2D CXDGToplevelResource::layoutMaxSize() {
     Vector2D maxSize;
-    if (current.maxSize.x > 1)
-        maxSize.x = owner ? current.maxSize.x + owner->current.geometry.pos().x : current.maxSize.x;
-    if (current.maxSize.y > 1)
-        maxSize.y = owner ? current.maxSize.y + owner->current.geometry.pos().y : current.maxSize.y;
+    if (m_current.maxSize.x > 1)
+        maxSize.x = m_owner ? m_current.maxSize.x + m_owner->m_current.geometry.pos().x : m_current.maxSize.x;
+    if (m_current.maxSize.y > 1)
+        maxSize.y = m_owner ? m_current.maxSize.y + m_owner->m_current.geometry.pos().y : m_current.maxSize.y;
     return maxSize;
 }
 
 CXDGSurfaceResource::CXDGSurfaceResource(SP<CXdgSurface> resource_, SP<CXDGWMBase> owner_, SP<CWLSurfaceResource> surface_) :
-    owner(owner_), surface(surface_), resource(resource_) {
+    m_owner(owner_), m_surface(surface_), m_resource(resource_) {
     if UNLIKELY (!good())
         return;
 
-    resource->setData(this);
+    m_resource->setData(this);
 
-    resource->setDestroy([this](CXdgSurface* r) {
-        if (mapped)
-            events.unmap.emit();
-        events.destroy.emit();
+    m_resource->setDestroy([this](CXdgSurface* r) {
+        if (m_mapped)
+            m_events.unmap.emit();
+        m_events.destroy.emit();
         PROTO::xdgShell->destroyResource(this);
     });
-    resource->setOnDestroy([this](CXdgSurface* r) {
-        if (mapped)
-            events.unmap.emit();
-        events.destroy.emit();
+    m_resource->setOnDestroy([this](CXdgSurface* r) {
+        if (m_mapped)
+            m_events.unmap.emit();
+        m_events.destroy.emit();
         PROTO::xdgShell->destroyResource(this);
     });
 
-    listeners.surfaceDestroy = surface->m_events.destroy.registerListener([this](std::any d) {
+    m_listeners.surfaceDestroy = m_surface->m_events.destroy.registerListener([this](std::any d) {
         LOGM(WARN, "wl_surface destroyed before its xdg_surface role object");
-        listeners.surfaceDestroy.reset();
-        listeners.surfaceCommit.reset();
+        m_listeners.surfaceDestroy.reset();
+        m_listeners.surfaceCommit.reset();
 
-        if (mapped)
-            events.unmap.emit();
+        if (m_mapped)
+            m_events.unmap.emit();
 
-        mapped = false;
-        surface.reset();
-        events.destroy.emit();
+        m_mapped = false;
+        m_surface.reset();
+        m_events.destroy.emit();
     });
 
-    listeners.surfaceCommit = surface->m_events.commit.registerListener([this](std::any d) {
-        current = pending;
-        if (toplevel)
-            toplevel->current = toplevel->pending;
+    m_listeners.surfaceCommit = m_surface->m_events.commit.registerListener([this](std::any d) {
+        m_current = m_pending;
+        if (m_toplevel)
+            m_toplevel->m_current = m_toplevel->m_pending;
 
-        if UNLIKELY (initialCommit && surface->m_pending.buffer) {
-            resource->error(-1, "Buffer attached before initial commit");
+        if UNLIKELY (m_initialCommit && m_surface->m_pending.buffer) {
+            m_resource->error(-1, "Buffer attached before initial commit");
             return;
         }
 
-        if (surface->m_current.texture && !mapped) {
+        if (m_surface->m_current.texture && !m_mapped) {
             // this forces apps to not draw CSD.
-            if (toplevel)
-                toplevel->setMaximized(true);
+            if (m_toplevel)
+                m_toplevel->setMaximized(true);
 
-            mapped = true;
-            surface->map();
-            events.map.emit();
+            m_mapped = true;
+            m_surface->map();
+            m_events.map.emit();
             return;
         }
 
-        if (!surface->m_current.texture && mapped) {
-            mapped = false;
-            events.unmap.emit();
-            surface->unmap();
+        if (!m_surface->m_current.texture && m_mapped) {
+            m_mapped = false;
+            m_events.unmap.emit();
+            m_surface->unmap();
             return;
         }
 
-        events.commit.emit();
-        initialCommit = false;
+        m_events.commit.emit();
+        m_initialCommit = false;
     });
 
-    resource->setGetToplevel([this](CXdgSurface* r, uint32_t id) {
-        const auto RESOURCE = PROTO::xdgShell->m_vToplevels.emplace_back(makeShared<CXDGToplevelResource>(makeShared<CXdgToplevel>(r->client(), r->version(), id), self.lock()));
+    m_resource->setGetToplevel([this](CXdgSurface* r, uint32_t id) {
+        const auto RESOURCE = PROTO::xdgShell->m_toplevels.emplace_back(makeShared<CXDGToplevelResource>(makeShared<CXdgToplevel>(r->client(), r->version(), id), m_self.lock()));
 
         if UNLIKELY (!RESOURCE->good()) {
             r->noMemory();
-            PROTO::xdgShell->m_vToplevels.pop_back();
+            PROTO::xdgShell->m_toplevels.pop_back();
             return;
         }
 
-        toplevel       = RESOURCE;
-        toplevel->self = RESOURCE;
+        m_toplevel         = RESOURCE;
+        m_toplevel->m_self = RESOURCE;
 
-        LOGM(LOG, "xdg_surface {:x} gets a toplevel {:x}", (uintptr_t)owner.get(), (uintptr_t)RESOURCE.get());
+        LOGM(LOG, "xdg_surface {:x} gets a toplevel {:x}", (uintptr_t)m_owner.get(), (uintptr_t)RESOURCE.get());
 
-        g_pCompositor->m_windows.emplace_back(CWindow::create(self.lock()));
+        g_pCompositor->m_windows.emplace_back(CWindow::create(m_self.lock()));
 
-        for (auto const& p : popups) {
+        for (auto const& p : m_popups) {
             if (!p)
                 continue;
-            events.newPopup.emit(p);
+            m_events.newPopup.emit(p);
         }
     });
 
-    resource->setGetPopup([this](CXdgSurface* r, uint32_t id, wl_resource* parentXDG, wl_resource* positionerRes) {
+    m_resource->setGetPopup([this](CXdgSurface* r, uint32_t id, wl_resource* parentXDG, wl_resource* positionerRes) {
         auto       parent     = parentXDG ? CXDGSurfaceResource::fromResource(parentXDG) : nullptr;
         auto       positioner = CXDGPositionerResource::fromResource(positionerRes);
         const auto RESOURCE =
-            PROTO::xdgShell->m_vPopups.emplace_back(makeShared<CXDGPopupResource>(makeShared<CXdgPopup>(r->client(), r->version(), id), parent, self.lock(), positioner));
+            PROTO::xdgShell->m_popups.emplace_back(makeShared<CXDGPopupResource>(makeShared<CXdgPopup>(r->client(), r->version(), id), parent, m_self.lock(), positioner));
 
         if UNLIKELY (!RESOURCE->good()) {
             r->noMemory();
-            PROTO::xdgShell->m_vPopups.pop_back();
+            PROTO::xdgShell->m_popups.pop_back();
             return;
         }
 
-        popup          = RESOURCE;
-        RESOURCE->self = RESOURCE;
+        m_popup          = RESOURCE;
+        RESOURCE->m_self = RESOURCE;
 
-        LOGM(LOG, "xdg_surface {:x} gets a popup {:x} owner {:x}", (uintptr_t)self.get(), (uintptr_t)RESOURCE.get(), (uintptr_t)parent.get());
+        LOGM(LOG, "xdg_surface {:x} gets a popup {:x} owner {:x}", (uintptr_t)m_self.get(), (uintptr_t)RESOURCE.get(), (uintptr_t)parent.get());
 
         if (!parent)
             return;
 
-        parent->popups.emplace_back(RESOURCE);
-        if (parent->mapped)
-            parent->events.newPopup.emit(RESOURCE);
+        parent->m_popups.emplace_back(RESOURCE);
+        if (parent->m_mapped)
+            parent->m_events.newPopup.emit(RESOURCE);
     });
 
-    resource->setAckConfigure([this](CXdgSurface* r, uint32_t serial) {
-        if (serial < lastConfigureSerial)
+    m_resource->setAckConfigure([this](CXdgSurface* r, uint32_t serial) {
+        if (serial < m_lastConfigureSerial)
             return;
-        lastConfigureSerial = serial;
-        events.ack.emit(serial);
+        m_lastConfigureSerial = serial;
+        m_events.ack.emit(serial);
     });
 
-    resource->setSetWindowGeometry([this](CXdgSurface* r, int32_t x, int32_t y, int32_t w, int32_t h) {
+    m_resource->setSetWindowGeometry([this](CXdgSurface* r, int32_t x, int32_t y, int32_t w, int32_t h) {
         LOGM(LOG, "xdg_surface {:x} requests geometry {}x{} {}x{}", (uintptr_t)this, x, y, w, h);
-        pending.geometry = {x, y, w, h};
+        m_pending.geometry = {x, y, w, h};
     });
 }
 
 CXDGSurfaceResource::~CXDGSurfaceResource() {
-    events.destroy.emit();
-    if (configureSource)
-        wl_event_source_remove(configureSource);
-    if (surface)
-        surface->resetRole();
+    m_events.destroy.emit();
+    if (m_configureSource)
+        wl_event_source_remove(m_configureSource);
+    if (m_surface)
+        m_surface->resetRole();
 }
 
 bool CXDGSurfaceResource::good() {
-    return resource->resource();
+    return m_resource->resource();
 }
 
 SP<CXDGSurfaceResource> CXDGSurfaceResource::fromResource(wl_resource* res) {
     auto data = (CXDGSurfaceResource*)(((CXdgSurface*)wl_resource_get_user_data(res))->data());
-    return data ? data->self.lock() : nullptr;
+    return data ? data->m_self.lock() : nullptr;
 }
 
 static void onConfigure(void* data) {
@@ -500,54 +500,54 @@ static void onConfigure(void* data) {
 }
 
 uint32_t CXDGSurfaceResource::scheduleConfigure() {
-    if (configureSource)
-        return scheduledSerial;
+    if (m_configureSource)
+        return m_scheduledSerial;
 
-    configureSource = wl_event_loop_add_idle(g_pCompositor->m_wlEventLoop, onConfigure, this);
-    scheduledSerial = wl_display_next_serial(g_pCompositor->m_wlDisplay);
+    m_configureSource = wl_event_loop_add_idle(g_pCompositor->m_wlEventLoop, onConfigure, this);
+    m_scheduledSerial = wl_display_next_serial(g_pCompositor->m_wlDisplay);
 
-    return scheduledSerial;
+    return m_scheduledSerial;
 }
 
 void CXDGSurfaceResource::configure() {
-    configureSource = nullptr;
-    resource->sendConfigure(scheduledSerial);
+    m_configureSource = nullptr;
+    m_resource->sendConfigure(m_scheduledSerial);
 }
 
-CXDGPositionerResource::CXDGPositionerResource(SP<CXdgPositioner> resource_, SP<CXDGWMBase> owner_) : owner(owner_), resource(resource_) {
+CXDGPositionerResource::CXDGPositionerResource(SP<CXdgPositioner> resource_, SP<CXDGWMBase> owner_) : m_owner(owner_), m_resource(resource_) {
     if UNLIKELY (!good())
         return;
 
-    resource->setData(this);
+    m_resource->setData(this);
 
-    resource->setDestroy([this](CXdgPositioner* r) { PROTO::xdgShell->destroyResource(this); });
-    resource->setOnDestroy([this](CXdgPositioner* r) { PROTO::xdgShell->destroyResource(this); });
+    m_resource->setDestroy([this](CXdgPositioner* r) { PROTO::xdgShell->destroyResource(this); });
+    m_resource->setOnDestroy([this](CXdgPositioner* r) { PROTO::xdgShell->destroyResource(this); });
 
-    resource->setSetSize([this](CXdgPositioner* r, int32_t x, int32_t y) {
+    m_resource->setSetSize([this](CXdgPositioner* r, int32_t x, int32_t y) {
         if UNLIKELY (x <= 0 || y <= 0) {
             r->error(XDG_POSITIONER_ERROR_INVALID_INPUT, "Invalid size");
             return;
         }
 
-        state.requestedSize = {x, y};
+        m_state.requestedSize = {x, y};
     });
 
-    resource->setSetAnchorRect([this](CXdgPositioner* r, int32_t x, int32_t y, int32_t w, int32_t h) {
+    m_resource->setSetAnchorRect([this](CXdgPositioner* r, int32_t x, int32_t y, int32_t w, int32_t h) {
         if UNLIKELY (w <= 0 || h <= 0) {
             r->error(XDG_POSITIONER_ERROR_INVALID_INPUT, "Invalid box");
             return;
         }
 
-        state.anchorRect = {x, y, w, h};
+        m_state.anchorRect = {x, y, w, h};
     });
 
-    resource->setSetOffset([this](CXdgPositioner* r, int32_t x, int32_t y) { state.offset = {x, y}; });
+    m_resource->setSetOffset([this](CXdgPositioner* r, int32_t x, int32_t y) { m_state.offset = {x, y}; });
 
-    resource->setSetAnchor([this](CXdgPositioner* r, xdgPositionerAnchor a) { state.setAnchor(a); });
+    m_resource->setSetAnchor([this](CXdgPositioner* r, xdgPositionerAnchor a) { m_state.setAnchor(a); });
 
-    resource->setSetGravity([this](CXdgPositioner* r, xdgPositionerGravity g) { state.setGravity(g); });
+    m_resource->setSetGravity([this](CXdgPositioner* r, xdgPositionerGravity g) { m_state.setGravity(g); });
 
-    resource->setSetConstraintAdjustment([this](CXdgPositioner* r, xdgPositionerConstraintAdjustment a) { state.constraintAdjustment = (uint32_t)a; });
+    m_resource->setSetConstraintAdjustment([this](CXdgPositioner* r, xdgPositionerConstraintAdjustment a) { m_state.constraintAdjustment = (uint32_t)a; });
 
     // TODO: support this shit better. The current impl _works_, but is lacking and could be wrong in a few cases.
     // doesn't matter _that_ much for now, though.
@@ -555,14 +555,14 @@ CXDGPositionerResource::CXDGPositionerResource(SP<CXdgPositioner> resource_, SP<
 
 SP<CXDGPositionerResource> CXDGPositionerResource::fromResource(wl_resource* res) {
     auto data = (CXDGPositionerResource*)(((CXdgPositioner*)wl_resource_get_user_data(res))->data());
-    return data ? data->self.lock() : nullptr;
+    return data ? data->m_self.lock() : nullptr;
 }
 
 bool CXDGPositionerResource::good() {
-    return resource->resource();
+    return m_resource->resource();
 }
 
-CXDGPositionerRules::CXDGPositionerRules(SP<CXDGPositionerResource> positioner) : state(positioner->state) {
+CXDGPositionerRules::CXDGPositionerRules(SP<CXDGPositionerResource> positioner) : m_state(positioner->m_state) {
     ;
 }
 
@@ -572,20 +572,20 @@ CBox CXDGPositionerRules::getPosition(CBox constraint, const Vector2D& parentCoo
     // padding
     constraint.expand(-4);
 
-    auto anchorRect = state.anchorRect.copy().translate(parentCoord);
+    auto anchorRect = m_state.anchorRect.copy().translate(parentCoord);
 
-    auto width   = state.requestedSize.x;
-    auto height  = state.requestedSize.y;
-    auto gravity = state.gravity;
+    auto width   = m_state.requestedSize.x;
+    auto height  = m_state.requestedSize.y;
+    auto gravity = m_state.gravity;
 
-    auto anchorX = state.anchor.left() ? anchorRect.x : state.anchor.right() ? anchorRect.extent().x : anchorRect.middle().x;
-    auto anchorY = state.anchor.top() ? anchorRect.y : state.anchor.bottom() ? anchorRect.extent().y : anchorRect.middle().y;
+    auto anchorX = m_state.anchor.left() ? anchorRect.x : m_state.anchor.right() ? anchorRect.extent().x : anchorRect.middle().x;
+    auto anchorY = m_state.anchor.top() ? anchorRect.y : m_state.anchor.bottom() ? anchorRect.extent().y : anchorRect.middle().y;
 
     auto calcEffectiveX = [&](CEdges anchorGravity, double anchorX) { return anchorGravity.left() ? anchorX - width : anchorGravity.right() ? anchorX : anchorX - width / 2; };
     auto calcEffectiveY = [&](CEdges anchorGravity, double anchorY) { return anchorGravity.top() ? anchorY - height : anchorGravity.bottom() ? anchorY : anchorY - height / 2; };
 
     auto calcRemainingWidth = [&](double effectiveX) {
-        auto width = state.requestedSize.x;
+        auto width = m_state.requestedSize.x;
         if (effectiveX < constraint.x) {
             auto diff  = constraint.x - effectiveX;
             effectiveX = constraint.x;
@@ -600,7 +600,7 @@ CBox CXDGPositionerRules::getPosition(CBox constraint, const Vector2D& parentCoo
     };
 
     auto calcRemainingHeight = [&](double effectiveY) {
-        auto height = state.requestedSize.y;
+        auto height = m_state.requestedSize.y;
         if (effectiveY < constraint.y) {
             auto diff  = constraint.y - effectiveY;
             effectiveY = constraint.y;
@@ -621,12 +621,12 @@ CBox CXDGPositionerRules::getPosition(CBox constraint, const Vector2D& parentCoo
     // It considers the offset when deciding whether or not to flip but does not actually flip the offset, instead
     // applying it after the flip step.
 
-    if (state.constraintAdjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_X) {
-        auto flip = (gravity.left() && effectiveX + state.offset.x < constraint.x) || (gravity.right() && effectiveX + state.offset.x + width > constraint.extent().x);
+    if (m_state.constraintAdjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_X) {
+        auto flip = (gravity.left() && effectiveX + m_state.offset.x < constraint.x) || (gravity.right() && effectiveX + m_state.offset.x + width > constraint.extent().x);
 
         if (flip) {
             auto newGravity    = gravity ^ (CEdges::LEFT | CEdges::RIGHT);
-            auto newAnchorX    = state.anchor.left() ? anchorRect.extent().x : state.anchor.right() ? anchorRect.x : anchorX;
+            auto newAnchorX    = m_state.anchor.left() ? anchorRect.extent().x : m_state.anchor.right() ? anchorRect.x : anchorX;
             auto newEffectiveX = calcEffectiveX(newGravity, newAnchorX);
 
             if (calcRemainingWidth(newEffectiveX).second > calcRemainingWidth(effectiveX).second) {
@@ -637,12 +637,13 @@ CBox CXDGPositionerRules::getPosition(CBox constraint, const Vector2D& parentCoo
         }
     }
 
-    if (state.constraintAdjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_Y) {
-        auto flip = (state.gravity.top() && effectiveY + state.offset.y < constraint.y) || (state.gravity.bottom() && effectiveY + state.offset.y + height > constraint.extent().y);
+    if (m_state.constraintAdjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_Y) {
+        auto flip =
+            (m_state.gravity.top() && effectiveY + m_state.offset.y < constraint.y) || (m_state.gravity.bottom() && effectiveY + m_state.offset.y + height > constraint.extent().y);
 
         if (flip) {
             auto newGravity    = gravity ^ (CEdges::TOP | CEdges::BOTTOM);
-            auto newAnchorY    = state.anchor.top() ? anchorRect.extent().y : state.anchor.bottom() ? anchorRect.y : anchorY;
+            auto newAnchorY    = m_state.anchor.top() ? anchorRect.extent().y : m_state.anchor.bottom() ? anchorRect.y : anchorY;
             auto newEffectiveY = calcEffectiveY(newGravity, newAnchorY);
 
             if (calcRemainingHeight(newEffectiveY).second > calcRemainingHeight(effectiveY).second) {
@@ -653,12 +654,12 @@ CBox CXDGPositionerRules::getPosition(CBox constraint, const Vector2D& parentCoo
         }
     }
 
-    effectiveX += state.offset.x;
-    effectiveY += state.offset.y;
+    effectiveX += m_state.offset.x;
+    effectiveY += m_state.offset.y;
 
     // Slide order is important for the case where the window is too large to fit on screen.
 
-    if (state.constraintAdjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_X) {
+    if (m_state.constraintAdjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_X) {
         if (effectiveX + width > constraint.extent().x)
             effectiveX = constraint.extent().x - width;
 
@@ -666,7 +667,7 @@ CBox CXDGPositionerRules::getPosition(CBox constraint, const Vector2D& parentCoo
             effectiveX = constraint.x;
     }
 
-    if (state.constraintAdjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_Y) {
+    if (m_state.constraintAdjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_Y) {
         if (effectiveY + height > constraint.extent().y)
             effectiveY = constraint.extent().y - height;
 
@@ -674,13 +675,13 @@ CBox CXDGPositionerRules::getPosition(CBox constraint, const Vector2D& parentCoo
             effectiveY = constraint.y;
     }
 
-    if (state.constraintAdjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_X) {
+    if (m_state.constraintAdjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_X) {
         auto [newX, newWidth] = calcRemainingWidth(effectiveX);
         effectiveX            = newX;
         width                 = newWidth;
     }
 
-    if (state.constraintAdjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_Y) {
+    if (m_state.constraintAdjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_Y) {
         auto [newY, newHeight] = calcRemainingHeight(effectiveY);
         effectiveY             = newY;
         height                 = newHeight;
@@ -689,33 +690,33 @@ CBox CXDGPositionerRules::getPosition(CBox constraint, const Vector2D& parentCoo
     return {effectiveX - parentCoord.x, effectiveY - parentCoord.y, width, height};
 }
 
-CXDGWMBase::CXDGWMBase(SP<CXdgWmBase> resource_) : resource(resource_) {
+CXDGWMBase::CXDGWMBase(SP<CXdgWmBase> resource_) : m_resource(resource_) {
     if UNLIKELY (!good())
         return;
 
-    resource->setDestroy([this](CXdgWmBase* r) { PROTO::xdgShell->destroyResource(this); });
-    resource->setOnDestroy([this](CXdgWmBase* r) { PROTO::xdgShell->destroyResource(this); });
+    m_resource->setDestroy([this](CXdgWmBase* r) { PROTO::xdgShell->destroyResource(this); });
+    m_resource->setOnDestroy([this](CXdgWmBase* r) { PROTO::xdgShell->destroyResource(this); });
 
-    pClient = resource->client();
+    m_client = m_resource->client();
 
-    resource->setCreatePositioner([this](CXdgWmBase* r, uint32_t id) {
+    m_resource->setCreatePositioner([this](CXdgWmBase* r, uint32_t id) {
         const auto RESOURCE =
-            PROTO::xdgShell->m_vPositioners.emplace_back(makeShared<CXDGPositionerResource>(makeShared<CXdgPositioner>(r->client(), r->version(), id), self.lock()));
+            PROTO::xdgShell->m_positioners.emplace_back(makeShared<CXDGPositionerResource>(makeShared<CXdgPositioner>(r->client(), r->version(), id), m_self.lock()));
 
         if UNLIKELY (!RESOURCE->good()) {
             r->noMemory();
-            PROTO::xdgShell->m_vPositioners.pop_back();
+            PROTO::xdgShell->m_positioners.pop_back();
             return;
         }
 
-        RESOURCE->self = RESOURCE;
+        RESOURCE->m_self = RESOURCE;
 
-        positioners.emplace_back(RESOURCE);
+        m_positioners.emplace_back(RESOURCE);
 
         LOGM(LOG, "New xdg_positioner at {:x}", (uintptr_t)RESOURCE.get());
     });
 
-    resource->setGetXdgSurface([this](CXdgWmBase* r, uint32_t id, wl_resource* surf) {
+    m_resource->setGetXdgSurface([this](CXdgWmBase* r, uint32_t id, wl_resource* surf) {
         auto SURF = CWLSurfaceResource::fromResource(surf);
 
         if UNLIKELY (!SURF) {
@@ -728,123 +729,124 @@ CXDGWMBase::CXDGWMBase(SP<CXdgWmBase> resource_) : resource(resource_) {
             return;
         }
 
-        const auto RESOURCE = PROTO::xdgShell->m_vSurfaces.emplace_back(makeShared<CXDGSurfaceResource>(makeShared<CXdgSurface>(r->client(), r->version(), id), self.lock(), SURF));
+        const auto RESOURCE =
+            PROTO::xdgShell->m_surfaces.emplace_back(makeShared<CXDGSurfaceResource>(makeShared<CXdgSurface>(r->client(), r->version(), id), m_self.lock(), SURF));
 
         if UNLIKELY (!RESOURCE->good()) {
             r->noMemory();
-            PROTO::xdgShell->m_vSurfaces.pop_back();
+            PROTO::xdgShell->m_surfaces.pop_back();
             return;
         }
 
-        RESOURCE->self    = RESOURCE;
-        RESOURCE->surface = SURF;
-        SURF->m_role      = makeShared<CXDGSurfaceRole>(RESOURCE);
+        RESOURCE->m_self    = RESOURCE;
+        RESOURCE->m_surface = SURF;
+        SURF->m_role        = makeShared<CXDGSurfaceRole>(RESOURCE);
 
-        surfaces.emplace_back(RESOURCE);
+        m_surfaces.emplace_back(RESOURCE);
 
         LOGM(LOG, "New xdg_surface at {:x}", (uintptr_t)RESOURCE.get());
     });
 
-    resource->setPong([this](CXdgWmBase* r, uint32_t serial) {
-        g_pANRManager->onResponse(self.lock());
-        events.pong.emit();
+    m_resource->setPong([this](CXdgWmBase* r, uint32_t serial) {
+        g_pANRManager->onResponse(m_self.lock());
+        m_events.pong.emit();
     });
 }
 
 bool CXDGWMBase::good() {
-    return resource->resource();
+    return m_resource->resource();
 }
 
 wl_client* CXDGWMBase::client() {
-    return pClient;
+    return m_client;
 }
 
 void CXDGWMBase::ping() {
-    resource->sendPing(1337);
+    m_resource->sendPing(1337);
 }
 
 CXDGShellProtocol::CXDGShellProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) {
-    grab             = makeShared<CSeatGrab>();
-    grab->m_keyboard = true;
-    grab->m_pointer  = true;
-    grab->setCallback([this]() {
-        for (auto const& g : grabbed) {
+    m_grab             = makeShared<CSeatGrab>();
+    m_grab->m_keyboard = true;
+    m_grab->m_pointer  = true;
+    m_grab->setCallback([this]() {
+        for (auto const& g : m_grabbed) {
             g->done();
         }
-        grabbed.clear();
+        m_grabbed.clear();
     });
 }
 
 void CXDGShellProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
-    const auto RESOURCE = m_vWMBases.emplace_back(makeShared<CXDGWMBase>(makeShared<CXdgWmBase>(client, ver, id)));
+    const auto RESOURCE = m_wmBases.emplace_back(makeShared<CXDGWMBase>(makeShared<CXdgWmBase>(client, ver, id)));
 
     if UNLIKELY (!RESOURCE->good()) {
         wl_client_post_no_memory(client);
-        m_vWMBases.pop_back();
+        m_wmBases.pop_back();
         return;
     }
 
-    RESOURCE->self = RESOURCE;
+    RESOURCE->m_self = RESOURCE;
 
     LOGM(LOG, "New xdg_wm_base at {:x}", (uintptr_t)RESOURCE.get());
 }
 
 void CXDGShellProtocol::destroyResource(CXDGWMBase* resource) {
-    std::erase_if(m_vWMBases, [&](const auto& other) { return other.get() == resource; });
+    std::erase_if(m_wmBases, [&](const auto& other) { return other.get() == resource; });
 }
 
 void CXDGShellProtocol::destroyResource(CXDGPositionerResource* resource) {
-    std::erase_if(m_vPositioners, [&](const auto& other) { return other.get() == resource; });
+    std::erase_if(m_positioners, [&](const auto& other) { return other.get() == resource; });
 }
 
 void CXDGShellProtocol::destroyResource(CXDGSurfaceResource* resource) {
-    std::erase_if(m_vSurfaces, [&](const auto& other) { return other.get() == resource; });
+    std::erase_if(m_surfaces, [&](const auto& other) { return other.get() == resource; });
 }
 
 void CXDGShellProtocol::destroyResource(CXDGToplevelResource* resource) {
-    std::erase_if(m_vToplevels, [&](const auto& other) { return other.get() == resource; });
+    std::erase_if(m_toplevels, [&](const auto& other) { return other.get() == resource; });
 }
 
 void CXDGShellProtocol::destroyResource(CXDGPopupResource* resource) {
-    std::erase_if(m_vPopups, [&](const auto& other) { return other.get() == resource; });
+    std::erase_if(m_popups, [&](const auto& other) { return other.get() == resource; });
 }
 
 void CXDGShellProtocol::addOrStartGrab(SP<CXDGPopupResource> popup) {
-    if (!grabOwner) {
-        grabOwner = popup;
-        grabbed.clear();
-        grab->clear();
-        grab->add(popup->surface->surface.lock());
-        if (popup->parent)
-            grab->add(popup->parent->surface.lock());
-        g_pSeatManager->setGrab(grab);
-        grabbed.emplace_back(popup);
+    if (!m_grabOwner) {
+        m_grabOwner = popup;
+        m_grabbed.clear();
+        m_grab->clear();
+        m_grab->add(popup->m_surface->m_surface.lock());
+        if (popup->m_parent)
+            m_grab->add(popup->m_parent->m_surface.lock());
+        g_pSeatManager->setGrab(m_grab);
+        m_grabbed.emplace_back(popup);
         return;
     }
 
-    grabbed.emplace_back(popup);
+    m_grabbed.emplace_back(popup);
 
-    grab->add(popup->surface->surface.lock());
+    m_grab->add(popup->m_surface->m_surface.lock());
 
-    if (popup->parent)
-        grab->add(popup->parent->surface.lock());
+    if (popup->m_parent)
+        m_grab->add(popup->m_parent->m_surface.lock());
 }
 
 void CXDGShellProtocol::onPopupDestroy(WP<CXDGPopupResource> popup) {
-    if (popup == grabOwner) {
+    if (popup == m_grabOwner) {
         g_pSeatManager->setGrab(nullptr);
-        for (auto const& g : grabbed) {
+        for (auto const& g : m_grabbed) {
             g->done();
         }
-        grabbed.clear();
+        m_grabbed.clear();
         return;
     }
 
-    std::erase(grabbed, popup);
-    if (popup->surface)
-        grab->remove(popup->surface->surface.lock());
+    std::erase(m_grabbed, popup);
+    if (popup->m_surface)
+        m_grab->remove(popup->m_surface->m_surface.lock());
 }
 
-CXDGSurfaceRole::CXDGSurfaceRole(SP<CXDGSurfaceResource> xdg) : xdgSurface(xdg) {
+CXDGSurfaceRole::CXDGSurfaceRole(SP<CXDGSurfaceResource> xdg) : m_xdgSurface(xdg) {
     ;
 }