twin/hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/Hyprland.git synced 2025-05-19 08:30:22 -07:00
Code Issues Packages Projects Releases Wiki Activity

core: move all shared_ptrs from the STL to hyprutils (#9143)

Browse Source
This commit is contained in:
Vaxry 2025-01-23 21:55:41 +01:00 committed by GitHub
parent ae403e6a05
commit 0a1ae48a9f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
152 changed files with 297 additions and 349 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -104,7 +104,7 @@ find_package(OpenGL REQUIRED COMPONENTS ${GLES_VERSION})
pkg_check_modules(aquamarine_dep REQUIRED IMPORTED_TARGET aquamarine>=0.4.5) pkg_check_modules(aquamarine_dep REQUIRED IMPORTED_TARGET aquamarine>=0.4.5)
pkg_check_modules(hyprlang_dep REQUIRED IMPORTED_TARGET hyprlang>=0.3.2) pkg_check_modules(hyprlang_dep REQUIRED IMPORTED_TARGET hyprlang>=0.3.2)
pkg_check_modules(hyprcursor_dep REQUIRED IMPORTED_TARGET hyprcursor>=0.1.7) pkg_check_modules(hyprcursor_dep REQUIRED IMPORTED_TARGET hyprcursor>=0.1.7)
pkg_check_modules(hyprutils_dep REQUIRED IMPORTED_TARGET hyprutils>=0.3.3) pkg_check_modules(hyprutils_dep REQUIRED IMPORTED_TARGET hyprutils>=0.4.0)
pkg_check_modules(hyprgraphics_dep REQUIRED IMPORTED_TARGET hyprgraphics>=0.1.1) pkg_check_modules(hyprgraphics_dep REQUIRED IMPORTED_TARGET hyprgraphics>=0.1.1)
add_compile_definitions(AQUAMARINE_VERSION="${aquamarine_dep_VERSION}") add_compile_definitions(AQUAMARINE_VERSION="${aquamarine_dep_VERSION}")

56
src/Compositor.cpp
View File

@ -586,92 +586,92 @@ void CCompositor::initManagers(eManagersInitStage stage) {
switch (stage) { switch (stage) {
case STAGE_PRIORITY: { case STAGE_PRIORITY: {
Debug::log(LOG, "Creating the EventLoopManager!"); Debug::log(LOG, "Creating the EventLoopManager!");
g_pEventLoopManager = std::make_unique<CEventLoopManager>(m_sWLDisplay, m_sWLEventLoop); g_pEventLoopManager = makeUnique<CEventLoopManager>(m_sWLDisplay, m_sWLEventLoop);
Debug::log(LOG, "Creating the HookSystem!"); Debug::log(LOG, "Creating the HookSystem!");
g_pHookSystem = std::make_unique<CHookSystemManager>(); g_pHookSystem = makeUnique<CHookSystemManager>();
Debug::log(LOG, "Creating the KeybindManager!"); Debug::log(LOG, "Creating the KeybindManager!");
g_pKeybindManager = std::make_unique<CKeybindManager>(); g_pKeybindManager = makeUnique<CKeybindManager>();
Debug::log(LOG, "Creating the AnimationManager!"); Debug::log(LOG, "Creating the AnimationManager!");
g_pAnimationManager = std::make_unique<CHyprAnimationManager>(); g_pAnimationManager = makeUnique<CHyprAnimationManager>();
Debug::log(LOG, "Creating the ConfigManager!"); Debug::log(LOG, "Creating the ConfigManager!");
g_pConfigManager = std::make_unique<CConfigManager>(); g_pConfigManager = makeUnique<CConfigManager>();
Debug::log(LOG, "Creating the CHyprError!"); Debug::log(LOG, "Creating the CHyprError!");
g_pHyprError = std::make_unique<CHyprError>(); g_pHyprError = makeUnique<CHyprError>();
Debug::log(LOG, "Creating the LayoutManager!"); Debug::log(LOG, "Creating the LayoutManager!");
g_pLayoutManager = std::make_unique<CLayoutManager>(); g_pLayoutManager = makeUnique<CLayoutManager>();
Debug::log(LOG, "Creating the TokenManager!"); Debug::log(LOG, "Creating the TokenManager!");
g_pTokenManager = std::make_unique<CTokenManager>(); g_pTokenManager = makeUnique<CTokenManager>();
g_pConfigManager->init(); g_pConfigManager->init();
g_pWatchdog = std::make_unique<CWatchdog>(); // requires config g_pWatchdog = makeUnique<CWatchdog>(); // requires config
// wait for watchdog to initialize to not hit data races in reading config values. // wait for watchdog to initialize to not hit data races in reading config values.
while (!g_pWatchdog->m_bWatchdogInitialized) { while (!g_pWatchdog->m_bWatchdogInitialized) {
std::this_thread::yield(); std::this_thread::yield();
} }
Debug::log(LOG, "Creating the PointerManager!"); Debug::log(LOG, "Creating the PointerManager!");
g_pPointerManager = std::make_unique<CPointerManager>(); g_pPointerManager = makeUnique<CPointerManager>();
Debug::log(LOG, "Creating the EventManager!"); Debug::log(LOG, "Creating the EventManager!");
g_pEventManager = std::make_unique<CEventManager>(); g_pEventManager = makeUnique<CEventManager>();
} break; } break;
case STAGE_BASICINIT: { case STAGE_BASICINIT: {
Debug::log(LOG, "Creating the CHyprOpenGLImpl!"); Debug::log(LOG, "Creating the CHyprOpenGLImpl!");
g_pHyprOpenGL = std::make_unique<CHyprOpenGLImpl>(); g_pHyprOpenGL = makeUnique<CHyprOpenGLImpl>();
Debug::log(LOG, "Creating the ProtocolManager!"); Debug::log(LOG, "Creating the ProtocolManager!");
g_pProtocolManager = std::make_unique<CProtocolManager>(); g_pProtocolManager = makeUnique<CProtocolManager>();
Debug::log(LOG, "Creating the SeatManager!"); Debug::log(LOG, "Creating the SeatManager!");
g_pSeatManager = std::make_unique<CSeatManager>(); g_pSeatManager = makeUnique<CSeatManager>();
} break; } break;
case STAGE_LATE: { case STAGE_LATE: {
Debug::log(LOG, "Creating CHyprCtl"); Debug::log(LOG, "Creating CHyprCtl");
g_pHyprCtl = std::make_unique<CHyprCtl>(); g_pHyprCtl = makeUnique<CHyprCtl>();
Debug::log(LOG, "Creating the InputManager!"); Debug::log(LOG, "Creating the InputManager!");
g_pInputManager = std::make_unique<CInputManager>(); g_pInputManager = makeUnique<CInputManager>();
Debug::log(LOG, "Creating the HyprRenderer!"); Debug::log(LOG, "Creating the HyprRenderer!");
g_pHyprRenderer = std::make_unique<CHyprRenderer>(); g_pHyprRenderer = makeUnique<CHyprRenderer>();
Debug::log(LOG, "Creating the XWaylandManager!"); Debug::log(LOG, "Creating the XWaylandManager!");
g_pXWaylandManager = std::make_unique<CHyprXWaylandManager>(); g_pXWaylandManager = makeUnique<CHyprXWaylandManager>();
Debug::log(LOG, "Creating the SessionLockManager!"); Debug::log(LOG, "Creating the SessionLockManager!");
g_pSessionLockManager = std::make_unique<CSessionLockManager>(); g_pSessionLockManager = makeUnique<CSessionLockManager>();
Debug::log(LOG, "Creating the HyprDebugOverlay!"); Debug::log(LOG, "Creating the HyprDebugOverlay!");
g_pDebugOverlay = std::make_unique<CHyprDebugOverlay>(); g_pDebugOverlay = makeUnique<CHyprDebugOverlay>();
Debug::log(LOG, "Creating the HyprNotificationOverlay!"); Debug::log(LOG, "Creating the HyprNotificationOverlay!");
g_pHyprNotificationOverlay = std::make_unique<CHyprNotificationOverlay>(); g_pHyprNotificationOverlay = makeUnique<CHyprNotificationOverlay>();
Debug::log(LOG, "Creating the PluginSystem!"); Debug::log(LOG, "Creating the PluginSystem!");
g_pPluginSystem = std::make_unique<CPluginSystem>(); g_pPluginSystem = makeUnique<CPluginSystem>();
g_pConfigManager->handlePluginLoads(); g_pConfigManager->handlePluginLoads();
Debug::log(LOG, "Creating the DecorationPositioner!"); Debug::log(LOG, "Creating the DecorationPositioner!");
g_pDecorationPositioner = std::make_unique<CDecorationPositioner>(); g_pDecorationPositioner = makeUnique<CDecorationPositioner>();
Debug::log(LOG, "Creating the CursorManager!"); Debug::log(LOG, "Creating the CursorManager!");
g_pCursorManager = std::make_unique<CCursorManager>(); g_pCursorManager = makeUnique<CCursorManager>();
Debug::log(LOG, "Creating the VersionKeeper!"); Debug::log(LOG, "Creating the VersionKeeper!");
g_pVersionKeeperMgr = std::make_unique<CVersionKeeperManager>(); g_pVersionKeeperMgr = makeUnique<CVersionKeeperManager>();
Debug::log(LOG, "Creating the DonationNag!"); Debug::log(LOG, "Creating the DonationNag!");
g_pDonationNagManager = std::make_unique<CDonationNagManager>(); g_pDonationNagManager = makeUnique<CDonationNagManager>();
Debug::log(LOG, "Starting XWayland"); Debug::log(LOG, "Starting XWayland");
g_pXWayland = std::make_unique<CXWayland>(g_pCompositor->m_bWantsXwayland); g_pXWayland = makeUnique<CXWayland>(g_pCompositor->m_bWantsXwayland);
} break; } break;
default: UNREACHABLE(); default: UNREACHABLE();
} }
@ -2701,7 +2701,7 @@ void CCompositor::moveWindowToWorkspaceSafe(PHLWINDOW pWindow, PHLWORKSPACE pWor
g_pLayoutManager->getCurrentLayout()->recalculateWindow(pWindow); g_pLayoutManager->getCurrentLayout()->recalculateWindow(pWindow);
if (!pWindow->getDecorationByType(DECORATION_GROUPBAR)) if (!pWindow->getDecorationByType(DECORATION_GROUPBAR))
pWindow->addWindowDeco(std::make_unique<CHyprGroupBarDecoration>(pWindow)); pWindow->addWindowDeco(makeUnique<CHyprGroupBarDecoration>(pWindow));
} else { } else {
if (!pWindow->m_bIsFloating) if (!pWindow->m_bIsFloating)

4
src/Compositor.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <list> #include <list>
#include <sys/resource.h> #include <sys/resource.h>
@ -10,6 +9,7 @@
#include "managers/SessionLockManager.hpp" #include "managers/SessionLockManager.hpp"
#include "desktop/Window.hpp" #include "desktop/Window.hpp"
#include "protocols/types/ColorManagement.hpp" #include "protocols/types/ColorManagement.hpp"
#include "helpers/memory/Memory.hpp"
#include <aquamarine/backend/Backend.hpp> #include <aquamarine/backend/Backend.hpp>
#include <aquamarine/output/Output.hpp> #include <aquamarine/output/Output.hpp>
@ -170,4 +170,4 @@ class CCompositor {
rlimit m_sOriginalNofile = {0}; rlimit m_sOriginalNofile = {0};
}; };
inline std::unique_ptr<CCompositor> g_pCompositor; inline UP<CCompositor> g_pCompositor;

10
src/config/ConfigManager.cpp
View File

@ -44,6 +44,7 @@
#include <unordered_set> #include <unordered_set>
#include <hyprutils/string/String.hpp> #include <hyprutils/string/String.hpp>
#include <filesystem> #include <filesystem>
#include <memory>
using namespace Hyprutils::String; using namespace Hyprutils::String;
using namespace Hyprutils::Animation; using namespace Hyprutils::Animation;
@ -374,7 +375,7 @@ CConfigManager::CConfigManager() {
const auto ERR = verifyConfigExists(); const auto ERR = verifyConfigExists();
m_configPaths.emplace_back(getMainConfigPath()); m_configPaths.emplace_back(getMainConfigPath());
m_pConfig = std::make_unique<Hyprlang::CConfig>(m_configPaths.begin()->c_str(), Hyprlang::SConfigOptions{.throwAllErrors = true, .allowMissingConfig = true}); m_pConfig = makeUnique<Hyprlang::CConfig>(m_configPaths.begin()->c_str(), Hyprlang::SConfigOptions{.throwAllErrors = true, .allowMissingConfig = true});
m_pConfig->addConfigValue("general:border_size", Hyprlang::INT{1}); m_pConfig->addConfigValue("general:border_size", Hyprlang::INT{1});
m_pConfig->addConfigValue("general:no_border_on_floating", Hyprlang::INT{0}); m_pConfig->addConfigValue("general:no_border_on_floating", Hyprlang::INT{0});
@ -955,9 +956,8 @@ void CConfigManager::postConfigReload(const Hyprlang::CParseResult& result) {
// enable/disable xwayland usage // enable/disable xwayland usage
if (!isFirstLaunch) { if (!isFirstLaunch) {
bool prevEnabledXwayland = g_pXWayland->enabled(); bool prevEnabledXwayland = g_pXWayland->enabled();
if (g_pCompositor->m_bWantsXwayland != prevEnabledXwayland) { if (g_pCompositor->m_bWantsXwayland != prevEnabledXwayland)
g_pXWayland = std::make_unique<CXWayland>(g_pCompositor->m_bWantsXwayland); g_pXWayland = makeUnique<CXWayland>(g_pCompositor->m_bWantsXwayland);
}
} else } else
g_pCompositor->m_bWantsXwayland = PENABLEXWAYLAND; g_pCompositor->m_bWantsXwayland = PENABLEXWAYLAND;
#endif #endif
@ -1659,7 +1659,7 @@ void CConfigManager::addExecRule(const SExecRequestedRule& rule) {
} }
void CConfigManager::handlePluginLoads() { void CConfigManager::handlePluginLoads() {
if (g_pPluginSystem == nullptr) if (!g_pPluginSystem)
return; return;
bool pluginsChanged = false; bool pluginsChanged = false;

4
src/config/ConfigManager.hpp
View File

@ -262,7 +262,7 @@ class CConfigManager {
bool isLaunchingExecOnce = false; // For exec-once to skip initial ws tracking bool isLaunchingExecOnce = false; // For exec-once to skip initial ws tracking
private: private:
std::unique_ptr<Hyprlang::CConfig> m_pConfig; UP<Hyprlang::CConfig> m_pConfig;
std::vector<std::string> m_configPaths; std::vector<std::string> m_configPaths;
@ -303,4 +303,4 @@ class CConfigManager {
SWorkspaceRule mergeWorkspaceRules(const SWorkspaceRule&, const SWorkspaceRule&); SWorkspaceRule mergeWorkspaceRules(const SWorkspaceRule&, const SWorkspaceRule&);
}; };
inline std::unique_ptr<CConfigManager> g_pConfigManager; inline UP<CConfigManager> g_pConfigManager;

4
src/config/ConfigWatcher.hpp
View File

@ -1,5 +1,5 @@
#pragma once #pragma once
#include <memory> #include "../helpers/memory/Memory.hpp"
#include <vector> #include <vector>
#include <string> #include <string>
#include <functional> #include <functional>
@ -29,4 +29,4 @@ class CConfigWatcher {
int m_inotifyFd = -1; int m_inotifyFd = -1;
}; };
inline std::unique_ptr<CConfigWatcher> g_pConfigWatcher = std::make_unique<CConfigWatcher>(); inline UP<CConfigWatcher> g_pConfigWatcher = makeUnique<CConfigWatcher>();

2
src/debug/HyprCtl.hpp
View File

@ -38,4 +38,4 @@ class CHyprCtl {
std::string m_socketPath; std::string m_socketPath;
}; };
inline std::unique_ptr<CHyprCtl> g_pHyprCtl; inline UP<CHyprCtl> g_pHyprCtl;

2
src/debug/HyprDebugOverlay.hpp
View File

@ -48,4 +48,4 @@ class CHyprDebugOverlay {
friend class CHyprRenderer; friend class CHyprRenderer;
}; };
inline std::unique_ptr<CHyprDebugOverlay> g_pDebugOverlay; inline UP<CHyprDebugOverlay> g_pDebugOverlay;

2
src/debug/HyprNotificationOverlay.cpp
View File

@ -40,7 +40,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_vNotifications.emplace_back(std::make_unique<SNotification>()).get(); const auto PNOTIF = m_vNotifications.emplace_back(makeUnique<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;

18
src/debug/HyprNotificationOverlay.hpp
View File

@ -46,18 +46,18 @@ class CHyprNotificationOverlay {
bool hasAny(); bool hasAny();
private: private:
CBox drawNotifications(PHLMONITOR pMonitor); CBox drawNotifications(PHLMONITOR pMonitor);
CBox m_bLastDamage; CBox m_bLastDamage;
std::vector<std::unique_ptr<SNotification>> m_vNotifications; std::vector<UP<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 UP<CHyprNotificationOverlay> g_pHyprNotificationOverlay;

2
src/desktop/LayerRule.cpp
View File

@ -1,7 +1,7 @@
#include <re2/re2.h>
#include "LayerRule.hpp" #include "LayerRule.hpp"
#include <unordered_set> #include <unordered_set>
#include <algorithm> #include <algorithm>
#include <re2/re2.h>
#include "../debug/Log.hpp" #include "../debug/Log.hpp"
static const auto RULES = std::unordered_set<std::string>{"noanim", "blur", "blurpopups", "dimaround"}; static const auto RULES = std::unordered_set<std::string>{"noanim", "blur", "blurpopups", "dimaround"};

2
src/desktop/LayerSurface.cpp
View File

@ -32,7 +32,7 @@ PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
pLS->szNamespace = resource->layerNamespace; pLS->szNamespace = resource->layerNamespace;
pLS->layer = resource->current.layer; pLS->layer = resource->current.layer;
pLS->popupHead = std::make_unique<CPopup>(pLS); pLS->popupHead = makeUnique<CPopup>(pLS);
pLS->monitor = pMonitor; pLS->monitor = pMonitor;
pMonitor->m_aLayerSurfaceLayers[resource->current.layer].emplace_back(pLS); pMonitor->m_aLayerSurfaceLayers[resource->current.layer].emplace_back(pLS);

2
src/desktop/LayerSurface.hpp
View File

@ -59,7 +59,7 @@ class CLayerSurface {
CBox geometry = {0, 0, 0, 0}; CBox geometry = {0, 0, 0, 0};
Vector2D position; Vector2D position;
std::string szNamespace = ""; std::string szNamespace = "";
std::unique_ptr<CPopup> popupHead; UP<CPopup> popupHead;
void onDestroy(); void onDestroy();
void onMap(); void onMap();

2
src/desktop/Popup.cpp
View File

@ -89,7 +89,7 @@ void CPopup::onMap() {
g_pInputManager->simulateMouseMovement(); g_pInputManager->simulateMouseMovement();
m_pSubsurfaceHead = std::make_unique<CSubsurface>(this); m_pSubsurfaceHead = makeUnique<CSubsurface>(this);
//unconstrain(); //unconstrain();
sendScale(); sendScale();

6
src/desktop/Popup.hpp
View File

@ -1,9 +1,9 @@
#pragma once #pragma once
#include <vector> #include <vector>
#include <memory>
#include "Subsurface.hpp" #include "Subsurface.hpp"
#include "../helpers/signal/Signal.hpp" #include "../helpers/signal/Signal.hpp"
#include "../helpers/memory/Memory.hpp"
class CXDGPopupResource; class CXDGPopupResource;
@ -61,8 +61,8 @@ class CPopup {
bool m_bInert = false; bool m_bInert = false;
// //
std::vector<SP<CPopup>> m_vChildren; std::vector<SP<CPopup>> m_vChildren;
std::unique_ptr<CSubsurface> m_pSubsurfaceHead; UP<CSubsurface> m_pSubsurfaceHead;
struct { struct {
CHyprSignalListener newPopup; CHyprSignalListener newPopup;

5
src/desktop/Rule.cpp
View File

@ -1,12 +1,13 @@
#include "Rule.hpp"
#include <re2/re2.h> #include <re2/re2.h>
#include "../helpers/memory/Memory.hpp"
#include "Rule.hpp"
#include "../debug/Log.hpp" #include "../debug/Log.hpp"
CRuleRegexContainer::CRuleRegexContainer(const std::string& regex_) { CRuleRegexContainer::CRuleRegexContainer(const std::string& regex_) {
const bool NEGATIVE = regex_.starts_with("negative:"); const bool NEGATIVE = regex_.starts_with("negative:");
negative = NEGATIVE; negative = NEGATIVE;
regex = std::make_unique<RE2>(NEGATIVE ? regex_.substr(9) : regex_); regex = makeUnique<RE2>(NEGATIVE ? regex_.substr(9) : regex_);
// TODO: maybe pop an error? // TODO: maybe pop an error?
if (!regex->ok()) if (!regex->ok())

6
src/desktop/Rule.hpp
View File

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <memory> #include <hyprutils/memory/UniquePtr.hpp>
//NOLINTNEXTLINE //NOLINTNEXTLINE
namespace re2 { namespace re2 {
@ -16,6 +16,6 @@ class CRuleRegexContainer {
bool passes(const std::string& str) const; bool passes(const std::string& str) const;
private: private:
std::unique_ptr<re2::RE2> regex; Hyprutils::Memory::CUniquePointer<re2::RE2> regex;
bool negative = false; bool negative = false;
}; };

4
src/desktop/Subsurface.cpp
View File

@ -126,9 +126,9 @@ void CSubsurface::onNewSubsurface(SP<CWLSubsurfaceResource> pSubsurface) {
CSubsurface* PSUBSURFACE = nullptr; CSubsurface* PSUBSURFACE = nullptr;
if (!m_pWindowParent.expired()) if (!m_pWindowParent.expired())
PSUBSURFACE = m_vChildren.emplace_back(std::make_unique<CSubsurface>(pSubsurface, m_pWindowParent.lock())).get(); PSUBSURFACE = m_vChildren.emplace_back(makeUnique<CSubsurface>(pSubsurface, m_pWindowParent.lock())).get();
else if (m_pPopupParent) else if (m_pPopupParent)
PSUBSURFACE = m_vChildren.emplace_back(std::make_unique<CSubsurface>(pSubsurface, m_pPopupParent)).get(); PSUBSURFACE = m_vChildren.emplace_back(makeUnique<CSubsurface>(pSubsurface, m_pPopupParent)).get();
ASSERT(PSUBSURFACE); ASSERT(PSUBSURFACE);

16
src/desktop/Subsurface.hpp
View File

@ -48,16 +48,16 @@ class CSubsurface {
Vector2D m_vLastSize = {}; Vector2D m_vLastSize = {};
// if nullptr, means it's a dummy node // if nullptr, means it's a dummy node
CSubsurface* m_pParent = nullptr; CSubsurface* m_pParent = nullptr;
PHLWINDOWREF m_pWindowParent; PHLWINDOWREF m_pWindowParent;
CPopup* m_pPopupParent = nullptr; CPopup* m_pPopupParent = nullptr;
std::vector<std::unique_ptr<CSubsurface>> m_vChildren; std::vector<UP<CSubsurface>> m_vChildren;
bool m_bInert = false; bool m_bInert = false;
void initSignals(); void initSignals();
void initExistingSubsurfaces(SP<CWLSurfaceResource> pSurface); void initExistingSubsurfaces(SP<CWLSurfaceResource> pSurface);
void checkSiblingDamage(); void checkSiblingDamage();
}; };

18
src/desktop/Window.cpp
View File

@ -47,8 +47,8 @@ PHLWINDOW CWindow::create(SP<CXWaylandSurface> surface) {
g_pAnimationManager->createAnimation(0.f, pWindow->m_fMovingToWorkspaceAlpha, g_pConfigManager->getAnimationPropertyConfig("fadeOut"), pWindow, AVARDAMAGE_ENTIRE); g_pAnimationManager->createAnimation(0.f, pWindow->m_fMovingToWorkspaceAlpha, g_pConfigManager->getAnimationPropertyConfig("fadeOut"), pWindow, AVARDAMAGE_ENTIRE);
g_pAnimationManager->createAnimation(0.f, pWindow->m_fMovingFromWorkspaceAlpha, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE); g_pAnimationManager->createAnimation(0.f, pWindow->m_fMovingFromWorkspaceAlpha, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
pWindow->addWindowDeco(std::make_unique<CHyprDropShadowDecoration>(pWindow)); pWindow->addWindowDeco(makeUnique<CHyprDropShadowDecoration>(pWindow));
pWindow->addWindowDeco(std::make_unique<CHyprBorderDecoration>(pWindow)); pWindow->addWindowDeco(makeUnique<CHyprBorderDecoration>(pWindow));
return pWindow; return pWindow;
} }
@ -70,8 +70,8 @@ PHLWINDOW CWindow::create(SP<CXDGSurfaceResource> resource) {
g_pAnimationManager->createAnimation(0.f, pWindow->m_fMovingToWorkspaceAlpha, g_pConfigManager->getAnimationPropertyConfig("fadeOut"), pWindow, AVARDAMAGE_ENTIRE); g_pAnimationManager->createAnimation(0.f, pWindow->m_fMovingToWorkspaceAlpha, g_pConfigManager->getAnimationPropertyConfig("fadeOut"), pWindow, AVARDAMAGE_ENTIRE);
g_pAnimationManager->createAnimation(0.f, pWindow->m_fMovingFromWorkspaceAlpha, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE); g_pAnimationManager->createAnimation(0.f, pWindow->m_fMovingFromWorkspaceAlpha, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), pWindow, AVARDAMAGE_ENTIRE);
pWindow->addWindowDeco(std::make_unique<CHyprDropShadowDecoration>(pWindow)); pWindow->addWindowDeco(makeUnique<CHyprDropShadowDecoration>(pWindow));
pWindow->addWindowDeco(std::make_unique<CHyprBorderDecoration>(pWindow)); pWindow->addWindowDeco(makeUnique<CHyprBorderDecoration>(pWindow));
pWindow->m_pWLSurface->assign(pWindow->m_pXDGSurface->surface.lock(), pWindow); pWindow->m_pWLSurface->assign(pWindow->m_pXDGSurface->surface.lock(), pWindow);
@ -296,7 +296,7 @@ void CWindow::updateWindowDecos() {
} }
} }
void CWindow::addWindowDeco(std::unique_ptr<IHyprWindowDecoration> deco) { void CWindow::addWindowDeco(UP<IHyprWindowDecoration> deco) {
m_dWindowDecorations.emplace_back(std::move(deco)); m_dWindowDecorations.emplace_back(std::move(deco));
g_pDecorationPositioner->forceRecalcFor(m_pSelf.lock()); g_pDecorationPositioner->forceRecalcFor(m_pSelf.lock());
updateWindowDecos(); updateWindowDecos();
@ -567,8 +567,8 @@ void CWindow::onMap() {
if (m_bIsX11) if (m_bIsX11)
return; return;
m_pSubsurfaceHead = std::make_unique<CSubsurface>(m_pSelf.lock()); m_pSubsurfaceHead = makeUnique<CSubsurface>(m_pSelf.lock());
m_pPopupHead = std::make_unique<CPopup>(m_pSelf.lock()); m_pPopupHead = makeUnique<CPopup>(m_pSelf.lock());
} }
void CWindow::onBorderAngleAnimEnd(WP<CBaseAnimatedVariable> pav) { void CWindow::onBorderAngleAnimEnd(WP<CBaseAnimatedVariable> pav) {
@ -870,7 +870,7 @@ void CWindow::createGroup() {
m_sGroupData.locked = false; m_sGroupData.locked = false;
m_sGroupData.deny = false; m_sGroupData.deny = false;
addWindowDeco(std::make_unique<CHyprGroupBarDecoration>(m_pSelf.lock())); addWindowDeco(makeUnique<CHyprGroupBarDecoration>(m_pSelf.lock()));
if (m_pWorkspace) { if (m_pWorkspace) {
m_pWorkspace->updateWindows(); m_pWorkspace->updateWindows();
@ -1052,7 +1052,7 @@ void CWindow::insertWindowToGroup(PHLWINDOW pWindow) {
const auto ENDAT = m_sGroupData.pNextWindow.lock(); const auto ENDAT = m_sGroupData.pNextWindow.lock();
if (!pWindow->getDecorationByType(DECORATION_GROUPBAR)) if (!pWindow->getDecorationByType(DECORATION_GROUPBAR))
pWindow->addWindowDeco(std::make_unique<CHyprGroupBarDecoration>(pWindow)); pWindow->addWindowDeco(makeUnique<CHyprGroupBarDecoration>(pWindow));
if (!pWindow->m_sGroupData.pNextWindow.lock()) { if (!pWindow->m_sGroupData.pNextWindow.lock()) {
BEGINAT->m_sGroupData.pNextWindow = pWindow; BEGINAT->m_sGroupData.pNextWindow = pWindow;

12
src/desktop/Window.hpp
View File

@ -296,8 +296,8 @@ class CWindow {
uint64_t m_eSuppressedEvents = SUPPRESS_NONE; uint64_t m_eSuppressedEvents = SUPPRESS_NONE;
// desktop components // desktop components
std::unique_ptr<CSubsurface> m_pSubsurfaceHead; UP<CSubsurface> m_pSubsurfaceHead;
std::unique_ptr<CPopup> m_pPopupHead; UP<CPopup> m_pPopupHead;
// Animated border // Animated border
CGradientValueData m_cRealBorderColor = {0}; CGradientValueData m_cRealBorderColor = {0};
@ -328,14 +328,14 @@ class CWindow {
// Window decorations // Window decorations
// TODO: make this a SP. // TODO: make this a SP.
std::vector<std::unique_ptr<IHyprWindowDecoration>> m_dWindowDecorations; std::vector<UP<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;
// Transformers // Transformers
std::vector<std::unique_ptr<IWindowTransformer>> m_vTransformers; std::vector<UP<IWindowTransformer>> m_vTransformers;
// for alpha // for alpha
PHLANIMVAR<float> m_fActiveInactiveAlpha; PHLANIMVAR<float> m_fActiveInactiveAlpha;
@ -396,7 +396,7 @@ class CWindow {
SBoxExtents getFullWindowExtents(); SBoxExtents getFullWindowExtents();
CBox getWindowBoxUnified(uint64_t props); CBox getWindowBoxUnified(uint64_t props);
CBox getWindowIdealBoundingBoxIgnoreReserved(); CBox getWindowIdealBoundingBoxIgnoreReserved();
void addWindowDeco(std::unique_ptr<IHyprWindowDecoration> deco); void addWindowDeco(UP<IHyprWindowDecoration> deco);
void updateWindowDecos(); void updateWindowDecos();
void removeWindowDeco(IHyprWindowDecoration* deco); void removeWindowDeco(IHyprWindowDecoration* deco);
void uncacheWindowDecos(); void uncacheWindowDecos();

2
src/helpers/Monitor.hpp
View File

@ -8,7 +8,7 @@
#include "WLClasses.hpp" #include "WLClasses.hpp"
#include <vector> #include <vector>
#include <array> #include <array>
#include <memory>
#include <xf86drmMode.h> #include <xf86drmMode.h>
#include "Timer.hpp" #include "Timer.hpp"
#include "math/Math.hpp" #include "math/Math.hpp"

2
src/helpers/SdDaemon.cpp
View File

@ -1,7 +1,7 @@
#include "SdDaemon.hpp" #include "SdDaemon.hpp"
#include "memory/Memory.hpp"
#include <memory> #include <memory>
#include <fcntl.h> #include <fcntl.h>
#include <unistd.h> #include <unistd.h>
#include <cerrno> #include <cerrno>

2
src/helpers/Watchdog.cpp
View File

@ -14,7 +14,7 @@ CWatchdog::~CWatchdog() {
CWatchdog::CWatchdog() : m_iMainThreadPID(pthread_self()) { CWatchdog::CWatchdog() : m_iMainThreadPID(pthread_self()) {
m_pWatchdog = std::make_unique<std::thread>([this] { m_pWatchdog = makeUnique<std::thread>([this] {
static auto PTIMEOUT = CConfigValue<Hyprlang::INT>("debug:watchdog_timeout"); static auto PTIMEOUT = CConfigValue<Hyprlang::INT>("debug:watchdog_timeout");
m_bWatchdogInitialized = true; m_bWatchdogInitialized = true;

6
src/helpers/Watchdog.hpp
View File

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <memory> #include "memory/Memory.hpp"
#include <chrono> #include <chrono>
#include <thread> #include <thread>
#include <condition_variable> #include <condition_variable>
@ -24,11 +24,11 @@ class CWatchdog {
std::atomic<bool> m_bWatching = false; std::atomic<bool> m_bWatching = false;
std::atomic<bool> m_bWillWatch = false; std::atomic<bool> m_bWillWatch = false;
std::unique_ptr<std::thread> m_pWatchdog; UP<std::thread> m_pWatchdog;
std::mutex m_mWatchdogMutex; std::mutex m_mWatchdogMutex;
std::atomic<bool> m_bNotified = false; std::atomic<bool> m_bNotified = false;
std::atomic<bool> m_bExitThread = false; std::atomic<bool> m_bExitThread = false;
std::condition_variable m_cvWatchdogCondition; std::condition_variable m_cvWatchdogCondition;
}; };
inline std::unique_ptr<CWatchdog> g_pWatchdog; inline UP<CWatchdog> g_pWatchdog;

2
src/helpers/memory/Memory.hpp
View File

@ -7,4 +7,4 @@ using namespace Hyprutils::Memory;
#define SP Hyprutils::Memory::CSharedPointer #define SP Hyprutils::Memory::CSharedPointer
#define WP Hyprutils::Memory::CWeakPointer #define WP Hyprutils::Memory::CWeakPointer
#define UP std::unique_ptr #define UP Hyprutils::Memory::CUniquePointer

2
src/hyprerror/HyprError.hpp
View File

@ -32,4 +32,4 @@ class CHyprError {
bool m_bMonitorChanged = false; bool m_bMonitorChanged = false;
}; };
inline std::unique_ptr<CHyprError> g_pHyprError; // This is a full-screen error. Treat it with respect, and there can only be one at a time. inline UP<CHyprError> g_pHyprError; // This is a full-screen error. Treat it with respect, and there can only be one at a time.

4
src/layout/IHyprLayout.cpp
View File

@ -215,7 +215,7 @@ bool IHyprLayout::onWindowCreatedAutoGroup(PHLWINDOW pWindow) {
recalculateWindow(pWindow); recalculateWindow(pWindow);
if (!pWindow->getDecorationByType(DECORATION_GROUPBAR)) if (!pWindow->getDecorationByType(DECORATION_GROUPBAR))
pWindow->addWindowDeco(std::make_unique<CHyprGroupBarDecoration>(pWindow)); pWindow->addWindowDeco(makeUnique<CHyprGroupBarDecoration>(pWindow));
return true; return true;
} }
@ -374,7 +374,7 @@ void IHyprLayout::onEndDragWindow() {
DRAGGINGWINDOW->updateWindowDecos(); DRAGGINGWINDOW->updateWindowDecos();
if (!DRAGGINGWINDOW->getDecorationByType(DECORATION_GROUPBAR)) if (!DRAGGINGWINDOW->getDecorationByType(DECORATION_GROUPBAR))
DRAGGINGWINDOW->addWindowDeco(std::make_unique<CHyprGroupBarDecoration>(DRAGGINGWINDOW)); DRAGGINGWINDOW->addWindowDeco(makeUnique<CHyprGroupBarDecoration>(DRAGGINGWINDOW));
} }
} }
} }

2
src/main.cpp
View File

@ -155,7 +155,7 @@ int main(int argc, char** argv) {
// let's init the compositor. // let's init the compositor.
// it initializes basic Wayland stuff in the constructor. // it initializes basic Wayland stuff in the constructor.
try { try {
g_pCompositor = std::make_unique<CCompositor>(); g_pCompositor = makeUnique<CCompositor>();
g_pCompositor->explicitConfigPath = configPath; g_pCompositor->explicitConfigPath = configPath;
} catch (const std::exception& e) { } catch (const std::exception& e) {
std::println(stderr, "Hyprland threw in ctor: {}\nCannot continue.", e.what()); std::println(stderr, "Hyprland threw in ctor: {}\nCannot continue.", e.what());

2
src/managers/AnimationManager.hpp
View File

@ -61,4 +61,4 @@ class CHyprAnimationManager : public Hyprutils::Animation::CAnimationManager {
void animationSlide(PHLWINDOW, std::string force = "", bool close = false); void animationSlide(PHLWINDOW, std::string force = "", bool close = false);
}; };
inline std::unique_ptr<CHyprAnimationManager> g_pAnimationManager; inline UP<CHyprAnimationManager> g_pAnimationManager;

6
src/managers/CursorManager.cpp
View File

@ -64,8 +64,8 @@ void CCursorBuffer::endDataPtr() {
} }
CCursorManager::CCursorManager() { CCursorManager::CCursorManager() {
m_pHyprcursor = std::make_unique<Hyprcursor::CHyprcursorManager>(m_szTheme.empty() ? nullptr : m_szTheme.c_str(), hcLogger); m_pHyprcursor = makeUnique<Hyprcursor::CHyprcursorManager>(m_szTheme.empty() ? nullptr : m_szTheme.c_str(), hcLogger);
m_pXcursor = std::make_unique<CXCursorManager>(); m_pXcursor = makeUnique<CXCursorManager>();
static auto PUSEHYPRCURSOR = CConfigValue<Hyprlang::INT>("cursor:enable_hyprcursor"); static auto PUSEHYPRCURSOR = CConfigValue<Hyprlang::INT>("cursor:enable_hyprcursor");
if (m_pHyprcursor->valid() && *PUSEHYPRCURSOR) { if (m_pHyprcursor->valid() && *PUSEHYPRCURSOR) {
@ -323,7 +323,7 @@ bool CCursorManager::changeTheme(const std::string& name, const int size) {
m_szTheme = name.empty() ? "" : name; m_szTheme = name.empty() ? "" : name;
m_iSize = size; m_iSize = size;
m_pHyprcursor = std::make_unique<Hyprcursor::CHyprcursorManager>(m_szTheme.empty() ? nullptr : m_szTheme.c_str(), options); m_pHyprcursor = makeUnique<Hyprcursor::CHyprcursorManager>(m_szTheme.empty() ? nullptr : m_szTheme.c_str(), options);
if (!m_pHyprcursor->valid()) { if (!m_pHyprcursor->valid()) {
Debug::log(ERR, "Hyprcursor failed loading theme \"{}\", falling back to XCursor.", m_szTheme); Debug::log(ERR, "Hyprcursor failed loading theme \"{}\", falling back to XCursor.", m_szTheme);
m_pXcursor->loadTheme(m_szTheme.empty() ? xcursor_theme : m_szTheme, m_iSize, m_fCursorScale); m_pXcursor->loadTheme(m_szTheme.empty() ? xcursor_theme : m_szTheme, m_iSize, m_fCursorScale);

27
src/managers/CursorManager.hpp
View File

@ -2,7 +2,6 @@
#include <string> #include <string>
#include <hyprcursor/hyprcursor.hpp> #include <hyprcursor/hyprcursor.hpp>
#include <memory>
#include "../includes.hpp" #include "../includes.hpp"
#include "../helpers/math/Math.hpp" #include "../helpers/math/Math.hpp"
#include "../helpers/memory/Memory.hpp" #include "../helpers/memory/Memory.hpp"
@ -58,22 +57,22 @@ class CCursorManager {
void tickAnimatedCursor(); void tickAnimatedCursor();
private: private:
bool m_bOurBufferConnected = false; bool m_bOurBufferConnected = false;
std::vector<SP<CCursorBuffer>> m_vCursorBuffers; std::vector<SP<CCursorBuffer>> m_vCursorBuffers;
std::unique_ptr<Hyprcursor::CHyprcursorManager> m_pHyprcursor; UP<Hyprcursor::CHyprcursorManager> m_pHyprcursor;
std::unique_ptr<CXCursorManager> m_pXcursor; UP<CXCursorManager> m_pXcursor;
SP<SXCursors> m_currentXcursor; SP<SXCursors> m_currentXcursor;
std::string m_szTheme = ""; std::string m_szTheme = "";
int m_iSize = 0; int m_iSize = 0;
float m_fCursorScale = 1.0; float m_fCursorScale = 1.0;
Hyprcursor::SCursorStyleInfo m_sCurrentStyleInfo; Hyprcursor::SCursorStyleInfo m_sCurrentStyleInfo;
SP<CEventLoopTimer> m_pAnimationTimer; SP<CEventLoopTimer> m_pAnimationTimer;
int m_iCurrentAnimationFrame = 0; int m_iCurrentAnimationFrame = 0;
Hyprcursor::SCursorShapeData m_sCurrentCursorShapeData; Hyprcursor::SCursorShapeData m_sCurrentCursorShapeData;
}; };
inline std::unique_ptr<CCursorManager> g_pCursorManager; inline UP<CCursorManager> g_pCursorManager;

4
src/managers/DonationNagManager.hpp
View File

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <memory> #include "../helpers/memory/Memory.hpp"
class CDonationNagManager { class CDonationNagManager {
public: public:
@ -13,4 +13,4 @@ class CDonationNagManager {
bool m_bFired = false; bool m_bFired = false;
}; };
inline std::unique_ptr<CDonationNagManager> g_pDonationNagManager; inline UP<CDonationNagManager> g_pDonationNagManager;

2
src/managers/EventManager.hpp
View File

@ -42,4 +42,4 @@ class CEventManager {
std::vector<SClient> m_vClients; std::vector<SClient> m_vClients;
}; };
inline std::unique_ptr<CEventManager> g_pEventManager; inline UP<CEventManager> g_pEventManager;

2
src/managers/HookSystemManager.hpp
View File

@ -57,4 +57,4 @@ class CHookSystemManager {
std::unordered_map<std::string, std::vector<SCallbackFNPtr>> m_mRegisteredHooks; std::unordered_map<std::string, std::vector<SCallbackFNPtr>> m_mRegisteredHooks;
}; };
inline std::unique_ptr<CHookSystemManager> g_pHookSystem; inline UP<CHookSystemManager> g_pHookSystem;

2
src/managers/KeybindManager.cpp
View File

@ -2840,7 +2840,7 @@ void CKeybindManager::moveWindowIntoGroup(PHLWINDOW pWindow, PHLWINDOW pWindowIn
pWindow->warpCursor(); pWindow->warpCursor();
if (!pWindow->getDecorationByType(DECORATION_GROUPBAR)) if (!pWindow->getDecorationByType(DECORATION_GROUPBAR))
pWindow->addWindowDeco(std::make_unique<CHyprGroupBarDecoration>(pWindow)); pWindow->addWindowDeco(makeUnique<CHyprGroupBarDecoration>(pWindow));
g_pEventManager->postEvent(SHyprIPCEvent{"moveintogroup", std::format("{:x}", (uintptr_t)pWindow.get())}); g_pEventManager->postEvent(SHyprIPCEvent{"moveintogroup", std::format("{:x}", (uintptr_t)pWindow.get())});
} }

2
src/managers/KeybindManager.hpp
View File

@ -229,4 +229,4 @@ class CKeybindManager {
friend class CPointerManager; friend class CPointerManager;
}; };
inline std::unique_ptr<CKeybindManager> g_pKeybindManager; inline UP<CKeybindManager> g_pKeybindManager;

2
src/managers/LayoutManager.hpp
View File

@ -28,4 +28,4 @@ class CLayoutManager {
std::vector<std::pair<std::string, IHyprLayout*>> m_vLayouts; std::vector<std::pair<std::string, IHyprLayout*>> m_vLayouts;
}; };
inline std::unique_ptr<CLayoutManager> g_pLayoutManager; inline UP<CLayoutManager> g_pLayoutManager;

108
src/managers/ProtocolManager.cpp
View File

@ -119,75 +119,75 @@ CProtocolManager::CProtocolManager() {
}); });
// Core // Core
PROTO::seat = std::make_unique<CWLSeatProtocol>(&wl_seat_interface, 9, "WLSeat"); PROTO::seat = makeUnique<CWLSeatProtocol>(&wl_seat_interface, 9, "WLSeat");
PROTO::data = std::make_unique<CWLDataDeviceProtocol>(&wl_data_device_manager_interface, 3, "WLDataDevice"); PROTO::data = makeUnique<CWLDataDeviceProtocol>(&wl_data_device_manager_interface, 3, "WLDataDevice");
PROTO::compositor = std::make_unique<CWLCompositorProtocol>(&wl_compositor_interface, 6, "WLCompositor"); PROTO::compositor = makeUnique<CWLCompositorProtocol>(&wl_compositor_interface, 6, "WLCompositor");
PROTO::subcompositor = std::make_unique<CWLSubcompositorProtocol>(&wl_subcompositor_interface, 1, "WLSubcompositor"); PROTO::subcompositor = makeUnique<CWLSubcompositorProtocol>(&wl_subcompositor_interface, 1, "WLSubcompositor");
PROTO::shm = std::make_unique<CWLSHMProtocol>(&wl_shm_interface, 1, "WLSHM"); PROTO::shm = makeUnique<CWLSHMProtocol>(&wl_shm_interface, 1, "WLSHM");
// Extensions // Extensions
PROTO::viewport = std::make_unique<CViewporterProtocol>(&wp_viewporter_interface, 1, "Viewporter"); PROTO::viewport = makeUnique<CViewporterProtocol>(&wp_viewporter_interface, 1, "Viewporter");
PROTO::tearing = std::make_unique<CTearingControlProtocol>(&wp_tearing_control_manager_v1_interface, 1, "TearingControl"); PROTO::tearing = makeUnique<CTearingControlProtocol>(&wp_tearing_control_manager_v1_interface, 1, "TearingControl");
PROTO::fractional = std::make_unique<CFractionalScaleProtocol>(&wp_fractional_scale_manager_v1_interface, 1, "FractionalScale"); PROTO::fractional = makeUnique<CFractionalScaleProtocol>(&wp_fractional_scale_manager_v1_interface, 1, "FractionalScale");
PROTO::xdgOutput = std::make_unique<CXDGOutputProtocol>(&zxdg_output_manager_v1_interface, 3, "XDGOutput"); PROTO::xdgOutput = makeUnique<CXDGOutputProtocol>(&zxdg_output_manager_v1_interface, 3, "XDGOutput");
PROTO::cursorShape = std::make_unique<CCursorShapeProtocol>(&wp_cursor_shape_manager_v1_interface, 1, "CursorShape"); PROTO::cursorShape = makeUnique<CCursorShapeProtocol>(&wp_cursor_shape_manager_v1_interface, 1, "CursorShape");
PROTO::idleInhibit = std::make_unique<CIdleInhibitProtocol>(&zwp_idle_inhibit_manager_v1_interface, 1, "IdleInhibit"); PROTO::idleInhibit = makeUnique<CIdleInhibitProtocol>(&zwp_idle_inhibit_manager_v1_interface, 1, "IdleInhibit");
PROTO::relativePointer = std::make_unique<CRelativePointerProtocol>(&zwp_relative_pointer_manager_v1_interface, 1, "RelativePointer"); PROTO::relativePointer = makeUnique<CRelativePointerProtocol>(&zwp_relative_pointer_manager_v1_interface, 1, "RelativePointer");
PROTO::xdgDecoration = std::make_unique<CXDGDecorationProtocol>(&zxdg_decoration_manager_v1_interface, 1, "XDGDecoration"); PROTO::xdgDecoration = makeUnique<CXDGDecorationProtocol>(&zxdg_decoration_manager_v1_interface, 1, "XDGDecoration");
PROTO::alphaModifier = std::make_unique<CAlphaModifierProtocol>(&wp_alpha_modifier_v1_interface, 1, "AlphaModifier"); PROTO::alphaModifier = makeUnique<CAlphaModifierProtocol>(&wp_alpha_modifier_v1_interface, 1, "AlphaModifier");
PROTO::gamma = std::make_unique<CGammaControlProtocol>(&zwlr_gamma_control_manager_v1_interface, 1, "GammaControl"); PROTO::gamma = makeUnique<CGammaControlProtocol>(&zwlr_gamma_control_manager_v1_interface, 1, "GammaControl");
PROTO::foreignToplevel = std::make_unique<CForeignToplevelProtocol>(&ext_foreign_toplevel_list_v1_interface, 1, "ForeignToplevel"); PROTO::foreignToplevel = makeUnique<CForeignToplevelProtocol>(&ext_foreign_toplevel_list_v1_interface, 1, "ForeignToplevel");
PROTO::pointerGestures = std::make_unique<CPointerGesturesProtocol>(&zwp_pointer_gestures_v1_interface, 3, "PointerGestures"); PROTO::pointerGestures = makeUnique<CPointerGesturesProtocol>(&zwp_pointer_gestures_v1_interface, 3, "PointerGestures");
PROTO::foreignToplevelWlr = std::make_unique<CForeignToplevelWlrProtocol>(&zwlr_foreign_toplevel_manager_v1_interface, 3, "ForeignToplevelWlr"); PROTO::foreignToplevelWlr = makeUnique<CForeignToplevelWlrProtocol>(&zwlr_foreign_toplevel_manager_v1_interface, 3, "ForeignToplevelWlr");
PROTO::shortcutsInhibit = std::make_unique<CKeyboardShortcutsInhibitProtocol>(&zwp_keyboard_shortcuts_inhibit_manager_v1_interface, 1, "ShortcutsInhibit"); PROTO::shortcutsInhibit = makeUnique<CKeyboardShortcutsInhibitProtocol>(&zwp_keyboard_shortcuts_inhibit_manager_v1_interface, 1, "ShortcutsInhibit");
PROTO::textInputV1 = std::make_unique<CTextInputV1Protocol>(&zwp_text_input_manager_v1_interface, 1, "TextInputV1"); PROTO::textInputV1 = makeUnique<CTextInputV1Protocol>(&zwp_text_input_manager_v1_interface, 1, "TextInputV1");
PROTO::textInputV3 = std::make_unique<CTextInputV3Protocol>(&zwp_text_input_manager_v3_interface, 1, "TextInputV3"); PROTO::textInputV3 = makeUnique<CTextInputV3Protocol>(&zwp_text_input_manager_v3_interface, 1, "TextInputV3");
PROTO::constraints = std::make_unique<CPointerConstraintsProtocol>(&zwp_pointer_constraints_v1_interface, 1, "PointerConstraints"); PROTO::constraints = makeUnique<CPointerConstraintsProtocol>(&zwp_pointer_constraints_v1_interface, 1, "PointerConstraints");
PROTO::outputPower = std::make_unique<COutputPowerProtocol>(&zwlr_output_power_manager_v1_interface, 1, "OutputPower"); PROTO::outputPower = makeUnique<COutputPowerProtocol>(&zwlr_output_power_manager_v1_interface, 1, "OutputPower");
PROTO::activation = std::make_unique<CXDGActivationProtocol>(&xdg_activation_v1_interface, 1, "XDGActivation"); PROTO::activation = makeUnique<CXDGActivationProtocol>(&xdg_activation_v1_interface, 1, "XDGActivation");
PROTO::idle = std::make_unique<CIdleNotifyProtocol>(&ext_idle_notifier_v1_interface, 1, "IdleNotify"); PROTO::idle = makeUnique<CIdleNotifyProtocol>(&ext_idle_notifier_v1_interface, 1, "IdleNotify");
PROTO::lockNotify = std::make_unique<CLockNotifyProtocol>(&hyprland_lock_notifier_v1_interface, 1, "IdleNotify"); PROTO::lockNotify = makeUnique<CLockNotifyProtocol>(&hyprland_lock_notifier_v1_interface, 1, "IdleNotify");
PROTO::sessionLock = std::make_unique<CSessionLockProtocol>(&ext_session_lock_manager_v1_interface, 1, "SessionLock"); PROTO::sessionLock = makeUnique<CSessionLockProtocol>(&ext_session_lock_manager_v1_interface, 1, "SessionLock");
PROTO::ime = std::make_unique<CInputMethodV2Protocol>(&zwp_input_method_manager_v2_interface, 1, "IMEv2"); PROTO::ime = makeUnique<CInputMethodV2Protocol>(&zwp_input_method_manager_v2_interface, 1, "IMEv2");
PROTO::virtualKeyboard = std::make_unique<CVirtualKeyboardProtocol>(&zwp_virtual_keyboard_manager_v1_interface, 1, "VirtualKeyboard"); PROTO::virtualKeyboard = makeUnique<CVirtualKeyboardProtocol>(&zwp_virtual_keyboard_manager_v1_interface, 1, "VirtualKeyboard");
PROTO::virtualPointer = std::make_unique<CVirtualPointerProtocol>(&zwlr_virtual_pointer_manager_v1_interface, 2, "VirtualPointer"); PROTO::virtualPointer = makeUnique<CVirtualPointerProtocol>(&zwlr_virtual_pointer_manager_v1_interface, 2, "VirtualPointer");
PROTO::outputManagement = std::make_unique<COutputManagementProtocol>(&zwlr_output_manager_v1_interface, 4, "OutputManagement"); PROTO::outputManagement = makeUnique<COutputManagementProtocol>(&zwlr_output_manager_v1_interface, 4, "OutputManagement");
PROTO::serverDecorationKDE = std::make_unique<CServerDecorationKDEProtocol>(&org_kde_kwin_server_decoration_manager_interface, 1, "ServerDecorationKDE"); PROTO::serverDecorationKDE = makeUnique<CServerDecorationKDEProtocol>(&org_kde_kwin_server_decoration_manager_interface, 1, "ServerDecorationKDE");
PROTO::focusGrab = std::make_unique<CFocusGrabProtocol>(&hyprland_focus_grab_manager_v1_interface, 1, "FocusGrab"); PROTO::focusGrab = makeUnique<CFocusGrabProtocol>(&hyprland_focus_grab_manager_v1_interface, 1, "FocusGrab");
PROTO::tablet = std::make_unique<CTabletV2Protocol>(&zwp_tablet_manager_v2_interface, 1, "TabletV2"); PROTO::tablet = makeUnique<CTabletV2Protocol>(&zwp_tablet_manager_v2_interface, 1, "TabletV2");
PROTO::layerShell = std::make_unique<CLayerShellProtocol>(&zwlr_layer_shell_v1_interface, 5, "LayerShell"); PROTO::layerShell = makeUnique<CLayerShellProtocol>(&zwlr_layer_shell_v1_interface, 5, "LayerShell");
PROTO::presentation = std::make_unique<CPresentationProtocol>(&wp_presentation_interface, 1, "Presentation"); PROTO::presentation = makeUnique<CPresentationProtocol>(&wp_presentation_interface, 1, "Presentation");
PROTO::xdgShell = std::make_unique<CXDGShellProtocol>(&xdg_wm_base_interface, 6, "XDGShell"); PROTO::xdgShell = makeUnique<CXDGShellProtocol>(&xdg_wm_base_interface, 6, "XDGShell");
PROTO::dataWlr = std::make_unique<CDataDeviceWLRProtocol>(&zwlr_data_control_manager_v1_interface, 2, "DataDeviceWlr"); PROTO::dataWlr = makeUnique<CDataDeviceWLRProtocol>(&zwlr_data_control_manager_v1_interface, 2, "DataDeviceWlr");
PROTO::primarySelection = std::make_unique<CPrimarySelectionProtocol>(&zwp_primary_selection_device_manager_v1_interface, 1, "PrimarySelection"); PROTO::primarySelection = makeUnique<CPrimarySelectionProtocol>(&zwp_primary_selection_device_manager_v1_interface, 1, "PrimarySelection");
PROTO::xwaylandShell = std::make_unique<CXWaylandShellProtocol>(&xwayland_shell_v1_interface, 1, "XWaylandShell"); PROTO::xwaylandShell = makeUnique<CXWaylandShellProtocol>(&xwayland_shell_v1_interface, 1, "XWaylandShell");
PROTO::screencopy = std::make_unique<CScreencopyProtocol>(&zwlr_screencopy_manager_v1_interface, 3, "Screencopy"); PROTO::screencopy = makeUnique<CScreencopyProtocol>(&zwlr_screencopy_manager_v1_interface, 3, "Screencopy");
PROTO::toplevelExport = std::make_unique<CToplevelExportProtocol>(&hyprland_toplevel_export_manager_v1_interface, 2, "ToplevelExport"); PROTO::toplevelExport = makeUnique<CToplevelExportProtocol>(&hyprland_toplevel_export_manager_v1_interface, 2, "ToplevelExport");
PROTO::globalShortcuts = std::make_unique<CGlobalShortcutsProtocol>(&hyprland_global_shortcuts_manager_v1_interface, 1, "GlobalShortcuts"); PROTO::globalShortcuts = makeUnique<CGlobalShortcutsProtocol>(&hyprland_global_shortcuts_manager_v1_interface, 1, "GlobalShortcuts");
PROTO::xdgDialog = std::make_unique<CXDGDialogProtocol>(&xdg_dialog_v1_interface, 1, "XDGDialog"); PROTO::xdgDialog = makeUnique<CXDGDialogProtocol>(&xdg_dialog_v1_interface, 1, "XDGDialog");
PROTO::singlePixel = std::make_unique<CSinglePixelProtocol>(&wp_single_pixel_buffer_manager_v1_interface, 1, "SinglePixel"); PROTO::singlePixel = makeUnique<CSinglePixelProtocol>(&wp_single_pixel_buffer_manager_v1_interface, 1, "SinglePixel");
PROTO::securityContext = std::make_unique<CSecurityContextProtocol>(&wp_security_context_manager_v1_interface, 1, "SecurityContext"); PROTO::securityContext = makeUnique<CSecurityContextProtocol>(&wp_security_context_manager_v1_interface, 1, "SecurityContext");
PROTO::ctm = std::make_unique<CHyprlandCTMControlProtocol>(&hyprland_ctm_control_manager_v1_interface, 1, "CTMControl"); PROTO::ctm = makeUnique<CHyprlandCTMControlProtocol>(&hyprland_ctm_control_manager_v1_interface, 1, "CTMControl");
PROTO::hyprlandSurface = std::make_unique<CHyprlandSurfaceProtocol>(&hyprland_surface_manager_v1_interface, 1, "HyprlandSurface"); PROTO::hyprlandSurface = makeUnique<CHyprlandSurfaceProtocol>(&hyprland_surface_manager_v1_interface, 1, "HyprlandSurface");
if (*PENABLEXXCM) { if (*PENABLEXXCM) {
PROTO::colorManagement = std::make_unique<CColorManagementProtocol>(&xx_color_manager_v4_interface, 1, "ColorManagement"); PROTO::colorManagement = makeUnique<CColorManagementProtocol>(&xx_color_manager_v4_interface, 1, "ColorManagement");
PROTO::frogColorManagement = std::make_unique<CFrogColorManagementProtocol>(&frog_color_management_factory_v1_interface, 1, "FrogColorManagement"); PROTO::frogColorManagement = makeUnique<CFrogColorManagementProtocol>(&frog_color_management_factory_v1_interface, 1, "FrogColorManagement");
} }
for (auto const& b : g_pCompositor->m_pAqBackend->getImplementations()) { for (auto const& b : g_pCompositor->m_pAqBackend->getImplementations()) {
if (b->type() != Aquamarine::AQ_BACKEND_DRM) if (b->type() != Aquamarine::AQ_BACKEND_DRM)
continue; continue;
PROTO::lease = std::make_unique<CDRMLeaseProtocol>(&wp_drm_lease_device_v1_interface, 1, "DRMLease"); PROTO::lease = makeUnique<CDRMLeaseProtocol>(&wp_drm_lease_device_v1_interface, 1, "DRMLease");
if (*PENABLEEXPLICIT) if (*PENABLEEXPLICIT)
PROTO::sync = std::make_unique<CDRMSyncobjProtocol>(&wp_linux_drm_syncobj_manager_v1_interface, 1, "DRMSyncobj"); PROTO::sync = makeUnique<CDRMSyncobjProtocol>(&wp_linux_drm_syncobj_manager_v1_interface, 1, "DRMSyncobj");
break; break;
} }
if (g_pHyprOpenGL->getDRMFormats().size() > 0) { if (g_pHyprOpenGL->getDRMFormats().size() > 0) {
PROTO::mesaDRM = std::make_unique<CMesaDRMProtocol>(&wl_drm_interface, 2, "MesaDRM"); PROTO::mesaDRM = makeUnique<CMesaDRMProtocol>(&wl_drm_interface, 2, "MesaDRM");
PROTO::linuxDma = std::make_unique<CLinuxDMABufV1Protocol>(&zwp_linux_dmabuf_v1_interface, 5, "LinuxDMABUF"); PROTO::linuxDma = makeUnique<CLinuxDMABufV1Protocol>(&zwp_linux_dmabuf_v1_interface, 5, "LinuxDMABUF");
} else } else
Debug::log(WARN, "ProtocolManager: Not binding linux-dmabuf and MesaDRM: DMABUF not available"); Debug::log(WARN, "ProtocolManager: Not binding linux-dmabuf and MesaDRM: DMABUF not available");
} }

2
src/managers/ProtocolManager.hpp
View File

@ -18,4 +18,4 @@ class CProtocolManager {
void onMonitorModeChange(PHLMONITOR pMonitor); void onMonitorModeChange(PHLMONITOR pMonitor);
}; };
inline std::unique_ptr<CProtocolManager> g_pProtocolManager; inline UP<CProtocolManager> g_pProtocolManager;

4
src/managers/SessionLockManager.cpp
View File

@ -57,7 +57,7 @@ void CSessionLockManager::onNewSessionLock(SP<CSessionLock> pLock) {
Debug::log(LOG, "Session got locked by {:x}", (uintptr_t)pLock.get()); Debug::log(LOG, "Session got locked by {:x}", (uintptr_t)pLock.get());
m_pSessionLock = std::make_unique<SSessionLock>(); m_pSessionLock = makeUnique<SSessionLock>();
m_pSessionLock->lock = pLock; m_pSessionLock->lock = pLock;
m_pSessionLock->mLockTimer.reset(); m_pSessionLock->mLockTimer.reset();
@ -66,7 +66,7 @@ void CSessionLockManager::onNewSessionLock(SP<CSessionLock> pLock) {
const auto PMONITOR = SURFACE->monitor(); const auto PMONITOR = SURFACE->monitor();
const auto NEWSURFACE = m_pSessionLock->vSessionLockSurfaces.emplace_back(std::make_unique<SSessionLockSurface>(SURFACE)).get(); const auto NEWSURFACE = m_pSessionLock->vSessionLockSurfaces.emplace_back(makeUnique<SSessionLockSurface>(SURFACE)).get();
NEWSURFACE->iMonitorID = PMONITOR->ID; NEWSURFACE->iMonitorID = PMONITOR->ID;
PROTO::fractional->sendScale(SURFACE->surface(), PMONITOR->scale); PROTO::fractional->sendScale(SURFACE->surface(), PMONITOR->scale);
}); });

10
src/managers/SessionLockManager.hpp
View File

@ -28,11 +28,11 @@ struct SSessionLockSurface {
}; };
struct SSessionLock { struct SSessionLock {
WP<CSessionLock> lock; WP<CSessionLock> lock;
CTimer mLockTimer; CTimer mLockTimer;
std::vector<std::unique_ptr<SSessionLockSurface>> vSessionLockSurfaces; std::vector<UP<SSessionLockSurface>> vSessionLockSurfaces;
std::unordered_map<uint64_t, CTimer> mMonitorsWithoutMappedSurfaceTimers; std::unordered_map<uint64_t, CTimer> mMonitorsWithoutMappedSurfaceTimers;
struct { struct {
CHyprSignalListener newSurface; CHyprSignalListener newSurface;
@ -74,4 +74,4 @@ class CSessionLockManager {
void onNewSessionLock(SP<CSessionLock> pWlrLock); void onNewSessionLock(SP<CSessionLock> pWlrLock);
}; };
inline std::unique_ptr<CSessionLockManager> g_pSessionLockManager; inline UP<CSessionLockManager> g_pSessionLockManager;

2
src/managers/TokenManager.hpp
View File

@ -35,4 +35,4 @@ class CTokenManager {
std::unordered_map<std::string, SP<CUUIDToken>> m_mTokens; std::unordered_map<std::string, SP<CUUIDToken>> m_mTokens;
}; };
inline std::unique_ptr<CTokenManager> g_pTokenManager; inline UP<CTokenManager> g_pTokenManager;

4
src/managers/VersionKeeperManager.hpp
View File

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <memory> #include "../helpers/memory/Memory.hpp"
class CVersionKeeperManager { class CVersionKeeperManager {
public: public:
@ -15,4 +15,4 @@ class CVersionKeeperManager {
bool m_bFired = false; bool m_bFired = false;
}; };
inline std::unique_ptr<CVersionKeeperManager> g_pVersionKeeperMgr; inline UP<CVersionKeeperManager> g_pVersionKeeperMgr;

1
src/managers/XCursorManager.cpp
View File

@ -9,6 +9,7 @@
#include "../managers/CursorManager.hpp" #include "../managers/CursorManager.hpp"
#include "debug/Log.hpp" #include "debug/Log.hpp"
#include "XCursorManager.hpp" #include "XCursorManager.hpp"
#include <memory>
// clang-format off // clang-format off
static std::vector<uint32_t> HYPR_XCURSOR_PIXELS = { static std::vector<uint32_t> HYPR_XCURSOR_PIXELS = {

2
src/managers/XWaylandManager.hpp
View File

@ -25,4 +25,4 @@ class CHyprXWaylandManager {
Vector2D waylandToXWaylandCoords(const Vector2D&); Vector2D waylandToXWaylandCoords(const Vector2D&);
}; };
inline std::unique_ptr<CHyprXWaylandManager> g_pXWaylandManager; inline UP<CHyprXWaylandManager> g_pXWaylandManager;

2
src/managers/eventLoop/EventLoopManager.hpp
View File

@ -69,4 +69,4 @@ class CEventLoopManager {
friend class CSyncTimeline; friend class CSyncTimeline;
}; };
inline std::unique_ptr<CEventLoopManager> g_pEventLoopManager; inline UP<CEventLoopManager> g_pEventLoopManager;

2
src/managers/input/IdleInhibitor.cpp
View File

@ -5,7 +5,7 @@
#include "../../protocols/core/Compositor.hpp" #include "../../protocols/core/Compositor.hpp"
void CInputManager::newIdleInhibitor(std::any inhibitor) { void CInputManager::newIdleInhibitor(std::any inhibitor) {
const auto PINHIBIT = m_vIdleInhibitors.emplace_back(std::make_unique<SIdleInhibitor>()).get(); const auto PINHIBIT = m_vIdleInhibitors.emplace_back(makeUnique<SIdleInhibitor>()).get();
PINHIBIT->inhibitor = std::any_cast<SP<CIdleInhibitor>>(inhibitor); PINHIBIT->inhibitor = std::any_cast<SP<CIdleInhibitor>>(inhibitor);
Debug::log(LOG, "New idle inhibitor registered for surface {:x}", (uintptr_t)PINHIBIT->inhibitor->surface.get()); Debug::log(LOG, "New idle inhibitor registered for surface {:x}", (uintptr_t)PINHIBIT->inhibitor->surface.get());

4
src/managers/input/InputManager.hpp
View File

@ -268,7 +268,7 @@ class CInputManager {
bool nonDesktop = false; bool nonDesktop = false;
CHyprSignalListener surfaceDestroyListener; CHyprSignalListener surfaceDestroyListener;
}; };
std::vector<std::unique_ptr<SIdleInhibitor>> m_vIdleInhibitors; std::vector<UP<SIdleInhibitor>> m_vIdleInhibitors;
// swipe // swipe
void beginWorkspaceSwipe(); void beginWorkspaceSwipe();
@ -304,4 +304,4 @@ class CInputManager {
friend class CWLSurface; friend class CWLSurface;
}; };
inline std::unique_ptr<CInputManager> g_pInputManager; inline UP<CInputManager> g_pInputManager;

6
src/managers/input/InputMethodRelay.cpp
View File

@ -50,7 +50,7 @@ void CInputMethodRelay::onNewIME(SP<CInputMethodV2> pIME) {
}); });
listeners.newPopup = pIME->events.newPopup.registerListener([this](std::any d) { listeners.newPopup = pIME->events.newPopup.registerListener([this](std::any d) {
m_vIMEPopups.emplace_back(std::make_unique<CInputPopup>(std::any_cast<SP<CInputMethodPopupV2>>(d))); m_vIMEPopups.emplace_back(makeUnique<CInputPopup>(std::any_cast<SP<CInputMethodPopupV2>>(d)));
Debug::log(LOG, "New input popup"); Debug::log(LOG, "New input popup");
}); });
@ -86,11 +86,11 @@ CTextInput* CInputMethodRelay::getFocusedTextInput() {
} }
void CInputMethodRelay::onNewTextInput(WP<CTextInputV3> tiv3) { void CInputMethodRelay::onNewTextInput(WP<CTextInputV3> tiv3) {
m_vTextInputs.emplace_back(std::make_unique<CTextInput>(tiv3)); m_vTextInputs.emplace_back(makeUnique<CTextInput>(tiv3));
} }
void CInputMethodRelay::onNewTextInput(WP<CTextInputV1> pTIV1) { void CInputMethodRelay::onNewTextInput(WP<CTextInputV1> pTIV1) {
m_vTextInputs.emplace_back(std::make_unique<CTextInput>(pTIV1)); m_vTextInputs.emplace_back(makeUnique<CTextInput>(pTIV1));
} }
void CInputMethodRelay::removeTextInput(CTextInput* pInput) { void CInputMethodRelay::removeTextInput(CTextInput* pInput) {

6
src/managers/input/InputMethodRelay.hpp
View File

@ -40,10 +40,10 @@ class CInputMethodRelay {
WP<CInputMethodV2> m_pIME; WP<CInputMethodV2> m_pIME;
private: private:
std::vector<std::unique_ptr<CTextInput>> m_vTextInputs; std::vector<UP<CTextInput>> m_vTextInputs;
std::vector<std::unique_ptr<CInputPopup>> m_vIMEPopups; std::vector<UP<CInputPopup>> m_vIMEPopups;
WP<CWLSurfaceResource> m_pLastKbFocus; WP<CWLSurfaceResource> m_pLastKbFocus;
struct { struct {
CHyprSignalListener newTIV3; CHyprSignalListener newTIV3;

1
src/managers/input/TextInput.hpp
View File

@ -3,7 +3,6 @@
#include "../../helpers/math/Math.hpp" #include "../../helpers/math/Math.hpp"
#include "../../helpers/signal/Signal.hpp" #include "../../helpers/signal/Signal.hpp"
#include "../../helpers/memory/Memory.hpp" #include "../../helpers/memory/Memory.hpp"
#include <memory>
struct wl_client; struct wl_client;

2
src/pch/pch.hpp
View File

@ -11,7 +11,7 @@
#include <iterator> #include <iterator>
#include <list> #include <list>
#include <map> #include <map>
#include <memory>
#include <mutex> #include <mutex>
#include <optional> #include <optional>
#include <random> #include <random>

2
src/plugins/HookSystem.cpp
View File

@ -253,7 +253,7 @@ bool CFunctionHook::unhook() {
} }
CFunctionHook* CHookSystem::initHook(HANDLE owner, void* source, void* destination) { CFunctionHook* CHookSystem::initHook(HANDLE owner, void* source, void* destination) {
return m_vHooks.emplace_back(std::make_unique<CFunctionHook>(owner, source, destination)).get(); return m_vHooks.emplace_back(makeUnique<CFunctionHook>(owner, source, destination)).get();
} }
bool CHookSystem::removeHook(CFunctionHook* hook) { bool CHookSystem::removeHook(CFunctionHook* hook) {

8
src/plugins/HookSystem.hpp
View File

@ -2,7 +2,7 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include <memory> #include "../helpers/memory/Memory.hpp"
#define HANDLE void* #define HANDLE void*
#define HOOK_TRAMPOLINE_MAX_SIZE 64 #define HOOK_TRAMPOLINE_MAX_SIZE 64
@ -60,9 +60,9 @@ class CHookSystem {
void removeAllHooksFrom(HANDLE handle); void removeAllHooksFrom(HANDLE handle);
private: private:
std::vector<std::unique_ptr<CFunctionHook>> m_vHooks; std::vector<UP<CFunctionHook>> m_vHooks;
uint64_t getAddressForTrampo(); uint64_t getAddressForTrampo();
struct SAllocatedPage { struct SAllocatedPage {
uint64_t addr = 0; uint64_t addr = 0;
@ -75,4 +75,4 @@ class CHookSystem {
friend class CFunctionHook; friend class CFunctionHook;
}; };
inline std::unique_ptr<CHookSystem> g_pFunctionHookSystem; inline UP<CHookSystem> g_pFunctionHookSystem;

2
src/plugins/PluginAPI.cpp
View File

@ -106,7 +106,7 @@ APICALL bool HyprlandAPI::removeFunctionHook(HANDLE handle, CFunctionHook* hook)
return g_pFunctionHookSystem->removeHook(hook); return g_pFunctionHookSystem->removeHook(hook);
} }
APICALL bool HyprlandAPI::addWindowDecoration(HANDLE handle, PHLWINDOW pWindow, std::unique_ptr<IHyprWindowDecoration> pDecoration) { APICALL bool HyprlandAPI::addWindowDecoration(HANDLE handle, PHLWINDOW pWindow, UP<IHyprWindowDecoration> pDecoration) {
auto* const PLUGIN = g_pPluginSystem->getPluginByHandle(handle); auto* const PLUGIN = g_pPluginSystem->getPluginByHandle(handle);
if (!PLUGIN) if (!PLUGIN)

2
src/plugins/PluginAPI.hpp
View File

@ -223,7 +223,7 @@ namespace HyprlandAPI {
returns: true on success. False otherwise. returns: true on success. False otherwise.
*/ */
APICALL bool addWindowDecoration(HANDLE handle, PHLWINDOW pWindow, std::unique_ptr<IHyprWindowDecoration> pDecoration); APICALL bool addWindowDecoration(HANDLE handle, PHLWINDOW pWindow, UP<IHyprWindowDecoration> pDecoration);
/* /*
Removes a window decoration Removes a window decoration

4
src/plugins/PluginSystem.cpp
View File

@ -8,7 +8,7 @@
#include "../managers/eventLoop/EventLoopManager.hpp" #include "../managers/eventLoop/EventLoopManager.hpp"
CPluginSystem::CPluginSystem() { CPluginSystem::CPluginSystem() {
g_pFunctionHookSystem = std::make_unique<CHookSystem>(); g_pFunctionHookSystem = makeUnique<CHookSystem>();
} }
CPlugin* CPluginSystem::loadPlugin(const std::string& path) { CPlugin* CPluginSystem::loadPlugin(const std::string& path) {
@ -21,7 +21,7 @@ CPlugin* CPluginSystem::loadPlugin(const std::string& path) {
return nullptr; return nullptr;
} }
auto* const PLUGIN = m_vLoadedPlugins.emplace_back(std::make_unique<CPlugin>()).get(); auto* const PLUGIN = m_vLoadedPlugins.emplace_back(makeUnique<CPlugin>()).get();
PLUGIN->path = path; PLUGIN->path = path;

6
src/plugins/PluginSystem.hpp
View File

@ -44,9 +44,9 @@ class CPluginSystem {
std::string m_szLastError = ""; std::string m_szLastError = "";
private: private:
std::vector<std::unique_ptr<CPlugin>> m_vLoadedPlugins; std::vector<UP<CPlugin>> m_vLoadedPlugins;
jmp_buf m_jbPluginFaultJumpBuf; jmp_buf m_jbPluginFaultJumpBuf;
}; };
inline std::unique_ptr<CPluginSystem> g_pPluginSystem; inline UP<CPluginSystem> g_pPluginSystem;

7
src/protocols/AlphaModifier.cpp
View File

@ -64,7 +64,7 @@ CAlphaModifierProtocol::CAlphaModifierProtocol(const wl_interface* iface, const
} }
void CAlphaModifierProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { void CAlphaModifierProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
const auto RESOURCE = m_vManagers.emplace_back(std::make_unique<CWpAlphaModifierV1>(client, ver, id)).get(); const auto RESOURCE = m_vManagers.emplace_back(makeUnique<CWpAlphaModifierV1>(client, ver, id)).get();
RESOURCE->setOnDestroy([this](CWpAlphaModifierV1* manager) { destroyManager(manager); }); RESOURCE->setOnDestroy([this](CWpAlphaModifierV1* manager) { destroyManager(manager); });
RESOURCE->setDestroy([this](CWpAlphaModifierV1* manager) { destroyManager(manager); }); RESOURCE->setDestroy([this](CWpAlphaModifierV1* manager) { destroyManager(manager); });
@ -93,9 +93,8 @@ void CAlphaModifierProtocol::getSurface(CWpAlphaModifierV1* manager, uint32_t id
alphaModifier = iter->second.get(); alphaModifier = iter->second.get();
} }
} else { } else {
alphaModifier = alphaModifier = m_mAlphaModifiers.emplace(surface, makeUnique<CAlphaModifier>(makeShared<CWpAlphaModifierSurfaceV1>(manager->client(), manager->version(), id), surface))
m_mAlphaModifiers.emplace(surface, std::make_unique<CAlphaModifier>(makeShared<CWpAlphaModifierSurfaceV1>(manager->client(), manager->version(), id), surface)) .first->second.get();
.first->second.get();
} }
if UNLIKELY (!alphaModifier->good()) { if UNLIKELY (!alphaModifier->good()) {

1
src/protocols/AlphaModifier.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include <unordered_map> #include <unordered_map>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"

2
src/protocols/CTMControl.cpp
View File

@ -106,7 +106,7 @@ void CHyprlandCTMControlProtocol::setCTM(PHLMONITOR monitor, const Mat3x3& ctm)
std::erase_if(m_mCTMDatas, [](const auto& el) { return !el.first; }); std::erase_if(m_mCTMDatas, [](const auto& el) { return !el.first; });
if (!m_mCTMDatas.contains(monitor)) if (!m_mCTMDatas.contains(monitor))
m_mCTMDatas[monitor] = std::make_unique<SCTMData>(); m_mCTMDatas[monitor] = makeUnique<SCTMData>();
auto& data = m_mCTMDatas.at(monitor); auto& data = m_mCTMDatas.at(monitor);

3
src/protocols/CTMControl.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"
@ -45,7 +44,7 @@ class CHyprlandCTMControlProtocol : public IWaylandProtocol {
Mat3x3 ctmFrom = Mat3x3::identity(), ctmTo = Mat3x3::identity(); Mat3x3 ctmFrom = Mat3x3::identity(), ctmTo = Mat3x3::identity();
PHLANIMVAR<float> progress; PHLANIMVAR<float> progress;
}; };
std::map<PHLMONITORREF, std::unique_ptr<SCTMData>> m_mCTMDatas; std::map<PHLMONITORREF, UP<SCTMData>> m_mCTMDatas;
friend class CHyprlandCTMControlResource; friend class CHyprlandCTMControlResource;
}; };

1
src/protocols/ColorManagement.hpp
View File

@ -1,7 +1,6 @@
#pragma once #pragma once
#include <drm_mode.h> #include <drm_mode.h>
#include <memory>
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"

2
src/protocols/CursorShape.cpp
View File

@ -15,7 +15,7 @@ void CCursorShapeProtocol::onDeviceResourceDestroy(wl_resource* res) {
} }
void CCursorShapeProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { void CCursorShapeProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
const auto RESOURCE = m_vManagers.emplace_back(std::make_unique<CWpCursorShapeManagerV1>(client, ver, id)).get(); const auto RESOURCE = m_vManagers.emplace_back(makeUnique<CWpCursorShapeManagerV1>(client, ver, id)).get();
RESOURCE->setOnDestroy([this](CWpCursorShapeManagerV1* p) { this->onManagerResourceDestroy(p->resource()); }); RESOURCE->setOnDestroy([this](CWpCursorShapeManagerV1* p) { this->onManagerResourceDestroy(p->resource()); });
RESOURCE->setDestroy([this](CWpCursorShapeManagerV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); }); RESOURCE->setDestroy([this](CWpCursorShapeManagerV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); });

1
src/protocols/CursorShape.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <unordered_map> #include <unordered_map>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"
#include "../helpers/signal/Signal.hpp" #include "../helpers/signal/Signal.hpp"

1
src/protocols/DRMLease.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include <unordered_map> #include <unordered_map>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"

1
src/protocols/DRMSyncobj.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"
#include "linux-drm-syncobj-v1.hpp" #include "linux-drm-syncobj-v1.hpp"

1
src/protocols/DataDeviceWlr.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"

7
src/protocols/FocusGrab.cpp
View File

@ -5,7 +5,6 @@
#include "../managers/SeatManager.hpp" #include "../managers/SeatManager.hpp"
#include "core/Compositor.hpp" #include "core/Compositor.hpp"
#include <cstdint> #include <cstdint>
#include <memory>
#include <wayland-server.h> #include <wayland-server.h>
CFocusGrabSurfaceState::CFocusGrabSurfaceState(CFocusGrab* grab, SP<CWLSurfaceResource> surface) { CFocusGrabSurfaceState::CFocusGrabSurfaceState(CFocusGrab* grab, SP<CWLSurfaceResource> surface) {
@ -77,7 +76,7 @@ void CFocusGrab::finish(bool sendCleared) {
void CFocusGrab::addSurface(SP<CWLSurfaceResource> surface) { void CFocusGrab::addSurface(SP<CWLSurfaceResource> surface) {
auto iter = std::find_if(m_mSurfaces.begin(), m_mSurfaces.end(), [surface](const auto& e) { return e.first == surface; }); auto iter = std::find_if(m_mSurfaces.begin(), m_mSurfaces.end(), [surface](const auto& e) { return e.first == surface; });
if (iter == m_mSurfaces.end()) if (iter == m_mSurfaces.end())
m_mSurfaces.emplace(surface, std::make_unique<CFocusGrabSurfaceState>(this, surface)); m_mSurfaces.emplace(surface, makeUnique<CFocusGrabSurfaceState>(this, surface));
} }
void CFocusGrab::removeSurface(SP<CWLSurfaceResource> surface) { void CFocusGrab::removeSurface(SP<CWLSurfaceResource> surface) {
@ -151,7 +150,7 @@ CFocusGrabProtocol::CFocusGrabProtocol(const wl_interface* iface, const int& ver
} }
void CFocusGrabProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { void CFocusGrabProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
const auto RESOURCE = m_vManagers.emplace_back(std::make_unique<CHyprlandFocusGrabManagerV1>(client, ver, id)).get(); const auto RESOURCE = m_vManagers.emplace_back(makeUnique<CHyprlandFocusGrabManagerV1>(client, ver, id)).get();
RESOURCE->setOnDestroy([this](CHyprlandFocusGrabManagerV1* p) { onManagerResourceDestroy(p->resource()); }); RESOURCE->setOnDestroy([this](CHyprlandFocusGrabManagerV1* p) { onManagerResourceDestroy(p->resource()); });
RESOURCE->setDestroy([this](CHyprlandFocusGrabManagerV1* p) { onManagerResourceDestroy(p->resource()); }); RESOURCE->setDestroy([this](CHyprlandFocusGrabManagerV1* p) { onManagerResourceDestroy(p->resource()); });
@ -167,7 +166,7 @@ void CFocusGrabProtocol::destroyGrab(CFocusGrab* grab) {
} }
void CFocusGrabProtocol::onCreateGrab(CHyprlandFocusGrabManagerV1* pMgr, uint32_t id) { void CFocusGrabProtocol::onCreateGrab(CHyprlandFocusGrabManagerV1* pMgr, uint32_t id) {
m_vGrabs.push_back(std::make_unique<CFocusGrab>(makeShared<CHyprlandFocusGrabV1>(pMgr->client(), pMgr->version(), id))); m_vGrabs.push_back(makeUnique<CFocusGrab>(makeShared<CHyprlandFocusGrabV1>(pMgr->client(), pMgr->version(), id)));
const auto RESOURCE = m_vGrabs.back().get(); const auto RESOURCE = m_vGrabs.back().get();
if UNLIKELY (!RESOURCE->good()) { if UNLIKELY (!RESOURCE->good()) {

2
src/protocols/ForeignToplevel.cpp
View File

@ -147,7 +147,7 @@ CForeignToplevelProtocol::CForeignToplevelProtocol(const wl_interface* iface, co
} }
void CForeignToplevelProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { void CForeignToplevelProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
const auto RESOURCE = m_vManagers.emplace_back(std::make_unique<CForeignToplevelList>(makeShared<CExtForeignToplevelListV1>(client, ver, id))).get(); const auto RESOURCE = m_vManagers.emplace_back(makeUnique<CForeignToplevelList>(makeShared<CExtForeignToplevelListV1>(client, ver, id))).get();
if UNLIKELY (!RESOURCE->good()) { if UNLIKELY (!RESOURCE->good()) {
LOGM(ERR, "Couldn't create a foreign list"); LOGM(ERR, "Couldn't create a foreign list");

1
src/protocols/ForeignToplevel.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include <unordered_map> #include <unordered_map>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"

2
src/protocols/ForeignToplevelWlr.cpp
View File

@ -376,7 +376,7 @@ CForeignToplevelWlrProtocol::CForeignToplevelWlrProtocol(const wl_interface* ifa
} }
void CForeignToplevelWlrProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { void CForeignToplevelWlrProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
const auto RESOURCE = m_vManagers.emplace_back(std::make_unique<CForeignToplevelWlrManager>(makeShared<CZwlrForeignToplevelManagerV1>(client, ver, id))).get(); const auto RESOURCE = m_vManagers.emplace_back(makeUnique<CForeignToplevelWlrManager>(makeShared<CZwlrForeignToplevelManagerV1>(client, ver, id))).get();
if UNLIKELY (!RESOURCE->good()) { if UNLIKELY (!RESOURCE->good()) {
LOGM(ERR, "Couldn't create a foreign list"); LOGM(ERR, "Couldn't create a foreign list");

1
src/protocols/ForeignToplevelWlr.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"
#include "wlr-foreign-toplevel-management-unstable-v1.hpp" #include "wlr-foreign-toplevel-management-unstable-v1.hpp"

4
src/protocols/FractionalScale.cpp
View File

@ -7,7 +7,7 @@ CFractionalScaleProtocol::CFractionalScaleProtocol(const wl_interface* iface, co
} }
void CFractionalScaleProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { void CFractionalScaleProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
const auto RESOURCE = m_vManagers.emplace_back(std::make_unique<CWpFractionalScaleManagerV1>(client, ver, id)).get(); const auto RESOURCE = m_vManagers.emplace_back(makeUnique<CWpFractionalScaleManagerV1>(client, ver, id)).get();
RESOURCE->setOnDestroy([this](CWpFractionalScaleManagerV1* p) { this->onManagerResourceDestroy(p->resource()); }); RESOURCE->setOnDestroy([this](CWpFractionalScaleManagerV1* p) { this->onManagerResourceDestroy(p->resource()); });
RESOURCE->setDestroy([this](CWpFractionalScaleManagerV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); }); RESOURCE->setDestroy([this](CWpFractionalScaleManagerV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); });
@ -33,7 +33,7 @@ void CFractionalScaleProtocol::onGetFractionalScale(CWpFractionalScaleManagerV1*
} }
const auto PADDON = const auto PADDON =
m_mAddons.emplace(surface, std::make_unique<CFractionalScaleAddon>(makeShared<CWpFractionalScaleV1>(pMgr->client(), pMgr->version(), id), surface)).first->second.get(); m_mAddons.emplace(surface, makeUnique<CFractionalScaleAddon>(makeShared<CWpFractionalScaleV1>(pMgr->client(), pMgr->version(), id), surface)).first->second.get();
if UNLIKELY (!PADDON->good()) { if UNLIKELY (!PADDON->good()) {
m_mAddons.erase(surface); m_mAddons.erase(surface);

1
src/protocols/FractionalScale.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <unordered_map> #include <unordered_map>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"
#include "fractional-scale-v1.hpp" #include "fractional-scale-v1.hpp"

1
src/protocols/FrogColorManagement.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <cstdint> #include <cstdint>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"
#include "protocols/core/Compositor.hpp" #include "protocols/core/Compositor.hpp"

4
src/protocols/GammaControl.cpp
View File

@ -160,7 +160,7 @@ CGammaControlProtocol::CGammaControlProtocol(const wl_interface* iface, const in
} }
void CGammaControlProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { void CGammaControlProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
const auto RESOURCE = m_vManagers.emplace_back(std::make_unique<CZwlrGammaControlManagerV1>(client, ver, id)).get(); const auto RESOURCE = m_vManagers.emplace_back(makeUnique<CZwlrGammaControlManagerV1>(client, ver, id)).get();
RESOURCE->setOnDestroy([this](CZwlrGammaControlManagerV1* p) { this->onManagerResourceDestroy(p->resource()); }); RESOURCE->setOnDestroy([this](CZwlrGammaControlManagerV1* p) { this->onManagerResourceDestroy(p->resource()); });
RESOURCE->setDestroy([this](CZwlrGammaControlManagerV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); }); RESOURCE->setDestroy([this](CZwlrGammaControlManagerV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); });
@ -177,7 +177,7 @@ void CGammaControlProtocol::destroyGammaControl(CGammaControl* gamma) {
void CGammaControlProtocol::onGetGammaControl(CZwlrGammaControlManagerV1* pMgr, uint32_t id, wl_resource* output) { void CGammaControlProtocol::onGetGammaControl(CZwlrGammaControlManagerV1* pMgr, uint32_t id, wl_resource* output) {
const auto CLIENT = pMgr->client(); const auto CLIENT = pMgr->client();
const auto RESOURCE = m_vGammaControllers.emplace_back(std::make_unique<CGammaControl>(makeShared<CZwlrGammaControlV1>(CLIENT, pMgr->version(), id), output)).get(); const auto RESOURCE = m_vGammaControllers.emplace_back(makeUnique<CGammaControl>(makeShared<CZwlrGammaControlV1>(CLIENT, pMgr->version(), id), output)).get();
if UNLIKELY (!RESOURCE->good()) { if UNLIKELY (!RESOURCE->good()) {
pMgr->noMemory(); pMgr->noMemory();

1
src/protocols/GammaControl.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"

6
src/protocols/HyprlandSurface.cpp
View File

@ -70,7 +70,7 @@ CHyprlandSurfaceProtocol::CHyprlandSurfaceProtocol(const wl_interface* iface, co
} }
void CHyprlandSurfaceProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { void CHyprlandSurfaceProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
auto manager = m_vManagers.emplace_back(std::make_unique<CHyprlandSurfaceManagerV1>(client, ver, id)).get(); auto manager = m_vManagers.emplace_back(makeUnique<CHyprlandSurfaceManagerV1>(client, ver, id)).get();
manager->setOnDestroy([this](CHyprlandSurfaceManagerV1* manager) { destroyManager(manager); }); manager->setOnDestroy([this](CHyprlandSurfaceManagerV1* manager) { destroyManager(manager); });
manager->setDestroy([this](CHyprlandSurfaceManagerV1* manager) { destroyManager(manager); }); manager->setDestroy([this](CHyprlandSurfaceManagerV1* manager) { destroyManager(manager); });
@ -100,8 +100,8 @@ void CHyprlandSurfaceProtocol::getSurface(CHyprlandSurfaceManagerV1* manager, ui
hyprlandSurface = iter->second.get(); hyprlandSurface = iter->second.get();
} }
} else { } else {
hyprlandSurface = m_mSurfaces.emplace(surface, std::make_unique<CHyprlandSurface>(makeShared<CHyprlandSurfaceV1>(manager->client(), manager->version(), id), surface)) hyprlandSurface =
.first->second.get(); m_mSurfaces.emplace(surface, makeUnique<CHyprlandSurface>(makeShared<CHyprlandSurfaceV1>(manager->client(), manager->version(), id), surface)).first->second.get();
} }
if UNLIKELY (!hyprlandSurface->good()) { if UNLIKELY (!hyprlandSurface->good()) {

1
src/protocols/HyprlandSurface.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include <unordered_map> #include <unordered_map>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"

2
src/protocols/IdleInhibit.cpp
View File

@ -31,7 +31,7 @@ void CIdleInhibitProtocol::onManagerResourceDestroy(wl_resource* res) {
} }
void CIdleInhibitProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { void CIdleInhibitProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
const auto RESOURCE = m_vManagers.emplace_back(std::make_unique<CZwpIdleInhibitManagerV1>(client, ver, id)).get(); const auto RESOURCE = m_vManagers.emplace_back(makeUnique<CZwpIdleInhibitManagerV1>(client, ver, id)).get();
RESOURCE->setOnDestroy([this](CZwpIdleInhibitManagerV1* p) { this->onManagerResourceDestroy(p->resource()); }); RESOURCE->setOnDestroy([this](CZwpIdleInhibitManagerV1* p) { this->onManagerResourceDestroy(p->resource()); });
RESOURCE->setDestroy([this](CZwpIdleInhibitManagerV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); }); RESOURCE->setDestroy([this](CZwpIdleInhibitManagerV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); });

1
src/protocols/IdleInhibit.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <unordered_map> #include <unordered_map>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"
#include "idle-inhibit-unstable-v1.hpp" #include "idle-inhibit-unstable-v1.hpp"

2
src/protocols/IdleNotify.cpp
View File

@ -59,7 +59,7 @@ CIdleNotifyProtocol::CIdleNotifyProtocol(const wl_interface* iface, const int& v
} }
void CIdleNotifyProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { void CIdleNotifyProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
const auto RESOURCE = m_vManagers.emplace_back(std::make_unique<CExtIdleNotifierV1>(client, ver, id)).get(); const auto RESOURCE = m_vManagers.emplace_back(makeUnique<CExtIdleNotifierV1>(client, ver, id)).get();
RESOURCE->setOnDestroy([this](CExtIdleNotifierV1* p) { this->onManagerResourceDestroy(p->resource()); }); RESOURCE->setOnDestroy([this](CExtIdleNotifierV1* p) { this->onManagerResourceDestroy(p->resource()); });
RESOURCE->setDestroy([this](CExtIdleNotifierV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); }); RESOURCE->setDestroy([this](CExtIdleNotifierV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); });

1
src/protocols/IdleNotify.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include <unordered_map> #include <unordered_map>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"

2
src/protocols/InputMethodV2.cpp
View File

@ -334,7 +334,7 @@ CInputMethodV2Protocol::CInputMethodV2Protocol(const wl_interface* iface, const
} }
void CInputMethodV2Protocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { void CInputMethodV2Protocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
const auto RESOURCE = m_vManagers.emplace_back(std::make_unique<CZwpInputMethodManagerV2>(client, ver, id)).get(); const auto RESOURCE = m_vManagers.emplace_back(makeUnique<CZwpInputMethodManagerV2>(client, ver, id)).get();
RESOURCE->setOnDestroy([this](CZwpInputMethodManagerV2* p) { this->onManagerResourceDestroy(p->resource()); }); RESOURCE->setOnDestroy([this](CZwpInputMethodManagerV2* p) { this->onManagerResourceDestroy(p->resource()); });
RESOURCE->setDestroy([this](CZwpInputMethodManagerV2* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); }); RESOURCE->setDestroy([this](CZwpInputMethodManagerV2* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); });

1
src/protocols/InputMethodV2.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"

2
src/protocols/LayerShell.cpp
View File

@ -201,7 +201,7 @@ CLayerShellProtocol::CLayerShellProtocol(const wl_interface* iface, const int& v
} }
void CLayerShellProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { void CLayerShellProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
const auto RESOURCE = m_vManagers.emplace_back(std::make_unique<CZwlrLayerShellV1>(client, ver, id)).get(); const auto RESOURCE = m_vManagers.emplace_back(makeUnique<CZwlrLayerShellV1>(client, ver, id)).get();
RESOURCE->setOnDestroy([this](CZwlrLayerShellV1* p) { this->onManagerResourceDestroy(p->resource()); }); RESOURCE->setOnDestroy([this](CZwlrLayerShellV1* p) { this->onManagerResourceDestroy(p->resource()); });
RESOURCE->setDestroy([this](CZwlrLayerShellV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); }); RESOURCE->setDestroy([this](CZwlrLayerShellV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); });

1
src/protocols/LayerShell.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
#include <tuple> #include <tuple>

4
src/protocols/LinuxDMABUF.cpp
View File

@ -469,7 +469,7 @@ CLinuxDMABufV1Protocol::CLinuxDMABufV1Protocol(const wl_interface* iface, const
}); });
} }
formatTable = std::make_unique<CDMABUFFormatTable>(eglTranche, tches); formatTable = makeUnique<CDMABUFFormatTable>(eglTranche, tches);
drmDevice* device = nullptr; drmDevice* device = nullptr;
if (drmGetDeviceFromDevId(mainDevice, 0, &device) != 0) { if (drmGetDeviceFromDevId(mainDevice, 0, &device) != 0) {
@ -501,7 +501,7 @@ void CLinuxDMABufV1Protocol::resetFormatTable() {
LOGM(LOG, "Resetting format table"); LOGM(LOG, "Resetting format table");
// this might be a big copy // this might be a big copy
auto newFormatTable = std::make_unique<CDMABUFFormatTable>(formatTable->rendererTranche, formatTable->monitorTranches); auto newFormatTable = makeUnique<CDMABUFFormatTable>(formatTable->rendererTranche, formatTable->monitorTranches);
for (auto const& feedback : m_vFeedbacks) { for (auto const& feedback : m_vFeedbacks) {
feedback->resource->sendFormatTable(newFormatTable->tableFD, newFormatTable->tableSize); feedback->resource->sendFormatTable(newFormatTable->tableFD, newFormatTable->tableSize);

1
src/protocols/LinuxDMABUF.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"

2
src/protocols/LockNotify.cpp
View File

@ -31,7 +31,7 @@ CLockNotifyProtocol::CLockNotifyProtocol(const wl_interface* iface, const int& v
} }
void CLockNotifyProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { void CLockNotifyProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
const auto RESOURCE = m_managers.emplace_back(std::make_unique<CHyprlandLockNotifierV1>(client, ver, id)).get(); const auto RESOURCE = m_managers.emplace_back(makeUnique<CHyprlandLockNotifierV1>(client, ver, id)).get();
RESOURCE->setOnDestroy([this](CHyprlandLockNotifierV1* p) { this->onManagerResourceDestroy(p->resource()); }); RESOURCE->setOnDestroy([this](CHyprlandLockNotifierV1* p) { this->onManagerResourceDestroy(p->resource()); });
RESOURCE->setDestroy([this](CHyprlandLockNotifierV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); }); RESOURCE->setDestroy([this](CHyprlandLockNotifierV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); });

1
src/protocols/MesaDRM.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"

1
src/protocols/OutputManagement.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
#include <unordered_map> #include <unordered_map>

4
src/protocols/OutputPower.cpp
View File

@ -43,7 +43,7 @@ COutputPowerProtocol::COutputPowerProtocol(const wl_interface* iface, const int&
} }
void COutputPowerProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { void COutputPowerProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
const auto RESOURCE = m_vManagers.emplace_back(std::make_unique<CZwlrOutputPowerManagerV1>(client, ver, id)).get(); const auto RESOURCE = m_vManagers.emplace_back(makeUnique<CZwlrOutputPowerManagerV1>(client, ver, id)).get();
RESOURCE->setOnDestroy([this](CZwlrOutputPowerManagerV1* p) { this->onManagerResourceDestroy(p->resource()); }); RESOURCE->setOnDestroy([this](CZwlrOutputPowerManagerV1* p) { this->onManagerResourceDestroy(p->resource()); });
RESOURCE->setDestroy([this](CZwlrOutputPowerManagerV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); }); RESOURCE->setDestroy([this](CZwlrOutputPowerManagerV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); });
@ -68,7 +68,7 @@ void COutputPowerProtocol::onGetOutputPower(CZwlrOutputPowerManagerV1* pMgr, uin
} }
const auto CLIENT = pMgr->client(); const auto CLIENT = pMgr->client();
const auto RESOURCE = m_vOutputPowers.emplace_back(std::make_unique<COutputPower>(makeShared<CZwlrOutputPowerV1>(CLIENT, pMgr->version(), id), OUTPUT->monitor.lock())).get(); const auto RESOURCE = m_vOutputPowers.emplace_back(makeUnique<COutputPower>(makeShared<CZwlrOutputPowerV1>(CLIENT, pMgr->version(), id), OUTPUT->monitor.lock())).get();
if UNLIKELY (!RESOURCE->good()) { if UNLIKELY (!RESOURCE->good()) {
pMgr->noMemory(); pMgr->noMemory();

1
src/protocols/OutputPower.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"

2
src/protocols/PointerConstraints.cpp
View File

@ -199,7 +199,7 @@ CPointerConstraintsProtocol::CPointerConstraintsProtocol(const wl_interface* ifa
} }
void CPointerConstraintsProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { void CPointerConstraintsProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
const auto RESOURCE = m_vManagers.emplace_back(std::make_unique<CZwpPointerConstraintsV1>(client, ver, id)).get(); const auto RESOURCE = m_vManagers.emplace_back(makeUnique<CZwpPointerConstraintsV1>(client, ver, id)).get();
RESOURCE->setOnDestroy([this](CZwpPointerConstraintsV1* p) { this->onManagerResourceDestroy(p->resource()); }); RESOURCE->setOnDestroy([this](CZwpPointerConstraintsV1* p) { this->onManagerResourceDestroy(p->resource()); });
RESOURCE->setDestroy([this](CZwpPointerConstraintsV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); }); RESOURCE->setDestroy([this](CZwpPointerConstraintsV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); });

1
src/protocols/PointerConstraints.hpp
View File

@ -2,7 +2,6 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"

8
src/protocols/PointerGestures.cpp
View File

@ -44,7 +44,7 @@ CPointerGesturesProtocol::CPointerGesturesProtocol(const wl_interface* iface, co
} }
void CPointerGesturesProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { void CPointerGesturesProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
const auto RESOURCE = m_vManagers.emplace_back(std::make_unique<CZwpPointerGesturesV1>(client, ver, id)).get(); const auto RESOURCE = m_vManagers.emplace_back(makeUnique<CZwpPointerGesturesV1>(client, ver, id)).get();
RESOURCE->setOnDestroy([this](CZwpPointerGesturesV1* p) { this->onManagerResourceDestroy(p->resource()); }); RESOURCE->setOnDestroy([this](CZwpPointerGesturesV1* p) { this->onManagerResourceDestroy(p->resource()); });
RESOURCE->setRelease([this](CZwpPointerGesturesV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); }); RESOURCE->setRelease([this](CZwpPointerGesturesV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); });
@ -71,7 +71,7 @@ void CPointerGesturesProtocol::onGestureDestroy(CPointerGestureHold* gesture) {
void CPointerGesturesProtocol::onGetPinchGesture(CZwpPointerGesturesV1* pMgr, uint32_t id, wl_resource* pointer) { void CPointerGesturesProtocol::onGetPinchGesture(CZwpPointerGesturesV1* pMgr, uint32_t id, wl_resource* pointer) {
const auto CLIENT = pMgr->client(); const auto CLIENT = pMgr->client();
const auto RESOURCE = m_vPinches.emplace_back(std::make_unique<CPointerGesturePinch>(makeShared<CZwpPointerGesturePinchV1>(CLIENT, pMgr->version(), id))).get(); const auto RESOURCE = m_vPinches.emplace_back(makeUnique<CPointerGesturePinch>(makeShared<CZwpPointerGesturePinchV1>(CLIENT, pMgr->version(), id))).get();
if UNLIKELY (!RESOURCE->good()) { if UNLIKELY (!RESOURCE->good()) {
pMgr->noMemory(); pMgr->noMemory();
@ -82,7 +82,7 @@ void CPointerGesturesProtocol::onGetPinchGesture(CZwpPointerGesturesV1* pMgr, ui
void CPointerGesturesProtocol::onGetSwipeGesture(CZwpPointerGesturesV1* pMgr, uint32_t id, wl_resource* pointer) { void CPointerGesturesProtocol::onGetSwipeGesture(CZwpPointerGesturesV1* pMgr, uint32_t id, wl_resource* pointer) {
const auto CLIENT = pMgr->client(); const auto CLIENT = pMgr->client();
const auto RESOURCE = m_vSwipes.emplace_back(std::make_unique<CPointerGestureSwipe>(makeShared<CZwpPointerGestureSwipeV1>(CLIENT, pMgr->version(), id))).get(); const auto RESOURCE = m_vSwipes.emplace_back(makeUnique<CPointerGestureSwipe>(makeShared<CZwpPointerGestureSwipeV1>(CLIENT, pMgr->version(), id))).get();
if UNLIKELY (!RESOURCE->good()) { if UNLIKELY (!RESOURCE->good()) {
pMgr->noMemory(); pMgr->noMemory();
@ -93,7 +93,7 @@ void CPointerGesturesProtocol::onGetSwipeGesture(CZwpPointerGesturesV1* pMgr, ui
void CPointerGesturesProtocol::onGetHoldGesture(CZwpPointerGesturesV1* pMgr, uint32_t id, wl_resource* pointer) { void CPointerGesturesProtocol::onGetHoldGesture(CZwpPointerGesturesV1* pMgr, uint32_t id, wl_resource* pointer) {
const auto CLIENT = pMgr->client(); const auto CLIENT = pMgr->client();
const auto RESOURCE = m_vHolds.emplace_back(std::make_unique<CPointerGestureHold>(makeShared<CZwpPointerGestureHoldV1>(CLIENT, pMgr->version(), id))).get(); const auto RESOURCE = m_vHolds.emplace_back(makeUnique<CPointerGestureHold>(makeShared<CZwpPointerGestureHoldV1>(CLIENT, pMgr->version(), id))).get();
if UNLIKELY (!RESOURCE->good()) { if UNLIKELY (!RESOURCE->good()) {
pMgr->noMemory(); pMgr->noMemory();

1
src/protocols/PointerGestures.hpp
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <memory>
#include <vector> #include <vector>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"
#include "pointer-gestures-unstable-v1.hpp" #include "pointer-gestures-unstable-v1.hpp"

Some files were not shown because too many files have changed in this diff Show More