Added clang format (#1239)

* clang-format stuff and format files

7 files changed, 238 insertions, 209 deletions

diff --git a/src/events/Devices.cpp b/src/events/Devices.cpp
index 146c8c54..a41ba98e 100644
--- a/src/events/Devices.cpp
+++ b/src/events/Devices.cpp
@@ -61,7 +61,7 @@ void Events::listener_requestMouse(wl_listener* listener, void* data) {
 void Events::listener_newInput(wl_listener* listener, void* data) {
     const auto DEVICE = (wlr_input_device*)data;
 
-    switch(DEVICE->type) {
+    switch (DEVICE->type) {
         case WLR_INPUT_DEVICE_KEYBOARD:
             Debug::log(LOG, "Attached a keyboard with name %s", DEVICE->name);
             g_pInputManager->newKeyboard(DEVICE);
@@ -86,9 +86,7 @@ void Events::listener_newInput(wl_listener* listener, void* data) {
             Debug::log(LOG, "Attached a switch device with name %s", DEVICE->name);
             g_pInputManager->newSwitch(DEVICE);
             break;
-        default:
-            Debug::log(WARN, "Unrecognized input device plugged in: %s", DEVICE->name);
-            break;
+        default: Debug::log(WARN, "Unrecognized input device plugged in: %s", DEVICE->name); break;
     }
 
     g_pInputManager->updateCapabilities();
@@ -102,7 +100,7 @@ void Events::listener_newConstraint(wl_listener* listener, void* data) {
     g_pInputManager->m_lConstraints.emplace_back();
     const auto CONSTRAINT = &g_pInputManager->m_lConstraints.back();
 
-    CONSTRAINT->pMouse = g_pCompositor->m_sSeat.mouse;
+    CONSTRAINT->pMouse     = g_pCompositor->m_sSeat.mouse;
     CONSTRAINT->constraint = PCONSTRAINT;
 
     CONSTRAINT->hyprListener_destroyConstraint.initCallback(&PCONSTRAINT->events.destroy, &Events::listener_destroyConstraint, CONSTRAINT, "Constraint");
@@ -112,7 +110,7 @@ void Events::listener_newConstraint(wl_listener* listener, void* data) {
         g_pInputManager->constrainMouse(CONSTRAINT->pMouse, PCONSTRAINT);
 
         if (!CONSTRAINT->hintSet) {
-            const auto PWINDOW = g_pCompositor->getConstraintWindow(g_pCompositor->m_sSeat.mouse);
+            const auto PWINDOW       = g_pCompositor->getConstraintWindow(g_pCompositor->m_sSeat.mouse);
             CONSTRAINT->positionHint = g_pInputManager->getMouseCoordsInternal() - PWINDOW->m_vRealPosition.goalv();
         }
     }
@@ -128,13 +126,13 @@ void Events::listener_destroyConstraint(void* owner, void* data) {
 
         if (PWINDOW) {
             if (PWINDOW->m_bIsX11) {
-                wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr,
-                                PCONSTRAINT->positionHint.x + PWINDOW->m_uSurface.xwayland->x, PWINDOW->m_uSurface.xwayland->y + PCONSTRAINT->positionHint.y);
+                wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, PCONSTRAINT->positionHint.x + PWINDOW->m_uSurface.xwayland->x,
+                                PWINDOW->m_uSurface.xwayland->y + PCONSTRAINT->positionHint.y);
 
                 wlr_seat_pointer_warp(PCONSTRAINT->constraint->seat, PCONSTRAINT->positionHint.x, PCONSTRAINT->positionHint.y);
             } else {
-                wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr,
-                                PCONSTRAINT->positionHint.x + PWINDOW->m_vRealPosition.vec().x, PCONSTRAINT->positionHint.y + PWINDOW->m_vRealPosition.vec().y);
+                wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, PCONSTRAINT->positionHint.x + PWINDOW->m_vRealPosition.vec().x,
+                                PCONSTRAINT->positionHint.y + PWINDOW->m_vRealPosition.vec().y);
 
                 wlr_seat_pointer_warp(PCONSTRAINT->constraint->seat, PCONSTRAINT->positionHint.x, PCONSTRAINT->positionHint.y);
             }
@@ -153,9 +151,9 @@ void Events::listener_setConstraintRegion(void* owner, void* data) {
 }
 
 void Events::listener_newVirtPtr(wl_listener* listener, void* data) {
-    const auto EV = (wlr_virtual_pointer_v1_new_pointer_event*)data;
+    const auto EV      = (wlr_virtual_pointer_v1_new_pointer_event*)data;
     const auto POINTER = EV->new_pointer;
-    const auto DEVICE = &POINTER->pointer.base;
+    const auto DEVICE  = &POINTER->pointer.base;
 
     g_pInputManager->newMouse(DEVICE, true);
 }
diff --git a/src/events/Events.hpp b/src/events/Events.hpp
index e3088110..5036bd75 100644
--- a/src/events/Events.hpp
+++ b/src/events/Events.hpp
@@ -31,7 +31,7 @@ namespace Events {
     DYNLISTENFUNC(commitSubsurface);
 
     // Popups
-    DYNLISTENFUNC(newPopup);  // LayerSurface
+    DYNLISTENFUNC(newPopup); // LayerSurface
 
     DYNLISTENFUNC(newPopupXDG);
     DYNLISTENFUNC(mapPopupXDG);
@@ -60,7 +60,7 @@ namespace Events {
     DYNLISTENFUNC(requestMaximize);
 
     // Window subsurfaces
-   // LISTENER(newSubsurfaceWindow);
+    // LISTENER(newSubsurfaceWindow);
 
     // Input events
     LISTENER(mouseMove);
diff --git a/src/events/Layers.cpp b/src/events/Layers.cpp
index f26575ec..70481c71 100644
--- a/src/events/Layers.cpp
+++ b/src/events/Layers.cpp
@@ -34,7 +34,7 @@ void Events::listener_newLayerSurface(wl_listener* listener, void* data) {
     auto PMONITOR = (CMonitor*)g_pCompositor->getMonitorFromOutput(WLRLAYERSURFACE->output);
 
     if (!WLRLAYERSURFACE->output || !PMONITOR || PMONITOR->pMirrorOf) {
-        PMONITOR = g_pCompositor->m_vMonitors.front().get();
+        PMONITOR                = g_pCompositor->m_vMonitors.front().get();
         WLRLAYERSURFACE->output = PMONITOR->output; // TODO: current mon
     }
 
@@ -49,13 +49,14 @@ void Events::listener_newLayerSurface(wl_listener* listener, void* data) {
     layerSurface->hyprListener_newPopup.initCallback(&WLRLAYERSURFACE->events.new_popup, &Events::listener_newPopup, layerSurface, "layerSurface");
 
     layerSurface->layerSurface = WLRLAYERSURFACE;
-    layerSurface->layer = WLRLAYERSURFACE->current.layer;
-    WLRLAYERSURFACE->data = layerSurface;
-    layerSurface->monitorID = PMONITOR->ID;
+    layerSurface->layer        = WLRLAYERSURFACE->current.layer;
+    WLRLAYERSURFACE->data      = layerSurface;
+    layerSurface->monitorID    = PMONITOR->ID;
 
     layerSurface->forceBlur = g_pConfigManager->shouldBlurLS(layerSurface->szNamespace);
 
-    Debug::log(LOG, "LayerSurface %x (namespace %s layer %d) created on monitor %s", layerSurface->layerSurface, layerSurface->layerSurface->_namespace, layerSurface->layer, PMONITOR->szName.c_str());
+    Debug::log(LOG, "LayerSurface %x (namespace %s layer %d) created on monitor %s", layerSurface->layerSurface, layerSurface->layerSurface->_namespace, layerSurface->layer,
+               PMONITOR->szName.c_str());
 }
 
 void Events::listener_destroyLayerSurface(void* owner, void* data) {
@@ -94,12 +95,13 @@ void Events::listener_destroyLayerSurface(void* owner, void* data) {
         PMONITOR->scheduledRecalc = true;
 
         // and damage
-        wlr_box geomFixed = {layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y, layersurface->geometry.width, layersurface->geometry.height};
+        wlr_box geomFixed = {layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y, layersurface->geometry.width,
+                             layersurface->geometry.height};
         g_pHyprRenderer->damageBox(&geomFixed);
     }
 
     layersurface->readyToDelete = true;
-    layersurface->layerSurface = nullptr;
+    layersurface->layerSurface  = nullptr;
 }
 
 void Events::listener_mapLayerSurface(void* owner, void* data) {
@@ -108,7 +110,7 @@ void Events::listener_mapLayerSurface(void* owner, void* data) {
     Debug::log(LOG, "LayerSurface %x mapped", layersurface->layerSurface);
 
     layersurface->layerSurface->mapped = true;
-    layersurface->mapped = true;
+    layersurface->mapped               = true;
 
     // anim
     layersurface->alpha.setConfig(g_pConfigManager->getAnimationPropertyConfig("fadeIn"));
@@ -128,7 +130,7 @@ void Events::listener_mapLayerSurface(void* owner, void* data) {
                 break;
             }
         }
-        layersurface->monitorID = PMONITOR->ID;
+        layersurface->monitorID   = PMONITOR->ID;
         PMONITOR->scheduledRecalc = true;
         g_pHyprRenderer->arrangeLayersForMonitor(POLDMON->ID);
     }
@@ -137,23 +139,26 @@ void Events::listener_mapLayerSurface(void* owner, void* data) {
 
     wlr_surface_send_enter(layersurface->layerSurface->surface, layersurface->layerSurface->output);
 
-    if (layersurface->layerSurface->current.keyboard_interactive && (!g_pCompositor->m_sSeat.mouse || !g_pCompositor->m_sSeat.mouse->currentConstraint)) { // don't focus if constrained
+    if (layersurface->layerSurface->current.keyboard_interactive &&
+        (!g_pCompositor->m_sSeat.mouse || !g_pCompositor->m_sSeat.mouse->currentConstraint)) { // don't focus if constrained
         g_pCompositor->focusSurface(layersurface->layerSurface->surface);
 
-        const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y);
+        const auto LOCAL =
+            g_pInputManager->getMouseCoordsInternal() - Vector2D(layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y);
         wlr_seat_pointer_notify_enter(g_pCompositor->m_sSeat.seat, layersurface->layerSurface->surface, LOCAL.x, LOCAL.y);
         wlr_seat_pointer_notify_motion(g_pCompositor->m_sSeat.seat, 0, LOCAL.x, LOCAL.y);
     }
 
     layersurface->position = Vector2D(layersurface->geometry.x, layersurface->geometry.y);
 
-    wlr_box geomFixed = {layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y, layersurface->geometry.width, layersurface->geometry.height};
+    wlr_box geomFixed = {layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y, layersurface->geometry.width,
+                         layersurface->geometry.height};
     g_pHyprRenderer->damageBox(&geomFixed);
 
     layersurface->alpha.setValue(0);
-    layersurface->alpha = 255.f;
+    layersurface->alpha         = 255.f;
     layersurface->readyToDelete = false;
-    layersurface->fadingOut = false;
+    layersurface->fadingOut     = false;
 
     g_pEventManager->postEvent(SHyprIPCEvent{"openlayer", std::string(layersurface->layerSurface->_namespace ? layersurface->layerSurface->_namespace : "")});
 }
@@ -201,19 +206,20 @@ void Events::listener_unmapLayerSurface(void* owner, void* data) {
 
     // refocus if needed
     if (layersurface->layerSurface->surface == g_pCompositor->m_pLastFocus) {
-        
-        Vector2D surfaceCoords;
+
+        Vector2D       surfaceCoords;
         SLayerSurface* pFoundLayerSurface = nullptr;
-        wlr_surface* foundSurface = nullptr;
+        wlr_surface*   foundSurface       = nullptr;
 
         g_pCompositor->m_pLastFocus = nullptr;
 
         // find LS-es to focus
-        foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], &surfaceCoords, &pFoundLayerSurface);
+        foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
+                                                           &surfaceCoords, &pFoundLayerSurface);
 
         if (!foundSurface)
-            foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_TOP], &surfaceCoords, &pFoundLayerSurface);
-
+            foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
+                                                               &surfaceCoords, &pFoundLayerSurface);
 
         if (!foundSurface) {
             // if there isn't any, focus the last window
@@ -226,13 +232,16 @@ void Events::listener_unmapLayerSurface(void* owner, void* data) {
         }
     }
 
-    wlr_box geomFixed = {layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y, layersurface->geometry.width, layersurface->geometry.height};
+    wlr_box geomFixed = {layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y, layersurface->geometry.width,
+                         layersurface->geometry.height};
     g_pHyprRenderer->damageBox(&geomFixed);
 
-    geomFixed = {layersurface->geometry.x + (int)PMONITOR->vecPosition.x, layersurface->geometry.y + (int)PMONITOR->vecPosition.y, (int)layersurface->layerSurface->surface->current.width, (int)layersurface->layerSurface->surface->current.height};
+    geomFixed = {layersurface->geometry.x + (int)PMONITOR->vecPosition.x, layersurface->geometry.y + (int)PMONITOR->vecPosition.y,
+                 (int)layersurface->layerSurface->surface->current.width, (int)layersurface->layerSurface->surface->current.height};
     g_pHyprRenderer->damageBox(&geomFixed);
 
-    geomFixed = {layersurface->geometry.x, layersurface->geometry.y, (int)layersurface->layerSurface->surface->current.width, (int)layersurface->layerSurface->surface->current.height};
+    geomFixed              = {layersurface->geometry.x, layersurface->geometry.y, (int)layersurface->layerSurface->surface->current.width,
+                 (int)layersurface->layerSurface->surface->current.height};
     layersurface->geometry = geomFixed; // because the surface can overflow... for some reason?
 }
 
@@ -248,7 +257,7 @@ void Events::listener_commitLayerSurface(void* owner, void* data) {
         return;
 
     if (layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND || layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM)
-        g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR);  // so that blur is recalc'd
+        g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR); // so that blur is recalc'd
 
     wlr_box geomFixed = {layersurface->geometry.x, layersurface->geometry.y, layersurface->geometry.width, layersurface->geometry.height};
     g_pHyprRenderer->damageBox(&geomFixed);
@@ -265,7 +274,7 @@ void Events::listener_commitLayerSurface(void* owner, void* data) {
             }
         }
 
