From 21184404885cf61f7c10d2eb749478ef6b035dd2 Mon Sep 17 00:00:00 2001 From: davc0n Date: Mon, 28 Apr 2025 22:25:22 +0200 Subject: windows: refactor class member vars (#10168) --- src/layout/DwindleLayout.cpp | 164 ++++++++++++------------ src/layout/IHyprLayout.cpp | 293 +++++++++++++++++++++---------------------- src/layout/MasterLayout.cpp | 126 +++++++++---------- 3 files changed, 291 insertions(+), 292 deletions(-) (limited to 'src/layout') diff --git a/src/layout/DwindleLayout.cpp b/src/layout/DwindleLayout.cpp index 0c9f0803..5ebd14ce 100644 --- a/src/layout/DwindleLayout.cpp +++ b/src/layout/DwindleLayout.cpp @@ -147,13 +147,13 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for CBox nodeBox = pNode->box; nodeBox.round(); - PWINDOW->m_vSize = nodeBox.size(); - PWINDOW->m_vPosition = nodeBox.pos(); + PWINDOW->m_size = nodeBox.size(); + PWINDOW->m_position = nodeBox.pos(); PWINDOW->updateWindowDecos(); - auto calcPos = PWINDOW->m_vPosition; - auto calcSize = PWINDOW->m_vSize; + auto calcPos = PWINDOW->m_position; + auto calcSize = PWINDOW->m_size; const auto OFFSETTOPLEFT = Vector2D((double)(DISPLAYLEFT ? gapsOut.m_left : gapsIn.m_left), (double)(DISPLAYTOP ? gapsOut.m_top : gapsIn.m_top)); @@ -162,27 +162,27 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for calcPos = calcPos + OFFSETTOPLEFT; calcSize = calcSize - OFFSETTOPLEFT - OFFSETBOTTOMRIGHT; - if (PWINDOW->m_bIsPseudotiled) { + if (PWINDOW->m_isPseudotiled) { // Calculate pseudo float scale = 1; // adjust if doesnt fit - if (PWINDOW->m_vPseudoSize.x > calcSize.x || PWINDOW->m_vPseudoSize.y > calcSize.y) { - if (PWINDOW->m_vPseudoSize.x > calcSize.x) { - scale = calcSize.x / PWINDOW->m_vPseudoSize.x; + if (PWINDOW->m_pseudoSize.x > calcSize.x || PWINDOW->m_pseudoSize.y > calcSize.y) { + if (PWINDOW->m_pseudoSize.x > calcSize.x) { + scale = calcSize.x / PWINDOW->m_pseudoSize.x; } - if (PWINDOW->m_vPseudoSize.y * scale > calcSize.y) { - scale = calcSize.y / PWINDOW->m_vPseudoSize.y; + if (PWINDOW->m_pseudoSize.y * scale > calcSize.y) { + scale = calcSize.y / PWINDOW->m_pseudoSize.y; } - auto DELTA = calcSize - PWINDOW->m_vPseudoSize * scale; - calcSize = PWINDOW->m_vPseudoSize * scale; + auto DELTA = calcSize - PWINDOW->m_pseudoSize * scale; + calcSize = PWINDOW->m_pseudoSize * scale; calcPos = calcPos + DELTA / 2.f; // center } else { - auto DELTA = calcSize - PWINDOW->m_vPseudoSize; + auto DELTA = calcSize - PWINDOW->m_pseudoSize; calcPos = calcPos + DELTA / 2.f; // center - calcSize = PWINDOW->m_vPseudoSize; + calcSize = PWINDOW->m_pseudoSize; } } @@ -197,21 +197,21 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for CBox wb = {calcPos + (calcSize - calcSize * *PSCALEFACTOR) / 2.f, calcSize * *PSCALEFACTOR}; wb.round(); // avoid rounding mess - *PWINDOW->m_vRealPosition = wb.pos(); - *PWINDOW->m_vRealSize = wb.size(); + *PWINDOW->m_realPosition = wb.pos(); + *PWINDOW->m_realSize = wb.size(); } else { CBox wb = {calcPos, calcSize}; wb.round(); // avoid rounding mess - *PWINDOW->m_vRealSize = wb.size(); - *PWINDOW->m_vRealPosition = wb.pos(); + *PWINDOW->m_realSize = wb.size(); + *PWINDOW->m_realPosition = wb.pos(); } if (force) { g_pHyprRenderer->damageWindow(PWINDOW); - PWINDOW->m_vRealPosition->warp(); - PWINDOW->m_vRealSize->warp(); + PWINDOW->m_realPosition->warp(); + PWINDOW->m_realSize->warp(); g_pHyprRenderer->damageWindow(PWINDOW); } @@ -220,13 +220,13 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for } void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection direction) { - if (pWindow->m_bIsFloating) + if (pWindow->m_isFloating) return; m_lDwindleNodesData.emplace_back(); const auto PNODE = &m_lDwindleNodesData.back(); - const auto PMONITOR = pWindow->m_pMonitor.lock(); + const auto PMONITOR = pWindow->m_monitor.lock(); static auto PUSEACTIVE = CConfigValue("dwindle:use_active_for_splits"); static auto PDEFAULTSPLIT = CConfigValue("dwindle:default_split_ratio"); @@ -253,8 +253,8 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir OPENINGON = getClosestNodeOnWorkspace(PNODE->workspaceID, MOUSECOORDS); } else if (*PUSEACTIVE) { - if (g_pCompositor->m_lastWindow.lock() && !g_pCompositor->m_lastWindow->m_bIsFloating && g_pCompositor->m_lastWindow.lock() != pWindow && - g_pCompositor->m_lastWindow->m_pWorkspace == pWindow->m_pWorkspace && g_pCompositor->m_lastWindow->m_bIsMapped) { + if (g_pCompositor->m_lastWindow.lock() && !g_pCompositor->m_lastWindow->m_isFloating && g_pCompositor->m_lastWindow.lock() != pWindow && + g_pCompositor->m_lastWindow->m_workspace == pWindow->m_workspace && g_pCompositor->m_lastWindow->m_isMapped) { OPENINGON = getNodeFromWindow(g_pCompositor->m_lastWindow.lock()); } else { OPENINGON = getNodeFromWindow(g_pCompositor->vectorToWindowUnified(MOUSECOORDS, RESERVED_EXTENTS | INPUT_EXTENTS)); @@ -277,7 +277,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir const auto PREDSIZEMAX = OPENINGON ? Vector2D(OPENINGON->box.w, OPENINGON->box.h) : PMONITOR->vecSize; if (const auto MAXSIZE = pWindow->requestedMaxSize(); MAXSIZE.x < PREDSIZEMAX.x || MAXSIZE.y < PREDSIZEMAX.y) { // we can't continue. make it floating. - pWindow->m_bIsFloating = true; + pWindow->m_isFloating = true; m_lDwindleNodesData.remove(*PNODE); g_pLayoutManager->getCurrentLayout()->onWindowCreatedFloating(pWindow); return; @@ -379,7 +379,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir NEWPARENT->children[1] = OPENINGON; } } - } else if (*PFORCESPLIT == 0 || !pWindow->m_bFirstMap) { + } else if (*PFORCESPLIT == 0 || !pWindow->m_firstMap) { if ((SIDEBYSIDE && VECINRECT(MOUSECOORDS, NEWPARENT->box.x, NEWPARENT->box.y / *PWIDTHMULTIPLIER, NEWPARENT->box.x + NEWPARENT->box.w / 2.f, NEWPARENT->box.y + NEWPARENT->box.h)) || (!SIDEBYSIDE && @@ -509,15 +509,15 @@ void CHyprDwindleLayout::calculateWorkspace(const PHLWORKSPACE& pWorkspace) { const auto PFULLWINDOW = pWorkspace->getFullscreenWindow(); if (pWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) { - *PFULLWINDOW->m_vRealPosition = PMONITOR->vecPosition; - *PFULLWINDOW->m_vRealSize = PMONITOR->vecSize; + *PFULLWINDOW->m_realPosition = PMONITOR->vecPosition; + *PFULLWINDOW->m_realSize = PMONITOR->vecSize; } else if (pWorkspace->m_fullscreenMode == FSMODE_MAXIMIZED) { SDwindleNodeData fakeNode; - fakeNode.pWindow = PFULLWINDOW; - fakeNode.box = {PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft, PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight}; - fakeNode.workspaceID = pWorkspace->m_id; - PFULLWINDOW->m_vPosition = fakeNode.box.pos(); - PFULLWINDOW->m_vSize = fakeNode.box.size(); + fakeNode.pWindow = PFULLWINDOW; + fakeNode.box = {PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft, PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight}; + fakeNode.workspaceID = pWorkspace->m_id; + PFULLWINDOW->m_position = fakeNode.box.pos(); + PFULLWINDOW->m_size = fakeNode.box.size(); fakeNode.ignoreFullscreenChecks = true; applyNodeDataToWindow(&fakeNode); @@ -555,9 +555,9 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorn const auto PNODE = getNodeFromWindow(PWINDOW); if (!PNODE) { - *PWINDOW->m_vRealSize = - (PWINDOW->m_vRealSize->goal() + pixResize) - .clamp(PWINDOW->m_sWindowData.minSize.valueOr(Vector2D{MIN_WINDOW_SIZE, MIN_WINDOW_SIZE}), PWINDOW->m_sWindowData.maxSize.valueOr(Vector2D{INFINITY, INFINITY})); + *PWINDOW->m_realSize = + (PWINDOW->m_realSize->goal() + pixResize) + .clamp(PWINDOW->m_windowData.minSize.valueOr(Vector2D{MIN_WINDOW_SIZE, MIN_WINDOW_SIZE}), PWINDOW->m_windowData.maxSize.valueOr(Vector2D{INFINITY, INFINITY})); PWINDOW->updateWindowDecos(); return; } @@ -566,17 +566,17 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorn static auto PSMARTRESIZING = CConfigValue("dwindle:smart_resizing"); // get some data about our window - const auto PMONITOR = PWINDOW->m_pMonitor.lock(); - const bool DISPLAYLEFT = STICKS(PWINDOW->m_vPosition.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x); - const bool DISPLAYRIGHT = STICKS(PWINDOW->m_vPosition.x + PWINDOW->m_vSize.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x); - const bool DISPLAYTOP = STICKS(PWINDOW->m_vPosition.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y); - const bool DISPLAYBOTTOM = STICKS(PWINDOW->m_vPosition.y + PWINDOW->m_vSize.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y); + const auto PMONITOR = PWINDOW->m_monitor.lock(); + const bool DISPLAYLEFT = STICKS(PWINDOW->m_position.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x); + const bool DISPLAYRIGHT = STICKS(PWINDOW->m_position.x + PWINDOW->m_size.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x); + const bool DISPLAYTOP = STICKS(PWINDOW->m_position.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y); + const bool DISPLAYBOTTOM = STICKS(PWINDOW->m_position.y + PWINDOW->m_size.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y); - if (PWINDOW->m_bIsPseudotiled) { + if (PWINDOW->m_isPseudotiled) { if (!m_PseudoDragFlags.started) { m_PseudoDragFlags.started = true; - const auto pseudoSize = PWINDOW->m_vRealSize->goal(); + const auto pseudoSize = PWINDOW->m_realSize->goal(); const auto mouseOffset = g_pInputManager->getMouseCoordsInternal() - (PNODE->box.pos() + ((PNODE->box.size() / 2) - (pseudoSize / 2))); if (mouseOffset.x > 0 && mouseOffset.x < pseudoSize.x && mouseOffset.y > 0 && mouseOffset.y < pseudoSize.y) { @@ -584,7 +584,7 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorn m_PseudoDragFlags.xExtent = mouseOffset.x > pseudoSize.x / 2; m_PseudoDragFlags.yExtent = mouseOffset.y > pseudoSize.y / 2; - PWINDOW->m_vPseudoSize = pseudoSize; + PWINDOW->m_pseudoSize = pseudoSize; } else { m_PseudoDragFlags.pseudo = false; } @@ -592,20 +592,20 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorn if (m_PseudoDragFlags.pseudo) { if (m_PseudoDragFlags.xExtent) - PWINDOW->m_vPseudoSize.x += pixResize.x * 2; + PWINDOW->m_pseudoSize.x += pixResize.x * 2; else - PWINDOW->m_vPseudoSize.x -= pixResize.x * 2; + PWINDOW->m_pseudoSize.x -= pixResize.x * 2; if (m_PseudoDragFlags.yExtent) - PWINDOW->m_vPseudoSize.y += pixResize.y * 2; + PWINDOW->m_pseudoSize.y += pixResize.y * 2; else - PWINDOW->m_vPseudoSize.y -= pixResize.y * 2; + PWINDOW->m_pseudoSize.y -= pixResize.y * 2; CBox wbox = PNODE->box; wbox.round(); - PWINDOW->m_vPseudoSize = {std::clamp(PWINDOW->m_vPseudoSize.x, 30.0, wbox.w), std::clamp(PWINDOW->m_vPseudoSize.y, 30.0, wbox.h)}; + PWINDOW->m_pseudoSize = {std::clamp(PWINDOW->m_pseudoSize.x, 30.0, wbox.w), std::clamp(PWINDOW->m_pseudoSize.y, 30.0, wbox.h)}; - PWINDOW->m_vLastFloatingSize = PWINDOW->m_vPseudoSize; + PWINDOW->m_lastFloatingSize = PWINDOW->m_pseudoSize; PNODE->recalcSizePosRecursive(*PANIMATE == 0); return; @@ -739,15 +739,15 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorn } void CHyprDwindleLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFullscreenMode CURRENT_EFFECTIVE_MODE, const eFullscreenMode EFFECTIVE_MODE) { - const auto PMONITOR = pWindow->m_pMonitor.lock(); - const auto PWORKSPACE = pWindow->m_pWorkspace; + const auto PMONITOR = pWindow->m_monitor.lock(); + const auto PWORKSPACE = pWindow->m_workspace; // save position and size if floating - if (pWindow->m_bIsFloating && CURRENT_EFFECTIVE_MODE == FSMODE_NONE) { - pWindow->m_vLastFloatingSize = pWindow->m_vRealSize->goal(); - pWindow->m_vLastFloatingPosition = pWindow->m_vRealPosition->goal(); - pWindow->m_vPosition = pWindow->m_vRealPosition->goal(); - pWindow->m_vSize = pWindow->m_vRealSize->goal(); + if (pWindow->m_isFloating && CURRENT_EFFECTIVE_MODE == FSMODE_NONE) { + pWindow->m_lastFloatingSize = pWindow->m_realSize->goal(); + pWindow->m_lastFloatingPosition = pWindow->m_realPosition->goal(); + pWindow->m_position = pWindow->m_realPosition->goal(); + pWindow->m_size = pWindow->m_realSize->goal(); } if (EFFECTIVE_MODE == FSMODE_NONE) { @@ -757,8 +757,8 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFu applyNodeDataToWindow(PNODE); else { // get back its' dimensions from position and size - *pWindow->m_vRealPosition = pWindow->m_vLastFloatingPosition; - *pWindow->m_vRealSize = pWindow->m_vLastFloatingSize; + *pWindow->m_realPosition = pWindow->m_lastFloatingPosition; + *pWindow->m_realSize = pWindow->m_lastFloatingSize; pWindow->unsetWindowData(PRIORITY_LAYOUT); pWindow->updateWindowData(); @@ -766,8 +766,8 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFu } else { // apply new pos and size being monitors' box if (EFFECTIVE_MODE == FSMODE_FULLSCREEN) { - *pWindow->m_vRealPosition = PMONITOR->vecPosition; - *pWindow->m_vRealSize = PMONITOR->vecSize; + *pWindow->m_realPosition = PMONITOR->vecPosition; + *pWindow->m_realSize = PMONITOR->vecSize; } else { // This is a massive hack. // We make a fake "only" node and apply @@ -777,8 +777,8 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFu fakeNode.pWindow = pWindow; fakeNode.box = {PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft, PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight}; fakeNode.workspaceID = pWindow->workspaceID(); - pWindow->m_vPosition = fakeNode.box.pos(); - pWindow->m_vSize = fakeNode.box.size(); + pWindow->m_position = fakeNode.box.pos(); + pWindow->m_size = fakeNode.box.size(); fakeNode.ignoreFullscreenChecks = true; applyNodeDataToWindow(&fakeNode); @@ -816,12 +816,12 @@ void CHyprDwindleLayout::moveWindowTo(PHLWINDOW pWindow, const std::string& dir, const auto originalWorkspaceID = pWindow->workspaceID(); const Vector2D originalPos = pWindow->middle(); - if (!PNODE || !pWindow->m_pMonitor) + if (!PNODE || !pWindow->m_monitor) return; Vector2D focalPoint; - const auto WINDOWIDEALBB = pWindow->isFullscreen() ? CBox{pWindow->m_pMonitor->vecPosition, pWindow->m_pMonitor->vecSize} : pWindow->getWindowIdealBoundingBoxIgnoreReserved(); + const auto WINDOWIDEALBB = pWindow->isFullscreen() ? CBox{pWindow->m_monitor->vecPosition, pWindow->m_monitor->vecSize} : pWindow->getWindowIdealBoundingBoxIgnoreReserved(); switch (dir[0]) { case 't': @@ -841,17 +841,17 @@ void CHyprDwindleLayout::moveWindowTo(PHLWINDOW pWindow, const std::string& dir, const auto PMONITORFOCAL = g_pCompositor->getMonitorFromVector(focalPoint); - if (PMONITORFOCAL != pWindow->m_pMonitor) { + if (PMONITORFOCAL != pWindow->m_monitor) { pWindow->moveToWorkspace(PMONITORFOCAL->activeWorkspace); - pWindow->m_pMonitor = PMONITORFOCAL; + pWindow->m_monitor = PMONITORFOCAL; } pWindow->updateGroupOutputs(); - if (!pWindow->m_sGroupData.pNextWindow.expired()) { - PHLWINDOW next = pWindow->m_sGroupData.pNextWindow.lock(); + if (!pWindow->m_groupData.pNextWindow.expired()) { + PHLWINDOW next = pWindow->m_groupData.pNextWindow.lock(); while (next != pWindow) { next->updateToplevel(); - next = next->m_sGroupData.pNextWindow.lock(); + next = next->m_groupData.pNextWindow.lock(); } } @@ -876,8 +876,8 @@ void CHyprDwindleLayout::switchWindows(PHLWINDOW pWindow, PHLWINDOW pWindow2) { if (!PNODE2 || !PNODE) return; - const eFullscreenMode MODE1 = pWindow->m_sFullscreenState.internal; - const eFullscreenMode MODE2 = pWindow2->m_sFullscreenState.internal; + const eFullscreenMode MODE1 = pWindow->m_fullscreenState.internal; + const eFullscreenMode MODE2 = pWindow2->m_fullscreenState.internal; g_pCompositor->setWindowFullscreenInternal(pWindow, FSMODE_NONE); g_pCompositor->setWindowFullscreenInternal(pWindow2, FSMODE_NONE); @@ -890,8 +890,8 @@ void CHyprDwindleLayout::switchWindows(PHLWINDOW pWindow, PHLWINDOW pWindow2) { PNODE->pWindow = pWindow2; if (PNODE->workspaceID != PNODE2->workspaceID) { - std::swap(pWindow2->m_pMonitor, pWindow->m_pMonitor); - std::swap(pWindow2->m_pWorkspace, pWindow->m_pWorkspace); + std::swap(pWindow2->m_monitor, pWindow->m_monitor); + std::swap(pWindow2->m_workspace, pWindow->m_workspace); } pWindow->setAnimationsToMove(); @@ -904,15 +904,15 @@ void CHyprDwindleLayout::switchWindows(PHLWINDOW pWindow, PHLWINDOW pWindow2) { getMasterNodeOnWorkspace(PNODE2->workspaceID)->recalcSizePosRecursive(); if (ACTIVE1) { - ACTIVE1->box = PNODE->box; - ACTIVE1->pWindow->m_vPosition = ACTIVE1->box.pos(); - ACTIVE1->pWindow->m_vSize = ACTIVE1->box.size(); + ACTIVE1->box = PNODE->box; + ACTIVE1->pWindow->m_position = ACTIVE1->box.pos(); + ACTIVE1->pWindow->m_size = ACTIVE1->box.size(); } if (ACTIVE2) { - ACTIVE2->box = PNODE2->box; - ACTIVE2->pWindow->m_vPosition = ACTIVE2->box.pos(); - ACTIVE2->pWindow->m_vSize = ACTIVE2->box.size(); + ACTIVE2->box = PNODE2->box; + ACTIVE2->pWindow->m_position = ACTIVE2->box.pos(); + ACTIVE2->pWindow->m_size = ACTIVE2->box.size(); } g_pHyprRenderer->damageWindow(pWindow); @@ -1047,7 +1047,7 @@ void CHyprDwindleLayout::moveToRoot(PHLWINDOW pWindow, bool stable) { std::swap(pRoot->children[0], pRoot->children[1]); // if the workspace is visible, recalculate layout - if (pWindow->m_pWorkspace && pWindow->m_pWorkspace->isVisible()) + if (pWindow->m_workspace && pWindow->m_workspace->isVisible()) pRoot->recalcSizePosRecursive(); } @@ -1068,7 +1068,7 @@ std::string CHyprDwindleLayout::getLayoutName() { void CHyprDwindleLayout::onEnable() { for (auto const& w : g_pCompositor->m_windows) { - if (w->m_bIsFloating || !w->m_bIsMapped || w->isHidden()) + if (w->m_isFloating || !w->m_isMapped || w->isHidden()) continue; onWindowCreatedTiling(w); diff --git a/src/layout/IHyprLayout.cpp b/src/layout/IHyprLayout.cpp index cf036131..ac04157b 100644 --- a/src/layout/IHyprLayout.cpp +++ b/src/layout/IHyprLayout.cpp @@ -18,26 +18,26 @@ void IHyprLayout::onWindowCreated(PHLWINDOW pWindow, eDirection direction) { CBox desiredGeometry = g_pXWaylandManager->getGeometryForWindow(pWindow); const bool HASPERSISTENTSIZE = - std::any_of(pWindow->m_vMatchedRules.begin(), pWindow->m_vMatchedRules.end(), [](const auto& rule) { return rule->ruleType == CWindowRule::RULE_PERSISTENTSIZE; }); + std::any_of(pWindow->m_matchedRules.begin(), pWindow->m_matchedRules.end(), [](const auto& rule) { return rule->m_ruleType == CWindowRule::RULE_PERSISTENTSIZE; }); const auto STOREDSIZE = HASPERSISTENTSIZE ? g_pConfigManager->getStoredFloatingSize(pWindow) : std::nullopt; if (STOREDSIZE.has_value()) { - Debug::log(LOG, "using stored size {}x{} for new window {}::{}", STOREDSIZE->x, STOREDSIZE->y, pWindow->m_szClass, pWindow->m_szTitle); - pWindow->m_vLastFloatingSize = STOREDSIZE.value(); + Debug::log(LOG, "using stored size {}x{} for new window {}::{}", STOREDSIZE->x, STOREDSIZE->y, pWindow->m_class, pWindow->m_title); + pWindow->m_lastFloatingSize = STOREDSIZE.value(); } else if (desiredGeometry.width <= 5 || desiredGeometry.height <= 5) { - const auto PMONITOR = pWindow->m_pMonitor.lock(); - pWindow->m_vLastFloatingSize = PMONITOR->vecSize / 2.f; + const auto PMONITOR = pWindow->m_monitor.lock(); + pWindow->m_lastFloatingSize = PMONITOR->vecSize / 2.f; } else - pWindow->m_vLastFloatingSize = Vector2D(desiredGeometry.width, desiredGeometry.height); + pWindow->m_lastFloatingSize = Vector2D(desiredGeometry.width, desiredGeometry.height); - pWindow->m_vPseudoSize = pWindow->m_vLastFloatingSize; + pWindow->m_pseudoSize = pWindow->m_lastFloatingSize; bool autoGrouped = IHyprLayout::onWindowCreatedAutoGroup(pWindow); if (autoGrouped) return; - if (pWindow->m_bIsFloating) + if (pWindow->m_isFloating) onWindowCreatedFloating(pWindow); else onWindowCreatedTiling(pWindow, direction); @@ -50,24 +50,24 @@ void IHyprLayout::onWindowRemoved(PHLWINDOW pWindow) { if (pWindow->isFullscreen()) g_pCompositor->setWindowFullscreenInternal(pWindow, FSMODE_NONE); - if (!pWindow->m_sGroupData.pNextWindow.expired()) { - if (pWindow->m_sGroupData.pNextWindow.lock() == pWindow) - pWindow->m_sGroupData.pNextWindow.reset(); + if (!pWindow->m_groupData.pNextWindow.expired()) { + if (pWindow->m_groupData.pNextWindow.lock() == pWindow) + pWindow->m_groupData.pNextWindow.reset(); else { // find last window and update PHLWINDOW PWINDOWPREV = pWindow->getGroupPrevious(); const auto WINDOWISVISIBLE = pWindow->getGroupCurrent() == pWindow; if (WINDOWISVISIBLE) - PWINDOWPREV->setGroupCurrent(pWindow->m_sGroupData.head ? pWindow->m_sGroupData.pNextWindow.lock() : PWINDOWPREV); + PWINDOWPREV->setGroupCurrent(pWindow->m_groupData.head ? pWindow->m_groupData.pNextWindow.lock() : PWINDOWPREV); - PWINDOWPREV->m_sGroupData.pNextWindow = pWindow->m_sGroupData.pNextWindow; + PWINDOWPREV->m_groupData.pNextWindow = pWindow->m_groupData.pNextWindow; - pWindow->m_sGroupData.pNextWindow.reset(); + pWindow->m_groupData.pNextWindow.reset(); - if (pWindow->m_sGroupData.head) { - std::swap(PWINDOWPREV->m_sGroupData.pNextWindow->m_sGroupData.head, pWindow->m_sGroupData.head); - std::swap(PWINDOWPREV->m_sGroupData.pNextWindow->m_sGroupData.locked, pWindow->m_sGroupData.locked); + if (pWindow->m_groupData.head) { + std::swap(PWINDOWPREV->m_groupData.pNextWindow->m_groupData.head, pWindow->m_groupData.head); + std::swap(PWINDOWPREV->m_groupData.pNextWindow->m_groupData.locked, pWindow->m_groupData.locked); } if (pWindow == m_pLastTiledWindow) @@ -83,7 +83,7 @@ void IHyprLayout::onWindowRemoved(PHLWINDOW pWindow) { } } - if (pWindow->m_bIsFloating) { + if (pWindow->m_isFloating) { onWindowRemovedFloating(pWindow); } else { onWindowRemovedTiling(pWindow); @@ -100,9 +100,9 @@ void IHyprLayout::onWindowRemovedFloating(PHLWINDOW pWindow) { void IHyprLayout::onWindowCreatedFloating(PHLWINDOW pWindow) { CBox desiredGeometry = g_pXWaylandManager->getGeometryForWindow(pWindow); - const auto PMONITOR = pWindow->m_pMonitor.lock(); + const auto PMONITOR = pWindow->m_monitor.lock(); - if (pWindow->m_bIsX11) { + if (pWindow->m_isX11) { Vector2D xy = {desiredGeometry.x, desiredGeometry.y}; xy = g_pXWaylandManager->xwaylandToWaylandCoords(xy); desiredGeometry.x = xy.x; @@ -117,39 +117,39 @@ void IHyprLayout::onWindowCreatedFloating(PHLWINDOW pWindow) { } if (desiredGeometry.width <= 5 || desiredGeometry.height <= 5) { - const auto PWINDOWSURFACE = pWindow->m_pWLSurface->resource(); - *pWindow->m_vRealSize = PWINDOWSURFACE->current.size; + const auto PWINDOWSURFACE = pWindow->m_wlSurface->resource(); + *pWindow->m_realSize = PWINDOWSURFACE->current.size; - if ((desiredGeometry.width <= 1 || desiredGeometry.height <= 1) && pWindow->m_bIsX11 && + if ((desiredGeometry.width <= 1 || desiredGeometry.height <= 1) && pWindow->m_isX11 && pWindow->isX11OverrideRedirect()) { // XDG windows should be fine. TODO: check for weird atoms? pWindow->setHidden(true); return; } // reject any windows with size <= 5x5 - if (pWindow->m_vRealSize->goal().x <= 5 || pWindow->m_vRealSize->goal().y <= 5) - *pWindow->m_vRealSize = PMONITOR->vecSize / 2.f; + if (pWindow->m_realSize->goal().x <= 5 || pWindow->m_realSize->goal().y <= 5) + *pWindow->m_realSize = PMONITOR->vecSize / 2.f; - if (pWindow->m_bIsX11 && pWindow->isX11OverrideRedirect()) { + if (pWindow->m_isX11 && pWindow->isX11OverrideRedirect()) { - if (pWindow->m_pXWaylandSurface->geometry.x != 0 && pWindow->m_pXWaylandSurface->geometry.y != 0) - *pWindow->m_vRealPosition = g_pXWaylandManager->xwaylandToWaylandCoords(pWindow->m_pXWaylandSurface->geometry.pos()); + if (pWindow->m_xwaylandSurface->geometry.x != 0 && pWindow->m_xwaylandSurface->geometry.y != 0) + *pWindow->m_realPosition = g_pXWaylandManager->xwaylandToWaylandCoords(pWindow->m_xwaylandSurface->geometry.pos()); else - *pWindow->m_vRealPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_vRealSize->goal().x) / 2.f, - PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_vRealSize->goal().y) / 2.f); + *pWindow->m_realPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_realSize->goal().x) / 2.f, + PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_realSize->goal().y) / 2.f); } else { - *pWindow->m_vRealPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_vRealSize->goal().x) / 2.f, - PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_vRealSize->goal().y) / 2.f); + *pWindow->m_realPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_realSize->goal().x) / 2.f, + PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_realSize->goal().y) / 2.f); } } else { // we respect the size. - *pWindow->m_vRealSize = Vector2D(desiredGeometry.width, desiredGeometry.height); + *pWindow->m_realSize = Vector2D(desiredGeometry.width, desiredGeometry.height); // check if it's on the correct monitor! Vector2D middlePoint = Vector2D(desiredGeometry.x, desiredGeometry.y) + Vector2D(desiredGeometry.width, desiredGeometry.height) / 2.f; // check if it's visible on any monitor (only for XDG) - bool visible = pWindow->m_bIsX11; + bool visible = pWindow->m_isX11; if (!visible) { visible = g_pCompositor->isPointOnAnyMonitor(Vector2D(desiredGeometry.x, desiredGeometry.y)) && @@ -159,57 +159,57 @@ void IHyprLayout::onWindowCreatedFloating(PHLWINDOW pWindow) { } // TODO: detect a popup in a more consistent way. - if ((desiredGeometry.x == 0 && desiredGeometry.y == 0) || !visible || !pWindow->m_bIsX11) { + if ((desiredGeometry.x == 0 && desiredGeometry.y == 0) || !visible || !pWindow->m_isX11) { // if the pos isn't set, fall back to the center placement if it's not a child, otherwise middle of parent if available - if (!pWindow->m_bIsX11 && pWindow->m_pXDGSurface->toplevel->parent && validMapped(pWindow->m_pXDGSurface->toplevel->parent->window)) - *pWindow->m_vRealPosition = pWindow->m_pXDGSurface->toplevel->parent->window->m_vRealPosition->goal() + - pWindow->m_pXDGSurface->toplevel->parent->window->m_vRealSize->goal() / 2.F - desiredGeometry.size() / 2.F; + if (!pWindow->m_isX11 && pWindow->m_xdgSurface->toplevel->parent && validMapped(pWindow->m_xdgSurface->toplevel->parent->window)) + *pWindow->m_realPosition = pWindow->m_xdgSurface->toplevel->parent->window->m_realPosition->goal() + + pWindow->m_xdgSurface->toplevel->parent->window->m_realSize->goal() / 2.F - desiredGeometry.size() / 2.F; else - *pWindow->m_vRealPosition = PMONITOR->vecPosition + PMONITOR->vecSize / 2.F - desiredGeometry.size() / 2.F; + *pWindow->m_realPosition = PMONITOR->vecPosition + PMONITOR->vecSize / 2.F - desiredGeometry.size() / 2.F; } else { // if it is, we respect where it wants to put itself, but apply monitor offset if outside // most of these are popups if (const auto POPENMON = g_pCompositor->getMonitorFromVector(middlePoint); POPENMON->ID != PMONITOR->ID) - *pWindow->m_vRealPosition = Vector2D(desiredGeometry.x, desiredGeometry.y) - POPENMON->vecPosition + PMONITOR->vecPosition; + *pWindow->m_realPosition = Vector2D(desiredGeometry.x, desiredGeometry.y) - POPENMON->vecPosition + PMONITOR->vecPosition; else - *pWindow->m_vRealPosition = Vector2D(desiredGeometry.x, desiredGeometry.y); + *pWindow->m_realPosition = Vector2D(desiredGeometry.x, desiredGeometry.y); } } - if (*PXWLFORCESCALEZERO && pWindow->m_bIsX11) - *pWindow->m_vRealSize = pWindow->m_vRealSize->goal() / PMONITOR->scale; + if (*PXWLFORCESCALEZERO && pWindow->m_isX11) + *pWindow->m_realSize = pWindow->m_realSize->goal() / PMONITOR->scale; - if (pWindow->m_bX11DoesntWantBorders || (pWindow->m_bIsX11 && pWindow->isX11OverrideRedirect())) { - pWindow->m_vRealPosition->warp(); - pWindow->m_vRealSize->warp(); + if (pWindow->m_X11DoesntWantBorders || (pWindow->m_isX11 && pWindow->isX11OverrideRedirect())) { + pWindow->m_realPosition->warp(); + pWindow->m_realSize->warp(); } if (!pWindow->isX11OverrideRedirect()) g_pCompositor->changeWindowZOrder(pWindow, true); else { - pWindow->m_vPendingReportedSize = pWindow->m_vRealSize->goal(); - pWindow->m_vReportedSize = pWindow->m_vPendingReportedSize; + pWindow->m_pendingReportedSize = pWindow->m_realSize->goal(); + pWindow->m_reportedSize = pWindow->m_pendingReportedSize; } } bool IHyprLayout::onWindowCreatedAutoGroup(PHLWINDOW pWindow) { static auto PAUTOGROUP = CConfigValue("group:auto_group"); - const PHLWINDOW OPENINGON = g_pCompositor->m_lastWindow.lock() && g_pCompositor->m_lastWindow->m_pWorkspace == pWindow->m_pWorkspace ? + const PHLWINDOW OPENINGON = g_pCompositor->m_lastWindow.lock() && g_pCompositor->m_lastWindow->m_workspace == pWindow->m_workspace ? g_pCompositor->m_lastWindow.lock() : - (pWindow->m_pWorkspace ? pWindow->m_pWorkspace->getFirstWindow() : nullptr); - const bool FLOATEDINTOTILED = pWindow->m_bIsFloating && !OPENINGON->m_bIsFloating; - const bool SWALLOWING = pWindow->m_pSwallowed || pWindow->m_bGroupSwallowed; + (pWindow->m_workspace ? pWindow->m_workspace->getFirstWindow() : nullptr); + const bool FLOATEDINTOTILED = pWindow->m_isFloating && !OPENINGON->m_isFloating; + const bool SWALLOWING = pWindow->m_swallowed || pWindow->m_groupSwallowed; if ((*PAUTOGROUP || SWALLOWING) // continue if auto_group is enabled or if dealing with window swallowing. && OPENINGON // this shouldn't be 0, but honestly, better safe than sorry. && OPENINGON != pWindow // prevent freeze when the "group set" window rule makes the new window to be already a group. - && OPENINGON->m_sGroupData.pNextWindow.lock() // check if OPENINGON is a group. + && OPENINGON->m_groupData.pNextWindow.lock() // check if OPENINGON is a group. && pWindow->canBeGroupedInto(OPENINGON) // check if the new window can be grouped into OPENINGON. && !g_pXWaylandManager->shouldBeFloated(pWindow) // don't group child windows. Fix for floated groups. Tiled groups don't need this because we check if !FLOATEDINTOTILED. && !FLOATEDINTOTILED) { // don't group a new floated window into a tiled group (for convenience). - pWindow->m_bIsFloating = OPENINGON->m_bIsFloating; // match the floating state. Needed to autogroup a new tiled window into a floated group. + pWindow->m_isFloating = OPENINGON->m_isFloating; // match the floating state. Needed to autogroup a new tiled window into a floated group. static auto USECURRPOS = CConfigValue("group:insert_after_current"); (*USECURRPOS ? OPENINGON : OPENINGON->getGroupTail())->insertWindowToGroup(pWindow); @@ -250,7 +250,7 @@ void IHyprLayout::onBeginDragWindow() { // get the grab corner static auto RESIZECORNER = CConfigValue("general:resize_corner"); - if (*RESIZECORNER != 0 && *RESIZECORNER <= 4 && DRAGGINGWINDOW->m_bIsFloating) { + if (*RESIZECORNER != 0 && *RESIZECORNER <= 4 && DRAGGINGWINDOW->m_isFloating) { switch (*RESIZECORNER) { case 1: m_eGrabbedCorner = CORNER_TOPLEFT; @@ -324,24 +324,24 @@ void IHyprLayout::onEndDragWindow() { if (pWindow->checkInputOnDecos(INPUT_TYPE_DRAG_END, MOUSECOORDS, DRAGGINGWINDOW)) return; - const bool FLOATEDINTOTILED = !pWindow->m_bIsFloating && !DRAGGINGWINDOW->m_bDraggingTiled; + const bool FLOATEDINTOTILED = !pWindow->m_isFloating && !DRAGGINGWINDOW->m_draggingTiled; static auto PDRAGINTOGROUP = CConfigValue("group:drag_into_group"); - if (pWindow->m_sGroupData.pNextWindow.lock() && DRAGGINGWINDOW->canBeGroupedInto(pWindow) && *PDRAGINTOGROUP == 1 && !FLOATEDINTOTILED) { + if (pWindow->m_groupData.pNextWindow.lock() && DRAGGINGWINDOW->canBeGroupedInto(pWindow) && *PDRAGINTOGROUP == 1 && !FLOATEDINTOTILED) { - if (DRAGGINGWINDOW->m_sGroupData.pNextWindow) { - PHLWINDOW next = DRAGGINGWINDOW->m_sGroupData.pNextWindow.lock(); + if (DRAGGINGWINDOW->m_groupData.pNextWindow) { + PHLWINDOW next = DRAGGINGWINDOW->m_groupData.pNextWindow.lock(); while (next != DRAGGINGWINDOW) { - next->m_bIsFloating = pWindow->m_bIsFloating; // match the floating state of group members - *next->m_vRealSize = pWindow->m_vRealSize->goal(); // match the size of group members - *next->m_vRealPosition = pWindow->m_vRealPosition->goal(); // match the position of group members - next = next->m_sGroupData.pNextWindow.lock(); + next->m_isFloating = pWindow->m_isFloating; // match the floating state of group members + *next->m_realSize = pWindow->m_realSize->goal(); // match the size of group members + *next->m_realPosition = pWindow->m_realPosition->goal(); // match the position of group members + next = next->m_groupData.pNextWindow.lock(); } } - DRAGGINGWINDOW->m_bIsFloating = pWindow->m_bIsFloating; // match the floating state of the window - DRAGGINGWINDOW->m_vLastFloatingSize = m_vDraggingWindowOriginalFloatSize; - DRAGGINGWINDOW->m_bDraggingTiled = false; + DRAGGINGWINDOW->m_isFloating = pWindow->m_isFloating; // match the floating state of the window + DRAGGINGWINDOW->m_lastFloatingSize = m_vDraggingWindowOriginalFloatSize; + DRAGGINGWINDOW->m_draggingTiled = false; static auto USECURRPOS = CConfigValue("group:insert_after_current"); (*USECURRPOS ? pWindow : pWindow->getGroupTail())->insertWindowToGroup(DRAGGINGWINDOW); @@ -355,11 +355,11 @@ void IHyprLayout::onEndDragWindow() { } } - if (DRAGGINGWINDOW->m_bDraggingTiled) { - DRAGGINGWINDOW->m_bIsFloating = false; + if (DRAGGINGWINDOW->m_draggingTiled) { + DRAGGINGWINDOW->m_isFloating = false; g_pInputManager->refocus(); changeWindowFloatingMode(DRAGGINGWINDOW); - DRAGGINGWINDOW->m_vLastFloatingSize = m_vDraggingWindowOriginalFloatSize; + DRAGGINGWINDOW->m_lastFloatingSize = m_vDraggingWindowOriginalFloatSize; } g_pHyprRenderer->damageWindow(DRAGGINGWINDOW); @@ -404,10 +404,10 @@ static void performSnap(Vector2D& sourcePos, Vector2D& sourceSize, PHLWINDOW DRA if (*SNAPWINDOWGAP) { const double GAPSIZE = *SNAPWINDOWGAP; const auto WSID = DRAGGINGWINDOW->workspaceID(); - const bool HASFULLSCREEN = DRAGGINGWINDOW->m_pWorkspace && DRAGGINGWINDOW->m_pWorkspace->m_hasFullscreenWindow; + const bool HASFULLSCREEN = DRAGGINGWINDOW->m_workspace && DRAGGINGWINDOW->m_workspace->m_hasFullscreenWindow; for (auto& other : g_pCompositor->m_windows) { - if ((HASFULLSCREEN && !other->m_bCreatedOverFullscreen) || other == DRAGGINGWINDOW || other->workspaceID() != WSID || !other->m_bIsMapped || other->m_bFadingOut || + if ((HASFULLSCREEN && !other->m_createdOverFullscreen) || other == DRAGGINGWINDOW || other->workspaceID() != WSID || !other->m_isMapped || other->m_fadingOut || other->isX11OverrideRedirect()) continue; @@ -466,7 +466,7 @@ static void performSnap(Vector2D& sourcePos, Vector2D& sourceSize, PHLWINDOW DRA if (*SNAPMONITORGAP) { const double GAPSIZE = *SNAPMONITORGAP; const double BORDERDIFF = OVERLAP ? DRAGGINGBORDERSIZE : 0; - const auto MON = DRAGGINGWINDOW->m_pMonitor.lock(); + const auto MON = DRAGGINGWINDOW->m_monitor.lock(); SRange monX = {MON->vecPosition.x + MON->vecReservedTopLeft.x + DRAGGINGBORDERSIZE, MON->vecPosition.x + MON->vecSize.x - MON->vecReservedBottomRight.x - DRAGGINGBORDERSIZE}; @@ -584,30 +584,30 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) { if (g_pInputManager->dragMode == MBIND_MOVE) { Vector2D newPos = m_vBeginDragPositionXY + DELTA; - Vector2D newSize = DRAGGINGWINDOW->m_vRealSize->goal(); + Vector2D newSize = DRAGGINGWINDOW->m_realSize->goal(); - if (*SNAPENABLED && !DRAGGINGWINDOW->m_bDraggingTiled) + if (*SNAPENABLED && !DRAGGINGWINDOW->m_draggingTiled) performSnap(newPos, newSize, DRAGGINGWINDOW, MBIND_MOVE, -1, m_vBeginDragSizeXY); CBox wb = {newPos, newSize}; wb.round(); if (*PANIMATEMOUSE) - *DRAGGINGWINDOW->m_vRealPosition = wb.pos(); + *DRAGGINGWINDOW->m_realPosition = wb.pos(); else { - DRAGGINGWINDOW->m_vRealPosition->setValueAndWarp(wb.pos()); + DRAGGINGWINDOW->m_realPosition->setValueAndWarp(wb.pos()); DRAGGINGWINDOW->sendWindowSize(); } - DRAGGINGWINDOW->m_vPosition = wb.pos(); + DRAGGINGWINDOW->m_position = wb.pos(); } else if (g_pInputManager->dragMode == MBIND_RESIZE || g_pInputManager->dragMode == MBIND_RESIZE_FORCE_RATIO || g_pInputManager->dragMode == MBIND_RESIZE_BLOCK_RATIO) { - if (DRAGGINGWINDOW->m_bIsFloating) { + if (DRAGGINGWINDOW->m_isFloating) { - Vector2D MINSIZE = DRAGGINGWINDOW->requestedMinSize().clamp(DRAGGINGWINDOW->m_sWindowData.minSize.valueOr(Vector2D(MIN_WINDOW_SIZE, MIN_WINDOW_SIZE))); + Vector2D MINSIZE = DRAGGINGWINDOW->requestedMinSize().clamp(DRAGGINGWINDOW->m_windowData.minSize.valueOr(Vector2D(MIN_WINDOW_SIZE, MIN_WINDOW_SIZE))); Vector2D MAXSIZE; - if (DRAGGINGWINDOW->m_sWindowData.maxSize.hasValue()) - MAXSIZE = DRAGGINGWINDOW->requestedMaxSize().clamp({}, DRAGGINGWINDOW->m_sWindowData.maxSize.value()); + if (DRAGGINGWINDOW->m_windowData.maxSize.hasValue()) + MAXSIZE = DRAGGINGWINDOW->requestedMaxSize().clamp({}, DRAGGINGWINDOW->m_windowData.maxSize.value()); else MAXSIZE = DRAGGINGWINDOW->requestedMaxSize().clamp({}, Vector2D(std::numeric_limits::max(), std::numeric_limits::max())); @@ -624,7 +624,7 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) { newSize = newSize + Vector2D(-DELTA.x, DELTA.y); eMouseBindMode mode = g_pInputManager->dragMode; - if (DRAGGINGWINDOW->m_sWindowData.keepAspectRatio.valueOrDefault() && mode != MBIND_RESIZE_BLOCK_RATIO) + if (DRAGGINGWINDOW->m_windowData.keepAspectRatio.valueOrDefault() && mode != MBIND_RESIZE_BLOCK_RATIO) mode = MBIND_RESIZE_FORCE_RATIO; if (m_vBeginDragSizeXY.x >= 1 && m_vBeginDragSizeXY.y >= 1 && mode == MBIND_RESIZE_FORCE_RATIO) { @@ -665,29 +665,29 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) { wb.round(); if (*PANIMATE) { - *DRAGGINGWINDOW->m_vRealSize = wb.size(); - *DRAGGINGWINDOW->m_vRealPosition = wb.pos(); + *DRAGGINGWINDOW->m_realSize = wb.size(); + *DRAGGINGWINDOW->m_realPosition = wb.pos(); } else { - DRAGGINGWINDOW->m_vRealSize->setValueAndWarp(wb.size()); - DRAGGINGWINDOW->m_vRealPosition->setValueAndWarp(wb.pos()); + DRAGGINGWINDOW->m_realSize->setValueAndWarp(wb.size()); + DRAGGINGWINDOW->m_realPosition->setValueAndWarp(wb.pos()); DRAGGINGWINDOW->sendWindowSize(); } - DRAGGINGWINDOW->m_vPosition = wb.pos(); - DRAGGINGWINDOW->m_vSize = wb.size(); + DRAGGINGWINDOW->m_position = wb.pos(); + DRAGGINGWINDOW->m_size = wb.size(); } else { resizeActiveWindow(TICKDELTA, m_eGrabbedCorner, DRAGGINGWINDOW); } } // get middle point - Vector2D middle = DRAGGINGWINDOW->m_vRealPosition->value() + DRAGGINGWINDOW->m_vRealSize->value() / 2.f; + Vector2D middle = DRAGGINGWINDOW->m_realPosition->value() + DRAGGINGWINDOW->m_realSize->value() / 2.f; // and check its monitor const auto PMONITOR = g_pCompositor->getMonitorFromVector(middle); if (PMONITOR && !SPECIAL) { - DRAGGINGWINDOW->m_pMonitor = PMONITOR; + DRAGGINGWINDOW->m_monitor = PMONITOR; DRAGGINGWINDOW->moveToWorkspace(PMONITOR->activeWorkspace); DRAGGINGWINDOW->updateGroupOutputs(); @@ -706,7 +706,7 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) { g_pCompositor->setWindowFullscreenInternal(pWindow, FSMODE_NONE); } - pWindow->m_bPinned = false; + pWindow->m_pinned = false; g_pHyprRenderer->damageWindow(pWindow, true); @@ -717,8 +717,8 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) { EMIT_HOOK_EVENT("changeFloatingMode", pWindow); if (!TILED) { - const auto PNEWMON = g_pCompositor->getMonitorFromVector(pWindow->m_vRealPosition->value() + pWindow->m_vRealSize->value() / 2.f); - pWindow->m_pMonitor = PNEWMON; + const auto PNEWMON = g_pCompositor->getMonitorFromVector(pWindow->m_realPosition->value() + pWindow->m_realSize->value() / 2.f); + pWindow->m_monitor = PNEWMON; pWindow->moveToWorkspace(PNEWMON->activeSpecialWorkspace ? PNEWMON->activeSpecialWorkspace : PNEWMON->activeWorkspace); pWindow->updateGroupOutputs(); @@ -728,25 +728,25 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) { g_pCompositor->setWindowFullscreenInternal(PWORKSPACE->getFullscreenWindow(), FSMODE_NONE); // save real pos cuz the func applies the default 5,5 mid - const auto PSAVEDPOS = pWindow->m_vRealPosition->goal(); - const auto PSAVEDSIZE = pWindow->m_vRealSize->goal(); + const auto PSAVEDPOS = pWindow->m_realPosition->goal(); + const auto PSAVEDSIZE = pWindow->m_realSize->goal(); // if the window is pseudo, update its size - if (!pWindow->m_bDraggingTiled) - pWindow->m_vPseudoSize = pWindow->m_vRealSize->goal(); + if (!pWindow->m_draggingTiled) + pWindow->m_pseudoSize = pWindow->m_realSize->goal(); - pWindow->m_vLastFloatingSize = PSAVEDSIZE; + pWindow->m_lastFloatingSize = PSAVEDSIZE; // move to narnia because we don't wanna find our own node. onWindowCreatedTiling should apply the coords back. - pWindow->m_vPosition = Vector2D(-999999, -999999); + pWindow->m_position = Vector2D(-999999, -999999); onWindowCreatedTiling(pWindow); - pWindow->m_vRealPosition->setValue(PSAVEDPOS); - pWindow->m_vRealSize->setValue(PSAVEDSIZE); + pWindow->m_realPosition->setValue(PSAVEDPOS); + pWindow->m_realSize->setValue(PSAVEDSIZE); // fix pseudo leaving artifacts - g_pHyprRenderer->damageMonitor(pWindow->m_pMonitor.lock()); + g_pHyprRenderer->damageMonitor(pWindow->m_monitor.lock()); if (pWindow == g_pCompositor->m_lastWindow) m_pLastTiledWindow = pWindow; @@ -755,21 +755,21 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) { g_pCompositor->changeWindowZOrder(pWindow, true); - CBox wb = {pWindow->m_vRealPosition->goal() + (pWindow->m_vRealSize->goal() - pWindow->m_vLastFloatingSize) / 2.f, pWindow->m_vLastFloatingSize}; + CBox wb = {pWindow->m_realPosition->goal() + (pWindow->m_realSize->goal() - pWindow->m_lastFloatingSize) / 2.f, pWindow->m_lastFloatingSize}; wb.round(); - if (!(pWindow->m_bIsFloating && pWindow->m_bIsPseudotiled) && DELTALESSTHAN(pWindow->m_vRealSize->value().x, pWindow->m_vLastFloatingSize.x, 10) && - DELTALESSTHAN(pWindow->m_vRealSize->value().y, pWindow->m_vLastFloatingSize.y, 10)) { + if (!(pWindow->m_isFloating && pWindow->m_isPseudotiled) && DELTALESSTHAN(pWindow->m_realSize->value().x, pWindow->m_lastFloatingSize.x, 10) && + DELTALESSTHAN(pWindow->m_realSize->value().y, pWindow->m_lastFloatingSize.y, 10)) { wb = {wb.pos() + Vector2D{10, 10}, wb.size() - Vector2D{20, 20}}; } - *pWindow->m_vRealPosition = wb.pos(); - *pWindow->m_vRealSize = wb.size(); + *pWindow->m_realPosition = wb.pos(); + *pWindow->m_realSize = wb.size(); - pWindow->m_vSize = wb.size(); - pWindow->m_vPosition = wb.pos(); + pWindow->m_size = wb.size(); + pWindow->m_position = wb.pos(); - g_pHyprRenderer->damageMonitor(pWindow->m_pMonitor.lock()); + g_pHyprRenderer->damageMonitor(pWindow->m_monitor.lock()); pWindow->unsetWindowData(PRIORITY_LAYOUT); pWindow->updateWindowData(); @@ -789,21 +789,21 @@ void IHyprLayout::moveActiveWindow(const Vector2D& delta, PHLWINDOW pWindow) { if (!validMapped(PWINDOW)) return; - if (!PWINDOW->m_bIsFloating) { + if (!PWINDOW->m_isFloating) { Debug::log(LOG, "Dwindle cannot move a tiled window in moveActiveWindow!"); return; } PWINDOW->setAnimationsToMove(); - PWINDOW->m_vPosition += delta; - *PWINDOW->m_vRealPosition = PWINDOW->m_vRealPosition->goal() + delta; + PWINDOW->m_position += delta; + *PWINDOW->m_realPosition = PWINDOW->m_realPosition->goal() + delta; g_pHyprRenderer->damageWindow(PWINDOW); } void IHyprLayout::onWindowFocusChange(PHLWINDOW pNewFocus) { - m_pLastTiledWindow = pNewFocus && !pNewFocus->m_bIsFloating ? pNewFocus : m_pLastTiledWindow; + m_pLastTiledWindow = pNewFocus && !pNewFocus->m_isFloating ? pNewFocus : m_pLastTiledWindow; } PHLWINDOW IHyprLayout::getNextWindowCandidate(PHLWINDOW pWindow) { @@ -811,27 +811,26 @@ PHLWINDOW IHyprLayout::getNextWindowCandidate(PHLWINDOW pWindow) { if (!pWindow) return nullptr; - const auto PWORKSPACE = pWindow->m_pWorkspace; + const auto PWORKSPACE = pWindow->m_workspace; // first of all, if this is a fullscreen workspace, if (PWORKSPACE->m_hasFullscreenWindow) return PWORKSPACE->getFullscreenWindow(); - if (pWindow->m_bIsFloating) { + if (pWindow->m_isFloating) { // find whether there is a floating window below this one for (auto const& w : g_pCompositor->m_windows) { - if (w->m_bIsMapped && !w->isHidden() && w->m_bIsFloating && !w->isX11OverrideRedirect() && w->m_pWorkspace == pWindow->m_pWorkspace && !w->m_bX11ShouldntFocus && - !w->m_sWindowData.noFocus.valueOrDefault() && w != pWindow) { - if (VECINRECT((pWindow->m_vSize / 2.f + pWindow->m_vPosition), w->m_vPosition.x, w->m_vPosition.y, w->m_vPosition.x + w->m_vSize.x, - w->m_vPosition.y + w->m_vSize.y)) { + if (w->m_isMapped && !w->isHidden() && w->m_isFloating && !w->isX11OverrideRedirect() && w->m_workspace == pWindow->m_workspace && !w->m_X11ShouldntFocus && + !w->m_windowData.noFocus.valueOrDefault() && w != pWindow) { + if (VECINRECT((pWindow->m_size / 2.f + pWindow->m_position), w->m_position.x, w->m_position.y, w->m_position.x + w->m_size.x, w->m_position.y + w->m_size.y)) { return w; } } } // let's try the last tiled window. - if (m_pLastTiledWindow.lock() && m_pLastTiledWindow->m_pWorkspace == pWindow->m_pWorkspace) + if (m_pLastTiledWindow.lock() && m_pLastTiledWindow->m_workspace == pWindow->m_workspace) return m_pLastTiledWindow.lock(); // if we don't, let's try to find any window that is in the middle @@ -841,8 +840,8 @@ PHLWINDOW IHyprLayout::getNextWindowCandidate(PHLWINDOW pWindow) { // if not, floating window for (auto const& w : g_pCompositor->m_windows) { - if (w->m_bIsMapped && !w->isHidden() && w->m_bIsFloating && !w->isX11OverrideRedirect() && w->m_pWorkspace == pWindow->m_pWorkspace && !w->m_bX11ShouldntFocus && - !w->m_sWindowData.noFocus.valueOrDefault() && w != pWindow) + if (w->m_isMapped && !w->isHidden() && w->m_isFloating && !w->isX11OverrideRedirect() && w->m_workspace == pWindow->m_workspace && !w->m_X11ShouldntFocus && + !w->m_windowData.noFocus.valueOrDefault() && w != pWindow) return w; } @@ -859,22 +858,22 @@ PHLWINDOW IHyprLayout::getNextWindowCandidate(PHLWINDOW pWindow) { if (!pWindowCandidate) pWindowCandidate = PWORKSPACE->getFirstWindow(); - if (!pWindowCandidate || pWindow == pWindowCandidate || !pWindowCandidate->m_bIsMapped || pWindowCandidate->isHidden() || pWindowCandidate->m_bX11ShouldntFocus || - pWindowCandidate->isX11OverrideRedirect() || pWindowCandidate->m_pMonitor != g_pCompositor->m_lastMonitor) + if (!pWindowCandidate || pWindow == pWindowCandidate || !pWindowCandidate->m_isMapped || pWindowCandidate->isHidden() || pWindowCandidate->m_X11ShouldntFocus || + pWindowCandidate->isX11OverrideRedirect() || pWindowCandidate->m_monitor != g_pCompositor->m_lastMonitor) return nullptr; return pWindowCandidate; } bool IHyprLayout::isWindowReachable(PHLWINDOW pWindow) { - return pWindow && (!pWindow->isHidden() || pWindow->m_sGroupData.pNextWindow); + return pWindow && (!pWindow->isHidden() || pWindow->m_groupData.pNextWindow); } void IHyprLayout::bringWindowToTop(PHLWINDOW pWindow) { if (pWindow == nullptr) return; - if (pWindow->isHidden() && pWindow->m_sGroupData.pNextWindow) { + if (pWindow->isHidden() && pWindow->m_groupData.pNextWindow) { // grouped, change the current to this window pWindow->setGroupCurrent(pWindow); } @@ -890,11 +889,11 @@ Vector2D IHyprLayout::predictSizeForNewWindowFloating(PHLWINDOW pWindow) { // ge Vector2D sizeOverride = {}; if (g_pCompositor->m_lastMonitor) { for (auto const& r : g_pConfigManager->getMatchingRules(pWindow, true, true)) { - if (r->ruleType != CWindowRule::RULE_SIZE) + if (r->m_ruleType != CWindowRule::RULE_SIZE) continue; try { - const auto VALUE = r->szRule.substr(r->szRule.find(' ') + 1); + const auto VALUE = r->m_rule.substr(r->m_rule.find(' ') + 1); const auto SIZEXSTR = VALUE.substr(0, VALUE.find(' ')); const auto SIZEYSTR = VALUE.substr(VALUE.find(' ') + 1); @@ -908,7 +907,7 @@ Vector2D IHyprLayout::predictSizeForNewWindowFloating(PHLWINDOW pWindow) { // ge sizeOverride = {SIZEX, SIZEY}; - } catch (...) { Debug::log(LOG, "Rule size failed, rule: {} -> {}", r->szRule, r->szValue); } + } catch (...) { Debug::log(LOG, "Rule size failed, rule: {} -> {}", r->m_rule, r->m_value); } break; } } @@ -921,7 +920,7 @@ Vector2D IHyprLayout::predictSizeForNewWindow(PHLWINDOW pWindow) { if (!shouldBeFloated) { for (auto const& r : g_pConfigManager->getMatchingRules(pWindow, true, true)) { - if (r->ruleType != CWindowRule::RULE_FLOAT) + if (r->m_ruleType != CWindowRule::RULE_FLOAT) continue; shouldBeFloated = true; @@ -936,7 +935,7 @@ Vector2D IHyprLayout::predictSizeForNewWindow(PHLWINDOW pWindow) { else sizePredicted = predictSizeForNewWindowFloating(pWindow); - Vector2D maxSize = pWindow->m_pXDGSurface->toplevel->pending.maxSize; + Vector2D maxSize = pWindow->m_xdgSurface->toplevel->pending.maxSize; if ((maxSize.x > 0 && maxSize.x < sizePredicted.x) || (maxSize.y > 0 && maxSize.y < sizePredicted.y)) sizePredicted = {}; @@ -954,35 +953,35 @@ bool IHyprLayout::updateDragWindow() { g_pCompositor->setWindowFullscreenInternal(DRAGGINGWINDOW, FSMODE_NONE); } - const auto PWORKSPACE = DRAGGINGWINDOW->m_pWorkspace; + const auto PWORKSPACE = DRAGGINGWINDOW->m_workspace; - if (PWORKSPACE->m_hasFullscreenWindow && (!DRAGGINGWINDOW->m_bCreatedOverFullscreen || !DRAGGINGWINDOW->m_bIsFloating)) { + if (PWORKSPACE->m_hasFullscreenWindow && (!DRAGGINGWINDOW->m_createdOverFullscreen || !DRAGGINGWINDOW->m_isFloating)) { Debug::log(LOG, "Rejecting drag on a fullscreen workspace. (window under fullscreen)"); g_pKeybindManager->changeMouseBindMode(MBIND_INVALID); return true; } } - DRAGGINGWINDOW->m_bDraggingTiled = false; - m_vDraggingWindowOriginalFloatSize = DRAGGINGWINDOW->m_vLastFloatingSize; + DRAGGINGWINDOW->m_draggingTiled = false; + m_vDraggingWindowOriginalFloatSize = DRAGGINGWINDOW->m_lastFloatingSize; - if (WAS_FULLSCREEN && DRAGGINGWINDOW->m_bIsFloating) { - const auto MOUSECOORDS = g_pInputManager->getMouseCoordsInternal(); - *DRAGGINGWINDOW->m_vRealPosition = MOUSECOORDS - DRAGGINGWINDOW->m_vRealSize->goal() / 2.f; - } else if (!DRAGGINGWINDOW->m_bIsFloating && g_pInputManager->dragMode == MBIND_MOVE) { - Vector2D MINSIZE = DRAGGINGWINDOW->requestedMinSize().clamp(DRAGGINGWINDOW->m_sWindowData.minSize.valueOr(Vector2D(MIN_WINDOW_SIZE, MIN_WINDOW_SIZE))); - DRAGGINGWINDOW->m_vLastFloatingSize = (DRAGGINGWINDOW->m_vRealSize->goal() * 0.8489).clamp(MINSIZE, Vector2D{}).floor(); - *DRAGGINGWINDOW->m_vRealPosition = g_pInputManager->getMouseCoordsInternal() - DRAGGINGWINDOW->m_vRealSize->goal() / 2.f; + if (WAS_FULLSCREEN && DRAGGINGWINDOW->m_isFloating) { + const auto MOUSECOORDS = g_pInputManager->getMouseCoordsInternal(); + *DRAGGINGWINDOW->m_realPosition = MOUSECOORDS - DRAGGINGWINDOW->m_realSize->goal() / 2.f; + } else if (!DRAGGINGWINDOW->m_isFloating && g_pInputManager->dragMode == MBIND_MOVE) { + Vector2D MINSIZE = DRAGGINGWINDOW->requestedMinSize().clamp(DRAGGINGWINDOW->m_windowData.minSize.valueOr(Vector2D(MIN_WINDOW_SIZE, MIN_WINDOW_SIZE))); + DRAGGINGWINDOW->m_lastFloatingSize = (DRAGGINGWINDOW->m_realSize->goal() * 0.8489).clamp(MINSIZE, Vector2D{}).floor(); + *DRAGGINGWINDOW->m_realPosition = g_pInputManager->getMouseCoordsInternal() - DRAGGINGWINDOW->m_realSize->goal() / 2.f; if (g_pInputManager->m_bDragThresholdReached) { changeWindowFloatingMode(DRAGGINGWINDOW); - DRAGGINGWINDOW->m_bIsFloating = true; - DRAGGINGWINDOW->m_bDraggingTiled = true; + DRAGGINGWINDOW->m_isFloating = true; + DRAGGINGWINDOW->m_draggingTiled = true; } } m_vBeginDragXY = g_pInputManager->getMouseCoordsInternal(); - m_vBeginDragPositionXY = DRAGGINGWINDOW->m_vRealPosition->goal(); - m_vBeginDragSizeXY = DRAGGINGWINDOW->m_vRealSize->goal(); + m_vBeginDragPositionXY = DRAGGINGWINDOW->m_realPosition->goal(); + m_vBeginDragSizeXY = DRAGGINGWINDOW->m_realSize->goal(); m_vLastDragXY = m_vBeginDragXY; return false; diff --git a/src/layout/MasterLayout.cpp b/src/layout/MasterLayout.cpp index 052a6ed9..6c7f6d1a 100644 --- a/src/layout/MasterLayout.cpp +++ b/src/layout/MasterLayout.cpp @@ -78,14 +78,14 @@ SMasterNodeData* CHyprMasterLayout::getMasterNodeOnWorkspace(const WORKSPACEID& } void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection direction) { - if (pWindow->m_bIsFloating) + if (pWindow->m_isFloating) return; static auto PNEWONACTIVE = CConfigValue("master:new_on_active"); static auto PNEWONTOP = CConfigValue("master:new_on_top"); static auto PNEWSTATUS = CConfigValue("master:new_status"); - const auto PMONITOR = pWindow->m_pMonitor.lock(); + const auto PMONITOR = pWindow->m_monitor.lock(); const bool BNEWBEFOREACTIVE = *PNEWONACTIVE == "before"; const bool BNEWISMASTER = *PNEWSTATUS == "master"; @@ -110,13 +110,13 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire static auto PMFACT = CConfigValue("master:mfact"); float lastSplitPercent = *PMFACT; - auto OPENINGON = isWindowTiled(g_pCompositor->m_lastWindow.lock()) && g_pCompositor->m_lastWindow->m_pWorkspace == pWindow->m_pWorkspace ? + auto OPENINGON = isWindowTiled(g_pCompositor->m_lastWindow.lock()) && g_pCompositor->m_lastWindow->m_workspace == pWindow->m_workspace ? getNodeFromWindow(g_pCompositor->m_lastWindow.lock()) : getMasterNodeOnWorkspace(pWindow->workspaceID()); const auto MOUSECOORDS = g_pInputManager->getMouseCoordsInternal(); static auto PDROPATCURSOR = CConfigValue("master:drop_at_cursor"); - eOrientation orientation = getDynamicOrientation(pWindow->m_pWorkspace); + eOrientation orientation = getDynamicOrientation(pWindow->m_workspace); const auto NODEIT = std::find(m_lMasterNodesData.begin(), m_lMasterNodesData.end(), *PNODE); bool forceDropAsMaster = false; @@ -177,10 +177,10 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire } } - if ((BNEWISMASTER && g_pInputManager->dragMode != MBIND_MOVE) // - || WINDOWSONWORKSPACE == 1 // - || (WINDOWSONWORKSPACE > 2 && !pWindow->m_bFirstMap && OPENINGON->isMaster) // - || forceDropAsMaster // + if ((BNEWISMASTER && g_pInputManager->dragMode != MBIND_MOVE) // + || WINDOWSONWORKSPACE == 1 // + || (WINDOWSONWORKSPACE > 2 && !pWindow->m_firstMap && OPENINGON->isMaster) // + || forceDropAsMaster // || (*PNEWSTATUS == "inherit" && OPENINGON && OPENINGON->isMaster && g_pInputManager->dragMode != MBIND_MOVE)) { if (BNEWBEFOREACTIVE) { @@ -207,7 +207,7 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire // first, check if it isn't too big. if (const auto MAXSIZE = pWindow->requestedMaxSize(); MAXSIZE.x < PMONITOR->vecSize.x * lastSplitPercent || MAXSIZE.y < PMONITOR->vecSize.y) { // we can't continue. make it floating. - pWindow->m_bIsFloating = true; + pWindow->m_isFloating = true; m_lMasterNodesData.remove(*PNODE); g_pLayoutManager->getCurrentLayout()->onWindowCreatedFloating(pWindow); return; @@ -220,7 +220,7 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire if (const auto MAXSIZE = pWindow->requestedMaxSize(); MAXSIZE.x < PMONITOR->vecSize.x * (1 - lastSplitPercent) || MAXSIZE.y < PMONITOR->vecSize.y * (1.f / (WINDOWSONWORKSPACE - 1))) { // we can't continue. make it floating. - pWindow->m_bIsFloating = true; + pWindow->m_isFloating = true; m_lMasterNodesData.remove(*PNODE); g_pLayoutManager->getCurrentLayout()->onWindowCreatedFloating(pWindow); return; @@ -306,16 +306,16 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) { const auto PFULLWINDOW = pWorkspace->getFullscreenWindow(); if (pWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) { - *PFULLWINDOW->m_vRealPosition = PMONITOR->vecPosition; - *PFULLWINDOW->m_vRealSize = PMONITOR->vecSize; + *PFULLWINDOW->m_realPosition = PMONITOR->vecPosition; + *PFULLWINDOW->m_realSize = PMONITOR->vecSize; } else if (pWorkspace->m_fullscreenMode == FSMODE_MAXIMIZED) { SMasterNodeData fakeNode; fakeNode.pWindow = PFULLWINDOW; fakeNode.position = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft; fakeNode.size = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight; fakeNode.workspaceID = pWorkspace->m_id; - PFULLWINDOW->m_vPosition = fakeNode.position; - PFULLWINDOW->m_vSize = fakeNode.size; + PFULLWINDOW->m_position = fakeNode.position; + PFULLWINDOW->m_size = fakeNode.size; fakeNode.ignoreFullscreenChecks = true; applyNodeDataToWindow(&fakeNode); @@ -644,7 +644,7 @@ void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) { const auto PWINDOW = pNode->pWindow.lock(); // get specific gaps and rules for this workspace, // if user specified them in config - const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(PWINDOW->m_pWorkspace); + const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(PWINDOW->m_workspace); if (PWINDOW->isFullscreen() && !pNode->ignoreFullscreenChecks) return; @@ -666,13 +666,13 @@ void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) { return; } - PWINDOW->m_vSize = pNode->size; - PWINDOW->m_vPosition = pNode->position; + PWINDOW->m_size = pNode->size; + PWINDOW->m_position = pNode->position; PWINDOW->updateWindowDecos(); - auto calcPos = PWINDOW->m_vPosition; - auto calcSize = PWINDOW->m_vSize; + auto calcPos = PWINDOW->m_position; + auto calcSize = PWINDOW->m_size; const auto OFFSETTOPLEFT = Vector2D((double)(DISPLAYLEFT ? gapsOut.m_left : gapsIn.m_left), (double)(DISPLAYTOP ? gapsOut.m_top : gapsIn.m_top)); @@ -691,21 +691,21 @@ void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) { CBox wb = {calcPos + (calcSize - calcSize * *PSCALEFACTOR) / 2.f, calcSize * *PSCALEFACTOR}; wb.round(); // avoid rounding mess - *PWINDOW->m_vRealPosition = wb.pos(); - *PWINDOW->m_vRealSize = wb.size(); + *PWINDOW->m_realPosition = wb.pos(); + *PWINDOW->m_realSize = wb.size(); } else { CBox wb = {calcPos, calcSize}; wb.round(); // avoid rounding mess - *PWINDOW->m_vRealPosition = wb.pos(); - *PWINDOW->m_vRealSize = wb.size(); + *PWINDOW->m_realPosition = wb.pos(); + *PWINDOW->m_realSize = wb.size(); } if (m_bForceWarps && !*PANIMATE) { g_pHyprRenderer->damageWindow(PWINDOW); - PWINDOW->m_vRealPosition->warp(); - PWINDOW->m_vRealSize->warp(); + PWINDOW->m_realPosition->warp(); + PWINDOW->m_realSize->warp(); g_pHyprRenderer->damageWindow(PWINDOW); } @@ -726,21 +726,21 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne const auto PNODE = getNodeFromWindow(PWINDOW); if (!PNODE) { - *PWINDOW->m_vRealSize = - (PWINDOW->m_vRealSize->goal() + pixResize) - .clamp(PWINDOW->m_sWindowData.minSize.valueOr(Vector2D{MIN_WINDOW_SIZE, MIN_WINDOW_SIZE}), PWINDOW->m_sWindowData.maxSize.valueOr(Vector2D{INFINITY, INFINITY})); + *PWINDOW->m_realSize = + (PWINDOW->m_realSize->goal() + pixResize) + .clamp(PWINDOW->m_windowData.minSize.valueOr(Vector2D{MIN_WINDOW_SIZE, MIN_WINDOW_SIZE}), PWINDOW->m_windowData.maxSize.valueOr(Vector2D{INFINITY, INFINITY})); PWINDOW->updateWindowDecos(); return; } - const auto PMONITOR = PWINDOW->m_pMonitor.lock(); + const auto PMONITOR = PWINDOW->m_monitor.lock(); static auto SLAVECOUNTFORCENTER = CConfigValue("master:slave_count_for_center_master"); static auto PSMARTRESIZING = CConfigValue("master:smart_resizing"); - const bool DISPLAYBOTTOM = STICKS(PWINDOW->m_vPosition.y + PWINDOW->m_vSize.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y); - const bool DISPLAYRIGHT = STICKS(PWINDOW->m_vPosition.x + PWINDOW->m_vSize.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x); - const bool DISPLAYTOP = STICKS(PWINDOW->m_vPosition.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y); - const bool DISPLAYLEFT = STICKS(PWINDOW->m_vPosition.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x); + const bool DISPLAYBOTTOM = STICKS(PWINDOW->m_position.y + PWINDOW->m_size.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y); + const bool DISPLAYRIGHT = STICKS(PWINDOW->m_position.x + PWINDOW->m_size.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x); + const bool DISPLAYTOP = STICKS(PWINDOW->m_position.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y); + const bool DISPLAYLEFT = STICKS(PWINDOW->m_position.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x); const bool LEFT = corner == CORNER_TOPLEFT || corner == CORNER_BOTTOMLEFT; const bool TOP = corner == CORNER_TOPLEFT || corner == CORNER_TOPRIGHT; @@ -750,7 +750,7 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne const auto WINDOWS = getNodesOnWorkspace(PNODE->workspaceID); const auto STACKWINDOWS = WINDOWS - MASTERS; - eOrientation orientation = getDynamicOrientation(PWINDOW->m_pWorkspace); + eOrientation orientation = getDynamicOrientation(PWINDOW->m_workspace); bool centered = orientation == ORIENTATION_CENTER && (STACKWINDOWS >= *SLAVECOUNTFORCENTER); double delta = 0; @@ -862,15 +862,15 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne } void CHyprMasterLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFullscreenMode CURRENT_EFFECTIVE_MODE, const eFullscreenMode EFFECTIVE_MODE) { - const auto PMONITOR = pWindow->m_pMonitor.lock(); - const auto PWORKSPACE = pWindow->m_pWorkspace; + const auto PMONITOR = pWindow->m_monitor.lock(); + const auto PWORKSPACE = pWindow->m_workspace; // save position and size if floating - if (pWindow->m_bIsFloating && CURRENT_EFFECTIVE_MODE == FSMODE_NONE) { - pWindow->m_vLastFloatingSize = pWindow->m_vRealSize->goal(); - pWindow->m_vLastFloatingPosition = pWindow->m_vRealPosition->goal(); - pWindow->m_vPosition = pWindow->m_vRealPosition->goal(); - pWindow->m_vSize = pWindow->m_vRealSize->goal(); + if (pWindow->m_isFloating && CURRENT_EFFECTIVE_MODE == FSMODE_NONE) { + pWindow->m_lastFloatingSize = pWindow->m_realSize->goal(); + pWindow->m_lastFloatingPosition = pWindow->m_realPosition->goal(); + pWindow->m_position = pWindow->m_realPosition->goal(); + pWindow->m_size = pWindow->m_realSize->goal(); } if (EFFECTIVE_MODE == FSMODE_NONE) { @@ -880,8 +880,8 @@ void CHyprMasterLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFul applyNodeDataToWindow(PNODE); else { // get back its' dimensions from position and size - *pWindow->m_vRealPosition = pWindow->m_vLastFloatingPosition; - *pWindow->m_vRealSize = pWindow->m_vLastFloatingSize; + *pWindow->m_realPosition = pWindow->m_lastFloatingPosition; + *pWindow->m_realSize = pWindow->m_lastFloatingSize; pWindow->unsetWindowData(PRIORITY_LAYOUT); pWindow->updateWindowData(); @@ -889,8 +889,8 @@ void CHyprMasterLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFul } else { // apply new pos and size being monitors' box if (EFFECTIVE_MODE == FSMODE_FULLSCREEN) { - *pWindow->m_vRealPosition = PMONITOR->vecPosition; - *pWindow->m_vRealSize = PMONITOR->vecSize; + *pWindow->m_realPosition = PMONITOR->vecPosition; + *pWindow->m_realSize = PMONITOR->vecSize; } else { // This is a massive hack. // We make a fake "only" node and apply @@ -901,8 +901,8 @@ void CHyprMasterLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFul fakeNode.position = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft; fakeNode.size = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight; fakeNode.workspaceID = pWindow->workspaceID(); - pWindow->m_vPosition = fakeNode.position; - pWindow->m_vSize = fakeNode.size; + pWindow->m_position = fakeNode.position; + pWindow->m_size = fakeNode.size; fakeNode.ignoreFullscreenChecks = true; applyNodeDataToWindow(&fakeNode); @@ -940,13 +940,13 @@ void CHyprMasterLayout::moveWindowTo(PHLWINDOW pWindow, const std::string& dir, pWindow->setAnimationsToMove(); - if (pWindow->m_pWorkspace != PWINDOW2->m_pWorkspace) { + if (pWindow->m_workspace != PWINDOW2->m_workspace) { // if different monitors, send to monitor onWindowRemovedTiling(pWindow); - pWindow->moveToWorkspace(PWINDOW2->m_pWorkspace); - pWindow->m_pMonitor = PWINDOW2->m_pMonitor; + pWindow->moveToWorkspace(PWINDOW2->m_workspace); + pWindow->m_monitor = PWINDOW2->m_monitor; if (!silent) { - const auto pMonitor = pWindow->m_pMonitor.lock(); + const auto pMonitor = pWindow->m_monitor.lock(); g_pCompositor->setActiveMonitor(pMonitor); } onWindowCreatedTiling(pWindow); @@ -958,11 +958,11 @@ void CHyprMasterLayout::moveWindowTo(PHLWINDOW pWindow, const std::string& dir, } pWindow->updateGroupOutputs(); - if (!pWindow->m_sGroupData.pNextWindow.expired()) { - PHLWINDOW next = pWindow->m_sGroupData.pNextWindow.lock(); + if (!pWindow->m_groupData.pNextWindow.expired()) { + PHLWINDOW next = pWindow->m_groupData.pNextWindow.lock(); while (next != pWindow) { next->updateToplevel(); - next = next->m_sGroupData.pNextWindow.lock(); + next = next->m_groupData.pNextWindow.lock(); } } } @@ -977,8 +977,8 @@ void CHyprMasterLayout::switchWindows(PHLWINDOW pWindow, PHLWINDOW pWindow2) { return; if (PNODE->workspaceID != PNODE2->workspaceID) { - std::swap(pWindow2->m_pMonitor, pWindow->m_pMonitor); - std::swap(pWindow2->m_pWorkspace, pWindow->m_pWorkspace); + std::swap(pWindow2->m_monitor, pWindow->m_monitor); + std::swap(pWindow2->m_workspace, pWindow->m_workspace); } // massive hack: just swap window pointers, lol @@ -1047,8 +1047,8 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri return; if (header.pWindow->isFullscreen()) { - const auto PWORKSPACE = header.pWindow->m_pWorkspace; - const auto FSMODE = header.pWindow->m_sFullscreenState.internal; + const auto PWORKSPACE = header.pWindow->m_workspace; + const auto FSMODE = header.pWindow->m_fullscreenState.internal; static auto INHERITFULLSCREEN = CConfigValue("master:inherit_fullscreen"); g_pCompositor->setWindowFullscreenInternal(header.pWindow, FSMODE_NONE); g_pCompositor->focusWindow(PWINDOWTOCHANGETO); @@ -1167,7 +1167,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri if (!validMapped(header.pWindow)) return 0; - if (header.pWindow->m_bIsFloating) { + if (header.pWindow->m_isFloating) { g_pKeybindManager->m_mDispatchers["swapnext"](""); return 0; } @@ -1184,7 +1184,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri if (!validMapped(header.pWindow)) return 0; - if (header.pWindow->m_bIsFloating) { + if (header.pWindow->m_isFloating) { g_pKeybindManager->m_mDispatchers["swapnext"]("prev"); return 0; } @@ -1201,7 +1201,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri if (!validMapped(header.pWindow)) return 0; - if (header.pWindow->m_bIsFloating) + if (header.pWindow->m_isFloating) return 0; const auto PNODE = getNodeFromWindow(header.pWindow); @@ -1234,7 +1234,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri if (!validMapped(header.pWindow)) return 0; - if (header.pWindow->m_bIsFloating) + if (header.pWindow->m_isFloating) return 0; const auto PNODE = getNodeFromWindow(header.pWindow); @@ -1469,7 +1469,7 @@ Vector2D CHyprMasterLayout::predictSizeForNewWindowTiled() { void CHyprMasterLayout::onEnable() { for (auto const& w : g_pCompositor->m_windows) { - if (w->m_bIsFloating || !w->m_bIsMapped || w->isHidden()) + if (w->m_isFloating || !w->m_isMapped || w->isHidden()) continue; onWindowCreatedTiling(w); -- cgit v1.2.3