twin/hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/Hyprland.git synced 2025-05-19 08:30:22 -07:00
Code Issues Packages Projects Releases Wiki Activity

layouts: refactor class member vars (#10228)

Browse Source
This commit is contained in:
davc0n 2025-05-01 13:27:07 +02:00 committed by GitHub
parent ce4766772d
commit 615e0dae46
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
6 changed files with 168 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
src/layout/DwindleLayout.cpp
View File

@ -45,7 +45,7 @@ void SDwindleNodeData::recalcSizePosRecursive(bool force, bool horizontalOverrid
int CHyprDwindleLayout::getNodesOnWorkspace(const WORKSPACEID& id) { int CHyprDwindleLayout::getNodesOnWorkspace(const WORKSPACEID& id) {
int no = 0; int no = 0;
for (auto const& n : m_lDwindleNodesData) { for (auto const& n : m_dwindleNodesData) {
if (n.workspaceID == id && n.valid) if (n.workspaceID == id && n.valid)
++no; ++no;
} }
@ -53,7 +53,7 @@ int CHyprDwindleLayout::getNodesOnWorkspace(const WORKSPACEID& id) {
} }
SDwindleNodeData* CHyprDwindleLayout::getFirstNodeOnWorkspace(const WORKSPACEID& id) { SDwindleNodeData* CHyprDwindleLayout::getFirstNodeOnWorkspace(const WORKSPACEID& id) {
for (auto& n : m_lDwindleNodesData) { for (auto& n : m_dwindleNodesData) {
if (n.workspaceID == id && validMapped(n.pWindow)) if (n.workspaceID == id && validMapped(n.pWindow))
return &n; return &n;
} }
@ -63,7 +63,7 @@ SDwindleNodeData* CHyprDwindleLayout::getFirstNodeOnWorkspace(const WORKSPACEID&
SDwindleNodeData* CHyprDwindleLayout::getClosestNodeOnWorkspace(const WORKSPACEID& id, const Vector2D& point) { SDwindleNodeData* CHyprDwindleLayout::getClosestNodeOnWorkspace(const WORKSPACEID& id, const Vector2D& point) {
SDwindleNodeData* res = nullptr; SDwindleNodeData* res = nullptr;
double distClosest = -1; double distClosest = -1;
for (auto& n : m_lDwindleNodesData) { for (auto& n : m_dwindleNodesData) {
if (n.workspaceID == id && validMapped(n.pWindow)) { if (n.workspaceID == id && validMapped(n.pWindow)) {
auto distAnother = vecToRectDistanceSquared(point, n.box.pos(), n.box.pos() + n.box.size()); auto distAnother = vecToRectDistanceSquared(point, n.box.pos(), n.box.pos() + n.box.size());
if (!res || distAnother < distClosest) { if (!res || distAnother < distClosest) {
@ -76,7 +76,7 @@ SDwindleNodeData* CHyprDwindleLayout::getClosestNodeOnWorkspace(const WORKSPACEI
} }
SDwindleNodeData* CHyprDwindleLayout::getNodeFromWindow(PHLWINDOW pWindow) { SDwindleNodeData* CHyprDwindleLayout::getNodeFromWindow(PHLWINDOW pWindow) {
for (auto& n : m_lDwindleNodesData) { for (auto& n : m_dwindleNodesData) {
if (n.pWindow.lock() == pWindow && !n.isNode) if (n.pWindow.lock() == pWindow && !n.isNode)
return &n; return &n;
} }
@ -85,7 +85,7 @@ SDwindleNodeData* CHyprDwindleLayout::getNodeFromWindow(PHLWINDOW pWindow) {
} }
SDwindleNodeData* CHyprDwindleLayout::getMasterNodeOnWorkspace(const WORKSPACEID& id) { SDwindleNodeData* CHyprDwindleLayout::getMasterNodeOnWorkspace(const WORKSPACEID& id) {
for (auto& n : m_lDwindleNodesData) { for (auto& n : m_dwindleNodesData) {
if (!n.pParent && n.workspaceID == id) if (!n.pParent && n.workspaceID == id)
return &n; return &n;
} }
@ -223,16 +223,16 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
if (pWindow->m_isFloating) if (pWindow->m_isFloating)
return; return;
m_lDwindleNodesData.emplace_back(); m_dwindleNodesData.emplace_back();
const auto PNODE = &m_lDwindleNodesData.back(); const auto PNODE = &m_dwindleNodesData.back();
const auto PMONITOR = pWindow->m_monitor.lock(); const auto PMONITOR = pWindow->m_monitor.lock();
static auto PUSEACTIVE = CConfigValue<Hyprlang::INT>("dwindle:use_active_for_splits"); static auto PUSEACTIVE = CConfigValue<Hyprlang::INT>("dwindle:use_active_for_splits");
static auto PDEFAULTSPLIT = CConfigValue<Hyprlang::FLOAT>("dwindle:default_split_ratio"); static auto PDEFAULTSPLIT = CConfigValue<Hyprlang::FLOAT>("dwindle:default_split_ratio");
if (direction != DIRECTION_DEFAULT && overrideDirection == DIRECTION_DEFAULT) if (direction != DIRECTION_DEFAULT && m_overrideDirection == DIRECTION_DEFAULT)
overrideDirection = direction; m_overrideDirection = direction;
// Populate the node with our window's data // Populate the node with our window's data
PNODE->workspaceID = pWindow->workspaceID(); PNODE->workspaceID = pWindow->workspaceID();
@ -242,7 +242,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
SDwindleNodeData* OPENINGON; SDwindleNodeData* OPENINGON;
const auto MOUSECOORDS = m_vOverrideFocalPoint.value_or(g_pInputManager->getMouseCoordsInternal()); const auto MOUSECOORDS = m_overrideFocalPoint.value_or(g_pInputManager->getMouseCoordsInternal());
const auto MONFROMCURSOR = g_pCompositor->getMonitorFromVector(MOUSECOORDS); const auto MONFROMCURSOR = g_pCompositor->getMonitorFromVector(MOUSECOORDS);
if (PMONITOR->m_id == MONFROMCURSOR->m_id && if (PMONITOR->m_id == MONFROMCURSOR->m_id &&
@ -278,14 +278,14 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
if (const auto MAXSIZE = pWindow->requestedMaxSize(); MAXSIZE.x < PREDSIZEMAX.x || MAXSIZE.y < PREDSIZEMAX.y) { if (const auto MAXSIZE = pWindow->requestedMaxSize(); MAXSIZE.x < PREDSIZEMAX.x || MAXSIZE.y < PREDSIZEMAX.y) {
// we can't continue. make it floating. // we can't continue. make it floating.
pWindow->m_isFloating = true; pWindow->m_isFloating = true;
m_lDwindleNodesData.remove(*PNODE); m_dwindleNodesData.remove(*PNODE);
g_pLayoutManager->getCurrentLayout()->onWindowCreatedFloating(pWindow); g_pLayoutManager->getCurrentLayout()->onWindowCreatedFloating(pWindow);
return; return;
} }
// last fail-safe to avoid duplicate fullscreens // last fail-safe to avoid duplicate fullscreens
if ((!OPENINGON || OPENINGON->pWindow.lock() == pWindow) && getNodesOnWorkspace(PNODE->workspaceID) > 1) { if ((!OPENINGON || OPENINGON->pWindow.lock() == pWindow) && getNodesOnWorkspace(PNODE->workspaceID) > 1) {
for (auto& node : m_lDwindleNodesData) { for (auto& node : m_dwindleNodesData) {
if (node.workspaceID == PNODE->workspaceID && node.pWindow.lock() && node.pWindow.lock() != pWindow) { if (node.workspaceID == PNODE->workspaceID && node.pWindow.lock() && node.pWindow.lock() != pWindow) {
OPENINGON = &node; OPENINGON = &node;
break; break;
@ -304,8 +304,8 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
// get the node under our cursor // get the node under our cursor
m_lDwindleNodesData.emplace_back(); m_dwindleNodesData.emplace_back();
const auto NEWPARENT = &m_lDwindleNodesData.back(); const auto NEWPARENT = &m_dwindleNodesData.back();
// make the parent have the OPENINGON's stats // make the parent have the OPENINGON's stats
NEWPARENT->box = OPENINGON->box; NEWPARENT->box = OPENINGON->box;
@ -328,16 +328,16 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
bool verticalOverride = false; bool verticalOverride = false;
// let user select position -> top, right, bottom, left // let user select position -> top, right, bottom, left
if (overrideDirection != DIRECTION_DEFAULT) { if (m_overrideDirection != DIRECTION_DEFAULT) {
// this is horizontal // this is horizontal
if (overrideDirection % 2 == 0) if (m_overrideDirection % 2 == 0)
verticalOverride = true; verticalOverride = true;
else else
horizontalOverride = true; horizontalOverride = true;
// 0 -> top and left | 1,2 -> right and bottom // 0 -> top and left | 1,2 -> right and bottom
if (overrideDirection % 3 == 0) { if (m_overrideDirection % 3 == 0) {
NEWPARENT->children[1] = OPENINGON; NEWPARENT->children[1] = OPENINGON;
NEWPARENT->children[0] = PNODE; NEWPARENT->children[0] = PNODE;
} else { } else {
@ -347,7 +347,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
// whether or not the override persists after opening one window // whether or not the override persists after opening one window
if (*PERMANENTDIRECTIONOVERRIDE == 0) if (*PERMANENTDIRECTIONOVERRIDE == 0)
overrideDirection = DIRECTION_DEFAULT; m_overrideDirection = DIRECTION_DEFAULT;
} else if (*PSMARTSPLIT == 1) { } else if (*PSMARTSPLIT == 1) {
const auto PARENT_CENTER = NEWPARENT->box.pos() + NEWPARENT->box.size() / 2; const auto PARENT_CENTER = NEWPARENT->box.pos() + NEWPARENT->box.size() / 2;
const auto PARENT_PROPORTIONS = NEWPARENT->box.h / NEWPARENT->box.w; const auto PARENT_PROPORTIONS = NEWPARENT->box.h / NEWPARENT->box.w;
@ -455,7 +455,7 @@ void CHyprDwindleLayout::onWindowRemovedTiling(PHLWINDOW pWindow) {
if (!PPARENT) { if (!PPARENT) {
Debug::log(LOG, "Removing last node (dwindle)"); Debug::log(LOG, "Removing last node (dwindle)");
m_lDwindleNodesData.remove(*PNODE); m_dwindleNodesData.remove(*PNODE);
return; return;
} }
@ -480,8 +480,8 @@ void CHyprDwindleLayout::onWindowRemovedTiling(PHLWINDOW pWindow) {
else else
PSIBLING->recalcSizePosRecursive(); PSIBLING->recalcSizePosRecursive();
m_lDwindleNodesData.remove(*PPARENT); m_dwindleNodesData.remove(*PPARENT);
m_lDwindleNodesData.remove(*PNODE); m_dwindleNodesData.remove(*PNODE);
} }
void CHyprDwindleLayout::recalculateMonitor(const MONITORID& monid) { void CHyprDwindleLayout::recalculateMonitor(const MONITORID& monid) {
@ -540,8 +540,8 @@ bool CHyprDwindleLayout::isWindowTiled(PHLWINDOW pWindow) {
} }
void CHyprDwindleLayout::onBeginDragWindow() { void CHyprDwindleLayout::onBeginDragWindow() {
m_PseudoDragFlags.started = false; m_pseudoDragFlags.started = false;
m_PseudoDragFlags.pseudo = false; m_pseudoDragFlags.pseudo = false;
IHyprLayout::onBeginDragWindow(); IHyprLayout::onBeginDragWindow();
} }
@ -573,29 +573,29 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorn
const bool DISPLAYBOTTOM = STICKS(PWINDOW->m_position.y + PWINDOW->m_size.y, PMONITOR->m_position.y + PMONITOR->m_size.y - PMONITOR->m_reservedBottomRight.y); const bool DISPLAYBOTTOM = STICKS(PWINDOW->m_position.y + PWINDOW->m_size.y, PMONITOR->m_position.y + PMONITOR->m_size.y - PMONITOR->m_reservedBottomRight.y);
if (PWINDOW->m_isPseudotiled) { if (PWINDOW->m_isPseudotiled) {
if (!m_PseudoDragFlags.started) { if (!m_pseudoDragFlags.started) {
m_PseudoDragFlags.started = true; m_pseudoDragFlags.started = true;
const auto pseudoSize = PWINDOW->m_realSize->goal(); const auto pseudoSize = PWINDOW->m_realSize->goal();
const auto mouseOffset = g_pInputManager->getMouseCoordsInternal() - (PNODE->box.pos() + ((PNODE->box.size() / 2) - (pseudoSize / 2))); 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) { if (mouseOffset.x > 0 && mouseOffset.x < pseudoSize.x && mouseOffset.y > 0 && mouseOffset.y < pseudoSize.y) {
m_PseudoDragFlags.pseudo = true; m_pseudoDragFlags.pseudo = true;
m_PseudoDragFlags.xExtent = mouseOffset.x > pseudoSize.x / 2; m_pseudoDragFlags.xExtent = mouseOffset.x > pseudoSize.x / 2;
m_PseudoDragFlags.yExtent = mouseOffset.y > pseudoSize.y / 2; m_pseudoDragFlags.yExtent = mouseOffset.y > pseudoSize.y / 2;
PWINDOW->m_pseudoSize = pseudoSize; PWINDOW->m_pseudoSize = pseudoSize;
} else { } else {
m_PseudoDragFlags.pseudo = false; m_pseudoDragFlags.pseudo = false;
} }
} }
if (m_PseudoDragFlags.pseudo) { if (m_pseudoDragFlags.pseudo) {
if (m_PseudoDragFlags.xExtent) if (m_pseudoDragFlags.xExtent)
PWINDOW->m_pseudoSize.x += pixResize.x * 2; PWINDOW->m_pseudoSize.x += pixResize.x * 2;
else else
PWINDOW->m_pseudoSize.x -= pixResize.x * 2; PWINDOW->m_pseudoSize.x -= pixResize.x * 2;
if (m_PseudoDragFlags.yExtent) if (m_pseudoDragFlags.yExtent)
PWINDOW->m_pseudoSize.y += pixResize.y * 2; PWINDOW->m_pseudoSize.y += pixResize.y * 2;
else else
PWINDOW->m_pseudoSize.y -= pixResize.y * 2; PWINDOW->m_pseudoSize.y -= pixResize.y * 2;
@ -837,7 +837,7 @@ void CHyprDwindleLayout::moveWindowTo(PHLWINDOW pWindow, const std::string& dir,
onWindowRemovedTiling(pWindow); onWindowRemovedTiling(pWindow);
m_vOverrideFocalPoint = focalPoint; m_overrideFocalPoint = focalPoint;
const auto PMONITORFOCAL = g_pCompositor->getMonitorFromVector(focalPoint); const auto PMONITORFOCAL = g_pCompositor->getMonitorFromVector(focalPoint);
@ -857,7 +857,7 @@ void CHyprDwindleLayout::moveWindowTo(PHLWINDOW pWindow, const std::string& dir,
onWindowCreatedTiling(pWindow); onWindowCreatedTiling(pWindow);
m_vOverrideFocalPoint.reset(); m_overrideFocalPoint.reset();
// restore focus to the previous position // restore focus to the previous position
if (silent) { if (silent) {
@ -957,26 +957,26 @@ std::any CHyprDwindleLayout::layoutMessage(SLayoutMessageHeader header, std::str
switch (direction.front()) { switch (direction.front()) {
case 'u': case 'u':
case 't': { case 't': {
overrideDirection = DIRECTION_UP; m_overrideDirection = DIRECTION_UP;
break; break;
} }
case 'd': case 'd':
case 'b': { case 'b': {
overrideDirection = DIRECTION_DOWN; m_overrideDirection = DIRECTION_DOWN;
break; break;
} }
case 'r': { case 'r': {
overrideDirection = DIRECTION_RIGHT; m_overrideDirection = DIRECTION_RIGHT;
break; break;
} }
case 'l': { case 'l': {
overrideDirection = DIRECTION_LEFT; m_overrideDirection = DIRECTION_LEFT;
break; break;
} }
default: { default: {
// any other character resets the focus direction // any other character resets the focus direction
// needed for the persistent mode // needed for the persistent mode
overrideDirection = DIRECTION_DEFAULT; m_overrideDirection = DIRECTION_DEFAULT;
break; break;
} }
} }
@ -1076,7 +1076,7 @@ void CHyprDwindleLayout::onEnable() {
} }
void CHyprDwindleLayout::onDisable() { void CHyprDwindleLayout::onDisable() {
m_lDwindleNodesData.clear(); m_dwindleNodesData.clear();
} }
Vector2D CHyprDwindleLayout::predictSizeForNewWindowTiled() { Vector2D CHyprDwindleLayout::predictSizeForNewWindowTiled() {

8
src/layout/DwindleLayout.hpp
View File

@ -65,16 +65,16 @@ class CHyprDwindleLayout : public IHyprLayout {
virtual void onDisable(); virtual void onDisable();
private: private:
std::list<SDwindleNodeData> m_lDwindleNodesData; std::list<SDwindleNodeData> m_dwindleNodesData;
struct { struct {
bool started = false; bool started = false;
bool pseudo = false; bool pseudo = false;
bool xExtent = false; bool xExtent = false;
bool yExtent = false; bool yExtent = false;
} m_PseudoDragFlags; } m_pseudoDragFlags;
std::optional<Vector2D> m_vOverrideFocalPoint; // for onWindowCreatedTiling. std::optional<Vector2D> m_overrideFocalPoint; // for onWindowCreatedTiling.
int getNodesOnWorkspace(const WORKSPACEID&); int getNodesOnWorkspace(const WORKSPACEID&);
void applyNodeDataToWindow(SDwindleNodeData*, bool force = false); void applyNodeDataToWindow(SDwindleNodeData*, bool force = false);
@ -88,7 +88,7 @@ class CHyprDwindleLayout : public IHyprLayout {
void swapSplit(PHLWINDOW); void swapSplit(PHLWINDOW);
void moveToRoot(PHLWINDOW, bool stable = true); void moveToRoot(PHLWINDOW, bool stable = true);
eDirection overrideDirection = DIRECTION_DEFAULT; eDirection m_overrideDirection = DIRECTION_DEFAULT;
friend struct SDwindleNodeData; friend struct SDwindleNodeData;
}; };

118
src/layout/IHyprLayout.cpp
View File

@ -70,8 +70,8 @@ void IHyprLayout::onWindowRemoved(PHLWINDOW pWindow) {
std::swap(PWINDOWPREV->m_groupData.pNextWindow->m_groupData.locked, pWindow->m_groupData.locked); std::swap(PWINDOWPREV->m_groupData.pNextWindow->m_groupData.locked, pWindow->m_groupData.locked);
} }
if (pWindow == m_pLastTiledWindow) if (pWindow == m_lastTiledWindow)
m_pLastTiledWindow.reset(); m_lastTiledWindow.reset();
pWindow->setHidden(false); pWindow->setHidden(false);
@ -89,8 +89,8 @@ void IHyprLayout::onWindowRemoved(PHLWINDOW pWindow) {
onWindowRemovedTiling(pWindow); onWindowRemovedTiling(pWindow);
} }
if (pWindow == m_pLastTiledWindow) if (pWindow == m_lastTiledWindow)
m_pLastTiledWindow.reset(); m_lastTiledWindow.reset();
} }
void IHyprLayout::onWindowRemovedFloating(PHLWINDOW pWindow) { void IHyprLayout::onWindowRemovedFloating(PHLWINDOW pWindow) {
@ -232,8 +232,8 @@ void IHyprLayout::onBeginDragWindow() {
const auto DRAGGINGWINDOW = g_pInputManager->currentlyDraggedWindow.lock(); const auto DRAGGINGWINDOW = g_pInputManager->currentlyDraggedWindow.lock();
static auto PDRAGTHRESHOLD = CConfigValue<Hyprlang::INT>("binds:drag_threshold"); static auto PDRAGTHRESHOLD = CConfigValue<Hyprlang::INT>("binds:drag_threshold");
m_iMouseMoveEventCount = 1; m_mouseMoveEventCount = 1;
m_vBeginDragSizeXY = Vector2D(); m_beginDragSizeXY = Vector2D();
// Window will be floating. Let's check if it's valid. It should be, but I don't like crashing. // Window will be floating. Let's check if it's valid. It should be, but I don't like crashing.
if (!validMapped(DRAGGINGWINDOW)) { if (!validMapped(DRAGGINGWINDOW)) {
@ -253,36 +253,36 @@ void IHyprLayout::onBeginDragWindow() {
if (*RESIZECORNER != 0 && *RESIZECORNER <= 4 && DRAGGINGWINDOW->m_isFloating) { if (*RESIZECORNER != 0 && *RESIZECORNER <= 4 && DRAGGINGWINDOW->m_isFloating) {
switch (*RESIZECORNER) { switch (*RESIZECORNER) {
case 1: case 1:
m_eGrabbedCorner = CORNER_TOPLEFT; m_grabbedCorner = CORNER_TOPLEFT;
g_pInputManager->setCursorImageUntilUnset("nw-resize"); g_pInputManager->setCursorImageUntilUnset("nw-resize");
break; break;
case 2: case 2:
m_eGrabbedCorner = CORNER_TOPRIGHT; m_grabbedCorner = CORNER_TOPRIGHT;
g_pInputManager->setCursorImageUntilUnset("ne-resize"); g_pInputManager->setCursorImageUntilUnset("ne-resize");
break; break;
case 3: case 3:
m_eGrabbedCorner = CORNER_BOTTOMRIGHT; m_grabbedCorner = CORNER_BOTTOMRIGHT;
g_pInputManager->setCursorImageUntilUnset("se-resize"); g_pInputManager->setCursorImageUntilUnset("se-resize");
break; break;
case 4: case 4:
m_eGrabbedCorner = CORNER_BOTTOMLEFT; m_grabbedCorner = CORNER_BOTTOMLEFT;
g_pInputManager->setCursorImageUntilUnset("sw-resize"); g_pInputManager->setCursorImageUntilUnset("sw-resize");
break; break;
} }
} else if (m_vBeginDragXY.x < m_vBeginDragPositionXY.x + m_vBeginDragSizeXY.x / 2.0) { } else if (m_beginDragXY.x < m_beginDragPositionXY.x + m_beginDragSizeXY.x / 2.0) {
if (m_vBeginDragXY.y < m_vBeginDragPositionXY.y + m_vBeginDragSizeXY.y / 2.0) { if (m_beginDragXY.y < m_beginDragPositionXY.y + m_beginDragSizeXY.y / 2.0) {
m_eGrabbedCorner = CORNER_TOPLEFT; m_grabbedCorner = CORNER_TOPLEFT;
g_pInputManager->setCursorImageUntilUnset("nw-resize"); g_pInputManager->setCursorImageUntilUnset("nw-resize");
} else { } else {
m_eGrabbedCorner = CORNER_BOTTOMLEFT; m_grabbedCorner = CORNER_BOTTOMLEFT;
g_pInputManager->setCursorImageUntilUnset("sw-resize"); g_pInputManager->setCursorImageUntilUnset("sw-resize");
} }
} else { } else {
if (m_vBeginDragXY.y < m_vBeginDragPositionXY.y + m_vBeginDragSizeXY.y / 2.0) { if (m_beginDragXY.y < m_beginDragPositionXY.y + m_beginDragSizeXY.y / 2.0) {
m_eGrabbedCorner = CORNER_TOPRIGHT; m_grabbedCorner = CORNER_TOPRIGHT;
g_pInputManager->setCursorImageUntilUnset("ne-resize"); g_pInputManager->setCursorImageUntilUnset("ne-resize");
} else { } else {
m_eGrabbedCorner = CORNER_BOTTOMRIGHT; m_grabbedCorner = CORNER_BOTTOMRIGHT;
g_pInputManager->setCursorImageUntilUnset("se-resize"); g_pInputManager->setCursorImageUntilUnset("se-resize");
} }
} }
@ -301,7 +301,7 @@ void IHyprLayout::onBeginDragWindow() {
void IHyprLayout::onEndDragWindow() { void IHyprLayout::onEndDragWindow() {
const auto DRAGGINGWINDOW = g_pInputManager->currentlyDraggedWindow.lock(); const auto DRAGGINGWINDOW = g_pInputManager->currentlyDraggedWindow.lock();
m_iMouseMoveEventCount = 1; m_mouseMoveEventCount = 1;
if (!validMapped(DRAGGINGWINDOW)) { if (!validMapped(DRAGGINGWINDOW)) {
if (DRAGGINGWINDOW) { if (DRAGGINGWINDOW) {
@ -340,7 +340,7 @@ void IHyprLayout::onEndDragWindow() {
} }
DRAGGINGWINDOW->m_isFloating = pWindow->m_isFloating; // match the floating state of the window DRAGGINGWINDOW->m_isFloating = pWindow->m_isFloating; // match the floating state of the window
DRAGGINGWINDOW->m_lastFloatingSize = m_vDraggingWindowOriginalFloatSize; DRAGGINGWINDOW->m_lastFloatingSize = m_draggingWindowOriginalFloatSize;
DRAGGINGWINDOW->m_draggingTiled = false; DRAGGINGWINDOW->m_draggingTiled = false;
static auto USECURRPOS = CConfigValue<Hyprlang::INT>("group:insert_after_current"); static auto USECURRPOS = CConfigValue<Hyprlang::INT>("group:insert_after_current");
@ -359,7 +359,7 @@ void IHyprLayout::onEndDragWindow() {
DRAGGINGWINDOW->m_isFloating = false; DRAGGINGWINDOW->m_isFloating = false;
g_pInputManager->refocus(); g_pInputManager->refocus();
changeWindowFloatingMode(DRAGGINGWINDOW); changeWindowFloatingMode(DRAGGINGWINDOW);
DRAGGINGWINDOW->m_lastFloatingSize = m_vDraggingWindowOriginalFloatSize; DRAGGINGWINDOW->m_lastFloatingSize = m_draggingWindowOriginalFloatSize;
} }
g_pHyprRenderer->damageWindow(DRAGGINGWINDOW); g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
@ -525,14 +525,14 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
static auto PDRAGTHRESHOLD = CConfigValue<Hyprlang::INT>("binds:drag_threshold"); static auto PDRAGTHRESHOLD = CConfigValue<Hyprlang::INT>("binds:drag_threshold");
// Window invalid or drag begin size 0,0 meaning we rejected it. // Window invalid or drag begin size 0,0 meaning we rejected it.
if ((!validMapped(DRAGGINGWINDOW) || m_vBeginDragSizeXY == Vector2D())) { if ((!validMapped(DRAGGINGWINDOW) || m_beginDragSizeXY == Vector2D())) {
g_pKeybindManager->changeMouseBindMode(MBIND_INVALID); g_pKeybindManager->changeMouseBindMode(MBIND_INVALID);
return; return;
} }
// Yoink dragged window here instead if using drag_threshold and it has been reached // Yoink dragged window here instead if using drag_threshold and it has been reached
if (*PDRAGTHRESHOLD > 0 && !g_pInputManager->m_bDragThresholdReached) { if (*PDRAGTHRESHOLD > 0 && !g_pInputManager->m_bDragThresholdReached) {
if ((m_vBeginDragXY.distanceSq(mousePos) <= std::pow(*PDRAGTHRESHOLD, 2) && m_vBeginDragXY == m_vLastDragXY)) if ((m_beginDragXY.distanceSq(mousePos) <= std::pow(*PDRAGTHRESHOLD, 2) && m_beginDragXY == m_lastDragXY))
return; return;
g_pInputManager->m_bDragThresholdReached = true; g_pInputManager->m_bDragThresholdReached = true;
if (updateDragWindow()) if (updateDragWindow())
@ -543,8 +543,8 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
const auto SPECIAL = DRAGGINGWINDOW->onSpecialWorkspace(); const auto SPECIAL = DRAGGINGWINDOW->onSpecialWorkspace();
const auto DELTA = Vector2D(mousePos.x - m_vBeginDragXY.x, mousePos.y - m_vBeginDragXY.y); const auto DELTA = Vector2D(mousePos.x - m_beginDragXY.x, mousePos.y - m_beginDragXY.y);
const auto TICKDELTA = Vector2D(mousePos.x - m_vLastDragXY.x, mousePos.y - m_vLastDragXY.y); const auto TICKDELTA = Vector2D(mousePos.x - m_lastDragXY.x, mousePos.y - m_lastDragXY.y);
static auto PANIMATEMOUSE = CConfigValue<Hyprlang::INT>("misc:animate_mouse_windowdragging"); static auto PANIMATEMOUSE = CConfigValue<Hyprlang::INT>("misc:animate_mouse_windowdragging");
static auto PANIMATE = CConfigValue<Hyprlang::INT>("misc:animate_manual_resizes"); static auto PANIMATE = CConfigValue<Hyprlang::INT>("misc:animate_manual_resizes");
@ -559,15 +559,15 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
MSTIMER = std::chrono::high_resolution_clock::now(); MSTIMER = std::chrono::high_resolution_clock::now();
if (m_iMouseMoveEventCount == 1) if (m_mouseMoveEventCount == 1)
totalMs = 0; totalMs = 0;
if (MSMONITOR > 16.0) { if (MSMONITOR > 16.0) {
totalMs += MSDELTA < MSMONITOR ? MSDELTA : std::round(totalMs * 1.0 / m_iMouseMoveEventCount); totalMs += MSDELTA < MSMONITOR ? MSDELTA : std::round(totalMs * 1.0 / m_mouseMoveEventCount);
m_iMouseMoveEventCount += 1; m_mouseMoveEventCount += 1;
// check if time-window is enough to skip update on 60hz monitor // check if time-window is enough to skip update on 60hz monitor
canSkipUpdate = std::clamp(MSMONITOR - TIMERDELTA, 0.0, MSMONITOR) > totalMs * 1.0 / m_iMouseMoveEventCount; canSkipUpdate = std::clamp(MSMONITOR - TIMERDELTA, 0.0, MSMONITOR) > totalMs * 1.0 / m_mouseMoveEventCount;
} }
if ((abs(TICKDELTA.x) < 1.f && abs(TICKDELTA.y) < 1.f) || (TIMERDELTA < MSMONITOR && canSkipUpdate && (g_pInputManager->dragMode != MBIND_MOVE || *PANIMATEMOUSE))) if ((abs(TICKDELTA.x) < 1.f && abs(TICKDELTA.y) < 1.f) || (TIMERDELTA < MSMONITOR && canSkipUpdate && (g_pInputManager->dragMode != MBIND_MOVE || *PANIMATEMOUSE)))
@ -575,17 +575,17 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
TIMER = std::chrono::high_resolution_clock::now(); TIMER = std::chrono::high_resolution_clock::now();
m_vLastDragXY = mousePos; m_lastDragXY = mousePos;
g_pHyprRenderer->damageWindow(DRAGGINGWINDOW); g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
if (g_pInputManager->dragMode == MBIND_MOVE) { if (g_pInputManager->dragMode == MBIND_MOVE) {
Vector2D newPos = m_vBeginDragPositionXY + DELTA; Vector2D newPos = m_beginDragPositionXY + DELTA;
Vector2D newSize = DRAGGINGWINDOW->m_realSize->goal(); Vector2D newSize = DRAGGINGWINDOW->m_realSize->goal();
if (*SNAPENABLED && !DRAGGINGWINDOW->m_draggingTiled) if (*SNAPENABLED && !DRAGGINGWINDOW->m_draggingTiled)
performSnap(newPos, newSize, DRAGGINGWINDOW, MBIND_MOVE, -1, m_vBeginDragSizeXY); performSnap(newPos, newSize, DRAGGINGWINDOW, MBIND_MOVE, -1, m_beginDragSizeXY);
CBox wb = {newPos, newSize}; CBox wb = {newPos, newSize};
wb.round(); wb.round();
@ -609,25 +609,25 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
else else
MAXSIZE = DRAGGINGWINDOW->requestedMaxSize().clamp({}, Vector2D(std::numeric_limits<double>::max(), std::numeric_limits<double>::max())); MAXSIZE = DRAGGINGWINDOW->requestedMaxSize().clamp({}, Vector2D(std::numeric_limits<double>::max(), std::numeric_limits<double>::max()));
Vector2D newSize = m_vBeginDragSizeXY; Vector2D newSize = m_beginDragSizeXY;
Vector2D newPos = m_vBeginDragPositionXY; Vector2D newPos = m_beginDragPositionXY;
if (m_eGrabbedCorner == CORNER_BOTTOMRIGHT) if (m_grabbedCorner == CORNER_BOTTOMRIGHT)
newSize = newSize + DELTA; newSize = newSize + DELTA;
else if (m_eGrabbedCorner == CORNER_TOPLEFT) else if (m_grabbedCorner == CORNER_TOPLEFT)
newSize = newSize - DELTA; newSize = newSize - DELTA;
else if (m_eGrabbedCorner == CORNER_TOPRIGHT) else if (m_grabbedCorner == CORNER_TOPRIGHT)
newSize = newSize + Vector2D(DELTA.x, -DELTA.y); newSize = newSize + Vector2D(DELTA.x, -DELTA.y);
else if (m_eGrabbedCorner == CORNER_BOTTOMLEFT) else if (m_grabbedCorner == CORNER_BOTTOMLEFT)
newSize = newSize + Vector2D(-DELTA.x, DELTA.y); newSize = newSize + Vector2D(-DELTA.x, DELTA.y);
eMouseBindMode mode = g_pInputManager->dragMode; eMouseBindMode mode = g_pInputManager->dragMode;
if (DRAGGINGWINDOW->m_windowData.keepAspectRatio.valueOrDefault() && mode != MBIND_RESIZE_BLOCK_RATIO) if (DRAGGINGWINDOW->m_windowData.keepAspectRatio.valueOrDefault() && mode != MBIND_RESIZE_BLOCK_RATIO)
mode = MBIND_RESIZE_FORCE_RATIO; mode = MBIND_RESIZE_FORCE_RATIO;
if (m_vBeginDragSizeXY.x >= 1 && m_vBeginDragSizeXY.y >= 1 && mode == MBIND_RESIZE_FORCE_RATIO) { if (m_beginDragSizeXY.x >= 1 && m_beginDragSizeXY.y >= 1 && mode == MBIND_RESIZE_FORCE_RATIO) {
const float RATIO = m_vBeginDragSizeXY.y / m_vBeginDragSizeXY.x; const float RATIO = m_beginDragSizeXY.y / m_beginDragSizeXY.x;
if (MINSIZE.x * RATIO > MINSIZE.y) if (MINSIZE.x * RATIO > MINSIZE.y)
MINSIZE = Vector2D(MINSIZE.x, MINSIZE.x * RATIO); MINSIZE = Vector2D(MINSIZE.x, MINSIZE.x * RATIO);
@ -647,15 +647,15 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
newSize = newSize.clamp(MINSIZE, MAXSIZE); newSize = newSize.clamp(MINSIZE, MAXSIZE);
if (m_eGrabbedCorner == CORNER_TOPLEFT) if (m_grabbedCorner == CORNER_TOPLEFT)
newPos = newPos - newSize + m_vBeginDragSizeXY; newPos = newPos - newSize + m_beginDragSizeXY;
else if (m_eGrabbedCorner == CORNER_TOPRIGHT) else if (m_grabbedCorner == CORNER_TOPRIGHT)
newPos = newPos + Vector2D(0.0, (m_vBeginDragSizeXY - newSize).y); newPos = newPos + Vector2D(0.0, (m_beginDragSizeXY - newSize).y);
else if (m_eGrabbedCorner == CORNER_BOTTOMLEFT) else if (m_grabbedCorner == CORNER_BOTTOMLEFT)
newPos = newPos + Vector2D((m_vBeginDragSizeXY - newSize).x, 0.0); newPos = newPos + Vector2D((m_beginDragSizeXY - newSize).x, 0.0);
if (*SNAPENABLED) { if (*SNAPENABLED) {
performSnap(newPos, newSize, DRAGGINGWINDOW, mode, m_eGrabbedCorner, m_vBeginDragSizeXY); performSnap(newPos, newSize, DRAGGINGWINDOW, mode, m_grabbedCorner, m_beginDragSizeXY);
newSize = newSize.clamp(MINSIZE, MAXSIZE); newSize = newSize.clamp(MINSIZE, MAXSIZE);
} }
@ -674,7 +674,7 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
DRAGGINGWINDOW->m_position = wb.pos(); DRAGGINGWINDOW->m_position = wb.pos();
DRAGGINGWINDOW->m_size = wb.size(); DRAGGINGWINDOW->m_size = wb.size();
} else { } else {
resizeActiveWindow(TICKDELTA, m_eGrabbedCorner, DRAGGINGWINDOW); resizeActiveWindow(TICKDELTA, m_grabbedCorner, DRAGGINGWINDOW);
} }
} }
@ -747,7 +747,7 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) {
g_pHyprRenderer->damageMonitor(pWindow->m_monitor.lock()); g_pHyprRenderer->damageMonitor(pWindow->m_monitor.lock());
if (pWindow == g_pCompositor->m_lastWindow) if (pWindow == g_pCompositor->m_lastWindow)
m_pLastTiledWindow = pWindow; m_lastTiledWindow = pWindow;
} else { } else {
onWindowRemovedTiling(pWindow); onWindowRemovedTiling(pWindow);
@ -772,8 +772,8 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) {
pWindow->unsetWindowData(PRIORITY_LAYOUT); pWindow->unsetWindowData(PRIORITY_LAYOUT);
pWindow->updateWindowData(); pWindow->updateWindowData();
if (pWindow == m_pLastTiledWindow) if (pWindow == m_lastTiledWindow)
m_pLastTiledWindow.reset(); m_lastTiledWindow.reset();
} }
g_pCompositor->updateWindowAnimatedDecorationValues(pWindow); g_pCompositor->updateWindowAnimatedDecorationValues(pWindow);
@ -801,7 +801,7 @@ void IHyprLayout::moveActiveWindow(const Vector2D& delta, PHLWINDOW pWindow) {
} }
void IHyprLayout::onWindowFocusChange(PHLWINDOW pNewFocus) { void IHyprLayout::onWindowFocusChange(PHLWINDOW pNewFocus) {
m_pLastTiledWindow = pNewFocus && !pNewFocus->m_isFloating ? pNewFocus : m_pLastTiledWindow; m_lastTiledWindow = pNewFocus && !pNewFocus->m_isFloating ? pNewFocus : m_lastTiledWindow;
} }
PHLWINDOW IHyprLayout::getNextWindowCandidate(PHLWINDOW pWindow) { PHLWINDOW IHyprLayout::getNextWindowCandidate(PHLWINDOW pWindow) {
@ -828,8 +828,8 @@ PHLWINDOW IHyprLayout::getNextWindowCandidate(PHLWINDOW pWindow) {
} }
// let's try the last tiled window. // let's try the last tiled window.
if (m_pLastTiledWindow.lock() && m_pLastTiledWindow->m_workspace == pWindow->m_workspace) if (m_lastTiledWindow.lock() && m_lastTiledWindow->m_workspace == pWindow->m_workspace)
return m_pLastTiledWindow.lock(); return m_lastTiledWindow.lock();
// if we don't, let's try to find any window that is in the middle // if we don't, let's try to find any window that is in the middle
if (const auto PWINDOWCANDIDATE = g_pCompositor->vectorToWindowUnified(pWindow->middle(), RESERVED_EXTENTS | INPUT_EXTENTS | ALLOW_FLOATING); if (const auto PWINDOWCANDIDATE = g_pCompositor->vectorToWindowUnified(pWindow->middle(), RESERVED_EXTENTS | INPUT_EXTENTS | ALLOW_FLOATING);
@ -960,8 +960,8 @@ bool IHyprLayout::updateDragWindow() {
} }
} }
DRAGGINGWINDOW->m_draggingTiled = false; DRAGGINGWINDOW->m_draggingTiled = false;
m_vDraggingWindowOriginalFloatSize = DRAGGINGWINDOW->m_lastFloatingSize; m_draggingWindowOriginalFloatSize = DRAGGINGWINDOW->m_lastFloatingSize;
if (WAS_FULLSCREEN && DRAGGINGWINDOW->m_isFloating) { if (WAS_FULLSCREEN && DRAGGINGWINDOW->m_isFloating) {
const auto MOUSECOORDS = g_pInputManager->getMouseCoordsInternal(); const auto MOUSECOORDS = g_pInputManager->getMouseCoordsInternal();
@ -977,10 +977,10 @@ bool IHyprLayout::updateDragWindow() {
} }
} }
m_vBeginDragXY = g_pInputManager->getMouseCoordsInternal(); m_beginDragXY = g_pInputManager->getMouseCoordsInternal();
m_vBeginDragPositionXY = DRAGGINGWINDOW->m_realPosition->goal(); m_beginDragPositionXY = DRAGGINGWINDOW->m_realPosition->goal();
m_vBeginDragSizeXY = DRAGGINGWINDOW->m_realSize->goal(); m_beginDragSizeXY = DRAGGINGWINDOW->m_realSize->goal();
m_vLastDragXY = m_vBeginDragXY; m_lastDragXY = m_beginDragXY;
return false; return false;
} }

16
src/layout/IHyprLayout.hpp
View File

@ -212,13 +212,13 @@ class IHyprLayout {
virtual bool updateDragWindow(); virtual bool updateDragWindow();
private: private:
int m_iMouseMoveEventCount; int m_mouseMoveEventCount;
Vector2D m_vBeginDragXY; Vector2D m_beginDragXY;
Vector2D m_vLastDragXY; Vector2D m_lastDragXY;
Vector2D m_vBeginDragPositionXY; Vector2D m_beginDragPositionXY;
Vector2D m_vBeginDragSizeXY; Vector2D m_beginDragSizeXY;
Vector2D m_vDraggingWindowOriginalFloatSize; Vector2D m_draggingWindowOriginalFloatSize;
eRectCorner m_eGrabbedCorner = CORNER_TOPLEFT; eRectCorner m_grabbedCorner = CORNER_TOPLEFT;
PHLWINDOWREF m_pLastTiledWindow; PHLWINDOWREF m_lastTiledWindow;
}; };

108
src/layout/MasterLayout.cpp
View File

@ -11,7 +11,7 @@
#include "../managers/EventManager.hpp" #include "../managers/EventManager.hpp"
SMasterNodeData* CHyprMasterLayout::getNodeFromWindow(PHLWINDOW pWindow) { SMasterNodeData* CHyprMasterLayout::getNodeFromWindow(PHLWINDOW pWindow) {
for (auto& nd : m_lMasterNodesData) { for (auto& nd : m_masterNodesData) {
if (nd.pWindow.lock() == pWindow) if (nd.pWindow.lock() == pWindow)
return &nd; return &nd;
} }
@ -21,7 +21,7 @@ SMasterNodeData* CHyprMasterLayout::getNodeFromWindow(PHLWINDOW pWindow) {
int CHyprMasterLayout::getNodesOnWorkspace(const WORKSPACEID& ws) { int CHyprMasterLayout::getNodesOnWorkspace(const WORKSPACEID& ws) {
int no = 0; int no = 0;
for (auto const& n : m_lMasterNodesData) { for (auto const& n : m_masterNodesData) {
if (n.workspaceID == ws) if (n.workspaceID == ws)
no++; no++;
} }
@ -31,7 +31,7 @@ int CHyprMasterLayout::getNodesOnWorkspace(const WORKSPACEID& ws) {
int CHyprMasterLayout::getMastersOnWorkspace(const WORKSPACEID& ws) { int CHyprMasterLayout::getMastersOnWorkspace(const WORKSPACEID& ws) {
int no = 0; int no = 0;
for (auto const& n : m_lMasterNodesData) { for (auto const& n : m_masterNodesData) {
if (n.workspaceID == ws && n.isMaster) if (n.workspaceID == ws && n.isMaster)
no++; no++;
} }
@ -40,13 +40,13 @@ int CHyprMasterLayout::getMastersOnWorkspace(const WORKSPACEID& ws) {
} }
SMasterWorkspaceData* CHyprMasterLayout::getMasterWorkspaceData(const WORKSPACEID& ws) { SMasterWorkspaceData* CHyprMasterLayout::getMasterWorkspaceData(const WORKSPACEID& ws) {
for (auto& n : m_lMasterWorkspacesData) { for (auto& n : m_masterWorkspacesData) {
if (n.workspaceID == ws) if (n.workspaceID == ws)
return &n; return &n;
} }
//create on the fly if it doesn't exist yet //create on the fly if it doesn't exist yet
const auto PWORKSPACEDATA = &m_lMasterWorkspacesData.emplace_back(); const auto PWORKSPACEDATA = &m_masterWorkspacesData.emplace_back();
PWORKSPACEDATA->workspaceID = ws; PWORKSPACEDATA->workspaceID = ws;
static auto PORIENTATION = CConfigValue<std::string>("master:orientation"); static auto PORIENTATION = CConfigValue<std::string>("master:orientation");
@ -69,7 +69,7 @@ std::string CHyprMasterLayout::getLayoutName() {
} }
SMasterNodeData* CHyprMasterLayout::getMasterNodeOnWorkspace(const WORKSPACEID& ws) { SMasterNodeData* CHyprMasterLayout::getMasterNodeOnWorkspace(const WORKSPACEID& ws) {
for (auto& n : m_lMasterNodesData) { for (auto& n : m_masterNodesData) {
if (n.isMaster && n.workspaceID == ws) if (n.isMaster && n.workspaceID == ws)
return &n; return &n;
} }
@ -94,13 +94,13 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire
if (*PNEWONACTIVE != "none" && !BNEWISMASTER) { if (*PNEWONACTIVE != "none" && !BNEWISMASTER) {
const auto pLastNode = getNodeFromWindow(g_pCompositor->m_lastWindow.lock()); const auto pLastNode = getNodeFromWindow(g_pCompositor->m_lastWindow.lock());
if (pLastNode && !(pLastNode->isMaster && (getMastersOnWorkspace(pWindow->workspaceID()) == 1 || *PNEWSTATUS == "slave"))) { if (pLastNode && !(pLastNode->isMaster && (getMastersOnWorkspace(pWindow->workspaceID()) == 1 || *PNEWSTATUS == "slave"))) {
auto it = std::find(m_lMasterNodesData.begin(), m_lMasterNodesData.end(), *pLastNode); auto it = std::find(m_masterNodesData.begin(), m_masterNodesData.end(), *pLastNode);
if (!BNEWBEFOREACTIVE) if (!BNEWBEFOREACTIVE)
++it; ++it;
return &(*m_lMasterNodesData.emplace(it)); return &(*m_masterNodesData.emplace(it));
} }
} }
return *PNEWONTOP ? &m_lMasterNodesData.emplace_front() : &m_lMasterNodesData.emplace_back(); return *PNEWONTOP ? &m_masterNodesData.emplace_front() : &m_masterNodesData.emplace_back();
}(); }();
PNODE->workspaceID = pWindow->workspaceID(); PNODE->workspaceID = pWindow->workspaceID();
@ -117,13 +117,13 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire
const auto MOUSECOORDS = g_pInputManager->getMouseCoordsInternal(); const auto MOUSECOORDS = g_pInputManager->getMouseCoordsInternal();
static auto PDROPATCURSOR = CConfigValue<Hyprlang::INT>("master:drop_at_cursor"); static auto PDROPATCURSOR = CConfigValue<Hyprlang::INT>("master:drop_at_cursor");
eOrientation orientation = getDynamicOrientation(pWindow->m_workspace); eOrientation orientation = getDynamicOrientation(pWindow->m_workspace);
const auto NODEIT = std::find(m_lMasterNodesData.begin(), m_lMasterNodesData.end(), *PNODE); const auto NODEIT = std::find(m_masterNodesData.begin(), m_masterNodesData.end(), *PNODE);
bool forceDropAsMaster = false; bool forceDropAsMaster = false;
// if dragging window to move, drop it at the cursor position instead of bottom/top of stack // if dragging window to move, drop it at the cursor position instead of bottom/top of stack
if (*PDROPATCURSOR && g_pInputManager->dragMode == MBIND_MOVE) { if (*PDROPATCURSOR && g_pInputManager->dragMode == MBIND_MOVE) {
if (WINDOWSONWORKSPACE > 2) { if (WINDOWSONWORKSPACE > 2) {
for (auto it = m_lMasterNodesData.begin(); it != m_lMasterNodesData.end(); ++it) { for (auto it = m_masterNodesData.begin(); it != m_masterNodesData.end(); ++it) {
if (it->workspaceID != pWindow->workspaceID()) if (it->workspaceID != pWindow->workspaceID())
continue; continue;
const CBox box = it->pWindow->getWindowIdealBoundingBoxIgnoreReserved(); const CBox box = it->pWindow->getWindowIdealBoundingBoxIgnoreReserved();
@ -142,14 +142,14 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire
case ORIENTATION_CENTER: break; case ORIENTATION_CENTER: break;
default: UNREACHABLE(); default: UNREACHABLE();
} }
m_lMasterNodesData.splice(it, m_lMasterNodesData, NODEIT); m_masterNodesData.splice(it, m_masterNodesData, NODEIT);
break; break;
} }
} }
} else if (WINDOWSONWORKSPACE == 2) { } else if (WINDOWSONWORKSPACE == 2) {
// when dropping as the second tiled window in the workspace, // when dropping as the second tiled window in the workspace,
// make it the master only if the cursor is on the master side of the screen // make it the master only if the cursor is on the master side of the screen
for (auto const& nd : m_lMasterNodesData) { for (auto const& nd : m_masterNodesData) {
if (nd.isMaster && nd.workspaceID == PNODE->workspaceID) { if (nd.isMaster && nd.workspaceID == PNODE->workspaceID) {
switch (orientation) { switch (orientation) {
case ORIENTATION_LEFT: case ORIENTATION_LEFT:
@ -184,7 +184,7 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire
|| (*PNEWSTATUS == "inherit" && OPENINGON && OPENINGON->isMaster && g_pInputManager->dragMode != MBIND_MOVE)) { || (*PNEWSTATUS == "inherit" && OPENINGON && OPENINGON->isMaster && g_pInputManager->dragMode != MBIND_MOVE)) {
if (BNEWBEFOREACTIVE) { if (BNEWBEFOREACTIVE) {
for (auto& nd : m_lMasterNodesData | std::views::reverse) { for (auto& nd : m_masterNodesData | std::views::reverse) {
if (nd.isMaster && nd.workspaceID == PNODE->workspaceID) { if (nd.isMaster && nd.workspaceID == PNODE->workspaceID) {
nd.isMaster = false; nd.isMaster = false;
lastSplitPercent = nd.percMaster; lastSplitPercent = nd.percMaster;
@ -192,7 +192,7 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire
} }
} }
} else { } else {
for (auto& nd : m_lMasterNodesData) { for (auto& nd : m_masterNodesData) {
if (nd.isMaster && nd.workspaceID == PNODE->workspaceID) { if (nd.isMaster && nd.workspaceID == PNODE->workspaceID) {
nd.isMaster = false; nd.isMaster = false;
lastSplitPercent = nd.percMaster; lastSplitPercent = nd.percMaster;
@ -208,7 +208,7 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire
if (const auto MAXSIZE = pWindow->requestedMaxSize(); MAXSIZE.x < PMONITOR->m_size.x * lastSplitPercent || MAXSIZE.y < PMONITOR->m_size.y) { if (const auto MAXSIZE = pWindow->requestedMaxSize(); MAXSIZE.x < PMONITOR->m_size.x * lastSplitPercent || MAXSIZE.y < PMONITOR->m_size.y) {
// we can't continue. make it floating. // we can't continue. make it floating.
pWindow->m_isFloating = true; pWindow->m_isFloating = true;
m_lMasterNodesData.remove(*PNODE); m_masterNodesData.remove(*PNODE);
g_pLayoutManager->getCurrentLayout()->onWindowCreatedFloating(pWindow); g_pLayoutManager->getCurrentLayout()->onWindowCreatedFloating(pWindow);
return; return;
} }
@ -221,7 +221,7 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire
MAXSIZE.x < PMONITOR->m_size.x * (1 - lastSplitPercent) || MAXSIZE.y < PMONITOR->m_size.y * (1.f / (WINDOWSONWORKSPACE - 1))) { MAXSIZE.x < PMONITOR->m_size.x * (1 - lastSplitPercent) || MAXSIZE.y < PMONITOR->m_size.y * (1.f / (WINDOWSONWORKSPACE - 1))) {
// we can't continue. make it floating. // we can't continue. make it floating.
pWindow->m_isFloating = true; pWindow->m_isFloating = true;
m_lMasterNodesData.remove(*PNODE); m_masterNodesData.remove(*PNODE);
g_pLayoutManager->getCurrentLayout()->onWindowCreatedFloating(pWindow); g_pLayoutManager->getCurrentLayout()->onWindowCreatedFloating(pWindow);
return; return;
} }
@ -249,7 +249,7 @@ void CHyprMasterLayout::onWindowRemovedTiling(PHLWINDOW pWindow) {
if (PNODE->isMaster && (MASTERSLEFT <= 1 || *SMALLSPLIT == 1)) { if (PNODE->isMaster && (MASTERSLEFT <= 1 || *SMALLSPLIT == 1)) {
// find a new master from top of the list // find a new master from top of the list
for (auto& nd : m_lMasterNodesData) { for (auto& nd : m_masterNodesData) {
if (!nd.isMaster && nd.workspaceID == WORKSPACEID) { if (!nd.isMaster && nd.workspaceID == WORKSPACEID) {
nd.isMaster = true; nd.isMaster = true;
nd.percMaster = PNODE->percMaster; nd.percMaster = PNODE->percMaster;
@ -258,10 +258,10 @@ void CHyprMasterLayout::onWindowRemovedTiling(PHLWINDOW pWindow) {
} }
} }
m_lMasterNodesData.remove(*PNODE); m_masterNodesData.remove(*PNODE);
if (getMastersOnWorkspace(WORKSPACEID) == getNodesOnWorkspace(WORKSPACEID) && MASTERSLEFT > 1) { if (getMastersOnWorkspace(WORKSPACEID) == getNodesOnWorkspace(WORKSPACEID) && MASTERSLEFT > 1) {
for (auto& nd : m_lMasterNodesData | std::views::reverse) { for (auto& nd : m_masterNodesData | std::views::reverse) {
if (nd.workspaceID == WORKSPACEID) { if (nd.workspaceID == WORKSPACEID) {
nd.isMaster = false; nd.isMaster = false;
break; break;
@ -271,7 +271,7 @@ void CHyprMasterLayout::onWindowRemovedTiling(PHLWINDOW pWindow) {
// BUGFIX: correct bug where closing one master in a stack of 2 would leave // BUGFIX: correct bug where closing one master in a stack of 2 would leave
// the screen half bare, and make it difficult to select remaining window // the screen half bare, and make it difficult to select remaining window
if (getNodesOnWorkspace(WORKSPACEID) == 1) { if (getNodesOnWorkspace(WORKSPACEID) == 1) {
for (auto& nd : m_lMasterNodesData) { for (auto& nd : m_masterNodesData) {
if (nd.workspaceID == WORKSPACEID && !nd.isMaster) { if (nd.workspaceID == WORKSPACEID && !nd.isMaster) {
nd.isMaster = true; nd.isMaster = true;
break; break;
@ -363,7 +363,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
if (*PSMARTRESIZING) { if (*PSMARTRESIZING) {
// check the total width and height so that later // check the total width and height so that later
// if larger/smaller than screen size them down/up // if larger/smaller than screen size them down/up
for (auto const& nd : m_lMasterNodesData) { for (auto const& nd : m_masterNodesData) {
if (nd.workspaceID == pWorkspace->m_id) { if (nd.workspaceID == pWorkspace->m_id) {
if (nd.isMaster) if (nd.isMaster)
masterAccumulatedSize += totalSize / MASTERS * nd.percSize; masterAccumulatedSize += totalSize / MASTERS * nd.percSize;
@ -404,7 +404,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
if (orientation == ORIENTATION_BOTTOM) if (orientation == ORIENTATION_BOTTOM)
nextY = WSSIZE.y - HEIGHT; nextY = WSSIZE.y - HEIGHT;
for (auto& nd : m_lMasterNodesData) { for (auto& nd : m_masterNodesData) {
if (nd.workspaceID != pWorkspace->m_id || !nd.isMaster) if (nd.workspaceID != pWorkspace->m_id || !nd.isMaster)
continue; continue;
@ -441,7 +441,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
nextX = ((*PIGNORERESERVED && centerMasterWindow ? PMONITOR->m_size.x : WSSIZE.x) - WIDTH) / 2; nextX = ((*PIGNORERESERVED && centerMasterWindow ? PMONITOR->m_size.x : WSSIZE.x) - WIDTH) / 2;
} }
for (auto& nd : m_lMasterNodesData) { for (auto& nd : m_masterNodesData) {
if (nd.workspaceID != pWorkspace->m_id || !nd.isMaster) if (nd.workspaceID != pWorkspace->m_id || !nd.isMaster)
continue; continue;
@ -478,7 +478,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
if (orientation == ORIENTATION_TOP) if (orientation == ORIENTATION_TOP)
nextY = PMASTERNODE->size.y; nextY = PMASTERNODE->size.y;
for (auto& nd : m_lMasterNodesData) { for (auto& nd : m_masterNodesData) {
if (nd.workspaceID != pWorkspace->m_id || nd.isMaster) if (nd.workspaceID != pWorkspace->m_id || nd.isMaster)
continue; continue;
@ -508,7 +508,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
if (orientation == ORIENTATION_LEFT) if (orientation == ORIENTATION_LEFT)
nextX = PMASTERNODE->size.x; nextX = PMASTERNODE->size.x;
for (auto& nd : m_lMasterNodesData) { for (auto& nd : m_masterNodesData) {
if (nd.workspaceID != pWorkspace->m_id || nd.isMaster) if (nd.workspaceID != pWorkspace->m_id || nd.isMaster)
continue; continue;
@ -553,7 +553,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
float slaveAccumulatedHeightR = 0; float slaveAccumulatedHeightR = 0;
if (*PSMARTRESIZING) { if (*PSMARTRESIZING) {
for (auto const& nd : m_lMasterNodesData) { for (auto const& nd : m_masterNodesData) {
if (nd.workspaceID != pWorkspace->m_id || nd.isMaster) if (nd.workspaceID != pWorkspace->m_id || nd.isMaster)
continue; continue;
@ -568,7 +568,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
onRight = *CMSLAVESONRIGHT; onRight = *CMSLAVESONRIGHT;
} }
for (auto& nd : m_lMasterNodesData) { for (auto& nd : m_masterNodesData) {
if (nd.workspaceID != pWorkspace->m_id || nd.isMaster) if (nd.workspaceID != pWorkspace->m_id || nd.isMaster)
continue; continue;
@ -701,7 +701,7 @@ void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) {
*PWINDOW->m_realSize = wb.size(); *PWINDOW->m_realSize = wb.size();
} }
if (m_bForceWarps && !*PANIMATE) { if (m_forceWarps && !*PANIMATE) {
g_pHyprRenderer->damageWindow(PWINDOW); g_pHyprRenderer->damageWindow(PWINDOW);
PWINDOW->m_realPosition->warp(); PWINDOW->m_realPosition->warp();
@ -757,7 +757,7 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
if (getNodesOnWorkspace(PWINDOW->workspaceID()) == 1 && !centered) if (getNodesOnWorkspace(PWINDOW->workspaceID()) == 1 && !centered)
return; return;
m_bForceWarps = true; m_forceWarps = true;
switch (orientation) { switch (orientation) {
case ORIENTATION_LEFT: delta = pixResize.x / PMONITOR->m_size.x; break; case ORIENTATION_LEFT: delta = pixResize.x / PMONITOR->m_size.x; break;
@ -777,7 +777,7 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
} }
const auto workspaceIdForResizing = PMONITOR->m_activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspaceID() : PMONITOR->activeWorkspaceID(); const auto workspaceIdForResizing = PMONITOR->m_activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspaceID() : PMONITOR->activeWorkspaceID();
for (auto& n : m_lMasterNodesData) { for (auto& n : m_masterNodesData) {
if (n.isMaster && n.workspaceID == workspaceIdForResizing) if (n.isMaster && n.workspaceID == workspaceIdForResizing)
n.percMaster = std::clamp(n.percMaster + delta, 0.05, 0.95); n.percMaster = std::clamp(n.percMaster + delta, 0.05, 0.95);
} }
@ -798,8 +798,8 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
if (!*PSMARTRESIZING) { if (!*PSMARTRESIZING) {
PNODE->percSize = std::clamp(PNODE->percSize + RESIZEDELTA / SIZE, 0.05, 1.95); PNODE->percSize = std::clamp(PNODE->percSize + RESIZEDELTA / SIZE, 0.05, 1.95);
} else { } else {
const auto NODEIT = std::find(m_lMasterNodesData.begin(), m_lMasterNodesData.end(), *PNODE); const auto NODEIT = std::find(m_masterNodesData.begin(), m_masterNodesData.end(), *PNODE);
const auto REVNODEIT = std::find(m_lMasterNodesData.rbegin(), m_lMasterNodesData.rend(), *PNODE); const auto REVNODEIT = std::find(m_masterNodesData.rbegin(), m_masterNodesData.rend(), *PNODE);
const float totalSize = isStackVertical ? WSSIZE.y : WSSIZE.x; const float totalSize = isStackVertical ? WSSIZE.y : WSSIZE.x;
const float minSize = totalSize / nodesInSameColumn * 0.2; const float minSize = totalSize / nodesInSameColumn * 0.2;
@ -820,10 +820,10 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
}; };
float resizeDiff; float resizeDiff;
if (resizePrevNodes) { if (resizePrevNodes) {
std::for_each(std::next(REVNODEIT), m_lMasterNodesData.rend(), checkNodesLeft); std::for_each(std::next(REVNODEIT), m_masterNodesData.rend(), checkNodesLeft);
resizeDiff = -RESIZEDELTA; resizeDiff = -RESIZEDELTA;
} else { } else {
std::for_each(std::next(NODEIT), m_lMasterNodesData.end(), checkNodesLeft); std::for_each(std::next(NODEIT), m_masterNodesData.end(), checkNodesLeft);
resizeDiff = RESIZEDELTA; resizeDiff = RESIZEDELTA;
} }
@ -849,16 +849,16 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
it.percSize -= resizeDeltaForEach / SIZE; it.percSize -= resizeDeltaForEach / SIZE;
}; };
if (resizePrevNodes) { if (resizePrevNodes) {
std::for_each(std::next(REVNODEIT), m_lMasterNodesData.rend(), resizeNodesLeft); std::for_each(std::next(REVNODEIT), m_masterNodesData.rend(), resizeNodesLeft);
} else { } else {
std::for_each(std::next(NODEIT), m_lMasterNodesData.end(), resizeNodesLeft); std::for_each(std::next(NODEIT), m_masterNodesData.end(), resizeNodesLeft);
} }
} }
} }
recalculateMonitor(PMONITOR->m_id); recalculateMonitor(PMONITOR->m_id);
m_bForceWarps = false; m_forceWarps = false;
} }
void CHyprMasterLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFullscreenMode CURRENT_EFFECTIVE_MODE, const eFullscreenMode EFFECTIVE_MODE) { void CHyprMasterLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFullscreenMode CURRENT_EFFECTIVE_MODE, const eFullscreenMode EFFECTIVE_MODE) {
@ -1018,7 +1018,7 @@ PHLWINDOW CHyprMasterLayout::getNextWindow(PHLWINDOW pWindow, bool next, bool lo
const auto PNODE = getNodeFromWindow(pWindow); const auto PNODE = getNodeFromWindow(pWindow);
auto nodes = m_lMasterNodesData; auto nodes = m_masterNodesData;
if (!next) if (!next)
std::reverse(nodes.begin(), nodes.end()); std::reverse(nodes.begin(), nodes.end());
@ -1101,7 +1101,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
const auto NEWFOCUS = newFocusToChild ? NEWCHILD : NEWMASTER; const auto NEWFOCUS = newFocusToChild ? NEWCHILD : NEWMASTER;
switchToWindow(NEWFOCUS); switchToWindow(NEWFOCUS);
} else { } else {
for (auto const& n : m_lMasterNodesData) { for (auto const& n : m_masterNodesData) {
if (n.workspaceID == PMASTER->workspaceID && !n.isMaster) { if (n.workspaceID == PMASTER->workspaceID && !n.isMaster) {
const auto NEWMASTER = n.pWindow.lock(); const auto NEWMASTER = n.pWindow.lock();
switchWindows(NEWMASTER, NEWCHILD); switchWindows(NEWMASTER, NEWCHILD);
@ -1136,7 +1136,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
return 0; return 0;
} else { } else {
// if master is focused keep master focused (don't do anything) // if master is focused keep master focused (don't do anything)
for (auto const& n : m_lMasterNodesData) { for (auto const& n : m_masterNodesData) {
if (n.workspaceID == PMASTER->workspaceID && !n.isMaster) { if (n.workspaceID == PMASTER->workspaceID && !n.isMaster) {
switchToWindow(n.pWindow.lock()); switchToWindow(n.pWindow.lock());
break; break;
@ -1217,7 +1217,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
if (!PNODE || PNODE->isMaster) { if (!PNODE || PNODE->isMaster) {
// first non-master node // first non-master node
for (auto& n : m_lMasterNodesData) { for (auto& n : m_masterNodesData) {
if (n.workspaceID == header.pWindow->workspaceID() && !n.isMaster) { if (n.workspaceID == header.pWindow->workspaceID() && !n.isMaster) {
n.isMaster = true; n.isMaster = true;
break; break;
@ -1249,7 +1249,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
if (!PNODE || !PNODE->isMaster) { if (!PNODE || !PNODE->isMaster) {
// first non-master node // first non-master node
for (auto& nd : m_lMasterNodesData | std::views::reverse) { for (auto& nd : m_masterNodesData | std::views::reverse) {
if (nd.workspaceID == header.pWindow->workspaceID() && nd.isMaster) { if (nd.workspaceID == header.pWindow->workspaceID() && nd.isMaster) {
nd.isMaster = false; nd.isMaster = false;
break; break;
@ -1302,16 +1302,16 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
if (!OLDMASTER) if (!OLDMASTER)
return 0; return 0;
const auto OLDMASTERIT = std::find(m_lMasterNodesData.begin(), m_lMasterNodesData.end(), *OLDMASTER); const auto OLDMASTERIT = std::find(m_masterNodesData.begin(), m_masterNodesData.end(), *OLDMASTER);
for (auto& nd : m_lMasterNodesData) { for (auto& nd : m_masterNodesData) {
if (nd.workspaceID == PNODE->workspaceID && !nd.isMaster) { if (nd.workspaceID == PNODE->workspaceID && !nd.isMaster) {
nd.isMaster = true; nd.isMaster = true;
const auto NEWMASTERIT = std::find(m_lMasterNodesData.begin(), m_lMasterNodesData.end(), nd); const auto NEWMASTERIT = std::find(m_masterNodesData.begin(), m_masterNodesData.end(), nd);
m_lMasterNodesData.splice(OLDMASTERIT, m_lMasterNodesData, NEWMASTERIT); m_masterNodesData.splice(OLDMASTERIT, m_masterNodesData, NEWMASTERIT);
switchToWindow(nd.pWindow.lock()); switchToWindow(nd.pWindow.lock());
OLDMASTER->isMaster = false; OLDMASTER->isMaster = false;
m_lMasterNodesData.splice(m_lMasterNodesData.end(), m_lMasterNodesData, OLDMASTERIT); m_masterNodesData.splice(m_masterNodesData.end(), m_masterNodesData, OLDMASTERIT);
break; break;
} }
} }
@ -1328,16 +1328,16 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
if (!OLDMASTER) if (!OLDMASTER)
return 0; return 0;
const auto OLDMASTERIT = std::find(m_lMasterNodesData.begin(), m_lMasterNodesData.end(), *OLDMASTER); const auto OLDMASTERIT = std::find(m_masterNodesData.begin(), m_masterNodesData.end(), *OLDMASTER);
for (auto& nd : m_lMasterNodesData | std::views::reverse) { for (auto& nd : m_masterNodesData | std::views::reverse) {
if (nd.workspaceID == PNODE->workspaceID && !nd.isMaster) { if (nd.workspaceID == PNODE->workspaceID && !nd.isMaster) {
nd.isMaster = true; nd.isMaster = true;
const auto NEWMASTERIT = std::find(m_lMasterNodesData.begin(), m_lMasterNodesData.end(), nd); const auto NEWMASTERIT = std::find(m_masterNodesData.begin(), m_masterNodesData.end(), nd);
m_lMasterNodesData.splice(OLDMASTERIT, m_lMasterNodesData, NEWMASTERIT); m_masterNodesData.splice(OLDMASTERIT, m_masterNodesData, NEWMASTERIT);
switchToWindow(nd.pWindow.lock()); switchToWindow(nd.pWindow.lock());
OLDMASTER->isMaster = false; OLDMASTER->isMaster = false;
m_lMasterNodesData.splice(m_lMasterNodesData.begin(), m_lMasterNodesData, OLDMASTERIT); m_masterNodesData.splice(m_masterNodesData.begin(), m_masterNodesData, OLDMASTERIT);
break; break;
} }
} }
@ -1477,5 +1477,5 @@ void CHyprMasterLayout::onEnable() {
} }
void CHyprMasterLayout::onDisable() { void CHyprMasterLayout::onDisable() {
m_lMasterNodesData.clear(); m_masterNodesData.clear();
} }

6
src/layout/MasterLayout.hpp
View File

@ -71,10 +71,10 @@ class CHyprMasterLayout : public IHyprLayout {
virtual void onDisable(); virtual void onDisable();
private: private:
std::list<SMasterNodeData> m_lMasterNodesData; std::list<SMasterNodeData> m_masterNodesData;
std::vector<SMasterWorkspaceData> m_lMasterWorkspacesData; std::vector<SMasterWorkspaceData> m_masterWorkspacesData;
bool m_bForceWarps = false; bool m_forceWarps = false;
void buildOrientationCycleVectorFromVars(std::vector<eOrientation>& cycle, CVarList& vars); void buildOrientationCycleVectorFromVars(std::vector<eOrientation>& cycle, CVarList& vars);
void buildOrientationCycleVectorFromEOperation(std::vector<eOrientation>& cycle); void buildOrientationCycleVectorFromEOperation(std::vector<eOrientation>& cycle);