mirrors/Hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/Hyprland.git synced 2025-09-14 23:38:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

core: use new typed signals from hu (#10853)

Browse Source
This commit is contained in:
outfoxxed
2025-07-08 09:56:40 -07:00
committed by GitHub
parent 2f34ef141b
commit 78e9eddfb6
85 changed files with 667 additions and 865 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
src/Compositor.cpp
View File

@@ -405,90 +405,67 @@ void CCompositor::initServer(std::string socketName, int socketFd) {
} }
void CCompositor::initAllSignals() { void CCompositor::initAllSignals() {
m_aqBackend->events.newOutput.registerStaticListener( m_aqBackend->events.newOutput.listenStatic([this](const SP<Aquamarine::IOutput>& output) {
[this](void* p, std::any data) { Debug::log(LOG, "New aquamarine output with name {}", output->name);
auto output = std::any_cast<SP<Aquamarine::IOutput>>(data); if (m_initialized)
Debug::log(LOG, "New aquamarine output with name {}", output->name); onNewMonitor(output);
if (m_initialized) else
onNewMonitor(output); pendingOutputs.emplace_back(output);
else });
pendingOutputs.emplace_back(output);
},
nullptr);
m_aqBackend->events.newPointer.registerStaticListener( m_aqBackend->events.newPointer.listenStatic([](const SP<Aquamarine::IPointer>& dev) {
[](void* data, std::any d) { Debug::log(LOG, "New aquamarine pointer with name {}", dev->getName());
auto dev = std::any_cast<SP<Aquamarine::IPointer>>(d); g_pInputManager->newMouse(dev);
Debug::log(LOG, "New aquamarine pointer with name {}", dev->getName()); g_pInputManager->updateCapabilities();
g_pInputManager->newMouse(dev); });
g_pInputManager->updateCapabilities();
},
nullptr);
m_aqBackend->events.newKeyboard.registerStaticListener( m_aqBackend->events.newKeyboard.listenStatic([](const SP<Aquamarine::IKeyboard>& dev) {
[](void* data, std::any d) { Debug::log(LOG, "New aquamarine keyboard with name {}", dev->getName());
auto dev = std::any_cast<SP<Aquamarine::IKeyboard>>(d); g_pInputManager->newKeyboard(dev);
Debug::log(LOG, "New aquamarine keyboard with name {}", dev->getName()); g_pInputManager->updateCapabilities();
g_pInputManager->newKeyboard(dev); });
g_pInputManager->updateCapabilities();
},
nullptr);
m_aqBackend->events.newTouch.registerStaticListener( m_aqBackend->events.newTouch.listenStatic([](const SP<Aquamarine::ITouch>& dev) {
[](void* data, std::any d) { Debug::log(LOG, "New aquamarine touch with name {}", dev->getName());
auto dev = std::any_cast<SP<Aquamarine::ITouch>>(d); g_pInputManager->newTouchDevice(dev);
Debug::log(LOG, "New aquamarine touch with name {}", dev->getName()); g_pInputManager->updateCapabilities();
g_pInputManager->newTouchDevice(dev); });
g_pInputManager->updateCapabilities();
},
nullptr);
m_aqBackend->events.newSwitch.registerStaticListener( m_aqBackend->events.newSwitch.listenStatic([](const SP<Aquamarine::ISwitch>& dev) {
[](void* data, std::any d) { Debug::log(LOG, "New aquamarine switch with name {}", dev->getName());
auto dev = std::any_cast<SP<Aquamarine::ISwitch>>(d); g_pInputManager->newSwitch(dev);
Debug::log(LOG, "New aquamarine switch with name {}", dev->getName()); });
g_pInputManager->newSwitch(dev);
},
nullptr);
m_aqBackend->events.newTablet.registerStaticListener( m_aqBackend->events.newTablet.listenStatic([](const SP<Aquamarine::ITablet>& dev) {
[](void* data, std::any d) { Debug::log(LOG, "New aquamarine tablet with name {}", dev->getName());
auto dev = std::any_cast<SP<Aquamarine::ITablet>>(d); g_pInputManager->newTablet(dev);
Debug::log(LOG, "New aquamarine tablet with name {}", dev->getName()); });
g_pInputManager->newTablet(dev);
},
nullptr);
m_aqBackend->events.newTabletPad.registerStaticListener( m_aqBackend->events.newTabletPad.listenStatic([](const SP<Aquamarine::ITabletPad>& dev) {
[](void* data, std::any d) { Debug::log(LOG, "New aquamarine tablet pad with name {}", dev->getName());
auto dev = std::any_cast<SP<Aquamarine::ITabletPad>>(d); g_pInputManager->newTabletPad(dev);
Debug::log(LOG, "New aquamarine tablet pad with name {}", dev->getName()); });
g_pInputManager->newTabletPad(dev);
},
nullptr);
if (m_aqBackend->hasSession()) { if (m_aqBackend->hasSession()) {
m_aqBackend->session->events.changeActive.registerStaticListener( m_aqBackend->session->events.changeActive.listenStatic([this] {
[this](void*, std::any) { if (m_aqBackend->session->active) {
if (m_aqBackend->session->active) { Debug::log(LOG, "Session got activated!");
Debug::log(LOG, "Session got activated!");
m_sessionActive = true; m_sessionActive = true;
for (auto const& m : m_monitors) { for (auto const& m : m_monitors) {
scheduleFrameForMonitor(m); scheduleFrameForMonitor(m);
m->applyMonitorRule(&m->m_activeMonitorRule, true); m->applyMonitorRule(&m->m_activeMonitorRule, true);
}
g_pConfigManager->m_wantsMonitorReload = true;
g_pCursorManager->syncGsettings();
} else {
Debug::log(LOG, "Session got deactivated!");
m_sessionActive = false;
} }
},
nullptr); g_pConfigManager->m_wantsMonitorReload = true;
g_pCursorManager->syncGsettings();
} else {
Debug::log(LOG, "Session got deactivated!");
m_sessionActive = false;
}
});
} }
} }
@@ -1973,7 +1950,7 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor
const auto PWORKSPACEB = pMonitorB->m_activeWorkspace; const auto PWORKSPACEB = pMonitorB->m_activeWorkspace;
PWORKSPACEA->m_monitor = pMonitorB; PWORKSPACEA->m_monitor = pMonitorB;
PWORKSPACEA->m_events.monitorChange.emit(); PWORKSPACEA->m_events.monitorChanged.emit();
for (auto const& w : m_windows) { for (auto const& w : m_windows) {
if (w->m_workspace == PWORKSPACEA) { if (w->m_workspace == PWORKSPACEA) {
@@ -1998,7 +1975,7 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor
} }
PWORKSPACEB->m_monitor = pMonitorA; PWORKSPACEB->m_monitor = pMonitorA;
PWORKSPACEB->m_events.monitorChange.emit(); PWORKSPACEB->m_events.monitorChanged.emit();
for (auto const& w : m_windows) { for (auto const& w : m_windows) {
if (w->m_workspace == PWORKSPACEB) { if (w->m_workspace == PWORKSPACEB) {
@@ -2178,7 +2155,7 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
// move the workspace // move the workspace
pWorkspace->m_monitor = pMonitor; pWorkspace->m_monitor = pMonitor;
pWorkspace->m_events.monitorChange.emit(); pWorkspace->m_events.monitorChanged.emit();
for (auto const& w : m_windows) { for (auto const& w : m_windows) {
if (w->m_workspace == pWorkspace) { if (w->m_workspace == pWorkspace) {
@@ -2227,9 +2204,9 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo
pMonitor->m_activeWorkspace = pWorkspace; pMonitor->m_activeWorkspace = pWorkspace;
if (oldWorkspace) if (oldWorkspace)
oldWorkspace->m_events.activeChange.emit(); oldWorkspace->m_events.activeChanged.emit();
pWorkspace->m_events.activeChange.emit(); pWorkspace->m_events.activeChanged.emit();
g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitor->m_id); g_pLayoutManager->getCurrentLayout()->recalculateMonitor(pMonitor->m_id);

8
src/desktop/LayerSurface.cpp
View File

@@ -59,10 +59,10 @@ void CLayerSurface::registerCallbacks() {
} }
CLayerSurface::CLayerSurface(SP<CLayerShellResource> resource_) : m_layerSurface(resource_) { CLayerSurface::CLayerSurface(SP<CLayerShellResource> resource_) : m_layerSurface(resource_) {
m_listeners.commit = m_layerSurface->m_events.commit.registerListener([this](std::any d) { onCommit(); }); m_listeners.commit = m_layerSurface->m_events.commit.listen([this] { onCommit(); });
m_listeners.map = m_layerSurface->m_events.map.registerListener([this](std::any d) { onMap(); }); m_listeners.map = m_layerSurface->m_events.map.listen([this] { onMap(); });
m_listeners.unmap = m_layerSurface->m_events.unmap.registerListener([this](std::any d) { onUnmap(); }); m_listeners.unmap = m_layerSurface->m_events.unmap.listen([this] { onUnmap(); });
m_listeners.destroy = m_layerSurface->m_events.destroy.registerListener([this](std::any d) { onDestroy(); }); m_listeners.destroy = m_layerSurface->m_events.destroy.listen([this] { onDestroy(); });
m_surface = CWLSurface::create(); m_surface = CWLSurface::create();
} }

20
src/desktop/Popup.cpp
View File

@@ -53,24 +53,22 @@ void CPopup::initAllSignals() {
if (!m_resource) { if (!m_resource) {
if (!m_windowOwner.expired()) if (!m_windowOwner.expired())
m_listeners.newPopup = m_listeners.newPopup = m_windowOwner->m_xdgSurface->m_events.newPopup.listen([this](const auto& resource) { this->onNewPopup(resource); });
m_windowOwner->m_xdgSurface->m_events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast<SP<CXDGPopupResource>>(d)); });
else if (!m_layerOwner.expired()) else if (!m_layerOwner.expired())
m_listeners.newPopup = m_listeners.newPopup = m_layerOwner->m_layerSurface->m_events.newPopup.listen([this](const auto& resource) { this->onNewPopup(resource); });
m_layerOwner->m_layerSurface->m_events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast<SP<CXDGPopupResource>>(d)); });
else else
ASSERT(false); ASSERT(false);
return; return;
} }
m_listeners.reposition = m_resource->m_events.reposition.registerListener([this](std::any d) { this->onReposition(); }); m_listeners.reposition = m_resource->m_events.reposition.listen([this] { this->onReposition(); });
m_listeners.map = m_resource->m_surface->m_events.map.registerListener([this](std::any d) { this->onMap(); }); m_listeners.map = m_resource->m_surface->m_events.map.listen([this] { this->onMap(); });
m_listeners.unmap = m_resource->m_surface->m_events.unmap.registerListener([this](std::any d) { this->onUnmap(); }); m_listeners.unmap = m_resource->m_surface->m_events.unmap.listen([this] { this->onUnmap(); });
m_listeners.dismissed = m_resource->m_events.dismissed.registerListener([this](std::any d) { this->onUnmap(); }); m_listeners.dismissed = m_resource->m_events.dismissed.listen([this] { this->onUnmap(); });
m_listeners.destroy = m_resource->m_surface->m_events.destroy.registerListener([this](std::any d) { this->onDestroy(); }); m_listeners.destroy = m_resource->m_surface->m_events.destroy.listen([this] { this->onDestroy(); });
m_listeners.commit = m_resource->m_surface->m_events.commit.registerListener([this](std::any d) { this->onCommit(); }); m_listeners.commit = m_resource->m_surface->m_events.commit.listen([this] { this->onCommit(); });
m_listeners.newPopup = m_resource->m_surface->m_events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast<SP<CXDGPopupResource>>(d)); }); m_listeners.newPopup = m_resource->m_surface->m_events.newPopup.listen([this](const auto& resource) { this->onNewPopup(resource); });
} }
void CPopup::onNewPopup(SP<CXDGPopupResource> popup) { void CPopup::onNewPopup(SP<CXDGPopupResource> popup) {

17
src/desktop/Subsurface.cpp
View File

@@ -52,19 +52,16 @@ UP<CSubsurface> CSubsurface::create(SP<CWLSubsurfaceResource> pSubsurface, WP<CP
void CSubsurface::initSignals() { void CSubsurface::initSignals() {
if (m_subsurface) { if (m_subsurface) {
m_listeners.commitSubsurface = m_subsurface->m_surface->m_events.commit.registerListener([this](std::any d) { onCommit(); }); m_listeners.commitSubsurface = m_subsurface->m_surface->m_events.commit.listen([this] { onCommit(); });
m_listeners.destroySubsurface = m_subsurface->m_events.destroy.registerListener([this](std::any d) { onDestroy(); }); m_listeners.destroySubsurface = m_subsurface->m_events.destroy.listen([this] { onDestroy(); });
m_listeners.mapSubsurface = m_subsurface->m_surface->m_events.map.registerListener([this](std::any d) { onMap(); }); m_listeners.mapSubsurface = m_subsurface->m_surface->m_events.map.listen([this] { onMap(); });
m_listeners.unmapSubsurface = m_subsurface->m_surface->m_events.unmap.registerListener([this](std::any d) { onUnmap(); }); m_listeners.unmapSubsurface = m_subsurface->m_surface->m_events.unmap.listen([this] { onUnmap(); });
m_listeners.newSubsurface = m_listeners.newSubsurface = m_subsurface->m_surface->m_events.newSubsurface.listen([this](const auto& resource) { onNewSubsurface(resource); });
m_subsurface->m_surface->m_events.newSubsurface.registerListener([this](std::any d) { onNewSubsurface(std::any_cast<SP<CWLSubsurfaceResource>>(d)); });
} else { } else {
if (m_windowParent) if (m_windowParent)
m_listeners.newSubsurface = m_windowParent->m_wlSurface->resource()->m_events.newSubsurface.registerListener( m_listeners.newSubsurface = m_windowParent->m_wlSurface->resource()->m_events.newSubsurface.listen([this](const auto& resource) { onNewSubsurface(resource); });
[this](std::any d) { onNewSubsurface(std::any_cast<SP<CWLSubsurfaceResource>>(d)); });
else if (m_popupParent) else if (m_popupParent)
m_listeners.newSubsurface = m_popupParent->m_wlSurface->resource()->m_events.newSubsurface.registerListener( m_listeners.newSubsurface = m_popupParent->m_wlSurface->resource()->m_events.newSubsurface.listen([this](const auto& resource) { onNewSubsurface(resource); });
[this](std::any d) { onNewSubsurface(std::any_cast<SP<CWLSubsurfaceResource>>(d)); });
else else
ASSERT(false); ASSERT(false);
} }

2
src/desktop/WLSurface.cpp
View File

@@ -159,7 +159,7 @@ void CWLSurface::init() {
m_resource->m_hlSurface = m_self.lock(); m_resource->m_hlSurface = m_self.lock();
m_listeners.destroy = m_resource->m_events.destroy.registerListener([this](std::any d) { destroy(); }); m_listeners.destroy = m_resource->m_events.destroy.listen([this] { destroy(); });
Debug::log(LOG, "CWLSurface {:x} called init()", (uintptr_t)this); Debug::log(LOG, "CWLSurface {:x} called init()", (uintptr_t)this);
} }

2
src/desktop/WLSurface.hpp
View File

@@ -91,7 +91,7 @@ class CWLSurface {
CRegion m_visibleRegion; CRegion m_visibleRegion;
struct { struct {
CSignal destroy; CSignalT<> destroy;
} m_events; } m_events;
WP<CWLSurface> m_self; WP<CWLSurface> m_self;

34
src/desktop/Window.cpp
View File

@@ -89,30 +89,30 @@ PHLWINDOW CWindow::create(SP<CXDGSurfaceResource> resource) {
CWindow::CWindow(SP<CXDGSurfaceResource> resource) : m_xdgSurface(resource) { CWindow::CWindow(SP<CXDGSurfaceResource> resource) : m_xdgSurface(resource) {
m_wlSurface = CWLSurface::create(); m_wlSurface = CWLSurface::create();
m_listeners.map = m_xdgSurface->m_events.map.registerListener([this](std::any d) { Events::listener_mapWindow(this, nullptr); }); m_listeners.map = m_xdgSurface->m_events.map.listen([this] { Events::listener_mapWindow(this, nullptr); });
m_listeners.ack = m_xdgSurface->m_events.ack.registerListener([this](std::any d) { onAck(std::any_cast<uint32_t>(d)); }); m_listeners.ack = m_xdgSurface->m_events.ack.listen([this](uint32_t d) { onAck(d); });
m_listeners.unmap = m_xdgSurface->m_events.unmap.registerListener([this](std::any d) { Events::listener_unmapWindow(this, nullptr); }); m_listeners.unmap = m_xdgSurface->m_events.unmap.listen([this] { Events::listener_unmapWindow(this, nullptr); });
m_listeners.destroy = m_xdgSurface->m_events.destroy.registerListener([this](std::any d) { Events::listener_destroyWindow(this, nullptr); }); m_listeners.destroy = m_xdgSurface->m_events.destroy.listen([this] { Events::listener_destroyWindow(this, nullptr); });
m_listeners.commit = m_xdgSurface->m_events.commit.registerListener([this](std::any d) { Events::listener_commitWindow(this, nullptr); }); m_listeners.commit = m_xdgSurface->m_events.commit.listen([this] { Events::listener_commitWindow(this, nullptr); });
m_listeners.updateState = m_xdgSurface->m_toplevel->m_events.stateChanged.registerListener([this](std::any d) { onUpdateState(); }); m_listeners.updateState = m_xdgSurface->m_toplevel->m_events.stateChanged.listen([this] { onUpdateState(); });
m_listeners.updateMetadata = m_xdgSurface->m_toplevel->m_events.metadataChanged.registerListener([this](std::any d) { onUpdateMeta(); }); m_listeners.updateMetadata = m_xdgSurface->m_toplevel->m_events.metadataChanged.listen([this] { onUpdateMeta(); });
} }
CWindow::CWindow(SP<CXWaylandSurface> surface) : m_xwaylandSurface(surface) { CWindow::CWindow(SP<CXWaylandSurface> surface) : m_xwaylandSurface(surface) {
m_wlSurface = CWLSurface::create(); m_wlSurface = CWLSurface::create();
m_listeners.map = m_xwaylandSurface->m_events.map.registerListener([this](std::any d) { Events::listener_mapWindow(this, nullptr); }); m_listeners.map = m_xwaylandSurface->m_events.map.listen([this] { Events::listener_mapWindow(this, nullptr); });
m_listeners.unmap = m_xwaylandSurface->m_events.unmap.registerListener([this](std::any d) { Events::listener_unmapWindow(this, nullptr); }); m_listeners.unmap = m_xwaylandSurface->m_events.unmap.listen([this] { Events::listener_unmapWindow(this, nullptr); });
m_listeners.destroy = m_xwaylandSurface->m_events.destroy.registerListener([this](std::any d) { Events::listener_destroyWindow(this, nullptr); }); m_listeners.destroy = m_xwaylandSurface->m_events.destroy.listen([this] { Events::listener_destroyWindow(this, nullptr); });
m_listeners.commit = m_xwaylandSurface->m_events.commit.registerListener([this](std::any d) { Events::listener_commitWindow(this, nullptr); }); m_listeners.commit = m_xwaylandSurface->m_events.commit.listen([this] { Events::listener_commitWindow(this, nullptr); });
m_listeners.configureRequest = m_xwaylandSurface->m_events.configureRequest.registerListener([this](std::any d) { onX11ConfigureRequest(std::any_cast<CBox>(d)); }); m_listeners.configureRequest = m_xwaylandSurface->m_events.configureRequest.listen([this](const CBox& box) { onX11ConfigureRequest(box); });
m_listeners.updateState = m_xwaylandSurface->m_events.stateChanged.registerListener([this](std::any d) { onUpdateState(); }); m_listeners.updateState = m_xwaylandSurface->m_events.stateChanged.listen([this] { onUpdateState(); });
m_listeners.updateMetadata = m_xwaylandSurface->m_events.metadataChanged.registerListener([this](std::any d) { onUpdateMeta(); }); m_listeners.updateMetadata = m_xwaylandSurface->m_events.metadataChanged.listen([this] { onUpdateMeta(); });
m_listeners.resourceChange = m_xwaylandSurface->m_events.resourceChange.registerListener([this](std::any d) { onResourceChangeX11(); }); m_listeners.resourceChange = m_xwaylandSurface->m_events.resourceChange.listen([this] { onResourceChangeX11(); });
m_listeners.activate = m_xwaylandSurface->m_events.activate.registerListener([this](std::any d) { Events::listener_activateX11(this, nullptr); }); m_listeners.activate = m_xwaylandSurface->m_events.activate.listen([this] { Events::listener_activateX11(this, nullptr); });
if (m_xwaylandSurface->m_overrideRedirect) if (m_xwaylandSurface->m_overrideRedirect)
m_listeners.setGeometry = m_xwaylandSurface->m_events.setGeometry.registerListener([this](std::any d) { Events::listener_unmanagedSetGeometry(this, nullptr); }); m_listeners.setGeometry = m_xwaylandSurface->m_events.setGeometry.listen([this] { Events::listener_unmanagedSetGeometry(this, nullptr); });
} }
CWindow::~CWindow() { CWindow::~CWindow() {

2
src/desktop/Window.hpp
View File

@@ -148,7 +148,7 @@ class CWindow {
SP<CWLSurface> m_wlSurface; SP<CWLSurface> m_wlSurface;
struct { struct {
CSignal destroy; CSignalT<> destroy;
} m_events; } m_events;
WP<CXDGSurfaceResource> m_xdgSurface; WP<CXDGSurfaceResource> m_xdgSurface;

2
src/desktop/Workspace.cpp
View File

@@ -644,7 +644,7 @@ void CWorkspace::rename(const std::string& name) {
g_pCompositor->ensurePersistentWorkspacesPresent(std::vector<SWorkspaceRule>{WORKSPACERULE}, m_self.lock()); g_pCompositor->ensurePersistentWorkspacesPresent(std::vector<SWorkspaceRule>{WORKSPACERULE}, m_self.lock());
g_pEventManager->postEvent({.event = "renameworkspace", .data = std::to_string(m_id) + "," + m_name}); g_pEventManager->postEvent({.event = "renameworkspace", .data = std::to_string(m_id) + "," + m_name});
m_events.rename.emit(); m_events.renamed.emit();
} }
void CWorkspace::updateWindows() { void CWorkspace::updateWindows() {

8
src/desktop/Workspace.hpp
View File

@@ -85,10 +85,10 @@ class CWorkspace {
void updateWindows(); void updateWindows();
struct { struct {
CSignal destroy; CSignalT<> destroy;
CSignal rename; CSignalT<> renamed;
CSignal monitorChange; CSignalT<> monitorChanged;
CSignal activeChange; CSignalT<> activeChanged;
} m_events; } m_events;
private: private:

4
src/devices/IHID.hpp
View File

@@ -33,9 +33,9 @@ class IHID {
virtual eHIDType getType(); virtual eHIDType getType();
struct { struct {
CSignal destroy; CSignalT<> destroy;
} m_events; } m_events;
std::string m_deviceName; std::string m_deviceName;
std::string m_hlName; std::string m_hlName;
}; };

8
src/devices/IKeyboard.hpp
View File

@@ -48,10 +48,10 @@ class IKeyboard : public IHID {
}; };
struct { struct {
CSignal key; CSignalT<SKeyEvent> key;
CSignal modifiers; CSignalT<SModifiersEvent> modifiers;
CSignal keymap; CSignalT<SKeymapEvent> keymap;
CSignal repeatInfo; CSignalT<> repeatInfo;
} m_keyboardEvents; } m_keyboardEvents;
struct SStringRuleNames { struct SStringRuleNames {

26
src/devices/IPointer.hpp
View File

@@ -90,22 +90,22 @@ class IPointer : public IHID {
}; };
struct { struct {
CSignal motion; CSignalT<SMotionEvent> motion;
CSignal motionAbsolute; CSignalT<SMotionAbsoluteEvent> motionAbsolute;
CSignal button; CSignalT<SButtonEvent> button;
CSignal axis; CSignalT<SAxisEvent> axis;
CSignal frame; CSignalT<> frame;
CSignal swipeBegin; CSignalT<SSwipeBeginEvent> swipeBegin;
CSignal swipeEnd; CSignalT<SSwipeEndEvent> swipeEnd;
CSignal swipeUpdate; CSignalT<SSwipeUpdateEvent> swipeUpdate;
CSignal pinchBegin; CSignalT<SPinchBeginEvent> pinchBegin;
CSignal pinchEnd; CSignalT<SPinchEndEvent> pinchEnd;
CSignal pinchUpdate; CSignalT<SPinchUpdateEvent> pinchUpdate;
CSignal holdBegin; CSignalT<SHoldBeginEvent> holdBegin;
CSignal holdEnd; CSignalT<SHoldEndEvent> holdEnd;
} m_pointerEvents; } m_pointerEvents;
bool m_connected = false; // means connected to the cursor bool m_connected = false; // means connected to the cursor

12
src/devices/ITouch.hpp
View File

@@ -37,14 +37,14 @@ class ITouch : public IHID {
}; };
struct { struct {
CSignal down; CSignalT<SDownEvent> down;
CSignal up; CSignalT<SUpEvent> up;
CSignal motion; CSignalT<SMotionEvent> motion;
CSignal cancel; CSignalT<SCancelEvent> cancel;
CSignal frame; CSignalT<> frame;
} m_touchEvents; } m_touchEvents;
std::string m_boundOutput = ""; std::string m_boundOutput = "";
WP<ITouch> m_self; WP<ITouch> m_self;
}; };

16
src/devices/Keyboard.cpp
View File

@@ -23,24 +23,22 @@ CKeyboard::CKeyboard(SP<Aquamarine::IKeyboard> keeb) : m_keyboard(keeb) {
if (!keeb) if (!keeb)
return; return;
m_listeners.destroy = keeb->events.destroy.registerListener([this](std::any d) { m_listeners.destroy = keeb->events.destroy.listen([this] {
m_keyboard.reset(); m_keyboard.reset();
m_events.destroy.emit(); m_events.destroy.emit();
}); });
m_listeners.key = keeb->events.key.registerListener([this](std::any d) { m_listeners.key = keeb->events.key.listen([this](const Aquamarine::IKeyboard::SKeyEvent& event) {
auto E = std::any_cast<Aquamarine::IKeyboard::SKeyEvent>(d);
m_keyboardEvents.key.emit(SKeyEvent{ m_keyboardEvents.key.emit(SKeyEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.keycode = E.key, .keycode = event.key,
.state = E.pressed ? WL_KEYBOARD_KEY_STATE_PRESSED : WL_KEYBOARD_KEY_STATE_RELEASED, .state = event.pressed ? WL_KEYBOARD_KEY_STATE_PRESSED : WL_KEYBOARD_KEY_STATE_RELEASED,
}); });
updateXkbStateWithKey(E.key + 8, E.pressed); updateXkbStateWithKey(event.key + 8, event.pressed);
}); });
m_listeners.modifiers = keeb->events.modifiers.registerListener([this](std::any d) { m_listeners.modifiers = keeb->events.modifiers.listen([this] {
updateModifiersState(); updateModifiersState();
m_keyboardEvents.modifiers.emit(SModifiersEvent{ m_keyboardEvents.modifiers.emit(SModifiersEvent{

120
src/devices/Mouse.cpp
View File

@@ -19,133 +19,109 @@ CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : m_mouse(mouse_) {
m_isTouchpad = libinput_device_has_capability(handle, LIBINPUT_DEVICE_CAP_POINTER) && libinput_device_get_size(handle, &w, &h) == 0; m_isTouchpad = libinput_device_has_capability(handle, LIBINPUT_DEVICE_CAP_POINTER) && libinput_device_get_size(handle, &w, &h) == 0;
} }
m_listeners.destroy = m_mouse->events.destroy.registerListener([this](std::any d) { m_listeners.destroy = m_mouse->events.destroy.listen([this] {
m_mouse.reset(); m_mouse.reset();
m_events.destroy.emit(); m_events.destroy.emit();
}); });
m_listeners.motion = m_mouse->events.move.registerListener([this](std::any d) { m_listeners.motion = m_mouse->events.move.listen([this](const Aquamarine::IPointer::SMoveEvent& event) {
auto E = std::any_cast<Aquamarine::IPointer::SMoveEvent>(d);
m_pointerEvents.motion.emit(SMotionEvent{ m_pointerEvents.motion.emit(SMotionEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.delta = E.delta, .delta = event.delta,
.unaccel = E.unaccel, .unaccel = event.unaccel,
.mouse = true, .mouse = true,
.device = m_self.lock(), .device = m_self.lock(),
}); });
}); });
m_listeners.motionAbsolute = m_mouse->events.warp.registerListener([this](std::any d) { m_listeners.motionAbsolute = m_mouse->events.warp.listen([this](const Aquamarine::IPointer::SWarpEvent& event) {
auto E = std::any_cast<Aquamarine::IPointer::SWarpEvent>(d);
m_pointerEvents.motionAbsolute.emit(SMotionAbsoluteEvent{ m_pointerEvents.motionAbsolute.emit(SMotionAbsoluteEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.absolute = E.absolute, .absolute = event.absolute,
.device = m_self.lock(), .device = m_self.lock(),
}); });
}); });
m_listeners.button = m_mouse->events.button.registerListener([this](std::any d) { m_listeners.button = m_mouse->events.button.listen([this](const Aquamarine::IPointer::SButtonEvent& event) {
auto E = std::any_cast<Aquamarine::IPointer::SButtonEvent>(d);
m_pointerEvents.button.emit(SButtonEvent{ m_pointerEvents.button.emit(SButtonEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.button = E.button, .button = event.button,
.state = E.pressed ? WL_POINTER_BUTTON_STATE_PRESSED : WL_POINTER_BUTTON_STATE_RELEASED, .state = event.pressed ? WL_POINTER_BUTTON_STATE_PRESSED : WL_POINTER_BUTTON_STATE_RELEASED,
.mouse = true, .mouse = true,
}); });
}); });
m_listeners.axis = m_mouse->events.axis.registerListener([this](std::any d) { m_listeners.axis = m_mouse->events.axis.listen([this](const Aquamarine::IPointer::SAxisEvent& event) {
auto E = std::any_cast<Aquamarine::IPointer::SAxisEvent>(d);
m_pointerEvents.axis.emit(SAxisEvent{ m_pointerEvents.axis.emit(SAxisEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.source = (wl_pointer_axis_source)E.source, .source = (wl_pointer_axis_source)event.source,
.axis = (wl_pointer_axis)E.axis, .axis = (wl_pointer_axis)event.axis,
.relativeDirection = (wl_pointer_axis_relative_direction)E.direction, .relativeDirection = (wl_pointer_axis_relative_direction)event.direction,
.delta = E.delta, .delta = event.delta,
.deltaDiscrete = E.discrete, .deltaDiscrete = event.discrete,
.mouse = true, .mouse = true,
}); });
}); });
m_listeners.frame = m_mouse->events.frame.registerListener([this](std::any d) { m_pointerEvents.frame.emit(); }); m_listeners.frame = m_mouse->events.frame.listen([this] { m_pointerEvents.frame.emit(); });
m_listeners.swipeBegin = m_mouse->events.swipeBegin.registerListener([this](std::any d) {
auto E = std::any_cast<Aquamarine::IPointer::SSwipeBeginEvent>(d);
m_listeners.swipeBegin = m_mouse->events.swipeBegin.listen([this](const Aquamarine::IPointer::SSwipeBeginEvent& event) {
m_pointerEvents.swipeBegin.emit(SSwipeBeginEvent{ m_pointerEvents.swipeBegin.emit(SSwipeBeginEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.fingers = E.fingers, .fingers = event.fingers,
}); });
}); });
m_listeners.swipeEnd = m_mouse->events.swipeEnd.registerListener([this](std::any d) { m_listeners.swipeEnd = m_mouse->events.swipeEnd.listen([this](const Aquamarine::IPointer::SSwipeEndEvent& event) {
auto E = std::any_cast<Aquamarine::IPointer::SSwipeEndEvent>(d);
m_pointerEvents.swipeEnd.emit(SSwipeEndEvent{ m_pointerEvents.swipeEnd.emit(SSwipeEndEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.cancelled = E.cancelled, .cancelled = event.cancelled,
}); });
}); });
m_listeners.swipeUpdate = m_mouse->events.swipeUpdate.registerListener([this](std::any d) { m_listeners.swipeUpdate = m_mouse->events.swipeUpdate.listen([this](const Aquamarine::IPointer::SSwipeUpdateEvent& event) {
auto E = std::any_cast<Aquamarine::IPointer::SSwipeUpdateEvent>(d);
m_pointerEvents.swipeUpdate.emit(SSwipeUpdateEvent{ m_pointerEvents.swipeUpdate.emit(SSwipeUpdateEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.fingers = E.fingers, .fingers = event.fingers,
.delta = E.delta, .delta = event.delta,
}); });
}); });
m_listeners.pinchBegin = m_mouse->events.pinchBegin.registerListener([this](std::any d) { m_listeners.pinchBegin = m_mouse->events.pinchBegin.listen([this](const Aquamarine::IPointer::SPinchBeginEvent& event) {
auto E = std::any_cast<Aquamarine::IPointer::SPinchBeginEvent>(d);
m_pointerEvents.pinchBegin.emit(SPinchBeginEvent{ m_pointerEvents.pinchBegin.emit(SPinchBeginEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.fingers = E.fingers, .fingers = event.fingers,
}); });
}); });
m_listeners.pinchEnd = m_mouse->events.pinchEnd.registerListener([this](std::any d) { m_listeners.pinchEnd = m_mouse->events.pinchEnd.listen([this](const Aquamarine::IPointer::SPinchEndEvent& event) {
auto E = std::any_cast<Aquamarine::IPointer::SPinchEndEvent>(d);
m_pointerEvents.pinchEnd.emit(SPinchEndEvent{ m_pointerEvents.pinchEnd.emit(SPinchEndEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.cancelled = E.cancelled, .cancelled = event.cancelled,
}); });
}); });
m_listeners.pinchUpdate = m_mouse->events.pinchUpdate.registerListener([this](std::any d) { m_listeners.pinchUpdate = m_mouse->events.pinchUpdate.listen([this](const Aquamarine::IPointer::SPinchUpdateEvent& event) {
auto E = std::any_cast<Aquamarine::IPointer::SPinchUpdateEvent>(d);
m_pointerEvents.pinchUpdate.emit(SPinchUpdateEvent{ m_pointerEvents.pinchUpdate.emit(SPinchUpdateEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.fingers = E.fingers, .fingers = event.fingers,
.delta = E.delta, .delta = event.delta,
.scale = E.scale, .scale = event.scale,
.rotation = E.rotation, .rotation = event.rotation,
}); });
}); });
m_listeners.holdBegin = m_mouse->events.holdBegin.registerListener([this](std::any d) { m_listeners.holdBegin = m_mouse->events.holdBegin.listen([this](const Aquamarine::IPointer::SHoldBeginEvent& event) {
auto E = std::any_cast<Aquamarine::IPointer::SHoldBeginEvent>(d);
m_pointerEvents.holdBegin.emit(SHoldBeginEvent{ m_pointerEvents.holdBegin.emit(SHoldBeginEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.fingers = E.fingers, .fingers = event.fingers,
}); });
}); });
m_listeners.holdEnd = m_mouse->events.holdEnd.registerListener([this](std::any d) { m_listeners.holdEnd = m_mouse->events.holdEnd.listen([this](const Aquamarine::IPointer::SHoldEndEvent& event) {
auto E = std::any_cast<Aquamarine::IPointer::SHoldEndEvent>(d);
m_pointerEvents.holdEnd.emit(SHoldEndEvent{ m_pointerEvents.holdEnd.emit(SHoldEndEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.cancelled = E.cancelled, .cancelled = event.cancelled,
}); });
}); });

114
src/devices/Tablet.cpp
View File

@@ -69,63 +69,55 @@ CTablet::CTablet(SP<Aquamarine::ITablet> tablet_) : m_tablet(tablet_) {
if (!m_tablet) if (!m_tablet)
return; return;
m_listeners.destroy = m_tablet->events.destroy.registerListener([this](std::any d) { m_listeners.destroy = m_tablet->events.destroy.listen([this] {
m_tablet.reset(); m_tablet.reset();
m_events.destroy.emit(); m_events.destroy.emit();
}); });
m_listeners.axis = m_tablet->events.axis.registerListener([this](std::any d) { m_listeners.axis = m_tablet->events.axis.listen([this](const Aquamarine::ITablet::SAxisEvent& event) {
auto E = std::any_cast<Aquamarine::ITablet::SAxisEvent>(d);
m_tabletEvents.axis.emit(SAxisEvent{ m_tabletEvents.axis.emit(SAxisEvent{
.tool = E.tool, .tool = event.tool,
.tablet = m_self.lock(), .tablet = m_self.lock(),
.timeMs = E.timeMs, .timeMs = event.timeMs,
.updatedAxes = aqUpdateToHl(E.updatedAxes), .updatedAxes = aqUpdateToHl(event.updatedAxes),
.axis = E.absolute, .axis = event.absolute,
.axisDelta = E.delta, .axisDelta = event.delta,
.tilt = E.tilt, .tilt = event.tilt,
.pressure = E.pressure, .pressure = event.pressure,
.distance = E.distance, .distance = event.distance,
.rotation = E.rotation, .rotation = event.rotation,
.slider = E.slider, .slider = event.slider,
.wheelDelta = E.wheelDelta, .wheelDelta = event.wheelDelta,
}); });
}); });
m_listeners.proximity = m_tablet->events.proximity.registerListener([this](std::any d) { m_listeners.proximity = m_tablet->events.proximity.listen([this](const Aquamarine::ITablet::SProximityEvent& event) {
auto E = std::any_cast<Aquamarine::ITablet::SProximityEvent>(d);
m_tabletEvents.proximity.emit(SProximityEvent{ m_tabletEvents.proximity.emit(SProximityEvent{
.tool = E.tool, .tool = event.tool,
.tablet = m_self.lock(), .tablet = m_self.lock(),
.timeMs = E.timeMs, .timeMs = event.timeMs,
.proximity = E.absolute, .proximity = event.absolute,
.in = E.in, .in = event.in,
}); });
}); });
m_listeners.tip = m_tablet->events.tip.registerListener([this](std::any d) { m_listeners.tip = m_tablet->events.tip.listen([this](const Aquamarine::ITablet::STipEvent& event) {
auto E = std::any_cast<Aquamarine::ITablet::STipEvent>(d);
m_tabletEvents.tip.emit(STipEvent{ m_tabletEvents.tip.emit(STipEvent{
.tool = E.tool, .tool = event.tool,
.tablet = m_self.lock(), .tablet = m_self.lock(),
.timeMs = E.timeMs, .timeMs = event.timeMs,
.tip = E.absolute, .tip = event.absolute,
.in = E.down, .in = event.down,
}); });
}); });
m_listeners.button = m_tablet->events.button.registerListener([this](std::any d) { m_listeners.button = m_tablet->events.button.listen([this](const Aquamarine::ITablet::SButtonEvent& event) {
auto E = std::any_cast<Aquamarine::ITablet::SButtonEvent>(d);
m_tabletEvents.button.emit(SButtonEvent{ m_tabletEvents.button.emit(SButtonEvent{
.tool = E.tool, .tool = event.tool,
.tablet = m_self.lock(), .tablet = m_self.lock(),
.timeMs = E.timeMs, .timeMs = event.timeMs,
.button = E.button, .button = event.button,
.down = E.down, .down = event.down,
}); });
}); });
@@ -156,48 +148,42 @@ CTabletPad::CTabletPad(SP<Aquamarine::ITabletPad> pad_) : m_pad(pad_) {
if (!m_pad) if (!m_pad)
return; return;
m_listeners.destroy = m_pad->events.destroy.registerListener([this](std::any d) { m_listeners.destroy = m_pad->events.destroy.listen([this] {
m_pad.reset(); m_pad.reset();
m_events.destroy.emit(); m_events.destroy.emit();
}); });
m_listeners.button = m_pad->events.button.registerListener([this](std::any d) { m_listeners.button = m_pad->events.button.listen([this](const Aquamarine::ITabletPad::SButtonEvent& event) {
auto E = std::any_cast<Aquamarine::ITabletPad::SButtonEvent>(d);
m_padEvents.button.emit(SButtonEvent{ m_padEvents.button.emit(SButtonEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.button = E.button, .button = event.button,
.down = E.down, .down = event.down,
.mode = E.mode, .mode = event.mode,
.group = E.group, .group = event.group,
}); });
}); });
m_listeners.ring = m_pad->events.ring.registerListener([this](std::any d) { m_listeners.ring = m_pad->events.ring.listen([this](const Aquamarine::ITabletPad::SRingEvent& event) {
auto E = std::any_cast<Aquamarine::ITabletPad::SRingEvent>(d);
m_padEvents.ring.emit(SRingEvent{ m_padEvents.ring.emit(SRingEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.finger = E.source == Aquamarine::ITabletPad::AQ_TABLET_PAD_RING_SOURCE_FINGER, .finger = event.source == Aquamarine::ITabletPad::AQ_TABLET_PAD_RING_SOURCE_FINGER,
.ring = E.ring, .ring = event.ring,
.position = E.pos, .position = event.pos,
.mode = E.mode, .mode = event.mode,
}); });
}); });
m_listeners.strip = m_pad->events.strip.registerListener([this](std::any d) { m_listeners.strip = m_pad->events.strip.listen([this](const Aquamarine::ITabletPad::SStripEvent& event) {
auto E = std::any_cast<Aquamarine::ITabletPad::SStripEvent>(d);
m_padEvents.strip.emit(SStripEvent{ m_padEvents.strip.emit(SStripEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.finger = E.source == Aquamarine::ITabletPad::AQ_TABLET_PAD_STRIP_SOURCE_FINGER, .finger = event.source == Aquamarine::ITabletPad::AQ_TABLET_PAD_STRIP_SOURCE_FINGER,
.strip = E.strip, .strip = event.strip,
.position = E.pos, .position = event.pos,
.mode = E.mode, .mode = event.mode,
}); });
}); });
m_listeners.attach = m_pad->events.attach.registerListener([](std::any d) { m_listeners.attach = m_pad->events.attach.listen([] {
; // TODO: this doesn't do anything in aq atm ; // TODO: this doesn't do anything in aq atm
}); });
@@ -224,7 +210,7 @@ CTabletTool::CTabletTool(SP<Aquamarine::ITabletTool> tool_) : m_tool(tool_) {
if (!m_tool) if (!m_tool)
return; return;
m_listeners.destroyTool = m_tool->events.destroy.registerListener([this](std::any d) { m_listeners.destroyTool = m_tool->events.destroy.listen([this] {
m_tool.reset(); m_tool.reset();
m_events.destroy.emit(); m_events.destroy.emit();
}); });
@@ -265,7 +251,7 @@ void CTabletTool::setSurface(SP<CWLSurfaceResource> surf) {
m_surface = surf; m_surface = surf;
if (surf) { if (surf) {
m_listeners.destroySurface = surf->m_events.destroy.registerListener([this](std::any d) { m_listeners.destroySurface = surf->m_events.destroy.listen([this] {
PROTO::tablet->proximityOut(m_self.lock()); PROTO::tablet->proximityOut(m_self.lock());
m_surface.reset(); m_surface.reset();
m_listeners.destroySurface.reset(); m_listeners.destroySurface.reset();

18
src/devices/Tablet.hpp
View File

@@ -82,10 +82,10 @@ class CTablet : public IHID {
}; };
struct { struct {
CSignal axis; CSignalT<SAxisEvent> axis;
CSignal proximity; CSignalT<SProximityEvent> proximity;
CSignal tip; CSignalT<STipEvent> tip;
CSignal button; CSignalT<SButtonEvent> button;
} m_tabletEvents; } m_tabletEvents;
WP<CTablet> m_self; WP<CTablet> m_self;
@@ -144,10 +144,10 @@ class CTabletPad : public IHID {
}; };
struct { struct {
CSignal button; CSignalT<SButtonEvent> button;
CSignal ring; CSignalT<SRingEvent> ring;
CSignal strip; CSignalT<SStripEvent> strip;
CSignal attach; CSignalT<SP<CTabletTool>> attach;
} m_padEvents; } m_padEvents;
WP<CTabletPad> m_self; WP<CTabletPad> m_self;
@@ -217,4 +217,4 @@ class CTabletTool : public IHID {
CHyprSignalListener destroySurface; CHyprSignalListener destroySurface;
CHyprSignalListener destroyTool; CHyprSignalListener destroyTool;
} m_listeners; } m_listeners;
}; };

40
src/devices/TouchDevice.cpp
View File

@@ -14,51 +14,43 @@ CTouchDevice::CTouchDevice(SP<Aquamarine::ITouch> touch_) : m_touch(touch_) {
if (!m_touch) if (!m_touch)
return; return;
m_listeners.destroy = m_touch->events.destroy.registerListener([this](std::any d) { m_listeners.destroy = m_touch->events.destroy.listen([this] {
m_events.destroy.emit(); m_events.destroy.emit();
m_touch.reset(); m_touch.reset();
}); });
m_listeners.down = m_touch->events.down.registerListener([this](std::any d) { m_listeners.down = m_touch->events.down.listen([this](const Aquamarine::ITouch::SDownEvent& event) {
auto E = std::any_cast<Aquamarine::ITouch::SDownEvent>(d);
m_touchEvents.down.emit(SDownEvent{ m_touchEvents.down.emit(SDownEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.touchID = E.touchID, .touchID = event.touchID,
.pos = E.pos, .pos = event.pos,
.device = m_self.lock(), .device = m_self.lock(),
}); });
}); });
m_listeners.up = m_touch->events.up.registerListener([this](std::any d) { m_listeners.up = m_touch->events.up.listen([this](const Aquamarine::ITouch::SUpEvent& event) {
auto E = std::any_cast<Aquamarine::ITouch::SUpEvent>(d);
m_touchEvents.up.emit(SUpEvent{ m_touchEvents.up.emit(SUpEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.touchID = E.touchID, .touchID = event.touchID,
}); });
}); });
m_listeners.motion = m_touch->events.move.registerListener([this](std::any d) { m_listeners.motion = m_touch->events.move.listen([this](const Aquamarine::ITouch::SMotionEvent& event) {
auto E = std::any_cast<Aquamarine::ITouch::SMotionEvent>(d);
m_touchEvents.motion.emit(SMotionEvent{ m_touchEvents.motion.emit(SMotionEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.touchID = E.touchID, .touchID = event.touchID,
.pos = E.pos, .pos = event.pos,
}); });
}); });
m_listeners.cancel = m_touch->events.cancel.registerListener([this](std::any d) { m_listeners.cancel = m_touch->events.cancel.listen([this](const Aquamarine::ITouch::SCancelEvent& event) {
auto E = std::any_cast<Aquamarine::ITouch::SCancelEvent>(d);
m_touchEvents.cancel.emit(SCancelEvent{ m_touchEvents.cancel.emit(SCancelEvent{
.timeMs = E.timeMs, .timeMs = event.timeMs,
.touchID = E.touchID, .touchID = event.touchID,
}); });
}); });
m_listeners.frame = m_touch->events.frame.registerListener([this](std::any d) { m_touchEvents.frame.emit(); }); m_listeners.frame = m_touch->events.frame.listen([this] { m_touchEvents.frame.emit(); });
m_deviceName = m_touch->getName(); m_deviceName = m_touch->getName();
} }

