diff options
| author | Vaxry <43317083+vaxerski@users.noreply.github.com> | 2025-12-20 22:16:13 +0000 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2025-12-20 22:16:13 +0000 |
| commit | b9bef6955487b75d13cfedd230bdc4adafedd115 (patch) | |
| tree | 21400bb6bbb37651ad8e2f3338d2fa5e317b4098 /src/desktop | |
| parent | 70f54a1e1ba3478a56faf82431b2770bd727431d (diff) | |
Desktop/history: Move history to desktop (#12676)
Diffstat (limited to 'src/desktop')
| -rw-r--r-- | src/desktop/Workspace.cpp | 22 | ||||
| -rw-r--r-- | src/desktop/Workspace.hpp | 49 | ||||
| -rw-r--r-- | src/desktop/history/WindowHistoryTracker.cpp | 55 | ||||
| -rw-r--r-- | src/desktop/history/WindowHistoryTracker.hpp | 30 | ||||
| -rw-r--r-- | src/desktop/history/WorkspaceHistoryTracker.cpp | 158 | ||||
| -rw-r--r-- | src/desktop/history/WorkspaceHistoryTracker.hpp | 54 | ||||
| -rw-r--r-- | src/desktop/state/FocusState.cpp | 47 | ||||
| -rw-r--r-- | src/desktop/state/FocusState.hpp | 29 | ||||
| -rw-r--r-- | src/desktop/view/Window.cpp | 3 |
9 files changed, 336 insertions, 111 deletions
diff --git a/src/desktop/Workspace.cpp b/src/desktop/Workspace.cpp index cbb584b6..2895137d 100644 --- a/src/desktop/Workspace.cpp +++ b/src/desktop/Workspace.cpp @@ -55,10 +55,6 @@ void CWorkspace::init(PHLWORKSPACE self) { EMIT_HOOK_EVENT("createWorkspace", this); } -SWorkspaceIDName CWorkspace::getPrevWorkspaceIDName() const { - return m_prevWorkspace; -} - CWorkspace::~CWorkspace() { Log::logger->log(Log::DEBUG, "Destroying workspace ID {}", m_id); @@ -82,24 +78,6 @@ PHLWINDOW CWorkspace::getLastFocusedWindow() { return m_lastFocusedWindow.lock(); } -void CWorkspace::rememberPrevWorkspace(const PHLWORKSPACE& prev) { - if (!prev) { - m_prevWorkspace.id = -1; - m_prevWorkspace.name = ""; - return; - } - - if (prev->m_id == m_id) { - Log::logger->log(Log::DEBUG, "Tried to set prev workspace to the same as current one"); - return; - } - - m_prevWorkspace.id = prev->m_id; - m_prevWorkspace.name = prev->m_name; - - prev->m_monitor->addPrevWorkspaceID(prev->m_id); -} - std::string CWorkspace::getConfigName() { if (m_isSpecialWorkspace) { return m_name; diff --git a/src/desktop/Workspace.hpp b/src/desktop/Workspace.hpp index 392ef642..1aad1aaa 100644 --- a/src/desktop/Workspace.hpp +++ b/src/desktop/Workspace.hpp @@ -57,29 +57,27 @@ class CWorkspace { bool m_wasCreatedEmpty = true; // Inert: destroyed and invalid. If this is true, release the ptr you have. - bool inert(); - MONITORID monitorID(); - PHLWINDOW getLastFocusedWindow(); - void rememberPrevWorkspace(const PHLWORKSPACE& prevWorkspace); - std::string getConfigName(); - bool matchesStaticSelector(const std::string& selector); - void markInert(); - SWorkspaceIDName getPrevWorkspaceIDName() const; - void updateWindowDecos(); - void updateWindowData(); - int getWindows(std::optional<bool> onlyTiled = {}, std::optional<bool> onlyPinned = {}, std::optional<bool> onlyVisible = {}); - int getGroups(std::optional<bool> onlyTiled = {}, std::optional<bool> onlyPinned = {}, std::optional<bool> onlyVisible = {}); - bool hasUrgentWindow(); - PHLWINDOW getFirstWindow(); - PHLWINDOW getTopLeftWindow(); - PHLWINDOW getFullscreenWindow(); - bool isVisible(); - bool isVisibleNotCovered(); - void rename(const std::string& name = ""); - void forceReportSizesToWindows(); - void updateWindows(); - void setPersistent(bool persistent); - bool isPersistent(); + bool inert(); + MONITORID monitorID(); + PHLWINDOW getLastFocusedWindow(); + std::string getConfigName(); + bool matchesStaticSelector(const std::string& selector); + void markInert(); + void updateWindowDecos(); + void updateWindowData(); + int getWindows(std::optional<bool> onlyTiled = {}, std::optional<bool> onlyPinned = {}, std::optional<bool> onlyVisible = {}); + int getGroups(std::optional<bool> onlyTiled = {}, std::optional<bool> onlyPinned = {}, std::optional<bool> onlyVisible = {}); + bool hasUrgentWindow(); + PHLWINDOW getFirstWindow(); + PHLWINDOW getTopLeftWindow(); + PHLWINDOW getFullscreenWindow(); + bool isVisible(); + bool isVisibleNotCovered(); + void rename(const std::string& name = ""); + void forceReportSizesToWindows(); + void updateWindows(); + void setPersistent(bool persistent); + bool isPersistent(); struct { CSignalT<> destroy; @@ -89,10 +87,7 @@ class CWorkspace { } m_events; private: - void init(PHLWORKSPACE self); - // Previous workspace ID and name is stored during a workspace change, allowing travel - // to the previous workspace. - SWorkspaceIDName m_prevWorkspace; + void init(PHLWORKSPACE self); SP<HOOK_CALLBACK_FN> m_focusedWindowHook; bool m_inert = true; diff --git a/src/desktop/history/WindowHistoryTracker.cpp b/src/desktop/history/WindowHistoryTracker.cpp new file mode 100644 index 00000000..5dc0742f --- /dev/null +++ b/src/desktop/history/WindowHistoryTracker.cpp @@ -0,0 +1,55 @@ +#include "WindowHistoryTracker.hpp" + +#include "../../managers/HookSystemManager.hpp" +#include "../view/Window.hpp" + +using namespace Desktop; +using namespace Desktop::History; + +SP<CWindowHistoryTracker> History::windowTracker() { + static SP<CWindowHistoryTracker> tracker = makeShared<CWindowHistoryTracker>(); + return tracker; +} + +CWindowHistoryTracker::CWindowHistoryTracker() { + static auto P = g_pHookSystem->hookDynamic("openWindowEarly", [this](void* self, SCallbackInfo& info, std::any data) { + auto window = std::any_cast<PHLWINDOW>(data); + + // add a last track + m_history.insert(m_history.begin(), window); + }); + + static auto P1 = g_pHookSystem->hookDynamic("activeWindow", [this](void* self, SCallbackInfo& info, std::any data) { + auto window = std::any_cast<PHLWINDOW>(data); + + track(window); + }); +} + +void CWindowHistoryTracker::track(PHLWINDOW w) { + std::erase(m_history, w); + m_history.emplace_back(w); +} + +const std::vector<PHLWINDOWREF>& CWindowHistoryTracker::fullHistory() { + gc(); + return m_history; +} + +std::vector<PHLWINDOWREF> CWindowHistoryTracker::historyForWorkspace(PHLWORKSPACE ws) { + gc(); + std::vector<PHLWINDOWREF> windows; + + for (const auto& w : m_history) { + if (w->m_workspace != ws) + continue; + + windows.emplace_back(w); + } + + return windows; +} + +void CWindowHistoryTracker::gc() { + std::erase_if(m_history, [](const auto& e) { return !e; }); +} diff --git a/src/desktop/history/WindowHistoryTracker.hpp b/src/desktop/history/WindowHistoryTracker.hpp new file mode 100644 index 00000000..92645683 --- /dev/null +++ b/src/desktop/history/WindowHistoryTracker.hpp @@ -0,0 +1,30 @@ +#pragma once + +#include "../DesktopTypes.hpp" + +#include <vector> + +namespace Desktop::History { + class CWindowHistoryTracker { + public: + CWindowHistoryTracker(); + ~CWindowHistoryTracker() = default; + + CWindowHistoryTracker(const CWindowHistoryTracker&) = delete; + CWindowHistoryTracker(CWindowHistoryTracker&) = delete; + CWindowHistoryTracker(CWindowHistoryTracker&&) = delete; + + // History is ordered old -> new, meaning .front() is oldest, while .back() is newest + + const std::vector<PHLWINDOWREF>& fullHistory(); + std::vector<PHLWINDOWREF> historyForWorkspace(PHLWORKSPACE ws); + + private: + std::vector<PHLWINDOWREF> m_history; + + void track(PHLWINDOW w); + void gc(); + }; + + SP<CWindowHistoryTracker> windowTracker(); +};
\ No newline at end of file diff --git a/src/desktop/history/WorkspaceHistoryTracker.cpp b/src/desktop/history/WorkspaceHistoryTracker.cpp new file mode 100644 index 00000000..bfedda13 --- /dev/null +++ b/src/desktop/history/WorkspaceHistoryTracker.cpp @@ -0,0 +1,158 @@ +#include "WorkspaceHistoryTracker.hpp" + +#include "../../helpers/Monitor.hpp" +#include "../Workspace.hpp" +#include "../../managers/HookSystemManager.hpp" +#include "../../config/ConfigValue.hpp" + +using namespace Desktop; +using namespace Desktop::History; + +SP<CWorkspaceHistoryTracker> History::workspaceTracker() { + static SP<CWorkspaceHistoryTracker> tracker = makeShared<CWorkspaceHistoryTracker>(); + return tracker; +} + +CWorkspaceHistoryTracker::CWorkspaceHistoryTracker() { + static auto P = g_pHookSystem->hookDynamic("workspace", [this](void* self, SCallbackInfo& info, std::any data) { + auto workspace = std::any_cast<PHLWORKSPACE>(data); + track(workspace); + }); + + static auto P1 = g_pHookSystem->hookDynamic("monitorAdded", [this](void* self, SCallbackInfo& info, std::any data) { + auto mon = std::any_cast<PHLMONITOR>(data); + track(mon); + }); +} + +CWorkspaceHistoryTracker::SMonitorData& CWorkspaceHistoryTracker::dataFor(PHLMONITOR mon) { + for (auto& ref : m_monitorDatas) { + if (ref.monitor != mon) + continue; + + return ref; + } + + return m_monitorDatas.emplace_back(SMonitorData{ + .monitor = mon, + }); +} + +CWorkspaceHistoryTracker::SWorkspacePreviousData& CWorkspaceHistoryTracker::dataFor(PHLWORKSPACE ws) { + for (auto& ref : m_datas) { + if (ref.workspace != ws) + continue; + + return ref; + } + + return m_datas.emplace_back(SWorkspacePreviousData{ + .workspace = ws, + }); +} + +void CWorkspaceHistoryTracker::track(PHLWORKSPACE w) { + if (!w->m_monitor) + return; + + static auto PALLOWWORKSPACECYCLES = CConfigValue<Hyprlang::INT>("binds:allow_workspace_cycles"); + + auto& data = dataFor(w); + auto& monData = dataFor(w->m_monitor.lock()); + + if (!monData.workspace) { + data.previous.reset(); + data.previousID = WORKSPACE_INVALID; + data.previousName = ""; + return; + } + + if (monData.workspace == w && !*PALLOWWORKSPACECYCLES) { + track(w->m_monitor.lock()); + return; + } + + data.previous = monData.workspace; + data.previousName = monData.workspace->m_name; + data.previousID = monData.workspace->m_id; + data.previousMon = monData.workspace->m_monitor; + + track(w->m_monitor.lock()); +} + +void CWorkspaceHistoryTracker::track(PHLMONITOR mon) { + auto& data = dataFor(mon); + data.workspace = mon->m_activeWorkspace; + data.workspaceName = mon->m_activeWorkspace ? mon->m_activeWorkspace->m_name : ""; + data.workspaceID = mon->activeWorkspaceID(); +} + +void CWorkspaceHistoryTracker::gc() { + std::erase_if(m_datas, [](const auto& e) { return !e.workspace; }); + std::erase_if(m_monitorDatas, [](const auto& e) { return !e.monitor; }); +} + +const CWorkspaceHistoryTracker::SWorkspacePreviousData* CWorkspaceHistoryTracker::previousWorkspace(PHLWORKSPACE ws) { + gc(); + + for (const auto& d : m_datas) { + if (d.workspace != ws) + continue; + return &d; + } + + return &dataFor(ws); +} + +SWorkspaceIDName CWorkspaceHistoryTracker::previousWorkspaceIDName(PHLWORKSPACE ws) { + gc(); + + for (const auto& d : m_datas) { + if (d.workspace != ws) + continue; + return SWorkspaceIDName{.id = d.previousID, .name = d.previousName, .isAutoIDd = d.previousID <= 0}; + } + + auto& d = dataFor(ws); + return SWorkspaceIDName{.id = d.previousID, .name = d.previousName, .isAutoIDd = d.previousID <= 0}; +} + +const CWorkspaceHistoryTracker::SWorkspacePreviousData* CWorkspaceHistoryTracker::previousWorkspace(PHLWORKSPACE ws, PHLMONITOR restrict) { + if (!restrict) + return previousWorkspace(ws); + + auto& data = dataFor(ws); + while (true) { + + // case 1: previous exists + if (data.previous) { + if (data.previous->m_monitor != restrict) { + data = dataFor(data.previous.lock()); + continue; + } + + break; + } + + // case 2: previous doesnt exist, but we have mon + if (data.previousMon) { + if (data.previousMon != restrict) + return nullptr; + + break; + } + + // case 3: no mon and no previous + return nullptr; + } + + return &data; +} + +SWorkspaceIDName CWorkspaceHistoryTracker::previousWorkspaceIDName(PHLWORKSPACE ws, PHLMONITOR restrict) { + const auto DATA = previousWorkspace(ws, restrict); + if (!DATA) + return SWorkspaceIDName{.id = WORKSPACE_INVALID}; + + return SWorkspaceIDName{.id = DATA->previousID, .name = DATA->previousName, .isAutoIDd = DATA->previousID <= 0}; +} diff --git a/src/desktop/history/WorkspaceHistoryTracker.hpp b/src/desktop/history/WorkspaceHistoryTracker.hpp new file mode 100644 index 00000000..4a3c109a --- /dev/null +++ b/src/desktop/history/WorkspaceHistoryTracker.hpp @@ -0,0 +1,54 @@ +#pragma once + +#include "../DesktopTypes.hpp" +#include "../../SharedDefs.hpp" +#include "../../macros.hpp" +#include "../../helpers/MiscFunctions.hpp" + +#include <vector> + +namespace Desktop::History { + class CWorkspaceHistoryTracker { + public: + CWorkspaceHistoryTracker(); + ~CWorkspaceHistoryTracker() = default; + + CWorkspaceHistoryTracker(const CWorkspaceHistoryTracker&) = delete; + CWorkspaceHistoryTracker(CWorkspaceHistoryTracker&) = delete; + CWorkspaceHistoryTracker(CWorkspaceHistoryTracker&&) = delete; + + struct SWorkspacePreviousData { + PHLWORKSPACEREF workspace; + PHLWORKSPACEREF previous; + PHLMONITORREF previousMon; + std::string previousName = ""; + WORKSPACEID previousID = WORKSPACE_INVALID; + }; + + const SWorkspacePreviousData* previousWorkspace(PHLWORKSPACE ws); + SWorkspaceIDName previousWorkspaceIDName(PHLWORKSPACE ws); + + const SWorkspacePreviousData* previousWorkspace(PHLWORKSPACE ws, PHLMONITOR restrict); + SWorkspaceIDName previousWorkspaceIDName(PHLWORKSPACE ws, PHLMONITOR restrict); + + private: + struct SMonitorData { + PHLMONITORREF monitor; + PHLWORKSPACEREF workspace; + std::string workspaceName = ""; + WORKSPACEID workspaceID = WORKSPACE_INVALID; + }; + + std::vector<SWorkspacePreviousData> m_datas; + std::vector<SMonitorData> m_monitorDatas; + + void track(PHLWORKSPACE w); + void track(PHLMONITOR mon); + void gc(); + + SMonitorData& dataFor(PHLMONITOR mon); + SWorkspacePreviousData& dataFor(PHLWORKSPACE ws); + }; + + SP<CWorkspaceHistoryTracker> workspaceTracker(); +};
\ No newline at end of file diff --git a/src/desktop/state/FocusState.cpp b/src/desktop/state/FocusState.cpp index ea869398..e6257690 100644 --- a/src/desktop/state/FocusState.cpp +++ b/src/desktop/state/FocusState.cpp @@ -16,19 +16,7 @@ SP<CFocusState> Desktop::focusState() { return state; } -Desktop::CFocusState::CFocusState() { - m_windowOpen = g_pHookSystem->hookDynamic("openWindowEarly", [this](void* self, SCallbackInfo& info, std::any data) { - auto window = std::any_cast<PHLWINDOW>(data); - - addWindowToHistory(window); - }); - - m_windowClose = g_pHookSystem->hookDynamic("closeWindow", [this](void* self, SCallbackInfo& info, std::any data) { - auto window = std::any_cast<PHLWINDOW>(data); - - removeWindowFromHistory(window); - }); -} +Desktop::CFocusState::CFocusState() = default; struct SFullscreenWorkspaceFocusResult { PHLWINDOW overrideFocusWindow = nullptr; @@ -73,7 +61,7 @@ static SFullscreenWorkspaceFocusResult onFullscreenWorkspaceFocusWindow(PHLWINDO return {}; } -void CFocusState::fullWindowFocus(PHLWINDOW pWindow, SP<CWLSurfaceResource> surface, bool preserveFocusHistory, bool forceFSCycle) { +void CFocusState::fullWindowFocus(PHLWINDOW pWindow, SP<CWLSurfaceResource> surface, bool forceFSCycle) { if (pWindow) { if (!pWindow->m_workspace) return; @@ -93,10 +81,10 @@ void CFocusState::fullWindowFocus(PHLWINDOW pWindow, SP<CWLSurfaceResource> surf return; } - rawWindowFocus(pWindow, surface, preserveFocusHistory); + rawWindowFocus(pWindow, surface); } -void CFocusState::rawWindowFocus(PHLWINDOW pWindow, SP<CWLSurfaceResource> surface, bool preserveFocusHistory) { +void CFocusState::rawWindowFocus(PHLWINDOW pWindow, SP<CWLSurfaceResource> surface) { static auto PFOLLOWMOUSE = CConfigValue<Hyprlang::INT>("input:follow_mouse"); static auto PSPECIALFALLTHROUGH = CConfigValue<Hyprlang::INT>("input:special_fallthrough"); @@ -164,8 +152,6 @@ void CFocusState::rawWindowFocus(PHLWINDOW pWindow, SP<CWLSurfaceResource> surfa const auto PWORKSPACE = pWindow->m_workspace; // This is to fix incorrect feedback on the focus history. PWORKSPACE->m_lastFocusedWindow = pWindow; - if (m_focusMonitor->m_activeWorkspace) - PWORKSPACE->rememberPrevWorkspace(m_focusMonitor->m_activeWorkspace); if (PWORKSPACE->m_isSpecialWorkspace) m_focusMonitor->changeWorkspace(PWORKSPACE, false, true); // if special ws, open on current monitor else if (PMONITOR) @@ -214,11 +200,6 @@ void CFocusState::rawWindowFocus(PHLWINDOW pWindow, SP<CWLSurfaceResource> surfa g_pInputManager->recheckIdleInhibitorStatus(); - if (!preserveFocusHistory) { - // move to front of the window history - moveWindowToLatestInHistory(pWindow); - } - if (*PFOLLOWMOUSE == 0) g_pInputManager->sendMotionEventsToFocused(); @@ -308,23 +289,3 @@ PHLWINDOW CFocusState::window() { PHLMONITOR CFocusState::monitor() { return m_focusMonitor.lock(); } - -const std::vector<PHLWINDOWREF>& CFocusState::windowHistory() { - return m_windowFocusHistory; -} - -void CFocusState::removeWindowFromHistory(PHLWINDOW w) { - std::erase_if(m_windowFocusHistory, [&w](const auto& e) { return !e || e == w; }); -} - -void CFocusState::addWindowToHistory(PHLWINDOW w) { - m_windowFocusHistory.emplace_back(w); -} - -void CFocusState::moveWindowToLatestInHistory(PHLWINDOW w) { - const auto HISTORYPIVOT = std::ranges::find_if(m_windowFocusHistory, [&w](const auto& other) { return other.lock() == w; }); - if (HISTORYPIVOT == m_windowFocusHistory.end()) - Log::logger->log(Log::TRACE, "CFocusState: {} has no pivot in history, ignoring request to move to latest", w); - else - std::rotate(m_windowFocusHistory.begin(), HISTORYPIVOT, HISTORYPIVOT + 1); -} diff --git a/src/desktop/state/FocusState.hpp b/src/desktop/state/FocusState.hpp index 2bf0953d..5603b0cc 100644 --- a/src/desktop/state/FocusState.hpp +++ b/src/desktop/state/FocusState.hpp @@ -15,28 +15,21 @@ namespace Desktop { CFocusState(CFocusState&) = delete; CFocusState(const CFocusState&) = delete; - void fullWindowFocus(PHLWINDOW w, SP<CWLSurfaceResource> surface = nullptr, bool preserveFocusHistory = false, bool forceFSCycle = false); - void rawWindowFocus(PHLWINDOW w, SP<CWLSurfaceResource> surface = nullptr, bool preserveFocusHistory = false); - void rawSurfaceFocus(SP<CWLSurfaceResource> s, PHLWINDOW pWindowOwner = nullptr); - void rawMonitorFocus(PHLMONITOR m); + void fullWindowFocus(PHLWINDOW w, SP<CWLSurfaceResource> surface = nullptr, bool forceFSCycle = false); + void rawWindowFocus(PHLWINDOW w, SP<CWLSurfaceResource> surface = nullptr); + void rawSurfaceFocus(SP<CWLSurfaceResource> s, PHLWINDOW pWindowOwner = nullptr); + void rawMonitorFocus(PHLMONITOR m); - SP<CWLSurfaceResource> surface(); - PHLWINDOW window(); - PHLMONITOR monitor(); - const std::vector<PHLWINDOWREF>& windowHistory(); - - void addWindowToHistory(PHLWINDOW w); + SP<CWLSurfaceResource> surface(); + PHLWINDOW window(); + PHLMONITOR monitor(); private: - void removeWindowFromHistory(PHLWINDOW w); - void moveWindowToLatestInHistory(PHLWINDOW w); - - WP<CWLSurfaceResource> m_focusSurface; - PHLWINDOWREF m_focusWindow; - PHLMONITORREF m_focusMonitor; - std::vector<PHLWINDOWREF> m_windowFocusHistory; // first element is the most recently focused + WP<CWLSurfaceResource> m_focusSurface; + PHLWINDOWREF m_focusWindow; + PHLMONITORREF m_focusMonitor; - SP<HOOK_CALLBACK_FN> m_windowOpen, m_windowClose; + SP<HOOK_CALLBACK_FN> m_windowOpen, m_windowClose; }; SP<CFocusState> focusState(); diff --git a/src/desktop/view/Window.cpp b/src/desktop/view/Window.cpp index bdb9affe..c2246db8 100644 --- a/src/desktop/view/Window.cpp +++ b/src/desktop/view/Window.cpp @@ -15,6 +15,7 @@ #include "Window.hpp" #include "LayerSurface.hpp" #include "../state/FocusState.hpp" +#include "../history/WindowHistoryTracker.hpp" #include "../../Compositor.hpp" #include "../../render/decorations/CHyprDropShadowDecoration.hpp" #include "../../render/decorations/CHyprGroupBarDecoration.hpp" @@ -1553,7 +1554,7 @@ PHLWINDOW CWindow::getSwallower() { return candidates[0]; // walk up the focus history and find the last focused - for (auto const& w : Desktop::focusState()->windowHistory()) { + for (auto const& w : Desktop::History::windowTracker()->fullHistory() | std::views::reverse) { if (!w) continue; |
