summaryrefslogtreecommitdiff
path: root/src/desktop
diff options
context:
space:
mode:
authorVaxry <43317083+vaxerski@users.noreply.github.com>2025-12-20 22:16:13 +0000
committerGitHub <noreply@github.com>2025-12-20 22:16:13 +0000
commitb9bef6955487b75d13cfedd230bdc4adafedd115 (patch)
tree21400bb6bbb37651ad8e2f3338d2fa5e317b4098 /src/desktop
parent70f54a1e1ba3478a56faf82431b2770bd727431d (diff)
Desktop/history: Move history to desktop (#12676)
Diffstat (limited to 'src/desktop')
-rw-r--r--src/desktop/Workspace.cpp22
-rw-r--r--src/desktop/Workspace.hpp49
-rw-r--r--src/desktop/history/WindowHistoryTracker.cpp55
-rw-r--r--src/desktop/history/WindowHistoryTracker.hpp30
-rw-r--r--src/desktop/history/WorkspaceHistoryTracker.cpp158
-rw-r--r--src/desktop/history/WorkspaceHistoryTracker.hpp54
-rw-r--r--src/desktop/state/FocusState.cpp47
-rw-r--r--src/desktop/state/FocusState.hpp29
-rw-r--r--src/desktop/view/Window.cpp3
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;