Added clang format (#1239)

* clang-format stuff and format files

21 files changed, 487 insertions, 478 deletions

diff --git a/src/helpers/AnimatedVariable.cpp b/src/helpers/AnimatedVariable.cpp
index 18162c99..f3b1d1e4 100644
--- a/src/helpers/AnimatedVariable.cpp
+++ b/src/helpers/AnimatedVariable.cpp
@@ -7,10 +7,10 @@ CAnimatedVariable::CAnimatedVariable() {
 }
 
 void CAnimatedVariable::create(ANIMATEDVARTYPE type, SAnimationPropertyConfig* pAnimConfig, void* pWindow, AVARDAMAGEPOLICY policy) {
-    m_eVarType = type;
+    m_eVarType      = type;
     m_eDamagePolicy = policy;
-    m_pConfig = pAnimConfig;
-    m_pWindow = pWindow;
+    m_pConfig       = pAnimConfig;
+    m_pWindow       = pWindow;
 
     m_bDummy = false;
 }
@@ -22,25 +22,23 @@ void CAnimatedVariable::create(ANIMATEDVARTYPE type, std::any val, SAnimationPro
         switch (type) {
             case AVARTYPE_FLOAT: {
                 const auto V = std::any_cast<float>(val);
-                m_fValue = V;
-                m_fGoal = V;
+                m_fValue     = V;
+                m_fGoal      = V;
                 break;
             }
             case AVARTYPE_VECTOR: {
                 const auto V = std::any_cast<Vector2D>(val);
-                m_vValue = V;
-                m_vGoal = V;
+                m_vValue     = V;
+                m_vGoal      = V;
                 break;
             }
             case AVARTYPE_COLOR: {
                 const auto V = std::any_cast<CColor>(val);
-                m_cValue = V;
-                m_cGoal = V;
+                m_cValue     = V;
+                m_cGoal      = V;
                 break;
             }
-            default:
-                ASSERT(false);
-                break;
+            default: ASSERT(false); break;
         }
     } catch (std::exception& e) {
         Debug::log(ERR, "CAnimatedVariable create error: %s", e.what());
@@ -64,7 +62,8 @@ void CAnimatedVariable::registerVar() {
 }
 
 int CAnimatedVariable::getDurationLeftMs() {
-    return std::max((int)(m_pConfig->pValues->internalSpeed * 100) - (int)std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - animationBegin).count(), 0);
+    return std::max(
+        (int)(m_pConfig->pValues->internalSpeed * 100) - (int)std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - animationBegin).count(), 0);
 }
 
 float CAnimatedVariable::getPercent() {
diff --git a/src/helpers/AnimatedVariable.hpp b/src/helpers/AnimatedVariable.hpp
index ab1dcf42..6aa33255 100644
--- a/src/helpers/AnimatedVariable.hpp
+++ b/src/helpers/AnimatedVariable.hpp
@@ -3,16 +3,18 @@
 #include "../defines.hpp"
 #include <any>
 
-enum ANIMATEDVARTYPE {
+enum ANIMATEDVARTYPE
+{
     AVARTYPE_INVALID = -1,
     AVARTYPE_FLOAT,
     AVARTYPE_VECTOR,
     AVARTYPE_COLOR
 };
 
-enum AVARDAMAGEPOLICY {
+enum AVARDAMAGEPOLICY
+{
     AVARDAMAGE_INVALID = -1,
-    AVARDAMAGE_ENTIRE = 0,
+    AVARDAMAGE_ENTIRE  = 0,
     AVARDAMAGE_BORDER,
     AVARDAMAGE_SHADOW
 };
@@ -24,7 +26,7 @@ struct SAnimationPropertyConfig;
 class CHyprRenderer;
 
 class CAnimatedVariable {
-public:
+  public:
     CAnimatedVariable(); // dummy var
 
     void create(ANIMATEDVARTYPE, SAnimationPropertyConfig*, void* pWindow, AVARDAMAGEPOLICY);
@@ -65,53 +67,59 @@ public:
         return m_cGoal;
     }
 
-    void operator=(const Vector2D& v) {
-        m_vGoal = v;
+    CAnimatedVariable& operator=(const Vector2D& v) {
+        m_vGoal        = v;
         animationBegin = std::chrono::system_clock::now();
-        m_vBegun = m_vValue;
+        m_vBegun       = m_vValue;
 
         onAnimationBegin();
+
+        return *this;
     }
 
-    void operator=(const float& v) {
-        m_fGoal = v;
+    CAnimatedVariable& operator=(const float& v) {
+        m_fGoal        = v;
         animationBegin = std::chrono::system_clock::now();
-        m_fBegun = m_fValue;
+        m_fBegun       = m_fValue;
 
         onAnimationBegin();
+
+        return *this;
     }
 
-    void operator=(const CColor& v) {
-        m_cGoal = v;
+    CAnimatedVariable& operator=(const CColor& v) {
+        m_cGoal        = v;
         animationBegin = std::chrono::system_clock::now();
-        m_cBegun = m_cValue;
+        m_cBegun       = m_cValue;
 
         onAnimationBegin();
+
+        return *this;
     }
 
     // Sets the actual stored value, without affecting the goal, but resets the timer
     void setValue(const Vector2D& v) {
-        m_vValue = v;
+        m_vValue       = v;
         animationBegin = std::chrono::system_clock::now();
-        m_vBegun = m_vValue;
+        m_vBegun       = m_vValue;
 
         onAnimationBegin();
     }
 
     // Sets the actual stored value, without affecting the goal, but resets the timer
     void setValue(const float& v) {
-        m_fValue = v;
+        m_fValue       = v;
         animationBegin = std::chrono::system_clock::now();
-        m_vBegun = m_vValue;
+        m_vBegun       = m_vValue;
 
         onAnimationBegin();
     }
 
     // Sets the actual stored value, without affecting the goal, but resets the timer
     void setValue(const CColor& v) {
-        m_cValue = v;
+        m_cValue       = v;
         animationBegin = std::chrono::system_clock::now();
-        m_vBegun = m_vValue;
+        m_vBegun       = m_vValue;
 
         onAnimationBegin();
     }
@@ -137,14 +145,10 @@ public:
     // checks if an animation is in progress
     bool isBeingAnimated() {
         switch (m_eVarType) {
-            case AVARTYPE_FLOAT:
-                return m_fValue != m_fGoal;
-            case AVARTYPE_VECTOR:
-                return m_vValue != m_vGoal;
-            case AVARTYPE_COLOR:
-                return m_cValue != m_cGoal;
-            default:
-                UNREACHABLE();
+            case AVARTYPE_FLOAT: return m_fValue != m_fGoal;
+            case AVARTYPE_VECTOR: return m_vValue != m_vGoal;
+            case AVARTYPE_COLOR: return m_cValue != m_cGoal;
+            default: UNREACHABLE();
         }
 
         UNREACHABLE();
@@ -166,8 +170,7 @@ public:
                 m_cValue = m_cGoal;
                 break;
             }
-            default:
-                UNREACHABLE();
+            default: UNREACHABLE();
         }
 
         if (endCallback)
@@ -191,7 +194,7 @@ public:
         if an animation is not running, runs instantly.
         if "remove" is set to true, will remove the callback when ran. */
     void setCallbackOnEnd(std::function<void(void* thisptr)> func, bool remove = true) {
-        m_fEndCallback = func;
+        m_fEndCallback       = func;
         m_bRemoveEndAfterRan = remove;
 
         if (!isBeingAnimated())
@@ -201,58 +204,57 @@ public:
     /*  sets a function to be ran when an animation is started.
         if "remove" is set to true, will remove the callback when ran. */
     void setCallbackOnBegin(std::function<void(void* thisptr)> func, bool remove = true) {
-        m_fBeginCallback = func;
+        m_fBeginCallback       = func;
         m_bRemoveBeginAfterRan = remove;
     }
 
     /*  resets all callbacks. Does not call any. */
     void resetAllCallbacks() {
-        m_fBeginCallback = nullptr;
-        m_fEndCallback = nullptr;
+        m_fBeginCallback       = nullptr;
+        m_fEndCallback         = nullptr;
         m_bRemoveBeginAfterRan = false;
-        m_bRemoveEndAfterRan = false;
+        m_bRemoveEndAfterRan   = false;
     }
 
-private:
-
-    Vector2D        m_vValue = Vector2D(0,0);
-    float           m_fValue = 0;
-    CColor          m_cValue;
+  private:
+    Vector2D m_vValue = Vector2D(0, 0);
+    float    m_fValue = 0;
+    CColor   m_cValue;
 
-    Vector2D        m_vGoal = Vector2D(0,0);
-    float           m_fGoal = 0;
-    CColor          m_cGoal;
+    Vector2D m_vGoal = Vector2D(0, 0);
+    float    m_fGoal = 0;
+    CColor   m_cGoal;
 
-    Vector2D        m_vBegun = Vector2D(0,0);
-    float           m_fBegun = 0;
-    CColor          m_cBegun;
+    Vector2D m_vBegun = Vector2D(0, 0);
+    float    m_fBegun = 0;
+    CColor   m_cBegun;
 
     // owners
-    void*           m_pWindow = nullptr;
-    void*           m_pWorkspace = nullptr;
-    void*           m_pLayer = nullptr;
+    void*                                 m_pWindow    = nullptr;
+    void*                                 m_pWorkspace = nullptr;
+    void*                                 m_pLayer     = nullptr;
 
-    SAnimationPropertyConfig* m_pConfig = nullptr;
+    SAnimationPropertyConfig*             m_pConfig = nullptr;
 
-    bool            m_bDummy = true;
-    bool            m_bIsRegistered = false;
+    bool                                  m_bDummy        = true;
+    bool                                  m_bIsRegistered = false;
 
     std::chrono::system_clock::time_point animationBegin;
 
-    ANIMATEDVARTYPE     m_eVarType      = AVARTYPE_INVALID;
-    AVARDAMAGEPOLICY    m_eDamagePolicy = AVARDAMAGE_INVALID;
+    ANIMATEDVARTYPE                       m_eVarType      = AVARTYPE_INVALID;
+    AVARDAMAGEPOLICY                      m_eDamagePolicy = AVARDAMAGE_INVALID;
 
-    bool            m_bRemoveEndAfterRan = true;
-    bool            m_bRemoveBeginAfterRan = true;
-    std::function<void(void* thisptr)> m_fEndCallback;
-    std::function<void(void* thisptr)> m_fBeginCallback;
+    bool                                  m_bRemoveEndAfterRan   = true;
+    bool                                  m_bRemoveBeginAfterRan = true;
+    std::function<void(void* thisptr)>    m_fEndCallback;
+    std::function<void(void* thisptr)>    m_fBeginCallback;
 
     // methods
     void onAnimationEnd() {
         if (m_fEndCallback) {
             m_fEndCallback(this);
             if (m_bRemoveEndAfterRan)
-                m_fEndCallback = nullptr;  // reset
+                m_fEndCallback = nullptr; // reset
         }
     }
 
@@ -260,7 +262,7 @@ private:
         if (m_fBeginCallback) {
             m_fBeginCallback(this);
             if (m_bRemoveBeginAfterRan)
-                m_fBeginCallback = nullptr;  // reset
+                m_fBeginCallback = nullptr; // reset
         }
     }
 
diff --git a/src/helpers/BezierCurve.cpp b/src/helpers/BezierCurve.cpp
index bdf2c4b1..07726b8d 100644
--- a/src/helpers/BezierCurve.cpp
+++ b/src/helpers/BezierCurve.cpp
@@ -5,13 +5,13 @@ void CBezierCurve::setup(std::vector<Vector2D>* pVec) {
 
     const auto BEGIN = std::chrono::high_resolution_clock::now();
 
-    m_dPoints.emplace_back(Vector2D(0,0));
+    m_dPoints.emplace_back(Vector2D(0, 0));
 
     for (auto& p : *pVec) {
         m_dPoints.push_back(p);
     }
 
-    m_dPoints.emplace_back(Vector2D(1,1));
+    m_dPoints.emplace_back(Vector2D(1, 1));
 
     RASSERT(m_dPoints.size() == 4, "CBezierCurve only supports cubic beziers! (points num: %i)", m_dPoints.size());
 
@@ -21,7 +21,7 @@ void CBezierCurve::setup(std::vector<Vector2D>* pVec) {
         m_aPointsBaked[i] = Vector2D(getXForT((i + 1) / (float)BAKEDPOINTS), getYForT((i + 1) / (float)BAKEDPOINTS));
     }
 
-    const auto ELAPSEDUS = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - BEGIN).count() / 1000.f;
+    const auto ELAPSEDUS  = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - BEGIN).count() / 1000.f;
     const auto POINTSSIZE = m_aPointsBaked.size() * sizeof(m_aPointsBaked[0]) / 1000.f;
 
     const auto BEGINCALC = std::chrono::high_resolution_clock::now();
@@ -29,9 +29,8 @@ void CBezierCurve::setup(std::vector<Vector2D>* pVec) {
         getYForPoint(i);
     const auto ELAPSEDCALCAVG = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - BEGINCALC).count() / 1000.f / 10.f;
 
-    Debug::log(LOG, "Created a bezier curve, baked %i points, mem usage: %.2fkB, time to bake: %.2fµs. Estimated average calc time: %.2fµs.",
-        BAKEDPOINTS, POINTSSIZE, ELAPSEDUS, ELAPSEDCALCAVG);
-
+    Debug::log(LOG, "Created a bezier curve, baked %i points, mem usage: %.2fkB, time to bake: %.2fµs. Estimated average calc time: %.2fµs.", BAKEDPOINTS, POINTSSIZE, ELAPSEDUS,
+               ELAPSEDCALCAVG);
 }
 
 float CBezierCurve::getYForT(float t) {
@@ -47,9 +46,9 @@ float CBezierCurve::getYForPoint(float x) {
     // binary search for the range UPDOWN X
     float upperT = 1;
     float lowerT = 0;
-    float mid = 0.5;
+    float mid    = 0.5;
 
-    while(std::abs(upperT - lowerT) > INVBAKEDPOINTS) {
+    while (std::abs(upperT - lowerT) > INVBAKEDPOINTS) {
         if (m_aPointsBaked[((int)(mid * (float)BAKEDPOINTS))].x > x) {
             upperT = mid;
         } else {
@@ -65,7 +64,7 @@ float CBezierCurve::getYForPoint(float x) {
 
     const auto PERCINDELTA = (x - LOWERPOINT->x) / (UPPERPOINT->x - LOWERPOINT->x);
 
-    if (std::isnan(PERCINDELTA) || std::isinf(PERCINDELTA))  // can sometimes happen for VERY small x
+    if (std::isnan(PERCINDELTA) || std::isinf(PERCINDELTA)) // can sometimes happen for VERY small x
         return 0.f;
 
     return LOWERPOINT->y + (UPPERPOINT->y - UPPERPOINT->y) * PERCINDELTA;
diff --git a/src/helpers/BezierCurve.hpp b/src/helpers/BezierCurve.hpp
index da01b688..81cf74b6 100644
--- a/src/helpers/BezierCurve.hpp
+++ b/src/helpers/BezierCurve.hpp
@@ -3,25 +3,25 @@
 #include "../defines.hpp"
 #include <deque>
 
-constexpr int BAKEDPOINTS = 200;
+constexpr int   BAKEDPOINTS    = 200;
 constexpr float INVBAKEDPOINTS = 1.f / BAKEDPOINTS;
 
 // an implementation of a cubic bezier curve
 // might do better later
 // TODO: n-point curves
 class CBezierCurve {
-public:
+  public:
     // sets up the bezier curve.
     // this EXCLUDES the 0,0 and 1,1 points,
-    void    setup(std::vector<Vector2D>* points);
+    void  setup(std::vector<Vector2D>* points);
 
-    float   getYForT(float t);
-    float   getXForT(float t);
-    float   getYForPoint(float x);
+    float getYForT(float t);
+    float getXForT(float t);
+    float getYForPoint(float x);
 
-private:
+  private:
     // this INCLUDES the 0,0 and 1,1 points.
-    std::deque<Vector2D>    m_dPoints;
+    std::deque<Vector2D>              m_dPoints;
 
-    std::array<Vector2D, BAKEDPOINTS>  m_aPointsBaked;
+    std::array<Vector2D, BAKEDPOINTS> m_aPointsBaked;
 };
\ No newline at end of file
diff --git a/src/helpers/Color.cpp b/src/helpers/Color.cpp
index 37ea39c8..c92f74ae 100644
--- a/src/helpers/Color.cpp
+++ b/src/helpers/Color.cpp
@@ -1,7 +1,7 @@
 #include "Color.hpp"
 #include "../defines.hpp"
 
-CColor::CColor() { }
+CColor::CColor() {}
 
 CColor::CColor(float r, float g, float b, float a) {
     this->r = r;
diff --git a/src/helpers/Color.hpp b/src/helpers/Color.hpp
index 5844d322..d3cae689 100644
--- a/src/helpers/Color.hpp
+++ b/src/helpers/Color.hpp
@@ -3,24 +3,24 @@
 #include "../includes.hpp"
 
 class CColor {
-public:
+  public:
     CColor();
     CColor(float, float, float, float);
     CColor(uint64_t);
 
-    float r = 0, g = 0, b = 0, a = 255;
+    float    r = 0, g = 0, b = 0, a = 255;
 
-    uint64_t    getAsHex();
+    uint64_t getAsHex();
 
-    CColor operator- (const CColor& c2) const {
+    CColor   operator-(const CColor& c2) const {
         return CColor(r - c2.r, g - c2.g, b - c2.b, a - c2.a);
     }
 
-    CColor operator+ (const CColor& c2) const {
+    CColor operator+(const CColor& c2) const {
         return CColor(r + c2.r, g + c2.g, b + c2.b, a + c2.a);
     }
 
-    CColor operator* (const float& v) const {
+    CColor operator*(const float& v) const {
         return CColor(r * v, g * v, b * v, a * v);
     }
 
diff --git a/src/helpers/MiscFunctions.cpp b/src/helpers/MiscFunctions.cpp
index e0dcb6dc..67b0efcb 100644
--- a/src/helpers/MiscFunctions.cpp
+++ b/src/helpers/MiscFunctions.cpp
@@ -5,29 +5,28 @@
 #include <sys/utsname.h>
 #include <iomanip>
 
-#if defined(__DragonFly__) || defined(__FreeBSD__) || \
-  defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__)
-# include <sys/sysctl.h>
-# if defined(__DragonFly__)
-#  include <sys/kinfo.h>      // struct kinfo_proc
-# elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
-#  include <sys/user.h>       // struct kinfo_proc
-# endif
-
-# if defined(__NetBSD__)
-#  undef KERN_PROC
-#  define KERN_PROC KERN_PROC2
-#  define KINFO_PROC struct kinfo_proc2
-# else
-#  define KINFO_PROC struct kinfo_proc
-# endif
-# if defined(__DragonFly__)
-#  define KP_PPID(kp) kp.kp_ppid
-# elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
-#  define KP_PPID(kp) kp.ki_ppid
-# else
-#  define KP_PPID(kp) kp.p_ppid
-# endif
+#if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__)
+#include <sys/sysctl.h>
+#if defined(__DragonFly__)
+#include <sys/kinfo.h> // struct kinfo_proc
+#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+#include <sys/user.h> // struct kinfo_proc
+#endif
+
+#if defined(__NetBSD__)
+#undef KERN_PROC
+#define KERN_PROC  KERN_PROC2
+#define KINFO_PROC struct kinfo_proc2
+#else
+#define KINFO_PROC struct kinfo_proc
+#endif
+#if defined(__DragonFly__)
+#define KP_PPID(kp) kp.kp_ppid
+#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+#define KP_PPID(kp) kp.ki_ppid
+#else
+#define KP_PPID(kp) kp.p_ppid
+#endif
 #endif
 
 static const float transforms[][9] = {{
@@ -87,7 +86,7 @@ std::string absolutePath(const std::string& rawpath, const std::string& currentP
     return value;
 }
 
-void addWLSignal(wl_signal* pSignal, wl_listener* pListener, void* pOwner, std::string ownerString) {
+void addWLSignal(wl_signal* pSignal, wl_listener* pListener, void* pOwner, const std::string& ownerString) {
     ASSERT(pSignal);
     ASSERT(pListener);
 
@@ -96,12 +95,12 @@ void addWLSignal(wl_signal* pSignal, wl_listener* pListener, void* pOwner, std::
     Debug::log(LOG, "Registered signal for owner %x: %x -> %x (owner: %s)", pOwner, pSignal, pListener, ownerString.c_str());
 }
 
-void handleNoop(struct wl_listener *listener, void *data) {
+void handleNoop(struct wl_listener* listener, void* data) {
     // Do nothing
 }
 
-std::string getFormat(const char *fmt, ...) {
-    char* outputStr = nullptr;
+std::string getFormat(const char* fmt, ...) {
+    char*   outputStr = nullptr;
 
     va_list args;
     va_start(args, fmt);
@@ -116,32 +115,31 @@ std::string getFormat(const char *fmt, ...) {
 
 std::string escapeJSONStrings(const std::string& str) {
     std::ostringstream oss;
-    for (auto &c : str) {
+    for (auto& c : str) {
         switch (c) {
-        case '"': oss << "\\\""; break;
-        case '\\': oss << "\\\\"; break;
-        case '\b': oss << "\\b"; break;
-        case '\f': oss << "\\f"; break;
-        case '\n': oss << "\\n"; break;
-        case '\r': oss << "\\r"; break;
-        case '\t': oss << "\\t"; break;
-        default:
-            if ('\x00' <= c && c <= '\x1f') {
-                oss << "\\u"
-                    << std::hex << std::setw(4) << std::setfill('0') << static_cast<int>(c);
-            } else {
-                oss << c;
-            }
+            case '"': oss << "\\\""; break;
+            case '\\': oss << "\\\\"; break;
+            case '\b': oss << "\\b"; break;
+            case '\f': oss << "\\f"; break;
+            case '\n': oss << "\\n"; break;
+            case '\r': oss << "\\r"; break;
+            case '\t': oss << "\\t"; break;
+            default:
+                if ('\x00' <= c && c <= '\x1f') {
+                    oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') << static_cast<int>(c);
+                } else {
+                    oss << c;
+                }
         }
     }
     return oss.str();
 }
 
 void scaleBox(wlr_box* box, float scale) {
-    box->width = std::round(box->width * scale);
+    box->width  = std::round(box->width * scale);
     box->height = std::round(box->height * scale);
-    box->x = std::round(box->x * scale);
-    box->y = std::round(box->y * scale);
+    box->x      = std::round(box->x * scale);
+    box->y      = std::round(box->y * scale);
 }
 
 std::string removeBeginEndSpacesTabs(std::string str) {
@@ -166,9 +164,9 @@ std::string removeBeginEndSpacesTabs(std::string str) {
 float getPlusMinusKeywordResult(std::string source, float relative) {
     float result = INT_MAX;
 
-    if (source.find_first_of("+") == 0) {
+    if (source[0] == '+') {
         try {
-            if (source.contains("."))
+            if (source.contains('.'))
                 result = relative + std::stof(source.substr(1));
             else
                 result = relative + std::stoi(source.substr(1));
@@ -176,9 +174,9 @@ float getPlusMinusKeywordResult(std::string source, float relative) {
             Debug::log(ERR, "Invalid arg \"%s\" in getPlusMinusKeywordResult!", source.c_str());
             return INT_MAX;
         }
-    } else if (source.find_first_of("-") == 0) {
+    } else if (source[0] == '-') {
         try {
-            if (source.contains("."))
+            if (source.contains('.'))
                 result = relative - std::stof(source.substr(1));
             else
                 result = relative - std::stoi(source.substr(1));
@@ -188,7 +186,7 @@ float getPlusMinusKeywordResult(std::string source, float relative) {
         }
     } else {
         try {
-            if (source.contains("."))
+            if (source.contains('.'))
                 result = stof(source);
             else
                 result = stoi(source);
@@ -239,7 +237,7 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
             const auto NAME = in.substr(8);
 
             const auto WS = g_pCompositor->getWorkspaceByName("special:" + NAME);
-            
+
             outName = "special:" + NAME;
 
             return WS ? WS->m_iID : g_pCompositor->getNewSpecialID();
@@ -248,7 +246,7 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
         return SPECIAL_WORKSPACE_START;
     } else if (in.find("name:") == 0) {
         const auto WORKSPACENAME = in.substr(in.find_first_of(':') + 1);
-        const auto WORKSPACE = g_pCompositor->getWorkspaceByName(WORKSPACENAME);
+        const auto WORKSPACE     = g_pCompositor->getWorkspaceByName(WORKSPACENAME);
         if (!WORKSPACE) {
             result = g_pCompositor->getNextAvailableNamedWorkspace();
         } else {
@@ -276,8 +274,8 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
             result = (int)getPlusMinusKeywordResult(in.substr(1), 0);
 
             // result now has +/- what we should move on mon
-            int remains = (int)result;
-            
+            int              remains = (int)result;
+
             std::vector<int> validWSes;
             for (auto& ws : g_pCompositor->m_vWorkspaces) {
                 if (ws->m_bIsSpecialWorkspace || (ws->m_iMonitorID != g_pCompositor->m_pLastMonitor->ID && !onAllMonitors))
@@ -310,7 +308,7 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
                 currentItem = validWSes.size() + currentItem;
             }
 
-            result = validWSes[currentItem];
+            result  = validWSes[currentItem];
             outName = g_pCompositor->getWorkspaceByID(validWSes[currentItem])->m_szName;
 
         } else {
@@ -345,8 +343,8 @@ float vecToRectDistanceSquared(const Vector2D& vec, const Vector2D& p1, const Ve
 
 // Execute a shell command and get the output
 std::string execAndGet(const char* cmd) {
-    std::array<char, 128> buffer;
-    std::string result;
+    std::array<char, 128>                          buffer;
+    std::string                                    result;
     const std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(cmd, "r"), pclose);
     if (!pipe) {
         Debug::log(ERR, "execAndGet: failed in pipe");
@@ -387,8 +385,8 @@ void matrixProjection(float mat[9], int w, int h, wl_output_transform tr) {
     memset(mat, 0, sizeof(*mat) * 9);
 
     const float* t = transforms[tr];
-    float x = 2.0f / w;
-    float y = 2.0f / h;
+    float        x = 2.0f / w;
+    float        y = 2.0f / h;
 
     // Rotation + reflection
     mat[0] = x * t[0];
@@ -411,35 +409,35 @@ int64_t getPPIDof(int64_t pid) {
         KERN_PROC,
         KERN_PROC_PID,
         (int)pid,
-# if defined(__NetBSD__) || defined(__OpenBSD__)
+#if defined(__NetBSD__) || defined(__OpenBSD__)
         sizeof(KINFO_PROC),
         1,
-# endif
+#endif
     };
-    u_int miblen = sizeof(mib) / sizeof(mib[0]);
+    u_int      miblen = sizeof(mib) / sizeof(mib[0]);
     KINFO_PROC kp;
-    size_t sz = sizeof(KINFO_PROC);
+    size_t     sz = sizeof(KINFO_PROC);
     if (sysctl(mib, miblen, &kp, &sz, NULL, 0) != -1)
         return KP_PPID(kp);
 
     return 0;
 #else
     std::string dir = "/proc/" + std::to_string(pid) + "/status";
-    FILE* infile;
+    FILE*       infile;
 
     infile = fopen(dir.c_str(), "r");
     if (!infile)
         return 0;
 
-    char* line = nullptr;
-    size_t len = 0;
-    ssize_t len2 = 0;
+    char*       line = nullptr;
+    size_t      len  = 0;
+    ssize_t     len2 = 0;
 
     std::string pidstr;
 
     while ((len2 = getline(&line, &len, infile)) != -1) {
         if (strstr(line, "PPid:")) {
-            pidstr = std::string(line, len2);
+            pidstr            = std::string(line, len2);
             const auto tabpos = pidstr.find_last_of('\t');
             if (tabpos != std::string::npos)
                 pidstr = pidstr.substr(tabpos);
@@ -453,9 +451,7 @@ int64_t getPPIDof(int64_t pid) {
 
     try {
         return std::stoll(pidstr);
-    } catch (std::exception& e) {
-        return 0;
-    }
+    } catch (std::exception& e) { return 0; }
 #endif
 }
 
@@ -464,7 +460,7 @@ int64_t configStringToInt(const std::string& VALUE) {
         // Values with 0x are hex
         const auto VALUEWITHOUTHEX = VALUE.substr(2);
         return stol(VALUEWITHOUTHEX, nullptr, 16);
-    } else if (VALUE.find("rgba(") == 0 && VALUE.find(")") == VALUE.length() - 1) {
+    } else if (VALUE.find("rgba(") == 0 && VALUE.find(')') == VALUE.length() - 1) {
         const auto VALUEWITHOUTFUNC = VALUE.substr(5, VALUE.length() - 6);
 
         if (removeBeginEndSpacesTabs(VALUEWITHOUTFUNC).length() != 8) {
@@ -476,7 +472,7 @@ int64_t configStringToInt(const std::string& VALUE) {
 
         // now we need to RGBA -> ARGB. The config holds ARGB only.
         return (RGBA >> 8) + 0x1000000 * (RGBA & 0xFF);
-    } else if (VALUE.find("rgb(") == 0 && VALUE.find(")") == VALUE.length() - 1) {
+    } else if (VALUE.find("rgb(") == 0 && VALUE.find(')') == VALUE.length() - 1) {
         const auto VALUEWITHOUTFUNC = VALUE.substr(4, VALUE.length() - 5);
 
         if (removeBeginEndSpacesTabs(VALUEWITHOUTFUNC).length() != 6) {
diff --git a/src/helpers/MiscFunctions.hpp b/src/helpers/MiscFunctions.hpp
index 9f30960e..36bdc3b7 100644
--- a/src/helpers/MiscFunctions.hpp
+++ b/src/helpers/MiscFunctions.hpp
@@ -3,20 +3,20 @@
 #include "../includes.hpp"
 
 std::string absolutePath(const std::string&, const std::string&);
-void addWLSignal(wl_signal*, wl_listener*, void* pOwner, std::string ownerString);
-std::string getFormat(const char *fmt, ...); // Basically Debug::log to a string
+void        addWLSignal(wl_signal*, wl_listener*, void* pOwner, const std::string& ownerString);
+std::string getFormat(const char* fmt, ...); // Basically Debug::log to a string
 std::string escapeJSONStrings(const std::string& str);
-void scaleBox(wlr_box*, float);
+void        scaleBox(wlr_box*, float);
 std::string removeBeginEndSpacesTabs(std::string);
-bool isNumber(const std::string&, bool allowfloat = false);
-bool isDirection(const std::string&);
-int getWorkspaceIDFromString(const std::string&, std::string&);
-float vecToRectDistanceSquared(const Vector2D& vec, const Vector2D& p1, const Vector2D& p2);
-void logSystemInfo();
+bool        isNumber(const std::string&, bool allowfloat = false);
+bool        isDirection(const std::string&);
+int         getWorkspaceIDFromString(const std::string&, std::string&);
+float       vecToRectDistanceSquared(const Vector2D& vec, const Vector2D& p1, const Vector2D& p2);
+void        logSystemInfo();
 std::string execAndGet(const char*);
-int64_t getPPIDof(int64_t pid);
-int64_t configStringToInt(const std::string&);
+int64_t     getPPIDof(int64_t pid);
+int64_t     configStringToInt(const std::string&);
 
-float getPlusMinusKeywordResult(std::string in, float relative);
+float       getPlusMinusKeywordResult(std::string in, float relative);
 
-void matrixProjection(float mat[9], int w, int h, wl_output_transform tr);
+void        matrixProjection(float mat[9], int w, int h, wl_output_transform tr);
diff --git a/src/helpers/Monitor.cpp b/src/helpers/Monitor.cpp
index 823066ac..74630bd5 100644
--- a/src/helpers/Monitor.cpp
+++ b/src/helpers/Monitor.cpp
@@ -67,15 +67,15 @@ void CMonitor::onConnect(bool noRule) {
 
     if (output->non_desktop) {
         Debug::log(LOG, "Not configuring non-desktop output");
-		if (g_pCompositor->m_sWRLDRMLeaseMgr) {
-			wlr_drm_lease_v1_manager_offer_output(g_pCompositor->m_sWRLDRMLeaseMgr, output);
-		}
-		return;
-	}
+        if (g_pCompositor->m_sWRLDRMLeaseMgr) {
+            wlr_drm_lease_v1_manager_offer_output(g_pCompositor->m_sWRLDRMLeaseMgr, output);
+        }
+        return;
+    }
 
     if (!m_bRenderingInitPassed) {
         output->allocator = nullptr;
-        output->renderer = nullptr;
+        output->renderer  = nullptr;
         wlr_output_init_render(output, g_pCompositor->m_sWLRAllocator, g_pCompositor->m_sWLRRenderer);
         m_bRenderingInitPassed = true;
     }
@@ -91,7 +91,7 @@ void CMonitor::onConnect(bool noRule) {
         }
     }
 
-    if (std::find_if(g_pCompositor->m_vMonitors.begin(), g_pCompositor->m_vMonitors.end(), [&](auto& other) { return other.get() == this; }) == g_pCompositor->m_vMonitors.end()){
+    if (std::find_if(g_pCompositor->m_vMonitors.begin(), g_pCompositor->m_vMonitors.end(), [&](auto& other) { return other.get() == this; }) == g_pCompositor->m_vMonitors.end()) {
         g_pCompositor->m_vMonitors.push_back(*m_pThisWrap);
     }
 
@@ -99,7 +99,7 @@ void CMonitor::onConnect(bool noRule) {
 
     // create it in the arr
     vecPosition = monitorRule.offset;
-    vecSize = monitorRule.resolution;
+    vecSize     = monitorRule.resolution;
     refreshRate = monitorRule.refreshRate;
 
     wlr_output_enable(output, 1);
@@ -110,7 +110,8 @@ void CMonitor::onConnect(bool noRule) {
 
     wlr_xcursor_manager_load(g_pCompositor->m_sWLRXCursorMgr, scale);
 
-    Debug::log(LOG, "Added new monitor with name %s at %i,%i with size %ix%i, pointer %x", output->name, (int)vecPosition.x, (int)vecPosition.y, (int)vecPixelSize.x, (int)vecPixelSize.y, output);
+    Debug::log(LOG, "Added new monitor with name %s at %i,%i with size %ix%i, pointer %x", output->name, (int)vecPosition.x, (int)vecPosition.y, (int)vecPixelSize.x,
+               (int)vecPixelSize.y, output);
 
     damage = wlr_output_damage_create(output);
 
@@ -127,12 +128,12 @@ void CMonitor::onConnect(bool noRule) {
 
     m_pThisWrap = nullptr;
 
-    forceFullFrames = 3;  // force 3 full frames to make sure there is no blinking due to double-buffering.
+    forceFullFrames = 3; // force 3 full frames to make sure there is no blinking due to double-buffering.
     //
 
     g_pEventManager->postEvent(SHyprIPCEvent{"monitoradded", szName});
 
-    if (!g_pCompositor->m_pLastMonitor)  // set the last monitor if it isnt set yet
+    if (!g_pCompositor->m_pLastMonitor) // set the last monitor if it isnt set yet
         g_pCompositor->setActiveMonitor(this);
 
     wlr_xcursor_manager_load(g_pCompositor->m_sWLRXCursorMgr, scale);
@@ -189,7 +190,7 @@ void CMonitor::onDisconnect() {
         g_pConfigManager->m_bWantsMonitorReload = true;
     }
 
-    m_bEnabled = false;
+    m_bEnabled             = false;
     m_bRenderingInitPassed = false;
 
     hyprListener_monitorFrame.removeCallback();
@@ -206,7 +207,8 @@ void CMonitor::onDisconnect() {
     }
 
     // snap cursor
-    wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, BACKUPMON->vecPosition.x + BACKUPMON->vecTransformedSize.x / 2.f, BACKUPMON->vecPosition.y + BACKUPMON->vecTransformedSize.y / 2.f);
+    wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, BACKUPMON->vecPosition.x + BACKUPMON->vecTransformedSize.x / 2.f,
+                    BACKUPMON->vecPosition.y + BACKUPMON->vecTransformedSize.y / 2.f);
 
     // move workspaces
     std::deque<CWorkspace*> wspToMove;
@@ -259,7 +261,7 @@ int CMonitor::findAvailableDefaultWS() {
 
         if (const auto BOUND = g_pConfigManager->getBoundMonitorStringForWS(std::to_string(i)); !BOUND.empty() && BOUND != szName)
             continue;
-        
+
         return i;
     }
 
@@ -269,10 +271,10 @@ int CMonitor::findAvailableDefaultWS() {
 void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
     // Workspace
     std::string newDefaultWorkspaceName = "";
-    int64_t WORKSPACEID = monitorRule.defaultWorkspace == "" ? findAvailableDefaultWS() : getWorkspaceIDFromString(monitorRule.defaultWorkspace, newDefaultWorkspaceName);
+    int64_t     WORKSPACEID = monitorRule.defaultWorkspace == "" ? findAvailableDefaultWS() : getWorkspaceIDFromString(monitorRule.defaultWorkspace, newDefaultWorkspaceName);
 
     if (WORKSPACEID == INT_MAX || (WORKSPACEID >= SPECIAL_WORKSPACE_START && WORKSPACEID <= -2)) {
-        WORKSPACEID = g_pCompositor->m_vWorkspaces.size() + 1;
+        WORKSPACEID             = g_pCompositor->m_vWorkspaces.size() + 1;
         newDefaultWorkspaceName = std::to_string(WORKSPACEID);
 
         Debug::log(LOG, "Invalid workspace= directive name in monitor parsing, workspace name \"%s\" is invalid.", monitorRule.defaultWorkspace.c_str());
@@ -347,7 +349,8 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
             }
         }
 
-        if (std::find_if(g_pCompositor->m_vMonitors.begin(), g_pCompositor->m_vMonitors.end(), [&](auto& other) { return other.get() == this; }) == g_pCompositor->m_vMonitors.end()) {
+        if (std::find_if(g_pCompositor->m_vMonitors.begin(), g_pCompositor->m_vMonitors.end(), [&](auto& other) { return other.get() == this; }) ==
+            g_pCompositor->m_vMonitors.end()) {
             g_pCompositor->m_vMonitors.push_back(*m_pThisWrap);
         }
 
@@ -387,9 +390,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
         pMirrorOf->mirrors.push_back(this);
 
         // remove from mvmonitors
-        if (std::find_if(g_pCompositor->m_vMonitors.begin(), g_pCompositor->m_vMonitors.end(), [&](auto& other) { return other.get() == this; }) != g_pCompositor->m_vMonitors.end()) {
-            g_pCompositor->m_vMonitors.erase(std::remove_if(g_pCompositor->m_vMonitors.begin(), g_pCompositor->m_vMonitors.end(), [&](const auto& other) { return other.get() == this; }));
-        }
+        std::erase_if(g_pCompositor->m_vMonitors, [&](const auto& other) { return other.get() == this; });
 
         g_pCompositor->setActiveMonitor(g_pCompositor->m_vMonitors.front().get());
     }
@@ -401,10 +402,10 @@ float CMonitor::getDefaultScale() {
 
     static constexpr double MMPERINCH = 25.4;
 
-    const auto DIAGONALPX = sqrt(pow(vecPixelSize.x, 2) + pow(vecPixelSize.y, 2));
-    const auto DIAGONALIN = sqrt(pow(output->phys_width / MMPERINCH, 2) + pow(output->phys_height / MMPERINCH, 2));
+    const auto              DIAGONALPX = sqrt(pow(vecPixelSize.x, 2) + pow(vecPixelSize.y, 2));
+    const auto              DIAGONALIN = sqrt(pow(output->phys_width / MMPERINCH, 2) + pow(output->phys_height / MMPERINCH, 2));
 
-    const auto PPI = DIAGONALPX / DIAGONALIN;
+    const auto              PPI = DIAGONALPX / DIAGONALIN;
 
     if (PPI > 200 /* High PPI, 2x*/)
         return 2;
diff --git a/src/helpers/Monitor.hpp b/src/helpers/Monitor.hpp
index 75cdb969..ca2913b7 100644
--- a/src/helpers/Monitor.hpp
+++ b/src/helpers/Monitor.hpp
@@ -10,49 +10,49 @@
 struct SMonitorRule;
 
 class CMonitor {
-public:
-    Vector2D    vecPosition         = Vector2D(-1,-1); // means unset
-    Vector2D    vecSize             = Vector2D(0,0);
-    Vector2D    vecPixelSize        = Vector2D(0,0);
-    Vector2D    vecTransformedSize  = Vector2D(0,0);
+  public:
+    Vector2D    vecPosition        = Vector2D(-1, -1); // means unset
+    Vector2D    vecSize            = Vector2D(0, 0);
+    Vector2D    vecPixelSize       = Vector2D(0, 0);
+    Vector2D    vecTransformedSize = Vector2D(0, 0);
 
-    bool        primary         = false;
+    bool        primary = false;
 
     uint64_t    ID              = -1;
     int         activeWorkspace = -1;
     float       scale           = 1;
 
-    std::string szName          = "";
+    std::string szName = "";
 
-    Vector2D    vecReservedTopLeft = Vector2D(0,0);
-    Vector2D    vecReservedBottomRight = Vector2D(0,0);
+    Vector2D    vecReservedTopLeft     = Vector2D(0, 0);
+    Vector2D    vecReservedBottomRight = Vector2D(0, 0);
 
     // WLR stuff
-    wlr_output* output          = nullptr;
-    float       refreshRate     = 60;
-    wlr_output_damage* damage   = nullptr;
-    int         framesToSkip    = 0;
-    int         forceFullFrames = 0;
-    bool        noFrameSchedule = false;
-    bool        scheduledRecalc = false;
-    wl_output_transform transform = WL_OUTPUT_TRANSFORM_NORMAL;
-
-    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.
-    bool        createdByUser = false;
+    wlr_output*         output          = nullptr;
+    float               refreshRate     = 60;
+    wlr_output_damage*  damage          = nullptr;
+    int                 framesToSkip    = 0;
+    int                 forceFullFrames = 0;
+    bool                noFrameSchedule = false;
+    bool                scheduledRecalc = false;
+    wl_output_transform transform       = WL_OUTPUT_TRANSFORM_NORMAL;
+
+    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.
+    bool                createdByUser = false;
 
     // mirroring
-    CMonitor*   pMirrorOf = nullptr;
+    CMonitor*              pMirrorOf = nullptr;
     std::vector<CMonitor*> mirrors;
 
     // for the special workspace. 0 means not open.
-    int         specialWorkspaceID = 0;
+    int specialWorkspaceID = 0;
 
     // Double-linked list because we need to have constant mem addresses for signals
     // We have to store pointers and use raw new/delete because they might be moved between them
     // and I am lazy
-    std::array<std::vector<std::unique_ptr<SLayerSurface>>, 4>   m_aLayerSurfaceLists;
+    std::array<std::vector<std::unique_ptr<SLayerSurface>>, 4> m_aLayerSurfaceLists;
 
     DYNLISTENER(monitorFrame);
     DYNLISTENER(monitorDestroy);
@@ -62,19 +62,18 @@ public:
     // I don't really care lol :P
     wlr_ext_workspace_group_handle_v1* pWLRWorkspaceGroupHandle = nullptr;
 
-
     // methods
-    void        onConnect(bool noRule);
-    void        onDisconnect();
-    void        addDamage(pixman_region32_t* rg);
-    void        addDamage(wlr_box* box);
-    void        setMirror(const std::string&);
-    bool        isMirror();
-    float       getDefaultScale();
-
-    std::shared_ptr<CMonitor>* m_pThisWrap = nullptr;
-    bool        m_bEnabled = false;
-    bool        m_bRenderingInitPassed = false;
+    void                       onConnect(bool noRule);
+    void                       onDisconnect();
+    void                       addDamage(pixman_region32_t* rg);
+    void                       addDamage(wlr_box* box);
+    void                       setMirror(const std::string&);
+    bool                       isMirror();
+    float                      getDefaultScale();
+
+    std::shared_ptr<CMonitor>* m_pThisWrap            = nullptr;
+    bool                       m_bEnabled             = false;
+    bool                       m_bRenderingInitPassed = false;
 
     // For the list lookup
 
@@ -82,7 +81,7 @@ public:
         return vecPosition == rhs.vecPosition && vecSize == rhs.vecSize && szName == rhs.szName;
     }
 
-private:
-    void        setupDefaultWS(const SMonitorRule&);
-    int         findAvailableDefaultWS();
+  private:
+    void setupDefaultWS(const SMonitorRule&);
+    int  findAvailableDefaultWS();
 };
diff --git a/src/helpers/SubsurfaceTree.cpp b/src/helpers/SubsurfaceTree.cpp
index a41030f5..633d80ad 100644
--- a/src/helpers/SubsurfaceTree.cpp
+++ b/src/helpers/SubsurfaceTree.cpp
@@ -23,7 +23,7 @@ void addSurfaceGlobalOffset(SSurfaceTreeNode* node, int* lx, int* ly) {
 SSurfaceTreeNode* createTree(wlr_surface* pSurface, CWindow* pWindow) {
     const auto PNODE = &SubsurfaceTree::surfaceTreeNodes.emplace_back();
 
-    PNODE->pSurface = pSurface;
+    PNODE->pSurface     = pSurface;
     PNODE->pWindowOwner = pWindow;
 
     PNODE->hyprListener_newSubsurface.initCallback(&pSurface->events.new_subsurface, &Events::listener_newSubsurfaceNode, PNODE, "SurfaceTreeNode");
@@ -42,8 +42,8 @@ SSurfaceTreeNode* createTree(wlr_surface* pSurface, CWindow* pWindow) {
 }
 
 SSurfaceTreeNode* createSubsurfaceNode(SSurfaceTreeNode* pParent, SSubsurface* pSubsurface, wlr_surface* surface, CWindow* pWindow) {
-    const auto PNODE = createTree(surface, pWindow);
-    PNODE->pParent = pParent;
+    const auto PNODE   = createTree(surface, pWindow);
+    PNODE->pParent     = pParent;
     PNODE->pSubsurface = pSubsurface;
 
     Debug::log(LOG, "Creating a subsurface Node! (pWindow: %x)", pWindow);
@@ -56,7 +56,7 @@ SSurfaceTreeNode* SubsurfaceTree::createTreeRoot(wlr_surface* pSurface, applyGlo
 
     Debug::log(LOG, "Creating a surfaceTree Root! (pWindow: %x)", pWindow);
 
-    PNODE->offsetfn = fn;
+    PNODE->offsetfn         = fn;
     PNODE->globalOffsetData = data;
 
     return PNODE;
@@ -74,8 +74,8 @@ void SubsurfaceTree::destroySurfaceTree(SSurfaceTreeNode* pNode) {
     }
 
     if (!exists) {
-	    Debug::log(ERR, "Tried to remove a SurfaceTreeNode that doesn't exist?? (Node %x)", pNode);
-	    return;
+        Debug::log(ERR, "Tried to remove a SurfaceTreeNode that doesn't exist?? (Node %x)", pNode);
+        return;
     }
 
     for (auto& c : pNode->childSubsurfaces)
@@ -132,14 +132,14 @@ void destroySubsurface(SSubsurface* pSubsurface) {
 void Events::listener_newSubsurfaceNode(void* owner, void* data) {
     SSurfaceTreeNode* pNode = (SSurfaceTreeNode*)owner;
 
-    const auto PSUBSURFACE = (wlr_subsurface*)data;
+    const auto        PSUBSURFACE = (wlr_subsurface*)data;
 
-    const auto PNEWSUBSURFACE = &pNode->childSubsurfaces.emplace_back();
+    const auto        PNEWSUBSURFACE = &pNode->childSubsurfaces.emplace_back();
 
     Debug::log(LOG, "Added a new subsurface %x", PSUBSURFACE);
 
     PNEWSUBSURFACE->pSubsurface = PSUBSURFACE;
-    PNEWSUBSURFACE->pParent = pNode;
+    PNEWSUBSURFACE->pParent     = pNode;
 
     PNEWSUBSURFACE->hyprListener_map.initCallback(&PSUBSURFACE->events.map, &Events::listener_mapSubsurface, PNEWSUBSURFACE, "Subsurface");
     PNEWSUBSURFACE->hyprListener_unmap.initCallback(&PSUBSURFACE->events.unmap, &Events::listener_unmapSubsurface, PNEWSUBSURFACE, "Subsurface");
@@ -178,7 +178,8 @@ void Events::listener_unmapSubsurface(void* owner, void* data) {
     if (subsurface->pChild) {
         const auto PNODE = subsurface->pChild;
 
-        const auto IT = std::find_if(SubsurfaceTree::surfaceTreeNodes.begin(), SubsurfaceTree::surfaceTreeNodes.end(), [&](const SSurfaceTreeNode& other) { return &other == PNODE; });
+        const auto IT =
+            std::find_if(SubsurfaceTree::surfaceTreeNodes.begin(), SubsurfaceTree::surfaceTreeNodes.end(), [&](const SSurfaceTreeNode& other) { return &other == PNODE; });
 
         if (IT != SubsurfaceTree::surfaceTreeNodes.end()) {
             int lx = 0, ly = 0;
@@ -186,7 +187,7 @@ void Events::listener_unmapSubsurface(void* owner, void* data) {
 
             wlr_box extents = {lx, ly, 0, 0};
             if (PNODE->pSurface) {
-                extents.width = PNODE->pSurface->current.width;
+                extents.width  = PNODE->pSurface->current.width;
                 extents.height = PNODE->pSurface->current.height;
 
                 g_pHyprRenderer->damageBox(&extents);
@@ -203,7 +204,7 @@ void Events::listener_commitSubsurface(void* owner, void* data) {
 
     // no damaging if it's not visible
     if (!g_pHyprRenderer->shouldRenderWindow(pNode->pWindowOwner)) {
-        static auto *const PLOGDAMAGE = &g_pConfigManager->getConfigValuePtr("debug:log_damage")->intValue;
+        static auto* const PLOGDAMAGE = &g_pConfigManager->getConfigValuePtr("debug:log_damage")->intValue;
         if (*PLOGDAMAGE)
             Debug::log(LOG, "Refusing to commit damage from %x because it's invisible.", pNode->pWindowOwner);
         return;
@@ -216,13 +217,14 @@ void Events::listener_commitSubsurface(void* owner, void* data) {
     // I do not think this is correct, but it solves a lot of issues with some apps (e.g. firefox)
     // What this does is that basically, if the pNode is a child of some other node, on commit,
     // it will also damage (check & damage if needed) all its siblings.
-    if (pNode->pParent) for (auto& cs : pNode->pParent->childSubsurfaces) {
-        const auto NODECOORDS = pNode->pSubsurface ? Vector2D(pNode->pSubsurface->pSubsurface->current.x, pNode->pSubsurface->pSubsurface->current.y) : Vector2D();
+    if (pNode->pParent)
+        for (auto& cs : pNode->pParent->childSubsurfaces) {
+            const auto NODECOORDS = pNode->pSubsurface ? Vector2D(pNode->pSubsurface->pSubsurface->current.x, pNode->pSubsurface->pSubsurface->current.y) : Vector2D();
 
-        if (&cs != pNode->pSubsurface && cs.pSubsurface) {
-            g_pHyprRenderer->damageSurface(cs.pSubsurface->surface, lx - NODECOORDS.x + cs.pSubsurface->current.x, ly - NODECOORDS.y + cs.pSubsurface->current.y);
+            if (&cs != pNode->pSubsurface && cs.pSubsurface) {
+                g_pHyprRenderer->damageSurface(cs.pSubsurface->surface, lx - NODECOORDS.x + cs.pSubsurface->current.x, ly - NODECOORDS.y + cs.pSubsurface->current.y);
+            }
         }
-    }
 
     g_pHyprRenderer->damageSurface(pNode->pSurface, lx, ly);
 }
diff --git a/src/helpers/SubsurfaceTree.hpp b/src/helpers/SubsurfaceTree.hpp
index 52f54f16..c5d3934f 100644
--- a/src/helpers/SubsurfaceTree.hpp
+++ b/src/helpers/SubsurfaceTree.hpp
@@ -6,49 +6,49 @@
 struct SSubsurface;
 class CWindow;
 
-typedef void (*applyGlobalOffsetFn)(void *, int *, int *);
+typedef void (*applyGlobalOffsetFn)(void*, int*, int*);
 
 struct SSurfaceTreeNode {
-    wlr_surface*        pSurface = nullptr;
+    wlr_surface* pSurface = nullptr;
 
     DYNLISTENER(newSubsurface);
     DYNLISTENER(commit);
     DYNLISTENER(destroy);
 
-    SSurfaceTreeNode*   pParent = nullptr;
-    SSubsurface*        pSubsurface = nullptr;
+    SSurfaceTreeNode*      pParent     = nullptr;
+    SSubsurface*           pSubsurface = nullptr;
 
     std::list<SSubsurface> childSubsurfaces;
 
-    applyGlobalOffsetFn offsetfn;
-    void *globalOffsetData;
-    CWindow*            pWindowOwner = nullptr;
+    applyGlobalOffsetFn    offsetfn;
+    void*                  globalOffsetData;
+    CWindow*               pWindowOwner = nullptr;
 
-    bool operator==(const SSurfaceTreeNode& rhs) {
+    bool                   operator==(const SSurfaceTreeNode& rhs) {
         return pSurface == rhs.pSurface;
     }
 };
 
 struct SSubsurface {
-    wlr_subsurface*     pSubsurface = nullptr;
+    wlr_subsurface*   pSubsurface = nullptr;
 
-    SSurfaceTreeNode*   pParent = nullptr;
-    SSurfaceTreeNode*   pChild = nullptr;
+    SSurfaceTreeNode* pParent = nullptr;
+    SSurfaceTreeNode* pChild  = nullptr;
 
     DYNLISTENER(map);
     DYNLISTENER(unmap);
     DYNLISTENER(destroy);
 
-    CWindow*            pWindowOwner = nullptr;
+    CWindow* pWindowOwner = nullptr;
 
-    bool operator==(const SSubsurface& rhs) {
+    bool     operator==(const SSubsurface& rhs) {
         return pSubsurface == rhs.pSubsurface;
     }
 };
 
 namespace SubsurfaceTree {
-    SSurfaceTreeNode* createTreeRoot(wlr_surface*, applyGlobalOffsetFn, void*, CWindow* pWindow = nullptr);
-    void destroySurfaceTree(SSurfaceTreeNode*);
+    SSurfaceTreeNode*                  createTreeRoot(wlr_surface*, applyGlobalOffsetFn, void*, CWindow* pWindow = nullptr);
+    void                               destroySurfaceTree(SSurfaceTreeNode*);
 
     inline std::list<SSurfaceTreeNode> surfaceTreeNodes;
 };
diff --git a/src/helpers/Timer.hpp b/src/helpers/Timer.hpp
index 2e8d6adc..7b5bfc9d 100644
--- a/src/helpers/Timer.hpp
+++ b/src/helpers/Timer.hpp
@@ -3,13 +3,13 @@
 #include "../defines.hpp"
 
 class CTimer {
-public:
-    void        reset();
-    float       getSeconds();
-    int         getMillis();
+  public:
+    void  reset();
+    float getSeconds();
+    int   getMillis();
 
-private:
+  private:
     std::chrono::system_clock::time_point m_tpLastReset;
 
-    std::chrono::system_clock::duration getDuration();
+    std::chrono::system_clock::duration   getDuration();
 };
\ No newline at end of file
diff --git a/src/helpers/Vector2D.cpp b/src/helpers/Vector2D.cpp
index a96411e6..97a9685c 100644
--- a/src/helpers/Vector2D.cpp
+++ b/src/helpers/Vector2D.cpp
@@ -6,7 +6,11 @@ Vector2D::Vector2D(double xx, double yy) {
     y = yy;
 }
 
-Vector2D::Vector2D() { x = 0; y = 0; }
+Vector2D::Vector2D() {
+    x = 0;
+    y = 0;
+}
+
 Vector2D::~Vector2D() {}
 
 double Vector2D::normalize() {
@@ -24,8 +28,5 @@ Vector2D Vector2D::floor() {
 }
 
 Vector2D Vector2D::clamp(const Vector2D& min, const Vector2D& max) {
-    return Vector2D(
-        std::clamp(this->x, min.x, max.x == 0 ? INFINITY : max.x),
-        std::clamp(this->y, min.y, max.y == 0 ? INFINITY : max.y)
-    );
+    return Vector2D(std::clamp(this->x, min.x, max.x == 0 ? INFINITY : max.x), std::clamp(this->y, min.y, max.y == 0 ? INFINITY : max.y));
 }
\ No newline at end of file
diff --git a/src/helpers/Vector2D.hpp b/src/helpers/Vector2D.hpp
index 557cdb53..f2f47e6b 100644
--- a/src/helpers/Vector2D.hpp
+++ b/src/helpers/Vector2D.hpp
@@ -3,7 +3,7 @@
 #include <math.h>
 
 class Vector2D {
-   public:
+  public:
     Vector2D(double, double);
     Vector2D();
     ~Vector2D();
@@ -12,18 +12,18 @@ class Vector2D {
     double y = 0;
 
     // returns the scale
-    double normalize();
+    double   normalize();
 
-    Vector2D operator+(const Vector2D a) const {
+    Vector2D operator+(const Vector2D& a) const {
         return Vector2D(this->x + a.x, this->y + a.y);
     }
-    Vector2D operator-(const Vector2D a) const {
+    Vector2D operator-(const Vector2D& a) const {
         return Vector2D(this->x - a.x, this->y - a.y);
     }
-    Vector2D operator*(const float a) const {
+    Vector2D operator*(const float& a) const {
         return Vector2D(this->x * a, this->y * a);
     }
-    Vector2D operator/(const float a) const {
+    Vector2D operator/(const float& a) const {
         return Vector2D(this->x / a, this->y / a);
     }
 
diff --git a/src/helpers/WLClasses.hpp b/src/helpers/WLClasses.hpp
index 1461e481..3da363f9 100644
--- a/src/helpers/WLClasses.hpp
+++ b/src/helpers/WLClasses.hpp
@@ -10,8 +10,8 @@
 struct SLayerSurface {
     SLayerSurface();
 
-    wlr_layer_surface_v1*   layerSurface;
-    wl_list                 link;
+    wlr_layer_surface_v1* layerSurface;
+    wl_list               link;
 
     DYNLISTENER(destroyLayerSurface);
     DYNLISTENER(mapLayerSurface);
@@ -19,22 +19,22 @@ struct SLayerSurface {
     DYNLISTENER(commitLayerSurface);
     DYNLISTENER(newPopup);
 
-    wlr_box                 geometry = {0,0,0,0};
-    Vector2D                position;
+    wlr_box                   geometry = {0, 0, 0, 0};
+    Vector2D                  position;
     zwlr_layer_shell_v1_layer layer;
 
-    bool                    mapped = false;
+    bool                      mapped = false;
 
-    int                     monitorID = -1;
+    int                       monitorID = -1;
 
-    std::string             szNamespace = "";
+    std::string               szNamespace = "";
 
-    CAnimatedVariable       alpha;
-    bool                    fadingOut = false;
-    bool                    readyToDelete = false;
-    bool                    noProcess = false;
+    CAnimatedVariable         alpha;
+    bool                      fadingOut     = false;
+    bool                      readyToDelete = false;
+    bool                      noProcess     = false;
 
-    bool                    forceBlur = false;
+    bool                      forceBlur = false;
 
     // For the list lookup
     bool operator==(const SLayerSurface& rhs) {
@@ -44,14 +44,14 @@ struct SLayerSurface {
 
 struct SRenderData {
     wlr_output* output;
-    timespec* when;
-    int x, y;
+    timespec*   when;
+    int         x, y;
 
     // for iters
-    void* data = nullptr;
+    void*        data    = nullptr;
     wlr_surface* surface = nullptr;
-    int w, h;
-    void* pMonitor = nullptr;
+    int          w, h;
+    void*        pMonitor = nullptr;
 
     // for rounding
     bool dontRound = true;
@@ -69,7 +69,7 @@ struct SRenderData {
     int rounding = -1; // -1 means not set
 
     // for blurring
-    bool blur = false;
+    bool blur                  = false;
     bool blockBlurOptimization = false;
 
     // only for windows, not popups
@@ -80,17 +80,17 @@ struct SRenderData {
 };
 
 struct SExtensionFindingData {
-    Vector2D origin;
-    Vector2D vec;
+    Vector2D      origin;
+    Vector2D      vec;
     wlr_surface** found;
 };
 
 struct SStringRuleNames {
-    std::string layout = "";
-    std::string model = "";
+    std::string layout  = "";
+    std::string model   = "";
     std::string variant = "";
     std::string options = "";
-    std::string rules = "";
+    std::string rules   = "";
 };
 
 struct SKeyboard {
@@ -101,18 +101,18 @@ struct SKeyboard {
     DYNLISTENER(keyboardKeymap);
     DYNLISTENER(keyboardDestroy);
 
-    bool isVirtual = false;
-    bool active = false;
+    bool               isVirtual = false;
+    bool               active    = false;
 
     xkb_layout_index_t activeLayout = 0;
 
-    std::string name = "";
-    std::string xkbFilePath = "";
+    std::string        name        = "";
+    std::string        xkbFilePath = "";
 
-    SStringRuleNames currentRules;
-    int repeatRate = 0;
-    int repeatDelay = 0;
-    int numlockOn = -1;
+    SStringRuleNames   currentRules;
+    int                repeatRate  = 0;
+    int                repeatDelay = 0;
+    int                numlockOn   = -1;
 
     // For the list lookup
     bool operator==(const SKeyboard& rhs) {
@@ -121,18 +121,18 @@ struct SKeyboard {
 };
 
 struct SMouse {
-    wlr_input_device* mouse = nullptr;
+    wlr_input_device*          mouse = nullptr;
 
     wlr_pointer_constraint_v1* currentConstraint = nullptr;
-    bool                       constraintActive = false;
+    bool                       constraintActive  = false;
 
-    pixman_region32_t confinedTo;
+    pixman_region32_t          confinedTo;
 
-    std::string name = "";
+    std::string                name = "";
 
-    bool        virt = false;
+    bool                       virt = false;
 
-    bool        connected = false; // means connected to the cursor
+    bool                       connected = false; // means connected to the cursor
 
     DYNLISTENER(commitConstraint);
     DYNLISTENER(destroyMouse);
@@ -143,11 +143,11 @@ struct SMouse {
 };
 
 struct SConstraint {
-    SMouse* pMouse = nullptr;
+    SMouse*                    pMouse     = nullptr;
     wlr_pointer_constraint_v1* constraint = nullptr;
 
-    bool     hintSet = false;
-    Vector2D positionHint; // the position hint, but will be set to the current cursor pos if not set.
+    bool                       hintSet = false;
+    Vector2D                   positionHint; // the position hint, but will be set to the current cursor pos if not set.
 
     DYNLISTENER(setConstraintRegion);
     DYNLISTENER(destroyConstraint);
@@ -160,10 +160,10 @@ struct SConstraint {
 class CMonitor;
 
 struct SXDGPopup {
-    CWindow*        parentWindow = nullptr;
-    SXDGPopup*      parentPopup = nullptr;
-    wlr_xdg_popup*  popup = nullptr;
-    CMonitor*       monitor = nullptr;
+    CWindow*       parentWindow = nullptr;
+    SXDGPopup*     parentPopup  = nullptr;
+    wlr_xdg_popup* popup        = nullptr;
+    CMonitor*      monitor      = nullptr;
 
     DYNLISTENER(newPopupFromPopupXDG);
     DYNLISTENER(destroyPopupXDG);
@@ -171,8 +171,8 @@ struct SXDGPopup {
     DYNLISTENER(unmapPopupXDG);
     DYNLISTENER(commitPopupXDG);
 
-    double lx;
-    double ly;
+    double            lx;
+    double            ly;
 
     SSurfaceTreeNode* pSurfaceTree = nullptr;
 
@@ -183,24 +183,24 @@ struct SXDGPopup {
 };
 
 struct SSeat {
-    wlr_seat*       seat = nullptr;
-    wl_client*      exclusiveClient = nullptr;
+    wlr_seat*  seat            = nullptr;
+    wl_client* exclusiveClient = nullptr;
 
-    SMouse*         mouse = nullptr;
+    SMouse*    mouse = nullptr;
 };
 
 struct SDrag {
-    wlr_drag*       drag = nullptr;
+    wlr_drag* drag = nullptr;
 
     DYNLISTENER(destroy);
 
     // Icon
 
-    bool            iconMapped = false;
+    bool           iconMapped = false;
 
-    wlr_drag_icon*  dragIcon = nullptr;
+    wlr_drag_icon* dragIcon = nullptr;
 
-    Vector2D        pos;
+    Vector2D       pos;
 
     DYNLISTENER(destroyIcon);
     DYNLISTENER(mapIcon);
@@ -215,31 +215,31 @@ struct STablet {
     DYNLISTENER(Proximity);
     DYNLISTENER(Destroy);
 
-    wlr_tablet* wlrTablet = nullptr;
+    wlr_tablet*           wlrTablet   = nullptr;
     wlr_tablet_v2_tablet* wlrTabletV2 = nullptr;
-    wlr_input_device* wlrDevice = nullptr;
+    wlr_input_device*     wlrDevice   = nullptr;
 
-    std::string name = "";
+    std::string           name = "";
 
-    bool operator==(const STablet& b) {
+    bool                  operator==(const STablet& b) {
         return wlrDevice == b.wlrDevice;
     }
 };
 
 struct STabletTool {
-    wlr_tablet_tool* wlrTabletTool = nullptr;
+    wlr_tablet_tool*           wlrTabletTool   = nullptr;
     wlr_tablet_v2_tablet_tool* wlrTabletToolV2 = nullptr;
 
-    wlr_tablet_v2_tablet* wlrTabletOwnerV2 = nullptr;
+    wlr_tablet_v2_tablet*      wlrTabletOwnerV2 = nullptr;
 
-    wlr_surface* pSurface = nullptr;
+    wlr_surface*               pSurface = nullptr;
 
-    double tiltX = 0;
-    double tiltY = 0;
+    double                     tiltX = 0;
+    double                     tiltY = 0;
 
-    bool active = true;
+    bool                       active = true;
 
-    std::string name = "";
+    std::string                name = "";
 
     DYNLISTENER(TabletToolDestroy);
     DYNLISTENER(TabletToolSetCursor);
@@ -251,9 +251,9 @@ struct STabletTool {
 
 struct STabletPad {
     wlr_tablet_v2_tablet_pad* wlrTabletPadV2 = nullptr;
-    STablet* pTabletParent = nullptr;
+    STablet*                  pTabletParent  = nullptr;
 
-    std::string name = "";
+    std::string               name = "";
 
     DYNLISTENER(Attach);
     DYNLISTENER(Button);
@@ -268,7 +268,7 @@ struct STabletPad {
 
 struct SIdleInhibitor {
     wlr_idle_inhibitor_v1* pWlrInhibitor = nullptr;
-    CWindow* pWindow = nullptr;
+    CWindow*               pWindow       = nullptr;
 
     DYNLISTENER(Destroy);
 
@@ -278,20 +278,20 @@ struct SIdleInhibitor {
 };
 
 struct SSwipeGesture {
-    CWorkspace*  pWorkspaceBegin = nullptr;
+    CWorkspace* pWorkspaceBegin = nullptr;
 
-    double       delta = 0;
+    double      delta = 0;
 
-    float        avgSpeed = 0;
-    int          speedPoints = 0;
+    float       avgSpeed    = 0;
+    int         speedPoints = 0;
 
-    CMonitor*    pMonitor = nullptr;
+    CMonitor*   pMonitor = nullptr;
 };
 
 struct STextInput {
     wlr_text_input_v3* pWlrInput = nullptr;
 
-    wlr_surface* pPendingSurface = nullptr;
+    wlr_surface*       pPendingSurface = nullptr;
 
     DYNLISTENER(textInputEnable);
     DYNLISTENER(textInputDisable);
@@ -304,7 +304,7 @@ struct STextInput {
 struct SIMEKbGrab {
     wlr_input_method_keyboard_grab_v2* pWlrKbGrab = nullptr;
 
-    wlr_keyboard* pKeyboard = nullptr;
+    wlr_keyboard*                      pKeyboard = nullptr;
 
     DYNLISTENER(grabDestroy);
 };
@@ -312,10 +312,10 @@ struct SIMEKbGrab {
 struct SIMEPopup {
     wlr_input_popup_surface_v2* pSurface = nullptr;
 
-    int x, y;
-    int realX, realY;
-    bool visible;
-    Vector2D lastSize;
+    int                         x, y;
+    int                         realX, realY;
+    bool                        visible;
+    Vector2D                    lastSize;
 
     DYNLISTENER(mapPopup);
     DYNLISTENER(unmapPopup);
@@ -332,9 +332,9 @@ struct SIMEPopup {
 struct STouchDevice {
     wlr_input_device* pWlrDevice = nullptr;
 
-    std::string name = "";
+    std::string       name = "";
 
-    std::string boundOutput = "";
+    std::string       boundOutput = "";
 
     DYNLISTENER(destroy);
 
diff --git a/src/helpers/WLListener.cpp b/src/helpers/WLListener.cpp
index 78932a9f..7070c9c8 100644
--- a/src/helpers/WLListener.cpp
+++ b/src/helpers/WLListener.cpp
@@ -14,7 +14,7 @@ CHyprWLListener::CHyprWLListener(wl_signal* pSignal, std::function<void(void*, v
 }
 
 CHyprWLListener::CHyprWLListener() {
-    m_swWrapper.m_pSelf = this;
+    m_swWrapper.m_pSelf            = this;
     m_swWrapper.m_sListener.notify = &handleWrapped;
     wl_list_init(&m_swWrapper.m_sListener.link);
 }
@@ -41,9 +41,9 @@ void CHyprWLListener::initCallback(wl_signal* pSignal, std::function<void(void*,
         return;
     }
 
-    m_pOwner = pOwner;
+    m_pOwner    = pOwner;
     m_pCallback = callback;
-    m_szAuthor = author;
+    m_szAuthor  = author;
 
     addWLSignal(pSignal, &m_swWrapper.m_sListener, pOwner, m_szAuthor);
 }
diff --git a/src/helpers/WLListener.hpp b/src/helpers/WLListener.hpp
index d8d1d7c1..8327e945 100644
--- a/src/helpers/WLListener.hpp
+++ b/src/helpers/WLListener.hpp
@@ -4,35 +4,35 @@
 #include <functional>
 
 class CHyprWLListener {
-public:
+  public:
     CHyprWLListener(wl_signal*, std::function<void(void*, void*)>, void* owner);
     CHyprWLListener();
     ~CHyprWLListener();
 
     CHyprWLListener(const CHyprWLListener&) = delete;
-    CHyprWLListener(CHyprWLListener&&) = delete;
+    CHyprWLListener(CHyprWLListener&&)      = delete;
     CHyprWLListener& operator=(const CHyprWLListener&) = delete;
     CHyprWLListener& operator=(CHyprWLListener&&) = delete;
 
-    void initCallback(wl_signal*, std::function<void(void*, void*)>, void* owner, std::string author = "");
+    void             initCallback(wl_signal*, std::function<void(void*, void*)>, void* owner, std::string author = "");
 
-    void removeCallback();
+    void             removeCallback();
 
-    bool isConnected();
+    bool             isConnected();
 
     struct SWrapper {
-        wl_listener m_sListener;
+        wl_listener      m_sListener;
         CHyprWLListener* m_pSelf;
     };
 
     void emit(void*);
 
-private:
-    SWrapper        m_swWrapper;
+  private:
+    SWrapper                          m_swWrapper;
 
-    void*           m_pOwner = nullptr;
+    void*                             m_pOwner = nullptr;
 
     std::function<void(void*, void*)> m_pCallback = nullptr;
 
-    std::string     m_szAuthor = "";
+    std::string                       m_szAuthor = "";
 };
\ No newline at end of file
diff --git a/src/helpers/Workspace.cpp b/src/helpers/Workspace.cpp
index 8e87c113..d2a8cdf0 100644
--- a/src/helpers/Workspace.cpp
+++ b/src/helpers/Workspace.cpp
@@ -9,8 +9,8 @@ CWorkspace::CWorkspace(int monitorID, std::string name, bool special) {
         return;
     }
 
-    m_iMonitorID = monitorID;
-    m_szName = name;
+    m_iMonitorID          = monitorID;
+    m_szName              = name;
     m_bIsSpecialWorkspace = special;
 
     if (!special) {
@@ -26,9 +26,11 @@ CWorkspace::CWorkspace(int monitorID, std::string name, bool special) {
     }
 
     m_vRenderOffset.m_pWorkspace = this;
-    m_vRenderOffset.create(AVARTYPE_VECTOR, special ? g_pConfigManager->getAnimationPropertyConfig("specialWorkspace") : g_pConfigManager->getAnimationPropertyConfig("workspaces"), nullptr, AVARDAMAGE_ENTIRE);
+    m_vRenderOffset.create(AVARTYPE_VECTOR, special ? g_pConfigManager->getAnimationPropertyConfig("specialWorkspace") : g_pConfigManager->getAnimationPropertyConfig("workspaces"),
+                           nullptr, AVARDAMAGE_ENTIRE);
     m_fAlpha.m_pWorkspace = this;
-    m_fAlpha.create(AVARTYPE_FLOAT, special ? g_pConfigManager->getAnimationPropertyConfig("specialWorkspace") : g_pConfigManager->getAnimationPropertyConfig("workspaces"), nullptr, AVARDAMAGE_ENTIRE);
+    m_fAlpha.create(AVARTYPE_FLOAT, special ? g_pConfigManager->getAnimationPropertyConfig("specialWorkspace") : g_pConfigManager->getAnimationPropertyConfig("workspaces"),
+                    nullptr, AVARDAMAGE_ENTIRE);
     m_fAlpha.setValueAndWarp(255.f);
 
     m_vRenderOffset.registerVar();
@@ -68,7 +70,7 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
         // fallback is slide
         const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
 
-        m_fAlpha.setValueAndWarp(255.f);  // fix a bug, if switching from fade -> slide.
+        m_fAlpha.setValueAndWarp(255.f); // fix a bug, if switching from fade -> slide.
 
         if (in) {
             m_vRenderOffset.setValueAndWarp(Vector2D(0, left ? PMONITOR->vecSize.y : -PMONITOR->vecSize.y));
diff --git a/src/helpers/Workspace.hpp b/src/helpers/Workspace.hpp
index ee70dcff..2fa29d1c 100644
--- a/src/helpers/Workspace.hpp
+++ b/src/helpers/Workspace.hpp
@@ -3,7 +3,8 @@
 #include "../defines.hpp"
 #include "AnimatedVariable.hpp"
 
-enum eFullscreenMode : uint8_t {
+enum eFullscreenMode : uint8_t
+{
     FULLSCREEN_FULL = 0,
     FULLSCREEN_MAXIMIZED
 };
@@ -11,24 +12,24 @@ enum eFullscreenMode : uint8_t {
 class CWindow;
 
 class CWorkspace {
-public:
+  public:
     CWorkspace(int monitorID, std::string name, bool special = false);
     ~CWorkspace();
 
     // Workspaces ID-based have IDs > 0
     // and workspaces name-based have IDs starting with -1337
-    int             m_iID = -1;
-    std::string     m_szName = "";
-    uint64_t        m_iMonitorID = -1;
+    int         m_iID        = -1;
+    std::string m_szName     = "";
+    uint64_t    m_iMonitorID = -1;
     // Previous workspace ID is stored during a workspace change, allowing travel
     // to the previous workspace.
-    int             m_iPrevWorkspaceID = -1;
-    bool            m_bHasFullscreenWindow = false;
-    eFullscreenMode m_efFullscreenMode = FULLSCREEN_FULL;
+    int                          m_iPrevWorkspaceID     = -1;
+    bool                         m_bHasFullscreenWindow = false;
+    eFullscreenMode              m_efFullscreenMode     = FULLSCREEN_FULL;
 
     wlr_ext_workspace_handle_v1* m_pWlrHandle = nullptr;
 
-    wl_array        m_wlrCoordinateArr;
+    wl_array                     m_wlrCoordinateArr;
 
     // for animations
     CAnimatedVariable m_vRenderOffset;
@@ -36,19 +37,19 @@ public:
     bool              m_bForceRendering = false;
 
     // "scratchpad"
-    bool            m_bIsSpecialWorkspace = false;
+    bool m_bIsSpecialWorkspace = false;
 
     // last window
-    CWindow*        m_pLastFocusedWindow = nullptr;
+    CWindow* m_pLastFocusedWindow = nullptr;
 
     // user-set
-    bool            m_bDefaultFloating = false;
-    bool            m_bDefaultPseudo = false;
+    bool     m_bDefaultFloating = false;
+    bool     m_bDefaultPseudo   = false;
 
-    void            startAnim(bool in, bool left, bool instant = false);
-    void            setActive(bool on);
+    void     startAnim(bool in, bool left, bool instant = false);
+    void     setActive(bool on);
 
-    void            moveToMonitor(const int&);
+    void     moveToMonitor(const int&);
 
-    CWindow*        getLastFocusedWindow();
+    CWindow* getLastFocusedWindow();
 };
diff --git a/src/helpers/XWaylandStubs.hpp b/src/helpers/XWaylandStubs.hpp
index 97147f76..256709c7 100644
--- a/src/helpers/XWaylandStubs.hpp
+++ b/src/helpers/XWaylandStubs.hpp
@@ -28,68 +28,69 @@ typedef struct {
 } xcb_size_hints_t;
 typedef unsigned int xcb_window_t;
 
-typedef enum xcb_stack_mode_t {
-    XCB_STACK_MODE_ABOVE = 0,
-    XCB_STACK_MODE_BELOW = 1,
-    XCB_STACK_MODE_TOP_IF = 2,
+typedef enum xcb_stack_mode_t
+{
+    XCB_STACK_MODE_ABOVE     = 0,
+    XCB_STACK_MODE_BELOW     = 1,
+    XCB_STACK_MODE_TOP_IF    = 2,
     XCB_STACK_MODE_BOTTOM_IF = 3,
-    XCB_STACK_MODE_OPPOSITE = 4
+    XCB_STACK_MODE_OPPOSITE  = 4
 } xcb_stack_mode_t;
 
 struct wlr_xwayland {
-    struct wlr_xwayland_server *server;
-	struct wlr_xwm *xwm;
-	struct wlr_xwayland_cursor *cursor;
+    struct wlr_xwayland_server* server;
+    struct wlr_xwm*             xwm;
+    struct wlr_xwayland_cursor* cursor;
 
-	const char *display_name;
+    const char*                 display_name;
 
-	struct wl_display *wl_display;
-	struct wlr_compositor *compositor;
-	struct wlr_seat *seat;
+    struct wl_display*          wl_display;
+    struct wlr_compositor*      compositor;
+    struct wlr_seat*            seat;
 
-	void *data;
+    void*                       data;
 };
 
 struct wlr_xwayland_surface {
-    xcb_window_t window_id;
-    struct wlr_xwm *xwm;
-    uint32_t surface_id;
-
-    struct wl_list link;
-    struct wl_list stack_link;
-    struct wl_list unpaired_link;
-
-    struct wlr_surface *surface;
-    int16_t x, y;
-    uint16_t width, height;
-    uint16_t saved_width, saved_height;
-    bool override_redirect;
-    bool mapped;
-
-    char *title;
-    char *_class;
-    char *instance;
-    char *role;
-    char *startup_id;
-    pid_t pid;
-    bool has_utf8_title;
-
-    struct wl_list children;  // wlr_xwayland_surface::parent_link
-    struct wlr_xwayland_surface *parent;
-    struct wl_list parent_link;  // wlr_xwayland_surface::children
-
-    xcb_atom_t *window_type;
-    size_t window_type_len;
-
-    xcb_atom_t *protocols;
-    size_t protocols_len;
-
-    uint32_t decorations;
-    xcb_icccm_wm_hints_t *hints;
-    xcb_size_hints_t *size_hints;
-
-    bool pinging;
-    struct wl_event_source *ping_timer;
+    xcb_window_t                 window_id;
+    struct wlr_xwm*              xwm;
+    uint32_t                     surface_id;
+
+    struct wl_list               link;
+    struct wl_list               stack_link;
+    struct wl_list               unpaired_link;
+
+    struct wlr_surface*          surface;
+    int16_t                      x, y;
+    uint16_t                     width, height;
+    uint16_t                     saved_width, saved_height;
+    bool                         override_redirect;
+    bool                         mapped;
+
+    char*                        title;
+    char*                        _class;
+    char*                        instance;
+    char*                        role;
+    char*                        startup_id;
+    pid_t                        pid;
+    bool                         has_utf8_title;
+
+    struct wl_list               children; // wlr_xwayland_surface::parent_link
+    struct wlr_xwayland_surface* parent;
+    struct wl_list               parent_link; // wlr_xwayland_surface::children
+
+    xcb_atom_t*                  window_type;
+    size_t                       window_type_len;
+
+    xcb_atom_t*                  protocols;
+    size_t                       protocols_len;
+
+    uint32_t                     decorations;
+    xcb_icccm_wm_hints_t*        hints;
+    xcb_size_hints_t*            size_hints;
+
+    bool                         pinging;
+    struct wl_event_source*      ping_timer;
 
     // _NET_WM_STATE
     bool modal;
@@ -127,35 +128,41 @@ struct wlr_xwayland_surface {
 };
 
 struct wlr_xwayland_surface_configure_event {
-    struct wlr_xwayland_surface *surface;
-    int16_t x, y;
-    uint16_t width, height;
-    uint16_t mask;  // xcb_config_window_t
+    struct wlr_xwayland_surface* surface;
+    int16_t                      x, y;
+    uint16_t                     width, height;
+    uint16_t                     mask; // xcb_config_window_t
 };
 
 struct wlr_xwayland_minimize_event {
-    struct wlr_xwayland_surface *surface;
-    bool minimize;
+    struct wlr_xwayland_surface* surface;
+    bool                         minimize;
 };
 
-inline void wlr_xwayland_destroy(wlr_xwayland*) { }
+inline void wlr_xwayland_destroy(wlr_xwayland*) {}
 
-inline void wlr_xwayland_surface_configure(wlr_xwayland_surface*, int, int, int, int) { }
+inline void wlr_xwayland_surface_configure(wlr_xwayland_surface*, int, int, int, int) {}
 
-inline bool wlr_surface_is_xwayland_surface(void*) { return false; }
+inline bool wlr_surface_is_xwayland_surface(void*) {
+    return false;
+}
 
-inline void wlr_xwayland_surface_activate(wlr_xwayland_surface*, bool) { }
+inline void                  wlr_xwayland_surface_activate(wlr_xwayland_surface*, bool) {}
 
-inline void wlr_xwayland_surface_restack(wlr_xwayland_surface*, int, xcb_stack_mode_t) { }
+inline void                  wlr_xwayland_surface_restack(wlr_xwayland_surface*, int, xcb_stack_mode_t) {}
 
-inline wlr_xwayland_surface* wlr_xwayland_surface_from_wlr_surface(void*) { return nullptr; }
+inline wlr_xwayland_surface* wlr_xwayland_surface_from_wlr_surface(void*) {
+    return nullptr;
+}
 
-inline void wlr_xwayland_surface_close(wlr_xwayland_surface*) { }
+inline void wlr_xwayland_surface_close(wlr_xwayland_surface*) {}
 
-inline void wlr_xwayland_surface_set_fullscreen(wlr_xwayland_surface*, bool) { }
+inline void wlr_xwayland_surface_set_fullscreen(wlr_xwayland_surface*, bool) {}
 
-inline void wlr_xwayland_surface_set_minimized(wlr_xwayland_surface *, bool) { }
+inline void wlr_xwayland_surface_set_minimized(wlr_xwayland_surface*, bool) {}
 
-inline bool wlr_backend_is_x11(void*) { return false; }
+inline bool wlr_backend_is_x11(void*) {
+    return false;
+}
 
-inline void wlr_x11_output_create(void*) { }
\ No newline at end of file
+inline void wlr_x11_output_create(void*) {}
\ No newline at end of file