16
src/devices/VirtualKeyboard.cpp
View File

@@ -14,15 +14,14 @@ CVirtualKeyboard::CVirtualKeyboard(SP<CVirtualKeyboardV1Resource> keeb_) : m_key
if (!keeb_) if (!keeb_)
return; return;
m_listeners.destroy = keeb_->m_events.destroy.registerListener([this](std::any d) { m_listeners.destroy = keeb_->m_events.destroy.listen([this] {
m_keyboard.reset(); m_keyboard.reset();
m_events.destroy.emit(); m_events.destroy.emit();
}); });
m_listeners.key = keeb_->m_events.key.registerListener([this](std::any d) { m_keyboardEvents.key.emit(d); }); m_listeners.key = keeb_->m_events.key.listen([this](const auto& event) { m_keyboardEvents.key.emit(event); });
m_listeners.modifiers = keeb_->m_events.modifiers.registerListener([this](std::any d) { m_listeners.modifiers = keeb_->m_events.modifiers.listen([this](const SModifiersEvent& event) {
auto E = std::any_cast<SModifiersEvent>(d); updateModifiers(event.depressed, event.latched, event.locked, event.group);
updateModifiers(E.depressed, E.latched, E.locked, E.group);
m_keyboardEvents.modifiers.emit(SModifiersEvent{ m_keyboardEvents.modifiers.emit(SModifiersEvent{
.depressed = m_modifiersState.depressed, .depressed = m_modifiersState.depressed,
.latched = m_modifiersState.latched, .latched = m_modifiersState.latched,
@@ -30,15 +29,14 @@ CVirtualKeyboard::CVirtualKeyboard(SP<CVirtualKeyboardV1Resource> keeb_) : m_key
.group = m_modifiersState.group, .group = m_modifiersState.group,
}); });
}); });
m_listeners.keymap = keeb_->m_events.keymap.registerListener([this](std::any d) { m_listeners.keymap = keeb_->m_events.keymap.listen([this](const SKeymapEvent& event) {
auto E = std::any_cast<SKeymapEvent>(d);
if (m_xkbKeymap) if (m_xkbKeymap)
xkb_keymap_unref(m_xkbKeymap); xkb_keymap_unref(m_xkbKeymap);
m_xkbKeymap = xkb_keymap_ref(E.keymap); m_xkbKeymap = xkb_keymap_ref(event.keymap);
m_keymapOverridden = true; m_keymapOverridden = true;
updateXKBTranslationState(m_xkbKeymap); updateXKBTranslationState(m_xkbKeymap);
updateKeymapFD(); updateKeymapFD();
m_keyboardEvents.keymap.emit(d); m_keyboardEvents.keymap.emit(event);
}); });
m_deviceName = keeb_->m_name; m_deviceName = keeb_->m_name;

