helpers: refactor class member vars (#10218)

9 files changed, 595 insertions, 596 deletions

diff --git a/src/helpers/Color.cpp b/src/helpers/Color.cpp
index 8dfefbbd..42ae1fd4 100644
--- a/src/helpers/Color.cpp
+++ b/src/helpers/Color.cpp
@@ -8,11 +8,11 @@
 CHyprColor::CHyprColor() = default;
 
 CHyprColor::CHyprColor(float r_, float g_, float b_, float a_) : r(r_), g(g_), b(b_), a(a_) {
-    okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab();
+    m_okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab();
 }
 
 CHyprColor::CHyprColor(uint64_t hex) : r(RED(hex)), g(GREEN(hex)), b(BLUE(hex)), a(ALPHA(hex)) {
-    okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab();
+    m_okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab();
 }
 
 CHyprColor::CHyprColor(const Hyprgraphics::CColor& color, float a_) : a(a_) {
@@ -21,7 +21,7 @@ CHyprColor::CHyprColor(const Hyprgraphics::CColor& color, float a_) : a(a_) {
     g               = SRGB.g;
     b               = SRGB.b;
 
-    okLab = color.asOkLab();
+    m_okLab = color.asOkLab();
 }
 
 uint32_t CHyprColor::getAsHex() const {
@@ -33,11 +33,11 @@ Hyprgraphics::CColor::SSRGB CHyprColor::asRGB() const {
 }
 
 Hyprgraphics::CColor::SOkLab CHyprColor::asOkLab() const {
-    return okLab;
+    return m_okLab;
 }
 
 Hyprgraphics::CColor::SHSL CHyprColor::asHSL() const {
-    return Hyprgraphics::CColor(okLab).asHSL();
+    return Hyprgraphics::CColor(m_okLab).asHSL();
 }
 
 CHyprColor CHyprColor::stripA() const {
diff --git a/src/helpers/Color.hpp b/src/helpers/Color.hpp
index 8050bebd..e72fcd58 100644
--- a/src/helpers/Color.hpp
+++ b/src/helpers/Color.hpp
@@ -43,7 +43,7 @@ class CHyprColor {
     double r = 0, g = 0, b = 0, a = 0;
 
   private:
-    Hyprgraphics::CColor::SOkLab okLab; // cache for the OkLab representation
+    Hyprgraphics::CColor::SOkLab m_okLab; // cache for the OkLab representation
 };
 
 //NOLINTNEXTLINE
diff --git a/src/helpers/DamageRing.cpp b/src/helpers/DamageRing.cpp
index 093e7ca6..82c8894b 100644
--- a/src/helpers/DamageRing.cpp
+++ b/src/helpers/DamageRing.cpp
@@ -1,43 +1,43 @@
 #include "DamageRing.hpp"
 
 void CDamageRing::setSize(const Vector2D& size_) {
-    if (size_ == size)
+    if (size_ == m_size)
         return;
 
-    size = size_;
+    m_size = size_;
 
     damageEntire();
 }
 
 bool CDamageRing::damage(const CRegion& rg) {
-    CRegion clipped = rg.copy().intersect(CBox{{}, size});
+    CRegion clipped = rg.copy().intersect(CBox{{}, m_size});
     if (clipped.empty())
         return false;
 
-    current.add(clipped);
+    m_current.add(clipped);
     return true;
 }
 
 void CDamageRing::damageEntire() {
-    damage(CBox{{}, size});
+    damage(CBox{{}, m_size});
 }
 
 void CDamageRing::rotate() {
-    previousIdx = (previousIdx + DAMAGE_RING_PREVIOUS_LEN - 1) % DAMAGE_RING_PREVIOUS_LEN;
+    m_previousIdx = (m_previousIdx + DAMAGE_RING_PREVIOUS_LEN - 1) % DAMAGE_RING_PREVIOUS_LEN;
 
-    previous[previousIdx] = current;
-    current.clear();
+    m_previous[m_previousIdx] = m_current;
+    m_current.clear();
 }
 
 CRegion CDamageRing::getBufferDamage(int age) {
     if (age <= 0 || age > DAMAGE_RING_PREVIOUS_LEN + 1)
-        return CBox{{}, size};
+        return CBox{{}, m_size};
 
-    CRegion damage = current;
+    CRegion damage = m_current;
 
     for (int i = 0; i < age - 1; ++i) {
-        int j = (previousIdx + i) % DAMAGE_RING_PREVIOUS_LEN;
-        damage.add(previous.at(j));
+        int j = (m_previousIdx + i) % DAMAGE_RING_PREVIOUS_LEN;
+        damage.add(m_previous.at(j));
     }
 
     // don't return a ludicrous amount of rects
@@ -48,5 +48,5 @@ CRegion CDamageRing::getBufferDamage(int age) {
 }
 
 bool CDamageRing::hasChanged() {
-    return !current.empty();
+    return !m_current.empty();
 }
diff --git a/src/helpers/DamageRing.hpp b/src/helpers/DamageRing.hpp
index ae85c453..f53d6bf0 100644
--- a/src/helpers/DamageRing.hpp
+++ b/src/helpers/DamageRing.hpp
@@ -15,8 +15,8 @@ class CDamageRing {
     bool    hasChanged();
 
   private:
-    Vector2D                                      size;
-    CRegion                                       current;
-    std::array<CRegion, DAMAGE_RING_PREVIOUS_LEN> previous;
-    size_t                                        previousIdx = 0;
+    Vector2D                                      m_size;
+    CRegion                                       m_current;
+    std::array<CRegion, DAMAGE_RING_PREVIOUS_LEN> m_previous;
+    size_t                                        m_previousIdx = 0;
 };
diff --git a/src/helpers/MiscFunctions.cpp b/src/helpers/MiscFunctions.cpp
index bb5510b6..ed67618e 100644
--- a/src/helpers/MiscFunctions.cpp
+++ b/src/helpers/MiscFunctions.cpp
@@ -148,7 +148,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
         if (same_mon) {
             for (auto const& rule : g_pConfigManager->getAllWorkspaceRules()) {
                 const auto PMONITOR = g_pCompositor->getMonitorFromName(rule.monitor);
-                if (PMONITOR && (PMONITOR->ID != g_pCompositor->m_lastMonitor->ID))
+                if (PMONITOR && (PMONITOR->m_id != g_pCompositor->m_lastMonitor->m_id))
                     invalidWSes.insert(rule.workspaceId);
             }
         }
@@ -165,7 +165,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
         if (!g_pCompositor->m_lastMonitor)
             return {WORKSPACE_INVALID};
 
-        const auto PWORKSPACE = g_pCompositor->m_lastMonitor->activeWorkspace;
+        const auto PWORKSPACE = g_pCompositor->m_lastMonitor->m_activeWorkspace;
 
         if (!valid(PWORKSPACE))
             return {WORKSPACE_INVALID};
@@ -184,12 +184,12 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
 
         return {PLASTWORKSPACE->m_id, PLASTWORKSPACE->m_name};
     } else if (in == "next") {
-        if (!g_pCompositor->m_lastMonitor || !g_pCompositor->m_lastMonitor->activeWorkspace) {
+        if (!g_pCompositor->m_lastMonitor || !g_pCompositor->m_lastMonitor->m_activeWorkspace) {
             Debug::log(ERR, "no active monitor or workspace for 'next'");
             return {WORKSPACE_INVALID};
         }
 
-        auto        PCURRENTWORKSPACE = g_pCompositor->m_lastMonitor->activeWorkspace;
+        auto        PCURRENTWORKSPACE = g_pCompositor->m_lastMonitor->m_activeWorkspace;
 
         WORKSPACEID nextId = PCURRENTWORKSPACE->m_id + 1;
 
@@ -227,7 +227,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             }
             for (auto const& rule : g_pConfigManager->getAllWorkspaceRules()) {
                 const auto PMONITOR = g_pCompositor->getMonitorFromName(rule.monitor);
-                if (!PMONITOR || PMONITOR->ID == g_pCompositor->m_lastMonitor->ID) {
+                if (!PMONITOR || PMONITOR->m_id == g_pCompositor->m_lastMonitor->m_id) {
                     // Can't be invalid
                     continue;
                 }
@@ -265,7 +265,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
             } else {
 
                 // Just take a blind guess at where we'll probably end up
-                WORKSPACEID activeWSID    = g_pCompositor->m_lastMonitor->activeWorkspace ? g_pCompositor->m_lastMonitor->activeWorkspace->m_id : 1;
+                WORKSPACEID activeWSID    = g_pCompositor->m_lastMonitor->m_activeWorkspace ? g_pCompositor->m_lastMonitor->m_activeWorkspace->m_id : 1;
                 WORKSPACEID predictedWSID = activeWSID + remains;
                 int         remainingWSes = 0;
                 char        walkDir       = in[1];
@@ -407,7 +407,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
                 remains = remains < 0 ? -((-remains) % validWSes.size()) : remains % validWSes.size();
 
                 // get the current item
-                WORKSPACEID activeWSID = g_pCompositor->m_lastMonitor->activeWorkspace ? g_pCompositor->m_lastMonitor->activeWorkspace->m_id : 1;
+                WORKSPACEID activeWSID = g_pCompositor->m_lastMonitor->m_activeWorkspace ? g_pCompositor->m_lastMonitor->m_activeWorkspace->m_id : 1;
                 for (ssize_t i = 0; i < (ssize_t)validWSes.size(); i++) {
                     if (validWSes[i] == activeWSID) {
                         currentItem = i;
diff --git a/src/helpers/Monitor.cpp b/src/helpers/Monitor.cpp
index 4ee0166f..2edba78a 100644
--- a/src/helpers/Monitor.cpp
+++ b/src/helpers/Monitor.cpp
@@ -39,133 +39,133 @@ using namespace Hyprutils::OS;
 using enum NContentType::eContentType;
 
 static int ratHandler(void* data) {
-    g_pHyprRenderer->renderMonitor(((CMonitor*)data)->self.lock());
+    g_pHyprRenderer->renderMonitor(((CMonitor*)data)->m_self.lock());
 
     return 1;
 }
 
-CMonitor::CMonitor(SP<Aquamarine::IOutput> output_) : state(this), output(output_) {
+CMonitor::CMonitor(SP<Aquamarine::IOutput> output_) : m_state(this), m_output(output_) {
     ;
 }
 
 CMonitor::~CMonitor() {
-    events.destroy.emit();
+    m_events.destroy.emit();
     if (g_pHyprOpenGL)
-        g_pHyprOpenGL->destroyMonitorResources(self);
+        g_pHyprOpenGL->destroyMonitorResources(m_self);
 }
 
 void CMonitor::onConnect(bool noRule) {
-    EMIT_HOOK_EVENT("preMonitorAdded", self.lock());
+    EMIT_HOOK_EVENT("preMonitorAdded", m_self.lock());
     CScopeGuard x = {[]() { g_pCompositor->arrangeMonitors(); }};
 
     g_pEventLoopManager->doLater([] { g_pConfigManager->ensurePersistentWorkspacesPresent(); });
 
-    listeners.frame  = output->events.frame.registerListener([this](std::any d) { onMonitorFrame(); });
-    listeners.commit = output->events.commit.registerListener([this](std::any d) {
+    m_listeners.frame  = m_output->events.frame.registerListener([this](std::any d) { onMonitorFrame(); });
+    m_listeners.commit = m_output->events.commit.registerListener([this](std::any d) {
         if (true) { // FIXME: E->state->committed & WLR_OUTPUT_STATE_BUFFER
-            PROTO::screencopy->onOutputCommit(self.lock());
-            PROTO::toplevelExport->onOutputCommit(self.lock());
+            PROTO::screencopy->onOutputCommit(m_self.lock());
+            PROTO::toplevelExport->onOutputCommit(m_self.lock());
         }
     });
-    listeners.needsFrame =
-        output->events.needsFrame.registerListener([this](std::any d) { g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_NEEDS_FRAME); });
+    m_listeners.needsFrame =
+        m_output->events.needsFrame.registerListener([this](std::any d) { g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_NEEDS_FRAME); });
 
-    listeners.presented = output->events.present.registerListener([this](std::any d) {
+    m_listeners.presented = m_output->events.present.registerListener([this](std::any d) {
         auto      E = std::any_cast<Aquamarine::IOutput::SPresentEvent>(d);
 
         timespec* ts = E.when;
         if (!ts) {
             timespec now;
             clock_gettime(CLOCK_MONOTONIC, &now);
-            PROTO::presentation->onPresented(self.lock(), Time::fromTimespec(&now), E.refresh, E.seq, E.flags);
+            PROTO::presentation->onPresented(m_self.lock(), Time::fromTimespec(&now), E.refresh, E.seq, E.flags);
         } else
-            PROTO::presentation->onPresented(self.lock(), Time::fromTimespec(E.when), E.refresh, E.seq, E.flags);
+            PROTO::presentation->onPresented(m_self.lock(), Time::fromTimespec(E.when), E.refresh, E.seq, E.flags);
     });
 
-    listeners.destroy = output->events.destroy.registerListener([this](std::any d) {
-        Debug::log(LOG, "Destroy called for monitor {}", szName);
+    m_listeners.destroy = m_output->events.destroy.registerListener([this](std::any d) {
+        Debug::log(LOG, "Destroy called for monitor {}", m_name);
 
         onDisconnect(true);
 
-        output                 = nullptr;
-        m_bRenderingInitPassed = false;
+        m_output              = nullptr;
+        m_renderingInitPassed = false;
 
-        Debug::log(LOG, "Removing monitor {} from realMonitors", szName);
+        Debug::log(LOG, "Removing monitor {} from realMonitors", m_name);
 
         std::erase_if(g_pCompositor->m_realMonitors, [&](PHLMONITOR& el) { return el.get() == this; });
     });
 
-    listeners.state = output->events.state.registerListener([this](std::any d) {
+    m_listeners.state = m_output->events.state.registerListener([this](std::any d) {
         auto E = std::any_cast<Aquamarine::IOutput::SStateEvent>(d);
 
         if (E.size == Vector2D{}) {
             // an indication to re-set state
             // we can't do much for createdByUser displays I think
-            if (createdByUser)
+            if (m_createdByUser)
                 return;
 
-            Debug::log(LOG, "Reapplying monitor rule for {} from a state request", szName);
-            applyMonitorRule(&activeMonitorRule, true);
+            Debug::log(LOG, "Reapplying monitor rule for {} from a state request", m_name);
+            applyMonitorRule(&m_activeMonitorRule, true);
             return;
         }
 
-        if (!createdByUser)
+        if (!m_createdByUser)
             return;
 
         const auto SIZE = E.size;
 
-        forceSize = SIZE;
+        m_forceSize = SIZE;
 
-        SMonitorRule rule = activeMonitorRule;
+        SMonitorRule rule = m_activeMonitorRule;
         rule.resolution   = SIZE;
 
         applyMonitorRule(&rule);
     });
 
-    tearingState.canTear = output->getBackend()->type() == Aquamarine::AQ_BACKEND_DRM;
+    m_tearingState.canTear = m_output->getBackend()->type() == Aquamarine::AQ_BACKEND_DRM;
 
-    if (m_bEnabled) {
-        output->state->resetExplicitFences();
-        output->state->setEnabled(true);
-        state.commit();
+    if (m_enabled) {
+        m_output->state->resetExplicitFences();
+        m_output->state->setEnabled(true);
+        m_state.commit();
         return;
     }
 
-    szName = output->name;
+    m_name = m_output->name;
 
-    szDescription = output->description;
+    m_description = m_output->description;
     // remove comma character from description. This allow monitor specific rules to work on monitor with comma on their description
-    std::erase(szDescription, ',');
+    std::erase(m_description, ',');
 
     // field is backwards-compatible with intended usage of `szDescription` but excludes the parenthesized DRM node name suffix
-    szShortDescription = trim(std::format("{} {} {}", output->make, output->model, output->serial));
-    std::erase(szShortDescription, ',');
+    m_shortDescription = trim(std::format("{} {} {}", m_output->make, m_output->model, m_output->serial));
+    std::erase(m_shortDescription, ',');
 
-    if (output->getBackend()->type() != Aquamarine::AQ_BACKEND_DRM)
-        createdByUser = true; // should be true. WL and Headless backends should be addable / removable
+    if (m_output->getBackend()->type() != Aquamarine::AQ_BACKEND_DRM)
+        m_createdByUser = true; // should be true. WL and Headless backends should be addable / removable
 
     // get monitor rule that matches
-    SMonitorRule monitorRule = g_pConfigManager->getMonitorRuleFor(self.lock());
+    SMonitorRule monitorRule = g_pConfigManager->getMonitorRuleFor(m_self.lock());
 
     // if it's disabled, disable and ignore
     if (monitorRule.disabled) {
 
-        output->state->resetExplicitFences();
-        output->state->setEnabled(false);
+        m_output->state->resetExplicitFences();
+        m_output->state->setEnabled(false);
 
-        if (!state.commit())
-            Debug::log(ERR, "Couldn't commit disabled state on output {}", output->name);
+        if (!m_state.commit())
+            Debug::log(ERR, "Couldn't commit disabled state on output {}", m_output->name);
 
-        m_bEnabled = false;
+        m_enabled = false;
 
-        listeners.frame.reset();
+        m_listeners.frame.reset();
         return;
     }
 
-    if (output->nonDesktop) {
+    if (m_output->nonDesktop) {
         Debug::log(LOG, "Not configuring non-desktop output");
         if (PROTO::lease)
-            PROTO::lease->offer(self.lock());
+            PROTO::lease->offer(m_self.lock());
 
         return;
     }
@@ -174,7 +174,7 @@ void CMonitor::onConnect(bool noRule) {
 
     // find the wrap
     for (auto& m : g_pCompositor->m_realMonitors) {
-        if (m->ID == ID) {
+        if (m->m_id == m_id) {
             thisWrapper = &m;
             break;
         }
@@ -185,21 +185,21 @@ void CMonitor::onConnect(bool noRule) {
     if (std::find_if(g_pCompositor->m_monitors.begin(), g_pCompositor->m_monitors.end(), [&](auto& other) { return other.get() == this; }) == g_pCompositor->m_monitors.end())
         g_pCompositor->m_monitors.push_back(*thisWrapper);
 
-    m_bEnabled = true;
+    m_enabled = true;
 
-    output->state->resetExplicitFences();
-    output->state->setEnabled(true);
+    m_output->state->resetExplicitFences();
+    m_output->state->setEnabled(true);
 
     // set mode, also applies
     if (!noRule)
         applyMonitorRule(&monitorRule, true);
 
-    if (!state.commit())
+    if (!m_state.commit())
         Debug::log(WARN, "state.commit() failed in CMonitor::onCommit");
 
-    damage.setSize(vecTransformedSize);
+    m_damage.setSize(m_transformedSize);
 
-    Debug::log(LOG, "Added new monitor with name {} at {:j0} with size {:j0}, pointer {:x}", output->name, vecPosition, vecPixelSize, (uintptr_t)output.get());
+    Debug::log(LOG, "Added new monitor with name {} at {:j0} with size {:j0}, pointer {:x}", m_output->name, m_position, m_pixelSize, (uintptr_t)m_output.get());
 
     setupDefaultWS(monitorRule);
 
@@ -207,31 +207,31 @@ void CMonitor::onConnect(bool noRule) {
         if (!valid(ws))
             continue;
 
-        if (ws->m_lastMonitor == szName || g_pCompositor->m_monitors.size() == 1 /* avoid lost workspaces on recover */) {
-            g_pCompositor->moveWorkspaceToMonitor(ws, self.lock());
+        if (ws->m_lastMonitor == m_name || g_pCompositor->m_monitors.size() == 1 /* avoid lost workspaces on recover */) {
+            g_pCompositor->moveWorkspaceToMonitor(ws, m_self.lock());
             ws->startAnim(true, true, true);
             ws->m_lastMonitor = "";
         }
     }
 
-    scale = monitorRule.scale;
-    if (scale < 0.1)
-        scale = getDefaultScale();
+    m_scale = monitorRule.scale;
+    if (m_scale < 0.1)
+        m_scale = getDefaultScale();
 
-    forceFullFrames = 3; // force 3 full frames to make sure there is no blinking due to double-buffering.
+    m_forceFullFrames = 3; // force 3 full frames to make sure there is no blinking due to double-buffering.
     //
 
-    if (!activeMonitorRule.mirrorOf.empty())
-        setMirror(activeMonitorRule.mirrorOf);
+    if (!m_activeMonitorRule.mirrorOf.empty())
+        setMirror(m_activeMonitorRule.mirrorOf);
 
     if (!g_pCompositor->m_lastMonitor) // set the last monitor if it isnt set yet
-        g_pCompositor->setActiveMonitor(self.lock());
+        g_pCompositor->setActiveMonitor(m_self.lock());
 
-    g_pHyprRenderer->arrangeLayersForMonitor(ID);
-    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
+    g_pHyprRenderer->arrangeLayersForMonitor(m_id);
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_id);
 
     // ensure VRR (will enable if necessary)
-    g_pConfigManager->ensureVRR(self.lock());
+    g_pConfigManager->ensureVRR(m_self.lock());
 
     // verify last mon valid
     bool found = false;
@@ -242,63 +242,63 @@ void CMonitor::onConnect(bool noRule) {
         }
     }
 
-    Debug::log(LOG, "checking if we have seen this monitor before: {}", szName);
+    Debug::log(LOG, "checking if we have seen this monitor before: {}", m_name);
     // if we saw this monitor before, set it to the workspace it was on
-    if (g_pCompositor->m_seenMonitorWorkspaceMap.contains(szName)) {
-        auto workspaceID = g_pCompositor->m_seenMonitorWorkspaceMap[szName];
-        Debug::log(LOG, "Monitor {} was on workspace {}, setting it to that", szName, workspaceID);
+    if (g_pCompositor->m_seenMonitorWorkspaceMap.contains(m_name)) {
+        auto workspaceID = g_pCompositor->m_seenMonitorWorkspaceMap[m_name];
+        Debug::log(LOG, "Monitor {} was on workspace {}, setting it to that", m_name, workspaceID);
         auto ws = g_pCompositor->getWorkspaceByID(workspaceID);
         if (ws) {
-            g_pCompositor->moveWorkspaceToMonitor(ws, self.lock());
+            g_pCompositor->moveWorkspaceToMonitor(ws, m_self.lock());
             changeWorkspace(ws, true, false, false);
         }
     } else
-        Debug::log(LOG, "Monitor {} was not on any workspace", szName);
+        Debug::log(LOG, "Monitor {} was not on any workspace", m_name);
 
     if (!found)
-        g_pCompositor->setActiveMonitor(self.lock());
+        g_pCompositor->setActiveMonitor(m_self.lock());
 
-    renderTimer = wl_event_loop_add_timer(g_pCompositor->m_wlEventLoop, ratHandler, this);
+    m_renderTimer = wl_event_loop_add_timer(g_pCompositor->m_wlEventLoop, ratHandler, this);
 
-    g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_NEW_MONITOR);
+    g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_NEW_MONITOR);
 
-    PROTO::gamma->applyGammaToState(self.lock());
+    PROTO::gamma->applyGammaToState(m_self.lock());
 
-    events.connect.emit();
+    m_events.connect.emit();
 
-    g_pEventManager->postEvent(SHyprIPCEvent{"monitoradded", szName});
-    g_pEventManager->postEvent(SHyprIPCEvent{"monitoraddedv2", std::format("{},{},{}", ID, szName, szShortDescription)});
-    EMIT_HOOK_EVENT("monitorAdded", self.lock());
+    g_pEventManager->postEvent(SHyprIPCEvent{"monitoradded", m_name});
+    g_pEventManager->postEvent(SHyprIPCEvent{"monitoraddedv2", std::format("{},{},{}", m_id, m_name, m_shortDescription)});
+    EMIT_HOOK_EVENT("monitorAdded", m_self.lock());
 }
 
 void CMonitor::onDisconnect(bool destroy) {
-    EMIT_HOOK_EVENT("preMonitorRemoved", self.lock());
+    EMIT_HOOK_EVENT("preMonitorRemoved", m_self.lock());
     CScopeGuard x = {[this]() {
         if (g_pCompositor->m_isShuttingDown)
             return;
-        g_pEventManager->postEvent(SHyprIPCEvent{"monitorremoved", szName});
-        EMIT_HOOK_EVENT("monitorRemoved", self.lock());
+        g_pEventManager->postEvent(SHyprIPCEvent{"monitorremoved", m_name});
+        EMIT_HOOK_EVENT("monitorRemoved", m_self.lock());
         g_pCompositor->arrangeMonitors();
     }};
 
-    if (renderTimer) {
-        wl_event_source_remove(renderTimer);
-        renderTimer = nullptr;
+    if (m_renderTimer) {
+        wl_event_source_remove(m_renderTimer);
+        m_renderTimer = nullptr;
     }
 
-    if (!m_bEnabled || g_pCompositor->m_isShuttingDown)
+    if (!m_enabled || g_pCompositor->m_isShuttingDown)
         return;
 
-    Debug::log(LOG, "onDisconnect called for {}", output->name);
+    Debug::log(LOG, "onDisconnect called for {}", m_output->name);
 
-    events.disconnect.emit();
+    m_events.disconnect.emit();
     if (g_pHyprOpenGL)
-        g_pHyprOpenGL->destroyMonitorResources(self);
+        g_pHyprOpenGL->destroyMonitorResources(m_self);
 
     // record what workspace this monitor was on
-    if (activeWorkspace) {
-        Debug::log(LOG, "Disconnecting Monitor {} was on workspace {}", szName, activeWorkspace->m_id);
-        g_pCompositor->m_seenMonitorWorkspaceMap[szName] = activeWorkspace->m_id;
+    if (m_activeWorkspace) {
+        Debug::log(LOG, "Disconnecting Monitor {} was on workspace {}", m_name, m_activeWorkspace->m_id);
+        g_pCompositor->m_seenMonitorWorkspaceMap[m_name] = m_activeWorkspace->m_id;
     }
 
     // Cleanup everything. Move windows back, snap cursor, shit.
@@ -311,58 +311,58 @@ void CMonitor::onDisconnect(bool destroy) {
     }
 
     // remove mirror
-    if (pMirrorOf) {
-        pMirrorOf->mirrors.erase(std::find_if(pMirrorOf->mirrors.begin(), pMirrorOf->mirrors.end(), [&](const auto& other) { return other == self; }));
+    if (m_mirrorOf) {
+        m_mirrorOf->m_mirrors.erase(std::find_if(m_mirrorOf->m_mirrors.begin(), m_mirrorOf->m_mirrors.end(), [&](const auto& other) { return other == m_self; }));
 
         // unlock software for mirrored monitor
-        g_pPointerManager->unlockSoftwareForMonitor(pMirrorOf.lock());
-        pMirrorOf.reset();
+        g_pPointerManager->unlockSoftwareForMonitor(m_mirrorOf.lock());
+        m_mirrorOf.reset();
     }
 
-    if (!mirrors.empty()) {
-        for (auto const& m : mirrors) {
+    if (!m_mirrors.empty()) {
+        for (auto const& m : m_mirrors) {
             m->setMirror("");
         }
 
         g_pConfigManager->m_wantsMonitorReload = true;
     }
 
-    listeners.frame.reset();
-    listeners.presented.reset();
-    listeners.needsFrame.reset();
-    listeners.commit.reset();
+    m_listeners.frame.reset();
+    m_listeners.presented.reset();
+    m_listeners.needsFrame.reset();
+    m_listeners.commit.reset();
 
     for (size_t i = 0; i < 4; ++i) {
-        for (auto const& ls : m_aLayerSurfaceLayers[i]) {
+        for (auto const& ls : m_layerSurfaceLayers[i]) {
             if (ls->m_layerSurface && !ls->m_fadingOut)
                 ls->m_layerSurface->sendClosed();
         }
-        m_aLayerSurfaceLayers[i].clear();
+        m_layerSurfaceLayers[i].clear();
     }
 
-    Debug::log(LOG, "Removed monitor {}!", szName);
+    Debug::log(LOG, "Removed monitor {}!", m_name);
 
     if (!BACKUPMON) {
         Debug::log(WARN, "Unplugged last monitor, entering an unsafe state. Good luck my friend.");
         g_pCompositor->enterUnsafeState();
     }
 
-    m_bEnabled             = false;
-    m_bRenderingInitPassed = false;
+    m_enabled             = false;
+    m_renderingInitPassed = false;
 
     if (BACKUPMON) {
         // snap cursor
-        g_pCompositor->warpCursorTo(BACKUPMON->vecPosition + BACKUPMON->vecTransformedSize / 2.F, true);
+        g_pCompositor->warpCursorTo(BACKUPMON->m_position + BACKUPMON->m_transformedSize / 2.F, true);
 
         // move workspaces
         std::vector<PHLWORKSPACE> wspToMove;
         for (auto const& w : g_pCompositor->m_workspaces) {
-            if (w->m_monitor == self || !w->m_monitor)
+            if (w->m_monitor == m_self || !w->m_monitor)
                 wspToMove.push_back(w);
         }
 
         for (auto const& w : wspToMove) {
-            w->m_lastMonitor = szName;
+            w->m_lastMonitor = m_name;
             g_pCompositor->moveWorkspaceToMonitor(w, BACKUPMON);
             w->startAnim(true, true, true);
         }
@@ -372,28 +372,28 @@ void CMonitor::onDisconnect(bool destroy) {
         g_pCompositor->m_lastMonitor.reset();
     }
 
-    if (activeWorkspace)
-        activeWorkspace->m_visible = false;
-    activeWorkspace.reset();
+    if (m_activeWorkspace)
+        m_activeWorkspace->m_visible = false;
+    m_activeWorkspace.reset();
 
-    output->state->resetExplicitFences();
-    output->state->setAdaptiveSync(false);
-    output->state->setEnabled(false);
+    m_output->state->resetExplicitFences();
+    m_output->state->setAdaptiveSync(false);
+    m_output->state->setEnabled(false);
 
-    if (!state.commit())
+    if (!m_state.commit())
         Debug::log(WARN, "state.commit() failed in CMonitor::onDisconnect");
 
-    if (g_pCompositor->m_lastMonitor == self)
+    if (g_pCompositor->m_lastMonitor == m_self)
         g_pCompositor->setActiveMonitor(BACKUPMON ? BACKUPMON : g_pCompositor->m_unsafeOutput.lock());
 
-    if (g_pHyprRenderer->m_pMostHzMonitor == self) {
+    if (g_pHyprRenderer->m_pMostHzMonitor == m_self) {
         int        mostHz         = 0;
         PHLMONITOR pMonitorMostHz = nullptr;
 
         for (auto const& m : g_pCompositor->m_monitors) {
-            if (m->refreshRate > mostHz && m != self) {
+            if (m->m_refreshRate > mostHz && m != m_self) {
                 pMonitorMostHz = m;
-                mostHz         = m->refreshRate;
+                mostHz         = m->m_refreshRate;
             }
         }
 
@@ -406,44 +406,44 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
 
     static auto PDISABLESCALECHECKS = CConfigValue<Hyprlang::INT>("debug:disable_scale_checks");
 
-    Debug::log(LOG, "Applying monitor rule for {}", szName);
+    Debug::log(LOG, "Applying monitor rule for {}", m_name);
 
-    activeMonitorRule = *pMonitorRule;
+    m_activeMonitorRule = *pMonitorRule;
 
-    if (forceSize.has_value())
-        activeMonitorRule.resolution = forceSize.value();
+    if (m_forceSize.has_value())
+        m_activeMonitorRule.resolution = m_forceSize.value();
 
-    const auto RULE = &activeMonitorRule;
+    const auto RULE = &m_activeMonitorRule;
 
     // if it's disabled, disable and ignore
     if (RULE->disabled) {
-        if (m_bEnabled)
+        if (m_enabled)
             onDisconnect();
 
-        events.modeChanged.emit();
+        m_events.modeChanged.emit();
 
         return true;
     }
 
     // don't touch VR headsets
-    if (output->nonDesktop)
+    if (m_output->nonDesktop)
         return true;
 
-    if (!m_bEnabled) {
+    if (!m_enabled) {
         onConnect(true); // enable it.
-        Debug::log(LOG, "Monitor {} is disabled but is requested to be enabled", szName);
+        Debug::log(LOG, "Monitor {} is disabled but is requested to be enabled", m_name);
         force = true;
     }
 
     // Check if the rule isn't already applied
     // TODO: clean this up lol
-    if (!force && DELTALESSTHAN(vecPixelSize.x, RULE->resolution.x, 1) && DELTALESSTHAN(vecPixelSize.y, RULE->resolution.y, 1) &&
-        DELTALESSTHAN(refreshRate, RULE->refreshRate, 1) && setScale == RULE->scale &&
-        ((DELTALESSTHAN(vecPosition.x, RULE->offset.x, 1) && DELTALESSTHAN(vecPosition.y, RULE->offset.y, 1)) || RULE->offset == Vector2D(-INT32_MAX, -INT32_MAX)) &&
-        transform == RULE->transform && RULE->enable10bit == enabled10bit && RULE->cmType == cmType && RULE->sdrSaturation == sdrSaturation &&
-        RULE->sdrBrightness == sdrBrightness && !std::memcmp(&customDrmMode, &RULE->drmMode, sizeof(customDrmMode))) {
+    if (!force && DELTALESSTHAN(m_pixelSize.x, RULE->resolution.x, 1) && DELTALESSTHAN(m_pixelSize.y, RULE->resolution.y, 1) &&
+        DELTALESSTHAN(m_refreshRate, RULE->refreshRate, 1) && m_setScale == RULE->scale &&
+        ((DELTALESSTHAN(m_position.x, RULE->offset.x, 1) && DELTALESSTHAN(m_position.y, RULE->offset.y, 1)) || RULE->offset == Vector2D(-INT32_MAX, -INT32_MAX)) &&
+        m_transform == RULE->transform && RULE->enable10bit == m_enabled10bit && RULE->cmType == m_cmType && RULE->sdrSaturation == m_sdrSaturation &&
+        RULE->sdrBrightness == m_sdrBrightness && !std::memcmp(&m_customDrmMode, &RULE->drmMode, sizeof(m_customDrmMode))) {
 
-        Debug::log(LOG, "Not applying a new rule to {} because it's already applied!", szName);
+        Debug::log(LOG, "Not applying a new rule to {} because it's already applied!", m_name);
 
         setMirror(RULE->mirrorOf);
 
@@ -453,15 +453,15 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
     bool autoScale = false;
 
     if (RULE->scale > 0.1) {
-        scale = RULE->scale;
+        m_scale = RULE->scale;
     } else {
         autoScale               = true;
         const auto DEFAULTSCALE = getDefaultScale();
-        scale                   = DEFAULTSCALE;
+        m_scale                 = DEFAULTSCALE;
     }
 
-    setScale  = scale;
-    transform = RULE->transform;
+    m_setScale  = m_scale;
+    m_transform = RULE->transform;
 
     // accumulate requested modes in reverse order (cause inesrting at front is inefficient)
     std::vector<SP<Aquamarine::SOutputMode>> requestedModes;
@@ -469,7 +469,7 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
 
     // use sortFunc, add best 3 to requestedModes in reverse, since we test in reverse
     auto addBest3Modes = [&](auto const& sortFunc) {
-        auto sortedModes = output->modes;
+        auto sortedModes = m_output->modes;
         std::ranges::sort(sortedModes, sortFunc);
         if (sortedModes.size() > 3)
             sortedModes.erase(sortedModes.begin() + 3, sortedModes.end());
@@ -477,22 +477,22 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
     };
 
     // last fallback is always preferred mode
-    if (!output->preferredMode())
-        Debug::log(ERR, "Monitor {} has NO PREFERRED MODE", output->name);
+    if (!m_output->preferredMode())
+        Debug::log(ERR, "Monitor {} has NO PREFERRED MODE", m_output->name);
     else
-        requestedModes.push_back(output->preferredMode());
+        requestedModes.push_back(m_output->preferredMode());
 
     if (RULE->resolution == Vector2D()) {
         requestedStr = "preferred";
 
         // fallback to first 3 modes if preferred fails/doesn't exist
-        requestedModes = output->modes;
+        requestedModes = m_output->modes;
         if (requestedModes.size() > 3)
             requestedModes.erase(requestedModes.begin() + 3, requestedModes.end());
         std::ranges::reverse(requestedModes.begin(), requestedModes.end());
 
-        if (output->preferredMode())
-            requestedModes.push_back(output->preferredMode());
+        if (m_output->preferredMode())
+            requestedModes.push_back(m_output->preferredMode());
     } else if (RULE->resolution == Vector2D(-1, -1)) {
         requestedStr = "highrr";
 
@@ -541,7 +541,7 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
 
         // then if requested is custom, try custom mode first
         if (RULE->drmMode.type == DRM_MODE_TYPE_USERDEF) {
-            if (output->getBackend()->type() != Aquamarine::eBackendType::AQ_BACKEND_DRM)
+            if (m_output->getBackend()->type() != Aquamarine::eBackendType::AQ_BACKEND_DRM)
                 Debug::log(ERR, "Tried to set custom modeline on non-DRM output");
             else
                 requestedModes.push_back(makeShared<Aquamarine::SOutputMode>(
@@ -549,21 +549,21 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
         }
     }
 
-    const auto WAS10B  = enabled10bit;
-    const auto OLDRES  = vecPixelSize;
+    const auto WAS10B  = m_enabled10bit;
+    const auto OLDRES  = m_pixelSize;
     bool       success = false;
 
     // Needed in case we are switching from a custom modeline to a standard mode
-    customDrmMode = {};
-    currentMode   = nullptr;
+    m_customDrmMode = {};
+    m_currentMode   = nullptr;
 
-    output->state->setFormat(DRM_FORMAT_XRGB8888);
-    prevDrmFormat = drmFormat;
-    drmFormat     = DRM_FORMAT_XRGB8888;
-    output->state->resetExplicitFences();
+    m_output->state->setFormat(DRM_FORMAT_XRGB8888);
+    m_prevDrmFormat = m_drmFormat;
+    m_drmFormat     = DRM_FORMAT_XRGB8888;
+    m_output->state->resetExplicitFences();
 
     if (Debug::m_trace) {
-        Debug::log(TRACE, "Monitor {} requested modes:", szName);
+        Debug::log(TRACE, "Monitor {} requested modes:", m_name);
         if (requestedModes.empty())
             Debug::log(TRACE, "| None");
         else {
@@ -577,81 +577,81 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
         std::string modeStr = std::format("{:X0}@{:.2f}Hz", mode->pixelSize, mode->refreshRate / 1000.f);
 
         if (mode->modeInfo.has_value() && mode->modeInfo->type == DRM_MODE_TYPE_USERDEF) {
-            output->state->setCustomMode(mode);
+            m_output->state->setCustomMode(mode);
 
-            if (!state.test()) {
-                Debug::log(ERR, "Monitor {}: REJECTED custom mode {}!", szName, modeStr);
+            if (!m_state.test()) {
+                Debug::log(ERR, "Monitor {}: REJECTED custom mode {}!", m_name, modeStr);
                 continue;
             }
 
-            customDrmMode = mode->modeInfo.value();
+            m_customDrmMode = mode->modeInfo.value();
         } else {
-            output->state->setMode(mode);
+            m_output->state->setMode(mode);
 
-            if (!state.test()) {
-                Debug::log(ERR, "Monitor {}: REJECTED available mode {}!", szName, modeStr);
+            if (!m_state.test()) {
+                Debug::log(ERR, "Monitor {}: REJECTED available mode {}!", m_name, modeStr);
                 if (mode->preferred)
-                    Debug::log(ERR, "Monitor {}: REJECTED preferred mode!!!", szName);
+                    Debug::log(ERR, "Monitor {}: REJECTED preferred mode!!!", m_name);
                 continue;
             }
 
-            customDrmMode = {};
+            m_customDrmMode = {};
         }
 
-        refreshRate = mode->refreshRate / 1000.f;
-        vecSize     = mode->pixelSize;
-        currentMode = mode;
+        m_refreshRate = mode->refreshRate / 1000.f;
+        m_size        = mode->pixelSize;
+        m_currentMode = mode;
 
         success = true;
 
         if (mode->preferred)
-            Debug::log(LOG, "Monitor {}: requested {}, using preferred mode {}", szName, requestedStr, modeStr);
+            Debug::log(LOG, "Monitor {}: requested {}, using preferred mode {}", m_name, requestedStr, modeStr);
         else if (mode->modeInfo.has_value() && mode->modeInfo->type == DRM_MODE_TYPE_USERDEF)
-            Debug::log(LOG, "Monitor {}: requested {}, using custom mode {}", szName, requestedStr, modeStr);
+            Debug::log(LOG, "Monitor {}: requested {}, using custom mode {}", m_name, requestedStr, modeStr);
         else
-            Debug::log(LOG, "Monitor {}: requested {}, using available mode {}", szName, requestedStr, modeStr);
+            Debug::log(LOG, "Monitor {}: requested {}, using available mode {}", m_name, requestedStr, modeStr);
 
         break;
     }
 
     // try requested as custom mode jic it works
     if (!success && RULE->resolution != Vector2D() && RULE->resolution != Vector2D(-1, -1) && RULE->resolution != Vector2D(-1, -2)) {
-        auto        refreshRate = output->getBackend()->type() == Aquamarine::eBackendType::AQ_BACKEND_DRM ? RULE->refreshRate * 1000 : 0;
+        auto        refreshRate = m_output->getBackend()->type() == Aquamarine::eBackendType::AQ_BACKEND_DRM ? RULE->refreshRate * 1000 : 0;
         auto        mode        = makeShared<Aquamarine::SOutputMode>(Aquamarine::SOutputMode{.pixelSize = RULE->resolution, .refreshRate = refreshRate});
         std::string modeStr     = std::format("{:X0}@{:.2f}Hz", mode->pixelSize, mode->refreshRate / 1000.f);
 
-        output->state->setCustomMode(mode);
+        m_output->state->setCustomMode(mode);
 
-        if (state.test()) {
-            Debug::log(LOG, "Monitor {}: requested {}, using custom mode {}", szName, requestedStr, modeStr);
+        if (m_state.test()) {
+            Debug::log(LOG, "Monitor {}: requested {}, using custom mode {}", m_name, requestedStr, modeStr);
 
-            refreshRate   = mode->refreshRate / 1000.f;
-            vecSize       = mode->pixelSize;
-            currentMode   = mode;
-            customDrmMode = {};
+            refreshRate     = mode->refreshRate / 1000.f;
+            m_size          = mode->pixelSize;
+            m_currentMode   = mode;
+            m_customDrmMode = {};
 
             success = true;
         } else
-            Debug::log(ERR, "Monitor {}: REJECTED custom mode {}!", szName, modeStr);
+            Debug::log(ERR, "Monitor {}: REJECTED custom mode {}!", m_name, modeStr);
     }
 
     // try any of the modes if none of the above work
     if (!success) {
-        for (auto const& mode : output->modes) {
-            output->state->setMode(mode);
+        for (auto const& mode : m_output->modes) {
+            m_output->state->setMode(mode);
 
-            if (!state.test())
+            if (!m_state.test())
                 continue;
 
             auto errorMessage =
-                std::format("Monitor {} failed to set any requested modes, falling back to mode {:X0}@{:.2f}Hz", szName, mode->pixelSize, mode->refreshRate / 1000.f);
+                std::format("Monitor {} failed to set any requested modes, falling back to mode {:X0}@{:.2f}Hz", m_name, mode->pixelSize, mode->refreshRate / 1000.f);
             Debug::log(WARN, errorMessage);
             g_pHyprNotificationOverlay->addNotification(errorMessage, CHyprColor(0xff0000ff), 5000, ICON_WARNING);
 
-            refreshRate   = mode->refreshRate / 1000.f;
-            vecSize       = mode->pixelSize;
-            currentMode   = mode;
-            customDrmMode = {};
+            m_refreshRate   = mode->refreshRate / 1000.f;
+            m_size          = mode->pixelSize;
+            m_currentMode   = mode;
+            m_customDrmMode = {};
 
             success = true;
 
@@ -660,14 +660,14 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
     }
 
     if (!success) {
-        Debug::log(ERR, "Monitor {} has NO FALLBACK MODES, and an INVALID one was requested: {:X0}@{:.2f}Hz", szName, RULE->resolution, RULE->refreshRate);
+        Debug::log(ERR, "Monitor {} has NO FALLBACK MODES, and an INVALID one was requested: {:X0}@{:.2f}Hz", m_name, RULE->resolution, RULE->refreshRate);
         return true;
     }
 
-    vrrActive = output->state->state().adaptiveSync // disabled here, will be tested in CConfigManager::ensureVRR()
-        || createdByUser;                           // wayland backend doesn't allow for disabling adaptive_sync
+    m_vrrActive = m_output->state->state().adaptiveSync // disabled here, will be tested in CConfigManager::ensureVRR()
+        || m_createdByUser;                             // wayland backend doesn't allow for disabling adaptive_sync
 
-    vecPixelSize = vecSize;
+    m_pixelSize = m_size;
 
     // clang-format off
     static const std::array<std::vector<std::pair<std::string, uint32_t>>, 2> formats{
@@ -683,102 +683,102 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
     bool set10bit = false;
 
     for (auto const& fmt : formats[(int)!RULE->enable10bit]) {
-        output->state->setFormat(fmt.second);
-        prevDrmFormat = drmFormat;
-        drmFormat     = fmt.second;
+        m_output->state->setFormat(fmt.second);
+        m_prevDrmFormat = m_drmFormat;
+        m_drmFormat     = fmt.second;
 
-        if (!state.test()) {
-            Debug::log(ERR, "output {} failed basic test on format {}", szName, fmt.first);
+        if (!m_state.test()) {
+            Debug::log(ERR, "output {} failed basic test on format {}", m_name, fmt.first);
         } else {
-            Debug::log(LOG, "output {} succeeded basic test on format {}", szName, fmt.first);
+            Debug::log(LOG, "output {} succeeded basic test on format {}", m_name, fmt.first);
             if (RULE->enable10bit && fmt.first.contains("101010"))
                 set10bit = true;
             break;
         }
     }
 
-    enabled10bit = set10bit;
+    m_enabled10bit = set10bit;
 
-    auto oldImageDescription = imageDescription;
-    cmType                   = RULE->cmType;
-    switch (cmType) {
-        case CM_AUTO: cmType = enabled10bit && output->parsedEDID.supportsBT2020 ? CM_WIDE : CM_SRGB; break;
-        case CM_EDID: cmType = output->parsedEDID.chromaticityCoords.has_value() ? CM_EDID : CM_SRGB; break;
+    auto oldImageDescription = m_imageDescription;
+    m_cmType                 = RULE->cmType;
+    switch (m_cmType) {
+        case CM_AUTO: m_cmType = m_enabled10bit && m_output->parsedEDID.supportsBT2020 ? CM_WIDE : CM_SRGB; break;
+        case CM_EDID: m_cmType = m_output->parsedEDID.chromaticityCoords.has_value() ? CM_EDID : CM_SRGB; break;
         case CM_HDR:
         case CM_HDR_EDID:
-            cmType = output->parsedEDID.supportsBT2020 && output->parsedEDID.hdrMetadata.has_value() && output->parsedEDID.hdrMetadata->supportsPQ ? cmType : CM_SRGB;
+            m_cmType = m_output->parsedEDID.supportsBT2020 && m_output->parsedEDID.hdrMetadata.has_value() && m_output->parsedEDID.hdrMetadata->supportsPQ ? m_cmType : CM_SRGB;
             break;
         default: break;
     }
-    switch (cmType) {
-        case CM_SRGB: imageDescription = {}; break; // assumes SImageDescirption defaults to sRGB
+    switch (m_cmType) {
+        case CM_SRGB: m_imageDescription = {}; break; // assumes SImageDescirption defaults to sRGB
         case CM_WIDE:
-            imageDescription = {.primariesNameSet = true,
-                                .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
-                                .primaries        = NColorManagement::getPrimaries(NColorManagement::CM_PRIMARIES_BT2020)};
+            m_imageDescription = {.primariesNameSet = true,
+                                  .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
+                                  .primaries        = NColorManagement::getPrimaries(NColorManagement::CM_PRIMARIES_BT2020)};
             break;
         case CM_EDID:
-            imageDescription = {.primariesNameSet = false,
-                                .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
-                                .primaries        = {
-                                           .red   = {.x = output->parsedEDID.chromaticityCoords->red.x, .y = output->parsedEDID.chromaticityCoords->red.y},
-                                           .green = {.x = output->parsedEDID.chromaticityCoords->green.x, .y = output->parsedEDID.chromaticityCoords->green.y},
-                                           .blue  = {.x = output->parsedEDID.chromaticityCoords->blue.x, .y = output->parsedEDID.chromaticityCoords->blue.y},
-                                           .white = {.x = output->parsedEDID.chromaticityCoords->white.x, .y = output->parsedEDID.chromaticityCoords->white.y},
-                                }};
+            m_imageDescription = {.primariesNameSet = false,
+                                  .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
+                                  .primaries        = {
+                                             .red   = {.x = m_output->parsedEDID.chromaticityCoords->red.x, .y = m_output->parsedEDID.chromaticityCoords->red.y},
+                                             .green = {.x = m_output->parsedEDID.chromaticityCoords->green.x, .y = m_output->parsedEDID.chromaticityCoords->green.y},
+                                             .blue  = {.x = m_output->parsedEDID.chromaticityCoords->blue.x, .y = m_output->parsedEDID.chromaticityCoords->blue.y},
+                                             .white = {.x = m_output->parsedEDID.chromaticityCoords->white.x, .y = m_output->parsedEDID.chromaticityCoords->white.y},
+                                  }};
             break;
         case CM_HDR:
-            imageDescription = {.transferFunction = NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ,
-                                .primariesNameSet = true,
-                                .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
-                                .primaries        = NColorManagement::getPrimaries(NColorManagement::CM_PRIMARIES_BT2020),
-                                .luminances       = {.min = 0, .max = 10000, .reference = 203}};
+            m_imageDescription = {.transferFunction = NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ,
+                                  .primariesNameSet = true,
+                                  .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
+                                  .primaries        = NColorManagement::getPrimaries(NColorManagement::CM_PRIMARIES_BT2020),
+                                  .luminances       = {.min = 0, .max = 10000, .reference = 203}};
             break;
         case CM_HDR_EDID:
-            imageDescription = {.transferFunction = NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ,
-                                .primariesNameSet = false,
-                                .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
-                                .primaries        = output->parsedEDID.chromaticityCoords.has_value() ?
-                                           NColorManagement::SPCPRimaries{
-                                               .red   = {.x = output->parsedEDID.chromaticityCoords->red.x, .y = output->parsedEDID.chromaticityCoords->red.y},
-                                               .green = {.x = output->parsedEDID.chromaticityCoords->green.x, .y = output->parsedEDID.chromaticityCoords->green.y},
-                                               .blue  = {.x = output->parsedEDID.chromaticityCoords->blue.x, .y = output->parsedEDID.chromaticityCoords->blue.y},
-                                               .white = {.x = output->parsedEDID.chromaticityCoords->white.x, .y = output->parsedEDID.chromaticityCoords->white.y},
-                                    } :
-                                           NColorManagement::getPrimaries(NColorManagement::CM_PRIMARIES_BT2020),
-                                .luminances       = {.min       = output->parsedEDID.hdrMetadata->desiredContentMinLuminance,
-                                                     .max       = output->parsedEDID.hdrMetadata->desiredContentMaxLuminance,
-                                                     .reference = output->parsedEDID.hdrMetadata->desiredMaxFrameAverageLuminance}};
+            m_imageDescription = {.transferFunction = NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ,
+                                  .primariesNameSet = false,
+                                  .primariesNamed   = NColorManagement::CM_PRIMARIES_BT2020,
+                                  .primaries        = m_output->parsedEDID.chromaticityCoords.has_value() ?
+                                             NColorManagement::SPCPRimaries{
+                                                 .red   = {.x = m_output->parsedEDID.chromaticityCoords->red.x, .y = m_output->parsedEDID.chromaticityCoords->red.y},
+                                                 .green = {.x = m_output->parsedEDID.chromaticityCoords->green.x, .y = m_output->parsedEDID.chromaticityCoords->green.y},
+                                                 .blue  = {.x = m_output->parsedEDID.chromaticityCoords->blue.x, .y = m_output->parsedEDID.chromaticityCoords->blue.y},
+                                                 .white = {.x = m_output->parsedEDID.chromaticityCoords->white.x, .y = m_output->parsedEDID.chromaticityCoords->white.y},
+                                      } :
+                                             NColorManagement::getPrimaries(NColorManagement::CM_PRIMARIES_BT2020),
+                                  .luminances       = {.min       = m_output->parsedEDID.hdrMetadata->desiredContentMinLuminance,
+                                                       .max       = m_output->parsedEDID.hdrMetadata->desiredContentMaxLuminance,
+                                                       .reference = m_output->parsedEDID.hdrMetadata->desiredMaxFrameAverageLuminance}};
 
             break;
         default: UNREACHABLE();
     }
-    if (oldImageDescription != imageDescription)
-        PROTO::colorManagement->onMonitorImageDescriptionChanged(self);
+    if (oldImageDescription != m_imageDescription)
+        PROTO::colorManagement->onMonitorImageDescriptionChanged(m_self);
 
-    sdrSaturation = RULE->sdrSaturation;
-    sdrBrightness = RULE->sdrBrightness;
+    m_sdrSaturation = RULE->sdrSaturation;
+    m_sdrBrightness = RULE->sdrBrightness;
 
-    Vector2D logicalSize = vecPixelSize / scale;
+    Vector2D logicalSize = m_pixelSize / m_scale;
     if (!*PDISABLESCALECHECKS && (logicalSize.x != std::round(logicalSize.x) || logicalSize.y != std::round(logicalSize.y))) {
         // invalid scale, will produce fractional pixels.
         // find the nearest valid.
 
-        float    searchScale = std::round(scale * 120.0);
+        float    searchScale = std::round(m_scale * 120.0);
         bool     found       = false;
 
         double   scaleZero = searchScale / 120.0;
 
-        Vector2D logicalZero = vecPixelSize / scaleZero;
+        Vector2D logicalZero = m_pixelSize / scaleZero;
         if (logicalZero == logicalZero.round())
-            scale = scaleZero;
+            m_scale = scaleZero;
         else {
             for (size_t i = 1; i < 90; ++i) {
                 double   scaleUp   = (searchScale + i) / 120.0;
                 double   scaleDown = (searchScale - i) / 120.0;
 
-                Vector2D logicalUp   = vecPixelSize / scaleUp;
-                Vector2D logicalDown = vecPixelSize / scaleDown;
+                Vector2D logicalUp   = m_pixelSize / scaleUp;
+                Vector2D logicalDown = m_pixelSize / scaleDown;
 
                 if (logicalUp == logicalUp.round()) {
                     found       = true;
@@ -794,48 +794,48 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
 
             if (!found) {
                 if (autoScale)
-                    scale = std::round(scaleZero);
+                    m_scale = std::round(scaleZero);
                 else {
-                    Debug::log(ERR, "Invalid scale passed to monitor, {} failed to find a clean divisor", scale);
-                    g_pConfigManager->addParseError("Invalid scale passed to monitor " + szName + ", failed to find a clean divisor");
-                    scale = getDefaultScale();
+                    Debug::log(ERR, "Invalid scale passed to monitor, {} failed to find a clean divisor", m_scale);
+                    g_pConfigManager->addParseError("Invalid scale passed to monitor " + m_name + ", failed to find a clean divisor");
+                    m_scale = getDefaultScale();
                 }
             } else {
                 if (!autoScale) {
-                    Debug::log(ERR, "Invalid scale passed to monitor, {} found suggestion {}", scale, searchScale);
+                    Debug::log(ERR, "Invalid scale passed to monitor, {} found suggestion {}", m_scale, searchScale);
                     g_pConfigManager->addParseError(
-                        std::format("Invalid scale passed to monitor {}, failed to find a clean divisor. Suggested nearest scale: {:5f}", szName, searchScale));
-                    scale = getDefaultScale();
+                        std::format("Invalid scale passed to monitor {}, failed to find a clean divisor. Suggested nearest scale: {:5f}", m_name, searchScale));
+                    m_scale = getDefaultScale();
                 } else
-                    scale = searchScale;
+                    m_scale = searchScale;
             }
         }
     }
 
-    output->scheduleFrame();
+    m_output->scheduleFrame();
 
-    if (!state.commit())
-        Debug::log(ERR, "Couldn't commit output named {}", output->name);
+    if (!m_state.commit())
+        Debug::log(ERR, "Couldn't commit output named {}", m_output->name);
 
-    Vector2D xfmd      = transform % 2 == 1 ? Vector2D{vecPixelSize.y, vecPixelSize.x} : vecPixelSize;
-    vecSize            = (xfmd / scale).round();
-    vecTransformedSize = xfmd;
+    Vector2D xfmd     = m_transform % 2 == 1 ? Vector2D{m_pixelSize.y, m_pixelSize.x} : m_pixelSize;
+    m_size            = (xfmd / m_scale).round();
+    m_transformedSize = xfmd;
 
-    if (createdByUser) {
-        CBox transformedBox = {0, 0, vecTransformedSize.x, vecTransformedSize.y};
-        transformedBox.transform(wlTransformToHyprutils(invertTransform(transform)), vecTransformedSize.x, vecTransformedSize.y);
+    if (m_createdByUser) {
+        CBox transformedBox = {0, 0, m_transformedSize.x, m_transformedSize.y};
+        transformedBox.transform(wlTransformToHyprutils(invertTransform(m_transform)), m_transformedSize.x, m_transformedSize.y);
 
-        vecPixelSize = Vector2D(transformedBox.width, transformedBox.height);
+        m_pixelSize = Vector2D(transformedBox.width, transformedBox.height);
     }
 
     updateMatrix();
 
-    if (WAS10B != enabled10bit || OLDRES != vecPixelSize)
-        g_pHyprOpenGL->destroyMonitorResources(self);
+    if (WAS10B != m_enabled10bit || OLDRES != m_pixelSize)
+        g_pHyprOpenGL->destroyMonitorResources(m_self);
 
     g_pCompositor->arrangeMonitors();
 
-    damage.setSize(vecTransformedSize);
+    m_damage.setSize(m_transformedSize);
 
     // Set scale for all surfaces on this monitor, needed for some clients
     // but not on unsafe state to avoid crashes
@@ -845,28 +845,28 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
         }
     }
     // updato us
-    g_pHyprRenderer->arrangeLayersForMonitor(ID);
+    g_pHyprRenderer->arrangeLayersForMonitor(m_id);
 
     // reload to fix mirrors
     g_pConfigManager->m_wantsMonitorReload = true;
 
-    Debug::log(LOG, "Monitor {} data dump: res {:X}@{:.2f}Hz, scale {:.2f}, transform {}, pos {:X}, 10b {}", szName, vecPixelSize, refreshRate, scale, (int)transform, vecPosition,
-               (int)enabled10bit);
+    Debug::log(LOG, "Monitor {} data dump: res {:X}@{:.2f}Hz, scale {:.2f}, transform {}, pos {:X}, 10b {}", m_name, m_pixelSize, m_refreshRate, m_scale, (int)m_transform,
+               m_position, (int)m_enabled10bit);
 
     EMIT_HOOK_EVENT("monitorLayoutChanged", nullptr);
 
-    events.modeChanged.emit();
+    m_events.modeChanged.emit();
 
     return true;
 }
 
 void CMonitor::addDamage(const pixman_region32_t* rg) {
     static auto PZOOMFACTOR = CConfigValue<Hyprlang::FLOAT>("cursor:zoom_factor");
-    if (*PZOOMFACTOR != 1.f && g_pCompositor->getMonitorFromCursor() == self) {
-        damage.damageEntire();
-        g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
-    } else if (damage.damage(rg))
-        g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
+    if (*PZOOMFACTOR != 1.f && g_pCompositor->getMonitorFromCursor() == m_self) {
+        m_damage.damageEntire();
+        g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
+    } else if (m_damage.damage(rg))
+        g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
 }
 
 void CMonitor::addDamage(const CRegion& rg) {
@@ -875,13 +875,13 @@ void CMonitor::addDamage(const CRegion& rg) {
 
 void CMonitor::addDamage(const CBox& box) {
     static auto PZOOMFACTOR = CConfigValue<Hyprlang::FLOAT>("cursor:zoom_factor");
-    if (*PZOOMFACTOR != 1.f && g_pCompositor->getMonitorFromCursor() == self) {
-        damage.damageEntire();
-        g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
+    if (*PZOOMFACTOR != 1.f && g_pCompositor->getMonitorFromCursor() == m_self) {
+        m_damage.damageEntire();
+        g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
     }
 
-    if (damage.damage(box))
-        g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
+    if (m_damage.damage(box))
+        g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_DAMAGE);
 }
 
 bool CMonitor::shouldSkipScheduleFrameOnMouseEvent() {
@@ -889,13 +889,13 @@ bool CMonitor::shouldSkipScheduleFrameOnMouseEvent() {
     static auto PMINRR   = CConfigValue<Hyprlang::INT>("cursor:min_refresh_rate");
 
     // skip scheduling extra frames for fullsreen apps with vrr
-    const bool shouldSkip = activeWorkspace && activeWorkspace->m_hasFullscreenWindow && activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN &&
-        (*PNOBREAK == 1 || (*PNOBREAK == 2 && activeWorkspace->getFullscreenWindow()->getContentType() == CONTENT_TYPE_GAME)) && output->state->state().adaptiveSync;
+    const bool shouldSkip = m_activeWorkspace && m_activeWorkspace->m_hasFullscreenWindow && m_activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN &&
+        (*PNOBREAK == 1 || (*PNOBREAK == 2 && m_activeWorkspace->getFullscreenWindow()->getContentType() == CONTENT_TYPE_GAME)) && m_output->state->state().adaptiveSync;
 
     // keep requested minimum refresh rate
-    if (shouldSkip && *PMINRR && lastPresentationTimer.getMillis() > 1000.0f / *PMINRR) {
+    if (shouldSkip && *PMINRR && m_lastPresentationTimer.getMillis() > 1000.0f / *PMINRR) {
         // damage whole screen because some previous cursor box damages were skipped
-        damage.damageEntire();
+        m_damage.damageEntire();
         return false;
     }
 
@@ -903,7 +903,7 @@ bool CMonitor::shouldSkipScheduleFrameOnMouseEvent() {
 }
 
 bool CMonitor::isMirror() {
-    return pMirrorOf != nullptr;
+    return m_mirrorOf != nullptr;
 }
 
 bool CMonitor::matchesStaticSelector(const std::string& selector) const {
@@ -911,10 +911,10 @@ bool CMonitor::matchesStaticSelector(const std::string& selector) const {
         // match by description
         const auto DESCRIPTIONSELECTOR = trim(selector.substr(5));
 
-        return szDescription.starts_with(DESCRIPTIONSELECTOR) || szShortDescription.starts_with(DESCRIPTIONSELECTOR);
+        return m_description.starts_with(DESCRIPTIONSELECTOR) || m_shortDescription.starts_with(DESCRIPTIONSELECTOR);
     } else {
         // match by selector
-        return szName == selector;
+        return m_name == selector;
     }
 }
 
@@ -923,7 +923,7 @@ WORKSPACEID CMonitor::findAvailableDefaultWS() {
         if (g_pCompositor->getWorkspaceByID(i))
             continue;
 
-        if (const auto BOUND = g_pConfigManager->getBoundMonitorStringForWS(std::to_string(i)); !BOUND.empty() && BOUND != szName)
+        if (const auto BOUND = g_pConfigManager->getBoundMonitorStringForWS(std::to_string(i)); !BOUND.empty() && BOUND != m_name)
             continue;
 
         return i;
@@ -936,10 +936,10 @@ void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
     // Workspace
     std::string newDefaultWorkspaceName = "";
     int64_t     wsID                    = WORKSPACE_INVALID;
-    if (g_pConfigManager->getDefaultWorkspaceFor(szName).empty())
+    if (g_pConfigManager->getDefaultWorkspaceFor(m_name).empty())
         wsID = findAvailableDefaultWS();
     else {
-        const auto ws           = getWorkspaceIDNameFromString(g_pConfigManager->getDefaultWorkspaceFor(szName));
+        const auto ws           = getWorkspaceIDNameFromString(g_pConfigManager->getDefaultWorkspaceFor(m_name));
         wsID                    = ws.id;
         newDefaultWorkspaceName = ws.name;
     }
@@ -948,7 +948,7 @@ void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
         wsID                    = g_pCompositor->m_workspaces.size() + 1;
         newDefaultWorkspaceName = std::to_string(wsID);
 
-        Debug::log(LOG, "Invalid workspace= directive name in monitor parsing, workspace name \"{}\" is invalid.", g_pConfigManager->getDefaultWorkspaceFor(szName));
+        Debug::log(LOG, "Invalid workspace= directive name in monitor parsing, workspace name \"{}\" is invalid.", g_pConfigManager->getDefaultWorkspaceFor(m_name));
     }
 
     auto PNEWWORKSPACE = g_pCompositor->getWorkspaceByID(wsID);
@@ -957,18 +957,18 @@ void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
 
     if (PNEWWORKSPACE) {
         // workspace exists, move it to the newly connected monitor
-        g_pCompositor->moveWorkspaceToMonitor(PNEWWORKSPACE, self.lock());
-        activeWorkspace = PNEWWORKSPACE;
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
+        g_pCompositor->moveWorkspaceToMonitor(PNEWWORKSPACE, m_self.lock());
+        m_activeWorkspace = PNEWWORKSPACE;
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_id);
         PNEWWORKSPACE->startAnim(true, true, true);
     } else {
         if (newDefaultWorkspaceName == "")
             newDefaultWorkspaceName = std::to_string(wsID);
 
-        PNEWWORKSPACE = g_pCompositor->m_workspaces.emplace_back(CWorkspace::create(wsID, self.lock(), newDefaultWorkspaceName));
+        PNEWWORKSPACE = g_pCompositor->m_workspaces.emplace_back(CWorkspace::create(wsID, m_self.lock(), newDefaultWorkspaceName));
     }
 
-    activeWorkspace = PNEWWORKSPACE;
+    m_activeWorkspace = PNEWWORKSPACE;
 
     PNEWWORKSPACE->setActive(true);
     PNEWWORKSPACE->m_visible     = true;
@@ -978,7 +978,7 @@ void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
 void CMonitor::setMirror(const std::string& mirrorOf) {
     const auto PMIRRORMON = g_pCompositor->getMonitorFromString(mirrorOf);
 
-    if (PMIRRORMON == pMirrorOf)
+    if (PMIRRORMON == m_mirrorOf)
         return;
 
     if (PMIRRORMON && PMIRRORMON->isMirror()) {
@@ -986,7 +986,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
         return;
     }
 
-    if (PMIRRORMON == self) {
+    if (PMIRRORMON == m_self) {
         Debug::log(ERR, "Cannot mirror self!");
         return;
     }
@@ -994,19 +994,19 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
     if (!PMIRRORMON) {
         // disable mirroring
 
-        if (pMirrorOf) {
-            pMirrorOf->mirrors.erase(std::find_if(pMirrorOf->mirrors.begin(), pMirrorOf->mirrors.end(), [&](const auto& other) { return other == self; }));
+        if (m_mirrorOf) {
+            m_mirrorOf->m_mirrors.erase(std::find_if(m_mirrorOf->m_mirrors.begin(), m_mirrorOf->m_mirrors.end(), [&](const auto& other) { return other == m_self; }));
 
             // unlock software for mirrored monitor
-            g_pPointerManager->unlockSoftwareForMonitor(pMirrorOf.lock());
+            g_pPointerManager->unlockSoftwareForMonitor(m_mirrorOf.lock());
         }
 
-        pMirrorOf.reset();
+        m_mirrorOf.reset();
 
         // set rule
-        const auto RULE = g_pConfigManager->getMonitorRuleFor(self.lock());
+        const auto RULE = g_pConfigManager->getMonitorRuleFor(m_self.lock());
 
-        vecPosition = RULE.offset;
+        m_position = RULE.offset;
 
         // push to mvmonitors
 
@@ -1014,7 +1014,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
 
         // find the wrap
         for (auto& m : g_pCompositor->m_realMonitors) {
-            if (m->ID == ID) {
+            if (m->m_id == m_id) {
                 thisWrapper = &m;
                 break;
             }
@@ -1041,7 +1041,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
         // move all the WS
         std::vector<PHLWORKSPACE> wspToMove;
         for (auto const& w : g_pCompositor->m_workspaces) {
-            if (w->m_monitor == self || !w->m_monitor)
+            if (w->m_monitor == m_self || !w->m_monitor)
                 wspToMove.push_back(w);
         }
 
@@ -1050,16 +1050,16 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
             w->startAnim(true, true, true);
         }
 
-        activeWorkspace.reset();
+        m_activeWorkspace.reset();
 
-        vecPosition = PMIRRORMON->vecPosition;
+        m_position = PMIRRORMON->m_position;
 
-        pMirrorOf = PMIRRORMON;
+        m_mirrorOf = PMIRRORMON;
 
-        pMirrorOf->mirrors.push_back(self);
+        m_mirrorOf->m_mirrors.push_back(m_self);
 
         // remove from mvmonitors
-        std::erase_if(g_pCompositor->m_monitors, [&](const auto& other) { return other == self; });
+        std::erase_if(g_pCompositor->m_monitors, [&](const auto& other) { return other == m_self; });
 
         g_pCompositor->arrangeMonitors();
 
@@ -1071,17 +1071,17 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
         g_pPointerManager->lockSoftwareForMonitor(PMIRRORMON);
     }
 
-    events.modeChanged.emit();
+    m_events.modeChanged.emit();
 }
 
 float CMonitor::getDefaultScale() {
-    if (!m_bEnabled)
+    if (!m_enabled)
         return 1;
 
     static constexpr double MMPERINCH = 25.4;
 
-    const auto              DIAGONALPX = sqrt(pow(vecPixelSize.x, 2) + pow(vecPixelSize.y, 2));
-    const auto              DIAGONALIN = sqrt(pow(output->physicalSize.x / MMPERINCH, 2) + pow(output->physicalSize.y / MMPERINCH, 2));
+    const auto              DIAGONALPX = sqrt(pow(m_pixelSize.x, 2) + pow(m_pixelSize.y, 2));
+    const auto              DIAGONALIN = sqrt(pow(m_output->physicalSize.x / MMPERINCH, 2) + pow(m_output->physicalSize.y / MMPERINCH, 2));
 
     const auto              PPI = DIAGONALPX / DIAGONALIN;
 
@@ -1097,22 +1097,22 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo
         return;
 
     if (pWorkspace->m_isSpecialWorkspace) {
-        if (activeSpecialWorkspace != pWorkspace) {
+        if (m_activeSpecialWorkspace != pWorkspace) {
             Debug::log(LOG, "changeworkspace on special, togglespecialworkspace to id {}", pWorkspace->m_id);
             setSpecialWorkspace(pWorkspace);
         }
         return;
     }
 
-    if (pWorkspace == activeWorkspace)
+    if (pWorkspace == m_activeWorkspace)
         return;
 
-    const auto POLDWORKSPACE = activeWorkspace;
+    const auto POLDWORKSPACE = m_activeWorkspace;
     if (POLDWORKSPACE)
         POLDWORKSPACE->m_visible = false;
     pWorkspace->m_visible = true;
 
-    activeWorkspace = pWorkspace;
+    m_activeWorkspace = pWorkspace;
 
     if (!internal) {
         const auto ANIMTOLEFT = POLDWORKSPACE && pWorkspace->m_id > POLDWORKSPACE->m_id;
@@ -1126,8 +1126,8 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo
                 w->moveToWorkspace(pWorkspace);
         }
 
-        if (!noFocus && !g_pCompositor->m_lastMonitor->activeSpecialWorkspace &&
-            !(g_pCompositor->m_lastWindow.lock() && g_pCompositor->m_lastWindow->m_pinned && g_pCompositor->m_lastWindow->m_monitor == self)) {
+        if (!noFocus && !g_pCompositor->m_lastMonitor->m_activeSpecialWorkspace &&
+            !(g_pCompositor->m_lastWindow.lock() && g_pCompositor->m_lastWindow->m_pinned && g_pCompositor->m_lastWindow->m_monitor == m_self)) {
             static auto PFOLLOWMOUSE = CConfigValue<Hyprlang::INT>("input:follow_mouse");
             auto        pWindow      = pWorkspace->m_hasFullscreenWindow ? pWorkspace->getFullscreenWindow() : pWorkspace->getLastFocusedWindow();
 
@@ -1148,23 +1148,23 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo
         if (!noMouseMove)
             g_pInputManager->simulateMouseMovement();
 
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_id);
 
         g_pEventManager->postEvent(SHyprIPCEvent{"workspace", pWorkspace->m_name});
         g_pEventManager->postEvent(SHyprIPCEvent{"workspacev2", std::format("{},{}", pWorkspace->m_id, pWorkspace->m_name)});
         EMIT_HOOK_EVENT("workspace", pWorkspace);
     }
 
-    g_pHyprRenderer->damageMonitor(self.lock());
+    g_pHyprRenderer->damageMonitor(m_self.lock());
 
     g_pCompositor->updateFullscreenFadeOnWorkspace(pWorkspace);
 
-    g_pConfigManager->ensureVRR(self.lock());
+    g_pConfigManager->ensureVRR(m_self.lock());
 
     g_pCompositor->updateSuspendedStates();
 
-    if (activeSpecialWorkspace)
-        g_pCompositor->updateFullscreenFadeOnWorkspace(activeSpecialWorkspace);
+    if (m_activeSpecialWorkspace)
+        g_pCompositor->updateFullscreenFadeOnWorkspace(m_activeSpecialWorkspace);
 }
 
 void CMonitor::changeWorkspace(const WORKSPACEID& id, bool internal, bool noMouseMove, bool noFocus) {
@@ -1172,83 +1172,83 @@ void CMonitor::changeWorkspace(const WORKSPACEID& id, bool internal, bool noMous
 }
 
 void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
-    if (activeSpecialWorkspace == pWorkspace)
+    if (m_activeSpecialWorkspace == pWorkspace)
         return;
 
-    g_pHyprRenderer->damageMonitor(self.lock());
+    g_pHyprRenderer->damageMonitor(m_self.lock());
 
     if (!pWorkspace) {
         // remove special if exists
-        if (activeSpecialWorkspace) {
-            activeSpecialWorkspace->m_visible = false;
-            activeSpecialWorkspace->startAnim(false, false);
-            g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + szName});
-            g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", ",," + szName});
+        if (m_activeSpecialWorkspace) {
+            m_activeSpecialWorkspace->m_visible = false;
+            m_activeSpecialWorkspace->startAnim(false, false);
+            g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + m_name});
+            g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", ",," + m_name});
         }
-        activeSpecialWorkspace.reset();
+        m_activeSpecialWorkspace.reset();
 
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_id);
 
-        if (!(g_pCompositor->m_lastWindow.lock() && g_pCompositor->m_lastWindow->m_pinned && g_pCompositor->m_lastWindow->m_monitor == self)) {
-            if (const auto PLAST = activeWorkspace->getLastFocusedWindow(); PLAST)
+        if (!(g_pCompositor->m_lastWindow.lock() && g_pCompositor->m_lastWindow->m_pinned && g_pCompositor->m_lastWindow->m_monitor == m_self)) {
+            if (const auto PLAST = m_activeWorkspace->getLastFocusedWindow(); PLAST)
                 g_pCompositor->focusWindow(PLAST);
             else
                 g_pInputManager->refocus();
         }
 
-        g_pCompositor->updateFullscreenFadeOnWorkspace(activeWorkspace);
+        g_pCompositor->updateFullscreenFadeOnWorkspace(m_activeWorkspace);
 
-        g_pConfigManager->ensureVRR(self.lock());
+        g_pConfigManager->ensureVRR(m_self.lock());
 
         g_pCompositor->updateSuspendedStates();
 
         return;
     }
 
-    if (activeSpecialWorkspace) {
-        activeSpecialWorkspace->m_visible = false;
-        activeSpecialWorkspace->startAnim(false, false);
+    if (m_activeSpecialWorkspace) {
+        m_activeSpecialWorkspace->m_visible = false;
+        m_activeSpecialWorkspace->startAnim(false, false);
     }
 
     bool animate = true;
     //close if open elsewhere
     const auto PMONITORWORKSPACEOWNER = pWorkspace->m_monitor.lock();
-    if (const auto PMWSOWNER = pWorkspace->m_monitor.lock(); PMWSOWNER && PMWSOWNER->activeSpecialWorkspace == pWorkspace) {
-        PMWSOWNER->activeSpecialWorkspace.reset();
-        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMWSOWNER->ID);
-        g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + PMWSOWNER->szName});
-        g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", ",," + PMWSOWNER->szName});
+    if (const auto PMWSOWNER = pWorkspace->m_monitor.lock(); PMWSOWNER && PMWSOWNER->m_activeSpecialWorkspace == pWorkspace) {
+        PMWSOWNER->m_activeSpecialWorkspace.reset();
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMWSOWNER->m_id);
+        g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + PMWSOWNER->m_name});
+        g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", ",," + PMWSOWNER->m_name});
 
-        const auto PACTIVEWORKSPACE = PMWSOWNER->activeWorkspace;
+        const auto PACTIVEWORKSPACE = PMWSOWNER->m_activeWorkspace;
         g_pCompositor->updateFullscreenFadeOnWorkspace(PACTIVEWORKSPACE);
 
         animate = false;
     }
 
     // open special
-    pWorkspace->m_monitor             = self;
-    activeSpecialWorkspace            = pWorkspace;
-    activeSpecialWorkspace->m_visible = true;
+    pWorkspace->m_monitor               = m_self;
+    m_activeSpecialWorkspace            = pWorkspace;
+    m_activeSpecialWorkspace->m_visible = true;
     if (animate)
         pWorkspace->startAnim(true, true);
 
     for (auto const& w : g_pCompositor->m_windows) {
         if (w->m_workspace == pWorkspace) {
-            w->m_monitor = self;
+            w->m_monitor = m_self;
             w->updateSurfaceScaleTransformDetails();
             w->setAnimationsToMove();
 
             const auto MIDDLE = w->middle();
-            if (w->m_isFloating && !VECINRECT(MIDDLE, vecPosition.x, vecPosition.y, vecPosition.x + vecSize.x, vecPosition.y + vecSize.y) && !w->isX11OverrideRedirect()) {
+            if (w->m_isFloating && !VECINRECT(MIDDLE, m_position.x, m_position.y, m_position.x + m_size.x, m_position.y + m_size.y) && !w->isX11OverrideRedirect()) {
                 // if it's floating and the middle isnt on the current mon, move it to the center
                 const auto PMONFROMMIDDLE = g_pCompositor->getMonitorFromVector(MIDDLE);
                 Vector2D   pos            = w->m_realPosition->goal();
-                if (!VECINRECT(MIDDLE, PMONFROMMIDDLE->vecPosition.x, PMONFROMMIDDLE->vecPosition.y, PMONFROMMIDDLE->vecPosition.x + PMONFROMMIDDLE->vecSize.x,
-                               PMONFROMMIDDLE->vecPosition.y + PMONFROMMIDDLE->vecSize.y)) {
+                if (!VECINRECT(MIDDLE, PMONFROMMIDDLE->m_position.x, PMONFROMMIDDLE->m_position.y, PMONFROMMIDDLE->m_position.x + PMONFROMMIDDLE->m_size.x,
+                               PMONFROMMIDDLE->m_position.y + PMONFROMMIDDLE->m_size.y)) {
                     // not on any monitor, center
                     pos = middle() / 2.f - w->m_realSize->goal() / 2.f;
                 } else
-                    pos = pos - PMONFROMMIDDLE->vecPosition + vecPosition;
+                    pos = pos - PMONFROMMIDDLE->m_position + m_position;
 
                 *w->m_realPosition = pos;
                 w->m_position      = pos;
@@ -1256,23 +1256,23 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
         }
     }
 
-    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
+    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_id);
 
-    if (!(g_pCompositor->m_lastWindow.lock() && g_pCompositor->m_lastWindow->m_pinned && g_pCompositor->m_lastWindow->m_monitor == self)) {
+    if (!(g_pCompositor->m_lastWindow.lock() && g_pCompositor->m_lastWindow->m_pinned && g_pCompositor->m_lastWindow->m_monitor == m_self)) {
         if (const auto PLAST = pWorkspace->getLastFocusedWindow(); PLAST)
             g_pCompositor->focusWindow(PLAST);
         else
             g_pInputManager->refocus();
     }
 
-    g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", pWorkspace->m_name + "," + szName});
-    g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", std::to_string(pWorkspace->m_id) + "," + pWorkspace->m_name + "," + szName});
+    g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", pWorkspace->m_name + "," + m_name});
+    g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", std::to_string(pWorkspace->m_id) + "," + pWorkspace->m_name + "," + m_name});
 
-    g_pHyprRenderer->damageMonitor(self.lock());
+    g_pHyprRenderer->damageMonitor(m_self.lock());
 
     g_pCompositor->updateFullscreenFadeOnWorkspace(pWorkspace);
 
-    g_pConfigManager->ensureVRR(self.lock());
+    g_pConfigManager->ensureVRR(m_self.lock());
 
     g_pCompositor->updateSuspendedStates();
 }
@@ -1282,19 +1282,19 @@ void CMonitor::setSpecialWorkspace(const WORKSPACEID& id) {
 }
 
 void CMonitor::moveTo(const Vector2D& pos) {
-    vecPosition = pos;
+    m_position = pos;
 }
 
 SWorkspaceIDName CMonitor::getPrevWorkspaceIDName(const WORKSPACEID id) {
-    while (!prevWorkSpaces.empty()) {
-        const int PREVID = prevWorkSpaces.top();
-        prevWorkSpaces.pop();
+    while (!m_prevWorkSpaces.empty()) {
+        const int PREVID = m_prevWorkSpaces.top();
+        m_prevWorkSpaces.pop();
         if (PREVID == id) // skip same workspace
             continue;
 
         // recheck if previous workspace's was moved to another monitor
         const auto ws = g_pCompositor->getWorkspaceByID(PREVID);
-        if (ws && ws->monitorID() == ID)
+        if (ws && ws->monitorID() == m_id)
             return {.id = PREVID, .name = ws->m_name};
     }
 
@@ -1302,66 +1302,66 @@ SWorkspaceIDName CMonitor::getPrevWorkspaceIDName(const WORKSPACEID id) {
 }
 
 void CMonitor::addPrevWorkspaceID(const WORKSPACEID id) {
-    if (!prevWorkSpaces.empty() && prevWorkSpaces.top() == id)
+    if (!m_prevWorkSpaces.empty() && m_prevWorkSpaces.top() == id)
         return;
 
-    prevWorkSpaces.emplace(id);
+    m_prevWorkSpaces.emplace(id);
 }
 
 Vector2D CMonitor::middle() {
-    return vecPosition + vecSize / 2.f;
+    return m_position + m_size / 2.f;
 }
 
 void CMonitor::updateMatrix() {
-    projMatrix = Mat3x3::identity();
-    if (transform != WL_OUTPUT_TRANSFORM_NORMAL)
-        projMatrix.translate(vecPixelSize / 2.0).transform(wlTransformToHyprutils(transform)).translate(-vecTransformedSize / 2.0);
+    m_projMatrix = Mat3x3::identity();
+    if (m_transform != WL_OUTPUT_TRANSFORM_NORMAL)
+        m_projMatrix.translate(m_pixelSize / 2.0).transform(wlTransformToHyprutils(m_transform)).translate(-m_transformedSize / 2.0);
 }
 
 WORKSPACEID CMonitor::activeWorkspaceID() {
-    return activeWorkspace ? activeWorkspace->m_id : 0;
+    return m_activeWorkspace ? m_activeWorkspace->m_id : 0;
 }
 
 WORKSPACEID CMonitor::activeSpecialWorkspaceID() {
-    return activeSpecialWorkspace ? activeSpecialWorkspace->m_id : 0;
+    return m_activeSpecialWorkspace ? m_activeSpecialWorkspace->m_id : 0;
 }
 
 CBox CMonitor::logicalBox() {
-    return {vecPosition, vecSize};
+    return {m_position, m_size};
 }
 
 void CMonitor::scheduleDone() {
-    if (doneScheduled)
+    if (m_doneScheduled)
         return;
 
-    doneScheduled = true;
+    m_doneScheduled = true;
 
-    g_pEventLoopManager->doLater([M = self] {
+    g_pEventLoopManager->doLater([M = m_self] {
         if (!M) // if M is gone, we got destroyed, doesn't matter.
             return;
 
-        if (!PROTO::outputs.contains(M->szName))
+        if (!PROTO::outputs.contains(M->m_name))
             return;
 
-        PROTO::outputs.at(M->szName)->sendDone();
-        M->doneScheduled = false;
+        PROTO::outputs.at(M->m_name)->sendDone();
+        M->m_doneScheduled = false;
     });
 }
 
 void CMonitor::setCTM(const Mat3x3& ctm_) {
-    ctm        = ctm_;
-    ctmUpdated = true;
-    g_pCompositor->scheduleFrameForMonitor(self.lock(), Aquamarine::IOutput::scheduleFrameReason::AQ_SCHEDULE_NEEDS_FRAME);
+    m_ctm        = ctm_;
+    m_ctmUpdated = true;
+    g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::scheduleFrameReason::AQ_SCHEDULE_NEEDS_FRAME);
 }
 
 bool CMonitor::attemptDirectScanout() {
-    if (!mirrors.empty() || isMirror() || g_pHyprRenderer->m_bDirectScanoutBlocked)
+    if (!m_mirrors.empty() || isMirror() || g_pHyprRenderer->m_bDirectScanoutBlocked)
         return false; // do not DS if this monitor is being mirrored. Will break the functionality.
 
-    if (g_pPointerManager->softwareLockedFor(self.lock()))
+    if (g_pPointerManager->softwareLockedFor(m_self.lock()))
         return false;
 
-    const auto PCANDIDATE = solitaryClient.lock();
+    const auto PCANDIDATE = m_solitaryClient.lock();
 
     if (!PCANDIDATE)
         return false;
@@ -1371,7 +1371,7 @@ bool CMonitor::attemptDirectScanout() {
     if (!PSURFACE || !PSURFACE->current.texture || !PSURFACE->current.buffer)
         return false;
 
-    if (PSURFACE->current.bufferSize != vecPixelSize || PSURFACE->current.transform != transform)
+    if (PSURFACE->current.bufferSize != m_pixelSize || PSURFACE->current.transform != m_transform)
         return false;
 
     // we can't scanout shm buffers.
@@ -1383,22 +1383,22 @@ bool CMonitor::attemptDirectScanout() {
 
     auto PBUFFER = PSURFACE->current.buffer.buffer;
 
-    if (PBUFFER == output->state->state().buffer) {
-        PSURFACE->presentFeedback(Time::steadyNow(), self.lock());
+    if (PBUFFER == m_output->state->state().buffer) {
+        PSURFACE->presentFeedback(Time::steadyNow(), m_self.lock());
 
-        if (scanoutNeedsCursorUpdate) {
-            if (!state.test()) {
+        if (m_scanoutNeedsCursorUpdate) {
+            if (!m_state.test()) {
                 Debug::log(TRACE, "attemptDirectScanout: failed basic test");
                 return false;
             }
 
-            if (!output->commit()) {
+            if (!m_output->commit()) {
                 Debug::log(TRACE, "attemptDirectScanout: failed to commit cursor update");
-                lastScanout.reset();
+                m_lastScanout.reset();
                 return false;
             }
 
-            scanoutNeedsCursorUpdate = false;
+            m_scanoutNeedsCursorUpdate = false;
         }
 
         return true;
@@ -1408,44 +1408,44 @@ bool CMonitor::attemptDirectScanout() {
     // and comes from the appropriate device. This may implode on multi-gpu!!
 
     // entering into scanout, so save monitor format
-    if (lastScanout.expired())
-        prevDrmFormat = drmFormat;
+    if (m_lastScanout.expired())
+        m_prevDrmFormat = m_drmFormat;
 
-    if (drmFormat != params.format) {
-        output->state->setFormat(params.format);
-        drmFormat = params.format;
+    if (m_drmFormat != params.format) {
+        m_output->state->setFormat(params.format);
+        m_drmFormat = params.format;
     }
 
-    output->state->setBuffer(PBUFFER);
-    output->state->setPresentationMode(tearingState.activelyTearing ? Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_IMMEDIATE :
-                                                                      Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_VSYNC);
+    m_output->state->setBuffer(PBUFFER);
+    m_output->state->setPresentationMode(m_tearingState.activelyTearing ? Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_IMMEDIATE :
+                                                                          Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_VSYNC);
 
-    if (!state.test()) {
+    if (!m_state.test()) {
         Debug::log(TRACE, "attemptDirectScanout: failed basic test");
         return false;
     }
 
-    PSURFACE->presentFeedback(Time::steadyNow(), self.lock());
+    PSURFACE->presentFeedback(Time::steadyNow(), m_self.lock());
 
-    output->state->addDamage(PSURFACE->current.accumulateBufferDamage());
-    output->state->resetExplicitFences();
+    m_output->state->addDamage(PSURFACE->current.accumulateBufferDamage());
+    m_output->state->resetExplicitFences();
 
     // no need to do explicit sync here as surface current can only ever be ready to read
 
-    bool ok = output->commit();
+    bool ok = m_output->commit();
 
     if (!ok) {
         Debug::log(TRACE, "attemptDirectScanout: failed to scanout surface");
-        lastScanout.reset();
+        m_lastScanout.reset();
         return false;
     }
 
-    if (lastScanout.expired()) {
-        lastScanout = PCANDIDATE;
+    if (m_lastScanout.expired()) {
+        m_lastScanout = PCANDIDATE;
         Debug::log(LOG, "Entered a direct scanout to {:x}: \"{}\"", (uintptr_t)PCANDIDATE.get(), PCANDIDATE->m_title);
     }
 
-    scanoutNeedsCursorUpdate = false;
+    m_scanoutNeedsCursorUpdate = false;
 
     if (!PBUFFER->lockedByBackend || PBUFFER->hlEvents.backendRelease)
         return true;
@@ -1459,16 +1459,17 @@ bool CMonitor::attemptDirectScanout() {
 }
 
 void CMonitor::debugLastPresentation(const std::string& message) {
-    Debug::log(TRACE, "{} (last presentation {} - {} fps)", message, lastPresentationTimer.getMillis(),
-               lastPresentationTimer.getMillis() > 0 ? 1000.0f / lastPresentationTimer.getMillis() : 0.0f);
+    Debug::log(TRACE, "{} (last presentation {} - {} fps)", message, m_lastPresentationTimer.getMillis(),
+               m_lastPresentationTimer.getMillis() > 0 ? 1000.0f / m_lastPresentationTimer.getMillis() : 0.0f);
 }
 
 void CMonitor::onMonitorFrame() {
     if ((g_pCompositor->m_aqBackend->hasSession() && !g_pCompositor->m_aqBackend->session->active) || !g_pCompositor->m_sessionActive || g_pCompositor->m_unsafeState) {
         Debug::log(WARN, "Attempted to render frame on inactive session!");
 
-        if (g_pCompositor->m_unsafeState &&
-            std::ranges::any_of(g_pCompositor->m_monitors.begin(), g_pCompositor->m_monitors.end(), [&](auto& m) { return m->output != g_pCompositor->m_unsafeOutput->output; })) {
+        if (g_pCompositor->m_unsafeState && std::ranges::any_of(g_pCompositor->m_monitors.begin(), g_pCompositor->m_monitors.end(), [&](auto& m) {
+                return m->m_output != g_pCompositor->m_unsafeOutput->m_output;
+            })) {
             // restore from unsafe state
             g_pCompositor->leaveUnsafeState();
         }
@@ -1476,57 +1477,57 @@ void CMonitor::onMonitorFrame() {
         return; // cannot draw on session inactive (different tty)
     }
 
-    if (!m_bEnabled)
+    if (!m_enabled)
         return;
 
-    g_pHyprRenderer->recheckSolitaryForMonitor(self.lock());
+    g_pHyprRenderer->recheckSolitaryForMonitor(m_self.lock());
 
-    tearingState.busy = false;
+    m_tearingState.busy = false;
 
-    if (tearingState.activelyTearing && solitaryClient.lock() /* can be invalidated by a recheck */) {
+    if (m_tearingState.activelyTearing && m_solitaryClient.lock() /* can be invalidated by a recheck */) {
 
-        if (!tearingState.frameScheduledWhileBusy)
+        if (!m_tearingState.frameScheduledWhileBusy)
             return; // we did not schedule a frame yet to be displayed, but we are tearing. Why render?
 
-        tearingState.nextRenderTorn          = true;
-        tearingState.frameScheduledWhileBusy = false;
+        m_tearingState.nextRenderTorn          = true;
+        m_tearingState.frameScheduledWhileBusy = false;
     }
 
     static auto PENABLERAT = CConfigValue<Hyprlang::INT>("misc:render_ahead_of_time");
     static auto PRATSAFE   = CConfigValue<Hyprlang::INT>("misc:render_ahead_safezone");
 
-    lastPresentationTimer.reset();
+    m_lastPresentationTimer.reset();
 
-    if (*PENABLERAT && !tearingState.nextRenderTorn) {
-        if (!RATScheduled) {
+    if (*PENABLERAT && !m_tearingState.nextRenderTorn) {
+        if (!m_ratsScheduled) {
             // render
-            g_pHyprRenderer->renderMonitor(self.lock());
+            g_pHyprRenderer->renderMonitor(m_self.lock());
         }
 
-        RATScheduled = false;
+        m_ratsScheduled = false;
 
-        const auto& [avg, max, min] = g_pHyprRenderer->getRenderTimes(self.lock());
+        const auto& [avg, max, min] = g_pHyprRenderer->getRenderTimes(m_self.lock());
 
-        if (max + *PRATSAFE > 1000.0 / refreshRate)
+        if (max + *PRATSAFE > 1000.0 / m_refreshRate)
             return;
 
-        const auto MSLEFT = 1000.0 / refreshRate - lastPresentationTimer.getMillis();
+        const auto MSLEFT = (1000.0 / m_refreshRate) - m_lastPresentationTimer.getMillis();
 
-        RATScheduled = true;
+        m_ratsScheduled = true;
 
         const auto ESTRENDERTIME = std::ceil(avg + *PRATSAFE);
         const auto TIMETOSLEEP   = std::floor(MSLEFT - ESTRENDERTIME);
 
         if (MSLEFT < 1 || MSLEFT < ESTRENDERTIME || TIMETOSLEEP < 1)
-            g_pHyprRenderer->renderMonitor(self.lock());
+            g_pHyprRenderer->renderMonitor(m_self.lock());
         else
-            wl_event_source_timer_update(renderTimer, TIMETOSLEEP);
+            wl_event_source_timer_update(m_renderTimer, TIMETOSLEEP);
     } else
-        g_pHyprRenderer->renderMonitor(self.lock());
+        g_pHyprRenderer->renderMonitor(m_self.lock());
 }
 
 void CMonitor::onCursorMovedOnMonitor() {
-    if (!tearingState.activelyTearing || !solitaryClient || !g_pHyprRenderer->shouldRenderCursor())
+    if (!m_tearingState.activelyTearing || !m_solitaryClient || !g_pHyprRenderer->shouldRenderCursor())
         return;
 
     // submit a frame immediately. This will only update the cursor pos.
@@ -1540,41 +1541,41 @@ void CMonitor::onCursorMovedOnMonitor() {
     // and throws a "nO pRoP cAn Be ChAnGeD dUrInG AsYnC fLiP" on crtc_x
     // this will throw too but fix it if we use sw cursors
 
-    tearingState.frameScheduledWhileBusy = true;
+    m_tearingState.frameScheduledWhileBusy = true;
 }
 
-CMonitorState::CMonitorState(CMonitor* owner) : m_pOwner(owner) {
+CMonitorState::CMonitorState(CMonitor* owner) : m_owner(owner) {
     ;
 }
 
 void CMonitorState::ensureBufferPresent() {
-    const auto STATE = m_pOwner->output->state->state();
+    const auto STATE = m_owner->m_output->state->state();
     if (!STATE.enabled) {
         Debug::log(TRACE, "CMonitorState::ensureBufferPresent: Ignoring, monitor is not enabled");
         return;
     }
 
     if (STATE.buffer) {
-        if (const auto params = STATE.buffer->dmabuf(); params.success && params.format == m_pOwner->drmFormat)
+        if (const auto params = STATE.buffer->dmabuf(); params.success && params.format == m_owner->m_drmFormat)
             return;
     }
 
     // this is required for modesetting being possible and might be missing in case of first tests in the renderer
     // where we test modes and buffers
     Debug::log(LOG, "CMonitorState::ensureBufferPresent: no buffer or mismatched format, attaching one from the swapchain for modeset being possible");
-    m_pOwner->output->state->setBuffer(m_pOwner->output->swapchain->next(nullptr));
-    m_pOwner->output->swapchain->rollback(); // restore the counter, don't advance the swapchain
+    m_owner->m_output->state->setBuffer(m_owner->m_output->swapchain->next(nullptr));
+    m_owner->m_output->swapchain->rollback(); // restore the counter, don't advance the swapchain
 }
 
 bool CMonitorState::commit() {
     if (!updateSwapchain())
         return false;
 
-    EMIT_HOOK_EVENT("preMonitorCommit", m_pOwner->self.lock());
+    EMIT_HOOK_EVENT("preMonitorCommit", m_owner->m_self.lock());
 
     ensureBufferPresent();
 
-    bool ret = m_pOwner->output->commit();
+    bool ret = m_owner->m_output->commit();
     return ret;
 }
 
@@ -1584,20 +1585,20 @@ bool CMonitorState::test() {
 
     ensureBufferPresent();
 
-    return m_pOwner->output->test();
+    return m_owner->m_output->test();
 }
 
 bool CMonitorState::updateSwapchain() {
-    auto        options = m_pOwner->output->swapchain->currentOptions();
-    const auto& STATE   = m_pOwner->output->state->state();
+    auto        options = m_owner->m_output->swapchain->currentOptions();
+    const auto& STATE   = m_owner->m_output->state->state();
     const auto& MODE    = STATE.mode ? STATE.mode : STATE.customMode;
     if (!MODE) {
         Debug::log(WARN, "updateSwapchain: No mode?");
         return true;
     }
-    options.format  = m_pOwner->drmFormat;
+    options.format  = m_owner->m_drmFormat;
     options.scanout = true;
     options.length  = 2;
     options.size    = MODE->pixelSize;
-    return m_pOwner->output->swapchain->reconfigure(options);
+    return m_owner->m_output->swapchain->reconfigure(options);
 }
diff --git a/src/helpers/Monitor.hpp b/src/helpers/Monitor.hpp
index 88252ab4..31777b0c 100644
--- a/src/helpers/Monitor.hpp
+++ b/src/helpers/Monitor.hpp
@@ -71,7 +71,7 @@ class CMonitorState {
   private:
     void      ensureBufferPresent();
 
-    CMonitor* m_pOwner = nullptr;
+    CMonitor* m_owner = nullptr;
 };
 
 class CMonitor {
@@ -79,84 +79,82 @@ class CMonitor {
     CMonitor(SP<Aquamarine::IOutput> output);
     ~CMonitor();
 
-    Vector2D                    vecPosition         = Vector2D(-1, -1); // means unset
-    Vector2D                    vecXWaylandPosition = Vector2D(-1, -1); // means unset
-    Vector2D                    vecSize             = Vector2D(0, 0);
-    Vector2D                    vecPixelSize        = Vector2D(0, 0);
-    Vector2D                    vecTransformedSize  = Vector2D(0, 0);
-
-    bool                        primary = false;
-
-    MONITORID                   ID                     = MONITOR_INVALID;
-    PHLWORKSPACE                activeWorkspace        = nullptr;
-    PHLWORKSPACE                activeSpecialWorkspace = nullptr;
-    float                       setScale               = 1; // scale set by cfg
-    float                       scale                  = 1; // real scale
-
-    std::string                 szName             = "";
-    std::string                 szDescription      = "";
-    std::string                 szShortDescription = "";
-
-    Vector2D                    vecReservedTopLeft     = Vector2D(0, 0);
-    Vector2D                    vecReservedBottomRight = Vector2D(0, 0);
-
-    drmModeModeInfo             customDrmMode = {};
-
-    CMonitorState               state;
-    CDamageRing                 damage;
-
-    SP<Aquamarine::IOutput>     output;
-    float                       refreshRate     = 60; // Hz
-    int                         forceFullFrames = 0;
-    bool                        scheduledRecalc = false;
-    wl_output_transform         transform       = WL_OUTPUT_TRANSFORM_NORMAL;
-    float                       xwaylandScale   = 1.f;
-    Mat3x3                      projMatrix;
-    std::optional<Vector2D>     forceSize;
-    SP<Aquamarine::SOutputMode> currentMode;
-    SP<Aquamarine::CSwapchain>  cursorSwapchain;
-    uint32_t                    drmFormat     = DRM_FORMAT_INVALID;
-    uint32_t                    prevDrmFormat = DRM_FORMAT_INVALID;
-
-    bool                        dpmsStatus       = true;
-    bool                        vrrActive        = false; // this can be TRUE even if VRR is not active in the case that this display does not support it.
-    bool                        enabled10bit     = false; // as above, this can be TRUE even if 10 bit failed.
-    eCMType                     cmType           = CM_SRGB;
-    float                       sdrSaturation    = 1.0f;
-    float                       sdrBrightness    = 1.0f;
-    bool                        createdByUser    = false;
-    bool                        isUnsafeFallback = false;
-
-    bool                        pendingFrame    = false; // if we schedule a frame during rendering, reschedule it after
-    bool                        renderingActive = false;
-
-    wl_event_source*            renderTimer  = nullptr; // for RAT
-    bool                        RATScheduled = false;
-    CTimer                      lastPresentationTimer;
-
-    bool                        isBeingLeased = false;
-
-    SMonitorRule                activeMonitorRule;
+    Vector2D                    m_position         = Vector2D(-1, -1); // means unset
+    Vector2D                    m_xwaylandPosition = Vector2D(-1, -1); // means unset
+    Vector2D                    m_size             = Vector2D(0, 0);
+    Vector2D                    m_pixelSize        = Vector2D(0, 0);
+    Vector2D                    m_transformedSize  = Vector2D(0, 0);
+
+    MONITORID                   m_id                     = MONITOR_INVALID;
+    PHLWORKSPACE                m_activeWorkspace        = nullptr;
+    PHLWORKSPACE                m_activeSpecialWorkspace = nullptr;
+    float                       m_setScale               = 1; // scale set by cfg
+    float                       m_scale                  = 1; // real scale
+
+    std::string                 m_name             = "";
+    std::string                 m_description      = "";
+    std::string                 m_shortDescription = "";
+
+    Vector2D                    m_reservedTopLeft     = Vector2D(0, 0);
+    Vector2D                    m_reservedBottomRight = Vector2D(0, 0);
+
+    drmModeModeInfo             m_customDrmMode = {};
+
+    CMonitorState               m_state;
+    CDamageRing                 m_damage;
+
+    SP<Aquamarine::IOutput>     m_output;
+    float                       m_refreshRate     = 60; // Hz
+    int                         m_forceFullFrames = 0;
+    bool                        m_scheduledRecalc = false;
+    wl_output_transform         m_transform       = WL_OUTPUT_TRANSFORM_NORMAL;
+    float                       m_xwaylandScale   = 1.f;
+    Mat3x3                      m_projMatrix;
+    std::optional<Vector2D>     m_forceSize;
+    SP<Aquamarine::SOutputMode> m_currentMode;
+    SP<Aquamarine::CSwapchain>  m_cursorSwapchain;
+    uint32_t                    m_drmFormat     = DRM_FORMAT_INVALID;
+    uint32_t                    m_prevDrmFormat = DRM_FORMAT_INVALID;
+
+    bool                        m_dpmsStatus       = true;
+    bool                        m_vrrActive        = false; // this can be TRUE even if VRR is not active in the case that this display does not support it.
+    bool                        m_enabled10bit     = false; // as above, this can be TRUE even if 10 bit failed.
+    eCMType                     m_cmType           = CM_SRGB;
+    float                       m_sdrSaturation    = 1.0f;
+    float                       m_sdrBrightness    = 1.0f;
+    bool                        m_createdByUser    = false;
+    bool                        m_isUnsafeFallback = false;
+
+    bool                        m_pendingFrame    = false; // if we schedule a frame during rendering, reschedule it after
+    bool                        m_renderingActive = false;
+
+    wl_event_source*            m_renderTimer   = nullptr; // for RAT
+    bool                        m_ratsScheduled = false;
+    CTimer                      m_lastPresentationTimer;
+
+    bool                        m_isBeingLeased = false;
+
+    SMonitorRule                m_activeMonitorRule;
 
     // explicit sync
-    Hyprutils::OS::CFileDescriptor inFence; // TODO: remove when aq uses CFileDescriptor
+    Hyprutils::OS::CFileDescriptor m_inFence; // TODO: remove when aq uses CFileDescriptor
 
-    PHLMONITORREF                  self;
+    PHLMONITORREF                  m_self;
 
     // mirroring
-    PHLMONITORREF              pMirrorOf;
-    std::vector<PHLMONITORREF> mirrors;
+    PHLMONITORREF              m_mirrorOf;
+    std::vector<PHLMONITORREF> m_mirrors;
 
     // ctm
-    Mat3x3 ctm        = Mat3x3::identity();
-    bool   ctmUpdated = false;
+    Mat3x3 m_ctm        = Mat3x3::identity();
+    bool   m_ctmUpdated = false;
 
     // for tearing
-    PHLWINDOWREF solitaryClient;
+    PHLWINDOWREF m_solitaryClient;
 
     // for direct scanout
-    PHLWINDOWREF lastScanout;
-    bool         scanoutNeedsCursorUpdate = false;
+    PHLWINDOWREF m_lastScanout;
+    bool         m_scanoutNeedsCursorUpdate = false;
 
     struct {
         bool canTear         = false;
@@ -165,7 +163,7 @@ class CMonitor {
 
         bool busy                    = false;
         bool frameScheduledWhileBusy = false;
-    } tearingState;
+    } m_tearingState;
 
     struct {
         CSignal destroy;
@@ -173,9 +171,9 @@ class CMonitor {
         CSignal disconnect;
         CSignal dpmsChanged;
         CSignal modeChanged;
-    } events;
+    } m_events;
 
-    std::array<std::vector<PHLLSREF>, 4> m_aLayerSurfaceLayers;
+    std::array<std::vector<PHLLSREF>, 4> m_layerSurfaceLayers;
 
     // methods
     void                                onConnect(bool noRule);
@@ -207,15 +205,15 @@ class CMonitor {
     void                                debugLastPresentation(const std::string& message);
     void                                onMonitorFrame();
 
-    bool                                m_bEnabled             = false;
-    bool                                m_bRenderingInitPassed = false;
+    bool                                m_enabled             = false;
+    bool                                m_renderingInitPassed = false;
     WP<CWindow>                         m_previousFSWindow;
-    NColorManagement::SImageDescription imageDescription;
+    NColorManagement::SImageDescription m_imageDescription;
 
     // For the list lookup
 
     bool operator==(const CMonitor& rhs) {
-        return vecPosition == rhs.vecPosition && vecSize == rhs.vecSize && szName == rhs.szName;
+        return m_position == rhs.m_position && m_size == rhs.m_size && m_name == rhs.m_name;
     }
 
     // workspace previous per monitor functionality
@@ -226,8 +224,8 @@ class CMonitor {
     void                    setupDefaultWS(const SMonitorRule&);
     WORKSPACEID             findAvailableDefaultWS();
 
-    bool                    doneScheduled = false;
-    std::stack<WORKSPACEID> prevWorkSpaces;
+    bool                    m_doneScheduled = false;
+    std::stack<WORKSPACEID> m_prevWorkSpaces;
 
     struct {
         CHyprSignalListener frame;
@@ -236,5 +234,5 @@ class CMonitor {
         CHyprSignalListener needsFrame;
         CHyprSignalListener presented;
         CHyprSignalListener commit;
-    } listeners;
+    } m_listeners;
 };
diff --git a/src/helpers/sync/SyncTimeline.cpp b/src/helpers/sync/SyncTimeline.cpp
index edb2b190..1b089caa 100644
--- a/src/helpers/sync/SyncTimeline.cpp
+++ b/src/helpers/sync/SyncTimeline.cpp
@@ -7,11 +7,11 @@
 using namespace Hyprutils::OS;
 
 SP<CSyncTimeline> CSyncTimeline::create(int drmFD_) {
-    auto timeline   = SP<CSyncTimeline>(new CSyncTimeline);
-    timeline->drmFD = drmFD_;
-    timeline->self  = timeline;
+    auto timeline     = SP<CSyncTimeline>(new CSyncTimeline);
+    timeline->m_drmFD = drmFD_;
+    timeline->m_self  = timeline;
 
-    if (drmSyncobjCreate(drmFD_, 0, &timeline->handle)) {
+    if (drmSyncobjCreate(drmFD_, 0, &timeline->m_handle)) {
         Debug::log(ERR, "CSyncTimeline: failed to create a drm syncobj??");
         return nullptr;
     }
@@ -20,12 +20,12 @@ SP<CSyncTimeline> CSyncTimeline::create(int drmFD_) {
 }
 
 SP<CSyncTimeline> CSyncTimeline::create(int drmFD_, CFileDescriptor&& drmSyncobjFD) {
-    auto timeline       = SP<CSyncTimeline>(new CSyncTimeline);
-    timeline->drmFD     = drmFD_;
-    timeline->syncobjFd = std::move(drmSyncobjFD);
-    timeline->self      = timeline;
+    auto timeline         = SP<CSyncTimeline>(new CSyncTimeline);
+    timeline->m_drmFD     = drmFD_;
+    timeline->m_syncobjFD = std::move(drmSyncobjFD);
+    timeline->m_self      = timeline;
 
-    if (drmSyncobjFDToHandle(drmFD_, timeline->syncobjFd.get(), &timeline->handle)) {
+    if (drmSyncobjFDToHandle(drmFD_, timeline->m_syncobjFD.get(), &timeline->m_handle)) {
         Debug::log(ERR, "CSyncTimeline: failed to create a drm syncobj from fd??");
         return nullptr;
     }
@@ -34,10 +34,10 @@ SP<CSyncTimeline> CSyncTimeline::create(int drmFD_, CFileDescriptor&& drmSyncobj
 }
 
 CSyncTimeline::~CSyncTimeline() {
-    if (handle == 0)
+    if (m_handle == 0)
         return;
 
-    drmSyncobjDestroy(drmFD, handle);
+    drmSyncobjDestroy(m_drmFD, m_handle);
 }
 
 std::optional<bool> CSyncTimeline::check(uint64_t point, uint32_t flags) {
@@ -48,7 +48,7 @@ std::optional<bool> CSyncTimeline::check(uint64_t point, uint32_t flags) {
 #endif
 
     uint32_t signaled = 0;
-    int      ret      = drmSyncobjTimelineWait(drmFD, &handle, &point, 1, 0, flags, &signaled);
+    int      ret      = drmSyncobjTimelineWait(m_drmFD, &m_handle, &point, 1, 0, flags, &signaled);
     if (ret != 0 && ret != -ETIME_ERR) {
         Debug::log(ERR, "CSyncTimeline::check: drmSyncobjTimelineWait failed");
         return std::nullopt;
@@ -65,7 +65,7 @@ bool CSyncTimeline::addWaiter(const std::function<void()>& waiter, uint64_t poin
         return false;
     }
 
-    if (drmSyncobjEventfd(drmFD, handle, point, eventFd.get(), flags)) {
+    if (drmSyncobjEventfd(m_drmFD, m_handle, point, eventFd.get(), flags)) {
         Debug::log(ERR, "CSyncTimeline::addWaiter: drmSyncobjEventfd failed");
         return false;
     }
@@ -79,58 +79,58 @@ CFileDescriptor CSyncTimeline::exportAsSyncFileFD(uint64_t src) {
     int      sync = -1;
 
     uint32_t syncHandle = 0;
-    if (drmSyncobjCreate(drmFD, 0, &syncHandle)) {
+    if (drmSyncobjCreate(m_drmFD, 0, &syncHandle)) {
         Debug::log(ERR, "exportAsSyncFileFD: drmSyncobjCreate failed");
         return {};
     }
 
-    if (drmSyncobjTransfer(drmFD, syncHandle, 0, handle, src, 0)) {
+    if (drmSyncobjTransfer(m_drmFD, syncHandle, 0, m_handle, src, 0)) {
         Debug::log(ERR, "exportAsSyncFileFD: drmSyncobjTransfer failed");
-        drmSyncobjDestroy(drmFD, syncHandle);
+        drmSyncobjDestroy(m_drmFD, syncHandle);
         return {};
     }
 
-    if (drmSyncobjExportSyncFile(drmFD, syncHandle, &sync)) {
+    if (drmSyncobjExportSyncFile(m_drmFD, syncHandle, &sync)) {
         Debug::log(ERR, "exportAsSyncFileFD: drmSyncobjExportSyncFile failed");
-        drmSyncobjDestroy(drmFD, syncHandle);
+        drmSyncobjDestroy(m_drmFD, syncHandle);
         return {};
     }
 
-    drmSyncobjDestroy(drmFD, syncHandle);
+    drmSyncobjDestroy(m_drmFD, syncHandle);
     return CFileDescriptor{sync};
 }
 
 bool CSyncTimeline::importFromSyncFileFD(uint64_t dst, CFileDescriptor& fd) {
     uint32_t syncHandle = 0;
 
-    if (drmSyncobjCreate(drmFD, 0, &syncHandle)) {
+    if (drmSyncobjCreate(m_drmFD, 0, &syncHandle)) {
         Debug::log(ERR, "importFromSyncFileFD: drmSyncobjCreate failed");
         return false;
     }
 
-    if (drmSyncobjImportSyncFile(drmFD, syncHandle, fd.get())) {
+    if (drmSyncobjImportSyncFile(m_drmFD, syncHandle, fd.get())) {
         Debug::log(ERR, "importFromSyncFileFD: drmSyncobjImportSyncFile failed");
-        drmSyncobjDestroy(drmFD, syncHandle);
+        drmSyncobjDestroy(m_drmFD, syncHandle);
         return false;
     }
 
-    if (drmSyncobjTransfer(drmFD, handle, dst, syncHandle, 0, 0)) {
+    if (drmSyncobjTransfer(m_drmFD, m_handle, dst, syncHandle, 0, 0)) {
         Debug::log(ERR, "importFromSyncFileFD: drmSyncobjTransfer failed");
-        drmSyncobjDestroy(drmFD, syncHandle);
+        drmSyncobjDestroy(m_drmFD, syncHandle);
         return false;
     }
 
-    drmSyncobjDestroy(drmFD, syncHandle);
+    drmSyncobjDestroy(m_drmFD, syncHandle);
     return true;
 }
 
 bool CSyncTimeline::transfer(SP<CSyncTimeline> from, uint64_t fromPoint, uint64_t toPoint) {
-    if (drmFD != from->drmFD) {
-        Debug::log(ERR, "CSyncTimeline::transfer: cannot transfer timelines between gpus, {} -> {}", from->drmFD, drmFD);
+    if (m_drmFD != from->m_drmFD) {
+        Debug::log(ERR, "CSyncTimeline::transfer: cannot transfer timelines between gpus, {} -> {}", from->m_drmFD, m_drmFD);
         return false;
     }
 
-    if (drmSyncobjTransfer(drmFD, handle, toPoint, from->handle, fromPoint, 0)) {
+    if (drmSyncobjTransfer(m_drmFD, m_handle, toPoint, from->m_handle, fromPoint, 0)) {
         Debug::log(ERR, "CSyncTimeline::transfer: drmSyncobjTransfer failed");
         return false;
     }
@@ -139,6 +139,6 @@ bool CSyncTimeline::transfer(SP<CSyncTimeline> from, uint64_t fromPoint, uint64_
 }
 
 void CSyncTimeline::signal(uint64_t point) {
-    if (drmSyncobjTimelineSignal(drmFD, &handle, &point, 1))
+    if (drmSyncobjTimelineSignal(m_drmFD, &m_handle, &point, 1))
         Debug::log(ERR, "CSyncTimeline::signal: drmSyncobjTimelineSignal failed");
 }
diff --git a/src/helpers/sync/SyncTimeline.hpp b/src/helpers/sync/SyncTimeline.hpp
index 51012c85..37d5b301 100644
--- a/src/helpers/sync/SyncTimeline.hpp
+++ b/src/helpers/sync/SyncTimeline.hpp
@@ -31,10 +31,10 @@ class CSyncTimeline {
     bool                           transfer(SP<CSyncTimeline> from, uint64_t fromPoint, uint64_t toPoint);
     void                           signal(uint64_t point);
 
-    int                            drmFD = -1;
-    Hyprutils::OS::CFileDescriptor syncobjFd;
-    uint32_t                       handle = 0;
-    WP<CSyncTimeline>              self;
+    int                            m_drmFD = -1;
+    Hyprutils::OS::CFileDescriptor m_syncobjFD;
+    uint32_t                       m_handle = 0;
+    WP<CSyncTimeline>              m_self;
 
   private:
     CSyncTimeline() = default;