hyprwm/Hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/Hyprland synced 2024-12-23 18:09:49 +01:00
Code Issues Projects Releases Packages Wiki Activity

core: drop using deques in favor of vectors

Browse source 
No point in most of these.
This commit is contained in:
Vaxry 2024-12-16 15:58:19 +00:00
parent de3ad245dc
commit a5234f26e4
25 changed files with 181 additions and 157 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
hyprctl/main.cpp
View file

@ -21,7 +21,6 @@
#include <fstream> #include <fstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <deque>
#include <filesystem> #include <filesystem>
#include <cstdarg> #include <cstdarg>
#include <regex> #include <regex>
@ -322,11 +321,11 @@ void instancesRequest(bool json) {
log(result + "\n"); log(result + "\n");
} }
std::deque<std::string> splitArgs(int argc, char** argv) { std::vector<std::string> splitArgs(int argc, char** argv) {
std::deque<std::string> result; std::vector<std::string> result;
for (auto i = 1 /* skip the executable */; i < argc; ++i) for (auto i = 1 /* skip the executable */; i < argc; ++i)
result.push_back(std::string(argv[i])); result.emplace_back(argv[i]);
return result; return result;
} }

6
src/Compositor.cpp
View file

@ -1349,13 +1349,13 @@ void CCompositor::changeWindowZOrder(PHLWINDOW pWindow, bool top) {
else { else {
// move X11 window stack // move X11 window stack
std::deque<PHLWINDOW> toMove; std::vector<PHLWINDOW> toMove;
auto x11Stack = [&](PHLWINDOW pw, bool top, auto&& x11Stack) -> void { auto x11Stack = [&](PHLWINDOW pw, bool top, auto&& x11Stack) -> void {
if (top) if (top)
toMove.emplace_back(pw); toMove.emplace_back(pw);
else else
toMove.emplace_front(pw); toMove.insert(toMove.begin(), pw);
for (auto const& w : m_vWindows) { for (auto const& w : m_vWindows) {
if (w->m_bIsMapped && !w->isHidden() && w->m_bIsX11 && w->x11TransientFor() == pw && w != pw && std::find(toMove.begin(), toMove.end(), w) == toMove.end()) { if (w->m_bIsMapped && !w->isHidden() && w->m_bIsX11 && w->x11TransientFor() == pw && w != pw && std::find(toMove.begin(), toMove.end(), w) == toMove.end()) {

1
src/Compositor.hpp
View file

@ -1,7 +1,6 @@
#pragma once #pragma once
#include <memory> #include <memory>
#include <deque>
#include <list> #include <list>
#include <sys/resource.h> #include <sys/resource.h>

66
src/config/ConfigManager.cpp
View file

@ -838,16 +838,16 @@ void CConfigManager::setDefaultAnimationVars() {
} }
std::optional<std::string> CConfigManager::resetHLConfig() { std::optional<std::string> CConfigManager::resetHLConfig() {
m_dMonitorRules.clear(); m_vMonitorRules.clear();
m_dWindowRules.clear(); m_vWindowRules.clear();
g_pKeybindManager->clearKeybinds(); g_pKeybindManager->clearKeybinds();
g_pAnimationManager->removeAllBeziers(); g_pAnimationManager->removeAllBeziers();
m_mAdditionalReservedAreas.clear(); m_mAdditionalReservedAreas.clear();
m_dBlurLSNamespaces.clear(); m_dBlurLSNamespaces.clear();
m_dWorkspaceRules.clear(); m_vWorkspaceRules.clear();
setDefaultAnimationVars(); // reset anims setDefaultAnimationVars(); // reset anims
m_vDeclaredPlugins.clear(); m_vDeclaredPlugins.clear();
m_dLayerRules.clear(); m_vLayerRules.clear();
m_vFailedPluginConfigValues.clear(); m_vFailedPluginConfigValues.clear();
finalExecRequests.clear(); finalExecRequests.clear();
@ -1154,7 +1154,7 @@ SMonitorRule CConfigManager::getMonitorRuleFor(const PHLMONITOR PMONITOR) {
return rule; return rule;
}; };
for (auto const& r : m_dMonitorRules | std::views::reverse) { for (auto const& r : m_vMonitorRules | std::views::reverse) {
if (PMONITOR->matchesStaticSelector(r.name)) { if (PMONITOR->matchesStaticSelector(r.name)) {
return applyWlrOutputConfig(r); return applyWlrOutputConfig(r);
} }
@ -1162,7 +1162,7 @@ SMonitorRule CConfigManager::getMonitorRuleFor(const PHLMONITOR PMONITOR) {
Debug::log(WARN, "No rule found for {}, trying to use the first.", PMONITOR->szName); Debug::log(WARN, "No rule found for {}, trying to use the first.", PMONITOR->szName);
for (auto const& r : m_dMonitorRules) { for (auto const& r : m_vMonitorRules) {
if (r.name.empty()) { if (r.name.empty()) {
return applyWlrOutputConfig(r); return applyWlrOutputConfig(r);
} }
@ -1179,7 +1179,7 @@ SMonitorRule CConfigManager::getMonitorRuleFor(const PHLMONITOR PMONITOR) {
SWorkspaceRule CConfigManager::getWorkspaceRuleFor(PHLWORKSPACE pWorkspace) { SWorkspaceRule CConfigManager::getWorkspaceRuleFor(PHLWORKSPACE pWorkspace) {
SWorkspaceRule mergedRule{}; SWorkspaceRule mergedRule{};
for (auto const& rule : m_dWorkspaceRules) { for (auto const& rule : m_vWorkspaceRules) {
if (!pWorkspace->matchesStaticSelector(rule.workspaceString)) if (!pWorkspace->matchesStaticSelector(rule.workspaceString))
continue; continue;
@ -1252,7 +1252,7 @@ std::vector<SWindowRule> CConfigManager::getMatchingRules(PHLWINDOW pWindow, boo
// local tags for dynamic tag rule match // local tags for dynamic tag rule match
auto tags = pWindow->m_tags; auto tags = pWindow->m_tags;
for (auto const& rule : m_dWindowRules) { for (auto const& rule : m_vWindowRules) {
// check if we have a matching rule // check if we have a matching rule
if (!rule.v2) { if (!rule.v2) {
try { try {
@ -1437,7 +1437,7 @@ std::vector<SLayerRule> CConfigManager::getMatchingRules(PHLLS pLS) {
if (!pLS->layerSurface || pLS->fadingOut) if (!pLS->layerSurface || pLS->fadingOut)
return returns; return returns;
for (auto const& lr : m_dLayerRules) { for (auto const& lr : m_vLayerRules) {
if (lr.targetNamespace.starts_with("address:0x")) { if (lr.targetNamespace.starts_with("address:0x")) {
if (std::format("address:0x{:x}", (uintptr_t)pLS.get()) != lr.targetNamespace) if (std::format("address:0x{:x}", (uintptr_t)pLS.get()) != lr.targetNamespace)
continue; continue;
@ -1510,13 +1510,13 @@ void CConfigManager::dispatchExecShutdown() {
} }
void CConfigManager::appendMonitorRule(const SMonitorRule& r) { void CConfigManager::appendMonitorRule(const SMonitorRule& r) {
m_dMonitorRules.emplace_back(r); m_vMonitorRules.emplace_back(r);
} }
bool CConfigManager::replaceMonitorRule(const SMonitorRule& newrule) { bool CConfigManager::replaceMonitorRule(const SMonitorRule& newrule) {
// Looks for an existing monitor rule (compared by name). // Looks for an existing monitor rule (compared by name).
// If the rule exists, it is replaced with the input rule. // If the rule exists, it is replaced with the input rule.
for (auto& r : m_dMonitorRules) { for (auto& r : m_vMonitorRules) {
if (r.name == newrule.name) { if (r.name == newrule.name) {
r = newrule; r = newrule;
return true; return true;
@ -1693,7 +1693,7 @@ PHLMONITOR CConfigManager::getBoundMonitorForWS(const std::string& wsname) {
} }
std::string CConfigManager::getBoundMonitorStringForWS(const std::string& wsname) { std::string CConfigManager::getBoundMonitorStringForWS(const std::string& wsname) {
for (auto const& wr : m_dWorkspaceRules) { for (auto const& wr : m_vWorkspaceRules) {
const auto WSNAME = wr.workspaceName.starts_with("name:") ? wr.workspaceName.substr(5) : wr.workspaceName; const auto WSNAME = wr.workspaceName.starts_with("name:") ? wr.workspaceName.substr(5) : wr.workspaceName;
if (WSNAME == wsname) if (WSNAME == wsname)
@ -1703,8 +1703,8 @@ std::string CConfigManager::getBoundMonitorStringForWS(const std::string& wsname
return ""; return "";
} }
const std::deque<SWorkspaceRule>& CConfigManager::getAllWorkspaceRules() { const std::vector<SWorkspaceRule>& CConfigManager::getAllWorkspaceRules() {
return m_dWorkspaceRules; return m_vWorkspaceRules;
} }
void CConfigManager::addExecRule(const SExecRequestedRule& rule) { void CConfigManager::addExecRule(const SExecRequestedRule& rule) {
@ -1782,7 +1782,7 @@ void CConfigManager::removePluginConfig(HANDLE handle) {
} }
std::string CConfigManager::getDefaultWorkspaceFor(const std::string& name) { std::string CConfigManager::getDefaultWorkspaceFor(const std::string& name) {
for (auto other = m_dWorkspaceRules.begin(); other != m_dWorkspaceRules.end(); ++other) { for (auto other = m_vWorkspaceRules.begin(); other != m_vWorkspaceRules.end(); ++other) {
if (other->isDefault) { if (other->isDefault) {
if (other->monitor == name) if (other->monitor == name)
return other->workspaceString; return other->workspaceString;
@ -1900,7 +1900,7 @@ std::optional<std::string> CConfigManager::handleMonitor(const std::string& comm
const auto TRANSFORM = (wl_output_transform)TSF; const auto TRANSFORM = (wl_output_transform)TSF;
// overwrite if exists // overwrite if exists
for (auto& r : m_dMonitorRules) { for (auto& r : m_vMonitorRules) {
if (r.name == newrule.name) { if (r.name == newrule.name) {
r.transform = TRANSFORM; r.transform = TRANSFORM;
return {}; return {};
@ -1925,9 +1925,9 @@ std::optional<std::string> CConfigManager::handleMonitor(const std::string& comm
return "parse error: curitem bogus"; return "parse error: curitem bogus";
} }
std::erase_if(m_dMonitorRules, [&](const auto& other) { return other.name == newrule.name; }); std::erase_if(m_vMonitorRules, [&](const auto& other) { return other.name == newrule.name; });
m_dMonitorRules.push_back(newrule); m_vMonitorRules.push_back(newrule);
return {}; return {};
} }
@ -1960,7 +1960,7 @@ std::optional<std::string> CConfigManager::handleMonitor(const std::string& comm
if (ARGS[2].starts_with("auto")) { if (ARGS[2].starts_with("auto")) {
newrule.offset = Vector2D(-INT32_MAX, -INT32_MAX); newrule.offset = Vector2D(-INT32_MAX, -INT32_MAX);
// If this is the first monitor rule needs to be on the right. // If this is the first monitor rule needs to be on the right.
if (ARGS[2] == "auto-right" || ARGS[2] == "auto" || m_dMonitorRules.empty()) if (ARGS[2] == "auto-right" || ARGS[2] == "auto" || m_vMonitorRules.empty())
newrule.autoDir = eAutoDirs::DIR_AUTO_RIGHT; newrule.autoDir = eAutoDirs::DIR_AUTO_RIGHT;
else if (ARGS[2] == "auto-left") else if (ARGS[2] == "auto-left")
newrule.autoDir = eAutoDirs::DIR_AUTO_LEFT; newrule.autoDir = eAutoDirs::DIR_AUTO_LEFT;
@ -2043,7 +2043,7 @@ std::optional<std::string> CConfigManager::handleMonitor(const std::string& comm
wsRule.workspaceId = id; wsRule.workspaceId = id;
wsRule.workspaceName = name; wsRule.workspaceName = name;
m_dWorkspaceRules.emplace_back(wsRule); m_vWorkspaceRules.emplace_back(wsRule);
argno++; argno++;
} else { } else {
Debug::log(ERR, "Config error: invalid monitor syntax at \"{}\"", ARGS[argno]); Debug::log(ERR, "Config error: invalid monitor syntax at \"{}\"", ARGS[argno]);
@ -2053,9 +2053,9 @@ std::optional<std::string> CConfigManager::handleMonitor(const std::string& comm
argno++; argno++;
} }
std::erase_if(m_dMonitorRules, [&](const auto& other) { return other.name == newrule.name; }); std::erase_if(m_vMonitorRules, [&](const auto& other) { return other.name == newrule.name; });
m_dMonitorRules.push_back(newrule); m_vMonitorRules.push_back(newrule);
if (error.empty()) if (error.empty())
return {}; return {};
@ -2338,7 +2338,7 @@ std::optional<std::string> CConfigManager::handleWindowRule(const std::string& c
return "empty rule?"; return "empty rule?";
if (RULE == "unset") { if (RULE == "unset") {
std::erase_if(m_dWindowRules, [&](const SWindowRule& other) { return other.szValue == VALUE; }); std::erase_if(m_vWindowRules, [&](const SWindowRule& other) { return other.szValue == VALUE; });
return {}; return {};
} }
@ -2349,9 +2349,9 @@ std::optional<std::string> CConfigManager::handleWindowRule(const std::string& c
} }
if (RULE.starts_with("size") || RULE.starts_with("maxsize") || RULE.starts_with("minsize")) if (RULE.starts_with("size") || RULE.starts_with("maxsize") || RULE.starts_with("minsize"))
m_dWindowRules.push_front({RULE, VALUE}); m_vWindowRules.insert(m_vWindowRules.begin(), {RULE, VALUE});
else else
m_dWindowRules.push_back({RULE, VALUE}); m_vWindowRules.push_back({RULE, VALUE});
return {}; return {};
} }
@ -2365,7 +2365,7 @@ std::optional<std::string> CConfigManager::handleLayerRule(const std::string& co
return "empty rule?"; return "empty rule?";
if (RULE == "unset") { if (RULE == "unset") {
std::erase_if(m_dLayerRules, [&](const SLayerRule& other) { return other.targetNamespace == VALUE; }); std::erase_if(m_vLayerRules, [&](const SLayerRule& other) { return other.targetNamespace == VALUE; });
return {}; return {};
} }
@ -2374,7 +2374,7 @@ std::optional<std::string> CConfigManager::handleLayerRule(const std::string& co
return "Invalid rule found: " + RULE; return "Invalid rule found: " + RULE;
} }
m_dLayerRules.push_back({VALUE, RULE}); m_vLayerRules.push_back({VALUE, RULE});
for (auto const& m : g_pCompositor->m_vMonitors) for (auto const& m : g_pCompositor->m_vMonitors)
for (auto const& lsl : m->m_aLayerSurfaceLayers) for (auto const& lsl : m->m_aLayerSurfaceLayers)
@ -2512,7 +2512,7 @@ std::optional<std::string> CConfigManager::handleWindowRuleV2(const std::string&
rule.szOnWorkspace = extract(ONWORKSPACEPOS + 12); rule.szOnWorkspace = extract(ONWORKSPACEPOS + 12);
if (RULE == "unset") { if (RULE == "unset") {
std::erase_if(m_dWindowRules, [&](const SWindowRule& other) { std::erase_if(m_vWindowRules, [&](const SWindowRule& other) {
if (!other.v2) { if (!other.v2) {
return other.szClass == rule.szClass && !rule.szClass.empty(); return other.szClass == rule.szClass && !rule.szClass.empty();
} else { } else {
@ -2562,9 +2562,9 @@ std::optional<std::string> CConfigManager::handleWindowRuleV2(const std::string&
} }
if (RULE.starts_with("size") || RULE.starts_with("maxsize") || RULE.starts_with("minsize")) if (RULE.starts_with("size") || RULE.starts_with("maxsize") || RULE.starts_with("minsize"))
m_dWindowRules.push_front(rule); m_vWindowRules.insert(m_vWindowRules.begin(), rule);
else else
m_dWindowRules.push_back(rule); m_vWindowRules.push_back(rule);
return {}; return {};
} }
@ -2713,10 +2713,10 @@ std::optional<std::string> CConfigManager::handleWorkspaceRules(const std::strin
wsRule.workspaceId = id; wsRule.workspaceId = id;
wsRule.workspaceName = name; wsRule.workspaceName = name;
const auto IT = std::find_if(m_dWorkspaceRules.begin(), m_dWorkspaceRules.end(), [&](const auto& other) { return other.workspaceString == wsRule.workspaceString; }); const auto IT = std::find_if(m_vWorkspaceRules.begin(), m_vWorkspaceRules.end(), [&](const auto& other) { return other.workspaceString == wsRule.workspaceString; });
if (IT == m_dWorkspaceRules.end()) if (IT == m_vWorkspaceRules.end())
m_dWorkspaceRules.emplace_back(wsRule); m_vWorkspaceRules.emplace_back(wsRule);
else else
*IT = mergeWorkspaceRules(*IT, wsRule); *IT = mergeWorkspaceRules(*IT, wsRule);

19
src/config/ConfigManager.hpp
View file

@ -8,7 +8,6 @@
#include "../defines.hpp" #include "../defines.hpp"
#include <variant> #include <variant>
#include <vector> #include <vector>
#include <deque>
#include <algorithm> #include <algorithm>
#include <regex> #include <regex>
#include <optional> #include <optional>
@ -175,7 +174,7 @@ class CConfigManager {
PHLMONITOR getBoundMonitorForWS(const std::string&); PHLMONITOR getBoundMonitorForWS(const std::string&);
std::string getBoundMonitorStringForWS(const std::string&); std::string getBoundMonitorStringForWS(const std::string&);
const std::deque<SWorkspaceRule>& getAllWorkspaceRules(); const std::vector<SWorkspaceRule>& getAllWorkspaceRules();
std::vector<SWindowRule> getMatchingRules(PHLWINDOW, bool dynamic = true, bool shadowExec = false); std::vector<SWindowRule> getMatchingRules(PHLWINDOW, bool dynamic = true, bool shadowExec = false);
std::vector<SLayerRule> getMatchingRules(PHLLS); std::vector<SLayerRule> getMatchingRules(PHLLS);
@ -275,7 +274,7 @@ class CConfigManager {
private: private:
std::unique_ptr<Hyprlang::CConfig> m_pConfig; std::unique_ptr<Hyprlang::CConfig> m_pConfig;
std::deque<std::string> configPaths; // stores all the config paths std::vector<std::string> configPaths; // stores all the config paths
std::unordered_map<std::string, time_t> configModifyTimes; // stores modify times std::unordered_map<std::string, time_t> configModifyTimes; // stores modify times
std::unordered_map<std::string, SAnimationPropertyConfig> animationConfig; // stores all the animations with their set values std::unordered_map<std::string, SAnimationPropertyConfig> animationConfig; // stores all the animations with their set values
@ -290,16 +289,16 @@ class CConfigManager {
bool isFirstLaunch = true; // For exec-once bool isFirstLaunch = true; // For exec-once
std::deque<SMonitorRule> m_dMonitorRules; std::vector<SMonitorRule> m_vMonitorRules;
std::deque<SWorkspaceRule> m_dWorkspaceRules; std::vector<SWorkspaceRule> m_vWorkspaceRules;
std::deque<SWindowRule> m_dWindowRules; std::vector<SWindowRule> m_vWindowRules;
std::deque<SLayerRule> m_dLayerRules; std::vector<SLayerRule> m_vLayerRules;
std::deque<std::string> m_dBlurLSNamespaces; std::vector<std::string> m_dBlurLSNamespaces;
bool firstExecDispatched = false; bool firstExecDispatched = false;
bool m_bManualCrashInitiated = false; bool m_bManualCrashInitiated = false;
std::deque<std::string> firstExecRequests; std::vector<std::string> firstExecRequests;
std::deque<std::string> finalExecRequests; std::vector<std::string> finalExecRequests;
std::vector<std::pair<std::string, std::string>> m_vFailedPluginConfigValues; // for plugin values of unloaded plugins std::vector<std::pair<std::string, std::string>> m_vFailedPluginConfigValues; // for plugin values of unloaded plugins
std::string m_szConfigErrors = ""; std::string m_szConfigErrors = "";

36
src/debug/HyprDebugOverlay.cpp
View file

@ -8,7 +8,12 @@ CHyprDebugOverlay::CHyprDebugOverlay() {
} }
void CHyprMonitorDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs) { void CHyprMonitorDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs) {
m_dLastRenderTimes.push_back(durationUs / 1000.f); static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
if (!*PDEBUGOVERLAY)
return;
m_dLastRenderTimes.emplace_back(durationUs / 1000.f);
if (m_dLastRenderTimes.size() > (long unsigned int)pMonitor->refreshRate) if (m_dLastRenderTimes.size() > (long unsigned int)pMonitor->refreshRate)
m_dLastRenderTimes.pop_front(); m_dLastRenderTimes.pop_front();
@ -18,7 +23,12 @@ void CHyprMonitorDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs)
} }
void CHyprMonitorDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float durationUs) { void CHyprMonitorDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float durationUs) {
m_dLastRenderTimesNoOverlay.push_back(durationUs / 1000.f); static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
if (!*PDEBUGOVERLAY)
return;
m_dLastRenderTimesNoOverlay.emplace_back(durationUs / 1000.f);
if (m_dLastRenderTimesNoOverlay.size() > (long unsigned int)pMonitor->refreshRate) if (m_dLastRenderTimesNoOverlay.size() > (long unsigned int)pMonitor->refreshRate)
m_dLastRenderTimesNoOverlay.pop_front(); m_dLastRenderTimesNoOverlay.pop_front();
@ -28,7 +38,12 @@ void CHyprMonitorDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float du
} }
void CHyprMonitorDebugOverlay::frameData(PHLMONITOR pMonitor) { void CHyprMonitorDebugOverlay::frameData(PHLMONITOR pMonitor) {
m_dLastFrametimes.push_back(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - m_tpLastFrame).count() / 1000.f); static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
if (!*PDEBUGOVERLAY)
return;
m_dLastFrametimes.emplace_back(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - m_tpLastFrame).count() / 1000.f);
if (m_dLastFrametimes.size() > (long unsigned int)pMonitor->refreshRate) if (m_dLastFrametimes.size() > (long unsigned int)pMonitor->refreshRate)
m_dLastFrametimes.pop_front(); m_dLastFrametimes.pop_front();
@ -189,14 +204,29 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
} }
void CHyprDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs) { void CHyprDebugOverlay::renderData(PHLMONITOR pMonitor, float durationUs) {
static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
if (!*PDEBUGOVERLAY)
return;
m_mMonitorOverlays[pMonitor].renderData(pMonitor, durationUs); m_mMonitorOverlays[pMonitor].renderData(pMonitor, durationUs);
} }
void CHyprDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float durationUs) { void CHyprDebugOverlay::renderDataNoOverlay(PHLMONITOR pMonitor, float durationUs) {
static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
if (!*PDEBUGOVERLAY)
return;
m_mMonitorOverlays[pMonitor].renderDataNoOverlay(pMonitor, durationUs); m_mMonitorOverlays[pMonitor].renderDataNoOverlay(pMonitor, durationUs);
} }
void CHyprDebugOverlay::frameData(PHLMONITOR pMonitor) { void CHyprDebugOverlay::frameData(PHLMONITOR pMonitor) {
static auto PDEBUGOVERLAY = CConfigValue<Hyprlang::INT>("debug:overlay");
if (!*PDEBUGOVERLAY)
return;
m_mMonitorOverlays[pMonitor].frameData(pMonitor); m_mMonitorOverlays[pMonitor].frameData(pMonitor);
} }

2
src/debug/HyprDebugOverlay.hpp
View file

@ -3,9 +3,9 @@
#include "../defines.hpp" #include "../defines.hpp"
#include "../helpers/Monitor.hpp" #include "../helpers/Monitor.hpp"
#include "../render/Texture.hpp" #include "../render/Texture.hpp"
#include <deque>
#include <cairo/cairo.h> #include <cairo/cairo.h>
#include <map> #include <map>
#include <deque>
class CHyprRenderer; class CHyprRenderer;

18
src/debug/HyprNotificationOverlay.cpp
View file

@ -18,7 +18,7 @@ inline auto iconBackendFromLayout(PangoLayout* layout) {
CHyprNotificationOverlay::CHyprNotificationOverlay() { CHyprNotificationOverlay::CHyprNotificationOverlay() {
static auto P = g_pHookSystem->hookDynamic("focusedMon", [&](void* self, SCallbackInfo& info, std::any param) { static auto P = g_pHookSystem->hookDynamic("focusedMon", [&](void* self, SCallbackInfo& info, std::any param) {
if (m_dNotifications.size() == 0) if (m_vNotifications.size() == 0)
return; return;
g_pHyprRenderer->damageBox(&m_bLastDamage); g_pHyprRenderer->damageBox(&m_bLastDamage);
@ -35,7 +35,7 @@ CHyprNotificationOverlay::~CHyprNotificationOverlay() {
} }
void CHyprNotificationOverlay::addNotification(const std::string& text, const CHyprColor& color, const float timeMs, const eIcons icon, const float fontSize) { void CHyprNotificationOverlay::addNotification(const std::string& text, const CHyprColor& color, const float timeMs, const eIcons icon, const float fontSize) {
const auto PNOTIF = m_dNotifications.emplace_back(std::make_unique<SNotification>()).get(); const auto PNOTIF = m_vNotifications.emplace_back(std::make_unique<SNotification>()).get();
PNOTIF->text = icon != eIcons::ICON_NONE ? " " + text /* tiny bit of padding otherwise icon touches text */ : text; PNOTIF->text = icon != eIcons::ICON_NONE ? " " + text /* tiny bit of padding otherwise icon touches text */ : text;
PNOTIF->color = color == CHyprColor(0) ? ICONS_COLORS[icon] : color; PNOTIF->color = color == CHyprColor(0) ? ICONS_COLORS[icon] : color;
@ -51,12 +51,12 @@ void CHyprNotificationOverlay::addNotification(const std::string& text, const CH
void CHyprNotificationOverlay::dismissNotifications(const int amount) { void CHyprNotificationOverlay::dismissNotifications(const int amount) {
if (amount == -1) if (amount == -1)
m_dNotifications.clear(); m_vNotifications.clear();
else { else {
const int AMT = std::min(amount, static_cast<int>(m_dNotifications.size())); const int AMT = std::min(amount, static_cast<int>(m_vNotifications.size()));
for (int i = 0; i < AMT; ++i) { for (int i = 0; i < AMT; ++i) {
m_dNotifications.pop_front(); m_vNotifications.erase(m_vNotifications.begin());
} }
} }
} }
@ -87,7 +87,7 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
const auto iconBackendID = iconBackendFromLayout(layout); const auto iconBackendID = iconBackendFromLayout(layout);
const auto PBEZIER = g_pAnimationManager->getBezier("default"); const auto PBEZIER = g_pAnimationManager->getBezier("default");
for (auto const& notif : m_dNotifications) { for (auto const& notif : m_vNotifications) {
const auto ICONPADFORNOTIF = notif->icon == ICON_NONE ? 0 : ICON_PAD; const auto ICONPADFORNOTIF = notif->icon == ICON_NONE ? 0 : ICON_PAD;
const auto FONTSIZE = std::clamp((int)(notif->fontSize * ((pMonitor->vecPixelSize.x * SCALE) / 1920.f)), 8, 40); const auto FONTSIZE = std::clamp((int)(notif->fontSize * ((pMonitor->vecPixelSize.x * SCALE) / 1920.f)), 8, 40);
@ -182,7 +182,7 @@ CBox CHyprNotificationOverlay::drawNotifications(PHLMONITOR pMonitor) {
g_object_unref(layout); g_object_unref(layout);
// cleanup notifs // cleanup notifs
std::erase_if(m_dNotifications, [](const auto& notif) { return notif->started.getMillis() > notif->timeMs; }); std::erase_if(m_vNotifications, [](const auto& notif) { return notif->started.getMillis() > notif->timeMs; });
return CBox{(int)(pMonitor->vecPosition.x + pMonitor->vecSize.x - maxWidth - 20), (int)pMonitor->vecPosition.y, (int)maxWidth + 20, (int)offsetY + 10}; return CBox{(int)(pMonitor->vecPosition.x + pMonitor->vecSize.x - maxWidth - 20), (int)pMonitor->vecPosition.y, (int)maxWidth + 20, (int)offsetY + 10};
} }
@ -205,7 +205,7 @@ void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) {
} }
// Draw the notifications // Draw the notifications
if (m_dNotifications.size() == 0) if (m_vNotifications.size() == 0)
return; return;
// Render to the monitor // Render to the monitor
@ -246,5 +246,5 @@ void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) {
} }
bool CHyprNotificationOverlay::hasAny() { bool CHyprNotificationOverlay::hasAny() {
return !m_dNotifications.empty(); return !m_vNotifications.empty();
} }

18
src/debug/HyprNotificationOverlay.hpp
View file

@ -6,7 +6,7 @@
#include "../render/Texture.hpp" #include "../render/Texture.hpp"
#include "../SharedDefs.hpp" #include "../SharedDefs.hpp"
#include <deque> #include <vector>
#include <cairo/cairo.h> #include <cairo/cairo.h>
@ -47,18 +47,18 @@ class CHyprNotificationOverlay {
bool hasAny(); bool hasAny();
private: private:
CBox drawNotifications(PHLMONITOR pMonitor); CBox drawNotifications(PHLMONITOR pMonitor);
CBox m_bLastDamage; CBox m_bLastDamage;
std::deque<std::unique_ptr<SNotification>> m_dNotifications; std::vector<std::unique_ptr<SNotification>> m_vNotifications;
cairo_surface_t* m_pCairoSurface = nullptr; cairo_surface_t* m_pCairoSurface = nullptr;
cairo_t* m_pCairo = nullptr; cairo_t* m_pCairo = nullptr;
PHLMONITORREF m_pLastMonitor; PHLMONITORREF m_pLastMonitor;
Vector2D m_vecLastSize = Vector2D(-1, -1); Vector2D m_vecLastSize = Vector2D(-1, -1);
SP<CTexture> m_pTexture; SP<CTexture> m_pTexture;
}; };
inline std::unique_ptr<CHyprNotificationOverlay> g_pHyprNotificationOverlay; inline std::unique_ptr<CHyprNotificationOverlay> g_pHyprNotificationOverlay;

6
src/desktop/Window.hpp
View file

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <deque> #include <vector>
#include <string> #include <string>
#include "../config/ConfigDataValues.hpp" #include "../config/ConfigDataValues.hpp"
@ -344,8 +344,8 @@ class CWindow {
// Window decorations // Window decorations
// TODO: make this a SP. // TODO: make this a SP.
std::deque<std::unique_ptr<IHyprWindowDecoration>> m_dWindowDecorations; std::vector<std::unique_ptr<IHyprWindowDecoration>> m_dWindowDecorations;
std::vector<IHyprWindowDecoration*> m_vDecosToRemove; std::vector<IHyprWindowDecoration*> m_vDecosToRemove;
// Special render data, rules, etc // Special render data, rules, etc
SWindowData m_sWindowData; SWindowData m_sWindowData;

16
src/helpers/BezierCurve.cpp
View file

@ -9,18 +9,18 @@ void CBezierCurve::setup(std::vector<Vector2D>* pVec) {
const auto BEGIN = std::chrono::high_resolution_clock::now(); const auto BEGIN = std::chrono::high_resolution_clock::now();
// Avoid reallocations by reserving enough memory upfront // Avoid reallocations by reserving enough memory upfront
m_dPoints.resize(pVec->size() + 2); m_vPoints.resize(pVec->size() + 2);
m_dPoints[0] = Vector2D(0, 0); // Start point m_vPoints[0] = Vector2D(0, 0); // Start point
size_t index = 1; // Start after the first element size_t index = 1; // Start after the first element
for (const auto& vec : *pVec) { for (const auto& vec : *pVec) {
if (index < m_dPoints.size() - 1) { // Bounds check to ensure safety if (index < m_vPoints.size() - 1) { // Bounds check to ensure safety
m_dPoints[index] = vec; m_vPoints[index] = vec;
++index; ++index;
} }
} }
m_dPoints.back() = Vector2D(1, 1); // End point m_vPoints.back() = Vector2D(1, 1); // End point
RASSERT(m_dPoints.size() == 4, "CBezierCurve only supports cubic beziers! (points num: {})", m_dPoints.size()); RASSERT(m_vPoints.size() == 4, "CBezierCurve only supports cubic beziers! (points num: {})", m_vPoints.size());
// bake BAKEDPOINTS points for faster lookups // bake BAKEDPOINTS points for faster lookups
// T -> X ( / BAKEDPOINTS ) // T -> X ( / BAKEDPOINTS )
@ -47,14 +47,14 @@ float CBezierCurve::getXForT(float const& t) {
float t2 = t * t; float t2 = t * t;
float t3 = t2 * t; float t3 = t2 * t;
return 3 * t * (1 - t) * (1 - t) * m_dPoints[1].x + 3 * t2 * (1 - t) * m_dPoints[2].x + t3 * m_dPoints[3].x; return 3 * t * (1 - t) * (1 - t) * m_vPoints[1].x + 3 * t2 * (1 - t) * m_vPoints[2].x + t3 * m_vPoints[3].x;
} }
float CBezierCurve::getYForT(float const& t) { float CBezierCurve::getYForT(float const& t) {
float t2 = t * t; float t2 = t * t;
float t3 = t2 * t; float t3 = t2 * t;
return 3 * t * (1 - t) * (1 - t) * m_dPoints[1].y + 3 * t2 * (1 - t) * m_dPoints[2].y + t3 * m_dPoints[3].y; return 3 * t * (1 - t) * (1 - t) * m_vPoints[1].y + 3 * t2 * (1 - t) * m_vPoints[2].y + t3 * m_vPoints[3].y;
} }
// Todo: this probably can be done better and faster // Todo: this probably can be done better and faster

4
src/helpers/BezierCurve.hpp
View file

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <deque> #include <vector>
#include <array> #include <array>
#include <vector> #include <vector>
#include "math/Math.hpp" #include "math/Math.hpp"
@ -22,7 +22,7 @@ class CBezierCurve {
private: private:
// this INCLUDES the 0,0 and 1,1 points. // this INCLUDES the 0,0 and 1,1 points.
std::vector<Vector2D> m_dPoints; std::vector<Vector2D> m_vPoints;
std::array<Vector2D, BAKEDPOINTS> m_aPointsBaked; std::array<Vector2D, BAKEDPOINTS> m_aPointsBaked;
}; };

4
src/helpers/Monitor.cpp
View file

@ -314,7 +314,7 @@ void CMonitor::onDisconnect(bool destroy) {
g_pCompositor->warpCursorTo(BACKUPMON->vecPosition + BACKUPMON->vecTransformedSize / 2.F, true); g_pCompositor->warpCursorTo(BACKUPMON->vecPosition + BACKUPMON->vecTransformedSize / 2.F, true);
// move workspaces // move workspaces
std::deque<PHLWORKSPACE> wspToMove; std::vector<PHLWORKSPACE> wspToMove;
for (auto const& w : g_pCompositor->m_vWorkspaces) { for (auto const& w : g_pCompositor->m_vWorkspaces) {
if (w->m_pMonitor == self || !w->m_pMonitor) if (w->m_pMonitor == self || !w->m_pMonitor)
wspToMove.push_back(w); wspToMove.push_back(w);
@ -541,7 +541,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
} }
// move all the WS // move all the WS
std::deque<PHLWORKSPACE> wspToMove; std::vector<PHLWORKSPACE> wspToMove;
for (auto const& w : g_pCompositor->m_vWorkspaces) { for (auto const& w : g_pCompositor->m_vWorkspaces) {
if (w->m_pMonitor == self || !w->m_pMonitor) if (w->m_pMonitor == self || !w->m_pMonitor)
wspToMove.push_back(w); wspToMove.push_back(w);

2
src/helpers/Monitor.hpp
View file

@ -1,7 +1,7 @@
#pragma once #pragma once
#include "../defines.hpp" #include "../defines.hpp"
#include <deque> #include <vector>
#include "WLClasses.hpp" #include "WLClasses.hpp"
#include <vector> #include <vector>
#include <array> #include <array>

24
src/layout/DwindleLayout.cpp
View file

@ -38,13 +38,12 @@ void SDwindleNodeData::recalcSizePosRecursive(bool force, bool horizontalOverrid
} }
} }
void SDwindleNodeData::getAllChildrenRecursive(std::deque<SDwindleNodeData*>* pDeque) { void SDwindleNodeData::getAllChildrenRecursive(std::vector<SDwindleNodeData*>* pVec) {
if (children[0]) { if (children[0]) {
children[0]->getAllChildrenRecursive(pDeque); children[0]->getAllChildrenRecursive(pVec);
children[1]->getAllChildrenRecursive(pDeque); children[1]->getAllChildrenRecursive(pVec);
} else { } else
pDeque->push_back(this); pVec->push_back(this);
}
} }
int CHyprDwindleLayout::getNodesOnWorkspace(const WORKSPACEID& id) { int CHyprDwindleLayout::getNodesOnWorkspace(const WORKSPACEID& id) {
@ -805,14 +804,13 @@ void CHyprDwindleLayout::recalculateWindow(PHLWINDOW pWindow) {
PNODE->recalcSizePosRecursive(); PNODE->recalcSizePosRecursive();
} }
void addToDequeRecursive(std::deque<SDwindleNodeData*>* pDeque, std::deque<SDwindleNodeData*>* pParents, SDwindleNodeData* node) { static void addToVectorRecursive(std::vector<SDwindleNodeData*>* pVec, std::vector<SDwindleNodeData*>* pParents, SDwindleNodeData* node) {
if (node->isNode) { if (node->isNode) {
pParents->push_back(node); pParents->emplace_back(node);
addToDequeRecursive(pDeque, pParents, node->children[0]); addToVectorRecursive(pVec, pParents, node->children[0]);
addToDequeRecursive(pDeque, pParents, node->children[1]); addToVectorRecursive(pVec, pParents, node->children[1]);
} else { } else
pDeque->emplace_back(node); pVec->emplace_back(node);
}
} }
SWindowRenderLayoutHints CHyprDwindleLayout::requestRenderHints(PHLWINDOW pWindow) { SWindowRenderLayoutHints CHyprDwindleLayout::requestRenderHints(PHLWINDOW pWindow) {

4
src/layout/DwindleLayout.hpp
View file

@ -4,7 +4,7 @@
#include "../desktop/DesktopTypes.hpp" #include "../desktop/DesktopTypes.hpp"
#include <list> #include <list>
#include <deque> #include <vector>
#include <array> #include <array>
#include <optional> #include <optional>
#include <format> #include <format>
@ -39,7 +39,7 @@ struct SDwindleNodeData {
} }
void recalcSizePosRecursive(bool force = false, bool horizontalOverride = false, bool verticalOverride = false); void recalcSizePosRecursive(bool force = false, bool horizontalOverride = false, bool verticalOverride = false);
void getAllChildrenRecursive(std::deque<SDwindleNodeData*>*); void getAllChildrenRecursive(std::vector<SDwindleNodeData*>*);
CHyprDwindleLayout* layout = nullptr; CHyprDwindleLayout* layout = nullptr;
}; };

2
src/layout/MasterLayout.hpp
View file

@ -5,7 +5,7 @@
#include "../config/ConfigManager.hpp" #include "../config/ConfigManager.hpp"
#include <vector> #include <vector>
#include <list> #include <list>
#include <deque> #include <vector>
#include <any> #include <any>
enum eFullscreenMode : int8_t; enum eFullscreenMode : int8_t;

2
src/managers/AnimationManager.cpp
View file

@ -301,7 +301,7 @@ void CAnimationManager::tick() {
g_pCompositor->scheduleFrameForMonitor(PMONITOR, Aquamarine::IOutput::AQ_SCHEDULE_ANIMATION); g_pCompositor->scheduleFrameForMonitor(PMONITOR, Aquamarine::IOutput::AQ_SCHEDULE_ANIMATION);
} }
// do it here, because if this alters the animation vars deque we would be in trouble above. // do it here, because if this alters the animation vars vec we would be in trouble above.
for (auto const& ave : animationEndedVars) { for (auto const& ave : animationEndedVars) {
ave->onAnimationEnd(); ave->onAnimationEnd();
} }

2
src/managers/EventManager.cpp
View file

@ -116,7 +116,7 @@ int CEventManager::onClientEvent(int fd, uint32_t mask) {
if (write(CLIENTIT->fd, event->c_str(), event->length()) < 0) if (write(CLIENTIT->fd, event->c_str(), event->length()) < 0)
break; break;
CLIENTIT->events.pop_front(); CLIENTIT->events.erase(CLIENTIT->events.begin());
} }
// stop polling when we sent all events // stop polling when we sent all events

8
src/managers/EventManager.hpp
View file

@ -1,5 +1,5 @@
#pragma once #pragma once
#include <deque> #include <vector>
#include <vector> #include <vector>
#include "../defines.hpp" #include "../defines.hpp"
@ -27,9 +27,9 @@ class CEventManager {
int onClientEvent(int fd, uint32_t mask); int onClientEvent(int fd, uint32_t mask);
struct SClient { struct SClient {
int fd = -1; int fd = -1;
std::deque<SP<std::string>> events; std::vector<SP<std::string>> events;
wl_event_source* eventSource = nullptr; wl_event_source* eventSource = nullptr;
}; };
std::vector<SClient>::iterator findClientByFD(int fd); std::vector<SClient>::iterator findClientByFD(int fd);

2
src/managers/KeybindManager.cpp
View file

@ -1776,7 +1776,7 @@ SDispatchResult CKeybindManager::workspaceOpt(std::string args) {
// apply // apply
// we make a copy because changeWindowFloatingMode might invalidate the iterator // we make a copy because changeWindowFloatingMode might invalidate the iterator
std::deque<PHLWINDOW> ptrs; std::vector<PHLWINDOW> ptrs;
for (auto const& w : g_pCompositor->m_vWindows) for (auto const& w : g_pCompositor->m_vWindows)
ptrs.push_back(w); ptrs.push_back(w);

56
src/managers/KeybindManager.hpp
View file

@ -1,7 +1,7 @@
#pragma once #pragma once
#include "../defines.hpp" #include "../defines.hpp"
#include <deque> #include <vector>
#include <set> #include <set>
#include <unordered_map> #include <unordered_map>
#include <functional> #include <functional>
@ -116,45 +116,45 @@ class CKeybindManager {
static SDispatchResult changeMouseBindMode(const eMouseBindMode mode); static SDispatchResult changeMouseBindMode(const eMouseBindMode mode);
private: private:
std::deque<SPressedKeyWithMods> m_dPressedKeys; std::vector<SPressedKeyWithMods> m_dPressedKeys;
inline static std::string m_szCurrentSelectedSubmap = ""; inline static std::string m_szCurrentSelectedSubmap = "";
std::vector<WP<SKeybind>> m_vActiveKeybinds; std::vector<WP<SKeybind>> m_vActiveKeybinds;
WP<SKeybind> m_pLastLongPressKeybind; WP<SKeybind> m_pLastLongPressKeybind;
SP<CEventLoopTimer> m_pLongPressTimer, m_pRepeatKeyTimer; SP<CEventLoopTimer> m_pLongPressTimer, m_pRepeatKeyTimer;
uint32_t m_uTimeLastMs = 0; uint32_t m_uTimeLastMs = 0;
uint32_t m_uLastCode = 0; uint32_t m_uLastCode = 0;
uint32_t m_uLastMouseCode = 0; uint32_t m_uLastMouseCode = 0;
std::vector<WP<SKeybind>> m_vPressedSpecialBinds; std::vector<WP<SKeybind>> m_vPressedSpecialBinds;
int m_iPassPressed = -1; // used for pass int m_iPassPressed = -1; // used for pass
CTimer m_tScrollTimer; CTimer m_tScrollTimer;
SDispatchResult handleKeybinds(const uint32_t, const SPressedKeyWithMods&, bool); SDispatchResult handleKeybinds(const uint32_t, const SPressedKeyWithMods&, bool);
std::set<xkb_keysym_t> m_sMkKeys = {}; std::set<xkb_keysym_t> m_sMkKeys = {};
std::set<xkb_keysym_t> m_sMkMods = {}; std::set<xkb_keysym_t> m_sMkMods = {};
eMultiKeyCase mkBindMatches(const SP<SKeybind>); eMultiKeyCase mkBindMatches(const SP<SKeybind>);
eMultiKeyCase mkKeysymSetMatches(const std::set<xkb_keysym_t>, const std::set<xkb_keysym_t>); eMultiKeyCase mkKeysymSetMatches(const std::set<xkb_keysym_t>, const std::set<xkb_keysym_t>);
bool handleInternalKeybinds(xkb_keysym_t); bool handleInternalKeybinds(xkb_keysym_t);
bool handleVT(xkb_keysym_t); bool handleVT(xkb_keysym_t);
xkb_state* m_pXKBTranslationState = nullptr; xkb_state* m_pXKBTranslationState = nullptr;
void updateXKBTranslationState(); void updateXKBTranslationState();
bool ensureMouseBindState(); bool ensureMouseBindState();
static bool tryMoveFocusToMonitor(PHLMONITOR monitor); static bool tryMoveFocusToMonitor(PHLMONITOR monitor);
static void moveWindowOutOfGroup(PHLWINDOW pWindow, const std::string& dir = ""); static void moveWindowOutOfGroup(PHLWINDOW pWindow, const std::string& dir = "");
static void moveWindowIntoGroup(PHLWINDOW pWindow, PHLWINDOW pWindowInDirection); static void moveWindowIntoGroup(PHLWINDOW pWindow, PHLWINDOW pWindowInDirection);
static void switchToWindow(PHLWINDOW PWINDOWTOCHANGETO); static void switchToWindow(PHLWINDOW PWINDOWTOCHANGETO);
static uint64_t spawnRawProc(std::string, PHLWORKSPACE pInitialWorkspace); static uint64_t spawnRawProc(std::string, PHLWORKSPACE pInitialWorkspace);
static uint64_t spawnWithRules(std::string, PHLWORKSPACE pInitialWorkspace); static uint64_t spawnWithRules(std::string, PHLWORKSPACE pInitialWorkspace);
// -------------- Dispatchers -------------- // // -------------- Dispatchers -------------- //
static SDispatchResult killActive(std::string); static SDispatchResult killActive(std::string);

2
src/managers/input/InputManager.hpp
View file

@ -163,7 +163,7 @@ class CInputManager {
std::list<SSwitchDevice> m_lSwitches; std::list<SSwitchDevice> m_lSwitches;
// Exclusive layer surfaces // Exclusive layer surfaces
std::deque<PHLLSREF> m_dExclusiveLSes; std::vector<PHLLSREF> m_dExclusiveLSes;
// constraints // constraints
std::vector<WP<CPointerConstraint>> m_vConstraints; std::vector<WP<CPointerConstraint>> m_vConstraints;

1
src/pch/pch.hpp
View file

@ -5,7 +5,6 @@
#include <array> #include <array>
#include <chrono> #include <chrono>
#include <concepts> #include <concepts>
#include <deque>
#include <filesystem> #include <filesystem>
#include <fstream> #include <fstream>
#include <functional> #include <functional>

30
src/render/decorations/CHyprGroupBarDecoration.hpp
View file

@ -2,7 +2,7 @@
#include "IHyprWindowDecoration.hpp" #include "IHyprWindowDecoration.hpp"
#include "../../devices/IPointer.hpp" #include "../../devices/IPointer.hpp"
#include <deque> #include <vector>
#include "../Texture.hpp" #include "../Texture.hpp"
#include <string> #include <string>
#include <memory> #include <memory>
@ -48,29 +48,29 @@ class CHyprGroupBarDecoration : public IHyprWindowDecoration {
virtual std::string getDisplayName(); virtual std::string getDisplayName();
private: private:
SBoxExtents m_seExtents; SBoxExtents m_seExtents;
CBox m_bAssignedBox = {0}; CBox m_bAssignedBox = {0};
PHLWINDOWREF m_pWindow; PHLWINDOWREF m_pWindow;
std::deque<PHLWINDOWREF> m_dwGroupMembers; std::vector<PHLWINDOWREF> m_dwGroupMembers;
float m_fBarWidth; float m_fBarWidth;
float m_fBarHeight; float m_fBarHeight;
CTitleTex* textureFromTitle(const std::string&); CTitleTex* textureFromTitle(const std::string&);
void invalidateTextures(); void invalidateTextures();
CBox assignedBoxGlobal(); CBox assignedBoxGlobal();
bool onBeginWindowDragOnDeco(const Vector2D&); bool onBeginWindowDragOnDeco(const Vector2D&);
bool onEndWindowDragOnDeco(const Vector2D&, PHLWINDOW); bool onEndWindowDragOnDeco(const Vector2D&, PHLWINDOW);
bool onMouseButtonOnDeco(const Vector2D&, const IPointer::SButtonEvent&); bool onMouseButtonOnDeco(const Vector2D&, const IPointer::SButtonEvent&);
bool onScrollOnDeco(const Vector2D&, const IPointer::SAxisEvent); bool onScrollOnDeco(const Vector2D&, const IPointer::SAxisEvent);
struct STitleTexs { struct STitleTexs {
// STitleTexs* overriden = nullptr; // TODO: make shit shared in-group to decrease VRAM usage. // STitleTexs* overriden = nullptr; // TODO: make shit shared in-group to decrease VRAM usage.
std::deque<std::unique_ptr<CTitleTex>> titleTexs; std::vector<std::unique_ptr<CTitleTex>> titleTexs;
} m_sTitleTexs; } m_sTitleTexs;
}; };