38
src/devices/VirtualPointer.cpp
View File

@@ -14,33 +14,31 @@ CVirtualPointer::CVirtualPointer(SP<CVirtualPointerV1Resource> resource) : m_poi
if UNLIKELY (!resource->good()) if UNLIKELY (!resource->good())
return; return;
m_listeners.destroy = m_pointer->m_events.destroy.registerListener([this](std::any d) { m_listeners.destroy = m_pointer->m_events.destroy.listen([this] {
m_pointer.reset(); m_pointer.reset();
m_events.destroy.emit(); m_events.destroy.emit();
}); });
m_listeners.motion = m_pointer->m_events.move.registerListener([this](std::any d) { m_listeners.motion = m_pointer->m_events.move.listen([this](SMotionEvent event) {
auto E = std::any_cast<SMotionEvent>(d); event.device = m_self.lock();
E.device = m_self.lock(); m_pointerEvents.motion.emit(event);
m_pointerEvents.motion.emit(E);
}); });
m_listeners.motionAbsolute = m_pointer->m_events.warp.registerListener([this](std::any d) { m_listeners.motionAbsolute = m_pointer->m_events.warp.listen([this](SMotionAbsoluteEvent event) {
// we need to unpack the event and add our device here because it's required to calculate the position correctly // we need to unpack the event and add our device here because it's required to calculate the position correctly
auto E = std::any_cast<SMotionAbsoluteEvent>(d); event.device = m_self.lock();
E.device = m_self.lock(); m_pointerEvents.motionAbsolute.emit(event);
m_pointerEvents.motionAbsolute.emit(E);
}); });
m_listeners.button = m_pointer->m_events.button.registerListener([this](std::any d) { m_pointerEvents.button.emit(d); }); m_listeners.button = m_pointer->m_events.button.forward(m_pointerEvents.button);
m_listeners.axis = m_pointer->m_events.axis.registerListener([this](std::any d) { m_pointerEvents.axis.emit(d); }); m_listeners.axis = m_pointer->m_events.axis.forward(m_pointerEvents.axis);
m_listeners.frame = m_pointer->m_events.frame.registerListener([this](std::any d) { m_pointerEvents.frame.emit(); }); m_listeners.frame = m_pointer->m_events.frame.forward(m_pointerEvents.frame);
m_listeners.swipeBegin = m_pointer->m_events.swipeBegin.registerListener([this](std::any d) { m_pointerEvents.swipeBegin.emit(d); }); m_listeners.swipeBegin = m_pointer->m_events.swipeBegin.forward(m_pointerEvents.swipeBegin);
m_listeners.swipeEnd = m_pointer->m_events.swipeEnd.registerListener([this](std::any d) { m_pointerEvents.swipeEnd.emit(d); }); m_listeners.swipeEnd = m_pointer->m_events.swipeEnd.forward(m_pointerEvents.swipeEnd);
m_listeners.swipeUpdate = m_pointer->m_events.swipeUpdate.registerListener([this](std::any d) { m_pointerEvents.swipeUpdate.emit(d); }); m_listeners.swipeUpdate = m_pointer->m_events.swipeUpdate.forward(m_pointerEvents.swipeUpdate);
m_listeners.pinchBegin = m_pointer->m_events.pinchBegin.registerListener([this](std::any d) { m_pointerEvents.pinchBegin.emit(d); }); m_listeners.pinchBegin = m_pointer->m_events.pinchBegin.forward(m_pointerEvents.pinchBegin);
m_listeners.pinchEnd = m_pointer->m_events.pinchEnd.registerListener([this](std::any d) { m_pointerEvents.pinchEnd.emit(d); }); m_listeners.pinchEnd = m_pointer->m_events.pinchEnd.forward(m_pointerEvents.pinchEnd);
m_listeners.pinchUpdate = m_pointer->m_events.pinchUpdate.registerListener([this](std::any d) { m_pointerEvents.pinchUpdate.emit(d); }); m_listeners.pinchUpdate = m_pointer->m_events.pinchUpdate.forward(m_pointerEvents.pinchUpdate);
m_listeners.holdBegin = m_pointer->m_events.holdBegin.registerListener([this](std::any d) { m_pointerEvents.holdBegin.emit(d); }); m_listeners.holdBegin = m_pointer->m_events.holdBegin.forward(m_pointerEvents.holdBegin);
m_listeners.holdEnd = m_pointer->m_events.holdEnd.registerListener([this](std::any d) { m_pointerEvents.holdEnd.emit(d); }); m_listeners.holdEnd = m_pointer->m_events.holdEnd.forward(m_pointerEvents.holdEnd);
m_boundOutput = resource->m_boundOutput ? resource->m_boundOutput->m_name : ""; m_boundOutput = resource->m_boundOutput ? resource->m_boundOutput->m_name : "";

41
src/helpers/Monitor.cpp
View File

