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

11 files changed, 183 insertions, 235 deletions

diff --git a/src/devices/IHID.hpp b/src/devices/IHID.hpp
index 4de5abe6..c57778ff 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 c66aee27..25a7efd1 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<SKeyEvent>       key;
+        CSignalT<SModifiersEvent> modifiers;
+        CSignalT<SKeymapEvent>    keymap;
+        CSignalT<>                repeatInfo;
     } m_keyboardEvents;
 
     struct SStringRuleNames {
diff --git a/src/devices/IPointer.hpp b/src/devices/IPointer.hpp
index 993095e0..e5d76344 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;
-
-        CSignal swipeBegin;
-        CSignal swipeEnd;
-        CSignal swipeUpdate;
-
-        CSignal pinchBegin;
-        CSignal pinchEnd;
-        CSignal pinchUpdate;
-
-        CSignal holdBegin;
-        CSignal holdEnd;
+        CSignalT<SMotionEvent>         motion;
+        CSignalT<SMotionAbsoluteEvent> motionAbsolute;
+        CSignalT<SButtonEvent>         button;
+        CSignalT<SAxisEvent>           axis;
+        CSignalT<>                     frame;
+
+        CSignalT<SSwipeBeginEvent>     swipeBegin;
+        CSignalT<SSwipeEndEvent>       swipeEnd;
+        CSignalT<SSwipeUpdateEvent>    swipeUpdate;
+
+        CSignalT<SPinchBeginEvent>     pinchBegin;
+        CSignalT<SPinchEndEvent>       pinchEnd;
+        CSignalT<SPinchUpdateEvent>    pinchUpdate;
+
+        CSignalT<SHoldBeginEvent>      holdBegin;
+        CSignalT<SHoldEndEvent>        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 e5230394..14803011 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<SDownEvent>   down;
+        CSignalT<SUpEvent>     up;
+        CSignalT<SMotionEvent> motion;
+        CSignalT<SCancelEvent> cancel;
+        CSignalT<>             frame;
     } m_touchEvents;
 
     std::string m_boundOutput = "";
 
     WP<ITouch>  m_self;
-};
\ No newline at end of file
+};
diff --git a/src/devices/Keyboard.cpp b/src/devices/Keyboard.cpp
index 70abe54d..9ce37e6b 100644
--- a/src/devices/Keyboard.cpp
+++ b/src/devices/Keyboard.cpp
@@ -23,24 +23,22 @@ CKeyboard::CKeyboard(SP<Aquamarine::IKeyboard> 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<Aquamarine::IKeyboard::SKeyEvent>(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 539aecf7..b9cf9ffc 100644
--- a/src/devices/Mouse.cpp
+++ b/src/devices/Mouse.cpp
@@ -19,133 +19,109 @@ CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : m_mouse(mouse_) {
         m_isTouchpad = libinput_device_has_capability(handle, LIBINPUT_DEVICE_CAP_POINTER) && libinput_device_get_size(handle, &w, &h) == 0;
     }
 
-    m_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<Aquamarine::IPointer::SMoveEvent>(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<Aquamarine::IPointer::SWarpEvent>(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<Aquamarine::IPointer::SButtonEvent>(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<Aquamarine::IPointer::SAxisEvent>(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<Aquamarine::IPointer::SSwipeBeginEvent>(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<Aquamarine::IPointer::SSwipeEndEvent>(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<Aquamarine::IPointer::SSwipeUpdateEvent>(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<Aquamarine::IPointer::SPinchBeginEvent>(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<Aquamarine::IPointer::SPinchEndEvent>(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<Aquamarine::IPointer::SPinchUpdateEvent>(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<Aquamarine::IPointer::SHoldBeginEvent>(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<Aquamarine::IPointer::SHoldEndEvent>(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 faeb3d73..cbda1a71 100644
--- a/src/devices/Tablet.cpp
+++ b/src/devices/Tablet.cpp
@@ -69,63 +69,55 @@ CTablet::CTablet(SP<Aquamarine::ITablet> 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<Aquamarine::ITablet::SAxisEvent>(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<Aquamarine::ITablet::SProximityEvent>(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<Aquamarine::ITablet::STipEvent>(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<Aquamarine::ITablet::SButtonEvent>(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<Aquamarine::ITabletPad> 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<Aquamarine::ITabletPad::SButtonEvent>(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<Aquamarine::ITabletPad::SRingEvent>(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<Aquamarine::ITabletPad::SStripEvent>(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<Aquamarine::ITabletTool> 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<CWLSurfaceResource> 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 b98c7f85..b5e55c19 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<SAxisEvent>      axis;
+        CSignalT<SProximityEvent> proximity;
+        CSignalT<STipEvent>       tip;
+        CSignalT<SButtonEvent>    button;
     } m_tabletEvents;
 
     WP<CTablet> m_self;
@@ -144,10 +144,10 @@ class CTabletPad : public IHID {
     };
 
     struct {
-        CSignal button;
-        CSignal ring;
-        CSignal strip;
-        CSignal attach;
+        CSignalT<SButtonEvent>    button;
+        CSignalT<SRingEvent>      ring;
+        CSignalT<SStripEvent>     strip;
+        CSignalT<SP<CTabletTool>> attach;
     } m_padEvents;
 
     WP<CTabletPad>  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 c2ff4d6f..527cb02a 100644
--- a/src/devices/TouchDevice.cpp
+++ b/src/devices/TouchDevice.cpp
@@ -14,51 +14,43 @@ CTouchDevice::CTouchDevice(SP<Aquamarine::ITouch> 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<Aquamarine::ITouch::SDownEvent>(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<Aquamarine::ITouch::SUpEvent>(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<Aquamarine::ITouch::SMotionEvent>(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<Aquamarine::ITouch::SCancelEvent>(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 9952847a..ea21a22b 100644
--- a/src/devices/VirtualKeyboard.cpp
+++ b/src/devices/VirtualKeyboard.cpp
@@ -14,15 +14,14 @@ CVirtualKeyboard::CVirtualKeyboard(SP<CVirtualKeyboardV1Resource> 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<SModifiersEvent>(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<CVirtualKeyboardV1Resource> keeb_) : m_key
             .group     = m_modifiersState.group,
         });
     });
-    m_listeners.keymap    = keeb_->m_events.keymap.registerListener([this](std::any d) {
-        auto E = std::any_cast<SKeymapEvent>(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 2b42b21c..23d860bf 100644
--- a/src/devices/VirtualPointer.cpp
+++ b/src/devices/VirtualPointer.cpp
@@ -14,33 +14,31 @@ CVirtualPointer::CVirtualPointer(SP<CVirtualPointerV1Resource> 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<SMotionEvent>(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<SMotionAbsoluteEvent>(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 : "";