cry/Hyprland
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Desktop/history: Move history to desktop (#12676)

Browse source
This commit is contained in:
Vaxry 2025-12-20 22:16:13 +00:00 • committed by GitHub
parent 70f54a1e1b
commit b9bef69554
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
17 changed files with 372 additions and 181 deletions
Download patch file Download diff file Expand all files Collapse all files

22
src/desktop/Workspace.cpp
View file

@ -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;

49
src/desktop/Workspace.hpp
View file

@ -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;

55
src/desktop/history/WindowHistoryTracker.cpp Normal file
View file

@ -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; });
}

30
src/desktop/history/WindowHistoryTracker.hpp Normal file
View file

@ -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();
};

158
src/desktop/history/WorkspaceHistoryTracker.cpp Normal file
View file

@ -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};
}

54
src/desktop/history/WorkspaceHistoryTracker.hpp Normal file
View file

@ -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();
};

47
src/desktop/state/FocusState.cpp
View file

@ -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);
}

29
src/desktop/state/FocusState.hpp
View file

@ -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;
WP<CWLSurfaceResource> m_focusSurface;
PHLWINDOWREF m_focusWindow;
PHLMONITORREF m_focusMonitor;
std::vector<PHLWINDOWREF> m_windowFocusHistory; // first element is the most recently focused
SP<HOOK_CALLBACK_FN> m_windowOpen, m_windowClose;
SP<HOOK_CALLBACK_FN> m_windowOpen, m_windowClose;
};
SP<CFocusState> focusState();

3
src/desktop/view/Window.cpp
View file

@ -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;