-        layersurface->monitorID = PMONITOR->ID;
+        layersurface->monitorID   = PMONITOR->ID;
         PMONITOR->scheduledRecalc = true;
         g_pHyprRenderer->arrangeLayersForMonitor(POLDMON->ID);
     }
@@ -284,7 +293,7 @@ void Events::listener_commitLayerSurface(void* owner, void* data) {
             layersurface->layer = layersurface->layerSurface->current.layer;
 
             if (layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND || layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM)
-                g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR);  // so that blur is recalc'd
+                g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR); // so that blur is recalc'd
         }
 
         g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID);
@@ -295,7 +304,8 @@ void Events::listener_commitLayerSurface(void* owner, void* data) {
     layersurface->position = Vector2D(layersurface->geometry.x, layersurface->geometry.y);
 
     // update geom if it changed
-    layersurface->geometry = {layersurface->geometry.x, layersurface->geometry.y, layersurface->layerSurface->surface->current.width, layersurface->layerSurface->surface->current.height};
+    layersurface->geometry = {layersurface->geometry.x, layersurface->geometry.y, layersurface->layerSurface->surface->current.width,
+                              layersurface->layerSurface->surface->current.height};
 
     g_pHyprRenderer->damageSurface(layersurface->layerSurface->surface, layersurface->position.x, layersurface->position.y);
 }
