cry/Hyprland
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
outfoxxed 2025-07-08 09:56:40 -07:00 • committed by GitHub
parent 2f34ef141b
commit 78e9eddfb6
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
85 changed files with 667 additions and 865 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/devices/IHID.hpp
View file

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

8
src/devices/IKeyboard.hpp
View file

@ -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 {

26
src/devices/IPointer.hpp
View file

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

12
src/devices/ITouch.hpp
View file

@ -37,14 +37,14 @@ class ITouch : public IHID {
};
struct {
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;
};
};

16
src/devices/Keyboard.cpp
View file

@ -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{

120
src/devices/Mouse.cpp
View file

@ -19,133 +19,109 @@ CMouse::CMouse(SP<Aquamarine::IPointer> mouse_) : m_mouse(mouse_) {
m_isTouchpad = libinput_device_has_capability(handle, LIBINPUT_DEVICE_CAP_POINTER) && libinput_device_get_size(handle, &w, &h) == 0;
}
m_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,
});
});

114
src/devices/Tablet.cpp
View file

@ -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();

18
src/devices/Tablet.hpp
View file

@ -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;
};
};

40
src/devices/TouchDevice.cpp
View file

@ -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();
}

16
src/devices/VirtualKeyboard.cpp
View file

@ -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;

38
src/devices/VirtualPointer.cpp
View file

@ -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 : "";