diff --git a/src/Compositor.cpp b/src/Compositor.cpp index 9d8bb62e..d4e5bc43 100644 --- a/src/Compositor.cpp +++ b/src/Compositor.cpp @@ -952,7 +952,7 @@ PHLWINDOW CCompositor::vectorToWindowUnified(const Vector2D& pos, uint8_t proper const WORKSPACEID WSPID = special ? PMONITOR->activeSpecialWorkspaceID() : PMONITOR->activeWorkspaceID(); const auto PWORKSPACE = getWorkspaceByID(WSPID); - if (PWORKSPACE->m_bHasFullscreenWindow && !(properties & SKIP_FULLSCREEN_PRIORITY)) + if (PWORKSPACE->m_hasFullscreenWindow && !(properties & SKIP_FULLSCREEN_PRIORITY)) return PWORKSPACE->getFullscreenWindow(); auto found = floating(false); @@ -1145,10 +1145,10 @@ void CCompositor::focusWindow(PHLWINDOW pWindow, SP pSurface if (!pWindow->m_pWorkspace || !pWindow->m_pWorkspace->isVisible()) { const auto PWORKSPACE = pWindow->m_pWorkspace; // This is to fix incorrect feedback on the focus history. - PWORKSPACE->m_pLastFocusedWindow = pWindow; + PWORKSPACE->m_lastFocusedWindow = pWindow; if (m_lastMonitor->activeWorkspace) PWORKSPACE->rememberPrevWorkspace(m_lastMonitor->activeWorkspace); - if (PWORKSPACE->m_bIsSpecialWorkspace) + if (PWORKSPACE->m_isSpecialWorkspace) m_lastMonitor->changeWorkspace(PWORKSPACE, false, true); // if special ws, open on current monitor else if (PMONITOR) PMONITOR->changeWorkspace(PWORKSPACE, false, true); @@ -1327,7 +1327,7 @@ PHLWINDOW CCompositor::getWindowFromHandle(uint32_t handle) { PHLWORKSPACE CCompositor::getWorkspaceByID(const WORKSPACEID& id) { for (auto const& w : m_workspaces) { - if (w->m_iID == id && !w->inert()) + if (w->m_id == id && !w->inert()) return w; } @@ -1340,7 +1340,7 @@ void CCompositor::sanityCheckWorkspaces() { const auto& WORKSPACE = *it; // If ref == 1, only the compositor holds a ref, which means it's inactive and has no mapped windows. - if (!WORKSPACE->m_bPersistent && WORKSPACE.strongRef() == 1) { + if (!WORKSPACE->m_persistent && WORKSPACE.strongRef() == 1) { it = m_workspaces.erase(it); continue; } @@ -1551,13 +1551,13 @@ PHLWINDOW CCompositor::getWindowInDirection(const CBox& box, PHLWORKSPACE pWorks if (w == ignoreWindow || !w->m_pWorkspace || !w->m_bIsMapped || w->isHidden() || (!w->isFullscreen() && w->m_bIsFloating) || !w->m_pWorkspace->isVisible()) continue; - if (pWorkspace->m_pMonitor == w->m_pMonitor && pWorkspace != w->m_pWorkspace) + if (pWorkspace->m_monitor == w->m_pMonitor && pWorkspace != w->m_pWorkspace) continue; - if (pWorkspace->m_bHasFullscreenWindow && !w->isFullscreen() && !w->m_bCreatedOverFullscreen) + if (pWorkspace->m_hasFullscreenWindow && !w->isFullscreen() && !w->m_bCreatedOverFullscreen) continue; - if (!*PMONITORFALLBACK && pWorkspace->m_pMonitor != w->m_pMonitor) + if (!*PMONITORFALLBACK && pWorkspace->m_monitor != w->m_pMonitor) continue; const auto BWINDOWIDEALBB = w->getWindowIdealBoundingBoxIgnoreReserved(); @@ -1640,13 +1640,13 @@ PHLWINDOW CCompositor::getWindowInDirection(const CBox& box, PHLWORKSPACE pWorks if (w == ignoreWindow || !w->m_bIsMapped || !w->m_pWorkspace || w->isHidden() || (!w->isFullscreen() && !w->m_bIsFloating) || !w->m_pWorkspace->isVisible()) continue; - if (pWorkspace->m_pMonitor == w->m_pMonitor && pWorkspace != w->m_pWorkspace) + if (pWorkspace->m_monitor == w->m_pMonitor && pWorkspace != w->m_pWorkspace) continue; - if (pWorkspace->m_bHasFullscreenWindow && !w->isFullscreen() && !w->m_bCreatedOverFullscreen) + if (pWorkspace->m_hasFullscreenWindow && !w->isFullscreen() && !w->m_bCreatedOverFullscreen) continue; - if (!*PMONITORFALLBACK && pWorkspace->m_pMonitor != w->m_pMonitor) + if (!*PMONITORFALLBACK && pWorkspace->m_monitor != w->m_pMonitor) continue; const auto DIST = w->middle().distance(box.middle()); @@ -1662,7 +1662,7 @@ PHLWINDOW CCompositor::getWindowInDirection(const CBox& box, PHLWORKSPACE pWorks } } - if (!leaderWindow && pWorkspace->m_bHasFullscreenWindow) + if (!leaderWindow && pWorkspace->m_hasFullscreenWindow) leaderWindow = pWorkspace->getFullscreenWindow(); } @@ -1722,8 +1722,8 @@ PHLWINDOW CCompositor::getWindowCycle(PHLWINDOW cur, bool focusableOnly, std::op WORKSPACEID CCompositor::getNextAvailableNamedWorkspace() { WORKSPACEID lowest = -1337 + 1; for (auto const& w : m_workspaces) { - if (w->m_iID < -1 && w->m_iID < lowest) - lowest = w->m_iID; + if (w->m_id < -1 && w->m_id < lowest) + lowest = w->m_id; } return lowest - 1; @@ -1731,7 +1731,7 @@ WORKSPACEID CCompositor::getNextAvailableNamedWorkspace() { PHLWORKSPACE CCompositor::getWorkspaceByName(const std::string& name) { for (auto const& w : m_workspaces) { - if (w->m_szName == name && !w->inert()) + if (w->m_name == name && !w->inert()) return w; } @@ -1956,7 +1956,7 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor const auto PWORKSPACEA = pMonitorA->activeWorkspace; const auto PWORKSPACEB = pMonitorB->activeWorkspace; - PWORKSPACEA->m_pMonitor = pMonitorB; + PWORKSPACEA->m_monitor = pMonitorB; PWORKSPACEA->moveToMonitor(pMonitorB->ID); for (auto const& w : m_windows) { @@ -1981,7 +1981,7 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor } } - PWORKSPACEB->m_pMonitor = pMonitorA; + PWORKSPACEB->m_monitor = pMonitorA; PWORKSPACEB->moveToMonitor(pMonitorA->ID); for (auto const& w : m_windows) { @@ -2024,17 +2024,17 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor (g_pCompositor->vectorToWindowUnified(g_pInputManager->getMouseCoordsInternal(), RESERVED_EXTENTS | INPUT_EXTENTS | ALLOW_FLOATING))); const auto PNEWWORKSPACE = pMonitorA->ID == g_pCompositor->m_lastMonitor->ID ? PWORKSPACEB : PWORKSPACEA; - g_pEventManager->postEvent(SHyprIPCEvent{.event = "workspace", .data = PNEWWORKSPACE->m_szName}); - g_pEventManager->postEvent(SHyprIPCEvent{.event = "workspacev2", .data = std::format("{},{}", PNEWWORKSPACE->m_iID, PNEWWORKSPACE->m_szName)}); + 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)}); EMIT_HOOK_EVENT("workspace", PNEWWORKSPACE); } // event - g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = PWORKSPACEA->m_szName + "," + pMonitorB->szName}); - g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", PWORKSPACEA->m_iID, PWORKSPACEA->m_szName, pMonitorB->szName)}); + g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = PWORKSPACEA->m_name + "," + pMonitorB->szName}); + g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", PWORKSPACEA->m_id, PWORKSPACEA->m_name, pMonitorB->szName)}); EMIT_HOOK_EVENT("moveWorkspace", (std::vector{PWORKSPACEA, pMonitorB})); - g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = PWORKSPACEB->m_szName + "," + pMonitorA->szName}); - g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", PWORKSPACEB->m_iID, PWORKSPACEB->m_szName, pMonitorA->szName)}); + g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = PWORKSPACEB->m_name + "," + pMonitorA->szName}); + g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", PWORKSPACEB->m_id, PWORKSPACEB->m_name, pMonitorA->szName)}); EMIT_HOOK_EVENT("moveWorkspace", (std::vector{PWORKSPACEB, pMonitorA})); } @@ -2119,23 +2119,23 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo if (!pWorkspace || !pMonitor) return; - if (pWorkspace->m_pMonitor == pMonitor) + if (pWorkspace->m_monitor == pMonitor) return; - Debug::log(LOG, "moveWorkspaceToMonitor: Moving {} to monitor {}", pWorkspace->m_iID, pMonitor->ID); + Debug::log(LOG, "moveWorkspaceToMonitor: Moving {} to monitor {}", pWorkspace->m_id, pMonitor->ID); - const auto POLDMON = pWorkspace->m_pMonitor.lock(); + const auto POLDMON = pWorkspace->m_monitor.lock(); const bool SWITCHINGISACTIVE = POLDMON ? POLDMON->activeWorkspace == pWorkspace : false; // fix old mon WORKSPACEID nextWorkspaceOnMonitorID = WORKSPACE_INVALID; if (!SWITCHINGISACTIVE) - nextWorkspaceOnMonitorID = pWorkspace->m_iID; + nextWorkspaceOnMonitorID = pWorkspace->m_id; else { for (auto const& w : m_workspaces) { - if (w->m_pMonitor == POLDMON && w->m_iID != pWorkspace->m_iID && !w->m_bIsSpecialWorkspace) { - nextWorkspaceOnMonitorID = w->m_iID; + if (w->m_monitor == POLDMON && w->m_id != pWorkspace->m_id && !w->m_isSpecialWorkspace) { + nextWorkspaceOnMonitorID = w->m_id; break; } } @@ -2161,7 +2161,7 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo } // move the workspace - pWorkspace->m_pMonitor = pMonitor; + pWorkspace->m_monitor = pMonitor; pWorkspace->moveToMonitor(pMonitor->ID); for (auto const& w : m_windows) { @@ -2195,10 +2195,10 @@ 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. - Debug::log(LOG, "moveWorkspaceToMonitor: SWITCHINGISACTIVE, active {} -> {}", pMonitor->activeWorkspaceID(), pWorkspace->m_iID); + Debug::log(LOG, "moveWorkspaceToMonitor: SWITCHINGISACTIVE, active {} -> {}", pMonitor->activeWorkspaceID(), pWorkspace->m_id); if (valid(pMonitor->activeWorkspace)) { - pMonitor->activeWorkspace->m_bVisible = false; + pMonitor->activeWorkspace->m_visible = false; pMonitor->activeWorkspace->startAnim(false, false); } @@ -2210,7 +2210,7 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitor->ID); pWorkspace->startAnim(true, true, true); - pWorkspace->m_bVisible = true; + pWorkspace->m_visible = true; if (!noWarpCursor) g_pPointerManager->warpTo(pMonitor->vecPosition + pMonitor->vecTransformedSize / 2.F); @@ -2230,8 +2230,8 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo updateSuspendedStates(); // event - g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = pWorkspace->m_szName + "," + pMonitor->szName}); - g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", pWorkspace->m_iID, pWorkspace->m_szName, pMonitor->szName)}); + g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspace", .data = pWorkspace->m_name + "," + pMonitor->szName}); + g_pEventManager->postEvent(SHyprIPCEvent{.event = "moveworkspacev2", .data = std::format("{},{},{}", pWorkspace->m_id, pWorkspace->m_name, pMonitor->szName)}); EMIT_HOOK_EVENT("moveWorkspace", (std::vector{pWorkspace, pMonitor})); } @@ -2240,10 +2240,10 @@ bool CCompositor::workspaceIDOutOfBounds(const WORKSPACEID& id) { WORKSPACEID highestID = INT64_MIN; for (auto const& w : m_workspaces) { - if (w->m_bIsSpecialWorkspace) + if (w->m_isSpecialWorkspace) continue; - lowestID = std::min(w->m_iID, lowestID); - highestID = std::max(w->m_iID, highestID); + lowestID = std::min(w->m_id, lowestID); + highestID = std::max(w->m_id, highestID); } return std::clamp(id, lowestID, highestID) != id; @@ -2254,7 +2254,7 @@ void CCompositor::updateFullscreenFadeOnWorkspace(PHLWORKSPACE pWorkspace) { if (!pWorkspace) return; - const auto FULLSCREEN = pWorkspace->m_bHasFullscreenWindow; + const auto FULLSCREEN = pWorkspace->m_hasFullscreenWindow; for (auto const& w : g_pCompositor->m_windows) { if (w->m_pWorkspace == pWorkspace) { @@ -2269,12 +2269,12 @@ void CCompositor::updateFullscreenFadeOnWorkspace(PHLWORKSPACE pWorkspace) { } } - const auto PMONITOR = pWorkspace->m_pMonitor.lock(); + const auto PMONITOR = pWorkspace->m_monitor.lock(); - if (pWorkspace->m_iID == PMONITOR->activeWorkspaceID() || pWorkspace->m_iID == 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]) { if (!ls->m_fadingOut) - *ls->m_alpha = FULLSCREEN && pWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN ? 0.f : 1.f; + *ls->m_alpha = FULLSCREEN && pWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN ? 0.f : 1.f; } } } @@ -2322,7 +2322,7 @@ void CCompositor::setWindowFullscreenState(const PHLWINDOW PWINDOW, SFullscreenS PWINDOW->m_bPinFullscreened = true; } - if (PWORKSPACE->m_bHasFullscreenWindow && !PWINDOW->isFullscreen()) + if (PWORKSPACE->m_hasFullscreenWindow && !PWINDOW->isFullscreen()) setWindowFullscreenInternal(PWORKSPACE->getFullscreenWindow(), FSMODE_NONE); const bool CHANGEINTERNAL = !PWINDOW->m_bPinned && CURRENT_EFFECTIVE_MODE != EFFECTIVE_MODE; @@ -2349,8 +2349,8 @@ void CCompositor::setWindowFullscreenState(const PHLWINDOW PWINDOW, SFullscreenS g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(PWINDOW, CURRENT_EFFECTIVE_MODE, EFFECTIVE_MODE); PWINDOW->m_sFullscreenState.internal = state.internal; - PWORKSPACE->m_efFullscreenMode = EFFECTIVE_MODE; - PWORKSPACE->m_bHasFullscreenWindow = EFFECTIVE_MODE != FSMODE_NONE; + PWORKSPACE->m_fullscreenMode = EFFECTIVE_MODE; + PWORKSPACE->m_hasFullscreenWindow = EFFECTIVE_MODE != FSMODE_NONE; g_pEventManager->postEvent(SHyprIPCEvent{.event = "fullscreen", .data = std::to_string((int)EFFECTIVE_MODE != FSMODE_NONE)}); EMIT_HOOK_EVENT("fullscreen", PWINDOW); @@ -2644,7 +2644,7 @@ PHLWORKSPACE CCompositor::createNewWorkspace(const WORKSPACEID& id, const MONITO const auto PWORKSPACE = m_workspaces.emplace_back(CWorkspace::create(id, PMONITOR, NAME, SPECIAL, isEmpty)); - PWORKSPACE->m_fAlpha->setValueAndWarp(0); + PWORKSPACE->m_alpha->setValueAndWarp(0); return PWORKSPACE; } @@ -2660,8 +2660,8 @@ void CCompositor::setActiveMonitor(PHLMONITOR pMonitor) { const auto PWORKSPACE = pMonitor->activeWorkspace; - const auto WORKSPACE_ID = PWORKSPACE ? std::to_string(PWORKSPACE->m_iID) : std::to_string(WORKSPACE_INVALID); - const auto WORKSPACE_NAME = PWORKSPACE ? PWORKSPACE->m_szName : "?"; + const auto WORKSPACE_ID = PWORKSPACE ? std::to_string(PWORKSPACE->m_id) : std::to_string(WORKSPACE_INVALID); + const auto WORKSPACE_NAME = PWORKSPACE ? PWORKSPACE->m_name : "?"; g_pEventManager->postEvent(SHyprIPCEvent{.event = "focusedmon", .data = pMonitor->szName + "," + WORKSPACE_NAME}); g_pEventManager->postEvent(SHyprIPCEvent{.event = "focusedmonv2", .data = pMonitor->szName + "," + WORKSPACE_ID}); @@ -2677,8 +2677,8 @@ bool CCompositor::isWorkspaceSpecial(const WORKSPACEID& id) { WORKSPACEID CCompositor::getNewSpecialID() { WORKSPACEID highest = SPECIAL_WORKSPACE_START; for (auto const& ws : m_workspaces) { - if (ws->m_bIsSpecialWorkspace && ws->m_iID > highest) { - highest = ws->m_iID; + if (ws->m_isSpecialWorkspace && ws->m_id > highest) { + highest = ws->m_id; } } @@ -2717,7 +2717,7 @@ void CCompositor::moveWindowToWorkspaceSafe(PHLWINDOW pWindow, PHLWORKSPACE pWor if (!pWindow || !pWorkspace) return; - if (pWindow->m_bPinned && pWorkspace->m_bIsSpecialWorkspace) + if (pWindow->m_bPinned && pWorkspace->m_isSpecialWorkspace) return; if (pWindow->m_pWorkspace == pWorkspace) @@ -2733,13 +2733,13 @@ void CCompositor::moveWindowToWorkspaceSafe(PHLWINDOW pWindow, PHLWORKSPACE pWor const PHLWINDOW pFirstWindowOnWorkspace = pWorkspace->getFirstWindow(); const int visibleWindowsOnWorkspace = pWorkspace->getWindows(std::nullopt, true); const auto POSTOMON = pWindow->m_vRealPosition->goal() - (pWindow->m_pMonitor ? pWindow->m_pMonitor->vecPosition : Vector2D{}); - const auto PWORKSPACEMONITOR = pWorkspace->m_pMonitor.lock(); + const auto PWORKSPACEMONITOR = pWorkspace->m_monitor.lock(); if (!pWindow->m_bIsFloating) g_pLayoutManager->getCurrentLayout()->onWindowRemovedTiling(pWindow); pWindow->moveToWorkspace(pWorkspace); - pWindow->m_pMonitor = pWorkspace->m_pMonitor; + pWindow->m_pMonitor = pWorkspace->m_monitor; static auto PGROUPONMOVETOWORKSPACE = CConfigValue("group:group_on_movetoworkspace"); if (*PGROUPONMOVETOWORKSPACE && visibleWindowsOnWorkspace == 1 && pFirstWindowOnWorkspace && pFirstWindowOnWorkspace != pWindow && @@ -2950,8 +2950,8 @@ void CCompositor::setPreferredScaleForSurface(SP pSurface, d return; } - PSURFACE->m_fLastScale = scale; - PSURFACE->m_iLastScale = static_cast(std::ceil(scale)); + PSURFACE->m_lastScaleFloat = scale; + PSURFACE->m_lastScaleInt = static_cast(std::ceil(scale)); } void CCompositor::setPreferredTransformForSurface(SP pSurface, wl_output_transform transform) { @@ -2963,7 +2963,7 @@ void CCompositor::setPreferredTransformForSurface(SP pSurfac return; } - PSURFACE->m_eLastTransform = transform; + PSURFACE->m_lastTransform = transform; } void CCompositor::updateSuspendedStates() { @@ -3115,7 +3115,7 @@ void CCompositor::ensurePersistentWorkspacesPresent(const std::vectorm_bPersistent = true; + PWORKSPACE->m_persistent = true; if (!PMONITOR) { Debug::log(ERR, "ensurePersistentWorkspacesPresent: couldn't resolve monitor for {}, skipping", rule.monitor); @@ -3123,7 +3123,7 @@ void CCompositor::ensurePersistentWorkspacesPresent(const std::vectorm_pMonitor == PMONITOR) { + if (PWORKSPACE->m_monitor == PMONITOR) { Debug::log(LOG, "ensurePersistentWorkspacesPresent: workspace persistent {} already on {}", rule.workspaceString, PMONITOR->szName); continue; diff --git a/src/config/ConfigManager.cpp b/src/config/ConfigManager.cpp index 3ead5c5b..872456a6 100644 --- a/src/config/ConfigManager.cpp +++ b/src/config/ConfigManager.cpp @@ -1452,7 +1452,7 @@ std::vector> CConfigManager::getMatchingRules(PHLWINDOW pWindow, continue; if (rule->szWorkspace.starts_with("name:")) { - if (PWORKSPACE->m_szName != rule->szWorkspace.substr(5)) + if (PWORKSPACE->m_name != rule->szWorkspace.substr(5)) continue; } else { // number @@ -1461,7 +1461,7 @@ std::vector> CConfigManager::getMatchingRules(PHLWINDOW pWindow, const int64_t ID = std::stoll(rule->szWorkspace); - if (PWORKSPACE->m_iID != ID) + if (PWORKSPACE->m_id != ID) continue; } } @@ -1713,7 +1713,7 @@ void CConfigManager::ensureVRR(PHLMONITOR pMonitor) { if (!PWORKSPACE) return; // ??? - bool wantVRR = PWORKSPACE->m_bHasFullscreenWindow && (PWORKSPACE->m_efFullscreenMode & FSMODE_FULLSCREEN); + bool wantVRR = PWORKSPACE->m_hasFullscreenWindow && (PWORKSPACE->m_fullscreenMode & FSMODE_FULLSCREEN); if (wantVRR && USEVRR == 3) { const auto contentType = PWORKSPACE->getFullscreenWindow()->getContentType(); wantVRR = contentType == CONTENT_TYPE_GAME || contentType == CONTENT_TYPE_VIDEO; diff --git a/src/debug/HyprCtl.cpp b/src/debug/HyprCtl.cpp index 72dde67f..e66e4208 100644 --- a/src/debug/HyprCtl.cpp +++ b/src/debug/HyprCtl.cpp @@ -130,8 +130,8 @@ std::string CHyprCtl::getMonitorData(Hyprutils::Memory::CSharedPointer m->ID, escapeJSONStrings(m->szName), escapeJSONStrings(m->szShortDescription), escapeJSONStrings(m->output->make), escapeJSONStrings(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, - m->activeWorkspaceID(), (!m->activeWorkspace ? "" : escapeJSONStrings(m->activeWorkspace->m_szName)), m->activeSpecialWorkspaceID(), - escapeJSONStrings(m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_szName : ""), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y, + m->activeWorkspaceID(), (!m->activeWorkspace ? "" : escapeJSONStrings(m->activeWorkspace->m_name)), m->activeSpecialWorkspaceID(), + escapeJSONStrings(m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_name : ""), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)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->tearingState.activelyTearing ? "true" : "false"), (uint64_t)m->lastScanout.get(), (m->m_bEnabled ? "false" : "true"), @@ -143,8 +143,8 @@ std::string CHyprCtl::getMonitorData(Hyprutils::Memory::CSharedPointer "dpmsStatus: {}\n\tvrr: {}\n\tsolitary: {:x}\n\tactivelyTearing: {}\n\tdirectScanoutTo: {:x}\n\tdisabled: {}\n\tcurrentFormat: {}\n\tmirrorOf: " "{}\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->output->make, m->output->model, m->output->serial, m->activeWorkspaceID(), (!m->activeWorkspace ? "" : m->activeWorkspace->m_szName), - m->activeSpecialWorkspaceID(), (m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_szName : ""), (int)m->vecReservedTopLeft.x, + m->output->make, m->output->model, m->output->serial, m->activeWorkspaceID(), (!m->activeWorkspace ? "" : m->activeWorkspace->m_name), + m->activeSpecialWorkspaceID(), (m->activeSpecialWorkspace ? m->activeSpecialWorkspace->m_name : ""), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m == g_pCompositor->m_lastMonitor ? "yes" : "no"), (int)m->dpmsStatus, m->output->state->state().adaptiveSync, (uint64_t)m->solitaryClient.get(), m->tearingState.activelyTearing, (uint64_t)m->lastScanout.get(), !m->m_bEnabled, formatToString(m->output->state->state().drmFormat), @@ -264,7 +264,7 @@ std::string CHyprCtl::getWindowData(PHLWINDOW w, eHyprCtlOutputFormat format) { }},)#", (uintptr_t)w.get(), (w->m_bIsMapped ? "true" : "false"), (w->isHidden() ? "true" : "false"), (int)w->m_vRealPosition->goal().x, (int)w->m_vRealPosition->goal().y, (int)w->m_vRealSize->goal().x, (int)w->m_vRealSize->goal().y, w->m_pWorkspace ? w->workspaceID() : WORKSPACE_INVALID, - escapeJSONStrings(!w->m_pWorkspace ? "" : w->m_pWorkspace->m_szName), ((int)w->m_bIsFloating == 1 ? "true" : "false"), (w->m_bIsPseudotiled ? "true" : "false"), + escapeJSONStrings(!w->m_pWorkspace ? "" : w->m_pWorkspace->m_name), ((int)w->m_bIsFloating == 1 ? "true" : "false"), (w->m_bIsPseudotiled ? "true" : "false"), (int64_t)w->monitorID(), escapeJSONStrings(w->m_szClass), escapeJSONStrings(w->m_szTitle), escapeJSONStrings(w->m_szInitialClass), escapeJSONStrings(w->m_szInitialTitle), w->getPID(), ((int)w->m_bIsX11 == 1 ? "true" : "false"), (w->m_bPinned ? "true" : "false"), (uint8_t)w->m_sFullscreenState.internal, (uint8_t)w->m_sFullscreenState.client, getGroupedData(w, format), getTagsData(w, format), (uintptr_t)w->m_pSwallowed.get(), @@ -278,11 +278,10 @@ std::string CHyprCtl::getWindowData(PHLWINDOW w, eHyprCtlOutputFormat format) { "{}\n\tfullscreen: {}\n\tfullscreenClient: {}\n\tgrouped: {}\n\ttags: {}\n\tswallowing: {:x}\n\tfocusHistoryID: {}\n\tinhibitingIdle: {}\n\txdgTag: " "{}\n\txdgDescription: {}\n\n", (uintptr_t)w.get(), w->m_szTitle, (int)w->m_bIsMapped, (int)w->isHidden(), (int)w->m_vRealPosition->goal().x, (int)w->m_vRealPosition->goal().y, - (int)w->m_vRealSize->goal().x, (int)w->m_vRealSize->goal().y, w->m_pWorkspace ? w->workspaceID() : WORKSPACE_INVALID, - (!w->m_pWorkspace ? "" : w->m_pWorkspace->m_szName), (int)w->m_bIsFloating, (int)w->m_bIsPseudotiled, (int64_t)w->monitorID(), w->m_szClass, w->m_szTitle, - w->m_szInitialClass, w->m_szInitialTitle, w->getPID(), (int)w->m_bIsX11, (int)w->m_bPinned, (uint8_t)w->m_sFullscreenState.internal, - (uint8_t)w->m_sFullscreenState.client, getGroupedData(w, format), getTagsData(w, format), (uintptr_t)w->m_pSwallowed.get(), getFocusHistoryID(w), - (int)g_pInputManager->isWindowInhibiting(w, false), w->xdgTag().value_or(""), w->xdgDescription().value_or("")); + (int)w->m_vRealSize->goal().x, (int)w->m_vRealSize->goal().y, w->m_pWorkspace ? w->workspaceID() : WORKSPACE_INVALID, (!w->m_pWorkspace ? "" : w->m_pWorkspace->m_name), + (int)w->m_bIsFloating, (int)w->m_bIsPseudotiled, (int64_t)w->monitorID(), w->m_szClass, w->m_szTitle, w->m_szInitialClass, w->m_szInitialTitle, w->getPID(), + (int)w->m_bIsX11, (int)w->m_bPinned, (uint8_t)w->m_sFullscreenState.internal, (uint8_t)w->m_sFullscreenState.client, getGroupedData(w, format), getTagsData(w, format), + (uintptr_t)w->m_pSwallowed.get(), getFocusHistoryID(w), (int)g_pInputManager->isWindowInhibiting(w, false), w->xdgTag().value_or(""), w->xdgDescription().value_or("")); } } @@ -314,7 +313,7 @@ static std::string clientsRequest(eHyprCtlOutputFormat format, std::string reque std::string CHyprCtl::getWorkspaceData(PHLWORKSPACE w, eHyprCtlOutputFormat format) { const auto PLASTW = w->getLastFocusedWindow(); - const auto PMONITOR = w->m_pMonitor.lock(); + const auto PMONITOR = w->m_monitor.lock(); if (format == eHyprCtlOutputFormat::FORMAT_JSON) { return std::format(R"#({{ "id": {}, @@ -327,14 +326,14 @@ std::string CHyprCtl::getWorkspaceData(PHLWORKSPACE w, eHyprCtlOutputFormat form "lastwindowtitle": "{}", "ispersistent": {} }})#", - w->m_iID, escapeJSONStrings(w->m_szName), escapeJSONStrings(PMONITOR ? PMONITOR->szName : "?"), - escapeJSONStrings(PMONITOR ? std::to_string(PMONITOR->ID) : "null"), w->getWindows(), w->m_bHasFullscreenWindow ? "true" : "false", - (uintptr_t)PLASTW.get(), PLASTW ? escapeJSONStrings(PLASTW->m_szTitle) : "", w->m_bPersistent ? "true" : "false"); + w->m_id, escapeJSONStrings(w->m_name), escapeJSONStrings(PMONITOR ? PMONITOR->szName : "?"), + escapeJSONStrings(PMONITOR ? std::to_string(PMONITOR->ID) : "null"), w->getWindows(), w->m_hasFullscreenWindow ? "true" : "false", + (uintptr_t)PLASTW.get(), PLASTW ? escapeJSONStrings(PLASTW->m_szTitle) : "", w->m_persistent ? "true" : "false"); } else { return std::format( "workspace ID {} ({}) on monitor {}:\n\tmonitorID: {}\n\twindows: {}\n\thasfullscreen: {}\n\tlastwindow: 0x{:x}\n\tlastwindowtitle: {}\n\tispersistent: {}\n\n", - w->m_iID, w->m_szName, PMONITOR ? PMONITOR->szName : "?", PMONITOR ? std::to_string(PMONITOR->ID) : "null", w->getWindows(), (int)w->m_bHasFullscreenWindow, - (uintptr_t)PLASTW.get(), PLASTW ? PLASTW->m_szTitle : "", (int)w->m_bPersistent); + w->m_id, w->m_name, PMONITOR ? PMONITOR->szName : "?", PMONITOR ? std::to_string(PMONITOR->ID) : "null", w->getWindows(), (int)w->m_hasFullscreenWindow, + (uintptr_t)PLASTW.get(), PLASTW ? PLASTW->m_szTitle : "", (int)w->m_persistent); } } diff --git a/src/desktop/LayerSurface.cpp b/src/desktop/LayerSurface.cpp index d8ba5f21..b44f652b 100644 --- a/src/desktop/LayerSurface.cpp +++ b/src/desktop/LayerSurface.cpp @@ -180,7 +180,7 @@ void CLayerSurface::onMap() { CBox geomFixed = {m_geometry.x + PMONITOR->vecPosition.x, m_geometry.y + PMONITOR->vecPosition.y, m_geometry.width, m_geometry.height}; g_pHyprRenderer->damageBox(geomFixed); - const bool FULLSCREEN = PMONITOR->activeWorkspace && PMONITOR->activeWorkspace->m_bHasFullscreenWindow && PMONITOR->activeWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN; + const bool FULLSCREEN = PMONITOR->activeWorkspace && PMONITOR->activeWorkspace->m_hasFullscreenWindow && PMONITOR->activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN; startAnimation(!(m_layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP && FULLSCREEN && !GRABSFOCUS)); m_readyToDelete = false; diff --git a/src/desktop/Popup.cpp b/src/desktop/Popup.cpp index d67eec6c..8043bc31 100644 --- a/src/desktop/Popup.cpp +++ b/src/desktop/Popup.cpp @@ -172,7 +172,7 @@ void CPopup::onCommit(bool ignoreSiblings) { return; } - if (!m_windowOwner.expired() && (!m_windowOwner->m_bIsMapped || !m_windowOwner->m_pWorkspace->m_bVisible)) { + if (!m_windowOwner.expired() && (!m_windowOwner->m_bIsMapped || !m_windowOwner->m_pWorkspace->m_visible)) { m_lastSize = m_resource->surface->surface->current.size; static auto PLOGDAMAGE = CConfigValue("debug:log_damage"); @@ -301,9 +301,9 @@ Vector2D CPopup::size() { void CPopup::sendScale() { if (!m_windowOwner.expired()) - g_pCompositor->setPreferredScaleForSurface(m_wlSurface->resource(), m_windowOwner->m_pWLSurface->m_fLastScale); + g_pCompositor->setPreferredScaleForSurface(m_wlSurface->resource(), m_windowOwner->m_pWLSurface->m_lastScaleFloat); else if (!m_layerOwner.expired()) - g_pCompositor->setPreferredScaleForSurface(m_wlSurface->resource(), m_layerOwner->m_surface->m_fLastScale); + g_pCompositor->setPreferredScaleForSurface(m_wlSurface->resource(), m_layerOwner->m_surface->m_lastScaleFloat); else UNREACHABLE(); } diff --git a/src/desktop/Rule.cpp b/src/desktop/Rule.cpp index aa87a483..93f38de0 100644 --- a/src/desktop/Rule.cpp +++ b/src/desktop/Rule.cpp @@ -6,17 +6,17 @@ CRuleRegexContainer::CRuleRegexContainer(const std::string& regex_) { const bool NEGATIVE = regex_.starts_with("negative:"); - negative = NEGATIVE; - regex = makeUnique(NEGATIVE ? regex_.substr(9) : regex_); + m_negative = NEGATIVE; + m_regex = makeUnique(NEGATIVE ? regex_.substr(9) : regex_); // TODO: maybe pop an error? - if (!regex->ok()) + if (!m_regex->ok()) Debug::log(ERR, "RuleRegexContainer: regex {} failed to parse!", regex_); } bool CRuleRegexContainer::passes(const std::string& str) const { - if (!regex) + if (!m_regex) return false; - return RE2::FullMatch(str, *regex) != negative; + return RE2::FullMatch(str, *m_regex) != m_negative; } \ No newline at end of file diff --git a/src/desktop/Rule.hpp b/src/desktop/Rule.hpp index 858b4ded..9d3de70e 100644 --- a/src/desktop/Rule.hpp +++ b/src/desktop/Rule.hpp @@ -16,6 +16,6 @@ class CRuleRegexContainer { bool passes(const std::string& str) const; private: - Hyprutils::Memory::CUniquePointer regex; - bool negative = false; + Hyprutils::Memory::CUniquePointer m_regex; + bool m_negative = false; }; \ No newline at end of file diff --git a/src/desktop/Subsurface.cpp b/src/desktop/Subsurface.cpp index d30692fe..60032ead 100644 --- a/src/desktop/Subsurface.cpp +++ b/src/desktop/Subsurface.cpp @@ -8,9 +8,9 @@ #include "../managers/input/InputManager.hpp" UP CSubsurface::create(PHLWINDOW pOwner) { - auto subsurface = UP(new CSubsurface()); - subsurface->m_pWindowParent = pOwner; - subsurface->m_pSelf = subsurface; + auto subsurface = UP(new CSubsurface()); + subsurface->m_windowParent = pOwner; + subsurface->m_self = subsurface; subsurface->initSignals(); subsurface->initExistingSubsurfaces(pOwner->m_pWLSurface->resource()); @@ -18,155 +18,155 @@ UP CSubsurface::create(PHLWINDOW pOwner) { } UP CSubsurface::create(WP pOwner) { - auto subsurface = UP(new CSubsurface()); - subsurface->m_pPopupParent = pOwner; - subsurface->m_pSelf = subsurface; + auto subsurface = UP(new CSubsurface()); + subsurface->m_popupParent = pOwner; + subsurface->m_self = subsurface; subsurface->initSignals(); subsurface->initExistingSubsurfaces(pOwner->m_wlSurface->resource()); return subsurface; } UP CSubsurface::create(SP pSubsurface, PHLWINDOW pOwner) { - auto subsurface = UP(new CSubsurface()); - subsurface->m_pWindowParent = pOwner; - subsurface->m_pSubsurface = pSubsurface; - subsurface->m_pSelf = subsurface; - subsurface->m_pWLSurface = CWLSurface::create(); - subsurface->m_pWLSurface->assign(pSubsurface->surface.lock(), subsurface.get()); + auto subsurface = UP(new CSubsurface()); + subsurface->m_windowParent = pOwner; + subsurface->m_subsurface = pSubsurface; + subsurface->m_self = subsurface; + subsurface->m_wlSurface = CWLSurface::create(); + subsurface->m_wlSurface->assign(pSubsurface->surface.lock(), subsurface.get()); subsurface->initSignals(); subsurface->initExistingSubsurfaces(pSubsurface->surface.lock()); return subsurface; } UP CSubsurface::create(SP pSubsurface, WP pOwner) { - auto subsurface = UP(new CSubsurface()); - subsurface->m_pPopupParent = pOwner; - subsurface->m_pSubsurface = pSubsurface; - subsurface->m_pSelf = subsurface; - subsurface->m_pWLSurface = CWLSurface::create(); - subsurface->m_pWLSurface->assign(pSubsurface->surface.lock(), subsurface.get()); + auto subsurface = UP(new CSubsurface()); + subsurface->m_popupParent = pOwner; + subsurface->m_subsurface = pSubsurface; + subsurface->m_self = subsurface; + subsurface->m_wlSurface = CWLSurface::create(); + subsurface->m_wlSurface->assign(pSubsurface->surface.lock(), subsurface.get()); subsurface->initSignals(); subsurface->initExistingSubsurfaces(pSubsurface->surface.lock()); return subsurface; } void CSubsurface::initSignals() { - if (m_pSubsurface) { - listeners.commitSubsurface = m_pSubsurface->surface->events.commit.registerListener([this](std::any d) { onCommit(); }); - listeners.destroySubsurface = m_pSubsurface->events.destroy.registerListener([this](std::any d) { onDestroy(); }); - listeners.mapSubsurface = m_pSubsurface->surface->events.map.registerListener([this](std::any d) { onMap(); }); - listeners.unmapSubsurface = m_pSubsurface->surface->events.unmap.registerListener([this](std::any d) { onUnmap(); }); - listeners.newSubsurface = - m_pSubsurface->surface->events.newSubsurface.registerListener([this](std::any d) { onNewSubsurface(std::any_cast>(d)); }); + if (m_subsurface) { + m_listeners.commitSubsurface = m_subsurface->surface->events.commit.registerListener([this](std::any d) { onCommit(); }); + m_listeners.destroySubsurface = m_subsurface->events.destroy.registerListener([this](std::any d) { onDestroy(); }); + m_listeners.mapSubsurface = m_subsurface->surface->events.map.registerListener([this](std::any d) { onMap(); }); + m_listeners.unmapSubsurface = m_subsurface->surface->events.unmap.registerListener([this](std::any d) { onUnmap(); }); + m_listeners.newSubsurface = + m_subsurface->surface->events.newSubsurface.registerListener([this](std::any d) { onNewSubsurface(std::any_cast>(d)); }); } else { - if (m_pWindowParent) - listeners.newSubsurface = m_pWindowParent->m_pWLSurface->resource()->events.newSubsurface.registerListener( - [this](std::any d) { onNewSubsurface(std::any_cast>(d)); }); - else if (m_pPopupParent) - listeners.newSubsurface = m_pPopupParent->m_wlSurface->resource()->events.newSubsurface.registerListener( + if (m_windowParent) + m_listeners.newSubsurface = m_windowParent->m_pWLSurface->resource()->events.newSubsurface.registerListener( [this](std::any d) { onNewSubsurface(std::any_cast>(d)); }); + else if (m_popupParent) + m_listeners.newSubsurface = + m_popupParent->m_wlSurface->resource()->events.newSubsurface.registerListener([this](std::any d) { onNewSubsurface(std::any_cast>(d)); }); else ASSERT(false); } } void CSubsurface::checkSiblingDamage() { - if (!m_pParent) + if (!m_parent) return; // ?????????? - const double SCALE = m_pWindowParent.lock() && m_pWindowParent->m_bIsX11 ? 1.0 / m_pWindowParent->m_fX11SurfaceScaledBy : 1.0; + const double SCALE = m_windowParent.lock() && m_windowParent->m_bIsX11 ? 1.0 / m_windowParent->m_fX11SurfaceScaledBy : 1.0; - for (auto const& n : m_pParent->m_vChildren) { + for (auto const& n : m_parent->m_children) { if (n.get() == this) continue; const auto COORDS = n->coordsGlobal(); - g_pHyprRenderer->damageSurface(n->m_pWLSurface->resource(), COORDS.x, COORDS.y, SCALE); + g_pHyprRenderer->damageSurface(n->m_wlSurface->resource(), COORDS.x, COORDS.y, SCALE); } } void CSubsurface::recheckDamageForSubsurfaces() { - for (auto const& n : m_vChildren) { + for (auto const& n : m_children) { const auto COORDS = n->coordsGlobal(); - g_pHyprRenderer->damageSurface(n->m_pWLSurface->resource(), COORDS.x, COORDS.y); + g_pHyprRenderer->damageSurface(n->m_wlSurface->resource(), COORDS.x, COORDS.y); } } void CSubsurface::onCommit() { // no damaging if it's not visible - if (!m_pWindowParent.expired() && (!m_pWindowParent->m_bIsMapped || !m_pWindowParent->m_pWorkspace->m_bVisible)) { - m_vLastSize = m_pWLSurface->resource()->current.size; + if (!m_windowParent.expired() && (!m_windowParent->m_bIsMapped || !m_windowParent->m_pWorkspace->m_visible)) { + m_lastSize = m_wlSurface->resource()->current.size; static auto PLOGDAMAGE = CConfigValue("debug:log_damage"); if (*PLOGDAMAGE) - Debug::log(LOG, "Refusing to commit damage from a subsurface of {} because it's invisible.", m_pWindowParent.lock()); + Debug::log(LOG, "Refusing to commit damage from a subsurface of {} because it's invisible.", m_windowParent.lock()); return; } const auto COORDS = coordsGlobal(); - g_pHyprRenderer->damageSurface(m_pWLSurface->resource(), COORDS.x, COORDS.y); + g_pHyprRenderer->damageSurface(m_wlSurface->resource(), COORDS.x, COORDS.y); - if (m_pPopupParent && !m_pPopupParent->inert() && m_pPopupParent->m_wlSurface) - m_pPopupParent->recheckTree(); - if (!m_pWindowParent.expired()) // I hate you firefox why are you doing this - m_pWindowParent->m_pPopupHead->recheckTree(); + if (m_popupParent && !m_popupParent->inert() && m_popupParent->m_wlSurface) + m_popupParent->recheckTree(); + if (!m_windowParent.expired()) // I hate you firefox why are you doing this + m_windowParent->m_pPopupHead->recheckTree(); // I do not think this is correct, but it solves a lot of issues with some apps (e.g. firefox) checkSiblingDamage(); - if (m_vLastSize != m_pWLSurface->resource()->current.size || m_vLastPosition != m_pSubsurface->position) { + if (m_lastSize != m_wlSurface->resource()->current.size || m_lastPosition != m_subsurface->position) { damageLastArea(); - m_vLastSize = m_pWLSurface->resource()->current.size; - m_vLastPosition = m_pSubsurface->position; + m_lastSize = m_wlSurface->resource()->current.size; + m_lastPosition = m_subsurface->position; } } void CSubsurface::onDestroy() { // destroy children - m_vChildren.clear(); + m_children.clear(); - m_bInert = true; + m_inert = true; - if (!m_pSubsurface) + if (!m_subsurface) return; // dummy node, nothing to do, it's the parent dying // kill ourselves - std::erase_if(m_pParent->m_vChildren, [this](const auto& other) { return other.get() == this; }); + std::erase_if(m_parent->m_children, [this](const auto& other) { return other.get() == this; }); } void CSubsurface::onNewSubsurface(SP pSubsurface) { WP PSUBSURFACE; - if (!m_pWindowParent.expired()) - PSUBSURFACE = m_vChildren.emplace_back(CSubsurface::create(pSubsurface, m_pWindowParent.lock())); - else if (m_pPopupParent) - PSUBSURFACE = m_vChildren.emplace_back(CSubsurface::create(pSubsurface, m_pPopupParent)); + if (!m_windowParent.expired()) + PSUBSURFACE = m_children.emplace_back(CSubsurface::create(pSubsurface, m_windowParent.lock())); + else if (m_popupParent) + PSUBSURFACE = m_children.emplace_back(CSubsurface::create(pSubsurface, m_popupParent)); - PSUBSURFACE->m_pSelf = PSUBSURFACE; + PSUBSURFACE->m_self = PSUBSURFACE; ASSERT(PSUBSURFACE); - PSUBSURFACE->m_pParent = m_pSelf; + PSUBSURFACE->m_parent = m_self; } void CSubsurface::onMap() { - m_vLastSize = m_pWLSurface->resource()->current.size; - m_vLastPosition = m_pSubsurface->position; + m_lastSize = m_wlSurface->resource()->current.size; + m_lastPosition = m_subsurface->position; const auto COORDS = coordsGlobal(); - CBox box{COORDS, m_vLastSize}; + CBox box{COORDS, m_lastSize}; box.expand(4); g_pHyprRenderer->damageBox(box); - if (!m_pWindowParent.expired()) - m_pWindowParent->updateSurfaceScaleTransformDetails(); + if (!m_windowParent.expired()) + m_windowParent->updateSurfaceScaleTransformDetails(); } void CSubsurface::onUnmap() { damageLastArea(); - if (m_pWLSurface->resource() == g_pCompositor->m_lastFocus) + if (m_wlSurface->resource() == g_pCompositor->m_lastFocus) g_pInputManager->releaseAllMouseButtons(); g_pInputManager->simulateMouseMovement(); @@ -175,25 +175,25 @@ void CSubsurface::onUnmap() { } void CSubsurface::damageLastArea() { - const auto COORDS = coordsGlobal() + m_vLastPosition - m_pSubsurface->position; - CBox box{COORDS, m_vLastSize}; + const auto COORDS = coordsGlobal() + m_lastPosition - m_subsurface->position; + CBox box{COORDS, m_lastSize}; box.expand(4); g_pHyprRenderer->damageBox(box); } Vector2D CSubsurface::coordsRelativeToParent() { - if (!m_pSubsurface) + if (!m_subsurface) return {}; - return m_pSubsurface->posRelativeToParent(); + return m_subsurface->posRelativeToParent(); } Vector2D CSubsurface::coordsGlobal() { Vector2D coords = coordsRelativeToParent(); - if (!m_pWindowParent.expired()) - coords += m_pWindowParent->m_vRealPosition->value(); - else if (m_pPopupParent) - coords += m_pPopupParent->coordsGlobal(); + if (!m_windowParent.expired()) + coords += m_windowParent->m_vRealPosition->value(); + else if (m_popupParent) + coords += m_popupParent->coordsGlobal(); return coords; } @@ -207,16 +207,16 @@ void CSubsurface::initExistingSubsurfaces(SP pSurface) { } Vector2D CSubsurface::size() { - return m_pWLSurface->resource()->current.size; + return m_wlSurface->resource()->current.size; } bool CSubsurface::visible() { - if (!m_pWindowParent.expired()) - return g_pHyprRenderer->shouldRenderWindow(m_pWindowParent.lock()); - if (m_pPopupParent) - return m_pPopupParent->visible(); - if (m_pParent) - return m_pParent->visible(); + if (!m_windowParent.expired()) + return g_pHyprRenderer->shouldRenderWindow(m_windowParent.lock()); + if (m_popupParent) + return m_popupParent->visible(); + if (m_parent) + return m_parent->visible(); return false; } diff --git a/src/desktop/Subsurface.hpp b/src/desktop/Subsurface.hpp index 7b596337..7c42dad9 100644 --- a/src/desktop/Subsurface.hpp +++ b/src/desktop/Subsurface.hpp @@ -34,7 +34,7 @@ class CSubsurface { void recheckDamageForSubsurfaces(); - WP m_pSelf; + WP m_self; private: CSubsurface() = default; @@ -45,22 +45,22 @@ class CSubsurface { CHyprSignalListener mapSubsurface; CHyprSignalListener unmapSubsurface; CHyprSignalListener newSubsurface; - } listeners; + } m_listeners; - WP m_pSubsurface; - SP m_pWLSurface; - Vector2D m_vLastSize = {}; - Vector2D m_vLastPosition = {}; + WP m_subsurface; + SP m_wlSurface; + Vector2D m_lastSize = {}; + Vector2D m_lastPosition = {}; // if nullptr, means it's a dummy node - WP m_pParent; + WP m_parent; - PHLWINDOWREF m_pWindowParent; - WP m_pPopupParent; + PHLWINDOWREF m_windowParent; + WP m_popupParent; - std::vector> m_vChildren; + std::vector> m_children; - bool m_bInert = false; + bool m_inert = false; void initSignals(); void initExistingSubsurfaces(SP pSurface); diff --git a/src/desktop/WLSurface.cpp b/src/desktop/WLSurface.cpp index ef62bc7a..5d0a32de 100644 --- a/src/desktop/WLSurface.cpp +++ b/src/desktop/WLSurface.cpp @@ -6,37 +6,37 @@ #include "../render/Renderer.hpp" void CWLSurface::assign(SP pSurface) { - m_pResource = pSurface; + m_resource = pSurface; init(); - m_bInert = false; + m_inert = false; } void CWLSurface::assign(SP pSurface, PHLWINDOW pOwner) { - m_pWindowOwner = pOwner; - m_pResource = pSurface; + m_windowOwner = pOwner; + m_resource = pSurface; init(); - m_bInert = false; + m_inert = false; } void CWLSurface::assign(SP pSurface, PHLLS pOwner) { - m_pLayerOwner = pOwner; - m_pResource = pSurface; + m_layerOwner = pOwner; + m_resource = pSurface; init(); - m_bInert = false; + m_inert = false; } void CWLSurface::assign(SP pSurface, CSubsurface* pOwner) { - m_pSubsurfaceOwner = pOwner; - m_pResource = pSurface; + m_subsurfaceOwner = pOwner; + m_resource = pSurface; init(); - m_bInert = false; + m_inert = false; } void CWLSurface::assign(SP pSurface, CPopup* pOwner) { - m_pPopupOwner = pOwner; - m_pResource = pSurface; + m_popupOwner = pOwner; + m_resource = pSurface; init(); - m_bInert = false; + m_inert = false; } void CWLSurface::unassign() { @@ -48,66 +48,66 @@ CWLSurface::~CWLSurface() { } bool CWLSurface::exists() const { - return m_pResource; + return m_resource; } SP CWLSurface::resource() const { - return m_pResource.lock(); + return m_resource.lock(); } bool CWLSurface::small() const { - if (!validMapped(m_pWindowOwner) || !exists()) + if (!validMapped(m_windowOwner) || !exists()) return false; - if (!m_pResource->current.texture) + if (!m_resource->current.texture) return false; - const auto O = m_pWindowOwner.lock(); + const auto O = m_windowOwner.lock(); - return O->m_vReportedSize.x > m_pResource->current.size.x + 1 || O->m_vReportedSize.y > m_pResource->current.size.y + 1; + return O->m_vReportedSize.x > m_resource->current.size.x + 1 || O->m_vReportedSize.y > m_resource->current.size.y + 1; } Vector2D CWLSurface::correctSmallVec() const { - if (!validMapped(m_pWindowOwner) || !exists() || !small() || m_bFillIgnoreSmall) + if (!validMapped(m_windowOwner) || !exists() || !small() || m_fillIgnoreSmall) return {}; const auto SIZE = getViewporterCorrectedSize(); - const auto O = m_pWindowOwner.lock(); + const auto O = m_windowOwner.lock(); return Vector2D{(O->m_vReportedSize.x - SIZE.x) / 2, (O->m_vReportedSize.y - SIZE.y) / 2}.clamp({}, {INFINITY, INFINITY}) * (O->m_vRealSize->value() / O->m_vReportedSize); } Vector2D CWLSurface::correctSmallVecBuf() const { - if (!exists() || !small() || m_bFillIgnoreSmall || !m_pResource->current.texture) + if (!exists() || !small() || m_fillIgnoreSmall || !m_resource->current.texture) return {}; const auto SIZE = getViewporterCorrectedSize(); - const auto BS = m_pResource->current.bufferSize; + const auto BS = m_resource->current.bufferSize; return Vector2D{(BS.x - SIZE.x) / 2, (BS.y - SIZE.y) / 2}.clamp({}, {INFINITY, INFINITY}); } Vector2D CWLSurface::getViewporterCorrectedSize() const { - if (!exists() || !m_pResource->current.texture) + if (!exists() || !m_resource->current.texture) return {}; - return m_pResource->current.viewport.hasDestination ? m_pResource->current.viewport.destination : m_pResource->current.bufferSize; + return m_resource->current.viewport.hasDestination ? m_resource->current.viewport.destination : m_resource->current.bufferSize; } CRegion CWLSurface::computeDamage() const { - if (!m_pResource->current.texture) + if (!m_resource->current.texture) return {}; - CRegion damage = m_pResource->current.accumulateBufferDamage(); - damage.transform(wlTransformToHyprutils(m_pResource->current.transform), m_pResource->current.bufferSize.x, m_pResource->current.bufferSize.y); + CRegion damage = m_resource->current.accumulateBufferDamage(); + damage.transform(wlTransformToHyprutils(m_resource->current.transform), m_resource->current.bufferSize.x, m_resource->current.bufferSize.y); - const auto BUFSIZE = m_pResource->current.bufferSize; + const auto BUFSIZE = m_resource->current.bufferSize; const auto CORRECTVEC = correctSmallVecBuf(); - if (m_pResource->current.viewport.hasSource) - damage.intersect(m_pResource->current.viewport.source); + if (m_resource->current.viewport.hasSource) + damage.intersect(m_resource->current.viewport.source); - const auto SCALEDSRCSIZE = m_pResource->current.viewport.hasSource ? m_pResource->current.viewport.source.size() * m_pResource->current.scale : m_pResource->current.bufferSize; + const auto SCALEDSRCSIZE = m_resource->current.viewport.hasSource ? m_resource->current.viewport.source.size() * m_resource->current.scale : m_resource->current.bufferSize; damage.scale({BUFSIZE.x / SCALEDSRCSIZE.x, BUFSIZE.y / SCALEDSRCSIZE.y}); damage.translate(CORRECTVEC); @@ -115,107 +115,107 @@ CRegion CWLSurface::computeDamage() const { // go from buffer coords in the damage to hl logical const auto BOX = getSurfaceBoxGlobal(); - const Vector2D SCALE = BOX.has_value() ? BOX->size() / m_pResource->current.bufferSize : - Vector2D{1.0 / m_pResource->current.scale, 1.0 / m_pResource->current.scale /* Wrong... but we can't really do better */}; + const Vector2D SCALE = BOX.has_value() ? BOX->size() / m_resource->current.bufferSize : + Vector2D{1.0 / m_resource->current.scale, 1.0 / m_resource->current.scale /* Wrong... but we can't really do better */}; damage.scale(SCALE); - if (m_pWindowOwner) - damage.scale(m_pWindowOwner->m_fX11SurfaceScaledBy); // fix xwayland:force_zero_scaling stuff that will be fucked by the above a bit + if (m_windowOwner) + damage.scale(m_windowOwner->m_fX11SurfaceScaledBy); // fix xwayland:force_zero_scaling stuff that will be fucked by the above a bit return damage; } void CWLSurface::destroy() { - if (!m_pResource) + if (!m_resource) return; - events.destroy.emit(); + m_events.destroy.emit(); - m_pConstraint.reset(); + m_constraint.reset(); - listeners.destroy.reset(); - m_pResource->hlSurface.reset(); - m_pWindowOwner.reset(); - m_pLayerOwner.reset(); - m_pPopupOwner = nullptr; - m_pSubsurfaceOwner = nullptr; - m_bInert = true; + m_listeners.destroy.reset(); + m_resource->hlSurface.reset(); + m_windowOwner.reset(); + m_layerOwner.reset(); + m_popupOwner = nullptr; + m_subsurfaceOwner = nullptr; + m_inert = true; if (g_pHyprRenderer && g_pHyprRenderer->m_sLastCursorData.surf && g_pHyprRenderer->m_sLastCursorData.surf->get() == this) g_pHyprRenderer->m_sLastCursorData.surf.reset(); - m_pResource.reset(); + m_resource.reset(); Debug::log(LOG, "CWLSurface {:x} called destroy()", (uintptr_t)this); } void CWLSurface::init() { - if (!m_pResource) + if (!m_resource) return; - RASSERT(!m_pResource->hlSurface, "Attempted to duplicate CWLSurface ownership!"); + RASSERT(!m_resource->hlSurface, "Attempted to duplicate CWLSurface ownership!"); - m_pResource->hlSurface = self.lock(); + m_resource->hlSurface = m_self.lock(); - listeners.destroy = m_pResource->events.destroy.registerListener([this](std::any d) { destroy(); }); + m_listeners.destroy = m_resource->events.destroy.registerListener([this](std::any d) { destroy(); }); Debug::log(LOG, "CWLSurface {:x} called init()", (uintptr_t)this); } PHLWINDOW CWLSurface::getWindow() const { - return m_pWindowOwner.lock(); + return m_windowOwner.lock(); } PHLLS CWLSurface::getLayer() const { - return m_pLayerOwner.lock(); + return m_layerOwner.lock(); } CPopup* CWLSurface::getPopup() const { - return m_pPopupOwner; + return m_popupOwner; } CSubsurface* CWLSurface::getSubsurface() const { - return m_pSubsurfaceOwner; + return m_subsurfaceOwner; } bool CWLSurface::desktopComponent() const { - return !m_pLayerOwner.expired() || !m_pWindowOwner.expired() || m_pSubsurfaceOwner || m_pPopupOwner; + return !m_layerOwner.expired() || !m_windowOwner.expired() || m_subsurfaceOwner || m_popupOwner; } std::optional CWLSurface::getSurfaceBoxGlobal() const { if (!desktopComponent()) return {}; - if (!m_pWindowOwner.expired()) - return m_pWindowOwner->getWindowMainSurfaceBox(); - if (!m_pLayerOwner.expired()) - return m_pLayerOwner->m_geometry; - if (m_pPopupOwner) - return CBox{m_pPopupOwner->coordsGlobal(), m_pPopupOwner->size()}; - if (m_pSubsurfaceOwner) - return CBox{m_pSubsurfaceOwner->coordsGlobal(), m_pSubsurfaceOwner->size()}; + if (!m_windowOwner.expired()) + return m_windowOwner->getWindowMainSurfaceBox(); + if (!m_layerOwner.expired()) + return m_layerOwner->m_geometry; + if (m_popupOwner) + return CBox{m_popupOwner->coordsGlobal(), m_popupOwner->size()}; + if (m_subsurfaceOwner) + return CBox{m_subsurfaceOwner->coordsGlobal(), m_subsurfaceOwner->size()}; return {}; } void CWLSurface::appendConstraint(WP constraint) { - m_pConstraint = constraint; + m_constraint = constraint; } SP CWLSurface::constraint() const { - return m_pConstraint.lock(); + return m_constraint.lock(); } bool CWLSurface::visible() { - if (!m_pWindowOwner.expired()) - return g_pHyprRenderer->shouldRenderWindow(m_pWindowOwner.lock()); - if (!m_pLayerOwner.expired()) + if (!m_windowOwner.expired()) + return g_pHyprRenderer->shouldRenderWindow(m_windowOwner.lock()); + if (!m_layerOwner.expired()) return true; - if (m_pPopupOwner) - return m_pPopupOwner->visible(); - if (m_pSubsurfaceOwner) - return m_pSubsurfaceOwner->visible(); + if (m_popupOwner) + return m_popupOwner->visible(); + if (m_subsurfaceOwner) + return m_subsurfaceOwner->visible(); return true; // non-desktop, we don't know much. } @@ -226,9 +226,9 @@ SP CWLSurface::fromResource(SP pSurface) { } bool CWLSurface::keyboardFocusable() const { - if (m_pWindowOwner || m_pPopupOwner || m_pSubsurfaceOwner) + if (m_windowOwner || m_popupOwner || m_subsurfaceOwner) return true; - if (m_pLayerOwner && m_pLayerOwner->m_layerSurface) - return m_pLayerOwner->m_layerSurface->current.interactivity != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE; + if (m_layerOwner && m_layerOwner->m_layerSurface) + return m_layerOwner->m_layerSurface->current.interactivity != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE; return false; } diff --git a/src/desktop/WLSurface.hpp b/src/desktop/WLSurface.hpp index 5f8da715..d0da546c 100644 --- a/src/desktop/WLSurface.hpp +++ b/src/desktop/WLSurface.hpp @@ -12,8 +12,8 @@ class CWLSurfaceResource; class CWLSurface { public: static SP create() { - auto p = SP(new CWLSurface); - p->self = p; + auto p = SP(new CWLSurface); + p->m_self = p; return p; } ~CWLSurface(); @@ -53,17 +53,17 @@ class CWLSurface { SP constraint() const; // allow stretching. Useful for plugins. - bool m_bFillIgnoreSmall = false; + bool m_fillIgnoreSmall = false; // track surface data and avoid dupes - float m_fLastScale = 0; - int m_iLastScale = 0; - wl_output_transform m_eLastTransform = (wl_output_transform)-1; + float m_lastScaleFloat = 0; + int m_lastScaleInt = 0; + wl_output_transform m_lastTransform = (wl_output_transform)-1; // CWLSurface& operator=(SP pSurface) { destroy(); - m_pResource = pSurface; + m_resource = pSurface; init(); return *this; @@ -84,32 +84,32 @@ class CWLSurface { static SP fromResource(SP pSurface); // used by the alpha-modifier protocol - float m_fAlphaModifier = 1.F; + float m_alphaModifier = 1.F; // used by the hyprland-surface protocol - float m_fOverallOpacity = 1.F; + float m_overallOpacity = 1.F; CRegion m_visibleRegion; struct { CSignal destroy; - } events; + } m_events; - WP self; + WP m_self; private: CWLSurface() = default; - bool m_bInert = true; + bool m_inert = true; - WP m_pResource; + WP m_resource; - PHLWINDOWREF m_pWindowOwner; - PHLLSREF m_pLayerOwner; - CPopup* m_pPopupOwner = nullptr; - CSubsurface* m_pSubsurfaceOwner = nullptr; + PHLWINDOWREF m_windowOwner; + PHLLSREF m_layerOwner; + CPopup* m_popupOwner = nullptr; + CSubsurface* m_subsurfaceOwner = nullptr; // - WP m_pConstraint; + WP m_constraint; void destroy(); void init(); @@ -117,7 +117,7 @@ class CWLSurface { struct { CHyprSignalListener destroy; - } listeners; + } m_listeners; friend class CPointerConstraint; friend class CXxColorManagerV4; diff --git a/src/desktop/Window.cpp b/src/desktop/Window.cpp index b22de459..5472b444 100644 --- a/src/desktop/Window.cpp +++ b/src/desktop/Window.cpp @@ -396,7 +396,7 @@ void CWindow::updateSurfaceScaleTransformDetails(bool force) { m_pWLSurface->resource()->breadthfirst( [PMONITOR](SP s, const Vector2D& offset, void* d) { const auto PSURFACE = CWLSurface::fromResource(s); - if (PSURFACE && PSURFACE->m_fLastScale == PMONITOR->scale) + if (PSURFACE && PSURFACE->m_lastScaleFloat == PMONITOR->scale) return; PROTO::fractional->sendScale(s, PMONITOR->scale); @@ -452,8 +452,8 @@ void CWindow::moveToWorkspace(PHLWORKSPACE pWorkspace) { g_pCompositor->updateAllWindowsAnimatedDecorationValues(); if (valid(pWorkspace)) { - g_pEventManager->postEvent(SHyprIPCEvent{"movewindow", std::format("{:x},{}", (uintptr_t)this, pWorkspace->m_szName)}); - g_pEventManager->postEvent(SHyprIPCEvent{"movewindowv2", std::format("{:x},{},{}", (uintptr_t)this, pWorkspace->m_iID, pWorkspace->m_szName)}); + g_pEventManager->postEvent(SHyprIPCEvent{"movewindow", std::format("{:x},{}", (uintptr_t)this, pWorkspace->m_name)}); + g_pEventManager->postEvent(SHyprIPCEvent{"movewindowv2", std::format("{:x},{},{}", (uintptr_t)this, pWorkspace->m_id, pWorkspace->m_name)}); EMIT_HOOK_EVENT("moveWindow", (std::vector{m_pSelf.lock(), pWorkspace})); } @@ -464,8 +464,8 @@ void CWindow::moveToWorkspace(PHLWORKSPACE pWorkspace) { } } - if (OLDWORKSPACE && g_pCompositor->isWorkspaceSpecial(OLDWORKSPACE->m_iID) && OLDWORKSPACE->getWindows() == 0 && *PCLOSEONLASTSPECIAL) { - if (const auto PMONITOR = OLDWORKSPACE->m_pMonitor.lock(); PMONITOR) + if (OLDWORKSPACE && g_pCompositor->isWorkspaceSpecial(OLDWORKSPACE->m_id) && OLDWORKSPACE->getWindows() == 0 && *PCLOSEONLASTSPECIAL) { + if (const auto PMONITOR = OLDWORKSPACE->m_monitor.lock(); PMONITOR) PMONITOR->setSpecialWorkspace(nullptr); } } @@ -514,7 +514,7 @@ void CWindow::onUnmap() { } } - m_iLastWorkspace = m_pWorkspace->m_iID; + m_iLastWorkspace = m_pWorkspace->m_id; std::erase_if(g_pCompositor->m_windowFocusHistory, [this](const auto& other) { return other.expired() || other == m_pSelf; }); @@ -1153,10 +1153,10 @@ bool CWindow::opaque() { const auto PWORKSPACE = m_pWorkspace; - if (m_pWLSurface->small() && !m_pWLSurface->m_bFillIgnoreSmall) + if (m_pWLSurface->small() && !m_pWLSurface->m_fillIgnoreSmall) return false; - if (PWORKSPACE->m_fAlpha->value() != 1.f) + if (PWORKSPACE->m_alpha->value() != 1.f) return false; if (m_bIsX11 && m_pXWaylandSurface && m_pXWaylandSurface->surface && m_pXWaylandSurface->surface->current.texture) @@ -1273,16 +1273,16 @@ void CWindow::onWorkspaceAnimUpdate() { return; const auto WINBB = getFullWindowBoundingBox(); - if (PWORKSPACE->m_vRenderOffset->value().x != 0) { - const auto PROGRESS = PWORKSPACE->m_vRenderOffset->value().x / PWSMON->vecSize.x; + if (PWORKSPACE->m_renderOffset->value().x != 0) { + const auto PROGRESS = PWORKSPACE->m_renderOffset->value().x / PWSMON->vecSize.x; if (WINBB.x < PWSMON->vecPosition.x) offset.x += (PWSMON->vecPosition.x - WINBB.x) * PROGRESS; if (WINBB.x + WINBB.width > PWSMON->vecPosition.x + PWSMON->vecSize.x) offset.x += (WINBB.x + WINBB.width - PWSMON->vecPosition.x - PWSMON->vecSize.x) * PROGRESS; - } else if (PWORKSPACE->m_vRenderOffset->value().y != 0) { - const auto PROGRESS = PWORKSPACE->m_vRenderOffset->value().y / PWSMON->vecSize.y; + } else if (PWORKSPACE->m_renderOffset->value().y != 0) { + const auto PROGRESS = PWORKSPACE->m_renderOffset->value().y / PWSMON->vecSize.y; if (WINBB.y < PWSMON->vecPosition.y) offset.y += (PWSMON->vecPosition.y - WINBB.y) * PROGRESS; @@ -1338,7 +1338,7 @@ bool CWindow::isEffectiveInternalFSMode(const eFullscreenMode MODE) { } WORKSPACEID CWindow::workspaceID() { - return m_pWorkspace ? m_pWorkspace->m_iID : m_iLastWorkspace; + return m_pWorkspace ? m_pWorkspace->m_id : m_iLastWorkspace; } MONITORID CWindow::monitorID() { @@ -1346,7 +1346,7 @@ MONITORID CWindow::monitorID() { } bool CWindow::onSpecialWorkspace() { - return m_pWorkspace ? m_pWorkspace->m_bIsSpecialWorkspace : g_pCompositor->isWorkspaceSpecial(m_iLastWorkspace); + return m_pWorkspace ? m_pWorkspace->m_isSpecialWorkspace : g_pCompositor->isWorkspaceSpecial(m_iLastWorkspace); } std::unordered_map CWindow::getEnv() { diff --git a/src/desktop/Workspace.cpp b/src/desktop/Workspace.cpp index 5907c970..18322799 100644 --- a/src/desktop/Workspace.cpp +++ b/src/desktop/Workspace.cpp @@ -17,76 +17,76 @@ PHLWORKSPACE CWorkspace::create(WORKSPACEID id, PHLMONITOR monitor, std::string } CWorkspace::CWorkspace(WORKSPACEID id, PHLMONITOR monitor, std::string name, bool special, bool isEmpty) : - m_iID(id), m_szName(name), m_pMonitor(monitor), m_bIsSpecialWorkspace(special), m_bWasCreatedEmpty(isEmpty) { + m_id(id), m_name(name), m_monitor(monitor), m_isSpecialWorkspace(special), m_wasCreatedEmpty(isEmpty) { ; } void CWorkspace::init(PHLWORKSPACE self) { - m_pSelf = self; + m_self = self; - g_pAnimationManager->createAnimation(Vector2D(0, 0), m_vRenderOffset, - g_pConfigManager->getAnimationPropertyConfig(m_bIsSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"), self, AVARDAMAGE_ENTIRE); - g_pAnimationManager->createAnimation(1.f, m_fAlpha, g_pConfigManager->getAnimationPropertyConfig(m_bIsSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"), self, + g_pAnimationManager->createAnimation(Vector2D(0, 0), m_renderOffset, g_pConfigManager->getAnimationPropertyConfig(m_isSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"), + self, AVARDAMAGE_ENTIRE); + g_pAnimationManager->createAnimation(1.f, m_alpha, g_pConfigManager->getAnimationPropertyConfig(m_isSpecialWorkspace ? "specialWorkspaceIn" : "workspacesIn"), self, AVARDAMAGE_ENTIRE); const auto RULEFORTHIS = g_pConfigManager->getWorkspaceRuleFor(self); if (RULEFORTHIS.defaultName.has_value()) - m_szName = RULEFORTHIS.defaultName.value(); + m_name = RULEFORTHIS.defaultName.value(); - m_pFocusedWindowHook = g_pHookSystem->hookDynamic("closeWindow", [this](void* self, SCallbackInfo& info, std::any param) { + m_focusedWindowHook = g_pHookSystem->hookDynamic("closeWindow", [this](void* self, SCallbackInfo& info, std::any param) { const auto PWINDOW = std::any_cast(param); - if (PWINDOW == m_pLastFocusedWindow.lock()) - m_pLastFocusedWindow.reset(); + if (PWINDOW == m_lastFocusedWindow.lock()) + m_lastFocusedWindow.reset(); }); - m_bInert = false; + m_inert = false; const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(self); - m_bPersistent = WORKSPACERULE.isPersistent; + m_persistent = WORKSPACERULE.isPersistent; - if (self->m_bWasCreatedEmpty) + if (self->m_wasCreatedEmpty) if (auto cmd = WORKSPACERULE.onCreatedEmptyRunCmd) g_pKeybindManager->spawnWithRules(*cmd, self); - g_pEventManager->postEvent({"createworkspace", m_szName}); - g_pEventManager->postEvent({"createworkspacev2", std::format("{},{}", m_iID, m_szName)}); + g_pEventManager->postEvent({"createworkspace", m_name}); + g_pEventManager->postEvent({"createworkspacev2", std::format("{},{}", m_id, m_name)}); EMIT_HOOK_EVENT("createWorkspace", this); } SWorkspaceIDName CWorkspace::getPrevWorkspaceIDName() const { - return m_sPrevWorkspace; + return m_prevWorkspace; } CWorkspace::~CWorkspace() { - Debug::log(LOG, "Destroying workspace ID {}", m_iID); + Debug::log(LOG, "Destroying workspace ID {}", m_id); // check if g_pHookSystem and g_pEventManager exist, they might be destroyed as in when the compositor is closing. if (g_pHookSystem) - g_pHookSystem->unhook(m_pFocusedWindowHook); + g_pHookSystem->unhook(m_focusedWindowHook); if (g_pEventManager) { - g_pEventManager->postEvent({"destroyworkspace", m_szName}); - g_pEventManager->postEvent({"destroyworkspacev2", std::format("{},{}", m_iID, m_szName)}); + g_pEventManager->postEvent({"destroyworkspace", m_name}); + g_pEventManager->postEvent({"destroyworkspacev2", std::format("{},{}", m_id, m_name)}); EMIT_HOOK_EVENT("destroyWorkspace", this); } } void CWorkspace::startAnim(bool in, bool left, bool instant) { if (!instant) { - const std::string ANIMNAME = std::format("{}{}", m_bIsSpecialWorkspace ? "specialWorkspace" : "workspaces", in ? "In" : "Out"); + const std::string ANIMNAME = std::format("{}{}", m_isSpecialWorkspace ? "specialWorkspace" : "workspaces", in ? "In" : "Out"); - m_fAlpha->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME)); - m_vRenderOffset->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME)); + m_alpha->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME)); + m_renderOffset->setConfig(g_pConfigManager->getAnimationPropertyConfig(ANIMNAME)); } - const auto ANIMSTYLE = m_fAlpha->getStyle(); + const auto ANIMSTYLE = m_alpha->getStyle(); static auto PWORKSPACEGAP = CConfigValue("general:gaps_workspaces"); // set floating windows offset callbacks - m_vRenderOffset->setUpdateCallback([&](auto) { + m_renderOffset->setUpdateCallback([&](auto) { for (auto const& w : g_pCompositor->m_windows) { - if (!validMapped(w) || w->workspaceID() != m_iID) + if (!validMapped(w) || w->workspaceID() != m_id) continue; w->onWorkspaceAnimUpdate(); @@ -94,7 +94,7 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) { }); if (ANIMSTYLE.starts_with("slidefade")) { - const auto PMONITOR = m_pMonitor.lock(); + const auto PMONITOR = m_monitor.lock(); float movePerc = 100.f; if (ANIMSTYLE.find('%') != std::string::npos) { @@ -104,84 +104,84 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) { } catch (std::exception& e) { Debug::log(ERR, "Error in startAnim: invalid percentage"); } } - m_fAlpha->setValueAndWarp(1.f); - m_vRenderOffset->setValueAndWarp(Vector2D(0, 0)); + m_alpha->setValueAndWarp(1.f); + m_renderOffset->setValueAndWarp(Vector2D(0, 0)); if (ANIMSTYLE.starts_with("slidefadevert")) { if (in) { - m_fAlpha->setValueAndWarp(0.f); - m_vRenderOffset->setValueAndWarp(Vector2D(0.0, (left ? PMONITOR->vecSize.y : -PMONITOR->vecSize.y) * (movePerc / 100.f))); - *m_fAlpha = 1.f; - *m_vRenderOffset = Vector2D(0, 0); + m_alpha->setValueAndWarp(0.f); + m_renderOffset->setValueAndWarp(Vector2D(0.0, (left ? PMONITOR->vecSize.y : -PMONITOR->vecSize.y) * (movePerc / 100.f))); + *m_alpha = 1.f; + *m_renderOffset = Vector2D(0, 0); } else { - m_fAlpha->setValueAndWarp(1.f); - *m_fAlpha = 0.f; - *m_vRenderOffset = Vector2D(0.0, (left ? -PMONITOR->vecSize.y : PMONITOR->vecSize.y) * (movePerc / 100.f)); + m_alpha->setValueAndWarp(1.f); + *m_alpha = 0.f; + *m_renderOffset = Vector2D(0.0, (left ? -PMONITOR->vecSize.y : PMONITOR->vecSize.y) * (movePerc / 100.f)); } } else { if (in) { - m_fAlpha->setValueAndWarp(0.f); - m_vRenderOffset->setValueAndWarp(Vector2D((left ? PMONITOR->vecSize.x : -PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0)); - *m_fAlpha = 1.f; - *m_vRenderOffset = Vector2D(0, 0); + m_alpha->setValueAndWarp(0.f); + m_renderOffset->setValueAndWarp(Vector2D((left ? PMONITOR->vecSize.x : -PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0)); + *m_alpha = 1.f; + *m_renderOffset = Vector2D(0, 0); } else { - m_fAlpha->setValueAndWarp(1.f); - *m_fAlpha = 0.f; - *m_vRenderOffset = Vector2D((left ? -PMONITOR->vecSize.x : PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0); + m_alpha->setValueAndWarp(1.f); + *m_alpha = 0.f; + *m_renderOffset = Vector2D((left ? -PMONITOR->vecSize.x : PMONITOR->vecSize.x) * (movePerc / 100.f), 0.0); } } } else if (ANIMSTYLE == "fade") { - m_vRenderOffset->setValueAndWarp(Vector2D(0, 0)); // fix a bug, if switching from slide -> fade. + m_renderOffset->setValueAndWarp(Vector2D(0, 0)); // fix a bug, if switching from slide -> fade. if (in) { - m_fAlpha->setValueAndWarp(0.f); - *m_fAlpha = 1.f; + m_alpha->setValueAndWarp(0.f); + *m_alpha = 1.f; } else { - m_fAlpha->setValueAndWarp(1.f); - *m_fAlpha = 0.f; + m_alpha->setValueAndWarp(1.f); + *m_alpha = 0.f; } } else if (ANIMSTYLE == "slidevert") { // fallback is slide - const auto PMONITOR = m_pMonitor.lock(); + const auto PMONITOR = m_monitor.lock(); const auto YDISTANCE = PMONITOR->vecSize.y + *PWORKSPACEGAP; - m_fAlpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide. + m_alpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide. if (in) { - m_vRenderOffset->setValueAndWarp(Vector2D(0.0, left ? YDISTANCE : -YDISTANCE)); - *m_vRenderOffset = Vector2D(0, 0); + m_renderOffset->setValueAndWarp(Vector2D(0.0, left ? YDISTANCE : -YDISTANCE)); + *m_renderOffset = Vector2D(0, 0); } else { - *m_vRenderOffset = Vector2D(0.0, left ? -YDISTANCE : YDISTANCE); + *m_renderOffset = Vector2D(0.0, left ? -YDISTANCE : YDISTANCE); } } else { // fallback is slide - const auto PMONITOR = m_pMonitor.lock(); + const auto PMONITOR = m_monitor.lock(); const auto XDISTANCE = PMONITOR->vecSize.x + *PWORKSPACEGAP; - m_fAlpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide. + m_alpha->setValueAndWarp(1.f); // fix a bug, if switching from fade -> slide. if (in) { - m_vRenderOffset->setValueAndWarp(Vector2D(left ? XDISTANCE : -XDISTANCE, 0.0)); - *m_vRenderOffset = Vector2D(0, 0); + m_renderOffset->setValueAndWarp(Vector2D(left ? XDISTANCE : -XDISTANCE, 0.0)); + *m_renderOffset = Vector2D(0, 0); } else { - *m_vRenderOffset = Vector2D(left ? -XDISTANCE : XDISTANCE, 0.0); + *m_renderOffset = Vector2D(left ? -XDISTANCE : XDISTANCE, 0.0); } } - if (m_bIsSpecialWorkspace) { + if (m_isSpecialWorkspace) { // required for open/close animations if (in) { - m_fAlpha->setValueAndWarp(0.f); - *m_fAlpha = 1.f; + m_alpha->setValueAndWarp(0.f); + *m_alpha = 1.f; } else { - m_fAlpha->setValueAndWarp(1.f); - *m_fAlpha = 0.f; + m_alpha->setValueAndWarp(1.f); + *m_alpha = 0.f; } } if (instant) { - m_vRenderOffset->warp(); - m_fAlpha->warp(); + m_renderOffset->warp(); + m_alpha->warp(); } } @@ -194,39 +194,39 @@ void CWorkspace::moveToMonitor(const MONITORID& id) { } PHLWINDOW CWorkspace::getLastFocusedWindow() { - if (!validMapped(m_pLastFocusedWindow) || m_pLastFocusedWindow->workspaceID() != m_iID) + if (!validMapped(m_lastFocusedWindow) || m_lastFocusedWindow->workspaceID() != m_id) return nullptr; - return m_pLastFocusedWindow.lock(); + return m_lastFocusedWindow.lock(); } void CWorkspace::rememberPrevWorkspace(const PHLWORKSPACE& prev) { if (!prev) { - m_sPrevWorkspace.id = -1; - m_sPrevWorkspace.name = ""; + m_prevWorkspace.id = -1; + m_prevWorkspace.name = ""; return; } - if (prev->m_iID == m_iID) { + if (prev->m_id == m_id) { Debug::log(LOG, "Tried to set prev workspace to the same as current one"); return; } - m_sPrevWorkspace.id = prev->m_iID; - m_sPrevWorkspace.name = prev->m_szName; + m_prevWorkspace.id = prev->m_id; + m_prevWorkspace.name = prev->m_name; - prev->m_pMonitor->addPrevWorkspaceID(prev->m_iID); + prev->m_monitor->addPrevWorkspaceID(prev->m_id); } std::string CWorkspace::getConfigName() { - if (m_bIsSpecialWorkspace) { - return m_szName; + if (m_isSpecialWorkspace) { + return m_name; } - if (m_iID > 0) - return std::to_string(m_iID); + if (m_id > 0) + return std::to_string(m_id); - return "name:" + m_szName; + return "name:" + m_name; } bool CWorkspace::matchesStaticSelector(const std::string& selector_) { @@ -241,12 +241,12 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) { if (wsid == WORKSPACE_INVALID) return false; - return wsid == m_iID; + return wsid == m_id; } else if (selector.starts_with("name:")) { - return m_szName == selector.substr(5); + return m_name == selector.substr(5); } else if (selector.starts_with("special")) { - return m_szName == selector; + return m_name == selector; } else { // parse selector @@ -306,7 +306,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) { return false; } - if (std::clamp(m_iID, from, to) != m_iID) + if (std::clamp(m_id, from, to) != m_id) return false; continue; } @@ -321,7 +321,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) { const auto SHOULDBESPECIAL = configStringToInt(prop); - if (SHOULDBESPECIAL && (bool)*SHOULDBESPECIAL != m_bIsSpecialWorkspace) + if (SHOULDBESPECIAL && (bool)*SHOULDBESPECIAL != m_isSpecialWorkspace) return false; continue; } @@ -336,7 +336,7 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) { const auto PMONITOR = g_pCompositor->getMonitorFromString(prop); - if (!(PMONITOR ? PMONITOR == m_pMonitor : false)) + if (!(PMONITOR ? PMONITOR == m_monitor : false)) return false; continue; } @@ -349,14 +349,14 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) { prop = prop.substr(2, prop.length() - 3); - if (prop.starts_with("s:") && !m_szName.starts_with(prop.substr(2))) + if (prop.starts_with("s:") && !m_name.starts_with(prop.substr(2))) return false; - if (prop.starts_with("e:") && !m_szName.ends_with(prop.substr(2))) + if (prop.starts_with("e:") && !m_name.ends_with(prop.substr(2))) return false; const auto WANTSNAMED = configStringToInt(prop); - if (WANTSNAMED && *WANTSNAMED != (m_iID <= -1337)) + if (WANTSNAMED && *WANTSNAMED != (m_id <= -1337)) return false; continue; } @@ -481,15 +481,15 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) { switch (FSSTATE) { case -1: // no fullscreen - if (m_bHasFullscreenWindow) + if (m_hasFullscreenWindow) return false; break; case 0: // fullscreen full - if (!m_bHasFullscreenWindow || m_efFullscreenMode != FSMODE_FULLSCREEN) + if (!m_hasFullscreenWindow || m_fullscreenMode != FSMODE_FULLSCREEN) return false; break; case 1: // maximized - if (!m_bHasFullscreenWindow || m_efFullscreenMode != FSMODE_MAXIMIZED) + if (!m_hasFullscreenWindow || m_fullscreenMode != FSMODE_MAXIMIZED) return false; break; default: break; @@ -509,23 +509,23 @@ bool CWorkspace::matchesStaticSelector(const std::string& selector_) { } void CWorkspace::markInert() { - m_bInert = true; - m_iID = WORKSPACE_INVALID; - m_bVisible = false; - m_pMonitor.reset(); + m_inert = true; + m_id = WORKSPACE_INVALID; + m_visible = false; + m_monitor.reset(); } bool CWorkspace::inert() { - return m_bInert; + return m_inert; } MONITORID CWorkspace::monitorID() { - return m_pMonitor ? m_pMonitor->ID : MONITOR_INVALID; + return m_monitor ? m_monitor->ID : MONITOR_INVALID; } PHLWINDOW CWorkspace::getFullscreenWindow() { for (auto const& w : g_pCompositor->m_windows) { - if (w->m_pWorkspace == m_pSelf && w->isFullscreen()) + if (w->m_pWorkspace == m_self && w->isFullscreen()) return w; } @@ -533,21 +533,21 @@ PHLWINDOW CWorkspace::getFullscreenWindow() { } bool CWorkspace::isVisible() { - return m_bVisible; + return m_visible; } bool CWorkspace::isVisibleNotCovered() { - const auto PMONITOR = m_pMonitor.lock(); + const auto PMONITOR = m_monitor.lock(); if (PMONITOR->activeSpecialWorkspace) - return PMONITOR->activeSpecialWorkspace->m_iID == m_iID; + return PMONITOR->activeSpecialWorkspace->m_id == m_id; - return PMONITOR->activeWorkspace->m_iID == m_iID; + return PMONITOR->activeWorkspace->m_id == m_id; } int CWorkspace::getWindows(std::optional onlyTiled, std::optional onlyPinned, std::optional onlyVisible) { int no = 0; for (auto const& w : g_pCompositor->m_windows) { - if (w->workspaceID() != m_iID || !w->m_bIsMapped) + if (w->workspaceID() != m_id || !w->m_bIsMapped) continue; if (onlyTiled.has_value() && w->m_bIsFloating == onlyTiled.value()) continue; @@ -564,7 +564,7 @@ int CWorkspace::getWindows(std::optional onlyTiled, std::optional on int CWorkspace::getGroups(std::optional onlyTiled, std::optional onlyPinned, std::optional onlyVisible) { int no = 0; for (auto const& w : g_pCompositor->m_windows) { - if (w->workspaceID() != m_iID || !w->m_bIsMapped) + if (w->workspaceID() != m_id || !w->m_bIsMapped) continue; if (!w->m_sGroupData.head) continue; @@ -581,7 +581,7 @@ int CWorkspace::getGroups(std::optional onlyTiled, std::optional onl PHLWINDOW CWorkspace::getFirstWindow() { for (auto const& w : g_pCompositor->m_windows) { - if (w->m_pWorkspace == m_pSelf && w->m_bIsMapped && !w->isHidden()) + if (w->m_pWorkspace == m_self && w->m_bIsMapped && !w->isHidden()) return w; } @@ -589,10 +589,10 @@ PHLWINDOW CWorkspace::getFirstWindow() { } PHLWINDOW CWorkspace::getTopLeftWindow() { - const auto PMONITOR = m_pMonitor.lock(); + const auto PMONITOR = m_monitor.lock(); for (auto const& w : g_pCompositor->m_windows) { - if (w->m_pWorkspace != m_pSelf || !w->m_bIsMapped || w->isHidden()) + if (w->m_pWorkspace != m_self || !w->m_bIsMapped || w->isHidden()) continue; const auto WINDOWIDEALBB = w->getWindowIdealBoundingBoxIgnoreReserved(); @@ -605,7 +605,7 @@ PHLWINDOW CWorkspace::getTopLeftWindow() { bool CWorkspace::hasUrgentWindow() { for (auto const& w : g_pCompositor->m_windows) { - if (w->m_pWorkspace == m_pSelf && w->m_bIsMapped && w->m_bIsUrgent) + if (w->m_pWorkspace == m_self && w->m_bIsMapped && w->m_bIsUrgent) return true; } @@ -614,7 +614,7 @@ bool CWorkspace::hasUrgentWindow() { void CWorkspace::updateWindowDecos() { for (auto const& w : g_pCompositor->m_windows) { - if (w->m_pWorkspace != m_pSelf) + if (w->m_pWorkspace != m_self) continue; w->updateWindowDecos(); @@ -622,10 +622,10 @@ void CWorkspace::updateWindowDecos() { } void CWorkspace::updateWindowData() { - const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_pSelf.lock()); + const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_self.lock()); for (auto const& w : g_pCompositor->m_windows) { - if (w->m_pWorkspace != m_pSelf) + if (w->m_pWorkspace != m_self) continue; w->updateWindowData(WORKSPACERULE); @@ -634,7 +634,7 @@ void CWorkspace::updateWindowData() { void CWorkspace::forceReportSizesToWindows() { for (auto const& w : g_pCompositor->m_windows) { - if (w->m_pWorkspace != m_pSelf || !w->m_bIsMapped || w->isHidden()) + if (w->m_pWorkspace != m_self || !w->m_bIsMapped || w->isHidden()) continue; w->sendWindowSize(true); @@ -642,26 +642,26 @@ void CWorkspace::forceReportSizesToWindows() { } void CWorkspace::rename(const std::string& name) { - if (g_pCompositor->isWorkspaceSpecial(m_iID)) + if (g_pCompositor->isWorkspaceSpecial(m_id)) return; - Debug::log(LOG, "CWorkspace::rename: Renaming workspace {} to '{}'", m_iID, name); - m_szName = name; + Debug::log(LOG, "CWorkspace::rename: Renaming workspace {} to '{}'", m_id, name); + m_name = name; - const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_pSelf.lock()); - m_bPersistent = WORKSPACERULE.isPersistent; + const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(m_self.lock()); + m_persistent = WORKSPACERULE.isPersistent; if (WORKSPACERULE.isPersistent) - g_pCompositor->ensurePersistentWorkspacesPresent(std::vector{WORKSPACERULE}, m_pSelf.lock()); + g_pCompositor->ensurePersistentWorkspacesPresent(std::vector{WORKSPACERULE}, m_self.lock()); - g_pEventManager->postEvent({"renameworkspace", std::to_string(m_iID) + "," + m_szName}); + g_pEventManager->postEvent({"renameworkspace", std::to_string(m_id) + "," + m_name}); } void CWorkspace::updateWindows() { - m_bHasFullscreenWindow = std::ranges::any_of(g_pCompositor->m_windows, [this](const auto& w) { return w->m_bIsMapped && w->m_pWorkspace == m_pSelf && w->isFullscreen(); }); + m_hasFullscreenWindow = std::ranges::any_of(g_pCompositor->m_windows, [this](const auto& w) { return w->m_bIsMapped && w->m_pWorkspace == m_self && w->isFullscreen(); }); for (auto const& w : g_pCompositor->m_windows) { - if (!w->m_bIsMapped || w->m_pWorkspace != m_pSelf) + if (!w->m_bIsMapped || w->m_pWorkspace != m_self) continue; w->updateDynamicRules(); diff --git a/src/desktop/Workspace.hpp b/src/desktop/Workspace.hpp index 12dbe328..a3fe21e8 100644 --- a/src/desktop/Workspace.hpp +++ b/src/desktop/Workspace.hpp @@ -24,39 +24,39 @@ class CWorkspace { // Workspaces ID-based have IDs > 0 // and workspaces name-based have IDs starting with -1337 - WORKSPACEID m_iID = WORKSPACE_INVALID; - std::string m_szName = ""; - PHLMONITORREF m_pMonitor; + WORKSPACEID m_id = WORKSPACE_INVALID; + std::string m_name = ""; + PHLMONITORREF m_monitor; - bool m_bHasFullscreenWindow = false; - eFullscreenMode m_efFullscreenMode = FSMODE_NONE; + bool m_hasFullscreenWindow = false; + eFullscreenMode m_fullscreenMode = FSMODE_NONE; wl_array m_wlrCoordinateArr; // for animations - PHLANIMVAR m_vRenderOffset; - PHLANIMVAR m_fAlpha; - bool m_bForceRendering = false; + PHLANIMVAR m_renderOffset; + PHLANIMVAR m_alpha; + bool m_forceRendering = false; // allows damage to propagate. - bool m_bVisible = false; + bool m_visible = false; // "scratchpad" - bool m_bIsSpecialWorkspace = false; + bool m_isSpecialWorkspace = false; // last window - PHLWINDOWREF m_pLastFocusedWindow; + PHLWINDOWREF m_lastFocusedWindow; // user-set - bool m_bDefaultFloating = false; - bool m_bDefaultPseudo = false; + bool m_defaultFloating = false; + bool m_defaultPseudo = false; // last monitor (used on reconnect) - std::string m_szLastMonitor = ""; + std::string m_lastMonitor = ""; - bool m_bWasCreatedEmpty = true; + bool m_wasCreatedEmpty = true; - bool m_bPersistent = false; + bool m_persistent = false; // Inert: destroyed and invalid. If this is true, release the ptr you have. bool inert(); @@ -88,11 +88,11 @@ class CWorkspace { void init(PHLWORKSPACE self); // Previous workspace ID and name is stored during a workspace change, allowing travel // to the previous workspace. - SWorkspaceIDName m_sPrevWorkspace; + SWorkspaceIDName m_prevWorkspace; - SP m_pFocusedWindowHook; - bool m_bInert = true; - WP m_pSelf; + SP m_focusedWindowHook; + bool m_inert = true; + WP m_self; }; inline bool valid(const PHLWORKSPACE& ref) { diff --git a/src/events/Windows.cpp b/src/events/Windows.cpp index 7d5cfd3f..7b0fbd34 100644 --- a/src/events/Windows.cpp +++ b/src/events/Windows.cpp @@ -190,7 +190,7 @@ void Events::listener_mapWindow(void* owner, void* data) { const auto JUSTWORKSPACE = WORKSPACERQ.contains(' ') ? WORKSPACERQ.substr(0, WORKSPACERQ.find_first_of(' ')) : WORKSPACERQ; - if (JUSTWORKSPACE == PWORKSPACE->m_szName || JUSTWORKSPACE == "name:" + PWORKSPACE->m_szName) + if (JUSTWORKSPACE == PWORKSPACE->m_name || JUSTWORKSPACE == "name:" + PWORKSPACE->m_name) requestedWorkspace = ""; Debug::log(LOG, "Rule workspace matched by {}, {} applied.", PWINDOW, r->szValue); @@ -342,14 +342,14 @@ void Events::listener_mapWindow(void* owner, void* data) { PWORKSPACE = pWorkspace; PWINDOW->m_pWorkspace = pWorkspace; - PWINDOW->m_pMonitor = pWorkspace->m_pMonitor; + PWINDOW->m_pMonitor = pWorkspace->m_monitor; - if (PWINDOW->m_pMonitor.lock()->activeSpecialWorkspace && !pWorkspace->m_bIsSpecialWorkspace) + if (PWINDOW->m_pMonitor.lock()->activeSpecialWorkspace && !pWorkspace->m_isSpecialWorkspace) workspaceSilent = true; if (!workspaceSilent) { - if (pWorkspace->m_bIsSpecialWorkspace) - pWorkspace->m_pMonitor->setSpecialWorkspace(pWorkspace); + if (pWorkspace->m_isSpecialWorkspace) + pWorkspace->m_monitor->setSpecialWorkspace(pWorkspace); else if (PMONITOR->activeWorkspaceID() != REQUESTEDWORKSPACEID && !PWINDOW->m_bNoInitialFocus) g_pKeybindManager->m_mDispatchers["workspace"](requestedWorkspaceName); @@ -379,10 +379,10 @@ void Events::listener_mapWindow(void* owner, void* data) { Debug::log(LOG, "Requested monitor, applying to {:mw}", PWINDOW); } - if (PWORKSPACE->m_bDefaultFloating) + if (PWORKSPACE->m_defaultFloating) PWINDOW->m_bIsFloating = true; - if (PWORKSPACE->m_bDefaultPseudo) { + if (PWORKSPACE->m_defaultPseudo) { PWINDOW->m_bIsPseudotiled = true; CBox desiredGeometry = g_pXWaylandManager->getGeometryForWindow(PWINDOW); PWINDOW->m_vPseudoSize = Vector2D(desiredGeometry.width, desiredGeometry.height); @@ -584,11 +584,11 @@ void Events::listener_mapWindow(void* owner, void* data) { if (PLSFROMFOCUS && PLSFROMFOCUS->m_layerSurface->current.interactivity != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE) PWINDOW->m_bNoInitialFocus = true; - if (PWINDOW->m_pWorkspace->m_bHasFullscreenWindow && !requestedInternalFSMode.has_value() && !requestedClientFSMode.has_value() && !PWINDOW->m_bIsFloating) { + if (PWINDOW->m_pWorkspace->m_hasFullscreenWindow && !requestedInternalFSMode.has_value() && !requestedClientFSMode.has_value() && !PWINDOW->m_bIsFloating) { if (*PNEWTAKESOVERFS == 0) PWINDOW->m_bNoInitialFocus = true; else if (*PNEWTAKESOVERFS == 1) - requestedInternalFSMode = PWINDOW->m_pWorkspace->m_efFullscreenMode; + requestedInternalFSMode = PWINDOW->m_pWorkspace->m_fullscreenMode; else if (*PNEWTAKESOVERFS == 2) g_pCompositor->setWindowFullscreenInternal(PWINDOW->m_pWorkspace->getFullscreenWindow(), FSMODE_NONE); } @@ -611,7 +611,7 @@ void Events::listener_mapWindow(void* owner, void* data) { if (!PWINDOW->m_bNoInitialFocus && (requestedInternalFSMode.has_value() || requestedClientFSMode.has_value() || requestedFSState.has_value())) { // fix fullscreen on requested (basically do a switcheroo) - if (PWINDOW->m_pWorkspace->m_bHasFullscreenWindow) + if (PWINDOW->m_pWorkspace->m_hasFullscreenWindow) g_pCompositor->setWindowFullscreenInternal(PWINDOW->m_pWorkspace->getFullscreenWindow(), FSMODE_NONE); PWINDOW->m_vRealPosition->warp(); @@ -652,7 +652,7 @@ void Events::listener_mapWindow(void* owner, void* data) { Debug::log(LOG, "Map request dispatched, monitor {}, window pos: {:5j}, window size: {:5j}", PMONITOR->szName, PWINDOW->m_vRealPosition->goal(), PWINDOW->m_vRealSize->goal()); - auto workspaceID = requestedWorkspace != "" ? requestedWorkspace : PWORKSPACE->m_szName; + auto workspaceID = requestedWorkspace != "" ? requestedWorkspace : PWORKSPACE->m_name; g_pEventManager->postEvent(SHyprIPCEvent{"openwindow", std::format("{:x},{},{},{}", PWINDOW, workspaceID, PWINDOW->m_szClass, PWINDOW->m_szTitle)}); EMIT_HOOK_EVENT("openWindow", PWINDOW); @@ -672,7 +672,7 @@ void Events::listener_mapWindow(void* owner, void* data) { // recalc the values for this window g_pCompositor->updateWindowAnimatedDecorationValues(PWINDOW); // avoid this window being visible - if (PWORKSPACE->m_bHasFullscreenWindow && !PWINDOW->isFullscreen() && !PWINDOW->m_bIsFloating) + if (PWORKSPACE->m_hasFullscreenWindow && !PWINDOW->isFullscreen() && !PWINDOW->m_bIsFloating) PWINDOW->m_fAlpha->setValueAndWarp(0.f); g_pCompositor->setPreferredScaleForSurface(PWINDOW->m_pWLSurface->resource(), PMONITOR->scale); @@ -764,8 +764,8 @@ void Events::listener_unmapWindow(void* owner, void* data) { // remove the fullscreen window status from workspace if we closed it const auto PWORKSPACE = PWINDOW->m_pWorkspace; - if (PWORKSPACE->m_bHasFullscreenWindow && PWINDOW->isFullscreen()) - PWORKSPACE->m_bHasFullscreenWindow = false; + if (PWORKSPACE->m_hasFullscreenWindow && PWINDOW->isFullscreen()) + PWORKSPACE->m_hasFullscreenWindow = false; g_pLayoutManager->getCurrentLayout()->onWindowRemoved(PWINDOW); @@ -853,7 +853,7 @@ void Events::listener_commitWindow(void* owner, void* data) { g_pHyprRenderer->damageWindow(PWINDOW); } - if (!PWINDOW->m_pWorkspace->m_bVisible) + if (!PWINDOW->m_pWorkspace->m_visible) return; const auto PMONITOR = PWINDOW->m_pMonitor.lock(); diff --git a/src/helpers/MiscFunctions.cpp b/src/helpers/MiscFunctions.cpp index 6f97c3bf..e2d3c907 100644 --- a/src/helpers/MiscFunctions.cpp +++ b/src/helpers/MiscFunctions.cpp @@ -122,7 +122,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) { const auto NAME = in.substr(8); const auto WS = g_pCompositor->getWorkspaceByName("special:" + NAME); - return {WS ? WS->m_iID : g_pCompositor->getNewSpecialID(), "special:" + NAME}; + return {WS ? WS->m_id : g_pCompositor->getNewSpecialID(), "special:" + NAME}; } result.id = SPECIAL_WORKSPACE_START; @@ -133,7 +133,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) { if (!WORKSPACE) { result.id = g_pCompositor->getNextAvailableNamedWorkspace(); } else { - result.id = WORKSPACE->m_iID; + result.id = WORKSPACE->m_id; } result.name = WORKSPACENAME; } else if (in.starts_with("empty")) { @@ -175,7 +175,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) { if (!PLASTWORKSPACE) return {WORKSPACE_INVALID}; - return {PLASTWORKSPACE->m_iID, PLASTWORKSPACE->m_szName}; + return {PLASTWORKSPACE->m_id, PLASTWORKSPACE->m_name}; } else { if (in[0] == 'r' && (in[1] == '-' || in[1] == '+' || in[1] == '~') && isNumber(in.substr(2))) { bool absolute = in[1] == '~'; @@ -197,9 +197,9 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) { // Collect all the workspaces we can't jump to. for (auto const& ws : g_pCompositor->m_workspaces) { - if (ws->m_bIsSpecialWorkspace || (ws->m_pMonitor != g_pCompositor->m_lastMonitor)) { + if (ws->m_isSpecialWorkspace || (ws->m_monitor != g_pCompositor->m_lastMonitor)) { // Can't jump to this workspace - invalidWSes.insert(ws->m_iID); + invalidWSes.insert(ws->m_id); } } for (auto const& rule : g_pConfigManager->getAllWorkspaceRules()) { @@ -215,10 +215,10 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) { // Prepare all named workspaces in case when we need them std::vector namedWSes; for (auto const& ws : g_pCompositor->m_workspaces) { - if (ws->m_bIsSpecialWorkspace || (ws->m_pMonitor != g_pCompositor->m_lastMonitor) || ws->m_iID >= 0) + if (ws->m_isSpecialWorkspace || (ws->m_monitor != g_pCompositor->m_lastMonitor) || ws->m_id >= 0) continue; - namedWSes.push_back(ws->m_iID); + namedWSes.push_back(ws->m_id); } std::sort(namedWSes.begin(), namedWSes.end()); @@ -242,7 +242,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) { } else { // 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_iID : 1; + WORKSPACEID activeWSID = g_pCompositor->m_lastMonitor->activeWorkspace ? g_pCompositor->m_lastMonitor->activeWorkspace->m_id : 1; WORKSPACEID predictedWSID = activeWSID + remains; int remainingWSes = 0; char walkDir = in[1]; @@ -333,7 +333,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) { const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(result.id); if (PWORKSPACE) - result.name = g_pCompositor->getWorkspaceByID(result.id)->m_szName; + result.name = g_pCompositor->getWorkspaceByID(result.id)->m_name; else result.name = std::to_string(result.id); @@ -359,10 +359,10 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) { std::vector validWSes; for (auto const& ws : g_pCompositor->m_workspaces) { - if (ws->m_bIsSpecialWorkspace || (ws->m_pMonitor != g_pCompositor->m_lastMonitor && !onAllMonitors)) + if (ws->m_isSpecialWorkspace || (ws->m_monitor != g_pCompositor->m_lastMonitor && !onAllMonitors)) continue; - validWSes.push_back(ws->m_iID); + validWSes.push_back(ws->m_id); } std::sort(validWSes.begin(), validWSes.end()); @@ -384,7 +384,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) { remains = remains < 0 ? -((-remains) % validWSes.size()) : remains % validWSes.size(); // get the current item - WORKSPACEID activeWSID = g_pCompositor->m_lastMonitor->activeWorkspace ? g_pCompositor->m_lastMonitor->activeWorkspace->m_iID : 1; + WORKSPACEID activeWSID = g_pCompositor->m_lastMonitor->activeWorkspace ? g_pCompositor->m_lastMonitor->activeWorkspace->m_id : 1; for (ssize_t i = 0; i < (ssize_t)validWSes.size(); i++) { if (validWSes[i] == activeWSID) { currentItem = i; @@ -404,7 +404,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) { } result.id = validWSes[currentItem]; - result.name = g_pCompositor->getWorkspaceByID(validWSes[currentItem])->m_szName; + result.name = g_pCompositor->getWorkspaceByID(validWSes[currentItem])->m_name; } else { if (in[0] == '+' || in[0] == '-') { if (g_pCompositor->m_lastMonitor) { @@ -423,7 +423,7 @@ SWorkspaceIDName getWorkspaceIDNameFromString(const std::string& in) { // maybe name const auto PWORKSPACE = g_pCompositor->getWorkspaceByName(in); if (PWORKSPACE) - result.id = PWORKSPACE->m_iID; + result.id = PWORKSPACE->m_id; } result.name = std::to_string(result.id); diff --git a/src/helpers/Monitor.cpp b/src/helpers/Monitor.cpp index 6397e8c3..d5c4e2d1 100644 --- a/src/helpers/Monitor.cpp +++ b/src/helpers/Monitor.cpp @@ -212,10 +212,10 @@ void CMonitor::onConnect(bool noRule) { if (!valid(ws)) continue; - if (ws->m_szLastMonitor == szName || g_pCompositor->m_monitors.size() == 1 /* avoid lost workspaces on recover */) { + if (ws->m_lastMonitor == szName || g_pCompositor->m_monitors.size() == 1 /* avoid lost workspaces on recover */) { g_pCompositor->moveWorkspaceToMonitor(ws, self.lock()); ws->startAnim(true, true, true); - ws->m_szLastMonitor = ""; + ws->m_lastMonitor = ""; } } @@ -302,8 +302,8 @@ void CMonitor::onDisconnect(bool destroy) { // record what workspace this monitor was on if (activeWorkspace) { - Debug::log(LOG, "Disconnecting Monitor {} was on workspace {}", szName, activeWorkspace->m_iID); - g_pCompositor->m_seenMonitorWorkspaceMap[szName] = activeWorkspace->m_iID; + Debug::log(LOG, "Disconnecting Monitor {} was on workspace {}", szName, activeWorkspace->m_id); + g_pCompositor->m_seenMonitorWorkspaceMap[szName] = activeWorkspace->m_id; } // Cleanup everything. Move windows back, snap cursor, shit. @@ -362,12 +362,12 @@ void CMonitor::onDisconnect(bool destroy) { // move workspaces std::vector wspToMove; for (auto const& w : g_pCompositor->m_workspaces) { - if (w->m_pMonitor == self || !w->m_pMonitor) + if (w->m_monitor == self || !w->m_monitor) wspToMove.push_back(w); } for (auto const& w : wspToMove) { - w->m_szLastMonitor = szName; + w->m_lastMonitor = szName; g_pCompositor->moveWorkspaceToMonitor(w, BACKUPMON); w->startAnim(true, true, true); } @@ -378,7 +378,7 @@ void CMonitor::onDisconnect(bool destroy) { } if (activeWorkspace) - activeWorkspace->m_bVisible = false; + activeWorkspace->m_visible = false; activeWorkspace.reset(); output->state->resetExplicitFences(); @@ -894,7 +894,7 @@ bool CMonitor::shouldSkipScheduleFrameOnMouseEvent() { static auto PMINRR = CConfigValue("cursor:min_refresh_rate"); // skip scheduling extra frames for fullsreen apps with vrr - const bool shouldSkip = activeWorkspace && activeWorkspace->m_bHasFullscreenWindow && activeWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN && + const bool shouldSkip = activeWorkspace && activeWorkspace->m_hasFullscreenWindow && activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN && (*PNOBREAK == 1 || (*PNOBREAK == 2 && activeWorkspace->getFullscreenWindow()->getContentType() == CONTENT_TYPE_GAME)) && output->state->state().adaptiveSync; // keep requested minimum refresh rate @@ -976,8 +976,8 @@ void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) { activeWorkspace = PNEWWORKSPACE; PNEWWORKSPACE->setActive(true); - PNEWWORKSPACE->m_bVisible = true; - PNEWWORKSPACE->m_szLastMonitor = ""; + PNEWWORKSPACE->m_visible = true; + PNEWWORKSPACE->m_lastMonitor = ""; } void CMonitor::setMirror(const std::string& mirrorOf) { @@ -1046,7 +1046,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) { // move all the WS std::vector wspToMove; for (auto const& w : g_pCompositor->m_workspaces) { - if (w->m_pMonitor == self || !w->m_pMonitor) + if (w->m_monitor == self || !w->m_monitor) wspToMove.push_back(w); } @@ -1101,9 +1101,9 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo if (!pWorkspace) return; - if (pWorkspace->m_bIsSpecialWorkspace) { + if (pWorkspace->m_isSpecialWorkspace) { if (activeSpecialWorkspace != pWorkspace) { - Debug::log(LOG, "changeworkspace on special, togglespecialworkspace to id {}", pWorkspace->m_iID); + Debug::log(LOG, "changeworkspace on special, togglespecialworkspace to id {}", pWorkspace->m_id); setSpecialWorkspace(pWorkspace); } return; @@ -1114,13 +1114,13 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo const auto POLDWORKSPACE = activeWorkspace; if (POLDWORKSPACE) - POLDWORKSPACE->m_bVisible = false; - pWorkspace->m_bVisible = true; + POLDWORKSPACE->m_visible = false; + pWorkspace->m_visible = true; activeWorkspace = pWorkspace; if (!internal) { - const auto ANIMTOLEFT = POLDWORKSPACE && pWorkspace->m_iID > POLDWORKSPACE->m_iID; + const auto ANIMTOLEFT = POLDWORKSPACE && pWorkspace->m_id > POLDWORKSPACE->m_id; if (POLDWORKSPACE) POLDWORKSPACE->startAnim(false, ANIMTOLEFT); pWorkspace->startAnim(true, ANIMTOLEFT); @@ -1134,7 +1134,7 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo if (!noFocus && !g_pCompositor->m_lastMonitor->activeSpecialWorkspace && !(g_pCompositor->m_lastWindow.lock() && g_pCompositor->m_lastWindow->m_bPinned && g_pCompositor->m_lastWindow->m_pMonitor == self)) { static auto PFOLLOWMOUSE = CConfigValue("input:follow_mouse"); - auto pWindow = pWorkspace->m_bHasFullscreenWindow ? pWorkspace->getFullscreenWindow() : pWorkspace->getLastFocusedWindow(); + auto pWindow = pWorkspace->m_hasFullscreenWindow ? pWorkspace->getFullscreenWindow() : pWorkspace->getLastFocusedWindow(); if (!pWindow) { if (*PFOLLOWMOUSE == 1) @@ -1155,8 +1155,8 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID); - g_pEventManager->postEvent(SHyprIPCEvent{"workspace", pWorkspace->m_szName}); - g_pEventManager->postEvent(SHyprIPCEvent{"workspacev2", std::format("{},{}", pWorkspace->m_iID, pWorkspace->m_szName)}); + g_pEventManager->postEvent(SHyprIPCEvent{"workspace", pWorkspace->m_name}); + g_pEventManager->postEvent(SHyprIPCEvent{"workspacev2", std::format("{},{}", pWorkspace->m_id, pWorkspace->m_name)}); EMIT_HOOK_EVENT("workspace", pWorkspace); } @@ -1185,7 +1185,7 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) { if (!pWorkspace) { // remove special if exists if (activeSpecialWorkspace) { - activeSpecialWorkspace->m_bVisible = false; + activeSpecialWorkspace->m_visible = false; activeSpecialWorkspace->startAnim(false, false); g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + szName}); g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", ",," + szName}); @@ -1211,14 +1211,14 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) { } if (activeSpecialWorkspace) { - activeSpecialWorkspace->m_bVisible = false; + activeSpecialWorkspace->m_visible = false; activeSpecialWorkspace->startAnim(false, false); } bool animate = true; //close if open elsewhere - const auto PMONITORWORKSPACEOWNER = pWorkspace->m_pMonitor.lock(); - if (const auto PMWSOWNER = pWorkspace->m_pMonitor.lock(); PMWSOWNER && PMWSOWNER->activeSpecialWorkspace == pWorkspace) { + const auto PMONITORWORKSPACEOWNER = pWorkspace->m_monitor.lock(); + if (const auto PMWSOWNER = pWorkspace->m_monitor.lock(); PMWSOWNER && PMWSOWNER->activeSpecialWorkspace == pWorkspace) { PMWSOWNER->activeSpecialWorkspace.reset(); g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMWSOWNER->ID); g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + PMWSOWNER->szName}); @@ -1231,9 +1231,9 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) { } // open special - pWorkspace->m_pMonitor = self; - activeSpecialWorkspace = pWorkspace; - activeSpecialWorkspace->m_bVisible = true; + pWorkspace->m_monitor = self; + activeSpecialWorkspace = pWorkspace; + activeSpecialWorkspace->m_visible = true; if (animate) pWorkspace->startAnim(true, true); @@ -1270,8 +1270,8 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) { g_pInputManager->refocus(); } - g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", pWorkspace->m_szName + "," + szName}); - g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", std::to_string(pWorkspace->m_iID) + "," + pWorkspace->m_szName + "," + szName}); + g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", pWorkspace->m_name + "," + szName}); + g_pEventManager->postEvent(SHyprIPCEvent{"activespecialv2", std::to_string(pWorkspace->m_id) + "," + pWorkspace->m_name + "," + szName}); g_pHyprRenderer->damageMonitor(self.lock()); @@ -1300,7 +1300,7 @@ SWorkspaceIDName CMonitor::getPrevWorkspaceIDName(const WORKSPACEID id) { // recheck if previous workspace's was moved to another monitor const auto ws = g_pCompositor->getWorkspaceByID(PREVID); if (ws && ws->monitorID() == ID) - return {.id = PREVID, .name = ws->m_szName}; + return {.id = PREVID, .name = ws->m_name}; } return {.id = WORKSPACE_INVALID}; @@ -1324,11 +1324,11 @@ void CMonitor::updateMatrix() { } WORKSPACEID CMonitor::activeWorkspaceID() { - return activeWorkspace ? activeWorkspace->m_iID : 0; + return activeWorkspace ? activeWorkspace->m_id : 0; } WORKSPACEID CMonitor::activeSpecialWorkspaceID() { - return activeSpecialWorkspace ? activeSpecialWorkspace->m_iID : 0; + return activeSpecialWorkspace ? activeSpecialWorkspace->m_id : 0; } CBox CMonitor::logicalBox() { diff --git a/src/layout/DwindleLayout.cpp b/src/layout/DwindleLayout.cpp index 7e823f88..0c9f0803 100644 --- a/src/layout/DwindleLayout.cpp +++ b/src/layout/DwindleLayout.cpp @@ -107,7 +107,7 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for } } } else if (const auto WS = g_pCompositor->getWorkspaceByID(pNode->workspaceID); WS) - PMONITOR = WS->m_pMonitor.lock(); + PMONITOR = WS->m_monitor.lock(); if (!PMONITOR) { Debug::log(ERR, "Orphaned Node {}!!", pNode); @@ -499,23 +499,23 @@ void CHyprDwindleLayout::recalculateMonitor(const MONITORID& monid) { } void CHyprDwindleLayout::calculateWorkspace(const PHLWORKSPACE& pWorkspace) { - const auto PMONITOR = pWorkspace->m_pMonitor.lock(); + const auto PMONITOR = pWorkspace->m_monitor.lock(); if (!PMONITOR) return; - if (pWorkspace->m_bHasFullscreenWindow) { + if (pWorkspace->m_hasFullscreenWindow) { // massive hack from the fullscreen func const auto PFULLWINDOW = pWorkspace->getFullscreenWindow(); - if (pWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN) { + if (pWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) { *PFULLWINDOW->m_vRealPosition = PMONITOR->vecPosition; *PFULLWINDOW->m_vRealSize = PMONITOR->vecSize; - } else if (pWorkspace->m_efFullscreenMode == FSMODE_MAXIMIZED) { + } else if (pWorkspace->m_fullscreenMode == FSMODE_MAXIMIZED) { SDwindleNodeData fakeNode; fakeNode.pWindow = PFULLWINDOW; fakeNode.box = {PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft, PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight}; - fakeNode.workspaceID = pWorkspace->m_iID; + fakeNode.workspaceID = pWorkspace->m_id; PFULLWINDOW->m_vPosition = fakeNode.box.pos(); PFULLWINDOW->m_vSize = fakeNode.box.size(); fakeNode.ignoreFullscreenChecks = true; @@ -527,7 +527,7 @@ void CHyprDwindleLayout::calculateWorkspace(const PHLWORKSPACE& pWorkspace) { return; } - const auto TOPNODE = getMasterNodeOnWorkspace(pWorkspace->m_iID); + const auto TOPNODE = getMasterNodeOnWorkspace(pWorkspace->m_id); if (TOPNODE) { TOPNODE->box = {PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft, PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight}; diff --git a/src/layout/IHyprLayout.cpp b/src/layout/IHyprLayout.cpp index 963639e5..cf036131 100644 --- a/src/layout/IHyprLayout.cpp +++ b/src/layout/IHyprLayout.cpp @@ -404,7 +404,7 @@ static void performSnap(Vector2D& sourcePos, Vector2D& sourceSize, PHLWINDOW DRA if (*SNAPWINDOWGAP) { const double GAPSIZE = *SNAPWINDOWGAP; const auto WSID = DRAGGINGWINDOW->workspaceID(); - const bool HASFULLSCREEN = DRAGGINGWINDOW->m_pWorkspace && DRAGGINGWINDOW->m_pWorkspace->m_bHasFullscreenWindow; + const bool HASFULLSCREEN = DRAGGINGWINDOW->m_pWorkspace && DRAGGINGWINDOW->m_pWorkspace->m_hasFullscreenWindow; for (auto& other : g_pCompositor->m_windows) { if ((HASFULLSCREEN && !other->m_bCreatedOverFullscreen) || other == DRAGGINGWINDOW || other->workspaceID() != WSID || !other->m_bIsMapped || other->m_bFadingOut || @@ -724,7 +724,7 @@ void IHyprLayout::changeWindowFloatingMode(PHLWINDOW pWindow) { const auto PWORKSPACE = PNEWMON->activeSpecialWorkspace ? PNEWMON->activeSpecialWorkspace : PNEWMON->activeWorkspace; - if (PWORKSPACE->m_bHasFullscreenWindow) + if (PWORKSPACE->m_hasFullscreenWindow) g_pCompositor->setWindowFullscreenInternal(PWORKSPACE->getFullscreenWindow(), FSMODE_NONE); // save real pos cuz the func applies the default 5,5 mid @@ -814,7 +814,7 @@ PHLWINDOW IHyprLayout::getNextWindowCandidate(PHLWINDOW pWindow) { const auto PWORKSPACE = pWindow->m_pWorkspace; // first of all, if this is a fullscreen workspace, - if (PWORKSPACE->m_bHasFullscreenWindow) + if (PWORKSPACE->m_hasFullscreenWindow) return PWORKSPACE->getFullscreenWindow(); if (pWindow->m_bIsFloating) { @@ -956,7 +956,7 @@ bool IHyprLayout::updateDragWindow() { const auto PWORKSPACE = DRAGGINGWINDOW->m_pWorkspace; - if (PWORKSPACE->m_bHasFullscreenWindow && (!DRAGGINGWINDOW->m_bCreatedOverFullscreen || !DRAGGINGWINDOW->m_bIsFloating)) { + if (PWORKSPACE->m_hasFullscreenWindow && (!DRAGGINGWINDOW->m_bCreatedOverFullscreen || !DRAGGINGWINDOW->m_bIsFloating)) { Debug::log(LOG, "Rejecting drag on a fullscreen workspace. (window under fullscreen)"); g_pKeybindManager->changeMouseBindMode(MBIND_INVALID); return true; diff --git a/src/layout/MasterLayout.cpp b/src/layout/MasterLayout.cpp index 555d660f..052a6ed9 100644 --- a/src/layout/MasterLayout.cpp +++ b/src/layout/MasterLayout.cpp @@ -296,24 +296,24 @@ void CHyprMasterLayout::recalculateMonitor(const MONITORID& monid) { } void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) { - const auto PMONITOR = pWorkspace->m_pMonitor.lock(); + const auto PMONITOR = pWorkspace->m_monitor.lock(); if (!PMONITOR) return; - if (pWorkspace->m_bHasFullscreenWindow) { + if (pWorkspace->m_hasFullscreenWindow) { // massive hack from the fullscreen func const auto PFULLWINDOW = pWorkspace->getFullscreenWindow(); - if (pWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN) { + if (pWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) { *PFULLWINDOW->m_vRealPosition = PMONITOR->vecPosition; *PFULLWINDOW->m_vRealSize = PMONITOR->vecSize; - } else if (pWorkspace->m_efFullscreenMode == FSMODE_MAXIMIZED) { + } else if (pWorkspace->m_fullscreenMode == FSMODE_MAXIMIZED) { SMasterNodeData fakeNode; fakeNode.pWindow = PFULLWINDOW; fakeNode.position = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft; fakeNode.size = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight; - fakeNode.workspaceID = pWorkspace->m_iID; + fakeNode.workspaceID = pWorkspace->m_id; PFULLWINDOW->m_vPosition = fakeNode.position; PFULLWINDOW->m_vSize = fakeNode.size; fakeNode.ignoreFullscreenChecks = true; @@ -325,7 +325,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) { return; } - const auto PMASTERNODE = getMasterNodeOnWorkspace(pWorkspace->m_iID); + const auto PMASTERNODE = getMasterNodeOnWorkspace(pWorkspace->m_id); if (!PMASTERNODE) return; @@ -337,8 +337,8 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) { static auto PIGNORERESERVED = CConfigValue("master:center_ignores_reserved"); static auto PSMARTRESIZING = CConfigValue("master:smart_resizing"); - const auto MASTERS = getMastersOnWorkspace(pWorkspace->m_iID); - const auto WINDOWS = getNodesOnWorkspace(pWorkspace->m_iID); + const auto MASTERS = getMastersOnWorkspace(pWorkspace->m_id); + const auto WINDOWS = getNodesOnWorkspace(pWorkspace->m_id); const auto STACKWINDOWS = WINDOWS - MASTERS; const auto WSSIZE = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight; const auto WSPOS = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft; @@ -364,7 +364,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) { // check the total width and height so that later // if larger/smaller than screen size them down/up for (auto const& nd : m_lMasterNodesData) { - if (nd.workspaceID == pWorkspace->m_iID) { + if (nd.workspaceID == pWorkspace->m_id) { if (nd.isMaster) masterAccumulatedSize += totalSize / MASTERS * nd.percSize; else @@ -405,7 +405,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) { nextY = WSSIZE.y - HEIGHT; for (auto& nd : m_lMasterNodesData) { - if (nd.workspaceID != pWorkspace->m_iID || !nd.isMaster) + if (nd.workspaceID != pWorkspace->m_id || !nd.isMaster) continue; float WIDTH = mastersLeft > 1 ? widthLeft / mastersLeft * nd.percSize : widthLeft; @@ -442,7 +442,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) { } for (auto& nd : m_lMasterNodesData) { - if (nd.workspaceID != pWorkspace->m_iID || !nd.isMaster) + if (nd.workspaceID != pWorkspace->m_id || !nd.isMaster) continue; float HEIGHT = mastersLeft > 1 ? heightLeft / mastersLeft * nd.percSize : heightLeft; @@ -479,7 +479,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) { nextY = PMASTERNODE->size.y; for (auto& nd : m_lMasterNodesData) { - if (nd.workspaceID != pWorkspace->m_iID || nd.isMaster) + if (nd.workspaceID != pWorkspace->m_id || nd.isMaster) continue; float WIDTH = slavesLeft > 1 ? widthLeft / slavesLeft * nd.percSize : widthLeft; @@ -509,7 +509,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) { nextX = PMASTERNODE->size.x; for (auto& nd : m_lMasterNodesData) { - if (nd.workspaceID != pWorkspace->m_iID || nd.isMaster) + if (nd.workspaceID != pWorkspace->m_id || nd.isMaster) continue; float HEIGHT = slavesLeft > 1 ? heightLeft / slavesLeft * nd.percSize : heightLeft; @@ -554,7 +554,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) { if (*PSMARTRESIZING) { for (auto const& nd : m_lMasterNodesData) { - if (nd.workspaceID != pWorkspace->m_iID || nd.isMaster) + if (nd.workspaceID != pWorkspace->m_id || nd.isMaster) continue; if (onRight) { @@ -569,7 +569,7 @@ void CHyprMasterLayout::calculateWorkspace(PHLWORKSPACE pWorkspace) { } for (auto& nd : m_lMasterNodesData) { - if (nd.workspaceID != pWorkspace->m_iID || nd.isMaster) + if (nd.workspaceID != pWorkspace->m_id || nd.isMaster) continue; if (onRight) { @@ -628,7 +628,7 @@ void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) { } } } else - PMONITOR = g_pCompositor->getWorkspaceByID(pNode->workspaceID)->m_pMonitor.lock(); + PMONITOR = g_pCompositor->getWorkspaceByID(pNode->workspaceID)->m_monitor.lock(); if (!PMONITOR) { Debug::log(ERR, "Orphaned Node {}!!", pNode); @@ -1411,7 +1411,7 @@ eOrientation CHyprMasterLayout::getDynamicOrientation(PHLWORKSPACE pWorkspace) { if (WORKSPACERULE.layoutopts.contains("orientation")) orientationString = WORKSPACERULE.layoutopts.at("orientation"); - eOrientation orientation = getMasterWorkspaceData(pWorkspace->m_iID)->orientation; + eOrientation orientation = getMasterWorkspaceData(pWorkspace->m_id)->orientation; // override if workspace rule is set if (!orientationString.empty()) { if (orientationString == "top") @@ -1446,19 +1446,19 @@ Vector2D CHyprMasterLayout::predictSizeForNewWindowTiled() { if (!g_pCompositor->m_lastMonitor) return {}; - const int NODES = getNodesOnWorkspace(g_pCompositor->m_lastMonitor->activeWorkspace->m_iID); + const int NODES = getNodesOnWorkspace(g_pCompositor->m_lastMonitor->activeWorkspace->m_id); if (NODES <= 0) return g_pCompositor->m_lastMonitor->vecSize; - const auto MASTER = getMasterNodeOnWorkspace(g_pCompositor->m_lastMonitor->activeWorkspace->m_iID); + const auto MASTER = getMasterNodeOnWorkspace(g_pCompositor->m_lastMonitor->activeWorkspace->m_id); if (!MASTER) // wtf return {}; if (*PNEWSTATUS == "master") { return MASTER->size; } else { - const auto SLAVES = NODES - getMastersOnWorkspace(g_pCompositor->m_lastMonitor->activeWorkspace->m_iID); + const auto SLAVES = NODES - getMastersOnWorkspace(g_pCompositor->m_lastMonitor->activeWorkspace->m_id); // TODO: make this better return {g_pCompositor->m_lastMonitor->vecSize.x - MASTER->size.x, g_pCompositor->m_lastMonitor->vecSize.y / (SLAVES + 1)}; diff --git a/src/managers/AnimationManager.cpp b/src/managers/AnimationManager.cpp index 2c8cf1f9..0db60e58 100644 --- a/src/managers/AnimationManager.cpp +++ b/src/managers/AnimationManager.cpp @@ -100,12 +100,12 @@ static void handleUpdate(CAnimatedVariable& av, bool warp) { animationsDisabled = PWINDOW->m_sWindowData.noAnim.valueOr(animationsDisabled); } else if (PWORKSPACE) { - PMONITOR = PWORKSPACE->m_pMonitor.lock(); + PMONITOR = PWORKSPACE->m_monitor.lock(); if (!PMONITOR) return; // dont damage the whole monitor on workspace change, unless it's a special workspace, because dim/blur etc - if (PWORKSPACE->m_bIsSpecialWorkspace) + if (PWORKSPACE->m_isSpecialWorkspace) g_pHyprRenderer->damageMonitor(PMONITOR); // TODO: just make this into a damn callback already vax... @@ -122,7 +122,7 @@ static void handleUpdate(CAnimatedVariable& av, bool warp) { g_pHyprRenderer->damageWindow(w, true); } - if (PWORKSPACE->m_bIsSpecialWorkspace) + if (PWORKSPACE->m_isSpecialWorkspace) g_pHyprRenderer->damageWindow(w, true); // hack for special too because it can cross multiple monitors } diff --git a/src/managers/KeybindManager.cpp b/src/managers/KeybindManager.cpp index 9d7163f6..84f3a6d1 100644 --- a/src/managers/KeybindManager.cpp +++ b/src/managers/KeybindManager.cpp @@ -391,7 +391,7 @@ void CKeybindManager::switchToWindow(PHLWINDOW PWINDOWTOCHANGETO, bool preserveF if (PLASTWINDOW && PLASTWINDOW->m_pWorkspace == PWINDOWTOCHANGETO->m_pWorkspace && PLASTWINDOW->isFullscreen()) { const auto PWORKSPACE = PLASTWINDOW->m_pWorkspace; - const auto MODE = PWORKSPACE->m_efFullscreenMode; + const auto MODE = PWORKSPACE->m_fullscreenMode; if (!PWINDOWTOCHANGETO->m_bPinned) g_pCompositor->setWindowFullscreenInternal(PLASTWINDOW, FSMODE_NONE); @@ -1223,15 +1223,15 @@ static SWorkspaceIDName getWorkspaceToChangeFromArgs(std::string args, PHLWORKSP } const bool PER_MON = args.contains("_per_monitor"); - const SWorkspaceIDName PPREVWS = PER_MON ? PMONITOR->getPrevWorkspaceIDName(PCURRENTWORKSPACE->m_iID) : PCURRENTWORKSPACE->getPrevWorkspaceIDName(); + const SWorkspaceIDName PPREVWS = PER_MON ? PMONITOR->getPrevWorkspaceIDName(PCURRENTWORKSPACE->m_id) : PCURRENTWORKSPACE->getPrevWorkspaceIDName(); // Do nothing if there's no previous workspace, otherwise switch to it. - if (PPREVWS.id == -1 || PPREVWS.id == PCURRENTWORKSPACE->m_iID) { + if (PPREVWS.id == -1 || PPREVWS.id == PCURRENTWORKSPACE->m_id) { Debug::log(LOG, "No previous workspace to change to"); return {.id = WORKSPACE_NOT_CHANGED}; } if (const auto PWORKSPACETOCHANGETO = g_pCompositor->getWorkspaceByID(PPREVWS.id); PWORKSPACETOCHANGETO) { - return {.id = PWORKSPACETOCHANGETO->m_iID, .name = PWORKSPACETOCHANGETO->m_szName}; + return {.id = PWORKSPACETOCHANGETO->m_id, .name = PWORKSPACETOCHANGETO->m_name}; } return {.id = PPREVWS.id, .name = PPREVWS.name.empty() ? std::to_string(PPREVWS.id) : PPREVWS.name}; @@ -1262,9 +1262,9 @@ SDispatchResult CKeybindManager::changeworkspace(std::string args) { if (workspaceToChangeTo == WORKSPACE_NOT_CHANGED) return {}; - const SWorkspaceIDName PPREVWS = args.contains("_per_monitor") ? PMONITOR->getPrevWorkspaceIDName(PCURRENTWORKSPACE->m_iID) : PCURRENTWORKSPACE->getPrevWorkspaceIDName(); + const SWorkspaceIDName PPREVWS = args.contains("_per_monitor") ? PMONITOR->getPrevWorkspaceIDName(PCURRENTWORKSPACE->m_id) : PCURRENTWORKSPACE->getPrevWorkspaceIDName(); - const bool BISWORKSPACECURRENT = workspaceToChangeTo == PCURRENTWORKSPACE->m_iID; + const bool BISWORKSPACECURRENT = workspaceToChangeTo == PCURRENTWORKSPACE->m_id; if (BISWORKSPACECURRENT && (!(*PBACKANDFORTH || EXPLICITPREVIOUS) || PPREVWS.id == -1)) { if (*PHIDESPECIALONWORKSPACECHANGE) PMONITOR->setSpecialWorkspace(nullptr); @@ -1280,7 +1280,7 @@ SDispatchResult CKeybindManager::changeworkspace(std::string args) { pWorkspaceToChangeTo = g_pCompositor->createNewWorkspace(BISWORKSPACECURRENT ? PPREVWS.id : workspaceToChangeTo, PMONITOR->ID, BISWORKSPACECURRENT ? PPREVWS.name : workspaceName); - if (!BISWORKSPACECURRENT && pWorkspaceToChangeTo->m_bIsSpecialWorkspace) { + if (!BISWORKSPACECURRENT && pWorkspaceToChangeTo->m_isSpecialWorkspace) { PMONITOR->setSpecialWorkspace(pWorkspaceToChangeTo); g_pInputManager->simulateMouseMovement(); return {}; @@ -1288,7 +1288,7 @@ SDispatchResult CKeybindManager::changeworkspace(std::string args) { g_pInputManager->releaseAllMouseButtons(); - const auto PMONITORWORKSPACEOWNER = PMONITOR == pWorkspaceToChangeTo->m_pMonitor ? PMONITOR : pWorkspaceToChangeTo->m_pMonitor.lock(); + const auto PMONITORWORKSPACEOWNER = PMONITOR == pWorkspaceToChangeTo->m_monitor ? PMONITOR : pWorkspaceToChangeTo->m_monitor.lock(); if (!PMONITORWORKSPACEOWNER) return {.success = false, .error = "Workspace to switch to has no monitor"}; @@ -1425,20 +1425,20 @@ SDispatchResult CKeybindManager::moveActiveToWorkspace(std::string args) { if (pWorkspace) { g_pCompositor->moveWindowToWorkspaceSafe(PWINDOW, pWorkspace); - pMonitor = pWorkspace->m_pMonitor.lock(); + pMonitor = pWorkspace->m_monitor.lock(); g_pCompositor->setActiveMonitor(pMonitor); } else { pWorkspace = g_pCompositor->createNewWorkspace(WORKSPACEID, PWINDOW->monitorID(), workspaceName, false); - pMonitor = pWorkspace->m_pMonitor.lock(); + pMonitor = pWorkspace->m_monitor.lock(); g_pCompositor->moveWindowToWorkspaceSafe(PWINDOW, pWorkspace); } - POLDWS->m_pLastFocusedWindow = POLDWS->getFirstWindow(); + POLDWS->m_lastFocusedWindow = POLDWS->getFirstWindow(); - if (pWorkspace->m_bIsSpecialWorkspace) + if (pWorkspace->m_isSpecialWorkspace) pMonitor->setSpecialWorkspace(pWorkspace); - else if (POLDWS->m_bIsSpecialWorkspace) - POLDWS->m_pMonitor.lock()->setSpecialWorkspace(nullptr); + else if (POLDWS->m_isSpecialWorkspace) + POLDWS->m_monitor.lock()->setSpecialWorkspace(nullptr); if (*PALLOWWORKSPACECYCLES) pWorkspace->rememberPrevWorkspace(POLDWS); @@ -1782,7 +1782,7 @@ SDispatchResult CKeybindManager::toggleSplit(std::string args) { const auto PWORKSPACE = header.pWindow->m_pWorkspace; - if (PWORKSPACE->m_bHasFullscreenWindow) + if (PWORKSPACE->m_hasFullscreenWindow) return {.success = false, .error = "Can't split windows that already split"}; g_pLayoutManager->getCurrentLayout()->layoutMessage(header, "togglesplit"); @@ -1799,7 +1799,7 @@ SDispatchResult CKeybindManager::swapSplit(std::string args) { const auto PWORKSPACE = header.pWindow->m_pWorkspace; - if (PWORKSPACE->m_bHasFullscreenWindow) + if (PWORKSPACE->m_hasFullscreenWindow) return {.success = false, .error = "Can't split windows that already split"}; g_pLayoutManager->getCurrentLayout()->layoutMessage(header, "swapsplit"); @@ -1919,17 +1919,17 @@ SDispatchResult CKeybindManager::workspaceOpt(std::string args) { return {.success = false, .error = "Workspace not found"}; // ???? if (args == "allpseudo") { - PWORKSPACE->m_bDefaultPseudo = !PWORKSPACE->m_bDefaultPseudo; + PWORKSPACE->m_defaultPseudo = !PWORKSPACE->m_defaultPseudo; // apply for (auto const& w : g_pCompositor->m_windows) { if (!w->m_bIsMapped || w->m_pWorkspace != PWORKSPACE) continue; - w->m_bIsPseudotiled = PWORKSPACE->m_bDefaultPseudo; + w->m_bIsPseudotiled = PWORKSPACE->m_defaultPseudo; } } else if (args == "allfloat") { - PWORKSPACE->m_bDefaultFloating = !PWORKSPACE->m_bDefaultFloating; + PWORKSPACE->m_defaultFloating = !PWORKSPACE->m_defaultFloating; // apply // we make a copy because changeWindowFloatingMode might invalidate the iterator @@ -1939,14 +1939,14 @@ SDispatchResult CKeybindManager::workspaceOpt(std::string args) { if (!w->m_bIsMapped || w->m_pWorkspace != PWORKSPACE || w->isHidden()) continue; - if (!w->m_bRequestsFloat && w->m_bIsFloating != PWORKSPACE->m_bDefaultFloating) { + if (!w->m_bRequestsFloat && w->m_bIsFloating != PWORKSPACE->m_defaultFloating) { const auto SAVEDPOS = w->m_vRealPosition->goal(); const auto SAVEDSIZE = w->m_vRealSize->goal(); - w->m_bIsFloating = PWORKSPACE->m_bDefaultFloating; + w->m_bIsFloating = PWORKSPACE->m_defaultFloating; g_pLayoutManager->getCurrentLayout()->changeWindowFloatingMode(w); - if (PWORKSPACE->m_bDefaultFloating) { + if (PWORKSPACE->m_defaultFloating) { w->m_vRealPosition->setValueAndWarp(SAVEDPOS); w->m_vRealSize->setValueAndWarp(SAVEDSIZE); *w->m_vRealSize = w->m_vRealSize->value() + Vector2D(4, 4); @@ -2082,11 +2082,11 @@ SDispatchResult CKeybindManager::focusWorkspaceOnCurrentMonitor(std::string args if (!pWorkspace) pWorkspace = g_pCompositor->createNewWorkspace(PREVWS.id, PCURRMONITOR->ID, PREVWS.name); - workspaceID = pWorkspace->m_iID; + workspaceID = pWorkspace->m_id; } - if (pWorkspace->m_pMonitor != PCURRMONITOR) { - const auto POLDMONITOR = pWorkspace->m_pMonitor.lock(); + if (pWorkspace->m_monitor != PCURRMONITOR) { + const auto POLDMONITOR = pWorkspace->m_monitor.lock(); if (!POLDMONITOR) { // wat Debug::log(ERR, "focusWorkspaceOnCurrentMonitor old monitor doesn't exist!"); return {.success = false, .error = "focusWorkspaceOnCurrentMonitor old monitor doesn't exist!"}; @@ -2319,9 +2319,9 @@ SDispatchResult CKeybindManager::focusWindow(std::string regexp) { changeworkspace(PWORKSPACE->getConfigName()); } - if (PWORKSPACE->m_bHasFullscreenWindow) { + if (PWORKSPACE->m_hasFullscreenWindow) { const auto FSWINDOW = PWORKSPACE->getFullscreenWindow(); - const auto FSMODE = PWORKSPACE->m_efFullscreenMode; + const auto FSMODE = PWORKSPACE->m_fullscreenMode; if (PWINDOW->m_bIsFloating) { // don't make floating implicitly fs @@ -2775,7 +2775,7 @@ SDispatchResult CKeybindManager::pinActive(std::string args) { const auto PWORKSPACE = PWINDOW->m_pWorkspace; - PWORKSPACE->m_pLastFocusedWindow = g_pCompositor->vectorToWindowUnified(g_pInputManager->getMouseCoordsInternal(), RESERVED_EXTENTS | INPUT_EXTENTS); + PWORKSPACE->m_lastFocusedWindow = g_pCompositor->vectorToWindowUnified(g_pInputManager->getMouseCoordsInternal(), RESERVED_EXTENTS | INPUT_EXTENTS); g_pEventManager->postEvent(SHyprIPCEvent{"pin", std::format("{:x},{}", (uintptr_t)PWINDOW.get(), (int)PWINDOW->m_bPinned)}); EMIT_HOOK_EVENT("pin", PWINDOW); diff --git a/src/managers/PointerManager.cpp b/src/managers/PointerManager.cpp index d9e5c9f3..6a53001b 100644 --- a/src/managers/PointerManager.cpp +++ b/src/managers/PointerManager.cpp @@ -149,7 +149,7 @@ void CPointerManager::setCursorSurface(SP surf, const Vector2D& hots surf->resource()->map(); - currentCursorImage.destroySurface = surf->events.destroy.registerListener([this](std::any data) { resetCursorImage(); }); + currentCursorImage.destroySurface = surf->m_events.destroy.registerListener([this](std::any data) { resetCursorImage(); }); currentCursorImage.commitSurface = surf->resource()->events.commit.registerListener([this](std::any data) { damageIfSoftware(); currentCursorImage.size = currentCursorImage.surface->resource()->current.texture ? currentCursorImage.surface->resource()->current.bufferSize : Vector2D{}; diff --git a/src/managers/XWaylandManager.cpp b/src/managers/XWaylandManager.cpp index e33621c9..61820fe5 100644 --- a/src/managers/XWaylandManager.cpp +++ b/src/managers/XWaylandManager.cpp @@ -74,7 +74,7 @@ void CHyprXWaylandManager::activateWindow(PHLWINDOW pWindow, bool activate) { } if (!pWindow->m_bPinned) - pWindow->m_pWorkspace->m_pLastFocusedWindow = pWindow; + pWindow->m_pWorkspace->m_lastFocusedWindow = pWindow; } CBox CHyprXWaylandManager::getGeometryForWindow(PHLWINDOW pWindow) { diff --git a/src/managers/input/IdleInhibitor.cpp b/src/managers/input/IdleInhibitor.cpp index 4481002a..f0050381 100644 --- a/src/managers/input/IdleInhibitor.cpp +++ b/src/managers/input/IdleInhibitor.cpp @@ -24,7 +24,7 @@ void CInputManager::newIdleInhibitor(std::any inhibitor) { return; } - PINHIBIT->surfaceDestroyListener = WLSurface->events.destroy.registerListener( + PINHIBIT->surfaceDestroyListener = WLSurface->m_events.destroy.registerListener( [this, PINHIBIT](std::any data) { std::erase_if(m_vIdleInhibitors, [PINHIBIT](const auto& other) { return other.get() == PINHIBIT; }); }); recheckIdleInhibitorStatus(); diff --git a/src/managers/input/InputManager.cpp b/src/managers/input/InputManager.cpp index 4aadff96..c51b8e1c 100644 --- a/src/managers/input/InputManager.cpp +++ b/src/managers/input/InputManager.cpp @@ -338,12 +338,12 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) { // then, we check if the workspace doesnt have a fullscreen window const auto PWORKSPACE = PMONITOR->activeWorkspace; const auto PWINDOWIDEAL = g_pCompositor->vectorToWindowUnified(mouseCoords, RESERVED_EXTENTS | INPUT_EXTENTS | ALLOW_FLOATING); - if (PWORKSPACE->m_bHasFullscreenWindow && !foundSurface && PWORKSPACE->m_efFullscreenMode == FSMODE_FULLSCREEN) { + if (PWORKSPACE->m_hasFullscreenWindow && !foundSurface && PWORKSPACE->m_fullscreenMode == FSMODE_FULLSCREEN) { pFoundWindow = PWORKSPACE->getFullscreenWindow(); if (!pFoundWindow) { // what the fuck, somehow happens occasionally?? - PWORKSPACE->m_bHasFullscreenWindow = false; + PWORKSPACE->m_hasFullscreenWindow = false; return; } @@ -363,7 +363,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse) { // then windows if (!foundSurface) { - if (PWORKSPACE->m_bHasFullscreenWindow && PWORKSPACE->m_efFullscreenMode == FSMODE_MAXIMIZED) { + if (PWORKSPACE->m_hasFullscreenWindow && PWORKSPACE->m_fullscreenMode == FSMODE_MAXIMIZED) { if (!foundSurface) { if (PMONITOR->activeSpecialWorkspace) { if (pFoundWindow != PWINDOWIDEAL) diff --git a/src/managers/input/Swipe.cpp b/src/managers/input/Swipe.cpp index 76119aab..c6916ee0 100644 --- a/src/managers/input/Swipe.cpp +++ b/src/managers/input/Swipe.cpp @@ -18,7 +18,7 @@ void CInputManager::onSwipeBegin(IPointer::SSwipeBeginEvent e) { int onMonitor = 0; for (auto const& w : g_pCompositor->m_workspaces) { - if (w->m_pMonitor == g_pCompositor->m_lastMonitor && !g_pCompositor->isWorkspaceSpecial(w->m_iID)) + if (w->m_monitor == g_pCompositor->m_lastMonitor && !g_pCompositor->isWorkspaceSpecial(w->m_id)) onMonitor++; } @@ -31,7 +31,7 @@ void CInputManager::onSwipeBegin(IPointer::SSwipeBeginEvent e) { void CInputManager::beginWorkspaceSwipe() { const auto PWORKSPACE = g_pCompositor->m_lastMonitor->activeWorkspace; - Debug::log(LOG, "Starting a swipe from {}", PWORKSPACE->m_szName); + Debug::log(LOG, "Starting a swipe from {}", PWORKSPACE->m_name); m_sActiveSwipe.pWorkspaceBegin = PWORKSPACE; m_sActiveSwipe.delta = 0; @@ -39,7 +39,7 @@ void CInputManager::beginWorkspaceSwipe() { m_sActiveSwipe.avgSpeed = 0; m_sActiveSwipe.speedPoints = 0; - if (PWORKSPACE->m_bHasFullscreenWindow) { + if (PWORKSPACE->m_hasFullscreenWindow) { for (auto const& ls : g_pCompositor->m_lastMonitor->m_aLayerSurfaceLayers[2]) { *ls->m_alpha = 1.f; } @@ -61,7 +61,7 @@ void CInputManager::endWorkspaceSwipe() { static auto PSWIPENEW = CConfigValue("gestures:workspace_swipe_create_new"); static auto PSWIPEUSER = CConfigValue("gestures:workspace_swipe_use_r"); static auto PWORKSPACEGAP = CConfigValue("general:gaps_workspaces"); - const auto ANIMSTYLE = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->getStyle(); + const auto ANIMSTYLE = m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->getStyle(); const bool VERTANIMS = ANIMSTYLE == "slidevert" || ANIMSTYLE.starts_with("slidefadevert"); // commit @@ -71,14 +71,14 @@ void CInputManager::endWorkspaceSwipe() { // If we've been swiping off the right end with PSWIPENEW enabled, there is // no workspace there yet, and we need to choose an ID for a new one now. - if (workspaceIDRight <= m_sActiveSwipe.pWorkspaceBegin->m_iID && *PSWIPENEW) { + if (workspaceIDRight <= m_sActiveSwipe.pWorkspaceBegin->m_id && *PSWIPENEW) { workspaceIDRight = getWorkspaceIDNameFromString("r+1").id; } auto PWORKSPACER = g_pCompositor->getWorkspaceByID(workspaceIDRight); // not guaranteed if PSWIPENEW || PSWIPENUMBER auto PWORKSPACEL = g_pCompositor->getWorkspaceByID(workspaceIDLeft); // not guaranteed if PSWIPENUMBER - const auto RENDEROFFSETMIDDLE = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->value(); + const auto RENDEROFFSETMIDDLE = m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->value(); const auto XDISTANCE = m_sActiveSwipe.pMonitor->vecSize.x + *PWORKSPACEGAP; const auto YDISTANCE = m_sActiveSwipe.pMonitor->vecSize.y + *PWORKSPACEGAP; @@ -89,35 +89,35 @@ void CInputManager::endWorkspaceSwipe() { // revert if (abs(m_sActiveSwipe.delta) < 2) { if (PWORKSPACEL) - PWORKSPACEL->m_vRenderOffset->setValueAndWarp(Vector2D(0, 0)); + PWORKSPACEL->m_renderOffset->setValueAndWarp(Vector2D(0, 0)); if (PWORKSPACER) - PWORKSPACER->m_vRenderOffset->setValueAndWarp(Vector2D(0, 0)); - m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(0, 0)); + PWORKSPACER->m_renderOffset->setValueAndWarp(Vector2D(0, 0)); + m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->setValueAndWarp(Vector2D(0, 0)); } else { if (m_sActiveSwipe.delta < 0) { // to left if (PWORKSPACEL) { if (VERTANIMS) - *PWORKSPACEL->m_vRenderOffset = Vector2D{0.0, -YDISTANCE}; + *PWORKSPACEL->m_renderOffset = Vector2D{0.0, -YDISTANCE}; else - *PWORKSPACEL->m_vRenderOffset = Vector2D{-XDISTANCE, 0.0}; + *PWORKSPACEL->m_renderOffset = Vector2D{-XDISTANCE, 0.0}; } } else if (PWORKSPACER) { // to right if (VERTANIMS) - *PWORKSPACER->m_vRenderOffset = Vector2D{0.0, YDISTANCE}; + *PWORKSPACER->m_renderOffset = Vector2D{0.0, YDISTANCE}; else - *PWORKSPACER->m_vRenderOffset = Vector2D{XDISTANCE, 0.0}; + *PWORKSPACER->m_renderOffset = Vector2D{XDISTANCE, 0.0}; } - *m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(); + *m_sActiveSwipe.pWorkspaceBegin->m_renderOffset = Vector2D(); } pSwitchedTo = m_sActiveSwipe.pWorkspaceBegin; } else if (m_sActiveSwipe.delta < 0) { // switch to left - const auto RENDEROFFSET = PWORKSPACEL ? PWORKSPACEL->m_vRenderOffset->value() : Vector2D(); + const auto RENDEROFFSET = PWORKSPACEL ? PWORKSPACEL->m_renderOffset->value() : Vector2D(); if (PWORKSPACEL) m_sActiveSwipe.pMonitor->changeWorkspace(workspaceIDLeft); @@ -127,15 +127,15 @@ void CInputManager::endWorkspaceSwipe() { PWORKSPACEL->rememberPrevWorkspace(m_sActiveSwipe.pWorkspaceBegin); } - PWORKSPACEL->m_vRenderOffset->setValue(RENDEROFFSET); - PWORKSPACEL->m_fAlpha->setValueAndWarp(1.f); + PWORKSPACEL->m_renderOffset->setValue(RENDEROFFSET); + PWORKSPACEL->m_alpha->setValueAndWarp(1.f); - m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValue(RENDEROFFSETMIDDLE); + m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->setValue(RENDEROFFSETMIDDLE); if (VERTANIMS) - *m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(0.0, YDISTANCE); + *m_sActiveSwipe.pWorkspaceBegin->m_renderOffset = Vector2D(0.0, YDISTANCE); else - *m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(XDISTANCE, 0.0); - m_sActiveSwipe.pWorkspaceBegin->m_fAlpha->setValueAndWarp(1.f); + *m_sActiveSwipe.pWorkspaceBegin->m_renderOffset = Vector2D(XDISTANCE, 0.0); + m_sActiveSwipe.pWorkspaceBegin->m_alpha->setValueAndWarp(1.f); g_pInputManager->unconstrainMouse(); @@ -144,7 +144,7 @@ void CInputManager::endWorkspaceSwipe() { pSwitchedTo = PWORKSPACEL; } else { // switch to right - const auto RENDEROFFSET = PWORKSPACER ? PWORKSPACER->m_vRenderOffset->value() : Vector2D(); + const auto RENDEROFFSET = PWORKSPACER ? PWORKSPACER->m_renderOffset->value() : Vector2D(); if (PWORKSPACER) m_sActiveSwipe.pMonitor->changeWorkspace(workspaceIDRight); @@ -154,15 +154,15 @@ void CInputManager::endWorkspaceSwipe() { PWORKSPACER->rememberPrevWorkspace(m_sActiveSwipe.pWorkspaceBegin); } - PWORKSPACER->m_vRenderOffset->setValue(RENDEROFFSET); - PWORKSPACER->m_fAlpha->setValueAndWarp(1.f); + PWORKSPACER->m_renderOffset->setValue(RENDEROFFSET); + PWORKSPACER->m_alpha->setValueAndWarp(1.f); - m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValue(RENDEROFFSETMIDDLE); + m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->setValue(RENDEROFFSETMIDDLE); if (VERTANIMS) - *m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(0.0, -YDISTANCE); + *m_sActiveSwipe.pWorkspaceBegin->m_renderOffset = Vector2D(0.0, -YDISTANCE); else - *m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset = Vector2D(-XDISTANCE, 0.0); - m_sActiveSwipe.pWorkspaceBegin->m_fAlpha->setValueAndWarp(1.f); + *m_sActiveSwipe.pWorkspaceBegin->m_renderOffset = Vector2D(-XDISTANCE, 0.0); + m_sActiveSwipe.pWorkspaceBegin->m_alpha->setValueAndWarp(1.f); g_pInputManager->unconstrainMouse(); @@ -175,10 +175,10 @@ void CInputManager::endWorkspaceSwipe() { g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor.lock()); if (PWORKSPACEL) - PWORKSPACEL->m_bForceRendering = false; + PWORKSPACEL->m_forceRendering = false; if (PWORKSPACER) - PWORKSPACER->m_bForceRendering = false; - m_sActiveSwipe.pWorkspaceBegin->m_bForceRendering = false; + PWORKSPACER->m_forceRendering = false; + m_sActiveSwipe.pWorkspaceBegin->m_forceRendering = false; m_sActiveSwipe.pWorkspaceBegin = nullptr; m_sActiveSwipe.initialDirection = 0; @@ -187,7 +187,7 @@ void CInputManager::endWorkspaceSwipe() { // apply alpha for (auto const& ls : g_pCompositor->m_lastMonitor->m_aLayerSurfaceLayers[2]) { - *ls->m_alpha = pSwitchedTo->m_bHasFullscreenWindow && pSwitchedTo->m_efFullscreenMode == FSMODE_FULLSCREEN ? 0.f : 1.f; + *ls->m_alpha = pSwitchedTo->m_hasFullscreenWindow && pSwitchedTo->m_fullscreenMode == FSMODE_FULLSCREEN ? 0.f : 1.f; } } @@ -197,7 +197,7 @@ void CInputManager::onSwipeUpdate(IPointer::SSwipeUpdateEvent e) { if (!m_sActiveSwipe.pWorkspaceBegin) return; static auto PSWIPEINVR = CConfigValue("gestures:workspace_swipe_invert"); - const auto ANIMSTYLE = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->getStyle(); + const auto ANIMSTYLE = m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->getStyle(); const bool VERTANIMS = ANIMSTYLE == "slidevert" || ANIMSTYLE.starts_with("slidefadevert"); const double delta = m_sActiveSwipe.delta + (VERTANIMS ? (*PSWIPEINVR ? -e.delta.y : e.delta.y) : (*PSWIPEINVR ? -e.delta.x : e.delta.x)); @@ -216,7 +216,7 @@ void CInputManager::updateWorkspaceSwipe(double delta) { const auto SWIPEDISTANCE = std::clamp(*PSWIPEDIST, (int64_t)1LL, (int64_t)UINT32_MAX); const auto XDISTANCE = m_sActiveSwipe.pMonitor->vecSize.x + *PWORKSPACEGAP; const auto YDISTANCE = m_sActiveSwipe.pMonitor->vecSize.y + *PWORKSPACEGAP; - const auto ANIMSTYLE = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->getStyle(); + const auto ANIMSTYLE = m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->getStyle(); const bool VERTANIMS = ANIMSTYLE == "slidevert" || ANIMSTYLE.starts_with("slidefadevert"); const double d = m_sActiveSwipe.delta - delta; m_sActiveSwipe.delta = delta; @@ -227,18 +227,18 @@ void CInputManager::updateWorkspaceSwipe(double delta) { auto workspaceIDLeft = getWorkspaceIDNameFromString((*PSWIPEUSER ? "r-1" : "m-1")).id; auto workspaceIDRight = getWorkspaceIDNameFromString((*PSWIPEUSER ? "r+1" : "m+1")).id; - if ((workspaceIDLeft == WORKSPACE_INVALID || workspaceIDRight == WORKSPACE_INVALID || workspaceIDLeft == m_sActiveSwipe.pWorkspaceBegin->m_iID) && !*PSWIPENEW) { + if ((workspaceIDLeft == WORKSPACE_INVALID || workspaceIDRight == WORKSPACE_INVALID || workspaceIDLeft == m_sActiveSwipe.pWorkspaceBegin->m_id) && !*PSWIPENEW) { m_sActiveSwipe.pWorkspaceBegin = nullptr; // invalidate the swipe return; } - m_sActiveSwipe.pWorkspaceBegin->m_bForceRendering = true; + m_sActiveSwipe.pWorkspaceBegin->m_forceRendering = true; m_sActiveSwipe.delta = std::clamp(m_sActiveSwipe.delta, (double)-SWIPEDISTANCE, (double)SWIPEDISTANCE); - if ((m_sActiveSwipe.pWorkspaceBegin->m_iID == workspaceIDLeft && *PSWIPENEW && (m_sActiveSwipe.delta < 0)) || - (m_sActiveSwipe.delta > 0 && m_sActiveSwipe.pWorkspaceBegin->getWindows() == 0 && workspaceIDRight <= m_sActiveSwipe.pWorkspaceBegin->m_iID) || - (m_sActiveSwipe.delta < 0 && m_sActiveSwipe.pWorkspaceBegin->m_iID <= workspaceIDLeft)) { + if ((m_sActiveSwipe.pWorkspaceBegin->m_id == workspaceIDLeft && *PSWIPENEW && (m_sActiveSwipe.delta < 0)) || + (m_sActiveSwipe.delta > 0 && m_sActiveSwipe.pWorkspaceBegin->getWindows() == 0 && workspaceIDRight <= m_sActiveSwipe.pWorkspaceBegin->m_id) || + (m_sActiveSwipe.delta < 0 && m_sActiveSwipe.pWorkspaceBegin->m_id <= workspaceIDLeft)) { m_sActiveSwipe.delta = 0; return; @@ -254,14 +254,14 @@ void CInputManager::updateWorkspaceSwipe(double delta) { if (m_sActiveSwipe.delta < 0) { const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(workspaceIDLeft); - if (workspaceIDLeft > m_sActiveSwipe.pWorkspaceBegin->m_iID || !PWORKSPACE) { + if (workspaceIDLeft > m_sActiveSwipe.pWorkspaceBegin->m_id || !PWORKSPACE) { if (*PSWIPENEW) { g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor.lock()); if (VERTANIMS) - m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE)); + m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE)); else - m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE, 0.0)); + m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE, 0.0)); m_sActiveSwipe.pWorkspaceBegin->updateWindowDecos(); return; @@ -270,38 +270,38 @@ void CInputManager::updateWorkspaceSwipe(double delta) { return; } - PWORKSPACE->m_bForceRendering = true; - PWORKSPACE->m_fAlpha->setValueAndWarp(1.f); + PWORKSPACE->m_forceRendering = true; + PWORKSPACE->m_alpha->setValueAndWarp(1.f); - if (workspaceIDLeft != workspaceIDRight && workspaceIDRight != m_sActiveSwipe.pWorkspaceBegin->m_iID) { + if (workspaceIDLeft != workspaceIDRight && workspaceIDRight != m_sActiveSwipe.pWorkspaceBegin->m_id) { const auto PWORKSPACER = g_pCompositor->getWorkspaceByID(workspaceIDRight); if (PWORKSPACER) { - PWORKSPACER->m_bForceRendering = false; - PWORKSPACER->m_fAlpha->setValueAndWarp(0.f); + PWORKSPACER->m_forceRendering = false; + PWORKSPACER->m_alpha->setValueAndWarp(0.f); } } if (VERTANIMS) { - PWORKSPACE->m_vRenderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE - YDISTANCE)); - m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE)); + PWORKSPACE->m_renderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE - YDISTANCE)); + m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE)); } else { - PWORKSPACE->m_vRenderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE - XDISTANCE, 0.0)); - m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE, 0.0)); + PWORKSPACE->m_renderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE - XDISTANCE, 0.0)); + m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE, 0.0)); } PWORKSPACE->updateWindowDecos(); } else { const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(workspaceIDRight); - if (workspaceIDRight < m_sActiveSwipe.pWorkspaceBegin->m_iID || !PWORKSPACE) { + if (workspaceIDRight < m_sActiveSwipe.pWorkspaceBegin->m_id || !PWORKSPACE) { if (*PSWIPENEW) { g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor.lock()); if (VERTANIMS) - m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE)); + m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE)); else - m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE, 0.0)); + m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE, 0.0)); m_sActiveSwipe.pWorkspaceBegin->updateWindowDecos(); return; @@ -310,24 +310,24 @@ void CInputManager::updateWorkspaceSwipe(double delta) { return; } - PWORKSPACE->m_bForceRendering = true; - PWORKSPACE->m_fAlpha->setValueAndWarp(1.f); + PWORKSPACE->m_forceRendering = true; + PWORKSPACE->m_alpha->setValueAndWarp(1.f); - if (workspaceIDLeft != workspaceIDRight && workspaceIDLeft != m_sActiveSwipe.pWorkspaceBegin->m_iID) { + if (workspaceIDLeft != workspaceIDRight && workspaceIDLeft != m_sActiveSwipe.pWorkspaceBegin->m_id) { const auto PWORKSPACEL = g_pCompositor->getWorkspaceByID(workspaceIDLeft); if (PWORKSPACEL) { - PWORKSPACEL->m_bForceRendering = false; - PWORKSPACEL->m_fAlpha->setValueAndWarp(0.f); + PWORKSPACEL->m_forceRendering = false; + PWORKSPACEL->m_alpha->setValueAndWarp(0.f); } } if (VERTANIMS) { - PWORKSPACE->m_vRenderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE + YDISTANCE)); - m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE)); + PWORKSPACE->m_renderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE + YDISTANCE)); + m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->setValueAndWarp(Vector2D(0.0, ((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * YDISTANCE)); } else { - PWORKSPACE->m_vRenderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE + XDISTANCE, 0.0)); - m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE, 0.0)); + PWORKSPACE->m_renderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE + XDISTANCE, 0.0)); + m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / SWIPEDISTANCE) * XDISTANCE, 0.0)); } PWORKSPACE->updateWindowDecos(); diff --git a/src/managers/input/Touch.cpp b/src/managers/input/Touch.cpp index 5a030335..a5d53029 100644 --- a/src/managers/input/Touch.cpp +++ b/src/managers/input/Touch.cpp @@ -44,7 +44,7 @@ void CInputManager::onTouchDown(ITouch::SDownEvent e) { // TODO: Don't swipe if you touched a floating window. } else if (*PSWIPETOUCH && (m_pFoundLSToFocus.expired() || m_pFoundLSToFocus->m_layer <= 1) && !g_pSessionLockManager->isSessionLocked()) { const auto PWORKSPACE = PMONITOR->activeWorkspace; - const auto STYLE = PWORKSPACE->m_vRenderOffset->getStyle(); + const auto STYLE = PWORKSPACE->m_renderOffset->getStyle(); 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 TARGETRIGHT = 1 - (((VERTANIMS ? gapsOut.m_bottom : gapsOut.m_right) + *PBORDERSIZE) / (VERTANIMS ? PMONITOR->vecSize.y : PMONITOR->vecSize.x)); @@ -121,7 +121,7 @@ void CInputManager::onTouchMove(ITouch::SMotionEvent e) { if (e.touchID != m_sActiveSwipe.touch_id) return; - const auto ANIMSTYLE = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset->getStyle(); + const auto ANIMSTYLE = m_sActiveSwipe.pWorkspaceBegin->m_renderOffset->getStyle(); const bool VERTANIMS = ANIMSTYLE == "slidevert" || ANIMSTYLE.starts_with("slidefadevert"); static auto PSWIPEINVR = CConfigValue("gestures:workspace_swipe_touch_invert"); static auto PSWIPEDIST = CConfigValue("gestures:workspace_swipe_distance"); diff --git a/src/protocols/AlphaModifier.cpp b/src/protocols/AlphaModifier.cpp index 60037632..3fea51fe 100644 --- a/src/protocols/AlphaModifier.cpp +++ b/src/protocols/AlphaModifier.cpp @@ -33,9 +33,9 @@ void CAlphaModifier::setResource(SP resource) { listeners.surfaceCommitted = m_pSurface->events.commit.registerListener([this](std::any data) { auto surface = CWLSurface::fromResource(m_pSurface.lock()); - if (surface && surface->m_fAlphaModifier != m_fAlpha) { - surface->m_fAlphaModifier = m_fAlpha; - auto box = surface->getSurfaceBoxGlobal(); + if (surface && surface->m_alphaModifier != m_fAlpha) { + surface->m_alphaModifier = m_fAlpha; + auto box = surface->getSurfaceBoxGlobal(); if (box.has_value()) g_pHyprRenderer->damageBox(*box); diff --git a/src/protocols/HyprlandSurface.cpp b/src/protocols/HyprlandSurface.cpp index 8b65f0fa..cdf6d722 100644 --- a/src/protocols/HyprlandSurface.cpp +++ b/src/protocols/HyprlandSurface.cpp @@ -54,10 +54,10 @@ void CHyprlandSurface::setResource(SP resource) { listeners.surfaceCommitted = m_pSurface->events.commit.registerListener([this](std::any data) { auto surface = CWLSurface::fromResource(m_pSurface.lock()); - if (surface && (surface->m_fOverallOpacity != m_fOpacity || m_bVisibleRegionChanged)) { - surface->m_fOverallOpacity = m_fOpacity; - surface->m_visibleRegion = m_visibleRegion; - auto box = surface->getSurfaceBoxGlobal(); + if (surface && (surface->m_overallOpacity != m_fOpacity || m_bVisibleRegionChanged)) { + surface->m_overallOpacity = m_fOpacity; + surface->m_visibleRegion = m_visibleRegion; + auto box = surface->getSurfaceBoxGlobal(); if (box.has_value()) g_pHyprRenderer->damageBox(*box); diff --git a/src/protocols/PointerConstraints.cpp b/src/protocols/PointerConstraints.cpp index b4868b56..c25dfdee 100644 --- a/src/protocols/PointerConstraints.cpp +++ b/src/protocols/PointerConstraints.cpp @@ -75,12 +75,12 @@ CPointerConstraint::~CPointerConstraint() { }); if (pHLSurface) - pHLSurface->m_pConstraint.reset(); + pHLSurface->m_constraint.reset(); } void CPointerConstraint::sharedConstructions() { if (pHLSurface) { - listeners.destroySurface = pHLSurface->events.destroy.registerListener([this](std::any d) { + listeners.destroySurface = pHLSurface->m_events.destroy.registerListener([this](std::any d) { pHLSurface.reset(); if (active) deactivate(); diff --git a/src/render/OpenGL.cpp b/src/render/OpenGL.cpp index 0349cac1..bc606c8d 100644 --- a/src/render/OpenGL.cpp +++ b/src/render/OpenGL.cpp @@ -1558,8 +1558,8 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP tex, const CB const bool skipCM = !*PENABLECM || !m_bCMSupported /* CM unsupported or disabled */ || (imageDescription == m_RenderData.pMonitor->imageDescription) /* Source and target have the same image description */ || ((*PPASS == 1 || (*PPASS == 2 && imageDescription.transferFunction == CM_TRANSFER_FUNCTION_ST2084_PQ)) && m_RenderData.pMonitor->activeWorkspace && - m_RenderData.pMonitor->activeWorkspace->m_bHasFullscreenWindow && - m_RenderData.pMonitor->activeWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN) /* Fullscreen window with pass cm enabled */; + m_RenderData.pMonitor->activeWorkspace->m_hasFullscreenWindow && + m_RenderData.pMonitor->activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) /* Fullscreen window with pass cm enabled */; if (!skipCM && !usingFinalShader && (texType == TEXTURE_RGBA || texType == TEXTURE_RGBX)) shader = &m_shaders->m_shCM; @@ -2057,13 +2057,13 @@ void CHyprOpenGLImpl::preRender(PHLMONITOR pMonitor) { if (pWindow->m_sWindowData.noBlur.valueOrDefault()) return false; - if (pWindow->m_pWLSurface->small() && !pWindow->m_pWLSurface->m_bFillIgnoreSmall) + if (pWindow->m_pWLSurface->small() && !pWindow->m_pWLSurface->m_fillIgnoreSmall) return true; const auto PSURFACE = pWindow->m_pWLSurface->resource(); const auto PWORKSPACE = pWindow->m_pWorkspace; - const float A = pWindow->m_fAlpha->value() * pWindow->m_fActiveInactiveAlpha->value() * PWORKSPACE->m_fAlpha->value(); + const float A = pWindow->m_fAlpha->value() * pWindow->m_fActiveInactiveAlpha->value() * PWORKSPACE->m_alpha->value(); if (A >= 1.f) { // if (PSURFACE->opaque) diff --git a/src/render/Renderer.cpp b/src/render/Renderer.cpp index bf93d072..364f7fde 100644 --- a/src/render/Renderer.cpp +++ b/src/render/Renderer.cpp @@ -188,16 +188,16 @@ bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor) { return true; const auto PWINDOWWORKSPACE = pWindow->m_pWorkspace; - if (PWINDOWWORKSPACE && PWINDOWWORKSPACE->m_pMonitor == pMonitor) { - if (PWINDOWWORKSPACE->m_vRenderOffset->isBeingAnimated() || PWINDOWWORKSPACE->m_fAlpha->isBeingAnimated() || PWINDOWWORKSPACE->m_bForceRendering) + if (PWINDOWWORKSPACE && PWINDOWWORKSPACE->m_monitor == pMonitor) { + if (PWINDOWWORKSPACE->m_renderOffset->isBeingAnimated() || PWINDOWWORKSPACE->m_alpha->isBeingAnimated() || PWINDOWWORKSPACE->m_forceRendering) return true; // if hidden behind fullscreen - if (PWINDOWWORKSPACE->m_bHasFullscreenWindow && !pWindow->isFullscreen() && (!pWindow->m_bIsFloating || !pWindow->m_bCreatedOverFullscreen) && + if (PWINDOWWORKSPACE->m_hasFullscreenWindow && !pWindow->isFullscreen() && (!pWindow->m_bIsFloating || !pWindow->m_bCreatedOverFullscreen) && pWindow->m_fAlpha->value() == 0) return false; - if (!PWINDOWWORKSPACE->m_vRenderOffset->isBeingAnimated() && !PWINDOWWORKSPACE->m_fAlpha->isBeingAnimated() && !PWINDOWWORKSPACE->isVisible()) + if (!PWINDOWWORKSPACE->m_renderOffset->isBeingAnimated() && !PWINDOWWORKSPACE->m_alpha->isBeingAnimated() && !PWINDOWWORKSPACE->isVisible()) return false; } @@ -219,13 +219,13 @@ bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor) { return false; if (pWindow->m_vRealPosition->isBeingAnimated()) { - if (PWINDOWWORKSPACE && !PWINDOWWORKSPACE->m_bIsSpecialWorkspace && PWINDOWWORKSPACE->m_vRenderOffset->isBeingAnimated()) + if (PWINDOWWORKSPACE && !PWINDOWWORKSPACE->m_isSpecialWorkspace && PWINDOWWORKSPACE->m_renderOffset->isBeingAnimated()) return false; // render window if window and monitor intersect // (when moving out of or through a monitor) CBox windowBox = pWindow->getFullWindowBoundingBox(); - if (PWINDOWWORKSPACE && PWINDOWWORKSPACE->m_vRenderOffset->isBeingAnimated()) - windowBox.translate(PWINDOWWORKSPACE->m_vRenderOffset->value()); + if (PWINDOWWORKSPACE && PWINDOWWORKSPACE->m_renderOffset->isBeingAnimated()) + windowBox.translate(PWINDOWWORKSPACE->m_renderOffset->value()); windowBox.translate(pWindow->m_vFloatingOffset); const CBox monitorBox = {pMonitor->vecPosition, pMonitor->vecSize}; @@ -246,14 +246,14 @@ bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow) { if (!pWindow->m_pWorkspace) return false; - if (pWindow->m_bPinned || PWORKSPACE->m_bForceRendering) + if (pWindow->m_bPinned || PWORKSPACE->m_forceRendering) return true; if (PWORKSPACE && PWORKSPACE->isVisible()) return true; for (auto const& m : g_pCompositor->m_monitors) { - if (PWORKSPACE && PWORKSPACE->m_pMonitor == m && (PWORKSPACE->m_vRenderOffset->isBeingAnimated() || PWORKSPACE->m_fAlpha->isBeingAnimated())) + if (PWORKSPACE && PWORKSPACE->m_monitor == m && (PWORKSPACE->m_renderOffset->isBeingAnimated() || PWORKSPACE->m_alpha->isBeingAnimated())) return true; if (m->activeSpecialWorkspace && pWindow->onSpecialWorkspace()) @@ -279,7 +279,7 @@ void CHyprRenderer::renderWorkspaceWindowsFullscreen(PHLMONITOR pMonitor, PHLWOR if (w->isFullscreen() || w->m_bIsFloating) continue; - if (pWorkspace->m_bIsSpecialWorkspace != w->onSpecialWorkspace()) + if (pWorkspace->m_isSpecialWorkspace != w->onSpecialWorkspace()) continue; renderWindow(w, pMonitor, time, true, RENDER_PASS_ALL); @@ -296,10 +296,10 @@ void CHyprRenderer::renderWorkspaceWindowsFullscreen(PHLMONITOR pMonitor, PHLWOR if (w->isFullscreen() || !w->m_bIsFloating) continue; - if (w->m_pMonitor == pWorkspace->m_pMonitor && pWorkspace->m_bIsSpecialWorkspace != w->onSpecialWorkspace()) + if (w->m_pMonitor == pWorkspace->m_monitor && pWorkspace->m_isSpecialWorkspace != w->onSpecialWorkspace()) continue; - if (pWorkspace->m_bIsSpecialWorkspace && w->m_pMonitor != pWorkspace->m_pMonitor) + if (pWorkspace->m_isSpecialWorkspace && w->m_pMonitor != pWorkspace->m_monitor) continue; // special on another are rendered as a part of the base pass renderWindow(w, pMonitor, time, true, RENDER_PASS_ALL); @@ -310,7 +310,7 @@ void CHyprRenderer::renderWorkspaceWindowsFullscreen(PHLMONITOR pMonitor, PHLWOR const auto PWORKSPACE = w->m_pWorkspace; if (w->m_pWorkspace != pWorkspace || !w->isFullscreen()) { - if (!(PWORKSPACE && (PWORKSPACE->m_vRenderOffset->isBeingAnimated() || PWORKSPACE->m_fAlpha->isBeingAnimated() || PWORKSPACE->m_bForceRendering))) + if (!(PWORKSPACE && (PWORKSPACE->m_renderOffset->isBeingAnimated() || PWORKSPACE->m_alpha->isBeingAnimated() || PWORKSPACE->m_forceRendering))) continue; if (w->m_pMonitor != pMonitor) @@ -320,11 +320,11 @@ void CHyprRenderer::renderWorkspaceWindowsFullscreen(PHLMONITOR pMonitor, PHLWOR if (!w->isFullscreen()) continue; - if (w->m_pMonitor == pWorkspace->m_pMonitor && pWorkspace->m_bIsSpecialWorkspace != w->onSpecialWorkspace()) + if (w->m_pMonitor == pWorkspace->m_monitor && pWorkspace->m_isSpecialWorkspace != w->onSpecialWorkspace()) continue; if (shouldRenderWindow(w, pMonitor)) - renderWindow(w, pMonitor, time, pWorkspace->m_efFullscreenMode != FSMODE_FULLSCREEN, RENDER_PASS_ALL); + renderWindow(w, pMonitor, time, pWorkspace->m_fullscreenMode != FSMODE_FULLSCREEN, RENDER_PASS_ALL); if (w->m_pWorkspace != pWorkspace) continue; @@ -334,7 +334,7 @@ void CHyprRenderer::renderWorkspaceWindowsFullscreen(PHLMONITOR pMonitor, PHLWOR if (!pWorkspaceWindow) { // ?? happens sometimes... - pWorkspace->m_bHasFullscreenWindow = false; + pWorkspace->m_hasFullscreenWindow = false; return; // this will produce one blank frame. Oh well. } @@ -344,10 +344,10 @@ void CHyprRenderer::renderWorkspaceWindowsFullscreen(PHLMONITOR pMonitor, PHLWOR w->isFullscreen()) continue; - if (w->m_pMonitor == pWorkspace->m_pMonitor && pWorkspace->m_bIsSpecialWorkspace != w->onSpecialWorkspace()) + if (w->m_pMonitor == pWorkspace->m_monitor && pWorkspace->m_isSpecialWorkspace != w->onSpecialWorkspace()) continue; - if (pWorkspace->m_bIsSpecialWorkspace && w->m_pMonitor != pWorkspace->m_pMonitor) + if (pWorkspace->m_isSpecialWorkspace && w->m_pMonitor != pWorkspace->m_monitor) continue; // special on another are rendered as a part of the base pass renderWindow(w, pMonitor, time, true, RENDER_PASS_ALL); @@ -380,7 +380,7 @@ void CHyprRenderer::renderWorkspaceWindows(PHLMONITOR pMonitor, PHLWORKSPACE pWo // some things may force us to ignore the special/not special disparity const bool IGNORE_SPECIAL_CHECK = w->m_iMonitorMovedFrom != -1 && (w->m_pWorkspace && !w->m_pWorkspace->isVisible()); - if (!IGNORE_SPECIAL_CHECK && pWorkspace->m_bIsSpecialWorkspace != w->onSpecialWorkspace()) + if (!IGNORE_SPECIAL_CHECK && pWorkspace->m_isSpecialWorkspace != w->onSpecialWorkspace()) continue; // render active window after all others of this pass @@ -422,7 +422,7 @@ void CHyprRenderer::renderWorkspaceWindows(PHLMONITOR pMonitor, PHLWORKSPACE pWo // some things may force us to ignore the special/not special disparity const bool IGNORE_SPECIAL_CHECK = w->m_iMonitorMovedFrom != -1 && (w->m_pWorkspace && !w->m_pWorkspace->isVisible()); - if (!IGNORE_SPECIAL_CHECK && pWorkspace->m_bIsSpecialWorkspace != w->onSpecialWorkspace()) + if (!IGNORE_SPECIAL_CHECK && pWorkspace->m_isSpecialWorkspace != w->onSpecialWorkspace()) continue; // render the bad boy @@ -441,10 +441,10 @@ void CHyprRenderer::renderWorkspaceWindows(PHLMONITOR pMonitor, PHLWORKSPACE pWo // some things may force us to ignore the special/not special disparity const bool IGNORE_SPECIAL_CHECK = w->m_iMonitorMovedFrom != -1 && (w->m_pWorkspace && !w->m_pWorkspace->isVisible()); - if (!IGNORE_SPECIAL_CHECK && pWorkspace->m_bIsSpecialWorkspace != w->onSpecialWorkspace()) + if (!IGNORE_SPECIAL_CHECK && pWorkspace->m_isSpecialWorkspace != w->onSpecialWorkspace()) continue; - if (pWorkspace->m_bIsSpecialWorkspace && w->m_pMonitor != pWorkspace->m_pMonitor) + if (pWorkspace->m_isSpecialWorkspace && w->m_pMonitor != pWorkspace->m_monitor) continue; // special on another are rendered as a part of the base pass // render the bad boy @@ -468,7 +468,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T TRACY_GPU_ZONE("RenderWindow"); const auto PWORKSPACE = pWindow->m_pWorkspace; - const auto REALPOS = pWindow->m_vRealPosition->value() + (pWindow->m_bPinned ? Vector2D{} : PWORKSPACE->m_vRenderOffset->value()); + const auto REALPOS = pWindow->m_vRealPosition->value() + (pWindow->m_bPinned ? Vector2D{} : PWORKSPACE->m_renderOffset->value()); static auto PDIMAROUND = CConfigValue("decoration:dim_around"); static auto PBLUR = CConfigValue("decoration:blur:enabled"); @@ -500,7 +500,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T renderdata.surface = pWindow->m_pWLSurface->resource(); renderdata.dontRound = pWindow->isEffectiveInternalFSMode(FSMODE_FULLSCREEN) || pWindow->m_sWindowData.noRounding.valueOrDefault(); - renderdata.fadeAlpha = pWindow->m_fAlpha->value() * (pWindow->m_bPinned || USE_WORKSPACE_FADE_ALPHA ? 1.f : PWORKSPACE->m_fAlpha->value()) * + renderdata.fadeAlpha = pWindow->m_fAlpha->value() * (pWindow->m_bPinned || USE_WORKSPACE_FADE_ALPHA ? 1.f : PWORKSPACE->m_alpha->value()) * (USE_WORKSPACE_FADE_ALPHA ? pWindow->m_fMovingToWorkspaceAlpha->value() : 1.F) * pWindow->m_fMovingFromWorkspaceAlpha->value(); renderdata.alpha = pWindow->m_fActiveInactiveAlpha->value(); renderdata.decorate = decorate && !pWindow->m_bX11DoesntWantBorders && !pWindow->isEffectiveInternalFSMode(FSMODE_FULLSCREEN); @@ -534,9 +534,9 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T renderdata.pos.y += pWindow->m_vFloatingOffset.y; // if window is floating and we have a slide animation, clip it to its full bb - if (!ignorePosition && pWindow->m_bIsFloating && !pWindow->isFullscreen() && PWORKSPACE->m_vRenderOffset->isBeingAnimated() && !pWindow->m_bPinned) { + if (!ignorePosition && pWindow->m_bIsFloating && !pWindow->isFullscreen() && PWORKSPACE->m_renderOffset->isBeingAnimated() && !pWindow->m_bPinned) { CRegion rg = - pWindow->getFullWindowBoundingBox().translate(-pMonitor->vecPosition + PWORKSPACE->m_vRenderOffset->value() + pWindow->m_vFloatingOffset).scale(pMonitor->scale); + pWindow->getFullWindowBoundingBox().translate(-pMonitor->vecPosition + PWORKSPACE->m_renderOffset->value() + pWindow->m_vFloatingOffset).scale(pMonitor->scale); renderdata.clipBox = rg.getExtents(); } @@ -573,7 +573,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T if ((pWindow->m_bIsX11 && *PXWLUSENN) || pWindow->m_sWindowData.nearestNeighbor.valueOrDefault()) renderdata.useNearestNeighbor = true; - if (!pWindow->m_sWindowData.noBlur.valueOrDefault() && pWindow->m_pWLSurface->small() && !pWindow->m_pWLSurface->m_bFillIgnoreSmall && renderdata.blur && *PBLUR) { + if (!pWindow->m_sWindowData.noBlur.valueOrDefault() && pWindow->m_pWLSurface->small() && !pWindow->m_pWLSurface->m_fillIgnoreSmall && renderdata.blur && *PBLUR) { CBox wb = {renderdata.pos.x - pMonitor->vecPosition.x, renderdata.pos.y - pMonitor->vecPosition.y, renderdata.w, renderdata.h}; wb.scale(pMonitor->scale).round(); CRectPassElement::SRectData data; @@ -901,15 +901,15 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA // pre window pass g_pHyprOpenGL->preWindowPass(); - if (pWorkspace->m_bHasFullscreenWindow) + if (pWorkspace->m_hasFullscreenWindow) renderWorkspaceWindowsFullscreen(pMonitor, pWorkspace, time); else renderWorkspaceWindows(pMonitor, pWorkspace, time); // and then special for (auto const& ws : g_pCompositor->m_workspaces) { - if (ws->m_pMonitor == pMonitor && ws->m_fAlpha->value() > 0.f && ws->m_bIsSpecialWorkspace) { - const auto SPECIALANIMPROGRS = ws->m_vRenderOffset->isBeingAnimated() ? ws->m_vRenderOffset->getCurveValue() : ws->m_fAlpha->getCurveValue(); + 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 bool ANIMOUT = !pMonitor->activeSpecialWorkspace; if (*PDIMSPECIAL != 0.f) { @@ -936,8 +936,8 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA // special for (auto const& ws : g_pCompositor->m_workspaces) { - if (ws->m_fAlpha->value() > 0.f && ws->m_bIsSpecialWorkspace) { - if (ws->m_bHasFullscreenWindow) + if (ws->m_alpha->value() > 0.f && ws->m_isSpecialWorkspace) { + if (ws->m_hasFullscreenWindow) renderWorkspaceWindowsFullscreen(pMonitor, ws, time); else renderWorkspaceWindows(pMonitor, ws, time); @@ -1107,7 +1107,7 @@ void CHyprRenderer::calculateUVForSurface(PHLWINDOW pWindow, SPm_pWLSurface->small() && !pWindow->m_pWLSurface->m_bFillIgnoreSmall) + if (pWindow->m_pWLSurface->small() && !pWindow->m_pWLSurface->m_fillIgnoreSmall) maxSize = pWindow->m_pWLSurface->getViewporterCorrectedSize(); if (geom.width > maxSize.x) @@ -1225,8 +1225,8 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) { pMonitor->tearingState.activelyTearing = shouldTear; if ((*PDIRECTSCANOUT == 1 || - (*PDIRECTSCANOUT == 2 && pMonitor->activeWorkspace && pMonitor->activeWorkspace->m_bHasFullscreenWindow && - pMonitor->activeWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN && pMonitor->activeWorkspace->getFullscreenWindow()->getContentType() == CONTENT_TYPE_GAME)) && + (*PDIRECTSCANOUT == 2 && pMonitor->activeWorkspace && pMonitor->activeWorkspace->m_hasFullscreenWindow && + pMonitor->activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN && pMonitor->activeWorkspace->getFullscreenWindow()->getContentType() == CONTENT_TYPE_GAME)) && !shouldTear) { if (pMonitor->attemptDirectScanout()) { return; @@ -1481,7 +1481,7 @@ bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) { bool wantHDR = PHDR; bool hdrIsHandled = false; - if (*PPASS && pMonitor->activeWorkspace && pMonitor->activeWorkspace->m_bHasFullscreenWindow && pMonitor->activeWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN) { + if (*PPASS && pMonitor->activeWorkspace && pMonitor->activeWorkspace->m_hasFullscreenWindow && pMonitor->activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) { const auto WINDOW = pMonitor->activeWorkspace->getFullscreenWindow(); const auto ROOT_SURF = WINDOW->m_pWLSurface->resource(); const auto SURF = @@ -1525,7 +1525,7 @@ bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) { } } - if (pMonitor->activeWorkspace && pMonitor->activeWorkspace->m_bHasFullscreenWindow && pMonitor->activeWorkspace->m_efFullscreenMode == FSMODE_FULLSCREEN) { + if (pMonitor->activeWorkspace && pMonitor->activeWorkspace->m_hasFullscreenWindow && pMonitor->activeWorkspace->m_fullscreenMode == FSMODE_FULLSCREEN) { const auto WINDOW = pMonitor->activeWorkspace->getFullscreenWindow(); pMonitor->output->state->setContentType(NContentType::toDRM(WINDOW->getContentType())); } else @@ -1870,8 +1870,8 @@ void CHyprRenderer::damageWindow(PHLWINDOW pWindow, bool forceFull) { CBox windowBox = pWindow->getFullWindowBoundingBox(); const auto PWINDOWWORKSPACE = pWindow->m_pWorkspace; - if (PWINDOWWORKSPACE && PWINDOWWORKSPACE->m_vRenderOffset->isBeingAnimated() && !pWindow->m_bPinned) - windowBox.translate(PWINDOWWORKSPACE->m_vRenderOffset->value()); + if (PWINDOWWORKSPACE && PWINDOWWORKSPACE->m_renderOffset->isBeingAnimated() && !pWindow->m_bPinned) + windowBox.translate(PWINDOWWORKSPACE->m_renderOffset->value()); windowBox.translate(pWindow->m_vFloatingOffset); for (auto const& m : g_pCompositor->m_monitors) { @@ -2119,8 +2119,8 @@ void CHyprRenderer::recheckSolitaryForMonitor(PHLMONITOR pMonitor) { const auto PWORKSPACE = pMonitor->activeWorkspace; - if (!PWORKSPACE || !PWORKSPACE->m_bHasFullscreenWindow || PROTO::data->dndActive() || pMonitor->activeSpecialWorkspace || PWORKSPACE->m_fAlpha->value() != 1.f || - PWORKSPACE->m_vRenderOffset->value() != Vector2D{}) + if (!PWORKSPACE || !PWORKSPACE->m_hasFullscreenWindow || PROTO::data->dndActive() || pMonitor->activeSpecialWorkspace || PWORKSPACE->m_alpha->value() != 1.f || + PWORKSPACE->m_renderOffset->value() != Vector2D{}) return; const auto PCANDIDATE = PWORKSPACE->getFullscreenWindow(); diff --git a/src/render/decorations/CHyprBorderDecoration.cpp b/src/render/decorations/CHyprBorderDecoration.cpp index 4af6e449..229736de 100644 --- a/src/render/decorations/CHyprBorderDecoration.cpp +++ b/src/render/decorations/CHyprBorderDecoration.cpp @@ -41,7 +41,7 @@ CBox CHyprBorderDecoration::assignedBoxGlobal() { if (!PWORKSPACE) return box; - const auto WORKSPACEOFFSET = PWORKSPACE && !m_pWindow->m_bPinned ? PWORKSPACE->m_vRenderOffset->value() : Vector2D(); + const auto WORKSPACEOFFSET = PWORKSPACE && !m_pWindow->m_bPinned ? PWORKSPACE->m_renderOffset->value() : Vector2D(); return box.translate(WORKSPACEOFFSET); } @@ -120,8 +120,8 @@ void CHyprBorderDecoration::damageEntire() { const auto BORDERSIZE = m_pWindow->getRealBorderSize() + 1; const auto PWINDOWWORKSPACE = m_pWindow->m_pWorkspace; - if (PWINDOWWORKSPACE && PWINDOWWORKSPACE->m_vRenderOffset->isBeingAnimated() && !m_pWindow->m_bPinned) - surfaceBox.translate(PWINDOWWORKSPACE->m_vRenderOffset->value()); + if (PWINDOWWORKSPACE && PWINDOWWORKSPACE->m_renderOffset->isBeingAnimated() && !m_pWindow->m_bPinned) + surfaceBox.translate(PWINDOWWORKSPACE->m_renderOffset->value()); surfaceBox.translate(m_pWindow->m_vFloatingOffset); CBox surfaceBoxExpandedBorder = surfaceBox; diff --git a/src/render/decorations/CHyprDropShadowDecoration.cpp b/src/render/decorations/CHyprDropShadowDecoration.cpp index a9593c1f..8a3e9334 100644 --- a/src/render/decorations/CHyprDropShadowDecoration.cpp +++ b/src/render/decorations/CHyprDropShadowDecoration.cpp @@ -48,8 +48,8 @@ void CHyprDropShadowDecoration::damageEntire() { PWINDOW->m_vRealSize->value().y + m_seExtents.topLeft.y + m_seExtents.bottomRight.y}; const auto PWORKSPACE = PWINDOW->m_pWorkspace; - if (PWORKSPACE && PWORKSPACE->m_vRenderOffset->isBeingAnimated() && !PWINDOW->m_bPinned) - shadowBox.translate(PWORKSPACE->m_vRenderOffset->value()); + if (PWORKSPACE && PWORKSPACE->m_renderOffset->isBeingAnimated() && !PWINDOW->m_bPinned) + shadowBox.translate(PWORKSPACE->m_renderOffset->value()); shadowBox.translate(PWINDOW->m_vFloatingOffset); static auto PSHADOWIGNOREWINDOW = CConfigValue("decoration:shadow:ignore_window"); @@ -59,8 +59,8 @@ void CHyprDropShadowDecoration::damageEntire() { CRegion shadowRegion(shadowBox); if (*PSHADOWIGNOREWINDOW) { CBox surfaceBox = PWINDOW->getWindowMainSurfaceBox(); - if (PWORKSPACE && PWORKSPACE->m_vRenderOffset->isBeingAnimated() && !PWINDOW->m_bPinned) - surfaceBox.translate(PWORKSPACE->m_vRenderOffset->value()); + if (PWORKSPACE && PWORKSPACE->m_renderOffset->isBeingAnimated() && !PWINDOW->m_bPinned) + surfaceBox.translate(PWORKSPACE->m_renderOffset->value()); surfaceBox.translate(PWINDOW->m_vFloatingOffset); surfaceBox.expand(-ROUNDINGSIZE); shadowRegion.subtract(CRegion(surfaceBox)); @@ -121,7 +121,7 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) { const auto ROUNDINGPOWER = PWINDOW->roundingPower(); const auto ROUNDING = ROUNDINGBASE > 0 ? ROUNDINGBASE + PWINDOW->getRealBorderSize() : 0; const auto PWORKSPACE = PWINDOW->m_pWorkspace; - const auto WORKSPACEOFFSET = PWORKSPACE && !PWINDOW->m_bPinned ? PWORKSPACE->m_vRenderOffset->value() : Vector2D(); + const auto WORKSPACEOFFSET = PWORKSPACE && !PWINDOW->m_bPinned ? PWORKSPACE->m_renderOffset->value() : Vector2D(); // draw the shadow CBox fullBox = m_bLastWindowBoxWithDecos; diff --git a/src/render/decorations/CHyprGroupBarDecoration.cpp b/src/render/decorations/CHyprGroupBarDecoration.cpp index 7eca6d69..c09ca991 100644 --- a/src/render/decorations/CHyprGroupBarDecoration.cpp +++ b/src/render/decorations/CHyprGroupBarDecoration.cpp @@ -582,7 +582,7 @@ CBox CHyprGroupBarDecoration::assignedBoxGlobal() { const auto PWORKSPACE = m_pWindow->m_pWorkspace; if (PWORKSPACE && !m_pWindow->m_bPinned) - box.translate(PWORKSPACE->m_vRenderOffset->value()); + box.translate(PWORKSPACE->m_renderOffset->value()); return box.round(); } diff --git a/src/render/pass/SurfacePassElement.cpp b/src/render/pass/SurfacePassElement.cpp index 813ab8ea..252c0924 100644 --- a/src/render/pass/SurfacePassElement.cpp +++ b/src/render/pass/SurfacePassElement.cpp @@ -56,8 +56,8 @@ void CSurfacePassElement::draw(const CRegion& damage) { auto PSURFACE = CWLSurface::fromResource(data.surface); - const float ALPHA = data.alpha * data.fadeAlpha * (PSURFACE ? PSURFACE->m_fAlphaModifier : 1.F); - const float OVERALL_ALPHA = PSURFACE ? PSURFACE->m_fOverallOpacity : 1.F; + const float ALPHA = data.alpha * data.fadeAlpha * (PSURFACE ? PSURFACE->m_alphaModifier : 1.F); + const float OVERALL_ALPHA = PSURFACE ? PSURFACE->m_overallOpacity : 1.F; const bool BLUR = data.blur && (!TEXTURE->m_bOpaque || ALPHA < 1.F || OVERALL_ALPHA < 1.F); auto windowBox = getTexBox(); @@ -146,7 +146,7 @@ CBox CSurfacePassElement::getTexBox() { const auto PWINDOW = PSURFACE ? PSURFACE->getWindow() : nullptr; // center the surface if it's smaller than the viewport we assign it - if (PSURFACE && !PSURFACE->m_bFillIgnoreSmall && PSURFACE->small() /* guarantees PWINDOW */) { + if (PSURFACE && !PSURFACE->m_fillIgnoreSmall && PSURFACE->small() /* guarantees PWINDOW */) { const auto CORRECT = PSURFACE->correctSmallVec(); const auto SIZE = PSURFACE->getViewporterCorrectedSize(); @@ -184,7 +184,7 @@ CBox CSurfacePassElement::getTexBox() { bool CSurfacePassElement::needsLiveBlur() { auto PSURFACE = CWLSurface::fromResource(data.surface); - const float ALPHA = data.alpha * data.fadeAlpha * (PSURFACE ? PSURFACE->m_fAlphaModifier * PSURFACE->m_fOverallOpacity : 1.F); + const float ALPHA = data.alpha * data.fadeAlpha * (PSURFACE ? PSURFACE->m_alphaModifier * PSURFACE->m_overallOpacity : 1.F); const bool BLUR = data.blur && (!data.texture || !data.texture->m_bOpaque || ALPHA < 1.F); if (!data.pLS && !data.pWindow) @@ -198,7 +198,7 @@ bool CSurfacePassElement::needsLiveBlur() { bool CSurfacePassElement::needsPrecomputeBlur() { auto PSURFACE = CWLSurface::fromResource(data.surface); - const float ALPHA = data.alpha * data.fadeAlpha * (PSURFACE ? PSURFACE->m_fAlphaModifier * PSURFACE->m_fOverallOpacity : 1.F); + const float ALPHA = data.alpha * data.fadeAlpha * (PSURFACE ? PSURFACE->m_alphaModifier * PSURFACE->m_overallOpacity : 1.F); const bool BLUR = data.blur && (!data.texture || !data.texture->m_bOpaque || ALPHA < 1.F); if (!data.pLS && !data.pWindow) @@ -216,7 +216,7 @@ std::optional CSurfacePassElement::boundingBox() { CRegion CSurfacePassElement::opaqueRegion() { auto PSURFACE = CWLSurface::fromResource(data.surface); - const float ALPHA = data.alpha * data.fadeAlpha * (PSURFACE ? PSURFACE->m_fAlphaModifier * PSURFACE->m_fOverallOpacity : 1.F); + const float ALPHA = data.alpha * data.fadeAlpha * (PSURFACE ? PSURFACE->m_alphaModifier * PSURFACE->m_overallOpacity : 1.F); if (ALPHA < 1.F) return {};