@@ -68,20 +68,17 @@ void CMonitor::onConnect(bool noRule) {
g_pEventLoopManager->doLater([] { g_pConfigManager->ensurePersistentWorkspacesPresent(); }); g_pEventLoopManager->doLater([] { g_pConfigManager->ensurePersistentWorkspacesPresent(); });
m_listeners.frame = m_output->events.frame.registerListener([this](std::any d) { m_frameScheduler->onFrame(); }); m_listeners.frame = m_output->events.frame.listen([this] { m_frameScheduler->onFrame(); });
m_listeners.commit = m_output->events.commit.registerListener([this](std::any d) { m_listeners.commit = m_output->events.commit.listen([this] {
if (true) { // FIXME: E->state->committed & WLR_OUTPUT_STATE_BUFFER if (true) { // FIXME: E->state->committed & WLR_OUTPUT_STATE_BUFFER
PROTO::screencopy->onOutputCommit(m_self.lock()); PROTO::screencopy->onOutputCommit(m_self.lock());
PROTO::toplevelExport->onOutputCommit(m_self.lock()); PROTO::toplevelExport->onOutputCommit(m_self.lock());
} }
}); });
m_listeners.needsFrame = m_listeners.needsFrame = m_output->events.needsFrame.listen([this] { g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_NEEDS_FRAME); });
m_output->events.needsFrame.registerListener([this](std::any d) { g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_NEEDS_FRAME); });
m_listeners.presented = m_output->events.present.registerListener([this](std::any d) { m_listeners.presented = m_output->events.present.listen([this](const Aquamarine::IOutput::SPresentEvent& event) {
auto E = std::any_cast<Aquamarine::IOutput::SPresentEvent>(d); timespec* ts = event.when;
timespec* ts = E.when;
if (ts && ts->tv_sec <= 2) { if (ts && ts->tv_sec <= 2) {
// drop this timestamp, it's not valid. Likely drm is cringe. We can't push it further because // drop this timestamp, it's not valid. Likely drm is cringe. We can't push it further because
@@ -90,14 +87,14 @@ void CMonitor::onConnect(bool noRule) {
} }
if (!ts) if (!ts)
PROTO::presentation->onPresented(m_self.lock(), Time::steadyNow(), E.refresh, E.seq, E.flags); PROTO::presentation->onPresented(m_self.lock(), Time::steadyNow(), event.refresh, event.seq, event.flags);
else else
PROTO::presentation->onPresented(m_self.lock(), Time::fromTimespec(E.when), E.refresh, E.seq, E.flags); PROTO::presentation->onPresented(m_self.lock(), Time::fromTimespec(event.when), event.refresh, event.seq, event.flags);
m_frameScheduler->onPresented(); m_frameScheduler->onPresented();
}); });
m_listeners.destroy = m_output->events.destroy.registerListener([this](std::any d) { m_listeners.destroy = m_output->events.destroy.listen([this] {
Debug::log(LOG, "Destroy called for monitor {}", m_name); Debug::log(LOG, "Destroy called for monitor {}", m_name);
onDisconnect(true); onDisconnect(true);
@@ -110,10 +107,8 @@ void CMonitor::onConnect(bool noRule) {
std::erase_if(g_pCompositor->m_realMonitors, [&](PHLMONITOR& el) { return el.get() == this; }); std::erase_if(g_pCompositor->m_realMonitors, [&](PHLMONITOR& el) { return el.get() == this; });
}); });
m_listeners.state = m_output->events.state.registerListener([this](std::any d) { m_listeners.state = m_output->events.state.listen([this](const Aquamarine::IOutput::SStateEvent& event) {
auto E = std::any_cast<Aquamarine::IOutput::SStateEvent>(d); if (event.size == Vector2D{}) {
if (E.size == Vector2D{}) {
// an indication to re-set state // an indication to re-set state
// we can't do much for createdByUser displays I think // we can't do much for createdByUser displays I think
if (m_createdByUser) if (m_createdByUser)
@@ -127,7 +122,7 @@ void CMonitor::onConnect(bool noRule) {
if (!m_createdByUser) if (!m_createdByUser)
return; return;
const auto SIZE = E.size; const auto SIZE = event.size;
m_forceSize = SIZE; m_forceSize = SIZE;
@@ -1034,7 +1029,7 @@ void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
m_activeWorkspace = PNEWWORKSPACE; m_activeWorkspace = PNEWWORKSPACE;
PNEWWORKSPACE->m_events.activeChange.emit(); PNEWWORKSPACE->m_events.activeChanged.emit();
PNEWWORKSPACE->m_visible = true; PNEWWORKSPACE->m_visible = true;
PNEWWORKSPACE->m_lastMonitor = ""; PNEWWORKSPACE->m_lastMonitor = "";
} }
@@ -1195,7 +1190,7 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo
if (POLDWORKSPACE) { if (POLDWORKSPACE) {
POLDWORKSPACE->m_visible = false; POLDWORKSPACE->m_visible = false;
POLDWORKSPACE->m_events.activeChange.emit(); POLDWORKSPACE->m_events.activeChanged.emit();
} }
pWorkspace->m_visible = true; pWorkspace->m_visible = true;
@@ -1241,7 +1236,7 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo
EMIT_HOOK_EVENT("workspace", pWorkspace); EMIT_HOOK_EVENT("workspace", pWorkspace);
} }
pWorkspace->m_events.activeChange.emit(); pWorkspace->m_events.activeChanged.emit();
g_pHyprRenderer->damageMonitor(m_self.lock()); g_pHyprRenderer->damageMonitor(m_self.lock());
@@ -1281,7 +1276,7 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
m_activeSpecialWorkspace.reset(); m_activeSpecialWorkspace.reset();
if (POLDSPECIAL) if (POLDSPECIAL)
POLDSPECIAL->m_events.activeChange.emit(); POLDSPECIAL->m_events.activeChanged.emit();
g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_id); g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_id);
@@ -1327,13 +1322,13 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) {
m_activeSpecialWorkspace->m_visible = true; m_activeSpecialWorkspace->m_visible = true;
if (POLDSPECIAL) if (POLDSPECIAL)
POLDSPECIAL->m_events.activeChange.emit(); POLDSPECIAL->m_events.activeChanged.emit();
if (PMONITORWORKSPACEOWNER != m_self) if (PMONITORWORKSPACEOWNER != m_self)
pWorkspace->m_events.monitorChange.emit(); pWorkspace->m_events.monitorChanged.emit();
if (!wasActive) if (!wasActive)
pWorkspace->m_events.activeChange.emit(); pWorkspace->m_events.activeChanged.emit();
if (!wasActive) if (!wasActive)
pWorkspace->startAnim(true, true); pWorkspace->startAnim(true, true);

10
src/helpers/Monitor.hpp
View File

@@ -194,11 +194,11 @@ class CMonitor {
} m_tearingState; } m_tearingState;
struct { struct {
CSignal destroy; CSignalT<> destroy;
CSignal connect; CSignalT<> connect;
CSignal disconnect; CSignalT<> disconnect;
CSignal dpmsChanged; CSignalT<> dpmsChanged;
CSignal modeChanged; CSignalT<> modeChanged;
} m_events; } m_events;
std::array<std::vector<PHLLSREF>, 4> m_layerSurfaceLayers; std::array<std::vector<PHLLSREF>, 4> m_layerSurfaceLayers;

172
src/managers/PointerManager.cpp
View File

@@ -29,14 +29,12 @@ CPointerManager::CPointerManager() {
onMonitorLayoutChange(); onMonitorLayoutChange();
PMONITOR->m_events.modeChanged.registerStaticListener([this](void* owner, std::any data) { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); }, nullptr); PMONITOR->m_events.modeChanged.listenStatic([this] { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); });
PMONITOR->m_events.disconnect.registerStaticListener([this](void* owner, std::any data) { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); }, nullptr); PMONITOR->m_events.disconnect.listenStatic([this] { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); });
PMONITOR->m_events.destroy.registerStaticListener( PMONITOR->m_events.destroy.listenStatic([this] {
[this](void* owner, std::any data) { if (g_pCompositor && !g_pCompositor->m_isShuttingDown)
if (g_pCompositor && !g_pCompositor->m_isShuttingDown) std::erase_if(m_monitorStates, [](const auto& other) { return other->monitor.expired(); });
std::erase_if(m_monitorStates, [](const auto& other) { return other->monitor.expired(); }); });
},
nullptr);
}); });
m_hooks.monitorPreRender = g_pHookSystem->hookDynamic("preMonitorCommit", [this](void* self, SCallbackInfo& info, std::any data) { m_hooks.monitorPreRender = g_pHookSystem->hookDynamic("preMonitorCommit", [this](void* self, SCallbackInfo& info, std::any data) {
@@ -149,8 +147,8 @@ void CPointerManager::setCursorSurface(SP<CWLSurface> surf, const Vector2D& hots
surf->resource()->map(); surf->resource()->map();
m_currentCursorImage.destroySurface = surf->m_events.destroy.registerListener([this](std::any data) { resetCursorImage(); }); m_currentCursorImage.destroySurface = surf->m_events.destroy.listen([this] { resetCursorImage(); });
m_currentCursorImage.commitSurface = surf->resource()->m_events.commit.registerListener([this](std::any data) { m_currentCursorImage.commitSurface = surf->resource()->m_events.commit.listen([this] {
damageIfSoftware(); damageIfSoftware();
m_currentCursorImage.size = m_currentCursorImage.surface->resource()->m_current.texture ? m_currentCursorImage.surface->resource()->m_current.bufferSize : Vector2D{}; m_currentCursorImage.size = m_currentCursorImage.surface->resource()->m_current.texture ? m_currentCursorImage.surface->resource()->m_current.bufferSize : Vector2D{};
m_currentCursorImage.scale = m_currentCursorImage.surface ? m_currentCursorImage.surface->resource()->m_current.scale : 1.F; m_currentCursorImage.scale = m_currentCursorImage.surface ? m_currentCursorImage.surface->resource()->m_current.scale : 1.F;
@@ -898,15 +896,9 @@ void CPointerManager::attachPointer(SP<IPointer> pointer) {
listener->pointer = pointer; listener->pointer = pointer;
// clang-format off listener->destroy = pointer->m_events.destroy.listen([this] { detachPointer(nullptr); });
listener->destroy = pointer->m_events.destroy.registerListener([this] (std::any d) { listener->motion = pointer->m_pointerEvents.motion.listen([](const IPointer::SMotionEvent& event) {
detachPointer(nullptr); g_pInputManager->onMouseMoved(event);
});
listener->motion = pointer->m_pointerEvents.motion.registerListener([] (std::any e) {
auto E = std::any_cast<IPointer::SMotionEvent>(e);
g_pInputManager->onMouseMoved(E);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
@@ -914,10 +906,8 @@ void CPointerManager::attachPointer(SP<IPointer> pointer) {
g_pKeybindManager->dpms("on"); g_pKeybindManager->dpms("on");
}); });
listener->motionAbsolute = pointer->m_pointerEvents.motionAbsolute.registerListener([] (std::any e) { listener->motionAbsolute = pointer->m_pointerEvents.motionAbsolute.listen([](const IPointer::SMotionAbsoluteEvent& event) {
auto E = std::any_cast<IPointer::SMotionAbsoluteEvent>(e); g_pInputManager->onMouseWarp(event);
g_pInputManager->onMouseWarp(E);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
@@ -925,37 +915,29 @@ void CPointerManager::attachPointer(SP<IPointer> pointer) {
g_pKeybindManager->dpms("on"); g_pKeybindManager->dpms("on");
}); });
listener->button = pointer->m_pointerEvents.button.registerListener([] (std::any e) { listener->button = pointer->m_pointerEvents.button.listen([](const IPointer::SButtonEvent& event) {
auto E = std::any_cast<IPointer::SButtonEvent>(e); g_pInputManager->onMouseButton(event);
g_pInputManager->onMouseButton(E);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
}); });
listener->axis = pointer->m_pointerEvents.axis.registerListener([] (std::any e) { listener->axis = pointer->m_pointerEvents.axis.listen([](const IPointer::SAxisEvent& event) {
auto E = std::any_cast<IPointer::SAxisEvent>(e); g_pInputManager->onMouseWheel(event);
g_pInputManager->onMouseWheel(E);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
}); });
listener->frame = pointer->m_pointerEvents.frame.registerListener([] (std::any e) { listener->frame = pointer->m_pointerEvents.frame.listen([] {
bool shouldSkip = false; bool shouldSkip = false;
if (!g_pSeatManager->m_mouse.expired() && g_pInputManager->isLocked()) { if (!g_pSeatManager->m_mouse.expired() && g_pInputManager->isLocked()) {
auto PMONITOR = g_pCompositor->m_lastMonitor.get(); auto PMONITOR = g_pCompositor->m_lastMonitor.get();
shouldSkip = PMONITOR && PMONITOR->shouldSkipScheduleFrameOnMouseEvent(); shouldSkip = PMONITOR && PMONITOR->shouldSkipScheduleFrameOnMouseEvent();
} }
g_pSeatManager->m_isPointerFrameSkipped = shouldSkip; g_pSeatManager->m_isPointerFrameSkipped = shouldSkip;
if (!g_pSeatManager->m_isPointerFrameSkipped) if (!g_pSeatManager->m_isPointerFrameSkipped)
g_pSeatManager->sendPointerFrame(); g_pSeatManager->sendPointerFrame();
}); });
listener->swipeBegin = pointer->m_pointerEvents.swipeBegin.registerListener([] (std::any e) { listener->swipeBegin = pointer->m_pointerEvents.swipeBegin.listen([](const IPointer::SSwipeBeginEvent& event) {
auto E = std::any_cast<IPointer::SSwipeBeginEvent>(e); g_pInputManager->onSwipeBegin(event);
g_pInputManager->onSwipeBegin(E);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
@@ -963,26 +945,18 @@ void CPointerManager::attachPointer(SP<IPointer> pointer) {
g_pKeybindManager->dpms("on"); g_pKeybindManager->dpms("on");
}); });
listener->swipeEnd = pointer->m_pointerEvents.swipeEnd.registerListener([] (std::any e) { listener->swipeEnd = pointer->m_pointerEvents.swipeEnd.listen([](const IPointer::SSwipeEndEvent& event) {
auto E = std::any_cast<IPointer::SSwipeEndEvent>(e); g_pInputManager->onSwipeEnd(event);
g_pInputManager->onSwipeEnd(E);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
}); });
listener->swipeUpdate = pointer->m_pointerEvents.swipeUpdate.registerListener([] (std::any e) { listener->swipeUpdate = pointer->m_pointerEvents.swipeUpdate.listen([](const IPointer::SSwipeUpdateEvent& event) {
auto E = std::any_cast<IPointer::SSwipeUpdateEvent>(e); g_pInputManager->onSwipeUpdate(event);
g_pInputManager->onSwipeUpdate(E);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
}); });
listener->pinchBegin = pointer->m_pointerEvents.pinchBegin.registerListener([] (std::any e) { listener->pinchBegin = pointer->m_pointerEvents.pinchBegin.listen([](const IPointer::SPinchBeginEvent& event) {
auto E = std::any_cast<IPointer::SPinchBeginEvent>(e); PROTO::pointerGestures->pinchBegin(event.timeMs, event.fingers);
PROTO::pointerGestures->pinchBegin(E.timeMs, E.fingers);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
@@ -990,38 +964,25 @@ void CPointerManager::attachPointer(SP<IPointer> pointer) {
g_pKeybindManager->dpms("on"); g_pKeybindManager->dpms("on");
}); });
listener->pinchEnd = pointer->m_pointerEvents.pinchEnd.registerListener([] (std::any e) { listener->pinchEnd = pointer->m_pointerEvents.pinchEnd.listen([](const IPointer::SPinchEndEvent& event) {
auto E = std::any_cast<IPointer::SPinchEndEvent>(e); PROTO::pointerGestures->pinchEnd(event.timeMs, event.cancelled);
PROTO::pointerGestures->pinchEnd(E.timeMs, E.cancelled);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
}); });
listener->pinchUpdate = pointer->m_pointerEvents.pinchUpdate.registerListener([] (std::any e) { listener->pinchUpdate = pointer->m_pointerEvents.pinchUpdate.listen([](const IPointer::SPinchUpdateEvent& event) {
auto E = std::any_cast<IPointer::SPinchUpdateEvent>(e); PROTO::pointerGestures->pinchUpdate(event.timeMs, event.delta, event.scale, event.rotation);
PROTO::pointerGestures->pinchUpdate(E.timeMs, E.delta, E.scale, E.rotation);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
}); });
listener->holdBegin = pointer->m_pointerEvents.holdBegin.registerListener([] (std::any e) { listener->holdBegin = pointer->m_pointerEvents.holdBegin.listen([](const IPointer::SHoldBeginEvent& event) {
auto E = std::any_cast<IPointer::SHoldBeginEvent>(e); PROTO::pointerGestures->holdBegin(event.timeMs, event.fingers);
PROTO::pointerGestures->holdBegin(E.timeMs, E.fingers);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
}); });
listener->holdEnd = pointer->m_pointerEvents.holdEnd.registerListener([] (std::any e) { listener->holdEnd = pointer->m_pointerEvents.holdEnd.listen([](const IPointer::SHoldEndEvent& event) {
auto E = std::any_cast<IPointer::SHoldEndEvent>(e); PROTO::pointerGestures->holdEnd(event.timeMs, event.cancelled);
PROTO::pointerGestures->holdEnd(E.timeMs, E.cancelled);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
}); });
// clang-format on
Debug::log(LOG, "Attached pointer {} to global", pointer->m_hlName); Debug::log(LOG, "Attached pointer {} to global", pointer->m_hlName);
} }
@@ -1037,15 +998,10 @@ void CPointerManager::attachTouch(SP<ITouch> touch) {
listener->touch = touch; listener->touch = touch;
// clang-format off listener->destroy = touch->m_events.destroy.listen([this] { detachTouch(nullptr); });
listener->destroy = touch->m_events.destroy.registerListener([this] (std::any d) {
detachTouch(nullptr);
});
listener->down = touch->m_touchEvents.down.registerListener([] (std::any e) { listener->down = touch->m_touchEvents.down.listen([](const ITouch::SDownEvent& event) {
auto E = std::any_cast<ITouch::SDownEvent>(e); g_pInputManager->onTouchDown(event);
g_pInputManager->onTouchDown(E);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
@@ -1053,30 +1009,21 @@ void CPointerManager::attachTouch(SP<ITouch> touch) {
g_pKeybindManager->dpms("on"); g_pKeybindManager->dpms("on");
}); });
listener->up = touch->m_touchEvents.up.registerListener([] (std::any e) { listener->up = touch->m_touchEvents.up.listen([](const ITouch::SUpEvent& event) {
auto E = std::any_cast<ITouch::SUpEvent>(e); g_pInputManager->onTouchUp(event);
g_pInputManager->onTouchUp(E);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
}); });
listener->motion = touch->m_touchEvents.motion.registerListener([] (std::any e) { listener->motion = touch->m_touchEvents.motion.listen([](const ITouch::SMotionEvent& event) {
auto E = std::any_cast<ITouch::SMotionEvent>(e); g_pInputManager->onTouchMove(event);
g_pInputManager->onTouchMove(E);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
}); });
listener->cancel = touch->m_touchEvents.cancel.registerListener([] (std::any e) { listener->cancel = touch->m_touchEvents.cancel.listen([] {
// //
}); });
listener->frame = touch->m_touchEvents.frame.registerListener([] (std::any e) { listener->frame = touch->m_touchEvents.frame.listen([] { g_pSeatManager->sendTouchFrame(); });
g_pSeatManager->sendTouchFrame();
});
// clang-format on
Debug::log(LOG, "Attached touch {} to global", touch->m_hlName); Debug::log(LOG, "Attached touch {} to global", touch->m_hlName);
} }
@@ -1092,15 +1039,10 @@ void CPointerManager::attachTablet(SP<CTablet> tablet) {
listener->tablet = tablet; listener->tablet = tablet;
// clang-format off listener->destroy = tablet->m_events.destroy.listen([this] { detachTablet(nullptr); });
listener->destroy = tablet->m_events.destroy.registerListener([this] (std::any d) {
detachTablet(nullptr);
});
listener->axis = tablet->m_tabletEvents.axis.registerListener([] (std::any e) { listener->axis = tablet->m_tabletEvents.axis.listen([](const CTablet::SAxisEvent& event) {
auto E = std::any_cast<CTablet::SAxisEvent>(e); g_pInputManager->onTabletAxis(event);
g_pInputManager->onTabletAxis(E);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
@@ -1108,18 +1050,13 @@ void CPointerManager::attachTablet(SP<CTablet> tablet) {
g_pKeybindManager->dpms("on"); g_pKeybindManager->dpms("on");
}); });
listener->proximity = tablet->m_tabletEvents.proximity.registerListener([] (std::any e) { listener->proximity = tablet->m_tabletEvents.proximity.listen([](const CTablet::SProximityEvent& event) {
auto E = std::any_cast<CTablet::SProximityEvent>(e); g_pInputManager->onTabletProximity(event);
g_pInputManager->onTabletProximity(E);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
}); });
listener->tip = tablet->m_tabletEvents.tip.registerListener([] (std::any e) { listener->tip = tablet->m_tabletEvents.tip.listen([](const CTablet::STipEvent& event) {
auto E = std::any_cast<CTablet::STipEvent>(e); g_pInputManager->onTabletTip(event);
g_pInputManager->onTabletTip(E);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
@@ -1127,11 +1064,8 @@ void CPointerManager::attachTablet(SP<CTablet> tablet) {
g_pKeybindManager->dpms("on"); g_pKeybindManager->dpms("on");
}); });
listener->button = tablet->m_tabletEvents.button.registerListener([] (std::any e) { listener->button = tablet->m_tabletEvents.button.listen([](const CTablet::SButtonEvent& event) {
auto E = std::any_cast<CTablet::SButtonEvent>(e); g_pInputManager->onTabletButton(event);
g_pInputManager->onTabletButton(E);
PROTO::idle->onActivity(); PROTO::idle->onActivity();
}); });
// clang-format on // clang-format on

2
src/managers/ProtocolManager.cpp
View File

@@ -122,7 +122,7 @@ CProtocolManager::CProtocolManager() {
PROTO::outputs.emplace(M->m_name, ref); PROTO::outputs.emplace(M->m_name, ref);
ref->m_self = ref; ref->m_self = ref;
m_modeChangeListeners[M->m_name] = M->m_events.modeChanged.registerListener([M, this](std::any d) { onMonitorModeChange(M); }); m_modeChangeListeners[M->m_name] = M->m_events.modeChanged.listen([this, M] { onMonitorModeChange(M); });
}); });
static auto P2 = g_pHookSystem->hookDynamic("monitorRemoved", [this](void* self, SCallbackInfo& info, std::any param) { static auto P2 = g_pHookSystem->hookDynamic("monitorRemoved", [this](void* self, SCallbackInfo& info, std::any param) {

16
src/managers/SeatManager.cpp
View File

@@ -14,12 +14,12 @@
#include <ranges> #include <ranges>
CSeatManager::CSeatManager() { CSeatManager::CSeatManager() {
m_listeners.newSeatResource = PROTO::seat->m_events.newSeatResource.registerListener([this](std::any res) { onNewSeatResource(std::any_cast<SP<CWLSeatResource>>(res)); }); m_listeners.newSeatResource = PROTO::seat->m_events.newSeatResource.listen([this](const auto& resource) { onNewSeatResource(resource); });
} }
CSeatManager::SSeatResourceContainer::SSeatResourceContainer(SP<CWLSeatResource> res) : resource(res) { CSeatManager::SSeatResourceContainer::SSeatResourceContainer(SP<CWLSeatResource> res) : resource(res) {
listeners.destroy = res->m_events.destroy.registerListener( listeners.destroy = res->m_events.destroy.listen(
[this](std::any data) { std::erase_if(g_pSeatManager->m_seatResources, [this](const auto& e) { return e->resource.expired() || e->resource == resource; }); }); [this] { std::erase_if(g_pSeatManager->m_seatResources, [this](const auto& e) { return e->resource.expired() || e->resource == resource; }); });
} }
void CSeatManager::onNewSeatResource(SP<CWLSeatResource> resource) { void CSeatManager::onNewSeatResource(SP<CWLSeatResource> resource) {
@@ -151,7 +151,7 @@ void CSeatManager::setKeyboardFocus(SP<CWLSurfaceResource> surf) {
} }
} }
m_listeners.keyboardSurfaceDestroy = surf->m_events.destroy.registerListener([this](std::any d) { setKeyboardFocus(nullptr); }); m_listeners.keyboardSurfaceDestroy = surf->m_events.destroy.listen([this] { setKeyboardFocus(nullptr); });
m_events.keyboardFocusChange.emit(); m_events.keyboardFocusChange.emit();
} }
@@ -258,7 +258,7 @@ void CSeatManager::setPointerFocus(SP<CWLSurfaceResource> surf, const Vector2D&
sendPointerFrame(); sendPointerFrame();
m_listeners.pointerSurfaceDestroy = surf->m_events.destroy.registerListener([this](std::any d) { setPointerFocus(nullptr, {}); }); m_listeners.pointerSurfaceDestroy = surf->m_events.destroy.listen([this] { setPointerFocus(nullptr, {}); });
m_events.pointerFocusChange.emit(); m_events.pointerFocusChange.emit();
m_events.dndPointerFocusChange.emit(); m_events.dndPointerFocusChange.emit();
@@ -372,7 +372,7 @@ void CSeatManager::sendTouchDown(SP<CWLSurfaceResource> surf, uint32_t timeMs, i
} }
} }
m_listeners.touchSurfaceDestroy = surf->m_events.destroy.registerListener([this, timeMs, id](std::any d) { sendTouchUp(timeMs + 10, id); }); m_listeners.touchSurfaceDestroy = surf->m_events.destroy.listen([this, timeMs, id] { sendTouchUp(timeMs + 10, id); });
m_touchLocks++; m_touchLocks++;
@@ -559,7 +559,7 @@ void CSeatManager::setCurrentSelection(SP<IDataSource> source) {
m_selection.currentSelection = source; m_selection.currentSelection = source;
if (source) { if (source) {
m_selection.destroySelection = source->m_events.destroy.registerListener([this](std::any d) { setCurrentSelection(nullptr); }); m_selection.destroySelection = source->m_events.destroy.listen([this] { setCurrentSelection(nullptr); });
PROTO::data->setSelection(source); PROTO::data->setSelection(source);
PROTO::dataWlr->setSelection(source, false); PROTO::dataWlr->setSelection(source, false);
} }
@@ -584,7 +584,7 @@ void CSeatManager::setCurrentPrimarySelection(SP<IDataSource> source) {
m_selection.currentPrimarySelection = source; m_selection.currentPrimarySelection = source;
if (source) { if (source) {
m_selection.destroyPrimarySelection = source->m_events.destroy.registerListener([this](std::any d) { setCurrentPrimarySelection(nullptr); }); m_selection.destroyPrimarySelection = source->m_events.destroy.listen([this] { setCurrentPrimarySelection(nullptr); });
PROTO::primarySelection->setSelection(source); PROTO::primarySelection->setSelection(source);
PROTO::dataWlr->setSelection(source, true); PROTO::dataWlr->setSelection(source, true);
} }

14
src/managers/SeatManager.hpp
View File

@@ -101,13 +101,13 @@ class CSeatManager {
}; };
struct { struct {
CSignal keyboardFocusChange; CSignalT<> keyboardFocusChange;
CSignal pointerFocusChange; CSignalT<> pointerFocusChange;
CSignal dndPointerFocusChange; CSignalT<> dndPointerFocusChange;
CSignal touchFocusChange; CSignalT<> touchFocusChange;
CSignal setCursor; // SSetCursorEvent CSignalT<SSetCursorEvent> setCursor;
CSignal setSelection; CSignalT<> setSelection;
CSignal setPrimarySelection; CSignalT<> setPrimarySelection;
} m_events; } m_events;
struct { struct {

23
src/managers/SessionLockManager.cpp
View File

@@ -12,7 +12,7 @@
SSessionLockSurface::SSessionLockSurface(SP<CSessionLockSurface> surface_) : surface(surface_) { SSessionLockSurface::SSessionLockSurface(SP<CSessionLockSurface> surface_) : surface(surface_) {
pWlrSurface = surface->surface(); pWlrSurface = surface->surface();
listeners.map = surface_->m_events.map.registerListener([this](std::any data) { listeners.map = surface_->m_events.map.listen([this] {
mapped = true; mapped = true;
g_pInputManager->simulateMouseMovement(); g_pInputManager->simulateMouseMovement();
@@ -23,14 +23,14 @@ SSessionLockSurface::SSessionLockSurface(SP<CSessionLockSurface> surface_) : sur
g_pHyprRenderer->damageMonitor(PMONITOR); g_pHyprRenderer->damageMonitor(PMONITOR);
}); });
listeners.destroy = surface_->m_events.destroy.registerListener([this](std::any data) { listeners.destroy = surface_->m_events.destroy.listen([this] {
if (pWlrSurface == g_pCompositor->m_lastFocus) if (pWlrSurface == g_pCompositor->m_lastFocus)
g_pCompositor->m_lastFocus.reset(); g_pCompositor->m_lastFocus.reset();
g_pSessionLockManager->removeSessionLockSurface(this); g_pSessionLockManager->removeSessionLockSurface(this);
}); });
listeners.commit = surface_->m_events.commit.registerListener([this](std::any data) { listeners.commit = surface_->m_events.commit.listen([this] {
const auto PMONITOR = g_pCompositor->getMonitorFromID(iMonitorID); const auto PMONITOR = g_pCompositor->getMonitorFromID(iMonitorID);
if (mapped && !g_pCompositor->m_lastFocus) if (mapped && !g_pCompositor->m_lastFocus)
@@ -42,11 +42,10 @@ SSessionLockSurface::SSessionLockSurface(SP<CSessionLockSurface> surface_) : sur
} }
CSessionLockManager::CSessionLockManager() { CSessionLockManager::CSessionLockManager() {
m_listeners.newLock = PROTO::sessionLock->m_events.newLock.registerListener([this](std::any data) { this->onNewSessionLock(std::any_cast<SP<CSessionLock>>(data)); }); m_listeners.newLock = PROTO::sessionLock->m_events.newLock.listen([this](const auto& lock) { this->onNewSessionLock(lock); });
} }
void CSessionLockManager::onNewSessionLock(SP<CSessionLock> pLock) { void CSessionLockManager::onNewSessionLock(SP<CSessionLock> pLock) {
static auto PALLOWRELOCK = CConfigValue<Hyprlang::INT>("misc:allow_session_lock_restore"); static auto PALLOWRELOCK = CConfigValue<Hyprlang::INT>("misc:allow_session_lock_restore");
if (PROTO::sessionLock->isLocked() && !*PALLOWRELOCK) { if (PROTO::sessionLock->isLocked() && !*PALLOWRELOCK) {
@@ -61,17 +60,15 @@ void CSessionLockManager::onNewSessionLock(SP<CSessionLock> pLock) {
m_sessionLock->lock = pLock; m_sessionLock->lock = pLock;
m_sessionLock->mLockTimer.reset(); m_sessionLock->mLockTimer.reset();
m_sessionLock->listeners.newSurface = pLock->m_events.newLockSurface.registerListener([this](std::any data) { m_sessionLock->listeners.newSurface = pLock->m_events.newLockSurface.listen([this](const SP<CSessionLockSurface>& surface) {
auto SURFACE = std::any_cast<SP<CSessionLockSurface>>(data); const auto PMONITOR = surface->monitor();
const auto PMONITOR = SURFACE->monitor(); const auto NEWSURFACE = m_sessionLock->vSessionLockSurfaces.emplace_back(makeUnique<SSessionLockSurface>(surface)).get();
const auto NEWSURFACE = m_sessionLock->vSessionLockSurfaces.emplace_back(makeUnique<SSessionLockSurface>(SURFACE)).get();
NEWSURFACE->iMonitorID = PMONITOR->m_id; NEWSURFACE->iMonitorID = PMONITOR->m_id;
PROTO::fractional->sendScale(SURFACE->surface(), PMONITOR->m_scale); PROTO::fractional->sendScale(surface->surface(), PMONITOR->m_scale);
}); });
m_sessionLock->listeners.unlock = pLock->m_events.unlockAndDestroy.registerListener([this](std::any data) { m_sessionLock->listeners.unlock = pLock->m_events.unlockAndDestroy.listen([this] {
m_sessionLock.reset(); m_sessionLock.reset();
g_pInputManager->refocus(); g_pInputManager->refocus();
@@ -79,7 +76,7 @@ void CSessionLockManager::onNewSessionLock(SP<CSessionLock> pLock) {
g_pHyprRenderer->damageMonitor(m); g_pHyprRenderer->damageMonitor(m);
}); });
m_sessionLock->listeners.destroy = pLock->m_events.destroyed.registerListener([this](std::any data) { m_sessionLock->listeners.destroy = pLock->m_events.destroyed.listen([this] {
m_sessionLock.reset(); m_sessionLock.reset();
g_pCompositor->focusSurface(nullptr); g_pCompositor->focusSurface(nullptr);

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

@@ -88,7 +88,7 @@ void CEventLoopManager::enterLoop() {
m_configWatcherInotifySource = wl_event_loop_add_fd(m_wayland.loop, FD.get(), WL_EVENT_READABLE, configWatcherWrite, nullptr); m_configWatcherInotifySource = wl_event_loop_add_fd(m_wayland.loop, FD.get(), WL_EVENT_READABLE, configWatcherWrite, nullptr);
syncPollFDs(); syncPollFDs();
m_listeners.pollFDsChanged = g_pCompositor->m_aqBackend->events.pollFDsChanged.registerListener([this](std::any d) { syncPollFDs(); }); m_listeners.pollFDsChanged = g_pCompositor->m_aqBackend->events.pollFDsChanged.listen([this] { syncPollFDs(); });
// if we have a session, dispatch it to get the pending input devices // if we have a session, dispatch it to get the pending input devices
if (g_pCompositor->m_aqBackend->hasSession()) if (g_pCompositor->m_aqBackend->hasSession())

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

@@ -10,7 +10,7 @@ void CInputManager::newIdleInhibitor(std::any inhibitor) {
Debug::log(LOG, "New idle inhibitor registered for surface {:x}", (uintptr_t)PINHIBIT->inhibitor->m_surface.get()); Debug::log(LOG, "New idle inhibitor registered for surface {:x}", (uintptr_t)PINHIBIT->inhibitor->m_surface.get());
PINHIBIT->inhibitor->m_listeners.destroy = PINHIBIT->inhibitor->m_resource->m_events.destroy.registerListener([this, PINHIBIT](std::any data) { PINHIBIT->inhibitor->m_listeners.destroy = PINHIBIT->inhibitor->m_resource->m_events.destroy.listen([this, PINHIBIT] {
std::erase_if(m_idleInhibitors, [PINHIBIT](const auto& other) { return other.get() == PINHIBIT; }); std::erase_if(m_idleInhibitors, [PINHIBIT](const auto& other) { return other.get() == PINHIBIT; });
recheckIdleInhibitorStatus(); recheckIdleInhibitorStatus();
}); });
@@ -24,8 +24,8 @@ void CInputManager::newIdleInhibitor(std::any inhibitor) {
return; return;
} }
PINHIBIT->surfaceDestroyListener = WLSurface->m_events.destroy.registerListener( PINHIBIT->surfaceDestroyListener =
[this, PINHIBIT](std::any data) { std::erase_if(m_idleInhibitors, [PINHIBIT](const auto& other) { return other.get() == PINHIBIT; }); }); WLSurface->m_events.destroy.listen([this, PINHIBIT] { std::erase_if(m_idleInhibitors, [PINHIBIT](const auto& other) { return other.get() == PINHIBIT; }); });
recheckIdleInhibitorStatus(); recheckIdleInhibitorStatus();
} }

148
src/managers/input/InputManager.cpp
View File

@@ -43,12 +43,10 @@
#include <aquamarine/input/Input.hpp> #include <aquamarine/input/Input.hpp>
CInputManager::CInputManager() { CInputManager::CInputManager() {
m_listeners.setCursorShape = PROTO::cursorShape->m_events.setShape.registerListener([this](std::any data) { m_listeners.setCursorShape = PROTO::cursorShape->m_events.setShape.listen([this](const CCursorShapeProtocol::SSetShapeEvent& event) {
if (!cursorImageUnlocked()) if (!cursorImageUnlocked())
return; return;
auto event = std::any_cast<CCursorShapeProtocol::SSetShapeEvent>(data);
if (!g_pSeatManager->m_state.pointerFocusResource) if (!g_pSeatManager->m_state.pointerFocusResource)
return; return;
@@ -66,16 +64,16 @@ CInputManager::CInputManager() {
g_pHyprRenderer->setCursorFromName(m_cursorSurfaceInfo.name); g_pHyprRenderer->setCursorFromName(m_cursorSurfaceInfo.name);
}); });
m_listeners.newIdleInhibitor = PROTO::idleInhibit->m_events.newIdleInhibitor.registerListener([this](std::any data) { this->newIdleInhibitor(data); }); m_listeners.newIdleInhibitor = PROTO::idleInhibit->m_events.newIdleInhibitor.listen([this](const auto& data) { this->newIdleInhibitor(data); });
m_listeners.newVirtualKeyboard = PROTO::virtualKeyboard->m_events.newKeyboard.registerListener([this](std::any data) { m_listeners.newVirtualKeyboard = PROTO::virtualKeyboard->m_events.newKeyboard.listen([this](const auto& keyboard) {
this->newVirtualKeyboard(std::any_cast<SP<CVirtualKeyboardV1Resource>>(data)); this->newVirtualKeyboard(keyboard);
updateCapabilities(); updateCapabilities();
}); });
m_listeners.newVirtualMouse = PROTO::virtualPointer->m_events.newPointer.registerListener([this](std::any data) { m_listeners.newVirtualMouse = PROTO::virtualPointer->m_events.newPointer.listen([this](const auto& mouse) {
this->newVirtualMouse(std::any_cast<SP<CVirtualPointerV1Resource>>(data)); this->newVirtualMouse(mouse);
updateCapabilities(); updateCapabilities();
}); });
m_listeners.setCursor = g_pSeatManager->m_events.setCursor.registerListener([this](std::any d) { this->processMouseRequest(d); }); m_listeners.setCursor = g_pSeatManager->m_events.setCursor.listen([this](const auto& event) { this->processMouseRequest(event); });
m_cursorSurfaceInfo.wlSurface = CWLSurface::create(); m_cursorSurfaceInfo.wlSurface = CWLSurface::create();
} }
@@ -641,23 +639,21 @@ void CInputManager::onMouseButton(IPointer::SButtonEvent e) {
} }
} }
void CInputManager::processMouseRequest(std::any E) { void CInputManager::processMouseRequest(const CSeatManager::SSetCursorEvent& event) {
if (!cursorImageUnlocked()) if (!cursorImageUnlocked())
return; return;
auto e = std::any_cast<CSeatManager::SSetCursorEvent>(E); Debug::log(LOG, "cursorImage request: surface {:x}", (uintptr_t)event.surf.get());
Debug::log(LOG, "cursorImage request: surface {:x}", (uintptr_t)e.surf.get()); if (event.surf != m_cursorSurfaceInfo.wlSurface->resource()) {
if (e.surf != m_cursorSurfaceInfo.wlSurface->resource()) {
m_cursorSurfaceInfo.wlSurface->unassign(); m_cursorSurfaceInfo.wlSurface->unassign();
if (e.surf) if (event.surf)
m_cursorSurfaceInfo.wlSurface->assign(e.surf); m_cursorSurfaceInfo.wlSurface->assign(event.surf);
} }
if (e.surf) { if (event.surf) {
m_cursorSurfaceInfo.vHotspot = e.hotspot; m_cursorSurfaceInfo.vHotspot = event.hotspot;
m_cursorSurfaceInfo.hidden = false; m_cursorSurfaceInfo.hidden = false;
} else { } else {
m_cursorSurfaceInfo.vHotspot = {}; m_cursorSurfaceInfo.vHotspot = {};
@@ -667,7 +663,7 @@ void CInputManager::processMouseRequest(std::any E) {
m_cursorSurfaceInfo.name = ""; m_cursorSurfaceInfo.name = "";
m_cursorSurfaceInfo.inUse = true; m_cursorSurfaceInfo.inUse = true;
g_pHyprRenderer->setCursorSurface(m_cursorSurfaceInfo.wlSurface, e.hotspot.x, e.hotspot.y); g_pHyprRenderer->setCursorSurface(m_cursorSurfaceInfo.wlSurface, event.hotspot.x, event.hotspot.y);
} }
void CInputManager::restoreCursorIconToApp() { void CInputManager::restoreCursorIconToApp() {
@@ -962,60 +958,52 @@ void CInputManager::setupKeyboard(SP<IKeyboard> keeb) {
Debug::log(ERR, "Keyboard had no name???"); // logic error Debug::log(ERR, "Keyboard had no name???"); // logic error
} }
keeb->m_events.destroy.registerStaticListener( keeb->m_events.destroy.listenStatic([this, keeb = keeb.get()] {
[this](void* owner, std::any data) { auto PKEEB = keeb->m_self.lock();
auto PKEEB = ((IKeyboard*)owner)->m_self.lock();
if (!PKEEB) if (!PKEEB)
return; return;
destroyKeyboard(PKEEB); destroyKeyboard(PKEEB);
Debug::log(LOG, "Destroyed keyboard {:x}", (uintptr_t)owner); Debug::log(LOG, "Destroyed keyboard {:x}", (uintptr_t)keeb);
}, });
keeb.get());
keeb->m_keyboardEvents.key.registerStaticListener( keeb->m_keyboardEvents.key.listenStatic([this, keeb = keeb.get()](const IKeyboard::SKeyEvent& event) {
[this](void* owner, std::any data) { auto PKEEB = keeb->m_self.lock();
auto PKEEB = ((IKeyboard*)owner)->m_self.lock();
onKeyboardKey(data, PKEEB); onKeyboardKey(event, PKEEB);
if (PKEEB->m_enabled) if (PKEEB->m_enabled)
PROTO::idle->onActivity(); PROTO::idle->onActivity();
if (PKEEB->m_enabled && *PDPMS && !g_pCompositor->m_dpmsStateOn) if (PKEEB->m_enabled && *PDPMS && !g_pCompositor->m_dpmsStateOn)
g_pKeybindManager->dpms("on"); g_pKeybindManager->dpms("on");
}, });
keeb.get());
keeb->m_keyboardEvents.modifiers.registerStaticListener( keeb->m_keyboardEvents.modifiers.listenStatic([this, keeb = keeb.get()] {
[this](void* owner, std::any data) { auto PKEEB = keeb->m_self.lock();
auto PKEEB = ((IKeyboard*)owner)->m_self.lock();
onKeyboardMod(PKEEB); onKeyboardMod(PKEEB);
if (PKEEB->m_enabled) if (PKEEB->m_enabled)
PROTO::idle->onActivity(); PROTO::idle->onActivity();
if (PKEEB->m_enabled && *PDPMS && !g_pCompositor->m_dpmsStateOn) if (PKEEB->m_enabled && *PDPMS && !g_pCompositor->m_dpmsStateOn)
g_pKeybindManager->dpms("on"); g_pKeybindManager->dpms("on");
}, });
keeb.get());
keeb->m_keyboardEvents.keymap.registerStaticListener( keeb->m_keyboardEvents.keymap.listenStatic([keeb = keeb.get()] {
[](void* owner, std::any data) { auto PKEEB = keeb->m_self.lock();
auto PKEEB = ((IKeyboard*)owner)->m_self.lock(); const auto LAYOUT = PKEEB->getActiveLayout();
const auto LAYOUT = PKEEB->getActiveLayout();
if (PKEEB == g_pSeatManager->m_keyboard) { if (PKEEB == g_pSeatManager->m_keyboard) {
g_pSeatManager->updateActiveKeyboardData(); g_pSeatManager->updateActiveKeyboardData();
g_pKeybindManager->m_keyToCodeCache.clear(); g_pKeybindManager->m_keyToCodeCache.clear();
} }
g_pEventManager->postEvent(SHyprIPCEvent{"activelayout", PKEEB->m_hlName + "," + LAYOUT}); g_pEventManager->postEvent(SHyprIPCEvent{"activelayout", PKEEB->m_hlName + "," + LAYOUT});
EMIT_HOOK_EVENT("activeLayout", (std::vector<std::any>{PKEEB, LAYOUT})); EMIT_HOOK_EVENT("activeLayout", (std::vector<std::any>{PKEEB, LAYOUT}));
}, });
keeb.get());
disableAllKeyboards(false); disableAllKeyboards(false);
@@ -1148,16 +1136,7 @@ void CInputManager::setupMouse(SP<IPointer> mauz) {
setPointerConfigs(); setPointerConfigs();
mauz->m_events.destroy.registerStaticListener( mauz->m_events.destroy.listenStatic([this, PMOUSE = mauz.get()] { destroyPointer(PMOUSE->m_self.lock()); });
[this](void* mouse, std::any data) {
const auto PMOUSE = (IPointer*)mouse;
if (!PMOUSE)
return;
destroyPointer(PMOUSE->m_self.lock());
},
mauz.get());
g_pSeatManager->setMouse(mauz); g_pSeatManager->setMouse(mauz);
@@ -1413,7 +1392,7 @@ void CInputManager::updateKeyboardsLeds(SP<IKeyboard> pKeyboard) {
} }
} }
void CInputManager::onKeyboardKey(std::any event, SP<IKeyboard> pKeyboard) { void CInputManager::onKeyboardKey(const IKeyboard::SKeyEvent& event, SP<IKeyboard> pKeyboard) {
if (!pKeyboard->m_enabled || !pKeyboard->m_allowed) if (!pKeyboard->m_enabled || !pKeyboard->m_allowed)
return; return;
@@ -1424,17 +1403,15 @@ void CInputManager::onKeyboardKey(std::any event, SP<IKeyboard> pKeyboard) {
bool passEvent = DISALLOWACTION || g_pKeybindManager->onKeyEvent(event, pKeyboard); bool passEvent = DISALLOWACTION || g_pKeybindManager->onKeyEvent(event, pKeyboard);
auto e = std::any_cast<IKeyboard::SKeyEvent>(event);
if (passEvent) { if (passEvent) {
const auto IME = m_relay.m_inputMethod.lock(); const auto IME = m_relay.m_inputMethod.lock();
if (IME && IME->hasGrab() && !DISALLOWACTION) { if (IME && IME->hasGrab() && !DISALLOWACTION) {
IME->setKeyboard(pKeyboard); IME->setKeyboard(pKeyboard);
IME->sendKey(e.timeMs, e.keycode, e.state); IME->sendKey(event.timeMs, event.keycode, event.state);
} else { } else {
g_pSeatManager->setKeyboard(pKeyboard); g_pSeatManager->setKeyboard(pKeyboard);
g_pSeatManager->sendKeyboardKey(e.timeMs, e.keycode, e.state); g_pSeatManager->sendKeyboardKey(event.timeMs, event.keycode, event.state);
} }
updateKeyboardsLeds(pKeyboard); updateKeyboardsLeds(pKeyboard);
@@ -1627,16 +1604,14 @@ void CInputManager::newTouchDevice(SP<Aquamarine::ITouch> pDevice) {
setTouchDeviceConfigs(PNEWDEV); setTouchDeviceConfigs(PNEWDEV);
g_pPointerManager->attachTouch(PNEWDEV); g_pPointerManager->attachTouch(PNEWDEV);
PNEWDEV->m_events.destroy.registerStaticListener( PNEWDEV->m_events.destroy.listenStatic([this, dev = PNEWDEV.get()] {
[this](void* owner, std::any data) { auto PDEV = dev->m_self.lock();
auto PDEV = ((ITouch*)owner)->m_self.lock();
if (!PDEV) if (!PDEV)
return; return;
destroyTouchDevice(PDEV); destroyTouchDevice(PDEV);
}, });
PNEWDEV.get());
Debug::log(LOG, "New touch device added at {:x}", (uintptr_t)PNEWDEV.get()); Debug::log(LOG, "New touch device added at {:x}", (uintptr_t)PNEWDEV.get());
} }
@@ -1739,17 +1714,16 @@ void CInputManager::newSwitch(SP<Aquamarine::ISwitch> pDevice) {
Debug::log(LOG, "New switch with name \"{}\" added", pDevice->getName()); Debug::log(LOG, "New switch with name \"{}\" added", pDevice->getName());
PNEWDEV->listeners.destroy = pDevice->events.destroy.registerListener([this, PNEWDEV](std::any d) { destroySwitch(PNEWDEV); }); PNEWDEV->listeners.destroy = pDevice->events.destroy.listen([this, PNEWDEV] { destroySwitch(PNEWDEV); });
PNEWDEV->listeners.fire = pDevice->events.fire.registerListener([PNEWDEV](std::any d) { PNEWDEV->listeners.fire = pDevice->events.fire.listen([PNEWDEV](const Aquamarine::ISwitch::SFireEvent& event) {
const auto NAME = PNEWDEV->pDevice->getName(); const auto NAME = PNEWDEV->pDevice->getName();
const auto E = std::any_cast<Aquamarine::ISwitch::SFireEvent>(d);
Debug::log(LOG, "Switch {} fired, triggering binds.", NAME); Debug::log(LOG, "Switch {} fired, triggering binds.", NAME);
g_pKeybindManager->onSwitchEvent(NAME); g_pKeybindManager->onSwitchEvent(NAME);
if (E.enable) { if (event.enable) {
Debug::log(LOG, "Switch {} turn on, triggering binds.", NAME); Debug::log(LOG, "Switch {} turn on, triggering binds.", NAME);
g_pKeybindManager->onSwitchOnEvent(NAME); g_pKeybindManager->onSwitchOnEvent(NAME);
} else { } else {

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

@@ -9,8 +9,10 @@
#include "../../helpers/signal/Signal.hpp" #include "../../helpers/signal/Signal.hpp"
#include "../../devices/IPointer.hpp" #include "../../devices/IPointer.hpp"
#include "../../devices/ITouch.hpp" #include "../../devices/ITouch.hpp"
#include "../../devices/IKeyboard.hpp"
#include "../../devices/Tablet.hpp" #include "../../devices/Tablet.hpp"
#include "../SessionLockManager.hpp" #include "../SessionLockManager.hpp"
#include "../SeatManager.hpp"
class CPointerConstraint; class CPointerConstraint;
class CWindow; class CWindow;
@@ -89,7 +91,7 @@ class CInputManager {
void onMouseWarp(IPointer::SMotionAbsoluteEvent); void onMouseWarp(IPointer::SMotionAbsoluteEvent);
void onMouseButton(IPointer::SButtonEvent); void onMouseButton(IPointer::SButtonEvent);
void onMouseWheel(IPointer::SAxisEvent); void onMouseWheel(IPointer::SAxisEvent);
void onKeyboardKey(std::any, SP<IKeyboard>); void onKeyboardKey(const IKeyboard::SKeyEvent&, SP<IKeyboard>);
void onKeyboardMod(SP<IKeyboard>); void onKeyboardMod(SP<IKeyboard>);
void newKeyboard(SP<Aquamarine::IKeyboard>); void newKeyboard(SP<Aquamarine::IKeyboard>);
@@ -128,7 +130,7 @@ class CInputManager {
void setClickMode(eClickBehaviorMode); void setClickMode(eClickBehaviorMode);
eClickBehaviorMode getClickMode(); eClickBehaviorMode getClickMode();
void processMouseRequest(std::any e); void processMouseRequest(const CSeatManager::SSetCursorEvent& event);
void onTouchDown(ITouch::SDownEvent); void onTouchDown(ITouch::SDownEvent);
void onTouchUp(ITouch::SUpEvent); void onTouchUp(ITouch::SUpEvent);

8
src/managers/input/InputMethodPopup.cpp
View File

@@ -8,10 +8,10 @@
#include "../../render/Renderer.hpp" #include "../../render/Renderer.hpp"
CInputPopup::CInputPopup(SP<CInputMethodPopupV2> popup_) : m_popup(popup_) { CInputPopup::CInputPopup(SP<CInputMethodPopupV2> popup_) : m_popup(popup_) {
m_listeners.commit = popup_->m_events.commit.registerListener([this](std::any d) { onCommit(); }); m_listeners.commit = popup_->m_events.commit.listen([this] { onCommit(); });
m_listeners.map = popup_->m_events.map.registerListener([this](std::any d) { onMap(); }); m_listeners.map = popup_->m_events.map.listen([this] { onMap(); });
m_listeners.unmap = popup_->m_events.unmap.registerListener([this](std::any d) { onUnmap(); }); m_listeners.unmap = popup_->m_events.unmap.listen([this] { onUnmap(); });
m_listeners.destroy = popup_->m_events.destroy.registerListener([this](std::any d) { onDestroy(); }); m_listeners.destroy = popup_->m_events.destroy.listen([this] { onDestroy(); });
m_surface = CWLSurface::create(); m_surface = CWLSurface::create();
m_surface->assign(popup_->surface()); m_surface->assign(popup_->surface());
} }

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

@@ -11,9 +11,9 @@ CInputMethodRelay::CInputMethodRelay() {
static auto P = static auto P =
g_pHookSystem->hookDynamic("keyboardFocus", [&](void* self, SCallbackInfo& info, std::any param) { onKeyboardFocus(std::any_cast<SP<CWLSurfaceResource>>(param)); }); g_pHookSystem->hookDynamic("keyboardFocus", [&](void* self, SCallbackInfo& info, std::any param) { onKeyboardFocus(std::any_cast<SP<CWLSurfaceResource>>(param)); });
m_listeners.newTIV3 = PROTO::textInputV3->m_events.newTextInput.registerListener([this](std::any ti) { onNewTextInput(std::any_cast<WP<CTextInputV3>>(ti)); }); m_listeners.newTIV3 = PROTO::textInputV3->m_events.newTextInput.listen([this](const auto& input) { onNewTextInput(input); });
m_listeners.newTIV1 = PROTO::textInputV1->m_events.newTextInput.registerListener([this](std::any ti) { onNewTextInput(std::any_cast<WP<CTextInputV1>>(ti)); }); m_listeners.newTIV1 = PROTO::textInputV1->m_events.newTextInput.listen([this](const auto& input) { onNewTextInput(input); });
m_listeners.newIME = PROTO::ime->m_events.newIME.registerListener([this](std::any ime) { onNewIME(std::any_cast<SP<CInputMethodV2>>(ime)); }); m_listeners.newIME = PROTO::ime->m_events.newIME.listen([this](const auto& ime) { onNewIME(ime); });
} }
void CInputMethodRelay::onNewIME(SP<CInputMethodV2> pIME) { void CInputMethodRelay::onNewIME(SP<CInputMethodV2> pIME) {
@@ -27,7 +27,7 @@ void CInputMethodRelay::onNewIME(SP<CInputMethodV2> pIME) {
m_inputMethod = pIME; m_inputMethod = pIME;
m_listeners.commitIME = pIME->m_events.onCommit.registerListener([this](std::any d) { m_listeners.commitIME = pIME->m_events.onCommit.listen([this] {
const auto PTI = getFocusedTextInput(); const auto PTI = getFocusedTextInput();
if (!PTI) { if (!PTI) {
@@ -38,7 +38,7 @@ void CInputMethodRelay::onNewIME(SP<CInputMethodV2> pIME) {
PTI->updateIMEState(m_inputMethod.lock()); PTI->updateIMEState(m_inputMethod.lock());
}); });
m_listeners.destroyIME = pIME->m_events.destroy.registerListener([this](std::any d) { m_listeners.destroyIME = pIME->m_events.destroy.listen([this] {
const auto PTI = getFocusedTextInput(); const auto PTI = getFocusedTextInput();
Debug::log(LOG, "IME Destroy"); Debug::log(LOG, "IME Destroy");
@@ -49,9 +49,8 @@ void CInputMethodRelay::onNewIME(SP<CInputMethodV2> pIME) {
m_inputMethod.reset(); m_inputMethod.reset();
}); });
m_listeners.newPopup = pIME->m_events.newPopup.registerListener([this](std::any d) { m_listeners.newPopup = pIME->m_events.newPopup.listen([this](const SP<CInputMethodPopupV2>& popup) {
m_inputMethodPopups.emplace_back(makeUnique<CInputPopup>(std::any_cast<SP<CInputMethodPopupV2>>(d))); m_inputMethodPopups.emplace_back(makeUnique<CInputPopup>(popup));
Debug::log(LOG, "New input popup"); Debug::log(LOG, "New input popup");
}); });

66
src/managers/input/Tablets.cpp
View File

@@ -229,12 +229,10 @@ void CInputManager::newTablet(SP<Aquamarine::ITablet> pDevice) {
g_pPointerManager->attachTablet(PNEWTABLET); g_pPointerManager->attachTablet(PNEWTABLET);
PNEWTABLET->m_events.destroy.registerStaticListener( PNEWTABLET->m_events.destroy.listenStatic([this, tablet = PNEWTABLET.get()] {
[this](void* owner, std::any d) { auto TABLET = tablet->m_self;
auto TABLET = ((CTablet*)owner)->m_self; destroyTablet(TABLET.lock());
destroyTablet(TABLET.lock()); });
},
PNEWTABLET.get());
setTabletConfigs(); setTabletConfigs();
} }
@@ -255,12 +253,10 @@ SP<CTabletTool> CInputManager::ensureTabletToolPresent(SP<Aquamarine::ITabletToo
Debug::log(ERR, "Tablet had no name???"); // logic error Debug::log(ERR, "Tablet had no name???"); // logic error
} }
PTOOL->m_events.destroy.registerStaticListener( PTOOL->m_events.destroy.listenStatic([this, tool = PTOOL.get()] {
[this](void* owner, std::any d) { auto TOOL = tool->m_self;
auto TOOL = ((CTabletTool*)owner)->m_self; destroyTabletTool(TOOL.lock());
destroyTabletTool(TOOL.lock()); });
},
PTOOL.get());
return PTOOL; return PTOOL;
} }
@@ -275,39 +271,27 @@ void CInputManager::newTabletPad(SP<Aquamarine::ITabletPad> pDevice) {
Debug::log(ERR, "Pad had no name???"); // logic error Debug::log(ERR, "Pad had no name???"); // logic error
} }
// clang-format off PNEWPAD->m_events.destroy.listenStatic([this, pad = PNEWPAD.get()] {
PNEWPAD->m_events.destroy.registerStaticListener([this](void* owner, std::any d) { auto PAD = pad->m_self;
auto PAD = ((CTabletPad*)owner)->m_self;
destroyTabletPad(PAD.lock()); destroyTabletPad(PAD.lock());
}, PNEWPAD.get()); });
PNEWPAD->m_padEvents.button.registerStaticListener([](void* owner, std::any e) { PNEWPAD->m_padEvents.button.listenStatic([pad = PNEWPAD.get()](const CTabletPad::SButtonEvent& event) {
const auto E = std::any_cast<CTabletPad::SButtonEvent>(e); const auto PPAD = pad->m_self.lock();
const auto PPAD = ((CTabletPad*)owner)->m_self.lock();
PROTO::tablet->mode(PPAD, 0, E.mode, E.timeMs); PROTO::tablet->mode(PPAD, 0, event.mode, event.timeMs);
PROTO::tablet->buttonPad(PPAD, E.button, E.timeMs, E.down); PROTO::tablet->buttonPad(PPAD, event.button, event.timeMs, event.down);
}, PNEWPAD.get()); });
PNEWPAD->m_padEvents.strip.registerStaticListener([](void* owner, std::any e) { PNEWPAD->m_padEvents.strip.listenStatic([pad = PNEWPAD.get()](const CTabletPad::SStripEvent& event) {
const auto E = std::any_cast<CTabletPad::SStripEvent>(e); const auto PPAD = pad->m_self.lock();
const auto PPAD = ((CTabletPad*)owner)->m_self.lock(); PROTO::tablet->strip(PPAD, event.strip, event.position, event.finger, event.timeMs);
});
PROTO::tablet->strip(PPAD, E.strip, E.position, E.finger, E.timeMs); PNEWPAD->m_padEvents.ring.listenStatic([pad = PNEWPAD.get()](const CTabletPad::SRingEvent& event) {
}, PNEWPAD.get()); const auto PPAD = pad->m_self.lock();
PROTO::tablet->ring(PPAD, event.ring, event.position, event.finger, event.timeMs);
});
PNEWPAD->m_padEvents.ring.registerStaticListener([](void* owner, std::any e) { PNEWPAD->m_padEvents.attach.listenStatic([pad = PNEWPAD.get()](const SP<CTabletTool>& tool) { pad->m_parent = tool; });
const auto E = std::any_cast<CTabletPad::SRingEvent>(e);
const auto PPAD = ((CTabletPad*)owner)->m_self.lock();
PROTO::tablet->ring(PPAD, E.ring, E.position, E.finger, E.timeMs);
}, PNEWPAD.get());
PNEWPAD->m_padEvents.attach.registerStaticListener([](void* owner, std::any e) {
const auto PPAD = ((CTabletPad*)owner)->m_self.lock();
const auto TOOL = std::any_cast<SP<CTabletTool>>(e);
PPAD->m_parent = TOOL;
}, PNEWPAD.get());
// clang-format on
} }

27
src/managers/input/TextInput.cpp
View File

@@ -19,11 +19,11 @@ void CTextInput::initCallbacks() {
if (isV3()) { if (isV3()) {
const auto INPUT = m_v3Input.lock(); const auto INPUT = m_v3Input.lock();
m_listeners.enable = INPUT->m_events.enable.registerListener([this](std::any p) { onEnabled(); }); m_listeners.enable = INPUT->m_events.enable.listen([this] { onEnabled(); });
m_listeners.disable = INPUT->m_events.disable.registerListener([this](std::any p) { onDisabled(); }); m_listeners.disable = INPUT->m_events.disable.listen([this] { onDisabled(); });
m_listeners.commit = INPUT->m_events.onCommit.registerListener([this](std::any p) { onCommit(); }); m_listeners.commit = INPUT->m_events.onCommit.listen([this] { onCommit(); });
m_listeners.reset = INPUT->m_events.reset.registerListener([this](std::any p) { onReset(); }); m_listeners.reset = INPUT->m_events.reset.listen([this] { onReset(); });
m_listeners.destroy = INPUT->m_events.destroy.registerListener([this](std::any p) { m_listeners.destroy = INPUT->m_events.destroy.listen([this] {
m_listeners.surfaceUnmap.reset(); m_listeners.surfaceUnmap.reset();
m_listeners.surfaceDestroy.reset(); m_listeners.surfaceDestroy.reset();
g_pInputManager->m_relay.removeTextInput(this); g_pInputManager->m_relay.removeTextInput(this);
@@ -36,14 +36,11 @@ void CTextInput::initCallbacks() {
} else { } else {
const auto INPUT = m_v1Input.lock(); const auto INPUT = m_v1Input.lock();
m_listeners.enable = INPUT->m_events.enable.registerListener([this](std::any p) { m_listeners.enable = INPUT->m_events.enable.listen([this](const auto& surface) { onEnabled(surface); });
const auto SURFACE = std::any_cast<SP<CWLSurfaceResource>>(p); m_listeners.disable = INPUT->m_events.disable.listen([this] { onDisabled(); });
onEnabled(SURFACE); m_listeners.commit = INPUT->m_events.onCommit.listen([this] { onCommit(); });
}); m_listeners.reset = INPUT->m_events.reset.listen([this] { onReset(); });
m_listeners.disable = INPUT->m_events.disable.registerListener([this](std::any p) { onDisabled(); }); m_listeners.destroy = INPUT->m_events.destroy.listen([this] {
m_listeners.commit = INPUT->m_events.onCommit.registerListener([this](std::any p) { onCommit(); });
m_listeners.reset = INPUT->m_events.reset.registerListener([this](std::any p) { onReset(); });
m_listeners.destroy = INPUT->m_events.destroy.registerListener([this](std::any p) {
m_listeners.surfaceUnmap.reset(); m_listeners.surfaceUnmap.reset();
m_listeners.surfaceDestroy.reset(); m_listeners.surfaceDestroy.reset();
g_pInputManager->m_relay.removeTextInput(this); g_pInputManager->m_relay.removeTextInput(this);
@@ -135,7 +132,7 @@ void CTextInput::setFocusedSurface(SP<CWLSurfaceResource> pSurface) {
m_listeners.surfaceUnmap.reset(); m_listeners.surfaceUnmap.reset();
m_listeners.surfaceDestroy.reset(); m_listeners.surfaceDestroy.reset();
m_listeners.surfaceUnmap = pSurface->m_events.unmap.registerListener([this](std::any d) { m_listeners.surfaceUnmap = pSurface->m_events.unmap.listen([this] {
Debug::log(LOG, "Unmap TI owner1"); Debug::log(LOG, "Unmap TI owner1");
if (m_enterLocks) if (m_enterLocks)
@@ -155,7 +152,7 @@ void CTextInput::setFocusedSurface(SP<CWLSurfaceResource> pSurface) {
g_pInputManager->m_relay.deactivateIME(this); g_pInputManager->m_relay.deactivateIME(this);
}); });
m_listeners.surfaceDestroy = pSurface->m_events.destroy.registerListener([this](std::any d) { m_listeners.surfaceDestroy = pSurface->m_events.destroy.listen([this] {
Debug::log(LOG, "Destroy TI owner1"); Debug::log(LOG, "Destroy TI owner1");
if (m_enterLocks) if (m_enterLocks)

4
src/protocols/AlphaModifier.cpp
View File

@@ -30,7 +30,7 @@ void CAlphaModifier::setResource(SP<CWpAlphaModifierSurfaceV1> resource) {
m_alpha = alpha / (float)UINT32_MAX; m_alpha = alpha / (float)UINT32_MAX;
}); });
m_listeners.surfaceCommitted = m_surface->m_events.commit.registerListener([this](std::any data) { m_listeners.surfaceCommitted = m_surface->m_events.commit.listen([this] {
auto surface = CWLSurface::fromResource(m_surface.lock()); auto surface = CWLSurface::fromResource(m_surface.lock());
if (surface && surface->m_alphaModifier != m_alpha) { if (surface && surface->m_alphaModifier != m_alpha) {
@@ -45,7 +45,7 @@ void CAlphaModifier::setResource(SP<CWpAlphaModifierSurfaceV1> resource) {
} }
}); });
m_listeners.surfaceDestroyed = m_surface->m_events.destroy.registerListener([this](std::any data) { m_listeners.surfaceDestroyed = m_surface->m_events.destroy.listen([this] {
if (!m_resource) if (!m_resource)
PROTO::alphaModifier->destroyAlphaModifier(this); PROTO::alphaModifier->destroyAlphaModifier(this);
}); });

2
src/protocols/ContentType.cpp
View File

@@ -42,7 +42,7 @@ bool CContentTypeManager::good() {
} }
CContentType::CContentType(WP<CWLSurfaceResource> surface) { CContentType::CContentType(WP<CWLSurfaceResource> surface) {
m_destroy = surface->m_events.destroy.registerListener([this](std::any d) { PROTO::contentType->destroyResource(this); }); m_destroy = surface->m_events.destroy.listen([this] { PROTO::contentType->destroyResource(this); });
} }
CContentType::CContentType(SP<CWpContentTypeV1> resource) : m_resource(resource) { CContentType::CContentType(SP<CWpContentTypeV1> resource) : m_resource(resource) {

4
src/protocols/CursorShape.hpp
View File

@@ -18,7 +18,7 @@ class CCursorShapeProtocol : public IWaylandProtocol {
}; };
struct { struct {
CSignal setShape; CSignalT<SSetShapeEvent> setShape;
} m_events; } m_events;
private: private:
@@ -38,4 +38,4 @@ class CCursorShapeProtocol : public IWaylandProtocol {
namespace PROTO { namespace PROTO {
inline UP<CCursorShapeProtocol> cursorShape; inline UP<CCursorShapeProtocol> cursorShape;
}; };

4
src/protocols/DRMLease.cpp
View File

@@ -64,7 +64,7 @@ CDRMLeaseResource::CDRMLeaseResource(SP<CWpDrmLeaseV1> resource_, SP<CDRMLeaseRe
m->m_monitor->m_isBeingLeased = true; m->m_monitor->m_isBeingLeased = true;
} }
m_listeners.destroyLease = m_lease->events.destroy.registerListener([this](std::any d) { m_listeners.destroyLease = m_lease->events.destroy.listen([this] {
for (auto const& m : m_requested) { for (auto const& m : m_requested) {
if (m && m->m_monitor) if (m && m->m_monitor)
m->m_monitor->m_isBeingLeased = false; m->m_monitor->m_isBeingLeased = false;
@@ -167,7 +167,7 @@ CDRMLeaseConnectorResource::CDRMLeaseConnectorResource(WP<CDRMLeaseDeviceResourc
m_resource->setData(this); m_resource->setData(this);
m_listeners.destroyMonitor = m_monitor->m_events.destroy.registerListener([this](std::any d) { m_listeners.destroyMonitor = m_monitor->m_events.destroy.listen([this] {
m_resource->sendWithdrawn(); m_resource->sendWithdrawn();
m_dead = true; m_dead = true;
}); });

2
src/protocols/DRMSyncobj.cpp
View File

@@ -74,7 +74,7 @@ CDRMSyncobjSurfaceResource::CDRMSyncobjSurfaceResource(UP<CWpLinuxDrmSyncobjSurf
m_pendingRelease = {timeline->m_timeline, ((uint64_t)hi << 32) | (uint64_t)lo}; m_pendingRelease = {timeline->m_timeline, ((uint64_t)hi << 32) | (uint64_t)lo};
}); });
m_listeners.surfacePrecommit = m_surface->m_events.precommit.registerListener([this](std::any d) { m_listeners.surfacePrecommit = m_surface->m_events.precommit.listen([this] {
if (!m_surface->m_pending.updated.bits.buffer || !m_surface->m_pending.buffer) { if (!m_surface->m_pending.updated.bits.buffer || !m_surface->m_pending.buffer) {
if (m_pendingAcquire.timeline() || m_pendingRelease.timeline()) { if (m_pendingAcquire.timeline() || m_pendingRelease.timeline()) {
m_resource->error(WP_LINUX_DRM_SYNCOBJ_SURFACE_V1_ERROR_NO_BUFFER, "Missing buffer"); m_resource->error(WP_LINUX_DRM_SYNCOBJ_SURFACE_V1_ERROR_NO_BUFFER, "Missing buffer");

18
src/protocols/ExtWorkspace.cpp
View File

@@ -15,7 +15,7 @@ CExtWorkspaceGroupResource::CExtWorkspaceGroupResource(WP<CExtWorkspaceManagerRe
m_resource->setData(this); m_resource->setData(this);
m_manager->m_resource->sendWorkspaceGroup(m_resource.get()); m_manager->m_resource->sendWorkspaceGroup(m_resource.get());
m_listeners.destroyed = m_monitor->m_events.destroy.registerListener([this](auto) { m_resource->sendRemoved(); }); m_listeners.destroyed = m_monitor->m_events.destroy.listen([this] { m_resource->sendRemoved(); });
m_resource->setOnDestroy([this](auto) { PROTO::extWorkspace->destroyGroup(m_self); }); m_resource->setOnDestroy([this](auto) { PROTO::extWorkspace->destroyGroup(m_self); });
m_resource->setDestroy([this](auto) { PROTO::extWorkspace->destroyGroup(m_self); }); m_resource->setDestroy([this](auto) { PROTO::extWorkspace->destroyGroup(m_self); });
@@ -27,11 +27,9 @@ CExtWorkspaceGroupResource::CExtWorkspaceGroupResource(WP<CExtWorkspaceManagerRe
if (auto resource = output->outputResourceFrom(m_resource->client())) if (auto resource = output->outputResourceFrom(m_resource->client()))
m_resource->sendOutputEnter(resource->getResource()->resource()); m_resource->sendOutputEnter(resource->getResource()->resource());
m_listeners.outputBound = output->m_events.outputBound.registerListener([this](std::any data) { m_listeners.outputBound = output->m_events.outputBound.listen([this](const SP<CWLOutputResource>& output) {
auto resource = std::any_cast<SP<CWLOutputResource>>(data); if (output->client() == m_resource->client())
m_resource->sendOutputEnter(output->getResource()->resource());
if (resource->client() == m_resource->client())
m_resource->sendOutputEnter(resource->getResource()->resource());
}); });
m_manager->sendGroupToWorkspaces(m_self); m_manager->sendGroupToWorkspaces(m_self);
@@ -63,21 +61,21 @@ CExtWorkspaceResource::CExtWorkspaceResource(WP<CExtWorkspaceManagerResource> ma
m_resource->setData(this); m_resource->setData(this);
m_manager->m_resource->sendWorkspace(m_resource.get()); m_manager->m_resource->sendWorkspace(m_resource.get());
m_listeners.destroyed = m_workspace->m_events.destroy.registerListener([this](auto) { m_listeners.destroyed = m_workspace->m_events.destroy.listen([this] {
m_resource->sendRemoved(); m_resource->sendRemoved();
if (m_manager) if (m_manager)
m_manager->scheduleDone(); m_manager->scheduleDone();
}); });
m_listeners.activeChanged = m_workspace->m_events.activeChange.registerListener([this](auto) { m_listeners.activeChanged = m_workspace->m_events.activeChanged.listen([this] {
sendState(); sendState();
sendCapabilities(); sendCapabilities();
}); });
m_listeners.monitorChanged = m_workspace->m_events.monitorChange.registerListener([this](auto) { this->sendGroup(); }); m_listeners.monitorChanged = m_workspace->m_events.monitorChanged.listen([this] { this->sendGroup(); });
m_listeners.renamed = m_workspace->m_events.rename.registerListener([this](auto) { m_listeners.renamed = m_workspace->m_events.renamed.listen([this] {
m_resource->sendName(m_workspace->m_name.c_str()); m_resource->sendName(m_workspace->m_name.c_str());
if (m_manager) if (m_manager)

2
src/protocols/FocusGrab.cpp
View File

@@ -8,7 +8,7 @@
#include <wayland-server.h> #include <wayland-server.h>
CFocusGrabSurfaceState::CFocusGrabSurfaceState(CFocusGrab* grab, SP<CWLSurfaceResource> surface) { CFocusGrabSurfaceState::CFocusGrabSurfaceState(CFocusGrab* grab, SP<CWLSurfaceResource> surface) {
m_listeners.destroy = surface->m_events.destroy.registerListener([=](std::any d) { grab->eraseSurface(surface); }); m_listeners.destroy = surface->m_events.destroy.listen([grab, surface] { grab->eraseSurface(surface); });
} }
CFocusGrab::CFocusGrab(SP<CHyprlandFocusGrabV1> resource_) : m_resource(resource_) { CFocusGrab::CFocusGrab(SP<CHyprlandFocusGrabV1> resource_) : m_resource(resource_) {

4
src/protocols/GammaControl.cpp
View File

@@ -108,8 +108,8 @@ CGammaControl::CGammaControl(SP<CZwlrGammaControlV1> resource_, wl_resource* out
m_resource->sendGammaSize(m_gammaSize); m_resource->sendGammaSize(m_gammaSize);
m_listeners.monitorDestroy = m_monitor->m_events.destroy.registerListener([this](std::any) { this->onMonitorDestroy(); }); m_listeners.monitorDestroy = m_monitor->m_events.destroy.listen([this] { this->onMonitorDestroy(); });
m_listeners.monitorDisconnect = m_monitor->m_events.disconnect.registerListener([this](std::any) { this->onMonitorDestroy(); }); m_listeners.monitorDisconnect = m_monitor->m_events.disconnect.listen([this] { this->onMonitorDestroy(); });
} }
CGammaControl::~CGammaControl() { CGammaControl::~CGammaControl() {

4
src/protocols/HyprlandSurface.cpp
View File

@@ -51,7 +51,7 @@ void CHyprlandSurface::setResource(SP<CHyprlandSurfaceV1> resource) {
m_visibleRegion = CWLRegionResource::fromResource(region)->m_region; m_visibleRegion = CWLRegionResource::fromResource(region)->m_region;
}); });
m_listeners.surfaceCommitted = m_surface->m_events.commit.registerListener([this](std::any data) { m_listeners.surfaceCommitted = m_surface->m_events.commit.listen([this] {
auto surface = CWLSurface::fromResource(m_surface.lock()); auto surface = CWLSurface::fromResource(m_surface.lock());
if (surface && (surface->m_overallOpacity != m_opacity || m_visibleRegionChanged)) { if (surface && (surface->m_overallOpacity != m_opacity || m_visibleRegionChanged)) {
@@ -67,7 +67,7 @@ void CHyprlandSurface::setResource(SP<CHyprlandSurfaceV1> resource) {
} }
}); });
m_listeners.surfaceDestroyed = m_surface->m_events.destroy.registerListener([this](std::any data) { m_listeners.surfaceDestroyed = m_surface->m_events.destroy.listen([this] {
if (!m_resource) if (!m_resource)
PROTO::hyprlandSurface->destroySurface(this); PROTO::hyprlandSurface->destroySurface(this);
}); });

4
src/protocols/IdleInhibit.cpp
View File

@@ -6,7 +6,7 @@ CIdleInhibitor::CIdleInhibitor(SP<CIdleInhibitorResource> resource_, SP<CWLSurfa
} }
CIdleInhibitorResource::CIdleInhibitorResource(SP<CZwpIdleInhibitorV1> resource_, SP<CWLSurfaceResource> surface_) : m_resource(resource_), m_surface(surface_) { CIdleInhibitorResource::CIdleInhibitorResource(SP<CZwpIdleInhibitorV1> resource_, SP<CWLSurfaceResource> surface_) : m_resource(resource_), m_surface(surface_) {
m_listeners.destroySurface = m_surface->m_events.destroy.registerListener([this](std::any d) { m_listeners.destroySurface = m_surface->m_events.destroy.listen([this] {
m_surface.reset(); m_surface.reset();
m_listeners.destroySurface.reset(); m_listeners.destroySurface.reset();
m_destroySent = true; m_destroySent = true;
@@ -49,4 +49,4 @@ void CIdleInhibitProtocol::onCreateInhibitor(CZwpIdleInhibitManagerV1* pMgr, uin
RESOURCE->m_inhibitor = makeShared<CIdleInhibitor>(RESOURCE, surface); RESOURCE->m_inhibitor = makeShared<CIdleInhibitor>(RESOURCE, surface);
m_events.newIdleInhibitor.emit(RESOURCE->m_inhibitor); m_events.newIdleInhibitor.emit(RESOURCE->m_inhibitor);
} }

4
src/protocols/IdleInhibit.hpp
View File

@@ -28,7 +28,7 @@ class CIdleInhibitorResource {
SP<CIdleInhibitor> m_inhibitor; SP<CIdleInhibitor> m_inhibitor;
struct { struct {
CSignal destroy; CSignalT<> destroy;
} m_events; } m_events;
private: private:
@@ -48,7 +48,7 @@ class CIdleInhibitProtocol : public IWaylandProtocol {
virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id); virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);
struct { struct {
CSignal newIdleInhibitor; // data: SP<CIdleInhibitor> CSignalT<SP<CIdleInhibitor>> newIdleInhibitor;
} m_events; } m_events;
private: private:

4
src/protocols/InputMethodV2.cpp
View File

@@ -89,7 +89,7 @@ CInputMethodPopupV2::CInputMethodPopupV2(SP<CZwpInputPopupSurfaceV2> resource_,
m_surface = surface; m_surface = surface;
m_listeners.destroySurface = surface->m_events.destroy.registerListener([this](std::any d) { m_listeners.destroySurface = surface->m_events.destroy.listen([this] {
if (m_mapped) if (m_mapped)
m_events.unmap.emit(); m_events.unmap.emit();
@@ -102,7 +102,7 @@ CInputMethodPopupV2::CInputMethodPopupV2(SP<CZwpInputPopupSurfaceV2> resource_,
m_surface.reset(); m_surface.reset();
}); });
m_listeners.commitSurface = surface->m_events.commit.registerListener([this](std::any d) { m_listeners.commitSurface = surface->m_events.commit.listen([this] {
if (m_surface->m_current.texture && !m_mapped) { if (m_surface->m_current.texture && !m_mapped) {
m_mapped = true; m_mapped = true;
m_surface->map(); m_surface->map();

18
src/protocols/InputMethodV2.hpp
View File

@@ -18,9 +18,9 @@ class CInputMethodV2 {
~CInputMethodV2(); ~CInputMethodV2();
struct { struct {
CSignal onCommit; CSignalT<> onCommit;
CSignal destroy; CSignalT<> destroy;
CSignal newPopup; CSignalT<SP<CInputMethodPopupV2>> newPopup;
} m_events; } m_events;
struct SState { struct SState {
@@ -110,10 +110,10 @@ class CInputMethodPopupV2 {
SP<CWLSurfaceResource> surface(); SP<CWLSurfaceResource> surface();
struct { struct {
CSignal map; CSignalT<> map;
CSignal unmap; CSignalT<> unmap;
CSignal commit; CSignalT<> commit;
CSignal destroy; CSignalT<> destroy;
} m_events; } m_events;
bool m_mapped = false; bool m_mapped = false;
@@ -136,7 +136,7 @@ class CInputMethodV2Protocol : public IWaylandProtocol {
virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id); virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);
struct { struct {
CSignal newIME; // SP<CInputMethodV2> CSignalT<SP<CInputMethodV2>> newIME;
} m_events; } m_events;
private: private:
@@ -160,4 +160,4 @@ class CInputMethodV2Protocol : public IWaylandProtocol {
namespace PROTO { namespace PROTO {
inline UP<CInputMethodV2Protocol> ime; inline UP<CInputMethodV2Protocol> ime;
}; };

6
src/protocols/LayerShell.cpp
View File

@@ -33,14 +33,14 @@ CLayerShellResource::CLayerShellResource(SP<CZwlrLayerSurfaceV1> resource_, SP<C
PROTO::layerShell->destroyResource(this); PROTO::layerShell->destroyResource(this);
}); });
m_listeners.destroySurface = surf_->m_events.destroy.registerListener([this](std::any d) { m_listeners.destroySurface = surf_->m_events.destroy.listen([this] {
m_events.destroy.emit(); m_events.destroy.emit();
PROTO::layerShell->destroyResource(this); PROTO::layerShell->destroyResource(this);
}); });
m_listeners.unmapSurface = surf_->m_events.unmap.registerListener([this](std::any d) { m_events.unmap.emit(); }); m_listeners.unmapSurface = surf_->m_events.unmap.listen([this] { m_events.unmap.emit(); });
m_listeners.commitSurface = surf_->m_events.commit.registerListener([this](std::any d) { m_listeners.commitSurface = surf_->m_events.commit.listen([this] {
m_current = m_pending; m_current = m_pending;
m_pending.committed = 0; m_pending.committed = 0;

11
src/protocols/LayerShell.hpp
View File

@@ -10,6 +10,7 @@
#include "types/SurfaceRole.hpp" #include "types/SurfaceRole.hpp"
class CMonitor; class CMonitor;
class CXDGPopupResource;
class CWLSurfaceResource; class CWLSurfaceResource;
class CLayerShellResource; class CLayerShellResource;
@@ -44,11 +45,11 @@ class CLayerShellResource {
}; };
struct { struct {
CSignal destroy; CSignalT<> destroy;
CSignal commit; CSignalT<> commit;
CSignal map; CSignalT<> map;
CSignal unmap; CSignalT<> unmap;
CSignal newPopup; // wlr_xdg_popup* CSignalT<SP<CXDGPopupResource>> newPopup;
} m_events; } m_events;
struct SState { struct SState {

2
src/protocols/LinuxDMABUF.cpp
View File

@@ -99,7 +99,7 @@ CLinuxDMABuffer::CLinuxDMABuffer(uint32_t id, wl_client* client, Aquamarine::SDM
m_buffer->m_resource->m_buffer = m_buffer; m_buffer->m_resource->m_buffer = m_buffer;
m_listeners.bufferResourceDestroy = m_buffer->events.destroy.registerListener([this](std::any d) { m_listeners.bufferResourceDestroy = m_buffer->events.destroy.listen([this] {
m_listeners.bufferResourceDestroy.reset(); m_listeners.bufferResourceDestroy.reset();
PROTO::linuxDma->destroyResource(this); PROTO::linuxDma->destroyResource(this);
}); });

2
src/protocols/MesaDRM.cpp
View File

@@ -14,7 +14,7 @@ CMesaDRMBufferResource::CMesaDRMBufferResource(uint32_t id, wl_client* client, A
m_buffer = makeShared<CDMABuffer>(id, client, attrs_); m_buffer = makeShared<CDMABuffer>(id, client, attrs_);
m_buffer->m_resource->m_buffer = m_buffer; m_buffer->m_resource->m_buffer = m_buffer;
m_listeners.bufferResourceDestroy = m_buffer->events.destroy.registerListener([this](std::any d) { m_listeners.bufferResourceDestroy = m_buffer->events.destroy.listen([this] {
m_listeners.bufferResourceDestroy.reset(); m_listeners.bufferResourceDestroy.reset();
PROTO::mesaDRM->destroyResource(this); PROTO::mesaDRM->destroyResource(this);
}); });

4
src/protocols/OutputManagement.cpp
View File

@@ -96,7 +96,7 @@ COutputHead::COutputHead(SP<CZwlrOutputHeadV1> resource_, PHLMONITOR pMonitor_)
m_resource->setRelease([this](CZwlrOutputHeadV1* r) { PROTO::outputManagement->destroyResource(this); }); m_resource->setRelease([this](CZwlrOutputHeadV1* r) { PROTO::outputManagement->destroyResource(this); });
m_resource->setOnDestroy([this](CZwlrOutputHeadV1* r) { PROTO::outputManagement->destroyResource(this); }); m_resource->setOnDestroy([this](CZwlrOutputHeadV1* r) { PROTO::outputManagement->destroyResource(this); });
m_listeners.monitorDestroy = m_monitor->m_events.destroy.registerListener([this](std::any d) { m_listeners.monitorDestroy = m_monitor->m_events.destroy.listen([this] {
m_resource->sendFinished(); m_resource->sendFinished();
for (auto const& mw : m_modes) { for (auto const& mw : m_modes) {
@@ -114,7 +114,7 @@ COutputHead::COutputHead(SP<CZwlrOutputHeadV1> resource_, PHLMONITOR pMonitor_)
} }
}); });
m_listeners.monitorModeChange = m_monitor->m_events.modeChanged.registerListener([this](std::any d) { updateMode(); }); m_listeners.monitorModeChange = m_monitor->m_events.modeChanged.listen([this] { updateMode(); });
} }
bool COutputHead::good() { bool COutputHead::good() {

10
src/protocols/OutputPower.cpp
View File

@@ -23,15 +23,15 @@ COutputPower::COutputPower(SP<CZwlrOutputPowerV1> resource_, PHLMONITOR pMonitor
m_resource->sendMode(m_monitor->m_dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); m_resource->sendMode(m_monitor->m_dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF);
m_listeners.monitorDestroy = m_monitor->m_events.destroy.registerListener([this](std::any v) { m_listeners.monitorDestroy = m_monitor->m_events.destroy.listen([this] {
m_monitor.reset(); m_monitor.reset();
m_resource->sendFailed(); m_resource->sendFailed();
}); });
m_listeners.monitorDpms = m_monitor->m_events.dpmsChanged.registerListener( m_listeners.monitorDpms =
[this](std::any v) { m_resource->sendMode(m_monitor->m_dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); }); m_monitor->m_events.dpmsChanged.listen([this] { m_resource->sendMode(m_monitor->m_dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); });
m_listeners.monitorState = m_monitor->m_events.modeChanged.registerListener( m_listeners.monitorState =
[this](std::any v) { m_resource->sendMode(m_monitor->m_dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); }); m_monitor->m_events.modeChanged.listen([this] { m_resource->sendMode(m_monitor->m_dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); });
} }
bool COutputPower::good() { bool COutputPower::good() {

2
src/protocols/PointerConstraints.cpp
View File

@@ -80,7 +80,7 @@ CPointerConstraint::~CPointerConstraint() {
void CPointerConstraint::sharedConstructions() { void CPointerConstraint::sharedConstructions() {
if (m_hlSurface) { if (m_hlSurface) {
m_listeners.destroySurface = m_hlSurface->m_events.destroy.registerListener([this](std::any d) { m_listeners.destroySurface = m_hlSurface->m_events.destroy.listen([this] {
m_hlSurface.reset(); m_hlSurface.reset();
if (m_active) if (m_active)
deactivate(); deactivate();

2
src/protocols/PrimarySelection.cpp
View File

@@ -228,7 +228,7 @@ void CPrimarySelectionProtocol::bindManager(wl_client* client, void* data, uint3
// we need to do it here because protocols come before seatMgr // we need to do it here because protocols come before seatMgr
if (!m_listeners.onPointerFocusChange) if (!m_listeners.onPointerFocusChange)
m_listeners.onPointerFocusChange = g_pSeatManager->m_events.pointerFocusChange.registerListener([this](std::any d) { this->onPointerFocus(); }); m_listeners.onPointerFocusChange = g_pSeatManager->m_events.pointerFocusChange.listen([this] { this->onPointerFocus(); });
} }
void CPrimarySelectionProtocol::destroyResource(CPrimarySelectionManager* resource) { void CPrimarySelectionProtocol::destroyResource(CPrimarySelectionManager* resource) {

6
src/protocols/SessionLock.cpp
View File

@@ -24,7 +24,7 @@ CSessionLockSurface::CSessionLockSurface(SP<CExtSessionLockSurfaceV1> resource_,
m_resource->setAckConfigure([this](CExtSessionLockSurfaceV1* r, uint32_t serial) { m_ackdConfigure = true; }); m_resource->setAckConfigure([this](CExtSessionLockSurfaceV1* r, uint32_t serial) { m_ackdConfigure = true; });
m_listeners.surfaceCommit = m_surface->m_events.commit.registerListener([this](std::any d) { m_listeners.surfaceCommit = m_surface->m_events.commit.listen([this] {
if (!m_surface->m_current.texture) { if (!m_surface->m_current.texture) {
LOGM(ERR, "SessionLock attached a null buffer"); LOGM(ERR, "SessionLock attached a null buffer");
m_resource->error(EXT_SESSION_LOCK_SURFACE_V1_ERROR_NULL_BUFFER, "Null buffer attached"); m_resource->error(EXT_SESSION_LOCK_SURFACE_V1_ERROR_NULL_BUFFER, "Null buffer attached");
@@ -46,7 +46,7 @@ CSessionLockSurface::CSessionLockSurface(SP<CExtSessionLockSurfaceV1> resource_,
m_committed = true; m_committed = true;
}); });
m_listeners.surfaceDestroy = m_surface->m_events.destroy.registerListener([this](std::any d) { m_listeners.surfaceDestroy = m_surface->m_events.destroy.listen([this] {
LOGM(WARN, "SessionLockSurface object remains but surface is being destroyed???"); LOGM(WARN, "SessionLockSurface object remains but surface is being destroyed???");
m_surface->unmap(); m_surface->unmap();
m_listeners.surfaceCommit.reset(); m_listeners.surfaceCommit.reset();
@@ -61,7 +61,7 @@ CSessionLockSurface::CSessionLockSurface(SP<CExtSessionLockSurfaceV1> resource_,
sendConfigure(); sendConfigure();
m_listeners.monitorMode = m_monitor->m_events.modeChanged.registerListener([this](std::any data) { sendConfigure(); }); m_listeners.monitorMode = m_monitor->m_events.modeChanged.listen([this] { sendConfigure(); });
} }
CSessionLockSurface::~CSessionLockSurface() { CSessionLockSurface::~CSessionLockSurface() {

14
src/protocols/SessionLock.hpp
View File

@@ -21,9 +21,9 @@ class CSessionLockSurface {
SP<CWLSurfaceResource> surface(); SP<CWLSurfaceResource> surface();
struct { struct {
CSignal map; CSignalT<> map;
CSignal destroy; CSignalT<> destroy;
CSignal commit; CSignalT<> commit;
} m_events; } m_events;
private: private:
@@ -54,9 +54,9 @@ class CSessionLock {
void sendDenied(); void sendDenied();
struct { struct {
CSignal newLockSurface; // SP<CSessionLockSurface> CSignalT<SP<CSessionLockSurface>> newLockSurface;
CSignal unlockAndDestroy; CSignalT<> unlockAndDestroy;
CSignal destroyed; // fires regardless of whether there was a unlockAndDestroy or not. CSignalT<> destroyed; // fires regardless of whether there was a unlockAndDestroy or not.
} m_events; } m_events;
private: private:
@@ -76,7 +76,7 @@ class CSessionLockProtocol : public IWaylandProtocol {
bool isLocked(); bool isLocked();
struct { struct {
CSignal newLock; // SP<CSessionLock> CSignalT<SP<CSessionLock>> newLock;
} m_events; } m_events;
private: private:

2
src/protocols/SinglePixel.cpp
View File

@@ -69,7 +69,7 @@ CSinglePixelBufferResource::CSinglePixelBufferResource(uint32_t id, wl_client* c
m_buffer->m_resource->m_buffer = m_buffer; m_buffer->m_resource->m_buffer = m_buffer;
m_listeners.bufferResourceDestroy = m_buffer->events.destroy.registerListener([this](std::any d) { m_listeners.bufferResourceDestroy = m_buffer->events.destroy.listen([this] {
m_listeners.bufferResourceDestroy.reset(); m_listeners.bufferResourceDestroy.reset();
PROTO::singlePixel->destroyResource(this); PROTO::singlePixel->destroyResource(this);
}); });

12
src/protocols/TextInputV1.hpp
View File

@@ -33,11 +33,11 @@ class CTextInputV1 {
bool m_active = false; bool m_active = false;
struct { struct {
CSignal onCommit; CSignalT<> onCommit;
CSignal enable; CSignalT<SP<CWLSurfaceResource>> enable;
CSignal disable; CSignalT<> disable;
CSignal reset; CSignalT<> reset;
CSignal destroy; CSignalT<> destroy;
} m_events; } m_events;
struct SPendingSurr { struct SPendingSurr {
@@ -68,7 +68,7 @@ class CTextInputV1Protocol : public IWaylandProtocol {
void destroyResource(CZwpTextInputManagerV1* client); void destroyResource(CZwpTextInputManagerV1* client);
struct { struct {
CSignal newTextInput; // WP<CTextInputV3> CSignalT<WP<CTextInputV1>> newTextInput;
} m_events; } m_events;
private: private:

14
src/protocols/TextInputV3.hpp
View File

@@ -27,11 +27,11 @@ class CTextInputV3 {
wl_client* client(); wl_client* client();
struct { struct {
CSignal onCommit; CSignalT<> onCommit;
CSignal enable; CSignalT<> enable;
CSignal disable; CSignalT<> disable;
CSignal reset; CSignalT<> reset;
CSignal destroy; CSignalT<> destroy;
} m_events; } m_events;
struct SState { struct SState {
@@ -80,7 +80,7 @@ class CTextInputV3Protocol : public IWaylandProtocol {
virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id); virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);
struct { struct {
CSignal newTextInput; // WP<CTextInputV3> CSignalT<WP<CTextInputV3>> newTextInput;
} m_events; } m_events;
private: private:
@@ -97,4 +97,4 @@ class CTextInputV3Protocol : public IWaylandProtocol {
namespace PROTO { namespace PROTO {
inline UP<CTextInputV3Protocol> textInputV3; inline UP<CTextInputV3Protocol> textInputV3;
}; };

2
src/protocols/Viewporter.cpp
View File

@@ -55,7 +55,7 @@ CViewportResource::CViewportResource(SP<CWpViewport> resource_, SP<CWLSurfaceRes
m_surface->m_pending.viewport.source = {x, y, w, h}; m_surface->m_pending.viewport.source = {x, y, w, h};
}); });
m_listeners.surfacePrecommit = m_surface->m_events.precommit.registerListener([this](std::any d) { m_listeners.surfacePrecommit = m_surface->m_events.precommit.listen([this] {
if (!m_surface || !m_surface->m_pending.buffer) if (!m_surface || !m_surface->m_pending.buffer)
return; return;

12
src/protocols/VirtualKeyboard.hpp
View File

@@ -3,6 +3,8 @@
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
#include "WaylandProtocol.hpp" #include "WaylandProtocol.hpp"
#include "../devices/IKeyboard.hpp"
#include "../devices/VirtualKeyboard.hpp"
#include "virtual-keyboard-unstable-v1.hpp" #include "virtual-keyboard-unstable-v1.hpp"
#include "../helpers/signal/Signal.hpp" #include "../helpers/signal/Signal.hpp"
#include <hyprutils/os/FileDescriptor.hpp> #include <hyprutils/os/FileDescriptor.hpp>
@@ -13,10 +15,10 @@ class CVirtualKeyboardV1Resource {
~CVirtualKeyboardV1Resource(); ~CVirtualKeyboardV1Resource();
struct { struct {
CSignal destroy; CSignalT<> destroy;
CSignal key; CSignalT<IKeyboard::SKeyEvent> key;
CSignal modifiers; CSignalT<IKeyboard::SModifiersEvent> modifiers;
CSignal keymap; CSignalT<IKeyboard::SKeymapEvent> keymap;
} m_events; } m_events;
bool good(); bool good();
@@ -41,7 +43,7 @@ class CVirtualKeyboardProtocol : public IWaylandProtocol {
virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id); virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);
struct { struct {
CSignal newKeyboard; // SP<CVirtualKeyboard> CSignalT<SP<CVirtualKeyboardV1Resource>> newKeyboard;
} m_events; } m_events;
private: private:

2
src/protocols/VirtualPointer.cpp
View File

@@ -148,4 +148,4 @@ void CVirtualPointerProtocol::onCreatePointer(CZwlrVirtualPointerManagerV1* pMgr
LOGM(LOG, "New VPointer at id {}", id); LOGM(LOG, "New VPointer at id {}", id);
m_events.newPointer.emit(RESOURCE); m_events.newPointer.emit(RESOURCE);
} }

30
src/protocols/VirtualPointer.hpp
View File

@@ -15,23 +15,23 @@ class CVirtualPointerV1Resource {
~CVirtualPointerV1Resource(); ~CVirtualPointerV1Resource();
struct { struct {
CSignal destroy; CSignalT<> destroy;
CSignal move; CSignalT<IPointer::SMotionEvent> move;
CSignal warp; CSignalT<IPointer::SMotionAbsoluteEvent> warp;
CSignal button; CSignalT<IPointer::SButtonEvent> button;
CSignal axis; CSignalT<IPointer::SAxisEvent> axis;
CSignal frame; CSignalT<> frame;
CSignal swipeBegin; CSignalT<IPointer::SSwipeBeginEvent> swipeBegin;
CSignal swipeUpdate; CSignalT<IPointer::SSwipeUpdateEvent> swipeUpdate;
CSignal swipeEnd; CSignalT<IPointer::SSwipeEndEvent> swipeEnd;
CSignal pinchBegin; CSignalT<IPointer::SPinchBeginEvent> pinchBegin;
CSignal pinchUpdate; CSignalT<IPointer::SPinchUpdateEvent> pinchUpdate;
CSignal pinchEnd; CSignalT<IPointer::SPinchEndEvent> pinchEnd;
CSignal holdBegin; CSignalT<IPointer::SHoldBeginEvent> holdBegin;
CSignal holdEnd; CSignalT<IPointer::SHoldEndEvent> holdEnd;
} m_events; } m_events;
bool good(); bool good();
@@ -56,7 +56,7 @@ class CVirtualPointerProtocol : public IWaylandProtocol {
virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id); virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);
struct { struct {
CSignal newPointer; // SP<CVirtualPointerV1Resource> CSignalT<SP<CVirtualPointerV1Resource>> newPointer;
} m_events; } m_events;
private: private:

6
src/protocols/XDGShell.cpp
View File

@@ -372,7 +372,7 @@ CXDGSurfaceResource::CXDGSurfaceResource(SP<CXdgSurface> resource_, SP<CXDGWMBas
PROTO::xdgShell->destroyResource(this); PROTO::xdgShell->destroyResource(this);
}); });
m_listeners.surfaceDestroy = m_surface->m_events.destroy.registerListener([this](std::any d) { m_listeners.surfaceDestroy = m_surface->m_events.destroy.listen([this] {
LOGM(WARN, "wl_surface destroyed before its xdg_surface role object"); LOGM(WARN, "wl_surface destroyed before its xdg_surface role object");
m_listeners.surfaceDestroy.reset(); m_listeners.surfaceDestroy.reset();
m_listeners.surfaceCommit.reset(); m_listeners.surfaceCommit.reset();
@@ -385,7 +385,7 @@ CXDGSurfaceResource::CXDGSurfaceResource(SP<CXdgSurface> resource_, SP<CXDGWMBas
m_events.destroy.emit(); m_events.destroy.emit();
}); });
m_listeners.surfaceCommit = m_surface->m_events.commit.registerListener([this](std::any d) { m_listeners.surfaceCommit = m_surface->m_events.commit.listen([this] {
m_current = m_pending; m_current = m_pending;
if (m_toplevel) if (m_toplevel)
m_toplevel->m_current = m_toplevel->m_pending; m_toplevel->m_current = m_toplevel->m_pending;
@@ -436,7 +436,7 @@ CXDGSurfaceResource::CXDGSurfaceResource(SP<CXdgSurface> resource_, SP<CXDGWMBas
for (auto const& p : m_popups) { for (auto const& p : m_popups) {
if (!p) if (!p)
continue; continue;
m_events.newPopup.emit(p); m_events.newPopup.emit(p.lock());
} }
}); });

28
src/protocols/XDGShell.hpp
View File

@@ -63,9 +63,9 @@ class CXDGPopupResource {
CBox m_geometry; CBox m_geometry;
struct { struct {
CSignal reposition; CSignalT<> reposition;
CSignal dismissed; CSignalT<> dismissed;
CSignal destroy; // only the role CSignalT<> destroy; // only the role
} m_events; } m_events;
// schedules a configure event // schedules a configure event
@@ -111,10 +111,10 @@ class CXDGToplevelResource {
void close(); void close();
struct { struct {
CSignal sizeLimitsChanged; CSignalT<> sizeLimitsChanged;
CSignal stateChanged; // maximized, fs, minimized, etc. CSignalT<> stateChanged; // maximized, fs, minimized, etc.
CSignal metadataChanged; // title, appid CSignalT<> metadataChanged; // title, appid
CSignal destroy; // only the role CSignalT<> destroy; // only the role
} m_events; } m_events;
struct { struct {
@@ -186,12 +186,12 @@ class CXDGSurfaceResource {
} m_pending, m_current; } m_pending, m_current;
struct { struct {
CSignal ack; CSignalT<uint32_t> ack;
CSignal commit; CSignalT<> commit;
CSignal map; CSignalT<> map;
CSignal unmap; CSignalT<> unmap;
CSignal destroy; CSignalT<> destroy;
CSignal newPopup; // SP<CXDGPopupResource> CSignalT<SP<CXDGPopupResource>> newPopup;
} m_events; } m_events;
bool m_initialCommit = true; bool m_initialCommit = true;
@@ -252,7 +252,7 @@ class CXDGWMBase {
WP<CXDGWMBase> m_self; WP<CXDGWMBase> m_self;
struct { struct {
CSignal pong; CSignalT<> pong;
} m_events; } m_events;
private: private:

4
src/protocols/XWaylandShell.hpp
View File

@@ -17,7 +17,7 @@ class CXWaylandSurfaceResource {
wl_client* client(); wl_client* client();
struct { struct {
CSignal destroy; CSignalT<> destroy;
} events; } events;
uint64_t m_serial = 0; uint64_t m_serial = 0;
@@ -47,7 +47,7 @@ class CXWaylandShellProtocol : public IWaylandProtocol {
virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id); virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);
struct { struct {
CSignal newSurface; // SP<CXWaylandSurfaceResource>. Fired when it sets a serial, otherwise it's useless CSignalT<SP<CXWaylandSurfaceResource>> newSurface; // Fired when it sets a serial, otherwise it's useless
} m_events; } m_events;
private: private:

14
src/protocols/core/Compositor.hpp
View File

@@ -80,12 +80,12 @@ class CWLSurfaceResource {
void resetRole(); void resetRole();
struct { struct {
CSignal precommit; // before commit CSignalT<> precommit; // before commit
CSignal commit; // after commit CSignalT<> commit; // after commit
CSignal map; CSignalT<> map;
CSignal unmap; CSignalT<> unmap;
CSignal newSubsurface; CSignalT<SP<CWLSubsurfaceResource>> newSubsurface;
CSignal destroy; CSignalT<> destroy;
} m_events; } m_events;
SSurfaceState m_current; SSurfaceState m_current;
@@ -146,7 +146,7 @@ class CWLCompositorProtocol : public IWaylandProtocol {
void forEachSurface(std::function<void(SP<CWLSurfaceResource>)> fn); void forEachSurface(std::function<void(SP<CWLSurfaceResource>)> fn);
struct { struct {
CSignal newSurface; // SP<CWLSurfaceResource> CSignalT<SP<CWLSurfaceResource>> newSurface;
} m_events; } m_events;
private: private:

8
src/protocols/core/DataDevice.cpp
View File

@@ -385,8 +385,8 @@ bool CWLDataDeviceManagerResource::good() {
CWLDataDeviceProtocol::CWLDataDeviceProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) { CWLDataDeviceProtocol::CWLDataDeviceProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) {
g_pEventLoopManager->doLater([this]() { g_pEventLoopManager->doLater([this]() {
m_listeners.onKeyboardFocusChange = g_pSeatManager->m_events.keyboardFocusChange.registerListener([this](std::any d) { onKeyboardFocus(); }); m_listeners.onKeyboardFocusChange = g_pSeatManager->m_events.keyboardFocusChange.listen([this] { onKeyboardFocus(); });
m_listeners.onDndPointerFocusChange = g_pSeatManager->m_events.dndPointerFocusChange.registerListener([this](std::any d) { onDndPointerFocus(); }); m_listeners.onDndPointerFocusChange = g_pSeatManager->m_events.dndPointerFocusChange.listen([this] { onDndPointerFocus(); });
}); });
} }
@@ -564,8 +564,8 @@ void CWLDataDeviceProtocol::initiateDrag(WP<CWLDataSourceResource> currentSource
m_dnd.originSurface = origin; m_dnd.originSurface = origin;
m_dnd.dndSurface = dragSurface; m_dnd.dndSurface = dragSurface;
if (dragSurface) { if (dragSurface) {
m_dnd.dndSurfaceDestroy = dragSurface->m_events.destroy.registerListener([this](std::any d) { abortDrag(); }); m_dnd.dndSurfaceDestroy = dragSurface->m_events.destroy.listen([this] { abortDrag(); });
m_dnd.dndSurfaceCommit = dragSurface->m_events.commit.registerListener([this](std::any d) { m_dnd.dndSurfaceCommit = dragSurface->m_events.commit.listen([this] {
if (m_dnd.dndSurface->m_current.texture && !m_dnd.dndSurface->m_mapped) { if (m_dnd.dndSurface->m_current.texture && !m_dnd.dndSurface->m_mapped) {
m_dnd.dndSurface->map(); m_dnd.dndSurface->map();
return; return;

2
src/protocols/core/Output.cpp
View File

@@ -86,7 +86,7 @@ void CWLOutputResource::updateState() {
CWLOutputProtocol::CWLOutputProtocol(const wl_interface* iface, const int& ver, const std::string& name, PHLMONITOR pMonitor) : CWLOutputProtocol::CWLOutputProtocol(const wl_interface* iface, const int& ver, const std::string& name, PHLMONITOR pMonitor) :
IWaylandProtocol(iface, ver, name), m_monitor(pMonitor), m_name(pMonitor->m_name) { IWaylandProtocol(iface, ver, name), m_monitor(pMonitor), m_name(pMonitor->m_name) {
m_listeners.modeChanged = m_monitor->m_events.modeChanged.registerListener([this](std::any d) { m_listeners.modeChanged = m_monitor->m_events.modeChanged.listen([this] {
for (auto const& o : m_outputs) { for (auto const& o : m_outputs) {
o->updateState(); o->updateState();
} }

2
src/protocols/core/Output.hpp
View File

@@ -47,7 +47,7 @@ class CWLOutputProtocol : public IWaylandProtocol {
bool isDefunct(); // true if above was called bool isDefunct(); // true if above was called
struct { struct {
CSignal outputBound; CSignalT<SP<CWLOutputResource>> outputBound;
} m_events; } m_events;
private: private:

6
src/protocols/core/Seat.cpp
View File

@@ -32,7 +32,7 @@ void CWLTouchResource::sendDown(SP<CWLSurfaceResource> surface, uint32_t timeMs,
ASSERT(surface->client() == m_owner->client()); ASSERT(surface->client() == m_owner->client());
m_currentSurface = surface; m_currentSurface = surface;
m_listeners.destroySurface = surface->m_events.destroy.registerListener([this, timeMs, id](std::any d) { sendUp(timeMs + 10 /* hack */, id); }); m_listeners.destroySurface = surface->m_events.destroy.listen([this, timeMs, id] { sendUp(timeMs + 10 /* hack */, id); });
m_resource->sendDown(g_pSeatManager->nextSerial(m_owner.lock()), timeMs, surface->getResource().get(), id, wl_fixed_from_double(local.x), wl_fixed_from_double(local.y)); m_resource->sendDown(g_pSeatManager->nextSerial(m_owner.lock()), timeMs, surface->getResource().get(), id, wl_fixed_from_double(local.x), wl_fixed_from_double(local.y));
@@ -160,7 +160,7 @@ void CWLPointerResource::sendEnter(SP<CWLSurfaceResource> surface, const Vector2
ASSERT(surface->client() == m_owner->client()); ASSERT(surface->client() == m_owner->client());
m_currentSurface = surface; m_currentSurface = surface;
m_listeners.destroySurface = surface->m_events.destroy.registerListener([this](std::any d) { sendLeave(); }); m_listeners.destroySurface = surface->m_events.destroy.listen([this] { sendLeave(); });
m_resource->sendEnter(g_pSeatManager->nextSerial(m_owner.lock()), surface->getResource().get(), wl_fixed_from_double(local.x), wl_fixed_from_double(local.y)); m_resource->sendEnter(g_pSeatManager->nextSerial(m_owner.lock()), surface->getResource().get(), wl_fixed_from_double(local.x), wl_fixed_from_double(local.y));
} }
@@ -349,7 +349,7 @@ void CWLKeyboardResource::sendEnter(SP<CWLSurfaceResource> surface) {
ASSERT(surface->client() == m_owner->client()); ASSERT(surface->client() == m_owner->client());
m_currentSurface = surface; m_currentSurface = surface;
m_listeners.destroySurface = surface->m_events.destroy.registerListener([this](std::any d) { sendLeave(); }); m_listeners.destroySurface = surface->m_events.destroy.listen([this] { sendLeave(); });
wl_array arr; wl_array arr;
wl_array_init(&arr); wl_array_init(&arr);

4
src/protocols/core/Seat.hpp
View File

@@ -142,7 +142,7 @@ class CWLSeatResource {
WP<CWLSeatResource> m_self; WP<CWLSeatResource> m_self;
struct { struct {
CSignal destroy; CSignalT<> destroy;
} m_events; } m_events;
private: private:
@@ -157,7 +157,7 @@ class CWLSeatProtocol : public IWaylandProtocol {
virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id); virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);
struct { struct {
CSignal newSeatResource; // SP<CWLSeatResource> CSignalT<SP<CWLSeatResource>> newSeatResource;
} m_events; } m_events;
private: private:

2
src/protocols/core/Shm.cpp
View File

@@ -24,7 +24,7 @@ CWLSHMBuffer::CWLSHMBuffer(SP<CWLSHMPoolResource> pool_, uint32_t id, int32_t of
m_resource = CWLBufferResource::create(makeShared<CWlBuffer>(pool_->m_resource->client(), 1, id)); m_resource = CWLBufferResource::create(makeShared<CWlBuffer>(pool_->m_resource->client(), 1, id));
m_listeners.bufferResourceDestroy = events.destroy.registerListener([this](std::any d) { m_listeners.bufferResourceDestroy = events.destroy.listen([this] {
m_listeners.bufferResourceDestroy.reset(); m_listeners.bufferResourceDestroy.reset();
PROTO::shm->destroyResource(this); PROTO::shm->destroyResource(this);
}); });

2
src/protocols/core/Subcompositor.cpp
View File

@@ -71,7 +71,7 @@ CWLSubsurfaceResource::CWLSubsurfaceResource(SP<CWlSubsurface> resource_, SP<CWL
} }
}); });
m_listeners.commitSurface = m_surface->m_events.commit.registerListener([this](std::any d) { m_listeners.commitSurface = m_surface->m_events.commit.listen([this] {
if (m_surface->m_current.texture && !m_surface->m_mapped) { if (m_surface->m_current.texture && !m_surface->m_mapped) {
m_surface->map(); m_surface->map();
m_surface->m_events.map.emit(); m_surface->m_events.map.emit();

2
src/protocols/core/Subcompositor.hpp
View File

@@ -48,7 +48,7 @@ class CWLSubsurfaceResource {
int m_zIndex = 1; // by default, it's above int m_zIndex = 1; // by default, it's above
struct { struct {
CSignal destroy; CSignalT<> destroy;
} m_events; } m_events;
private: private:

2
src/protocols/types/Buffer.cpp
View File

@@ -36,7 +36,7 @@ void IHLBuffer::onBackendRelease(const std::function<void()>& fn) {
m_backendReleaseQueuedFn = fn; m_backendReleaseQueuedFn = fn;
m_hlEvents.backendRelease = events.backendRelease.registerListener([this](std::any) { m_hlEvents.backendRelease = events.backendRelease.listen([this] {
if (m_backendReleaseQueuedFn) if (m_backendReleaseQueuedFn)
m_backendReleaseQueuedFn(); m_backendReleaseQueuedFn();
m_backendReleaseQueuedFn = nullptr; m_backendReleaseQueuedFn = nullptr;

2
src/protocols/types/DMABuffer.cpp
View File

@@ -15,7 +15,7 @@ using namespace Hyprutils::OS;
CDMABuffer::CDMABuffer(uint32_t id, wl_client* client, Aquamarine::SDMABUFAttrs const& attrs_) : m_attrs(attrs_) { CDMABuffer::CDMABuffer(uint32_t id, wl_client* client, Aquamarine::SDMABUFAttrs const& attrs_) : m_attrs(attrs_) {
g_pHyprRenderer->makeEGLCurrent(); g_pHyprRenderer->makeEGLCurrent();
m_listeners.resourceDestroy = events.destroy.registerListener([this](std::any d) { m_listeners.resourceDestroy = events.destroy.listen([this] {
closeFDs(); closeFDs();
m_listeners.resourceDestroy.reset(); m_listeners.resourceDestroy.reset();
}); });

2
src/protocols/types/DataDevice.hpp
View File

@@ -41,7 +41,7 @@ class IDataSource {
virtual void sendDndAction(wl_data_device_manager_dnd_action a); virtual void sendDndAction(wl_data_device_manager_dnd_action a);
struct { struct {
CSignal destroy; CSignalT<> destroy;
} m_events; } m_events;
private: private:

2
src/render/Renderbuffer.cpp
View File

@@ -48,7 +48,7 @@ CRenderbuffer::CRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t format) :
m_framebuffer.unbind(); m_framebuffer.unbind();
m_listeners.destroyBuffer = buffer->events.destroy.registerListener([this](std::any d) { g_pHyprRenderer->onRenderbufferDestroy(this); }); m_listeners.destroyBuffer = buffer->events.destroy.listen([this] { g_pHyprRenderer->onRenderbufferDestroy(this); });
m_good = true; m_good = true;
} }

8
src/xwayland/XSurface.cpp
View File

@@ -42,7 +42,7 @@ CXWaylandSurface::CXWaylandSurface(uint32_t xID_, CBox geometry_, bool OR) : m_x
free(reply); free(reply);
} }
m_events.resourceChange.registerStaticListener([this](void* data, std::any d) { ensureListeners(); }, nullptr); m_events.resourceChange.listenStatic([this] { ensureListeners(); });
} }
void CXWaylandSurface::ensureListeners() { void CXWaylandSurface::ensureListeners() {
@@ -52,7 +52,7 @@ void CXWaylandSurface::ensureListeners() {
m_listeners.destroySurface.reset(); m_listeners.destroySurface.reset();
m_listeners.commitSurface.reset(); m_listeners.commitSurface.reset();
} else if (!connected && m_surface) { } else if (!connected && m_surface) {
m_listeners.destroySurface = m_surface->m_events.destroy.registerListener([this](std::any d) { m_listeners.destroySurface = m_surface->m_events.destroy.listen([this] {
if (m_mapped) if (m_mapped)
unmap(); unmap();
@@ -62,7 +62,7 @@ void CXWaylandSurface::ensureListeners() {
m_events.resourceChange.emit(); m_events.resourceChange.emit();
}); });
m_listeners.commitSurface = m_surface->m_events.commit.registerListener([this](std::any d) { m_listeners.commitSurface = m_surface->m_events.commit.listen([this] {
if (m_surface->m_current.texture && !m_mapped) { if (m_surface->m_current.texture && !m_mapped) {
map(); map();
return; return;
@@ -78,7 +78,7 @@ void CXWaylandSurface::ensureListeners() {
} }
if (m_resource) { if (m_resource) {
m_listeners.destroyResource = m_resource->events.destroy.registerListener([this](std::any d) { m_listeners.destroyResource = m_resource->events.destroy.listen([this] {
unmap(); unmap();
m_surface.reset(); m_surface.reset();
m_events.resourceChange.emit(); m_events.resourceChange.emit();

20
src/xwayland/XSurface.hpp
View File

@@ -43,20 +43,20 @@ class CXWaylandSurface {
WP<CXWaylandSurfaceResource> m_resource; WP<CXWaylandSurfaceResource> m_resource;
struct { struct {
CSignal stateChanged; // maximized, fs, minimized, etc. CSignalT<> stateChanged; // maximized, fs, minimized, etc.
CSignal metadataChanged; // title, appid CSignalT<> metadataChanged; // title, appid
CSignal destroy; CSignalT<> destroy;
CSignal resourceChange; // associated / dissociated CSignalT<> resourceChange; // associated / dissociated
CSignal setGeometry; CSignalT<> setGeometry;
CSignal configureRequest; // CBox CSignalT<CBox> configureRequest;
CSignal map; CSignalT<> map;
CSignal unmap; CSignalT<> unmap;
CSignal commit; CSignalT<> commit;
CSignal activate; CSignalT<> activate;
} m_events; } m_events;
struct { struct {

13
src/xwayland/XWM.cpp
View File

@@ -984,9 +984,8 @@ CXWM::CXWM() : m_connection(makeUnique<CXCBConnection>(g_pXWayland->m_server->m_
setActiveWindow(XCB_WINDOW_NONE); setActiveWindow(XCB_WINDOW_NONE);
initSelection(); initSelection();
m_listeners.newWLSurface = PROTO::compositor->m_events.newSurface.registerListener([this](std::any d) { onNewSurface(std::any_cast<SP<CWLSurfaceResource>>(d)); }); m_listeners.newWLSurface = PROTO::compositor->m_events.newSurface.listen([this](const auto& surface) { onNewSurface(surface); });
m_listeners.newXShellSurface = m_listeners.newXShellSurface = PROTO::xwaylandShell->m_events.newSurface.listen([this](const auto& surface) { onNewResource(surface); });
PROTO::xwaylandShell->m_events.newSurface.registerListener([this](std::any d) { onNewResource(std::any_cast<SP<CXWaylandSurfaceResource>>(d)); });
createWMWindow(); createWMWindow();
@@ -1218,12 +1217,12 @@ void CXWM::initSelection() {
createSelectionWindow(m_clipboard.window, "CLIPBOARD_MANAGER"); createSelectionWindow(m_clipboard.window, "CLIPBOARD_MANAGER");
createSelectionWindow(m_clipboard.window, "CLIPBOARD"); createSelectionWindow(m_clipboard.window, "CLIPBOARD");
m_clipboard.listeners.setSelection = g_pSeatManager->m_events.setSelection.registerListener([this](std::any) { m_clipboard.onSelection(); }); m_clipboard.listeners.setSelection = g_pSeatManager->m_events.setSelection.listen([this] { m_clipboard.onSelection(); });
m_clipboard.listeners.keyboardFocusChange = g_pSeatManager->m_events.keyboardFocusChange.registerListener([this](std::any) { m_clipboard.onKeyboardFocus(); }); m_clipboard.listeners.keyboardFocusChange = g_pSeatManager->m_events.keyboardFocusChange.listen([this] { m_clipboard.onKeyboardFocus(); });
createSelectionWindow(m_primarySelection.window, "PRIMARY"); createSelectionWindow(m_primarySelection.window, "PRIMARY");
m_primarySelection.listeners.setSelection = g_pSeatManager->m_events.setPrimarySelection.registerListener([this](std::any) { m_primarySelection.onSelection(); }); m_primarySelection.listeners.setSelection = g_pSeatManager->m_events.setPrimarySelection.listen([this] { m_primarySelection.onSelection(); });
m_primarySelection.listeners.keyboardFocusChange = g_pSeatManager->m_events.keyboardFocusChange.registerListener([this](std::any) { m_primarySelection.onKeyboardFocus(); }); m_primarySelection.listeners.keyboardFocusChange = g_pSeatManager->m_events.keyboardFocusChange.listen([this] { m_primarySelection.onKeyboardFocus(); });
createSelectionWindow(m_dndSelection.window, "XdndAware", true); createSelectionWindow(m_dndSelection.window, "XdndAware", true);
const uint32_t xdndVersion = XDND_VERSION; const uint32_t xdndVersion = XDND_VERSION;