workspaces: refactor class member vars (#10167)

1 files changed, 119 insertions, 119 deletions

diff --git a/src/desktop/Workspace.cpp b/src/desktop/Workspace.cpp
index 5907c970..18322799 100644
--- a/src/desktop/Workspace.cpp
+++ b/src/desktop/Workspace.cpp
@@ -17,76 +17,76 @@ PHLWORKSPACE CWorkspace::create(WORKSPACEID id, PHLMONITOR monitor, std::string
 }
 
 CWorkspace::CWorkspace(WORKSPACEID id, PHLMONITOR monitor, std::string name, bool special, bool isEmpty) :
-    m_iID(id), m_szName(name), m_pMonitor(monitor), m_bIsSpecialWorkspace(special), m_bWasCreatedEmpty(isEmpty) {
+    m_id(id), m_name(name), m_monitor(monitor), m_isSpecialWorkspace(special), m_wasCreatedEmpty(isEmpty) {
     ;
 }
 
 void CWorkspace::init(PHLWORKSPACE self) {
-    m_pSelf = self;
+    m_self = self;
 
-    g_pAnimationManager->createAnimation(Vector2D(0, 0), m_vRenderOffset,
-                                         g_pConfigManager->getAnimationPropertyConfig(m_bIsSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"), self, AVARDAMAGE_ENTIRE);
-    g_pAnimationManager->createAnimation(1.f, m_fAlpha, g_pConfigManager->getAnimationPropertyConfig(m_bIsSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"), self,
+    g_pAnimationManager->createAnimation(Vector2D(0, 0), m_renderOffset, g_pConfigManager->getAnimationPropertyConfig(m_isSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"),
+                                         self, AVARDAMAGE_ENTIRE);
+    g_pAnimationManager->createAnimation(1.f, m_alpha, g_pConfigManager->getAnimationPropertyConfig(m_isSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"), self,
                                          AVARDAMAGE_ENTIRE);
 
     const auto RULEFORTHIS = g_pConfigManager->getWorkspaceRuleFor(self);
     if (RULEFORTHIS.defaultName.has_value())
-        m_szName = RULEFORTHIS.defaultName.value();
+        m_name = RULEFORTHIS.defaultName.value();
 
-    m_pFocusedWindowHook = g_pHookSystem->hookDynamic("closeWindow", [this](void* self, SCallbackInfo& info, std::any param) {
+    m_focusedWindowHook = g_pHookSystem->hookDynamic("closeWindow", [this](void* self, SCallbackInfo& info, std::any param) {
         const auto PWINDOW = std::any_cast<PHLWINDOW>(param);
 
-        if (PWINDOW == m_pLastFocusedWindow.lock())
-            m_pLastFocusedWindow.reset();
+        if (PWINDOW == m_lastFocusedWindow.lock())
+            m_lastFocusedWindow.reset();
     });
 
-    m_bInert = false;
+    m_inert = false;
 
     const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(self);
-    m_bPersistent            = WORKSPACERULE.isPersistent;
+    m_persistent             = WORKSPACERULE.isPersistent;
 
-    if (self->m_bWasCreatedEmpty)
+    if (self->m_wasCreatedEmpty)
         if (auto cmd = WORKSPACERULE.onCreatedEmptyRunCmd)
             g_pKeybindManager->spawnWithRules(*cmd, self);
 
-    g_pEventManager->postEvent({"createworkspace", m_szName});
-    g_pEventManager->postEvent({"createworkspacev2", std::format("{},{}", m_iID, m_szName)});
+    g_pEventManager->postEvent({"createworkspace", m_name});
+    g_pEventManager->postEvent({"createworkspacev2", std::format("{},{}", m_id, m_name)});
     EMIT_HOOK_EVENT("createWorkspace", this);
 }
 
 SWorkspaceIDName CWorkspace::getPrevWorkspaceIDName() const {
-    return m_sPrevWorkspace;
+    return m_prevWorkspace;
 }
 
 CWorkspace::~CWorkspace() {
-    Debug::log(LOG, "Destroying workspace ID {}", m_iID);
+    Debug::log(LOG, "Destroying workspace ID {}", m_id);
 
     // check if g_pHookSystem and g_pEventManager exist, they might be destroyed as in when the compositor is closing.
     if (g_pHookSystem)
-        g_pHookSystem->unhook(m_pFocusedWindowHook);
+        g_pHookSystem->unhook(m_focusedWindowHook);
 
     if (g_pEventManager) {
-        g_pEventManager->postEvent({"destroyworkspace", m_szName});
-        g_pEventManager->postEvent({"destroyworkspacev2", std::format("{},{}", m_iID, m_szName)});
+        g_pEventManager->postEvent({"destroyworkspace", m_name});
+        g_pEventManager->postEvent({"destroyworkspacev2", std::format("{},{}", m_id, m_name)});
         EMIT_HOOK_EVENT("destroyWorkspace", this);
     }
 }
 
 void CWorkspace::startAnim(bool in, bool left, bool instant) {
     if (!instant) {
-        const std::string ANIMNAME = std::format("{}{}", m_bIsSpecialWorkspace ? "specialWorkspace" : "workspaces", in ? "In" : "Out");
+        const std::string ANIMNAME = std::format("{}{}", m_isSpecialWorkspace ? "specialWorkspace" : "workspaces", in ? "In" : "Out");
 
-        m_fAlpha->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
-        m_vRenderOffset->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
+        m_alpha->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
+        m_renderOffset->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME));
     }
 
-    const auto  ANIMSTYLE     = m_fAlpha->getStyle();
+    const auto  ANIMSTYLE     = m_alpha->getStyle();
     static auto PWORKSPACEGAP = CConfigValue<Hyprlang::INT>("general:gaps_workspaces");
 
     // set floating windows offset callbacks
-    m_vRenderOffset->setUpdateCallback([&](auto) {
+    m_renderOffset->setUpdateCallback([&](auto) {
         for (auto const& w : g_pCompositor->m_windows) {
-            if (!validMapped(w) || w->workspaceID() != m_iID)
+            if (!validMapped(w) || w->workspaceID() != m_id)
                 continue;
 
             w->onWorkspaceAnimUpdate();
@@ -94,7 +94,7 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
     });
 
     if (ANIMSTYLE.starts_with("slidefade")) {
-        const auto PMONITOR = m_pMonitor.lock();
+        const auto PMONITOR = m_monitor.lock();
         float      movePerc = 100.f;
 
         if (ANIMSTYLE.find('%') != std::string::npos) {
@@ -104,84 +104,84 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
             } catch (std::exception& e) { Debug::log(ERR, "Error in startAnim: invalid percentage"); }
         }
 
-        m_fAlpha->setValueAndWarp(1.f);
-        m_vRenderOffset->setValueAndWarp(Vector2D(0, 0));
+        m_alpha->setValueAndWarp(1.f);
+        m_renderOffset->setValueAndWarp(Vector2D(0, 0));
 
         if (ANIMSTYLE.starts_with("slidefadevert")) {
             if (in) {
-                m_fAlpha->setValueAndWarp(0.f);
-                m_vRenderOffset->setValueAndWarp(Vector2D(0.0, (left ? PMONITOR->vecSize.y : -PMONITOR->vecSize.y) * (movePerc / 100.f)));
-                *m_fAlpha        = 1.f;
-                *m_vRenderOffset = Vector2D(0, 0);
+                m_alpha->setValueAndWarp(0.f);
+                m_renderOffset->setValueAndWarp(Vector2D(0.0, (left ? PMONITOR->vecSize.y : -PMONITOR->vecSize.y) * (movePerc / 100.f)));
+                *m_alpha        = 1.f;
+                *m_renderOffset = Vector2D(0, 0);
             } else {
-                m_fAlpha->setValueAndWarp(1.f);
-                *m_fAlpha        = 0.f;
-                *m_vRenderOffset = Vector2D(0.0, (left ? -PMONITOR->vecSize.y : PMONITOR->vecSize.y) * (movePerc / 100.f));
+                m_alpha->setValueAndWarp(1.f);
+                *m_alpha        = 0.f;
+                *m_renderOffset = Vector2D(0.0, (left ? -PMONITOR->vecSize.y : PMONITOR->vecSize.y) * (movePerc / 100.f));
             }
         } else {
             if (in) {
-                m_fAlpha->setValueAndWarp(0.f);
-                m_vRenderOffset->setValueAndWarp(Vector2D((left ? PMONITOR->vecSize.x : -PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0));
-                *m_fAlpha        = 1.f;
-                *m_vRenderOffset = Vector2D(0, 0);
+                m_alpha->setValueAndWarp(0.f);
+                m_renderOffset->setValueAndWarp(Vector2D((left ? PMONITOR->vecSize.x : -PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0));
+                *m_alpha        = 1.f;
+                *m_renderOffset = Vector2D(0, 0);
             } else {
-                m_fAlpha->setValueAndWarp(1.f);
-                *m_fAlpha        = 0.f;
-                *m_vRenderOffset = Vector2D((left ? -PMONITOR->vecSize.x : PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0);
+                m_alpha->setValueAndWarp(1.f);
+                *m_alpha        = 0.f;
+                *m_renderOffset = Vector2D((left ? -PMONITOR->vecSize.x : PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0);
             }
         }
     } else if (ANIMSTYLE == "fade") {
-        m_vRenderOffset->setValueAndWarp(Vector2D(0, 0)); // fix a bug, if switching from slide -> fade.
+        m_renderOffset->setValueAndWarp(Vector2D(0, 0)); // fix a bug, if switching from slide -> fade.
 
         if (in) {
-            m_fAlpha->setValueAndWarp(0.f);
-            *m_fAlpha = 1.f;
+            m_alpha->setValueAndWarp(0.f);
+            *m_alpha = 1.f;
         } else {
-            m_fAlpha->setValueAndWarp(1.f);
-            *m_fAlpha = 0.f;
+            m_alpha->setValueAndWarp(1.f);
+            *m_alpha = 0.f;
         }
     } else if (ANIMSTYLE == "slidevert") {
         // fallback is slide
-        const auto PMONITOR  = m_pMonitor.lock();
+        const auto PMONITOR  = m_monitor.lock();
         const auto YDISTANCE = PMONITOR->vecSize.y + *PWORKSPACEGAP;
 
-        m_fAlpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
+        m_alpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
 
         if (in) {
-            m_vRenderOffset->setValueAndWarp(Vector2D(0.0, left ? YDISTANCE : -YDISTANCE));
-            *m_vRenderOffset = Vector2D(0, 0);
+            m_renderOffset->setValueAndWarp(Vector2D(0.0, left ? YDISTANCE : -YDISTANCE));
+            *m_renderOffset = Vector2D(0, 0);
         } else {
-            *m_vRenderOffset = Vector2D(0.0, left ? -YDISTANCE : YDISTANCE);
+            *m_renderOffset = Vector2D(0.0, left ? -YDISTANCE : YDISTANCE);
         }
     } else {
         // fallback is slide
-        const auto PMONITOR  = m_pMonitor.lock();
+        const auto PMONITOR  = m_monitor.lock();
         const auto XDISTANCE = PMONITOR->vecSize.x + *PWORKSPACEGAP;
 
-        m_fAlpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
+        m_alpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
 
         if (in) {
-            m_vRenderOffset->setValueAndWarp(Vector2D(left ? XDISTANCE : -XDISTANCE, 0.0));
-            *m_vRenderOffset = Vector2D(0, 0);
+            m_renderOffset->setValueAndWarp(Vector2D(left ? XDISTANCE : -XDISTANCE, 0.0));
+            *m_renderOffset = Vector2D(0, 0);
         } else {
-            *m_vRenderOffset = Vector2D(left ? -XDISTANCE : XDISTANCE, 0.0);
+            *m_renderOffset = Vector2D(left ? -XDISTANCE : XDISTANCE, 0.0);
         }
     }
 
-    if (m_bIsSpecialWorkspace) {
+    if (m_isSpecialWorkspace) {
         // required for open/close animations
         if (in) {
-            m_fAlpha->setValueAndWarp(0.f);
-            *m_fAlpha = 1.f;
+            m_alpha->setValueAndWarp(0.f);
+            *m_alpha = 1.f;
         } else {
-            m_fAlpha->setValueAndWarp(1.f);
-            *m_fAlpha = 0.f;
+            m_alpha->setValueAndWarp(1.f);
+            *m_alpha = 0.f;
         }
     }
 
     if (instant) {
-        m_vRenderOffset->warp();
-        m_fAlpha->warp();
+        m_renderOffset->warp();
+        m_alpha->warp();
     }
 }
 
@@ -194,39 +194,39 @@ void CWorkspace::moveToMonitor(const MONITORID& id) {
 }
 
 PHLWINDOW CWorkspace::getLastFocusedWindow() {
-    if (!validMapped(m_pLastFocusedWindow) || m_pLastFocusedWindow->workspaceID() != m_iID)
+    if (!validMapped(m_lastFocusedWindow) || m_lastFocusedWindow->workspaceID() != m_id)
         return nullptr;
 
-    return m_pLastFocusedWindow.lock();
+    return m_lastFocusedWindow.lock();
 }
 
 void CWorkspace::rememberPrevWorkspace(const PHLWORKSPACE& prev) {
     if (!prev) {
-        m_sPrevWorkspace.id   = -1;
-        m_sPrevWorkspace.name = "";
+        m_prevWorkspace.id   = -1;
+        m_prevWorkspace.name = "";
         return;
     }
 
-    if (prev->m_iID == m_iID) {
+    if (prev->m_id == m_id) {
         Debug::log(LOG, "Tried to set prev workspace to the same as current one");
         return;
     }
 
-    m_sPrevWorkspace.id   = prev->m_iID;
-    m_sPrevWorkspace.name = prev->m_szName;
+    m_prevWorkspace.id   = prev->m_id;
+    m_prevWorkspace.name = prev->m_name;
 
-    prev->m_pMonitor->addPrevWorkspaceID(prev->m_iID);
+    prev->m_monitor->addPrevWorkspaceID(prev->m_id);
 }
 
 std::string CWorkspace::getConfigName() {
-    if (m_bIsSpecialWorkspace) {
-        return m_szName;
+    if (m_isSpecialWorkspace) {
+        return m_name;
     }
 
-    if (m_iID > 0)
-        return std::to_string(m_iID);
+    if (m_id > 0)
+        return std::to_string(m_id);
 
-    return "name:" + m_szName;
+    return "name:" + m_name;
 }
 
 bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
@@ -241,12 +241,12 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
         if (wsid == WORKSPACE_INVALID)
             return false;
 
-        return wsid == m_iID;
+        return wsid == m_id;
 
     } else if (selector.starts_with("name:")) {
-        return m_szName == selector.substr(5);
+        return m_name == selector.substr(5);
     } else if (selector.starts_with("special")) {
-        return m_szName == selector;
+        return m_name == selector;
     } else {
         // parse selector
 
@@ -306,7 +306,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
                     return false;
                 }
 
-                if (std::clamp(m_iID, from, to) != m_iID)
+                if (std::clamp(m_id, from, to) != m_id)
                     return false;
                 continue;
             }
@@ -321,7 +321,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 const auto SHOULDBESPECIAL = configStringToInt(prop);
 
-                if (SHOULDBESPECIAL && (bool)*SHOULDBESPECIAL != m_bIsSpecialWorkspace)
+                if (SHOULDBESPECIAL && (bool)*SHOULDBESPECIAL != m_isSpecialWorkspace)
                     return false;
                 continue;
             }
@@ -336,7 +336,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 const auto PMONITOR = g_pCompositor->getMonitorFromString(prop);
 
-                if (!(PMONITOR ? PMONITOR == m_pMonitor : false))
+                if (!(PMONITOR ? PMONITOR == m_monitor : false))
                     return false;
                 continue;
             }
@@ -349,14 +349,14 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 prop = prop.substr(2, prop.length() - 3);
 
-                if (prop.starts_with("s:") && !m_szName.starts_with(prop.substr(2)))
+                if (prop.starts_with("s:") && !m_name.starts_with(prop.substr(2)))
                     return false;
-                if (prop.starts_with("e:") && !m_szName.ends_with(prop.substr(2)))
+                if (prop.starts_with("e:") && !m_name.ends_with(prop.substr(2)))
                     return false;
 
                 const auto WANTSNAMED = configStringToInt(prop);
 
-                if (WANTSNAMED && *WANTSNAMED != (m_iID <= -1337))
+                if (WANTSNAMED && *WANTSNAMED != (m_id <= -1337))
                     return false;
                 continue;
             }
@@ -481,15 +481,15 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 
                 switch (FSSTATE) {
                     case -1: // no fullscreen
-                        if (m_bHasFullscreenWindow)
+                        if (m_hasFullscreenWindow)
                             return false;
                         break;
                     case 0: // fullscreen full
-                        if (!m_bHasFullscreenWindow || m_efFullscreenMode != FSMODE_FULLSCREEN)
+                        if (!m_hasFullscreenWindow || m_fullscreenMode != FSMODE_FULLSCREEN)
                             return false;
                         break;
                     case 1: // maximized
-                        if (!m_bHasFullscreenWindow || m_efFullscreenMode != FSMODE_MAXIMIZED)
+                        if (!m_hasFullscreenWindow || m_fullscreenMode != FSMODE_MAXIMIZED)
                             return false;
                         break;
                     default: break;
@@ -509,23 +509,23 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) {
 }
 
 void CWorkspace::markInert() {
-    m_bInert   = true;
-    m_iID      = WORKSPACE_INVALID;
-    m_bVisible = false;
-    m_pMonitor.reset();
+    m_inert   = true;
+    m_id      = WORKSPACE_INVALID;
+    m_visible = false;
+    m_monitor.reset();
 }
 
 bool CWorkspace::inert() {
-    return m_bInert;
+    return m_inert;
 }
 
 MONITORID CWorkspace::monitorID() {
-    return m_pMonitor ? m_pMonitor->ID : MONITOR_INVALID;
+    return m_monitor ? m_monitor->ID : MONITOR_INVALID;
 }
 
 PHLWINDOW CWorkspace::getFullscreenWindow() {
     for (auto const& w : g_pCompositor->m_windows) {
-        if (w->m_pWorkspace == m_pSelf && w->isFullscreen())
+        if (w->m_pWorkspace == m_self && w->isFullscreen())
             return w;
     }
 
@@ -533,21 +533,21 @@ PHLWINDOW CWorkspace::getFullscreenWindow() {
 }
 
 bool CWorkspace::isVisible() {
-    return m_bVisible;
+    return m_visible;
 }
 
 bool CWorkspace::isVisibleNotCovered() {
-    const auto PMONITOR = m_pMonitor.lock();
+    const auto PMONITOR = m_monitor.lock();
     if (PMONITOR->activeSpecialWorkspace)
-        return PMONITOR->activeSpecialWorkspace->m_iID == m_iID;
+        return PMONITOR->activeSpecialWorkspace->m_id == m_id;
 
-    return PMONITOR->activeWorkspace->m_iID == m_iID;
+    return PMONITOR->activeWorkspace->m_id == m_id;
 }
 
 int CWorkspace::getWindows(std::optional<bool> onlyTiled, std::optional<bool> onlyPinned, std::optional<bool> onlyVisible) {
     int no = 0;
     for (auto const& w : g_pCompositor->m_windows) {
-        if (w->workspaceID() != m_iID || !w->m_bIsMapped)
+        if (w->workspaceID() != m_id || !w->m_bIsMapped)
             continue;
         if (onlyTiled.has_value() && w->m_bIsFloating == onlyTiled.value())
             continue;
@@ -564,7 +564,7 @@ int CWorkspace::getWindows(std::optional<bool> onlyTiled, std::optional<bool> on
 int CWorkspace::getGroups(std::optional<bool> onlyTiled, std::optional<bool> onlyPinned, std::optional<bool> onlyVisible) {
     int no = 0;
     for (auto const& w : g_pCompositor->m_windows) {
-        if (w->workspaceID() != m_iID || !w->m_bIsMapped)
+        if (w->workspaceID() != m_id || !w->m_bIsMapped)
             continue;
         if (!w->m_sGroupData.head)
             continue;
@@ -581,7 +581,7 @@ int CWorkspace::getGroups(std::optional<bool> onlyTiled, std::optional<bool> onl
 
 PHLWINDOW CWorkspace::getFirstWindow() {
     for (auto const& w : g_pCompositor->m_windows) {
-        if (w->m_pWorkspace == m_pSelf && w->m_bIsMapped && !w->isHidden())
+        if (w->m_pWorkspace == m_self && w->m_bIsMapped && !w->isHidden())
             return w;
     }
 
@@ -589,10 +589,10 @@ PHLWINDOW CWorkspace::getFirstWindow() {
 }
 
 PHLWINDOW CWorkspace::getTopLeftWindow() {
-    const auto PMONITOR = m_pMonitor.lock();
+    const auto PMONITOR = m_monitor.lock();
 
     for (auto const& w : g_pCompositor->m_windows) {
-        if (w->m_pWorkspace != m_pSelf || !w->m_bIsMapped || w->isHidden())
+        if (w->m_pWorkspace != m_self || !w->m_bIsMapped || w->isHidden())
             continue;
 
         const auto WINDOWIDEALBB = w->getWindowIdealBoundingBoxIgnoreReserved();
@@ -605,7 +605,7 @@ PHLWINDOW CWorkspace::getTopLeftWindow() {
 
 bool CWorkspace::hasUrgentWindow() {
     for (auto const& w : g_pCompositor->m_windows) {
-        if (w->m_pWorkspace == m_pSelf && w->m_bIsMapped && w->m_bIsUrgent)
+        if (w->m_pWorkspace == m_self && w->m_bIsMapped && w->m_bIsUrgent)
             return true;
     }
 
@@ -614,7 +614,7 @@ bool CWorkspace::hasUrgentWindow() {
 
 void CWorkspace::updateWindowDecos() {
     for (auto const& w : g_pCompositor->m_windows) {
-        if (w->m_pWorkspace != m_pSelf)
+        if (w->m_pWorkspace != m_self)
             continue;
 
         w->updateWindowDecos();
@@ -622,10 +622,10 @@ void CWorkspace::updateWindowDecos() {
 }
 
 void CWorkspace::updateWindowData() {
-    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_pSelf.lock());
+    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_self.lock());
 
     for (auto const& w : g_pCompositor->m_windows) {
-        if (w->m_pWorkspace != m_pSelf)
+        if (w->m_pWorkspace != m_self)
             continue;
 
         w->updateWindowData(WORKSPACERULE);
@@ -634,7 +634,7 @@ void CWorkspace::updateWindowData() {
 
 void CWorkspace::forceReportSizesToWindows() {
     for (auto const& w : g_pCompositor->m_windows) {
-        if (w->m_pWorkspace != m_pSelf || !w->m_bIsMapped || w->isHidden())
+        if (w->m_pWorkspace != m_self || !w->m_bIsMapped || w->isHidden())
             continue;
 
         w->sendWindowSize(true);
@@ -642,26 +642,26 @@ void CWorkspace::forceReportSizesToWindows() {
 }
 
 void CWorkspace::rename(const std::string& name) {
-    if (g_pCompositor->isWorkspaceSpecial(m_iID))
+    if (g_pCompositor->isWorkspaceSpecial(m_id))
         return;
 
-    Debug::log(LOG, "CWorkspace::rename: Renaming workspace {} to '{}'", m_iID, name);
-    m_szName = name;
+    Debug::log(LOG, "CWorkspace::rename: Renaming workspace {} to '{}'", m_id, name);
+    m_name = name;
 
-    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_pSelf.lock());
-    m_bPersistent            = WORKSPACERULE.isPersistent;
+    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_self.lock());
+    m_persistent             = WORKSPACERULE.isPersistent;
 
     if (WORKSPACERULE.isPersistent)
-        g_pCompositor->ensurePersistentWorkspacesPresent(std::vector<SWorkspaceRule>{WORKSPACERULE}, m_pSelf.lock());
+        g_pCompositor->ensurePersistentWorkspacesPresent(std::vector<SWorkspaceRule>{WORKSPACERULE}, m_self.lock());
 
-    g_pEventManager->postEvent({"renameworkspace", std::to_string(m_iID) + "," + m_szName});
+    g_pEventManager->postEvent({"renameworkspace", std::to_string(m_id) + "," + m_name});
 }
 
 void CWorkspace::updateWindows() {
-    m_bHasFullscreenWindow = std::ranges::any_of(g_pCompositor->m_windows, [this](const auto& w) { return w->m_bIsMapped && w->m_pWorkspace == m_pSelf && w->isFullscreen(); });
+    m_hasFullscreenWindow = std::ranges::any_of(g_pCompositor->m_windows, [this](const auto& w) { return w->m_bIsMapped && w->m_pWorkspace == m_self && w->isFullscreen(); });
 
     for (auto const& w : g_pCompositor->m_windows) {
-        if (!w->m_bIsMapped || w->m_pWorkspace != m_pSelf)
+        if (!w->m_bIsMapped || w->m_pWorkspace != m_self)
             continue;
 
         w->updateDynamicRules();