diff --git a/src/Compositor.cpp b/src/Compositor.cpp index 3c0a4ec39..8873d7f29 100644 --- a/src/Compositor.cpp +++ b/src/Compositor.cpp @@ -405,90 +405,67 @@ void CCompositor::initServer(std::string socketName, int socketFd) { } void CCompositor::initAllSignals() { - m_aqBackend->events.newOutput.registerStaticListener( - [this](void* p, std::any data) { - auto output = std::any_cast>(data); - Debug::log(LOG, "New aquamarine output with name {}", output->name); - if (m_initialized) - onNewMonitor(output); - else - pendingOutputs.emplace_back(output); - }, - nullptr); + m_aqBackend->events.newOutput.listenStatic([this](const SP& output) { + Debug::log(LOG, "New aquamarine output with name {}", output->name); + if (m_initialized) + onNewMonitor(output); + else + pendingOutputs.emplace_back(output); + }); - m_aqBackend->events.newPointer.registerStaticListener( - [](void* data, std::any d) { - auto dev = std::any_cast>(d); - Debug::log(LOG, "New aquamarine pointer with name {}", dev->getName()); - g_pInputManager->newMouse(dev); - g_pInputManager->updateCapabilities(); - }, - nullptr); + m_aqBackend->events.newPointer.listenStatic([](const SP& dev) { + Debug::log(LOG, "New aquamarine pointer with name {}", dev->getName()); + g_pInputManager->newMouse(dev); + g_pInputManager->updateCapabilities(); + }); - m_aqBackend->events.newKeyboard.registerStaticListener( - [](void* data, std::any d) { - auto dev = std::any_cast>(d); - Debug::log(LOG, "New aquamarine keyboard with name {}", dev->getName()); - g_pInputManager->newKeyboard(dev); - g_pInputManager->updateCapabilities(); - }, - nullptr); + m_aqBackend->events.newKeyboard.listenStatic([](const SP& dev) { + Debug::log(LOG, "New aquamarine keyboard with name {}", dev->getName()); + g_pInputManager->newKeyboard(dev); + g_pInputManager->updateCapabilities(); + }); - m_aqBackend->events.newTouch.registerStaticListener( - [](void* data, std::any d) { - auto dev = std::any_cast>(d); - Debug::log(LOG, "New aquamarine touch with name {}", dev->getName()); - g_pInputManager->newTouchDevice(dev); - g_pInputManager->updateCapabilities(); - }, - nullptr); + m_aqBackend->events.newTouch.listenStatic([](const SP& dev) { + Debug::log(LOG, "New aquamarine touch with name {}", dev->getName()); + g_pInputManager->newTouchDevice(dev); + g_pInputManager->updateCapabilities(); + }); - m_aqBackend->events.newSwitch.registerStaticListener( - [](void* data, std::any d) { - auto dev = std::any_cast>(d); - Debug::log(LOG, "New aquamarine switch with name {}", dev->getName()); - g_pInputManager->newSwitch(dev); - }, - nullptr); + m_aqBackend->events.newSwitch.listenStatic([](const SP& dev) { + Debug::log(LOG, "New aquamarine switch with name {}", dev->getName()); + g_pInputManager->newSwitch(dev); + }); - m_aqBackend->events.newTablet.registerStaticListener( - [](void* data, std::any d) { - auto dev = std::any_cast>(d); - Debug::log(LOG, "New aquamarine tablet with name {}", dev->getName()); - g_pInputManager->newTablet(dev); - }, - nullptr); + m_aqBackend->events.newTablet.listenStatic([](const SP& dev) { + Debug::log(LOG, "New aquamarine tablet with name {}", dev->getName()); + g_pInputManager->newTablet(dev); + }); - m_aqBackend->events.newTabletPad.registerStaticListener( - [](void* data, std::any d) { - auto dev = std::any_cast>(d); - Debug::log(LOG, "New aquamarine tablet pad with name {}", dev->getName()); - g_pInputManager->newTabletPad(dev); - }, - nullptr); + m_aqBackend->events.newTabletPad.listenStatic([](const SP& dev) { + Debug::log(LOG, "New aquamarine tablet pad with name {}", dev->getName()); + g_pInputManager->newTabletPad(dev); + }); if (m_aqBackend->hasSession()) { - m_aqBackend->session->events.changeActive.registerStaticListener( - [this](void*, std::any) { - if (m_aqBackend->session->active) { - Debug::log(LOG, "Session got activated!"); + m_aqBackend->session->events.changeActive.listenStatic([this] { + if (m_aqBackend->session->active) { + Debug::log(LOG, "Session got activated!"); - m_sessionActive = true; + m_sessionActive = true; - for (auto const& m : m_monitors) { - scheduleFrameForMonitor(m); - m->applyMonitorRule(&m->m_activeMonitorRule, true); - } - - g_pConfigManager->m_wantsMonitorReload = true; - g_pCursorManager->syncGsettings(); - } else { - Debug::log(LOG, "Session got deactivated!"); - - m_sessionActive = false; + for (auto const& m : m_monitors) { + scheduleFrameForMonitor(m); + m->applyMonitorRule(&m->m_activeMonitorRule, true); } - }, - 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; PWORKSPACEA->m_monitor = pMonitorB; - PWORKSPACEA->m_events.monitorChange.emit(); + PWORKSPACEA->m_events.monitorChanged.emit(); for (auto const& w : m_windows) { if (w->m_workspace == PWORKSPACEA) { @@ -1998,7 +1975,7 @@ void CCompositor::swapActiveWorkspaces(PHLMONITOR pMonitorA, PHLMONITOR pMonitor } PWORKSPACEB->m_monitor = pMonitorA; - PWORKSPACEB->m_events.monitorChange.emit(); + PWORKSPACEB->m_events.monitorChanged.emit(); for (auto const& w : m_windows) { if (w->m_workspace == PWORKSPACEB) { @@ -2178,7 +2155,7 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo // move the workspace pWorkspace->m_monitor = pMonitor; - pWorkspace->m_events.monitorChange.emit(); + pWorkspace->m_events.monitorChanged.emit(); for (auto const& w : m_windows) { if (w->m_workspace == pWorkspace) { @@ -2227,9 +2204,9 @@ void CCompositor::moveWorkspaceToMonitor(PHLWORKSPACE pWorkspace, PHLMONITOR pMo pMonitor->m_activeWorkspace = pWorkspace; 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); diff --git a/src/desktop/LayerSurface.cpp b/src/desktop/LayerSurface.cpp index 135b06a3c..36ec030b9 100644 --- a/src/desktop/LayerSurface.cpp +++ b/src/desktop/LayerSurface.cpp @@ -59,10 +59,10 @@ void CLayerSurface::registerCallbacks() { } CLayerSurface::CLayerSurface(SP resource_) : m_layerSurface(resource_) { - m_listeners.commit = m_layerSurface->m_events.commit.registerListener([this](std::any d) { onCommit(); }); - m_listeners.map = m_layerSurface->m_events.map.registerListener([this](std::any d) { onMap(); }); - m_listeners.unmap = m_layerSurface->m_events.unmap.registerListener([this](std::any d) { onUnmap(); }); - m_listeners.destroy = m_layerSurface->m_events.destroy.registerListener([this](std::any d) { onDestroy(); }); + m_listeners.commit = m_layerSurface->m_events.commit.listen([this] { onCommit(); }); + m_listeners.map = m_layerSurface->m_events.map.listen([this] { onMap(); }); + m_listeners.unmap = m_layerSurface->m_events.unmap.listen([this] { onUnmap(); }); + m_listeners.destroy = m_layerSurface->m_events.destroy.listen([this] { onDestroy(); }); m_surface = CWLSurface::create(); } diff --git a/src/desktop/Popup.cpp b/src/desktop/Popup.cpp index b647bed5d..702ebdf9c 100644 --- a/src/desktop/Popup.cpp +++ b/src/desktop/Popup.cpp @@ -53,24 +53,22 @@ void CPopup::initAllSignals() { if (!m_resource) { if (!m_windowOwner.expired()) - m_listeners.newPopup = - m_windowOwner->m_xdgSurface->m_events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast>(d)); }); + m_listeners.newPopup = m_windowOwner->m_xdgSurface->m_events.newPopup.listen([this](const auto& resource) { this->onNewPopup(resource); }); else if (!m_layerOwner.expired()) - m_listeners.newPopup = - m_layerOwner->m_layerSurface->m_events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast>(d)); }); + m_listeners.newPopup = m_layerOwner->m_layerSurface->m_events.newPopup.listen([this](const auto& resource) { this->onNewPopup(resource); }); else ASSERT(false); return; } - m_listeners.reposition = m_resource->m_events.reposition.registerListener([this](std::any d) { this->onReposition(); }); - m_listeners.map = m_resource->m_surface->m_events.map.registerListener([this](std::any d) { this->onMap(); }); - m_listeners.unmap = m_resource->m_surface->m_events.unmap.registerListener([this](std::any d) { this->onUnmap(); }); - m_listeners.dismissed = m_resource->m_events.dismissed.registerListener([this](std::any d) { this->onUnmap(); }); - m_listeners.destroy = m_resource->m_surface->m_events.destroy.registerListener([this](std::any d) { this->onDestroy(); }); - m_listeners.commit = m_resource->m_surface->m_events.commit.registerListener([this](std::any d) { this->onCommit(); }); - m_listeners.newPopup = m_resource->m_surface->m_events.newPopup.registerListener([this](std::any d) { this->onNewPopup(std::any_cast>(d)); }); + m_listeners.reposition = m_resource->m_events.reposition.listen([this] { this->onReposition(); }); + m_listeners.map = m_resource->m_surface->m_events.map.listen([this] { this->onMap(); }); + m_listeners.unmap = m_resource->m_surface->m_events.unmap.listen([this] { this->onUnmap(); }); + m_listeners.dismissed = m_resource->m_events.dismissed.listen([this] { this->onUnmap(); }); + m_listeners.destroy = m_resource->m_surface->m_events.destroy.listen([this] { this->onDestroy(); }); + m_listeners.commit = m_resource->m_surface->m_events.commit.listen([this] { this->onCommit(); }); + m_listeners.newPopup = m_resource->m_surface->m_events.newPopup.listen([this](const auto& resource) { this->onNewPopup(resource); }); } void CPopup::onNewPopup(SP popup) { diff --git a/src/desktop/Subsurface.cpp b/src/desktop/Subsurface.cpp index 1c5d5c700..d13a13443 100644 --- a/src/desktop/Subsurface.cpp +++ b/src/desktop/Subsurface.cpp @@ -52,19 +52,16 @@ UP CSubsurface::create(SP pSubsurface, WPm_surface->m_events.commit.registerListener([this](std::any d) { onCommit(); }); - m_listeners.destroySubsurface = m_subsurface->m_events.destroy.registerListener([this](std::any d) { onDestroy(); }); - m_listeners.mapSubsurface = m_subsurface->m_surface->m_events.map.registerListener([this](std::any d) { onMap(); }); - m_listeners.unmapSubsurface = m_subsurface->m_surface->m_events.unmap.registerListener([this](std::any d) { onUnmap(); }); - m_listeners.newSubsurface = - m_subsurface->m_surface->m_events.newSubsurface.registerListener([this](std::any d) { onNewSubsurface(std::any_cast>(d)); }); + m_listeners.commitSubsurface = m_subsurface->m_surface->m_events.commit.listen([this] { onCommit(); }); + m_listeners.destroySubsurface = m_subsurface->m_events.destroy.listen([this] { onDestroy(); }); + m_listeners.mapSubsurface = m_subsurface->m_surface->m_events.map.listen([this] { onMap(); }); + m_listeners.unmapSubsurface = m_subsurface->m_surface->m_events.unmap.listen([this] { onUnmap(); }); + m_listeners.newSubsurface = m_subsurface->m_surface->m_events.newSubsurface.listen([this](const auto& resource) { onNewSubsurface(resource); }); } else { if (m_windowParent) - m_listeners.newSubsurface = m_windowParent->m_wlSurface->resource()->m_events.newSubsurface.registerListener( - [this](std::any d) { onNewSubsurface(std::any_cast>(d)); }); + m_listeners.newSubsurface = m_windowParent->m_wlSurface->resource()->m_events.newSubsurface.listen([this](const auto& resource) { onNewSubsurface(resource); }); else if (m_popupParent) - m_listeners.newSubsurface = m_popupParent->m_wlSurface->resource()->m_events.newSubsurface.registerListener( - [this](std::any d) { onNewSubsurface(std::any_cast>(d)); }); + m_listeners.newSubsurface = m_popupParent->m_wlSurface->resource()->m_events.newSubsurface.listen([this](const auto& resource) { onNewSubsurface(resource); }); else ASSERT(false); } diff --git a/src/desktop/WLSurface.cpp b/src/desktop/WLSurface.cpp index a7b9e620a..d1483db23 100644 --- a/src/desktop/WLSurface.cpp +++ b/src/desktop/WLSurface.cpp @@ -159,7 +159,7 @@ void CWLSurface::init() { 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); } diff --git a/src/desktop/WLSurface.hpp b/src/desktop/WLSurface.hpp index d0da546c5..3aed50461 100644 --- a/src/desktop/WLSurface.hpp +++ b/src/desktop/WLSurface.hpp @@ -91,7 +91,7 @@ class CWLSurface { CRegion m_visibleRegion; struct { - CSignal destroy; + CSignalT<> destroy; } m_events; WP m_self; diff --git a/src/desktop/Window.cpp b/src/desktop/Window.cpp index a7b0cdabb..8cdb5cebe 100644 --- a/src/desktop/Window.cpp +++ b/src/desktop/Window.cpp @@ -89,30 +89,30 @@ PHLWINDOW CWindow::create(SP resource) { CWindow::CWindow(SP resource) : m_xdgSurface(resource) { m_wlSurface = CWLSurface::create(); - m_listeners.map = m_xdgSurface->m_events.map.registerListener([this](std::any d) { Events::listener_mapWindow(this, nullptr); }); - m_listeners.ack = m_xdgSurface->m_events.ack.registerListener([this](std::any d) { onAck(std::any_cast(d)); }); - m_listeners.unmap = m_xdgSurface->m_events.unmap.registerListener([this](std::any d) { 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.commit = m_xdgSurface->m_events.commit.registerListener([this](std::any d) { Events::listener_commitWindow(this, nullptr); }); - m_listeners.updateState = m_xdgSurface->m_toplevel->m_events.stateChanged.registerListener([this](std::any d) { onUpdateState(); }); - m_listeners.updateMetadata = m_xdgSurface->m_toplevel->m_events.metadataChanged.registerListener([this](std::any d) { onUpdateMeta(); }); + m_listeners.map = m_xdgSurface->m_events.map.listen([this] { Events::listener_mapWindow(this, nullptr); }); + m_listeners.ack = m_xdgSurface->m_events.ack.listen([this](uint32_t d) { onAck(d); }); + m_listeners.unmap = m_xdgSurface->m_events.unmap.listen([this] { Events::listener_unmapWindow(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.listen([this] { Events::listener_commitWindow(this, nullptr); }); + m_listeners.updateState = m_xdgSurface->m_toplevel->m_events.stateChanged.listen([this] { onUpdateState(); }); + m_listeners.updateMetadata = m_xdgSurface->m_toplevel->m_events.metadataChanged.listen([this] { onUpdateMeta(); }); } CWindow::CWindow(SP surface) : m_xwaylandSurface(surface) { m_wlSurface = CWLSurface::create(); - m_listeners.map = m_xwaylandSurface->m_events.map.registerListener([this](std::any d) { 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.destroy = m_xwaylandSurface->m_events.destroy.registerListener([this](std::any d) { 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.configureRequest = m_xwaylandSurface->m_events.configureRequest.registerListener([this](std::any d) { onX11ConfigureRequest(std::any_cast(d)); }); - m_listeners.updateState = m_xwaylandSurface->m_events.stateChanged.registerListener([this](std::any d) { onUpdateState(); }); - m_listeners.updateMetadata = m_xwaylandSurface->m_events.metadataChanged.registerListener([this](std::any d) { onUpdateMeta(); }); - m_listeners.resourceChange = m_xwaylandSurface->m_events.resourceChange.registerListener([this](std::any d) { onResourceChangeX11(); }); - m_listeners.activate = m_xwaylandSurface->m_events.activate.registerListener([this](std::any d) { Events::listener_activateX11(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.listen([this] { Events::listener_unmapWindow(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.listen([this] { Events::listener_commitWindow(this, nullptr); }); + m_listeners.configureRequest = m_xwaylandSurface->m_events.configureRequest.listen([this](const CBox& box) { onX11ConfigureRequest(box); }); + m_listeners.updateState = m_xwaylandSurface->m_events.stateChanged.listen([this] { onUpdateState(); }); + m_listeners.updateMetadata = m_xwaylandSurface->m_events.metadataChanged.listen([this] { onUpdateMeta(); }); + m_listeners.resourceChange = m_xwaylandSurface->m_events.resourceChange.listen([this] { onResourceChangeX11(); }); + m_listeners.activate = m_xwaylandSurface->m_events.activate.listen([this] { Events::listener_activateX11(this, nullptr); }); 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() { diff --git a/src/desktop/Window.hpp b/src/desktop/Window.hpp index 3f73c468f..1c4d3c67f 100644 --- a/src/desktop/Window.hpp +++ b/src/desktop/Window.hpp @@ -148,7 +148,7 @@ class CWindow { SP m_wlSurface; struct { - CSignal destroy; + CSignalT<> destroy; } m_events; WP m_xdgSurface; diff --git a/src/desktop/Workspace.cpp b/src/desktop/Workspace.cpp index 1e5fbfa6f..b6320f052 100644 --- a/src/desktop/Workspace.cpp +++ b/src/desktop/Workspace.cpp @@ -644,7 +644,7 @@ void CWorkspace::rename(const std::string& name) { g_pCompositor->ensurePersistentWorkspacesPresent(std::vector{WORKSPACERULE}, m_self.lock()); g_pEventManager->postEvent({.event = "renameworkspace", .data = std::to_string(m_id) + "," + m_name}); - m_events.rename.emit(); + m_events.renamed.emit(); } void CWorkspace::updateWindows() { diff --git a/src/desktop/Workspace.hpp b/src/desktop/Workspace.hpp index 5bf384894..fa23966b5 100644 --- a/src/desktop/Workspace.hpp +++ b/src/desktop/Workspace.hpp @@ -85,10 +85,10 @@ class CWorkspace { void updateWindows(); struct { - CSignal destroy; - CSignal rename; - CSignal monitorChange; - CSignal activeChange; + CSignalT<> destroy; + CSignalT<> renamed; + CSignalT<> monitorChanged; + CSignalT<> activeChanged; } m_events; private: diff --git a/src/devices/IHID.hpp b/src/devices/IHID.hpp index 4de5abe65..c57778ffb 100644 --- a/src/devices/IHID.hpp +++ b/src/devices/IHID.hpp @@ -33,9 +33,9 @@ class IHID { virtual eHIDType getType(); struct { - CSignal destroy; + CSignalT<> destroy; } m_events; std::string m_deviceName; std::string m_hlName; -}; \ No newline at end of file +}; diff --git a/src/devices/IKeyboard.hpp b/src/devices/IKeyboard.hpp index c66aee271..25a7efd13 100644 --- a/src/devices/IKeyboard.hpp +++ b/src/devices/IKeyboard.hpp @@ -48,10 +48,10 @@ class IKeyboard : public IHID { }; struct { - CSignal key; - CSignal modifiers; - CSignal keymap; - CSignal repeatInfo; + CSignalT key; + CSignalT modifiers; + CSignalT keymap; + CSignalT<> repeatInfo; } m_keyboardEvents; struct SStringRuleNames { diff --git a/src/devices/IPointer.hpp b/src/devices/IPointer.hpp index 993095e00..e5d76344c 100644 --- a/src/devices/IPointer.hpp +++ b/src/devices/IPointer.hpp @@ -90,22 +90,22 @@ class IPointer : public IHID { }; struct { - CSignal motion; - CSignal motionAbsolute; - CSignal button; - CSignal axis; - CSignal frame; + CSignalT motion; + CSignalT motionAbsolute; + CSignalT button; + CSignalT axis; + CSignalT<> frame; - CSignal swipeBegin; - CSignal swipeEnd; - CSignal swipeUpdate; + CSignalT swipeBegin; + CSignalT swipeEnd; + CSignalT swipeUpdate; - CSignal pinchBegin; - CSignal pinchEnd; - CSignal pinchUpdate; + CSignalT pinchBegin; + CSignalT pinchEnd; + CSignalT pinchUpdate; - CSignal holdBegin; - CSignal holdEnd; + CSignalT holdBegin; + CSignalT holdEnd; } m_pointerEvents; bool m_connected = false; // means connected to the cursor diff --git a/src/devices/ITouch.hpp b/src/devices/ITouch.hpp index e52303946..148030117 100644 --- a/src/devices/ITouch.hpp +++ b/src/devices/ITouch.hpp @@ -37,14 +37,14 @@ class ITouch : public IHID { }; struct { - CSignal down; - CSignal up; - CSignal motion; - CSignal cancel; - CSignal frame; + CSignalT down; + CSignalT up; + CSignalT motion; + CSignalT cancel; + CSignalT<> frame; } m_touchEvents; std::string m_boundOutput = ""; WP m_self; -}; \ No newline at end of file +}; diff --git a/src/devices/Keyboard.cpp b/src/devices/Keyboard.cpp index 70abe54d6..9ce37e6b4 100644 --- a/src/devices/Keyboard.cpp +++ b/src/devices/Keyboard.cpp @@ -23,24 +23,22 @@ CKeyboard::CKeyboard(SP keeb) : m_keyboard(keeb) { if (!keeb) return; - m_listeners.destroy = keeb->events.destroy.registerListener([this](std::any d) { + m_listeners.destroy = keeb->events.destroy.listen([this] { m_keyboard.reset(); m_events.destroy.emit(); }); - m_listeners.key = keeb->events.key.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.key = keeb->events.key.listen([this](const Aquamarine::IKeyboard::SKeyEvent& event) { m_keyboardEvents.key.emit(SKeyEvent{ - .timeMs = E.timeMs, - .keycode = E.key, - .state = E.pressed ? WL_KEYBOARD_KEY_STATE_PRESSED : WL_KEYBOARD_KEY_STATE_RELEASED, + .timeMs = event.timeMs, + .keycode = event.key, + .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(); m_keyboardEvents.modifiers.emit(SModifiersEvent{ diff --git a/src/devices/Mouse.cpp b/src/devices/Mouse.cpp index 539aecf7e..b9cf9ffc6 100644 --- a/src/devices/Mouse.cpp +++ b/src/devices/Mouse.cpp @@ -19,133 +19,109 @@ CMouse::CMouse(SP mouse_) : m_mouse(mouse_) { 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_events.destroy.emit(); }); - m_listeners.motion = m_mouse->events.move.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.motion = m_mouse->events.move.listen([this](const Aquamarine::IPointer::SMoveEvent& event) { m_pointerEvents.motion.emit(SMotionEvent{ - .timeMs = E.timeMs, - .delta = E.delta, - .unaccel = E.unaccel, + .timeMs = event.timeMs, + .delta = event.delta, + .unaccel = event.unaccel, .mouse = true, .device = m_self.lock(), }); }); - m_listeners.motionAbsolute = m_mouse->events.warp.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.motionAbsolute = m_mouse->events.warp.listen([this](const Aquamarine::IPointer::SWarpEvent& event) { m_pointerEvents.motionAbsolute.emit(SMotionAbsoluteEvent{ - .timeMs = E.timeMs, - .absolute = E.absolute, + .timeMs = event.timeMs, + .absolute = event.absolute, .device = m_self.lock(), }); }); - m_listeners.button = m_mouse->events.button.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.button = m_mouse->events.button.listen([this](const Aquamarine::IPointer::SButtonEvent& event) { m_pointerEvents.button.emit(SButtonEvent{ - .timeMs = E.timeMs, - .button = E.button, - .state = E.pressed ? WL_POINTER_BUTTON_STATE_PRESSED : WL_POINTER_BUTTON_STATE_RELEASED, + .timeMs = event.timeMs, + .button = event.button, + .state = event.pressed ? WL_POINTER_BUTTON_STATE_PRESSED : WL_POINTER_BUTTON_STATE_RELEASED, .mouse = true, }); }); - m_listeners.axis = m_mouse->events.axis.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.axis = m_mouse->events.axis.listen([this](const Aquamarine::IPointer::SAxisEvent& event) { m_pointerEvents.axis.emit(SAxisEvent{ - .timeMs = E.timeMs, - .source = (wl_pointer_axis_source)E.source, - .axis = (wl_pointer_axis)E.axis, - .relativeDirection = (wl_pointer_axis_relative_direction)E.direction, - .delta = E.delta, - .deltaDiscrete = E.discrete, + .timeMs = event.timeMs, + .source = (wl_pointer_axis_source)event.source, + .axis = (wl_pointer_axis)event.axis, + .relativeDirection = (wl_pointer_axis_relative_direction)event.direction, + .delta = event.delta, + .deltaDiscrete = event.discrete, .mouse = true, }); }); - m_listeners.frame = m_mouse->events.frame.registerListener([this](std::any d) { m_pointerEvents.frame.emit(); }); - - m_listeners.swipeBegin = m_mouse->events.swipeBegin.registerListener([this](std::any d) { - auto E = std::any_cast(d); + m_listeners.frame = m_mouse->events.frame.listen([this] { m_pointerEvents.frame.emit(); }); + m_listeners.swipeBegin = m_mouse->events.swipeBegin.listen([this](const Aquamarine::IPointer::SSwipeBeginEvent& event) { m_pointerEvents.swipeBegin.emit(SSwipeBeginEvent{ - .timeMs = E.timeMs, - .fingers = E.fingers, + .timeMs = event.timeMs, + .fingers = event.fingers, }); }); - m_listeners.swipeEnd = m_mouse->events.swipeEnd.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.swipeEnd = m_mouse->events.swipeEnd.listen([this](const Aquamarine::IPointer::SSwipeEndEvent& event) { m_pointerEvents.swipeEnd.emit(SSwipeEndEvent{ - .timeMs = E.timeMs, - .cancelled = E.cancelled, + .timeMs = event.timeMs, + .cancelled = event.cancelled, }); }); - m_listeners.swipeUpdate = m_mouse->events.swipeUpdate.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.swipeUpdate = m_mouse->events.swipeUpdate.listen([this](const Aquamarine::IPointer::SSwipeUpdateEvent& event) { m_pointerEvents.swipeUpdate.emit(SSwipeUpdateEvent{ - .timeMs = E.timeMs, - .fingers = E.fingers, - .delta = E.delta, + .timeMs = event.timeMs, + .fingers = event.fingers, + .delta = event.delta, }); }); - m_listeners.pinchBegin = m_mouse->events.pinchBegin.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.pinchBegin = m_mouse->events.pinchBegin.listen([this](const Aquamarine::IPointer::SPinchBeginEvent& event) { m_pointerEvents.pinchBegin.emit(SPinchBeginEvent{ - .timeMs = E.timeMs, - .fingers = E.fingers, + .timeMs = event.timeMs, + .fingers = event.fingers, }); }); - m_listeners.pinchEnd = m_mouse->events.pinchEnd.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.pinchEnd = m_mouse->events.pinchEnd.listen([this](const Aquamarine::IPointer::SPinchEndEvent& event) { m_pointerEvents.pinchEnd.emit(SPinchEndEvent{ - .timeMs = E.timeMs, - .cancelled = E.cancelled, + .timeMs = event.timeMs, + .cancelled = event.cancelled, }); }); - m_listeners.pinchUpdate = m_mouse->events.pinchUpdate.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.pinchUpdate = m_mouse->events.pinchUpdate.listen([this](const Aquamarine::IPointer::SPinchUpdateEvent& event) { m_pointerEvents.pinchUpdate.emit(SPinchUpdateEvent{ - .timeMs = E.timeMs, - .fingers = E.fingers, - .delta = E.delta, - .scale = E.scale, - .rotation = E.rotation, + .timeMs = event.timeMs, + .fingers = event.fingers, + .delta = event.delta, + .scale = event.scale, + .rotation = event.rotation, }); }); - m_listeners.holdBegin = m_mouse->events.holdBegin.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.holdBegin = m_mouse->events.holdBegin.listen([this](const Aquamarine::IPointer::SHoldBeginEvent& event) { m_pointerEvents.holdBegin.emit(SHoldBeginEvent{ - .timeMs = E.timeMs, - .fingers = E.fingers, + .timeMs = event.timeMs, + .fingers = event.fingers, }); }); - m_listeners.holdEnd = m_mouse->events.holdEnd.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.holdEnd = m_mouse->events.holdEnd.listen([this](const Aquamarine::IPointer::SHoldEndEvent& event) { m_pointerEvents.holdEnd.emit(SHoldEndEvent{ - .timeMs = E.timeMs, - .cancelled = E.cancelled, + .timeMs = event.timeMs, + .cancelled = event.cancelled, }); }); diff --git a/src/devices/Tablet.cpp b/src/devices/Tablet.cpp index faeb3d738..cbda1a716 100644 --- a/src/devices/Tablet.cpp +++ b/src/devices/Tablet.cpp @@ -69,63 +69,55 @@ CTablet::CTablet(SP tablet_) : m_tablet(tablet_) { if (!m_tablet) 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_events.destroy.emit(); }); - m_listeners.axis = m_tablet->events.axis.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.axis = m_tablet->events.axis.listen([this](const Aquamarine::ITablet::SAxisEvent& event) { m_tabletEvents.axis.emit(SAxisEvent{ - .tool = E.tool, + .tool = event.tool, .tablet = m_self.lock(), - .timeMs = E.timeMs, - .updatedAxes = aqUpdateToHl(E.updatedAxes), - .axis = E.absolute, - .axisDelta = E.delta, - .tilt = E.tilt, - .pressure = E.pressure, - .distance = E.distance, - .rotation = E.rotation, - .slider = E.slider, - .wheelDelta = E.wheelDelta, + .timeMs = event.timeMs, + .updatedAxes = aqUpdateToHl(event.updatedAxes), + .axis = event.absolute, + .axisDelta = event.delta, + .tilt = event.tilt, + .pressure = event.pressure, + .distance = event.distance, + .rotation = event.rotation, + .slider = event.slider, + .wheelDelta = event.wheelDelta, }); }); - m_listeners.proximity = m_tablet->events.proximity.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.proximity = m_tablet->events.proximity.listen([this](const Aquamarine::ITablet::SProximityEvent& event) { m_tabletEvents.proximity.emit(SProximityEvent{ - .tool = E.tool, + .tool = event.tool, .tablet = m_self.lock(), - .timeMs = E.timeMs, - .proximity = E.absolute, - .in = E.in, + .timeMs = event.timeMs, + .proximity = event.absolute, + .in = event.in, }); }); - m_listeners.tip = m_tablet->events.tip.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.tip = m_tablet->events.tip.listen([this](const Aquamarine::ITablet::STipEvent& event) { m_tabletEvents.tip.emit(STipEvent{ - .tool = E.tool, + .tool = event.tool, .tablet = m_self.lock(), - .timeMs = E.timeMs, - .tip = E.absolute, - .in = E.down, + .timeMs = event.timeMs, + .tip = event.absolute, + .in = event.down, }); }); - m_listeners.button = m_tablet->events.button.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.button = m_tablet->events.button.listen([this](const Aquamarine::ITablet::SButtonEvent& event) { m_tabletEvents.button.emit(SButtonEvent{ - .tool = E.tool, + .tool = event.tool, .tablet = m_self.lock(), - .timeMs = E.timeMs, - .button = E.button, - .down = E.down, + .timeMs = event.timeMs, + .button = event.button, + .down = event.down, }); }); @@ -156,48 +148,42 @@ CTabletPad::CTabletPad(SP pad_) : m_pad(pad_) { if (!m_pad) 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_events.destroy.emit(); }); - m_listeners.button = m_pad->events.button.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.button = m_pad->events.button.listen([this](const Aquamarine::ITabletPad::SButtonEvent& event) { m_padEvents.button.emit(SButtonEvent{ - .timeMs = E.timeMs, - .button = E.button, - .down = E.down, - .mode = E.mode, - .group = E.group, + .timeMs = event.timeMs, + .button = event.button, + .down = event.down, + .mode = event.mode, + .group = event.group, }); }); - m_listeners.ring = m_pad->events.ring.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.ring = m_pad->events.ring.listen([this](const Aquamarine::ITabletPad::SRingEvent& event) { m_padEvents.ring.emit(SRingEvent{ - .timeMs = E.timeMs, - .finger = E.source == Aquamarine::ITabletPad::AQ_TABLET_PAD_RING_SOURCE_FINGER, - .ring = E.ring, - .position = E.pos, - .mode = E.mode, + .timeMs = event.timeMs, + .finger = event.source == Aquamarine::ITabletPad::AQ_TABLET_PAD_RING_SOURCE_FINGER, + .ring = event.ring, + .position = event.pos, + .mode = event.mode, }); }); - m_listeners.strip = m_pad->events.strip.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.strip = m_pad->events.strip.listen([this](const Aquamarine::ITabletPad::SStripEvent& event) { m_padEvents.strip.emit(SStripEvent{ - .timeMs = E.timeMs, - .finger = E.source == Aquamarine::ITabletPad::AQ_TABLET_PAD_STRIP_SOURCE_FINGER, - .strip = E.strip, - .position = E.pos, - .mode = E.mode, + .timeMs = event.timeMs, + .finger = event.source == Aquamarine::ITabletPad::AQ_TABLET_PAD_STRIP_SOURCE_FINGER, + .strip = event.strip, + .position = event.pos, + .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 }); @@ -224,7 +210,7 @@ CTabletTool::CTabletTool(SP tool_) : m_tool(tool_) { if (!m_tool) 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_events.destroy.emit(); }); @@ -265,7 +251,7 @@ void CTabletTool::setSurface(SP surf) { m_surface = 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()); m_surface.reset(); m_listeners.destroySurface.reset(); diff --git a/src/devices/Tablet.hpp b/src/devices/Tablet.hpp index b98c7f85f..b5e55c19c 100644 --- a/src/devices/Tablet.hpp +++ b/src/devices/Tablet.hpp @@ -82,10 +82,10 @@ class CTablet : public IHID { }; struct { - CSignal axis; - CSignal proximity; - CSignal tip; - CSignal button; + CSignalT axis; + CSignalT proximity; + CSignalT tip; + CSignalT button; } m_tabletEvents; WP m_self; @@ -144,10 +144,10 @@ class CTabletPad : public IHID { }; struct { - CSignal button; - CSignal ring; - CSignal strip; - CSignal attach; + CSignalT button; + CSignalT ring; + CSignalT strip; + CSignalT> attach; } m_padEvents; WP m_self; @@ -217,4 +217,4 @@ class CTabletTool : public IHID { CHyprSignalListener destroySurface; CHyprSignalListener destroyTool; } m_listeners; -}; \ No newline at end of file +}; diff --git a/src/devices/TouchDevice.cpp b/src/devices/TouchDevice.cpp index c2ff4d6f0..527cb02a2 100644 --- a/src/devices/TouchDevice.cpp +++ b/src/devices/TouchDevice.cpp @@ -14,51 +14,43 @@ CTouchDevice::CTouchDevice(SP touch_) : m_touch(touch_) { if (!m_touch) 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_touch.reset(); }); - m_listeners.down = m_touch->events.down.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.down = m_touch->events.down.listen([this](const Aquamarine::ITouch::SDownEvent& event) { m_touchEvents.down.emit(SDownEvent{ - .timeMs = E.timeMs, - .touchID = E.touchID, - .pos = E.pos, + .timeMs = event.timeMs, + .touchID = event.touchID, + .pos = event.pos, .device = m_self.lock(), }); }); - m_listeners.up = m_touch->events.up.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.up = m_touch->events.up.listen([this](const Aquamarine::ITouch::SUpEvent& event) { m_touchEvents.up.emit(SUpEvent{ - .timeMs = E.timeMs, - .touchID = E.touchID, + .timeMs = event.timeMs, + .touchID = event.touchID, }); }); - m_listeners.motion = m_touch->events.move.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.motion = m_touch->events.move.listen([this](const Aquamarine::ITouch::SMotionEvent& event) { m_touchEvents.motion.emit(SMotionEvent{ - .timeMs = E.timeMs, - .touchID = E.touchID, - .pos = E.pos, + .timeMs = event.timeMs, + .touchID = event.touchID, + .pos = event.pos, }); }); - m_listeners.cancel = m_touch->events.cancel.registerListener([this](std::any d) { - auto E = std::any_cast(d); - + m_listeners.cancel = m_touch->events.cancel.listen([this](const Aquamarine::ITouch::SCancelEvent& event) { m_touchEvents.cancel.emit(SCancelEvent{ - .timeMs = E.timeMs, - .touchID = E.touchID, + .timeMs = event.timeMs, + .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(); } diff --git a/src/devices/VirtualKeyboard.cpp b/src/devices/VirtualKeyboard.cpp index 9952847a8..ea21a22b7 100644 --- a/src/devices/VirtualKeyboard.cpp +++ b/src/devices/VirtualKeyboard.cpp @@ -14,15 +14,14 @@ CVirtualKeyboard::CVirtualKeyboard(SP keeb_) : m_key if (!keeb_) 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_events.destroy.emit(); }); - m_listeners.key = keeb_->m_events.key.registerListener([this](std::any d) { m_keyboardEvents.key.emit(d); }); - m_listeners.modifiers = keeb_->m_events.modifiers.registerListener([this](std::any d) { - auto E = std::any_cast(d); - updateModifiers(E.depressed, E.latched, E.locked, E.group); + m_listeners.key = keeb_->m_events.key.listen([this](const auto& event) { m_keyboardEvents.key.emit(event); }); + m_listeners.modifiers = keeb_->m_events.modifiers.listen([this](const SModifiersEvent& event) { + updateModifiers(event.depressed, event.latched, event.locked, event.group); m_keyboardEvents.modifiers.emit(SModifiersEvent{ .depressed = m_modifiersState.depressed, .latched = m_modifiersState.latched, @@ -30,15 +29,14 @@ CVirtualKeyboard::CVirtualKeyboard(SP keeb_) : m_key .group = m_modifiersState.group, }); }); - m_listeners.keymap = keeb_->m_events.keymap.registerListener([this](std::any d) { - auto E = std::any_cast(d); + m_listeners.keymap = keeb_->m_events.keymap.listen([this](const SKeymapEvent& event) { if (m_xkbKeymap) xkb_keymap_unref(m_xkbKeymap); - m_xkbKeymap = xkb_keymap_ref(E.keymap); + m_xkbKeymap = xkb_keymap_ref(event.keymap); m_keymapOverridden = true; updateXKBTranslationState(m_xkbKeymap); updateKeymapFD(); - m_keyboardEvents.keymap.emit(d); + m_keyboardEvents.keymap.emit(event); }); m_deviceName = keeb_->m_name; diff --git a/src/devices/VirtualPointer.cpp b/src/devices/VirtualPointer.cpp index 2b42b21cf..23d860bfa 100644 --- a/src/devices/VirtualPointer.cpp +++ b/src/devices/VirtualPointer.cpp @@ -14,33 +14,31 @@ CVirtualPointer::CVirtualPointer(SP resource) : m_poi if UNLIKELY (!resource->good()) 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_events.destroy.emit(); }); - m_listeners.motion = m_pointer->m_events.move.registerListener([this](std::any d) { - auto E = std::any_cast(d); - E.device = m_self.lock(); - m_pointerEvents.motion.emit(E); + m_listeners.motion = m_pointer->m_events.move.listen([this](SMotionEvent event) { + event.device = m_self.lock(); + m_pointerEvents.motion.emit(event); }); - 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 - auto E = std::any_cast(d); - E.device = m_self.lock(); - m_pointerEvents.motionAbsolute.emit(E); + event.device = m_self.lock(); + m_pointerEvents.motionAbsolute.emit(event); }); - m_listeners.button = m_pointer->m_events.button.registerListener([this](std::any d) { m_pointerEvents.button.emit(d); }); - m_listeners.axis = m_pointer->m_events.axis.registerListener([this](std::any d) { m_pointerEvents.axis.emit(d); }); - m_listeners.frame = m_pointer->m_events.frame.registerListener([this](std::any d) { m_pointerEvents.frame.emit(); }); - m_listeners.swipeBegin = m_pointer->m_events.swipeBegin.registerListener([this](std::any d) { m_pointerEvents.swipeBegin.emit(d); }); - m_listeners.swipeEnd = m_pointer->m_events.swipeEnd.registerListener([this](std::any d) { m_pointerEvents.swipeEnd.emit(d); }); - m_listeners.swipeUpdate = m_pointer->m_events.swipeUpdate.registerListener([this](std::any d) { m_pointerEvents.swipeUpdate.emit(d); }); - m_listeners.pinchBegin = m_pointer->m_events.pinchBegin.registerListener([this](std::any d) { m_pointerEvents.pinchBegin.emit(d); }); - m_listeners.pinchEnd = m_pointer->m_events.pinchEnd.registerListener([this](std::any d) { m_pointerEvents.pinchEnd.emit(d); }); - m_listeners.pinchUpdate = m_pointer->m_events.pinchUpdate.registerListener([this](std::any d) { m_pointerEvents.pinchUpdate.emit(d); }); - m_listeners.holdBegin = m_pointer->m_events.holdBegin.registerListener([this](std::any d) { m_pointerEvents.holdBegin.emit(d); }); - m_listeners.holdEnd = m_pointer->m_events.holdEnd.registerListener([this](std::any d) { m_pointerEvents.holdEnd.emit(d); }); + m_listeners.button = m_pointer->m_events.button.forward(m_pointerEvents.button); + m_listeners.axis = m_pointer->m_events.axis.forward(m_pointerEvents.axis); + m_listeners.frame = m_pointer->m_events.frame.forward(m_pointerEvents.frame); + m_listeners.swipeBegin = m_pointer->m_events.swipeBegin.forward(m_pointerEvents.swipeBegin); + m_listeners.swipeEnd = m_pointer->m_events.swipeEnd.forward(m_pointerEvents.swipeEnd); + m_listeners.swipeUpdate = m_pointer->m_events.swipeUpdate.forward(m_pointerEvents.swipeUpdate); + m_listeners.pinchBegin = m_pointer->m_events.pinchBegin.forward(m_pointerEvents.pinchBegin); + m_listeners.pinchEnd = m_pointer->m_events.pinchEnd.forward(m_pointerEvents.pinchEnd); + m_listeners.pinchUpdate = m_pointer->m_events.pinchUpdate.forward(m_pointerEvents.pinchUpdate); + m_listeners.holdBegin = m_pointer->m_events.holdBegin.forward(m_pointerEvents.holdBegin); + m_listeners.holdEnd = m_pointer->m_events.holdEnd.forward(m_pointerEvents.holdEnd); m_boundOutput = resource->m_boundOutput ? resource->m_boundOutput->m_name : ""; diff --git a/src/helpers/Monitor.cpp b/src/helpers/Monitor.cpp index e29d99637..7e75b02b3 100644 --- a/src/helpers/Monitor.cpp +++ b/src/helpers/Monitor.cpp @@ -68,20 +68,17 @@ void CMonitor::onConnect(bool noRule) { g_pEventLoopManager->doLater([] { g_pConfigManager->ensurePersistentWorkspacesPresent(); }); - m_listeners.frame = m_output->events.frame.registerListener([this](std::any d) { m_frameScheduler->onFrame(); }); - m_listeners.commit = m_output->events.commit.registerListener([this](std::any d) { + m_listeners.frame = m_output->events.frame.listen([this] { m_frameScheduler->onFrame(); }); + m_listeners.commit = m_output->events.commit.listen([this] { if (true) { // FIXME: E->state->committed & WLR_OUTPUT_STATE_BUFFER PROTO::screencopy->onOutputCommit(m_self.lock()); PROTO::toplevelExport->onOutputCommit(m_self.lock()); } }); - m_listeners.needsFrame = - m_output->events.needsFrame.registerListener([this](std::any d) { g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_NEEDS_FRAME); }); + m_listeners.needsFrame = m_output->events.needsFrame.listen([this] { g_pCompositor->scheduleFrameForMonitor(m_self.lock(), Aquamarine::IOutput::AQ_SCHEDULE_NEEDS_FRAME); }); - m_listeners.presented = m_output->events.present.registerListener([this](std::any d) { - auto E = std::any_cast(d); - - timespec* ts = E.when; + m_listeners.presented = m_output->events.present.listen([this](const Aquamarine::IOutput::SPresentEvent& event) { + timespec* ts = event.when; if (ts && ts->tv_sec <= 2) { // 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) - 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 - 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_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); onDisconnect(true); @@ -110,10 +107,8 @@ void CMonitor::onConnect(bool noRule) { 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) { - auto E = std::any_cast(d); - - if (E.size == Vector2D{}) { + m_listeners.state = m_output->events.state.listen([this](const Aquamarine::IOutput::SStateEvent& event) { + if (event.size == Vector2D{}) { // an indication to re-set state // we can't do much for createdByUser displays I think if (m_createdByUser) @@ -127,7 +122,7 @@ void CMonitor::onConnect(bool noRule) { if (!m_createdByUser) return; - const auto SIZE = E.size; + const auto SIZE = event.size; m_forceSize = SIZE; @@ -1034,7 +1029,7 @@ void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) { m_activeWorkspace = PNEWWORKSPACE; - PNEWWORKSPACE->m_events.activeChange.emit(); + PNEWWORKSPACE->m_events.activeChanged.emit(); PNEWWORKSPACE->m_visible = true; PNEWWORKSPACE->m_lastMonitor = ""; } @@ -1195,7 +1190,7 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo if (POLDWORKSPACE) { POLDWORKSPACE->m_visible = false; - POLDWORKSPACE->m_events.activeChange.emit(); + POLDWORKSPACE->m_events.activeChanged.emit(); } pWorkspace->m_visible = true; @@ -1241,7 +1236,7 @@ void CMonitor::changeWorkspace(const PHLWORKSPACE& pWorkspace, bool internal, bo EMIT_HOOK_EVENT("workspace", pWorkspace); } - pWorkspace->m_events.activeChange.emit(); + pWorkspace->m_events.activeChanged.emit(); g_pHyprRenderer->damageMonitor(m_self.lock()); @@ -1281,7 +1276,7 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) { m_activeSpecialWorkspace.reset(); if (POLDSPECIAL) - POLDSPECIAL->m_events.activeChange.emit(); + POLDSPECIAL->m_events.activeChanged.emit(); g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m_id); @@ -1327,13 +1322,13 @@ void CMonitor::setSpecialWorkspace(const PHLWORKSPACE& pWorkspace) { m_activeSpecialWorkspace->m_visible = true; if (POLDSPECIAL) - POLDSPECIAL->m_events.activeChange.emit(); + POLDSPECIAL->m_events.activeChanged.emit(); if (PMONITORWORKSPACEOWNER != m_self) - pWorkspace->m_events.monitorChange.emit(); + pWorkspace->m_events.monitorChanged.emit(); if (!wasActive) - pWorkspace->m_events.activeChange.emit(); + pWorkspace->m_events.activeChanged.emit(); if (!wasActive) pWorkspace->startAnim(true, true); diff --git a/src/helpers/Monitor.hpp b/src/helpers/Monitor.hpp index 1cde19f17..86ab8b765 100644 --- a/src/helpers/Monitor.hpp +++ b/src/helpers/Monitor.hpp @@ -194,11 +194,11 @@ class CMonitor { } m_tearingState; struct { - CSignal destroy; - CSignal connect; - CSignal disconnect; - CSignal dpmsChanged; - CSignal modeChanged; + CSignalT<> destroy; + CSignalT<> connect; + CSignalT<> disconnect; + CSignalT<> dpmsChanged; + CSignalT<> modeChanged; } m_events; std::array, 4> m_layerSurfaceLayers; diff --git a/src/managers/PointerManager.cpp b/src/managers/PointerManager.cpp index e4455486c..f6b08f1b5 100644 --- a/src/managers/PointerManager.cpp +++ b/src/managers/PointerManager.cpp @@ -29,14 +29,12 @@ CPointerManager::CPointerManager() { onMonitorLayoutChange(); - PMONITOR->m_events.modeChanged.registerStaticListener([this](void* owner, std::any data) { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); }, nullptr); - PMONITOR->m_events.disconnect.registerStaticListener([this](void* owner, std::any data) { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); }, nullptr); - PMONITOR->m_events.destroy.registerStaticListener( - [this](void* owner, std::any data) { - if (g_pCompositor && !g_pCompositor->m_isShuttingDown) - std::erase_if(m_monitorStates, [](const auto& other) { return other->monitor.expired(); }); - }, - nullptr); + PMONITOR->m_events.modeChanged.listenStatic([this] { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); }); + PMONITOR->m_events.disconnect.listenStatic([this] { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); }); + PMONITOR->m_events.destroy.listenStatic([this] { + if (g_pCompositor && !g_pCompositor->m_isShuttingDown) + std::erase_if(m_monitorStates, [](const auto& other) { return other->monitor.expired(); }); + }); }); m_hooks.monitorPreRender = g_pHookSystem->hookDynamic("preMonitorCommit", [this](void* self, SCallbackInfo& info, std::any data) { @@ -149,8 +147,8 @@ void CPointerManager::setCursorSurface(SP surf, const Vector2D& hots surf->resource()->map(); - m_currentCursorImage.destroySurface = surf->m_events.destroy.registerListener([this](std::any data) { resetCursorImage(); }); - m_currentCursorImage.commitSurface = surf->resource()->m_events.commit.registerListener([this](std::any data) { + m_currentCursorImage.destroySurface = surf->m_events.destroy.listen([this] { resetCursorImage(); }); + m_currentCursorImage.commitSurface = surf->resource()->m_events.commit.listen([this] { damageIfSoftware(); 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; @@ -898,15 +896,9 @@ void CPointerManager::attachPointer(SP pointer) { listener->pointer = pointer; - // clang-format off - listener->destroy = pointer->m_events.destroy.registerListener([this] (std::any d) { - detachPointer(nullptr); - }); - - listener->motion = pointer->m_pointerEvents.motion.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - g_pInputManager->onMouseMoved(E); + listener->destroy = pointer->m_events.destroy.listen([this] { detachPointer(nullptr); }); + listener->motion = pointer->m_pointerEvents.motion.listen([](const IPointer::SMotionEvent& event) { + g_pInputManager->onMouseMoved(event); PROTO::idle->onActivity(); @@ -914,10 +906,8 @@ void CPointerManager::attachPointer(SP pointer) { g_pKeybindManager->dpms("on"); }); - listener->motionAbsolute = pointer->m_pointerEvents.motionAbsolute.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - g_pInputManager->onMouseWarp(E); + listener->motionAbsolute = pointer->m_pointerEvents.motionAbsolute.listen([](const IPointer::SMotionAbsoluteEvent& event) { + g_pInputManager->onMouseWarp(event); PROTO::idle->onActivity(); @@ -925,37 +915,29 @@ void CPointerManager::attachPointer(SP pointer) { g_pKeybindManager->dpms("on"); }); - listener->button = pointer->m_pointerEvents.button.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - g_pInputManager->onMouseButton(E); - + listener->button = pointer->m_pointerEvents.button.listen([](const IPointer::SButtonEvent& event) { + g_pInputManager->onMouseButton(event); PROTO::idle->onActivity(); }); - listener->axis = pointer->m_pointerEvents.axis.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - g_pInputManager->onMouseWheel(E); - + listener->axis = pointer->m_pointerEvents.axis.listen([](const IPointer::SAxisEvent& event) { + g_pInputManager->onMouseWheel(event); PROTO::idle->onActivity(); }); - listener->frame = pointer->m_pointerEvents.frame.registerListener([] (std::any e) { + listener->frame = pointer->m_pointerEvents.frame.listen([] { bool shouldSkip = false; if (!g_pSeatManager->m_mouse.expired() && g_pInputManager->isLocked()) { auto PMONITOR = g_pCompositor->m_lastMonitor.get(); - shouldSkip = PMONITOR && PMONITOR->shouldSkipScheduleFrameOnMouseEvent(); + shouldSkip = PMONITOR && PMONITOR->shouldSkipScheduleFrameOnMouseEvent(); } g_pSeatManager->m_isPointerFrameSkipped = shouldSkip; if (!g_pSeatManager->m_isPointerFrameSkipped) g_pSeatManager->sendPointerFrame(); }); - listener->swipeBegin = pointer->m_pointerEvents.swipeBegin.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - g_pInputManager->onSwipeBegin(E); + listener->swipeBegin = pointer->m_pointerEvents.swipeBegin.listen([](const IPointer::SSwipeBeginEvent& event) { + g_pInputManager->onSwipeBegin(event); PROTO::idle->onActivity(); @@ -963,26 +945,18 @@ void CPointerManager::attachPointer(SP pointer) { g_pKeybindManager->dpms("on"); }); - listener->swipeEnd = pointer->m_pointerEvents.swipeEnd.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - g_pInputManager->onSwipeEnd(E); - + listener->swipeEnd = pointer->m_pointerEvents.swipeEnd.listen([](const IPointer::SSwipeEndEvent& event) { + g_pInputManager->onSwipeEnd(event); PROTO::idle->onActivity(); }); - listener->swipeUpdate = pointer->m_pointerEvents.swipeUpdate.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - g_pInputManager->onSwipeUpdate(E); - + listener->swipeUpdate = pointer->m_pointerEvents.swipeUpdate.listen([](const IPointer::SSwipeUpdateEvent& event) { + g_pInputManager->onSwipeUpdate(event); PROTO::idle->onActivity(); }); - listener->pinchBegin = pointer->m_pointerEvents.pinchBegin.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - PROTO::pointerGestures->pinchBegin(E.timeMs, E.fingers); + listener->pinchBegin = pointer->m_pointerEvents.pinchBegin.listen([](const IPointer::SPinchBeginEvent& event) { + PROTO::pointerGestures->pinchBegin(event.timeMs, event.fingers); PROTO::idle->onActivity(); @@ -990,38 +964,25 @@ void CPointerManager::attachPointer(SP pointer) { g_pKeybindManager->dpms("on"); }); - listener->pinchEnd = pointer->m_pointerEvents.pinchEnd.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - PROTO::pointerGestures->pinchEnd(E.timeMs, E.cancelled); - + listener->pinchEnd = pointer->m_pointerEvents.pinchEnd.listen([](const IPointer::SPinchEndEvent& event) { + PROTO::pointerGestures->pinchEnd(event.timeMs, event.cancelled); PROTO::idle->onActivity(); }); - listener->pinchUpdate = pointer->m_pointerEvents.pinchUpdate.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - PROTO::pointerGestures->pinchUpdate(E.timeMs, E.delta, E.scale, E.rotation); - + listener->pinchUpdate = pointer->m_pointerEvents.pinchUpdate.listen([](const IPointer::SPinchUpdateEvent& event) { + PROTO::pointerGestures->pinchUpdate(event.timeMs, event.delta, event.scale, event.rotation); PROTO::idle->onActivity(); }); - listener->holdBegin = pointer->m_pointerEvents.holdBegin.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - PROTO::pointerGestures->holdBegin(E.timeMs, E.fingers); - + listener->holdBegin = pointer->m_pointerEvents.holdBegin.listen([](const IPointer::SHoldBeginEvent& event) { + PROTO::pointerGestures->holdBegin(event.timeMs, event.fingers); PROTO::idle->onActivity(); }); - listener->holdEnd = pointer->m_pointerEvents.holdEnd.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - PROTO::pointerGestures->holdEnd(E.timeMs, E.cancelled); - + listener->holdEnd = pointer->m_pointerEvents.holdEnd.listen([](const IPointer::SHoldEndEvent& event) { + PROTO::pointerGestures->holdEnd(event.timeMs, event.cancelled); PROTO::idle->onActivity(); }); - // clang-format on Debug::log(LOG, "Attached pointer {} to global", pointer->m_hlName); } @@ -1037,15 +998,10 @@ void CPointerManager::attachTouch(SP touch) { listener->touch = touch; - // clang-format off - listener->destroy = touch->m_events.destroy.registerListener([this] (std::any d) { - detachTouch(nullptr); - }); + listener->destroy = touch->m_events.destroy.listen([this] { detachTouch(nullptr); }); - listener->down = touch->m_touchEvents.down.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - g_pInputManager->onTouchDown(E); + listener->down = touch->m_touchEvents.down.listen([](const ITouch::SDownEvent& event) { + g_pInputManager->onTouchDown(event); PROTO::idle->onActivity(); @@ -1053,30 +1009,21 @@ void CPointerManager::attachTouch(SP touch) { g_pKeybindManager->dpms("on"); }); - listener->up = touch->m_touchEvents.up.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - g_pInputManager->onTouchUp(E); - + listener->up = touch->m_touchEvents.up.listen([](const ITouch::SUpEvent& event) { + g_pInputManager->onTouchUp(event); PROTO::idle->onActivity(); }); - listener->motion = touch->m_touchEvents.motion.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - g_pInputManager->onTouchMove(E); - + listener->motion = touch->m_touchEvents.motion.listen([](const ITouch::SMotionEvent& event) { + g_pInputManager->onTouchMove(event); 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) { - g_pSeatManager->sendTouchFrame(); - }); - // clang-format on + listener->frame = touch->m_touchEvents.frame.listen([] { g_pSeatManager->sendTouchFrame(); }); Debug::log(LOG, "Attached touch {} to global", touch->m_hlName); } @@ -1092,15 +1039,10 @@ void CPointerManager::attachTablet(SP tablet) { listener->tablet = tablet; - // clang-format off - listener->destroy = tablet->m_events.destroy.registerListener([this] (std::any d) { - detachTablet(nullptr); - }); + listener->destroy = tablet->m_events.destroy.listen([this] { detachTablet(nullptr); }); - listener->axis = tablet->m_tabletEvents.axis.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - g_pInputManager->onTabletAxis(E); + listener->axis = tablet->m_tabletEvents.axis.listen([](const CTablet::SAxisEvent& event) { + g_pInputManager->onTabletAxis(event); PROTO::idle->onActivity(); @@ -1108,18 +1050,13 @@ void CPointerManager::attachTablet(SP tablet) { g_pKeybindManager->dpms("on"); }); - listener->proximity = tablet->m_tabletEvents.proximity.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - g_pInputManager->onTabletProximity(E); - + listener->proximity = tablet->m_tabletEvents.proximity.listen([](const CTablet::SProximityEvent& event) { + g_pInputManager->onTabletProximity(event); PROTO::idle->onActivity(); }); - listener->tip = tablet->m_tabletEvents.tip.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - g_pInputManager->onTabletTip(E); + listener->tip = tablet->m_tabletEvents.tip.listen([](const CTablet::STipEvent& event) { + g_pInputManager->onTabletTip(event); PROTO::idle->onActivity(); @@ -1127,11 +1064,8 @@ void CPointerManager::attachTablet(SP tablet) { g_pKeybindManager->dpms("on"); }); - listener->button = tablet->m_tabletEvents.button.registerListener([] (std::any e) { - auto E = std::any_cast(e); - - g_pInputManager->onTabletButton(E); - + listener->button = tablet->m_tabletEvents.button.listen([](const CTablet::SButtonEvent& event) { + g_pInputManager->onTabletButton(event); PROTO::idle->onActivity(); }); // clang-format on diff --git a/src/managers/ProtocolManager.cpp b/src/managers/ProtocolManager.cpp index e39dcf4eb..193b022c1 100644 --- a/src/managers/ProtocolManager.cpp +++ b/src/managers/ProtocolManager.cpp @@ -122,7 +122,7 @@ CProtocolManager::CProtocolManager() { PROTO::outputs.emplace(M->m_name, 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) { diff --git a/src/managers/SeatManager.cpp b/src/managers/SeatManager.cpp index 9fe2b26b1..762172387 100644 --- a/src/managers/SeatManager.cpp +++ b/src/managers/SeatManager.cpp @@ -14,12 +14,12 @@ #include CSeatManager::CSeatManager() { - m_listeners.newSeatResource = PROTO::seat->m_events.newSeatResource.registerListener([this](std::any res) { onNewSeatResource(std::any_cast>(res)); }); + m_listeners.newSeatResource = PROTO::seat->m_events.newSeatResource.listen([this](const auto& resource) { onNewSeatResource(resource); }); } CSeatManager::SSeatResourceContainer::SSeatResourceContainer(SP res) : resource(res) { - listeners.destroy = res->m_events.destroy.registerListener( - [this](std::any data) { std::erase_if(g_pSeatManager->m_seatResources, [this](const auto& e) { return e->resource.expired() || e->resource == resource; }); }); + listeners.destroy = res->m_events.destroy.listen( + [this] { std::erase_if(g_pSeatManager->m_seatResources, [this](const auto& e) { return e->resource.expired() || e->resource == resource; }); }); } void CSeatManager::onNewSeatResource(SP resource) { @@ -151,7 +151,7 @@ void CSeatManager::setKeyboardFocus(SP 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(); } @@ -258,7 +258,7 @@ void CSeatManager::setPointerFocus(SP surf, const Vector2D& 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.dndPointerFocusChange.emit(); @@ -372,7 +372,7 @@ void CSeatManager::sendTouchDown(SP 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++; @@ -559,7 +559,7 @@ void CSeatManager::setCurrentSelection(SP source) { m_selection.currentSelection = 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::dataWlr->setSelection(source, false); } @@ -584,7 +584,7 @@ void CSeatManager::setCurrentPrimarySelection(SP source) { m_selection.currentPrimarySelection = 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::dataWlr->setSelection(source, true); } diff --git a/src/managers/SeatManager.hpp b/src/managers/SeatManager.hpp index 6310f0d26..2d73e0875 100644 --- a/src/managers/SeatManager.hpp +++ b/src/managers/SeatManager.hpp @@ -101,13 +101,13 @@ class CSeatManager { }; struct { - CSignal keyboardFocusChange; - CSignal pointerFocusChange; - CSignal dndPointerFocusChange; - CSignal touchFocusChange; - CSignal setCursor; // SSetCursorEvent - CSignal setSelection; - CSignal setPrimarySelection; + CSignalT<> keyboardFocusChange; + CSignalT<> pointerFocusChange; + CSignalT<> dndPointerFocusChange; + CSignalT<> touchFocusChange; + CSignalT setCursor; + CSignalT<> setSelection; + CSignalT<> setPrimarySelection; } m_events; struct { diff --git a/src/managers/SessionLockManager.cpp b/src/managers/SessionLockManager.cpp index f39acf234..bfd819cf7 100644 --- a/src/managers/SessionLockManager.cpp +++ b/src/managers/SessionLockManager.cpp @@ -12,7 +12,7 @@ SSessionLockSurface::SSessionLockSurface(SP surface_) : 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; g_pInputManager->simulateMouseMovement(); @@ -23,14 +23,14 @@ SSessionLockSurface::SSessionLockSurface(SP surface_) : sur 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) g_pCompositor->m_lastFocus.reset(); 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); if (mapped && !g_pCompositor->m_lastFocus) @@ -42,11 +42,10 @@ SSessionLockSurface::SSessionLockSurface(SP surface_) : sur } CSessionLockManager::CSessionLockManager() { - m_listeners.newLock = PROTO::sessionLock->m_events.newLock.registerListener([this](std::any data) { this->onNewSessionLock(std::any_cast>(data)); }); + m_listeners.newLock = PROTO::sessionLock->m_events.newLock.listen([this](const auto& lock) { this->onNewSessionLock(lock); }); } void CSessionLockManager::onNewSessionLock(SP pLock) { - static auto PALLOWRELOCK = CConfigValue("misc:allow_session_lock_restore"); if (PROTO::sessionLock->isLocked() && !*PALLOWRELOCK) { @@ -61,17 +60,15 @@ void CSessionLockManager::onNewSessionLock(SP pLock) { m_sessionLock->lock = pLock; m_sessionLock->mLockTimer.reset(); - m_sessionLock->listeners.newSurface = pLock->m_events.newLockSurface.registerListener([this](std::any data) { - auto SURFACE = std::any_cast>(data); + m_sessionLock->listeners.newSurface = pLock->m_events.newLockSurface.listen([this](const SP& surface) { + const auto PMONITOR = surface->monitor(); - const auto PMONITOR = SURFACE->monitor(); - - const auto NEWSURFACE = m_sessionLock->vSessionLockSurfaces.emplace_back(makeUnique(SURFACE)).get(); + const auto NEWSURFACE = m_sessionLock->vSessionLockSurfaces.emplace_back(makeUnique(surface)).get(); 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(); g_pInputManager->refocus(); @@ -79,7 +76,7 @@ void CSessionLockManager::onNewSessionLock(SP pLock) { 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(); g_pCompositor->focusSurface(nullptr); diff --git a/src/managers/eventLoop/EventLoopManager.cpp b/src/managers/eventLoop/EventLoopManager.cpp index 5b2e09d1a..357c2fff6 100644 --- a/src/managers/eventLoop/EventLoopManager.cpp +++ b/src/managers/eventLoop/EventLoopManager.cpp @@ -88,7 +88,7 @@ void CEventLoopManager::enterLoop() { m_configWatcherInotifySource = wl_event_loop_add_fd(m_wayland.loop, FD.get(), WL_EVENT_READABLE, configWatcherWrite, nullptr); 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 (g_pCompositor->m_aqBackend->hasSession()) diff --git a/src/managers/input/IdleInhibitor.cpp b/src/managers/input/IdleInhibitor.cpp index 258b35dcf..8c33956b9 100644 --- a/src/managers/input/IdleInhibitor.cpp +++ b/src/managers/input/IdleInhibitor.cpp @@ -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()); - 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; }); recheckIdleInhibitorStatus(); }); @@ -24,8 +24,8 @@ void CInputManager::newIdleInhibitor(std::any inhibitor) { return; } - PINHIBIT->surfaceDestroyListener = WLSurface->m_events.destroy.registerListener( - [this, PINHIBIT](std::any data) { std::erase_if(m_idleInhibitors, [PINHIBIT](const auto& other) { return other.get() == PINHIBIT; }); }); + PINHIBIT->surfaceDestroyListener = + WLSurface->m_events.destroy.listen([this, PINHIBIT] { std::erase_if(m_idleInhibitors, [PINHIBIT](const auto& other) { return other.get() == PINHIBIT; }); }); recheckIdleInhibitorStatus(); } diff --git a/src/managers/input/InputManager.cpp b/src/managers/input/InputManager.cpp index 434bd677d..4d5bcb28f 100644 --- a/src/managers/input/InputManager.cpp +++ b/src/managers/input/InputManager.cpp @@ -43,12 +43,10 @@ #include 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()) return; - auto event = std::any_cast(data); - if (!g_pSeatManager->m_state.pointerFocusResource) return; @@ -66,16 +64,16 @@ CInputManager::CInputManager() { g_pHyprRenderer->setCursorFromName(m_cursorSurfaceInfo.name); }); - m_listeners.newIdleInhibitor = PROTO::idleInhibit->m_events.newIdleInhibitor.registerListener([this](std::any data) { this->newIdleInhibitor(data); }); - m_listeners.newVirtualKeyboard = PROTO::virtualKeyboard->m_events.newKeyboard.registerListener([this](std::any data) { - this->newVirtualKeyboard(std::any_cast>(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.listen([this](const auto& keyboard) { + this->newVirtualKeyboard(keyboard); updateCapabilities(); }); - m_listeners.newVirtualMouse = PROTO::virtualPointer->m_events.newPointer.registerListener([this](std::any data) { - this->newVirtualMouse(std::any_cast>(data)); + m_listeners.newVirtualMouse = PROTO::virtualPointer->m_events.newPointer.listen([this](const auto& mouse) { + this->newVirtualMouse(mouse); 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(); } @@ -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()) return; - auto e = std::any_cast(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 (e.surf != m_cursorSurfaceInfo.wlSurface->resource()) { + if (event.surf != m_cursorSurfaceInfo.wlSurface->resource()) { m_cursorSurfaceInfo.wlSurface->unassign(); - if (e.surf) - m_cursorSurfaceInfo.wlSurface->assign(e.surf); + if (event.surf) + m_cursorSurfaceInfo.wlSurface->assign(event.surf); } - if (e.surf) { - m_cursorSurfaceInfo.vHotspot = e.hotspot; + if (event.surf) { + m_cursorSurfaceInfo.vHotspot = event.hotspot; m_cursorSurfaceInfo.hidden = false; } else { m_cursorSurfaceInfo.vHotspot = {}; @@ -667,7 +663,7 @@ void CInputManager::processMouseRequest(std::any E) { m_cursorSurfaceInfo.name = ""; 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() { @@ -962,60 +958,52 @@ void CInputManager::setupKeyboard(SP keeb) { Debug::log(ERR, "Keyboard had no name???"); // logic error } - keeb->m_events.destroy.registerStaticListener( - [this](void* owner, std::any data) { - auto PKEEB = ((IKeyboard*)owner)->m_self.lock(); + keeb->m_events.destroy.listenStatic([this, keeb = keeb.get()] { + auto PKEEB = keeb->m_self.lock(); - if (!PKEEB) - return; + if (!PKEEB) + return; - destroyKeyboard(PKEEB); - Debug::log(LOG, "Destroyed keyboard {:x}", (uintptr_t)owner); - }, - keeb.get()); + destroyKeyboard(PKEEB); + Debug::log(LOG, "Destroyed keyboard {:x}", (uintptr_t)keeb); + }); - keeb->m_keyboardEvents.key.registerStaticListener( - [this](void* owner, std::any data) { - auto PKEEB = ((IKeyboard*)owner)->m_self.lock(); + keeb->m_keyboardEvents.key.listenStatic([this, keeb = keeb.get()](const IKeyboard::SKeyEvent& event) { + auto PKEEB = keeb->m_self.lock(); - onKeyboardKey(data, PKEEB); + onKeyboardKey(event, PKEEB); - if (PKEEB->m_enabled) - PROTO::idle->onActivity(); + if (PKEEB->m_enabled) + PROTO::idle->onActivity(); - if (PKEEB->m_enabled && *PDPMS && !g_pCompositor->m_dpmsStateOn) - g_pKeybindManager->dpms("on"); - }, - keeb.get()); + if (PKEEB->m_enabled && *PDPMS && !g_pCompositor->m_dpmsStateOn) + g_pKeybindManager->dpms("on"); + }); - keeb->m_keyboardEvents.modifiers.registerStaticListener( - [this](void* owner, std::any data) { - auto PKEEB = ((IKeyboard*)owner)->m_self.lock(); + keeb->m_keyboardEvents.modifiers.listenStatic([this, keeb = keeb.get()] { + auto PKEEB = keeb->m_self.lock(); - onKeyboardMod(PKEEB); + onKeyboardMod(PKEEB); - if (PKEEB->m_enabled) - PROTO::idle->onActivity(); + if (PKEEB->m_enabled) + PROTO::idle->onActivity(); - if (PKEEB->m_enabled && *PDPMS && !g_pCompositor->m_dpmsStateOn) - g_pKeybindManager->dpms("on"); - }, - keeb.get()); + if (PKEEB->m_enabled && *PDPMS && !g_pCompositor->m_dpmsStateOn) + g_pKeybindManager->dpms("on"); + }); - keeb->m_keyboardEvents.keymap.registerStaticListener( - [](void* owner, std::any data) { - auto PKEEB = ((IKeyboard*)owner)->m_self.lock(); - const auto LAYOUT = PKEEB->getActiveLayout(); + keeb->m_keyboardEvents.keymap.listenStatic([keeb = keeb.get()] { + auto PKEEB = keeb->m_self.lock(); + const auto LAYOUT = PKEEB->getActiveLayout(); - if (PKEEB == g_pSeatManager->m_keyboard) { - g_pSeatManager->updateActiveKeyboardData(); - g_pKeybindManager->m_keyToCodeCache.clear(); - } + if (PKEEB == g_pSeatManager->m_keyboard) { + g_pSeatManager->updateActiveKeyboardData(); + g_pKeybindManager->m_keyToCodeCache.clear(); + } - g_pEventManager->postEvent(SHyprIPCEvent{"activelayout", PKEEB->m_hlName + "," + LAYOUT}); - EMIT_HOOK_EVENT("activeLayout", (std::vector{PKEEB, LAYOUT})); - }, - keeb.get()); + g_pEventManager->postEvent(SHyprIPCEvent{"activelayout", PKEEB->m_hlName + "," + LAYOUT}); + EMIT_HOOK_EVENT("activeLayout", (std::vector{PKEEB, LAYOUT})); + }); disableAllKeyboards(false); @@ -1148,16 +1136,7 @@ void CInputManager::setupMouse(SP mauz) { setPointerConfigs(); - mauz->m_events.destroy.registerStaticListener( - [this](void* mouse, std::any data) { - const auto PMOUSE = (IPointer*)mouse; - - if (!PMOUSE) - return; - - destroyPointer(PMOUSE->m_self.lock()); - }, - mauz.get()); + mauz->m_events.destroy.listenStatic([this, PMOUSE = mauz.get()] { destroyPointer(PMOUSE->m_self.lock()); }); g_pSeatManager->setMouse(mauz); @@ -1413,7 +1392,7 @@ void CInputManager::updateKeyboardsLeds(SP pKeyboard) { } } -void CInputManager::onKeyboardKey(std::any event, SP pKeyboard) { +void CInputManager::onKeyboardKey(const IKeyboard::SKeyEvent& event, SP pKeyboard) { if (!pKeyboard->m_enabled || !pKeyboard->m_allowed) return; @@ -1424,17 +1403,15 @@ void CInputManager::onKeyboardKey(std::any event, SP pKeyboard) { bool passEvent = DISALLOWACTION || g_pKeybindManager->onKeyEvent(event, pKeyboard); - auto e = std::any_cast(event); - if (passEvent) { const auto IME = m_relay.m_inputMethod.lock(); if (IME && IME->hasGrab() && !DISALLOWACTION) { IME->setKeyboard(pKeyboard); - IME->sendKey(e.timeMs, e.keycode, e.state); + IME->sendKey(event.timeMs, event.keycode, event.state); } else { g_pSeatManager->setKeyboard(pKeyboard); - g_pSeatManager->sendKeyboardKey(e.timeMs, e.keycode, e.state); + g_pSeatManager->sendKeyboardKey(event.timeMs, event.keycode, event.state); } updateKeyboardsLeds(pKeyboard); @@ -1627,16 +1604,14 @@ void CInputManager::newTouchDevice(SP pDevice) { setTouchDeviceConfigs(PNEWDEV); g_pPointerManager->attachTouch(PNEWDEV); - PNEWDEV->m_events.destroy.registerStaticListener( - [this](void* owner, std::any data) { - auto PDEV = ((ITouch*)owner)->m_self.lock(); + PNEWDEV->m_events.destroy.listenStatic([this, dev = PNEWDEV.get()] { + auto PDEV = dev->m_self.lock(); - if (!PDEV) - return; + if (!PDEV) + return; - destroyTouchDevice(PDEV); - }, - PNEWDEV.get()); + destroyTouchDevice(PDEV); + }); Debug::log(LOG, "New touch device added at {:x}", (uintptr_t)PNEWDEV.get()); } @@ -1739,17 +1714,16 @@ void CInputManager::newSwitch(SP pDevice) { 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 E = std::any_cast(d); Debug::log(LOG, "Switch {} fired, triggering binds.", NAME); g_pKeybindManager->onSwitchEvent(NAME); - if (E.enable) { + if (event.enable) { Debug::log(LOG, "Switch {} turn on, triggering binds.", NAME); g_pKeybindManager->onSwitchOnEvent(NAME); } else { diff --git a/src/managers/input/InputManager.hpp b/src/managers/input/InputManager.hpp index 549a72fa6..1696dd0a8 100644 --- a/src/managers/input/InputManager.hpp +++ b/src/managers/input/InputManager.hpp @@ -9,8 +9,10 @@ #include "../../helpers/signal/Signal.hpp" #include "../../devices/IPointer.hpp" #include "../../devices/ITouch.hpp" +#include "../../devices/IKeyboard.hpp" #include "../../devices/Tablet.hpp" #include "../SessionLockManager.hpp" +#include "../SeatManager.hpp" class CPointerConstraint; class CWindow; @@ -89,7 +91,7 @@ class CInputManager { void onMouseWarp(IPointer::SMotionAbsoluteEvent); void onMouseButton(IPointer::SButtonEvent); void onMouseWheel(IPointer::SAxisEvent); - void onKeyboardKey(std::any, SP); + void onKeyboardKey(const IKeyboard::SKeyEvent&, SP); void onKeyboardMod(SP); void newKeyboard(SP); @@ -128,7 +130,7 @@ class CInputManager { void setClickMode(eClickBehaviorMode); eClickBehaviorMode getClickMode(); - void processMouseRequest(std::any e); + void processMouseRequest(const CSeatManager::SSetCursorEvent& event); void onTouchDown(ITouch::SDownEvent); void onTouchUp(ITouch::SUpEvent); diff --git a/src/managers/input/InputMethodPopup.cpp b/src/managers/input/InputMethodPopup.cpp index 981311680..71fdd5a48 100644 --- a/src/managers/input/InputMethodPopup.cpp +++ b/src/managers/input/InputMethodPopup.cpp @@ -8,10 +8,10 @@ #include "../../render/Renderer.hpp" CInputPopup::CInputPopup(SP popup_) : m_popup(popup_) { - m_listeners.commit = popup_->m_events.commit.registerListener([this](std::any d) { onCommit(); }); - m_listeners.map = popup_->m_events.map.registerListener([this](std::any d) { onMap(); }); - m_listeners.unmap = popup_->m_events.unmap.registerListener([this](std::any d) { onUnmap(); }); - m_listeners.destroy = popup_->m_events.destroy.registerListener([this](std::any d) { onDestroy(); }); + m_listeners.commit = popup_->m_events.commit.listen([this] { onCommit(); }); + m_listeners.map = popup_->m_events.map.listen([this] { onMap(); }); + m_listeners.unmap = popup_->m_events.unmap.listen([this] { onUnmap(); }); + m_listeners.destroy = popup_->m_events.destroy.listen([this] { onDestroy(); }); m_surface = CWLSurface::create(); m_surface->assign(popup_->surface()); } diff --git a/src/managers/input/InputMethodRelay.cpp b/src/managers/input/InputMethodRelay.cpp index 40c87f952..c09d0624c 100644 --- a/src/managers/input/InputMethodRelay.cpp +++ b/src/managers/input/InputMethodRelay.cpp @@ -11,9 +11,9 @@ CInputMethodRelay::CInputMethodRelay() { static auto P = g_pHookSystem->hookDynamic("keyboardFocus", [&](void* self, SCallbackInfo& info, std::any param) { onKeyboardFocus(std::any_cast>(param)); }); - m_listeners.newTIV3 = PROTO::textInputV3->m_events.newTextInput.registerListener([this](std::any ti) { onNewTextInput(std::any_cast>(ti)); }); - m_listeners.newTIV1 = PROTO::textInputV1->m_events.newTextInput.registerListener([this](std::any ti) { onNewTextInput(std::any_cast>(ti)); }); - m_listeners.newIME = PROTO::ime->m_events.newIME.registerListener([this](std::any ime) { onNewIME(std::any_cast>(ime)); }); + m_listeners.newTIV3 = PROTO::textInputV3->m_events.newTextInput.listen([this](const auto& input) { onNewTextInput(input); }); + m_listeners.newTIV1 = PROTO::textInputV1->m_events.newTextInput.listen([this](const auto& input) { onNewTextInput(input); }); + m_listeners.newIME = PROTO::ime->m_events.newIME.listen([this](const auto& ime) { onNewIME(ime); }); } void CInputMethodRelay::onNewIME(SP pIME) { @@ -27,7 +27,7 @@ void CInputMethodRelay::onNewIME(SP 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(); if (!PTI) { @@ -38,7 +38,7 @@ void CInputMethodRelay::onNewIME(SP pIME) { 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(); Debug::log(LOG, "IME Destroy"); @@ -49,9 +49,8 @@ void CInputMethodRelay::onNewIME(SP pIME) { m_inputMethod.reset(); }); - m_listeners.newPopup = pIME->m_events.newPopup.registerListener([this](std::any d) { - m_inputMethodPopups.emplace_back(makeUnique(std::any_cast>(d))); - + m_listeners.newPopup = pIME->m_events.newPopup.listen([this](const SP& popup) { + m_inputMethodPopups.emplace_back(makeUnique(popup)); Debug::log(LOG, "New input popup"); }); diff --git a/src/managers/input/Tablets.cpp b/src/managers/input/Tablets.cpp index b0fe7c649..5a0c5dbec 100644 --- a/src/managers/input/Tablets.cpp +++ b/src/managers/input/Tablets.cpp @@ -229,12 +229,10 @@ void CInputManager::newTablet(SP pDevice) { g_pPointerManager->attachTablet(PNEWTABLET); - PNEWTABLET->m_events.destroy.registerStaticListener( - [this](void* owner, std::any d) { - auto TABLET = ((CTablet*)owner)->m_self; - destroyTablet(TABLET.lock()); - }, - PNEWTABLET.get()); + PNEWTABLET->m_events.destroy.listenStatic([this, tablet = PNEWTABLET.get()] { + auto TABLET = tablet->m_self; + destroyTablet(TABLET.lock()); + }); setTabletConfigs(); } @@ -255,12 +253,10 @@ SP CInputManager::ensureTabletToolPresent(SPm_events.destroy.registerStaticListener( - [this](void* owner, std::any d) { - auto TOOL = ((CTabletTool*)owner)->m_self; - destroyTabletTool(TOOL.lock()); - }, - PTOOL.get()); + PTOOL->m_events.destroy.listenStatic([this, tool = PTOOL.get()] { + auto TOOL = tool->m_self; + destroyTabletTool(TOOL.lock()); + }); return PTOOL; } @@ -275,39 +271,27 @@ void CInputManager::newTabletPad(SP pDevice) { Debug::log(ERR, "Pad had no name???"); // logic error } - // clang-format off - PNEWPAD->m_events.destroy.registerStaticListener([this](void* owner, std::any d) { - auto PAD = ((CTabletPad*)owner)->m_self; + PNEWPAD->m_events.destroy.listenStatic([this, pad = PNEWPAD.get()] { + auto PAD = pad->m_self; destroyTabletPad(PAD.lock()); - }, PNEWPAD.get()); + }); - PNEWPAD->m_padEvents.button.registerStaticListener([](void* owner, std::any e) { - const auto E = std::any_cast(e); - const auto PPAD = ((CTabletPad*)owner)->m_self.lock(); + PNEWPAD->m_padEvents.button.listenStatic([pad = PNEWPAD.get()](const CTabletPad::SButtonEvent& event) { + const auto PPAD = pad->m_self.lock(); - PROTO::tablet->mode(PPAD, 0, E.mode, E.timeMs); - PROTO::tablet->buttonPad(PPAD, E.button, E.timeMs, E.down); - }, PNEWPAD.get()); + PROTO::tablet->mode(PPAD, 0, event.mode, event.timeMs); + PROTO::tablet->buttonPad(PPAD, event.button, event.timeMs, event.down); + }); - PNEWPAD->m_padEvents.strip.registerStaticListener([](void* owner, std::any e) { - const auto E = std::any_cast(e); - const auto PPAD = ((CTabletPad*)owner)->m_self.lock(); + PNEWPAD->m_padEvents.strip.listenStatic([pad = PNEWPAD.get()](const CTabletPad::SStripEvent& event) { + const auto PPAD = pad->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.get()); + PNEWPAD->m_padEvents.ring.listenStatic([pad = PNEWPAD.get()](const CTabletPad::SRingEvent& event) { + 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) { - const auto E = std::any_cast(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>(e); - - PPAD->m_parent = TOOL; - }, PNEWPAD.get()); - // clang-format on + PNEWPAD->m_padEvents.attach.listenStatic([pad = PNEWPAD.get()](const SP& tool) { pad->m_parent = tool; }); } diff --git a/src/managers/input/TextInput.cpp b/src/managers/input/TextInput.cpp index cac64da43..c1ce2062a 100644 --- a/src/managers/input/TextInput.cpp +++ b/src/managers/input/TextInput.cpp @@ -19,11 +19,11 @@ void CTextInput::initCallbacks() { if (isV3()) { const auto INPUT = m_v3Input.lock(); - m_listeners.enable = INPUT->m_events.enable.registerListener([this](std::any p) { onEnabled(); }); - m_listeners.disable = INPUT->m_events.disable.registerListener([this](std::any p) { onDisabled(); }); - 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.enable = INPUT->m_events.enable.listen([this] { onEnabled(); }); + m_listeners.disable = INPUT->m_events.disable.listen([this] { onDisabled(); }); + m_listeners.commit = INPUT->m_events.onCommit.listen([this] { onCommit(); }); + m_listeners.reset = INPUT->m_events.reset.listen([this] { onReset(); }); + m_listeners.destroy = INPUT->m_events.destroy.listen([this] { m_listeners.surfaceUnmap.reset(); m_listeners.surfaceDestroy.reset(); g_pInputManager->m_relay.removeTextInput(this); @@ -36,14 +36,11 @@ void CTextInput::initCallbacks() { } else { const auto INPUT = m_v1Input.lock(); - m_listeners.enable = INPUT->m_events.enable.registerListener([this](std::any p) { - const auto SURFACE = std::any_cast>(p); - onEnabled(SURFACE); - }); - m_listeners.disable = INPUT->m_events.disable.registerListener([this](std::any p) { onDisabled(); }); - 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.enable = INPUT->m_events.enable.listen([this](const auto& surface) { onEnabled(surface); }); + m_listeners.disable = INPUT->m_events.disable.listen([this] { onDisabled(); }); + m_listeners.commit = INPUT->m_events.onCommit.listen([this] { onCommit(); }); + m_listeners.reset = INPUT->m_events.reset.listen([this] { onReset(); }); + m_listeners.destroy = INPUT->m_events.destroy.listen([this] { m_listeners.surfaceUnmap.reset(); m_listeners.surfaceDestroy.reset(); g_pInputManager->m_relay.removeTextInput(this); @@ -135,7 +132,7 @@ void CTextInput::setFocusedSurface(SP pSurface) { m_listeners.surfaceUnmap.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"); if (m_enterLocks) @@ -155,7 +152,7 @@ void CTextInput::setFocusedSurface(SP pSurface) { 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"); if (m_enterLocks) diff --git a/src/protocols/AlphaModifier.cpp b/src/protocols/AlphaModifier.cpp index ad4bc107b..31e5e9962 100644 --- a/src/protocols/AlphaModifier.cpp +++ b/src/protocols/AlphaModifier.cpp @@ -30,7 +30,7 @@ void CAlphaModifier::setResource(SP resource) { 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()); if (surface && surface->m_alphaModifier != m_alpha) { @@ -45,7 +45,7 @@ void CAlphaModifier::setResource(SP 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) PROTO::alphaModifier->destroyAlphaModifier(this); }); diff --git a/src/protocols/ContentType.cpp b/src/protocols/ContentType.cpp index 218c7aebe..ba2c15330 100644 --- a/src/protocols/ContentType.cpp +++ b/src/protocols/ContentType.cpp @@ -42,7 +42,7 @@ bool CContentTypeManager::good() { } CContentType::CContentType(WP 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 resource) : m_resource(resource) { diff --git a/src/protocols/CursorShape.hpp b/src/protocols/CursorShape.hpp index d7ae75c16..918032ab9 100644 --- a/src/protocols/CursorShape.hpp +++ b/src/protocols/CursorShape.hpp @@ -18,7 +18,7 @@ class CCursorShapeProtocol : public IWaylandProtocol { }; struct { - CSignal setShape; + CSignalT setShape; } m_events; private: @@ -38,4 +38,4 @@ class CCursorShapeProtocol : public IWaylandProtocol { namespace PROTO { inline UP cursorShape; -}; \ No newline at end of file +}; diff --git a/src/protocols/DRMLease.cpp b/src/protocols/DRMLease.cpp index 891b503cf..d64555f23 100644 --- a/src/protocols/DRMLease.cpp +++ b/src/protocols/DRMLease.cpp @@ -64,7 +64,7 @@ CDRMLeaseResource::CDRMLeaseResource(SP resource_, SPm_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) { if (m && m->m_monitor) m->m_monitor->m_isBeingLeased = false; @@ -167,7 +167,7 @@ CDRMLeaseConnectorResource::CDRMLeaseConnectorResource(WPsetData(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_dead = true; }); diff --git a/src/protocols/DRMSyncobj.cpp b/src/protocols/DRMSyncobj.cpp index 12adc3878..2f5c3e14e 100644 --- a/src/protocols/DRMSyncobj.cpp +++ b/src/protocols/DRMSyncobj.cpp @@ -74,7 +74,7 @@ CDRMSyncobjSurfaceResource::CDRMSyncobjSurfaceResource(UPm_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_pendingAcquire.timeline() || m_pendingRelease.timeline()) { m_resource->error(WP_LINUX_DRM_SYNCOBJ_SURFACE_V1_ERROR_NO_BUFFER, "Missing buffer"); diff --git a/src/protocols/ExtWorkspace.cpp b/src/protocols/ExtWorkspace.cpp index 6c55e76e1..ecba454e3 100644 --- a/src/protocols/ExtWorkspace.cpp +++ b/src/protocols/ExtWorkspace.cpp @@ -15,7 +15,7 @@ CExtWorkspaceGroupResource::CExtWorkspaceGroupResource(WPsetData(this); 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->setDestroy([this](auto) { PROTO::extWorkspace->destroyGroup(m_self); }); @@ -27,11 +27,9 @@ CExtWorkspaceGroupResource::CExtWorkspaceGroupResource(WPoutputResourceFrom(m_resource->client())) m_resource->sendOutputEnter(resource->getResource()->resource()); - m_listeners.outputBound = output->m_events.outputBound.registerListener([this](std::any data) { - auto resource = std::any_cast>(data); - - if (resource->client() == m_resource->client()) - m_resource->sendOutputEnter(resource->getResource()->resource()); + m_listeners.outputBound = output->m_events.outputBound.listen([this](const SP& output) { + if (output->client() == m_resource->client()) + m_resource->sendOutputEnter(output->getResource()->resource()); }); m_manager->sendGroupToWorkspaces(m_self); @@ -63,21 +61,21 @@ CExtWorkspaceResource::CExtWorkspaceResource(WP ma m_resource->setData(this); 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(); if (m_manager) 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(); 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()); if (m_manager) diff --git a/src/protocols/FocusGrab.cpp b/src/protocols/FocusGrab.cpp index 41396459b..3ab8d1e2d 100644 --- a/src/protocols/FocusGrab.cpp +++ b/src/protocols/FocusGrab.cpp @@ -8,7 +8,7 @@ #include CFocusGrabSurfaceState::CFocusGrabSurfaceState(CFocusGrab* grab, SP 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 resource_) : m_resource(resource_) { diff --git a/src/protocols/GammaControl.cpp b/src/protocols/GammaControl.cpp index 1d5b4fd5b..29a9cae49 100644 --- a/src/protocols/GammaControl.cpp +++ b/src/protocols/GammaControl.cpp @@ -108,8 +108,8 @@ CGammaControl::CGammaControl(SP resource_, wl_resource* out m_resource->sendGammaSize(m_gammaSize); - m_listeners.monitorDestroy = m_monitor->m_events.destroy.registerListener([this](std::any) { this->onMonitorDestroy(); }); - m_listeners.monitorDisconnect = m_monitor->m_events.disconnect.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.listen([this] { this->onMonitorDestroy(); }); } CGammaControl::~CGammaControl() { diff --git a/src/protocols/HyprlandSurface.cpp b/src/protocols/HyprlandSurface.cpp index 2e3860274..b2692d1f6 100644 --- a/src/protocols/HyprlandSurface.cpp +++ b/src/protocols/HyprlandSurface.cpp @@ -51,7 +51,7 @@ void CHyprlandSurface::setResource(SP resource) { 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()); if (surface && (surface->m_overallOpacity != m_opacity || m_visibleRegionChanged)) { @@ -67,7 +67,7 @@ void CHyprlandSurface::setResource(SP 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) PROTO::hyprlandSurface->destroySurface(this); }); diff --git a/src/protocols/IdleInhibit.cpp b/src/protocols/IdleInhibit.cpp index f8031d22f..e7e0e6764 100644 --- a/src/protocols/IdleInhibit.cpp +++ b/src/protocols/IdleInhibit.cpp @@ -6,7 +6,7 @@ CIdleInhibitor::CIdleInhibitor(SP resource_, SP resource_, SP 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_listeners.destroySurface.reset(); m_destroySent = true; @@ -49,4 +49,4 @@ void CIdleInhibitProtocol::onCreateInhibitor(CZwpIdleInhibitManagerV1* pMgr, uin RESOURCE->m_inhibitor = makeShared(RESOURCE, surface); m_events.newIdleInhibitor.emit(RESOURCE->m_inhibitor); -} \ No newline at end of file +} diff --git a/src/protocols/IdleInhibit.hpp b/src/protocols/IdleInhibit.hpp index 791d83f9e..e04b67256 100644 --- a/src/protocols/IdleInhibit.hpp +++ b/src/protocols/IdleInhibit.hpp @@ -28,7 +28,7 @@ class CIdleInhibitorResource { SP m_inhibitor; struct { - CSignal destroy; + CSignalT<> destroy; } m_events; private: @@ -48,7 +48,7 @@ class CIdleInhibitProtocol : public IWaylandProtocol { virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id); struct { - CSignal newIdleInhibitor; // data: SP + CSignalT> newIdleInhibitor; } m_events; private: diff --git a/src/protocols/InputMethodV2.cpp b/src/protocols/InputMethodV2.cpp index 63f9f33fb..7826a9620 100644 --- a/src/protocols/InputMethodV2.cpp +++ b/src/protocols/InputMethodV2.cpp @@ -89,7 +89,7 @@ CInputMethodPopupV2::CInputMethodPopupV2(SP resource_, 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) m_events.unmap.emit(); @@ -102,7 +102,7 @@ CInputMethodPopupV2::CInputMethodPopupV2(SP resource_, 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) { m_mapped = true; m_surface->map(); diff --git a/src/protocols/InputMethodV2.hpp b/src/protocols/InputMethodV2.hpp index 74efcbb30..4ee579ec1 100644 --- a/src/protocols/InputMethodV2.hpp +++ b/src/protocols/InputMethodV2.hpp @@ -18,9 +18,9 @@ class CInputMethodV2 { ~CInputMethodV2(); struct { - CSignal onCommit; - CSignal destroy; - CSignal newPopup; + CSignalT<> onCommit; + CSignalT<> destroy; + CSignalT> newPopup; } m_events; struct SState { @@ -110,10 +110,10 @@ class CInputMethodPopupV2 { SP surface(); struct { - CSignal map; - CSignal unmap; - CSignal commit; - CSignal destroy; + CSignalT<> map; + CSignalT<> unmap; + CSignalT<> commit; + CSignalT<> destroy; } m_events; 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); struct { - CSignal newIME; // SP + CSignalT> newIME; } m_events; private: @@ -160,4 +160,4 @@ class CInputMethodV2Protocol : public IWaylandProtocol { namespace PROTO { inline UP ime; -}; \ No newline at end of file +}; diff --git a/src/protocols/LayerShell.cpp b/src/protocols/LayerShell.cpp index bb5480b63..be9e33708 100644 --- a/src/protocols/LayerShell.cpp +++ b/src/protocols/LayerShell.cpp @@ -33,14 +33,14 @@ CLayerShellResource::CLayerShellResource(SP resource_, SPdestroyResource(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(); 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_pending.committed = 0; diff --git a/src/protocols/LayerShell.hpp b/src/protocols/LayerShell.hpp index c6c162a33..ce8de05a4 100644 --- a/src/protocols/LayerShell.hpp +++ b/src/protocols/LayerShell.hpp @@ -10,6 +10,7 @@ #include "types/SurfaceRole.hpp" class CMonitor; +class CXDGPopupResource; class CWLSurfaceResource; class CLayerShellResource; @@ -44,11 +45,11 @@ class CLayerShellResource { }; struct { - CSignal destroy; - CSignal commit; - CSignal map; - CSignal unmap; - CSignal newPopup; // wlr_xdg_popup* + CSignalT<> destroy; + CSignalT<> commit; + CSignalT<> map; + CSignalT<> unmap; + CSignalT> newPopup; } m_events; struct SState { diff --git a/src/protocols/LinuxDMABUF.cpp b/src/protocols/LinuxDMABUF.cpp index a0fe571af..8bf95c139 100644 --- a/src/protocols/LinuxDMABUF.cpp +++ b/src/protocols/LinuxDMABUF.cpp @@ -99,7 +99,7 @@ CLinuxDMABuffer::CLinuxDMABuffer(uint32_t id, wl_client* client, Aquamarine::SDM 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(); PROTO::linuxDma->destroyResource(this); }); diff --git a/src/protocols/MesaDRM.cpp b/src/protocols/MesaDRM.cpp index c85322656..45ee24c51 100644 --- a/src/protocols/MesaDRM.cpp +++ b/src/protocols/MesaDRM.cpp @@ -14,7 +14,7 @@ CMesaDRMBufferResource::CMesaDRMBufferResource(uint32_t id, wl_client* client, A m_buffer = makeShared(id, client, attrs_); 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(); PROTO::mesaDRM->destroyResource(this); }); diff --git a/src/protocols/OutputManagement.cpp b/src/protocols/OutputManagement.cpp index b5c0de745..ab2ec88a7 100644 --- a/src/protocols/OutputManagement.cpp +++ b/src/protocols/OutputManagement.cpp @@ -96,7 +96,7 @@ COutputHead::COutputHead(SP resource_, PHLMONITOR pMonitor_) m_resource->setRelease([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(); for (auto const& mw : m_modes) { @@ -114,7 +114,7 @@ COutputHead::COutputHead(SP 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() { diff --git a/src/protocols/OutputPower.cpp b/src/protocols/OutputPower.cpp index bae3078f7..e3cc73360 100644 --- a/src/protocols/OutputPower.cpp +++ b/src/protocols/OutputPower.cpp @@ -23,15 +23,15 @@ COutputPower::COutputPower(SP resource_, PHLMONITOR pMonitor 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_resource->sendFailed(); }); - m_listeners.monitorDpms = m_monitor->m_events.dpmsChanged.registerListener( - [this](std::any v) { 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( - [this](std::any v) { m_resource->sendMode(m_monitor->m_dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); }); + m_listeners.monitorDpms = + 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.listen([this] { m_resource->sendMode(m_monitor->m_dpmsStatus ? ZWLR_OUTPUT_POWER_V1_MODE_ON : ZWLR_OUTPUT_POWER_V1_MODE_OFF); }); } bool COutputPower::good() { diff --git a/src/protocols/PointerConstraints.cpp b/src/protocols/PointerConstraints.cpp index ea917932b..24ccc980d 100644 --- a/src/protocols/PointerConstraints.cpp +++ b/src/protocols/PointerConstraints.cpp @@ -80,7 +80,7 @@ CPointerConstraint::~CPointerConstraint() { void CPointerConstraint::sharedConstructions() { 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(); if (m_active) deactivate(); diff --git a/src/protocols/PrimarySelection.cpp b/src/protocols/PrimarySelection.cpp index 2b01eddd5..9a61f25a6 100644 --- a/src/protocols/PrimarySelection.cpp +++ b/src/protocols/PrimarySelection.cpp @@ -228,7 +228,7 @@ void CPrimarySelectionProtocol::bindManager(wl_client* client, void* data, uint3 // we need to do it here because protocols come before seatMgr 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) { diff --git a/src/protocols/SessionLock.cpp b/src/protocols/SessionLock.cpp index d3916fdcd..64c0569b0 100644 --- a/src/protocols/SessionLock.cpp +++ b/src/protocols/SessionLock.cpp @@ -24,7 +24,7 @@ CSessionLockSurface::CSessionLockSurface(SP resource_, 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) { LOGM(ERR, "SessionLock attached a null buffer"); m_resource->error(EXT_SESSION_LOCK_SURFACE_V1_ERROR_NULL_BUFFER, "Null buffer attached"); @@ -46,7 +46,7 @@ CSessionLockSurface::CSessionLockSurface(SP resource_, 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???"); m_surface->unmap(); m_listeners.surfaceCommit.reset(); @@ -61,7 +61,7 @@ CSessionLockSurface::CSessionLockSurface(SP resource_, 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() { diff --git a/src/protocols/SessionLock.hpp b/src/protocols/SessionLock.hpp index 8f0e0af68..09b48b327 100644 --- a/src/protocols/SessionLock.hpp +++ b/src/protocols/SessionLock.hpp @@ -21,9 +21,9 @@ class CSessionLockSurface { SP surface(); struct { - CSignal map; - CSignal destroy; - CSignal commit; + CSignalT<> map; + CSignalT<> destroy; + CSignalT<> commit; } m_events; private: @@ -54,9 +54,9 @@ class CSessionLock { void sendDenied(); struct { - CSignal newLockSurface; // SP - CSignal unlockAndDestroy; - CSignal destroyed; // fires regardless of whether there was a unlockAndDestroy or not. + CSignalT> newLockSurface; + CSignalT<> unlockAndDestroy; + CSignalT<> destroyed; // fires regardless of whether there was a unlockAndDestroy or not. } m_events; private: @@ -76,7 +76,7 @@ class CSessionLockProtocol : public IWaylandProtocol { bool isLocked(); struct { - CSignal newLock; // SP + CSignalT> newLock; } m_events; private: diff --git a/src/protocols/SinglePixel.cpp b/src/protocols/SinglePixel.cpp index d069da0dd..42c4f8ed4 100644 --- a/src/protocols/SinglePixel.cpp +++ b/src/protocols/SinglePixel.cpp @@ -69,7 +69,7 @@ CSinglePixelBufferResource::CSinglePixelBufferResource(uint32_t id, wl_client* c 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(); PROTO::singlePixel->destroyResource(this); }); diff --git a/src/protocols/TextInputV1.hpp b/src/protocols/TextInputV1.hpp index 5f74bf72d..f22dfdfeb 100644 --- a/src/protocols/TextInputV1.hpp +++ b/src/protocols/TextInputV1.hpp @@ -33,11 +33,11 @@ class CTextInputV1 { bool m_active = false; struct { - CSignal onCommit; - CSignal enable; - CSignal disable; - CSignal reset; - CSignal destroy; + CSignalT<> onCommit; + CSignalT> enable; + CSignalT<> disable; + CSignalT<> reset; + CSignalT<> destroy; } m_events; struct SPendingSurr { @@ -68,7 +68,7 @@ class CTextInputV1Protocol : public IWaylandProtocol { void destroyResource(CZwpTextInputManagerV1* client); struct { - CSignal newTextInput; // WP + CSignalT> newTextInput; } m_events; private: diff --git a/src/protocols/TextInputV3.hpp b/src/protocols/TextInputV3.hpp index 65d29b7f6..420adf533 100644 --- a/src/protocols/TextInputV3.hpp +++ b/src/protocols/TextInputV3.hpp @@ -27,11 +27,11 @@ class CTextInputV3 { wl_client* client(); struct { - CSignal onCommit; - CSignal enable; - CSignal disable; - CSignal reset; - CSignal destroy; + CSignalT<> onCommit; + CSignalT<> enable; + CSignalT<> disable; + CSignalT<> reset; + CSignalT<> destroy; } m_events; struct SState { @@ -80,7 +80,7 @@ class CTextInputV3Protocol : public IWaylandProtocol { virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id); struct { - CSignal newTextInput; // WP + CSignalT> newTextInput; } m_events; private: @@ -97,4 +97,4 @@ class CTextInputV3Protocol : public IWaylandProtocol { namespace PROTO { inline UP textInputV3; -}; \ No newline at end of file +}; diff --git a/src/protocols/Viewporter.cpp b/src/protocols/Viewporter.cpp index f13d75405..06a47382c 100644 --- a/src/protocols/Viewporter.cpp +++ b/src/protocols/Viewporter.cpp @@ -55,7 +55,7 @@ CViewportResource::CViewportResource(SP resource_, SPm_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) return; diff --git a/src/protocols/VirtualKeyboard.hpp b/src/protocols/VirtualKeyboard.hpp index ad2eccfa7..c601c0fb5 100644 --- a/src/protocols/VirtualKeyboard.hpp +++ b/src/protocols/VirtualKeyboard.hpp @@ -3,6 +3,8 @@ #include #include #include "WaylandProtocol.hpp" +#include "../devices/IKeyboard.hpp" +#include "../devices/VirtualKeyboard.hpp" #include "virtual-keyboard-unstable-v1.hpp" #include "../helpers/signal/Signal.hpp" #include @@ -13,10 +15,10 @@ class CVirtualKeyboardV1Resource { ~CVirtualKeyboardV1Resource(); struct { - CSignal destroy; - CSignal key; - CSignal modifiers; - CSignal keymap; + CSignalT<> destroy; + CSignalT key; + CSignalT modifiers; + CSignalT keymap; } m_events; bool good(); @@ -41,7 +43,7 @@ class CVirtualKeyboardProtocol : public IWaylandProtocol { virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id); struct { - CSignal newKeyboard; // SP + CSignalT> newKeyboard; } m_events; private: diff --git a/src/protocols/VirtualPointer.cpp b/src/protocols/VirtualPointer.cpp index e40d35f27..c083fc3f0 100644 --- a/src/protocols/VirtualPointer.cpp +++ b/src/protocols/VirtualPointer.cpp @@ -148,4 +148,4 @@ void CVirtualPointerProtocol::onCreatePointer(CZwlrVirtualPointerManagerV1* pMgr LOGM(LOG, "New VPointer at id {}", id); m_events.newPointer.emit(RESOURCE); -} \ No newline at end of file +} diff --git a/src/protocols/VirtualPointer.hpp b/src/protocols/VirtualPointer.hpp index a608086a7..96f31d81c 100644 --- a/src/protocols/VirtualPointer.hpp +++ b/src/protocols/VirtualPointer.hpp @@ -15,23 +15,23 @@ class CVirtualPointerV1Resource { ~CVirtualPointerV1Resource(); struct { - CSignal destroy; - CSignal move; - CSignal warp; - CSignal button; - CSignal axis; - CSignal frame; + CSignalT<> destroy; + CSignalT move; + CSignalT warp; + CSignalT button; + CSignalT axis; + CSignalT<> frame; - CSignal swipeBegin; - CSignal swipeUpdate; - CSignal swipeEnd; + CSignalT swipeBegin; + CSignalT swipeUpdate; + CSignalT swipeEnd; - CSignal pinchBegin; - CSignal pinchUpdate; - CSignal pinchEnd; + CSignalT pinchBegin; + CSignalT pinchUpdate; + CSignalT pinchEnd; - CSignal holdBegin; - CSignal holdEnd; + CSignalT holdBegin; + CSignalT holdEnd; } m_events; bool good(); @@ -56,7 +56,7 @@ class CVirtualPointerProtocol : public IWaylandProtocol { virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id); struct { - CSignal newPointer; // SP + CSignalT> newPointer; } m_events; private: diff --git a/src/protocols/XDGShell.cpp b/src/protocols/XDGShell.cpp index 5351e267c..488ff6f16 100644 --- a/src/protocols/XDGShell.cpp +++ b/src/protocols/XDGShell.cpp @@ -372,7 +372,7 @@ CXDGSurfaceResource::CXDGSurfaceResource(SP resource_, SPdestroyResource(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"); m_listeners.surfaceDestroy.reset(); m_listeners.surfaceCommit.reset(); @@ -385,7 +385,7 @@ CXDGSurfaceResource::CXDGSurfaceResource(SP resource_, SPm_events.commit.registerListener([this](std::any d) { + m_listeners.surfaceCommit = m_surface->m_events.commit.listen([this] { m_current = m_pending; if (m_toplevel) m_toplevel->m_current = m_toplevel->m_pending; @@ -436,7 +436,7 @@ CXDGSurfaceResource::CXDGSurfaceResource(SP resource_, SP reposition; + CSignalT<> dismissed; + CSignalT<> destroy; // only the role } m_events; // schedules a configure event @@ -111,10 +111,10 @@ class CXDGToplevelResource { void close(); struct { - CSignal sizeLimitsChanged; - CSignal stateChanged; // maximized, fs, minimized, etc. - CSignal metadataChanged; // title, appid - CSignal destroy; // only the role + CSignalT<> sizeLimitsChanged; + CSignalT<> stateChanged; // maximized, fs, minimized, etc. + CSignalT<> metadataChanged; // title, appid + CSignalT<> destroy; // only the role } m_events; struct { @@ -186,12 +186,12 @@ class CXDGSurfaceResource { } m_pending, m_current; struct { - CSignal ack; - CSignal commit; - CSignal map; - CSignal unmap; - CSignal destroy; - CSignal newPopup; // SP + CSignalT ack; + CSignalT<> commit; + CSignalT<> map; + CSignalT<> unmap; + CSignalT<> destroy; + CSignalT> newPopup; } m_events; bool m_initialCommit = true; @@ -252,7 +252,7 @@ class CXDGWMBase { WP m_self; struct { - CSignal pong; + CSignalT<> pong; } m_events; private: diff --git a/src/protocols/XWaylandShell.hpp b/src/protocols/XWaylandShell.hpp index a83f258ea..346bfe884 100644 --- a/src/protocols/XWaylandShell.hpp +++ b/src/protocols/XWaylandShell.hpp @@ -17,7 +17,7 @@ class CXWaylandSurfaceResource { wl_client* client(); struct { - CSignal destroy; + CSignalT<> destroy; } events; 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); struct { - CSignal newSurface; // SP. Fired when it sets a serial, otherwise it's useless + CSignalT> newSurface; // Fired when it sets a serial, otherwise it's useless } m_events; private: diff --git a/src/protocols/core/Compositor.hpp b/src/protocols/core/Compositor.hpp index 90fac35d4..26b5a27b0 100644 --- a/src/protocols/core/Compositor.hpp +++ b/src/protocols/core/Compositor.hpp @@ -80,12 +80,12 @@ class CWLSurfaceResource { void resetRole(); struct { - CSignal precommit; // before commit - CSignal commit; // after commit - CSignal map; - CSignal unmap; - CSignal newSubsurface; - CSignal destroy; + CSignalT<> precommit; // before commit + CSignalT<> commit; // after commit + CSignalT<> map; + CSignalT<> unmap; + CSignalT> newSubsurface; + CSignalT<> destroy; } m_events; SSurfaceState m_current; @@ -146,7 +146,7 @@ class CWLCompositorProtocol : public IWaylandProtocol { void forEachSurface(std::function)> fn); struct { - CSignal newSurface; // SP + CSignalT> newSurface; } m_events; private: diff --git a/src/protocols/core/DataDevice.cpp b/src/protocols/core/DataDevice.cpp index 730113f12..4435e4c7e 100644 --- a/src/protocols/core/DataDevice.cpp +++ b/src/protocols/core/DataDevice.cpp @@ -385,8 +385,8 @@ bool CWLDataDeviceManagerResource::good() { CWLDataDeviceProtocol::CWLDataDeviceProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) { g_pEventLoopManager->doLater([this]() { - m_listeners.onKeyboardFocusChange = g_pSeatManager->m_events.keyboardFocusChange.registerListener([this](std::any d) { onKeyboardFocus(); }); - m_listeners.onDndPointerFocusChange = g_pSeatManager->m_events.dndPointerFocusChange.registerListener([this](std::any d) { onDndPointerFocus(); }); + m_listeners.onKeyboardFocusChange = g_pSeatManager->m_events.keyboardFocusChange.listen([this] { onKeyboardFocus(); }); + m_listeners.onDndPointerFocusChange = g_pSeatManager->m_events.dndPointerFocusChange.listen([this] { onDndPointerFocus(); }); }); } @@ -564,8 +564,8 @@ void CWLDataDeviceProtocol::initiateDrag(WP currentSource m_dnd.originSurface = origin; m_dnd.dndSurface = dragSurface; if (dragSurface) { - m_dnd.dndSurfaceDestroy = dragSurface->m_events.destroy.registerListener([this](std::any d) { abortDrag(); }); - m_dnd.dndSurfaceCommit = dragSurface->m_events.commit.registerListener([this](std::any d) { + m_dnd.dndSurfaceDestroy = dragSurface->m_events.destroy.listen([this] { abortDrag(); }); + m_dnd.dndSurfaceCommit = dragSurface->m_events.commit.listen([this] { if (m_dnd.dndSurface->m_current.texture && !m_dnd.dndSurface->m_mapped) { m_dnd.dndSurface->map(); return; diff --git a/src/protocols/core/Output.cpp b/src/protocols/core/Output.cpp index a9d75972a..8ebf87eb8 100644 --- a/src/protocols/core/Output.cpp +++ b/src/protocols/core/Output.cpp @@ -86,7 +86,7 @@ void CWLOutputResource::updateState() { 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) { - 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) { o->updateState(); } diff --git a/src/protocols/core/Output.hpp b/src/protocols/core/Output.hpp index 50deccd34..d0c6fb13f 100644 --- a/src/protocols/core/Output.hpp +++ b/src/protocols/core/Output.hpp @@ -47,7 +47,7 @@ class CWLOutputProtocol : public IWaylandProtocol { bool isDefunct(); // true if above was called struct { - CSignal outputBound; + CSignalT> outputBound; } m_events; private: diff --git a/src/protocols/core/Seat.cpp b/src/protocols/core/Seat.cpp index c341f95a8..53123abe9 100644 --- a/src/protocols/core/Seat.cpp +++ b/src/protocols/core/Seat.cpp @@ -32,7 +32,7 @@ void CWLTouchResource::sendDown(SP surface, uint32_t timeMs, ASSERT(surface->client() == m_owner->client()); 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)); @@ -160,7 +160,7 @@ void CWLPointerResource::sendEnter(SP surface, const Vector2 ASSERT(surface->client() == m_owner->client()); 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)); } @@ -349,7 +349,7 @@ void CWLKeyboardResource::sendEnter(SP surface) { ASSERT(surface->client() == m_owner->client()); 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_init(&arr); diff --git a/src/protocols/core/Seat.hpp b/src/protocols/core/Seat.hpp index 358393850..0c14e52a1 100644 --- a/src/protocols/core/Seat.hpp +++ b/src/protocols/core/Seat.hpp @@ -142,7 +142,7 @@ class CWLSeatResource { WP m_self; struct { - CSignal destroy; + CSignalT<> destroy; } m_events; private: @@ -157,7 +157,7 @@ class CWLSeatProtocol : public IWaylandProtocol { virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id); struct { - CSignal newSeatResource; // SP + CSignalT> newSeatResource; } m_events; private: diff --git a/src/protocols/core/Shm.cpp b/src/protocols/core/Shm.cpp index 8d610fe0a..d73525a60 100644 --- a/src/protocols/core/Shm.cpp +++ b/src/protocols/core/Shm.cpp @@ -24,7 +24,7 @@ CWLSHMBuffer::CWLSHMBuffer(SP pool_, uint32_t id, int32_t of m_resource = CWLBufferResource::create(makeShared(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(); PROTO::shm->destroyResource(this); }); diff --git a/src/protocols/core/Subcompositor.cpp b/src/protocols/core/Subcompositor.cpp index 71058d25a..d18d9fc66 100644 --- a/src/protocols/core/Subcompositor.cpp +++ b/src/protocols/core/Subcompositor.cpp @@ -71,7 +71,7 @@ CWLSubsurfaceResource::CWLSubsurfaceResource(SP resource_, SPm_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) { m_surface->map(); m_surface->m_events.map.emit(); diff --git a/src/protocols/core/Subcompositor.hpp b/src/protocols/core/Subcompositor.hpp index cf7913ec4..45b84eba4 100644 --- a/src/protocols/core/Subcompositor.hpp +++ b/src/protocols/core/Subcompositor.hpp @@ -48,7 +48,7 @@ class CWLSubsurfaceResource { int m_zIndex = 1; // by default, it's above struct { - CSignal destroy; + CSignalT<> destroy; } m_events; private: diff --git a/src/protocols/types/Buffer.cpp b/src/protocols/types/Buffer.cpp index 6608d6311..86b37be05 100644 --- a/src/protocols/types/Buffer.cpp +++ b/src/protocols/types/Buffer.cpp @@ -36,7 +36,7 @@ void IHLBuffer::onBackendRelease(const std::function& fn) { m_backendReleaseQueuedFn = fn; - m_hlEvents.backendRelease = events.backendRelease.registerListener([this](std::any) { + m_hlEvents.backendRelease = events.backendRelease.listen([this] { if (m_backendReleaseQueuedFn) m_backendReleaseQueuedFn(); m_backendReleaseQueuedFn = nullptr; diff --git a/src/protocols/types/DMABuffer.cpp b/src/protocols/types/DMABuffer.cpp index b1621de7b..1f6a1a6b3 100644 --- a/src/protocols/types/DMABuffer.cpp +++ b/src/protocols/types/DMABuffer.cpp @@ -15,7 +15,7 @@ using namespace Hyprutils::OS; CDMABuffer::CDMABuffer(uint32_t id, wl_client* client, Aquamarine::SDMABUFAttrs const& attrs_) : m_attrs(attrs_) { g_pHyprRenderer->makeEGLCurrent(); - m_listeners.resourceDestroy = events.destroy.registerListener([this](std::any d) { + m_listeners.resourceDestroy = events.destroy.listen([this] { closeFDs(); m_listeners.resourceDestroy.reset(); }); diff --git a/src/protocols/types/DataDevice.hpp b/src/protocols/types/DataDevice.hpp index 857d818d1..9a9579d3d 100644 --- a/src/protocols/types/DataDevice.hpp +++ b/src/protocols/types/DataDevice.hpp @@ -41,7 +41,7 @@ class IDataSource { virtual void sendDndAction(wl_data_device_manager_dnd_action a); struct { - CSignal destroy; + CSignalT<> destroy; } m_events; private: diff --git a/src/render/Renderbuffer.cpp b/src/render/Renderbuffer.cpp index addc99a80..da148b9cb 100644 --- a/src/render/Renderbuffer.cpp +++ b/src/render/Renderbuffer.cpp @@ -48,7 +48,7 @@ CRenderbuffer::CRenderbuffer(SP buffer, uint32_t format) : 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; } diff --git a/src/xwayland/XSurface.cpp b/src/xwayland/XSurface.cpp index d9419794e..3b0615a04 100644 --- a/src/xwayland/XSurface.cpp +++ b/src/xwayland/XSurface.cpp @@ -42,7 +42,7 @@ CXWaylandSurface::CXWaylandSurface(uint32_t xID_, CBox geometry_, bool OR) : m_x free(reply); } - m_events.resourceChange.registerStaticListener([this](void* data, std::any d) { ensureListeners(); }, nullptr); + m_events.resourceChange.listenStatic([this] { ensureListeners(); }); } void CXWaylandSurface::ensureListeners() { @@ -52,7 +52,7 @@ void CXWaylandSurface::ensureListeners() { m_listeners.destroySurface.reset(); m_listeners.commitSurface.reset(); } 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) unmap(); @@ -62,7 +62,7 @@ void CXWaylandSurface::ensureListeners() { 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) { map(); return; @@ -78,7 +78,7 @@ void CXWaylandSurface::ensureListeners() { } 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(); m_surface.reset(); m_events.resourceChange.emit(); diff --git a/src/xwayland/XSurface.hpp b/src/xwayland/XSurface.hpp index ec71aad30..10eecbaf2 100644 --- a/src/xwayland/XSurface.hpp +++ b/src/xwayland/XSurface.hpp @@ -43,20 +43,20 @@ class CXWaylandSurface { WP m_resource; struct { - CSignal stateChanged; // maximized, fs, minimized, etc. - CSignal metadataChanged; // title, appid - CSignal destroy; + CSignalT<> stateChanged; // maximized, fs, minimized, etc. + CSignalT<> metadataChanged; // title, appid + CSignalT<> destroy; - CSignal resourceChange; // associated / dissociated + CSignalT<> resourceChange; // associated / dissociated - CSignal setGeometry; - CSignal configureRequest; // CBox + CSignalT<> setGeometry; + CSignalT configureRequest; - CSignal map; - CSignal unmap; - CSignal commit; + CSignalT<> map; + CSignalT<> unmap; + CSignalT<> commit; - CSignal activate; + CSignalT<> activate; } m_events; struct { diff --git a/src/xwayland/XWM.cpp b/src/xwayland/XWM.cpp index 2854647dd..a2461bb26 100644 --- a/src/xwayland/XWM.cpp +++ b/src/xwayland/XWM.cpp @@ -984,9 +984,8 @@ CXWM::CXWM() : m_connection(makeUnique(g_pXWayland->m_server->m_ setActiveWindow(XCB_WINDOW_NONE); initSelection(); - m_listeners.newWLSurface = PROTO::compositor->m_events.newSurface.registerListener([this](std::any d) { onNewSurface(std::any_cast>(d)); }); - m_listeners.newXShellSurface = - PROTO::xwaylandShell->m_events.newSurface.registerListener([this](std::any d) { onNewResource(std::any_cast>(d)); }); + m_listeners.newWLSurface = PROTO::compositor->m_events.newSurface.listen([this](const auto& surface) { onNewSurface(surface); }); + m_listeners.newXShellSurface = PROTO::xwaylandShell->m_events.newSurface.listen([this](const auto& surface) { onNewResource(surface); }); createWMWindow(); @@ -1218,12 +1217,12 @@ void CXWM::initSelection() { createSelectionWindow(m_clipboard.window, "CLIPBOARD_MANAGER"); createSelectionWindow(m_clipboard.window, "CLIPBOARD"); - m_clipboard.listeners.setSelection = g_pSeatManager->m_events.setSelection.registerListener([this](std::any) { m_clipboard.onSelection(); }); - m_clipboard.listeners.keyboardFocusChange = g_pSeatManager->m_events.keyboardFocusChange.registerListener([this](std::any) { m_clipboard.onKeyboardFocus(); }); + m_clipboard.listeners.setSelection = g_pSeatManager->m_events.setSelection.listen([this] { m_clipboard.onSelection(); }); + m_clipboard.listeners.keyboardFocusChange = g_pSeatManager->m_events.keyboardFocusChange.listen([this] { m_clipboard.onKeyboardFocus(); }); createSelectionWindow(m_primarySelection.window, "PRIMARY"); - m_primarySelection.listeners.setSelection = g_pSeatManager->m_events.setPrimarySelection.registerListener([this](std::any) { m_primarySelection.onSelection(); }); - m_primarySelection.listeners.keyboardFocusChange = g_pSeatManager->m_events.keyboardFocusChange.registerListener([this](std::any) { m_primarySelection.onKeyboardFocus(); }); + m_primarySelection.listeners.setSelection = g_pSeatManager->m_events.setPrimarySelection.listen([this] { m_primarySelection.onSelection(); }); + m_primarySelection.listeners.keyboardFocusChange = g_pSeatManager->m_events.keyboardFocusChange.listen([this] { m_primarySelection.onKeyboardFocus(); }); createSelectionWindow(m_dndSelection.window, "XdndAware", true); const uint32_t xdndVersion = XDND_VERSION;