From 02d7badd15601e52547e2f3e1c594ceede0a0455 Mon Sep 17 00:00:00 2001 From: davc0n Date: Fri, 25 Apr 2025 02:37:12 +0200 Subject: workspaces: refactor class member vars (#10167) --- src/desktop/WLSurface.cpp | 154 +++++++++++++++++++++++----------------------- 1 file changed, 77 insertions(+), 77 deletions(-) (limited to 'src/desktop/WLSurface.cpp') diff --git a/src/desktop/WLSurface.cpp b/src/desktop/WLSurface.cpp index ef62bc7a..5d0a32de 100644 --- a/src/desktop/WLSurface.cpp +++ b/src/desktop/WLSurface.cpp @@ -6,37 +6,37 @@ #include "../render/Renderer.hpp" void CWLSurface::assign(SP pSurface) { - m_pResource = pSurface; + m_resource = pSurface; init(); - m_bInert = false; + m_inert = false; } void CWLSurface::assign(SP pSurface, PHLWINDOW pOwner) { - m_pWindowOwner = pOwner; - m_pResource = pSurface; + m_windowOwner = pOwner; + m_resource = pSurface; init(); - m_bInert = false; + m_inert = false; } void CWLSurface::assign(SP pSurface, PHLLS pOwner) { - m_pLayerOwner = pOwner; - m_pResource = pSurface; + m_layerOwner = pOwner; + m_resource = pSurface; init(); - m_bInert = false; + m_inert = false; } void CWLSurface::assign(SP pSurface, CSubsurface* pOwner) { - m_pSubsurfaceOwner = pOwner; - m_pResource = pSurface; + m_subsurfaceOwner = pOwner; + m_resource = pSurface; init(); - m_bInert = false; + m_inert = false; } void CWLSurface::assign(SP pSurface, CPopup* pOwner) { - m_pPopupOwner = pOwner; - m_pResource = pSurface; + m_popupOwner = pOwner; + m_resource = pSurface; init(); - m_bInert = false; + m_inert = false; } void CWLSurface::unassign() { @@ -48,66 +48,66 @@ CWLSurface::~CWLSurface() { } bool CWLSurface::exists() const { - return m_pResource; + return m_resource; } SP CWLSurface::resource() const { - return m_pResource.lock(); + return m_resource.lock(); } bool CWLSurface::small() const { - if (!validMapped(m_pWindowOwner) || !exists()) + if (!validMapped(m_windowOwner) || !exists()) return false; - if (!m_pResource->current.texture) + if (!m_resource->current.texture) return false; - const auto O = m_pWindowOwner.lock(); + const auto O = m_windowOwner.lock(); - return O->m_vReportedSize.x > m_pResource->current.size.x + 1 || O->m_vReportedSize.y > m_pResource->current.size.y + 1; + return O->m_vReportedSize.x > m_resource->current.size.x + 1 || O->m_vReportedSize.y > m_resource->current.size.y + 1; } Vector2D CWLSurface::correctSmallVec() const { - if (!validMapped(m_pWindowOwner) || !exists() || !small() || m_bFillIgnoreSmall) + if (!validMapped(m_windowOwner) || !exists() || !small() || m_fillIgnoreSmall) return {}; const auto SIZE = getViewporterCorrectedSize(); - const auto O = m_pWindowOwner.lock(); + const auto O = m_windowOwner.lock(); return Vector2D{(O->m_vReportedSize.x - SIZE.x) / 2, (O->m_vReportedSize.y - SIZE.y) / 2}.clamp({}, {INFINITY, INFINITY}) * (O->m_vRealSize->value() / O->m_vReportedSize); } Vector2D CWLSurface::correctSmallVecBuf() const { - if (!exists() || !small() || m_bFillIgnoreSmall || !m_pResource->current.texture) + if (!exists() || !small() || m_fillIgnoreSmall || !m_resource->current.texture) return {}; const auto SIZE = getViewporterCorrectedSize(); - const auto BS = m_pResource->current.bufferSize; + const auto BS = m_resource->current.bufferSize; return Vector2D{(BS.x - SIZE.x) / 2, (BS.y - SIZE.y) / 2}.clamp({}, {INFINITY, INFINITY}); } Vector2D CWLSurface::getViewporterCorrectedSize() const { - if (!exists() || !m_pResource->current.texture) + if (!exists() || !m_resource->current.texture) return {}; - return m_pResource->current.viewport.hasDestination ? m_pResource->current.viewport.destination : m_pResource->current.bufferSize; + return m_resource->current.viewport.hasDestination ? m_resource->current.viewport.destination : m_resource->current.bufferSize; } CRegion CWLSurface::computeDamage() const { - if (!m_pResource->current.texture) + if (!m_resource->current.texture) return {}; - CRegion damage = m_pResource->current.accumulateBufferDamage(); - damage.transform(wlTransformToHyprutils(m_pResource->current.transform), m_pResource->current.bufferSize.x, m_pResource->current.bufferSize.y); + CRegion damage = m_resource->current.accumulateBufferDamage(); + damage.transform(wlTransformToHyprutils(m_resource->current.transform), m_resource->current.bufferSize.x, m_resource->current.bufferSize.y); - const auto BUFSIZE = m_pResource->current.bufferSize; + const auto BUFSIZE = m_resource->current.bufferSize; const auto CORRECTVEC = correctSmallVecBuf(); - if (m_pResource->current.viewport.hasSource) - damage.intersect(m_pResource->current.viewport.source); + if (m_resource->current.viewport.hasSource) + damage.intersect(m_resource->current.viewport.source); - const auto SCALEDSRCSIZE = m_pResource->current.viewport.hasSource ? m_pResource->current.viewport.source.size() * m_pResource->current.scale : m_pResource->current.bufferSize; + const auto SCALEDSRCSIZE = m_resource->current.viewport.hasSource ? m_resource->current.viewport.source.size() * m_resource->current.scale : m_resource->current.bufferSize; damage.scale({BUFSIZE.x / SCALEDSRCSIZE.x, BUFSIZE.y / SCALEDSRCSIZE.y}); damage.translate(CORRECTVEC); @@ -115,107 +115,107 @@ CRegion CWLSurface::computeDamage() const { // go from buffer coords in the damage to hl logical const auto BOX = getSurfaceBoxGlobal(); - const Vector2D SCALE = BOX.has_value() ? BOX->size() / m_pResource->current.bufferSize : - Vector2D{1.0 / m_pResource->current.scale, 1.0 / m_pResource->current.scale /* Wrong... but we can't really do better */}; + const Vector2D SCALE = BOX.has_value() ? BOX->size() / m_resource->current.bufferSize : + Vector2D{1.0 / m_resource->current.scale, 1.0 / m_resource->current.scale /* Wrong... but we can't really do better */}; damage.scale(SCALE); - if (m_pWindowOwner) - damage.scale(m_pWindowOwner->m_fX11SurfaceScaledBy); // fix xwayland:force_zero_scaling stuff that will be fucked by the above a bit + if (m_windowOwner) + damage.scale(m_windowOwner->m_fX11SurfaceScaledBy); // fix xwayland:force_zero_scaling stuff that will be fucked by the above a bit return damage; } void CWLSurface::destroy() { - if (!m_pResource) + if (!m_resource) return; - events.destroy.emit(); + m_events.destroy.emit(); - m_pConstraint.reset(); + m_constraint.reset(); - listeners.destroy.reset(); - m_pResource->hlSurface.reset(); - m_pWindowOwner.reset(); - m_pLayerOwner.reset(); - m_pPopupOwner = nullptr; - m_pSubsurfaceOwner = nullptr; - m_bInert = true; + m_listeners.destroy.reset(); + m_resource->hlSurface.reset(); + m_windowOwner.reset(); + m_layerOwner.reset(); + m_popupOwner = nullptr; + m_subsurfaceOwner = nullptr; + m_inert = true; if (g_pHyprRenderer && g_pHyprRenderer->m_sLastCursorData.surf && g_pHyprRenderer->m_sLastCursorData.surf->get() == this) g_pHyprRenderer->m_sLastCursorData.surf.reset(); - m_pResource.reset(); + m_resource.reset(); Debug::log(LOG, "CWLSurface {:x} called destroy()", (uintptr_t)this); } void CWLSurface::init() { - if (!m_pResource) + if (!m_resource) return; - RASSERT(!m_pResource->hlSurface, "Attempted to duplicate CWLSurface ownership!"); + RASSERT(!m_resource->hlSurface, "Attempted to duplicate CWLSurface ownership!"); - m_pResource->hlSurface = self.lock(); + m_resource->hlSurface = m_self.lock(); - listeners.destroy = m_pResource->events.destroy.registerListener([this](std::any d) { destroy(); }); + m_listeners.destroy = m_resource->events.destroy.registerListener([this](std::any d) { destroy(); }); Debug::log(LOG, "CWLSurface {:x} called init()", (uintptr_t)this); } PHLWINDOW CWLSurface::getWindow() const { - return m_pWindowOwner.lock(); + return m_windowOwner.lock(); } PHLLS CWLSurface::getLayer() const { - return m_pLayerOwner.lock(); + return m_layerOwner.lock(); } CPopup* CWLSurface::getPopup() const { - return m_pPopupOwner; + return m_popupOwner; } CSubsurface* CWLSurface::getSubsurface() const { - return m_pSubsurfaceOwner; + return m_subsurfaceOwner; } bool CWLSurface::desktopComponent() const { - return !m_pLayerOwner.expired() || !m_pWindowOwner.expired() || m_pSubsurfaceOwner || m_pPopupOwner; + return !m_layerOwner.expired() || !m_windowOwner.expired() || m_subsurfaceOwner || m_popupOwner; } std::optional CWLSurface::getSurfaceBoxGlobal() const { if (!desktopComponent()) return {}; - if (!m_pWindowOwner.expired()) - return m_pWindowOwner->getWindowMainSurfaceBox(); - if (!m_pLayerOwner.expired()) - return m_pLayerOwner->m_geometry; - if (m_pPopupOwner) - return CBox{m_pPopupOwner->coordsGlobal(), m_pPopupOwner->size()}; - if (m_pSubsurfaceOwner) - return CBox{m_pSubsurfaceOwner->coordsGlobal(), m_pSubsurfaceOwner->size()}; + if (!m_windowOwner.expired()) + return m_windowOwner->getWindowMainSurfaceBox(); + if (!m_layerOwner.expired()) + return m_layerOwner->m_geometry; + if (m_popupOwner) + return CBox{m_popupOwner->coordsGlobal(), m_popupOwner->size()}; + if (m_subsurfaceOwner) + return CBox{m_subsurfaceOwner->coordsGlobal(), m_subsurfaceOwner->size()}; return {}; } void CWLSurface::appendConstraint(WP constraint) { - m_pConstraint = constraint; + m_constraint = constraint; } SP CWLSurface::constraint() const { - return m_pConstraint.lock(); + return m_constraint.lock(); } bool CWLSurface::visible() { - if (!m_pWindowOwner.expired()) - return g_pHyprRenderer->shouldRenderWindow(m_pWindowOwner.lock()); - if (!m_pLayerOwner.expired()) + if (!m_windowOwner.expired()) + return g_pHyprRenderer->shouldRenderWindow(m_windowOwner.lock()); + if (!m_layerOwner.expired()) return true; - if (m_pPopupOwner) - return m_pPopupOwner->visible(); - if (m_pSubsurfaceOwner) - return m_pSubsurfaceOwner->visible(); + if (m_popupOwner) + return m_popupOwner->visible(); + if (m_subsurfaceOwner) + return m_subsurfaceOwner->visible(); return true; // non-desktop, we don't know much. } @@ -226,9 +226,9 @@ SP CWLSurface::fromResource(SP pSurface) { } bool CWLSurface::keyboardFocusable() const { - if (m_pWindowOwner || m_pPopupOwner || m_pSubsurfaceOwner) + if (m_windowOwner || m_popupOwner || m_subsurfaceOwner) return true; - if (m_pLayerOwner && m_pLayerOwner->m_layerSurface) - return m_pLayerOwner->m_layerSurface->current.interactivity != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE; + if (m_layerOwner && m_layerOwner->m_layerSurface) + return m_layerOwner->m_layerSurface->current.interactivity != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE; return false; } -- cgit v1.2.3