diff --git a/src/events/Misc.cpp b/src/events/Misc.cpp
index 707cfde9..cba0a294 100644
--- a/src/events/Misc.cpp
+++ b/src/events/Misc.cpp
@@ -26,8 +26,8 @@ void Events::listener_outputMgrTest(wl_listener* listener, void* data) {
 }
 
 void Events::listener_leaseRequest(wl_listener* listener, void* data) {
-    const auto REQUEST = (wlr_drm_lease_request_v1*)data;
-    struct wlr_drm_lease_v1* lease = wlr_drm_lease_request_v1_grant(REQUEST);
+    const auto               REQUEST = (wlr_drm_lease_request_v1*)data;
+    struct wlr_drm_lease_v1* lease   = wlr_drm_lease_request_v1_grant(REQUEST);
     if (!lease) {
         Debug::log(ERR, "Failed to grant lease request!");
         wlr_drm_lease_request_v1_reject(REQUEST);
@@ -47,7 +47,7 @@ void Events::listener_requestSetSel(wl_listener* listener, void* data) {
 void Events::listener_readyXWayland(wl_listener* listener, void* data) {
 #ifndef NO_XWAYLAND
     const auto XCBCONNECTION = xcb_connect(g_pXWaylandManager->m_sWLRXWayland->display_name, NULL);
-    const auto ERR = xcb_connection_has_error(XCBCONNECTION);
+    const auto ERR           = xcb_connection_has_error(XCBCONNECTION);
     if (ERR) {
         Debug::log(LogLevel::ERR, "XWayland -> xcb_connection_has_error failed with %i", ERR);
         return;
@@ -55,7 +55,7 @@ void Events::listener_readyXWayland(wl_listener* listener, void* data) {
 
     for (auto& ATOM : HYPRATOMS) {
         xcb_intern_atom_cookie_t cookie = xcb_intern_atom(XCBCONNECTION, 0, ATOM.first.length(), ATOM.first.c_str());
-        xcb_intern_atom_reply_t* reply = xcb_intern_atom_reply(XCBCONNECTION, cookie, NULL);
+        xcb_intern_atom_reply_t* reply  = xcb_intern_atom_reply(XCBCONNECTION, cookie, NULL);
 
         if (!reply) {
             Debug::log(LogLevel::ERR, "XWayland -> Atom failed: %s", ATOM.first.c_str());
@@ -69,7 +69,8 @@ void Events::listener_readyXWayland(wl_listener* listener, void* data) {
 
     const auto XCURSOR = wlr_xcursor_manager_get_xcursor(g_pCompositor->m_sWLRXCursorMgr, "left_ptr", 1);
     if (XCURSOR) {
-        wlr_xwayland_set_cursor(g_pXWaylandManager->m_sWLRXWayland, XCURSOR->images[0]->buffer, XCURSOR->images[0]->width * 4, XCURSOR->images[0]->width, XCURSOR->images[0]->height, XCURSOR->images[0]->hotspot_x, XCURSOR->images[0]->hotspot_y);
+        wlr_xwayland_set_cursor(g_pXWaylandManager->m_sWLRXWayland, XCURSOR->images[0]->buffer, XCURSOR->images[0]->width * 4, XCURSOR->images[0]->width,
+                                XCURSOR->images[0]->height, XCURSOR->images[0]->hotspot_x, XCURSOR->images[0]->hotspot_y);
     }
 
     xcb_disconnect(XCBCONNECTION);
@@ -107,15 +108,16 @@ void Events::listener_startDrag(wl_listener* listener, void* data) {
         Debug::log(LOG, "Drag started with an icon %x", wlrDrag->icon);
 
         g_pInputManager->m_sDrag.dragIcon = wlrDrag->icon;
-        wlrDrag->icon->data = g_pInputManager->m_sDrag.dragIcon;
+        wlrDrag->icon->data               = g_pInputManager->m_sDrag.dragIcon;
 
         g_pInputManager->m_sDrag.hyprListener_mapIcon.initCallback(&wlrDrag->icon->events.map, &Events::listener_mapDragIcon, &g_pInputManager->m_sDrag, "DragIcon");
         g_pInputManager->m_sDrag.hyprListener_unmapIcon.initCallback(&wlrDrag->icon->events.unmap, &Events::listener_unmapDragIcon, &g_pInputManager->m_sDrag, "DragIcon");
         g_pInputManager->m_sDrag.hyprListener_destroyIcon.initCallback(&wlrDrag->icon->events.destroy, &Events::listener_destroyDragIcon, &g_pInputManager->m_sDrag, "DragIcon");
-        g_pInputManager->m_sDrag.hyprListener_commitIcon.initCallback(&wlrDrag->icon->surface->events.commit, &Events::listener_commitDragIcon, &g_pInputManager->m_sDrag, "DragIcon");
+        g_pInputManager->m_sDrag.hyprListener_commitIcon.initCallback(&wlrDrag->icon->surface->events.commit, &Events::listener_commitDragIcon, &g_pInputManager->m_sDrag,
+                                                                      "DragIcon");
     }
 
-    static auto *const PFOLLOWONDND = &g_pConfigManager->getConfigValuePtr("misc:always_follow_on_dnd")->intValue;
+    static auto* const PFOLLOWONDND = &g_pConfigManager->getConfigValuePtr("misc:always_follow_on_dnd")->intValue;
 
     if (*PFOLLOWONDND)
         g_pInputManager->m_pFollowOnDnDBegin = g_pCompositor->m_pLastWindow;
@@ -126,12 +128,13 @@ void Events::listener_startDrag(wl_listener* listener, void* data) {
 void Events::listener_destroyDrag(void* owner, void* data) {
     Debug::log(LOG, "Drag destroyed.");
 
-    static auto *const PFOLLOWMOUSE = &g_pConfigManager->getConfigValuePtr("input:follow_mouse")->intValue;
+    static auto* const PFOLLOWMOUSE = &g_pConfigManager->getConfigValuePtr("input:follow_mouse")->intValue;
 
     if (g_pInputManager->m_sDrag.drag && g_pInputManager->m_sDrag.dragIcon && g_pInputManager->m_sDrag.dragIcon->surface)
-        g_pHyprRenderer->damageBox(g_pInputManager->m_sDrag.pos.x - 2, g_pInputManager->m_sDrag.pos.y - 2, g_pInputManager->m_sDrag.dragIcon->surface->current.width + 4, g_pInputManager->m_sDrag.dragIcon->surface->current.height + 4);
+        g_pHyprRenderer->damageBox(g_pInputManager->m_sDrag.pos.x - 2, g_pInputManager->m_sDrag.pos.y - 2, g_pInputManager->m_sDrag.dragIcon->surface->current.width + 4,
+                                   g_pInputManager->m_sDrag.dragIcon->surface->current.height + 4);
 
-    g_pInputManager->m_sDrag.drag = nullptr;
+    g_pInputManager->m_sDrag.drag     = nullptr;
     g_pInputManager->m_sDrag.dragIcon = nullptr;
     g_pInputManager->m_sDrag.hyprListener_destroy.removeCallback();
 
diff --git a/src/events/Monitors.cpp b/src/events/Monitors.cpp
index 282cb4f9..db8a4553 100644
--- a/src/events/Monitors.cpp
+++ b/src/events/Monitors.cpp
@@ -17,7 +17,7 @@
 
 CMonitor* pMostHzMonitor = nullptr;
 
-void Events::listener_change(wl_listener* listener, void* data) {
+void      Events::listener_change(wl_listener* listener, void* data) {
     // layout got changed, let's update monitors.
     const auto CONFIG = wlr_output_configuration_v1_create();
 
@@ -29,14 +29,14 @@ void Events::listener_change(wl_listener* listener, void* data) {
         wlr_output_layout_get_box(g_pCompositor->m_sWLROutputLayout, m->output, &BOX);
 
         //m->vecSize.x = BOX.width;
-       // m->vecSize.y = BOX.height;
+        // m->vecSize.y = BOX.height;
         m->vecPosition.x = BOX.x;
         m->vecPosition.y = BOX.y;
 
         CONFIGHEAD->state.enabled = m->output->enabled;
-        CONFIGHEAD->state.mode = m->output->current_mode;
-        CONFIGHEAD->state.x = m->vecPosition.x;
-        CONFIGHEAD->state.y = m->vecPosition.y;
+        CONFIGHEAD->state.mode    = m->output->current_mode;
+        CONFIGHEAD->state.x       = m->vecPosition.x;
+        CONFIGHEAD->state.y       = m->vecPosition.y;
     }
 
     wlr_output_manager_v1_set_configuration(g_pCompositor->m_sWLROutputMgr, CONFIG);
@@ -75,7 +75,7 @@ void Events::listener_newOutput(wl_listener* listener, void* data) {
 
     const auto PNEWMONITOR = PNEWMONITORWRAP->get();
 
-    PNEWMONITOR->output = OUTPUT;
+    PNEWMONITOR->output      = OUTPUT;
     PNEWMONITOR->m_pThisWrap = PNEWMONITORWRAP;
 
     PNEWMONITOR->onConnect(false);
@@ -86,7 +86,7 @@ void Events::listener_newOutput(wl_listener* listener, void* data) {
     // ready to process cuz we have a monitor
     if (PNEWMONITOR->m_bEnabled) {
         g_pCompositor->m_bReadyToProcess = true;
-        g_pCompositor->m_bUnsafeState = false;
+        g_pCompositor->m_bUnsafeState    = false;
     }
 
     g_pConfigManager->m_bWantsMonitorReload = true;
@@ -104,17 +104,17 @@ void Events::listener_monitorFrame(void* owner, void* data) {
     if (!PMONITOR->m_bEnabled)
         return;
 
-    static std::chrono::high_resolution_clock::time_point startRender = std::chrono::high_resolution_clock::now();
+    static std::chrono::high_resolution_clock::time_point startRender        = std::chrono::high_resolution_clock::now();
     static std::chrono::high_resolution_clock::time_point startRenderOverlay = std::chrono::high_resolution_clock::now();
-    static std::chrono::high_resolution_clock::time_point endRenderOverlay = std::chrono::high_resolution_clock::now();
+    static std::chrono::high_resolution_clock::time_point endRenderOverlay   = std::chrono::high_resolution_clock::now();
 
-    static auto *const PDEBUGOVERLAY = &g_pConfigManager->getConfigValuePtr("debug:overlay")->intValue;
-    static auto *const PDAMAGETRACKINGMODE = &g_pConfigManager->getConfigValuePtr("debug:damage_tracking")->intValue;
-    static auto *const PDAMAGEBLINK = &g_pConfigManager->getConfigValuePtr("debug:damage_blink")->intValue;
-    static auto *const PNOVFR = &g_pConfigManager->getConfigValuePtr("misc:no_vfr")->intValue;
-    static auto *const PNODIRECTSCANOUT = &g_pConfigManager->getConfigValuePtr("misc:no_direct_scanout")->intValue;
+    static auto* const                                    PDEBUGOVERLAY       = &g_pConfigManager->getConfigValuePtr("debug:overlay")->intValue;
+    static auto* const                                    PDAMAGETRACKINGMODE = &g_pConfigManager->getConfigValuePtr("debug:damage_tracking")->intValue;
+    static auto* const                                    PDAMAGEBLINK        = &g_pConfigManager->getConfigValuePtr("debug:damage_blink")->intValue;
+    static auto* const                                    PNOVFR              = &g_pConfigManager->getConfigValuePtr("misc:no_vfr")->intValue;
+    static auto* const                                    PNODIRECTSCANOUT    = &g_pConfigManager->getConfigValuePtr("misc:no_direct_scanout")->intValue;
 
-    static int damageBlinkCleanup = 0; // because double-buffered
+    static int                                            damageBlinkCleanup = 0; // because double-buffered
 
     if (!*PDAMAGEBLINK)
         damageBlinkCleanup = 0;
@@ -140,16 +140,17 @@ void Events::listener_monitorFrame(void* owner, void* data) {
     }
 
     // checks //
-    if (PMONITOR->ID == pMostHzMonitor->ID || !*PNOVFR) {  // unfortunately with VFR we don't have the guarantee mostHz is going to be updated all the time, so we have to ignore that
+    if (PMONITOR->ID == pMostHzMonitor->ID ||
+        !*PNOVFR) { // unfortunately with VFR we don't have the guarantee mostHz is going to be updated all the time, so we have to ignore that
         g_pCompositor->sanityCheckWorkspaces();
         g_pAnimationManager->tick();
 
-        g_pConfigManager->dispatchExecOnce();  // We exec-once when at least one monitor starts refreshing, meaning stuff has init'd
+        g_pConfigManager->dispatchExecOnce(); // We exec-once when at least one monitor starts refreshing, meaning stuff has init'd
 
         if (g_pConfigManager->m_bWantsMonitorReload)
             g_pConfigManager->performMonitorReload();
 
-        g_pHyprRenderer->ensureCursorRenderingMode();  // so that the cursor gets hidden/shown if the user requested timeouts
+        g_pHyprRenderer->ensureCursorRenderingMode(); // so that the cursor gets hidden/shown if the user requested timeouts
     }
     //       //
 
@@ -173,7 +174,7 @@ void Events::listener_monitorFrame(void* owner, void* data) {
 
     // check the damage
     pixman_region32_t damage;
-    bool hasChanged;
+    bool              hasChanged;
     pixman_region32_init(&damage);
 
     if (*PDAMAGETRACKINGMODE == -1) {
@@ -183,7 +184,7 @@ void Events::listener_monitorFrame(void* owner, void* data) {
 
     g_pHyprOpenGL->preRender(PMONITOR);
 
-    if (!wlr_output_damage_attach_render(PMONITOR->damage, &hasChanged, &damage)){
+    if (!wlr_output_damage_attach_render(PMONITOR->damage, &hasChanged, &damage)) {
         Debug::log(ERR, "Couldn't attach render to display %s ???", PMONITOR->szName.c_str());
         return;
     }
@@ -202,24 +203,25 @@ void Events::listener_monitorFrame(void* owner, void* data) {
     }
 
     // if we have no tracking or full tracking, invalidate the entire monitor
-    if (*PDAMAGETRACKINGMODE == DAMAGE_TRACKING_NONE || *PDAMAGETRACKINGMODE == DAMAGE_TRACKING_MONITOR || PMONITOR->forceFullFrames > 0 || damageBlinkCleanup > 0 || PMONITOR->isMirror() /* why??? */) {
+    if (*PDAMAGETRACKINGMODE == DAMAGE_TRACKING_NONE || *PDAMAGETRACKINGMODE == DAMAGE_TRACKING_MONITOR || PMONITOR->forceFullFrames > 0 || damageBlinkCleanup > 0 ||
+        PMONITOR->isMirror() /* why??? */) {
         pixman_region32_union_rect(&damage, &damage, 0, 0, (int)PMONITOR->vecTransformedSize.x * 10, (int)PMONITOR->vecTransformedSize.y * 10); // wot?
 
         pixman_region32_copy(&g_pHyprOpenGL->m_rOriginalDamageRegion, &damage);
     } else {
-        static auto *const PBLURENABLED = &g_pConfigManager->getConfigValuePtr("decoration:blur")->intValue;
+        static auto* const PBLURENABLED = &g_pConfigManager->getConfigValuePtr("decoration:blur")->intValue;
 
         // if we use blur we need to expand the damage for proper blurring
         if (*PBLURENABLED == 1) {
             // TODO: can this be optimized?
-            static auto *const PBLURSIZE = &g_pConfigManager->getConfigValuePtr("decoration:blur_size")->intValue;
-            static auto *const PBLURPASSES = &g_pConfigManager->getConfigValuePtr("decoration:blur_passes")->intValue;
-            const auto BLURRADIUS = *PBLURSIZE * pow(2, *PBLURPASSES);  // is this 2^pass? I don't know but it works... I think.
+            static auto* const PBLURSIZE   = &g_pConfigManager->getConfigValuePtr("decoration:blur_size")->intValue;
+            static auto* const PBLURPASSES = &g_pConfigManager->getConfigValuePtr("decoration:blur_passes")->intValue;
+            const auto         BLURRADIUS  = *PBLURSIZE * pow(2, *PBLURPASSES); // is this 2^pass? I don't know but it works... I think.
 
             pixman_region32_copy(&g_pHyprOpenGL->m_rOriginalDamageRegion, &damage);
 
             // now, prep the damage, get the extended damage region
-            wlr_region_expand(&damage, &damage, BLURRADIUS);                                                   // expand for proper blurring
+            wlr_region_expand(&damage, &damage, BLURRADIUS); // expand for proper blurring
         } else {
             pixman_region32_copy(&g_pHyprOpenGL->m_rOriginalDamageRegion, &damage);
         }
@@ -231,7 +233,6 @@ void Events::listener_monitorFrame(void* owner, void* data) {
             PMONITOR->forceFullFrames = 0;
     }
 
-
     // TODO: this is getting called with extents being 0,0,0,0 should it be?
     // potentially can save on resources.
 
@@ -241,7 +242,7 @@ void Events::listener_monitorFrame(void* owner, void* data) {
         g_pHyprOpenGL->renderMirrored();
     } else {
         g_pHyprOpenGL->clear(CColor(17, 17, 17, 255));
-        g_pHyprOpenGL->clearWithTex();  // will apply the hypr "wallpaper"
+        g_pHyprOpenGL->clearWithTex(); // will apply the hypr "wallpaper"
 
         g_pHyprRenderer->renderAllClientsForMonitor(PMONITOR->ID, &now);
 
@@ -318,7 +319,7 @@ void Events::listener_monitorFrame(void* owner, void* data) {
 void Events::listener_monitorDestroy(void* owner, void* data) {
     const auto OUTPUT = (wlr_output*)data;
 
-    CMonitor* pMonitor = nullptr;
+    CMonitor*  pMonitor = nullptr;
 
     for (auto& m : g_pCompositor->m_vRealMonitors) {
         if (m->output == OUTPUT) {
@@ -338,16 +339,16 @@ void Events::listener_monitorDestroy(void* owner, void* data) {
     if (!g_pCompositor->m_bUnsafeState) {
         Debug::log(LOG, "Removing monitor %s from realMonitors", pMonitor->output->name);
 
-        g_pCompositor->m_vRealMonitors.erase(std::remove_if(g_pCompositor->m_vRealMonitors.begin(), g_pCompositor->m_vRealMonitors.end(), [&](std::shared_ptr<CMonitor>& el) { return el.get() == pMonitor; }));
+        std::erase_if(g_pCompositor->m_vRealMonitors, [&](std::shared_ptr<CMonitor>& el) { return el.get() == pMonitor; });
 
         if (pMostHzMonitor == pMonitor) {
-            int mostHz = 0;
+            int       mostHz         = 0;
             CMonitor* pMonitorMostHz = nullptr;
 
             for (auto& m : g_pCompositor->m_vMonitors) {
                 if (m->refreshRate > mostHz) {
                     pMonitorMostHz = m.get();
-                    mostHz = m->refreshRate;
+                    mostHz         = m->refreshRate;
                 }
             }
 
@@ -358,7 +359,7 @@ void Events::listener_monitorDestroy(void* owner, void* data) {
 
 void Events::listener_monitorStateRequest(void* owner, void* data) {
     const auto PMONITOR = (CMonitor*)owner;
-    const auto E = (wlr_output_event_request_state*)data;
+    const auto E        = (wlr_output_event_request_state*)data;
 
     wlr_output_commit_state(PMONITOR->output, E->state);
 }
diff --git a/src/events/Popups.cpp b/src/events/Popups.cpp
index afc1e7c8..00a49de0 100644
--- a/src/events/Popups.cpp
+++ b/src/events/Popups.cpp
@@ -16,12 +16,12 @@
 // --------------------------------------------- //
 
 void addPopupGlobalCoords(void* pPopup, int* x, int* y) {
-    SXDGPopup *const PPOPUP = (SXDGPopup*)pPopup;
+    SXDGPopup* const PPOPUP = (SXDGPopup*)pPopup;
 
-    auto curPopup = PPOPUP;
+    auto             curPopup = PPOPUP;
 
-    int px = 0;
-    int py = 0;
+    int              px = 0;
+    int              py = 0;
 
     while (true) {
         px += curPopup->popup->current.geometry.x;
@@ -63,13 +63,14 @@ void createNewPopup(wlr_xdg_popup* popup, SXDGPopup* pHyprPopup) {
 
     const auto PMONITOR = g_pCompositor->m_pLastMonitor;
 
-    wlr_box box = {.x = PMONITOR->vecPosition.x - pHyprPopup->lx, .y = PMONITOR->vecPosition.y - pHyprPopup->ly, .width = PMONITOR->vecSize.x, .height = PMONITOR->vecSize.y};
+    wlr_box    box = {.x = PMONITOR->vecPosition.x - pHyprPopup->lx, .y = PMONITOR->vecPosition.y - pHyprPopup->ly, .width = PMONITOR->vecSize.x, .height = PMONITOR->vecSize.y};
 
     wlr_xdg_popup_unconstrain_from_box(popup, &box);
 
     pHyprPopup->monitor = PMONITOR;
 
-    Debug::log(LOG, "Popup: Unconstrained from lx ly: %f %f, pHyprPopup lx ly: %f %f", (float)PMONITOR->vecPosition.x, (float)PMONITOR->vecPosition.y, (float)pHyprPopup->lx, (float)pHyprPopup->ly);
+    Debug::log(LOG, "Popup: Unconstrained from lx ly: %f %f, pHyprPopup lx ly: %f %f", (float)PMONITOR->vecPosition.x, (float)PMONITOR->vecPosition.y, (float)pHyprPopup->lx,
+               (float)pHyprPopup->ly);
 }
 
 void Events::listener_newPopup(void* owner, void* data) {
@@ -85,9 +86,9 @@ void Events::listener_newPopup(void* owner, void* data) {
 
     const auto PMONITOR = g_pCompositor->getMonitorFromID(layersurface->monitorID);
 
-    PNEWPOPUP->popup = WLRPOPUP;
-    PNEWPOPUP->lx = layersurface->position.x;
-    PNEWPOPUP->ly = layersurface->position.y;
+    PNEWPOPUP->popup   = WLRPOPUP;
+    PNEWPOPUP->lx      = layersurface->position.x;
+    PNEWPOPUP->ly      = layersurface->position.y;
     PNEWPOPUP->monitor = PMONITOR;
     createNewPopup(WLRPOPUP, PNEWPOPUP);
 }
@@ -108,11 +109,11 @@ void Events::listener_newPopupXDG(void* owner, void* data) {
 
     const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
 
-    PNEWPOPUP->popup = WLRPOPUP;
-    PNEWPOPUP->lx = PWINDOW->m_vRealPosition.goalv().x;
-    PNEWPOPUP->ly = PWINDOW->m_vRealPosition.goalv().y;
+    PNEWPOPUP->popup        = WLRPOPUP;
+    PNEWPOPUP->lx           = PWINDOW->m_vRealPosition.goalv().x;
+    PNEWPOPUP->ly           = PWINDOW->m_vRealPosition.goalv().y;
     PNEWPOPUP->parentWindow = PWINDOW;
-    PNEWPOPUP->monitor = PMONITOR;
+    PNEWPOPUP->monitor      = PMONITOR;
     createNewPopup(WLRPOPUP, PNEWPOPUP);
 }
 
@@ -130,12 +131,12 @@ void Events::listener_newPopupFromPopupXDG(void* owner, void* data) {
 
     const auto PNEWPOPUP = g_pCompositor->m_vXDGPopups.emplace_back(std::make_unique<SXDGPopup>()).get();
 
-    PNEWPOPUP->popup = WLRPOPUP;
-    PNEWPOPUP->parentPopup = PPOPUP;
-    PNEWPOPUP->lx = PPOPUP->lx;
-    PNEWPOPUP->ly = PPOPUP->ly;
+    PNEWPOPUP->popup        = WLRPOPUP;
+    PNEWPOPUP->parentPopup  = PPOPUP;
+    PNEWPOPUP->lx           = PPOPUP->lx;
+    PNEWPOPUP->ly           = PPOPUP->ly;
     PNEWPOPUP->parentWindow = PPOPUP->parentWindow;
-    PNEWPOPUP->monitor = PPOPUP->monitor;
+    PNEWPOPUP->monitor      = PPOPUP->monitor;
 
     createNewPopup(WLRPOPUP, PNEWPOPUP);
 }
@@ -182,7 +183,7 @@ void Events::listener_unmapPopupXDG(void* owner, void* data) {
 void Events::listener_commitPopupXDG(void* owner, void* data) {
     SXDGPopup* PPOPUP = (SXDGPopup*)owner;
 
-    int lx = 0, ly = 0;
+    int        lx = 0, ly = 0;
     addPopupGlobalCoords(PPOPUP, &lx, &ly);
 
     g_pHyprRenderer->damageSurface(PPOPUP->popup->base->surface, lx, ly);
@@ -200,5 +201,5 @@ void Events::listener_destroyPopupXDG(void* owner, void* data) {
         PPOPUP->pSurfaceTree = nullptr;
     }
 
-    g_pCompositor->m_vXDGPopups.erase(std::remove_if(g_pCompositor->m_vXDGPopups.begin(), g_pCompositor->m_vXDGPopups.end(), [&](std::unique_ptr<SXDGPopup>& el) { return el.get() == PPOPUP; }));
+    std::erase_if(g_pCompositor->m_vXDGPopups, [&](std::unique_ptr<SXDGPopup>& el) { return el.get() == PPOPUP; });
 }
diff --git a/src/events/Windows.cpp b/src/events/Windows.cpp
index 43145c13..1202d304 100644
--- a/src/events/Windows.cpp
+++ b/src/events/Windows.cpp
@@ -30,7 +30,7 @@ void addViewCoords(void* pWindow, int* x, int* y) {
 }
 
 void setAnimToMove(void* data) {
-    auto *const PANIMCFG = g_pConfigManager->getAnimationPropertyConfig("windowsMove");
+    auto* const        PANIMCFG = g_pConfigManager->getAnimationPropertyConfig("windowsMove");
 
     CAnimatedVariable* animvar = (CAnimatedVariable*)data;
 
@@ -38,23 +38,24 @@ void setAnimToMove(void* data) {
 }
 
 void Events::listener_mapWindow(void* owner, void* data) {
-    CWindow* PWINDOW = (CWindow*)owner;
-
-    static auto *const PINACTIVEALPHA = &g_pConfigManager->getConfigValuePtr("decoration:inactive_opacity")->floatValue;
-    static auto *const PACTIVEALPHA = &g_pConfigManager->getConfigValuePtr("decoration:active_opacity")->floatValue;
-    static auto *const PDIMSTRENGTH = &g_pConfigManager->getConfigValuePtr("decoration:dim_strength")->floatValue;
-    static auto *const PSWALLOW = &g_pConfigManager->getConfigValuePtr("misc:enable_swallow")->intValue;
-    static auto *const PSWALLOWREGEX = &g_pConfigManager->getConfigValuePtr("misc:swallow_regex")->strValue;
-
-    auto PMONITOR = g_pCompositor->m_pLastMonitor;
-    const auto PWORKSPACE = PMONITOR->specialWorkspaceID ? g_pCompositor->getWorkspaceByID(PMONITOR->specialWorkspaceID) : g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
-    PWINDOW->m_iMonitorID = PMONITOR->ID;
-    PWINDOW->m_bMappedX11 = true;
-    PWINDOW->m_iWorkspaceID = PMONITOR->specialWorkspaceID ? PMONITOR->specialWorkspaceID : PMONITOR->activeWorkspace;
-    PWINDOW->m_bIsMapped = true;
+    CWindow*           PWINDOW = (CWindow*)owner;
+
+    static auto* const PINACTIVEALPHA = &g_pConfigManager->getConfigValuePtr("decoration:inactive_opacity")->floatValue;
+    static auto* const PACTIVEALPHA   = &g_pConfigManager->getConfigValuePtr("decoration:active_opacity")->floatValue;
+    static auto* const PDIMSTRENGTH   = &g_pConfigManager->getConfigValuePtr("decoration:dim_strength")->floatValue;
+    static auto* const PSWALLOW       = &g_pConfigManager->getConfigValuePtr("misc:enable_swallow")->intValue;
+    static auto* const PSWALLOWREGEX  = &g_pConfigManager->getConfigValuePtr("misc:swallow_regex")->strValue;
+
+    auto               PMONITOR = g_pCompositor->m_pLastMonitor;
+    const auto         PWORKSPACE =
+        PMONITOR->specialWorkspaceID ? g_pCompositor->getWorkspaceByID(PMONITOR->specialWorkspaceID) : g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
+    PWINDOW->m_iMonitorID     = PMONITOR->ID;
+    PWINDOW->m_bMappedX11     = true;
+    PWINDOW->m_iWorkspaceID   = PMONITOR->specialWorkspaceID ? PMONITOR->specialWorkspaceID : PMONITOR->activeWorkspace;
+    PWINDOW->m_bIsMapped      = true;
     PWINDOW->m_bReadyToDelete = false;
-    PWINDOW->m_bFadingOut = false;
-    PWINDOW->m_szTitle = g_pXWaylandManager->getTitle(PWINDOW);
+    PWINDOW->m_bFadingOut     = false;
+    PWINDOW->m_szTitle        = g_pXWaylandManager->getTitle(PWINDOW);
 
     if (PWINDOW->m_iX11Type == 2)
         g_pCompositor->moveUnmanagedX11ToWindows(PWINDOW);
@@ -79,7 +80,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
     }
 
     if (g_pXWaylandManager->shouldBeFloated(PWINDOW)) {
-        PWINDOW->m_bIsFloating = true;
+        PWINDOW->m_bIsFloating    = true;
         PWINDOW->m_bRequestsFloat = true;
     }
 
@@ -90,7 +91,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
     if (PWORKSPACE->m_bDefaultPseudo) {
         PWINDOW->m_bIsPseudotiled = true;
-        wlr_box desiredGeometry = {0};
+        wlr_box desiredGeometry   = {0};
         g_pXWaylandManager->getGeometryForWindow(PWINDOW, &desiredGeometry);
         PWINDOW->m_vPseudoSize = Vector2D(desiredGeometry.width, desiredGeometry.height);
     }
@@ -99,22 +100,24 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
     if (PWORKSPACE->m_bHasFullscreenWindow && !PWINDOW->m_bIsFloating) {
         const auto PFULLWINDOW = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
-        pFullscreenWindow = PFULLWINDOW;
+        pFullscreenWindow      = PFULLWINDOW;
         g_pCompositor->setWindowFullscreen(PFULLWINDOW, false, PWORKSPACE->m_efFullscreenMode);
     }
 
     // window rules
-    const auto WINDOWRULES = g_pConfigManager->getMatchingRules(PWINDOW);
+    const auto  WINDOWRULES        = g_pConfigManager->getMatchingRules(PWINDOW);
     std::string requestedWorkspace = "";
-    bool workspaceSilent = false;
-    bool requestsFullscreen = PWINDOW->m_bWantsInitialFullscreen || (!PWINDOW->m_bIsX11 && PWINDOW->m_uSurface.xdg->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL && PWINDOW->m_uSurface.xdg->toplevel->requested.fullscreen) || (PWINDOW->m_bIsX11 && PWINDOW->m_uSurface.xwayland->fullscreen);
-    bool shouldFocus = true;
+    bool        workspaceSilent    = false;
+    bool        requestsFullscreen = PWINDOW->m_bWantsInitialFullscreen ||
+        (!PWINDOW->m_bIsX11 && PWINDOW->m_uSurface.xdg->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL && PWINDOW->m_uSurface.xdg->toplevel->requested.fullscreen) ||
+        (PWINDOW->m_bIsX11 && PWINDOW->m_uSurface.xwayland->fullscreen);
+    bool shouldFocus      = true;
     bool workspaceSpecial = false;
 
     for (auto& r : WINDOWRULES) {
         if (r.szRule.find("monitor") == 0) {
             try {
-                const auto MONITORSTR = r.szRule.substr(r.szRule.find(" "));
+                const auto MONITORSTR = r.szRule.substr(r.szRule.find(' '));
 
                 if (MONITORSTR == "unset") {
                     PWINDOW->m_iMonitorID = PMONITOR->ID;
@@ -133,9 +136,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                 }
 
                 Debug::log(ERR, "Rule monitor, applying to window %x -> mon: %i, workspace: %i", PWINDOW, PWINDOW->m_iMonitorID, PWINDOW->m_iWorkspaceID);
-            } catch (std::exception& e) {
-                Debug::log(ERR, "Rule monitor failed, rule: %s -> %s | err: %s", r.szRule.c_str(), r.szValue.c_str(), e.what());
-            }
+            } catch (std::exception& e) { Debug::log(ERR, "Rule monitor failed, rule: %s -> %s | err: %s", r.szRule.c_str(), r.szValue.c_str(), e.what()); }
         } else if (r.szRule.find("workspace") == 0) {
             // check if it isnt unset
             const auto WORKSPACERQ = r.szRule.substr(r.szRule.find_first_of(' ') + 1);
@@ -200,7 +201,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
             // check for silent
             if (requestedWorkspace.contains("silent")) {
                 workspaceSilent = true;
-                shouldFocus = false;
+                shouldFocus     = false;
 
                 requestedWorkspace = requestedWorkspace.substr(0, requestedWorkspace.find_first_of(' '));
             }
@@ -211,13 +212,13 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
         if (requestedWorkspace.find("special") == 0) {
             workspaceSpecial = true;
-            workspaceSilent = true;
+            workspaceSilent  = true;
         }
 
         if (!workspaceSilent) {
             g_pKeybindManager->m_mDispatchers["workspace"](requestedWorkspace);
 
-            PWINDOW->m_iMonitorID = g_pCompositor->m_pLastMonitor->ID;
+            PWINDOW->m_iMonitorID   = g_pCompositor->m_pLastMonitor->ID;
             PWINDOW->m_iWorkspaceID = g_pCompositor->m_pLastMonitor->activeWorkspace;
 
             PMONITOR = g_pCompositor->m_pLastMonitor;
@@ -231,14 +232,14 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
         if (!PWORKSPACE) {
             std::string workspaceName = "";
-            int workspaceID = 0;
+            int         workspaceID   = 0;
 
             if (requestedWorkspace.find("name:") == 0) {
                 workspaceName = requestedWorkspace.substr(5);
-                workspaceID = g_pCompositor->getNextAvailableNamedWorkspace();
+                workspaceID   = g_pCompositor->getNextAvailableNamedWorkspace();
             } else if (workspaceSpecial) {
                 workspaceName = "";
-                workspaceID = getWorkspaceIDFromString(requestedWorkspace, workspaceName);
+                workspaceID   = getWorkspaceIDFromString(requestedWorkspace, workspaceName);
             } else {
                 try {
                     workspaceID = std::stoi(requestedWorkspace);
@@ -258,7 +259,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
         if (PWORKSPACE) {
             PWINDOW->m_iWorkspaceID = PWORKSPACE->m_iID;
-            PWINDOW->m_iMonitorID = PWORKSPACE->m_iMonitorID;
+            PWINDOW->m_iMonitorID   = PWORKSPACE->m_iMonitorID;
         }
     }
 
@@ -270,14 +271,18 @@ void Events::listener_mapWindow(void* owner, void* data) {
         for (auto& r : WINDOWRULES) {
             if (r.szRule.find("size") == 0) {
                 try {
-                    const auto VALUE = r.szRule.substr(r.szRule.find(" ") + 1);
-                    const auto SIZEXSTR = VALUE.substr(0, VALUE.find(" "));
-                    const auto SIZEYSTR = VALUE.substr(VALUE.find(" ") + 1);
+                    const auto VALUE    = r.szRule.substr(r.szRule.find(' ') + 1);
+                    const auto SIZEXSTR = VALUE.substr(0, VALUE.find(' '));
+                    const auto SIZEYSTR = VALUE.substr(VALUE.find(' ') + 1);
 
                     const auto MAXSIZE = g_pXWaylandManager->getMaxSizeForWindow(PWINDOW);
 
-                    const auto SIZEX = SIZEXSTR == "max" ? std::clamp(MAXSIZE.x, 20.0, PMONITOR->vecSize.x) : (!SIZEXSTR.contains('%') ? std::stoi(SIZEXSTR) : std::stoi(SIZEXSTR.substr(0, SIZEXSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.x);
-                    const auto SIZEY = SIZEYSTR == "max" ? std::clamp(MAXSIZE.y, 20.0, PMONITOR->vecSize.y) : (!SIZEYSTR.contains('%') ? std::stoi(SIZEYSTR) : std::stoi(SIZEYSTR.substr(0, SIZEYSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.y);
+                    const auto SIZEX = SIZEXSTR == "max" ?
+                        std::clamp(MAXSIZE.x, 20.0, PMONITOR->vecSize.x) :
+                        (!SIZEXSTR.contains('%') ? std::stoi(SIZEXSTR) : std::stoi(SIZEXSTR.substr(0, SIZEXSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.x);
+                    const auto SIZEY = SIZEYSTR == "max" ?
+                        std::clamp(MAXSIZE.y, 20.0, PMONITOR->vecSize.y) :
+                        (!SIZEYSTR.contains('%') ? std::stoi(SIZEYSTR) : std::stoi(SIZEYSTR.substr(0, SIZEYSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.y);
 
                     Debug::log(LOG, "Rule size, applying to window %x", PWINDOW);
 
@@ -285,58 +290,55 @@ void Events::listener_mapWindow(void* owner, void* data) {
                     g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
 
                     PWINDOW->setHidden(false);
-                } catch (...) {
-                    Debug::log(LOG, "Rule size failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str());
-                }
+                } catch (...) { Debug::log(LOG, "Rule size failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str()); }
             } else if (r.szRule.find("minsize") == 0) {
                 try {
-                    const auto VALUE = r.szRule.substr(r.szRule.find(" ") + 1);
-                    const auto SIZEXSTR = VALUE.substr(0, VALUE.find(" "));
-                    const auto SIZEYSTR = VALUE.substr(VALUE.find(" ") + 1);
+                    const auto VALUE    = r.szRule.substr(r.szRule.find(' ') + 1);
+                    const auto SIZEXSTR = VALUE.substr(0, VALUE.find(' '));
+                    const auto SIZEYSTR = VALUE.substr(VALUE.find(' ') + 1);
 
-                    const auto SIZE = Vector2D(std::max((double)std::stoll(SIZEXSTR), PWINDOW->m_vRealSize.goalv().x), std::max((double)std::stoll(SIZEYSTR), PWINDOW->m_vRealSize.goalv().y));
+                    const auto SIZE =
+                        Vector2D(std::max((double)std::stoll(SIZEXSTR), PWINDOW->m_vRealSize.goalv().x), std::max((double)std::stoll(SIZEYSTR), PWINDOW->m_vRealSize.goalv().y));
 
                     PWINDOW->m_vRealSize = SIZE;
                     g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
 
                     PWINDOW->setHidden(false);
-                } catch (...) {
-                    Debug::log(LOG, "Rule minsize failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str());
-                }
+                } catch (...) { Debug::log(LOG, "Rule minsize failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str()); }
             } else if (r.szRule.find("maxsize") == 0) {
                 try {
-                    const auto VALUE = r.szRule.substr(r.szRule.find(" ") + 1);
-                    const auto SIZEXSTR = VALUE.substr(0, VALUE.find(" "));
-                    const auto SIZEYSTR = VALUE.substr(VALUE.find(" ") + 1);
+                    const auto VALUE    = r.szRule.substr(r.szRule.find(' ') + 1);
+                    const auto SIZEXSTR = VALUE.substr(0, VALUE.find(' '));
+                    const auto SIZEYSTR = VALUE.substr(VALUE.find(' ') + 1);
 
-                    const auto SIZE = Vector2D(std::min((double)std::stoll(SIZEXSTR), PWINDOW->m_vRealSize.goalv().x), std::min((double)std::stoll(SIZEYSTR), PWINDOW->m_vRealSize.goalv().y));
+                    const auto SIZE =
+                        Vector2D(std::min((double)std::stoll(SIZEXSTR), PWINDOW->m_vRealSize.goalv().x), std::min((double)std::stoll(SIZEYSTR), PWINDOW->m_vRealSize.goalv().y));
 
                     PWINDOW->m_vRealSize = SIZE;
                     g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
 
                     PWINDOW->setHidden(false);
-                } catch (...) {
-                    Debug::log(LOG, "Rule maxsize failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str());
-                }
+                } catch (...) { Debug::log(LOG, "Rule maxsize failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str()); }
             } else if (r.szRule.find("move") == 0) {
                 try {
-                    auto value = r.szRule.substr(r.szRule.find(" ") + 1);
+                    auto       value = r.szRule.substr(r.szRule.find(' ') + 1);
 
                     const bool CURSOR = value.find("cursor") == 0;
 
                     if (CURSOR)
                         value = value.substr(value.find_first_of(' ') + 1);
 
-                    const auto POSXSTR = value.substr(0, value.find(" "));
-                    const auto POSYSTR = value.substr(value.find(" ") + 1);
+                    const auto POSXSTR = value.substr(0, value.find(' '));
+                    const auto POSYSTR = value.substr(value.find(' ') + 1);
 
-                    int posX = 0;
-                    int posY = 0;
+                    int        posX = 0;
+                    int        posY = 0;
 
                     if (POSXSTR.find("100%-") == 0) {
                         const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
-                        const auto POSXRAW = POSXSTR.substr(5);
-                        posX = PMONITOR->vecSize.x - (!POSXRAW.contains('%') ? std::stoi(POSXRAW) : std::stoi(POSXRAW.substr(0, POSXRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.x);
+                        const auto POSXRAW  = POSXSTR.substr(5);
+                        posX =
+                            PMONITOR->vecSize.x - (!POSXRAW.contains('%') ? std::stoi(POSXRAW) : std::stoi(POSXRAW.substr(0, POSXRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.x);
 
                         if (CURSOR)
                             Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!");
@@ -347,14 +349,16 @@ void Events::listener_mapWindow(void* owner, void* data) {
                         if (POSXSTR == "cursor") {
                             posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->vecPosition.x;
                         } else {
-                            posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->vecPosition.x + (!POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stoi(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PWINDOW->m_vRealSize.goalv().x);
+                            posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->vecPosition.x +
+                                (!POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stoi(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PWINDOW->m_vRealSize.goalv().x);
                         }
                     }
 
                     if (POSYSTR.find("100%-") == 0) {
                         const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
-                        const auto POSYRAW = POSYSTR.substr(5);
-                        posY = PMONITOR->vecSize.y - (!POSYRAW.contains('%') ? std::stoi(POSYRAW) : std::stoi(POSYRAW.substr(0, POSYRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.y);
+                        const auto POSYRAW  = POSYSTR.substr(5);
+                        posY =
+                            PMONITOR->vecSize.y - (!POSYRAW.contains('%') ? std::stoi(POSYRAW) : std::stoi(POSYRAW.substr(0, POSYRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.y);
 
                         if (CURSOR)
                             Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!");
@@ -365,7 +369,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
                         if (POSYSTR == "cursor") {
                             posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->vecPosition.y;
                         } else {
-                            posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->vecPosition.y + (!POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stoi(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PWINDOW->m_vRealSize.goalv().y);
+                            posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->vecPosition.y +
+                                (!POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stoi(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PWINDOW->m_vRealSize.goalv().y);
                         }
                     }
 
@@ -374,9 +379,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                     PWINDOW->m_vRealPosition = Vector2D(posX, posY) + PMONITOR->vecPosition;
 
                     PWINDOW->setHidden(false);
-                } catch (...) {
-                    Debug::log(LOG, "Rule move failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str());
-                }
+                } catch (...) { Debug::log(LOG, "Rule move failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str()); }
             } else if (r.szRule == "center") {
                 PWINDOW->m_vRealPosition = PMONITOR->vecPosition + PMONITOR->vecSize / 2.f - PWINDOW->m_vRealSize.goalv() / 2.f;
             }
@@ -391,14 +394,14 @@ void Events::listener_mapWindow(void* owner, void* data) {
         g_pLayoutManager->getCurrentLayout()->onWindowCreated(PWINDOW);
 
         // Set the pseudo size here too so that it doesnt end up being 0x0
-        PWINDOW->m_vPseudoSize = PWINDOW->m_vRealSize.goalv() - Vector2D(10,10);
+        PWINDOW->m_vPseudoSize = PWINDOW->m_vRealSize.goalv() - Vector2D(10, 10);
     }
 
     const auto PFOCUSEDWINDOWPREV = g_pCompositor->m_pLastWindow;
 
     if (PWINDOW->m_sAdditionalConfigData.forceAllowsInput) {
-        PWINDOW->m_bNoFocus = false;
-        PWINDOW->m_bNoInitialFocus = false;
+        PWINDOW->m_bNoFocus          = false;
+        PWINDOW->m_bNoInitialFocus   = false;
         PWINDOW->m_bX11ShouldntFocus = false;
     }
 
@@ -422,21 +425,28 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PWINDOW->hyprListener_commitWindow.initCallback(&PWINDOW->m_uSurface.xdg->surface->events.commit, &Events::listener_commitWindow, PWINDOW, "XDG Window Late");
         PWINDOW->hyprListener_setTitleWindow.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.set_title, &Events::listener_setTitleWindow, PWINDOW, "XDG Window Late");
         PWINDOW->hyprListener_newPopupXDG.initCallback(&PWINDOW->m_uSurface.xdg->events.new_popup, &Events::listener_newPopupXDG, PWINDOW, "XDG Window Late");
-        PWINDOW->hyprListener_requestMaximize.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_maximize, &Events::listener_requestMaximize, PWINDOW, "XDG Window Late");
-        PWINDOW->hyprListener_requestMinimize.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_minimize, &Events::listener_requestMinimize, PWINDOW, "XDG Window Late");
+        PWINDOW->hyprListener_requestMaximize.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_maximize, &Events::listener_requestMaximize, PWINDOW,
+                                                           "XDG Window Late");
+        PWINDOW->hyprListener_requestMinimize.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_minimize, &Events::listener_requestMinimize, PWINDOW,
+                                                           "XDG Window Late");
         PWINDOW->hyprListener_requestMove.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_move, &Events::listener_requestMove, PWINDOW, "XDG Window Late");
         PWINDOW->hyprListener_requestResize.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_resize, &Events::listener_requestResize, PWINDOW, "XDG Window Late");
-        PWINDOW->hyprListener_fullscreenWindow.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_fullscreen, &Events::listener_fullscreenWindow, PWINDOW, "XDG Window Late");
+        PWINDOW->hyprListener_fullscreenWindow.initCallback(&PWINDOW->m_uSurface.xdg->toplevel->events.request_fullscreen, &Events::listener_fullscreenWindow, PWINDOW,
+                                                            "XDG Window Late");
     } else {
-        PWINDOW->hyprListener_fullscreenWindow.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_fullscreen, &Events::listener_fullscreenWindow, PWINDOW, "XWayland Window Late");
+        PWINDOW->hyprListener_fullscreenWindow.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_fullscreen, &Events::listener_fullscreenWindow, PWINDOW,
+                                                            "XWayland Window Late");
         PWINDOW->hyprListener_activateX11.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_activate, &Events::listener_activateX11, PWINDOW, "XWayland Window Late");
         PWINDOW->hyprListener_configureX11.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_configure, &Events::listener_configureX11, PWINDOW, "XWayland Window Late");
         PWINDOW->hyprListener_setTitleWindow.initCallback(&PWINDOW->m_uSurface.xwayland->events.set_title, &Events::listener_setTitleWindow, PWINDOW, "XWayland Window Late");
-        PWINDOW->hyprListener_requestMinimize.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_minimize, &Events::listener_requestMinimize, PWINDOW, "Xwayland Window Late");
-        PWINDOW->hyprListener_requestMinimize.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_maximize, &Events::listener_requestMaximize, PWINDOW, "Xwayland Window Late");
+        PWINDOW->hyprListener_requestMinimize.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_minimize, &Events::listener_requestMinimize, PWINDOW,
+                                                           "Xwayland Window Late");
+        PWINDOW->hyprListener_requestMinimize.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_maximize, &Events::listener_requestMaximize, PWINDOW,
+                                                           "Xwayland Window Late");
 
         if (PWINDOW->m_iX11Type == 2)
-            PWINDOW->hyprListener_setGeometryX11U.initCallback(&PWINDOW->m_uSurface.xwayland->events.set_geometry, &Events::listener_unmanagedSetGeometry, PWINDOW, "XWayland Window Late");
+            PWINDOW->hyprListener_setGeometryX11U.initCallback(&PWINDOW->m_uSurface.xwayland->events.set_geometry, &Events::listener_unmanagedSetGeometry, PWINDOW,
+                                                               "XWayland Window Late");
     }
 
     // do the animation thing
@@ -502,7 +512,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
             if (ppid) {
                 // get window by pid
                 std::vector<CWindow*> found;
-                CWindow* finalFound = nullptr;
+                CWindow*              finalFound = nullptr;
                 for (auto& w : g_pCompositor->m_vWindows) {
                     if (!w->m_bIsMapped || w->isHidden())
                         continue;
@@ -539,10 +549,12 @@ void Events::listener_mapWindow(void* owner, void* data) {
         }
     }
 
-    Debug::log(LOG, "Map request dispatched, monitor %s, xywh: %f %f %f %f", PMONITOR->szName.c_str(), PWINDOW->m_vRealPosition.goalv().x, PWINDOW->m_vRealPosition.goalv().y, PWINDOW->m_vRealSize.goalv().x, PWINDOW->m_vRealSize.goalv().y);
+    Debug::log(LOG, "Map request dispatched, monitor %s, xywh: %f %f %f %f", PMONITOR->szName.c_str(), PWINDOW->m_vRealPosition.goalv().x, PWINDOW->m_vRealPosition.goalv().y,
+               PWINDOW->m_vRealSize.goalv().x, PWINDOW->m_vRealSize.goalv().y);
 
     auto workspaceID = requestedWorkspace != "" ? requestedWorkspace : PWORKSPACE->m_szName;
-    g_pEventManager->postEvent(SHyprIPCEvent{"openwindow", getFormat("%x,%s,%s,%s", PWINDOW, workspaceID.c_str(), g_pXWaylandManager->getAppIDClass(PWINDOW).c_str(), PWINDOW->m_szTitle.c_str())});
+    g_pEventManager->postEvent(
+        SHyprIPCEvent{"openwindow", getFormat("%x,%s,%s,%s", PWINDOW, workspaceID.c_str(), g_pXWaylandManager->getAppIDClass(PWINDOW).c_str(), PWINDOW->m_szTitle.c_str())});
 
     // recalc the values for this window
     g_pCompositor->updateWindowAnimatedDecorationValues(PWINDOW);
@@ -595,9 +607,9 @@ void Events::listener_unmapWindow(void* owner, void* data) {
     bool wasLastWindow = false;
 
     if (PWINDOW == g_pCompositor->m_pLastWindow) {
-        wasLastWindow = true;
+        wasLastWindow                = true;
         g_pCompositor->m_pLastWindow = nullptr;
-        g_pCompositor->m_pLastFocus = nullptr;
+        g_pCompositor->m_pLastFocus  = nullptr;
     }
 
     PWINDOW->m_bMappedX11 = false;
@@ -645,11 +657,11 @@ void Events::listener_unmapWindow(void* owner, void* data) {
     const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
 
     // do the animation thing
-    PWINDOW->m_vOriginalClosedPos = PWINDOW->m_vRealPosition.vec() - PMONITOR->vecPosition;
+    PWINDOW->m_vOriginalClosedPos  = PWINDOW->m_vRealPosition.vec() - PMONITOR->vecPosition;
     PWINDOW->m_vOriginalClosedSize = PWINDOW->m_vRealSize.vec();
 
-    if (!PWINDOW->m_bX11DoesntWantBorders)   // don't animate out if they weren't animated in.
-        PWINDOW->m_vRealPosition = PWINDOW->m_vRealPosition.vec() + Vector2D(0.01f, 0.01f);  // it has to be animated, otherwise onWindowPostCreateClose will ignore it
+    if (!PWINDOW->m_bX11DoesntWantBorders)                                                  // don't animate out if they weren't animated in.
+        PWINDOW->m_vRealPosition = PWINDOW->m_vRealPosition.vec() + Vector2D(0.01f, 0.01f); // it has to be animated, otherwise onWindowPostCreateClose will ignore it
 
     // anims
     g_pAnimationManager->onWindowPostCreateClose(PWINDOW, true);
@@ -689,7 +701,7 @@ void Events::listener_destroyWindow(void* owner, void* data) {
 
     if (PWINDOW == g_pCompositor->m_pLastWindow) {
         g_pCompositor->m_pLastWindow = nullptr;
-        g_pCompositor->m_pLastFocus = nullptr;
+        g_pCompositor->m_pLastFocus  = nullptr;
     }
 
     PWINDOW->hyprListener_mapWindow.removeCallback();
@@ -705,7 +717,7 @@ void Events::listener_destroyWindow(void* owner, void* data) {
     }
 
     PWINDOW->m_bReadyToDelete = true;
-    
+
     if (!PWINDOW->m_bFadingOut) {
         g_pCompositor->removeWindowFromVectorSafe(PWINDOW); // most likely X11 unmanaged or sumn
         Debug::log(LOG, "Unmapped window %x removed instantly", PWINDOW);
@@ -716,7 +728,7 @@ void Events::listener_setTitleWindow(void* owner, void* data) {
     CWindow* PWINDOW = (CWindow*)owner;
 
     if (!g_pCompositor->windowValidMapped(PWINDOW))
-	    return;
+        return;
 
     PWINDOW->m_szTitle = g_pXWaylandManager->getTitle(PWINDOW);
 
@@ -761,9 +773,9 @@ void Events::listener_fullscreenWindow(void* owner, void* data) {
 }
 
 void Events::listener_activateXDG(wl_listener* listener, void* data) {
-    const auto E = (wlr_xdg_activation_v1_request_activate_event*)data;
+    const auto         E = (wlr_xdg_activation_v1_request_activate_event*)data;
 
-    static auto *const PFOCUSONACTIVATE = &g_pConfigManager->getConfigValuePtr("misc:focus_on_activate")->intValue;
+    static auto* const PFOCUSONACTIVATE = &g_pConfigManager->getConfigValuePtr("misc:focus_on_activate")->intValue;
 
     Debug::log(LOG, "Activate request for surface at %x", E->surface);
 
@@ -781,9 +793,9 @@ void Events::listener_activateXDG(wl_listener* listener, void* data) {
 }
 
 void Events::listener_activateX11(void* owner, void* data) {
-    const auto PWINDOW = (CWindow*)owner;
+    const auto         PWINDOW = (CWindow*)owner;
 
-    static auto *const PFOCUSONACTIVATE = &g_pConfigManager->getConfigValuePtr("misc:focus_on_activate")->intValue;
+    static auto* const PFOCUSONACTIVATE = &g_pConfigManager->getConfigValuePtr("misc:focus_on_activate")->intValue;
 
     Debug::log(LOG, "X11 Activate request for window %x", PWINDOW);
 
@@ -824,7 +836,7 @@ void Events::listener_configureX11(void* owner, void* data) {
     PWINDOW->m_vRealPosition.setValueAndWarp(Vector2D(E->x, E->y));
     PWINDOW->m_vRealSize.setValueAndWarp(Vector2D(E->width, E->height));
     PWINDOW->m_vPosition = PWINDOW->m_vRealPosition.vec();
-    PWINDOW->m_vSize = PWINDOW->m_vRealSize.vec();
+    PWINDOW->m_vSize     = PWINDOW->m_vRealSize.vec();
 
     wlr_xwayland_surface_configure(PWINDOW->m_uSurface.xwayland, E->x, E->y, E->width, E->height);
 
@@ -862,8 +874,10 @@ void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
         return;
     }
 
-    if (abs(std::floor(POS.x) - PWINDOW->m_uSurface.xwayland->x) > 2 || abs(std::floor(POS.y) - PWINDOW->m_uSurface.xwayland->y) > 2 || abs(std::floor(SIZ.x) - PWINDOW->m_uSurface.xwayland->width) > 2 || abs(std::floor(SIZ.y) - PWINDOW->m_uSurface.xwayland->height) > 2) {
-        Debug::log(LOG, "Unmanaged window %x requests geometry update to %i %i %i %i", PWINDOW, (int)PWINDOW->m_uSurface.xwayland->x, (int)PWINDOW->m_uSurface.xwayland->y, (int)PWINDOW->m_uSurface.xwayland->width, (int)PWINDOW->m_uSurface.xwayland->height);
+    if (abs(std::floor(POS.x) - PWINDOW->m_uSurface.xwayland->x) > 2 || abs(std::floor(POS.y) - PWINDOW->m_uSurface.xwayland->y) > 2 ||
+        abs(std::floor(SIZ.x) - PWINDOW->m_uSurface.xwayland->width) > 2 || abs(std::floor(SIZ.y) - PWINDOW->m_uSurface.xwayland->height) > 2) {
+        Debug::log(LOG, "Unmanaged window %x requests geometry update to %i %i %i %i", PWINDOW, (int)PWINDOW->m_uSurface.xwayland->x, (int)PWINDOW->m_uSurface.xwayland->y,
+                   (int)PWINDOW->m_uSurface.xwayland->width, (int)PWINDOW->m_uSurface.xwayland->height);
 
         g_pHyprRenderer->damageWindow(PWINDOW);
         PWINDOW->m_vRealPosition.setValueAndWarp(Vector2D(PWINDOW->m_uSurface.xwayland->x, PWINDOW->m_uSurface.xwayland->y));
@@ -886,11 +900,12 @@ void Events::listener_surfaceXWayland(wl_listener* listener, void* data) {
     if (XWSURFACE->parent)
         Debug::log(LOG, "Window parent data: %s at %x", XWSURFACE->parent->_class, XWSURFACE->parent);
 
-    const auto PNEWWINDOW = XWSURFACE->override_redirect ? g_pCompositor->m_dUnmanagedX11Windows.emplace_back(std::make_unique<CWindow>()).get() : g_pCompositor->m_vWindows.emplace_back(std::make_unique<CWindow>()).get();
+    const auto PNEWWINDOW = XWSURFACE->override_redirect ? g_pCompositor->m_dUnmanagedX11Windows.emplace_back(std::make_unique<CWindow>()).get() :
+                                                           g_pCompositor->m_vWindows.emplace_back(std::make_unique<CWindow>()).get();
 
     PNEWWINDOW->m_uSurface.xwayland = XWSURFACE;
-    PNEWWINDOW->m_iX11Type = XWSURFACE->override_redirect ? 2 : 1;
-    PNEWWINDOW->m_bIsX11 = true;
+    PNEWWINDOW->m_iX11Type          = XWSURFACE->override_redirect ? 2 : 1;
+    PNEWWINDOW->m_bIsX11            = true;
 
     PNEWWINDOW->m_pX11Parent = g_pCompositor->getX11Parent(PNEWWINDOW);
 
@@ -908,7 +923,7 @@ void Events::listener_newXDGSurface(wl_listener* listener, void* data) {
 
     Debug::log(LOG, "New XDG Surface created. (class: %s)", XDGSURFACE->toplevel->app_id);
 
-    const auto PNEWWINDOW = g_pCompositor->m_vWindows.emplace_back(std::make_unique<CWindow>()).get();
+    const auto PNEWWINDOW      = g_pCompositor->m_vWindows.emplace_back(std::make_unique<CWindow>()).get();
     PNEWWINDOW->m_uSurface.xdg = XDGSURFACE;
 
     PNEWWINDOW->hyprListener_mapWindow.initCallback(&XDGSURFACE->events.map, &Events::listener_mapWindow, PNEWWINDOW, "XDG Window");
@@ -931,7 +946,8 @@ void Events::listener_requestMaximize(void* owner, void* data) {
     if (!PWINDOW->m_bIsX11) {
         const auto EV = (wlr_foreign_toplevel_handle_v1_maximized_event*)data;
 
-        g_pCompositor->setWindowFullscreen(PWINDOW, EV ? EV->maximized : !PWINDOW->m_bIsFullscreen, FULLSCREEN_MAXIMIZED);  // this will be rejected if there already is a fullscreen window
+        g_pCompositor->setWindowFullscreen(PWINDOW, EV ? EV->maximized : !PWINDOW->m_bIsFullscreen,
+                                           FULLSCREEN_MAXIMIZED); // this will be rejected if there already is a fullscreen window
 
         wlr_xdg_surface_schedule_configure(PWINDOW->m_uSurface.xdg);
     } else {