From 78e9eddfb6bfbc6b103fc60c9831b23ef252886b Mon Sep 17 00:00:00 2001 From: outfoxxed Date: Tue, 8 Jul 2025 09:56:40 -0700 Subject: core: use new typed signals from hu (#10853) --- src/managers/PointerManager.cpp | 172 +++++++++------------------- src/managers/ProtocolManager.cpp | 2 +- src/managers/SeatManager.cpp | 16 +-- src/managers/SeatManager.hpp | 14 +-- src/managers/SessionLockManager.cpp | 23 ++-- src/managers/eventLoop/EventLoopManager.cpp | 2 +- src/managers/input/IdleInhibitor.cpp | 6 +- src/managers/input/InputManager.cpp | 148 ++++++++++-------------- src/managers/input/InputManager.hpp | 6 +- src/managers/input/InputMethodPopup.cpp | 8 +- src/managers/input/InputMethodRelay.cpp | 15 ++- src/managers/input/Tablets.cpp | 66 ++++------- src/managers/input/TextInput.cpp | 27 ++--- 13 files changed, 196 insertions(+), 309 deletions(-) (limited to 'src/managers') diff --git a/src/managers/PointerManager.cpp b/src/managers/PointerManager.cpp index e4455486..f6b08f1b 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->down = touch->m_touchEvents.down.registerListener([] (std::any e) { - auto E = std::any_cast(e); + listener->destroy = touch->m_events.destroy.listen([this] { detachTouch(nullptr); }); - 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 e39dcf4e..193b022c 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 9fe2b26b..76217238 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 6310f0d2..2d73e087 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 f39acf23..bfd819cf 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); - - const auto PMONITOR = SURFACE->monitor(); + m_sessionLock->listeners.newSurface = pLock->m_events.newLockSurface.listen([this](const SP& surface) { + 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 5b2e09d1..357c2fff 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 258b35dc..8c33956b 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 434bd677..4d5bcb28 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)e.surf.get()); + Debug::log(LOG, "cursorImage request: surface {:x}", (uintptr_t)event.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 549a72fa..1696dd0a 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 98131168..71fdd5a4 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 40c87f95..c09d0624 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 b0fe7c64..5a0c5dbe 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 cac64da4..c1ce2062 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) -- cgit v1.2.3