mirrors/Hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/Hyprland.git synced 2025-09-14 23:38:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

helpers: refactor class member vars (#10218)

Browse Source
This commit is contained in:
davc0n
2025-04-30 23:45:20 +02:00
committed by GitHub
parent b8a204c21d
commit 50e1bec85f
63 changed files with 1770 additions and 1769 deletions
Download Patch File Download Diff File Expand all files Collapse all files

237
src/Compositor.cpp
View File

@@ -476,7 +476,7 @@ void CCompositor::initAllSignals() {
for (auto const& m : m_monitors) { for (auto const& m : m_monitors) {
scheduleFrameForMonitor(m); scheduleFrameForMonitor(m);
m->applyMonitorRule(&m->activeMonitorRule, true); m->applyMonitorRule(&m->m_activeMonitorRule, true);
} }
g_pConfigManager->m_wantsMonitorReload = true; g_pConfigManager->m_wantsMonitorReload = true;
@@ -558,8 +558,8 @@ void CCompositor::cleanup() {
for (auto const& m : m_monitors) { for (auto const& m : m_monitors) {
g_pHyprOpenGL->destroyMonitorResources(m); g_pHyprOpenGL->destroyMonitorResources(m);
m->output->state->setEnabled(false); m->m_output->state->setEnabled(false);
m->state.commit(); m->m_state.commit();
} }
g_pXWayland.reset(); g_pXWayland.reset();
@@ -783,7 +783,7 @@ void CCompositor::startCompositor() {
PHLMONITOR CCompositor::getMonitorFromID(const MONITORID& id) { PHLMONITOR CCompositor::getMonitorFromID(const MONITORID& id) {
for (auto const& m : m_monitors) { for (auto const& m : m_monitors) {
if (m->ID == id) { if (m->m_id == id) {
return m; return m;
} }
} }
@@ -793,7 +793,7 @@ PHLMONITOR CCompositor::getMonitorFromID(const MONITORID& id) {
PHLMONITOR CCompositor::getMonitorFromName(const std::string& name) { PHLMONITOR CCompositor::getMonitorFromName(const std::string& name) {
for (auto const& m : m_monitors) { for (auto const& m : m_monitors) {
if (m->szName == name) { if (m->m_name == name) {
return m; return m;
} }
} }
@@ -802,7 +802,7 @@ PHLMONITOR CCompositor::getMonitorFromName(const std::string& name) {
PHLMONITOR CCompositor::getMonitorFromDesc(const std::string& desc) { PHLMONITOR CCompositor::getMonitorFromDesc(const std::string& desc) {
for (auto const& m : m_monitors) { for (auto const& m : m_monitors) {
if (m->szDescription.starts_with(desc)) if (m->m_description.starts_with(desc))
return m; return m;
} }
return nullptr; return nullptr;
@@ -820,7 +820,7 @@ PHLMONITOR CCompositor::getMonitorFromVector(const Vector2D& point) {
PHLMONITOR mon; PHLMONITOR mon;
for (auto const& m : m_monitors) { for (auto const& m : m_monitors) {
if (CBox{m->vecPosition, m->vecSize}.containsPoint(point)) { if (CBox{m->m_position, m->m_size}.containsPoint(point)) {
mon = m; mon = m;
break; break;
} }
@@ -831,7 +831,7 @@ PHLMONITOR CCompositor::getMonitorFromVector(const Vector2D& point) {
PHLMONITOR pBestMon; PHLMONITOR pBestMon;
for (auto const& m : m_monitors) { for (auto const& m : m_monitors) {
float dist = vecToRectDistanceSquared(point, m->vecPosition, m->vecPosition + m->vecSize); float dist = vecToRectDistanceSquared(point, m->m_position, m->m_position + m->m_size);
if (dist < bestDistance || !pBestMon) { if (dist < bestDistance || !pBestMon) {
bestDistance = dist; bestDistance = dist;
@@ -901,11 +901,10 @@ PHLWINDOW CCompositor::vectorToWindowUnified(const Vector2D& pos, uint8_t proper
const auto PWINDOWMONITOR = w->m_monitor.lock(); const auto PWINDOWMONITOR = w->m_monitor.lock();
// to avoid focusing windows behind special workspaces from other monitors // to avoid focusing windows behind special workspaces from other monitors
if (!*PSPECIALFALLTHRU && PWINDOWMONITOR && PWINDOWMONITOR->activeSpecialWorkspace && w->m_workspace != PWINDOWMONITOR->activeSpecialWorkspace) { if (!*PSPECIALFALLTHRU && PWINDOWMONITOR && PWINDOWMONITOR->m_activeSpecialWorkspace && w->m_workspace != PWINDOWMONITOR->m_activeSpecialWorkspace) {
const auto BB = w->getWindowBoxUnified(properties); const auto BB = w->getWindowBoxUnified(properties);
if (BB.x >= PWINDOWMONITOR->vecPosition.x && BB.y >= PWINDOWMONITOR->vecPosition.y && if (BB.x >= PWINDOWMONITOR->m_position.x && BB.y >= PWINDOWMONITOR->m_position.y &&
BB.x + BB.width <= PWINDOWMONITOR->vecPosition.x + PWINDOWMONITOR->vecSize.x && BB.x + BB.width <= PWINDOWMONITOR->m_position.x + PWINDOWMONITOR->m_size.x && BB.y + BB.height <= PWINDOWMONITOR->m_position.y + PWINDOWMONITOR->m_size.y)
BB.y + BB.height <= PWINDOWMONITOR->vecPosition.y + PWINDOWMONITOR->vecSize.y)
continue; continue;
} }
@@ -992,10 +991,10 @@ PHLWINDOW CCompositor::vectorToWindowUnified(const Vector2D& pos, uint8_t proper
}; };
// special workspace // special workspace
if (PMONITOR->activeSpecialWorkspace && !*PSPECIALFALLTHRU) if (PMONITOR->m_activeSpecialWorkspace && !*PSPECIALFALLTHRU)
return windowForWorkspace(true); return windowForWorkspace(true);
if (PMONITOR->activeSpecialWorkspace) { if (PMONITOR->m_activeSpecialWorkspace) {
const auto PWINDOW = windowForWorkspace(true); const auto PWINDOW = windowForWorkspace(true);
if (PWINDOW) if (PWINDOW)
@@ -1061,7 +1060,7 @@ Vector2D CCompositor::vectorToSurfaceLocal(const Vector2D& vec, PHLWINDOW pWindo
PHLMONITOR CCompositor::getMonitorFromOutput(SP<Aquamarine::IOutput> out) { PHLMONITOR CCompositor::getMonitorFromOutput(SP<Aquamarine::IOutput> out) {
for (auto const& m : m_monitors) { for (auto const& m : m_monitors) {
if (m->output == out) { if (m->m_output == out) {
return m; return m;
} }
} }
@@ -1071,7 +1070,7 @@ PHLMONITOR CCompositor::getMonitorFromOutput(SP<Aquamarine::IOutput> out) {
PHLMONITOR CCompositor::getRealMonitorFromOutput(SP<Aquamarine::IOutput> out) { PHLMONITOR CCompositor::getRealMonitorFromOutput(SP<Aquamarine::IOutput> out) {
for (auto const& m : m_realMonitors) { for (auto const& m : m_realMonitors) {
if (m->output == out) { if (m->m_output == out) {
return m; return m;
} }
} }
@@ -1137,7 +1136,7 @@ void CCompositor::focusWindow(PHLWINDOW pWindow, SP<CWLSurfaceResource> pSurface
return; return;
if (pWindow->m_pinned) if (pWindow->m_pinned)
pWindow->m_workspace = m_lastMonitor->activeWorkspace; pWindow->m_workspace = m_lastMonitor->m_activeWorkspace;
const auto PMONITOR = pWindow->m_monitor.lock(); const auto PMONITOR = pWindow->m_monitor.lock();
@@ -1145,8 +1144,8 @@ void CCompositor::focusWindow(PHLWINDOW pWindow, SP<CWLSurfaceResource> pSurface
const auto PWORKSPACE = pWindow->m_workspace; const auto PWORKSPACE = pWindow->m_workspace;
// This is to fix incorrect feedback on the focus history. // This is to fix incorrect feedback on the focus history.
PWORKSPACE->m_lastFocusedWindow = pWindow; PWORKSPACE->m_lastFocusedWindow = pWindow;
if (m_lastMonitor->activeWorkspace) if (m_lastMonitor->m_activeWorkspace)
PWORKSPACE->rememberPrevWorkspace(m_lastMonitor->activeWorkspace); PWORKSPACE->rememberPrevWorkspace(m_lastMonitor->m_activeWorkspace);
if (PWORKSPACE->m_isSpecialWorkspace) if (PWORKSPACE->m_isSpecialWorkspace)
m_lastMonitor->changeWorkspace(PWORKSPACE, false, true); // if special ws, open on current monitor m_lastMonitor->changeWorkspace(PWORKSPACE, false, true); // if special ws, open on current monitor
else if (PMONITOR) else if (PMONITOR)
@@ -1160,7 +1159,7 @@ void CCompositor::focusWindow(PHLWINDOW pWindow, SP<CWLSurfaceResource> pSurface
/* If special fallthrough is enabled, this behavior will be disabled, as I have no better idea of nicely tracking which /* If special fallthrough is enabled, this behavior will be disabled, as I have no better idea of nicely tracking which
window focuses are "via keybinds" and which ones aren't. */ window focuses are "via keybinds" and which ones aren't. */
if (PMONITOR && PMONITOR->activeSpecialWorkspace && PMONITOR->activeSpecialWorkspace != pWindow->m_workspace && !pWindow->m_pinned && !*PSPECIALFALLTHROUGH) if (PMONITOR && PMONITOR->m_activeSpecialWorkspace && PMONITOR->m_activeSpecialWorkspace != pWindow->m_workspace && !pWindow->m_pinned && !*PSPECIALFALLTHROUGH)
PMONITOR->setSpecialWorkspace(nullptr); PMONITOR->setSpecialWorkspace(nullptr);
// we need to make the PLASTWINDOW not equal to m_pLastWindow so that RENDERDATA is correct for an unfocused window // we need to make the PLASTWINDOW not equal to m_pLastWindow so that RENDERDATA is correct for an unfocused window
@@ -1267,7 +1266,7 @@ void CCompositor::focusSurface(SP<CWLSurfaceResource> pSurface, PHLWINDOW pWindo
} }
SP<CWLSurfaceResource> CCompositor::vectorToLayerPopupSurface(const Vector2D& pos, PHLMONITOR monitor, Vector2D* sCoords, PHLLS* ppLayerSurfaceFound) { SP<CWLSurfaceResource> CCompositor::vectorToLayerPopupSurface(const Vector2D& pos, PHLMONITOR monitor, Vector2D* sCoords, PHLLS* ppLayerSurfaceFound) {
for (auto const& lsl : monitor->m_aLayerSurfaceLayers | std::views::reverse) { for (auto const& lsl : monitor->m_layerSurfaceLayers | std::views::reverse) {
for (auto const& ls : lsl | std::views::reverse) { for (auto const& ls : lsl | std::views::reverse) {
if (!ls->m_mapped || ls->m_fadingOut || !ls->m_layerSurface || (ls->m_layerSurface && !ls->m_layerSurface->mapped) || ls->m_alpha->value() == 0.f) if (!ls->m_mapped || ls->m_fadingOut || !ls->m_layerSurface || (ls->m_layerSurface && !ls->m_layerSurface->mapped) || ls->m_alpha->value() == 0.f)
continue; continue;
@@ -1474,7 +1473,7 @@ void CCompositor::cleanupFadingOut(const MONITORID& monid) {
if (ls->m_fadingOut && ls->m_readyToDelete && ls->isFadedOut()) { if (ls->m_fadingOut && ls->m_readyToDelete && ls->isFadedOut()) {
for (auto const& m : m_monitors) { for (auto const& m : m_monitors) {
for (auto& lsl : m->m_aLayerSurfaceLayers) { for (auto& lsl : m->m_layerSurfaceLayers) {
if (!lsl.empty() && std::ranges::find_if(lsl, [&](auto& other) { return other == ls; }) != lsl.end()) { if (!lsl.empty() && std::ranges::find_if(lsl, [&](auto& other) { return other == ls; }) != lsl.end()) {
std::erase_if(lsl, [&](auto& other) { return other == ls || !other; }); std::erase_if(lsl, [&](auto& other) { return other == ls || !other; });
} }
@@ -1528,7 +1527,7 @@ PHLWINDOW CCompositor::getWindowInDirection(PHLWINDOW pWindow, char dir) {
if (!PMONITOR) if (!PMONITOR)
return nullptr; // ?? return nullptr; // ??
const auto WINDOWIDEALBB = pWindow->isFullscreen() ? CBox{PMONITOR->vecPosition, PMONITOR->vecSize} : pWindow->getWindowIdealBoundingBoxIgnoreReserved(); const auto WINDOWIDEALBB = pWindow->isFullscreen() ? CBox{PMONITOR->m_position, PMONITOR->m_size} : pWindow->getWindowIdealBoundingBoxIgnoreReserved();
const auto PWORKSPACE = pWindow->m_workspace; const auto PWORKSPACE = pWindow->m_workspace;
return getWindowInDirection(WINDOWIDEALBB, PWORKSPACE, dir, pWindow, pWindow->m_isFloating); return getWindowInDirection(WINDOWIDEALBB, PWORKSPACE, dir, pWindow, pWindow->m_isFloating);
@@ -1754,14 +1753,14 @@ PHLWORKSPACE CCompositor::getWorkspaceByString(const std::string& str) {
bool CCompositor::isPointOnAnyMonitor(const Vector2D& point) { bool CCompositor::isPointOnAnyMonitor(const Vector2D& point) {
return std::ranges::any_of( return std::ranges::any_of(
m_monitors, [&](const PHLMONITOR& m) { return VECINRECT(point, m->vecPosition.x, m->vecPosition.y, m->vecSize.x + m->vecPosition.x, m->vecSize.y + m->vecPosition.y); }); m_monitors, [&](const PHLMONITOR& m) { return VECINRECT(point, m->m_position.x, m->m_position.y, m->m_size.x + m->m_position.x, m->m_size.y + m->m_position.y); });
} }
bool CCompositor::isPointOnReservedArea(const Vector2D& point, const PHLMONITOR pMonitor) { bool CCompositor::isPointOnReservedArea(const Vector2D& point, const PHLMONITOR pMonitor) {
const auto PMONITOR = pMonitor ? pMonitor : getMonitorFromVector(point); const auto PMONITOR = pMonitor ? pMonitor : getMonitorFromVector(point);
const auto XY1 = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft; const auto XY1 = PMONITOR->m_position + PMONITOR->m_reservedTopLeft;
const auto XY2 = PMONITOR->vecPosition + PMONITOR->vecSize - PMONITOR->vecReservedBottomRight; const auto XY2 = PMONITOR->m_position + PMONITOR->m_size - PMONITOR->m_reservedBottomRight;
return VECNOTINRECT(point, XY1.x, XY1.y, XY2.x, XY2.y); return VECNOTINRECT(point, XY1.x, XY1.y, XY2.x, XY2.y);
} }
@@ -1774,8 +1773,8 @@ PHLMONITOR CCompositor::getMonitorInDirection(PHLMONITOR pSourceMonitor, const c
if (!pSourceMonitor) if (!pSourceMonitor)
return nullptr; return nullptr;
const auto POSA = pSourceMonitor->vecPosition; const auto POSA = pSourceMonitor->m_position;
const auto SIZEA = pSourceMonitor->vecSize; const auto SIZEA = pSourceMonitor->m_size;
auto longestIntersect = -1; auto longestIntersect = -1;
PHLMONITOR longestIntersectMonitor = nullptr; PHLMONITOR longestIntersectMonitor = nullptr;
@@ -1784,8 +1783,8 @@ PHLMONITOR CCompositor::getMonitorInDirection(PHLMONITOR pSourceMonitor, const c
if (m == pSourceMonitor) if (m == pSourceMonitor)
continue; continue;
const auto POSB = m->vecPosition; const auto POSB = m->m_position;
const auto SIZEB = m->vecSize; const auto SIZEB = m->m_size;
switch (dir) { switch (dir) {
case 'l': case 'l':
if (STICKS(POSA.x, POSB.x + SIZEB.x)) { if (STICKS(POSA.x, POSB.x + SIZEB.x)) {
@@ -1937,13 +1936,13 @@ void CCompositor::updateWindowAnimatedDecorationValues(PHLWINDOW pWindow) {
MONITORID CCompositor::getNextAvailableMonitorID(std::string const& name) { MONITORID CCompositor::getNextAvailableMonitorID(std::string const& name) {
// reuse ID if it's already in the map, and the monitor with that ID is not being used by another monitor // reuse ID if it's already in the map, and the monitor with that ID is not being used by another monitor
if (m_monitorIDMap.contains(name) && !std::ranges::any_of(m_realMonitors, [&](auto m) { return m->ID == m_monitorIDMap[name]; })) if (m_monitorIDMap.contains(name) && !std::ranges::any_of(m_realMonitors, [&](auto m) { return m->m_id == m_monitorIDMap[name]; }))
return m_monitorIDMap[name]; return m_monitorIDMap[name];
// otherwise, find minimum available ID that is not in the map // otherwise, find minimum available ID that is not in the map
std::unordered_set<MONITORID> usedIDs; std::unordered_set<MONITORID> usedIDs;
for (auto const& monitor : m_realMonitors) { for (auto const& monitor : m_realMonitors) {
usedIDs.insert(monitor->ID); usedIDs.insert(monitor->m_id);
} }
MONITORID nextID = 0; MONITORID nextID = 0;
@@ -1955,11 +1954,11 @@ MONITORID CCompositor::getNextAvailableMonitorID(std::string const& name) {
} }
void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitorB) { void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitorB) {
const auto PWORKSPACEA = pMonitorA->activeWorkspace; const auto PWORKSPACEA = pMonitorA->m_activeWorkspace;
const auto PWORKSPACEB = pMonitorB->activeWorkspace; const auto PWORKSPACEB = pMonitorB->m_activeWorkspace;
PWORKSPACEA->m_monitor = pMonitorB; PWORKSPACEA->m_monitor = pMonitorB;
PWORKSPACEA->moveToMonitor(pMonitorB->ID); PWORKSPACEA->moveToMonitor(pMonitorB->m_id);
for (auto const& w : m_windows) { for (auto const& w : m_windows) {
if (w->m_workspace == PWORKSPACEA) { if (w->m_workspace == PWORKSPACEA) {
@@ -1972,11 +1971,11 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor
// additionally, move floating and fs windows manually // additionally, move floating and fs windows manually
if (w->m_isFloating) if (w->m_isFloating)
*w->m_realPosition = w->m_realPosition->goal() - pMonitorA->vecPosition + pMonitorB->vecPosition; *w->m_realPosition = w->m_realPosition->goal() - pMonitorA->m_position + pMonitorB->m_position;
if (w->isFullscreen()) { if (w->isFullscreen()) {
*w->m_realPosition = pMonitorB->vecPosition; *w->m_realPosition = pMonitorB->m_position;
*w->m_realSize = pMonitorB->vecSize; *w->m_realSize = pMonitorB->m_size;
} }
w->updateToplevel(); w->updateToplevel();
@@ -1984,7 +1983,7 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor
} }
PWORKSPACEB->m_monitor = pMonitorA; PWORKSPACEB->m_monitor = pMonitorA;
PWORKSPACEB->moveToMonitor(pMonitorA->ID); PWORKSPACEB->moveToMonitor(pMonitorA->m_id);
for (auto const& w : m_windows) { for (auto const& w : m_windows) {
if (w->m_workspace == PWORKSPACEB) { if (w->m_workspace == PWORKSPACEB) {
@@ -1997,46 +1996,46 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor
// additionally, move floating and fs windows manually // additionally, move floating and fs windows manually
if (w->m_isFloating) if (w->m_isFloating)
*w->m_realPosition = w->m_realPosition->goal() - pMonitorB->vecPosition + pMonitorA->vecPosition; *w->m_realPosition = w->m_realPosition->goal() - pMonitorB->m_position + pMonitorA->m_position;
if (w->isFullscreen()) { if (w->isFullscreen()) {
*w->m_realPosition = pMonitorA->vecPosition; *w->m_realPosition = pMonitorA->m_position;
*w->m_realSize = pMonitorA->vecSize; *w->m_realSize = pMonitorA->m_size;
} }
w->updateToplevel(); w->updateToplevel();
} }
} }
pMonitorA->activeWorkspace = PWORKSPACEB; pMonitorA->m_activeWorkspace = PWORKSPACEB;
pMonitorB->activeWorkspace = PWORKSPACEA; pMonitorB->m_activeWorkspace = PWORKSPACEA;
PWORKSPACEA->rememberPrevWorkspace(PWORKSPACEB); PWORKSPACEA->rememberPrevWorkspace(PWORKSPACEB);
PWORKSPACEB->rememberPrevWorkspace(PWORKSPACEA); PWORKSPACEB->rememberPrevWorkspace(PWORKSPACEA);
g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitorA->ID); g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitorA->m_id);
g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitorB->ID); g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitorB->m_id);
updateFullscreenFadeOnWorkspace(PWORKSPACEB); updateFullscreenFadeOnWorkspace(PWORKSPACEB);
updateFullscreenFadeOnWorkspace(PWORKSPACEA); updateFullscreenFadeOnWorkspace(PWORKSPACEA);
if (pMonitorA->ID == g_pCompositor->m_lastMonitor->ID || pMonitorB->ID == g_pCompositor->m_lastMonitor->ID) { if (pMonitorA->m_id == g_pCompositor->m_lastMonitor->m_id || pMonitorB->m_id == g_pCompositor->m_lastMonitor->m_id) {
const auto LASTWIN = pMonitorA->ID == g_pCompositor->m_lastMonitor->ID ? PWORKSPACEB->getLastFocusedWindow() : PWORKSPACEA->getLastFocusedWindow(); const auto LASTWIN = pMonitorA->m_id == g_pCompositor->m_lastMonitor->m_id ? PWORKSPACEB->getLastFocusedWindow() : PWORKSPACEA->getLastFocusedWindow();
g_pCompositor->focusWindow(LASTWIN ? LASTWIN : g_pCompositor->focusWindow(LASTWIN ? LASTWIN :
(g_pCompositor->vectorToWindowUnified(g_pInputManager->getMouseCoordsInternal(), RESERVED_EXTENTS | INPUT_EXTENTS | ALLOW_FLOATING))); (g_pCompositor->vectorToWindowUnified(g_pInputManager->getMouseCoordsInternal(), RESERVED_EXTENTS | INPUT_EXTENTS | ALLOW_FLOATING)));
const auto PNEWWORKSPACE = pMonitorA->ID == g_pCompositor->m_lastMonitor->ID ? PWORKSPACEB : PWORKSPACEA; const auto PNEWWORKSPACE = pMonitorA->m_id == g_pCompositor->m_lastMonitor->m_id ? PWORKSPACEB : PWORKSPACEA;
g_pEventManager->postEvent(SHyprIPCEvent{.event = "workspace", .data = PNEWWORKSPACE->m_name}); g_pEventManager->postEvent(SHyprIPCEvent{.event = "workspace", .data = PNEWWORKSPACE->m_name});
g_pEventManager->postEvent(SHyprIPCEvent{.event = "workspacev2", .data = std::format("{},{}", PNEWWORKSPACE->m_id, PNEWWORKSPACE->m_name)}); g_pEventManager->postEvent(SHyprIPCEvent{.event = "workspacev2", .data = std::format("{},{}", PNEWWORKSPACE->m_id, PNEWWORKSPACE->m_name)});
EMIT_HOOK_EVENT("workspace", PNEWWORKSPACE); EMIT_HOOK_EVENT("workspace", PNEWWORKSPACE);
} }
// event // event
g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = PWORKSPACEA->m_name + "," + pMonitorB->szName}); g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = PWORKSPACEA->m_name + "," + pMonitorB->m_name});
g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", PWORKSPACEA->m_id, PWORKSPACEA->m_name, pMonitorB->szName)}); g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", PWORKSPACEA->m_id, PWORKSPACEA->m_name, pMonitorB->m_name)});
EMIT_HOOK_EVENT("moveWorkspace", (std::vector<std::any>{PWORKSPACEA, pMonitorB})); EMIT_HOOK_EVENT("moveWorkspace", (std::vector<std::any>{PWORKSPACEA, pMonitorB}));
g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = PWORKSPACEB->m_name + "," + pMonitorA->szName}); g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = PWORKSPACEB->m_name + "," + pMonitorA->m_name});
g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", PWORKSPACEB->m_id, PWORKSPACEB->m_name, pMonitorA->szName)}); g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", PWORKSPACEB->m_id, PWORKSPACEB->m_name, pMonitorA->m_name)});
EMIT_HOOK_EVENT("moveWorkspace", (std::vector<std::any>{PWORKSPACEB, pMonitorA})); EMIT_HOOK_EVENT("moveWorkspace", (std::vector<std::any>{PWORKSPACEB, pMonitorA}));
} }
@@ -2103,7 +2102,7 @@ PHLMONITOR CCompositor::getMonitorFromString(const std::string& name) {
} }
} else { } else {
for (auto const& m : m_monitors) { for (auto const& m : m_monitors) {
if (!m->output) if (!m->m_output)
continue; continue;
if (m->matchesStaticSelector(name)) { if (m->matchesStaticSelector(name)) {
@@ -2124,11 +2123,11 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
if (pWorkspace->m_monitor == pMonitor) if (pWorkspace->m_monitor == pMonitor)
return; return;
Debug::log(LOG, "moveWorkspaceToMonitor: Moving {} to monitor {}", pWorkspace->m_id, pMonitor->ID); Debug::log(LOG, "moveWorkspaceToMonitor: Moving {} to monitor {}", pWorkspace->m_id, pMonitor->m_id);
const auto POLDMON = pWorkspace->m_monitor.lock(); const auto POLDMON = pWorkspace->m_monitor.lock();
const bool SWITCHINGISACTIVE = POLDMON ? POLDMON->activeWorkspace == pWorkspace : false; const bool SWITCHINGISACTIVE = POLDMON ? POLDMON->m_activeWorkspace == pWorkspace : false;
// fix old mon // fix old mon
WORKSPACEID nextWorkspaceOnMonitorID = WORKSPACE_INVALID; WORKSPACEID nextWorkspaceOnMonitorID = WORKSPACE_INVALID;
@@ -2154,7 +2153,7 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
Debug::log(LOG, "moveWorkspaceToMonitor: Plugging gap with new {}", nextWorkspaceOnMonitorID); Debug::log(LOG, "moveWorkspaceToMonitor: Plugging gap with new {}", nextWorkspaceOnMonitorID);
if (POLDMON) if (POLDMON)
g_pCompositor->createNewWorkspace(nextWorkspaceOnMonitorID, POLDMON->ID); g_pCompositor->createNewWorkspace(nextWorkspaceOnMonitorID, POLDMON->m_id);
} }
Debug::log(LOG, "moveWorkspaceToMonitor: Plugging gap with existing {}", nextWorkspaceOnMonitorID); Debug::log(LOG, "moveWorkspaceToMonitor: Plugging gap with existing {}", nextWorkspaceOnMonitorID);
@@ -2164,7 +2163,7 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
// move the workspace // move the workspace
pWorkspace->m_monitor = pMonitor; pWorkspace->m_monitor = pMonitor;
pWorkspace->moveToMonitor(pMonitor->ID); pWorkspace->moveToMonitor(pMonitor->m_id);
for (auto const& w : m_windows) { for (auto const& w : m_windows) {
if (w->m_workspace == pWorkspace) { if (w->m_workspace == pWorkspace) {
@@ -2179,16 +2178,16 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
if (w->m_isMapped && !w->isHidden()) { if (w->m_isMapped && !w->isHidden()) {
if (POLDMON) { if (POLDMON) {
if (w->m_isFloating) if (w->m_isFloating)
*w->m_realPosition = w->m_realPosition->goal() - POLDMON->vecPosition + pMonitor->vecPosition; *w->m_realPosition = w->m_realPosition->goal() - POLDMON->m_position + pMonitor->m_position;
if (w->isFullscreen()) { if (w->isFullscreen()) {
*w->m_realPosition = pMonitor->vecPosition; *w->m_realPosition = pMonitor->m_position;
*w->m_realSize = pMonitor->vecSize; *w->m_realSize = pMonitor->m_size;
} }
} else } else
*w->m_realPosition = Vector2D{ *w->m_realPosition = Vector2D{
(pMonitor->vecSize.x != 0) ? (int)w->m_realPosition->goal().x % (int)pMonitor->vecSize.x : 0, (pMonitor->m_size.x != 0) ? (int)w->m_realPosition->goal().x % (int)pMonitor->m_size.x : 0,
(pMonitor->vecSize.y != 0) ? (int)w->m_realPosition->goal().y % (int)pMonitor->vecSize.y : 0, (pMonitor->m_size.y != 0) ? (int)w->m_realPosition->goal().y % (int)pMonitor->m_size.y : 0,
}; };
} }
@@ -2199,32 +2198,32 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
if (SWITCHINGISACTIVE && POLDMON == g_pCompositor->m_lastMonitor) { // if it was active, preserve its' status. If it wasn't, don't. if (SWITCHINGISACTIVE && POLDMON == g_pCompositor->m_lastMonitor) { // if it was active, preserve its' status. If it wasn't, don't.
Debug::log(LOG, "moveWorkspaceToMonitor: SWITCHINGISACTIVE, active {} -> {}", pMonitor->activeWorkspaceID(), pWorkspace->m_id); Debug::log(LOG, "moveWorkspaceToMonitor: SWITCHINGISACTIVE, active {} -> {}", pMonitor->activeWorkspaceID(), pWorkspace->m_id);
if (valid(pMonitor->activeWorkspace)) { if (valid(pMonitor->m_activeWorkspace)) {
pMonitor->activeWorkspace->m_visible = false; pMonitor->m_activeWorkspace->m_visible = false;
pMonitor->activeWorkspace->startAnim(false, false); pMonitor->m_activeWorkspace->startAnim(false, false);
} }
if (*PHIDESPECIALONWORKSPACECHANGE) if (*PHIDESPECIALONWORKSPACECHANGE)
pMonitor->setSpecialWorkspace(nullptr); pMonitor->setSpecialWorkspace(nullptr);
setActiveMonitor(pMonitor); setActiveMonitor(pMonitor);
pMonitor->activeWorkspace = pWorkspace; pMonitor->m_activeWorkspace = pWorkspace;
g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitor->ID); g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitor->m_id);
pWorkspace->startAnim(true, true, true); pWorkspace->startAnim(true, true, true);
pWorkspace->m_visible = true; pWorkspace->m_visible = true;
if (!noWarpCursor) if (!noWarpCursor)
g_pPointerManager->warpTo(pMonitor->vecPosition + pMonitor->vecTransformedSize / 2.F); g_pPointerManager->warpTo(pMonitor->m_position + pMonitor->m_transformedSize / 2.F);
g_pInputManager->sendMotionEventsToFocused(); g_pInputManager->sendMotionEventsToFocused();
} }
// finalize // finalize
if (POLDMON) { if (POLDMON) {
g_pLayoutManager->getCurrentLayout()->recalculateMonitor(POLDMON->ID); g_pLayoutManager->getCurrentLayout()->recalculateMonitor(POLDMON->m_id);
if (valid(POLDMON->activeWorkspace)) if (valid(POLDMON->m_activeWorkspace))
updateFullscreenFadeOnWorkspace(POLDMON->activeWorkspace); updateFullscreenFadeOnWorkspace(POLDMON->m_activeWorkspace);
updateSuspendedStates(); updateSuspendedStates();
} }
@@ -2232,8 +2231,8 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
updateSuspendedStates(); updateSuspendedStates();
// event // event
g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = pWorkspace->m_name + "," + pMonitor->szName}); g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = pWorkspace->m_name + "," + pMonitor->m_name});
g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", pWorkspace->m_id, pWorkspace->m_name, pMonitor->szName)}); g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", pWorkspace->m_id, pWorkspace->m_name, pMonitor->m_name)});
EMIT_HOOK_EVENT("moveWorkspace", (std::vector<std::any>{pWorkspace, pMonitor})); EMIT_HOOK_EVENT("moveWorkspace", (std::vector<std::any>{pWorkspace, pMonitor}));
} }
@@ -2274,7 +2273,7 @@ void CCompositor::updateFullscreenFadeOnWorkspace(PHLWORKSPACE pWorkspace) {
const auto PMONITOR = pWorkspace->m_monitor.lock(); const auto PMONITOR = pWorkspace->m_monitor.lock();
if (pWorkspace->m_id == PMONITOR->activeWorkspaceID() || pWorkspace->m_id == PMONITOR->activeSpecialWorkspaceID()) { if (pWorkspace->m_id == PMONITOR->activeWorkspaceID() || pWorkspace->m_id == PMONITOR->activeSpecialWorkspaceID()) {
for (auto const& ls : PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) { for (auto const& ls : PMONITOR->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
if (!ls->m_fadingOut) if (!ls->m_fadingOut)
*ls->m_alpha = FULLSCREEN && pWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN ? 0.f : 1.f; *ls->m_alpha = FULLSCREEN && pWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN ? 0.f : 1.f;
} }
@@ -2382,7 +2381,7 @@ void CCompositor::setWindowFullscreenState(const PHLWINDOW PWINDOW, SFullscreenS
// send a scanout tranche if we are entering fullscreen, and send a regular one if we aren't. // send a scanout tranche if we are entering fullscreen, and send a regular one if we aren't.
// ignore if DS is disabled. // ignore if DS is disabled.
if (*PDIRECTSCANOUT == 1 || (*PDIRECTSCANOUT == 2 && PWINDOW->getContentType() == CONTENT_TYPE_GAME)) if (*PDIRECTSCANOUT == 1 || (*PDIRECTSCANOUT == 2 && PWINDOW->getContentType() == CONTENT_TYPE_GAME))
g_pHyprRenderer->setSurfaceScanoutMode(PWINDOW->m_wlSurface->resource(), EFFECTIVE_MODE != FSMODE_NONE ? PMONITOR->self.lock() : nullptr); g_pHyprRenderer->setSurfaceScanoutMode(PWINDOW->m_wlSurface->resource(), EFFECTIVE_MODE != FSMODE_NONE ? PMONITOR->m_self.lock() : nullptr);
g_pConfigManager->ensureVRR(PMONITOR); g_pConfigManager->ensureVRR(PMONITOR);
} }
@@ -2406,13 +2405,13 @@ void CCompositor::scheduleFrameForMonitor(PHLMONITOR pMonitor, IOutput::schedule
if ((m_aqBackend->hasSession() && !m_aqBackend->session->active) || !m_sessionActive) if ((m_aqBackend->hasSession() && !m_aqBackend->session->active) || !m_sessionActive)
return; return;
if (!pMonitor->m_bEnabled) if (!pMonitor->m_enabled)
return; return;
if (pMonitor->renderingActive) if (pMonitor->m_renderingActive)
pMonitor->pendingFrame = true; pMonitor->m_pendingFrame = true;
pMonitor->output->scheduleFrame(reason); pMonitor->m_output->scheduleFrame(reason);
} }
PHLWINDOW CCompositor::getWindowByRegex(const std::string& regexp_) { PHLWINDOW CCompositor::getWindowByRegex(const std::string& regexp_) {
@@ -2617,8 +2616,8 @@ Vector2D CCompositor::parseWindowVectorArgsRelative(const std::string& args, con
int Y = 0; int Y = 0;
if (isExact) { if (isExact) {
X = xIsPercent ? std::stof(x) * 0.01 * PMONITOR->vecSize.x : std::stoi(x); X = xIsPercent ? std::stof(x) * 0.01 * PMONITOR->m_size.x : std::stoi(x);
Y = yIsPercent ? std::stof(y) * 0.01 * PMONITOR->vecSize.y : std::stoi(y); Y = yIsPercent ? std::stof(y) * 0.01 * PMONITOR->m_size.y : std::stoi(y);
} else { } else {
X = xIsPercent ? (std::stof(x) * 0.01 * relativeTo.x) + relativeTo.x : std::stoi(x) + relativeTo.x; X = xIsPercent ? (std::stof(x) * 0.01 * relativeTo.x) + relativeTo.x : std::stoi(x) + relativeTo.x;
Y = yIsPercent ? (std::stof(y) * 0.01 * relativeTo.y) + relativeTo.y : std::stoi(y) + relativeTo.y; Y = yIsPercent ? (std::stof(y) * 0.01 * relativeTo.y) + relativeTo.y : std::stoi(y) + relativeTo.y;
@@ -2633,7 +2632,7 @@ PHLWORKSPACE CCompositor::createNewWorkspace(const WORKSPACEID& id, const MONITO
// check if bound // check if bound
if (const auto PMONITOR = g_pConfigManager->getBoundMonitorForWS(NAME); PMONITOR) if (const auto PMONITOR = g_pConfigManager->getBoundMonitorForWS(NAME); PMONITOR)
monID = PMONITOR->ID; monID = PMONITOR->m_id;
const bool SPECIAL = id >= SPECIAL_WORKSPACE_START && id <= -2; const bool SPECIAL = id >= SPECIAL_WORKSPACE_START && id <= -2;
@@ -2659,16 +2658,16 @@ void CCompositor::setActiveMonitor(PHLMONITOR pMonitor) {
return; return;
} }
const auto PWORKSPACE = pMonitor->activeWorkspace; const auto PWORKSPACE = pMonitor->m_activeWorkspace;
const auto WORKSPACE_ID = PWORKSPACE ? std::to_string(PWORKSPACE->m_id) : std::to_string(WORKSPACE_INVALID); const auto WORKSPACE_ID = PWORKSPACE ? std::to_string(PWORKSPACE->m_id) : std::to_string(WORKSPACE_INVALID);
const auto WORKSPACE_NAME = PWORKSPACE ? PWORKSPACE->m_name : "?"; const auto WORKSPACE_NAME = PWORKSPACE ? PWORKSPACE->m_name : "?";
g_pEventManager->postEvent(SHyprIPCEvent{.event = "focusedmon", .data = pMonitor->szName + "," + WORKSPACE_NAME}); g_pEventManager->postEvent(SHyprIPCEvent{.event = "focusedmon", .data = pMonitor->m_name + "," + WORKSPACE_NAME});
g_pEventManager->postEvent(SHyprIPCEvent{.event = "focusedmonv2", .data = pMonitor->szName + "," + WORKSPACE_ID}); g_pEventManager->postEvent(SHyprIPCEvent{.event = "focusedmonv2", .data = pMonitor->m_name + "," + WORKSPACE_ID});
EMIT_HOOK_EVENT("focusedMon", pMonitor); EMIT_HOOK_EVENT("focusedMon", pMonitor);
m_lastMonitor = pMonitor->self; m_lastMonitor = pMonitor->m_self;
} }
bool CCompositor::isWorkspaceSpecial(const WORKSPACEID& id) { bool CCompositor::isWorkspaceSpecial(const WORKSPACEID& id) {
@@ -2733,7 +2732,7 @@ void CCompositor::moveWindowToWorkspaceSafe(PHLWINDOW pWindow, PHLWORKSPACE pWor
const PHLWINDOW pFirstWindowOnWorkspace = pWorkspace->getFirstWindow(); const PHLWINDOW pFirstWindowOnWorkspace = pWorkspace->getFirstWindow();
const int visibleWindowsOnWorkspace = pWorkspace->getWindows(std::nullopt, true); const int visibleWindowsOnWorkspace = pWorkspace->getWindows(std::nullopt, true);
const auto POSTOMON = pWindow->m_realPosition->goal() - (pWindow->m_monitor ? pWindow->m_monitor->vecPosition : Vector2D{}); const auto POSTOMON = pWindow->m_realPosition->goal() - (pWindow->m_monitor ? pWindow->m_monitor->m_position : Vector2D{});
const auto PWORKSPACEMONITOR = pWorkspace->m_monitor.lock(); const auto PWORKSPACEMONITOR = pWorkspace->m_monitor.lock();
if (!pWindow->m_isFloating) if (!pWindow->m_isFloating)
@@ -2770,7 +2769,7 @@ void CCompositor::moveWindowToWorkspaceSafe(PHLWINDOW pWindow, PHLWORKSPACE pWor
g_pLayoutManager->getCurrentLayout()->onWindowCreatedTiling(pWindow); g_pLayoutManager->getCurrentLayout()->onWindowCreatedTiling(pWindow);
if (pWindow->m_isFloating) if (pWindow->m_isFloating)
*pWindow->m_realPosition = POSTOMON + PWORKSPACEMONITOR->vecPosition; *pWindow->m_realPosition = POSTOMON + PWORKSPACEMONITOR->m_position;
} }
pWindow->updateToplevel(); pWindow->updateToplevel();
@@ -2826,11 +2825,11 @@ void CCompositor::arrangeMonitors() {
for (auto it = toArrange.begin(); it != toArrange.end();) { for (auto it = toArrange.begin(); it != toArrange.end();) {
auto m = *it; auto m = *it;
if (m->activeMonitorRule.offset != Vector2D{-INT32_MAX, -INT32_MAX}) { if (m->m_activeMonitorRule.offset != Vector2D{-INT32_MAX, -INT32_MAX}) {
// explicit. // explicit.
Debug::log(LOG, "arrangeMonitors: {} explicit {:j}", m->szName, m->activeMonitorRule.offset); Debug::log(LOG, "arrangeMonitors: {} explicit {:j}", m->m_name, m->m_activeMonitorRule.offset);
m->moveTo(m->activeMonitorRule.offset); m->moveTo(m->m_activeMonitorRule.offset);
arranged.push_back(m); arranged.push_back(m);
it = toArrange.erase(it); it = toArrange.erase(it);
@@ -2857,10 +2856,10 @@ void CCompositor::arrangeMonitors() {
// Finds the max and min values of explicitely placed monitors. // Finds the max and min values of explicitely placed monitors.
for (auto const& m : arranged) { for (auto const& m : arranged) {
maxXOffsetRight = std::max<double>(m->vecPosition.x + m->vecSize.x, maxXOffsetRight); maxXOffsetRight = std::max<double>(m->m_position.x + m->m_size.x, maxXOffsetRight);
maxXOffsetLeft = std::min<double>(m->vecPosition.x, maxXOffsetLeft); maxXOffsetLeft = std::min<double>(m->m_position.x, maxXOffsetLeft);
maxYOffsetDown = std::max<double>(m->vecPosition.y + m->vecSize.y, maxYOffsetDown); maxYOffsetDown = std::max<double>(m->m_position.y + m->m_size.y, maxYOffsetDown);
maxYOffsetUp = std::min<double>(m->vecPosition.y, maxYOffsetUp); maxYOffsetUp = std::min<double>(m->m_position.y, maxYOffsetUp);
} }
}; };
@@ -2871,15 +2870,15 @@ void CCompositor::arrangeMonitors() {
// Moves the monitor to their appropriate position on the x/y axis and // Moves the monitor to their appropriate position on the x/y axis and
// increments/decrements the corresponding max offset. // increments/decrements the corresponding max offset.
Vector2D newPosition = {0, 0}; Vector2D newPosition = {0, 0};
switch (m->activeMonitorRule.autoDir) { switch (m->m_activeMonitorRule.autoDir) {
case eAutoDirs::DIR_AUTO_UP: newPosition.y = maxYOffsetUp - m->vecSize.y; break; case eAutoDirs::DIR_AUTO_UP: newPosition.y = maxYOffsetUp - m->m_size.y; break;
case eAutoDirs::DIR_AUTO_DOWN: newPosition.y = maxYOffsetDown; break; case eAutoDirs::DIR_AUTO_DOWN: newPosition.y = maxYOffsetDown; break;
case eAutoDirs::DIR_AUTO_LEFT: newPosition.x = maxXOffsetLeft - m->vecSize.x; break; case eAutoDirs::DIR_AUTO_LEFT: newPosition.x = maxXOffsetLeft - m->m_size.x; break;
case eAutoDirs::DIR_AUTO_RIGHT: case eAutoDirs::DIR_AUTO_RIGHT:
case eAutoDirs::DIR_AUTO_NONE: newPosition.x = maxXOffsetRight; break; case eAutoDirs::DIR_AUTO_NONE: newPosition.x = maxXOffsetRight; break;
default: UNREACHABLE(); default: UNREACHABLE();
} }
Debug::log(LOG, "arrangeMonitors: {} auto {:j}", m->szName, m->vecPosition); Debug::log(LOG, "arrangeMonitors: {} auto {:j}", m->m_name, m->m_position);
m->moveTo(newPosition); m->moveTo(newPosition);
arranged.emplace_back(m); arranged.emplace_back(m);
} }
@@ -2888,14 +2887,14 @@ void CCompositor::arrangeMonitors() {
// and set xwayland positions aka auto for all // and set xwayland positions aka auto for all
maxXOffsetRight = 0; maxXOffsetRight = 0;
for (auto const& m : m_monitors) { for (auto const& m : m_monitors) {
Debug::log(LOG, "arrangeMonitors: {} xwayland [{}, {}]", m->szName, maxXOffsetRight, 0); Debug::log(LOG, "arrangeMonitors: {} xwayland [{}, {}]", m->m_name, maxXOffsetRight, 0);
m->vecXWaylandPosition = {maxXOffsetRight, 0}; m->m_xwaylandPosition = {maxXOffsetRight, 0};
maxXOffsetRight += (*PXWLFORCESCALEZERO ? m->vecTransformedSize.x : m->vecSize.x); maxXOffsetRight += (*PXWLFORCESCALEZERO ? m->m_transformedSize.x : m->m_size.x);
if (*PXWLFORCESCALEZERO) if (*PXWLFORCESCALEZERO)
m->xwaylandScale = m->scale; m->m_xwaylandScale = m->m_scale;
else else
m->xwaylandScale = 1.f; m->m_xwaylandScale = 1.f;
} }
PROTO::xdgOutput->updateAllOutputs(); PROTO::xdgOutput->updateAllOutputs();
@@ -2907,7 +2906,7 @@ void CCompositor::enterUnsafeState() {
Debug::log(LOG, "Entering unsafe state"); Debug::log(LOG, "Entering unsafe state");
if (!m_unsafeOutput->m_bEnabled) if (!m_unsafeOutput->m_enabled)
m_unsafeOutput->onConnect(false); m_unsafeOutput->onConnect(false);
m_unsafeState = true; m_unsafeState = true;
@@ -2925,7 +2924,7 @@ void CCompositor::leaveUnsafeState() {
PHLMONITOR pNewMonitor = nullptr; PHLMONITOR pNewMonitor = nullptr;
for (auto const& pMonitor : m_monitors) { for (auto const& pMonitor : m_monitors) {
if (pMonitor->output != m_unsafeOutput->output) { if (pMonitor->m_output != m_unsafeOutput->m_output) {
pNewMonitor = pMonitor; pNewMonitor = pMonitor;
break; break;
} }
@@ -2933,7 +2932,7 @@ void CCompositor::leaveUnsafeState() {
RASSERT(pNewMonitor, "Tried to leave unsafe without a monitor"); RASSERT(pNewMonitor, "Tried to leave unsafe without a monitor");
if (m_unsafeOutput->m_bEnabled) if (m_unsafeOutput->m_enabled)
m_unsafeOutput->onDisconnect(); m_unsafeOutput->onDisconnect();
for (auto const& m : m_monitors) { for (auto const& m : m_monitors) {
@@ -2993,7 +2992,7 @@ static void checkDefaultCursorWarp(PHLMONITOR monitor) {
} }
if (!cursorDefaultDone && *PCURSORMONITOR != STRVAL_EMPTY) { if (!cursorDefaultDone && *PCURSORMONITOR != STRVAL_EMPTY) {
if (*PCURSORMONITOR == monitor->szName) { if (*PCURSORMONITOR == monitor->m_name) {
cursorDefaultDone = true; cursorDefaultDone = true;
g_pCompositor->warpCursorTo(POS, true); g_pCompositor->warpCursorTo(POS, true);
g_pInputManager->refocus(); g_pInputManager->refocus();
@@ -3018,23 +3017,23 @@ void CCompositor::onNewMonitor(SP<Aquamarine::IOutput> output) {
Debug::log(LOG, "New output with name {}", output->name); Debug::log(LOG, "New output with name {}", output->name);
PNEWMONITOR->szName = output->name; PNEWMONITOR->m_name = output->name;
PNEWMONITOR->self = PNEWMONITOR; PNEWMONITOR->m_self = PNEWMONITOR;
const bool FALLBACK = g_pCompositor->m_unsafeOutput ? output == g_pCompositor->m_unsafeOutput->output : false; const bool FALLBACK = g_pCompositor->m_unsafeOutput ? output == g_pCompositor->m_unsafeOutput->m_output : false;
PNEWMONITOR->ID = FALLBACK ? MONITOR_INVALID : g_pCompositor->getNextAvailableMonitorID(output->name); PNEWMONITOR->m_id = FALLBACK ? MONITOR_INVALID : g_pCompositor->getNextAvailableMonitorID(output->name);
PNEWMONITOR->isUnsafeFallback = FALLBACK; PNEWMONITOR->m_isUnsafeFallback = FALLBACK;
EMIT_HOOK_EVENT("newMonitor", PNEWMONITOR); EMIT_HOOK_EVENT("newMonitor", PNEWMONITOR);
if (!FALLBACK) if (!FALLBACK)
PNEWMONITOR->onConnect(false); PNEWMONITOR->onConnect(false);
if (!PNEWMONITOR->m_bEnabled || FALLBACK) if (!PNEWMONITOR->m_enabled || FALLBACK)
return; return;
// ready to process if we have a real monitor // ready to process if we have a real monitor
if ((!g_pHyprRenderer->m_pMostHzMonitor || PNEWMONITOR->refreshRate > g_pHyprRenderer->m_pMostHzMonitor->refreshRate) && PNEWMONITOR->m_bEnabled) if ((!g_pHyprRenderer->m_pMostHzMonitor || PNEWMONITOR->m_refreshRate > g_pHyprRenderer->m_pMostHzMonitor->m_refreshRate) && PNEWMONITOR->m_enabled)
g_pHyprRenderer->m_pMostHzMonitor = PNEWMONITOR; g_pHyprRenderer->m_pMostHzMonitor = PNEWMONITOR;
g_pCompositor->m_readyToProcess = true; g_pCompositor->m_readyToProcess = true;
@@ -3112,7 +3111,7 @@ void CCompositor::ensurePersistentWorkspacesPresent(const std::vector<SWorkspace
} }
PWORKSPACE = getWorkspaceByID(id); PWORKSPACE = getWorkspaceByID(id);
if (!PWORKSPACE) if (!PWORKSPACE)
createNewWorkspace(id, PMONITOR ? PMONITOR->ID : m_lastMonitor->ID, wsname, false); createNewWorkspace(id, PMONITOR ? PMONITOR->m_id : m_lastMonitor->m_id, wsname, false);
} }
if (PWORKSPACE) if (PWORKSPACE)
@@ -3125,12 +3124,12 @@ void CCompositor::ensurePersistentWorkspacesPresent(const std::vector<SWorkspace
if (PWORKSPACE) { if (PWORKSPACE) {
if (PWORKSPACE->m_monitor == PMONITOR) { if (PWORKSPACE->m_monitor == PMONITOR) {
Debug::log(LOG, "ensurePersistentWorkspacesPresent: workspace persistent {} already on {}", rule.workspaceString, PMONITOR->szName); Debug::log(LOG, "ensurePersistentWorkspacesPresent: workspace persistent {} already on {}", rule.workspaceString, PMONITOR->m_name);
continue; continue;
} }
Debug::log(LOG, "ensurePersistentWorkspacesPresent: workspace persistent {} not on {}, moving", rule.workspaceString, PMONITOR->szName); Debug::log(LOG, "ensurePersistentWorkspacesPresent: workspace persistent {} not on {}, moving", rule.workspaceString, PMONITOR->m_name);
moveWorkspaceToMonitor(PWORKSPACE, PMONITOR); moveWorkspaceToMonitor(PWORKSPACE, PMONITOR);
continue; continue;
} }

82
src/config/ConfigManager.cpp
View File

@@ -1016,7 +1016,7 @@ void CConfigManager::postConfigReload(const Hyprlang::CParseResult& result) {
} }
for (auto const& m : g_pCompositor->m_monitors) for (auto const& m : g_pCompositor->m_monitors)
g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID); g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->m_id);
// Update the keyboard layout to the cfg'd one if this is not the first launch // Update the keyboard layout to the cfg'd one if this is not the first launch
if (!m_isFirstLaunch) { if (!m_isFirstLaunch) {
@@ -1113,11 +1113,11 @@ void CConfigManager::postConfigReload(const Hyprlang::CParseResult& result) {
g_pCompositor->scheduleFrameForMonitor(m); g_pCompositor->scheduleFrameForMonitor(m);
// Force the compositor to fully re-render all monitors // Force the compositor to fully re-render all monitors
m->forceFullFrames = 2; m->m_forceFullFrames = 2;
// also force mirrors, as the aspect ratio could've changed // also force mirrors, as the aspect ratio could've changed
for (auto const& mirror : m->mirrors) for (auto const& mirror : m->m_mirrors)
mirror->forceFullFrames = 3; mirror->m_forceFullFrames = 3;
} }
// Reset no monitor reload // Reset no monitor reload
@@ -1157,7 +1157,7 @@ std::string CConfigManager::parseKeyword(const std::string& COMMAND, const std::
// invalidate layouts if they changed // invalidate layouts if they changed
if (COMMAND == "monitor" || COMMAND.contains("gaps_") || COMMAND.starts_with("dwindle:") || COMMAND.starts_with("master:")) { if (COMMAND == "monitor" || COMMAND.contains("gaps_") || COMMAND.starts_with("dwindle:") || COMMAND.starts_with("master:")) {
for (auto const& m : g_pCompositor->m_monitors) for (auto const& m : g_pCompositor->m_monitors)
g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID); g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->m_id);
} }
if (COMMAND.contains("explicit")) { if (COMMAND.contains("explicit")) {
@@ -1225,7 +1225,7 @@ SMonitorRule CConfigManager::getMonitorRuleFor(const PHLMONITOR PMONITOR) {
if (!CONFIG) if (!CONFIG)
return rule; return rule;
Debug::log(LOG, "CConfigManager::getMonitorRuleFor: found a wlr_output_manager override for {}", PMONITOR->szName); Debug::log(LOG, "CConfigManager::getMonitorRuleFor: found a wlr_output_manager override for {}", PMONITOR->m_name);
Debug::log(LOG, " > overriding enabled: {} -> {}", !rule.disabled, !CONFIG->enabled); Debug::log(LOG, " > overriding enabled: {} -> {}", !rule.disabled, !CONFIG->enabled);
rule.disabled = !CONFIG->enabled; rule.disabled = !CONFIG->enabled;
@@ -1266,7 +1266,7 @@ SMonitorRule CConfigManager::getMonitorRuleFor(const PHLMONITOR PMONITOR) {
} }
} }
Debug::log(WARN, "No rule found for {}, trying to use the first.", PMONITOR->szName); Debug::log(WARN, "No rule found for {}, trying to use the first.", PMONITOR->m_name);
for (auto const& r : m_monitorRules) { for (auto const& r : m_monitorRules) {
if (r.name.empty()) { if (r.name.empty()) {
@@ -1605,7 +1605,7 @@ void CConfigManager::performMonitorReload() {
bool overAgain = false; bool overAgain = false;
for (auto const& m : g_pCompositor->m_realMonitors) { for (auto const& m : g_pCompositor->m_realMonitors) {
if (!m->output || m->isUnsafeFallback) if (!m->m_output || m->m_isUnsafeFallback)
continue; continue;
auto rule = getMonitorRuleFor(m); auto rule = getMonitorRuleFor(m);
@@ -1618,7 +1618,7 @@ void CConfigManager::performMonitorReload() {
// ensure mirror // ensure mirror
m->setMirror(rule.mirrorOf); m->setMirror(rule.mirrorOf);
g_pHyprRenderer->arrangeLayersForMonitor(m->ID); g_pHyprRenderer->arrangeLayersForMonitor(m->m_id);
} }
if (overAgain) if (overAgain)
@@ -1662,12 +1662,12 @@ bool CConfigManager::shouldBlurLS(const std::string& ns) {
void CConfigManager::ensureMonitorStatus() { void CConfigManager::ensureMonitorStatus() {
for (auto const& rm : g_pCompositor->m_realMonitors) { for (auto const& rm : g_pCompositor->m_realMonitors) {
if (!rm->output || rm->isUnsafeFallback) if (!rm->m_output || rm->m_isUnsafeFallback)
continue; continue;
auto rule = getMonitorRuleFor(rm); auto rule = getMonitorRuleFor(rm);
if (rule.disabled == rm->m_bEnabled) if (rule.disabled == rm->m_enabled)
rm->applyMonitorRule(&rule); rm->applyMonitorRule(&rule);
} }
} }
@@ -1676,38 +1676,38 @@ void CConfigManager::ensureVRR(PHLMONITOR pMonitor) {
static auto PVRR = reinterpret_cast<Hyprlang::INT* const*>(getConfigValuePtr("misc:vrr")); static auto PVRR = reinterpret_cast<Hyprlang::INT* const*>(getConfigValuePtr("misc:vrr"));
static auto ensureVRRForDisplay = [&](PHLMONITOR m) -> void { static auto ensureVRRForDisplay = [&](PHLMONITOR m) -> void {
if (!m->output || m->createdByUser) if (!m->m_output || m->m_createdByUser)
return; return;
const auto USEVRR = m->activeMonitorRule.vrr.has_value() ? m->activeMonitorRule.vrr.value() : **PVRR; const auto USEVRR = m->m_activeMonitorRule.vrr.has_value() ? m->m_activeMonitorRule.vrr.value() : **PVRR;
if (USEVRR == 0) { if (USEVRR == 0) {
if (m->vrrActive) { if (m->m_vrrActive) {
m->output->state->resetExplicitFences(); m->m_output->state->resetExplicitFences();
m->output->state->setAdaptiveSync(false); m->m_output->state->setAdaptiveSync(false);
if (!m->state.commit()) if (!m->m_state.commit())
Debug::log(ERR, "Couldn't commit output {} in ensureVRR -> false", m->output->name); Debug::log(ERR, "Couldn't commit output {} in ensureVRR -> false", m->m_output->name);
} }
m->vrrActive = false; m->m_vrrActive = false;
return; return;
} else if (USEVRR == 1) { } else if (USEVRR == 1) {
if (!m->vrrActive) { if (!m->m_vrrActive) {
m->output->state->resetExplicitFences(); m->m_output->state->resetExplicitFences();
m->output->state->setAdaptiveSync(true); m->m_output->state->setAdaptiveSync(true);
if (!m->state.test()) { if (!m->m_state.test()) {
Debug::log(LOG, "Pending output {} does not accept VRR.", m->output->name); Debug::log(LOG, "Pending output {} does not accept VRR.", m->m_output->name);
m->output->state->setAdaptiveSync(false); m->m_output->state->setAdaptiveSync(false);
} }
if (!m->state.commit()) if (!m->m_state.commit())
Debug::log(ERR, "Couldn't commit output {} in ensureVRR -> true", m->output->name); Debug::log(ERR, "Couldn't commit output {} in ensureVRR -> true", m->m_output->name);
} }
m->vrrActive = true; m->m_vrrActive = true;
return; return;
} else if (USEVRR == 2 || USEVRR == 3) { } else if (USEVRR == 2 || USEVRR == 3) {
const auto PWORKSPACE = m->activeWorkspace; const auto PWORKSPACE = m->m_activeWorkspace;
if (!PWORKSPACE) if (!PWORKSPACE)
return; // ??? return; // ???
@@ -1720,20 +1720,20 @@ void CConfigManager::ensureVRR(PHLMONITOR pMonitor) {
if (wantVRR) { if (wantVRR) {
/* fullscreen */ /* fullscreen */
m->vrrActive = true; m->m_vrrActive = true;
if (!m->output->state->state().adaptiveSync) { if (!m->m_output->state->state().adaptiveSync) {
m->output->state->setAdaptiveSync(true); m->m_output->state->setAdaptiveSync(true);
if (!m->state.test()) { if (!m->m_state.test()) {
Debug::log(LOG, "Pending output {} does not accept VRR.", m->output->name); Debug::log(LOG, "Pending output {} does not accept VRR.", m->m_output->name);
m->output->state->setAdaptiveSync(false); m->m_output->state->setAdaptiveSync(false);
} }
} }
} else { } else {
m->vrrActive = false; m->m_vrrActive = false;
m->output->state->setAdaptiveSync(false); m->m_output->state->setAdaptiveSync(false);
} }
} }
}; };
@@ -1840,7 +1840,7 @@ std::string CConfigManager::getDefaultWorkspaceFor(const std::string& name) {
return other->workspaceString; return other->workspaceString;
if (other->monitor.starts_with("desc:")) { if (other->monitor.starts_with("desc:")) {
auto const monitor = g_pCompositor->getMonitorFromDesc(trim(other->monitor.substr(5))); auto const monitor = g_pCompositor->getMonitorFromDesc(trim(other->monitor.substr(5)));
if (monitor && monitor->szName == name) if (monitor && monitor->m_name == name)
return other->workspaceString; return other->workspaceString;
} }
} }
@@ -2630,7 +2630,7 @@ std::optional<std::string> CConfigManager::handleLayerRule(const std::string& co
m_layerRules.emplace_back(rule); m_layerRules.emplace_back(rule);
for (auto const& m : g_pCompositor->m_monitors) for (auto const& m : g_pCompositor->m_monitors)
for (auto const& lsl : m->m_aLayerSurfaceLayers) for (auto const& lsl : m->m_layerSurfaceLayers)
for (auto const& ls : lsl) for (auto const& ls : lsl)
ls->applyRules(); ls->applyRules();
@@ -2645,7 +2645,7 @@ void CConfigManager::updateBlurredLS(const std::string& name, const bool forceBl
matchName = matchName.substr(8); matchName = matchName.substr(8);
for (auto const& m : g_pCompositor->m_monitors) { for (auto const& m : g_pCompositor->m_monitors) {
for (auto const& lsl : m->m_aLayerSurfaceLayers) { for (auto const& lsl : m->m_layerSurfaceLayers) {
for (auto const& ls : lsl) { for (auto const& ls : lsl) {
if (BYADDRESS) { if (BYADDRESS) {
if (std::format("0x{:x}", (uintptr_t)ls.get()) == matchName) if (std::format("0x{:x}", (uintptr_t)ls.get()) == matchName)
@@ -2925,7 +2925,7 @@ bool CConfigManager::shouldUseSoftwareCursors(PHLMONITOR pMonitor) {
switch (*PNOHW) { switch (*PNOHW) {
case 0: return false; case 0: return false;
case 1: return true; case 1: return true;
case 2: return pMonitor->tearingState.activelyTearing; case 2: return pMonitor->m_tearingState.activelyTearing;
default: break; default: break;
} }

65
src/debug/HyprCtl.cpp
View File

@@ -97,7 +97,7 @@ static std::string formatToString(uint32_t drmFormat) {
static std::string availableModesForOutput(PHLMONITOR pMonitor, eHyprCtlOutputFormat format) { static std::string availableModesForOutput(PHLMONITOR pMonitor, eHyprCtlOutputFormat format) {
std::string result; std::string result;
for (auto const& m : pMonitor->output->modes) { for (auto const& m : pMonitor->m_output->modes) {
if (format == FORMAT_NORMAL) if (format == FORMAT_NORMAL)
result += std::format("{}x{}@{:.2f}Hz ", m->pixelSize.x, m->pixelSize.y, m->refreshRate / 1000.0); result += std::format("{}x{}@{:.2f}Hz ", m->pixelSize.x, m->pixelSize.y, m->refreshRate / 1000.0);
else else
@@ -111,7 +111,7 @@ static std::string availableModesForOutput(PHLMONITOR pMonitor, eHyprCtlOutputFo
std::string CHyprCtl::getMonitorData(Hyprutils::Memory::CSharedPointer<CMonitor> m, eHyprCtlOutputFormat format) { std::string CHyprCtl::getMonitorData(Hyprutils::Memory::CSharedPointer<CMonitor> m, eHyprCtlOutputFormat format) {
std::string result; std::string result;
if (!m->output || m->ID == -1) if (!m->m_output || m->m_id == -1)
return ""; return "";
if (format == eHyprCtlOutputFormat::FORMAT_JSON) { if (format == eHyprCtlOutputFormat::FORMAT_JSON) {
@@ -152,27 +152,28 @@ std::string CHyprCtl::getMonitorData(Hyprutils::Memory::CSharedPointer<CMonitor>
"availableModes": [{}] "availableModes": [{}]
}},)#", }},)#",
m->ID, escapeJSONStrings(m->szName), escapeJSONStrings(m->szShortDescription), escapeJSONStrings(m->output->make), escapeJSONStrings(m->output->model), m->m_id, escapeJSONStrings(m->m_name), escapeJSONStrings(m->m_shortDescription), escapeJSONStrings(m->m_output->make), escapeJSONStrings(m->m_output->model),
escapeJSONStrings(m->output->serial), (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y, escapeJSONStrings(m->m_output->serial), (int)m->m_pixelSize.x, (int)m->m_pixelSize.y, m->m_refreshRate, (int)m->m_position.x, (int)m->m_position.y,
m->activeWorkspaceID(), (!m->activeWorkspace ? "" : escapeJSONStrings(m->activeWorkspace->m_name)), m->activeSpecialWorkspaceID(), m->activeWorkspaceID(), (!m->m_activeWorkspace ? "" : escapeJSONStrings(m->m_activeWorkspace->m_name)), m->activeSpecialWorkspaceID(),
escapeJSONStrings(m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_name : ""), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y, escapeJSONStrings(m->m_activeSpecialWorkspace ? m->m_activeSpecialWorkspace->m_name : ""), (int)m->m_reservedTopLeft.x, (int)m->m_reservedTopLeft.y,
(int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m == g_pCompositor->m_lastMonitor ? "true" : "false"), (int)m->m_reservedBottomRight.x, (int)m->m_reservedBottomRight.y, m->m_scale, (int)m->m_transform, (m == g_pCompositor->m_lastMonitor ? "true" : "false"),
(m->dpmsStatus ? "true" : "false"), (m->output->state->state().adaptiveSync ? "true" : "false"), (uint64_t)m->solitaryClient.get(), (m->m_dpmsStatus ? "true" : "false"), (m->m_output->state->state().adaptiveSync ? "true" : "false"), (uint64_t)m->m_solitaryClient.get(),
(m->tearingState.activelyTearing ? "true" : "false"), (uint64_t)m->lastScanout.get(), (m->m_bEnabled ? "false" : "true"), (m->m_tearingState.activelyTearing ? "true" : "false"), (uint64_t)m->m_lastScanout.get(), (m->m_enabled ? "false" : "true"),
formatToString(m->output->state->state().drmFormat), m->pMirrorOf ? std::format("{}", m->pMirrorOf->ID) : "none", availableModesForOutput(m, format)); formatToString(m->m_output->state->state().drmFormat), m->m_mirrorOf ? std::format("{}", m->m_mirrorOf->m_id) : "none", availableModesForOutput(m, format));
} else { } else {
result += std::format("Monitor {} (ID {}):\n\t{}x{}@{:.5f} at {}x{}\n\tdescription: {}\n\tmake: {}\n\tmodel: {}\n\tserial: {}\n\tactive workspace: {} ({})\n\t" result +=
std::format("Monitor {} (ID {}):\n\t{}x{}@{:.5f} at {}x{}\n\tdescription: {}\n\tmake: {}\n\tmodel: {}\n\tserial: {}\n\tactive workspace: {} ({})\n\t"
"special workspace: {} ({})\n\treserved: {} {} {} {}\n\tscale: {:.2f}\n\ttransform: {}\n\tfocused: {}\n\t" "special workspace: {} ({})\n\treserved: {} {} {} {}\n\tscale: {:.2f}\n\ttransform: {}\n\tfocused: {}\n\t"
"dpmsStatus: {}\n\tvrr: {}\n\tsolitary: {:x}\n\tactivelyTearing: {}\n\tdirectScanoutTo: {:x}\n\tdisabled: {}\n\tcurrentFormat: {}\n\tmirrorOf: " "dpmsStatus: {}\n\tvrr: {}\n\tsolitary: {:x}\n\tactivelyTearing: {}\n\tdirectScanoutTo: {:x}\n\tdisabled: {}\n\tcurrentFormat: {}\n\tmirrorOf: "
"{}\n\tavailableModes: {}\n\n", "{}\n\tavailableModes: {}\n\n",
m->szName, m->ID, (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y, m->szShortDescription, m->m_name, m->m_id, (int)m->m_pixelSize.x, (int)m->m_pixelSize.y, m->m_refreshRate, (int)m->m_position.x, (int)m->m_position.y, m->m_shortDescription,
m->output->make, m->output->model, m->output->serial, m->activeWorkspaceID(), (!m->activeWorkspace ? "" : m->activeWorkspace->m_name), m->m_output->make, m->m_output->model, m->m_output->serial, m->activeWorkspaceID(), (!m->m_activeWorkspace ? "" : m->m_activeWorkspace->m_name),
m->activeSpecialWorkspaceID(), (m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_name : ""), (int)m->vecReservedTopLeft.x, m->activeSpecialWorkspaceID(), (m->m_activeSpecialWorkspace ? m->m_activeSpecialWorkspace->m_name : ""), (int)m->m_reservedTopLeft.x,
(int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (int)m->m_reservedTopLeft.y, (int)m->m_reservedBottomRight.x, (int)m->m_reservedBottomRight.y, m->m_scale, (int)m->m_transform,
(m == g_pCompositor->m_lastMonitor ? "yes" : "no"), (int)m->dpmsStatus, m->output->state->state().adaptiveSync, (uint64_t)m->solitaryClient.get(), (m == g_pCompositor->m_lastMonitor ? "yes" : "no"), (int)m->m_dpmsStatus, m->m_output->state->state().adaptiveSync, (uint64_t)m->m_solitaryClient.get(),
m->tearingState.activelyTearing, (uint64_t)m->lastScanout.get(), !m->m_bEnabled, formatToString(m->output->state->state().drmFormat), m->m_tearingState.activelyTearing, (uint64_t)m->m_lastScanout.get(), !m->m_enabled, formatToString(m->m_output->state->state().drmFormat),
m->pMirrorOf ? std::format("{}", m->pMirrorOf->ID) : "none", availableModesForOutput(m, format)); m->m_mirrorOf ? std::format("{}", m->m_mirrorOf->m_id) : "none", availableModesForOutput(m, format));
} }
return result; return result;
@@ -201,7 +202,7 @@ static std::string monitorsRequest(eHyprCtlOutputFormat format, std::string requ
result += "]"; result += "]";
} else { } else {
for (auto const& m : allMonitors ? g_pCompositor->m_realMonitors : g_pCompositor->m_monitors) { for (auto const& m : allMonitors ? g_pCompositor->m_realMonitors : g_pCompositor->m_monitors) {
if (!m->output || m->ID == -1) if (!m->m_output || m->m_id == -1)
continue; continue;
result += CHyprCtl::getMonitorData(m, format); result += CHyprCtl::getMonitorData(m, format);
@@ -349,13 +350,13 @@ std::string CHyprCtl::getWorkspaceData(PHLWORKSPACE w, eHyprCtlOutputFormat form
"lastwindowtitle": "{}", "lastwindowtitle": "{}",
"ispersistent": {} "ispersistent": {}
}})#", }})#",
w->m_id, escapeJSONStrings(w->m_name), escapeJSONStrings(PMONITOR ? PMONITOR->szName : "?"), w->m_id, escapeJSONStrings(w->m_name), escapeJSONStrings(PMONITOR ? PMONITOR->m_name : "?"),
escapeJSONStrings(PMONITOR ? std::to_string(PMONITOR->ID) : "null"), w->getWindows(), w->m_hasFullscreenWindow ? "true" : "false", escapeJSONStrings(PMONITOR ? std::to_string(PMONITOR->m_id) : "null"), w->getWindows(), w->m_hasFullscreenWindow ? "true" : "false",
(uintptr_t)PLASTW.get(), PLASTW ? escapeJSONStrings(PLASTW->m_title) : "", w->m_persistent ? "true" : "false"); (uintptr_t)PLASTW.get(), PLASTW ? escapeJSONStrings(PLASTW->m_title) : "", w->m_persistent ? "true" : "false");
} else { } else {
return std::format( return std::format(
"workspace ID {} ({}) on monitor {}:\n\tmonitorID: {}\n\twindows: {}\n\thasfullscreen: {}\n\tlastwindow: 0x{:x}\n\tlastwindowtitle: {}\n\tispersistent: {}\n\n", "workspace ID {} ({}) on monitor {}:\n\tmonitorID: {}\n\twindows: {}\n\thasfullscreen: {}\n\tlastwindow: 0x{:x}\n\tlastwindowtitle: {}\n\tispersistent: {}\n\n",
w->m_id, w->m_name, PMONITOR ? PMONITOR->szName : "?", PMONITOR ? std::to_string(PMONITOR->ID) : "null", w->getWindows(), (int)w->m_hasFullscreenWindow, w->m_id, w->m_name, PMONITOR ? PMONITOR->m_name : "?", PMONITOR ? std::to_string(PMONITOR->m_id) : "null", w->getWindows(), (int)w->m_hasFullscreenWindow,
(uintptr_t)PLASTW.get(), PLASTW ? PLASTW->m_title : "", (int)w->m_persistent); (uintptr_t)PLASTW.get(), PLASTW ? PLASTW->m_title : "", (int)w->m_persistent);
} }
} }
@@ -415,7 +416,7 @@ static std::string activeWorkspaceRequest(eHyprCtlOutputFormat format, std::stri
return "unsafe state"; return "unsafe state";
std::string result = ""; std::string result = "";
auto w = g_pCompositor->m_lastMonitor->activeWorkspace; auto w = g_pCompositor->m_lastMonitor->m_activeWorkspace;
if (!valid(w)) if (!valid(w))
return "internal error"; return "internal error";
@@ -489,10 +490,10 @@ static std::string layersRequest(eHyprCtlOutputFormat format, std::string reques
R"#("{}": {{ R"#("{}": {{
"levels": {{ "levels": {{
)#", )#",
escapeJSONStrings(mon->szName)); escapeJSONStrings(mon->m_name));
int layerLevel = 0; int layerLevel = 0;
for (auto const& level : mon->m_aLayerSurfaceLayers) { for (auto const& level : mon->m_layerSurfaceLayers) {
result += std::format( result += std::format(
R"#( R"#(
"{}": [ "{}": [
@@ -534,10 +535,10 @@ static std::string layersRequest(eHyprCtlOutputFormat format, std::string reques
} else { } else {
for (auto const& mon : g_pCompositor->m_monitors) { for (auto const& mon : g_pCompositor->m_monitors) {
result += std::format("Monitor {}:\n", mon->szName); result += std::format("Monitor {}:\n", mon->m_name);
int layerLevel = 0; int layerLevel = 0;
static const std::array<std::string, 4> levelNames = {"background", "bottom", "top", "overlay"}; static const std::array<std::string, 4> levelNames = {"background", "bottom", "top", "overlay"};
for (auto const& level : mon->m_aLayerSurfaceLayers) { for (auto const& level : mon->m_layerSurfaceLayers) {
result += std::format("\tLayer level {} ({}):\n", layerLevel, levelNames[layerLevel]); result += std::format("\tLayer level {} ({}):\n", layerLevel, levelNames[layerLevel]);
for (auto const& layer : level) { for (auto const& layer : level) {
@@ -1143,7 +1144,7 @@ static std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in)
COMMAND.starts_with("windowrule")) { COMMAND.starts_with("windowrule")) {
for (auto const& m : g_pCompositor->m_monitors) { for (auto const& m : g_pCompositor->m_monitors) {
g_pHyprRenderer->damageMonitor(m); g_pHyprRenderer->damageMonitor(m);
g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID); g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->m_id);
} }
} }
@@ -1449,7 +1450,7 @@ static std::string dispatchOutput(eHyprCtlOutputFormat format, std::string reque
if (!vars[3].empty()) { if (!vars[3].empty()) {
for (auto const& m : g_pCompositor->m_realMonitors) { for (auto const& m : g_pCompositor->m_realMonitors) {
if (m->szName == vars[3]) if (m->m_name == vars[3])
return "Name already taken"; return "Name already taken";
} }
} }
@@ -1483,10 +1484,10 @@ static std::string dispatchOutput(eHyprCtlOutputFormat format, std::string reque
if (!PMONITOR) if (!PMONITOR)
return "output not found"; return "output not found";
if (!PMONITOR->createdByUser) if (!PMONITOR->m_createdByUser)
return "cannot remove a real display. Use the monitor keyword."; return "cannot remove a real display. Use the monitor keyword.";
PMONITOR->output->destroy(); PMONITOR->m_output->destroy();
} }
return "ok"; return "ok";
@@ -1836,7 +1837,7 @@ std::string CHyprCtl::getReply(std::string request) {
for (auto const& m : g_pCompositor->m_monitors) { for (auto const& m : g_pCompositor->m_monitors) {
g_pHyprRenderer->damageMonitor(m); g_pHyprRenderer->damageMonitor(m);
g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID); g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->m_id);
} }
} }

18
src/debug/HyprDebugOverlay.cpp
View File

@@ -18,7 +18,7 @@ void CHyprMonitorDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs)
m_lastRenderTimes.emplace_back(durationUs / 1000.f); m_lastRenderTimes.emplace_back(durationUs / 1000.f);
if (m_lastRenderTimes.size() > (long unsigned int)pMonitor->refreshRate) if (m_lastRenderTimes.size() > (long unsigned int)pMonitor->m_refreshRate)
m_lastRenderTimes.pop_front(); m_lastRenderTimes.pop_front();
if (!m_monitor) if (!m_monitor)
@@ -33,7 +33,7 @@ void CHyprMonitorDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float du
m_lastRenderTimesNoOverlay.emplace_back(durationUs / 1000.f); m_lastRenderTimesNoOverlay.emplace_back(durationUs / 1000.f);
if (m_lastRenderTimesNoOverlay.size() > (long unsigned int)pMonitor->refreshRate) if (m_lastRenderTimesNoOverlay.size() > (long unsigned int)pMonitor->m_refreshRate)
m_lastRenderTimesNoOverlay.pop_front(); m_lastRenderTimesNoOverlay.pop_front();
if (!m_monitor) if (!m_monitor)
@@ -48,7 +48,7 @@ void CHyprMonitorDebugOverlay::frameData(PHLMONITOR pMonitor) {
m_lastFrametimes.emplace_back(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - m_lastFrame).count() / 1000.f); m_lastFrametimes.emplace_back(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - m_lastFrame).count() / 1000.f);
if (m_lastFrametimes.size() > (long unsigned int)pMonitor->refreshRate) if (m_lastFrametimes.size() > (long unsigned int)pMonitor->m_refreshRate)
m_lastFrametimes.pop_front(); m_lastFrametimes.pop_front();
m_lastFrame = std::chrono::high_resolution_clock::now(); m_lastFrame = std::chrono::high_resolution_clock::now();
@@ -59,7 +59,7 @@ void CHyprMonitorDebugOverlay::frameData(PHLMONITOR pMonitor) {
// anim data too // anim data too
const auto PMONITORFORTICKS = g_pHyprRenderer->m_pMostHzMonitor ? g_pHyprRenderer->m_pMostHzMonitor.lock() : g_pCompositor->m_lastMonitor.lock(); const auto PMONITORFORTICKS = g_pHyprRenderer->m_pMostHzMonitor ? g_pHyprRenderer->m_pMostHzMonitor.lock() : g_pCompositor->m_lastMonitor.lock();
if (PMONITORFORTICKS) { if (PMONITORFORTICKS) {
if (m_lastAnimationTicks.size() > (long unsigned int)PMONITORFORTICKS->refreshRate) if (m_lastAnimationTicks.size() > (long unsigned int)PMONITORFORTICKS->m_refreshRate)
m_lastAnimationTicks.pop_front(); m_lastAnimationTicks.pop_front();
m_lastAnimationTicks.push_back(g_pAnimationManager->m_fLastTickTime); m_lastAnimationTicks.push_back(g_pAnimationManager->m_fLastTickTime);
@@ -166,7 +166,7 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
cairo_set_source_rgba(g_pDebugOverlay->m_cairo, 1.f, 1.f, 1.f, 1.f); cairo_set_source_rgba(g_pDebugOverlay->m_cairo, 1.f, 1.f, 1.f, 1.f);
std::string text; std::string text;
showText(m_monitor->szName.c_str(), 10); showText(m_monitor->m_name.c_str(), 10);
if (FPS > idealFPS * 0.95f) if (FPS > idealFPS * 0.95f)
cairo_set_source_rgba(g_pDebugOverlay->m_cairo, 0.2f, 1.f, 0.2f, 1.f); cairo_set_source_rgba(g_pDebugOverlay->m_cairo, 0.2f, 1.f, 0.2f, 1.f);
@@ -199,7 +199,7 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
cairo_get_current_point(cr, &posX, &posY); cairo_get_current_point(cr, &posX, &posY);
g_pHyprRenderer->damageBox(m_lastDrawnBox); g_pHyprRenderer->damageBox(m_lastDrawnBox);
m_lastDrawnBox = {(int)g_pCompositor->m_monitors.front()->vecPosition.x + MARGIN_LEFT - 1, (int)g_pCompositor->m_monitors.front()->vecPosition.y + offset + MARGIN_TOP - 1, m_lastDrawnBox = {(int)g_pCompositor->m_monitors.front()->m_position.x + MARGIN_LEFT - 1, (int)g_pCompositor->m_monitors.front()->m_position.y + offset + MARGIN_TOP - 1,
(int)maxTextW + 2, posY - offset - MARGIN_TOP + 2}; (int)maxTextW + 2, posY - offset - MARGIN_TOP + 2};
g_pHyprRenderer->damageBox(m_lastDrawnBox); g_pHyprRenderer->damageBox(m_lastDrawnBox);
@@ -238,7 +238,7 @@ void CHyprDebugOverlay::draw() {
const auto PMONITOR = g_pCompositor->m_monitors.front(); const auto PMONITOR = g_pCompositor->m_monitors.front();
if (!m_cairoSurface || !m_cairo) { if (!m_cairoSurface || !m_cairo) {
m_cairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y); m_cairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y);
m_cairo = cairo_create(m_cairoSurface); m_cairo = cairo_create(m_cairoSurface);
} }
@@ -269,10 +269,10 @@ void CHyprDebugOverlay::draw() {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
#endif #endif
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
CTexPassElement::SRenderData data; CTexPassElement::SRenderData data;
data.tex = m_texture; data.tex = m_texture;
data.box = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y}; data.box = {0, 0, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y};
g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data)); g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
} }

10
src/debug/HyprNotificationOverlay.cpp
View File

@@ -77,8 +77,8 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
float offsetY = 10; float offsetY = 10;
float maxWidth = 0; float maxWidth = 0;
const auto SCALE = pMonitor->scale; const auto SCALE = pMonitor->m_scale;
const auto MONSIZE = pMonitor->vecTransformedSize; const auto MONSIZE = pMonitor->m_transformedSize;
static auto fontFamily = CConfigValue<std::string>("misc:font_family"); static auto fontFamily = CConfigValue<std::string>("misc:font_family");
@@ -94,7 +94,7 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
for (auto const& notif : m_notifications) { for (auto const& notif : m_notifications) {
const auto ICONPADFORNOTIF = notif->icon == ICON_NONE ? 0 : ICON_PAD; const auto ICONPADFORNOTIF = notif->icon == ICON_NONE ? 0 : ICON_PAD;
const auto FONTSIZE = std::clamp((int)(notif->fontSize * ((pMonitor->vecPixelSize.x * SCALE) / 1920.f)), 8, 40); const auto FONTSIZE = std::clamp((int)(notif->fontSize * ((pMonitor->m_pixelSize.x * SCALE) / 1920.f)), 8, 40);
// first rect (bg, col) // first rect (bg, col)
const float FIRSTRECTANIMP = const float FIRSTRECTANIMP =
@@ -189,12 +189,12 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
// cleanup notifs // cleanup notifs
std::erase_if(m_notifications, [](const auto& notif) { return notif->started.getMillis() > notif->timeMs; }); std::erase_if(m_notifications, [](const auto& notif) { return notif->started.getMillis() > notif->timeMs; });
return CBox{(int)(pMonitor->vecPosition.x + pMonitor->vecSize.x - maxWidth - 20), (int)pMonitor->vecPosition.y, (int)maxWidth + 20, (int)offsetY + 10}; return CBox{(int)(pMonitor->m_position.x + pMonitor->m_size.x - maxWidth - 20), (int)pMonitor->m_position.y, (int)maxWidth + 20, (int)offsetY + 10};
} }
void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) { void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) {
const auto MONSIZE = pMonitor->vecTransformedSize; const auto MONSIZE = pMonitor->m_transformedSize;
if (m_lastMonitor != pMonitor || m_lastSize != MONSIZE || !m_cairo || !m_cairoSurface) { if (m_lastMonitor != pMonitor || m_lastSize != MONSIZE || !m_cairo || !m_cairoSurface) {

72
src/desktop/LayerSurface.cpp
View File

@@ -24,7 +24,7 @@ PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
return pLS; return pLS;
} }
if (pMonitor->pMirrorOf) if (pMonitor->m_mirrorOf)
pMonitor = g_pCompositor->m_monitors.front(); pMonitor = g_pCompositor->m_monitors.front();
pLS->m_self = pLS; pLS->m_self = pLS;
@@ -34,7 +34,7 @@ PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
pLS->m_layer = resource->current.layer; pLS->m_layer = resource->current.layer;
pLS->m_popupHead = CPopup::create(pLS); pLS->m_popupHead = CPopup::create(pLS);
pLS->m_monitor = pMonitor; pLS->m_monitor = pMonitor;
pMonitor->m_aLayerSurfaceLayers[resource->current.layer].emplace_back(pLS); pMonitor->m_layerSurfaceLayers[resource->current.layer].emplace_back(pLS);
pLS->m_forceBlur = g_pConfigManager->shouldBlurLS(pLS->m_namespace); pLS->m_forceBlur = g_pConfigManager->shouldBlurLS(pLS->m_namespace);
@@ -46,7 +46,7 @@ PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
pLS->m_alpha->setValueAndWarp(0.f); pLS->m_alpha->setValueAndWarp(0.f);
Debug::log(LOG, "LayerSurface {:x} (namespace {} layer {}) created on monitor {}", (uintptr_t)resource.get(), resource->layerNamespace, (int)pLS->m_layer, pMonitor->szName); Debug::log(LOG, "LayerSurface {:x} (namespace {} layer {}) created on monitor {}", (uintptr_t)resource.get(), resource->layerNamespace, (int)pLS->m_layer, pMonitor->m_name);
return pLS; return pLS;
} }
@@ -77,7 +77,7 @@ CLayerSurface::~CLayerSurface() {
std::erase_if(g_pHyprOpenGL->m_mLayerFramebuffers, [&](const auto& other) { return other.first.expired() || other.first.lock() == m_self.lock(); }); std::erase_if(g_pHyprOpenGL->m_mLayerFramebuffers, [&](const auto& other) { return other.first.expired() || other.first.lock() == m_self.lock(); });
for (auto const& mon : g_pCompositor->m_realMonitors) { for (auto const& mon : g_pCompositor->m_realMonitors) {
for (auto& lsl : mon->m_aLayerSurfaceLayers) { for (auto& lsl : mon->m_layerSurfaceLayers) {
std::erase_if(lsl, [this](auto& ls) { return ls.expired() || ls.get() == this; }); std::erase_if(lsl, [this](auto& ls) { return ls.expired() || ls.get() == this; });
} }
} }
@@ -110,11 +110,11 @@ void CLayerSurface::onDestroy() {
// rearrange to fix the reserved areas // rearrange to fix the reserved areas
if (PMONITOR) { if (PMONITOR) {
g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID); g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->m_id);
PMONITOR->scheduledRecalc = true; PMONITOR->m_scheduledRecalc = true;
// and damage // and damage
CBox geomFixed = {m_geometry.x + PMONITOR->vecPosition.x, m_geometry.y + PMONITOR->vecPosition.y, m_geometry.width, m_geometry.height}; CBox geomFixed = {m_geometry.x + PMONITOR->m_position.x, m_geometry.y + PMONITOR->m_position.y, m_geometry.width, m_geometry.height};
g_pHyprRenderer->damageBox(geomFixed); g_pHyprRenderer->damageBox(geomFixed);
} }
@@ -149,11 +149,11 @@ void CLayerSurface::onMap() {
applyRules(); applyRules();
PMONITOR->scheduledRecalc = true; PMONITOR->m_scheduledRecalc = true;
g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID); g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->m_id);
m_surface->resource()->enter(PMONITOR->self.lock()); m_surface->resource()->enter(PMONITOR->m_self.lock());
const bool ISEXCLUSIVE = m_layerSurface->current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE; const bool ISEXCLUSIVE = m_layerSurface->current.interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE;
@@ -171,16 +171,16 @@ void CLayerSurface::onMap() {
g_pInputManager->releaseAllMouseButtons(); g_pInputManager->releaseAllMouseButtons();
g_pCompositor->focusSurface(m_surface->resource()); g_pCompositor->focusSurface(m_surface->resource());
const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(m_geometry.x + PMONITOR->vecPosition.x, m_geometry.y + PMONITOR->vecPosition.y); const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(m_geometry.x + PMONITOR->m_position.x, m_geometry.y + PMONITOR->m_position.y);
g_pSeatManager->setPointerFocus(m_surface->resource(), LOCAL); g_pSeatManager->setPointerFocus(m_surface->resource(), LOCAL);
g_pInputManager->m_bEmptyFocusCursorSet = false; g_pInputManager->m_bEmptyFocusCursorSet = false;
} }
m_position = Vector2D(m_geometry.x, m_geometry.y); m_position = Vector2D(m_geometry.x, m_geometry.y);
CBox geomFixed = {m_geometry.x + PMONITOR->vecPosition.x, m_geometry.y + PMONITOR->vecPosition.y, m_geometry.width, m_geometry.height}; CBox geomFixed = {m_geometry.x + PMONITOR->m_position.x, m_geometry.y + PMONITOR->m_position.y, m_geometry.width, m_geometry.height};
g_pHyprRenderer->damageBox(geomFixed); g_pHyprRenderer->damageBox(geomFixed);
const bool FULLSCREEN = PMONITOR->activeWorkspace && PMONITOR->activeWorkspace->m_hasFullscreenWindow && PMONITOR->activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN; const bool FULLSCREEN = PMONITOR->m_activeWorkspace && PMONITOR->m_activeWorkspace->m_hasFullscreenWindow && PMONITOR->m_activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN;
startAnimation(!(m_layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP && FULLSCREEN && !GRABSFOCUS)); startAnimation(!(m_layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP && FULLSCREEN && !GRABSFOCUS));
m_readyToDelete = false; m_readyToDelete = false;
@@ -189,8 +189,8 @@ void CLayerSurface::onMap() {
g_pEventManager->postEvent(SHyprIPCEvent{"openlayer", m_namespace}); g_pEventManager->postEvent(SHyprIPCEvent{"openlayer", m_namespace});
EMIT_HOOK_EVENT("openLayer", m_self.lock()); EMIT_HOOK_EVENT("openLayer", m_self.lock());
g_pCompositor->setPreferredScaleForSurface(m_surface->resource(), PMONITOR->scale); g_pCompositor->setPreferredScaleForSurface(m_surface->resource(), PMONITOR->m_scale);
g_pCompositor->setPreferredTransformForSurface(m_surface->resource(), PMONITOR->transform); g_pCompositor->setPreferredTransformForSurface(m_surface->resource(), PMONITOR->m_transform);
} }
void CLayerSurface::onUnmap() { void CLayerSurface::onUnmap() {
@@ -244,16 +244,16 @@ void CLayerSurface::onUnmap() {
} else if (g_pCompositor->m_lastFocus && g_pCompositor->m_lastFocus != m_surface->resource()) } else if (g_pCompositor->m_lastFocus && g_pCompositor->m_lastFocus != m_surface->resource())
g_pSeatManager->setKeyboardFocus(g_pCompositor->m_lastFocus.lock()); g_pSeatManager->setKeyboardFocus(g_pCompositor->m_lastFocus.lock());
CBox geomFixed = {m_geometry.x + PMONITOR->vecPosition.x, m_geometry.y + PMONITOR->vecPosition.y, m_geometry.width, m_geometry.height}; CBox geomFixed = {m_geometry.x + PMONITOR->m_position.x, m_geometry.y + PMONITOR->m_position.y, m_geometry.width, m_geometry.height};
g_pHyprRenderer->damageBox(geomFixed); g_pHyprRenderer->damageBox(geomFixed);
geomFixed = {m_geometry.x + (int)PMONITOR->vecPosition.x, m_geometry.y + (int)PMONITOR->vecPosition.y, (int)m_layerSurface->surface->current.size.x, geomFixed = {m_geometry.x + (int)PMONITOR->m_position.x, m_geometry.y + (int)PMONITOR->m_position.y, (int)m_layerSurface->surface->current.size.x,
(int)m_layerSurface->surface->current.size.y}; (int)m_layerSurface->surface->current.size.y};
g_pHyprRenderer->damageBox(geomFixed); g_pHyprRenderer->damageBox(geomFixed);
g_pInputManager->simulateMouseMovement(); g_pInputManager->simulateMouseMovement();
g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID); g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->m_id);
} }
void CLayerSurface::onCommit() { void CLayerSurface::onCommit() {
@@ -285,12 +285,12 @@ void CLayerSurface::onCommit() {
if (m_layerSurface->current.committed != 0) { if (m_layerSurface->current.committed != 0) {
if (m_layerSurface->current.committed & CLayerShellResource::eCommittedState::STATE_LAYER) { if (m_layerSurface->current.committed & CLayerShellResource::eCommittedState::STATE_LAYER) {
for (auto it = PMONITOR->m_aLayerSurfaceLayers[m_layer].begin(); it != PMONITOR->m_aLayerSurfaceLayers[m_layer].end(); it++) { for (auto it = PMONITOR->m_layerSurfaceLayers[m_layer].begin(); it != PMONITOR->m_layerSurfaceLayers[m_layer].end(); it++) {
if (*it == m_self) { if (*it == m_self) {
if (m_layerSurface->current.layer == m_layer) if (m_layerSurface->current.layer == m_layer)
break; break;
PMONITOR->m_aLayerSurfaceLayers[m_layerSurface->current.layer].emplace_back(*it); PMONITOR->m_layerSurfaceLayers[m_layerSurface->current.layer].emplace_back(*it);
PMONITOR->m_aLayerSurfaceLayers[m_layer].erase(it); PMONITOR->m_layerSurfaceLayers[m_layer].erase(it);
break; break;
} }
} }
@@ -301,14 +301,14 @@ void CLayerSurface::onCommit() {
g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR); // so that blur is recalc'd g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR); // so that blur is recalc'd
} }
g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID); g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->m_id);
PMONITOR->scheduledRecalc = true; PMONITOR->m_scheduledRecalc = true;
} else { } else {
m_position = Vector2D(m_geometry.x, m_geometry.y); m_position = Vector2D(m_geometry.x, m_geometry.y);
// update geom if it changed // update geom if it changed
if (m_layerSurface->surface->current.scale == 1 && PMONITOR->scale != 1.f && m_layerSurface->surface->current.viewport.hasDestination) { if (m_layerSurface->surface->current.scale == 1 && PMONITOR->m_scale != 1.f && m_layerSurface->surface->current.viewport.hasDestination) {
// fractional scaling. Dirty hack. // fractional scaling. Dirty hack.
m_geometry = {m_geometry.pos(), m_layerSurface->surface->current.viewport.destination}; m_geometry = {m_geometry.pos(), m_layerSurface->surface->current.viewport.destination};
} else { } else {
@@ -364,7 +364,7 @@ void CLayerSurface::onCommit() {
g_pInputManager->releaseAllMouseButtons(); g_pInputManager->releaseAllMouseButtons();
g_pCompositor->focusSurface(m_surface->resource()); g_pCompositor->focusSurface(m_surface->resource());
const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(m_geometry.x + PMONITOR->vecPosition.x, m_geometry.y + PMONITOR->vecPosition.y); const auto LOCAL = g_pInputManager->getMouseCoordsInternal() - Vector2D(m_geometry.x + PMONITOR->m_position.x, m_geometry.y + PMONITOR->m_position.y);
g_pSeatManager->setPointerFocus(m_surface->resource(), LOCAL); g_pSeatManager->setPointerFocus(m_surface->resource(), LOCAL);
g_pInputManager->m_bEmptyFocusCursorSet = false; g_pInputManager->m_bEmptyFocusCursorSet = false;
} }
@@ -374,8 +374,8 @@ void CLayerSurface::onCommit() {
g_pHyprRenderer->damageSurface(m_surface->resource(), m_position.x, m_position.y); g_pHyprRenderer->damageSurface(m_surface->resource(), m_position.x, m_position.y);
g_pCompositor->setPreferredScaleForSurface(m_surface->resource(), PMONITOR->scale); g_pCompositor->setPreferredScaleForSurface(m_surface->resource(), PMONITOR->m_scale);
g_pCompositor->setPreferredTransformForSurface(m_surface->resource(), PMONITOR->transform); g_pCompositor->setPreferredTransformForSurface(m_surface->resource(), PMONITOR->m_transform);
} }
void CLayerSurface::applyRules() { void CLayerSurface::applyRules() {
@@ -484,10 +484,10 @@ void CLayerSurface::startAnimation(bool in, bool instant) {
} }
const std::array<Vector2D, 4> edgePoints = { const std::array<Vector2D, 4> edgePoints = {
PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x / 2, 0.0}, PMONITOR->m_position + Vector2D{PMONITOR->m_size.x / 2, 0.0},
PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x / 2, PMONITOR->vecSize.y}, PMONITOR->m_position + Vector2D{PMONITOR->m_size.x / 2, PMONITOR->m_size.y},
PMONITOR->vecPosition + Vector2D{0.0, PMONITOR->vecSize.y}, PMONITOR->m_position + Vector2D{0.0, PMONITOR->m_size.y},
PMONITOR->vecPosition + Vector2D{PMONITOR->vecSize.x, PMONITOR->vecSize.y / 2}, PMONITOR->m_position + Vector2D{PMONITOR->m_size.x, PMONITOR->m_size.y / 2},
}; };
float closest = std::numeric_limits<float>::max(); float closest = std::numeric_limits<float>::max();
@@ -511,19 +511,19 @@ void CLayerSurface::startAnimation(bool in, bool instant) {
switch (leader) { switch (leader) {
case 0: case 0:
// TOP // TOP
prePos = {m_geometry.x, PMONITOR->vecPosition.y - m_geometry.h}; prePos = {m_geometry.x, PMONITOR->m_position.y - m_geometry.h};
break; break;
case 1: case 1:
// BOTTOM // BOTTOM
prePos = {m_geometry.x, PMONITOR->vecPosition.y + PMONITOR->vecSize.y}; prePos = {m_geometry.x, PMONITOR->m_position.y + PMONITOR->m_size.y};
break; break;
case 2: case 2:
// LEFT // LEFT
prePos = {PMONITOR->vecPosition.x - m_geometry.w, m_geometry.y}; prePos = {PMONITOR->m_position.x - m_geometry.w, m_geometry.y};
break; break;
case 3: case 3:
// RIGHT // RIGHT
prePos = {PMONITOR->vecPosition.x + PMONITOR->vecSize.x, m_geometry.y}; prePos = {PMONITOR->m_position.x + PMONITOR->m_size.x, m_geometry.y};
break; break;
default: UNREACHABLE(); default: UNREACHABLE();
} }
@@ -594,7 +594,7 @@ int CLayerSurface::popupsCount() {
} }
MONITORID CLayerSurface::monitorID() { MONITORID CLayerSurface::monitorID() {
return m_monitor ? m_monitor->ID : MONITOR_INVALID; return m_monitor ? m_monitor->m_id : MONITOR_INVALID;
} }
pid_t CLayerSurface::getPID() { pid_t CLayerSurface::getPID() {

4
src/desktop/Popup.cpp
View File

@@ -110,7 +110,7 @@ void CPopup::onMap() {
//unconstrain(); //unconstrain();
sendScale(); sendScale();
m_resource->surface->surface->enter(PMONITOR->self.lock()); m_resource->surface->surface->enter(PMONITOR->m_self.lock());
if (!m_layerOwner.expired() && m_layerOwner->m_layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP) if (!m_layerOwner.expired() && m_layerOwner->m_layer < ZWLR_LAYER_SHELL_V1_LAYER_TOP)
g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_layerOwner->m_layer)); g_pHyprOpenGL->markBlurDirtyForMonitor(g_pCompositor->getMonitorFromID(m_layerOwner->m_layer));
@@ -224,7 +224,7 @@ void CPopup::reposition() {
if (!PMONITOR) if (!PMONITOR)
return; return;
CBox box = {PMONITOR->vecPosition.x, PMONITOR->vecPosition.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y}; CBox box = {PMONITOR->m_position.x, PMONITOR->m_position.y, PMONITOR->m_size.x, PMONITOR->m_size.y};
m_resource->applyPositioning(box, COORDS); m_resource->applyPositioning(box, COORDS);
} }

86
src/desktop/Window.cpp
View File

@@ -137,8 +137,8 @@ SBoxExtents CWindow::getFullWindowExtents() {
if (m_windowData.dimAround.valueOrDefault()) { if (m_windowData.dimAround.valueOrDefault()) {
if (const auto PMONITOR = m_monitor.lock(); PMONITOR) if (const auto PMONITOR = m_monitor.lock(); PMONITOR)
return {{m_realPosition->value().x - PMONITOR->vecPosition.x, m_realPosition->value().y - PMONITOR->vecPosition.y}, return {{m_realPosition->value().x - PMONITOR->m_position.x, m_realPosition->value().y - PMONITOR->m_position.y},
{PMONITOR->vecSize.x - (m_realPosition->value().x - PMONITOR->vecPosition.x), PMONITOR->vecSize.y - (m_realPosition->value().y - PMONITOR->vecPosition.y)}}; {PMONITOR->m_size.x - (m_realPosition->value().x - PMONITOR->m_position.x), PMONITOR->m_size.y - (m_realPosition->value().y - PMONITOR->m_position.y)}};
} }
SBoxExtents maxExtents = {{BORDERSIZE + 2, BORDERSIZE + 2}, {BORDERSIZE + 2, BORDERSIZE + 2}}; SBoxExtents maxExtents = {{BORDERSIZE + 2, BORDERSIZE + 2}, {BORDERSIZE + 2, BORDERSIZE + 2}};
@@ -197,7 +197,7 @@ SBoxExtents CWindow::getFullWindowExtents() {
CBox CWindow::getFullWindowBoundingBox() { CBox CWindow::getFullWindowBoundingBox() {
if (m_windowData.dimAround.valueOrDefault()) { if (m_windowData.dimAround.valueOrDefault()) {
if (const auto PMONITOR = m_monitor.lock(); PMONITOR) if (const auto PMONITOR = m_monitor.lock(); PMONITOR)
return {PMONITOR->vecPosition.x, PMONITOR->vecPosition.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y}; return {PMONITOR->m_position.x, PMONITOR->m_position.y, PMONITOR->m_size.x, PMONITOR->m_size.y};
} }
auto maxExtents = getFullWindowExtents(); auto maxExtents = getFullWindowExtents();
@@ -218,25 +218,25 @@ CBox CWindow::getWindowIdealBoundingBoxIgnoreReserved() {
auto SIZE = m_size; auto SIZE = m_size;
if (isFullscreen()) { if (isFullscreen()) {
POS = PMONITOR->vecPosition; POS = PMONITOR->m_position;
SIZE = PMONITOR->vecSize; SIZE = PMONITOR->m_size;
return CBox{(int)POS.x, (int)POS.y, (int)SIZE.x, (int)SIZE.y}; return CBox{(int)POS.x, (int)POS.y, (int)SIZE.x, (int)SIZE.y};
} }
if (DELTALESSTHAN(POS.y - PMONITOR->vecPosition.y, PMONITOR->vecReservedTopLeft.y, 1)) { if (DELTALESSTHAN(POS.y - PMONITOR->m_position.y, PMONITOR->m_reservedTopLeft.y, 1)) {
POS.y = PMONITOR->vecPosition.y; POS.y = PMONITOR->m_position.y;
SIZE.y += PMONITOR->vecReservedTopLeft.y; SIZE.y += PMONITOR->m_reservedTopLeft.y;
} }
if (DELTALESSTHAN(POS.x - PMONITOR->vecPosition.x, PMONITOR->vecReservedTopLeft.x, 1)) { if (DELTALESSTHAN(POS.x - PMONITOR->m_position.x, PMONITOR->m_reservedTopLeft.x, 1)) {
POS.x = PMONITOR->vecPosition.x; POS.x = PMONITOR->m_position.x;
SIZE.x += PMONITOR->vecReservedTopLeft.x; SIZE.x += PMONITOR->m_reservedTopLeft.x;
} }
if (DELTALESSTHAN(POS.x + SIZE.x - PMONITOR->vecPosition.x, PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x, 1)) { if (DELTALESSTHAN(POS.x + SIZE.x - PMONITOR->m_position.x, PMONITOR->m_size.x - PMONITOR->m_reservedBottomRight.x, 1)) {
SIZE.x += PMONITOR->vecReservedBottomRight.x; SIZE.x += PMONITOR->m_reservedBottomRight.x;
} }
if (DELTALESSTHAN(POS.y + SIZE.y - PMONITOR->vecPosition.y, PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y, 1)) { if (DELTALESSTHAN(POS.y + SIZE.y - PMONITOR->m_position.y, PMONITOR->m_size.y - PMONITOR->m_reservedBottomRight.y, 1)) {
SIZE.y += PMONITOR->vecReservedBottomRight.y; SIZE.y += PMONITOR->m_reservedBottomRight.y;
} }
return CBox{(int)POS.x, (int)POS.y, (int)SIZE.x, (int)SIZE.y}; return CBox{(int)POS.x, (int)POS.y, (int)SIZE.x, (int)SIZE.y};
@@ -246,7 +246,7 @@ CBox CWindow::getWindowBoxUnified(uint64_t properties) {
if (m_windowData.dimAround.valueOrDefault()) { if (m_windowData.dimAround.valueOrDefault()) {
const auto PMONITOR = m_monitor.lock(); const auto PMONITOR = m_monitor.lock();
if (PMONITOR) if (PMONITOR)
return {PMONITOR->vecPosition.x, PMONITOR->vecPosition.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y}; return {PMONITOR->m_position.x, PMONITOR->m_position.y, PMONITOR->m_size.x, PMONITOR->m_size.y};
} }
SBoxExtents EXTENTS = {{0, 0}, {0, 0}}; SBoxExtents EXTENTS = {{0, 0}, {0, 0}};
@@ -385,10 +385,10 @@ void CWindow::updateSurfaceScaleTransformDetails(bool force) {
return; return;
if (PNEWMONITOR != PLASTMONITOR || force) { if (PNEWMONITOR != PLASTMONITOR || force) {
if (PLASTMONITOR && PLASTMONITOR->m_bEnabled && PNEWMONITOR != PLASTMONITOR) if (PLASTMONITOR && PLASTMONITOR->m_enabled && PNEWMONITOR != PLASTMONITOR)
m_wlSurface->resource()->breadthfirst([PLASTMONITOR](SP<CWLSurfaceResource> s, const Vector2D& offset, void* d) { s->leave(PLASTMONITOR->self.lock()); }, nullptr); m_wlSurface->resource()->breadthfirst([PLASTMONITOR](SP<CWLSurfaceResource> s, const Vector2D& offset, void* d) { s->leave(PLASTMONITOR->m_self.lock()); }, nullptr);
m_wlSurface->resource()->breadthfirst([PNEWMONITOR](SP<CWLSurfaceResource> s, const Vector2D& offset, void* d) { s->enter(PNEWMONITOR->self.lock()); }, nullptr); m_wlSurface->resource()->breadthfirst([PNEWMONITOR](SP<CWLSurfaceResource> s, const Vector2D& offset, void* d) { s->enter(PNEWMONITOR->m_self.lock()); }, nullptr);
} }
const auto PMONITOR = m_monitor.lock(); const auto PMONITOR = m_monitor.lock();
@@ -396,12 +396,12 @@ void CWindow::updateSurfaceScaleTransformDetails(bool force) {
m_wlSurface->resource()->breadthfirst( m_wlSurface->resource()->breadthfirst(
[PMONITOR](SP<CWLSurfaceResource> s, const Vector2D& offset, void* d) { [PMONITOR](SP<CWLSurfaceResource> s, const Vector2D& offset, void* d) {
const auto PSURFACE = CWLSurface::fromResource(s); const auto PSURFACE = CWLSurface::fromResource(s);
if (PSURFACE && PSURFACE->m_lastScaleFloat == PMONITOR->scale) if (PSURFACE && PSURFACE->m_lastScaleFloat == PMONITOR->m_scale)
return; return;
PROTO::fractional->sendScale(s, PMONITOR->scale); PROTO::fractional->sendScale(s, PMONITOR->m_scale);
g_pCompositor->setPreferredScaleForSurface(s, PMONITOR->scale); g_pCompositor->setPreferredScaleForSurface(s, PMONITOR->m_scale);
g_pCompositor->setPreferredTransformForSurface(s, PMONITOR->transform); g_pCompositor->setPreferredTransformForSurface(s, PMONITOR->m_transform);
}, },
nullptr); nullptr);
} }
@@ -520,14 +520,14 @@ void CWindow::onUnmap() {
if (*PCLOSEONLASTSPECIAL && m_workspace && m_workspace->getWindows() == 0 && onSpecialWorkspace()) { if (*PCLOSEONLASTSPECIAL && m_workspace && m_workspace->getWindows() == 0 && onSpecialWorkspace()) {
const auto PMONITOR = m_monitor.lock(); const auto PMONITOR = m_monitor.lock();
if (PMONITOR && PMONITOR->activeSpecialWorkspace && PMONITOR->activeSpecialWorkspace == m_workspace) if (PMONITOR && PMONITOR->m_activeSpecialWorkspace && PMONITOR->m_activeSpecialWorkspace == m_workspace)
PMONITOR->setSpecialWorkspace(nullptr); PMONITOR->setSpecialWorkspace(nullptr);
} }
const auto PMONITOR = m_monitor.lock(); const auto PMONITOR = m_monitor.lock();
if (PMONITOR && PMONITOR->solitaryClient == m_self) if (PMONITOR && PMONITOR->m_solitaryClient == m_self)
PMONITOR->solitaryClient.reset(); PMONITOR->m_solitaryClient.reset();
if (m_workspace) { if (m_workspace) {
m_workspace->updateWindows(); m_workspace->updateWindows();
@@ -1248,7 +1248,7 @@ void CWindow::setSuspended(bool suspend) {
bool CWindow::visibleOnMonitor(PHLMONITOR pMonitor) { bool CWindow::visibleOnMonitor(PHLMONITOR pMonitor) {
CBox wbox = {m_realPosition->value(), m_realSize->value()}; CBox wbox = {m_realPosition->value(), m_realSize->value()};
return !wbox.intersection({pMonitor->vecPosition, pMonitor->vecSize}).empty(); return !wbox.intersection({pMonitor->m_position, pMonitor->m_size}).empty();
} }
void CWindow::setAnimationsToMove() { void CWindow::setAnimationsToMove() {
@@ -1274,21 +1274,21 @@ void CWindow::onWorkspaceAnimUpdate() {
const auto WINBB = getFullWindowBoundingBox(); const auto WINBB = getFullWindowBoundingBox();
if (PWORKSPACE->m_renderOffset->value().x != 0) { if (PWORKSPACE->m_renderOffset->value().x != 0) {
const auto PROGRESS = PWORKSPACE->m_renderOffset->value().x / PWSMON->vecSize.x; const auto PROGRESS = PWORKSPACE->m_renderOffset->value().x / PWSMON->m_size.x;
if (WINBB.x < PWSMON->vecPosition.x) if (WINBB.x < PWSMON->m_position.x)
offset.x += (PWSMON->vecPosition.x - WINBB.x) * PROGRESS; offset.x += (PWSMON->m_position.x - WINBB.x) * PROGRESS;
if (WINBB.x + WINBB.width > PWSMON->vecPosition.x + PWSMON->vecSize.x) if (WINBB.x + WINBB.width > PWSMON->m_position.x + PWSMON->m_size.x)
offset.x += (WINBB.x + WINBB.width - PWSMON->vecPosition.x - PWSMON->vecSize.x) * PROGRESS; offset.x += (WINBB.x + WINBB.width - PWSMON->m_position.x - PWSMON->m_size.x) * PROGRESS;
} else if (PWORKSPACE->m_renderOffset->value().y != 0) { } else if (PWORKSPACE->m_renderOffset->value().y != 0) {
const auto PROGRESS = PWORKSPACE->m_renderOffset->value().y / PWSMON->vecSize.y; const auto PROGRESS = PWORKSPACE->m_renderOffset->value().y / PWSMON->m_size.y;
if (WINBB.y < PWSMON->vecPosition.y) if (WINBB.y < PWSMON->m_position.y)
offset.y += (PWSMON->vecPosition.y - WINBB.y) * PROGRESS; offset.y += (PWSMON->m_position.y - WINBB.y) * PROGRESS;
if (WINBB.y + WINBB.height > PWSMON->vecPosition.y + PWSMON->vecSize.y) if (WINBB.y + WINBB.height > PWSMON->m_position.y + PWSMON->m_size.y)
offset.y += (WINBB.y + WINBB.height - PWSMON->vecPosition.y - PWSMON->vecSize.y) * PROGRESS; offset.y += (WINBB.y + WINBB.height - PWSMON->m_position.y - PWSMON->m_size.y) * PROGRESS;
} }
m_floatingOffset = offset; m_floatingOffset = offset;
@@ -1342,7 +1342,7 @@ WORKSPACEID CWindow::workspaceID() {
} }
MONITORID CWindow::monitorID() { MONITORID CWindow::monitorID() {
return m_monitor ? m_monitor->ID : MONITOR_INVALID; return m_monitor ? m_monitor->m_id : MONITOR_INVALID;
} }
bool CWindow::onSpecialWorkspace() { bool CWindow::onSpecialWorkspace() {
@@ -1426,7 +1426,7 @@ void CWindow::onUpdateState() {
if (requestsID.has_value() && (requestsID.value() != MONITOR_INVALID) && !(m_suppressedEvents & SUPPRESS_FULLSCREEN_OUTPUT)) { if (requestsID.has_value() && (requestsID.value() != MONITOR_INVALID) && !(m_suppressedEvents & SUPPRESS_FULLSCREEN_OUTPUT)) {
if (m_isMapped) { if (m_isMapped) {
const auto monitor = g_pCompositor->getMonitorFromID(requestsID.value()); const auto monitor = g_pCompositor->getMonitorFromID(requestsID.value());
g_pCompositor->moveWindowToWorkspaceSafe(m_self.lock(), monitor->activeWorkspace); g_pCompositor->moveWindowToWorkspaceSafe(m_self.lock(), monitor->m_activeWorkspace);
g_pCompositor->setActiveMonitor(monitor); g_pCompositor->setActiveMonitor(monitor);
} }
@@ -1580,7 +1580,7 @@ void CWindow::onX11ConfigureRequest(CBox box) {
if (!m_workspace || !m_workspace->isVisible()) if (!m_workspace || !m_workspace->isVisible())
return; // further things are only for visible windows return; // further things are only for visible windows
m_workspace = g_pCompositor->getMonitorFromVector(m_realPosition->goal() + m_realSize->goal() / 2.f)->activeWorkspace; m_workspace = g_pCompositor->getMonitorFromVector(m_realPosition->goal() + m_realSize->goal() / 2.f)->m_activeWorkspace;
g_pCompositor->changeWindowZOrder(m_self.lock(), true); g_pCompositor->changeWindowZOrder(m_self.lock(), true);
@@ -1711,7 +1711,7 @@ Vector2D CWindow::realToReportSize() {
const auto PMONITOR = m_monitor.lock(); const auto PMONITOR = m_monitor.lock();
if (*PXWLFORCESCALEZERO && PMONITOR) if (*PXWLFORCESCALEZERO && PMONITOR)
return REPORTSIZE * PMONITOR->scale; return REPORTSIZE * PMONITOR->m_scale;
return REPORTSIZE; return REPORTSIZE;
} }
@@ -1728,7 +1728,7 @@ Vector2D CWindow::xwaylandSizeToReal(Vector2D size) {
const auto PMONITOR = m_monitor.lock(); const auto PMONITOR = m_monitor.lock();
const auto SIZE = size.clamp(Vector2D{1, 1}, Vector2D{std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity()}); const auto SIZE = size.clamp(Vector2D{1, 1}, Vector2D{std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity()});
const auto SCALE = *PXWLFORCESCALEZERO ? PMONITOR->scale : 1.0f; const auto SCALE = *PXWLFORCESCALEZERO ? PMONITOR->m_scale : 1.0f;
return SIZE / SCALE; return SIZE / SCALE;
} }
@@ -1743,7 +1743,7 @@ void CWindow::updateX11SurfaceScale() {
m_X11SurfaceScaledBy = 1.0f; m_X11SurfaceScaledBy = 1.0f;
if (m_isX11 && *PXWLFORCESCALEZERO) { if (m_isX11 && *PXWLFORCESCALEZERO) {
if (const auto PMONITOR = m_monitor.lock(); PMONITOR) if (const auto PMONITOR = m_monitor.lock(); PMONITOR)
m_X11SurfaceScaledBy = PMONITOR->scale; m_X11SurfaceScaledBy = PMONITOR->m_scale;
} }
} }

22
src/desktop/Workspace.cpp
View File

@@ -110,24 +110,24 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
if (ANIMSTYLE.starts_with("slidefadevert")) { if (ANIMSTYLE.starts_with("slidefadevert")) {
if (in) { if (in) {
m_alpha->setValueAndWarp(0.f); m_alpha->setValueAndWarp(0.f);
m_renderOffset->setValueAndWarp(Vector2D(0.0, (left ? PMONITOR->vecSize.y : -PMONITOR->vecSize.y) * (movePerc / 100.f))); m_renderOffset->setValueAndWarp(Vector2D(0.0, (left ? PMONITOR->m_size.y : -PMONITOR->m_size.y) * (movePerc / 100.f)));
*m_alpha = 1.f; *m_alpha = 1.f;
*m_renderOffset = Vector2D(0, 0); *m_renderOffset = Vector2D(0, 0);
} else { } else {
m_alpha->setValueAndWarp(1.f); m_alpha->setValueAndWarp(1.f);
*m_alpha = 0.f; *m_alpha = 0.f;
*m_renderOffset = Vector2D(0.0, (left ? -PMONITOR->vecSize.y : PMONITOR->vecSize.y) * (movePerc / 100.f)); *m_renderOffset = Vector2D(0.0, (left ? -PMONITOR->m_size.y : PMONITOR->m_size.y) * (movePerc / 100.f));
} }
} else { } else {
if (in) { if (in) {
m_alpha->setValueAndWarp(0.f); m_alpha->setValueAndWarp(0.f);
m_renderOffset->setValueAndWarp(Vector2D((left ? PMONITOR->vecSize.x : -PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0)); m_renderOffset->setValueAndWarp(Vector2D((left ? PMONITOR->m_size.x : -PMONITOR->m_size.x) * (movePerc / 100.f), 0.0));
*m_alpha = 1.f; *m_alpha = 1.f;
*m_renderOffset = Vector2D(0, 0); *m_renderOffset = Vector2D(0, 0);
} else { } else {
m_alpha->setValueAndWarp(1.f); m_alpha->setValueAndWarp(1.f);
*m_alpha = 0.f; *m_alpha = 0.f;
*m_renderOffset = Vector2D((left ? -PMONITOR->vecSize.x : PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0); *m_renderOffset = Vector2D((left ? -PMONITOR->m_size.x : PMONITOR->m_size.x) * (movePerc / 100.f), 0.0);
} }
} }
} else if (ANIMSTYLE == "fade") { } else if (ANIMSTYLE == "fade") {
@@ -143,7 +143,7 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
} else if (ANIMSTYLE == "slidevert") { } else if (ANIMSTYLE == "slidevert") {
// fallback is slide // fallback is slide
const auto PMONITOR = m_monitor.lock(); const auto PMONITOR = m_monitor.lock();
const auto YDISTANCE = PMONITOR->vecSize.y + *PWORKSPACEGAP; const auto YDISTANCE = PMONITOR->m_size.y + *PWORKSPACEGAP;
m_alpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide. m_alpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
@@ -156,7 +156,7 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
} else { } else {
// fallback is slide // fallback is slide
const auto PMONITOR = m_monitor.lock(); const auto PMONITOR = m_monitor.lock();
const auto XDISTANCE = PMONITOR->vecSize.x + *PWORKSPACEGAP; const auto XDISTANCE = PMONITOR->m_size.x + *PWORKSPACEGAP;
m_alpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide. m_alpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide.
@@ -520,7 +520,7 @@ bool CWorkspace::inert() {
} }
MONITORID CWorkspace::monitorID() { MONITORID CWorkspace::monitorID() {
return m_monitor ? m_monitor->ID : MONITOR_INVALID; return m_monitor ? m_monitor->m_id : MONITOR_INVALID;
} }
PHLWINDOW CWorkspace::getFullscreenWindow() { PHLWINDOW CWorkspace::getFullscreenWindow() {
@@ -538,10 +538,10 @@ bool CWorkspace::isVisible() {
bool CWorkspace::isVisibleNotCovered() { bool CWorkspace::isVisibleNotCovered() {
const auto PMONITOR = m_monitor.lock(); const auto PMONITOR = m_monitor.lock();
if (PMONITOR->activeSpecialWorkspace) if (PMONITOR->m_activeSpecialWorkspace)
return PMONITOR->activeSpecialWorkspace->m_id == m_id; return PMONITOR->m_activeSpecialWorkspace->m_id == m_id;
return PMONITOR->activeWorkspace->m_id == m_id; return PMONITOR->m_activeWorkspace->m_id == m_id;
} }
int CWorkspace::getWindows(std::optional<bool> onlyTiled, std::optional<bool> onlyPinned, std::optional<bool> onlyVisible) { int CWorkspace::getWindows(std::optional<bool> onlyTiled, std::optional<bool> onlyPinned, std::optional<bool> onlyVisible) {
@@ -597,7 +597,7 @@ PHLWINDOW CWorkspace::getTopLeftWindow() {
const auto WINDOWIDEALBB = w->getWindowIdealBoundingBoxIgnoreReserved(); const auto WINDOWIDEALBB = w->getWindowIdealBoundingBoxIgnoreReserved();
if (WINDOWIDEALBB.x <= PMONITOR->vecPosition.x + 1 && WINDOWIDEALBB.y <= PMONITOR->vecPosition.y + 1) if (WINDOWIDEALBB.x <= PMONITOR->m_position.x + 1 && WINDOWIDEALBB.y <= PMONITOR->m_position.y + 1)
return w; return w;
} }
return nullptr; return nullptr;

2
src/devices/VirtualPointer.cpp
View File

@@ -42,7 +42,7 @@ CVirtualPointer::CVirtualPointer(SP<CVirtualPointerV1Resource> resource) : m_poi
m_listeners.holdBegin = m_pointer->events.holdBegin.registerListener([this](std::any d) { m_pointerEvents.holdBegin.emit(d); }); m_listeners.holdBegin = m_pointer->events.holdBegin.registerListener([this](std::any d) { m_pointerEvents.holdBegin.emit(d); });
m_listeners.holdEnd = m_pointer->events.holdEnd.registerListener([this](std::any d) { m_pointerEvents.holdEnd.emit(d); }); m_listeners.holdEnd = m_pointer->events.holdEnd.registerListener([this](std::any d) { m_pointerEvents.holdEnd.emit(d); });
m_boundOutput = resource->boundOutput ? resource->boundOutput->szName : ""; m_boundOutput = resource->boundOutput ? resource->boundOutput->m_name : "";
m_deviceName = m_pointer->name; m_deviceName = m_pointer->name;
} }

74
src/events/Windows.cpp
View File

@@ -63,7 +63,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
g_pCompositor->setActiveMonitor(g_pCompositor->getMonitorFromVector({})); g_pCompositor->setActiveMonitor(g_pCompositor->getMonitorFromVector({}));
PMONITOR = g_pCompositor->m_lastMonitor.lock(); PMONITOR = g_pCompositor->m_lastMonitor.lock();
} }
auto PWORKSPACE = PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspace : PMONITOR->activeWorkspace; auto PWORKSPACE = PMONITOR->m_activeSpecialWorkspace ? PMONITOR->m_activeSpecialWorkspace : PMONITOR->m_activeWorkspace;
PWINDOW->m_monitor = PMONITOR; PWINDOW->m_monitor = PMONITOR;
PWINDOW->m_workspace = PWORKSPACE; PWINDOW->m_workspace = PWORKSPACE;
PWINDOW->m_isMapped = true; PWINDOW->m_isMapped = true;
@@ -172,7 +172,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
g_pKeybindManager->m_mDispatchers["focusmonitor"](std::to_string(PWINDOW->monitorID())); g_pKeybindManager->m_mDispatchers["focusmonitor"](std::to_string(PWINDOW->monitorID()));
PMONITOR = PMONITORFROMID; PMONITOR = PMONITORFROMID;
} }
PWINDOW->m_workspace = PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspace : PMONITOR->activeWorkspace; PWINDOW->m_workspace = PMONITOR->m_activeSpecialWorkspace ? PMONITOR->m_activeSpecialWorkspace : PMONITOR->m_activeWorkspace;
PWORKSPACE = PWINDOW->m_workspace; PWORKSPACE = PWINDOW->m_workspace;
Debug::log(LOG, "Rule monitor, applying to {:mw}", PWINDOW); Debug::log(LOG, "Rule monitor, applying to {:mw}", PWINDOW);
@@ -356,7 +356,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
PWINDOW->m_workspace = pWorkspace; PWINDOW->m_workspace = pWorkspace;
PWINDOW->m_monitor = pWorkspace->m_monitor; PWINDOW->m_monitor = pWorkspace->m_monitor;
if (PWINDOW->m_monitor.lock()->activeSpecialWorkspace && !pWorkspace->m_isSpecialWorkspace) if (PWINDOW->m_monitor.lock()->m_activeSpecialWorkspace && !pWorkspace->m_isSpecialWorkspace)
workspaceSilent = true; workspaceSilent = true;
if (!workspaceSilent) { if (!workspaceSilent) {
@@ -385,7 +385,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
g_pKeybindManager->m_mDispatchers["focusmonitor"](std::to_string(PWINDOW->monitorID())); g_pKeybindManager->m_mDispatchers["focusmonitor"](std::to_string(PWINDOW->monitorID()));
PMONITOR = PMONITORFROMID; PMONITOR = PMONITORFROMID;
} }
PWINDOW->m_workspace = PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspace : PMONITOR->activeWorkspace; PWINDOW->m_workspace = PMONITOR->m_activeSpecialWorkspace ? PMONITOR->m_activeSpecialWorkspace : PMONITOR->m_activeWorkspace;
PWORKSPACE = PWINDOW->m_workspace; PWORKSPACE = PWINDOW->m_workspace;
Debug::log(LOG, "Requested monitor, applying to {:mw}", PWINDOW); Debug::log(LOG, "Requested monitor, applying to {:mw}", PWINDOW);
@@ -432,11 +432,11 @@ void Events::listener_mapWindow(void* owner, void* data) {
const auto MAXSIZE = PWINDOW->requestedMaxSize(); const auto MAXSIZE = PWINDOW->requestedMaxSize();
const float SIZEX = SIZEXSTR == "max" ? std::clamp(MAXSIZE.x, MIN_WINDOW_SIZE, PMONITOR->vecSize.x) : const float SIZEX = SIZEXSTR == "max" ? std::clamp(MAXSIZE.x, MIN_WINDOW_SIZE, PMONITOR->m_size.x) :
stringToFloatClamp(SIZEXSTR, PWINDOW->m_realSize->goal().x, PMONITOR->vecSize.x); stringToFloatClamp(SIZEXSTR, PWINDOW->m_realSize->goal().x, PMONITOR->m_size.x);
const float SIZEY = SIZEYSTR == "max" ? std::clamp(MAXSIZE.y, MIN_WINDOW_SIZE, PMONITOR->vecSize.y) : const float SIZEY = SIZEYSTR == "max" ? std::clamp(MAXSIZE.y, MIN_WINDOW_SIZE, PMONITOR->m_size.y) :
stringToFloatClamp(SIZEYSTR, PWINDOW->m_realSize->goal().y, PMONITOR->vecSize.y); stringToFloatClamp(SIZEYSTR, PWINDOW->m_realSize->goal().y, PMONITOR->m_size.y);
Debug::log(LOG, "Rule size, applying to {}", PWINDOW); Debug::log(LOG, "Rule size, applying to {}", PWINDOW);
@@ -469,8 +469,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
if (POSXSTR.starts_with("100%-")) { if (POSXSTR.starts_with("100%-")) {
const bool subtractWindow = POSXSTR.starts_with("100%-w-"); const bool subtractWindow = POSXSTR.starts_with("100%-w-");
const auto POSXRAW = (subtractWindow) ? POSXSTR.substr(7) : POSXSTR.substr(5); const auto POSXRAW = (subtractWindow) ? POSXSTR.substr(7) : POSXSTR.substr(5);
posX = PMONITOR->vecSize.x - posX =
(!POSXRAW.contains('%') ? std::stoi(POSXRAW) : std::stof(POSXRAW.substr(0, POSXRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.x); PMONITOR->m_size.x - (!POSXRAW.contains('%') ? std::stoi(POSXRAW) : std::stof(POSXRAW.substr(0, POSXRAW.length() - 1)) * 0.01 * PMONITOR->m_size.x);
if (subtractWindow) if (subtractWindow)
posX -= PWINDOW->m_realSize->goal().x; posX -= PWINDOW->m_realSize->goal().x;
@@ -478,13 +478,13 @@ void Events::listener_mapWindow(void* owner, void* data) {
if (CURSOR) if (CURSOR)
Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!"); Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!");
} else if (!CURSOR) { } else if (!CURSOR) {
posX = !POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stof(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.x; posX = !POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stof(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PMONITOR->m_size.x;
} else { } else {
// cursor // cursor
if (POSXSTR == "cursor") { if (POSXSTR == "cursor") {
posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->vecPosition.x; posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->m_position.x;
} else { } else {
posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->vecPosition.x + posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->m_position.x +
(!POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stof(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PWINDOW->m_realSize->goal().x); (!POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stof(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PWINDOW->m_realSize->goal().x);
} }
} }
@@ -492,8 +492,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
if (POSYSTR.starts_with("100%-")) { if (POSYSTR.starts_with("100%-")) {
const bool subtractWindow = POSYSTR.starts_with("100%-w-"); const bool subtractWindow = POSYSTR.starts_with("100%-w-");
const auto POSYRAW = (subtractWindow) ? POSYSTR.substr(7) : POSYSTR.substr(5); const auto POSYRAW = (subtractWindow) ? POSYSTR.substr(7) : POSYSTR.substr(5);
posY = PMONITOR->vecSize.y - posY =
(!POSYRAW.contains('%') ? std::stoi(POSYRAW) : std::stof(POSYRAW.substr(0, POSYRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.y); PMONITOR->m_size.y - (!POSYRAW.contains('%') ? std::stoi(POSYRAW) : std::stof(POSYRAW.substr(0, POSYRAW.length() - 1)) * 0.01 * PMONITOR->m_size.y);
if (subtractWindow) if (subtractWindow)
posY -= PWINDOW->m_realSize->goal().y; posY -= PWINDOW->m_realSize->goal().y;
@@ -501,13 +501,13 @@ void Events::listener_mapWindow(void* owner, void* data) {
if (CURSOR) if (CURSOR)
Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!"); Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!");
} else if (!CURSOR) { } else if (!CURSOR) {
posY = !POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stof(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.y; posY = !POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stof(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PMONITOR->m_size.y;
} else { } else {
// cursor // cursor
if (POSYSTR == "cursor") { if (POSYSTR == "cursor") {
posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->vecPosition.y; posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->m_position.y;
} else { } else {
posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->vecPosition.y + posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->m_position.y +
(!POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stof(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PWINDOW->m_realSize->goal().y); (!POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stof(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PWINDOW->m_realSize->goal().y);
} }
} }
@@ -515,16 +515,16 @@ void Events::listener_mapWindow(void* owner, void* data) {
if (ONSCREEN) { if (ONSCREEN) {
int borderSize = PWINDOW->getRealBorderSize(); int borderSize = PWINDOW->getRealBorderSize();
posX = std::clamp(posX, (int)(PMONITOR->vecReservedTopLeft.x + borderSize), posX = std::clamp(posX, (int)(PMONITOR->m_reservedTopLeft.x + borderSize),
(int)(PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PWINDOW->m_realSize->goal().x - borderSize)); (int)(PMONITOR->m_size.x - PMONITOR->m_reservedBottomRight.x - PWINDOW->m_realSize->goal().x - borderSize));
posY = std::clamp(posY, (int)(PMONITOR->vecReservedTopLeft.y + borderSize), posY = std::clamp(posY, (int)(PMONITOR->m_reservedTopLeft.y + borderSize),
(int)(PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PWINDOW->m_realSize->goal().y - borderSize)); (int)(PMONITOR->m_size.y - PMONITOR->m_reservedBottomRight.y - PWINDOW->m_realSize->goal().y - borderSize));
} }
Debug::log(LOG, "Rule move, applying to {}", PWINDOW); Debug::log(LOG, "Rule move, applying to {}", PWINDOW);
*PWINDOW->m_realPosition = Vector2D(posX, posY) + PMONITOR->vecPosition; *PWINDOW->m_realPosition = Vector2D(posX, posY) + PMONITOR->m_position;
PWINDOW->setHidden(false); PWINDOW->setHidden(false);
} catch (...) { Debug::log(LOG, "Rule move failed, rule: {} -> {}", r->m_rule, r->m_value); } } catch (...) { Debug::log(LOG, "Rule move failed, rule: {} -> {}", r->m_rule, r->m_value); }
@@ -534,7 +534,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
auto RESERVEDOFFSET = Vector2D(); auto RESERVEDOFFSET = Vector2D();
const auto ARGS = CVarList(r->m_rule, 2, ' '); const auto ARGS = CVarList(r->m_rule, 2, ' ');
if (ARGS[1] == "1") if (ARGS[1] == "1")
RESERVEDOFFSET = (PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight) / 2.f; RESERVEDOFFSET = (PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight) / 2.f;
*PWINDOW->m_realPosition = PMONITOR->middle() - PWINDOW->m_realSize->goal() / 2.f + RESERVEDOFFSET; *PWINDOW->m_realPosition = PMONITOR->middle() - PWINDOW->m_realSize->goal() / 2.f + RESERVEDOFFSET;
break; break;
@@ -565,9 +565,9 @@ void Events::listener_mapWindow(void* owner, void* data) {
const auto MAXSIZE = PWINDOW->requestedMaxSize(); const auto MAXSIZE = PWINDOW->requestedMaxSize();
const float SIZEX = SIZEXSTR == "max" ? std::clamp(MAXSIZE.x, MIN_WINDOW_SIZE, PMONITOR->vecSize.x) : stringToPercentage(SIZEXSTR, PMONITOR->vecSize.x); const float SIZEX = SIZEXSTR == "max" ? std::clamp(MAXSIZE.x, MIN_WINDOW_SIZE, PMONITOR->m_size.x) : stringToPercentage(SIZEXSTR, PMONITOR->m_size.x);
const float SIZEY = SIZEYSTR == "max" ? std::clamp(MAXSIZE.y, MIN_WINDOW_SIZE, PMONITOR->vecSize.y) : stringToPercentage(SIZEYSTR, PMONITOR->vecSize.y); const float SIZEY = SIZEYSTR == "max" ? std::clamp(MAXSIZE.y, MIN_WINDOW_SIZE, PMONITOR->m_size.y) : stringToPercentage(SIZEYSTR, PMONITOR->m_size.y);
Debug::log(LOG, "Rule size (tiled), applying to {}", PWINDOW); Debug::log(LOG, "Rule size (tiled), applying to {}", PWINDOW);
@@ -662,7 +662,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
PWINDOW->m_firstMap = false; PWINDOW->m_firstMap = false;
Debug::log(LOG, "Map request dispatched, monitor {}, window pos: {:5j}, window size: {:5j}", PMONITOR->szName, PWINDOW->m_realPosition->goal(), PWINDOW->m_realSize->goal()); Debug::log(LOG, "Map request dispatched, monitor {}, window pos: {:5j}, window size: {:5j}", PMONITOR->m_name, PWINDOW->m_realPosition->goal(), PWINDOW->m_realSize->goal());
auto workspaceID = requestedWorkspace != "" ? requestedWorkspace : PWORKSPACE->m_name; auto workspaceID = requestedWorkspace != "" ? requestedWorkspace : PWORKSPACE->m_name;
g_pEventManager->postEvent(SHyprIPCEvent{"openwindow", std::format("{:x},{},{},{}", PWINDOW, workspaceID, PWINDOW->m_class, PWINDOW->m_title)}); g_pEventManager->postEvent(SHyprIPCEvent{"openwindow", std::format("{:x},{},{},{}", PWINDOW, workspaceID, PWINDOW->m_class, PWINDOW->m_title)});
@@ -687,8 +687,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
if (PWORKSPACE->m_hasFullscreenWindow && !PWINDOW->isFullscreen() && !PWINDOW->m_isFloating) if (PWORKSPACE->m_hasFullscreenWindow && !PWINDOW->isFullscreen() && !PWINDOW->m_isFloating)
PWINDOW->m_alpha->setValueAndWarp(0.f); PWINDOW->m_alpha->setValueAndWarp(0.f);
g_pCompositor->setPreferredScaleForSurface(PWINDOW->m_wlSurface->resource(), PMONITOR->scale); g_pCompositor->setPreferredScaleForSurface(PWINDOW->m_wlSurface->resource(), PMONITOR->m_scale);
g_pCompositor->setPreferredTransformForSurface(PWINDOW->m_wlSurface->resource(), PMONITOR->transform); g_pCompositor->setPreferredTransformForSurface(PWINDOW->m_wlSurface->resource(), PMONITOR->m_transform);
if (g_pSeatManager->mouse.expired() || !g_pInputManager->isConstrained()) if (g_pSeatManager->mouse.expired() || !g_pInputManager->isConstrained())
g_pInputManager->sendMotionEventsToFocused(); g_pInputManager->sendMotionEventsToFocused();
@@ -700,7 +700,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
PWINDOW->m_workspace->updateWindows(); PWINDOW->m_workspace->updateWindows();
if (PMONITOR && PWINDOW->isX11OverrideRedirect()) if (PMONITOR && PWINDOW->isX11OverrideRedirect())
PWINDOW->m_X11SurfaceScaledBy = PMONITOR->scale; PWINDOW->m_X11SurfaceScaledBy = PMONITOR->m_scale;
} }
void Events::listener_unmapWindow(void* owner, void* data) { void Events::listener_unmapWindow(void* owner, void* data) {
@@ -721,7 +721,7 @@ void Events::listener_unmapWindow(void* owner, void* data) {
const auto PMONITOR = PWINDOW->m_monitor.lock(); const auto PMONITOR = PWINDOW->m_monitor.lock();
if (PMONITOR) { if (PMONITOR) {
PWINDOW->m_originalClosedPos = PWINDOW->m_realPosition->value() - PMONITOR->vecPosition; PWINDOW->m_originalClosedPos = PWINDOW->m_realPosition->value() - PMONITOR->m_position;
PWINDOW->m_originalClosedSize = PWINDOW->m_realSize->value(); PWINDOW->m_originalClosedSize = PWINDOW->m_realSize->value();
PWINDOW->m_originalClosedExtents = PWINDOW->getFullWindowExtents(); PWINDOW->m_originalClosedExtents = PWINDOW->getFullWindowExtents();
} }
@@ -892,14 +892,14 @@ void Events::listener_commitWindow(void* owner, void* data) {
} }
// tearing: if solitary, redraw it. This still might be a single surface window // tearing: if solitary, redraw it. This still might be a single surface window
if (PMONITOR && PMONITOR->solitaryClient.lock() == PWINDOW && PWINDOW->canBeTorn() && PMONITOR->tearingState.canTear && PWINDOW->m_wlSurface->resource()->current.texture) { if (PMONITOR && PMONITOR->m_solitaryClient.lock() == PWINDOW && PWINDOW->canBeTorn() && PMONITOR->m_tearingState.canTear && PWINDOW->m_wlSurface->resource()->current.texture) {
CRegion damageBox{PWINDOW->m_wlSurface->resource()->current.accumulateBufferDamage()}; CRegion damageBox{PWINDOW->m_wlSurface->resource()->current.accumulateBufferDamage()};
if (!damageBox.empty()) { if (!damageBox.empty()) {
if (PMONITOR->tearingState.busy) { if (PMONITOR->m_tearingState.busy) {
PMONITOR->tearingState.frameScheduledWhileBusy = true; PMONITOR->m_tearingState.frameScheduledWhileBusy = true;
} else { } else {
PMONITOR->tearingState.nextRenderTorn = true; PMONITOR->m_tearingState.nextRenderTorn = true;
g_pHyprRenderer->renderMonitor(PMONITOR); g_pHyprRenderer->renderMonitor(PMONITOR);
} }
} }
@@ -998,14 +998,14 @@ void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
if (*PXWLFORCESCALEZERO) { if (*PXWLFORCESCALEZERO) {
if (const auto PMONITOR = PWINDOW->m_monitor.lock(); PMONITOR) { if (const auto PMONITOR = PWINDOW->m_monitor.lock(); PMONITOR) {
PWINDOW->m_realSize->setValueAndWarp(PWINDOW->m_realSize->goal() / PMONITOR->scale); PWINDOW->m_realSize->setValueAndWarp(PWINDOW->m_realSize->goal() / PMONITOR->m_scale);
} }
} }
PWINDOW->m_position = PWINDOW->m_realPosition->goal(); PWINDOW->m_position = PWINDOW->m_realPosition->goal();
PWINDOW->m_size = PWINDOW->m_realSize->goal(); PWINDOW->m_size = PWINDOW->m_realSize->goal();
PWINDOW->m_workspace = g_pCompositor->getMonitorFromVector(PWINDOW->m_realPosition->value() + PWINDOW->m_realSize->value() / 2.f)->activeWorkspace; PWINDOW->m_workspace = g_pCompositor->getMonitorFromVector(PWINDOW->m_realPosition->value() + PWINDOW->m_realSize->value() / 2.f)->m_activeWorkspace;
g_pCompositor->changeWindowZOrder(PWINDOW, true); g_pCompositor->changeWindowZOrder(PWINDOW, true);
PWINDOW->updateWindowDecos(); PWINDOW->updateWindowDecos();

10
src/helpers/Color.cpp
View File

@@ -8,11 +8,11 @@
CHyprColor::CHyprColor() = default; CHyprColor::CHyprColor() = default;
CHyprColor::CHyprColor(float r_, float g_, float b_, float a_) : r(r_), g(g_), b(b_), a(a_) { CHyprColor::CHyprColor(float r_, float g_, float b_, float a_) : r(r_), g(g_), b(b_), a(a_) {
okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab(); m_okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab();
} }
CHyprColor::CHyprColor(uint64_t hex) : r(RED(hex)), g(GREEN(hex)), b(BLUE(hex)), a(ALPHA(hex)) { CHyprColor::CHyprColor(uint64_t hex) : r(RED(hex)), g(GREEN(hex)), b(BLUE(hex)), a(ALPHA(hex)) {
okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab(); m_okLab = Hyprgraphics::CColor(Hyprgraphics::CColor::SSRGB{r, g, b}).asOkLab();
} }
CHyprColor::CHyprColor(const Hyprgraphics::CColor& color, float a_) : a(a_) { CHyprColor::CHyprColor(const Hyprgraphics::CColor& color, float a_) : a(a_) {
@@ -21,7 +21,7 @@ CHyprColor::CHyprColor(const Hyprgraphics::CColor& color, float a_) : a(a_) {
g = SRGB.g; g = SRGB.g;
b = SRGB.b; b = SRGB.b;
okLab = color.asOkLab(); m_okLab = color.asOkLab();
} }
uint32_t CHyprColor::getAsHex() const { uint32_t CHyprColor::getAsHex() const {
@@ -33,11 +33,11 @@ Hyprgraphics::CColor::SSRGB CHyprColor::asRGB() const {
} }
Hyprgraphics::CColor::SOkLab CHyprColor::asOkLab() const { Hyprgraphics::CColor::SOkLab CHyprColor::asOkLab() const {
return okLab; return m_okLab;
} }
Hyprgraphics::CColor::SHSL CHyprColor::asHSL() const { Hyprgraphics::CColor::SHSL CHyprColor::asHSL() const {
return Hyprgraphics::CColor(okLab).asHSL(); return Hyprgraphics::CColor(m_okLab).asHSL();
} }
CHyprColor CHyprColor::stripA() const { CHyprColor CHyprColor::stripA() const {

2
src/helpers/Color.hpp
View File

@@ -43,7 +43,7 @@ class CHyprColor {
double r = 0, g = 0, b = 0, a = 0; double r = 0, g = 0, b = 0, a = 0;
private: private:
Hyprgraphics::CColor::SOkLab okLab; // cache for the OkLab representation Hyprgraphics::CColor::SOkLab m_okLab; // cache for the OkLab representation
}; };
//NOLINTNEXTLINE //NOLINTNEXTLINE

26
src/helpers/DamageRing.cpp
View File

@@ -1,43 +1,43 @@
#include "DamageRing.hpp" #include "DamageRing.hpp"
void CDamageRing::setSize(const Vector2D& size_) { void CDamageRing::setSize(const Vector2D& size_) {
if (size_ == size) if (size_ == m_size)
return; return;
size = size_; m_size = size_;
damageEntire(); damageEntire();
} }
bool CDamageRing::damage(const CRegion& rg) { bool CDamageRing::damage(const CRegion& rg) {
CRegion clipped = rg.copy().intersect(CBox{{}, size}); CRegion clipped = rg.copy().intersect(CBox{{}, m_size});
if (clipped.empty()) if (clipped.empty())
return false; return false;
current.add(clipped); m_current.add(clipped);
return true; return true;
} }
void CDamageRing::damageEntire() { void CDamageRing::damageEntire() {
damage(CBox{{}, size}); damage(CBox{{}, m_size});
} }
void CDamageRing::rotate() { void CDamageRing::rotate() {
previousIdx = (previousIdx + DAMAGE_RING_PREVIOUS_LEN - 1) % DAMAGE_RING_PREVIOUS_LEN; m_previousIdx = (m_previousIdx + DAMAGE_RING_PREVIOUS_LEN - 1) % DAMAGE_RING_PREVIOUS_LEN;
previous[previousIdx] = current; m_previous[m_previousIdx] = m_current;
current.clear(); m_current.clear();
} }
CRegion CDamageRing::getBufferDamage(int age) { CRegion CDamageRing::getBufferDamage(int age) {
if (age <= 0 || age > DAMAGE_RING_PREVIOUS_LEN + 1) if (age <= 0 || age > DAMAGE_RING_PREVIOUS_LEN + 1)
return CBox{{}, size}; return CBox{{}, m_size};
CRegion damage = current; CRegion damage = m_current;
for (int i = 0; i < age - 1; ++i) { for (int i = 0; i < age - 1; ++i) {
int j = (previousIdx + i) % DAMAGE_RING_PREVIOUS_LEN; int j = (m_previousIdx + i) % DAMAGE_RING_PREVIOUS_LEN;
damage.add(previous.at(j)); damage.add(m_previous.at(j));
} }
// don't return a ludicrous amount of rects // don't return a ludicrous amount of rects
@@ -48,5 +48,5 @@ CRegion CDamageRing::getBufferDamage(int age) {
} }
bool CDamageRing::hasChanged() { bool CDamageRing::hasChanged() {
return !current.empty(); return !m_current.empty();
} }

8
src/helpers/DamageRing.hpp
View File

@@ -15,8 +15,8 @@ class CDamageRing {
bool hasChanged(); bool hasChanged();
private: private:
Vector2D size; Vector2D m_size;
CRegion current; CRegion m_current;
std::array<CRegion, DAMAGE_RING_PREVIOUS_LEN> previous; std::array<CRegion, DAMAGE_RING_PREVIOUS_LEN> m_previous;
size_t previousIdx = 0; size_t m_previousIdx = 0;
}; };

14
src/helpers/MiscFunctions.cpp
View File

@@ -148,7 +148,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
if (same_mon) { if (same_mon) {
for (auto const& rule : g_pConfigManager->getAllWorkspaceRules()) { for (auto const& rule : g_pConfigManager->getAllWorkspaceRules()) {
const auto PMONITOR = g_pCompositor->getMonitorFromName(rule.monitor); const auto PMONITOR = g_pCompositor->getMonitorFromName(rule.monitor);
if (PMONITOR && (PMONITOR->ID != g_pCompositor->m_lastMonitor->ID)) if (PMONITOR && (PMONITOR->m_id != g_pCompositor->m_lastMonitor->m_id))
invalidWSes.insert(rule.workspaceId); invalidWSes.insert(rule.workspaceId);
} }
} }
@@ -165,7 +165,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
if (!g_pCompositor->m_lastMonitor) if (!g_pCompositor->m_lastMonitor)
return {WORKSPACE_INVALID}; return {WORKSPACE_INVALID};
const auto PWORKSPACE = g_pCompositor->m_lastMonitor->activeWorkspace; const auto PWORKSPACE = g_pCompositor->m_lastMonitor->m_activeWorkspace;
if (!valid(PWORKSPACE)) if (!valid(PWORKSPACE))
return {WORKSPACE_INVALID}; return {WORKSPACE_INVALID};
@@ -184,12 +184,12 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
return {PLASTWORKSPACE->m_id, PLASTWORKSPACE->m_name}; return {PLASTWORKSPACE->m_id, PLASTWORKSPACE->m_name};
} else if (in == "next") { } else if (in == "next") {
if (!g_pCompositor->m_lastMonitor || !g_pCompositor->m_lastMonitor->activeWorkspace) { if (!g_pCompositor->m_lastMonitor || !g_pCompositor->m_lastMonitor->m_activeWorkspace) {
Debug::log(ERR, "no active monitor or workspace for 'next'"); Debug::log(ERR, "no active monitor or workspace for 'next'");
return {WORKSPACE_INVALID}; return {WORKSPACE_INVALID};
} }
auto PCURRENTWORKSPACE = g_pCompositor->m_lastMonitor->activeWorkspace; auto PCURRENTWORKSPACE = g_pCompositor->m_lastMonitor->m_activeWorkspace;
WORKSPACEID nextId = PCURRENTWORKSPACE->m_id + 1; WORKSPACEID nextId = PCURRENTWORKSPACE->m_id + 1;
@@ -227,7 +227,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
} }
for (auto const& rule : g_pConfigManager->getAllWorkspaceRules()) { for (auto const& rule : g_pConfigManager->getAllWorkspaceRules()) {
const auto PMONITOR = g_pCompositor->getMonitorFromName(rule.monitor); const auto PMONITOR = g_pCompositor->getMonitorFromName(rule.monitor);
if (!PMONITOR || PMONITOR->ID == g_pCompositor->m_lastMonitor->ID) { if (!PMONITOR || PMONITOR->m_id == g_pCompositor->m_lastMonitor->m_id) {
// Can't be invalid // Can't be invalid
continue; continue;
} }
@@ -265,7 +265,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
} else { } else {
// Just take a blind guess at where we'll probably end up // Just take a blind guess at where we'll probably end up
WORKSPACEID activeWSID = g_pCompositor->m_lastMonitor->activeWorkspace ? g_pCompositor->m_lastMonitor->activeWorkspace->m_id : 1; WORKSPACEID activeWSID = g_pCompositor->m_lastMonitor->m_activeWorkspace ? g_pCompositor->m_lastMonitor->m_activeWorkspace->m_id : 1;
WORKSPACEID predictedWSID = activeWSID + remains; WORKSPACEID predictedWSID = activeWSID + remains;
int remainingWSes = 0; int remainingWSes = 0;
char walkDir = in[1]; char walkDir = in[1];
@@ -407,7 +407,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) {
remains = remains < 0 ? -((-remains) % validWSes.size()) : remains % validWSes.size(); remains = remains < 0 ? -((-remains) % validWSes.size()) : remains % validWSes.size();
// get the current item // get the current item
WORKSPACEID activeWSID = g_pCompositor->m_lastMonitor->activeWorkspace ? g_pCompositor->m_lastMonitor->activeWorkspace->m_id : 1; WORKSPACEID activeWSID = g_pCompositor->m_lastMonitor->m_activeWorkspace ? g_pCompositor->m_lastMonitor->m_activeWorkspace->m_id : 1;
for (ssize_t i = 0; i < (ssize_t)validWSes.size(); i++) { for (ssize_t i = 0; i < (ssize_t)validWSes.size(); i++) {
if (validWSes[i] == activeWSID) { if (validWSes[i] == activeWSID) {
currentItem = i; currentItem = i;

879
src/helpers/Monitor.cpp
View File

File diff suppressed because it is too large Load Diff

132
src/helpers/Monitor.hpp
View File

@@ -71,7 +71,7 @@ class CMonitorState {
private: private:
void ensureBufferPresent(); void ensureBufferPresent();
CMonitor* m_pOwner = nullptr; CMonitor* m_owner = nullptr;
}; };
class CMonitor { class CMonitor {
@@ -79,84 +79,82 @@ class CMonitor {
CMonitor(SP<Aquamarine::IOutput> output); CMonitor(SP<Aquamarine::IOutput> output);
~CMonitor(); ~CMonitor();
Vector2D vecPosition = Vector2D(-1, -1); // means unset Vector2D m_position = Vector2D(-1, -1); // means unset
Vector2D vecXWaylandPosition = Vector2D(-1, -1); // means unset Vector2D m_xwaylandPosition = Vector2D(-1, -1); // means unset
Vector2D vecSize = Vector2D(0, 0); Vector2D m_size = Vector2D(0, 0);
Vector2D vecPixelSize = Vector2D(0, 0); Vector2D m_pixelSize = Vector2D(0, 0);
Vector2D vecTransformedSize = Vector2D(0, 0); Vector2D m_transformedSize = Vector2D(0, 0);
bool primary = false; MONITORID m_id = MONITOR_INVALID;
PHLWORKSPACE m_activeWorkspace = nullptr;
PHLWORKSPACE m_activeSpecialWorkspace = nullptr;
float m_setScale = 1; // scale set by cfg
float m_scale = 1; // real scale
MONITORID ID = MONITOR_INVALID; std::string m_name = "";
PHLWORKSPACE activeWorkspace = nullptr; std::string m_description = "";
PHLWORKSPACE activeSpecialWorkspace = nullptr; std::string m_shortDescription = "";
float setScale = 1; // scale set by cfg
float scale = 1; // real scale
std::string szName = ""; Vector2D m_reservedTopLeft = Vector2D(0, 0);
std::string szDescription = ""; Vector2D m_reservedBottomRight = Vector2D(0, 0);
std::string szShortDescription = "";
Vector2D vecReservedTopLeft = Vector2D(0, 0); drmModeModeInfo m_customDrmMode = {};
Vector2D vecReservedBottomRight = Vector2D(0, 0);
drmModeModeInfo customDrmMode = {}; CMonitorState m_state;
CDamageRing m_damage;
CMonitorState state; SP<Aquamarine::IOutput> m_output;
CDamageRing damage; float m_refreshRate = 60; // Hz
int m_forceFullFrames = 0;
bool m_scheduledRecalc = false;
wl_output_transform m_transform = WL_OUTPUT_TRANSFORM_NORMAL;
float m_xwaylandScale = 1.f;
Mat3x3 m_projMatrix;
std::optional<Vector2D> m_forceSize;
SP<Aquamarine::SOutputMode> m_currentMode;
SP<Aquamarine::CSwapchain> m_cursorSwapchain;
uint32_t m_drmFormat = DRM_FORMAT_INVALID;
uint32_t m_prevDrmFormat = DRM_FORMAT_INVALID;
SP<Aquamarine::IOutput> output; bool m_dpmsStatus = true;
float refreshRate = 60; // Hz bool m_vrrActive = false; // this can be TRUE even if VRR is not active in the case that this display does not support it.
int forceFullFrames = 0; bool m_enabled10bit = false; // as above, this can be TRUE even if 10 bit failed.
bool scheduledRecalc = false; eCMType m_cmType = CM_SRGB;
wl_output_transform transform = WL_OUTPUT_TRANSFORM_NORMAL; float m_sdrSaturation = 1.0f;
float xwaylandScale = 1.f; float m_sdrBrightness = 1.0f;
Mat3x3 projMatrix; bool m_createdByUser = false;
std::optional<Vector2D> forceSize; bool m_isUnsafeFallback = false;
SP<Aquamarine::SOutputMode> currentMode;
SP<Aquamarine::CSwapchain> cursorSwapchain;
uint32_t drmFormat = DRM_FORMAT_INVALID;
uint32_t prevDrmFormat = DRM_FORMAT_INVALID;
bool dpmsStatus = true; bool m_pendingFrame = false; // if we schedule a frame during rendering, reschedule it after
bool vrrActive = false; // this can be TRUE even if VRR is not active in the case that this display does not support it. bool m_renderingActive = false;
bool enabled10bit = false; // as above, this can be TRUE even if 10 bit failed.
eCMType cmType = CM_SRGB;
float sdrSaturation = 1.0f;
float sdrBrightness = 1.0f;
bool createdByUser = false;
bool isUnsafeFallback = false;
bool pendingFrame = false; // if we schedule a frame during rendering, reschedule it after wl_event_source* m_renderTimer = nullptr; // for RAT
bool renderingActive = false; bool m_ratsScheduled = false;
CTimer m_lastPresentationTimer;
wl_event_source* renderTimer = nullptr; // for RAT bool m_isBeingLeased = false;
bool RATScheduled = false;
CTimer lastPresentationTimer;
bool isBeingLeased = false; SMonitorRule m_activeMonitorRule;
SMonitorRule activeMonitorRule;
// explicit sync // explicit sync
Hyprutils::OS::CFileDescriptor inFence; // TODO: remove when aq uses CFileDescriptor Hyprutils::OS::CFileDescriptor m_inFence; // TODO: remove when aq uses CFileDescriptor
PHLMONITORREF self; PHLMONITORREF m_self;
// mirroring // mirroring
PHLMONITORREF pMirrorOf; PHLMONITORREF m_mirrorOf;
std::vector<PHLMONITORREF> mirrors; std::vector<PHLMONITORREF> m_mirrors;
// ctm // ctm
Mat3x3 ctm = Mat3x3::identity(); Mat3x3 m_ctm = Mat3x3::identity();
bool ctmUpdated = false; bool m_ctmUpdated = false;
// for tearing // for tearing
PHLWINDOWREF solitaryClient; PHLWINDOWREF m_solitaryClient;
// for direct scanout // for direct scanout
PHLWINDOWREF lastScanout; PHLWINDOWREF m_lastScanout;
bool scanoutNeedsCursorUpdate = false; bool m_scanoutNeedsCursorUpdate = false;
struct { struct {
bool canTear = false; bool canTear = false;
@@ -165,7 +163,7 @@ class CMonitor {
bool busy = false; bool busy = false;
bool frameScheduledWhileBusy = false; bool frameScheduledWhileBusy = false;
} tearingState; } m_tearingState;
struct { struct {
CSignal destroy; CSignal destroy;
@@ -173,9 +171,9 @@ class CMonitor {
CSignal disconnect; CSignal disconnect;
CSignal dpmsChanged; CSignal dpmsChanged;
CSignal modeChanged; CSignal modeChanged;
} events; } m_events;
std::array<std::vector<PHLLSREF>, 4> m_aLayerSurfaceLayers; std::array<std::vector<PHLLSREF>, 4> m_layerSurfaceLayers;
// methods // methods
void onConnect(bool noRule); void onConnect(bool noRule);
@@ -207,15 +205,15 @@ class CMonitor {
void debugLastPresentation(const std::string& message); void debugLastPresentation(const std::string& message);
void onMonitorFrame(); void onMonitorFrame();
bool m_bEnabled = false; bool m_enabled = false;
bool m_bRenderingInitPassed = false; bool m_renderingInitPassed = false;
WP<CWindow> m_previousFSWindow; WP<CWindow> m_previousFSWindow;
NColorManagement::SImageDescription imageDescription; NColorManagement::SImageDescription m_imageDescription;
// For the list lookup // For the list lookup
bool operator==(const CMonitor& rhs) { bool operator==(const CMonitor& rhs) {
return vecPosition == rhs.vecPosition && vecSize == rhs.vecSize && szName == rhs.szName; return m_position == rhs.m_position && m_size == rhs.m_size && m_name == rhs.m_name;
} }
// workspace previous per monitor functionality // workspace previous per monitor functionality
@@ -226,8 +224,8 @@ class CMonitor {
void setupDefaultWS(const SMonitorRule&); void setupDefaultWS(const SMonitorRule&);
WORKSPACEID findAvailableDefaultWS(); WORKSPACEID findAvailableDefaultWS();
bool doneScheduled = false; bool m_doneScheduled = false;
std::stack<WORKSPACEID> prevWorkSpaces; std::stack<WORKSPACEID> m_prevWorkSpaces;
struct { struct {
CHyprSignalListener frame; CHyprSignalListener frame;
@@ -236,5 +234,5 @@ class CMonitor {
CHyprSignalListener needsFrame; CHyprSignalListener needsFrame;
CHyprSignalListener presented; CHyprSignalListener presented;
CHyprSignalListener commit; CHyprSignalListener commit;
} listeners; } m_listeners;
}; };

54
src/helpers/sync/SyncTimeline.cpp
View File

@@ -8,10 +8,10 @@ using namespace Hyprutils::OS;
SP<CSyncTimeline> CSyncTimeline::create(int drmFD_) { SP<CSyncTimeline> CSyncTimeline::create(int drmFD_) {
auto timeline = SP<CSyncTimeline>(new CSyncTimeline); auto timeline = SP<CSyncTimeline>(new CSyncTimeline);
timeline->drmFD = drmFD_; timeline->m_drmFD = drmFD_;
timeline->self = timeline; timeline->m_self = timeline;
if (drmSyncobjCreate(drmFD_, 0, &timeline->handle)) { if (drmSyncobjCreate(drmFD_, 0, &timeline->m_handle)) {
Debug::log(ERR, "CSyncTimeline: failed to create a drm syncobj??"); Debug::log(ERR, "CSyncTimeline: failed to create a drm syncobj??");
return nullptr; return nullptr;
} }
@@ -21,11 +21,11 @@ SP<CSyncTimeline> CSyncTimeline::create(int drmFD_) {
SP<CSyncTimeline> CSyncTimeline::create(int drmFD_, CFileDescriptor&& drmSyncobjFD) { SP<CSyncTimeline> CSyncTimeline::create(int drmFD_, CFileDescriptor&& drmSyncobjFD) {
auto timeline = SP<CSyncTimeline>(new CSyncTimeline); auto timeline = SP<CSyncTimeline>(new CSyncTimeline);
timeline->drmFD = drmFD_; timeline->m_drmFD = drmFD_;
timeline->syncobjFd = std::move(drmSyncobjFD); timeline->m_syncobjFD = std::move(drmSyncobjFD);
timeline->self = timeline; timeline->m_self = timeline;
if (drmSyncobjFDToHandle(drmFD_, timeline->syncobjFd.get(), &timeline->handle)) { if (drmSyncobjFDToHandle(drmFD_, timeline->m_syncobjFD.get(), &timeline->m_handle)) {
Debug::log(ERR, "CSyncTimeline: failed to create a drm syncobj from fd??"); Debug::log(ERR, "CSyncTimeline: failed to create a drm syncobj from fd??");
return nullptr; return nullptr;
} }
@@ -34,10 +34,10 @@ SP<CSyncTimeline> CSyncTimeline::create(int drmFD_, CFileDescriptor&& drmSyncobj
} }
CSyncTimeline::~CSyncTimeline() { CSyncTimeline::~CSyncTimeline() {
if (handle == 0) if (m_handle == 0)
return; return;
drmSyncobjDestroy(drmFD, handle); drmSyncobjDestroy(m_drmFD, m_handle);
} }
std::optional<bool> CSyncTimeline::check(uint64_t point, uint32_t flags) { std::optional<bool> CSyncTimeline::check(uint64_t point, uint32_t flags) {
@@ -48,7 +48,7 @@ std::optional<bool> CSyncTimeline::check(uint64_t point, uint32_t flags) {
#endif #endif
uint32_t signaled = 0; uint32_t signaled = 0;
int ret = drmSyncobjTimelineWait(drmFD, &handle, &point, 1, 0, flags, &signaled); int ret = drmSyncobjTimelineWait(m_drmFD, &m_handle, &point, 1, 0, flags, &signaled);
if (ret != 0 && ret != -ETIME_ERR) { if (ret != 0 && ret != -ETIME_ERR) {
Debug::log(ERR, "CSyncTimeline::check: drmSyncobjTimelineWait failed"); Debug::log(ERR, "CSyncTimeline::check: drmSyncobjTimelineWait failed");
return std::nullopt; return std::nullopt;
@@ -65,7 +65,7 @@ bool CSyncTimeline::addWaiter(const std::function<void()>& waiter, uint64_t poin
return false; return false;
} }
if (drmSyncobjEventfd(drmFD, handle, point, eventFd.get(), flags)) { if (drmSyncobjEventfd(m_drmFD, m_handle, point, eventFd.get(), flags)) {
Debug::log(ERR, "CSyncTimeline::addWaiter: drmSyncobjEventfd failed"); Debug::log(ERR, "CSyncTimeline::addWaiter: drmSyncobjEventfd failed");
return false; return false;
} }
@@ -79,58 +79,58 @@ CFileDescriptor CSyncTimeline::exportAsSyncFileFD(uint64_t src) {
int sync = -1; int sync = -1;
uint32_t syncHandle = 0; uint32_t syncHandle = 0;
if (drmSyncobjCreate(drmFD, 0, &syncHandle)) { if (drmSyncobjCreate(m_drmFD, 0, &syncHandle)) {
Debug::log(ERR, "exportAsSyncFileFD: drmSyncobjCreate failed"); Debug::log(ERR, "exportAsSyncFileFD: drmSyncobjCreate failed");
return {}; return {};
} }
if (drmSyncobjTransfer(drmFD, syncHandle, 0, handle, src, 0)) { if (drmSyncobjTransfer(m_drmFD, syncHandle, 0, m_handle, src, 0)) {
Debug::log(ERR, "exportAsSyncFileFD: drmSyncobjTransfer failed"); Debug::log(ERR, "exportAsSyncFileFD: drmSyncobjTransfer failed");
drmSyncobjDestroy(drmFD, syncHandle); drmSyncobjDestroy(m_drmFD, syncHandle);
return {}; return {};
} }
if (drmSyncobjExportSyncFile(drmFD, syncHandle, &sync)) { if (drmSyncobjExportSyncFile(m_drmFD, syncHandle, &sync)) {
Debug::log(ERR, "exportAsSyncFileFD: drmSyncobjExportSyncFile failed"); Debug::log(ERR, "exportAsSyncFileFD: drmSyncobjExportSyncFile failed");
drmSyncobjDestroy(drmFD, syncHandle); drmSyncobjDestroy(m_drmFD, syncHandle);
return {}; return {};
} }
drmSyncobjDestroy(drmFD, syncHandle); drmSyncobjDestroy(m_drmFD, syncHandle);
return CFileDescriptor{sync}; return CFileDescriptor{sync};
} }
bool CSyncTimeline::importFromSyncFileFD(uint64_t dst, CFileDescriptor& fd) { bool CSyncTimeline::importFromSyncFileFD(uint64_t dst, CFileDescriptor& fd) {
uint32_t syncHandle = 0; uint32_t syncHandle = 0;
if (drmSyncobjCreate(drmFD, 0, &syncHandle)) { if (drmSyncobjCreate(m_drmFD, 0, &syncHandle)) {
Debug::log(ERR, "importFromSyncFileFD: drmSyncobjCreate failed"); Debug::log(ERR, "importFromSyncFileFD: drmSyncobjCreate failed");
return false; return false;
} }
if (drmSyncobjImportSyncFile(drmFD, syncHandle, fd.get())) { if (drmSyncobjImportSyncFile(m_drmFD, syncHandle, fd.get())) {
Debug::log(ERR, "importFromSyncFileFD: drmSyncobjImportSyncFile failed"); Debug::log(ERR, "importFromSyncFileFD: drmSyncobjImportSyncFile failed");
drmSyncobjDestroy(drmFD, syncHandle); drmSyncobjDestroy(m_drmFD, syncHandle);
return false; return false;
} }
if (drmSyncobjTransfer(drmFD, handle, dst, syncHandle, 0, 0)) { if (drmSyncobjTransfer(m_drmFD, m_handle, dst, syncHandle, 0, 0)) {
Debug::log(ERR, "importFromSyncFileFD: drmSyncobjTransfer failed"); Debug::log(ERR, "importFromSyncFileFD: drmSyncobjTransfer failed");
drmSyncobjDestroy(drmFD, syncHandle); drmSyncobjDestroy(m_drmFD, syncHandle);
return false; return false;
} }
drmSyncobjDestroy(drmFD, syncHandle); drmSyncobjDestroy(m_drmFD, syncHandle);
return true; return true;
} }
bool CSyncTimeline::transfer(SP<CSyncTimeline> from, uint64_t fromPoint, uint64_t toPoint) { bool CSyncTimeline::transfer(SP<CSyncTimeline> from, uint64_t fromPoint, uint64_t toPoint) {
if (drmFD != from->drmFD) { if (m_drmFD != from->m_drmFD) {
Debug::log(ERR, "CSyncTimeline::transfer: cannot transfer timelines between gpus, {} -> {}", from->drmFD, drmFD); Debug::log(ERR, "CSyncTimeline::transfer: cannot transfer timelines between gpus, {} -> {}", from->m_drmFD, m_drmFD);
return false; return false;
} }
if (drmSyncobjTransfer(drmFD, handle, toPoint, from->handle, fromPoint, 0)) { if (drmSyncobjTransfer(m_drmFD, m_handle, toPoint, from->m_handle, fromPoint, 0)) {
Debug::log(ERR, "CSyncTimeline::transfer: drmSyncobjTransfer failed"); Debug::log(ERR, "CSyncTimeline::transfer: drmSyncobjTransfer failed");
return false; return false;
} }
@@ -139,6 +139,6 @@ bool CSyncTimeline::transfer(SP<CSyncTimeline> from, uint64_t fromPoint, uint64_
} }
void CSyncTimeline::signal(uint64_t point) { void CSyncTimeline::signal(uint64_t point) {
if (drmSyncobjTimelineSignal(drmFD, &handle, &point, 1)) if (drmSyncobjTimelineSignal(m_drmFD, &m_handle, &point, 1))
Debug::log(ERR, "CSyncTimeline::signal: drmSyncobjTimelineSignal failed"); Debug::log(ERR, "CSyncTimeline::signal: drmSyncobjTimelineSignal failed");
} }

8
src/helpers/sync/SyncTimeline.hpp
View File

@@ -31,10 +31,10 @@ class CSyncTimeline {
bool transfer(SP<CSyncTimeline> from, uint64_t fromPoint, uint64_t toPoint); bool transfer(SP<CSyncTimeline> from, uint64_t fromPoint, uint64_t toPoint);
void signal(uint64_t point); void signal(uint64_t point);
int drmFD = -1; int m_drmFD = -1;
Hyprutils::OS::CFileDescriptor syncobjFd; Hyprutils::OS::CFileDescriptor m_syncobjFD;
uint32_t handle = 0; uint32_t m_handle = 0;
WP<CSyncTimeline> self; WP<CSyncTimeline> m_self;
private: private:
CSyncTimeline() = default; CSyncTimeline() = default;

24
src/hyprerror/HyprError.cpp
View File

@@ -49,11 +49,11 @@ void CHyprError::createQueued() {
const auto PMONITOR = g_pCompositor->m_monitors.front(); const auto PMONITOR = g_pCompositor->m_monitors.front();
const auto SCALE = PMONITOR->scale; const auto SCALE = PMONITOR->m_scale;
const auto FONTSIZE = std::clamp((int)(10.f * ((PMONITOR->vecPixelSize.x * SCALE) / 1920.f)), 8, 40); const auto FONTSIZE = std::clamp((int)(10.f * ((PMONITOR->m_pixelSize.x * SCALE) / 1920.f)), 8, 40);
const auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y); const auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y);
const auto CAIRO = cairo_create(CAIROSURFACE); const auto CAIRO = cairo_create(CAIROSURFACE);
@@ -76,13 +76,13 @@ void CHyprError::createQueued() {
const double PAD = 10 * SCALE; const double PAD = 10 * SCALE;
const double WIDTH = PMONITOR->vecPixelSize.x - PAD * 2; const double WIDTH = PMONITOR->m_pixelSize.x - PAD * 2;
const double HEIGHT = (FONTSIZE + 2 * (FONTSIZE / 10.0)) * (VISLINECOUNT + EXTRALINES) + 3; const double HEIGHT = (FONTSIZE + 2 * (FONTSIZE / 10.0)) * (VISLINECOUNT + EXTRALINES) + 3;
const double RADIUS = PAD > HEIGHT / 2 ? HEIGHT / 2 - 1 : PAD; const double RADIUS = PAD > HEIGHT / 2 ? HEIGHT / 2 - 1 : PAD;
const double X = PAD; const double X = PAD;
const double Y = TOPBAR ? PAD : PMONITOR->vecPixelSize.y - HEIGHT - PAD; const double Y = TOPBAR ? PAD : PMONITOR->m_pixelSize.y - HEIGHT - PAD;
m_bDamageBox = {0, 0, (int)PMONITOR->vecPixelSize.x, (int)HEIGHT + (int)PAD * 2}; m_bDamageBox = {0, 0, (int)PMONITOR->m_pixelSize.x, (int)HEIGHT + (int)PAD * 2};
cairo_new_sub_path(CAIRO); cairo_new_sub_path(CAIRO);
cairo_arc(CAIRO, X + WIDTH - RADIUS, Y + RADIUS, RADIUS, -90 * DEGREES, 0 * DEGREES); cairo_arc(CAIRO, X + WIDTH - RADIUS, Y + RADIUS, RADIUS, -90 * DEGREES, 0 * DEGREES);
@@ -152,7 +152,7 @@ void CHyprError::createQueued() {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
#endif #endif
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
// delete cairo // delete cairo
cairo_destroy(CAIRO); cairo_destroy(CAIRO);
@@ -164,7 +164,7 @@ void CHyprError::createQueued() {
g_pHyprRenderer->damageMonitor(PMONITOR); g_pHyprRenderer->damageMonitor(PMONITOR);
g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->ID); g_pHyprRenderer->arrangeLayersForMonitor(PMONITOR->m_id);
} }
void CHyprError::draw() { void CHyprError::draw() {
@@ -183,7 +183,7 @@ void CHyprError::draw() {
m_szQueued = ""; m_szQueued = "";
for (auto& m : g_pCompositor->m_monitors) { for (auto& m : g_pCompositor->m_monitors) {
g_pHyprRenderer->arrangeLayersForMonitor(m->ID); g_pHyprRenderer->arrangeLayersForMonitor(m->m_id);
} }
return; return;
@@ -196,10 +196,10 @@ void CHyprError::draw() {
const auto PMONITOR = g_pHyprOpenGL->m_RenderData.pMonitor; const auto PMONITOR = g_pHyprOpenGL->m_RenderData.pMonitor;
CBox monbox = {0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y}; CBox monbox = {0, 0, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y};
m_bDamageBox.x = (int)PMONITOR->vecPosition.x; m_bDamageBox.x = (int)PMONITOR->m_position.x;
m_bDamageBox.y = (int)PMONITOR->vecPosition.y; m_bDamageBox.y = (int)PMONITOR->m_position.y;
if (m_fFadeOpacity->isBeingAnimated() || m_bMonitorChanged) if (m_fFadeOpacity->isBeingAnimated() || m_bMonitorChanged)
g_pHyprRenderer->damageBox(m_bDamageBox); g_pHyprRenderer->damageBox(m_bDamageBox);

56
src/layout/DwindleLayout.cpp
View File

@@ -115,10 +115,10 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for
} }
// for gaps outer // for gaps outer
const bool DISPLAYLEFT = STICKS(pNode->box.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x); const bool DISPLAYLEFT = STICKS(pNode->box.x, PMONITOR->m_position.x + PMONITOR->m_reservedTopLeft.x);
const bool DISPLAYRIGHT = STICKS(pNode->box.x + pNode->box.w, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x); const bool DISPLAYRIGHT = STICKS(pNode->box.x + pNode->box.w, PMONITOR->m_position.x + PMONITOR->m_size.x - PMONITOR->m_reservedBottomRight.x);
const bool DISPLAYTOP = STICKS(pNode->box.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y); const bool DISPLAYTOP = STICKS(pNode->box.y, PMONITOR->m_position.y + PMONITOR->m_reservedTopLeft.y);
const bool DISPLAYBOTTOM = STICKS(pNode->box.y + pNode->box.h, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y); const bool DISPLAYBOTTOM = STICKS(pNode->box.y + pNode->box.h, PMONITOR->m_position.y + PMONITOR->m_size.y - PMONITOR->m_reservedBottomRight.y);
const auto PWINDOW = pNode->pWindow.lock(); const auto PWINDOW = pNode->pWindow.lock();
// get specific gaps and rules for this workspace, // get specific gaps and rules for this workspace,
@@ -245,8 +245,8 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
const auto MOUSECOORDS = m_vOverrideFocalPoint.value_or(g_pInputManager->getMouseCoordsInternal()); const auto MOUSECOORDS = m_vOverrideFocalPoint.value_or(g_pInputManager->getMouseCoordsInternal());
const auto MONFROMCURSOR = g_pCompositor->getMonitorFromVector(MOUSECOORDS); const auto MONFROMCURSOR = g_pCompositor->getMonitorFromVector(MOUSECOORDS);
if (PMONITOR->ID == MONFROMCURSOR->ID && if (PMONITOR->m_id == MONFROMCURSOR->m_id &&
(PNODE->workspaceID == PMONITOR->activeWorkspaceID() || (g_pCompositor->isWorkspaceSpecial(PNODE->workspaceID) && PMONITOR->activeSpecialWorkspace)) && !*PUSEACTIVE) { (PNODE->workspaceID == PMONITOR->activeWorkspaceID() || (g_pCompositor->isWorkspaceSpecial(PNODE->workspaceID) && PMONITOR->m_activeSpecialWorkspace)) && !*PUSEACTIVE) {
OPENINGON = getNodeFromWindow(g_pCompositor->vectorToWindowUnified(MOUSECOORDS, RESERVED_EXTENTS | INPUT_EXTENTS | SKIP_FULLSCREEN_PRIORITY)); OPENINGON = getNodeFromWindow(g_pCompositor->vectorToWindowUnified(MOUSECOORDS, RESERVED_EXTENTS | INPUT_EXTENTS | SKIP_FULLSCREEN_PRIORITY));
if (!OPENINGON && g_pCompositor->isPointOnReservedArea(MOUSECOORDS, PMONITOR)) if (!OPENINGON && g_pCompositor->isPointOnReservedArea(MOUSECOORDS, PMONITOR))
@@ -266,7 +266,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
} else } else
OPENINGON = getFirstNodeOnWorkspace(pWindow->workspaceID()); OPENINGON = getFirstNodeOnWorkspace(pWindow->workspaceID());
Debug::log(LOG, "OPENINGON: {}, Monitor: {}", OPENINGON, PMONITOR->ID); Debug::log(LOG, "OPENINGON: {}, Monitor: {}", OPENINGON, PMONITOR->m_id);
if (OPENINGON && OPENINGON->workspaceID != PNODE->workspaceID) { if (OPENINGON && OPENINGON->workspaceID != PNODE->workspaceID) {
// special workspace handling // special workspace handling
@@ -274,7 +274,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
} }
// first, check if OPENINGON isn't too big. // first, check if OPENINGON isn't too big.
const auto PREDSIZEMAX = OPENINGON ? Vector2D(OPENINGON->box.w, OPENINGON->box.h) : PMONITOR->vecSize; const auto PREDSIZEMAX = OPENINGON ? Vector2D(OPENINGON->box.w, OPENINGON->box.h) : PMONITOR->m_size;
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;
@@ -295,7 +295,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dir
// if it's the first, it's easy. Make it fullscreen. // if it's the first, it's easy. Make it fullscreen.
if (!OPENINGON || OPENINGON->pWindow.lock() == pWindow) { if (!OPENINGON || OPENINGON->pWindow.lock() == pWindow) {
PNODE->box = CBox{PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft, PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight}; PNODE->box = CBox{PMONITOR->m_position + PMONITOR->m_reservedTopLeft, PMONITOR->m_size - PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight};
applyNodeDataToWindow(PNODE); applyNodeDataToWindow(PNODE);
@@ -487,15 +487,15 @@ void CHyprDwindleLayout::onWindowRemovedTiling(PHLWINDOW pWindow) {
void CHyprDwindleLayout::recalculateMonitor(const MONITORID& monid) { void CHyprDwindleLayout::recalculateMonitor(const MONITORID& monid) {
const auto PMONITOR = g_pCompositor->getMonitorFromID(monid); const auto PMONITOR = g_pCompositor->getMonitorFromID(monid);
if (!PMONITOR || !PMONITOR->activeWorkspace) if (!PMONITOR || !PMONITOR->m_activeWorkspace)
return; // ??? return; // ???
g_pHyprRenderer->damageMonitor(PMONITOR); g_pHyprRenderer->damageMonitor(PMONITOR);
if (PMONITOR->activeSpecialWorkspace) if (PMONITOR->m_activeSpecialWorkspace)
calculateWorkspace(PMONITOR->activeSpecialWorkspace); calculateWorkspace(PMONITOR->m_activeSpecialWorkspace);
calculateWorkspace(PMONITOR->activeWorkspace); calculateWorkspace(PMONITOR->m_activeWorkspace);
} }
void CHyprDwindleLayout::calculateWorkspace(const PHLWORKSPACE& pWorkspace) { void CHyprDwindleLayout::calculateWorkspace(const PHLWORKSPACE& pWorkspace) {
@@ -509,12 +509,12 @@ void CHyprDwindleLayout::calculateWorkspace(const PHLWORKSPACE& pWorkspace) {
const auto PFULLWINDOW = pWorkspace->getFullscreenWindow(); const auto PFULLWINDOW = pWorkspace->getFullscreenWindow();
if (pWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) { if (pWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) {
*PFULLWINDOW->m_realPosition = PMONITOR->vecPosition; *PFULLWINDOW->m_realPosition = PMONITOR->m_position;
*PFULLWINDOW->m_realSize = PMONITOR->vecSize; *PFULLWINDOW->m_realSize = PMONITOR->m_size;
} else if (pWorkspace->m_fullscreenMode == FSMODE_MAXIMIZED) { } else if (pWorkspace->m_fullscreenMode == FSMODE_MAXIMIZED) {
SDwindleNodeData fakeNode; SDwindleNodeData fakeNode;
fakeNode.pWindow = PFULLWINDOW; fakeNode.pWindow = PFULLWINDOW;
fakeNode.box = {PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft, PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight}; fakeNode.box = {PMONITOR->m_position + PMONITOR->m_reservedTopLeft, PMONITOR->m_size - PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight};
fakeNode.workspaceID = pWorkspace->m_id; fakeNode.workspaceID = pWorkspace->m_id;
PFULLWINDOW->m_position = fakeNode.box.pos(); PFULLWINDOW->m_position = fakeNode.box.pos();
PFULLWINDOW->m_size = fakeNode.box.size(); PFULLWINDOW->m_size = fakeNode.box.size();
@@ -530,7 +530,7 @@ void CHyprDwindleLayout::calculateWorkspace(const PHLWORKSPACE& pWorkspace) {
const auto TOPNODE = getMasterNodeOnWorkspace(pWorkspace->m_id); const auto TOPNODE = getMasterNodeOnWorkspace(pWorkspace->m_id);
if (TOPNODE) { if (TOPNODE) {
TOPNODE->box = {PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft, PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight}; TOPNODE->box = {PMONITOR->m_position + PMONITOR->m_reservedTopLeft, PMONITOR->m_size - PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight};
TOPNODE->recalcSizePosRecursive(); TOPNODE->recalcSizePosRecursive();
} }
} }
@@ -567,10 +567,10 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorn
// get some data about our window // get some data about our window
const auto PMONITOR = PWINDOW->m_monitor.lock(); const auto PMONITOR = PWINDOW->m_monitor.lock();
const bool DISPLAYLEFT = STICKS(PWINDOW->m_position.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x); const bool DISPLAYLEFT = STICKS(PWINDOW->m_position.x, PMONITOR->m_position.x + PMONITOR->m_reservedTopLeft.x);
const bool DISPLAYRIGHT = STICKS(PWINDOW->m_position.x + PWINDOW->m_size.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x); const bool DISPLAYRIGHT = STICKS(PWINDOW->m_position.x + PWINDOW->m_size.x, PMONITOR->m_position.x + PMONITOR->m_size.x - PMONITOR->m_reservedBottomRight.x);
const bool DISPLAYTOP = STICKS(PWINDOW->m_position.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y); const bool DISPLAYTOP = STICKS(PWINDOW->m_position.y, PMONITOR->m_position.y + PMONITOR->m_reservedTopLeft.y);
const bool DISPLAYBOTTOM = STICKS(PWINDOW->m_position.y + PWINDOW->m_size.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.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) {
@@ -766,8 +766,8 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFu
} else { } else {
// apply new pos and size being monitors' box // apply new pos and size being monitors' box
if (EFFECTIVE_MODE == FSMODE_FULLSCREEN) { if (EFFECTIVE_MODE == FSMODE_FULLSCREEN) {
*pWindow->m_realPosition = PMONITOR->vecPosition; *pWindow->m_realPosition = PMONITOR->m_position;
*pWindow->m_realSize = PMONITOR->vecSize; *pWindow->m_realSize = PMONITOR->m_size;
} else { } else {
// This is a massive hack. // This is a massive hack.
// We make a fake "only" node and apply // We make a fake "only" node and apply
@@ -775,7 +775,7 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFu
SDwindleNodeData fakeNode; SDwindleNodeData fakeNode;
fakeNode.pWindow = pWindow; fakeNode.pWindow = pWindow;
fakeNode.box = {PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft, PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight}; fakeNode.box = {PMONITOR->m_position + PMONITOR->m_reservedTopLeft, PMONITOR->m_size - PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight};
fakeNode.workspaceID = pWindow->workspaceID(); fakeNode.workspaceID = pWindow->workspaceID();
pWindow->m_position = fakeNode.box.pos(); pWindow->m_position = fakeNode.box.pos();
pWindow->m_size = fakeNode.box.size(); pWindow->m_size = fakeNode.box.size();
@@ -821,7 +821,7 @@ void CHyprDwindleLayout::moveWindowTo(PHLWINDOW pWindow, const std::string& dir,
Vector2D focalPoint; Vector2D focalPoint;
const auto WINDOWIDEALBB = pWindow->isFullscreen() ? CBox{pWindow->m_monitor->vecPosition, pWindow->m_monitor->vecSize} : pWindow->getWindowIdealBoundingBoxIgnoreReserved(); const auto WINDOWIDEALBB = pWindow->isFullscreen() ? CBox{pWindow->m_monitor->m_position, pWindow->m_monitor->m_size} : pWindow->getWindowIdealBoundingBoxIgnoreReserved();
switch (dir[0]) { switch (dir[0]) {
case 't': case 't':
@@ -842,7 +842,7 @@ void CHyprDwindleLayout::moveWindowTo(PHLWINDOW pWindow, const std::string& dir,
const auto PMONITORFOCAL = g_pCompositor->getMonitorFromVector(focalPoint); const auto PMONITORFOCAL = g_pCompositor->getMonitorFromVector(focalPoint);
if (PMONITORFOCAL != pWindow->m_monitor) { if (PMONITORFOCAL != pWindow->m_monitor) {
pWindow->moveToWorkspace(PMONITORFOCAL->activeWorkspace); pWindow->moveToWorkspace(PMONITORFOCAL->m_activeWorkspace);
pWindow->m_monitor = PMONITORFOCAL; pWindow->m_monitor = PMONITORFOCAL;
} }
@@ -1087,13 +1087,13 @@ Vector2D CHyprDwindleLayout::predictSizeForNewWindowTiled() {
PHLWINDOW candidate = g_pCompositor->m_lastWindow.lock(); PHLWINDOW candidate = g_pCompositor->m_lastWindow.lock();
if (!candidate) if (!candidate)
candidate = g_pCompositor->m_lastMonitor->activeWorkspace->getFirstWindow(); candidate = g_pCompositor->m_lastMonitor->m_activeWorkspace->getFirstWindow();
// create a fake node // create a fake node
SDwindleNodeData node; SDwindleNodeData node;
if (!candidate) if (!candidate)
return g_pCompositor->m_lastMonitor->vecSize; return g_pCompositor->m_lastMonitor->m_size;
else { else {
const auto PNODE = getNodeFromWindow(candidate); const auto PNODE = getNodeFromWindow(candidate);

58
src/layout/IHyprLayout.cpp
View File

@@ -27,7 +27,7 @@ void IHyprLayout::onWindowCreated(PHLWINDOW pWindow, eDirection direction) {
pWindow->m_lastFloatingSize = STOREDSIZE.value(); pWindow->m_lastFloatingSize = STOREDSIZE.value();
} else if (desiredGeometry.width <= 5 || desiredGeometry.height <= 5) { } else if (desiredGeometry.width <= 5 || desiredGeometry.height <= 5) {
const auto PMONITOR = pWindow->m_monitor.lock(); const auto PMONITOR = pWindow->m_monitor.lock();
pWindow->m_lastFloatingSize = PMONITOR->vecSize / 2.f; pWindow->m_lastFloatingSize = PMONITOR->m_size / 2.f;
} else } else
pWindow->m_lastFloatingSize = Vector2D(desiredGeometry.width, desiredGeometry.height); pWindow->m_lastFloatingSize = Vector2D(desiredGeometry.width, desiredGeometry.height);
@@ -128,18 +128,18 @@ void IHyprLayout::onWindowCreatedFloating(PHLWINDOW pWindow) {
// reject any windows with size <= 5x5 // reject any windows with size <= 5x5
if (pWindow->m_realSize->goal().x <= 5 || pWindow->m_realSize->goal().y <= 5) if (pWindow->m_realSize->goal().x <= 5 || pWindow->m_realSize->goal().y <= 5)
*pWindow->m_realSize = PMONITOR->vecSize / 2.f; *pWindow->m_realSize = PMONITOR->m_size / 2.f;
if (pWindow->m_isX11 && pWindow->isX11OverrideRedirect()) { if (pWindow->m_isX11 && pWindow->isX11OverrideRedirect()) {
if (pWindow->m_xwaylandSurface->geometry.x != 0 && pWindow->m_xwaylandSurface->geometry.y != 0) if (pWindow->m_xwaylandSurface->geometry.x != 0 && pWindow->m_xwaylandSurface->geometry.y != 0)
*pWindow->m_realPosition = g_pXWaylandManager->xwaylandToWaylandCoords(pWindow->m_xwaylandSurface->geometry.pos()); *pWindow->m_realPosition = g_pXWaylandManager->xwaylandToWaylandCoords(pWindow->m_xwaylandSurface->geometry.pos());
else else
*pWindow->m_realPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_realSize->goal().x) / 2.f, *pWindow->m_realPosition = Vector2D(PMONITOR->m_position.x + (PMONITOR->m_size.x - pWindow->m_realSize->goal().x) / 2.f,
PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_realSize->goal().y) / 2.f); PMONITOR->m_position.y + (PMONITOR->m_size.y - pWindow->m_realSize->goal().y) / 2.f);
} else { } else {
*pWindow->m_realPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_realSize->goal().x) / 2.f, *pWindow->m_realPosition = Vector2D(PMONITOR->m_position.x + (PMONITOR->m_size.x - pWindow->m_realSize->goal().x) / 2.f,
PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_realSize->goal().y) / 2.f); PMONITOR->m_position.y + (PMONITOR->m_size.y - pWindow->m_realSize->goal().y) / 2.f);
} }
} else { } else {
// we respect the size. // we respect the size.
@@ -165,20 +165,20 @@ void IHyprLayout::onWindowCreatedFloating(PHLWINDOW pWindow) {
*pWindow->m_realPosition = pWindow->m_xdgSurface->toplevel->parent->window->m_realPosition->goal() + *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; pWindow->m_xdgSurface->toplevel->parent->window->m_realSize->goal() / 2.F - desiredGeometry.size() / 2.F;
else else
*pWindow->m_realPosition = PMONITOR->vecPosition + PMONITOR->vecSize / 2.F - desiredGeometry.size() / 2.F; *pWindow->m_realPosition = PMONITOR->m_position + PMONITOR->m_size / 2.F - desiredGeometry.size() / 2.F;
} else { } else {
// if it is, we respect where it wants to put itself, but apply monitor offset if outside // if it is, we respect where it wants to put itself, but apply monitor offset if outside
// most of these are popups // most of these are popups
if (const auto POPENMON = g_pCompositor->getMonitorFromVector(middlePoint); POPENMON->ID != PMONITOR->ID) if (const auto POPENMON = g_pCompositor->getMonitorFromVector(middlePoint); POPENMON->m_id != PMONITOR->m_id)
*pWindow->m_realPosition = Vector2D(desiredGeometry.x, desiredGeometry.y) - POPENMON->vecPosition + PMONITOR->vecPosition; *pWindow->m_realPosition = Vector2D(desiredGeometry.x, desiredGeometry.y) - POPENMON->m_position + PMONITOR->m_position;
else else
*pWindow->m_realPosition = Vector2D(desiredGeometry.x, desiredGeometry.y); *pWindow->m_realPosition = Vector2D(desiredGeometry.x, desiredGeometry.y);
} }
} }
if (*PXWLFORCESCALEZERO && pWindow->m_isX11) if (*PXWLFORCESCALEZERO && pWindow->m_isX11)
*pWindow->m_realSize = pWindow->m_realSize->goal() / PMONITOR->scale; *pWindow->m_realSize = pWindow->m_realSize->goal() / PMONITOR->m_scale;
if (pWindow->m_X11DoesntWantBorders || (pWindow->m_isX11 && pWindow->isX11OverrideRedirect())) { if (pWindow->m_X11DoesntWantBorders || (pWindow->m_isX11 && pWindow->isX11OverrideRedirect())) {
pWindow->m_realPosition->warp(); pWindow->m_realPosition->warp();
@@ -468,32 +468,30 @@ static void performSnap(Vector2D& sourcePos, Vector2D& sourceSize, PHLWINDOW DRA
const double BORDERDIFF = OVERLAP ? DRAGGINGBORDERSIZE : 0; const double BORDERDIFF = OVERLAP ? DRAGGINGBORDERSIZE : 0;
const auto MON = DRAGGINGWINDOW->m_monitor.lock(); const auto MON = DRAGGINGWINDOW->m_monitor.lock();
SRange monX = {MON->vecPosition.x + MON->vecReservedTopLeft.x + DRAGGINGBORDERSIZE, SRange monX = {MON->m_position.x + MON->m_reservedTopLeft.x + DRAGGINGBORDERSIZE, MON->m_position.x + MON->m_size.x - MON->m_reservedBottomRight.x - DRAGGINGBORDERSIZE};
MON->vecPosition.x + MON->vecSize.x - MON->vecReservedBottomRight.x - DRAGGINGBORDERSIZE}; SRange monY = {MON->m_position.y + MON->m_reservedTopLeft.y + DRAGGINGBORDERSIZE, MON->m_position.y + MON->m_size.y - MON->m_reservedBottomRight.y - DRAGGINGBORDERSIZE};
SRange monY = {MON->vecPosition.y + MON->vecReservedTopLeft.y + DRAGGINGBORDERSIZE,
MON->vecPosition.y + MON->vecSize.y - MON->vecReservedBottomRight.y - DRAGGINGBORDERSIZE};
if (CORNER & (CORNER_TOPLEFT | CORNER_BOTTOMLEFT) && if (CORNER & (CORNER_TOPLEFT | CORNER_BOTTOMLEFT) &&
((MON->vecReservedTopLeft.x > 0 && canSnap(sourceX.start, monX.start, GAPSIZE)) || ((MON->m_reservedTopLeft.x > 0 && canSnap(sourceX.start, monX.start, GAPSIZE)) ||
canSnap(sourceX.start, (monX.start -= MON->vecReservedTopLeft.x + BORDERDIFF), GAPSIZE))) { canSnap(sourceX.start, (monX.start -= MON->m_reservedTopLeft.x + BORDERDIFF), GAPSIZE))) {
SNAP(sourceX.start, sourceX.end, monX.start); SNAP(sourceX.start, sourceX.end, monX.start);
snaps |= SNAP_LEFT; snaps |= SNAP_LEFT;
} }
if (CORNER & (CORNER_TOPRIGHT | CORNER_BOTTOMRIGHT) && if (CORNER & (CORNER_TOPRIGHT | CORNER_BOTTOMRIGHT) &&
((MON->vecReservedBottomRight.x > 0 && canSnap(sourceX.end, monX.end, GAPSIZE)) || ((MON->m_reservedBottomRight.x > 0 && canSnap(sourceX.end, monX.end, GAPSIZE)) ||
canSnap(sourceX.end, (monX.end += MON->vecReservedBottomRight.x + BORDERDIFF), GAPSIZE))) { canSnap(sourceX.end, (monX.end += MON->m_reservedBottomRight.x + BORDERDIFF), GAPSIZE))) {
SNAP(sourceX.end, sourceX.start, monX.end); SNAP(sourceX.end, sourceX.start, monX.end);
snaps |= SNAP_RIGHT; snaps |= SNAP_RIGHT;
} }
if (CORNER & (CORNER_TOPLEFT | CORNER_TOPRIGHT) && if (CORNER & (CORNER_TOPLEFT | CORNER_TOPRIGHT) &&
((MON->vecReservedTopLeft.y > 0 && canSnap(sourceY.start, monY.start, GAPSIZE)) || ((MON->m_reservedTopLeft.y > 0 && canSnap(sourceY.start, monY.start, GAPSIZE)) ||
canSnap(sourceY.start, (monY.start -= MON->vecReservedTopLeft.y + BORDERDIFF), GAPSIZE))) { canSnap(sourceY.start, (monY.start -= MON->m_reservedTopLeft.y + BORDERDIFF), GAPSIZE))) {
SNAP(sourceY.start, sourceY.end, monY.start); SNAP(sourceY.start, sourceY.end, monY.start);
snaps |= SNAP_UP; snaps |= SNAP_UP;
} }
if (CORNER & (CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT) && if (CORNER & (CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT) &&
((MON->vecReservedBottomRight.y > 0 && canSnap(sourceY.end, monY.end, GAPSIZE)) || ((MON->m_reservedBottomRight.y > 0 && canSnap(sourceY.end, monY.end, GAPSIZE)) ||
canSnap(sourceY.end, (monY.end += MON->vecReservedBottomRight.y + BORDERDIFF), GAPSIZE))) { canSnap(sourceY.end, (monY.end += MON->m_reservedBottomRight.y + BORDERDIFF), GAPSIZE))) {
SNAP(sourceY.end, sourceY.start, monY.end); SNAP(sourceY.end, sourceY.start, monY.end);
snaps |= SNAP_DOWN; snaps |= SNAP_DOWN;
} }
@@ -555,7 +553,7 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
const auto TIMERDELTA = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - TIMER).count(); const auto TIMERDELTA = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - TIMER).count();
const auto MSDELTA = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - MSTIMER).count(); const auto MSDELTA = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - MSTIMER).count();
const auto MSMONITOR = 1000.0 / g_pHyprRenderer->m_pMostHzMonitor->refreshRate; const auto MSMONITOR = 1000.0 / g_pHyprRenderer->m_pMostHzMonitor->m_refreshRate;
static int totalMs = 0; static int totalMs = 0;
bool canSkipUpdate = true; bool canSkipUpdate = true;
@@ -688,7 +686,7 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
if (PMONITOR && !SPECIAL) { if (PMONITOR && !SPECIAL) {
DRAGGINGWINDOW->m_monitor = PMONITOR; DRAGGINGWINDOW->m_monitor = PMONITOR;
DRAGGINGWINDOW->moveToWorkspace(PMONITOR->activeWorkspace); DRAGGINGWINDOW->moveToWorkspace(PMONITOR->m_activeWorkspace);
DRAGGINGWINDOW->updateGroupOutputs(); DRAGGINGWINDOW->updateGroupOutputs();
DRAGGINGWINDOW->updateToplevel(); DRAGGINGWINDOW->updateToplevel();
@@ -719,10 +717,10 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) {
if (!TILED) { if (!TILED) {
const auto PNEWMON = g_pCompositor->getMonitorFromVector(pWindow->m_realPosition->value() + pWindow->m_realSize->value() / 2.f); const auto PNEWMON = g_pCompositor->getMonitorFromVector(pWindow->m_realPosition->value() + pWindow->m_realSize->value() / 2.f);
pWindow->m_monitor = PNEWMON; pWindow->m_monitor = PNEWMON;
pWindow->moveToWorkspace(PNEWMON->activeSpecialWorkspace ? PNEWMON->activeSpecialWorkspace : PNEWMON->activeWorkspace); pWindow->moveToWorkspace(PNEWMON->m_activeSpecialWorkspace ? PNEWMON->m_activeSpecialWorkspace : PNEWMON->m_activeWorkspace);
pWindow->updateGroupOutputs(); pWindow->updateGroupOutputs();
const auto PWORKSPACE = PNEWMON->activeSpecialWorkspace ? PNEWMON->activeSpecialWorkspace : PNEWMON->activeWorkspace; const auto PWORKSPACE = PNEWMON->m_activeSpecialWorkspace ? PNEWMON->m_activeSpecialWorkspace : PNEWMON->m_activeWorkspace;
if (PWORKSPACE->m_hasFullscreenWindow) if (PWORKSPACE->m_hasFullscreenWindow)
g_pCompositor->setWindowFullscreenInternal(PWORKSPACE->getFullscreenWindow(), FSMODE_NONE); g_pCompositor->setWindowFullscreenInternal(PWORKSPACE->getFullscreenWindow(), FSMODE_NONE);
@@ -899,11 +897,11 @@ Vector2D IHyprLayout::predictSizeForNewWindowFloating(PHLWINDOW pWindow) { // ge
const auto MAXSIZE = pWindow->requestedMaxSize(); const auto MAXSIZE = pWindow->requestedMaxSize();
const float SIZEX = SIZEXSTR == "max" ? std::clamp(MAXSIZE.x, MIN_WINDOW_SIZE, g_pCompositor->m_lastMonitor->vecSize.x) : const float SIZEX = SIZEXSTR == "max" ? std::clamp(MAXSIZE.x, MIN_WINDOW_SIZE, g_pCompositor->m_lastMonitor->m_size.x) :
stringToPercentage(SIZEXSTR, g_pCompositor->m_lastMonitor->vecSize.x); stringToPercentage(SIZEXSTR, g_pCompositor->m_lastMonitor->m_size.x);
const float SIZEY = SIZEYSTR == "max" ? std::clamp(MAXSIZE.y, MIN_WINDOW_SIZE, g_pCompositor->m_lastMonitor->vecSize.y) : const float SIZEY = SIZEYSTR == "max" ? std::clamp(MAXSIZE.y, MIN_WINDOW_SIZE, g_pCompositor->m_lastMonitor->m_size.y) :
stringToPercentage(SIZEYSTR, g_pCompositor->m_lastMonitor->vecSize.y); stringToPercentage(SIZEYSTR, g_pCompositor->m_lastMonitor->m_size.y);
sizeOverride = {SIZEX, SIZEY}; sizeOverride = {SIZEX, SIZEY};

86
src/layout/MasterLayout.cpp
View File

@@ -205,7 +205,7 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire
PNODE->percMaster = lastSplitPercent; PNODE->percMaster = lastSplitPercent;
// first, check if it isn't too big. // 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) { 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_lMasterNodesData.remove(*PNODE);
@@ -218,7 +218,7 @@ void CHyprMasterLayout::onWindowCreatedTiling(PHLWINDOW pWindow, eDirection dire
// first, check if it isn't too big. // first, check if it isn't too big.
if (const auto MAXSIZE = pWindow->requestedMaxSize(); if (const auto MAXSIZE = pWindow->requestedMaxSize();
MAXSIZE.x < PMONITOR->vecSize.x * (1 - lastSplitPercent) || MAXSIZE.y < PMONITOR->vecSize.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_lMasterNodesData.remove(*PNODE);
@@ -284,15 +284,15 @@ void CHyprMasterLayout::onWindowRemovedTiling(PHLWINDOW pWindow) {
void CHyprMasterLayout::recalculateMonitor(const MONITORID& monid) { void CHyprMasterLayout::recalculateMonitor(const MONITORID& monid) {
const auto PMONITOR = g_pCompositor->getMonitorFromID(monid); const auto PMONITOR = g_pCompositor->getMonitorFromID(monid);
if (!PMONITOR || !PMONITOR->activeWorkspace) if (!PMONITOR || !PMONITOR->m_activeWorkspace)
return; return;
g_pHyprRenderer->damageMonitor(PMONITOR); g_pHyprRenderer->damageMonitor(PMONITOR);
if (PMONITOR->activeSpecialWorkspace) if (PMONITOR->m_activeSpecialWorkspace)
calculateWorkspace(PMONITOR->activeSpecialWorkspace); calculateWorkspace(PMONITOR->m_activeSpecialWorkspace);
calculateWorkspace(PMONITOR->activeWorkspace); calculateWorkspace(PMONITOR->m_activeWorkspace);
} }
void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) { void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
@@ -306,13 +306,13 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
const auto PFULLWINDOW = pWorkspace->getFullscreenWindow(); const auto PFULLWINDOW = pWorkspace->getFullscreenWindow();
if (pWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) { if (pWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) {
*PFULLWINDOW->m_realPosition = PMONITOR->vecPosition; *PFULLWINDOW->m_realPosition = PMONITOR->m_position;
*PFULLWINDOW->m_realSize = PMONITOR->vecSize; *PFULLWINDOW->m_realSize = PMONITOR->m_size;
} else if (pWorkspace->m_fullscreenMode == FSMODE_MAXIMIZED) { } else if (pWorkspace->m_fullscreenMode == FSMODE_MAXIMIZED) {
SMasterNodeData fakeNode; SMasterNodeData fakeNode;
fakeNode.pWindow = PFULLWINDOW; fakeNode.pWindow = PFULLWINDOW;
fakeNode.position = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft; fakeNode.position = PMONITOR->m_position + PMONITOR->m_reservedTopLeft;
fakeNode.size = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight; fakeNode.size = PMONITOR->m_size - PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight;
fakeNode.workspaceID = pWorkspace->m_id; fakeNode.workspaceID = pWorkspace->m_id;
PFULLWINDOW->m_position = fakeNode.position; PFULLWINDOW->m_position = fakeNode.position;
PFULLWINDOW->m_size = fakeNode.size; PFULLWINDOW->m_size = fakeNode.size;
@@ -340,8 +340,8 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
const auto MASTERS = getMastersOnWorkspace(pWorkspace->m_id); const auto MASTERS = getMastersOnWorkspace(pWorkspace->m_id);
const auto WINDOWS = getNodesOnWorkspace(pWorkspace->m_id); const auto WINDOWS = getNodesOnWorkspace(pWorkspace->m_id);
const auto STACKWINDOWS = WINDOWS - MASTERS; const auto STACKWINDOWS = WINDOWS - MASTERS;
const auto WSSIZE = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight; const auto WSSIZE = PMONITOR->m_size - PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight;
const auto WSPOS = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft; const auto WSPOS = PMONITOR->m_position + PMONITOR->m_reservedTopLeft;
if (orientation == ORIENTATION_CENTER) { if (orientation == ORIENTATION_CENTER) {
if (STACKWINDOWS >= *SLAVECOUNTFORCENTER) { if (STACKWINDOWS >= *SLAVECOUNTFORCENTER) {
@@ -426,7 +426,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
nextX += WIDTH; nextX += WIDTH;
} }
} else { // orientation left, right or center } else { // orientation left, right or center
float WIDTH = *PIGNORERESERVED && centerMasterWindow ? PMONITOR->vecSize.x : WSSIZE.x; float WIDTH = *PIGNORERESERVED && centerMasterWindow ? PMONITOR->m_size.x : WSSIZE.x;
float heightLeft = WSSIZE.y; float heightLeft = WSSIZE.y;
int mastersLeft = MASTERS; int mastersLeft = MASTERS;
float nextX = 0; float nextX = 0;
@@ -438,7 +438,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
if (orientation == ORIENTATION_RIGHT) { if (orientation == ORIENTATION_RIGHT) {
nextX = WSSIZE.x - WIDTH; nextX = WSSIZE.x - WIDTH;
} else if (centerMasterWindow) { } else if (centerMasterWindow) {
nextX = ((*PIGNORERESERVED && centerMasterWindow ? PMONITOR->vecSize.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_lMasterNodesData) {
@@ -455,7 +455,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
} }
nd.size = Vector2D(WIDTH, HEIGHT); nd.size = Vector2D(WIDTH, HEIGHT);
nd.position = (*PIGNORERESERVED && centerMasterWindow ? PMONITOR->vecPosition : WSPOS) + Vector2D(nextX, nextY); nd.position = (*PIGNORERESERVED && centerMasterWindow ? PMONITOR->m_position : WSPOS) + Vector2D(nextX, nextY);
applyNodeDataToWindow(&nd); applyNodeDataToWindow(&nd);
mastersLeft--; mastersLeft--;
@@ -530,7 +530,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
nextY += HEIGHT; nextY += HEIGHT;
} }
} else { // slaves for centered master window(s) } else { // slaves for centered master window(s)
const float WIDTH = ((*PIGNORERESERVED ? PMONITOR->vecSize.x : WSSIZE.x) - PMASTERNODE->size.x) / 2.0; const float WIDTH = ((*PIGNORERESERVED ? PMONITOR->m_size.x : WSSIZE.x) - PMASTERNODE->size.x) / 2.0;
float heightLeft = 0; float heightLeft = 0;
float heightLeftL = WSSIZE.y; float heightLeftL = WSSIZE.y;
float heightLeftR = WSSIZE.y; float heightLeftR = WSSIZE.y;
@@ -573,7 +573,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
continue; continue;
if (onRight) { if (onRight) {
nextX = WIDTH + PMASTERNODE->size.x - (*PIGNORERESERVED ? PMONITOR->vecReservedTopLeft.x : 0); nextX = WIDTH + PMASTERNODE->size.x - (*PIGNORERESERVED ? PMONITOR->m_reservedTopLeft.x : 0);
nextY = nextYR; nextY = nextYR;
heightLeft = heightLeftR; heightLeft = heightLeftR;
slavesLeft = slavesLeftR; slavesLeft = slavesLeftR;
@@ -598,7 +598,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) {
} }
} }
nd.size = Vector2D(*PIGNORERESERVED ? (WIDTH - (onRight ? PMONITOR->vecReservedBottomRight.x : PMONITOR->vecReservedTopLeft.x)) : WIDTH, HEIGHT); nd.size = Vector2D(*PIGNORERESERVED ? (WIDTH - (onRight ? PMONITOR->m_reservedBottomRight.x : PMONITOR->m_reservedTopLeft.x)) : WIDTH, HEIGHT);
nd.position = WSPOS + Vector2D(nextX, nextY); nd.position = WSPOS + Vector2D(nextX, nextY);
applyNodeDataToWindow(&nd); applyNodeDataToWindow(&nd);
@@ -636,10 +636,10 @@ void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) {
} }
// for gaps outer // for gaps outer
const bool DISPLAYLEFT = STICKS(pNode->position.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x); const bool DISPLAYLEFT = STICKS(pNode->position.x, PMONITOR->m_position.x + PMONITOR->m_reservedTopLeft.x);
const bool DISPLAYRIGHT = STICKS(pNode->position.x + pNode->size.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x); const bool DISPLAYRIGHT = STICKS(pNode->position.x + pNode->size.x, PMONITOR->m_position.x + PMONITOR->m_size.x - PMONITOR->m_reservedBottomRight.x);
const bool DISPLAYTOP = STICKS(pNode->position.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y); const bool DISPLAYTOP = STICKS(pNode->position.y, PMONITOR->m_position.y + PMONITOR->m_reservedTopLeft.y);
const bool DISPLAYBOTTOM = STICKS(pNode->position.y + pNode->size.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y); const bool DISPLAYBOTTOM = STICKS(pNode->position.y + pNode->size.y, PMONITOR->m_position.y + PMONITOR->m_size.y - PMONITOR->m_reservedBottomRight.y);
const auto PWINDOW = pNode->pWindow.lock(); const auto PWINDOW = pNode->pWindow.lock();
// get specific gaps and rules for this workspace, // get specific gaps and rules for this workspace,
@@ -737,10 +737,10 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
static auto SLAVECOUNTFORCENTER = CConfigValue<Hyprlang::INT>("master:slave_count_for_center_master"); static auto SLAVECOUNTFORCENTER = CConfigValue<Hyprlang::INT>("master:slave_count_for_center_master");
static auto PSMARTRESIZING = CConfigValue<Hyprlang::INT>("master:smart_resizing"); static auto PSMARTRESIZING = CConfigValue<Hyprlang::INT>("master:smart_resizing");
const bool DISPLAYBOTTOM = STICKS(PWINDOW->m_position.y + PWINDOW->m_size.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.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);
const bool DISPLAYRIGHT = STICKS(PWINDOW->m_position.x + PWINDOW->m_size.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x); const bool DISPLAYRIGHT = STICKS(PWINDOW->m_position.x + PWINDOW->m_size.x, PMONITOR->m_position.x + PMONITOR->m_size.x - PMONITOR->m_reservedBottomRight.x);
const bool DISPLAYTOP = STICKS(PWINDOW->m_position.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y); const bool DISPLAYTOP = STICKS(PWINDOW->m_position.y, PMONITOR->m_position.y + PMONITOR->m_reservedTopLeft.y);
const bool DISPLAYLEFT = STICKS(PWINDOW->m_position.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x); const bool DISPLAYLEFT = STICKS(PWINDOW->m_position.x, PMONITOR->m_position.x + PMONITOR->m_reservedTopLeft.x);
const bool LEFT = corner == CORNER_TOPLEFT || corner == CORNER_BOTTOMLEFT; const bool LEFT = corner == CORNER_TOPLEFT || corner == CORNER_BOTTOMLEFT;
const bool TOP = corner == CORNER_TOPLEFT || corner == CORNER_TOPRIGHT; const bool TOP = corner == CORNER_TOPLEFT || corner == CORNER_TOPRIGHT;
@@ -760,12 +760,12 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
m_bForceWarps = true; m_bForceWarps = true;
switch (orientation) { switch (orientation) {
case ORIENTATION_LEFT: delta = pixResize.x / PMONITOR->vecSize.x; break; case ORIENTATION_LEFT: delta = pixResize.x / PMONITOR->m_size.x; break;
case ORIENTATION_RIGHT: delta = -pixResize.x / PMONITOR->vecSize.x; break; case ORIENTATION_RIGHT: delta = -pixResize.x / PMONITOR->m_size.x; break;
case ORIENTATION_BOTTOM: delta = -pixResize.y / PMONITOR->vecSize.y; break; case ORIENTATION_BOTTOM: delta = -pixResize.y / PMONITOR->m_size.y; break;
case ORIENTATION_TOP: delta = pixResize.y / PMONITOR->vecSize.y; break; case ORIENTATION_TOP: delta = pixResize.y / PMONITOR->m_size.y; break;
case ORIENTATION_CENTER: case ORIENTATION_CENTER:
delta = pixResize.x / PMONITOR->vecSize.x; delta = pixResize.x / PMONITOR->m_size.x;
if (STACKWINDOWS >= *SLAVECOUNTFORCENTER) { if (STACKWINDOWS >= *SLAVECOUNTFORCENTER) {
if (!NONE || !PNODE->isMaster) if (!NONE || !PNODE->isMaster)
delta *= 2; delta *= 2;
@@ -776,7 +776,7 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
default: UNREACHABLE(); default: UNREACHABLE();
} }
const auto workspaceIdForResizing = PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspaceID() : PMONITOR->activeWorkspaceID(); const auto workspaceIdForResizing = PMONITOR->m_activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspaceID() : PMONITOR->activeWorkspaceID();
for (auto& n : m_lMasterNodesData) { for (auto& n : m_lMasterNodesData) {
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);
@@ -786,7 +786,7 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
const bool isStackVertical = orientation == ORIENTATION_LEFT || orientation == ORIENTATION_RIGHT || orientation == ORIENTATION_CENTER; const bool isStackVertical = orientation == ORIENTATION_LEFT || orientation == ORIENTATION_RIGHT || orientation == ORIENTATION_CENTER;
const auto RESIZEDELTA = isStackVertical ? pixResize.y : pixResize.x; const auto RESIZEDELTA = isStackVertical ? pixResize.y : pixResize.x;
const auto WSSIZE = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight; const auto WSSIZE = PMONITOR->m_size - PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight;
auto nodesInSameColumn = PNODE->isMaster ? MASTERS : STACKWINDOWS; auto nodesInSameColumn = PNODE->isMaster ? MASTERS : STACKWINDOWS;
if (orientation == ORIENTATION_CENTER && !PNODE->isMaster) if (orientation == ORIENTATION_CENTER && !PNODE->isMaster)
@@ -856,7 +856,7 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
} }
} }
recalculateMonitor(PMONITOR->ID); recalculateMonitor(PMONITOR->m_id);
m_bForceWarps = false; m_bForceWarps = false;
} }
@@ -889,8 +889,8 @@ void CHyprMasterLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFul
} else { } else {
// apply new pos and size being monitors' box // apply new pos and size being monitors' box
if (EFFECTIVE_MODE == FSMODE_FULLSCREEN) { if (EFFECTIVE_MODE == FSMODE_FULLSCREEN) {
*pWindow->m_realPosition = PMONITOR->vecPosition; *pWindow->m_realPosition = PMONITOR->m_position;
*pWindow->m_realSize = PMONITOR->vecSize; *pWindow->m_realSize = PMONITOR->m_size;
} else { } else {
// This is a massive hack. // This is a massive hack.
// We make a fake "only" node and apply // We make a fake "only" node and apply
@@ -898,8 +898,8 @@ void CHyprMasterLayout::fullscreenRequestForWindow(PHLWINDOW pWindow, const eFul
SMasterNodeData fakeNode; SMasterNodeData fakeNode;
fakeNode.pWindow = pWindow; fakeNode.pWindow = pWindow;
fakeNode.position = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft; fakeNode.position = PMONITOR->m_position + PMONITOR->m_reservedTopLeft;
fakeNode.size = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight; fakeNode.size = PMONITOR->m_size - PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight;
fakeNode.workspaceID = pWindow->workspaceID(); fakeNode.workspaceID = pWindow->workspaceID();
pWindow->m_position = fakeNode.position; pWindow->m_position = fakeNode.position;
pWindow->m_size = fakeNode.size; pWindow->m_size = fakeNode.size;
@@ -1446,22 +1446,22 @@ Vector2D CHyprMasterLayout::predictSizeForNewWindowTiled() {
if (!g_pCompositor->m_lastMonitor) if (!g_pCompositor->m_lastMonitor)
return {}; return {};
const int NODES = getNodesOnWorkspace(g_pCompositor->m_lastMonitor->activeWorkspace->m_id); const int NODES = getNodesOnWorkspace(g_pCompositor->m_lastMonitor->m_activeWorkspace->m_id);
if (NODES <= 0) if (NODES <= 0)
return g_pCompositor->m_lastMonitor->vecSize; return g_pCompositor->m_lastMonitor->m_size;
const auto MASTER = getMasterNodeOnWorkspace(g_pCompositor->m_lastMonitor->activeWorkspace->m_id); const auto MASTER = getMasterNodeOnWorkspace(g_pCompositor->m_lastMonitor->m_activeWorkspace->m_id);
if (!MASTER) // wtf if (!MASTER) // wtf
return {}; return {};
if (*PNEWSTATUS == "master") { if (*PNEWSTATUS == "master") {
return MASTER->size; return MASTER->size;
} else { } else {
const auto SLAVES = NODES - getMastersOnWorkspace(g_pCompositor->m_lastMonitor->activeWorkspace->m_id); const auto SLAVES = NODES - getMastersOnWorkspace(g_pCompositor->m_lastMonitor->m_activeWorkspace->m_id);
// TODO: make this better // TODO: make this better
return {g_pCompositor->m_lastMonitor->vecSize.x - MASTER->size.x, g_pCompositor->m_lastMonitor->vecSize.y / (SLAVES + 1)}; return {g_pCompositor->m_lastMonitor->m_size.x - MASTER->size.x, g_pCompositor->m_lastMonitor->m_size.y / (SLAVES + 1)};
} }
return {}; return {};

28
src/managers/AnimationManager.cpp
View File

@@ -21,7 +21,7 @@ static int wlTick(SP<CEventLoopTimer> self, void* data) {
g_pAnimationManager->onTicked(); g_pAnimationManager->onTicked();
if (g_pCompositor->m_sessionActive && g_pAnimationManager && g_pHookSystem && !g_pCompositor->m_unsafeState && if (g_pCompositor->m_sessionActive && g_pAnimationManager && g_pHookSystem && !g_pCompositor->m_unsafeState &&
std::ranges::any_of(g_pCompositor->m_monitors, [](const auto& mon) { return mon->m_bEnabled && mon->output; })) { std::ranges::any_of(g_pCompositor->m_monitors, [](const auto& mon) { return mon->m_enabled && mon->m_output; })) {
g_pAnimationManager->tick(); g_pAnimationManager->tick();
EMIT_HOOK_EVENT("tick", nullptr); EMIT_HOOK_EVENT("tick", nullptr);
} }
@@ -64,7 +64,7 @@ static void updateColorVariable(CAnimatedVariable<CHyprColor>& av, const float P
const auto& L1 = av.begun().asOkLab(); const auto& L1 = av.begun().asOkLab();
const auto& L2 = av.goal().asOkLab(); const auto& L2 = av.goal().asOkLab();
static const auto lerp = [](const float one, const float two, const float progress) -> float { return one + (two - one) * progress; }; static const auto lerp = [](const float one, const float two, const float progress) -> float { return one + ((two - one) * progress); };
const Hyprgraphics::CColor lerped = Hyprgraphics::CColor::SOkLab{ const Hyprgraphics::CColor lerped = Hyprgraphics::CColor::SOkLab{
.l = lerp(L1.l, L2.l, POINTY), .l = lerp(L1.l, L2.l, POINTY),
@@ -117,7 +117,7 @@ static void handleUpdate(CAnimatedVariable<VarType>& av, bool warp) {
// still doing the full damage hack for floating because sometimes when the window // still doing the full damage hack for floating because sometimes when the window
// goes through multiple monitors the last rendered frame is missing damage somehow?? // goes through multiple monitors the last rendered frame is missing damage somehow??
const CBox windowBoxNoOffset = w->getFullWindowBoundingBox(); const CBox windowBoxNoOffset = w->getFullWindowBoundingBox();
const CBox monitorBox = {PMONITOR->vecPosition, PMONITOR->vecSize}; const CBox monitorBox = {PMONITOR->m_position, PMONITOR->m_size};
if (windowBoxNoOffset.intersection(monitorBox) != windowBoxNoOffset) // on edges between multiple monitors if (windowBoxNoOffset.intersection(monitorBox) != windowBoxNoOffset) // on edges between multiple monitors
g_pHyprRenderer->damageWindow(w, true); g_pHyprRenderer->damageWindow(w, true);
} }
@@ -262,9 +262,9 @@ void CHyprAnimationManager::scheduleTick() {
return; return;
} }
float refreshDelayMs = std::floor(1000.f / PMOSTHZ->refreshRate); float refreshDelayMs = std::floor(1000.f / PMOSTHZ->m_refreshRate);
const float SINCEPRES = std::chrono::duration_cast<std::chrono::microseconds>(Time::steadyNow() - PMOSTHZ->lastPresentationTimer.chrono()).count() / 1000.F; const float SINCEPRES = std::chrono::duration_cast<std::chrono::microseconds>(Time::steadyNow() - PMOSTHZ->m_lastPresentationTimer.chrono()).count() / 1000.F;
const auto TOPRES = std::clamp(refreshDelayMs - SINCEPRES, 1.1f, 1000.f); // we can't send 0, that will disarm it const auto TOPRES = std::clamp(refreshDelayMs - SINCEPRES, 1.1f, 1000.f); // we can't send 0, that will disarm it
@@ -308,13 +308,13 @@ void CHyprAnimationManager::animationSlide(PHLWINDOW pWindow, std::string force,
if (force != "") { if (force != "") {
if (force == "bottom") if (force == "bottom")
posOffset = Vector2D(GOALPOS.x, PMONITOR->vecPosition.y + PMONITOR->vecSize.y); posOffset = Vector2D(GOALPOS.x, PMONITOR->m_position.y + PMONITOR->m_size.y);
else if (force == "left") else if (force == "left")
posOffset = GOALPOS - Vector2D(GOALSIZE.x, 0.0); posOffset = GOALPOS - Vector2D(GOALSIZE.x, 0.0);
else if (force == "right") else if (force == "right")
posOffset = GOALPOS + Vector2D(GOALSIZE.x, 0.0); posOffset = GOALPOS + Vector2D(GOALSIZE.x, 0.0);
else else
posOffset = Vector2D(GOALPOS.x, PMONITOR->vecPosition.y - GOALSIZE.y); posOffset = Vector2D(GOALPOS.x, PMONITOR->m_position.y - GOALSIZE.y);
if (!close) if (!close)
pWindow->m_realPosition->setValue(posOffset); pWindow->m_realPosition->setValue(posOffset);
@@ -327,10 +327,10 @@ void CHyprAnimationManager::animationSlide(PHLWINDOW pWindow, std::string force,
const auto MIDPOINT = GOALPOS + GOALSIZE / 2.f; const auto MIDPOINT = GOALPOS + GOALSIZE / 2.f;
// check sides it touches // check sides it touches
const bool DISPLAYLEFT = STICKS(pWindow->m_position.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x); const bool DISPLAYLEFT = STICKS(pWindow->m_position.x, PMONITOR->m_position.x + PMONITOR->m_reservedTopLeft.x);
const bool DISPLAYRIGHT = STICKS(pWindow->m_position.x + pWindow->m_size.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x); const bool DISPLAYRIGHT = STICKS(pWindow->m_position.x + pWindow->m_size.x, PMONITOR->m_position.x + PMONITOR->m_size.x - PMONITOR->m_reservedBottomRight.x);
const bool DISPLAYTOP = STICKS(pWindow->m_position.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y); const bool DISPLAYTOP = STICKS(pWindow->m_position.y, PMONITOR->m_position.y + PMONITOR->m_reservedTopLeft.y);
const bool DISPLAYBOTTOM = STICKS(pWindow->m_position.y + pWindow->m_size.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.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 (DISPLAYBOTTOM && DISPLAYTOP) { if (DISPLAYBOTTOM && DISPLAYTOP) {
if (DISPLAYLEFT && DISPLAYRIGHT) { if (DISPLAYLEFT && DISPLAYRIGHT) {
@@ -345,10 +345,10 @@ void CHyprAnimationManager::animationSlide(PHLWINDOW pWindow, std::string force,
} else if (DISPLAYBOTTOM) { } else if (DISPLAYBOTTOM) {
posOffset = GOALPOS + Vector2D(0.0, GOALSIZE.y); posOffset = GOALPOS + Vector2D(0.0, GOALSIZE.y);
} else { } else {
if (MIDPOINT.y > PMONITOR->vecPosition.y + PMONITOR->vecSize.y / 2.f) if (MIDPOINT.y > PMONITOR->m_position.y + PMONITOR->m_size.y / 2.f)
posOffset = Vector2D(GOALPOS.x, PMONITOR->vecPosition.y + PMONITOR->vecSize.y); posOffset = Vector2D(GOALPOS.x, PMONITOR->m_position.y + PMONITOR->m_size.y);
else else
posOffset = Vector2D(GOALPOS.x, PMONITOR->vecPosition.y - GOALSIZE.y); posOffset = Vector2D(GOALPOS.x, PMONITOR->m_position.y - GOALSIZE.y);
} }
if (!close) if (!close)

6
src/managers/CursorManager.cpp
View File

@@ -291,8 +291,8 @@ void CCursorManager::updateTheme() {
float highestScale = 1.0; float highestScale = 1.0;
for (auto const& m : g_pCompositor->m_monitors) { for (auto const& m : g_pCompositor->m_monitors) {
if (m->scale > highestScale) if (m->m_scale > highestScale)
highestScale = m->scale; highestScale = m->m_scale;
} }
m_fCursorScale = highestScale; m_fCursorScale = highestScale;
@@ -308,7 +308,7 @@ void CCursorManager::updateTheme() {
} }
for (auto const& m : g_pCompositor->m_monitors) { for (auto const& m : g_pCompositor->m_monitors) {
m->forceFullFrames = 5; m->m_forceFullFrames = 5;
g_pCompositor->scheduleFrameForMonitor(m, Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_SHAPE); g_pCompositor->scheduleFrameForMonitor(m, Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_SHAPE);
} }
} }

84
src/managers/KeybindManager.cpp
View File

@@ -49,16 +49,16 @@ static std::vector<std::pair<std::string, std::string>> getHyprlandLaunchEnv(PHL
return {}; return {};
const auto PMONITOR = g_pCompositor->m_lastMonitor; const auto PMONITOR = g_pCompositor->m_lastMonitor;
if (!PMONITOR || !PMONITOR->activeWorkspace) if (!PMONITOR || !PMONITOR->m_activeWorkspace)
return {}; return {};
std::vector<std::pair<std::string, std::string>> result; std::vector<std::pair<std::string, std::string>> result;
if (!pInitialWorkspace) { if (!pInitialWorkspace) {
if (PMONITOR->activeSpecialWorkspace) if (PMONITOR->m_activeSpecialWorkspace)
pInitialWorkspace = PMONITOR->activeSpecialWorkspace; pInitialWorkspace = PMONITOR->m_activeSpecialWorkspace;
else else
pInitialWorkspace = PMONITOR->activeWorkspace; pInitialWorkspace = PMONITOR->m_activeWorkspace;
} }
result.push_back(std::make_pair<>("HL_INITIAL_WORKSPACE_TOKEN", result.push_back(std::make_pair<>("HL_INITIAL_WORKSPACE_TOKEN",
@@ -349,13 +349,13 @@ bool CKeybindManager::tryMoveFocusToMonitor(PHLMONITOR monitor) {
static auto PFOLLOWMOUSE = CConfigValue<Hyprlang::INT>("input:follow_mouse"); static auto PFOLLOWMOUSE = CConfigValue<Hyprlang::INT>("input:follow_mouse");
static auto PNOWARPS = CConfigValue<Hyprlang::INT>("cursor:no_warps"); static auto PNOWARPS = CConfigValue<Hyprlang::INT>("cursor:no_warps");
const auto PWORKSPACE = g_pCompositor->m_lastMonitor->activeWorkspace; const auto PWORKSPACE = g_pCompositor->m_lastMonitor->m_activeWorkspace;
const auto PNEWMAINWORKSPACE = monitor->activeWorkspace; const auto PNEWMAINWORKSPACE = monitor->m_activeWorkspace;
g_pInputManager->unconstrainMouse(); g_pInputManager->unconstrainMouse();
PNEWMAINWORKSPACE->rememberPrevWorkspace(PWORKSPACE); PNEWMAINWORKSPACE->rememberPrevWorkspace(PWORKSPACE);
const auto PNEWWORKSPACE = monitor->activeSpecialWorkspace ? monitor->activeSpecialWorkspace : PNEWMAINWORKSPACE; const auto PNEWWORKSPACE = monitor->m_activeSpecialWorkspace ? monitor->m_activeSpecialWorkspace : PNEWMAINWORKSPACE;
const auto PNEWWINDOW = PNEWWORKSPACE->getLastFocusedWindow(); const auto PNEWWINDOW = PNEWWORKSPACE->getLastFocusedWindow();
if (PNEWWINDOW) { if (PNEWWINDOW) {
@@ -1196,7 +1196,7 @@ SDispatchResult CKeybindManager::centerWindow(std::string args) {
auto RESERVEDOFFSET = Vector2D(); auto RESERVEDOFFSET = Vector2D();
if (args == "1") if (args == "1")
RESERVEDOFFSET = (PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight) / 2.f; RESERVEDOFFSET = (PMONITOR->m_reservedTopLeft - PMONITOR->m_reservedBottomRight) / 2.f;
*PWINDOW->m_realPosition = PMONITOR->middle() - PWINDOW->m_realSize->goal() / 2.f + RESERVEDOFFSET; *PWINDOW->m_realPosition = PMONITOR->middle() - PWINDOW->m_realSize->goal() / 2.f + RESERVEDOFFSET;
PWINDOW->m_position = PWINDOW->m_realPosition->goal(); PWINDOW->m_position = PWINDOW->m_realPosition->goal();
@@ -1256,7 +1256,7 @@ SDispatchResult CKeybindManager::changeworkspace(std::string args) {
if (!PMONITOR) if (!PMONITOR)
return {.success = false, .error = "Last monitor not found"}; return {.success = false, .error = "Last monitor not found"};
const auto PCURRENTWORKSPACE = PMONITOR->activeWorkspace; const auto PCURRENTWORKSPACE = PMONITOR->m_activeWorkspace;
const bool EXPLICITPREVIOUS = args.contains("previous"); const bool EXPLICITPREVIOUS = args.contains("previous");
const auto& [workspaceToChangeTo, workspaceName] = getWorkspaceToChangeFromArgs(args, PCURRENTWORKSPACE, PMONITOR); const auto& [workspaceToChangeTo, workspaceName] = getWorkspaceToChangeFromArgs(args, PCURRENTWORKSPACE, PMONITOR);
@@ -1284,7 +1284,7 @@ SDispatchResult CKeybindManager::changeworkspace(std::string args) {
auto pWorkspaceToChangeTo = g_pCompositor->getWorkspaceByID(BISWORKSPACECURRENT ? PPREVWS.id : workspaceToChangeTo); auto pWorkspaceToChangeTo = g_pCompositor->getWorkspaceByID(BISWORKSPACECURRENT ? PPREVWS.id : workspaceToChangeTo);
if (!pWorkspaceToChangeTo) if (!pWorkspaceToChangeTo)
pWorkspaceToChangeTo = pWorkspaceToChangeTo =
g_pCompositor->createNewWorkspace(BISWORKSPACECURRENT ? PPREVWS.id : workspaceToChangeTo, PMONITOR->ID, BISWORKSPACECURRENT ? PPREVWS.name : workspaceName); g_pCompositor->createNewWorkspace(BISWORKSPACECURRENT ? PPREVWS.id : workspaceToChangeTo, PMONITOR->m_id, BISWORKSPACECURRENT ? PPREVWS.name : workspaceName);
if (!BISWORKSPACECURRENT && pWorkspaceToChangeTo->m_isSpecialWorkspace) { if (!BISWORKSPACECURRENT && pWorkspaceToChangeTo->m_isSpecialWorkspace) {
PMONITOR->setSpecialWorkspace(pWorkspaceToChangeTo); PMONITOR->setSpecialWorkspace(pWorkspaceToChangeTo);
@@ -1561,9 +1561,9 @@ SDispatchResult CKeybindManager::moveFocusTo(std::string args) {
return {.success = false, .error = "last window has no monitor?"}; return {.success = false, .error = "last window has no monitor?"};
if (arg == 'l' || arg == 'r') { if (arg == 'l' || arg == 'r') {
if (STICKS(PLASTWINDOW->m_position.x, PMONITOR->vecPosition.x) && STICKS(PLASTWINDOW->m_size.x, PMONITOR->vecSize.x)) if (STICKS(PLASTWINDOW->m_position.x, PMONITOR->m_position.x) && STICKS(PLASTWINDOW->m_size.x, PMONITOR->m_size.x))
return {.success = false, .error = "move does not make sense, would return back"}; return {.success = false, .error = "move does not make sense, would return back"};
} else if (STICKS(PLASTWINDOW->m_position.y, PMONITOR->vecPosition.y) && STICKS(PLASTWINDOW->m_size.y, PMONITOR->vecSize.y)) } else if (STICKS(PLASTWINDOW->m_position.y, PMONITOR->m_position.y) && STICKS(PLASTWINDOW->m_size.y, PMONITOR->m_size.y))
return {.success = false, .error = "move does not make sense, would return back"}; return {.success = false, .error = "move does not make sense, would return back"};
CBox box = PMONITOR->logicalBox(); CBox box = PMONITOR->logicalBox();
@@ -1588,8 +1588,8 @@ SDispatchResult CKeybindManager::moveFocusTo(std::string args) {
break; break;
} }
const auto PWINDOWCANDIDATE = g_pCompositor->getWindowInDirection(box, PMONITOR->activeSpecialWorkspace ? PMONITOR->activeSpecialWorkspace : PMONITOR->activeWorkspace, arg, const auto PWINDOWCANDIDATE = g_pCompositor->getWindowInDirection(box, PMONITOR->m_activeSpecialWorkspace ? PMONITOR->m_activeSpecialWorkspace : PMONITOR->m_activeWorkspace,
PLASTWINDOW, PLASTWINDOW->m_isFloating); arg, PLASTWINDOW, PLASTWINDOW->m_isFloating);
if (PWINDOWCANDIDATE) if (PWINDOWCANDIDATE)
switchToWindow(PWINDOWCANDIDATE); switchToWindow(PWINDOWCANDIDATE);
@@ -1661,9 +1661,9 @@ SDispatchResult CKeybindManager::moveActiveTo(std::string args) {
return {.success = false, .error = std::format("Monitor {} not found", args.substr(4))}; return {.success = false, .error = std::format("Monitor {} not found", args.substr(4))};
if (silent) if (silent)
moveActiveToWorkspaceSilent(PNEWMONITOR->activeWorkspace->getConfigName()); moveActiveToWorkspaceSilent(PNEWMONITOR->m_activeWorkspace->getConfigName());
else else
moveActiveToWorkspace(PNEWMONITOR->activeWorkspace->getConfigName()); moveActiveToWorkspace(PNEWMONITOR->m_activeWorkspace->getConfigName());
return {}; return {};
} }
@@ -1687,12 +1687,12 @@ SDispatchResult CKeybindManager::moveActiveTo(std::string args) {
const auto BORDERSIZE = PLASTWINDOW->getRealBorderSize(); const auto BORDERSIZE = PLASTWINDOW->getRealBorderSize();
switch (arg) { switch (arg) {
case 'l': vPosx = PMONITOR->vecReservedTopLeft.x + BORDERSIZE + PMONITOR->vecPosition.x; break; case 'l': vPosx = PMONITOR->m_reservedTopLeft.x + BORDERSIZE + PMONITOR->m_position.x; break;
case 'r': vPosx = PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PLASTWINDOW->m_realSize->goal().x - BORDERSIZE + PMONITOR->vecPosition.x; break; case 'r': vPosx = PMONITOR->m_size.x - PMONITOR->m_reservedBottomRight.x - PLASTWINDOW->m_realSize->goal().x - BORDERSIZE + PMONITOR->m_position.x; break;
case 't': case 't':
case 'u': vPosy = PMONITOR->vecReservedTopLeft.y + BORDERSIZE + PMONITOR->vecPosition.y; break; case 'u': vPosy = PMONITOR->m_reservedTopLeft.y + BORDERSIZE + PMONITOR->m_position.y; break;
case 'b': case 'b':
case 'd': vPosy = PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PLASTWINDOW->m_realSize->goal().y - BORDERSIZE + PMONITOR->vecPosition.y; break; case 'd': vPosy = PMONITOR->m_size.y - PMONITOR->m_reservedBottomRight.y - PLASTWINDOW->m_realSize->goal().y - BORDERSIZE + PMONITOR->m_position.y; break;
} }
*PLASTWINDOW->m_realPosition = Vector2D(vPosx.value_or(PLASTWINDOW->m_realPosition->goal().x), vPosy.value_or(PLASTWINDOW->m_realPosition->goal().y)); *PLASTWINDOW->m_realPosition = Vector2D(vPosx.value_or(PLASTWINDOW->m_realPosition->goal().x), vPosy.value_or(PLASTWINDOW->m_realPosition->goal().y));
@@ -1720,7 +1720,7 @@ SDispatchResult CKeybindManager::moveActiveTo(std::string args) {
if (!PMONITORTOCHANGETO) if (!PMONITORTOCHANGETO)
return {.success = false, .error = "Nowhere to move active window to"}; return {.success = false, .error = "Nowhere to move active window to"};
const auto PWORKSPACE = PMONITORTOCHANGETO->activeWorkspace; const auto PWORKSPACE = PMONITORTOCHANGETO->m_activeWorkspace;
if (silent) if (silent)
moveActiveToWorkspaceSilent(PWORKSPACE->getConfigName()); moveActiveToWorkspaceSilent(PWORKSPACE->getConfigName());
else else
@@ -1919,7 +1919,7 @@ SDispatchResult CKeybindManager::moveCursor(std::string args) {
SDispatchResult CKeybindManager::workspaceOpt(std::string args) { SDispatchResult CKeybindManager::workspaceOpt(std::string args) {
// current workspace // current workspace
const auto PWORKSPACE = g_pCompositor->m_lastMonitor->activeWorkspace; const auto PWORKSPACE = g_pCompositor->m_lastMonitor->m_activeWorkspace;
if (!PWORKSPACE) if (!PWORKSPACE)
return {.success = false, .error = "Workspace not found"}; // ???? return {.success = false, .error = "Workspace not found"}; // ????
@@ -1966,7 +1966,7 @@ SDispatchResult CKeybindManager::workspaceOpt(std::string args) {
} }
// recalc mon // recalc mon
g_pLayoutManager->getCurrentLayout()->recalculateMonitor(g_pCompositor->m_lastMonitor->ID); g_pLayoutManager->getCurrentLayout()->recalculateMonitor(g_pCompositor->m_lastMonitor->m_id);
return {}; return {};
} }
@@ -2012,7 +2012,7 @@ SDispatchResult CKeybindManager::moveCurrentWorkspaceToMonitor(std::string args)
} }
// get the current workspace // get the current workspace
const auto PCURRENTWORKSPACE = g_pCompositor->m_lastMonitor->activeWorkspace; const auto PCURRENTWORKSPACE = g_pCompositor->m_lastMonitor->m_activeWorkspace;
if (!PCURRENTWORKSPACE) { if (!PCURRENTWORKSPACE) {
Debug::log(ERR, "moveCurrentWorkspaceToMonitor invalid workspace!"); Debug::log(ERR, "moveCurrentWorkspaceToMonitor invalid workspace!");
return {.success = false, .error = "moveCurrentWorkspaceToMonitor invalid workspace!"}; return {.success = false, .error = "moveCurrentWorkspaceToMonitor invalid workspace!"};
@@ -2073,7 +2073,7 @@ SDispatchResult CKeybindManager::focusWorkspaceOnCurrentMonitor(std::string args
auto pWorkspace = g_pCompositor->getWorkspaceByID(workspaceID); auto pWorkspace = g_pCompositor->getWorkspaceByID(workspaceID);
if (!pWorkspace) { if (!pWorkspace) {
pWorkspace = g_pCompositor->createNewWorkspace(workspaceID, PCURRMONITOR->ID, workspaceName); pWorkspace = g_pCompositor->createNewWorkspace(workspaceID, PCURRMONITOR->m_id, workspaceName);
// we can skip the moving, since it's already on the current monitor // we can skip the moving, since it's already on the current monitor
changeworkspace(pWorkspace->getConfigName()); changeworkspace(pWorkspace->getConfigName());
return {}; return {};
@@ -2086,7 +2086,7 @@ SDispatchResult CKeybindManager::focusWorkspaceOnCurrentMonitor(std::string args
// Workspace to focus is previous workspace // Workspace to focus is previous workspace
pWorkspace = g_pCompositor->getWorkspaceByID(PREVWS.id); pWorkspace = g_pCompositor->getWorkspaceByID(PREVWS.id);
if (!pWorkspace) if (!pWorkspace)
pWorkspace = g_pCompositor->createNewWorkspace(PREVWS.id, PCURRMONITOR->ID, PREVWS.name); pWorkspace = g_pCompositor->createNewWorkspace(PREVWS.id, PCURRMONITOR->m_id, PREVWS.name);
workspaceID = pWorkspace->m_id; workspaceID = pWorkspace->m_id;
} }
@@ -2137,13 +2137,13 @@ SDispatchResult CKeybindManager::toggleSpecialWorkspace(std::string args) {
Debug::log(LOG, "Toggling special workspace {} to closed", workspaceID); Debug::log(LOG, "Toggling special workspace {} to closed", workspaceID);
PMONITOR->setSpecialWorkspace(nullptr); PMONITOR->setSpecialWorkspace(nullptr);
focusedWorkspace = PMONITOR->activeWorkspace; focusedWorkspace = PMONITOR->m_activeWorkspace;
} else { } else {
Debug::log(LOG, "Toggling special workspace {} to open", workspaceID); Debug::log(LOG, "Toggling special workspace {} to open", workspaceID);
auto PSPECIALWORKSPACE = g_pCompositor->getWorkspaceByID(workspaceID); auto PSPECIALWORKSPACE = g_pCompositor->getWorkspaceByID(workspaceID);
if (!PSPECIALWORKSPACE) if (!PSPECIALWORKSPACE)
PSPECIALWORKSPACE = g_pCompositor->createNewWorkspace(workspaceID, PMONITOR->ID, workspaceName); PSPECIALWORKSPACE = g_pCompositor->createNewWorkspace(workspaceID, PMONITOR->m_id, workspaceName);
PMONITOR->setSpecialWorkspace(PSPECIALWORKSPACE); PMONITOR->setSpecialWorkspace(PSPECIALWORKSPACE);
@@ -2167,7 +2167,7 @@ SDispatchResult CKeybindManager::forceRendererReload(std::string args) {
bool overAgain = false; bool overAgain = false;
for (auto const& m : g_pCompositor->m_monitors) { for (auto const& m : g_pCompositor->m_monitors) {
if (!m->output) if (!m->m_output)
continue; continue;
auto rule = g_pConfigManager->getMonitorRuleFor(m); auto rule = g_pConfigManager->getMonitorRuleFor(m);
@@ -2274,7 +2274,7 @@ SDispatchResult CKeybindManager::resizeWindow(std::string args) {
SDispatchResult CKeybindManager::circleNext(std::string arg) { SDispatchResult CKeybindManager::circleNext(std::string arg) {
if (g_pCompositor->m_lastWindow.expired()) { if (g_pCompositor->m_lastWindow.expired()) {
// if we have a clear focus, find the first window and get the next focusable. // if we have a clear focus, find the first window and get the next focusable.
const auto PWS = g_pCompositor->m_lastMonitor->activeWorkspace; const auto PWS = g_pCompositor->m_lastMonitor->m_activeWorkspace;
if (PWS && PWS->getWindows() > 0) { if (PWS && PWS->getWindows() > 0) {
const auto PWINDOW = PWS->getFirstWindow(); const auto PWINDOW = PWS->getFirstWindow();
switchToWindow(PWINDOW); switchToWindow(PWINDOW);
@@ -2319,8 +2319,8 @@ SDispatchResult CKeybindManager::focusWindow(std::string regexp) {
updateRelativeCursorCoords(); updateRelativeCursorCoords();
if (g_pCompositor->m_lastMonitor && g_pCompositor->m_lastMonitor->activeWorkspace != PWINDOW->m_workspace && if (g_pCompositor->m_lastMonitor && g_pCompositor->m_lastMonitor->m_activeWorkspace != PWINDOW->m_workspace &&
g_pCompositor->m_lastMonitor->activeSpecialWorkspace != PWINDOW->m_workspace) { g_pCompositor->m_lastMonitor->m_activeSpecialWorkspace != PWINDOW->m_workspace) {
Debug::log(LOG, "Fake executing workspace to move focus"); Debug::log(LOG, "Fake executing workspace to move focus");
changeworkspace(PWORKSPACE->getConfigName()); changeworkspace(PWORKSPACE->getConfigName());
} }
@@ -2670,19 +2670,19 @@ SDispatchResult CKeybindManager::dpms(std::string arg) {
for (auto const& m : g_pCompositor->m_monitors) { for (auto const& m : g_pCompositor->m_monitors) {
if (!port.empty() && m->szName != port) if (!port.empty() && m->m_name != port)
continue; continue;
if (isToggle) if (isToggle)
enable = !m->dpmsStatus; enable = !m->m_dpmsStatus;
m->output->state->resetExplicitFences(); m->m_output->state->resetExplicitFences();
m->output->state->setEnabled(enable); m->m_output->state->setEnabled(enable);
m->dpmsStatus = enable; m->m_dpmsStatus = enable;
if (!m->state.commit()) { if (!m->m_state.commit()) {
Debug::log(ERR, "Couldn't commit output {}", m->szName); Debug::log(ERR, "Couldn't commit output {}", m->m_name);
res.success = false; res.success = false;
res.error = "Couldn't commit output {}"; res.error = "Couldn't commit output {}";
} }
@@ -2690,7 +2690,7 @@ SDispatchResult CKeybindManager::dpms(std::string arg) {
if (enable) if (enable)
g_pHyprRenderer->damageMonitor(m); g_pHyprRenderer->damageMonitor(m);
m->events.dpmsChanged.emit(); m->m_events.dpmsChanged.emit();
} }
g_pCompositor->m_dpmsStateOn = enable; g_pCompositor->m_dpmsStateOn = enable;
@@ -2774,7 +2774,7 @@ SDispatchResult CKeybindManager::pinActive(std::string args) {
return {.success = false, .error = "pin: window not found"}; return {.success = false, .error = "pin: window not found"};
} }
PWINDOW->m_workspace = PMONITOR->activeWorkspace; PWINDOW->m_workspace = PMONITOR->m_activeWorkspace;
PWINDOW->updateDynamicRules(); PWINDOW->updateDynamicRules();
g_pCompositor->updateWindowAnimatedDecorationValues(PWINDOW); g_pCompositor->updateWindowAnimatedDecorationValues(PWINDOW);
@@ -3274,7 +3274,7 @@ SDispatchResult CKeybindManager::setProp(std::string args) {
} }
for (auto const& m : g_pCompositor->m_monitors) for (auto const& m : g_pCompositor->m_monitors)
g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID); g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->m_id);
return {}; return {};
} }

117
src/managers/PointerManager.cpp
View File

@@ -29,9 +29,9 @@ CPointerManager::CPointerManager() {
onMonitorLayoutChange(); onMonitorLayoutChange();
PMONITOR->events.modeChanged.registerStaticListener([this](void* owner, std::any data) { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); }, nullptr); PMONITOR->m_events.modeChanged.registerStaticListener([this](void* owner, std::any data) { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); }, nullptr);
PMONITOR->events.disconnect.registerStaticListener([this](void* owner, std::any data) { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); }, nullptr); PMONITOR->m_events.disconnect.registerStaticListener([this](void* owner, std::any data) { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); }, nullptr);
PMONITOR->events.destroy.registerStaticListener( PMONITOR->m_events.destroy.registerStaticListener(
[this](void* owner, std::any data) { [this](void* owner, std::any data) {
if (g_pCompositor && !g_pCompositor->m_isShuttingDown) if (g_pCompositor && !g_pCompositor->m_isShuttingDown)
std::erase_if(monitorStates, [](const auto& other) { return other->monitor.expired(); }); std::erase_if(monitorStates, [](const auto& other) { return other->monitor.expired(); });
@@ -179,7 +179,7 @@ void CPointerManager::recheckEnteredOutputs() {
auto box = getCursorBoxGlobal(); auto box = getCursorBoxGlobal();
for (auto const& s : monitorStates) { for (auto const& s : monitorStates) {
if (s->monitor.expired() || s->monitor->isMirror() || !s->monitor->m_bEnabled) if (s->monitor.expired() || s->monitor->isMirror() || !s->monitor->m_enabled)
continue; continue;
const bool overlaps = box.overlaps(s->monitor->logicalBox()); const bool overlaps = box.overlaps(s->monitor->logicalBox());
@@ -191,14 +191,15 @@ void CPointerManager::recheckEnteredOutputs() {
continue; continue;
currentCursorImage.surface->resource()->enter(s->monitor.lock()); currentCursorImage.surface->resource()->enter(s->monitor.lock());
PROTO::fractional->sendScale(currentCursorImage.surface->resource(), s->monitor->scale); PROTO::fractional->sendScale(currentCursorImage.surface->resource(), s->monitor->m_scale);
g_pCompositor->setPreferredScaleForSurface(currentCursorImage.surface->resource(), s->monitor->scale); g_pCompositor->setPreferredScaleForSurface(currentCursorImage.surface->resource(), s->monitor->m_scale);
} else if (s->entered && !overlaps) { } else if (s->entered && !overlaps) {
s->entered = false; s->entered = false;
// if we are using hw cursors, prevent // if we are using hw cursors, prevent
// the cursor from being stuck at the last point. // the cursor from being stuck at the last point.
if (!s->hardwareFailed && (s->monitor->output->getBackend()->capabilities() & Aquamarine::IBackendImplementation::eBackendCapabilities::AQ_BACKEND_CAPABILITY_POINTER)) if (!s->hardwareFailed &&
(s->monitor->m_output->getBackend()->capabilities() & Aquamarine::IBackendImplementation::eBackendCapabilities::AQ_BACKEND_CAPABILITY_POINTER))
setHWCursorBuffer(s, nullptr); setHWCursorBuffer(s, nullptr);
if (!currentCursorImage.surface) if (!currentCursorImage.surface)
@@ -232,7 +233,7 @@ void CPointerManager::resetCursorImage(bool apply) {
currentCursorImage.hotspot = {0, 0}; currentCursorImage.hotspot = {0, 0};
for (auto const& s : monitorStates) { for (auto const& s : monitorStates) {
if (s->monitor.expired() || s->monitor->isMirror() || !s->monitor->m_bEnabled) if (s->monitor.expired() || s->monitor->isMirror() || !s->monitor->m_enabled)
continue; continue;
s->entered = false; s->entered = false;
@@ -242,14 +243,14 @@ void CPointerManager::resetCursorImage(bool apply) {
return; return;
for (auto const& ms : monitorStates) { for (auto const& ms : monitorStates) {
if (!ms->monitor || !ms->monitor->m_bEnabled || !ms->monitor->dpmsStatus) { if (!ms->monitor || !ms->monitor->m_enabled || !ms->monitor->m_dpmsStatus) {
Debug::log(TRACE, "Not updating hw cursors: disabled / dpms off display"); Debug::log(TRACE, "Not updating hw cursors: disabled / dpms off display");
continue; continue;
} }
if (ms->cursorFrontBuffer) { if (ms->cursorFrontBuffer) {
if (ms->monitor->output->getBackend()->capabilities() & Aquamarine::IBackendImplementation::eBackendCapabilities::AQ_BACKEND_CAPABILITY_POINTER) if (ms->monitor->m_output->getBackend()->capabilities() & Aquamarine::IBackendImplementation::eBackendCapabilities::AQ_BACKEND_CAPABILITY_POINTER)
ms->monitor->output->setCursor(nullptr, {}); ms->monitor->m_output->setCursor(nullptr, {});
ms->cursorFrontBuffer = nullptr; ms->cursorFrontBuffer = nullptr;
} }
} }
@@ -259,7 +260,7 @@ void CPointerManager::updateCursorBackend() {
const auto CURSORBOX = getCursorBoxGlobal(); const auto CURSORBOX = getCursorBoxGlobal();
for (auto const& m : g_pCompositor->m_monitors) { for (auto const& m : g_pCompositor->m_monitors) {
if (!m->m_bEnabled || !m->dpmsStatus) { if (!m->m_enabled || !m->m_dpmsStatus) {
Debug::log(TRACE, "Not updating hw cursors: disabled / dpms off display"); Debug::log(TRACE, "Not updating hw cursors: disabled / dpms off display");
continue; continue;
} }
@@ -275,7 +276,7 @@ void CPointerManager::updateCursorBackend() {
} }
if (state->softwareLocks > 0 || g_pConfigManager->shouldUseSoftwareCursors(m) || !attemptHardwareCursor(state)) { if (state->softwareLocks > 0 || g_pConfigManager->shouldUseSoftwareCursors(m) || !attemptHardwareCursor(state)) {
Debug::log(TRACE, "Output {} rejected hardware cursors, falling back to sw", m->szName); Debug::log(TRACE, "Output {} rejected hardware cursors, falling back to sw", m->m_name);
state->box = getCursorBoxLogicalForMonitor(state->monitor.lock()); state->box = getCursorBoxLogicalForMonitor(state->monitor.lock());
state->hardwareFailed = true; state->hardwareFailed = true;
@@ -305,11 +306,11 @@ void CPointerManager::onCursorMoved() {
auto CROSSES = !m->logicalBox().intersection(CURSORBOX).empty(); auto CROSSES = !m->logicalBox().intersection(CURSORBOX).empty();
if (!CROSSES && state->cursorFrontBuffer) { if (!CROSSES && state->cursorFrontBuffer) {
Debug::log(TRACE, "onCursorMoved for output {}: cursor left the viewport, removing it from the backend", m->szName); Debug::log(TRACE, "onCursorMoved for output {}: cursor left the viewport, removing it from the backend", m->m_name);
setHWCursorBuffer(state, nullptr); setHWCursorBuffer(state, nullptr);
continue; continue;
} else if (CROSSES && !state->cursorFrontBuffer) { } else if (CROSSES && !state->cursorFrontBuffer) {
Debug::log(TRACE, "onCursorMoved for output {}: cursor entered the output, but no front buffer, forcing recalc", m->szName); Debug::log(TRACE, "onCursorMoved for output {}: cursor entered the output, but no front buffer, forcing recalc", m->m_name);
recalc = true; recalc = true;
} }
@@ -322,9 +323,9 @@ void CPointerManager::onCursorMoved() {
continue; continue;
const auto CURSORPOS = getCursorPosForMonitor(m); const auto CURSORPOS = getCursorPosForMonitor(m);
m->output->moveCursor(CURSORPOS, m->shouldSkipScheduleFrameOnMouseEvent()); m->m_output->moveCursor(CURSORPOS, m->shouldSkipScheduleFrameOnMouseEvent());
state->monitor->scanoutNeedsCursorUpdate = true; state->monitor->m_scanoutNeedsCursorUpdate = true;
} }
if (recalc) if (recalc)
@@ -332,13 +333,13 @@ void CPointerManager::onCursorMoved() {
} }
bool CPointerManager::attemptHardwareCursor(SP<CPointerManager::SMonitorPointerState> state) { bool CPointerManager::attemptHardwareCursor(SP<CPointerManager::SMonitorPointerState> state) {
auto output = state->monitor->output; auto output = state->monitor->m_output;
if (!(output->getBackend()->capabilities() & Aquamarine::IBackendImplementation::eBackendCapabilities::AQ_BACKEND_CAPABILITY_POINTER)) if (!(output->getBackend()->capabilities() & Aquamarine::IBackendImplementation::eBackendCapabilities::AQ_BACKEND_CAPABILITY_POINTER))
return false; return false;
const auto CURSORPOS = getCursorPosForMonitor(state->monitor.lock()); const auto CURSORPOS = getCursorPosForMonitor(state->monitor.lock());
state->monitor->output->moveCursor(CURSORPOS, state->monitor->shouldSkipScheduleFrameOnMouseEvent()); state->monitor->m_output->moveCursor(CURSORPOS, state->monitor->shouldSkipScheduleFrameOnMouseEvent());
auto texture = getCurrentCursorTexture(); auto texture = getCurrentCursorTexture();
@@ -369,14 +370,14 @@ bool CPointerManager::attemptHardwareCursor(SP<CPointerManager::SMonitorPointerS
} }
bool CPointerManager::setHWCursorBuffer(SP<SMonitorPointerState> state, SP<Aquamarine::IBuffer> buf) { bool CPointerManager::setHWCursorBuffer(SP<SMonitorPointerState> state, SP<Aquamarine::IBuffer> buf) {
if (!(state->monitor->output->getBackend()->capabilities() & Aquamarine::IBackendImplementation::eBackendCapabilities::AQ_BACKEND_CAPABILITY_POINTER)) if (!(state->monitor->m_output->getBackend()->capabilities() & Aquamarine::IBackendImplementation::eBackendCapabilities::AQ_BACKEND_CAPABILITY_POINTER))
return false; return false;
const auto HOTSPOT = transformedHotspot(state->monitor.lock()); const auto HOTSPOT = transformedHotspot(state->monitor.lock());
Debug::log(TRACE, "[pointer] hw transformed hotspot for {}: {}", state->monitor->szName, HOTSPOT); Debug::log(TRACE, "[pointer] hw transformed hotspot for {}: {}", state->monitor->m_name, HOTSPOT);
if (!state->monitor->output->setCursor(buf, HOTSPOT)) if (!state->monitor->m_output->setCursor(buf, HOTSPOT))
return false; return false;
state->cursorFrontBuffer = buf; state->cursorFrontBuffer = buf;
@@ -384,13 +385,13 @@ bool CPointerManager::setHWCursorBuffer(SP<SMonitorPointerState> state, SP<Aquam
if (!state->monitor->shouldSkipScheduleFrameOnMouseEvent()) if (!state->monitor->shouldSkipScheduleFrameOnMouseEvent())
g_pCompositor->scheduleFrameForMonitor(state->monitor.lock(), Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_SHAPE); g_pCompositor->scheduleFrameForMonitor(state->monitor.lock(), Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_SHAPE);
state->monitor->scanoutNeedsCursorUpdate = true; state->monitor->m_scanoutNeedsCursorUpdate = true;
return true; return true;
} }
SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager::SMonitorPointerState> state, SP<CTexture> texture) { SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager::SMonitorPointerState> state, SP<CTexture> texture) {
auto maxSize = state->monitor->output->cursorPlaneSize(); auto maxSize = state->monitor->m_output->cursorPlaneSize();
auto const& cursorSize = currentCursorImage.size; auto const& cursorSize = currentCursorImage.size;
static auto PCPUBUFFER = CConfigValue<Hyprlang::INT>("cursor:use_cpu_buffer"); static auto PCPUBUFFER = CConfigValue<Hyprlang::INT>("cursor:use_cpu_buffer");
@@ -408,14 +409,14 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
} else } else
maxSize = cursorSize; maxSize = cursorSize;
if (!state->monitor->cursorSwapchain || maxSize != state->monitor->cursorSwapchain->currentOptions().size || if (!state->monitor->m_cursorSwapchain || maxSize != state->monitor->m_cursorSwapchain->currentOptions().size ||
shouldUseCpuBuffer != (state->monitor->cursorSwapchain->getAllocator()->type() != Aquamarine::AQ_ALLOCATOR_TYPE_GBM)) { shouldUseCpuBuffer != (state->monitor->m_cursorSwapchain->getAllocator()->type() != Aquamarine::AQ_ALLOCATOR_TYPE_GBM)) {
if (!state->monitor->cursorSwapchain || shouldUseCpuBuffer != (state->monitor->cursorSwapchain->getAllocator()->type() != Aquamarine::AQ_ALLOCATOR_TYPE_GBM)) { if (!state->monitor->m_cursorSwapchain || shouldUseCpuBuffer != (state->monitor->m_cursorSwapchain->getAllocator()->type() != Aquamarine::AQ_ALLOCATOR_TYPE_GBM)) {
auto allocator = state->monitor->output->getBackend()->preferredAllocator(); auto allocator = state->monitor->m_output->getBackend()->preferredAllocator();
if (shouldUseCpuBuffer) { if (shouldUseCpuBuffer) {
for (const auto& a : state->monitor->output->getBackend()->getAllocators()) { for (const auto& a : state->monitor->m_output->getBackend()->getAllocators()) {
if (a->type() == Aquamarine::AQ_ALLOCATOR_TYPE_DRM_DUMB) { if (a->type() == Aquamarine::AQ_ALLOCATOR_TYPE_DRM_DUMB) {
allocator = a; allocator = a;
break; break;
@@ -423,23 +424,23 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
} }
} }
auto backend = state->monitor->output->getBackend(); auto backend = state->monitor->m_output->getBackend();
auto primary = backend->getPrimary(); auto primary = backend->getPrimary();
state->monitor->cursorSwapchain = Aquamarine::CSwapchain::create(allocator, primary ? primary.lock() : backend); state->monitor->m_cursorSwapchain = Aquamarine::CSwapchain::create(allocator, primary ? primary.lock() : backend);
} }
auto options = state->monitor->cursorSwapchain->currentOptions(); auto options = state->monitor->m_cursorSwapchain->currentOptions();
options.size = maxSize; options.size = maxSize;
options.length = 2; options.length = 2;
options.scanout = true; options.scanout = true;
options.cursor = true; options.cursor = true;
options.multigpu = state->monitor->output->getBackend()->preferredAllocator()->drmFD() != g_pCompositor->m_drmFD; options.multigpu = state->monitor->m_output->getBackend()->preferredAllocator()->drmFD() != g_pCompositor->m_drmFD;
// We do not set the format (unless shm). If it's unset (DRM_FORMAT_INVALID) then the swapchain will pick for us, // We do not set the format (unless shm). If it's unset (DRM_FORMAT_INVALID) then the swapchain will pick for us,
// but if it's set, we don't wanna change it. // but if it's set, we don't wanna change it.
if (shouldUseCpuBuffer) if (shouldUseCpuBuffer)
options.format = DRM_FORMAT_ARGB8888; options.format = DRM_FORMAT_ARGB8888;
if (!state->monitor->cursorSwapchain->reconfigure(options)) { if (!state->monitor->m_cursorSwapchain->reconfigure(options)) {
Debug::log(TRACE, "Failed to reconfigure cursor swapchain"); Debug::log(TRACE, "Failed to reconfigure cursor swapchain");
return nullptr; return nullptr;
} }
@@ -449,11 +450,11 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
// the current front buffer // the current front buffer
// this flag will be reset in the preRender hook, so when we commit this buffer to KMS // this flag will be reset in the preRender hook, so when we commit this buffer to KMS
if (state->cursorRendered) if (state->cursorRendered)
state->monitor->cursorSwapchain->rollback(); state->monitor->m_cursorSwapchain->rollback();
state->cursorRendered = true; state->cursorRendered = true;
auto buf = state->monitor->cursorSwapchain->next(nullptr); auto buf = state->monitor->m_cursorSwapchain->next(nullptr);
if (!buf) { if (!buf) {
Debug::log(TRACE, "Failed to acquire a buffer from the cursor swapchain"); Debug::log(TRACE, "Failed to acquire a buffer from the cursor swapchain");
return nullptr; return nullptr;
@@ -519,10 +520,10 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
cairo_matrix_t matrixPre; cairo_matrix_t matrixPre;
cairo_matrix_init_identity(&matrixPre); cairo_matrix_init_identity(&matrixPre);
const auto TR = state->monitor->transform; const auto TR = state->monitor->m_transform;
// we need to scale the cursor to the right size, because it might not be (esp with XCursor) // we need to scale the cursor to the right size, because it might not be (esp with XCursor)
const auto SCALE = texture->m_vSize / (currentCursorImage.size / currentCursorImage.scale * state->monitor->scale); const auto SCALE = texture->m_vSize / (currentCursorImage.size / currentCursorImage.scale * state->monitor->m_scale);
cairo_matrix_scale(&matrixPre, SCALE.x, SCALE.y); cairo_matrix_scale(&matrixPre, SCALE.x, SCALE.y);
if (TR) { if (TR) {
@@ -565,7 +566,7 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
g_pHyprRenderer->makeEGLCurrent(); g_pHyprRenderer->makeEGLCurrent();
g_pHyprOpenGL->m_RenderData.pMonitor = state->monitor; g_pHyprOpenGL->m_RenderData.pMonitor = state->monitor;
auto RBO = g_pHyprRenderer->getOrCreateRenderbuffer(buf, state->monitor->cursorSwapchain->currentOptions().format); auto RBO = g_pHyprRenderer->getOrCreateRenderbuffer(buf, state->monitor->m_cursorSwapchain->currentOptions().format);
if (!RBO) { if (!RBO) {
Debug::log(TRACE, "Failed to create cursor RB with format {}, mod {}", buf->dmabuf().format, buf->dmabuf().modifier); Debug::log(TRACE, "Failed to create cursor RB with format {}, mod {}", buf->dmabuf().format, buf->dmabuf().modifier);
return nullptr; return nullptr;
@@ -576,9 +577,9 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
g_pHyprOpenGL->beginSimple(state->monitor.lock(), {0, 0, INT16_MAX, INT16_MAX}, RBO); g_pHyprOpenGL->beginSimple(state->monitor.lock(), {0, 0, INT16_MAX, INT16_MAX}, RBO);
g_pHyprOpenGL->clear(CHyprColor{0.F, 0.F, 0.F, 0.F}); g_pHyprOpenGL->clear(CHyprColor{0.F, 0.F, 0.F, 0.F});
CBox xbox = {{}, Vector2D{currentCursorImage.size / currentCursorImage.scale * state->monitor->scale}.round()}; CBox xbox = {{}, Vector2D{currentCursorImage.size / currentCursorImage.scale * state->monitor->m_scale}.round()};
Debug::log(TRACE, "[pointer] monitor: {}, size: {}, hw buf: {}, scale: {:.2f}, monscale: {:.2f}, xbox: {}", state->monitor->szName, currentCursorImage.size, cursorSize, Debug::log(TRACE, "[pointer] monitor: {}, size: {}, hw buf: {}, scale: {:.2f}, monscale: {:.2f}, xbox: {}", state->monitor->m_name, currentCursorImage.size, cursorSize,
currentCursorImage.scale, state->monitor->scale, xbox.size()); currentCursorImage.scale, state->monitor->m_scale, xbox.size());
g_pHyprOpenGL->renderTexture(texture, xbox, 1.F); g_pHyprOpenGL->renderTexture(texture, xbox, 1.F);
@@ -609,14 +610,14 @@ void CPointerManager::renderSoftwareCursorsFor(PHLMONITOR pMonitor, const Time::
box.y = overridePos->y; box.y = overridePos->y;
} }
if (box.intersection(CBox{{}, {pMonitor->vecSize}}).empty()) if (box.intersection(CBox{{}, {pMonitor->m_size}}).empty())
return; return;
auto texture = getCurrentCursorTexture(); auto texture = getCurrentCursorTexture();
if (!texture) if (!texture)
return; return;
box.scale(pMonitor->scale); box.scale(pMonitor->m_scale);
box.x = std::round(box.x); box.x = std::round(box.x);
box.y = std::round(box.y); box.y = std::round(box.y);
@@ -631,25 +632,25 @@ void CPointerManager::renderSoftwareCursorsFor(PHLMONITOR pMonitor, const Time::
} }
Vector2D CPointerManager::getCursorPosForMonitor(PHLMONITOR pMonitor) { Vector2D CPointerManager::getCursorPosForMonitor(PHLMONITOR pMonitor) {
return CBox{pointerPos - pMonitor->vecPosition, {0, 0}} return CBox{pointerPos - pMonitor->m_position, {0, 0}}
.transform(wlTransformToHyprutils(invertTransform(pMonitor->transform)), pMonitor->vecTransformedSize.x / pMonitor->scale, .transform(wlTransformToHyprutils(invertTransform(pMonitor->m_transform)), pMonitor->m_transformedSize.x / pMonitor->m_scale,
pMonitor->vecTransformedSize.y / pMonitor->scale) pMonitor->m_transformedSize.y / pMonitor->m_scale)
.pos() * .pos() *
pMonitor->scale; pMonitor->m_scale;
} }
Vector2D CPointerManager::transformedHotspot(PHLMONITOR pMonitor) { Vector2D CPointerManager::transformedHotspot(PHLMONITOR pMonitor) {
if (!pMonitor->cursorSwapchain) if (!pMonitor->m_cursorSwapchain)
return {}; // doesn't matter, we have no hw cursor, and this is only for hw cursors return {}; // doesn't matter, we have no hw cursor, and this is only for hw cursors
return CBox{currentCursorImage.hotspot * pMonitor->scale, {0, 0}} return CBox{currentCursorImage.hotspot * pMonitor->m_scale, {0, 0}}
.transform(wlTransformToHyprutils(invertTransform(pMonitor->transform)), pMonitor->cursorSwapchain->currentOptions().size.x, .transform(wlTransformToHyprutils(invertTransform(pMonitor->m_transform)), pMonitor->m_cursorSwapchain->currentOptions().size.x,
pMonitor->cursorSwapchain->currentOptions().size.y) pMonitor->m_cursorSwapchain->currentOptions().size.y)
.pos(); .pos();
} }
CBox CPointerManager::getCursorBoxLogicalForMonitor(PHLMONITOR pMonitor) { CBox CPointerManager::getCursorBoxLogicalForMonitor(PHLMONITOR pMonitor) {
return getCursorBoxGlobal().translate(-pMonitor->vecPosition); return getCursorBoxGlobal().translate(-pMonitor->m_position);
} }
CBox CPointerManager::getCursorBoxGlobal() { CBox CPointerManager::getCursorBoxGlobal() {
@@ -736,11 +737,11 @@ void CPointerManager::damageIfSoftware() {
auto b = getCursorBoxGlobal().expand(4); auto b = getCursorBoxGlobal().expand(4);
for (auto const& mw : monitorStates) { for (auto const& mw : monitorStates) {
if (mw->monitor.expired() || !mw->monitor->output) if (mw->monitor.expired() || !mw->monitor->m_output)
continue; continue;
if ((mw->softwareLocks > 0 || mw->hardwareFailed || g_pConfigManager->shouldUseSoftwareCursors(mw->monitor.lock())) && if ((mw->softwareLocks > 0 || mw->hardwareFailed || g_pConfigManager->shouldUseSoftwareCursors(mw->monitor.lock())) &&
b.overlaps({mw->monitor->vecPosition, mw->monitor->vecSize})) { b.overlaps({mw->monitor->m_position, mw->monitor->m_size})) {
g_pHyprRenderer->damageBox(b, mw->monitor->shouldSkipScheduleFrameOnMouseEvent()); g_pHyprRenderer->damageBox(b, mw->monitor->shouldSkipScheduleFrameOnMouseEvent());
break; break;
} }
@@ -778,7 +779,7 @@ void CPointerManager::warpAbsolute(Vector2D abs, SP<IHID> dev) {
// find x and y size of the entire space // find x and y size of the entire space
const auto& MONITORS = g_pCompositor->m_monitors; const auto& MONITORS = g_pCompositor->m_monitors;
Vector2D topLeft = MONITORS.at(0)->vecPosition, bottomRight = MONITORS.at(0)->vecPosition + MONITORS.at(0)->vecSize; Vector2D topLeft = MONITORS.at(0)->m_position, bottomRight = MONITORS.at(0)->m_position + MONITORS.at(0)->m_size;
for (size_t i = 1; i < MONITORS.size(); ++i) { for (size_t i = 1; i < MONITORS.size(); ++i) {
const auto EXTENT = MONITORS[i]->logicalBox().extent(); const auto EXTENT = MONITORS[i]->logicalBox().extent();
const auto POS = MONITORS[i]->logicalBox().pos(); const auto POS = MONITORS[i]->logicalBox().pos();
@@ -852,10 +853,10 @@ void CPointerManager::warpAbsolute(Vector2D abs, SP<IHID> dev) {
void CPointerManager::onMonitorLayoutChange() { void CPointerManager::onMonitorLayoutChange() {
currentMonitorLayout.monitorBoxes.clear(); currentMonitorLayout.monitorBoxes.clear();
for (auto const& m : g_pCompositor->m_monitors) { for (auto const& m : g_pCompositor->m_monitors) {
if (m->isMirror() || !m->m_bEnabled || !m->output) if (m->isMirror() || !m->m_enabled || !m->m_output)
continue; continue;
currentMonitorLayout.monitorBoxes.emplace_back(m->vecPosition, m->vecSize); currentMonitorLayout.monitorBoxes.emplace_back(m->m_position, m->m_size);
} }
damageIfSoftware(); damageIfSoftware();

28
src/managers/ProtocolManager.cpp
View File

@@ -84,12 +84,12 @@ void CProtocolManager::onMonitorModeChange(PHLMONITOR pMonitor) {
// mirrored outputs should have their global removed, as they are not physical parts of the // mirrored outputs should have their global removed, as they are not physical parts of the
// layout. // layout.
if (ISMIRROR && PROTO::outputs.contains(pMonitor->szName)) if (ISMIRROR && PROTO::outputs.contains(pMonitor->m_name))
PROTO::outputs.at(pMonitor->szName)->remove(); PROTO::outputs.at(pMonitor->m_name)->remove();
else if (!ISMIRROR && (!PROTO::outputs.contains(pMonitor->szName) || PROTO::outputs.at(pMonitor->szName)->isDefunct())) { else if (!ISMIRROR && (!PROTO::outputs.contains(pMonitor->m_name) || PROTO::outputs.at(pMonitor->m_name)->isDefunct())) {
if (PROTO::outputs.contains(pMonitor->szName)) if (PROTO::outputs.contains(pMonitor->m_name))
PROTO::outputs.erase(pMonitor->szName); PROTO::outputs.erase(pMonitor->m_name);
PROTO::outputs.emplace(pMonitor->szName, makeShared<CWLOutputProtocol>(&wl_output_interface, 4, std::format("WLOutput ({})", pMonitor->szName), pMonitor->self.lock())); PROTO::outputs.emplace(pMonitor->m_name, makeShared<CWLOutputProtocol>(&wl_output_interface, 4, std::format("WLOutput ({})", pMonitor->m_name), pMonitor->m_self.lock()));
} }
if (PROTO::colorManagement && g_pCompositor->shouldChangePreferredImageDescription()) { if (PROTO::colorManagement && g_pCompositor->shouldChangePreferredImageDescription()) {
@@ -115,22 +115,22 @@ CProtocolManager::CProtocolManager() {
if (M->isMirror() || M == g_pCompositor->m_unsafeOutput) if (M->isMirror() || M == g_pCompositor->m_unsafeOutput)
return; return;
if (PROTO::outputs.contains(M->szName)) if (PROTO::outputs.contains(M->m_name))
PROTO::outputs.erase(M->szName); PROTO::outputs.erase(M->m_name);
auto ref = makeShared<CWLOutputProtocol>(&wl_output_interface, 4, std::format("WLOutput ({})", M->szName), M->self.lock()); auto ref = makeShared<CWLOutputProtocol>(&wl_output_interface, 4, std::format("WLOutput ({})", M->m_name), M->m_self.lock());
PROTO::outputs.emplace(M->szName, ref); PROTO::outputs.emplace(M->m_name, ref);
ref->self = ref; ref->self = ref;
m_mModeChangeListeners[M->szName] = M->events.modeChanged.registerListener([M, this](std::any d) { onMonitorModeChange(M); }); m_mModeChangeListeners[M->m_name] = M->m_events.modeChanged.registerListener([M, this](std::any d) { onMonitorModeChange(M); });
}); });
static auto P2 = g_pHookSystem->hookDynamic("monitorRemoved", [this](void* self, SCallbackInfo& info, std::any param) { static auto P2 = g_pHookSystem->hookDynamic("monitorRemoved", [this](void* self, SCallbackInfo& info, std::any param) {
auto M = std::any_cast<PHLMONITOR>(param); auto M = std::any_cast<PHLMONITOR>(param);
if (!PROTO::outputs.contains(M->szName)) if (!PROTO::outputs.contains(M->m_name))
return; return;
PROTO::outputs.at(M->szName)->remove(); PROTO::outputs.at(M->m_name)->remove();
m_mModeChangeListeners.erase(M->szName); m_mModeChangeListeners.erase(M->m_name);
}); });
// Core // Core

6
src/managers/SessionLockManager.cpp
View File

@@ -67,8 +67,8 @@ void CSessionLockManager::onNewSessionLock(SP<CSessionLock> pLock) {
const auto PMONITOR = SURFACE->monitor(); const auto PMONITOR = SURFACE->monitor();
const auto NEWSURFACE = m_pSessionLock->vSessionLockSurfaces.emplace_back(makeUnique<SSessionLockSurface>(SURFACE)).get(); const auto NEWSURFACE = m_pSessionLock->vSessionLockSurfaces.emplace_back(makeUnique<SSessionLockSurface>(SURFACE)).get();
NEWSURFACE->iMonitorID = PMONITOR->ID; NEWSURFACE->iMonitorID = PMONITOR->m_id;
PROTO::fractional->sendScale(SURFACE->surface(), PMONITOR->scale); PROTO::fractional->sendScale(SURFACE->surface(), PMONITOR->m_scale);
}); });
m_pSessionLock->listeners.unlock = pLock->events.unlockAndDestroy.registerListener([this](std::any data) { m_pSessionLock->listeners.unlock = pLock->events.unlockAndDestroy.registerListener([this](std::any data) {
@@ -138,7 +138,7 @@ void CSessionLockManager::onLockscreenRenderedOnMonitor(uint64_t id) {
if (!m_pSessionLock || m_pSessionLock->m_hasSentLocked) if (!m_pSessionLock || m_pSessionLock->m_hasSentLocked)
return; return;
m_pSessionLock->m_lockedMonitors.emplace(id); m_pSessionLock->m_lockedMonitors.emplace(id);
const bool LOCKED = std::ranges::all_of(g_pCompositor->m_monitors, [this](auto m) { return m_pSessionLock->m_lockedMonitors.contains(m->ID); }); const bool LOCKED = std::ranges::all_of(g_pCompositor->m_monitors, [this](auto m) { return m_pSessionLock->m_lockedMonitors.contains(m->m_id); });
if (LOCKED && m_pSessionLock->lock->good()) { if (LOCKED && m_pSessionLock->lock->good()) {
m_pSessionLock->lock->sendLocked(); m_pSessionLock->lock->sendLocked();
m_pSessionLock->m_hasSentLocked = true; m_pSessionLock->m_hasSentLocked = true;

20
src/managers/XWaylandManager.cpp
View File

@@ -170,9 +170,9 @@ Vector2D CHyprXWaylandManager::waylandToXWaylandCoords(const Vector2D& coord) {
PHLMONITOR pMonitor = nullptr; PHLMONITOR pMonitor = nullptr;
double bestDistance = __FLT_MAX__; double bestDistance = __FLT_MAX__;
for (const auto& m : g_pCompositor->m_monitors) { for (const auto& m : g_pCompositor->m_monitors) {
const auto SIZ = *PXWLFORCESCALEZERO ? m->vecTransformedSize : m->vecSize; const auto SIZ = *PXWLFORCESCALEZERO ? m->m_transformedSize : m->m_size;
double distance = vecToRectDistanceSquared(coord, {m->vecPosition.x, m->vecPosition.y}, {m->vecPosition.x + SIZ.x - 1, m->vecPosition.y + SIZ.y - 1}); double distance = vecToRectDistanceSquared(coord, {m->m_position.x, m->m_position.y}, {m->m_position.x + SIZ.x - 1, m->m_position.y + SIZ.y - 1});
if (distance < bestDistance) { if (distance < bestDistance) {
bestDistance = distance; bestDistance = distance;
@@ -184,12 +184,12 @@ Vector2D CHyprXWaylandManager::waylandToXWaylandCoords(const Vector2D& coord) {
return Vector2D{}; return Vector2D{};
// get local coords // get local coords
Vector2D result = coord - pMonitor->vecPosition; Vector2D result = coord - pMonitor->m_position;
// if scaled, scale // if scaled, scale
if (*PXWLFORCESCALEZERO) if (*PXWLFORCESCALEZERO)
result *= pMonitor->scale; result *= pMonitor->m_scale;
// add pos // add pos
result += pMonitor->vecXWaylandPosition; result += pMonitor->m_xwaylandPosition;
return result; return result;
} }
@@ -201,10 +201,10 @@ Vector2D CHyprXWaylandManager::xwaylandToWaylandCoords(const Vector2D& coord) {
PHLMONITOR pMonitor = nullptr; PHLMONITOR pMonitor = nullptr;
double bestDistance = __FLT_MAX__; double bestDistance = __FLT_MAX__;
for (const auto& m : g_pCompositor->m_monitors) { for (const auto& m : g_pCompositor->m_monitors) {
const auto SIZ = *PXWLFORCESCALEZERO ? m->vecTransformedSize : m->vecSize; const auto SIZ = *PXWLFORCESCALEZERO ? m->m_transformedSize : m->m_size;
double distance = double distance =
vecToRectDistanceSquared(coord, {m->vecXWaylandPosition.x, m->vecXWaylandPosition.y}, {m->vecXWaylandPosition.x + SIZ.x - 1, m->vecXWaylandPosition.y + SIZ.y - 1}); vecToRectDistanceSquared(coord, {m->m_xwaylandPosition.x, m->m_xwaylandPosition.y}, {m->m_xwaylandPosition.x + SIZ.x - 1, m->m_xwaylandPosition.y + SIZ.y - 1});
if (distance < bestDistance) { if (distance < bestDistance) {
bestDistance = distance; bestDistance = distance;
@@ -216,12 +216,12 @@ Vector2D CHyprXWaylandManager::xwaylandToWaylandCoords(const Vector2D& coord) {
return Vector2D{}; return Vector2D{};
// get local coords // get local coords
Vector2D result = coord - pMonitor->vecXWaylandPosition; Vector2D result = coord - pMonitor->m_xwaylandPosition;
// if scaled, unscale // if scaled, unscale
if (*PXWLFORCESCALEZERO) if (*PXWLFORCESCALEZERO)
result /= pMonitor->scale; result /= pMonitor->m_scale;
// add pos // add pos
result += pMonitor->vecPosition; result += pMonitor->m_position;
return result; return result;
} }

33
src/managers/input/InputManager.cpp
View File

@@ -217,7 +217,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
bool skipFrameSchedule = PMONITOR->shouldSkipScheduleFrameOnMouseEvent(); bool skipFrameSchedule = PMONITOR->shouldSkipScheduleFrameOnMouseEvent();
if (!PMONITOR->solitaryClient.lock() && g_pHyprRenderer->shouldRenderCursor() && g_pPointerManager->softwareLockedFor(PMONITOR->self.lock()) && !skipFrameSchedule) if (!PMONITOR->m_solitaryClient.lock() && g_pHyprRenderer->shouldRenderCursor() && g_pPointerManager->softwareLockedFor(PMONITOR->m_self.lock()) && !skipFrameSchedule)
g_pCompositor->scheduleFrameForMonitor(PMONITOR, Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_MOVE); g_pCompositor->scheduleFrameForMonitor(PMONITOR, Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_MOVE);
// constraints // constraints
@@ -252,13 +252,13 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
if (g_pSessionLockManager->isSessionLocked()) { if (g_pSessionLockManager->isSessionLocked()) {
// set keyboard focus on session lock surface regardless of layers // set keyboard focus on session lock surface regardless of layers
const auto PSESSIONLOCKSURFACE = g_pSessionLockManager->getSessionLockSurfaceForMonitor(PMONITOR->ID); const auto PSESSIONLOCKSURFACE = g_pSessionLockManager->getSessionLockSurfaceForMonitor(PMONITOR->m_id);
const auto foundLockSurface = PSESSIONLOCKSURFACE ? PSESSIONLOCKSURFACE->surface->surface() : nullptr; const auto foundLockSurface = PSESSIONLOCKSURFACE ? PSESSIONLOCKSURFACE->surface->surface() : nullptr;
g_pCompositor->focusSurface(foundLockSurface); g_pCompositor->focusSurface(foundLockSurface);
// search for interactable abovelock surfaces for pointer focus, or use session lock surface if not found // search for interactable abovelock surfaces for pointer focus, or use session lock surface if not found
for (auto& lsl : PMONITOR->m_aLayerSurfaceLayers | std::views::reverse) { for (auto& lsl : PMONITOR->m_layerSurfaceLayers | std::views::reverse) {
foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &lsl, &surfaceCoords, &pFoundLayerSurface, true); foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &lsl, &surfaceCoords, &pFoundLayerSurface, true);
if (foundSurface) if (foundSurface)
@@ -266,7 +266,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
} }
if (!foundSurface) { if (!foundSurface) {
surfaceCoords = mouseCoords - PMONITOR->vecPosition; surfaceCoords = mouseCoords - PMONITOR->m_position;
foundSurface = foundLockSurface; foundSurface = foundLockSurface;
} }
@@ -336,7 +336,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
// overlays are above fullscreen // overlays are above fullscreen
if (!foundSurface) if (!foundSurface)
foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], &surfaceCoords, &pFoundLayerSurface); foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], &surfaceCoords, &pFoundLayerSurface);
// also IME popups // also IME popups
if (!foundSurface) { if (!foundSurface) {
@@ -349,10 +349,10 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
// also top layers // also top layers
if (!foundSurface) if (!foundSurface)
foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP], &surfaceCoords, &pFoundLayerSurface); foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP], &surfaceCoords, &pFoundLayerSurface);
// then, we check if the workspace doesnt have a fullscreen window // then, we check if the workspace doesnt have a fullscreen window
const auto PWORKSPACE = PMONITOR->activeWorkspace; const auto PWORKSPACE = PMONITOR->m_activeWorkspace;
const auto PWINDOWIDEAL = g_pCompositor->vectorToWindowUnified(mouseCoords, RESERVED_EXTENTS | INPUT_EXTENTS | ALLOW_FLOATING); const auto PWINDOWIDEAL = g_pCompositor->vectorToWindowUnified(mouseCoords, RESERVED_EXTENTS | INPUT_EXTENTS | ALLOW_FLOATING);
if (PWORKSPACE->m_hasFullscreenWindow && !foundSurface && PWORKSPACE->m_fullscreenMode == FSMODE_FULLSCREEN) { if (PWORKSPACE->m_hasFullscreenWindow && !foundSurface && PWORKSPACE->m_fullscreenMode == FSMODE_FULLSCREEN) {
pFoundWindow = PWORKSPACE->getFullscreenWindow(); pFoundWindow = PWORKSPACE->getFullscreenWindow();
@@ -365,7 +365,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
if (PWINDOWIDEAL && if (PWINDOWIDEAL &&
((PWINDOWIDEAL->m_isFloating && PWINDOWIDEAL->m_createdOverFullscreen) /* floating over fullscreen */ ((PWINDOWIDEAL->m_isFloating && PWINDOWIDEAL->m_createdOverFullscreen) /* floating over fullscreen */
|| (PMONITOR->activeSpecialWorkspace == PWINDOWIDEAL->m_workspace) /* on an open special workspace */)) || (PMONITOR->m_activeSpecialWorkspace == PWINDOWIDEAL->m_workspace) /* on an open special workspace */))
pFoundWindow = PWINDOWIDEAL; pFoundWindow = PWINDOWIDEAL;
if (!pFoundWindow->m_isX11) { if (!pFoundWindow->m_isX11) {
@@ -381,7 +381,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
if (!foundSurface) { if (!foundSurface) {
if (PWORKSPACE->m_hasFullscreenWindow && PWORKSPACE->m_fullscreenMode == FSMODE_MAXIMIZED) { if (PWORKSPACE->m_hasFullscreenWindow && PWORKSPACE->m_fullscreenMode == FSMODE_MAXIMIZED) {
if (!foundSurface) { if (!foundSurface) {
if (PMONITOR->activeSpecialWorkspace) { if (PMONITOR->m_activeSpecialWorkspace) {
if (pFoundWindow != PWINDOWIDEAL) if (pFoundWindow != PWINDOWIDEAL)
pFoundWindow = g_pCompositor->vectorToWindowUnified(mouseCoords, RESERVED_EXTENTS | INPUT_EXTENTS | ALLOW_FLOATING); pFoundWindow = g_pCompositor->vectorToWindowUnified(mouseCoords, RESERVED_EXTENTS | INPUT_EXTENTS | ALLOW_FLOATING);
@@ -391,7 +391,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
} else { } else {
// if we have a maximized window, allow focusing on a bar or something if in reserved area. // if we have a maximized window, allow focusing on a bar or something if in reserved area.
if (g_pCompositor->isPointOnReservedArea(mouseCoords, PMONITOR)) { if (g_pCompositor->isPointOnReservedArea(mouseCoords, PMONITOR)) {
foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], &surfaceCoords, foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], &surfaceCoords,
&pFoundLayerSurface); &pFoundLayerSurface);
} }
@@ -426,13 +426,12 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) {
// then surfaces below // then surfaces below
if (!foundSurface) if (!foundSurface)
foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], &surfaceCoords, &pFoundLayerSurface); foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], &surfaceCoords, &pFoundLayerSurface);
if (!foundSurface) if (!foundSurface)
foundSurface = foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND], &surfaceCoords, &pFoundLayerSurface);
g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND], &surfaceCoords, &pFoundLayerSurface);
if (g_pPointerManager->softwareLockedFor(PMONITOR->self.lock()) > 0 && !skipFrameSchedule) if (g_pPointerManager->softwareLockedFor(PMONITOR->m_self.lock()) > 0 && !skipFrameSchedule)
g_pCompositor->scheduleFrameForMonitor(g_pCompositor->m_lastMonitor.lock(), Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_MOVE); g_pCompositor->scheduleFrameForMonitor(g_pCompositor->m_lastMonitor.lock(), Aquamarine::IOutput::AQ_SCHEDULE_CURSOR_MOVE);
// FIXME: This will be disabled during DnD operations because we do not exactly follow the spec // FIXME: This will be disabled during DnD operations because we do not exactly follow the spec
@@ -1471,14 +1470,14 @@ bool CInputManager::refocusLastWindow(PHLMONITOR pMonitor) {
// then any surfaces above windows on the same monitor // then any surfaces above windows on the same monitor
if (!foundSurface) { if (!foundSurface) {
foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
&surfaceCoords, &pFoundLayerSurface); &surfaceCoords, &pFoundLayerSurface);
if (pFoundLayerSurface && pFoundLayerSurface->m_interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND) if (pFoundLayerSurface && pFoundLayerSurface->m_interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND)
foundSurface = nullptr; foundSurface = nullptr;
} }
if (!foundSurface) { if (!foundSurface) {
foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP], foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
&surfaceCoords, &pFoundLayerSurface); &surfaceCoords, &pFoundLayerSurface);
if (pFoundLayerSurface && pFoundLayerSurface->m_interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND) if (pFoundLayerSurface && pFoundLayerSurface->m_interactivity == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND)
foundSurface = nullptr; foundSurface = nullptr;
@@ -1636,7 +1635,7 @@ void CInputManager::setTouchDeviceConfigs(SP<ITouch> dev) {
PTOUCHDEV->m_boundOutput = bound ? output : ""; PTOUCHDEV->m_boundOutput = bound ? output : "";
const auto PMONITOR = bound ? g_pCompositor->getMonitorFromName(output) : nullptr; const auto PMONITOR = bound ? g_pCompositor->getMonitorFromName(output) : nullptr;
if (PMONITOR) { if (PMONITOR) {
Debug::log(LOG, "Binding touch device {} to output {}", PTOUCHDEV->m_hlName, PMONITOR->szName); Debug::log(LOG, "Binding touch device {} to output {}", PTOUCHDEV->m_hlName, PMONITOR->m_name);
// wlr_cursor_map_input_to_output(g_pCompositor->m_sWLRCursor, &PTOUCHDEV->wlr()->base, PMONITOR->output); // wlr_cursor_map_input_to_output(g_pCompositor->m_sWLRCursor, &PTOUCHDEV->wlr()->base, PMONITOR->output);
} else if (bound) } else if (bound)
Debug::log(ERR, "Failed to bind touch device {} to output '{}': monitor not found", PTOUCHDEV->m_hlName, output); Debug::log(ERR, "Failed to bind touch device {} to output '{}': monitor not found", PTOUCHDEV->m_hlName, output);

14
src/managers/input/InputMethodPopup.cpp
View File

@@ -40,7 +40,7 @@ void CInputPopup::onMap() {
if (!PMONITOR) if (!PMONITOR)
return; return;
PROTO::fractional->sendScale(surface->resource(), PMONITOR->scale); PROTO::fractional->sendScale(surface->resource(), PMONITOR->m_scale);
} }
void CInputPopup::onUnmap() { void CInputPopup::onUnmap() {
@@ -108,12 +108,12 @@ void CInputPopup::updateBox() {
Vector2D popupOffset(0, 0); Vector2D popupOffset(0, 0);
if (parentBox.y + cursorBoxParent.y + cursorBoxParent.height + currentPopupSize.y > pMonitor->vecPosition.y + pMonitor->vecSize.y) if (parentBox.y + cursorBoxParent.y + cursorBoxParent.height + currentPopupSize.y > pMonitor->m_position.y + pMonitor->m_size.y)
popupOffset.y -= currentPopupSize.y; popupOffset.y -= currentPopupSize.y;
else else
popupOffset.y = cursorBoxParent.height; popupOffset.y = cursorBoxParent.height;
double popupOverflow = parentBox.x + cursorBoxParent.x + currentPopupSize.x - (pMonitor->vecPosition.x + pMonitor->vecSize.x); double popupOverflow = parentBox.x + cursorBoxParent.x + currentPopupSize.x - (pMonitor->m_position.x + pMonitor->m_size.x);
if (popupOverflow > 0) if (popupOverflow > 0)
popupOffset.x -= popupOverflow; popupOffset.x -= popupOverflow;
@@ -127,15 +127,15 @@ void CInputPopup::updateBox() {
} }
damageSurface(); damageSurface();
if (const auto PM = g_pCompositor->getMonitorFromCursor(); PM && PM->ID != lastMonitor) { if (const auto PM = g_pCompositor->getMonitorFromCursor(); PM && PM->m_id != lastMonitor) {
const auto PML = g_pCompositor->getMonitorFromID(lastMonitor); const auto PML = g_pCompositor->getMonitorFromID(lastMonitor);
if (PML) if (PML)
surface->resource()->leave(PML->self.lock()); surface->resource()->leave(PML->m_self.lock());
surface->resource()->enter(PM->self.lock()); surface->resource()->enter(PM->m_self.lock());
lastMonitor = PM->ID; lastMonitor = PM->m_id;
} }
} }

18
src/managers/input/Swipe.cpp
View File

@@ -29,7 +29,7 @@ void CInputManager::onSwipeBegin(IPointer::SSwipeBeginEvent e) {
} }
void CInputManager::beginWorkspaceSwipe() { void CInputManager::beginWorkspaceSwipe() {
const auto PWORKSPACE = g_pCompositor->m_lastMonitor->activeWorkspace; const auto PWORKSPACE = g_pCompositor->m_lastMonitor->m_activeWorkspace;
Debug::log(LOG, "Starting a swipe from {}", PWORKSPACE->m_name); Debug::log(LOG, "Starting a swipe from {}", PWORKSPACE->m_name);
@@ -40,7 +40,7 @@ void CInputManager::beginWorkspaceSwipe() {
m_sActiveSwipe.speedPoints = 0; m_sActiveSwipe.speedPoints = 0;
if (PWORKSPACE->m_hasFullscreenWindow) { if (PWORKSPACE->m_hasFullscreenWindow) {
for (auto const& ls : g_pCompositor->m_lastMonitor->m_aLayerSurfaceLayers[2]) { for (auto const& ls : g_pCompositor->m_lastMonitor->m_layerSurfaceLayers[2]) {
*ls->m_alpha = 1.f; *ls->m_alpha = 1.f;
} }
} }
@@ -79,8 +79,8 @@ void CInputManager::endWorkspaceSwipe() {
auto PWORKSPACEL = g_pCompositor->getWorkspaceByID(workspaceIDLeft); // not guaranteed if PSWIPENUMBER auto PWORKSPACEL = g_pCompositor->getWorkspaceByID(workspaceIDLeft); // not guaranteed if PSWIPENUMBER
const auto RENDEROFFSETMIDDLE = m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->value(); const auto RENDEROFFSETMIDDLE = m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->value();
const auto XDISTANCE = m_sActiveSwipe.pMonitor->vecSize.x + *PWORKSPACEGAP; const auto XDISTANCE = m_sActiveSwipe.pMonitor->m_size.x + *PWORKSPACEGAP;
const auto YDISTANCE = m_sActiveSwipe.pMonitor->vecSize.y + *PWORKSPACEGAP; const auto YDISTANCE = m_sActiveSwipe.pMonitor->m_size.y + *PWORKSPACEGAP;
PHLWORKSPACE pSwitchedTo = nullptr; PHLWORKSPACE pSwitchedTo = nullptr;
@@ -122,7 +122,7 @@ void CInputManager::endWorkspaceSwipe() {
if (PWORKSPACEL) if (PWORKSPACEL)
m_sActiveSwipe.pMonitor->changeWorkspace(workspaceIDLeft); m_sActiveSwipe.pMonitor->changeWorkspace(workspaceIDLeft);
else { else {
m_sActiveSwipe.pMonitor->changeWorkspace(g_pCompositor->createNewWorkspace(workspaceIDLeft, m_sActiveSwipe.pMonitor->ID)); m_sActiveSwipe.pMonitor->changeWorkspace(g_pCompositor->createNewWorkspace(workspaceIDLeft, m_sActiveSwipe.pMonitor->m_id));
PWORKSPACEL = g_pCompositor->getWorkspaceByID(workspaceIDLeft); PWORKSPACEL = g_pCompositor->getWorkspaceByID(workspaceIDLeft);
PWORKSPACEL->rememberPrevWorkspace(m_sActiveSwipe.pWorkspaceBegin); PWORKSPACEL->rememberPrevWorkspace(m_sActiveSwipe.pWorkspaceBegin);
} }
@@ -149,7 +149,7 @@ void CInputManager::endWorkspaceSwipe() {
if (PWORKSPACER) if (PWORKSPACER)
m_sActiveSwipe.pMonitor->changeWorkspace(workspaceIDRight); m_sActiveSwipe.pMonitor->changeWorkspace(workspaceIDRight);
else { else {
m_sActiveSwipe.pMonitor->changeWorkspace(g_pCompositor->createNewWorkspace(workspaceIDRight, m_sActiveSwipe.pMonitor->ID)); m_sActiveSwipe.pMonitor->changeWorkspace(g_pCompositor->createNewWorkspace(workspaceIDRight, m_sActiveSwipe.pMonitor->m_id));
PWORKSPACER = g_pCompositor->getWorkspaceByID(workspaceIDRight); PWORKSPACER = g_pCompositor->getWorkspaceByID(workspaceIDRight);
PWORKSPACER->rememberPrevWorkspace(m_sActiveSwipe.pWorkspaceBegin); PWORKSPACER->rememberPrevWorkspace(m_sActiveSwipe.pWorkspaceBegin);
} }
@@ -186,7 +186,7 @@ void CInputManager::endWorkspaceSwipe() {
g_pInputManager->refocus(); g_pInputManager->refocus();
// apply alpha // apply alpha
for (auto const& ls : g_pCompositor->m_lastMonitor->m_aLayerSurfaceLayers[2]) { for (auto const& ls : g_pCompositor->m_lastMonitor->m_layerSurfaceLayers[2]) {
*ls->m_alpha = pSwitchedTo->m_hasFullscreenWindow && pSwitchedTo->m_fullscreenMode == FSMODE_FULLSCREEN ? 0.f : 1.f; *ls->m_alpha = pSwitchedTo->m_hasFullscreenWindow && pSwitchedTo->m_fullscreenMode == FSMODE_FULLSCREEN ? 0.f : 1.f;
} }
} }
@@ -214,8 +214,8 @@ void CInputManager::updateWorkspaceSwipe(double delta) {
static auto PWORKSPACEGAP = CConfigValue<Hyprlang::INT>("general:gaps_workspaces"); static auto PWORKSPACEGAP = CConfigValue<Hyprlang::INT>("general:gaps_workspaces");
const auto SWIPEDISTANCE = std::clamp(*PSWIPEDIST, (int64_t)1LL, (int64_t)UINT32_MAX); const auto SWIPEDISTANCE = std::clamp(*PSWIPEDIST, (int64_t)1LL, (int64_t)UINT32_MAX);
const auto XDISTANCE = m_sActiveSwipe.pMonitor->vecSize.x + *PWORKSPACEGAP; const auto XDISTANCE = m_sActiveSwipe.pMonitor->m_size.x + *PWORKSPACEGAP;
const auto YDISTANCE = m_sActiveSwipe.pMonitor->vecSize.y + *PWORKSPACEGAP; const auto YDISTANCE = m_sActiveSwipe.pMonitor->m_size.y + *PWORKSPACEGAP;
const auto ANIMSTYLE = m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->getStyle(); const auto ANIMSTYLE = m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->getStyle();
const bool VERTANIMS = ANIMSTYLE == "slidevert" || ANIMSTYLE.starts_with("slidefadevert"); const bool VERTANIMS = ANIMSTYLE == "slidevert" || ANIMSTYLE.starts_with("slidefadevert");
const double d = m_sActiveSwipe.delta - delta; const double d = m_sActiveSwipe.delta - delta;

20
src/managers/input/Touch.cpp
View File

@@ -27,7 +27,7 @@ void CInputManager::onTouchDown(ITouch::SDownEvent e) {
PMONITOR = PMONITOR ? PMONITOR : g_pCompositor->m_lastMonitor.lock(); PMONITOR = PMONITOR ? PMONITOR : g_pCompositor->m_lastMonitor.lock();
g_pCompositor->warpCursorTo({PMONITOR->vecPosition.x + e.pos.x * PMONITOR->vecSize.x, PMONITOR->vecPosition.y + e.pos.y * PMONITOR->vecSize.y}, true); g_pCompositor->warpCursorTo({PMONITOR->m_position.x + e.pos.x * PMONITOR->m_size.x, PMONITOR->m_position.y + e.pos.y * PMONITOR->m_size.y}, true);
refocus(); refocus();
@@ -43,11 +43,11 @@ void CInputManager::onTouchDown(ITouch::SDownEvent e) {
return; return;
// TODO: Don't swipe if you touched a floating window. // TODO: Don't swipe if you touched a floating window.
} else if (*PSWIPETOUCH && (m_pFoundLSToFocus.expired() || m_pFoundLSToFocus->m_layer <= 1) && !g_pSessionLockManager->isSessionLocked()) { } else if (*PSWIPETOUCH && (m_pFoundLSToFocus.expired() || m_pFoundLSToFocus->m_layer <= 1) && !g_pSessionLockManager->isSessionLocked()) {
const auto PWORKSPACE = PMONITOR->activeWorkspace; const auto PWORKSPACE = PMONITOR->m_activeWorkspace;
const auto STYLE = PWORKSPACE->m_renderOffset->getStyle(); const auto STYLE = PWORKSPACE->m_renderOffset->getStyle();
const bool VERTANIMS = STYLE == "slidevert" || STYLE.starts_with("slidefadevert"); const bool VERTANIMS = STYLE == "slidevert" || STYLE.starts_with("slidefadevert");
const double TARGETLEFT = ((VERTANIMS ? gapsOut.m_top : gapsOut.m_left) + *PBORDERSIZE) / (VERTANIMS ? PMONITOR->vecSize.y : PMONITOR->vecSize.x); const double TARGETLEFT = ((VERTANIMS ? gapsOut.m_top : gapsOut.m_left) + *PBORDERSIZE) / (VERTANIMS ? PMONITOR->m_size.y : PMONITOR->m_size.x);
const double TARGETRIGHT = 1 - (((VERTANIMS ? gapsOut.m_bottom : gapsOut.m_right) + *PBORDERSIZE) / (VERTANIMS ? PMONITOR->vecSize.y : PMONITOR->vecSize.x)); const double TARGETRIGHT = 1 - (((VERTANIMS ? gapsOut.m_bottom : gapsOut.m_right) + *PBORDERSIZE) / (VERTANIMS ? PMONITOR->m_size.y : PMONITOR->m_size.x));
const double POSITION = (VERTANIMS ? e.pos.y : e.pos.x); const double POSITION = (VERTANIMS ? e.pos.y : e.pos.x);
if (POSITION < TARGETLEFT || POSITION > TARGETRIGHT) { if (POSITION < TARGETLEFT || POSITION > TARGETRIGHT) {
beginWorkspaceSwipe(); beginWorkspaceSwipe();
@@ -62,7 +62,7 @@ void CInputManager::onTouchDown(ITouch::SDownEvent e) {
} }
if (g_pSessionLockManager->isSessionLocked()) { if (g_pSessionLockManager->isSessionLocked()) {
m_sTouchData.touchFocusLockSurface = g_pSessionLockManager->getSessionLockSurfaceForMonitor(PMONITOR->ID); m_sTouchData.touchFocusLockSurface = g_pSessionLockManager->getSessionLockSurfaceForMonitor(PMONITOR->m_id);
if (!m_sTouchData.touchFocusLockSurface) if (!m_sTouchData.touchFocusLockSurface)
Debug::log(WARN, "The session is locked but can't find a lock surface"); Debug::log(WARN, "The session is locked but can't find a lock surface");
else else
@@ -77,7 +77,7 @@ void CInputManager::onTouchDown(ITouch::SDownEvent e) {
Vector2D local; Vector2D local;
if (m_sTouchData.touchFocusLockSurface) { if (m_sTouchData.touchFocusLockSurface) {
local = g_pInputManager->getMouseCoordsInternal() - PMONITOR->vecPosition; local = g_pInputManager->getMouseCoordsInternal() - PMONITOR->m_position;
m_sTouchData.touchSurfaceOrigin = g_pInputManager->getMouseCoordsInternal() - local; m_sTouchData.touchSurfaceOrigin = g_pInputManager->getMouseCoordsInternal() - local;
} else if (!m_sTouchData.touchFocusWindow.expired()) { } else if (!m_sTouchData.touchFocusWindow.expired()) {
if (m_sTouchData.touchFocusWindow->m_isX11) { if (m_sTouchData.touchFocusWindow->m_isX11) {
@@ -144,13 +144,13 @@ void CInputManager::onTouchMove(ITouch::SMotionEvent e) {
} }
if (m_sTouchData.touchFocusLockSurface) { if (m_sTouchData.touchFocusLockSurface) {
const auto PMONITOR = g_pCompositor->getMonitorFromID(m_sTouchData.touchFocusLockSurface->iMonitorID); const auto PMONITOR = g_pCompositor->getMonitorFromID(m_sTouchData.touchFocusLockSurface->iMonitorID);
g_pCompositor->warpCursorTo({PMONITOR->vecPosition.x + e.pos.x * PMONITOR->vecSize.x, PMONITOR->vecPosition.y + e.pos.y * PMONITOR->vecSize.y}, true); g_pCompositor->warpCursorTo({PMONITOR->m_position.x + e.pos.x * PMONITOR->m_size.x, PMONITOR->m_position.y + e.pos.y * PMONITOR->m_size.y}, true);
auto local = g_pInputManager->getMouseCoordsInternal() - PMONITOR->vecPosition; auto local = g_pInputManager->getMouseCoordsInternal() - PMONITOR->m_position;
g_pSeatManager->sendTouchMotion(e.timeMs, e.touchID, local); g_pSeatManager->sendTouchMotion(e.timeMs, e.touchID, local);
} else if (validMapped(m_sTouchData.touchFocusWindow)) { } else if (validMapped(m_sTouchData.touchFocusWindow)) {
const auto PMONITOR = m_sTouchData.touchFocusWindow->m_monitor.lock(); const auto PMONITOR = m_sTouchData.touchFocusWindow->m_monitor.lock();
g_pCompositor->warpCursorTo({PMONITOR->vecPosition.x + e.pos.x * PMONITOR->vecSize.x, PMONITOR->vecPosition.y + e.pos.y * PMONITOR->vecSize.y}, true); g_pCompositor->warpCursorTo({PMONITOR->m_position.x + e.pos.x * PMONITOR->m_size.x, PMONITOR->m_position.y + e.pos.y * PMONITOR->m_size.y}, true);
auto local = g_pInputManager->getMouseCoordsInternal() - m_sTouchData.touchSurfaceOrigin; auto local = g_pInputManager->getMouseCoordsInternal() - m_sTouchData.touchSurfaceOrigin;
if (m_sTouchData.touchFocusWindow->m_isX11) if (m_sTouchData.touchFocusWindow->m_isX11)
@@ -160,7 +160,7 @@ void CInputManager::onTouchMove(ITouch::SMotionEvent e) {
} else if (!m_sTouchData.touchFocusLS.expired()) { } else if (!m_sTouchData.touchFocusLS.expired()) {
const auto PMONITOR = m_sTouchData.touchFocusLS->m_monitor.lock(); const auto PMONITOR = m_sTouchData.touchFocusLS->m_monitor.lock();
g_pCompositor->warpCursorTo({PMONITOR->vecPosition.x + e.pos.x * PMONITOR->vecSize.x, PMONITOR->vecPosition.y + e.pos.y * PMONITOR->vecSize.y}, true); g_pCompositor->warpCursorTo({PMONITOR->m_position.x + e.pos.x * PMONITOR->m_size.x, PMONITOR->m_position.y + e.pos.y * PMONITOR->m_size.y}, true);
const auto local = g_pInputManager->getMouseCoordsInternal() - m_sTouchData.touchSurfaceOrigin; const auto local = g_pInputManager->getMouseCoordsInternal() - m_sTouchData.touchSurfaceOrigin;

8
src/protocols/CTMControl.cpp
View File

@@ -40,9 +40,9 @@ CHyprlandCTMControlResource::CHyprlandCTMControlResource(SP<CHyprlandCtmControlM
} }
} }
ctms[PMONITOR->szName] = MAT; ctms[PMONITOR->m_name] = MAT;
LOGM(LOG, "CTM set for output {}: {}", PMONITOR->szName, ctms.at(PMONITOR->szName).toString()); LOGM(LOG, "CTM set for output {}: {}", PMONITOR->m_name, ctms.at(PMONITOR->m_name).toString());
}); });
resource->setCommit([this](CHyprlandCtmControlManagerV1* r) { resource->setCommit([this](CHyprlandCtmControlManagerV1* r) {
@@ -52,12 +52,12 @@ CHyprlandCTMControlResource::CHyprlandCTMControlResource(SP<CHyprlandCtmControlM
LOGM(LOG, "Committing ctms to outputs"); LOGM(LOG, "Committing ctms to outputs");
for (auto& m : g_pCompositor->m_monitors) { for (auto& m : g_pCompositor->m_monitors) {
if (!ctms.contains(m->szName)) { if (!ctms.contains(m->m_name)) {
PROTO::ctm->setCTM(m, Mat3x3::identity()); PROTO::ctm->setCTM(m, Mat3x3::identity());
continue; continue;
} }
PROTO::ctm->setCTM(m, ctms.at(m->szName)); PROTO::ctm->setCTM(m, ctms.at(m->m_name));
} }
}); });
} }

2
src/protocols/ColorManagement.cpp
View File

@@ -235,7 +235,7 @@ CColorManagementOutput::CColorManagementOutput(SP<CWpColorManagementOutputV1> re
if (!m_monitor.valid()) if (!m_monitor.valid())
RESOURCE->m_resource->sendFailed(WP_IMAGE_DESCRIPTION_V1_CAUSE_NO_OUTPUT, "No output"); RESOURCE->m_resource->sendFailed(WP_IMAGE_DESCRIPTION_V1_CAUSE_NO_OUTPUT, "No output");
else { else {
RESOURCE->settings = m_monitor->imageDescription; RESOURCE->settings = m_monitor->m_imageDescription;
RESOURCE->m_resource->sendReady(RESOURCE->settings.updateId()); RESOURCE->m_resource->sendReady(RESOURCE->settings.updateId());
} }
}); });

28
src/protocols/DRMLease.cpp
View File

@@ -17,8 +17,8 @@ CDRMLeaseResource::CDRMLeaseResource(SP<CWpDrmLeaseV1> resource_, SP<CDRMLeaseRe
requested = request->requested; requested = request->requested;
for (auto const& m : requested) { for (auto const& m : requested) {
if (!m->monitor || m->monitor->isBeingLeased) { if (!m->monitor || m->monitor->m_isBeingLeased) {
LOGM(ERR, "Rejecting lease: no monitor or monitor is being leased for {}", (m->monitor ? m->monitor->szName : "null")); LOGM(ERR, "Rejecting lease: no monitor or monitor is being leased for {}", (m->monitor ? m->monitor->m_name : "null"));
resource->sendFinished(); resource->sendFinished();
return; return;
} }
@@ -29,7 +29,7 @@ CDRMLeaseResource::CDRMLeaseResource(SP<CWpDrmLeaseV1> resource_, SP<CDRMLeaseRe
LOGM(LOG, "Leasing outputs: {}", [this]() { LOGM(LOG, "Leasing outputs: {}", [this]() {
std::string roll; std::string roll;
for (auto const& o : requested) { for (auto const& o : requested) {
roll += std::format("{} ", o->monitor->szName); roll += std::format("{} ", o->monitor->m_name);
} }
return roll; return roll;
}()); }());
@@ -39,7 +39,7 @@ CDRMLeaseResource::CDRMLeaseResource(SP<CWpDrmLeaseV1> resource_, SP<CDRMLeaseRe
outputs.reserve(requested.size()); outputs.reserve(requested.size());
for (auto const& m : requested) { for (auto const& m : requested) {
outputs.emplace_back(m->monitor->output); outputs.emplace_back(m->monitor->m_output);
} }
auto aqlease = Aquamarine::CDRMLease::create(outputs); auto aqlease = Aquamarine::CDRMLease::create(outputs);
@@ -52,13 +52,13 @@ CDRMLeaseResource::CDRMLeaseResource(SP<CWpDrmLeaseV1> resource_, SP<CDRMLeaseRe
lease = aqlease; lease = aqlease;
for (auto const& m : requested) { for (auto const& m : requested) {
m->monitor->isBeingLeased = true; m->monitor->m_isBeingLeased = true;
} }
listeners.destroyLease = lease->events.destroy.registerListener([this](std::any d) { listeners.destroyLease = lease->events.destroy.registerListener([this](std::any d) {
for (auto const& m : requested) { for (auto const& m : requested) {
if (m && m->monitor) if (m && m->monitor)
m->monitor->isBeingLeased = false; m->monitor->m_isBeingLeased = false;
} }
resource->sendFinished(); resource->sendFinished();
@@ -143,7 +143,7 @@ CDRMLeaseConnectorResource::CDRMLeaseConnectorResource(SP<CWpDrmLeaseConnectorV1
resource->setData(this); resource->setData(this);
listeners.destroyMonitor = monitor->events.destroy.registerListener([this](std::any d) { listeners.destroyMonitor = monitor->m_events.destroy.registerListener([this](std::any d) {
resource->sendWithdrawn(); resource->sendWithdrawn();
dead = true; dead = true;
}); });
@@ -154,10 +154,10 @@ bool CDRMLeaseConnectorResource::good() {
} }
void CDRMLeaseConnectorResource::sendData() { void CDRMLeaseConnectorResource::sendData() {
resource->sendName(monitor->szName.c_str()); resource->sendName(monitor->m_name.c_str());
resource->sendDescription(monitor->szDescription.c_str()); resource->sendDescription(monitor->m_description.c_str());
auto AQDRMOutput = (Aquamarine::CDRMOutput*)monitor->output.get(); auto AQDRMOutput = (Aquamarine::CDRMOutput*)monitor->m_output.get();
resource->sendConnectorId(AQDRMOutput->getConnectorID()); resource->sendConnectorId(AQDRMOutput->getConnectorID());
resource->sendDone(); resource->sendDone();
@@ -220,7 +220,7 @@ void CDRMLeaseDeviceResource::sendConnector(PHLMONITOR monitor) {
RESOURCE->parent = self; RESOURCE->parent = self;
RESOURCE->self = RESOURCE; RESOURCE->self = RESOURCE;
LOGM(LOG, "Sending new connector {}", monitor->szName); LOGM(LOG, "Sending new connector {}", monitor->m_name);
connectorsSent.emplace_back(RESOURCE); connectorsSent.emplace_back(RESOURCE);
PROTO::lease->m_vConnectors.emplace_back(RESOURCE); PROTO::lease->m_vConnectors.emplace_back(RESOURCE);
@@ -297,11 +297,11 @@ void CDRMLeaseProtocol::offer(PHLMONITOR monitor) {
if (std::find(primaryDevice->offeredOutputs.begin(), primaryDevice->offeredOutputs.end(), monitor) != primaryDevice->offeredOutputs.end()) if (std::find(primaryDevice->offeredOutputs.begin(), primaryDevice->offeredOutputs.end(), monitor) != primaryDevice->offeredOutputs.end())
return; return;
if (monitor->output->getBackend()->type() != Aquamarine::AQ_BACKEND_DRM) if (monitor->m_output->getBackend()->type() != Aquamarine::AQ_BACKEND_DRM)
return; return;
if (monitor->output->getBackend() != primaryDevice->backend) { if (monitor->m_output->getBackend() != primaryDevice->backend) {
LOGM(ERR, "Monitor {} cannot be leased: primaryDevice lease is for a different device", monitor->szName); LOGM(ERR, "Monitor {} cannot be leased: primaryDevice lease is for a different device", monitor->m_name);
return; return;
} }

16
src/protocols/ForeignToplevelWlr.cpp
View File

@@ -46,8 +46,8 @@ CForeignToplevelHandleWlr::CForeignToplevelHandleWlr(SP<CZwlrForeignToplevelHand
if (!wpMonitor.expired()) { if (!wpMonitor.expired()) {
const auto monitor = wpMonitor.lock(); const auto monitor = wpMonitor.lock();
if (PWINDOW->m_workspace != monitor->activeWorkspace) { if (PWINDOW->m_workspace != monitor->m_activeWorkspace) {
g_pCompositor->moveWindowToWorkspaceSafe(PWINDOW, monitor->activeWorkspace); g_pCompositor->moveWindowToWorkspaceSafe(PWINDOW, monitor->m_activeWorkspace);
g_pCompositor->setActiveMonitor(monitor); g_pCompositor->setActiveMonitor(monitor);
} }
} }
@@ -145,26 +145,26 @@ wl_resource* CForeignToplevelHandleWlr::res() {
} }
void CForeignToplevelHandleWlr::sendMonitor(PHLMONITOR pMonitor) { void CForeignToplevelHandleWlr::sendMonitor(PHLMONITOR pMonitor) {
if (lastMonitorID == pMonitor->ID) if (lastMonitorID == pMonitor->m_id)
return; return;
const auto CLIENT = resource->client(); const auto CLIENT = resource->client();
if (const auto PLASTMONITOR = g_pCompositor->getMonitorFromID(lastMonitorID); PLASTMONITOR && PROTO::outputs.contains(PLASTMONITOR->szName)) { if (const auto PLASTMONITOR = g_pCompositor->getMonitorFromID(lastMonitorID); PLASTMONITOR && PROTO::outputs.contains(PLASTMONITOR->m_name)) {
const auto OLDRESOURCE = PROTO::outputs.at(PLASTMONITOR->szName)->outputResourceFrom(CLIENT); const auto OLDRESOURCE = PROTO::outputs.at(PLASTMONITOR->m_name)->outputResourceFrom(CLIENT);
if LIKELY (OLDRESOURCE) if LIKELY (OLDRESOURCE)
resource->sendOutputLeave(OLDRESOURCE->getResource()->resource()); resource->sendOutputLeave(OLDRESOURCE->getResource()->resource());
} }
if (PROTO::outputs.contains(pMonitor->szName)) { if (PROTO::outputs.contains(pMonitor->m_name)) {
const auto NEWRESOURCE = PROTO::outputs.at(pMonitor->szName)->outputResourceFrom(CLIENT); const auto NEWRESOURCE = PROTO::outputs.at(pMonitor->m_name)->outputResourceFrom(CLIENT);
if LIKELY (NEWRESOURCE) if LIKELY (NEWRESOURCE)
resource->sendOutputEnter(NEWRESOURCE->getResource()->resource()); resource->sendOutputEnter(NEWRESOURCE->getResource()->resource());
} }
lastMonitorID = pMonitor->ID; lastMonitorID = pMonitor->m_id;
} }
void CForeignToplevelHandleWlr::sendState() { void CForeignToplevelHandleWlr::sendState() {

32
src/protocols/GammaControl.cpp
View File

@@ -20,7 +20,7 @@ CGammaControl::CGammaControl(SP<CZwlrGammaControlV1> resource_, wl_resource* out
pMonitor = OUTPUTRES->monitor; pMonitor = OUTPUTRES->monitor;
if UNLIKELY (!pMonitor || !pMonitor->output) { if UNLIKELY (!pMonitor || !pMonitor->m_output) {
LOGM(ERR, "No CMonitor"); LOGM(ERR, "No CMonitor");
resource->sendFailed(); resource->sendFailed();
return; return;
@@ -33,10 +33,10 @@ CGammaControl::CGammaControl(SP<CZwlrGammaControlV1> resource_, wl_resource* out
} }
} }
gammaSize = pMonitor->output->getGammaSize(); gammaSize = pMonitor->m_output->getGammaSize();
if UNLIKELY (gammaSize <= 0) { if UNLIKELY (gammaSize <= 0) {
LOGM(ERR, "Output {} doesn't support gamma", pMonitor->szName); LOGM(ERR, "Output {} doesn't support gamma", pMonitor->m_name);
resource->sendFailed(); resource->sendFailed();
return; return;
} }
@@ -54,7 +54,7 @@ CGammaControl::CGammaControl(SP<CZwlrGammaControlV1> resource_, wl_resource* out
return; return;
} }
LOGM(LOG, "setGamma for {}", pMonitor->szName); LOGM(LOG, "setGamma for {}", pMonitor->m_name);
// TODO: make CFileDescriptor getflags use F_GETFL // TODO: make CFileDescriptor getflags use F_GETFL
int fdFlags = fcntl(gammaFd.get(), F_GETFL, 0); int fdFlags = fcntl(gammaFd.get(), F_GETFL, 0);
@@ -108,16 +108,16 @@ CGammaControl::CGammaControl(SP<CZwlrGammaControlV1> resource_, wl_resource* out
resource->sendGammaSize(gammaSize); resource->sendGammaSize(gammaSize);
listeners.monitorDestroy = pMonitor->events.destroy.registerListener([this](std::any) { this->onMonitorDestroy(); }); listeners.monitorDestroy = pMonitor->m_events.destroy.registerListener([this](std::any) { this->onMonitorDestroy(); });
listeners.monitorDisconnect = pMonitor->events.disconnect.registerListener([this](std::any) { this->onMonitorDestroy(); }); listeners.monitorDisconnect = pMonitor->m_events.disconnect.registerListener([this](std::any) { this->onMonitorDestroy(); });
} }
CGammaControl::~CGammaControl() { CGammaControl::~CGammaControl() {
if (!gammaTableSet || !pMonitor || !pMonitor->output) if (!gammaTableSet || !pMonitor || !pMonitor->m_output)
return; return;
// reset the LUT if the client dies for whatever reason and doesn't unset the gamma // reset the LUT if the client dies for whatever reason and doesn't unset the gamma
pMonitor->output->state->setGammaLut({}); pMonitor->m_output->state->setGammaLut({});
} }
bool CGammaControl::good() { bool CGammaControl::good() {
@@ -125,21 +125,21 @@ bool CGammaControl::good() {
} }
void CGammaControl::applyToMonitor() { void CGammaControl::applyToMonitor() {
if UNLIKELY (!pMonitor || !pMonitor->output) if UNLIKELY (!pMonitor || !pMonitor->m_output)
return; // ?? return; // ??
LOGM(LOG, "setting to monitor {}", pMonitor->szName); LOGM(LOG, "setting to monitor {}", pMonitor->m_name);
if (!gammaTableSet) { if (!gammaTableSet) {
pMonitor->output->state->setGammaLut({}); pMonitor->m_output->state->setGammaLut({});
return; return;
} }
pMonitor->output->state->setGammaLut(gammaTable); pMonitor->m_output->state->setGammaLut(gammaTable);
if (!pMonitor->state.test()) { if (!pMonitor->m_state.test()) {
LOGM(LOG, "setting to monitor {} failed", pMonitor->szName); LOGM(LOG, "setting to monitor {} failed", pMonitor->m_name);
pMonitor->output->state->setGammaLut({}); pMonitor->m_output->state->setGammaLut({});
} }
g_pHyprRenderer->damageMonitor(pMonitor.lock()); g_pHyprRenderer->damageMonitor(pMonitor.lock());
@@ -150,7 +150,7 @@ PHLMONITOR CGammaControl::getMonitor() {
} }
void CGammaControl::onMonitorDestroy() { void CGammaControl::onMonitorDestroy() {
LOGM(LOG, "Destroying gamma control for {}", pMonitor->szName); LOGM(LOG, "Destroying gamma control for {}", pMonitor->m_name);
resource->sendFailed(); resource->sendFailed();
} }

2
src/protocols/LayerShell.cpp
View File

@@ -22,7 +22,7 @@ CLayerShellResource::CLayerShellResource(SP<CZwlrLayerSurfaceV1> resource_, SP<C
return; return;
current.layer = layer; current.layer = layer;
monitor = pMonitor ? pMonitor->szName : ""; monitor = pMonitor ? pMonitor->m_name : "";
resource->setDestroy([this](CZwlrLayerSurfaceV1* r) { resource->setDestroy([this](CZwlrLayerSurfaceV1* r) {
events.destroy.emit(); events.destroy.emit();

6
src/protocols/LinuxDMABUF.cpp
View File

@@ -436,7 +436,7 @@ CLinuxDMABufV1Protocol::CLinuxDMABufV1Protocol(const wl_interface* iface, const
auto tranche = SDMABUFTranche{ auto tranche = SDMABUFTranche{
.device = mainDevice, .device = mainDevice,
.flags = ZWP_LINUX_DMABUF_FEEDBACK_V1_TRANCHE_FLAGS_SCANOUT, .flags = ZWP_LINUX_DMABUF_FEEDBACK_V1_TRANCHE_FLAGS_SCANOUT,
.formats = mon->output->getRenderFormats(), .formats = mon->m_output->getRenderFormats(),
}; };
tches.emplace_back(std::make_pair<>(mon, tranche)); tches.emplace_back(std::make_pair<>(mon, tranche));
} }
@@ -446,7 +446,7 @@ CLinuxDMABufV1Protocol::CLinuxDMABufV1Protocol(const wl_interface* iface, const
auto tranche = SDMABUFTranche{ auto tranche = SDMABUFTranche{
.device = mainDevice, .device = mainDevice,
.flags = ZWP_LINUX_DMABUF_FEEDBACK_V1_TRANCHE_FLAGS_SCANOUT, .flags = ZWP_LINUX_DMABUF_FEEDBACK_V1_TRANCHE_FLAGS_SCANOUT,
.formats = pMonitor->output->getRenderFormats(), .formats = pMonitor->m_output->getRenderFormats(),
}; };
formatTable->monitorTranches.emplace_back(std::make_pair<>(pMonitor, tranche)); formatTable->monitorTranches.emplace_back(std::make_pair<>(pMonitor, tranche));
resetFormatTable(); resetFormatTable();
@@ -500,7 +500,7 @@ void CLinuxDMABufV1Protocol::resetFormatTable() {
auto HLSurface = CWLSurface::fromResource(feedback->surface); auto HLSurface = CWLSurface::fromResource(feedback->surface);
if (auto w = HLSurface->getWindow(); w) if (auto w = HLSurface->getWindow(); w)
if (auto m = w->m_monitor.lock(); m) if (auto m = w->m_monitor.lock(); m)
mon = m->self.lock(); mon = m->m_self.lock();
if (!mon) { if (!mon) {
feedback->sendDefaultFeedback(); feedback->sendDefaultFeedback();

112
src/protocols/OutputManagement.cpp
View File

@@ -35,7 +35,7 @@ COutputManager::COutputManager(SP<CZwlrOutputManagerV1> resource_) : resource(re
if (m == g_pCompositor->m_unsafeOutput) if (m == g_pCompositor->m_unsafeOutput)
continue; continue;
LOGM(LOG, " | sending output head for {}", m->szName); LOGM(LOG, " | sending output head for {}", m->m_name);
makeAndSendNewHead(m); makeAndSendNewHead(m);
} }
@@ -96,7 +96,7 @@ COutputHead::COutputHead(SP<CZwlrOutputHeadV1> resource_, PHLMONITOR pMonitor_)
resource->setRelease([this](CZwlrOutputHeadV1* r) { PROTO::outputManagement->destroyResource(this); }); resource->setRelease([this](CZwlrOutputHeadV1* r) { PROTO::outputManagement->destroyResource(this); });
resource->setOnDestroy([this](CZwlrOutputHeadV1* r) { PROTO::outputManagement->destroyResource(this); }); resource->setOnDestroy([this](CZwlrOutputHeadV1* r) { PROTO::outputManagement->destroyResource(this); });
listeners.monitorDestroy = pMonitor->events.destroy.registerListener([this](std::any d) { listeners.monitorDestroy = pMonitor->m_events.destroy.registerListener([this](std::any d) {
resource->sendFinished(); resource->sendFinished();
for (auto const& mw : modes) { for (auto const& mw : modes) {
@@ -114,7 +114,7 @@ COutputHead::COutputHead(SP<CZwlrOutputHeadV1> resource_, PHLMONITOR pMonitor_)
} }
}); });
listeners.monitorModeChange = pMonitor->events.modeChanged.registerListener([this](std::any d) { updateMode(); }); listeners.monitorModeChange = pMonitor->m_events.modeChanged.registerListener([this](std::any d) { updateMode(); });
} }
bool COutputHead::good() { bool COutputHead::good() {
@@ -124,54 +124,54 @@ bool COutputHead::good() {
void COutputHead::sendAllData() { void COutputHead::sendAllData() {
const auto VERSION = resource->version(); const auto VERSION = resource->version();
resource->sendName(pMonitor->szName.c_str()); resource->sendName(pMonitor->m_name.c_str());
resource->sendDescription(pMonitor->szDescription.c_str()); resource->sendDescription(pMonitor->m_description.c_str());
if (pMonitor->output->physicalSize.x > 0 && pMonitor->output->physicalSize.y > 0) if (pMonitor->m_output->physicalSize.x > 0 && pMonitor->m_output->physicalSize.y > 0)
resource->sendPhysicalSize(pMonitor->output->physicalSize.x, pMonitor->output->physicalSize.y); resource->sendPhysicalSize(pMonitor->m_output->physicalSize.x, pMonitor->m_output->physicalSize.y);
resource->sendEnabled(pMonitor->m_bEnabled); resource->sendEnabled(pMonitor->m_enabled);
if (pMonitor->m_bEnabled) { if (pMonitor->m_enabled) {
resource->sendPosition(pMonitor->vecPosition.x, pMonitor->vecPosition.y); resource->sendPosition(pMonitor->m_position.x, pMonitor->m_position.y);
resource->sendTransform(pMonitor->transform); resource->sendTransform(pMonitor->m_transform);
resource->sendScale(wl_fixed_from_double(pMonitor->scale)); resource->sendScale(wl_fixed_from_double(pMonitor->m_scale));
} }
if (!pMonitor->output->make.empty() && VERSION >= 2) if (!pMonitor->m_output->make.empty() && VERSION >= 2)
resource->sendMake(pMonitor->output->make.c_str()); resource->sendMake(pMonitor->m_output->make.c_str());
if (!pMonitor->output->model.empty() && VERSION >= 2) if (!pMonitor->m_output->model.empty() && VERSION >= 2)
resource->sendModel(pMonitor->output->model.c_str()); resource->sendModel(pMonitor->m_output->model.c_str());
if (!pMonitor->output->serial.empty() && VERSION >= 2) if (!pMonitor->m_output->serial.empty() && VERSION >= 2)
resource->sendSerialNumber(pMonitor->output->serial.c_str()); resource->sendSerialNumber(pMonitor->m_output->serial.c_str());
if (VERSION >= 4) if (VERSION >= 4)
resource->sendAdaptiveSync(pMonitor->vrrActive ? ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_ENABLED : ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_DISABLED); resource->sendAdaptiveSync(pMonitor->m_vrrActive ? ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_ENABLED : ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_DISABLED);
// send all available modes // send all available modes
if (modes.empty()) { if (modes.empty()) {
if (!pMonitor->output->modes.empty()) { if (!pMonitor->m_output->modes.empty()) {
for (auto const& m : pMonitor->output->modes) { for (auto const& m : pMonitor->m_output->modes) {
makeAndSendNewMode(m); makeAndSendNewMode(m);
} }
} else if (pMonitor->output->state->state().customMode) { } else if (pMonitor->m_output->state->state().customMode) {
makeAndSendNewMode(pMonitor->output->state->state().customMode); makeAndSendNewMode(pMonitor->m_output->state->state().customMode);
} else } else
makeAndSendNewMode(nullptr); makeAndSendNewMode(nullptr);
} }
// send current mode // send current mode
if (pMonitor->m_bEnabled) { if (pMonitor->m_enabled) {
for (auto const& mw : modes) { for (auto const& mw : modes) {
auto m = mw.lock(); auto m = mw.lock();
if (!m) if (!m)
continue; continue;
if (m->mode == pMonitor->output->state->state().mode) { if (m->mode == pMonitor->m_output->state->state().mode) {
if (m->mode) if (m->mode)
LOGM(LOG, " | sending current mode for {}: {}x{}@{}", pMonitor->szName, m->mode->pixelSize.x, m->mode->pixelSize.y, m->mode->refreshRate); LOGM(LOG, " | sending current mode for {}: {}x{}@{}", pMonitor->m_name, m->mode->pixelSize.x, m->mode->pixelSize.y, m->mode->refreshRate);
else else
LOGM(LOG, " | sending current mode for {}: null (fake)", pMonitor->szName); LOGM(LOG, " | sending current mode for {}: null (fake)", pMonitor->m_name);
resource->sendCurrentMode(m->resource.get()); resource->sendCurrentMode(m->resource.get());
break; break;
} }
@@ -180,29 +180,29 @@ void COutputHead::sendAllData() {
} }
void COutputHead::updateMode() { void COutputHead::updateMode() {
resource->sendEnabled(pMonitor->m_bEnabled); resource->sendEnabled(pMonitor->m_enabled);
if (pMonitor->m_bEnabled) { if (pMonitor->m_enabled) {
resource->sendPosition(pMonitor->vecPosition.x, pMonitor->vecPosition.y); resource->sendPosition(pMonitor->m_position.x, pMonitor->m_position.y);
resource->sendTransform(pMonitor->transform); resource->sendTransform(pMonitor->m_transform);
resource->sendScale(wl_fixed_from_double(pMonitor->scale)); resource->sendScale(wl_fixed_from_double(pMonitor->m_scale));
} }
if (resource->version() >= 4) if (resource->version() >= 4)
resource->sendAdaptiveSync(pMonitor->vrrActive ? ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_ENABLED : ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_DISABLED); resource->sendAdaptiveSync(pMonitor->m_vrrActive ? ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_ENABLED : ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_DISABLED);
if (pMonitor->m_bEnabled) { if (pMonitor->m_enabled) {
for (auto const& mw : modes) { for (auto const& mw : modes) {
auto m = mw.lock(); auto m = mw.lock();
if (!m) if (!m)
continue; continue;
if (m->mode == pMonitor->currentMode) { if (m->mode == pMonitor->m_currentMode) {
if (m->mode) if (m->mode)
LOGM(LOG, " | sending current mode for {}: {}x{}@{}", pMonitor->szName, m->mode->pixelSize.x, m->mode->pixelSize.y, m->mode->refreshRate); LOGM(LOG, " | sending current mode for {}: {}x{}@{}", pMonitor->m_name, m->mode->pixelSize.x, m->mode->pixelSize.y, m->mode->refreshRate);
else else
LOGM(LOG, " | sending current mode for {}: null (fake)", pMonitor->szName); LOGM(LOG, " | sending current mode for {}: null (fake)", pMonitor->m_name);
resource->sendCurrentMode(m->resource.get()); resource->sendCurrentMode(m->resource.get());
break; break;
} }
@@ -290,7 +290,7 @@ COutputConfiguration::COutputConfiguration(SP<CZwlrOutputConfigurationV1> resour
heads.emplace_back(RESOURCE); heads.emplace_back(RESOURCE);
LOGM(LOG, "enableHead on {}. For now, doing nothing. Waiting for apply().", PMONITOR->szName); LOGM(LOG, "enableHead on {}. For now, doing nothing. Waiting for apply().", PMONITOR->m_name);
}); });
resource->setDisableHead([this](CZwlrOutputConfigurationV1* r, wl_resource* outputHead) { resource->setDisableHead([this](CZwlrOutputConfigurationV1* r, wl_resource* outputHead) {
@@ -308,17 +308,17 @@ COutputConfiguration::COutputConfiguration(SP<CZwlrOutputConfigurationV1> resour
return; return;
} }
LOGM(LOG, "disableHead on {}", PMONITOR->szName); LOGM(LOG, "disableHead on {}", PMONITOR->m_name);
SWlrManagerSavedOutputState newState; SWlrManagerSavedOutputState newState;
if (owner->monitorStates.contains(PMONITOR->szName)) if (owner->monitorStates.contains(PMONITOR->m_name))
newState = owner->monitorStates.at(PMONITOR->szName); newState = owner->monitorStates.at(PMONITOR->m_name);
newState.enabled = false; newState.enabled = false;
g_pConfigManager->m_wantsMonitorReload = true; g_pConfigManager->m_wantsMonitorReload = true;
owner->monitorStates[PMONITOR->szName] = newState; owner->monitorStates[PMONITOR->m_name] = newState;
}); });
resource->setTest([this](CZwlrOutputConfigurationV1* r) { resource->setTest([this](CZwlrOutputConfigurationV1* r) {
@@ -370,11 +370,11 @@ bool COutputConfiguration::applyTestConfiguration(bool test) {
if (!PMONITOR) if (!PMONITOR)
continue; continue;
LOGM(LOG, "Saving config for monitor {}", PMONITOR->szName); LOGM(LOG, "Saving config for monitor {}", PMONITOR->m_name);
SWlrManagerSavedOutputState newState; SWlrManagerSavedOutputState newState;
if (owner->monitorStates.contains(PMONITOR->szName)) if (owner->monitorStates.contains(PMONITOR->m_name))
newState = owner->monitorStates.at(PMONITOR->szName); newState = owner->monitorStates.at(PMONITOR->m_name);
newState.enabled = true; newState.enabled = true;
@@ -419,7 +419,7 @@ bool COutputConfiguration::applyTestConfiguration(bool test) {
g_pConfigManager->m_wantsMonitorReload = true; g_pConfigManager->m_wantsMonitorReload = true;
owner->monitorStates[PMONITOR->szName] = newState; owner->monitorStates[PMONITOR->m_name] = newState;
} }
LOGM(LOG, "Saved configuration"); LOGM(LOG, "Saved configuration");
@@ -454,7 +454,7 @@ COutputConfigurationHead::COutputConfigurationHead(SP<CZwlrOutputConfigurationHe
state.committedProperties |= OUTPUT_HEAD_COMMITTED_MODE; state.committedProperties |= OUTPUT_HEAD_COMMITTED_MODE;
state.mode = MODE; state.mode = MODE;
LOGM(LOG, " | configHead for {}: set mode to {}x{}@{}", pMonitor->szName, MODE->getMode()->pixelSize.x, MODE->getMode()->pixelSize.y, MODE->getMode()->refreshRate); LOGM(LOG, " | configHead for {}: set mode to {}x{}@{}", pMonitor->m_name, MODE->getMode()->pixelSize.x, MODE->getMode()->pixelSize.y, MODE->getMode()->refreshRate);
}); });
resource->setSetCustomMode([this](CZwlrOutputConfigurationHeadV1* r, int32_t w, int32_t h, int32_t refresh) { resource->setSetCustomMode([this](CZwlrOutputConfigurationHeadV1* r, int32_t w, int32_t h, int32_t refresh) {
@@ -474,14 +474,14 @@ COutputConfigurationHead::COutputConfigurationHead(SP<CZwlrOutputConfigurationHe
} }
if (refresh == 0) { if (refresh == 0) {
LOGM(LOG, " | configHead for {}: refreshRate 0, using old refresh rate of {:.2f}Hz", pMonitor->szName, pMonitor->refreshRate); LOGM(LOG, " | configHead for {}: refreshRate 0, using old refresh rate of {:.2f}Hz", pMonitor->m_name, pMonitor->m_refreshRate);
refresh = std::round(pMonitor->refreshRate * 1000.F); refresh = std::round(pMonitor->m_refreshRate * 1000.F);
} }
state.committedProperties |= OUTPUT_HEAD_COMMITTED_CUSTOM_MODE; state.committedProperties |= OUTPUT_HEAD_COMMITTED_CUSTOM_MODE;
state.customMode = {{w, h}, (uint32_t)refresh}; state.customMode = {{w, h}, (uint32_t)refresh};
LOGM(LOG, " | configHead for {}: set custom mode to {}x{}@{}", pMonitor->szName, w, h, refresh); LOGM(LOG, " | configHead for {}: set custom mode to {}x{}@{}", pMonitor->m_name, w, h, refresh);
}); });
resource->setSetPosition([this](CZwlrOutputConfigurationHeadV1* r, int32_t x, int32_t y) { resource->setSetPosition([this](CZwlrOutputConfigurationHeadV1* r, int32_t x, int32_t y) {
@@ -498,7 +498,7 @@ COutputConfigurationHead::COutputConfigurationHead(SP<CZwlrOutputConfigurationHe
state.committedProperties |= OUTPUT_HEAD_COMMITTED_POSITION; state.committedProperties |= OUTPUT_HEAD_COMMITTED_POSITION;
state.position = {x, y}; state.position = {x, y};
LOGM(LOG, " | configHead for {}: set pos to {}, {}", pMonitor->szName, x, y); LOGM(LOG, " | configHead for {}: set pos to {}, {}", pMonitor->m_name, x, y);
}); });
resource->setSetTransform([this](CZwlrOutputConfigurationHeadV1* r, int32_t transform) { resource->setSetTransform([this](CZwlrOutputConfigurationHeadV1* r, int32_t transform) {
@@ -520,7 +520,7 @@ COutputConfigurationHead::COutputConfigurationHead(SP<CZwlrOutputConfigurationHe
state.committedProperties |= OUTPUT_HEAD_COMMITTED_TRANSFORM; state.committedProperties |= OUTPUT_HEAD_COMMITTED_TRANSFORM;
state.transform = (wl_output_transform)transform; state.transform = (wl_output_transform)transform;
LOGM(LOG, " | configHead for {}: set transform to {}", pMonitor->szName, transform); LOGM(LOG, " | configHead for {}: set transform to {}", pMonitor->m_name, transform);
}); });
resource->setSetScale([this](CZwlrOutputConfigurationHeadV1* r, wl_fixed_t scale_) { resource->setSetScale([this](CZwlrOutputConfigurationHeadV1* r, wl_fixed_t scale_) {
@@ -544,7 +544,7 @@ COutputConfigurationHead::COutputConfigurationHead(SP<CZwlrOutputConfigurationHe
state.committedProperties |= OUTPUT_HEAD_COMMITTED_SCALE; state.committedProperties |= OUTPUT_HEAD_COMMITTED_SCALE;
state.scale = scale; state.scale = scale;
LOGM(LOG, " | configHead for {}: set scale to {:.2f}", pMonitor->szName, scale); LOGM(LOG, " | configHead for {}: set scale to {:.2f}", pMonitor->m_name, scale);
}); });
resource->setSetAdaptiveSync([this](CZwlrOutputConfigurationHeadV1* r, uint32_t as) { resource->setSetAdaptiveSync([this](CZwlrOutputConfigurationHeadV1* r, uint32_t as) {
@@ -566,7 +566,7 @@ COutputConfigurationHead::COutputConfigurationHead(SP<CZwlrOutputConfigurationHe
state.committedProperties |= OUTPUT_HEAD_COMMITTED_ADAPTIVE_SYNC; state.committedProperties |= OUTPUT_HEAD_COMMITTED_ADAPTIVE_SYNC;
state.adaptiveSync = as; state.adaptiveSync = as;
LOGM(LOG, " | configHead for {}: set adaptiveSync to {}", pMonitor->szName, as); LOGM(LOG, " | configHead for {}: set adaptiveSync to {}", pMonitor->m_name, as);
}); });
} }
@@ -638,10 +638,10 @@ SP<COutputMode> COutputManagementProtocol::modeFromResource(wl_resource* r) {
SP<SWlrManagerSavedOutputState> COutputManagementProtocol::getOutputStateFor(PHLMONITOR pMonitor) { SP<SWlrManagerSavedOutputState> COutputManagementProtocol::getOutputStateFor(PHLMONITOR pMonitor) {
for (auto const& m : m_vManagers) { for (auto const& m : m_vManagers) {
if (!m->monitorStates.contains(pMonitor->szName)) if (!m->monitorStates.contains(pMonitor->m_name))
continue; continue;
return makeShared<SWlrManagerSavedOutputState>(m->monitorStates.at(pMonitor->szName)); return makeShared<SWlrManagerSavedOutputState>(m->monitorStates.at(pMonitor->m_name));
} }
return nullptr; return nullptr;

20
src/protocols/OutputPower.cpp
View File

@@ -13,25 +13,25 @@ COutputPower::COutputPower(SP<CZwlrOutputPowerV1> resource_, PHLMONITOR pMonitor
if (!pMonitor) if (!pMonitor)
return; return;
pMonitor->dpmsStatus = mode == ZWLR_OUTPUT_POWER_V1_MODE_ON; pMonitor->m_dpmsStatus = mode == ZWLR_OUTPUT_POWER_V1_MODE_ON;
pMonitor->output->state->setEnabled(mode == ZWLR_OUTPUT_POWER_V1_MODE_ON); pMonitor->m_output->state->setEnabled(mode == ZWLR_OUTPUT_POWER_V1_MODE_ON);
if (!pMonitor->state.commit()) if (!pMonitor->m_state.commit())
LOGM(ERR, "Couldn't set dpms to {} for {}", pMonitor->dpmsStatus, pMonitor->szName); LOGM(ERR, "Couldn't set dpms to {} for {}", pMonitor->m_dpmsStatus, pMonitor->m_name);
}); });
resource->sendMode(pMonitor->dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); resource->sendMode(pMonitor->m_dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF);
listeners.monitorDestroy = pMonitor->events.destroy.registerListener([this](std::any v) { listeners.monitorDestroy = pMonitor->m_events.destroy.registerListener([this](std::any v) {
pMonitor.reset(); pMonitor.reset();
resource->sendFailed(); resource->sendFailed();
}); });
listeners.monitorDpms = pMonitor->events.dpmsChanged.registerListener( listeners.monitorDpms = pMonitor->m_events.dpmsChanged.registerListener(
[this](std::any v) { resource->sendMode(pMonitor->dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); }); [this](std::any v) { resource->sendMode(pMonitor->m_dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); });
listeners.monitorState = pMonitor->events.modeChanged.registerListener( listeners.monitorState = pMonitor->m_events.modeChanged.registerListener(
[this](std::any v) { resource->sendMode(pMonitor->dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); }); [this](std::any v) { resource->sendMode(pMonitor->m_dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); });
} }
bool COutputPower::good() { bool COutputPower::good() {

6
src/protocols/PresentationTime.cpp
View File

@@ -43,13 +43,13 @@ bool CPresentationFeedback::good() {
void CPresentationFeedback::sendQueued(SP<CQueuedPresentationData> data, const Time::steady_tp& when, uint32_t untilRefreshNs, uint64_t seq, uint32_t reportedFlags) { void CPresentationFeedback::sendQueued(SP<CQueuedPresentationData> data, const Time::steady_tp& when, uint32_t untilRefreshNs, uint64_t seq, uint32_t reportedFlags) {
auto client = resource->client(); auto client = resource->client();
if LIKELY (PROTO::outputs.contains(data->pMonitor->szName)) { if LIKELY (PROTO::outputs.contains(data->pMonitor->m_name)) {
if LIKELY (auto outputResource = PROTO::outputs.at(data->pMonitor->szName)->outputResourceFrom(client); outputResource) if LIKELY (auto outputResource = PROTO::outputs.at(data->pMonitor->m_name)->outputResourceFrom(client); outputResource)
resource->sendSyncOutput(outputResource->getResource()->resource()); resource->sendSyncOutput(outputResource->getResource()->resource());
} }
uint32_t flags = 0; uint32_t flags = 0;
if (!data->pMonitor->tearingState.activelyTearing) if (!data->pMonitor->m_tearingState.activelyTearing)
flags |= WP_PRESENTATION_FEEDBACK_KIND_VSYNC; flags |= WP_PRESENTATION_FEEDBACK_KIND_VSYNC;
if (data->zeroCopy) if (data->zeroCopy)
flags |= WP_PRESENTATION_FEEDBACK_KIND_ZERO_COPY; flags |= WP_PRESENTATION_FEEDBACK_KIND_ZERO_COPY;

26
src/protocols/Screencopy.cpp
View File

@@ -58,15 +58,15 @@ CScreencopyFrame::CScreencopyFrame(SP<CZwlrScreencopyFrameV1> resource_, int32_t
return; return;
} }
dmabufFormat = pMonitor->output->state->state().drmFormat; dmabufFormat = pMonitor->m_output->state->state().drmFormat;
if (box_.width == 0 && box_.height == 0) if (box_.width == 0 && box_.height == 0)
box = {0, 0, (int)(pMonitor->vecSize.x), (int)(pMonitor->vecSize.y)}; box = {0, 0, (int)(pMonitor->m_size.x), (int)(pMonitor->m_size.y)};
else { else {
box = box_; box = box_;
} }
box.transform(wlTransformToHyprutils(pMonitor->transform), pMonitor->vecTransformedSize.x, pMonitor->vecTransformedSize.y).scale(pMonitor->scale).round(); box.transform(wlTransformToHyprutils(pMonitor->m_transform), pMonitor->m_transformedSize.x, pMonitor->m_transformedSize.y).scale(pMonitor->m_scale).round();
shmStride = NFormatUtils::minStride(PSHMINFO, box.w); shmStride = NFormatUtils::minStride(PSHMINFO, box.w);
@@ -189,7 +189,7 @@ void CScreencopyFrame::share() {
void CScreencopyFrame::copyDmabuf(std::function<void(bool)> callback) { void CScreencopyFrame::copyDmabuf(std::function<void(bool)> callback) {
const auto PERM = g_pDynamicPermissionManager->clientPermissionMode(resource->client(), PERMISSION_TYPE_SCREENCOPY); const auto PERM = g_pDynamicPermissionManager->clientPermissionMode(resource->client(), PERMISSION_TYPE_SCREENCOPY);
auto TEXTURE = makeShared<CTexture>(pMonitor->output->state->state().buffer); auto TEXTURE = makeShared<CTexture>(pMonitor->m_output->state->state().buffer);
CRegion fakeDamage = {0, 0, INT16_MAX, INT16_MAX}; CRegion fakeDamage = {0, 0, INT16_MAX, INT16_MAX};
@@ -200,9 +200,9 @@ void CScreencopyFrame::copyDmabuf(std::function<void(bool)> callback) {
} }
if (PERM == PERMISSION_RULE_ALLOW_MODE_ALLOW) { if (PERM == PERMISSION_RULE_ALLOW_MODE_ALLOW) {
CBox monbox = CBox{0, 0, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y} CBox monbox = CBox{0, 0, pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y}
.translate({-box.x, -box.y}) // vvvv kinda ass-backwards but that's how I designed the renderer... sigh. .translate({-box.x, -box.y}) // vvvv kinda ass-backwards but that's how I designed the renderer... sigh.
.transform(wlTransformToHyprutils(invertTransform(pMonitor->transform)), pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y); .transform(wlTransformToHyprutils(invertTransform(pMonitor->m_transform)), pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y);
g_pHyprOpenGL->setMonitorTransformEnabled(true); g_pHyprOpenGL->setMonitorTransformEnabled(true);
g_pHyprOpenGL->setRenderModifEnabled(false); g_pHyprOpenGL->setRenderModifEnabled(false);
g_pHyprOpenGL->renderTexture(TEXTURE, monbox, 1); g_pHyprOpenGL->renderTexture(TEXTURE, monbox, 1);
@@ -210,13 +210,13 @@ void CScreencopyFrame::copyDmabuf(std::function<void(bool)> callback) {
g_pHyprOpenGL->setMonitorTransformEnabled(false); g_pHyprOpenGL->setMonitorTransformEnabled(false);
if (overlayCursor) if (overlayCursor)
g_pPointerManager->renderSoftwareCursorsFor(pMonitor.lock(), Time::steadyNow(), fakeDamage, g_pPointerManager->renderSoftwareCursorsFor(pMonitor.lock(), Time::steadyNow(), fakeDamage,
g_pInputManager->getMouseCoordsInternal() - pMonitor->vecPosition - box.pos(), true); g_pInputManager->getMouseCoordsInternal() - pMonitor->m_position - box.pos(), true);
} else if (PERM == PERMISSION_RULE_ALLOW_MODE_PENDING) } else if (PERM == PERMISSION_RULE_ALLOW_MODE_PENDING)
g_pHyprOpenGL->clear(Colors::BLACK); g_pHyprOpenGL->clear(Colors::BLACK);
else { else {
g_pHyprOpenGL->clear(Colors::BLACK); g_pHyprOpenGL->clear(Colors::BLACK);
CBox texbox = CBox texbox =
CBox{pMonitor->vecTransformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F); CBox{pMonitor->m_transformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F);
g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pScreencopyDeniedTexture, texbox, 1); g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pScreencopyDeniedTexture, texbox, 1);
} }
@@ -230,7 +230,7 @@ void CScreencopyFrame::copyDmabuf(std::function<void(bool)> callback) {
bool CScreencopyFrame::copyShm() { bool CScreencopyFrame::copyShm() {
const auto PERM = g_pDynamicPermissionManager->clientPermissionMode(resource->client(), PERMISSION_TYPE_SCREENCOPY); const auto PERM = g_pDynamicPermissionManager->clientPermissionMode(resource->client(), PERMISSION_TYPE_SCREENCOPY);
auto TEXTURE = makeShared<CTexture>(pMonitor->output->state->state().buffer); auto TEXTURE = makeShared<CTexture>(pMonitor->m_output->state->state().buffer);
auto shm = buffer->shm(); auto shm = buffer->shm();
auto [pixelData, fmt, bufLen] = buffer->beginDataPtr(0); // no need for end, cuz it's shm auto [pixelData, fmt, bufLen] = buffer->beginDataPtr(0); // no need for end, cuz it's shm
@@ -240,7 +240,7 @@ bool CScreencopyFrame::copyShm() {
g_pHyprRenderer->makeEGLCurrent(); g_pHyprRenderer->makeEGLCurrent();
CFramebuffer fb; CFramebuffer fb;
fb.alloc(box.w, box.h, pMonitor->output->state->state().drmFormat); fb.alloc(box.w, box.h, pMonitor->m_output->state->state().drmFormat);
if (!g_pHyprRenderer->beginRender(pMonitor.lock(), fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, &fb, true)) { if (!g_pHyprRenderer->beginRender(pMonitor.lock(), fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, &fb, true)) {
LOGM(ERR, "Can't copy: failed to begin rendering"); LOGM(ERR, "Can't copy: failed to begin rendering");
@@ -248,7 +248,7 @@ bool CScreencopyFrame::copyShm() {
} }
if (PERM == PERMISSION_RULE_ALLOW_MODE_ALLOW) { if (PERM == PERMISSION_RULE_ALLOW_MODE_ALLOW) {
CBox monbox = CBox{0, 0, pMonitor->vecTransformedSize.x, pMonitor->vecTransformedSize.y}.translate({-box.x, -box.y}); CBox monbox = CBox{0, 0, pMonitor->m_transformedSize.x, pMonitor->m_transformedSize.y}.translate({-box.x, -box.y});
g_pHyprOpenGL->setMonitorTransformEnabled(true); g_pHyprOpenGL->setMonitorTransformEnabled(true);
g_pHyprOpenGL->setRenderModifEnabled(false); g_pHyprOpenGL->setRenderModifEnabled(false);
g_pHyprOpenGL->renderTexture(TEXTURE, monbox, 1); g_pHyprOpenGL->renderTexture(TEXTURE, monbox, 1);
@@ -256,13 +256,13 @@ bool CScreencopyFrame::copyShm() {
g_pHyprOpenGL->setMonitorTransformEnabled(false); g_pHyprOpenGL->setMonitorTransformEnabled(false);
if (overlayCursor) if (overlayCursor)
g_pPointerManager->renderSoftwareCursorsFor(pMonitor.lock(), Time::steadyNow(), fakeDamage, g_pPointerManager->renderSoftwareCursorsFor(pMonitor.lock(), Time::steadyNow(), fakeDamage,
g_pInputManager->getMouseCoordsInternal() - pMonitor->vecPosition - box.pos(), true); g_pInputManager->getMouseCoordsInternal() - pMonitor->m_position - box.pos(), true);
} else if (PERM == PERMISSION_RULE_ALLOW_MODE_PENDING) } else if (PERM == PERMISSION_RULE_ALLOW_MODE_PENDING)
g_pHyprOpenGL->clear(Colors::BLACK); g_pHyprOpenGL->clear(Colors::BLACK);
else { else {
g_pHyprOpenGL->clear(Colors::BLACK); g_pHyprOpenGL->clear(Colors::BLACK);
CBox texbox = CBox texbox =
CBox{pMonitor->vecTransformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F); CBox{pMonitor->m_transformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F);
g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pScreencopyDeniedTexture, texbox, 1); g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pScreencopyDeniedTexture, texbox, 1);
} }

6
src/protocols/SessionLock.cpp
View File

@@ -56,11 +56,11 @@ CSessionLockSurface::CSessionLockSurface(SP<CExtSessionLockSurfaceV1> resource_,
pSurface.reset(); pSurface.reset();
}); });
PROTO::fractional->sendScale(surface_, pMonitor_->scale); PROTO::fractional->sendScale(surface_, pMonitor_->m_scale);
sendConfigure(); sendConfigure();
listeners.monitorMode = pMonitor->events.modeChanged.registerListener([this](std::any data) { sendConfigure(); }); listeners.monitorMode = pMonitor->m_events.modeChanged.registerListener([this](std::any data) { sendConfigure(); });
} }
CSessionLockSurface::~CSessionLockSurface() { CSessionLockSurface::~CSessionLockSurface() {
@@ -73,7 +73,7 @@ CSessionLockSurface::~CSessionLockSurface() {
void CSessionLockSurface::sendConfigure() { void CSessionLockSurface::sendConfigure() {
const auto SERIAL = g_pSeatManager->nextSerial(g_pSeatManager->seatResourceForClient(resource->client())); const auto SERIAL = g_pSeatManager->nextSerial(g_pSeatManager->seatResourceForClient(resource->client()));
resource->sendConfigure(SERIAL, pMonitor->vecSize.x, pMonitor->vecSize.y); resource->sendConfigure(SERIAL, pMonitor->m_size.x, pMonitor->m_size.y);
} }
bool CSessionLockSurface::good() { bool CSessionLockSurface::good() {

46
src/protocols/ToplevelExport.cpp
View File

@@ -114,11 +114,11 @@ CToplevelExportFrame::CToplevelExportFrame(SP<CHyprlandToplevelExportFrameV1> re
return; return;
} }
dmabufFormat = PMONITOR->output->state->state().drmFormat; dmabufFormat = PMONITOR->m_output->state->state().drmFormat;
box = {0, 0, (int)(pWindow->m_realSize->value().x * PMONITOR->scale), (int)(pWindow->m_realSize->value().y * PMONITOR->scale)}; box = {0, 0, (int)(pWindow->m_realSize->value().x * PMONITOR->m_scale), (int)(pWindow->m_realSize->value().y * PMONITOR->m_scale)};
box.transform(wlTransformToHyprutils(PMONITOR->transform), PMONITOR->vecTransformedSize.x, PMONITOR->vecTransformedSize.y).round(); box.transform(wlTransformToHyprutils(PMONITOR->m_transform), PMONITOR->m_transformedSize.x, PMONITOR->m_transformedSize.y).round();
shmStride = NFormatUtils::minStride(PSHMINFO, box.w); shmStride = NFormatUtils::minStride(PSHMINFO, box.w);
@@ -236,18 +236,18 @@ bool CToplevelExportFrame::copyShm(const Time::steady_tp& now) {
// render the client // render the client
const auto PMONITOR = pWindow->m_monitor.lock(); const auto PMONITOR = pWindow->m_monitor.lock();
CRegion fakeDamage{0, 0, PMONITOR->vecPixelSize.x * 10, PMONITOR->vecPixelSize.y * 10}; CRegion fakeDamage{0, 0, PMONITOR->m_pixelSize.x * 10, PMONITOR->m_pixelSize.y * 10};
g_pHyprRenderer->makeEGLCurrent(); g_pHyprRenderer->makeEGLCurrent();
CFramebuffer outFB; CFramebuffer outFB;
outFB.alloc(PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, PMONITOR->output->state->state().drmFormat); outFB.alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, PMONITOR->m_output->state->state().drmFormat);
auto overlayCursor = shouldOverlayCursor(); auto overlayCursor = shouldOverlayCursor();
if (overlayCursor) { if (overlayCursor) {
g_pPointerManager->lockSoftwareForMonitor(PMONITOR->self.lock()); g_pPointerManager->lockSoftwareForMonitor(PMONITOR->m_self.lock());
g_pPointerManager->damageCursor(PMONITOR->self.lock()); g_pPointerManager->damageCursor(PMONITOR->m_self.lock());
} }
if (!g_pHyprRenderer->beginRender(PMONITOR, fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, &outFB)) if (!g_pHyprRenderer->beginRender(PMONITOR, fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, &outFB))
@@ -262,10 +262,10 @@ bool CToplevelExportFrame::copyShm(const Time::steady_tp& now) {
g_pHyprRenderer->m_bBlockSurfaceFeedback = false; g_pHyprRenderer->m_bBlockSurfaceFeedback = false;
if (overlayCursor) if (overlayCursor)
g_pPointerManager->renderSoftwareCursorsFor(PMONITOR->self.lock(), now, fakeDamage, g_pInputManager->getMouseCoordsInternal() - pWindow->m_realPosition->value()); g_pPointerManager->renderSoftwareCursorsFor(PMONITOR->m_self.lock(), now, fakeDamage, g_pInputManager->getMouseCoordsInternal() - pWindow->m_realPosition->value());
} else if (PERM == PERMISSION_RULE_ALLOW_MODE_DENY) { } else if (PERM == PERMISSION_RULE_ALLOW_MODE_DENY) {
CBox texbox = CBox texbox =
CBox{PMONITOR->vecTransformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F); CBox{PMONITOR->m_transformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F);
g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pScreencopyDeniedTexture, texbox, 1); g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pScreencopyDeniedTexture, texbox, 1);
} }
@@ -291,21 +291,21 @@ bool CToplevelExportFrame::copyShm(const Time::steady_tp& now) {
auto glFormat = PFORMAT->flipRB ? GL_BGRA_EXT : GL_RGBA; auto glFormat = PFORMAT->flipRB ? GL_BGRA_EXT : GL_RGBA;
auto origin = Vector2D(0, 0); auto origin = Vector2D(0, 0);
switch (PMONITOR->transform) { switch (PMONITOR->m_transform) {
case WL_OUTPUT_TRANSFORM_FLIPPED_180: case WL_OUTPUT_TRANSFORM_FLIPPED_180:
case WL_OUTPUT_TRANSFORM_90: { case WL_OUTPUT_TRANSFORM_90: {
origin.y = PMONITOR->vecPixelSize.y - box.height; origin.y = PMONITOR->m_pixelSize.y - box.height;
break; break;
} }
case WL_OUTPUT_TRANSFORM_FLIPPED_270: case WL_OUTPUT_TRANSFORM_FLIPPED_270:
case WL_OUTPUT_TRANSFORM_180: { case WL_OUTPUT_TRANSFORM_180: {
origin.x = PMONITOR->vecPixelSize.x - box.width; origin.x = PMONITOR->m_pixelSize.x - box.width;
origin.y = PMONITOR->vecPixelSize.y - box.height; origin.y = PMONITOR->m_pixelSize.y - box.height;
break; break;
} }
case WL_OUTPUT_TRANSFORM_FLIPPED: case WL_OUTPUT_TRANSFORM_FLIPPED:
case WL_OUTPUT_TRANSFORM_270: { case WL_OUTPUT_TRANSFORM_270: {
origin.x = PMONITOR->vecPixelSize.x - box.width; origin.x = PMONITOR->m_pixelSize.x - box.width;
break; break;
} }
default: break; default: break;
@@ -314,8 +314,8 @@ bool CToplevelExportFrame::copyShm(const Time::steady_tp& now) {
glReadPixels(origin.x, origin.y, box.width, box.height, glFormat, PFORMAT->glType, pixelData); glReadPixels(origin.x, origin.y, box.width, box.height, glFormat, PFORMAT->glType, pixelData);
if (overlayCursor) { if (overlayCursor) {
g_pPointerManager->unlockSoftwareForMonitor(PMONITOR->self.lock()); g_pPointerManager->unlockSoftwareForMonitor(PMONITOR->m_self.lock());
g_pPointerManager->damageCursor(PMONITOR->self.lock()); g_pPointerManager->damageCursor(PMONITOR->m_self.lock());
} }
outFB.unbind(); outFB.unbind();
@@ -336,8 +336,8 @@ bool CToplevelExportFrame::copyDmabuf(const Time::steady_tp& now) {
auto overlayCursor = shouldOverlayCursor(); auto overlayCursor = shouldOverlayCursor();
if (overlayCursor) { if (overlayCursor) {
g_pPointerManager->lockSoftwareForMonitor(PMONITOR->self.lock()); g_pPointerManager->lockSoftwareForMonitor(PMONITOR->m_self.lock());
g_pPointerManager->damageCursor(PMONITOR->self.lock()); g_pPointerManager->damageCursor(PMONITOR->m_self.lock());
} }
if (!g_pHyprRenderer->beginRender(PMONITOR, fakeDamage, RENDER_MODE_TO_BUFFER, buffer.buffer)) if (!g_pHyprRenderer->beginRender(PMONITOR, fakeDamage, RENDER_MODE_TO_BUFFER, buffer.buffer))
@@ -350,10 +350,10 @@ bool CToplevelExportFrame::copyDmabuf(const Time::steady_tp& now) {
g_pHyprRenderer->m_bBlockSurfaceFeedback = false; g_pHyprRenderer->m_bBlockSurfaceFeedback = false;
if (overlayCursor) if (overlayCursor)
g_pPointerManager->renderSoftwareCursorsFor(PMONITOR->self.lock(), now, fakeDamage, g_pInputManager->getMouseCoordsInternal() - pWindow->m_realPosition->value()); g_pPointerManager->renderSoftwareCursorsFor(PMONITOR->m_self.lock(), now, fakeDamage, g_pInputManager->getMouseCoordsInternal() - pWindow->m_realPosition->value());
} else if (PERM == PERMISSION_RULE_ALLOW_MODE_DENY) { } else if (PERM == PERMISSION_RULE_ALLOW_MODE_DENY) {
CBox texbox = CBox texbox =
CBox{PMONITOR->vecTransformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F); CBox{PMONITOR->m_transformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F);
g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pScreencopyDeniedTexture, texbox, 1); g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pScreencopyDeniedTexture, texbox, 1);
} }
@@ -361,8 +361,8 @@ bool CToplevelExportFrame::copyDmabuf(const Time::steady_tp& now) {
g_pHyprRenderer->endRender(); g_pHyprRenderer->endRender();
if (overlayCursor) { if (overlayCursor) {
g_pPointerManager->unlockSoftwareForMonitor(PMONITOR->self.lock()); g_pPointerManager->unlockSoftwareForMonitor(PMONITOR->m_self.lock());
g_pPointerManager->damageCursor(PMONITOR->self.lock()); g_pPointerManager->damageCursor(PMONITOR->m_self.lock());
} }
return true; return true;
@@ -450,7 +450,7 @@ void CToplevelExportProtocol::onOutputCommit(PHLMONITOR pMonitor) {
CBox geometry = {PWINDOW->m_realPosition->value().x, PWINDOW->m_realPosition->value().y, PWINDOW->m_realSize->value().x, PWINDOW->m_realSize->value().y}; CBox geometry = {PWINDOW->m_realPosition->value().x, PWINDOW->m_realPosition->value().y, PWINDOW->m_realSize->value().x, PWINDOW->m_realSize->value().y};
if (geometry.intersection({pMonitor->vecPosition, pMonitor->vecSize}).empty()) if (geometry.intersection({pMonitor->m_position, pMonitor->m_size}).empty())
continue; continue;
f->share(); f->share();

14
src/protocols/XDGOutput.cpp
View File

@@ -65,14 +65,14 @@ void CXDGOutputProtocol::onManagerGetXDGOutput(CZxdgOutputManagerV1* mgr, uint32
return; return;
} }
LOGM(LOG, "New xdg_output for {}: client {:x} ({})", PMONITOR->szName, (uintptr_t)CLIENT, pXDGOutput->isXWayland ? "xwayland" : "not xwayland"); LOGM(LOG, "New xdg_output for {}: client {:x} ({})", PMONITOR->m_name, (uintptr_t)CLIENT, pXDGOutput->isXWayland ? "xwayland" : "not xwayland");
const auto XDGVER = pXDGOutput->resource->version(); const auto XDGVER = pXDGOutput->resource->version();
if (XDGVER >= OUTPUT_NAME_SINCE_VERSION) if (XDGVER >= OUTPUT_NAME_SINCE_VERSION)
pXDGOutput->resource->sendName(PMONITOR->szName.c_str()); pXDGOutput->resource->sendName(PMONITOR->m_name.c_str());
if (XDGVER >= OUTPUT_DESCRIPTION_SINCE_VERSION && !PMONITOR->output->description.empty()) if (XDGVER >= OUTPUT_DESCRIPTION_SINCE_VERSION && !PMONITOR->m_output->description.empty())
pXDGOutput->resource->sendDescription(PMONITOR->output->description.c_str()); pXDGOutput->resource->sendDescription(PMONITOR->m_output->description.c_str());
pXDGOutput->sendDetails(); pXDGOutput->sendDetails();
@@ -110,13 +110,13 @@ void CXDGOutput::sendDetails() {
if UNLIKELY (!monitor || !outputProto || outputProto->isDefunct()) if UNLIKELY (!monitor || !outputProto || outputProto->isDefunct())
return; return;
const auto POS = isXWayland ? monitor->vecXWaylandPosition : monitor->vecPosition; const auto POS = isXWayland ? monitor->m_xwaylandPosition : monitor->m_position;
resource->sendLogicalPosition(POS.x, POS.y); resource->sendLogicalPosition(POS.x, POS.y);
if (*PXWLFORCESCALEZERO && isXWayland) if (*PXWLFORCESCALEZERO && isXWayland)
resource->sendLogicalSize(monitor->vecTransformedSize.x, monitor->vecTransformedSize.y); resource->sendLogicalSize(monitor->m_transformedSize.x, monitor->m_transformedSize.y);
else else
resource->sendLogicalSize(monitor->vecSize.x, monitor->vecSize.y); resource->sendLogicalSize(monitor->m_size.x, monitor->m_size.y);
if (resource->version() < OUTPUT_DONE_DEPRECATED_SINCE_VERSION) if (resource->version() < OUTPUT_DONE_DEPRECATED_SINCE_VERSION)
resource->sendDone(); resource->sendDone();

2
src/protocols/XDGShell.cpp
View File

@@ -196,7 +196,7 @@ CXDGToplevelResource::CXDGToplevelResource(SP<CXdgToplevel> resource_, SP<CXDGSu
resource->setSetFullscreen([this](CXdgToplevel* r, wl_resource* output) { resource->setSetFullscreen([this](CXdgToplevel* r, wl_resource* output) {
if (output) if (output)
if (const auto PM = CWLOutputResource::fromResource(output)->monitor; PM) if (const auto PM = CWLOutputResource::fromResource(output)->monitor; PM)
state.requestsFullscreenMonitor = PM->ID; state.requestsFullscreenMonitor = PM->m_id;
state.requestsFullscreen = true; state.requestsFullscreen = true;
events.stateChanged.emit(); events.stateChanged.emit();

12
src/protocols/core/Compositor.cpp
View File

@@ -271,21 +271,21 @@ void CWLSurfaceResource::enter(PHLMONITOR monitor) {
if (std::find(enteredOutputs.begin(), enteredOutputs.end(), monitor) != enteredOutputs.end()) if (std::find(enteredOutputs.begin(), enteredOutputs.end(), monitor) != enteredOutputs.end())
return; return;
if UNLIKELY (!PROTO::outputs.contains(monitor->szName)) { if UNLIKELY (!PROTO::outputs.contains(monitor->m_name)) {
// can happen on unplug/replug // can happen on unplug/replug
LOGM(ERR, "enter() called on a non-existent output global"); LOGM(ERR, "enter() called on a non-existent output global");
return; return;
} }
if UNLIKELY (PROTO::outputs.at(monitor->szName)->isDefunct()) { if UNLIKELY (PROTO::outputs.at(monitor->m_name)->isDefunct()) {
LOGM(ERR, "enter() called on a defunct output global"); LOGM(ERR, "enter() called on a defunct output global");
return; return;
} }
auto output = PROTO::outputs.at(monitor->szName)->outputResourceFrom(pClient); auto output = PROTO::outputs.at(monitor->m_name)->outputResourceFrom(pClient);
if UNLIKELY (!output || !output->getResource() || !output->getResource()->resource()) { if UNLIKELY (!output || !output->getResource() || !output->getResource()->resource()) {
LOGM(ERR, "Cannot enter surface {:x} to {}, client hasn't bound the output", (uintptr_t)this, monitor->szName); LOGM(ERR, "Cannot enter surface {:x} to {}, client hasn't bound the output", (uintptr_t)this, monitor->m_name);
return; return;
} }
@@ -298,10 +298,10 @@ void CWLSurfaceResource::leave(PHLMONITOR monitor) {
if UNLIKELY (std::find(enteredOutputs.begin(), enteredOutputs.end(), monitor) == enteredOutputs.end()) if UNLIKELY (std::find(enteredOutputs.begin(), enteredOutputs.end(), monitor) == enteredOutputs.end())
return; return;
auto output = PROTO::outputs.at(monitor->szName)->outputResourceFrom(pClient); auto output = PROTO::outputs.at(monitor->m_name)->outputResourceFrom(pClient);
if UNLIKELY (!output) { if UNLIKELY (!output) {
LOGM(ERR, "Cannot leave surface {:x} from {}, client hasn't bound the output", (uintptr_t)this, monitor->szName); LOGM(ERR, "Cannot leave surface {:x} from {}, client hasn't bound the output", (uintptr_t)this, monitor->m_name);
return; return;
} }

2
src/protocols/core/DataDevice.cpp
View File

@@ -809,7 +809,7 @@ void CWLDataDeviceProtocol::renderDND(PHLMONITOR pMonitor, const Time::steady_tp
surfacePos += dnd.dndSurface->current.offset; surfacePos += dnd.dndSurface->current.offset;
CBox box = CBox{surfacePos, dnd.dndSurface->current.size}.translate(-pMonitor->vecPosition).scale(pMonitor->scale); CBox box = CBox{surfacePos, dnd.dndSurface->current.size}.translate(-pMonitor->m_position).scale(pMonitor->m_scale);
CTexPassElement::SRenderData data; CTexPassElement::SRenderData data;
data.tex = dnd.dndSurface->current.texture; data.tex = dnd.dndSurface->current.texture;

24
src/protocols/core/Output.cpp
View File

@@ -15,17 +15,17 @@ CWLOutputResource::CWLOutputResource(SP<CWlOutput> resource_, PHLMONITOR pMonito
return; return;
resource->setOnDestroy([this](CWlOutput* r) { resource->setOnDestroy([this](CWlOutput* r) {
if (monitor && PROTO::outputs.contains(monitor->szName)) if (monitor && PROTO::outputs.contains(monitor->m_name))
PROTO::outputs.at(monitor->szName)->destroyResource(this); PROTO::outputs.at(monitor->m_name)->destroyResource(this);
}); });
resource->setRelease([this](CWlOutput* r) { resource->setRelease([this](CWlOutput* r) {
if (monitor && PROTO::outputs.contains(monitor->szName)) if (monitor && PROTO::outputs.contains(monitor->m_name))
PROTO::outputs.at(monitor->szName)->destroyResource(this); PROTO::outputs.at(monitor->m_name)->destroyResource(this);
}); });
if (resource->version() >= 4) { if (resource->version() >= 4) {
resource->sendName(monitor->szName.c_str()); resource->sendName(monitor->m_name.c_str());
resource->sendDescription(monitor->szDescription.c_str()); resource->sendDescription(monitor->m_description.c_str());
} }
updateState(); updateState();
@@ -72,21 +72,21 @@ void CWLOutputResource::updateState() {
return; return;
if (resource->version() >= 2) if (resource->version() >= 2)
resource->sendScale(std::ceil(monitor->scale)); resource->sendScale(std::ceil(monitor->m_scale));
resource->sendMode((wl_output_mode)(WL_OUTPUT_MODE_CURRENT), monitor->vecPixelSize.x, monitor->vecPixelSize.y, monitor->refreshRate * 1000.0); resource->sendMode((wl_output_mode)(WL_OUTPUT_MODE_CURRENT), monitor->m_pixelSize.x, monitor->m_pixelSize.y, monitor->m_refreshRate * 1000.0);
resource->sendGeometry(0, 0, monitor->output->physicalSize.x, monitor->output->physicalSize.y, (wl_output_subpixel)monitor->output->subpixel, monitor->output->make.c_str(), resource->sendGeometry(0, 0, monitor->m_output->physicalSize.x, monitor->m_output->physicalSize.y, (wl_output_subpixel)monitor->m_output->subpixel,
monitor->output->model.c_str(), monitor->transform); monitor->m_output->make.c_str(), monitor->m_output->model.c_str(), monitor->m_transform);
if (resource->version() >= 2) if (resource->version() >= 2)
resource->sendDone(); resource->sendDone();
} }
CWLOutputProtocol::CWLOutputProtocol(const wl_interface* iface, const int& ver, const std::string& name, PHLMONITOR pMonitor) : CWLOutputProtocol::CWLOutputProtocol(const wl_interface* iface, const int& ver, const std::string& name, PHLMONITOR pMonitor) :
IWaylandProtocol(iface, ver, name), monitor(pMonitor), szName(pMonitor->szName) { IWaylandProtocol(iface, ver, name), monitor(pMonitor), szName(pMonitor->m_name) {
listeners.modeChanged = monitor->events.modeChanged.registerListener([this](std::any d) { listeners.modeChanged = monitor->m_events.modeChanged.registerListener([this](std::any d) {
for (auto const& o : m_vOutputs) { for (auto const& o : m_vOutputs) {
o->updateState(); o->updateState();
} }

2
src/render/Framebuffer.cpp
View File

@@ -85,7 +85,7 @@ void CFramebuffer::bind() {
#endif #endif
if (g_pHyprOpenGL) if (g_pHyprOpenGL)
glViewport(0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->vecPixelSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->vecPixelSize.y); glViewport(0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->m_pixelSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->m_pixelSize.y);
else else
glViewport(0, 0, m_vSize.x, m_vSize.y); glViewport(0, 0, m_vSize.x, m_vSize.y);
} }

235
src/render/OpenGL.cpp
View File

@@ -688,14 +688,14 @@ void CHyprOpenGLImpl::beginSimple(PHLMONITOR pMonitor, const CRegion& damage, SP
const auto FBO = rb ? rb->getFB() : fb; const auto FBO = rb ? rb->getFB() : fb;
glViewport(0, 0, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y); glViewport(0, 0, pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y);
m_RenderData.projection = Mat3x3::outputProjection(pMonitor->vecPixelSize, HYPRUTILS_TRANSFORM_NORMAL); m_RenderData.projection = Mat3x3::outputProjection(pMonitor->m_pixelSize, HYPRUTILS_TRANSFORM_NORMAL);
m_RenderData.monitorProjection = Mat3x3::identity(); m_RenderData.monitorProjection = Mat3x3::identity();
if (pMonitor->transform != WL_OUTPUT_TRANSFORM_NORMAL) { if (pMonitor->m_transform != WL_OUTPUT_TRANSFORM_NORMAL) {
const Vector2D tfmd = pMonitor->transform % 2 == 1 ? Vector2D{FBO->m_vSize.y, FBO->m_vSize.x} : FBO->m_vSize; const Vector2D tfmd = pMonitor->m_transform % 2 == 1 ? Vector2D{FBO->m_vSize.y, FBO->m_vSize.x} : FBO->m_vSize;
m_RenderData.monitorProjection.translate(FBO->m_vSize / 2.0).transform(wlTransformToHyprutils(pMonitor->transform)).translate(-tfmd / 2.0); m_RenderData.monitorProjection.translate(FBO->m_vSize / 2.0).transform(wlTransformToHyprutils(pMonitor->m_transform)).translate(-tfmd / 2.0);
} }
m_RenderData.pCurrentMonData = &m_mMonitorRenderResources[pMonitor]; m_RenderData.pCurrentMonData = &m_mMonitorRenderResources[pMonitor];
@@ -738,13 +738,13 @@ void CHyprOpenGLImpl::begin(PHLMONITOR pMonitor, const CRegion& damage_, CFrameb
TRACY_GPU_ZONE("RenderBegin"); TRACY_GPU_ZONE("RenderBegin");
glViewport(0, 0, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y); glViewport(0, 0, pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y);
m_RenderData.projection = Mat3x3::outputProjection(pMonitor->vecPixelSize, HYPRUTILS_TRANSFORM_NORMAL); m_RenderData.projection = Mat3x3::outputProjection(pMonitor->m_pixelSize, HYPRUTILS_TRANSFORM_NORMAL);
m_RenderData.monitorProjection = pMonitor->projMatrix; m_RenderData.monitorProjection = pMonitor->m_projMatrix;
if (m_mMonitorRenderResources.contains(pMonitor) && m_mMonitorRenderResources.at(pMonitor).offloadFB.m_vSize != pMonitor->vecPixelSize) if (m_mMonitorRenderResources.contains(pMonitor) && m_mMonitorRenderResources.at(pMonitor).offloadFB.m_vSize != pMonitor->m_pixelSize)
destroyMonitorResources(pMonitor); destroyMonitorResources(pMonitor);
m_RenderData.pCurrentMonData = &m_mMonitorRenderResources[pMonitor]; m_RenderData.pCurrentMonData = &m_mMonitorRenderResources[pMonitor];
@@ -753,19 +753,19 @@ void CHyprOpenGLImpl::begin(PHLMONITOR pMonitor, const CRegion& damage_, CFrameb
initShaders(); initShaders();
// ensure a framebuffer for the monitor exists // ensure a framebuffer for the monitor exists
if (m_RenderData.pCurrentMonData->offloadFB.m_vSize != pMonitor->vecPixelSize) { if (m_RenderData.pCurrentMonData->offloadFB.m_vSize != pMonitor->m_pixelSize) {
m_RenderData.pCurrentMonData->stencilTex->allocate(); m_RenderData.pCurrentMonData->stencilTex->allocate();
m_RenderData.pCurrentMonData->offloadFB.alloc(pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y, pMonitor->output->state->state().drmFormat); m_RenderData.pCurrentMonData->offloadFB.alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, pMonitor->m_output->state->state().drmFormat);
m_RenderData.pCurrentMonData->mirrorFB.alloc(pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y, pMonitor->output->state->state().drmFormat); m_RenderData.pCurrentMonData->mirrorFB.alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, pMonitor->m_output->state->state().drmFormat);
m_RenderData.pCurrentMonData->mirrorSwapFB.alloc(pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y, pMonitor->output->state->state().drmFormat); m_RenderData.pCurrentMonData->mirrorSwapFB.alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, pMonitor->m_output->state->state().drmFormat);
m_RenderData.pCurrentMonData->offloadFB.addStencil(m_RenderData.pCurrentMonData->stencilTex); m_RenderData.pCurrentMonData->offloadFB.addStencil(m_RenderData.pCurrentMonData->stencilTex);
m_RenderData.pCurrentMonData->mirrorFB.addStencil(m_RenderData.pCurrentMonData->stencilTex); m_RenderData.pCurrentMonData->mirrorFB.addStencil(m_RenderData.pCurrentMonData->stencilTex);
m_RenderData.pCurrentMonData->mirrorSwapFB.addStencil(m_RenderData.pCurrentMonData->stencilTex); m_RenderData.pCurrentMonData->mirrorSwapFB.addStencil(m_RenderData.pCurrentMonData->stencilTex);
} }
if (m_RenderData.pCurrentMonData->monitorMirrorFB.isAllocated() && m_RenderData.pMonitor->mirrors.empty()) if (m_RenderData.pCurrentMonData->monitorMirrorFB.isAllocated() && m_RenderData.pMonitor->m_mirrors.empty())
m_RenderData.pCurrentMonData->monitorMirrorFB.release(); m_RenderData.pCurrentMonData->monitorMirrorFB.release();
m_RenderData.damage.set(damage_); m_RenderData.damage.set(damage_);
@@ -797,23 +797,23 @@ void CHyprOpenGLImpl::end() {
m_RenderData.damage = m_RenderData.finalDamage; m_RenderData.damage = m_RenderData.finalDamage;
m_bEndFrame = true; m_bEndFrame = true;
CBox monbox = {0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y}; CBox monbox = {0, 0, m_RenderData.pMonitor->m_transformedSize.x, m_RenderData.pMonitor->m_transformedSize.y};
if (m_RenderData.mouseZoomFactor != 1.f) { if (m_RenderData.mouseZoomFactor != 1.f) {
const auto ZOOMCENTER = m_RenderData.mouseZoomUseMouse ? const auto ZOOMCENTER = m_RenderData.mouseZoomUseMouse ?
(g_pInputManager->getMouseCoordsInternal() - m_RenderData.pMonitor->vecPosition) * m_RenderData.pMonitor->scale : (g_pInputManager->getMouseCoordsInternal() - m_RenderData.pMonitor->m_position) * m_RenderData.pMonitor->m_scale :
m_RenderData.pMonitor->vecTransformedSize / 2.f; m_RenderData.pMonitor->m_transformedSize / 2.f;
monbox.translate(-ZOOMCENTER).scale(m_RenderData.mouseZoomFactor).translate(*PZOOMRIGID ? m_RenderData.pMonitor->vecTransformedSize / 2.0 : ZOOMCENTER); monbox.translate(-ZOOMCENTER).scale(m_RenderData.mouseZoomFactor).translate(*PZOOMRIGID ? m_RenderData.pMonitor->m_transformedSize / 2.0 : ZOOMCENTER);
if (monbox.x > 0) if (monbox.x > 0)
monbox.x = 0; monbox.x = 0;
if (monbox.y > 0) if (monbox.y > 0)
monbox.y = 0; monbox.y = 0;
if (monbox.x + monbox.width < m_RenderData.pMonitor->vecTransformedSize.x) if (monbox.x + monbox.width < m_RenderData.pMonitor->m_transformedSize.x)
monbox.x = m_RenderData.pMonitor->vecTransformedSize.x - monbox.width; monbox.x = m_RenderData.pMonitor->m_transformedSize.x - monbox.width;
if (monbox.y + monbox.height < m_RenderData.pMonitor->vecTransformedSize.y) if (monbox.y + monbox.height < m_RenderData.pMonitor->m_transformedSize.y)
monbox.y = m_RenderData.pMonitor->vecTransformedSize.y - monbox.height; monbox.y = m_RenderData.pMonitor->m_transformedSize.y - monbox.height;
} }
m_bApplyFinalShader = !m_RenderData.blockScreenShader; m_bApplyFinalShader = !m_RenderData.blockScreenShader;
@@ -822,7 +822,7 @@ void CHyprOpenGLImpl::end() {
// copy the damaged areas into the mirror buffer // copy the damaged areas into the mirror buffer
// we can't use the offloadFB for mirroring, as it contains artifacts from blurring // we can't use the offloadFB for mirroring, as it contains artifacts from blurring
if (!m_RenderData.pMonitor->mirrors.empty() && !m_bFakeFrame) if (!m_RenderData.pMonitor->m_mirrors.empty() && !m_bFakeFrame)
saveBufferForMirror(monbox); saveBufferForMirror(monbox);
m_RenderData.outFB->bind(); m_RenderData.outFB->bind();
@@ -1279,8 +1279,8 @@ void CHyprOpenGLImpl::scissor(const CBox& originalBox, bool transform) {
if (transform) { if (transform) {
CBox box = originalBox; CBox box = originalBox;
const auto TR = wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)); const auto TR = wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform));
box.transform(TR, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y); box.transform(TR, m_RenderData.pMonitor->m_transformedSize.x, m_RenderData.pMonitor->m_transformedSize.y);
glScissor(box.x, box.y, box.width, box.height); glScissor(box.x, box.y, box.width, box.height);
glEnable(GL_SCISSOR_TEST); glEnable(GL_SCISSOR_TEST);
return; return;
@@ -1342,7 +1342,7 @@ void CHyprOpenGLImpl::renderRectWithBlur(const CBox& box, const CHyprColor& col,
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
scissor(box); scissor(box);
CBox MONITORBOX = {0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y}; CBox MONITORBOX = {0, 0, m_RenderData.pMonitor->m_transformedSize.x, m_RenderData.pMonitor->m_transformedSize.y};
m_bEndFrame = true; // fix transformed m_bEndFrame = true; // fix transformed
const auto SAVEDRENDERMODIF = m_RenderData.renderModif; const auto SAVEDRENDERMODIF = m_RenderData.renderModif;
m_RenderData.renderModif = {}; // fix shit m_RenderData.renderModif = {}; // fix shit
@@ -1370,7 +1370,7 @@ void CHyprOpenGLImpl::renderRectWithDamage(const CBox& box, const CHyprColor& co
m_RenderData.renderModif.applyToBox(newBox); m_RenderData.renderModif.applyToBox(newBox);
Mat3x3 matrix = m_RenderData.monitorProjection.projectBox( Mat3x3 matrix = m_RenderData.monitorProjection.projectBox(
newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform)), newBox.rot); newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->m_transform)), newBox.rot);
Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix); Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix);
glUseProgram(m_shaders->m_shQUAD.program); glUseProgram(m_shaders->m_shQUAD.program);
@@ -1386,8 +1386,8 @@ void CHyprOpenGLImpl::renderRectWithDamage(const CBox& box, const CHyprColor& co
glUniform4f(m_shaders->m_shQUAD.color, col.r * col.a, col.g * col.a, col.b * col.a, col.a); glUniform4f(m_shaders->m_shQUAD.color, col.r * col.a, col.g * col.a, col.b * col.a, col.a);
CBox transformedBox = box; CBox transformedBox = box;
transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x, transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform)), m_RenderData.pMonitor->m_transformedSize.x,
m_RenderData.pMonitor->vecTransformedSize.y); m_RenderData.pMonitor->m_transformedSize.y);
const auto TOPLEFT = Vector2D(transformedBox.x, transformedBox.y); const auto TOPLEFT = Vector2D(transformedBox.x, transformedBox.y);
const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height); const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height);
@@ -1466,12 +1466,12 @@ void CHyprOpenGLImpl::passCMUniforms(const CShader& shader, const NColorManageme
glUniform1f(shader.dstMaxLuminance, targetImageDescription.luminances.max > 0 ? targetImageDescription.luminances.max : 10000); glUniform1f(shader.dstMaxLuminance, targetImageDescription.luminances.max > 0 ? targetImageDescription.luminances.max : 10000);
glUniform1f(shader.dstRefLuminance, targetImageDescription.luminances.reference); glUniform1f(shader.dstRefLuminance, targetImageDescription.luminances.reference);
glUniform1f(shader.sdrSaturation, glUniform1f(shader.sdrSaturation,
modifySDR && m_RenderData.pMonitor->sdrSaturation > 0 && targetImageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ? modifySDR && m_RenderData.pMonitor->m_sdrSaturation > 0 && targetImageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ?
m_RenderData.pMonitor->sdrSaturation : m_RenderData.pMonitor->m_sdrSaturation :
1.0f); 1.0f);
glUniform1f(shader.sdrBrightness, glUniform1f(shader.sdrBrightness,
modifySDR && m_RenderData.pMonitor->sdrBrightness > 0 && targetImageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ? modifySDR && m_RenderData.pMonitor->m_sdrBrightness > 0 && targetImageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ?
m_RenderData.pMonitor->sdrBrightness : m_RenderData.pMonitor->m_sdrBrightness :
1.0f); 1.0f);
const auto cacheKey = std::make_pair(imageDescription.getId(), targetImageDescription.getId()); const auto cacheKey = std::make_pair(imageDescription.getId(), targetImageDescription.getId());
@@ -1488,7 +1488,7 @@ void CHyprOpenGLImpl::passCMUniforms(const CShader& shader, const NColorManageme
} }
void CHyprOpenGLImpl::passCMUniforms(const CShader& shader, const SImageDescription& imageDescription) { void CHyprOpenGLImpl::passCMUniforms(const CShader& shader, const SImageDescription& imageDescription) {
passCMUniforms(shader, imageDescription, m_RenderData.pMonitor->imageDescription, true); passCMUniforms(shader, imageDescription, m_RenderData.pMonitor->m_imageDescription, true);
} }
void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, const CBox& box, float alpha, const CRegion& damage, int round, float roundingPower, bool discardActive, void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, const CBox& box, float alpha, const CRegion& damage, int round, float roundingPower, bool discardActive,
@@ -1511,10 +1511,10 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, const CB
static const auto PENABLECM = CConfigValue<Hyprlang::INT>("render:cm_enabled"); static const auto PENABLECM = CConfigValue<Hyprlang::INT>("render:cm_enabled");
// get the needed transform for this texture // get the needed transform for this texture
const bool TRANSFORMS_MATCH = wlTransformToHyprutils(m_RenderData.pMonitor->transform) == tex->m_eTransform; // FIXME: combine them properly!!! const bool TRANSFORMS_MATCH = wlTransformToHyprutils(m_RenderData.pMonitor->m_transform) == tex->m_eTransform; // FIXME: combine them properly!!!
eTransform TRANSFORM = HYPRUTILS_TRANSFORM_NORMAL; eTransform TRANSFORM = HYPRUTILS_TRANSFORM_NORMAL;
if (m_bEndFrame || TRANSFORMS_MATCH) if (m_bEndFrame || TRANSFORMS_MATCH)
TRANSFORM = wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)); TRANSFORM = wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform));
Mat3x3 matrix = m_RenderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot); Mat3x3 matrix = m_RenderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix); Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix);
@@ -1571,10 +1571,10 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, const CB
m_RenderData.surface.valid() && m_RenderData.surface->colorManagement.valid() ? m_RenderData.surface->colorManagement->imageDescription() : SImageDescription{}; m_RenderData.surface.valid() && m_RenderData.surface->colorManagement.valid() ? m_RenderData.surface->colorManagement->imageDescription() : SImageDescription{};
const bool skipCM = !*PENABLECM || !m_bCMSupported /* CM unsupported or disabled */ const bool skipCM = !*PENABLECM || !m_bCMSupported /* CM unsupported or disabled */
|| (imageDescription == m_RenderData.pMonitor->imageDescription) /* Source and target have the same image description */ || (imageDescription == m_RenderData.pMonitor->m_imageDescription) /* Source and target have the same image description */
|| ((*PPASS == 1 || (*PPASS == 2 && imageDescription.transferFunction == CM_TRANSFER_FUNCTION_ST2084_PQ)) && m_RenderData.pMonitor->activeWorkspace && || ((*PPASS == 1 || (*PPASS == 2 && imageDescription.transferFunction == CM_TRANSFER_FUNCTION_ST2084_PQ)) && m_RenderData.pMonitor->m_activeWorkspace &&
m_RenderData.pMonitor->activeWorkspace->m_hasFullscreenWindow && m_RenderData.pMonitor->m_activeWorkspace->m_hasFullscreenWindow &&
m_RenderData.pMonitor->activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) /* Fullscreen window with pass cm enabled */; m_RenderData.pMonitor->m_activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) /* Fullscreen window with pass cm enabled */;
if (!skipCM && !usingFinalShader && (texType == TEXTURE_RGBA || texType == TEXTURE_RGBX)) if (!skipCM && !usingFinalShader && (texType == TEXTURE_RGBA || texType == TEXTURE_RGBX))
shader = &m_shaders->m_shCM; shader = &m_shaders->m_shCM;
@@ -1602,13 +1602,13 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, const CB
} }
if (usingFinalShader && shader->wl_output != -1) if (usingFinalShader && shader->wl_output != -1)
glUniform1i(shader->wl_output, m_RenderData.pMonitor->ID); glUniform1i(shader->wl_output, m_RenderData.pMonitor->m_id);
if (usingFinalShader && shader->fullSize != -1) if (usingFinalShader && shader->fullSize != -1)
glUniform2f(shader->fullSize, m_RenderData.pMonitor->vecPixelSize.x, m_RenderData.pMonitor->vecPixelSize.y); glUniform2f(shader->fullSize, m_RenderData.pMonitor->m_pixelSize.x, m_RenderData.pMonitor->m_pixelSize.y);
if (CRASHING) { if (CRASHING) {
glUniform1f(shader->distort, g_pHyprRenderer->m_fCrashingDistort); glUniform1f(shader->distort, g_pHyprRenderer->m_fCrashingDistort);
glUniform2f(shader->fullSize, m_RenderData.pMonitor->vecPixelSize.x, m_RenderData.pMonitor->vecPixelSize.y); glUniform2f(shader->fullSize, m_RenderData.pMonitor->m_pixelSize.x, m_RenderData.pMonitor->m_pixelSize.y);
} }
if (!usingFinalShader) { if (!usingFinalShader) {
@@ -1625,8 +1625,8 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, const CB
} }
CBox transformedBox = newBox; CBox transformedBox = newBox;
transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x, transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform)), m_RenderData.pMonitor->m_transformedSize.x,
m_RenderData.pMonitor->vecTransformedSize.y); m_RenderData.pMonitor->m_transformedSize.y);
const auto TOPLEFT = Vector2D(transformedBox.x, transformedBox.y); const auto TOPLEFT = Vector2D(transformedBox.x, transformedBox.y);
const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height); const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height);
@@ -1712,7 +1712,7 @@ void CHyprOpenGLImpl::renderTexturePrimitive(SP<CTexture> tex, const CBox& box)
m_RenderData.renderModif.applyToBox(newBox); m_RenderData.renderModif.applyToBox(newBox);
// get transform // get transform
const auto TRANSFORM = wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform)); const auto TRANSFORM = wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->m_transform));
Mat3x3 matrix = m_RenderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot); Mat3x3 matrix = m_RenderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix); Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix);
@@ -1763,7 +1763,7 @@ void CHyprOpenGLImpl::renderTextureMatte(SP<CTexture> tex, const CBox& box, CFra
m_RenderData.renderModif.applyToBox(newBox); m_RenderData.renderModif.applyToBox(newBox);
// get transform // get transform
const auto TRANSFORM = wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform)); const auto TRANSFORM = wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->m_transform));
Mat3x3 matrix = m_RenderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot); Mat3x3 matrix = m_RenderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix); Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix);
@@ -1824,8 +1824,8 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, CRegion* o
glDisable(GL_STENCIL_TEST); glDisable(GL_STENCIL_TEST);
// get transforms for the full monitor // get transforms for the full monitor
const auto TRANSFORM = wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)); const auto TRANSFORM = wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform));
CBox MONITORBOX = {0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y}; CBox MONITORBOX = {0, 0, m_RenderData.pMonitor->m_transformedSize.x, m_RenderData.pMonitor->m_transformedSize.y};
Mat3x3 matrix = m_RenderData.monitorProjection.projectBox(MONITORBOX, TRANSFORM); Mat3x3 matrix = m_RenderData.monitorProjection.projectBox(MONITORBOX, TRANSFORM);
Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix); Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix);
@@ -1837,8 +1837,8 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, CRegion* o
// prep damage // prep damage
CRegion damage{*originalDamage}; CRegion damage{*originalDamage};
damage.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x, damage.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform)), m_RenderData.pMonitor->m_transformedSize.x,
m_RenderData.pMonitor->vecTransformedSize.y); m_RenderData.pMonitor->m_transformedSize.y);
damage.expand(*PBLURPASSES > 10 ? pow(2, 15) : std::clamp(*PBLURSIZE, (int64_t)1, (int64_t)40) * pow(2, *PBLURPASSES)); damage.expand(*PBLURPASSES > 10 ? pow(2, 15) : std::clamp(*PBLURSIZE, (int64_t)1, (int64_t)40) * pow(2, *PBLURPASSES));
// helper // helper
@@ -1866,17 +1866,19 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, CRegion* o
glUseProgram(m_shaders->m_shBLURPREPARE.program); glUseProgram(m_shaders->m_shBLURPREPARE.program);
// From FB to sRGB // From FB to sRGB
const bool skipCM = !m_bCMSupported || m_RenderData.pMonitor->imageDescription == SImageDescription{}; const bool skipCM = !m_bCMSupported || m_RenderData.pMonitor->m_imageDescription == SImageDescription{};
glUniform1i(m_shaders->m_shBLURPREPARE.skipCM, skipCM); glUniform1i(m_shaders->m_shBLURPREPARE.skipCM, skipCM);
if (!skipCM) { if (!skipCM) {
passCMUniforms(m_shaders->m_shBLURPREPARE, m_RenderData.pMonitor->imageDescription, SImageDescription{}); passCMUniforms(m_shaders->m_shBLURPREPARE, m_RenderData.pMonitor->m_imageDescription, SImageDescription{});
glUniform1f(m_shaders->m_shBLURPREPARE.sdrSaturation, glUniform1f(m_shaders->m_shBLURPREPARE.sdrSaturation,
m_RenderData.pMonitor->sdrSaturation > 0 && m_RenderData.pMonitor->imageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ? m_RenderData.pMonitor->m_sdrSaturation > 0 &&
m_RenderData.pMonitor->sdrSaturation : m_RenderData.pMonitor->m_imageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ?
m_RenderData.pMonitor->m_sdrSaturation :
1.0f); 1.0f);
glUniform1f(m_shaders->m_shBLURPREPARE.sdrBrightness, glUniform1f(m_shaders->m_shBLURPREPARE.sdrBrightness,
m_RenderData.pMonitor->sdrBrightness > 0 && m_RenderData.pMonitor->imageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ? m_RenderData.pMonitor->m_sdrBrightness > 0 &&
m_RenderData.pMonitor->sdrBrightness : m_RenderData.pMonitor->m_imageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ?
m_RenderData.pMonitor->m_sdrBrightness :
1.0f); 1.0f);
} }
@@ -1935,12 +1937,12 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, CRegion* o
#endif #endif
glUniform1f(pShader->radius, *PBLURSIZE * a); // this makes the blursize change with a glUniform1f(pShader->radius, *PBLURSIZE * a); // this makes the blursize change with a
if (pShader == &m_shaders->m_shBLUR1) { if (pShader == &m_shaders->m_shBLUR1) {
glUniform2f(m_shaders->m_shBLUR1.halfpixel, 0.5f / (m_RenderData.pMonitor->vecPixelSize.x / 2.f), 0.5f / (m_RenderData.pMonitor->vecPixelSize.y / 2.f)); glUniform2f(m_shaders->m_shBLUR1.halfpixel, 0.5f / (m_RenderData.pMonitor->m_pixelSize.x / 2.f), 0.5f / (m_RenderData.pMonitor->m_pixelSize.y / 2.f));
glUniform1i(m_shaders->m_shBLUR1.passes, *PBLURPASSES); glUniform1i(m_shaders->m_shBLUR1.passes, *PBLURPASSES);
glUniform1f(m_shaders->m_shBLUR1.vibrancy, *PBLURVIBRANCY); glUniform1f(m_shaders->m_shBLUR1.vibrancy, *PBLURVIBRANCY);
glUniform1f(m_shaders->m_shBLUR1.vibrancy_darkness, *PBLURVIBRANCYDARKNESS); glUniform1f(m_shaders->m_shBLUR1.vibrancy_darkness, *PBLURVIBRANCYDARKNESS);
} else } else
glUniform2f(m_shaders->m_shBLUR2.halfpixel, 0.5f / (m_RenderData.pMonitor->vecPixelSize.x * 2.f), 0.5f / (m_RenderData.pMonitor->vecPixelSize.y * 2.f)); glUniform2f(m_shaders->m_shBLUR2.halfpixel, 0.5f / (m_RenderData.pMonitor->m_pixelSize.x * 2.f), 0.5f / (m_RenderData.pMonitor->m_pixelSize.y * 2.f));
glUniform1i(pShader->tex, 0); glUniform1i(pShader->tex, 0);
glVertexAttribPointer(pShader->posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts); glVertexAttribPointer(pShader->posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
@@ -2058,7 +2060,7 @@ void CHyprOpenGLImpl::preRender(PHLMONITOR pMonitor) {
return; return;
// ignore if solitary present, nothing to blur // ignore if solitary present, nothing to blur
if (!pMonitor->solitaryClient.expired()) if (!pMonitor->m_solitaryClient.expired())
return; return;
// check if we need to update the blur fb // check if we need to update the blur fb
@@ -2099,7 +2101,7 @@ void CHyprOpenGLImpl::preRender(PHLMONITOR pMonitor) {
bool hasWindows = false; bool hasWindows = false;
for (auto const& w : g_pCompositor->m_windows) { for (auto const& w : g_pCompositor->m_windows) {
if (w->m_workspace == pMonitor->activeWorkspace && !w->isHidden() && w->m_isMapped && (!w->m_isFloating || *PBLURXRAY)) { if (w->m_workspace == pMonitor->m_activeWorkspace && !w->isHidden() && w->m_isMapped && (!w->m_isFloating || *PBLURXRAY)) {
// check if window is valid // check if window is valid
if (!windowShouldBeBlurred(w)) if (!windowShouldBeBlurred(w))
@@ -2111,7 +2113,7 @@ void CHyprOpenGLImpl::preRender(PHLMONITOR pMonitor) {
} }
for (auto const& m : g_pCompositor->m_monitors) { for (auto const& m : g_pCompositor->m_monitors) {
for (auto const& lsl : m->m_aLayerSurfaceLayers) { for (auto const& lsl : m->m_layerSurfaceLayers) {
for (auto const& ls : lsl) { for (auto const& ls : lsl) {
if (!ls->m_layerSurface || ls->m_xray != 1) if (!ls->m_layerSurface || ls->m_xray != 1)
continue; continue;
@@ -2140,18 +2142,18 @@ void CHyprOpenGLImpl::preBlurForCurrentMonitor() {
m_RenderData.renderModif = {}; // fix shit m_RenderData.renderModif = {}; // fix shit
// make the fake dmg // make the fake dmg
CRegion fakeDamage{0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y}; CRegion fakeDamage{0, 0, m_RenderData.pMonitor->m_transformedSize.x, m_RenderData.pMonitor->m_transformedSize.y};
const auto POUTFB = blurMainFramebufferWithDamage(1, &fakeDamage); const auto POUTFB = blurMainFramebufferWithDamage(1, &fakeDamage);
// render onto blurFB // render onto blurFB
m_RenderData.pCurrentMonData->blurFB.alloc(m_RenderData.pMonitor->vecPixelSize.x, m_RenderData.pMonitor->vecPixelSize.y, m_RenderData.pCurrentMonData->blurFB.alloc(m_RenderData.pMonitor->m_pixelSize.x, m_RenderData.pMonitor->m_pixelSize.y,
m_RenderData.pMonitor->output->state->state().drmFormat); m_RenderData.pMonitor->m_output->state->state().drmFormat);
m_RenderData.pCurrentMonData->blurFB.bind(); m_RenderData.pCurrentMonData->blurFB.bind();
clear(CHyprColor(0, 0, 0, 0)); clear(CHyprColor(0, 0, 0, 0));
m_bEndFrame = true; // fix transformed m_bEndFrame = true; // fix transformed
renderTextureInternalWithDamage(POUTFB->getTexture(), CBox{0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y}, 1, fakeDamage, 0, renderTextureInternalWithDamage(POUTFB->getTexture(), CBox{0, 0, m_RenderData.pMonitor->m_transformedSize.x, m_RenderData.pMonitor->m_transformedSize.y}, 1, fakeDamage, 0,
2.0f, false, true, false); 2.0f, false, true, false);
m_bEndFrame = false; m_bEndFrame = false;
@@ -2222,7 +2224,8 @@ void CHyprOpenGLImpl::renderTextureWithBlur(SP<CTexture> tex, const CBox& box, f
// amazing hack: the surface has an opaque region! // amazing hack: the surface has an opaque region!
CRegion inverseOpaque; CRegion inverseOpaque;
if (a >= 1.f && std::round(pSurface->current.size.x * m_RenderData.pMonitor->scale) == box.w && std::round(pSurface->current.size.y * m_RenderData.pMonitor->scale) == box.h) { if (a >= 1.f && std::round(pSurface->current.size.x * m_RenderData.pMonitor->m_scale) == box.w &&
std::round(pSurface->current.size.y * m_RenderData.pMonitor->m_scale) == box.h) {
pixman_box32_t surfbox = {0, 0, pSurface->current.size.x * pSurface->current.scale, pSurface->current.size.y * pSurface->current.scale}; pixman_box32_t surfbox = {0, 0, pSurface->current.size.x * pSurface->current.scale, pSurface->current.size.y * pSurface->current.scale};
inverseOpaque = pSurface->current.opaque; inverseOpaque = pSurface->current.opaque;
inverseOpaque.invert(&surfbox).intersect(0, 0, pSurface->current.size.x * pSurface->current.scale, pSurface->current.size.y * pSurface->current.scale); inverseOpaque.invert(&surfbox).intersect(0, 0, pSurface->current.size.x * pSurface->current.scale, pSurface->current.size.y * pSurface->current.scale);
@@ -2234,7 +2237,7 @@ void CHyprOpenGLImpl::renderTextureWithBlur(SP<CTexture> tex, const CBox& box, f
} else } else
inverseOpaque = {0, 0, box.width, box.height}; inverseOpaque = {0, 0, box.width, box.height};
inverseOpaque.scale(m_RenderData.pMonitor->scale); inverseOpaque.scale(m_RenderData.pMonitor->m_scale);
// vvv TODO: layered blur fbs? // vvv TODO: layered blur fbs?
const bool USENEWOPTIMIZE = shouldUseNewBlurOptimizations(m_RenderData.currentLS.lock(), m_RenderData.currentWindow.lock()) && !blockBlurOptimization; const bool USENEWOPTIMIZE = shouldUseNewBlurOptimizations(m_RenderData.currentLS.lock(), m_RenderData.currentWindow.lock()) && !blockBlurOptimization;
@@ -2276,16 +2279,16 @@ void CHyprOpenGLImpl::renderTextureWithBlur(SP<CTexture> tex, const CBox& box, f
const auto LASTBR = m_RenderData.primarySurfaceUVBottomRight; const auto LASTBR = m_RenderData.primarySurfaceUVBottomRight;
CBox transformedBox = box; CBox transformedBox = box;
transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x, transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform)), m_RenderData.pMonitor->m_transformedSize.x,
m_RenderData.pMonitor->vecTransformedSize.y); m_RenderData.pMonitor->m_transformedSize.y);
CBox monitorSpaceBox = {transformedBox.pos().x / m_RenderData.pMonitor->vecPixelSize.x * m_RenderData.pMonitor->vecTransformedSize.x, CBox monitorSpaceBox = {transformedBox.pos().x / m_RenderData.pMonitor->m_pixelSize.x * m_RenderData.pMonitor->m_transformedSize.x,
transformedBox.pos().y / m_RenderData.pMonitor->vecPixelSize.y * m_RenderData.pMonitor->vecTransformedSize.y, transformedBox.pos().y / m_RenderData.pMonitor->m_pixelSize.y * m_RenderData.pMonitor->m_transformedSize.y,
transformedBox.width / m_RenderData.pMonitor->vecPixelSize.x * m_RenderData.pMonitor->vecTransformedSize.x, transformedBox.width / m_RenderData.pMonitor->m_pixelSize.x * m_RenderData.pMonitor->m_transformedSize.x,
transformedBox.height / m_RenderData.pMonitor->vecPixelSize.y * m_RenderData.pMonitor->vecTransformedSize.y}; transformedBox.height / m_RenderData.pMonitor->m_pixelSize.y * m_RenderData.pMonitor->m_transformedSize.y};
m_RenderData.primarySurfaceUVTopLeft = monitorSpaceBox.pos() / m_RenderData.pMonitor->vecTransformedSize; m_RenderData.primarySurfaceUVTopLeft = monitorSpaceBox.pos() / m_RenderData.pMonitor->m_transformedSize;
m_RenderData.primarySurfaceUVBottomRight = (monitorSpaceBox.pos() + monitorSpaceBox.size()) / m_RenderData.pMonitor->vecTransformedSize; m_RenderData.primarySurfaceUVBottomRight = (monitorSpaceBox.pos() + monitorSpaceBox.size()) / m_RenderData.pMonitor->m_transformedSize;
static auto PBLURIGNOREOPACITY = CConfigValue<Hyprlang::INT>("decoration:blur:ignore_opacity"); static auto PBLURIGNOREOPACITY = CConfigValue<Hyprlang::INT>("decoration:blur:ignore_opacity");
setMonitorTransformEnabled(true); setMonitorTransformEnabled(true);
@@ -2327,7 +2330,7 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
if (borderSize < 1) if (borderSize < 1)
return; return;
int scaledBorderSize = std::round(borderSize * m_RenderData.pMonitor->scale); int scaledBorderSize = std::round(borderSize * m_RenderData.pMonitor->m_scale);
scaledBorderSize = std::round(scaledBorderSize * m_RenderData.renderModif.combinedScale()); scaledBorderSize = std::round(scaledBorderSize * m_RenderData.renderModif.combinedScale());
// adjust box // adjust box
@@ -2339,7 +2342,7 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
round += round == 0 ? 0 : scaledBorderSize; round += round == 0 ? 0 : scaledBorderSize;
Mat3x3 matrix = m_RenderData.monitorProjection.projectBox( Mat3x3 matrix = m_RenderData.monitorProjection.projectBox(
newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform)), newBox.rot); newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->m_transform)), newBox.rot);
Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix); Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix);
const auto BLEND = m_bBlend; const auto BLEND = m_bBlend;
@@ -2347,7 +2350,7 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
glUseProgram(m_shaders->m_shBORDER1.program); glUseProgram(m_shaders->m_shBORDER1.program);
const bool skipCM = !m_bCMSupported || m_RenderData.pMonitor->imageDescription == SImageDescription{}; const bool skipCM = !m_bCMSupported || m_RenderData.pMonitor->m_imageDescription == SImageDescription{};
glUniform1i(m_shaders->m_shBORDER1.skipCM, skipCM); glUniform1i(m_shaders->m_shBORDER1.skipCM, skipCM);
if (!skipCM) if (!skipCM)
passCMUniforms(m_shaders->m_shBORDER1, SImageDescription{}); passCMUniforms(m_shaders->m_shBORDER1, SImageDescription{});
@@ -2366,8 +2369,8 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
glUniform1i(m_shaders->m_shBORDER1.gradient2Length, 0); glUniform1i(m_shaders->m_shBORDER1.gradient2Length, 0);
CBox transformedBox = newBox; CBox transformedBox = newBox;
transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x, transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform)), m_RenderData.pMonitor->m_transformedSize.x,
m_RenderData.pMonitor->vecTransformedSize.y); m_RenderData.pMonitor->m_transformedSize.y);
const auto TOPLEFT = Vector2D(transformedBox.x, transformedBox.y); const auto TOPLEFT = Vector2D(transformedBox.x, transformedBox.y);
const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height); const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height);
@@ -2425,7 +2428,7 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
if (borderSize < 1) if (borderSize < 1)
return; return;
int scaledBorderSize = std::round(borderSize * m_RenderData.pMonitor->scale); int scaledBorderSize = std::round(borderSize * m_RenderData.pMonitor->m_scale);
scaledBorderSize = std::round(scaledBorderSize * m_RenderData.renderModif.combinedScale()); scaledBorderSize = std::round(scaledBorderSize * m_RenderData.renderModif.combinedScale());
// adjust box // adjust box
@@ -2437,7 +2440,7 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
round += round == 0 ? 0 : scaledBorderSize; round += round == 0 ? 0 : scaledBorderSize;
Mat3x3 matrix = m_RenderData.monitorProjection.projectBox( Mat3x3 matrix = m_RenderData.monitorProjection.projectBox(
newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform)), newBox.rot); newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->m_transform)), newBox.rot);
Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix); Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix);
const auto BLEND = m_bBlend; const auto BLEND = m_bBlend;
@@ -2463,8 +2466,8 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
glUniform1f(m_shaders->m_shBORDER1.gradientLerp, lerp); glUniform1f(m_shaders->m_shBORDER1.gradientLerp, lerp);
CBox transformedBox = newBox; CBox transformedBox = newBox;
transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x, transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->m_transform)), m_RenderData.pMonitor->m_transformedSize.x,
m_RenderData.pMonitor->vecTransformedSize.y); m_RenderData.pMonitor->m_transformedSize.y);
const auto TOPLEFT = Vector2D(transformedBox.x, transformedBox.y); const auto TOPLEFT = Vector2D(transformedBox.x, transformedBox.y);
const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height); const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height);
@@ -2526,13 +2529,13 @@ void CHyprOpenGLImpl::renderRoundedShadow(const CBox& box, int round, float roun
const auto col = color; const auto col = color;
Mat3x3 matrix = m_RenderData.monitorProjection.projectBox( Mat3x3 matrix = m_RenderData.monitorProjection.projectBox(
newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform)), newBox.rot); newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->m_transform)), newBox.rot);
Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix); Mat3x3 glMatrix = m_RenderData.projection.copy().multiply(matrix);
blend(true); blend(true);
glUseProgram(m_shaders->m_shSHADOW.program); glUseProgram(m_shaders->m_shSHADOW.program);
const bool skipCM = !m_bCMSupported || m_RenderData.pMonitor->imageDescription == SImageDescription{}; const bool skipCM = !m_bCMSupported || m_RenderData.pMonitor->m_imageDescription == SImageDescription{};
glUniform1i(m_shaders->m_shSHADOW.skipCM, skipCM); glUniform1i(m_shaders->m_shSHADOW.skipCM, skipCM);
if (!skipCM) if (!skipCM)
passCMUniforms(m_shaders->m_shSHADOW, SImageDescription{}); passCMUniforms(m_shaders->m_shSHADOW, SImageDescription{});
@@ -2588,8 +2591,8 @@ void CHyprOpenGLImpl::renderRoundedShadow(const CBox& box, int round, float roun
void CHyprOpenGLImpl::saveBufferForMirror(const CBox& box) { void CHyprOpenGLImpl::saveBufferForMirror(const CBox& box) {
if (!m_RenderData.pCurrentMonData->monitorMirrorFB.isAllocated()) if (!m_RenderData.pCurrentMonData->monitorMirrorFB.isAllocated())
m_RenderData.pCurrentMonData->monitorMirrorFB.alloc(m_RenderData.pMonitor->vecPixelSize.x, m_RenderData.pMonitor->vecPixelSize.y, m_RenderData.pCurrentMonData->monitorMirrorFB.alloc(m_RenderData.pMonitor->m_pixelSize.x, m_RenderData.pMonitor->m_pixelSize.y,
m_RenderData.pMonitor->output->state->state().drmFormat); m_RenderData.pMonitor->m_output->state->state().drmFormat);
m_RenderData.pCurrentMonData->monitorMirrorFB.bind(); m_RenderData.pCurrentMonData->monitorMirrorFB.bind();
@@ -2605,16 +2608,16 @@ void CHyprOpenGLImpl::saveBufferForMirror(const CBox& box) {
void CHyprOpenGLImpl::renderMirrored() { void CHyprOpenGLImpl::renderMirrored() {
auto monitor = m_RenderData.pMonitor; auto monitor = m_RenderData.pMonitor;
auto mirrored = monitor->pMirrorOf; auto mirrored = monitor->m_mirrorOf;
const double scale = std::min(monitor->vecTransformedSize.x / mirrored->vecTransformedSize.x, monitor->vecTransformedSize.y / mirrored->vecTransformedSize.y); const double scale = std::min(monitor->m_transformedSize.x / mirrored->m_transformedSize.x, monitor->m_transformedSize.y / mirrored->m_transformedSize.y);
CBox monbox = {0, 0, mirrored->vecTransformedSize.x * scale, mirrored->vecTransformedSize.y * scale}; CBox monbox = {0, 0, mirrored->m_transformedSize.x * scale, mirrored->m_transformedSize.y * scale};
// transform box as it will be drawn on a transformed projection // transform box as it will be drawn on a transformed projection
monbox.transform(wlTransformToHyprutils(mirrored->transform), mirrored->vecTransformedSize.x * scale, mirrored->vecTransformedSize.y * scale); monbox.transform(wlTransformToHyprutils(mirrored->m_transform), mirrored->m_transformedSize.x * scale, mirrored->m_transformedSize.y * scale);
monbox.x = (monitor->vecTransformedSize.x - monbox.w) / 2; monbox.x = (monitor->m_transformedSize.x - monbox.w) / 2;
monbox.y = (monitor->vecTransformedSize.y - monbox.h) / 2; monbox.y = (monitor->m_transformedSize.y - monbox.h) / 2;
const auto PFB = &m_mMonitorRenderResources[mirrored].monitorMirrorFB; const auto PFB = &m_mMonitorRenderResources[mirrored].monitorMirrorFB;
if (!PFB->isAllocated() || !PFB->getTexture()) if (!PFB->isAllocated() || !PFB->getTexture())
@@ -2626,10 +2629,10 @@ void CHyprOpenGLImpl::renderMirrored() {
data.tex = PFB->getTexture(); data.tex = PFB->getTexture();
data.box = monbox; data.box = monbox;
data.replaceProjection = Mat3x3::identity() data.replaceProjection = Mat3x3::identity()
.translate(monitor->vecPixelSize / 2.0) .translate(monitor->m_pixelSize / 2.0)
.transform(wlTransformToHyprutils(monitor->transform)) .transform(wlTransformToHyprutils(monitor->m_transform))
.transform(wlTransformToHyprutils(invertTransform(mirrored->transform))) .transform(wlTransformToHyprutils(invertTransform(mirrored->m_transform)))
.translate(-monitor->vecTransformedSize / 2.0); .translate(-monitor->m_transformedSize / 2.0);
g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data)); g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
} }
@@ -2912,7 +2915,7 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
const auto PFB = &m_mMonitorBGFBs[pMonitor]; const auto PFB = &m_mMonitorBGFBs[pMonitor];
PFB->release(); PFB->release();
PFB->alloc(pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y, pMonitor->output->state->state().drmFormat); PFB->alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, pMonitor->m_output->state->state().drmFormat);
if (!m_pBackgroundTexture) // ?!?!?! if (!m_pBackgroundTexture) // ?!?!?!
return; return;
@@ -2922,7 +2925,7 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
tex->allocate(); tex->allocate();
const auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y); const auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y);
const auto CAIRO = cairo_create(CAIROSURFACE); const auto CAIRO = cairo_create(CAIROSURFACE);
cairo_set_antialias(CAIRO, CAIRO_ANTIALIAS_GOOD); cairo_set_antialias(CAIRO, CAIRO_ANTIALIAS_GOOD);
@@ -2933,11 +2936,11 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
cairo_restore(CAIRO); cairo_restore(CAIRO);
if (!*PNOSPLASH) if (!*PNOSPLASH)
renderSplash(CAIRO, CAIROSURFACE, 0.02 * pMonitor->vecPixelSize.y, pMonitor->vecPixelSize); renderSplash(CAIRO, CAIROSURFACE, 0.02 * pMonitor->m_pixelSize.y, pMonitor->m_pixelSize);
cairo_surface_flush(CAIROSURFACE); cairo_surface_flush(CAIROSURFACE);
tex->m_vSize = pMonitor->vecPixelSize; tex->m_vSize = pMonitor->m_pixelSize;
// copy the data to an OpenGL texture we have // copy the data to an OpenGL texture we have
const GLint glFormat = GL_RGBA; const GLint glFormat = GL_RGBA;
@@ -2965,31 +2968,31 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
// first render the background // first render the background
if (m_pBackgroundTexture) { if (m_pBackgroundTexture) {
const double MONRATIO = m_RenderData.pMonitor->vecTransformedSize.x / m_RenderData.pMonitor->vecTransformedSize.y; const double MONRATIO = m_RenderData.pMonitor->m_transformedSize.x / m_RenderData.pMonitor->m_transformedSize.y;
const double WPRATIO = m_pBackgroundTexture->m_vSize.x / m_pBackgroundTexture->m_vSize.y; const double WPRATIO = m_pBackgroundTexture->m_vSize.x / m_pBackgroundTexture->m_vSize.y;
Vector2D origin; Vector2D origin;
double scale = 1.0; double scale = 1.0;
if (MONRATIO > WPRATIO) { if (MONRATIO > WPRATIO) {
scale = m_RenderData.pMonitor->vecTransformedSize.x / m_pBackgroundTexture->m_vSize.x; scale = m_RenderData.pMonitor->m_transformedSize.x / m_pBackgroundTexture->m_vSize.x;
origin.y = (m_RenderData.pMonitor->vecTransformedSize.y - m_pBackgroundTexture->m_vSize.y * scale) / 2.0; origin.y = (m_RenderData.pMonitor->m_transformedSize.y - m_pBackgroundTexture->m_vSize.y * scale) / 2.0;
} else { } else {
scale = m_RenderData.pMonitor->vecTransformedSize.y / m_pBackgroundTexture->m_vSize.y; scale = m_RenderData.pMonitor->m_transformedSize.y / m_pBackgroundTexture->m_vSize.y;
origin.x = (m_RenderData.pMonitor->vecTransformedSize.x - m_pBackgroundTexture->m_vSize.x * scale) / 2.0; origin.x = (m_RenderData.pMonitor->m_transformedSize.x - m_pBackgroundTexture->m_vSize.x * scale) / 2.0;
} }
CBox texbox = CBox{origin, m_pBackgroundTexture->m_vSize * scale}; CBox texbox = CBox{origin, m_pBackgroundTexture->m_vSize * scale};
renderTextureInternalWithDamage(m_pBackgroundTexture, texbox, 1.0, fakeDamage); renderTextureInternalWithDamage(m_pBackgroundTexture, texbox, 1.0, fakeDamage);
} }
CBox monbox = {{}, pMonitor->vecPixelSize}; CBox monbox = {{}, pMonitor->m_pixelSize};
renderTextureInternalWithDamage(tex, monbox, 1.0, fakeDamage); renderTextureInternalWithDamage(tex, monbox, 1.0, fakeDamage);
// bind back // bind back
if (m_RenderData.currentFB) if (m_RenderData.currentFB)
m_RenderData.currentFB->bind(); m_RenderData.currentFB->bind();
Debug::log(LOG, "Background created for monitor {}", pMonitor->szName); Debug::log(LOG, "Background created for monitor {}", pMonitor->m_name);
} }
void CHyprOpenGLImpl::clearWithTex() { void CHyprOpenGLImpl::clearWithTex() {
@@ -3004,7 +3007,7 @@ void CHyprOpenGLImpl::clearWithTex() {
if (TEXIT != m_mMonitorBGFBs.end()) { if (TEXIT != m_mMonitorBGFBs.end()) {
CTexPassElement::SRenderData data; CTexPassElement::SRenderData data;
data.box = {0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y}; data.box = {0, 0, m_RenderData.pMonitor->m_transformedSize.x, m_RenderData.pMonitor->m_transformedSize.y};
data.flipEndFrame = true; data.flipEndFrame = true;
data.tex = TEXIT->second.getTexture(); data.tex = TEXIT->second.getTexture();
g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data)); g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
@@ -3036,7 +3039,7 @@ void CHyprOpenGLImpl::destroyMonitorResources(PHLMONITORREF pMonitor) {
} }
if (pMonitor) if (pMonitor)
Debug::log(LOG, "Monitor {} -> destroyed all render data", pMonitor->szName); Debug::log(LOG, "Monitor {} -> destroyed all render data", pMonitor->m_name);
} }
void CHyprOpenGLImpl::saveMatrix() { void CHyprOpenGLImpl::saveMatrix() {
@@ -3053,8 +3056,8 @@ void CHyprOpenGLImpl::restoreMatrix() {
void CHyprOpenGLImpl::bindOffMain() { void CHyprOpenGLImpl::bindOffMain() {
if (!m_RenderData.pCurrentMonData->offMainFB.isAllocated()) { if (!m_RenderData.pCurrentMonData->offMainFB.isAllocated()) {
m_RenderData.pCurrentMonData->offMainFB.alloc(m_RenderData.pMonitor->vecPixelSize.x, m_RenderData.pMonitor->vecPixelSize.y, m_RenderData.pCurrentMonData->offMainFB.alloc(m_RenderData.pMonitor->m_pixelSize.x, m_RenderData.pMonitor->m_pixelSize.y,
m_RenderData.pMonitor->output->state->state().drmFormat); m_RenderData.pMonitor->m_output->state->state().drmFormat);
m_RenderData.pCurrentMonData->offMainFB.addStencil(m_RenderData.pCurrentMonData->stencilTex); m_RenderData.pCurrentMonData->offMainFB.addStencil(m_RenderData.pCurrentMonData->stencilTex);
} }
@@ -3065,7 +3068,7 @@ void CHyprOpenGLImpl::bindOffMain() {
} }
void CHyprOpenGLImpl::renderOffToMain(CFramebuffer* off) { void CHyprOpenGLImpl::renderOffToMain(CFramebuffer* off) {
CBox monbox = {0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y}; CBox monbox = {0, 0, m_RenderData.pMonitor->m_transformedSize.x, m_RenderData.pMonitor->m_transformedSize.y};
renderTexturePrimitive(off->getTexture(), monbox); renderTexturePrimitive(off->getTexture(), monbox);
} }
@@ -3083,7 +3086,7 @@ void CHyprOpenGLImpl::setRenderModifEnabled(bool enabled) {
} }
uint32_t CHyprOpenGLImpl::getPreferredReadFormat(PHLMONITOR pMonitor) { uint32_t CHyprOpenGLImpl::getPreferredReadFormat(PHLMONITOR pMonitor) {
return pMonitor->output->state->state().drmFormat; return pMonitor->m_output->state->state().drmFormat;
} }
std::vector<SDRMFormat> CHyprOpenGLImpl::getDRMFormats() { std::vector<SDRMFormat> CHyprOpenGLImpl::getDRMFormats() {

369
src/render/Renderer.cpp
View File

@@ -119,7 +119,7 @@ CHyprRenderer::CHyprRenderer() {
if (!g_pHyprError->active()) if (!g_pHyprError->active())
return; return;
for (auto& m : g_pCompositor->m_monitors) { for (auto& m : g_pCompositor->m_monitors) {
arrangeLayersForMonitor(m->ID); arrangeLayersForMonitor(m->m_id);
} }
}); });
}); });
@@ -209,7 +209,7 @@ bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor) {
if (pWindow->m_workspace && pWindow->m_workspace->isVisible() && pWindow->m_isFloating /* tiled windows can't be multi-ws */) if (pWindow->m_workspace && pWindow->m_workspace->isVisible() && pWindow->m_isFloating /* tiled windows can't be multi-ws */)
return !pWindow->isFullscreen(); // Do not draw fullscreen windows on other monitors return !pWindow->isFullscreen(); // Do not draw fullscreen windows on other monitors
if (pMonitor->activeSpecialWorkspace == pWindow->m_workspace) if (pMonitor->m_activeSpecialWorkspace == pWindow->m_workspace)
return true; return true;
// if window is tiled and it's flying in, don't render on other mons (for slide) // if window is tiled and it's flying in, don't render on other mons (for slide)
@@ -226,7 +226,7 @@ bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor) {
windowBox.translate(PWINDOWWORKSPACE->m_renderOffset->value()); windowBox.translate(PWINDOWWORKSPACE->m_renderOffset->value());
windowBox.translate(pWindow->m_floatingOffset); windowBox.translate(pWindow->m_floatingOffset);
const CBox monitorBox = {pMonitor->vecPosition, pMonitor->vecSize}; const CBox monitorBox = {pMonitor->m_position, pMonitor->m_size};
if (!windowBox.intersection(monitorBox).empty() && (pWindow->workspaceID() == pMonitor->activeWorkspaceID() || pWindow->m_monitorMovedFrom != -1)) if (!windowBox.intersection(monitorBox).empty() && (pWindow->workspaceID() == pMonitor->activeWorkspaceID() || pWindow->m_monitorMovedFrom != -1))
return true; return true;
} }
@@ -254,7 +254,7 @@ bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow) {
if (PWORKSPACE && PWORKSPACE->m_monitor == m && (PWORKSPACE->m_renderOffset->isBeingAnimated() || PWORKSPACE->m_alpha->isBeingAnimated())) if (PWORKSPACE && PWORKSPACE->m_monitor == m && (PWORKSPACE->m_renderOffset->isBeingAnimated() || PWORKSPACE->m_alpha->isBeingAnimated()))
return true; return true;
if (m->activeSpecialWorkspace && pWindow->onSpecialWorkspace()) if (m->m_activeSpecialWorkspace && pWindow->onSpecialWorkspace())
return true; return true;
} }
@@ -479,8 +479,8 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
renderdata.h = textureBox.h; renderdata.h = textureBox.h;
if (ignorePosition) { if (ignorePosition) {
renderdata.pos.x = pMonitor->vecPosition.x; renderdata.pos.x = pMonitor->m_position.x;
renderdata.pos.y = pMonitor->vecPosition.y; renderdata.pos.y = pMonitor->m_position.y;
} else { } else {
const bool ANR = pWindow->isNotResponding(); const bool ANR = pWindow->isNotResponding();
if (ANR && pWindow->m_notRespondingTint->goal() != 0.2F) if (ANR && pWindow->m_notRespondingTint->goal() != 0.2F)
@@ -502,7 +502,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
(USE_WORKSPACE_FADE_ALPHA ? pWindow->m_movingToWorkspaceAlpha->value() : 1.F) * pWindow->m_movingFromWorkspaceAlpha->value(); (USE_WORKSPACE_FADE_ALPHA ? pWindow->m_movingToWorkspaceAlpha->value() : 1.F) * pWindow->m_movingFromWorkspaceAlpha->value();
renderdata.alpha = pWindow->m_activeInactiveAlpha->value(); renderdata.alpha = pWindow->m_activeInactiveAlpha->value();
renderdata.decorate = decorate && !pWindow->m_X11DoesntWantBorders && !pWindow->isEffectiveInternalFSMode(FSMODE_FULLSCREEN); renderdata.decorate = decorate && !pWindow->m_X11DoesntWantBorders && !pWindow->isEffectiveInternalFSMode(FSMODE_FULLSCREEN);
renderdata.rounding = standalone || renderdata.dontRound ? 0 : pWindow->rounding() * pMonitor->scale; renderdata.rounding = standalone || renderdata.dontRound ? 0 : pWindow->rounding() * pMonitor->m_scale;
renderdata.roundingPower = standalone || renderdata.dontRound ? 2.0f : pWindow->roundingPower(); renderdata.roundingPower = standalone || renderdata.dontRound ? 2.0f : pWindow->roundingPower();
renderdata.blur = !standalone && *PBLUR && !DONT_BLUR; renderdata.blur = !standalone && *PBLUR && !DONT_BLUR;
renderdata.pWindow = pWindow; renderdata.pWindow = pWindow;
@@ -521,7 +521,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
EMIT_HOOK_EVENT("render", RENDER_PRE_WINDOW); EMIT_HOOK_EVENT("render", RENDER_PRE_WINDOW);
if (*PDIMAROUND && pWindow->m_windowData.dimAround.valueOrDefault() && !m_bRenderingSnapshot && mode != RENDER_PASS_POPUP) { if (*PDIMAROUND && pWindow->m_windowData.dimAround.valueOrDefault() && !m_bRenderingSnapshot && mode != RENDER_PASS_POPUP) {
CBox monbox = {0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->vecTransformedSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->vecTransformedSize.y}; CBox monbox = {0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize.y};
CRectPassElement::SRectData data; CRectPassElement::SRectData data;
data.color = CHyprColor(0, 0, 0, *PDIMAROUND * renderdata.alpha * renderdata.fadeAlpha); data.color = CHyprColor(0, 0, 0, *PDIMAROUND * renderdata.alpha * renderdata.fadeAlpha);
data.box = monbox; data.box = monbox;
@@ -533,7 +533,8 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
// if window is floating and we have a slide animation, clip it to its full bb // if window is floating and we have a slide animation, clip it to its full bb
if (!ignorePosition && pWindow->m_isFloating && !pWindow->isFullscreen() && PWORKSPACE->m_renderOffset->isBeingAnimated() && !pWindow->m_pinned) { if (!ignorePosition && pWindow->m_isFloating && !pWindow->isFullscreen() && PWORKSPACE->m_renderOffset->isBeingAnimated() && !pWindow->m_pinned) {
CRegion rg = pWindow->getFullWindowBoundingBox().translate(-pMonitor->vecPosition + PWORKSPACE->m_renderOffset->value() + pWindow->m_floatingOffset).scale(pMonitor->scale); CRegion rg =
pWindow->getFullWindowBoundingBox().translate(-pMonitor->m_position + PWORKSPACE->m_renderOffset->value() + pWindow->m_floatingOffset).scale(pMonitor->m_scale);
renderdata.clipBox = rg.getExtents(); renderdata.clipBox = rg.getExtents();
} }
@@ -571,8 +572,8 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
renderdata.useNearestNeighbor = true; renderdata.useNearestNeighbor = true;
if (!pWindow->m_windowData.noBlur.valueOrDefault() && pWindow->m_wlSurface->small() && !pWindow->m_wlSurface->m_fillIgnoreSmall && renderdata.blur && *PBLUR) { if (!pWindow->m_windowData.noBlur.valueOrDefault() && pWindow->m_wlSurface->small() && !pWindow->m_wlSurface->m_fillIgnoreSmall && renderdata.blur && *PBLUR) {
CBox wb = {renderdata.pos.x - pMonitor->vecPosition.x, renderdata.pos.y - pMonitor->vecPosition.y, renderdata.w, renderdata.h}; CBox wb = {renderdata.pos.x - pMonitor->m_position.x, renderdata.pos.y - pMonitor->m_position.y, renderdata.w, renderdata.h};
wb.scale(pMonitor->scale).round(); wb.scale(pMonitor->m_scale).round();
CRectPassElement::SRectData data; CRectPassElement::SRectData data;
data.color = CHyprColor(0, 0, 0, 0); data.color = CHyprColor(0, 0, 0, 0);
data.box = wb; data.box = wb;
@@ -699,7 +700,7 @@ void CHyprRenderer::renderLayer(PHLLS pLayer, PHLMONITOR pMonitor, const Time::s
if (*PDIMAROUND && pLayer->m_dimAround && !m_bRenderingSnapshot && !popups) { if (*PDIMAROUND && pLayer->m_dimAround && !m_bRenderingSnapshot && !popups) {
CRectPassElement::SRectData data; CRectPassElement::SRectData data;
data.box = {0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->vecTransformedSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->vecTransformedSize.y}; data.box = {0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize.y};
data.color = CHyprColor(0, 0, 0, *PDIMAROUND * pLayer->m_alpha->value()); data.color = CHyprColor(0, 0, 0, *PDIMAROUND * pLayer->m_alpha->value());
m_sRenderPass.add(makeShared<CRectPassElement>(data)); m_sRenderPass.add(makeShared<CRectPassElement>(data));
} }
@@ -727,7 +728,7 @@ void CHyprRenderer::renderLayer(PHLLS pLayer, PHLMONITOR pMonitor, const Time::s
renderdata.pLS = pLayer; renderdata.pLS = pLayer;
renderdata.blockBlurOptimization = pLayer->m_layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM || pLayer->m_layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND; renderdata.blockBlurOptimization = pLayer->m_layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM || pLayer->m_layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND;
renderdata.clipBox = CBox{0, 0, pMonitor->vecSize.x, pMonitor->vecSize.y}.scale(pMonitor->scale); renderdata.clipBox = CBox{0, 0, pMonitor->m_size.x, pMonitor->m_size.y}.scale(pMonitor->m_scale);
if (renderdata.blur && pLayer->m_ignoreAlpha) { if (renderdata.blur && pLayer->m_ignoreAlpha) {
renderdata.discardMode |= DISCARD_ALPHA; renderdata.discardMode |= DISCARD_ALPHA;
@@ -804,13 +805,13 @@ void CHyprRenderer::renderIMEPopup(CInputPopup* pPopup, PHLMONITOR pMonitor, con
} }
void CHyprRenderer::renderSessionLockSurface(WP<SSessionLockSurface> pSurface, PHLMONITOR pMonitor, const Time::steady_tp& time) { void CHyprRenderer::renderSessionLockSurface(WP<SSessionLockSurface> pSurface, PHLMONITOR pMonitor, const Time::steady_tp& time) {
CSurfacePassElement::SRenderData renderdata = {pMonitor, time, pMonitor->vecPosition, pMonitor->vecPosition}; CSurfacePassElement::SRenderData renderdata = {pMonitor, time, pMonitor->m_position, pMonitor->m_position};
renderdata.blur = false; renderdata.blur = false;
renderdata.surface = pSurface->surface->surface(); renderdata.surface = pSurface->surface->surface();
renderdata.decorate = false; renderdata.decorate = false;
renderdata.w = pMonitor->vecSize.x; renderdata.w = pMonitor->m_size.x;
renderdata.h = pMonitor->vecSize.y; renderdata.h = pMonitor->m_size.y;
renderdata.surface->breadthfirst( renderdata.surface->breadthfirst(
[this, &renderdata, &pSurface](SP<CWLSurfaceResource> s, const Vector2D& offset, void* data) { [this, &renderdata, &pSurface](SP<CWLSurfaceResource> s, const Vector2D& offset, void* data) {
@@ -869,16 +870,16 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
else else
g_pHyprOpenGL->clearWithTex(); // will apply the hypr "wallpaper" g_pHyprOpenGL->clearWithTex(); // will apply the hypr "wallpaper"
for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND]) { for (auto const& ls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND]) {
renderLayer(ls.lock(), pMonitor, time); renderLayer(ls.lock(), pMonitor, time);
} }
for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM]) { for (auto const& ls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM]) {
renderLayer(ls.lock(), pMonitor, time); renderLayer(ls.lock(), pMonitor, time);
} }
for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) { for (auto const& ls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
renderLayer(ls.lock(), pMonitor, time); renderLayer(ls.lock(), pMonitor, time);
} }
for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]) { for (auto const& ls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]) {
renderLayer(ls.lock(), pMonitor, time); renderLayer(ls.lock(), pMonitor, time);
} }
@@ -891,10 +892,10 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
else else
g_pHyprOpenGL->clearWithTex(); // will apply the hypr "wallpaper" g_pHyprOpenGL->clearWithTex(); // will apply the hypr "wallpaper"
for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND]) { for (auto const& ls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND]) {
renderLayer(ls.lock(), pMonitor, time); renderLayer(ls.lock(), pMonitor, time);
} }
for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM]) { for (auto const& ls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM]) {
renderLayer(ls.lock(), pMonitor, time); renderLayer(ls.lock(), pMonitor, time);
} }
} }
@@ -911,11 +912,11 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
for (auto const& ws : g_pCompositor->m_workspaces) { for (auto const& ws : g_pCompositor->m_workspaces) {
if (ws->m_monitor == pMonitor && ws->m_alpha->value() > 0.f && ws->m_isSpecialWorkspace) { if (ws->m_monitor == pMonitor && ws->m_alpha->value() > 0.f && ws->m_isSpecialWorkspace) {
const auto SPECIALANIMPROGRS = ws->m_renderOffset->isBeingAnimated() ? ws->m_renderOffset->getCurveValue() : ws->m_alpha->getCurveValue(); const auto SPECIALANIMPROGRS = ws->m_renderOffset->isBeingAnimated() ? ws->m_renderOffset->getCurveValue() : ws->m_alpha->getCurveValue();
const bool ANIMOUT = !pMonitor->activeSpecialWorkspace; const bool ANIMOUT = !pMonitor->m_activeSpecialWorkspace;
if (*PDIMSPECIAL != 0.f) { if (*PDIMSPECIAL != 0.f) {
CRectPassElement::SRectData data; CRectPassElement::SRectData data;
data.box = {translate.x, translate.y, pMonitor->vecTransformedSize.x * scale, pMonitor->vecTransformedSize.y * scale}; data.box = {translate.x, translate.y, pMonitor->m_transformedSize.x * scale, pMonitor->m_transformedSize.y * scale};
data.color = CHyprColor(0, 0, 0, *PDIMSPECIAL * (ANIMOUT ? (1.0 - SPECIALANIMPROGRS) : SPECIALANIMPROGRS)); data.color = CHyprColor(0, 0, 0, *PDIMSPECIAL * (ANIMOUT ? (1.0 - SPECIALANIMPROGRS) : SPECIALANIMPROGRS));
g_pHyprRenderer->m_sRenderPass.add(makeShared<CRectPassElement>(data)); g_pHyprRenderer->m_sRenderPass.add(makeShared<CRectPassElement>(data));
@@ -923,7 +924,7 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
if (*PBLURSPECIAL && *PBLUR) { if (*PBLURSPECIAL && *PBLUR) {
CRectPassElement::SRectData data; CRectPassElement::SRectData data;
data.box = {translate.x, translate.y, pMonitor->vecTransformedSize.x * scale, pMonitor->vecTransformedSize.y * scale}; data.box = {translate.x, translate.y, pMonitor->m_transformedSize.x * scale, pMonitor->m_transformedSize.y * scale};
data.color = CHyprColor(0, 0, 0, 0); data.color = CHyprColor(0, 0, 0, 0);
data.blur = true; data.blur = true;
data.blurA = (ANIMOUT ? (1.0 - SPECIALANIMPROGRS) : SPECIALANIMPROGRS); data.blurA = (ANIMOUT ? (1.0 - SPECIALANIMPROGRS) : SPECIALANIMPROGRS);
@@ -963,7 +964,7 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
EMIT_HOOK_EVENT("render", RENDER_POST_WINDOWS); EMIT_HOOK_EVENT("render", RENDER_POST_WINDOWS);
// Render surfaces above windows for monitor // Render surfaces above windows for monitor
for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) { for (auto const& ls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
renderLayer(ls.lock(), pMonitor, time); renderLayer(ls.lock(), pMonitor, time);
} }
@@ -972,11 +973,11 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
renderIMEPopup(imep.get(), pMonitor, time); renderIMEPopup(imep.get(), pMonitor, time);
} }
for (auto const& ls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]) { for (auto const& ls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]) {
renderLayer(ls.lock(), pMonitor, time); renderLayer(ls.lock(), pMonitor, time);
} }
for (auto const& lsl : pMonitor->m_aLayerSurfaceLayers) { for (auto const& lsl : pMonitor->m_layerSurfaceLayers) {
for (auto const& ls : lsl) { for (auto const& ls : lsl) {
renderLayer(ls.lock(), pMonitor, time, true); renderLayer(ls.lock(), pMonitor, time, true);
} }
@@ -993,7 +994,7 @@ void CHyprRenderer::renderLockscreen(PHLMONITOR pMonitor, const Time::steady_tp&
if (g_pSessionLockManager->isSessionLocked()) { if (g_pSessionLockManager->isSessionLocked()) {
Vector2D translate = {geometry.x, geometry.y}; Vector2D translate = {geometry.x, geometry.y};
const auto PSLS = g_pSessionLockManager->getSessionLockSurfaceForMonitor(pMonitor->ID); const auto PSLS = g_pSessionLockManager->getSessionLockSurfaceForMonitor(pMonitor->m_id);
if (!PSLS) { if (!PSLS) {
if (g_pSessionLockManager->shallConsiderLockMissing()) if (g_pSessionLockManager->shallConsiderLockMissing())
renderSessionLockMissing(pMonitor); renderSessionLockMissing(pMonitor);
@@ -1001,26 +1002,26 @@ void CHyprRenderer::renderLockscreen(PHLMONITOR pMonitor, const Time::steady_tp&
renderSessionLockSurface(PSLS, pMonitor, now); renderSessionLockSurface(PSLS, pMonitor, now);
// render layers and then their popups for abovelock rule // render layers and then their popups for abovelock rule
for (auto const& lsl : pMonitor->m_aLayerSurfaceLayers) { for (auto const& lsl : pMonitor->m_layerSurfaceLayers) {
for (auto const& ls : lsl) { for (auto const& ls : lsl) {
renderLayer(ls.lock(), pMonitor, now, false, true); renderLayer(ls.lock(), pMonitor, now, false, true);
} }
} }
for (auto const& lsl : pMonitor->m_aLayerSurfaceLayers) { for (auto const& lsl : pMonitor->m_layerSurfaceLayers) {
for (auto const& ls : lsl) { for (auto const& ls : lsl) {
renderLayer(ls.lock(), pMonitor, now, true, true); renderLayer(ls.lock(), pMonitor, now, true, true);
} }
} }
g_pSessionLockManager->onLockscreenRenderedOnMonitor(pMonitor->ID); g_pSessionLockManager->onLockscreenRenderedOnMonitor(pMonitor->m_id);
} }
} }
} }
void CHyprRenderer::renderSessionLockMissing(PHLMONITOR pMonitor) { void CHyprRenderer::renderSessionLockMissing(PHLMONITOR pMonitor) {
const auto ALPHA = g_pSessionLockManager->getRedScreenAlphaForMonitor(pMonitor->ID); const auto ALPHA = g_pSessionLockManager->getRedScreenAlphaForMonitor(pMonitor->m_id);
CBox monbox = {{}, pMonitor->vecPixelSize}; CBox monbox = {{}, pMonitor->m_pixelSize};
const bool ANY_PRESENT = g_pSessionLockManager->anySessionLockSurfacesPresent(); const bool ANY_PRESENT = g_pSessionLockManager->anySessionLockSurfacesPresent();
@@ -1041,7 +1042,7 @@ void CHyprRenderer::renderSessionLockMissing(PHLMONITOR pMonitor) {
if (ALPHA < 1.f) /* animate */ if (ALPHA < 1.f) /* animate */
damageMonitor(pMonitor); damageMonitor(pMonitor);
else else
g_pSessionLockManager->onLockscreenRenderedOnMonitor(pMonitor->ID); g_pSessionLockManager->onLockscreenRenderedOnMonitor(pMonitor->m_id);
} }
void CHyprRenderer::calculateUVForSurface(PHLWINDOW pWindow, SP<CWLSurfaceResource> pSurface, PHLMONITOR pMonitor, bool main, const Vector2D& projSize, void CHyprRenderer::calculateUVForSurface(PHLWINDOW pWindow, SP<CWLSurfaceResource> pSurface, PHLMONITOR pMonitor, bool main, const Vector2D& projSize,
@@ -1081,10 +1082,10 @@ void CHyprRenderer::calculateUVForSurface(PHLWINDOW pWindow, SP<CWLSurfaceResour
// to let the apps know to NOT add CSD. Also if source is there. // to let the apps know to NOT add CSD. Also if source is there.
// there is no way to fix this if that's the case // there is no way to fix this if that's the case
if (*PEXPANDEDGES) { if (*PEXPANDEDGES) {
const auto MONITOR_WL_SCALE = std::ceil(pMonitor->scale); const auto MONITOR_WL_SCALE = std::ceil(pMonitor->m_scale);
const bool SCALE_UNAWARE = MONITOR_WL_SCALE != pSurface->current.scale && !pSurface->current.viewport.hasDestination; const bool SCALE_UNAWARE = MONITOR_WL_SCALE != pSurface->current.scale && !pSurface->current.viewport.hasDestination;
const auto EXPECTED_SIZE = const auto EXPECTED_SIZE =
((pSurface->current.viewport.hasDestination ? pSurface->current.viewport.destination : pSurface->current.bufferSize / pSurface->current.scale) * pMonitor->scale) ((pSurface->current.viewport.hasDestination ? pSurface->current.viewport.destination : pSurface->current.bufferSize / pSurface->current.scale) * pMonitor->m_scale)
.round(); .round();
if (!SCALE_UNAWARE && (EXPECTED_SIZE.x < projSize.x || EXPECTED_SIZE.y < projSize.y)) { if (!SCALE_UNAWARE && (EXPECTED_SIZE.x < projSize.x || EXPECTED_SIZE.y < projSize.y)) {
// this will not work with shm AFAIK, idk why. // this will not work with shm AFAIK, idk why.
@@ -1194,7 +1195,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
if (!g_pCompositor->m_sessionActive) if (!g_pCompositor->m_sessionActive)
return; return;
if (pMonitor->ID == m_pMostHzMonitor->ID || if (pMonitor->m_id == m_pMostHzMonitor->m_id ||
*PVFR == 1) { // unfortunately with VFR we don't have the guarantee mostHz is going to be updated all the time, so we have to ignore that *PVFR == 1) { // unfortunately with VFR we don't have the guarantee mostHz is going to be updated all the time, so we have to ignore that
g_pCompositor->sanityCheckWorkspaces(); g_pCompositor->sanityCheckWorkspaces();
@@ -1204,18 +1205,18 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
g_pConfigManager->performMonitorReload(); g_pConfigManager->performMonitorReload();
} }
if (pMonitor->scheduledRecalc) { if (pMonitor->m_scheduledRecalc) {
pMonitor->scheduledRecalc = false; pMonitor->m_scheduledRecalc = false;
g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitor->ID); g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitor->m_id);
} }
if (!pMonitor->output->needsFrame && pMonitor->forceFullFrames == 0) if (!pMonitor->m_output->needsFrame && pMonitor->m_forceFullFrames == 0)
return; return;
// tearing and DS first // tearing and DS first
bool shouldTear = false; bool shouldTear = false;
if (pMonitor->tearingState.nextRenderTorn) { if (pMonitor->m_tearingState.nextRenderTorn) {
pMonitor->tearingState.nextRenderTorn = false; pMonitor->m_tearingState.nextRenderTorn = false;
if (!*PTEARINGENABLED) { if (!*PTEARINGENABLED) {
Debug::log(WARN, "Tearing commit requested but the master switch general:allow_tearing is off, ignoring"); Debug::log(WARN, "Tearing commit requested but the master switch general:allow_tearing is off, ignoring");
@@ -1227,32 +1228,32 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
return; return;
} }
if (!pMonitor->tearingState.canTear) { if (!pMonitor->m_tearingState.canTear) {
Debug::log(WARN, "Tearing commit requested but monitor doesn't support it, ignoring"); Debug::log(WARN, "Tearing commit requested but monitor doesn't support it, ignoring");
return; return;
} }
if (!pMonitor->solitaryClient.expired()) if (!pMonitor->m_solitaryClient.expired())
shouldTear = true; shouldTear = true;
} }
pMonitor->tearingState.activelyTearing = shouldTear; pMonitor->m_tearingState.activelyTearing = shouldTear;
if ((*PDIRECTSCANOUT == 1 || if ((*PDIRECTSCANOUT == 1 ||
(*PDIRECTSCANOUT == 2 && pMonitor->activeWorkspace && pMonitor->activeWorkspace->m_hasFullscreenWindow && (*PDIRECTSCANOUT == 2 && pMonitor->m_activeWorkspace && pMonitor->m_activeWorkspace->m_hasFullscreenWindow &&
pMonitor->activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN && pMonitor->activeWorkspace->getFullscreenWindow()->getContentType() == CONTENT_TYPE_GAME)) && pMonitor->m_activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN && pMonitor->m_activeWorkspace->getFullscreenWindow()->getContentType() == CONTENT_TYPE_GAME)) &&
!shouldTear) { !shouldTear) {
if (pMonitor->attemptDirectScanout()) { if (pMonitor->attemptDirectScanout()) {
return; return;
} else if (!pMonitor->lastScanout.expired()) { } else if (!pMonitor->m_lastScanout.expired()) {
Debug::log(LOG, "Left a direct scanout."); Debug::log(LOG, "Left a direct scanout.");
pMonitor->lastScanout.reset(); pMonitor->m_lastScanout.reset();
// reset DRM format, but only if needed since it might modeset // reset DRM format, but only if needed since it might modeset
if (pMonitor->output->state->state().drmFormat != pMonitor->prevDrmFormat) if (pMonitor->m_output->state->state().drmFormat != pMonitor->m_prevDrmFormat)
pMonitor->output->state->setFormat(pMonitor->prevDrmFormat); pMonitor->m_output->state->setFormat(pMonitor->m_prevDrmFormat);
pMonitor->drmFormat = pMonitor->prevDrmFormat; pMonitor->m_drmFormat = pMonitor->m_prevDrmFormat;
} }
} }
@@ -1261,9 +1262,9 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
const auto NOW = Time::steadyNow(); const auto NOW = Time::steadyNow();
// check the damage // check the damage
bool hasChanged = pMonitor->output->needsFrame || pMonitor->damage.hasChanged(); bool hasChanged = pMonitor->m_output->needsFrame || pMonitor->m_damage.hasChanged();
if (!hasChanged && *PDAMAGETRACKINGMODE != DAMAGE_TRACKING_NONE && pMonitor->forceFullFrames == 0 && damageBlinkCleanup == 0) if (!hasChanged && *PDAMAGETRACKINGMODE != DAMAGE_TRACKING_NONE && pMonitor->m_forceFullFrames == 0 && damageBlinkCleanup == 0)
return; return;
if (*PDAMAGETRACKINGMODE == -1) { if (*PDAMAGETRACKINGMODE == -1) {
@@ -1273,10 +1274,10 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
EMIT_HOOK_EVENT("render", RENDER_PRE); EMIT_HOOK_EVENT("render", RENDER_PRE);
pMonitor->renderingActive = true; pMonitor->m_renderingActive = true;
// we need to cleanup fading out when rendering the appropriate context // we need to cleanup fading out when rendering the appropriate context
g_pCompositor->cleanupFadingOut(pMonitor->ID); g_pCompositor->cleanupFadingOut(pMonitor->m_id);
// TODO: this is getting called with extents being 0,0,0,0 should it be? // TODO: this is getting called with extents being 0,0,0,0 should it be?
// potentially can save on resources. // potentially can save on resources.
@@ -1301,7 +1302,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
g_pHyprOpenGL->m_RenderData.mouseZoomFactor = zoomInFactorFirstLaunch; g_pHyprOpenGL->m_RenderData.mouseZoomFactor = zoomInFactorFirstLaunch;
g_pHyprOpenGL->m_RenderData.mouseZoomUseMouse = false; g_pHyprOpenGL->m_RenderData.mouseZoomUseMouse = false;
g_pHyprOpenGL->m_RenderData.useNearestNeighbor = false; g_pHyprOpenGL->m_RenderData.useNearestNeighbor = false;
pMonitor->forceFullFrames = 10; pMonitor->m_forceFullFrames = 10;
} }
CRegion damage, finalDamage; CRegion damage, finalDamage;
@@ -1311,18 +1312,18 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
} }
// if we have no tracking or full tracking, invalidate the entire monitor // if we have no tracking or full tracking, invalidate the entire monitor
if (*PDAMAGETRACKINGMODE == DAMAGE_TRACKING_NONE || *PDAMAGETRACKINGMODE == DAMAGE_TRACKING_MONITOR || pMonitor->forceFullFrames > 0 || damageBlinkCleanup > 0) if (*PDAMAGETRACKINGMODE == DAMAGE_TRACKING_NONE || *PDAMAGETRACKINGMODE == DAMAGE_TRACKING_MONITOR || pMonitor->m_forceFullFrames > 0 || damageBlinkCleanup > 0)
damage = {0, 0, (int)pMonitor->vecTransformedSize.x * 10, (int)pMonitor->vecTransformedSize.y * 10}; damage = {0, 0, (int)pMonitor->m_transformedSize.x * 10, (int)pMonitor->m_transformedSize.y * 10};
finalDamage = damage; finalDamage = damage;
// update damage in renderdata as we modified it // update damage in renderdata as we modified it
g_pHyprOpenGL->setDamage(damage, finalDamage); g_pHyprOpenGL->setDamage(damage, finalDamage);
if (pMonitor->forceFullFrames > 0) { if (pMonitor->m_forceFullFrames > 0) {
pMonitor->forceFullFrames -= 1; pMonitor->m_forceFullFrames -= 1;
if (pMonitor->forceFullFrames > 10) if (pMonitor->m_forceFullFrames > 10)
pMonitor->forceFullFrames = 0; pMonitor->m_forceFullFrames = 0;
} }
EMIT_HOOK_EVENT("render", RENDER_BEGIN); EMIT_HOOK_EVENT("render", RENDER_BEGIN);
@@ -1330,7 +1331,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
bool renderCursor = true; bool renderCursor = true;
if (!finalDamage.empty()) { if (!finalDamage.empty()) {
if (pMonitor->solitaryClient.expired()) { if (pMonitor->m_solitaryClient.expired()) {
if (pMonitor->isMirror()) { if (pMonitor->isMirror()) {
g_pHyprOpenGL->blend(false); g_pHyprOpenGL->blend(false);
g_pHyprOpenGL->renderMirrored(); g_pHyprOpenGL->renderMirrored();
@@ -1338,8 +1339,8 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
EMIT_HOOK_EVENT("render", RENDER_POST_MIRROR); EMIT_HOOK_EVENT("render", RENDER_POST_MIRROR);
renderCursor = false; renderCursor = false;
} else { } else {
CBox renderBox = {0, 0, (int)pMonitor->vecPixelSize.x, (int)pMonitor->vecPixelSize.y}; CBox renderBox = {0, 0, (int)pMonitor->m_pixelSize.x, (int)pMonitor->m_pixelSize.y};
renderWorkspace(pMonitor, pMonitor->activeWorkspace, NOW, renderBox); renderWorkspace(pMonitor, pMonitor->m_activeWorkspace, NOW, renderBox);
renderLockscreen(pMonitor, NOW, renderBox); renderLockscreen(pMonitor, NOW, renderBox);
@@ -1357,7 +1358,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
if (*PDAMAGEBLINK && damageBlinkCleanup == 0) { if (*PDAMAGEBLINK && damageBlinkCleanup == 0) {
CRectPassElement::SRectData data; CRectPassElement::SRectData data;
data.box = {0, 0, pMonitor->vecTransformedSize.x, pMonitor->vecTransformedSize.y}; data.box = {0, 0, pMonitor->m_transformedSize.x, pMonitor->m_transformedSize.y};
data.color = CHyprColor(1.0, 0.0, 1.0, 100.0 / 255.0); data.color = CHyprColor(1.0, 0.0, 1.0, 100.0 / 255.0);
m_sRenderPass.add(makeShared<CRectPassElement>(data)); m_sRenderPass.add(makeShared<CRectPassElement>(data));
damageBlinkCleanup = 1; damageBlinkCleanup = 1;
@@ -1368,18 +1369,18 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
} }
} }
} else } else
renderWindow(pMonitor->solitaryClient.lock(), pMonitor, NOW, false, RENDER_PASS_MAIN /* solitary = no popups */); renderWindow(pMonitor->m_solitaryClient.lock(), pMonitor, NOW, false, RENDER_PASS_MAIN /* solitary = no popups */);
} else if (!pMonitor->isMirror()) { } else if (!pMonitor->isMirror()) {
sendFrameEventsToWorkspace(pMonitor, pMonitor->activeWorkspace, NOW); sendFrameEventsToWorkspace(pMonitor, pMonitor->m_activeWorkspace, NOW);
if (pMonitor->activeSpecialWorkspace) if (pMonitor->m_activeSpecialWorkspace)
sendFrameEventsToWorkspace(pMonitor, pMonitor->activeSpecialWorkspace, NOW); sendFrameEventsToWorkspace(pMonitor, pMonitor->m_activeSpecialWorkspace, NOW);
} }
renderCursor = renderCursor && shouldRenderCursor(); renderCursor = renderCursor && shouldRenderCursor();
if (renderCursor) { if (renderCursor) {
TRACY_GPU_ZONE("RenderCursor"); TRACY_GPU_ZONE("RenderCursor");
g_pPointerManager->renderSoftwareCursorsFor(pMonitor->self.lock(), NOW, g_pHyprOpenGL->m_RenderData.damage); g_pPointerManager->renderSoftwareCursorsFor(pMonitor->m_self.lock(), NOW, g_pHyprOpenGL->m_RenderData.damage);
} }
EMIT_HOOK_EVENT("render", RENDER_LAST_MOMENT); EMIT_HOOK_EVENT("render", RENDER_LAST_MOMENT);
@@ -1390,35 +1391,35 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
CRegion frameDamage{g_pHyprOpenGL->m_RenderData.damage}; CRegion frameDamage{g_pHyprOpenGL->m_RenderData.damage};
const auto TRANSFORM = invertTransform(pMonitor->transform); const auto TRANSFORM = invertTransform(pMonitor->m_transform);
frameDamage.transform(wlTransformToHyprutils(TRANSFORM), pMonitor->vecTransformedSize.x, pMonitor->vecTransformedSize.y); frameDamage.transform(wlTransformToHyprutils(TRANSFORM), pMonitor->m_transformedSize.x, pMonitor->m_transformedSize.y);
if (*PDAMAGETRACKINGMODE == DAMAGE_TRACKING_NONE || *PDAMAGETRACKINGMODE == DAMAGE_TRACKING_MONITOR) if (*PDAMAGETRACKINGMODE == DAMAGE_TRACKING_NONE || *PDAMAGETRACKINGMODE == DAMAGE_TRACKING_MONITOR)
frameDamage.add(0, 0, (int)pMonitor->vecTransformedSize.x, (int)pMonitor->vecTransformedSize.y); frameDamage.add(0, 0, (int)pMonitor->m_transformedSize.x, (int)pMonitor->m_transformedSize.y);
if (*PDAMAGEBLINK) if (*PDAMAGEBLINK)
frameDamage.add(damage); frameDamage.add(damage);
if (!pMonitor->mirrors.empty()) if (!pMonitor->m_mirrors.empty())
damageMirrorsWith(pMonitor, frameDamage); damageMirrorsWith(pMonitor, frameDamage);
pMonitor->renderingActive = false; pMonitor->m_renderingActive = false;
EMIT_HOOK_EVENT("render", RENDER_POST); EMIT_HOOK_EVENT("render", RENDER_POST);
pMonitor->output->state->addDamage(frameDamage); pMonitor->m_output->state->addDamage(frameDamage);
pMonitor->output->state->setPresentationMode(shouldTear ? Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_IMMEDIATE : pMonitor->m_output->state->setPresentationMode(shouldTear ? Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_IMMEDIATE :
Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_VSYNC); Aquamarine::eOutputPresentationMode::AQ_OUTPUT_PRESENTATION_VSYNC);
commitPendingAndDoExplicitSync(pMonitor); commitPendingAndDoExplicitSync(pMonitor);
if (shouldTear) if (shouldTear)
pMonitor->tearingState.busy = true; pMonitor->m_tearingState.busy = true;
if (*PDAMAGEBLINK || *PVFR == 0 || pMonitor->pendingFrame) if (*PDAMAGEBLINK || *PVFR == 0 || pMonitor->m_pendingFrame)
g_pCompositor->scheduleFrameForMonitor(pMonitor, Aquamarine::IOutput::AQ_SCHEDULE_RENDER_MONITOR); g_pCompositor->scheduleFrameForMonitor(pMonitor, Aquamarine::IOutput::AQ_SCHEDULE_RENDER_MONITOR);
pMonitor->pendingFrame = false; pMonitor->m_pendingFrame = false;
const float durationUs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - renderStart).count() / 1000.f; const float durationUs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - renderStart).count() / 1000.f;
g_pDebugOverlay->renderData(pMonitor, durationUs); g_pDebugOverlay->renderData(pMonitor, durationUs);
@@ -1478,12 +1479,12 @@ static hdr_output_metadata createHDRMetadata(SImageDescription settings, A
bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) { bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) {
static auto PCT = CConfigValue<Hyprlang::INT>("render:send_content_type"); static auto PCT = CConfigValue<Hyprlang::INT>("render:send_content_type");
static auto PPASS = CConfigValue<Hyprlang::INT>("render:cm_fs_passthrough"); static auto PPASS = CConfigValue<Hyprlang::INT>("render:cm_fs_passthrough");
const bool PHDR = pMonitor->imageDescription.transferFunction == CM_TRANSFER_FUNCTION_ST2084_PQ; const bool PHDR = pMonitor->m_imageDescription.transferFunction == CM_TRANSFER_FUNCTION_ST2084_PQ;
const bool SUPPORTSPQ = pMonitor->output->parsedEDID.hdrMetadata.has_value() ? pMonitor->output->parsedEDID.hdrMetadata->supportsPQ : false; const bool SUPPORTSPQ = pMonitor->m_output->parsedEDID.hdrMetadata.has_value() ? pMonitor->m_output->parsedEDID.hdrMetadata->supportsPQ : false;
Debug::log(TRACE, "ColorManagement supportsBT2020 {}, supportsPQ {}", pMonitor->output->parsedEDID.supportsBT2020, SUPPORTSPQ); Debug::log(TRACE, "ColorManagement supportsBT2020 {}, supportsPQ {}", pMonitor->m_output->parsedEDID.supportsBT2020, SUPPORTSPQ);
if (pMonitor->output->parsedEDID.supportsBT2020 && SUPPORTSPQ) { if (pMonitor->m_output->parsedEDID.supportsBT2020 && SUPPORTSPQ) {
// HDR metadata determined by // HDR metadata determined by
// PPASS = 0 monitor settings // PPASS = 0 monitor settings
// PPASS = 1 // PPASS = 1
@@ -1496,8 +1497,8 @@ bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) {
bool wantHDR = PHDR; bool wantHDR = PHDR;
bool hdrIsHandled = false; bool hdrIsHandled = false;
if (*PPASS && pMonitor->activeWorkspace && pMonitor->activeWorkspace->m_hasFullscreenWindow && pMonitor->activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) { if (*PPASS && pMonitor->m_activeWorkspace && pMonitor->m_activeWorkspace->m_hasFullscreenWindow && pMonitor->m_activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) {
const auto WINDOW = pMonitor->activeWorkspace->getFullscreenWindow(); const auto WINDOW = pMonitor->m_activeWorkspace->getFullscreenWindow();
const auto ROOT_SURF = WINDOW->m_wlSurface->resource(); const auto ROOT_SURF = WINDOW->m_wlSurface->resource();
const auto SURF = const auto SURF =
ROOT_SURF->findFirstPreorder([ROOT_SURF](SP<CWLSurfaceResource> surf) { return surf->colorManagement.valid() && surf->extends() == ROOT_SURF->extends(); }); ROOT_SURF->findFirstPreorder([ROOT_SURF](SP<CWLSurfaceResource> surf) { return surf->colorManagement.valid() && surf->extends() == ROOT_SURF->extends(); });
@@ -1509,28 +1510,28 @@ bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) {
(!wantHDR || SURF->colorManagement->imageDescription().transferFunction == CM_TRANSFER_FUNCTION_ST2084_PQ)) { (!wantHDR || SURF->colorManagement->imageDescription().transferFunction == CM_TRANSFER_FUNCTION_ST2084_PQ)) {
bool needsHdrMetadataUpdate = SURF->colorManagement->needsHdrMetadataUpdate() || pMonitor->m_previousFSWindow != WINDOW; bool needsHdrMetadataUpdate = SURF->colorManagement->needsHdrMetadataUpdate() || pMonitor->m_previousFSWindow != WINDOW;
if (SURF->colorManagement->needsHdrMetadataUpdate()) if (SURF->colorManagement->needsHdrMetadataUpdate())
SURF->colorManagement->setHDRMetadata(createHDRMetadata(SURF->colorManagement->imageDescription(), pMonitor->output->parsedEDID)); SURF->colorManagement->setHDRMetadata(createHDRMetadata(SURF->colorManagement->imageDescription(), pMonitor->m_output->parsedEDID));
if (needsHdrMetadataUpdate) if (needsHdrMetadataUpdate)
pMonitor->output->state->setHDRMetadata(SURF->colorManagement->hdrMetadata()); pMonitor->m_output->state->setHDRMetadata(SURF->colorManagement->hdrMetadata());
hdrIsHandled = true; hdrIsHandled = true;
} }
pMonitor->m_previousFSWindow = WINDOW; pMonitor->m_previousFSWindow = WINDOW;
} }
if (!hdrIsHandled) { if (!hdrIsHandled) {
if ((pMonitor->output->state->state().hdrMetadata.hdmi_metadata_type1.eotf == 2) != wantHDR) if ((pMonitor->m_output->state->state().hdrMetadata.hdmi_metadata_type1.eotf == 2) != wantHDR)
pMonitor->output->state->setHDRMetadata(wantHDR ? createHDRMetadata(pMonitor->imageDescription, pMonitor->output->parsedEDID) : NO_HDR_METADATA); pMonitor->m_output->state->setHDRMetadata(wantHDR ? createHDRMetadata(pMonitor->m_imageDescription, pMonitor->m_output->parsedEDID) : NO_HDR_METADATA);
pMonitor->m_previousFSWindow.reset(); pMonitor->m_previousFSWindow.reset();
} }
} }
const bool needsWCG = pMonitor->output->state->state().hdrMetadata.hdmi_metadata_type1.eotf == 2 || pMonitor->imageDescription.primariesNamed == CM_PRIMARIES_BT2020; const bool needsWCG = pMonitor->m_output->state->state().hdrMetadata.hdmi_metadata_type1.eotf == 2 || pMonitor->m_imageDescription.primariesNamed == CM_PRIMARIES_BT2020;
if (pMonitor->output->state->state().wideColorGamut != needsWCG) { if (pMonitor->m_output->state->state().wideColorGamut != needsWCG) {
Debug::log(TRACE, "Setting wide color gamut {}", needsWCG ? "on" : "off"); Debug::log(TRACE, "Setting wide color gamut {}", needsWCG ? "on" : "off");
pMonitor->output->state->setWideColorGamut(needsWCG); pMonitor->m_output->state->setWideColorGamut(needsWCG);
// FIXME do not trust enabled10bit, auto switch to 10bit and back if needed // FIXME do not trust enabled10bit, auto switch to 10bit and back if needed
if (needsWCG && !pMonitor->enabled10bit) { if (needsWCG && !pMonitor->m_enabled10bit) {
Debug::log(WARN, "Wide color gamut is enabled but the display is not in 10bit mode"); Debug::log(WARN, "Wide color gamut is enabled but the display is not in 10bit mode");
static bool shown = false; static bool shown = false;
if (!shown) { if (!shown) {
@@ -1541,32 +1542,32 @@ bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) {
} }
if (*PCT) { if (*PCT) {
if (pMonitor->activeWorkspace && pMonitor->activeWorkspace->m_hasFullscreenWindow && pMonitor->activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) { if (pMonitor->m_activeWorkspace && pMonitor->m_activeWorkspace->m_hasFullscreenWindow && pMonitor->m_activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) {
const auto WINDOW = pMonitor->activeWorkspace->getFullscreenWindow(); const auto WINDOW = pMonitor->m_activeWorkspace->getFullscreenWindow();
pMonitor->output->state->setContentType(NContentType::toDRM(WINDOW->getContentType())); pMonitor->m_output->state->setContentType(NContentType::toDRM(WINDOW->getContentType()));
} else } else
pMonitor->output->state->setContentType(NContentType::toDRM(CONTENT_TYPE_NONE)); pMonitor->m_output->state->setContentType(NContentType::toDRM(CONTENT_TYPE_NONE));
} }
if (pMonitor->ctmUpdated) { if (pMonitor->m_ctmUpdated) {
pMonitor->ctmUpdated = false; pMonitor->m_ctmUpdated = false;
pMonitor->output->state->setCTM(pMonitor->ctm); pMonitor->m_output->state->setCTM(pMonitor->m_ctm);
} }
bool ok = pMonitor->state.commit(); bool ok = pMonitor->m_state.commit();
if (!ok) { if (!ok) {
if (pMonitor->inFence.isValid()) { if (pMonitor->m_inFence.isValid()) {
Debug::log(TRACE, "Monitor state commit failed, retrying without a fence"); Debug::log(TRACE, "Monitor state commit failed, retrying without a fence");
pMonitor->output->state->resetExplicitFences(); pMonitor->m_output->state->resetExplicitFences();
ok = pMonitor->state.commit(); ok = pMonitor->m_state.commit();
} }
if (!ok) { if (!ok) {
Debug::log(TRACE, "Monitor state commit failed"); Debug::log(TRACE, "Monitor state commit failed");
// rollback the buffer to avoid writing to the front buffer that is being // rollback the buffer to avoid writing to the front buffer that is being
// displayed // displayed
pMonitor->output->swapchain->rollback(); pMonitor->m_output->swapchain->rollback();
pMonitor->damage.damageEntire(); pMonitor->m_damage.damageEntire();
} }
} }
@@ -1575,11 +1576,11 @@ bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) {
void CHyprRenderer::renderWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, const Time::steady_tp& now, const CBox& geometry) { void CHyprRenderer::renderWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE pWorkspace, const Time::steady_tp& now, const CBox& geometry) {
Vector2D translate = {geometry.x, geometry.y}; Vector2D translate = {geometry.x, geometry.y};
float scale = (float)geometry.width / pMonitor->vecPixelSize.x; float scale = (float)geometry.width / pMonitor->m_pixelSize.x;
TRACY_GPU_ZONE("RenderWorkspace"); TRACY_GPU_ZONE("RenderWorkspace");
if (!DELTALESSTHAN((double)geometry.width / (double)geometry.height, pMonitor->vecPixelSize.x / pMonitor->vecPixelSize.y, 0.01)) { if (!DELTALESSTHAN((double)geometry.width / (double)geometry.height, pMonitor->m_pixelSize.x / pMonitor->m_pixelSize.y, 0.01)) {
Debug::log(ERR, "Ignoring geometry in renderWorkspace: aspect ratio mismatch"); Debug::log(ERR, "Ignoring geometry in renderWorkspace: aspect ratio mismatch");
scale = 1.f; scale = 1.f;
translate = Vector2D{}; translate = Vector2D{};
@@ -1599,7 +1600,7 @@ void CHyprRenderer::sendFrameEventsToWorkspace(PHLMONITOR pMonitor, PHLWORKSPACE
w->m_wlSurface->resource()->breadthfirst([now](SP<CWLSurfaceResource> r, const Vector2D& offset, void* d) { r->frame(now); }, nullptr); w->m_wlSurface->resource()->breadthfirst([now](SP<CWLSurfaceResource> r, const Vector2D& offset, void* d) { r->frame(now); }, nullptr);
} }
for (auto const& lsl : pMonitor->m_aLayerSurfaceLayers) { for (auto const& lsl : pMonitor->m_layerSurfaceLayers) {
for (auto const& ls : lsl) { for (auto const& ls : lsl) {
if (ls->m_fadingOut || !ls->m_surface->resource()) if (ls->m_fadingOut || !ls->m_surface->resource())
continue; continue;
@@ -1677,7 +1678,7 @@ static void applyExclusive(CBox& usableArea, uint32_t anchor, int32_t exclusive,
} }
void CHyprRenderer::arrangeLayerArray(PHLMONITOR pMonitor, const std::vector<PHLLSREF>& layerSurfaces, bool exclusiveZone, CBox* usableArea) { void CHyprRenderer::arrangeLayerArray(PHLMONITOR pMonitor, const std::vector<PHLLSREF>& layerSurfaces, bool exclusiveZone, CBox* usableArea) {
CBox full_area = {pMonitor->vecPosition.x, pMonitor->vecPosition.y, pMonitor->vecSize.x, pMonitor->vecSize.y}; CBox full_area = {pMonitor->m_position.x, pMonitor->m_position.y, pMonitor->m_size.x, pMonitor->m_size.y};
for (auto const& ls : layerSurfaces) { for (auto const& ls : layerSurfaces) {
if (!ls || ls->m_fadingOut || ls->m_readyToDelete || !ls->m_layerSurface || ls->m_noProcess) if (!ls || ls->m_fadingOut || ls->m_readyToDelete || !ls->m_layerSurface || ls->m_noProcess)
@@ -1772,44 +1773,44 @@ void CHyprRenderer::arrangeLayersForMonitor(const MONITORID& monitor) {
return; return;
// Reset the reserved // Reset the reserved
PMONITOR->vecReservedBottomRight = Vector2D(); PMONITOR->m_reservedBottomRight = Vector2D();
PMONITOR->vecReservedTopLeft = Vector2D(); PMONITOR->m_reservedTopLeft = Vector2D();
CBox usableArea = {PMONITOR->vecPosition.x, PMONITOR->vecPosition.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y}; CBox usableArea = {PMONITOR->m_position.x, PMONITOR->m_position.y, PMONITOR->m_size.x, PMONITOR->m_size.y};
if (g_pHyprError->active() && g_pCompositor->m_lastMonitor == PMONITOR->self) { if (g_pHyprError->active() && g_pCompositor->m_lastMonitor == PMONITOR->m_self) {
const auto HEIGHT = g_pHyprError->height(); const auto HEIGHT = g_pHyprError->height();
if (*BAR_POSITION == 0) { if (*BAR_POSITION == 0) {
PMONITOR->vecReservedTopLeft.y = HEIGHT; PMONITOR->m_reservedTopLeft.y = HEIGHT;
usableArea.y += HEIGHT; usableArea.y += HEIGHT;
usableArea.h -= HEIGHT; usableArea.h -= HEIGHT;
} else { } else {
PMONITOR->vecReservedBottomRight.y = HEIGHT; PMONITOR->m_reservedBottomRight.y = HEIGHT;
usableArea.h -= HEIGHT; usableArea.h -= HEIGHT;
} }
} }
for (auto& la : PMONITOR->m_aLayerSurfaceLayers) { for (auto& la : PMONITOR->m_layerSurfaceLayers) {
std::stable_sort(la.begin(), la.end(), [](const PHLLSREF& a, const PHLLSREF& b) { return a->m_order > b->m_order; }); std::stable_sort(la.begin(), la.end(), [](const PHLLSREF& a, const PHLLSREF& b) { return a->m_order > b->m_order; });
} }
for (auto const& la : PMONITOR->m_aLayerSurfaceLayers) for (auto const& la : PMONITOR->m_layerSurfaceLayers)
arrangeLayerArray(PMONITOR, la, true, &usableArea); arrangeLayerArray(PMONITOR, la, true, &usableArea);
for (auto const& la : PMONITOR->m_aLayerSurfaceLayers) for (auto const& la : PMONITOR->m_layerSurfaceLayers)
arrangeLayerArray(PMONITOR, la, false, &usableArea); arrangeLayerArray(PMONITOR, la, false, &usableArea);
PMONITOR->vecReservedTopLeft = Vector2D(usableArea.x, usableArea.y) - PMONITOR->vecPosition; PMONITOR->m_reservedTopLeft = Vector2D(usableArea.x, usableArea.y) - PMONITOR->m_position;
PMONITOR->vecReservedBottomRight = PMONITOR->vecSize - Vector2D(usableArea.width, usableArea.height) - PMONITOR->vecReservedTopLeft; PMONITOR->m_reservedBottomRight = PMONITOR->m_size - Vector2D(usableArea.width, usableArea.height) - PMONITOR->m_reservedTopLeft;
auto ADDITIONALRESERVED = g_pConfigManager->m_mAdditionalReservedAreas.find(PMONITOR->szName); auto ADDITIONALRESERVED = g_pConfigManager->m_mAdditionalReservedAreas.find(PMONITOR->m_name);
if (ADDITIONALRESERVED == g_pConfigManager->m_mAdditionalReservedAreas.end()) { if (ADDITIONALRESERVED == g_pConfigManager->m_mAdditionalReservedAreas.end()) {
ADDITIONALRESERVED = g_pConfigManager->m_mAdditionalReservedAreas.find(""); // glob wildcard ADDITIONALRESERVED = g_pConfigManager->m_mAdditionalReservedAreas.find(""); // glob wildcard
} }
if (ADDITIONALRESERVED != g_pConfigManager->m_mAdditionalReservedAreas.end()) { if (ADDITIONALRESERVED != g_pConfigManager->m_mAdditionalReservedAreas.end()) {
PMONITOR->vecReservedTopLeft = PMONITOR->vecReservedTopLeft + Vector2D(ADDITIONALRESERVED->second.left, ADDITIONALRESERVED->second.top); PMONITOR->m_reservedTopLeft = PMONITOR->m_reservedTopLeft + Vector2D(ADDITIONALRESERVED->second.left, ADDITIONALRESERVED->second.top);
PMONITOR->vecReservedBottomRight = PMONITOR->vecReservedBottomRight + Vector2D(ADDITIONALRESERVED->second.right, ADDITIONALRESERVED->second.bottom); PMONITOR->m_reservedBottomRight = PMONITOR->m_reservedBottomRight + Vector2D(ADDITIONALRESERVED->second.right, ADDITIONALRESERVED->second.bottom);
} }
// damage the monitor if can // damage the monitor if can
@@ -1846,11 +1847,11 @@ void CHyprRenderer::damageSurface(SP<CWLSurfaceResource> pSurface, double x, dou
CRegion damageBoxForEach; CRegion damageBoxForEach;
for (auto const& m : g_pCompositor->m_monitors) { for (auto const& m : g_pCompositor->m_monitors) {
if (!m->output) if (!m->m_output)
continue; continue;
damageBoxForEach.set(damageBox); damageBoxForEach.set(damageBox);
damageBoxForEach.translate({-m->vecPosition.x, -m->vecPosition.y}).scale(m->scale); damageBoxForEach.translate({-m->m_position.x, -m->m_position.y}).scale(m->m_scale);
m->addDamage(damageBoxForEach); m->addDamage(damageBoxForEach);
} }
@@ -1874,8 +1875,8 @@ void CHyprRenderer::damageWindow(PHLWINDOW pWindow, bool forceFull) {
for (auto const& m : g_pCompositor->m_monitors) { for (auto const& m : g_pCompositor->m_monitors) {
if (forceFull || shouldRenderWindow(pWindow, m)) { // only damage if window is rendered on monitor if (forceFull || shouldRenderWindow(pWindow, m)) { // only damage if window is rendered on monitor
CBox fixedDamageBox = {windowBox.x - m->vecPosition.x, windowBox.y - m->vecPosition.y, windowBox.width, windowBox.height}; CBox fixedDamageBox = {windowBox.x - m->m_position.x, windowBox.y - m->m_position.y, windowBox.width, windowBox.height};
fixedDamageBox.scale(m->scale); fixedDamageBox.scale(m->m_scale);
m->addDamage(fixedDamageBox); m->addDamage(fixedDamageBox);
} }
} }
@@ -1899,7 +1900,7 @@ void CHyprRenderer::damageMonitor(PHLMONITOR pMonitor) {
static auto PLOGDAMAGE = CConfigValue<Hyprlang::INT>("debug:log_damage"); static auto PLOGDAMAGE = CConfigValue<Hyprlang::INT>("debug:log_damage");
if (*PLOGDAMAGE) if (*PLOGDAMAGE)
Debug::log(LOG, "Damage: Monitor {}", pMonitor->szName); Debug::log(LOG, "Damage: Monitor {}", pMonitor->m_name);
} }
void CHyprRenderer::damageBox(const CBox& box, bool skipFrameSchedule) { void CHyprRenderer::damageBox(const CBox& box, bool skipFrameSchedule) {
@@ -1911,7 +1912,7 @@ void CHyprRenderer::damageBox(const CBox& box, bool skipFrameSchedule) {
continue; // don't damage mirrors traditionally continue; // don't damage mirrors traditionally
if (!skipFrameSchedule) { if (!skipFrameSchedule) {
CBox damageBox = box.copy().translate(-m->vecPosition).scale(m->scale); CBox damageBox = box.copy().translate(-m->m_position).scale(m->m_scale);
m->addDamage(damageBox); m->addDamage(damageBox);
} }
} }
@@ -1934,7 +1935,7 @@ void CHyprRenderer::damageRegion(const CRegion& rg) {
} }
void CHyprRenderer::damageMirrorsWith(PHLMONITOR pMonitor, const CRegion& pRegion) { void CHyprRenderer::damageMirrorsWith(PHLMONITOR pMonitor, const CRegion& pRegion) {
for (auto const& mirror : pMonitor->mirrors) { for (auto const& mirror : pMonitor->m_mirrors) {
// transform the damage here, so it won't get clipped by the monitor damage ring // transform the damage here, so it won't get clipped by the monitor damage ring
auto monitor = mirror; auto monitor = mirror;
@@ -1942,13 +1943,13 @@ void CHyprRenderer::damageMirrorsWith(PHLMONITOR pMonitor, const CRegion& pRegio
CRegion transformed{pRegion}; CRegion transformed{pRegion};
// we want to transform to the same box as in CHyprOpenGLImpl::renderMirrored // we want to transform to the same box as in CHyprOpenGLImpl::renderMirrored
double scale = std::min(monitor->vecTransformedSize.x / pMonitor->vecTransformedSize.x, monitor->vecTransformedSize.y / pMonitor->vecTransformedSize.y); double scale = std::min(monitor->m_transformedSize.x / pMonitor->m_transformedSize.x, monitor->m_transformedSize.y / pMonitor->m_transformedSize.y);
CBox monbox = {0, 0, pMonitor->vecTransformedSize.x * scale, pMonitor->vecTransformedSize.y * scale}; CBox monbox = {0, 0, pMonitor->m_transformedSize.x * scale, pMonitor->m_transformedSize.y * scale};
monbox.x = (monitor->vecTransformedSize.x - monbox.w) / 2; monbox.x = (monitor->m_transformedSize.x - monbox.w) / 2;
monbox.y = (monitor->vecTransformedSize.y - monbox.h) / 2; monbox.y = (monitor->m_transformedSize.y - monbox.h) / 2;
transformed.scale(scale); transformed.scale(scale);
transformed.transform(wlTransformToHyprutils(pMonitor->transform), pMonitor->vecPixelSize.x * scale, pMonitor->vecPixelSize.y * scale); transformed.transform(wlTransformToHyprutils(pMonitor->m_transform), pMonitor->m_pixelSize.x * scale, pMonitor->m_pixelSize.y * scale);
transformed.translate(Vector2D(monbox.x, monbox.y)); transformed.translate(Vector2D(monbox.x, monbox.y));
mirror->addDamage(transformed); mirror->addDamage(transformed);
@@ -2110,14 +2111,14 @@ void CHyprRenderer::initiateManualCrash() {
} }
void CHyprRenderer::recheckSolitaryForMonitor(PHLMONITOR pMonitor) { void CHyprRenderer::recheckSolitaryForMonitor(PHLMONITOR pMonitor) {
pMonitor->solitaryClient.reset(); // reset it, if we find one it will be set. pMonitor->m_solitaryClient.reset(); // reset it, if we find one it will be set.
if (g_pHyprNotificationOverlay->hasAny() || g_pSessionLockManager->isSessionLocked()) if (g_pHyprNotificationOverlay->hasAny() || g_pSessionLockManager->isSessionLocked())
return; return;
const auto PWORKSPACE = pMonitor->activeWorkspace; const auto PWORKSPACE = pMonitor->m_activeWorkspace;
if (!PWORKSPACE || !PWORKSPACE->m_hasFullscreenWindow || PROTO::data->dndActive() || pMonitor->activeSpecialWorkspace || PWORKSPACE->m_alpha->value() != 1.f || if (!PWORKSPACE || !PWORKSPACE->m_hasFullscreenWindow || PROTO::data->dndActive() || pMonitor->m_activeSpecialWorkspace || PWORKSPACE->m_alpha->value() != 1.f ||
PWORKSPACE->m_renderOffset->value() != Vector2D{}) PWORKSPACE->m_renderOffset->value() != Vector2D{})
return; return;
@@ -2129,14 +2130,14 @@ void CHyprRenderer::recheckSolitaryForMonitor(PHLMONITOR pMonitor) {
if (!PCANDIDATE->opaque()) if (!PCANDIDATE->opaque())
return; return;
if (PCANDIDATE->m_realSize->value() != pMonitor->vecSize || PCANDIDATE->m_realPosition->value() != pMonitor->vecPosition || PCANDIDATE->m_realPosition->isBeingAnimated() || if (PCANDIDATE->m_realSize->value() != pMonitor->m_size || PCANDIDATE->m_realPosition->value() != pMonitor->m_position || PCANDIDATE->m_realPosition->isBeingAnimated() ||
PCANDIDATE->m_realSize->isBeingAnimated()) PCANDIDATE->m_realSize->isBeingAnimated())
return; return;
if (!pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY].empty()) if (!pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY].empty())
return; return;
for (auto const& topls : pMonitor->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) { for (auto const& topls : pMonitor->m_layerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
if (topls->m_alpha->value() != 0.f) if (topls->m_alpha->value() != 0.f)
return; return;
} }
@@ -2149,7 +2150,7 @@ void CHyprRenderer::recheckSolitaryForMonitor(PHLMONITOR pMonitor) {
return; return;
} }
if (pMonitor->activeSpecialWorkspace) if (pMonitor->m_activeSpecialWorkspace)
return; return;
// check if it did not open any subsurfaces or shit // check if it did not open any subsurfaces or shit
@@ -2163,7 +2164,7 @@ void CHyprRenderer::recheckSolitaryForMonitor(PHLMONITOR pMonitor) {
return; return;
// found one! // found one!
pMonitor->solitaryClient = PCANDIDATE; pMonitor->m_solitaryClient = PCANDIDATE;
} }
SP<CRenderbuffer> CHyprRenderer::getOrCreateRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t fmt) { SP<CRenderbuffer> CHyprRenderer::getOrCreateRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t fmt) {
@@ -2221,29 +2222,29 @@ bool CHyprRenderer::beginRender(PHLMONITOR pMonitor, CRegion& damage, eRenderMod
static constexpr const int HL_BUFFER_AGE = 2; static constexpr const int HL_BUFFER_AGE = 2;
if (!buffer) { if (!buffer) {
m_pCurrentBuffer = pMonitor->output->swapchain->next(nullptr); m_pCurrentBuffer = pMonitor->m_output->swapchain->next(nullptr);
if (!m_pCurrentBuffer) { if (!m_pCurrentBuffer) {
Debug::log(ERR, "Failed to acquire swapchain buffer for {}", pMonitor->szName); Debug::log(ERR, "Failed to acquire swapchain buffer for {}", pMonitor->m_name);
return false; return false;
} }
} else } else
m_pCurrentBuffer = buffer; m_pCurrentBuffer = buffer;
try { try {
m_pCurrentRenderbuffer = getOrCreateRenderbuffer(m_pCurrentBuffer, pMonitor->output->state->state().drmFormat); m_pCurrentRenderbuffer = getOrCreateRenderbuffer(m_pCurrentBuffer, pMonitor->m_output->state->state().drmFormat);
} catch (std::exception& e) { } catch (std::exception& e) {
Debug::log(ERR, "getOrCreateRenderbuffer failed for {}", pMonitor->szName); Debug::log(ERR, "getOrCreateRenderbuffer failed for {}", pMonitor->m_name);
return false; return false;
} }
if (!m_pCurrentRenderbuffer) { if (!m_pCurrentRenderbuffer) {
Debug::log(ERR, "failed to start a render pass for output {}, no RBO could be obtained", pMonitor->szName); Debug::log(ERR, "failed to start a render pass for output {}, no RBO could be obtained", pMonitor->m_name);
return false; return false;
} }
if (mode == RENDER_MODE_NORMAL) { if (mode == RENDER_MODE_NORMAL) {
damage = pMonitor->damage.getBufferDamage(HL_BUFFER_AGE); damage = pMonitor->m_damage.getBufferDamage(HL_BUFFER_AGE);
pMonitor->damage.rotate(); pMonitor->m_damage.rotate();
} }
m_pCurrentRenderbuffer->bind(); m_pCurrentRenderbuffer->bind();
@@ -2283,7 +2284,7 @@ void CHyprRenderer::endRender(const std::function<void()>& renderingDoneCallback
return; return;
if (m_eRenderMode == RENDER_MODE_NORMAL) if (m_eRenderMode == RENDER_MODE_NORMAL)
PMONITOR->output->state->setBuffer(m_pCurrentBuffer); PMONITOR->m_output->state->setBuffer(m_pCurrentBuffer);
UP<CEGLSync> eglSync = CEGLSync::create(); UP<CEGLSync> eglSync = CEGLSync::create();
if (eglSync && eglSync->isValid()) { if (eglSync && eglSync->isValid()) {
@@ -2305,8 +2306,8 @@ void CHyprRenderer::endRender(const std::function<void()>& renderingDoneCallback
usedAsyncBuffers.clear(); usedAsyncBuffers.clear();
if (m_eRenderMode == RENDER_MODE_NORMAL) { if (m_eRenderMode == RENDER_MODE_NORMAL) {
PMONITOR->inFence = eglSync->takeFd(); PMONITOR->m_inFence = eglSync->takeFd();
PMONITOR->output->state->setExplicitInFence(PMONITOR->inFence.get()); PMONITOR->m_output->state->setExplicitInFence(PMONITOR->m_inFence.get());
} }
} else { } else {
Debug::log(ERR, "renderer: couldn't use EGLSync for explicit gpu synchronization"); Debug::log(ERR, "renderer: couldn't use EGLSync for explicit gpu synchronization");
@@ -2376,17 +2377,17 @@ void CHyprRenderer::makeRawWindowSnapshot(PHLWINDOW pWindow, CFramebuffer* pFram
// we trust the window is valid. // we trust the window is valid.
const auto PMONITOR = pWindow->m_monitor.lock(); const auto PMONITOR = pWindow->m_monitor.lock();
if (!PMONITOR || !PMONITOR->output || PMONITOR->vecPixelSize.x <= 0 || PMONITOR->vecPixelSize.y <= 0) if (!PMONITOR || !PMONITOR->m_output || PMONITOR->m_pixelSize.x <= 0 || PMONITOR->m_pixelSize.y <= 0)
return; return;
// we need to "damage" the entire monitor // we need to "damage" the entire monitor
// so that we render the entire window // so that we render the entire window
// this is temporary, doesnt mess with the actual damage // this is temporary, doesnt mess with the actual damage
CRegion fakeDamage{0, 0, (int)PMONITOR->vecTransformedSize.x, (int)PMONITOR->vecTransformedSize.y}; CRegion fakeDamage{0, 0, (int)PMONITOR->m_transformedSize.x, (int)PMONITOR->m_transformedSize.y};
makeEGLCurrent(); makeEGLCurrent();
pFramebuffer->alloc(PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, PMONITOR->output->state->state().drmFormat); pFramebuffer->alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, PMONITOR->m_output->state->state().drmFormat);
pFramebuffer->addStencil(g_pHyprOpenGL->m_RenderData.pCurrentMonData->stencilTex); pFramebuffer->addStencil(g_pHyprOpenGL->m_RenderData.pCurrentMonData->stencilTex);
beginRender(PMONITOR, fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, pFramebuffer); beginRender(PMONITOR, fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, pFramebuffer);
@@ -2403,7 +2404,7 @@ void CHyprRenderer::makeRawWindowSnapshot(PHLWINDOW pWindow, CFramebuffer* pFram
**PBLUR = 0; **PBLUR = 0;
// TODO: how can we make this the size of the window? setting it to window's size makes the entire screen render with the wrong res forever more. odd. // TODO: how can we make this the size of the window? setting it to window's size makes the entire screen render with the wrong res forever more. odd.
glViewport(0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y); glViewport(0, 0, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y);
g_pHyprOpenGL->m_RenderData.currentFB = pFramebuffer; g_pHyprOpenGL->m_RenderData.currentFB = pFramebuffer;
@@ -2420,7 +2421,7 @@ void CHyprRenderer::makeWindowSnapshot(PHLWINDOW pWindow) {
// we trust the window is valid. // we trust the window is valid.
const auto PMONITOR = pWindow->m_monitor.lock(); const auto PMONITOR = pWindow->m_monitor.lock();
if (!PMONITOR || !PMONITOR->output || PMONITOR->vecPixelSize.x <= 0 || PMONITOR->vecPixelSize.y <= 0) if (!PMONITOR || !PMONITOR->m_output || PMONITOR->m_pixelSize.x <= 0 || PMONITOR->m_pixelSize.y <= 0)
return; return;
if (!shouldRenderWindow(pWindow)) if (!shouldRenderWindow(pWindow))
@@ -2429,7 +2430,7 @@ void CHyprRenderer::makeWindowSnapshot(PHLWINDOW pWindow) {
// we need to "damage" the entire monitor // we need to "damage" the entire monitor
// so that we render the entire window // so that we render the entire window
// this is temporary, doesnt mess with the actual damage // this is temporary, doesnt mess with the actual damage
CRegion fakeDamage{0, 0, (int)PMONITOR->vecTransformedSize.x, (int)PMONITOR->vecTransformedSize.y}; CRegion fakeDamage{0, 0, (int)PMONITOR->m_transformedSize.x, (int)PMONITOR->m_transformedSize.y};
PHLWINDOWREF ref{pWindow}; PHLWINDOWREF ref{pWindow};
@@ -2437,7 +2438,7 @@ void CHyprRenderer::makeWindowSnapshot(PHLWINDOW pWindow) {
const auto PFRAMEBUFFER = &g_pHyprOpenGL->m_mWindowFramebuffers[ref]; const auto PFRAMEBUFFER = &g_pHyprOpenGL->m_mWindowFramebuffers[ref];
PFRAMEBUFFER->alloc(PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, PMONITOR->output->state->state().drmFormat); PFRAMEBUFFER->alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, PMONITOR->m_output->state->state().drmFormat);
beginRender(PMONITOR, fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, PFRAMEBUFFER); beginRender(PMONITOR, fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, PFRAMEBUFFER);
@@ -2469,19 +2470,19 @@ void CHyprRenderer::makeLayerSnapshot(PHLLS pLayer) {
// we trust the window is valid. // we trust the window is valid.
const auto PMONITOR = pLayer->m_monitor.lock(); const auto PMONITOR = pLayer->m_monitor.lock();
if (!PMONITOR || !PMONITOR->output || PMONITOR->vecPixelSize.x <= 0 || PMONITOR->vecPixelSize.y <= 0) if (!PMONITOR || !PMONITOR->m_output || PMONITOR->m_pixelSize.x <= 0 || PMONITOR->m_pixelSize.y <= 0)
return; return;
// we need to "damage" the entire monitor // we need to "damage" the entire monitor
// so that we render the entire window // so that we render the entire window
// this is temporary, doesnt mess with the actual damage // this is temporary, doesnt mess with the actual damage
CRegion fakeDamage{0, 0, (int)PMONITOR->vecTransformedSize.x, (int)PMONITOR->vecTransformedSize.y}; CRegion fakeDamage{0, 0, (int)PMONITOR->m_transformedSize.x, (int)PMONITOR->m_transformedSize.y};
makeEGLCurrent(); makeEGLCurrent();
const auto PFRAMEBUFFER = &g_pHyprOpenGL->m_mLayerFramebuffers[pLayer]; const auto PFRAMEBUFFER = &g_pHyprOpenGL->m_mLayerFramebuffers[pLayer];
PFRAMEBUFFER->alloc(PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, PMONITOR->output->state->state().drmFormat); PFRAMEBUFFER->alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, PMONITOR->m_output->state->state().drmFormat);
beginRender(PMONITOR, fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, PFRAMEBUFFER); beginRender(PMONITOR, fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, PFRAMEBUFFER);
@@ -2520,21 +2521,21 @@ void CHyprRenderer::renderSnapshot(PHLWINDOW pWindow) {
CBox windowBox; CBox windowBox;
// some mafs to figure out the correct box // some mafs to figure out the correct box
// the originalClosedPos is relative to the monitor's pos // the originalClosedPos is relative to the monitor's pos
Vector2D scaleXY = Vector2D((PMONITOR->scale * pWindow->m_realSize->value().x / (pWindow->m_originalClosedSize.x * PMONITOR->scale)), Vector2D scaleXY = Vector2D((PMONITOR->m_scale * pWindow->m_realSize->value().x / (pWindow->m_originalClosedSize.x * PMONITOR->m_scale)),
(PMONITOR->scale * pWindow->m_realSize->value().y / (pWindow->m_originalClosedSize.y * PMONITOR->scale))); (PMONITOR->m_scale * pWindow->m_realSize->value().y / (pWindow->m_originalClosedSize.y * PMONITOR->m_scale)));
windowBox.width = PMONITOR->vecTransformedSize.x * scaleXY.x; windowBox.width = PMONITOR->m_transformedSize.x * scaleXY.x;
windowBox.height = PMONITOR->vecTransformedSize.y * scaleXY.y; windowBox.height = PMONITOR->m_transformedSize.y * scaleXY.y;
windowBox.x = ((pWindow->m_realPosition->value().x - PMONITOR->vecPosition.x) * PMONITOR->scale) - ((pWindow->m_originalClosedPos.x * PMONITOR->scale) * scaleXY.x); windowBox.x = ((pWindow->m_realPosition->value().x - PMONITOR->m_position.x) * PMONITOR->m_scale) - ((pWindow->m_originalClosedPos.x * PMONITOR->m_scale) * scaleXY.x);
windowBox.y = ((pWindow->m_realPosition->value().y - PMONITOR->vecPosition.y) * PMONITOR->scale) - ((pWindow->m_originalClosedPos.y * PMONITOR->scale) * scaleXY.y); windowBox.y = ((pWindow->m_realPosition->value().y - PMONITOR->m_position.y) * PMONITOR->m_scale) - ((pWindow->m_originalClosedPos.y * PMONITOR->m_scale) * scaleXY.y);
CRegion fakeDamage{0, 0, PMONITOR->vecTransformedSize.x, PMONITOR->vecTransformedSize.y}; CRegion fakeDamage{0, 0, PMONITOR->m_transformedSize.x, PMONITOR->m_transformedSize.y};
if (*PDIMAROUND && pWindow->m_windowData.dimAround.valueOrDefault()) { if (*PDIMAROUND && pWindow->m_windowData.dimAround.valueOrDefault()) {
CRectPassElement::SRectData data; CRectPassElement::SRectData data;
data.box = {0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->vecPixelSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->vecPixelSize.y}; data.box = {0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->m_pixelSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->m_pixelSize.y};
data.color = CHyprColor(0, 0, 0, *PDIMAROUND * pWindow->m_alpha->value()); data.color = CHyprColor(0, 0, 0, *PDIMAROUND * pWindow->m_alpha->value());
m_sRenderPass.add(makeShared<CRectPassElement>(data)); m_sRenderPass.add(makeShared<CRectPassElement>(data));
@@ -2565,17 +2566,17 @@ void CHyprRenderer::renderSnapshot(PHLLS pLayer) {
CBox layerBox; CBox layerBox;
// some mafs to figure out the correct box // some mafs to figure out the correct box
// the originalClosedPos is relative to the monitor's pos // the originalClosedPos is relative to the monitor's pos
Vector2D scaleXY = Vector2D((PMONITOR->scale * pLayer->m_realSize->value().x / (pLayer->m_geometry.w * PMONITOR->scale)), Vector2D scaleXY = Vector2D((PMONITOR->m_scale * pLayer->m_realSize->value().x / (pLayer->m_geometry.w * PMONITOR->m_scale)),
(PMONITOR->scale * pLayer->m_realSize->value().y / (pLayer->m_geometry.h * PMONITOR->scale))); (PMONITOR->m_scale * pLayer->m_realSize->value().y / (pLayer->m_geometry.h * PMONITOR->m_scale)));
layerBox.width = PMONITOR->vecTransformedSize.x * scaleXY.x; layerBox.width = PMONITOR->m_transformedSize.x * scaleXY.x;
layerBox.height = PMONITOR->vecTransformedSize.y * scaleXY.y; layerBox.height = PMONITOR->m_transformedSize.y * scaleXY.y;
layerBox.x = layerBox.x =
((pLayer->m_realPosition->value().x - PMONITOR->vecPosition.x) * PMONITOR->scale) - (((pLayer->m_geometry.x - PMONITOR->vecPosition.x) * PMONITOR->scale) * scaleXY.x); ((pLayer->m_realPosition->value().x - PMONITOR->m_position.x) * PMONITOR->m_scale) - (((pLayer->m_geometry.x - PMONITOR->m_position.x) * PMONITOR->m_scale) * scaleXY.x);
layerBox.y = layerBox.y =
((pLayer->m_realPosition->value().y - PMONITOR->vecPosition.y) * PMONITOR->scale) - (((pLayer->m_geometry.y - PMONITOR->vecPosition.y) * PMONITOR->scale) * scaleXY.y); ((pLayer->m_realPosition->value().y - PMONITOR->m_position.y) * PMONITOR->m_scale) - (((pLayer->m_geometry.y - PMONITOR->m_position.y) * PMONITOR->m_scale) * scaleXY.y);
CRegion fakeDamage{0, 0, PMONITOR->vecTransformedSize.x, PMONITOR->vecTransformedSize.y}; CRegion fakeDamage{0, 0, PMONITOR->m_transformedSize.x, PMONITOR->m_transformedSize.y};
CTexPassElement::SRenderData data; CTexPassElement::SRenderData data;
data.flipEndFrame = true; data.flipEndFrame = true;

6
src/render/decorations/CHyprBorderDecoration.cpp
View File

@@ -52,7 +52,7 @@ void CHyprBorderDecoration::draw(PHLMONITOR pMonitor, float const& a) {
if (m_bAssignedGeometry.width < m_seExtents.topLeft.x + 1 || m_bAssignedGeometry.height < m_seExtents.topLeft.y + 1) if (m_bAssignedGeometry.width < m_seExtents.topLeft.x + 1 || m_bAssignedGeometry.height < m_seExtents.topLeft.y + 1)
return; return;
CBox windowBox = assignedBoxGlobal().translate(-pMonitor->vecPosition + m_pWindow->m_floatingOffset).expand(-m_pWindow->getRealBorderSize()).scale(pMonitor->scale).round(); CBox windowBox = assignedBoxGlobal().translate(-pMonitor->m_position + m_pWindow->m_floatingOffset).expand(-m_pWindow->getRealBorderSize()).scale(pMonitor->m_scale).round();
if (windowBox.width < 1 || windowBox.height < 1) if (windowBox.width < 1 || windowBox.height < 1)
return; return;
@@ -71,7 +71,7 @@ void CHyprBorderDecoration::draw(PHLMONITOR pMonitor, float const& a) {
} }
int borderSize = m_pWindow->getRealBorderSize(); int borderSize = m_pWindow->getRealBorderSize();
const auto ROUNDING = m_pWindow->rounding() * pMonitor->scale; const auto ROUNDING = m_pWindow->rounding() * pMonitor->m_scale;
const auto ROUNDINGPOWER = m_pWindow->roundingPower(); const auto ROUNDINGPOWER = m_pWindow->roundingPower();
CBorderPassElement::SBorderData data; CBorderPassElement::SBorderData data;
@@ -134,7 +134,7 @@ void CHyprBorderDecoration::damageEntire() {
for (auto const& m : g_pCompositor->m_monitors) { for (auto const& m : g_pCompositor->m_monitors) {
if (!g_pHyprRenderer->shouldRenderWindow(m_pWindow.lock(), m)) { if (!g_pHyprRenderer->shouldRenderWindow(m_pWindow.lock(), m)) {
const CRegion monitorRegion({m->vecPosition, m->vecSize}); const CRegion monitorRegion({m->m_position, m->m_size});
borderRegion.subtract(monitorRegion); borderRegion.subtract(monitorRegion);
} }
} }

30
src/render/decorations/CHyprDropShadowDecoration.cpp
View File

@@ -68,7 +68,7 @@ void CHyprDropShadowDecoration::damageEntire() {
for (auto const& m : g_pCompositor->m_monitors) { for (auto const& m : g_pCompositor->m_monitors) {
if (!g_pHyprRenderer->shouldRenderWindow(PWINDOW, m)) { if (!g_pHyprRenderer->shouldRenderWindow(PWINDOW, m)) {
const CRegion monitorRegion({m->vecPosition, m->vecSize}); const CRegion monitorRegion({m->m_position, m->m_size});
shadowRegion.subtract(monitorRegion); shadowRegion.subtract(monitorRegion);
} }
} }
@@ -125,7 +125,7 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
// draw the shadow // draw the shadow
CBox fullBox = m_bLastWindowBoxWithDecos; CBox fullBox = m_bLastWindowBoxWithDecos;
fullBox.translate(-pMonitor->vecPosition + WORKSPACEOFFSET); fullBox.translate(-pMonitor->m_position + WORKSPACEOFFSET);
fullBox.x -= *PSHADOWSIZE; fullBox.x -= *PSHADOWSIZE;
fullBox.y -= *PSHADOWSIZE; fullBox.y -= *PSHADOWSIZE;
fullBox.w += 2 * *PSHADOWSIZE; fullBox.w += 2 * *PSHADOWSIZE;
@@ -138,9 +138,9 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
updateWindow(PWINDOW); updateWindow(PWINDOW);
m_vLastWindowPos += WORKSPACEOFFSET; m_vLastWindowPos += WORKSPACEOFFSET;
m_seExtents = {{m_vLastWindowPos.x - fullBox.x - pMonitor->vecPosition.x + 2, m_vLastWindowPos.y - fullBox.y - pMonitor->vecPosition.y + 2}, m_seExtents = {{m_vLastWindowPos.x - fullBox.x - pMonitor->m_position.x + 2, m_vLastWindowPos.y - fullBox.y - pMonitor->m_position.y + 2},
{fullBox.x + fullBox.width + pMonitor->vecPosition.x - m_vLastWindowPos.x - m_vLastWindowSize.x + 2, {fullBox.x + fullBox.width + pMonitor->m_position.x - m_vLastWindowPos.x - m_vLastWindowSize.x + 2,
fullBox.y + fullBox.height + pMonitor->vecPosition.y - m_vLastWindowPos.y - m_vLastWindowSize.y + 2}}; fullBox.y + fullBox.height + pMonitor->m_position.y - m_vLastWindowPos.y - m_vLastWindowSize.y + 2}};
fullBox.translate(PWINDOW->m_floatingOffset); fullBox.translate(PWINDOW->m_floatingOffset);
@@ -155,25 +155,25 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
CFramebuffer& alphaSwapFB = g_pHyprOpenGL->m_RenderData.pCurrentMonData->mirrorSwapFB; CFramebuffer& alphaSwapFB = g_pHyprOpenGL->m_RenderData.pCurrentMonData->mirrorSwapFB;
auto* LASTFB = g_pHyprOpenGL->m_RenderData.currentFB; auto* LASTFB = g_pHyprOpenGL->m_RenderData.currentFB;
fullBox.scale(pMonitor->scale).round(); fullBox.scale(pMonitor->m_scale).round();
if (*PSHADOWIGNOREWINDOW) { if (*PSHADOWIGNOREWINDOW) {
CBox windowBox = m_bLastWindowBox; CBox windowBox = m_bLastWindowBox;
CBox withDecos = m_bLastWindowBoxWithDecos; CBox withDecos = m_bLastWindowBoxWithDecos;
// get window box // get window box
windowBox.translate(-pMonitor->vecPosition + WORKSPACEOFFSET); windowBox.translate(-pMonitor->m_position + WORKSPACEOFFSET);
withDecos.translate(-pMonitor->vecPosition + WORKSPACEOFFSET); withDecos.translate(-pMonitor->m_position + WORKSPACEOFFSET);
windowBox.translate(PWINDOW->m_floatingOffset); windowBox.translate(PWINDOW->m_floatingOffset);
withDecos.translate(PWINDOW->m_floatingOffset); withDecos.translate(PWINDOW->m_floatingOffset);
auto scaledExtentss = withDecos.extentsFrom(windowBox); auto scaledExtentss = withDecos.extentsFrom(windowBox);
scaledExtentss = scaledExtentss * pMonitor->scale; scaledExtentss = scaledExtentss * pMonitor->m_scale;
scaledExtentss = scaledExtentss.round(); scaledExtentss = scaledExtentss.round();
// add extents // add extents
windowBox.scale(pMonitor->scale).round().addExtents(scaledExtentss); windowBox.scale(pMonitor->m_scale).round().addExtents(scaledExtentss);
if (windowBox.width < 1 || windowBox.height < 1) if (windowBox.width < 1 || windowBox.height < 1)
return; // prevent assert failed return; // prevent assert failed
@@ -181,7 +181,7 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
CRegion saveDamage = g_pHyprOpenGL->m_RenderData.damage; CRegion saveDamage = g_pHyprOpenGL->m_RenderData.damage;
g_pHyprOpenGL->m_RenderData.damage = fullBox; g_pHyprOpenGL->m_RenderData.damage = fullBox;
g_pHyprOpenGL->m_RenderData.damage.subtract(windowBox.copy().expand(-ROUNDING * pMonitor->scale)).intersect(saveDamage); g_pHyprOpenGL->m_RenderData.damage.subtract(windowBox.copy().expand(-ROUNDING * pMonitor->m_scale)).intersect(saveDamage);
g_pHyprOpenGL->m_RenderData.renderModif.applyToRegion(g_pHyprOpenGL->m_RenderData.damage); g_pHyprOpenGL->m_RenderData.renderModif.applyToRegion(g_pHyprOpenGL->m_RenderData.damage);
alphaFB.bind(); alphaFB.bind();
@@ -192,10 +192,10 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
g_pHyprOpenGL->renderRect(fullBox, CHyprColor(0, 0, 0, 1), 0); g_pHyprOpenGL->renderRect(fullBox, CHyprColor(0, 0, 0, 1), 0);
// render white shadow with the alpha of the shadow color (otherwise we clear with alpha later and shit it to 2 bit) // render white shadow with the alpha of the shadow color (otherwise we clear with alpha later and shit it to 2 bit)
drawShadowInternal(fullBox, ROUNDING * pMonitor->scale, ROUNDINGPOWER, *PSHADOWSIZE * pMonitor->scale, CHyprColor(1, 1, 1, PWINDOW->m_realShadowColor->value().a), a); drawShadowInternal(fullBox, ROUNDING * pMonitor->m_scale, ROUNDINGPOWER, *PSHADOWSIZE * pMonitor->m_scale, CHyprColor(1, 1, 1, PWINDOW->m_realShadowColor->value().a), a);
// render black window box ("clip") // render black window box ("clip")
g_pHyprOpenGL->renderRect(windowBox, CHyprColor(0, 0, 0, 1.0), (ROUNDING + 1 /* This fixes small pixel gaps. */) * pMonitor->scale, ROUNDINGPOWER); g_pHyprOpenGL->renderRect(windowBox, CHyprColor(0, 0, 0, 1.0), (ROUNDING + 1 /* This fixes small pixel gaps. */) * pMonitor->m_scale, ROUNDINGPOWER);
alphaSwapFB.bind(); alphaSwapFB.bind();
@@ -204,7 +204,7 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
LASTFB->bind(); LASTFB->bind();
CBox monbox = {0, 0, pMonitor->vecTransformedSize.x, pMonitor->vecTransformedSize.y}; CBox monbox = {0, 0, pMonitor->m_transformedSize.x, pMonitor->m_transformedSize.y};
g_pHyprOpenGL->setMonitorTransformEnabled(true); g_pHyprOpenGL->setMonitorTransformEnabled(true);
g_pHyprOpenGL->setRenderModifEnabled(false); g_pHyprOpenGL->setRenderModifEnabled(false);
@@ -214,7 +214,7 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
g_pHyprOpenGL->m_RenderData.damage = saveDamage; g_pHyprOpenGL->m_RenderData.damage = saveDamage;
} else } else
drawShadowInternal(fullBox, ROUNDING * pMonitor->scale, ROUNDINGPOWER, *PSHADOWSIZE * pMonitor->scale, PWINDOW->m_realShadowColor->value(), a); drawShadowInternal(fullBox, ROUNDING * pMonitor->m_scale, ROUNDINGPOWER, *PSHADOWSIZE * pMonitor->m_scale, PWINDOW->m_realShadowColor->value(), a);
if (m_seExtents != m_seReportedExtents) if (m_seExtents != m_seReportedExtents)
g_pDecorationPositioner->repositionDeco(this); g_pDecorationPositioner->repositionDeco(this);

24
src/render/decorations/CHyprGroupBarDecoration.cpp
View File

@@ -143,11 +143,11 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
for (int i = 0; i < barsToDraw; ++i) { for (int i = 0; i < barsToDraw; ++i) {
const auto WINDOWINDEX = *PSTACKED ? m_dwGroupMembers.size() - i - 1 : i; const auto WINDOWINDEX = *PSTACKED ? m_dwGroupMembers.size() - i - 1 : i;
CBox rect = {ASSIGNEDBOX.x + xoff - pMonitor->vecPosition.x + m_pWindow->m_floatingOffset.x, CBox rect = {ASSIGNEDBOX.x + xoff - pMonitor->m_position.x + m_pWindow->m_floatingOffset.x,
ASSIGNEDBOX.y + ASSIGNEDBOX.h - floor(yoff) - *PINDICATORHEIGHT - *POUTERGAP - pMonitor->vecPosition.y + m_pWindow->m_floatingOffset.y, m_fBarWidth, ASSIGNEDBOX.y + ASSIGNEDBOX.h - floor(yoff) - *PINDICATORHEIGHT - *POUTERGAP - pMonitor->m_position.y + m_pWindow->m_floatingOffset.y, m_fBarWidth,
*PINDICATORHEIGHT}; *PINDICATORHEIGHT};
rect.scale(pMonitor->scale).round(); rect.scale(pMonitor->m_scale).round();
const bool GROUPLOCKED = m_pWindow->getGroupHead()->m_groupData.locked || g_pKeybindManager->m_bGroupsLocked; const bool GROUPLOCKED = m_pWindow->getGroupHead()->m_groupData.locked || g_pKeybindManager->m_bGroupsLocked;
const auto* const PCOLACTIVE = GROUPLOCKED ? GROUPCOLACTIVELOCKED : GROUPCOLACTIVE; const auto* const PCOLACTIVE = GROUPLOCKED ? GROUPCOLACTIVELOCKED : GROUPCOLACTIVE;
@@ -187,10 +187,10 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
g_pHyprRenderer->m_sRenderPass.add(makeShared<CRectPassElement>(rectdata)); g_pHyprRenderer->m_sRenderPass.add(makeShared<CRectPassElement>(rectdata));
} }
rect = {ASSIGNEDBOX.x + xoff - pMonitor->vecPosition.x + m_pWindow->m_floatingOffset.x, rect = {ASSIGNEDBOX.x + xoff - pMonitor->m_position.x + m_pWindow->m_floatingOffset.x,
ASSIGNEDBOX.y + ASSIGNEDBOX.h - floor(yoff) - ONEBARHEIGHT - pMonitor->vecPosition.y + m_pWindow->m_floatingOffset.y, m_fBarWidth, ASSIGNEDBOX.y + ASSIGNEDBOX.h - floor(yoff) - ONEBARHEIGHT - pMonitor->m_position.y + m_pWindow->m_floatingOffset.y, m_fBarWidth,
(*PGRADIENTS || *PRENDERTITLES ? *PHEIGHT : 0)}; (*PGRADIENTS || *PRENDERTITLES ? *PHEIGHT : 0)};
rect.scale(pMonitor->scale); rect.scale(pMonitor->m_scale);
if (!rect.empty()) { if (!rect.empty()) {
if (*PGRADIENTS) { if (*PGRADIENTS) {
@@ -232,17 +232,17 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
CTitleTex* pTitleTex = textureFromTitle(m_dwGroupMembers[WINDOWINDEX]->m_title); CTitleTex* pTitleTex = textureFromTitle(m_dwGroupMembers[WINDOWINDEX]->m_title);
if (!pTitleTex) if (!pTitleTex)
pTitleTex = pTitleTex = m_sTitleTexs.titleTexs
m_sTitleTexs.titleTexs
.emplace_back(makeUnique<CTitleTex>(m_dwGroupMembers[WINDOWINDEX].lock(), .emplace_back(makeUnique<CTitleTex>(m_dwGroupMembers[WINDOWINDEX].lock(),
Vector2D{m_fBarWidth * pMonitor->scale, (*PTITLEFONTSIZE + 2L * BAR_TEXT_PAD) * pMonitor->scale}, pMonitor->scale)) Vector2D{m_fBarWidth * pMonitor->m_scale, (*PTITLEFONTSIZE + 2L * BAR_TEXT_PAD) * pMonitor->m_scale},
pMonitor->m_scale))
.get(); .get();
const auto titleTex = m_dwGroupMembers[WINDOWINDEX] == g_pCompositor->m_lastWindow ? pTitleTex->texActive : pTitleTex->texInactive; const auto titleTex = m_dwGroupMembers[WINDOWINDEX] == g_pCompositor->m_lastWindow ? pTitleTex->texActive : pTitleTex->texInactive;
rect.y += std::ceil(((rect.height - titleTex->m_vSize.y) / 2.0) - (*PTEXTOFFSET * pMonitor->scale)); rect.y += std::ceil(((rect.height - titleTex->m_vSize.y) / 2.0) - (*PTEXTOFFSET * pMonitor->m_scale));
rect.height = titleTex->m_vSize.y; rect.height = titleTex->m_vSize.y;
rect.width = titleTex->m_vSize.x; rect.width = titleTex->m_vSize.x;
rect.x += std::round(((m_fBarWidth * pMonitor->scale) / 2.0) - (titleTex->m_vSize.x / 2.0)); rect.x += std::round(((m_fBarWidth * pMonitor->m_scale) / 2.0) - (titleTex->m_vSize.x / 2.0));
rect.round(); rect.round();
CTexPassElement::SRenderData data; CTexPassElement::SRenderData data;
@@ -300,7 +300,7 @@ static void renderGradientTo(SP<CTexture> tex, CGradientValueData* grad) {
if (!g_pCompositor->m_lastMonitor) if (!g_pCompositor->m_lastMonitor)
return; return;
const Vector2D& bufferSize = g_pCompositor->m_lastMonitor->vecPixelSize; const Vector2D& bufferSize = g_pCompositor->m_lastMonitor->m_pixelSize;
const auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, bufferSize.x, bufferSize.y); const auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, bufferSize.x, bufferSize.y);
const auto CAIRO = cairo_create(CAIROSURFACE); const auto CAIRO = cairo_create(CAIROSURFACE);

30
src/render/pass/Pass.cpp
View File

@@ -30,7 +30,7 @@ void CRenderPass::simplify() {
// if there is live blur, we need to NOT occlude any area where it will be influenced // if there is live blur, we need to NOT occlude any area where it will be influenced
const auto WILLBLUR = std::ranges::any_of(m_vPassElements, [](const auto& el) { return el->element->needsLiveBlur(); }); const auto WILLBLUR = std::ranges::any_of(m_vPassElements, [](const auto& el) { return el->element->needsLiveBlur(); });
CRegion newDamage = damage.copy().intersect(CBox{{}, g_pHyprOpenGL->m_RenderData.pMonitor->vecTransformedSize}); CRegion newDamage = damage.copy().intersect(CBox{{}, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize});
for (auto& el : m_vPassElements | std::views::reverse) { for (auto& el : m_vPassElements | std::views::reverse) {
if (newDamage.empty() && !el->element->undiscardable()) { if (newDamage.empty() && !el->element->undiscardable()) {
@@ -43,7 +43,7 @@ void CRenderPass::simplify() {
if (!bb1 || newDamage.empty()) if (!bb1 || newDamage.empty())
continue; continue;
auto bb = bb1->scale(g_pHyprOpenGL->m_RenderData.pMonitor->scale); auto bb = bb1->scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale);
// drop if empty // drop if empty
if (CRegion copy = newDamage.copy(); copy.intersect(bb).empty()) { if (CRegion copy = newDamage.copy(); copy.intersect(bb).empty()) {
@@ -54,7 +54,7 @@ void CRenderPass::simplify() {
auto opaque = el->element->opaqueRegion(); auto opaque = el->element->opaqueRegion();
if (!opaque.empty()) { if (!opaque.empty()) {
opaque.scale(g_pHyprOpenGL->m_RenderData.pMonitor->scale); opaque.scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale);
// if this intersects the liveBlur region, allow live blur to operate correctly. // if this intersects the liveBlur region, allow live blur to operate correctly.
// do not occlude a border near it. // do not occlude a border near it.
@@ -76,7 +76,7 @@ void CRenderPass::simplify() {
} }
// expand the region: this area needs to be proper to blur it right. // expand the region: this area needs to be proper to blur it right.
liveBlurRegion.scale(g_pHyprOpenGL->m_RenderData.pMonitor->scale).expand(oneBlurRadius() * 2.F); liveBlurRegion.scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale).expand(oneBlurRadius() * 2.F);
if (auto infringement = opaque.copy().intersect(liveBlurRegion); !infringement.empty()) { if (auto infringement = opaque.copy().intersect(liveBlurRegion); !infringement.empty()) {
// eh, this is not the correct solution, but it will do... // eh, this is not the correct solution, but it will do...
@@ -98,7 +98,7 @@ void CRenderPass::simplify() {
const auto BB = el2->element->boundingBox(); const auto BB = el2->element->boundingBox();
RASSERT(BB, "No bounding box for an element with live blur is illegal"); RASSERT(BB, "No bounding box for an element with live blur is illegal");
totalLiveBlurRegion.add(BB->copy().scale(g_pHyprOpenGL->m_RenderData.pMonitor->scale)); totalLiveBlurRegion.add(BB->copy().scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale));
} }
} }
} }
@@ -146,7 +146,7 @@ CRegion CRenderPass::render(const CRegion& damage_) {
blurRegion.add(*BB); blurRegion.add(*BB);
} }
blurRegion.scale(g_pHyprOpenGL->m_RenderData.pMonitor->scale); blurRegion.scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale);
blurRegion.intersect(damage).expand(oneBlurRadius()); blurRegion.intersect(damage).expand(oneBlurRadius());
@@ -197,7 +197,7 @@ CRegion CRenderPass::render(const CRegion& damage_) {
} }
void CRenderPass::renderDebugData() { void CRenderPass::renderDebugData() {
CBox box = {{}, g_pHyprOpenGL->m_RenderData.pMonitor->vecTransformedSize}; CBox box = {{}, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize};
for (const auto& rg : occludedRegions) { for (const auto& rg : occludedRegions) {
g_pHyprOpenGL->renderRectWithDamage(box, Colors::RED.modifyA(0.1F), rg); g_pHyprOpenGL->renderRectWithDamage(box, Colors::RED.modifyA(0.1F), rg);
} }
@@ -219,9 +219,9 @@ void CRenderPass::renderDebugData() {
if (!bb.has_value()) if (!bb.has_value())
return; return;
CBox box = bb->copy().translate(-g_pHyprOpenGL->m_RenderData.pMonitor->vecPosition).scale(g_pHyprOpenGL->m_RenderData.pMonitor->scale); CBox box = bb->copy().translate(-g_pHyprOpenGL->m_RenderData.pMonitor->m_position).scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale);
if (box.intersection(CBox{{}, g_pHyprOpenGL->m_RenderData.pMonitor->vecSize}).empty()) if (box.intersection(CBox{{}, g_pHyprOpenGL->m_RenderData.pMonitor->m_size}).empty())
return; return;
g_pHyprOpenGL->renderRectWithDamage(box, color, CRegion{0, 0, INT32_MAX, INT32_MAX}); g_pHyprOpenGL->renderRectWithDamage(box, color, CRegion{0, 0, INT32_MAX, INT32_MAX});
@@ -251,8 +251,8 @@ void CRenderPass::renderDebugData() {
auto BOX = hlSurface->getSurfaceBoxGlobal(); auto BOX = hlSurface->getSurfaceBoxGlobal();
if (BOX) { if (BOX) {
auto region = g_pSeatManager->state.pointerFocus->current.input.copy() auto region = g_pSeatManager->state.pointerFocus->current.input.copy()
.scale(g_pHyprOpenGL->m_RenderData.pMonitor->scale) .scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale)
.translate(BOX->pos() - g_pHyprOpenGL->m_RenderData.pMonitor->vecPosition); .translate(BOX->pos() - g_pHyprOpenGL->m_RenderData.pMonitor->m_position);
g_pHyprOpenGL->renderRectWithDamage(box, CHyprColor{0.8F, 0.8F, 0.2F, 0.4F}, region); g_pHyprOpenGL->renderRectWithDamage(box, CHyprColor{0.8F, 0.8F, 0.2F, 0.4F}, region);
} }
} }
@@ -261,11 +261,11 @@ void CRenderPass::renderDebugData() {
const auto DISCARDED_ELEMENTS = std::count_if(m_vPassElements.begin(), m_vPassElements.end(), [](const auto& e) { return e->discard; }); const auto DISCARDED_ELEMENTS = std::count_if(m_vPassElements.begin(), m_vPassElements.end(), [](const auto& e) { return e->discard; });
auto tex = g_pHyprOpenGL->renderText(std::format("occlusion layers: {}\npass elements: {} ({} discarded)\nviewport: {:X0}", occludedRegions.size(), m_vPassElements.size(), auto tex = g_pHyprOpenGL->renderText(std::format("occlusion layers: {}\npass elements: {} ({} discarded)\nviewport: {:X0}", occludedRegions.size(), m_vPassElements.size(),
DISCARDED_ELEMENTS, g_pHyprOpenGL->m_RenderData.pMonitor->vecPixelSize), DISCARDED_ELEMENTS, g_pHyprOpenGL->m_RenderData.pMonitor->m_pixelSize),
Colors::WHITE, 12); Colors::WHITE, 12);
if (tex) { if (tex) {
box = CBox{{0.F, g_pHyprOpenGL->m_RenderData.pMonitor->vecSize.y - tex->m_vSize.y}, tex->m_vSize}.scale(g_pHyprOpenGL->m_RenderData.pMonitor->scale); box = CBox{{0.F, g_pHyprOpenGL->m_RenderData.pMonitor->m_size.y - tex->m_vSize.y}, tex->m_vSize}.scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale);
g_pHyprOpenGL->renderTexture(tex, box, 1.F); g_pHyprOpenGL->renderTexture(tex, box, 1.F);
} }
@@ -282,8 +282,8 @@ void CRenderPass::renderDebugData() {
tex = g_pHyprOpenGL->renderText(passStructure, Colors::WHITE, 12); tex = g_pHyprOpenGL->renderText(passStructure, Colors::WHITE, 12);
if (tex) { if (tex) {
box = CBox{{g_pHyprOpenGL->m_RenderData.pMonitor->vecSize.x - tex->m_vSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->vecSize.y - tex->m_vSize.y}, tex->m_vSize}.scale( box = CBox{{g_pHyprOpenGL->m_RenderData.pMonitor->m_size.x - tex->m_vSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->m_size.y - tex->m_vSize.y}, tex->m_vSize}.scale(
g_pHyprOpenGL->m_RenderData.pMonitor->scale); g_pHyprOpenGL->m_RenderData.pMonitor->m_scale);
g_pHyprOpenGL->renderTexture(tex, box, 1.F); g_pHyprOpenGL->renderTexture(tex, box, 1.F);
} }
} }

2
src/render/pass/RectPassElement.cpp
View File

@@ -29,7 +29,7 @@ bool CRectPassElement::needsPrecomputeBlur() {
} }
std::optional<CBox> CRectPassElement::boundingBox() { std::optional<CBox> CRectPassElement::boundingBox() {
return data.box.copy().scale(1.F / g_pHyprOpenGL->m_RenderData.pMonitor->scale).round(); return data.box.copy().scale(1.F / g_pHyprOpenGL->m_RenderData.pMonitor->m_scale).round();
} }
CRegion CRectPassElement::opaqueRegion() { CRegion CRectPassElement::opaqueRegion() {

18
src/render/pass/SurfacePassElement.cpp
View File

@@ -64,7 +64,7 @@ void CSurfacePassElement::draw(const CRegion& damage) {
const auto PROJSIZEUNSCALED = windowBox.size(); const auto PROJSIZEUNSCALED = windowBox.size();
windowBox.scale(data.pMonitor->scale); windowBox.scale(data.pMonitor->m_scale);
windowBox.round(); windowBox.round();
if (windowBox.width <= 1 || windowBox.height <= 1) { if (windowBox.width <= 1 || windowBox.height <= 1) {
@@ -72,14 +72,14 @@ void CSurfacePassElement::draw(const CRegion& damage) {
return; return;
} }
const bool MISALIGNEDFSV1 = std::floor(data.pMonitor->scale) != data.pMonitor->scale /* Fractional */ && data.surface->current.scale == 1 /* fs protocol */ && const bool MISALIGNEDFSV1 = std::floor(data.pMonitor->m_scale) != data.pMonitor->m_scale /* Fractional */ && data.surface->current.scale == 1 /* fs protocol */ &&
windowBox.size() != data.surface->current.bufferSize /* misaligned */ && DELTALESSTHAN(windowBox.width, data.surface->current.bufferSize.x, 3) && windowBox.size() != data.surface->current.bufferSize /* misaligned */ && DELTALESSTHAN(windowBox.width, data.surface->current.bufferSize.x, 3) &&
DELTALESSTHAN(windowBox.height, data.surface->current.bufferSize.y, 3) /* off by one-or-two */ && DELTALESSTHAN(windowBox.height, data.surface->current.bufferSize.y, 3) /* off by one-or-two */ &&
(!data.pWindow || (!data.pWindow->m_realSize->isBeingAnimated() && !INTERACTIVERESIZEINPROGRESS)) /* not window or not animated/resizing */; (!data.pWindow || (!data.pWindow->m_realSize->isBeingAnimated() && !INTERACTIVERESIZEINPROGRESS)) /* not window or not animated/resizing */;
if (data.surface->colorManagement.valid()) if (data.surface->colorManagement.valid())
Debug::log(TRACE, "FIXME: rendering surface with color management enabled, should apply necessary transformations"); Debug::log(TRACE, "FIXME: rendering surface with color management enabled, should apply necessary transformations");
g_pHyprRenderer->calculateUVForSurface(data.pWindow, data.surface, data.pMonitor->self.lock(), data.mainSurface, windowBox.size(), PROJSIZEUNSCALED, MISALIGNEDFSV1); g_pHyprRenderer->calculateUVForSurface(data.pWindow, data.surface, data.pMonitor->m_self.lock(), data.mainSurface, windowBox.size(), PROJSIZEUNSCALED, MISALIGNEDFSV1);
auto cancelRender = false; auto cancelRender = false;
g_pHyprOpenGL->m_RenderData.clipRegion = visibleRegion(cancelRender); g_pHyprOpenGL->m_RenderData.clipRegion = visibleRegion(cancelRender);
@@ -127,7 +127,7 @@ void CSurfacePassElement::draw(const CRegion& damage) {
} }
if (!g_pHyprRenderer->m_bBlockSurfaceFeedback) if (!g_pHyprRenderer->m_bBlockSurfaceFeedback)
data.surface->presentFeedback(data.when, data.pMonitor->self.lock()); data.surface->presentFeedback(data.when, data.pMonitor->m_self.lock());
// add async (dmabuf) buffers to usedBuffers so we can handle release later // add async (dmabuf) buffers to usedBuffers so we can handle release later
// sync (shm) buffers will be released in commitState, so no need to track them here // sync (shm) buffers will be released in commitState, so no need to track them here
@@ -138,7 +138,7 @@ void CSurfacePassElement::draw(const CRegion& damage) {
} }
CBox CSurfacePassElement::getTexBox() { CBox CSurfacePassElement::getTexBox() {
const double outputX = -data.pMonitor->vecPosition.x, outputY = -data.pMonitor->vecPosition.y; const double outputX = -data.pMonitor->m_position.x, outputY = -data.pMonitor->m_position.y;
const auto INTERACTIVERESIZEINPROGRESS = data.pWindow && g_pInputManager->currentlyDraggedWindow && g_pInputManager->dragMode == MBIND_RESIZE; const auto INTERACTIVERESIZEINPROGRESS = data.pWindow && g_pInputManager->currentlyDraggedWindow && g_pInputManager->dragMode == MBIND_RESIZE;
auto PSURFACE = CWLSurface::fromResource(data.surface); auto PSURFACE = CWLSurface::fromResource(data.surface);
@@ -230,7 +230,7 @@ CRegion CSurfacePassElement::opaqueRegion() {
CRegion opaqueSurf = data.surface->current.opaque.copy().intersect(CBox{{}, {data.w, data.h}}); CRegion opaqueSurf = data.surface->current.opaque.copy().intersect(CBox{{}, {data.w, data.h}});
const auto texBox = getTexBox(); const auto texBox = getTexBox();
opaqueSurf.scale(texBox.size() / Vector2D{data.w, data.h}); opaqueSurf.scale(texBox.size() / Vector2D{data.w, data.h});
return opaqueSurf.translate(data.pos + data.localPos - data.pMonitor->vecPosition).expand(-data.rounding); return opaqueSurf.translate(data.pos + data.localPos - data.pMonitor->m_position).expand(-data.rounding);
} }
return data.texture && data.texture->m_bOpaque ? boundingBox()->expand(-data.rounding) : CRegion{}; return data.texture && data.texture->m_bOpaque ? boundingBox()->expand(-data.rounding) : CRegion{};
@@ -269,11 +269,11 @@ CRegion CSurfacePassElement::visibleRegion(bool& cancel) {
visibleRegion.translate(-uvTL * bufferSize); visibleRegion.translate(-uvTL * bufferSize);
auto texBox = getTexBox(); auto texBox = getTexBox();
texBox.scale(data.pMonitor->scale); texBox.scale(data.pMonitor->m_scale);
texBox.round(); texBox.round();
visibleRegion.scale((Vector2D(1, 1) / (uvBR - uvTL)) * (texBox.size() / bufferSize)); visibleRegion.scale((Vector2D(1, 1) / (uvBR - uvTL)) * (texBox.size() / bufferSize));
visibleRegion.translate((data.pos + data.localPos) * data.pMonitor->scale - data.pMonitor->vecPosition); visibleRegion.translate((data.pos + data.localPos) * data.pMonitor->m_scale - data.pMonitor->m_position);
return visibleRegion; return visibleRegion;
} }
@@ -281,6 +281,6 @@ CRegion CSurfacePassElement::visibleRegion(bool& cancel) {
void CSurfacePassElement::discard() { void CSurfacePassElement::discard() {
if (!g_pHyprRenderer->m_bBlockSurfaceFeedback) { if (!g_pHyprRenderer->m_bBlockSurfaceFeedback) {
Debug::log(TRACE, "discard for invisible surface"); Debug::log(TRACE, "discard for invisible surface");
data.surface->presentFeedback(data.when, data.pMonitor->self.lock(), true); data.surface->presentFeedback(data.when, data.pMonitor->m_self.lock(), true);
} }
} }

4
src/render/pass/TexPassElement.cpp
View File

@@ -24,7 +24,7 @@ void CTexPassElement::draw(const CRegion& damage) {
g_pHyprOpenGL->m_RenderData.monitorProjection = *data.replaceProjection; g_pHyprOpenGL->m_RenderData.monitorProjection = *data.replaceProjection;
g_pHyprOpenGL->renderTextureInternalWithDamage(data.tex, data.box, data.a, data.damage.empty() ? damage : data.damage, data.round, data.roundingPower); g_pHyprOpenGL->renderTextureInternalWithDamage(data.tex, data.box, data.a, data.damage.empty() ? damage : data.damage, data.round, data.roundingPower);
if (data.replaceProjection) if (data.replaceProjection)
g_pHyprOpenGL->m_RenderData.monitorProjection = g_pHyprOpenGL->m_RenderData.pMonitor->projMatrix; g_pHyprOpenGL->m_RenderData.monitorProjection = g_pHyprOpenGL->m_RenderData.pMonitor->m_projMatrix;
} }
bool CTexPassElement::needsLiveBlur() { bool CTexPassElement::needsLiveBlur() {
@@ -36,7 +36,7 @@ bool CTexPassElement::needsPrecomputeBlur() {
} }
std::optional<CBox> CTexPassElement::boundingBox() { std::optional<CBox> CTexPassElement::boundingBox() {
return data.box.copy().scale(1.F / g_pHyprOpenGL->m_RenderData.pMonitor->scale).round(); return data.box.copy().scale(1.F / g_pHyprOpenGL->m_RenderData.pMonitor->m_scale).round();
} }
CRegion CTexPassElement::opaqueRegion() { CRegion CTexPassElement::opaqueRegion() {