int evdev_device_process_event(struct libinput_event *event) { struct libinput_device *libinput_device = libinput_event_get_device(event); int handled = 1; switch (libinput_event_get_type(event)) { case LIBINPUT_EVENT_KEYBOARD_KEY: handle_keyboard_key(libinput_device, libinput_event_get_keyboard_event(event)); break; case LIBINPUT_EVENT_POINTER_MOTION: handle_pointer_motion(libinput_device, libinput_event_get_pointer_event(event)); break; case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE: handle_pointer_motion_absolute( libinput_device, libinput_event_get_pointer_event(event)); break; case LIBINPUT_EVENT_POINTER_BUTTON: handle_pointer_button(libinput_device, libinput_event_get_pointer_event(event)); break; case LIBINPUT_EVENT_POINTER_AXIS: handle_pointer_axis(libinput_device, libinput_event_get_pointer_event(event)); break; case LIBINPUT_EVENT_TOUCH_DOWN: handle_touch_down(libinput_device, libinput_event_get_touch_event(event)); break; case LIBINPUT_EVENT_TOUCH_MOTION: handle_touch_motion(libinput_device, libinput_event_get_touch_event(event)); break; case LIBINPUT_EVENT_TOUCH_UP: handle_touch_up(libinput_device, libinput_event_get_touch_event(event)); break; case LIBINPUT_EVENT_TOUCH_FRAME: handle_touch_frame(libinput_device, libinput_event_get_touch_event(event)); break; default: handled = 0; weston_log("unknown libinput event %d\n", libinput_event_get_type(event)); } return handled; }
void LibinputServer::handleTouchEvent(struct libinput_event *event, Input::TouchEvent::Type type) { auto* touchEvent = libinput_event_get_touch_event(event); uint32_t time = libinput_event_touch_get_time(touchEvent); int id = libinput_event_touch_get_slot(touchEvent); auto& targetPoint = m_touchEvents[id]; int32_t x, y; if (type != Input::TouchEvent::Up) { x = libinput_event_touch_get_x_transformed(touchEvent, m_pointerBounds.first); y = libinput_event_touch_get_y_transformed(touchEvent, m_pointerBounds.second); } else { // libinput can't return pointer position on touch-up x = targetPoint.x; y = targetPoint.y; } targetPoint = Input::TouchEvent::Raw{ type, time, id, x, y }; m_client->handleTouchEvent({ m_touchEvents, type, id, time }); if (type == Input::TouchEvent::Up) { targetPoint = Input::TouchEvent::Raw{ Input::TouchEvent::Null, 0, -1, -1, -1 }; } }
static int input_event(int fd, uint32_t mask, void *data) { (void)fd, (void)mask; struct input *input = data; if (libinput_dispatch(input->handle) != 0) wlc_log(WLC_LOG_WARN, "Failed to dispatch libinput"); struct libinput_event *event; while ((event = libinput_get_event(input->handle))) { struct libinput *handle = libinput_event_get_context(event); struct libinput_device *device = libinput_event_get_device(event); (void)handle; switch (libinput_event_get_type(event)) { case LIBINPUT_EVENT_DEVICE_ADDED: WLC_INTERFACE_EMIT(input.created, device); break; case LIBINPUT_EVENT_DEVICE_REMOVED: WLC_INTERFACE_EMIT(input.destroyed, device); break; case LIBINPUT_EVENT_POINTER_MOTION: { struct libinput_event_pointer *pev = libinput_event_get_pointer_event(event); struct wlc_input_event ev = {0}; ev.type = WLC_INPUT_EVENT_MOTION; ev.time = libinput_event_pointer_get_time(pev); ev.motion.dx = libinput_event_pointer_get_dx(pev); ev.motion.dy = libinput_event_pointer_get_dy(pev); wl_signal_emit(&wlc_system_signals()->input, &ev); } break; case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE: { struct libinput_event_pointer *pev = libinput_event_get_pointer_event(event); struct wlc_input_event ev = {0}; ev.type = WLC_INPUT_EVENT_MOTION_ABSOLUTE; ev.time = libinput_event_pointer_get_time(pev); ev.motion_abs.x = pointer_abs_x; ev.motion_abs.y = pointer_abs_y; ev.motion_abs.internal = pev; wl_signal_emit(&wlc_system_signals()->input, &ev); } break; case LIBINPUT_EVENT_POINTER_BUTTON: { struct libinput_event_pointer *pev = libinput_event_get_pointer_event(event); struct wlc_input_event ev = {0}; ev.type = WLC_INPUT_EVENT_BUTTON; ev.time = libinput_event_pointer_get_time(pev); ev.button.code = libinput_event_pointer_get_button(pev); ev.button.state = (enum wl_pointer_button_state)libinput_event_pointer_get_button_state(pev); wl_signal_emit(&wlc_system_signals()->input, &ev); } break; case LIBINPUT_EVENT_POINTER_AXIS: { struct libinput_event_pointer *pev = libinput_event_get_pointer_event(event); struct wlc_input_event ev = {0}; ev.type = WLC_INPUT_EVENT_SCROLL; ev.time = libinput_event_pointer_get_time(pev); #if LIBINPUT_VERSION_MAJOR == 0 && LIBINPUT_VERSION_MINOR < 8 /* < libinput 0.8.x (at least to 0.6.x) */ const enum wl_pointer_axis axis = libinput_event_pointer_get_axis(pev); ev.scroll.amount[(axis == LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL)] = libinput_event_pointer_get_axis_value(pev); ev.scroll.axis_bits |= (axis == LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL ? WLC_SCROLL_AXIS_HORIZONTAL : WLC_SCROLL_AXIS_VERTICAL); #else /* > libinput 0.8.0 */ if (libinput_event_pointer_has_axis(pev, LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL)) { ev.scroll.amount[0] = libinput_event_pointer_get_axis_value(pev, LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL); ev.scroll.axis_bits |= WLC_SCROLL_AXIS_VERTICAL; } if (libinput_event_pointer_has_axis(pev, LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL)) { ev.scroll.amount[1] = libinput_event_pointer_get_axis_value(pev, LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL); ev.scroll.axis_bits |= WLC_SCROLL_AXIS_HORIZONTAL; } #endif // We should get other axis information from libinput as well, like source (finger, wheel) (v0.8) wl_signal_emit(&wlc_system_signals()->input, &ev); } break; case LIBINPUT_EVENT_KEYBOARD_KEY: { struct libinput_event_keyboard *kev = libinput_event_get_keyboard_event(event); struct wlc_input_event ev = {0}; ev.type = WLC_INPUT_EVENT_KEY; ev.time = libinput_event_keyboard_get_time(kev); ev.key.code = libinput_event_keyboard_get_key(kev); ev.key.state = (enum wl_keyboard_key_state)libinput_event_keyboard_get_key_state(kev); ev.device = device; wl_signal_emit(&wlc_system_signals()->input, &ev); } break; case LIBINPUT_EVENT_TOUCH_UP: { struct libinput_event_touch *tev = libinput_event_get_touch_event(event); struct wlc_input_event ev = {0}; ev.type = WLC_INPUT_EVENT_TOUCH; ev.time = libinput_event_touch_get_time(tev); ev.touch.type = wlc_touch_type_for_libinput_type(libinput_event_get_type(event)); ev.touch.slot = libinput_event_touch_get_seat_slot(tev); wl_signal_emit(&wlc_system_signals()->input, &ev); } break; case LIBINPUT_EVENT_TOUCH_DOWN: case LIBINPUT_EVENT_TOUCH_MOTION: { struct libinput_event_touch *tev = libinput_event_get_touch_event(event); struct wlc_input_event ev = {0}; ev.type = WLC_INPUT_EVENT_TOUCH; ev.time = libinput_event_touch_get_time(tev); ev.touch.type = wlc_touch_type_for_libinput_type(libinput_event_get_type(event)); ev.touch.x = touch_abs_x; ev.touch.y = touch_abs_y; ev.touch.internal = tev; ev.touch.slot = libinput_event_touch_get_seat_slot(tev); wl_signal_emit(&wlc_system_signals()->input, &ev); } break; case LIBINPUT_EVENT_TOUCH_FRAME: case LIBINPUT_EVENT_TOUCH_CANCEL: { struct libinput_event_touch *tev = libinput_event_get_touch_event(event); struct wlc_input_event ev = {0}; ev.type = WLC_INPUT_EVENT_TOUCH; ev.time = libinput_event_touch_get_time(tev); ev.touch.type = wlc_touch_type_for_libinput_type(libinput_event_get_type(event)); wl_signal_emit(&wlc_system_signals()->input, &ev); } break; default: break; } libinput_event_destroy(event); } return 0; }
inline void LibInputHandler::HandleEvent(struct libinput_event *li_event) { int type = libinput_event_get_type(li_event); switch (type) { case LIBINPUT_EVENT_KEYBOARD_KEY: { /* Discard all data on stdin to avoid that keyboard input data is read * on the executing shell. */ tcflush(STDIN_FILENO, TCIFLUSH); libinput_event_keyboard *kb_li_event = libinput_event_get_keyboard_event(li_event); uint32_t key_code = libinput_event_keyboard_get_key(kb_li_event); libinput_key_state key_state = libinput_event_keyboard_get_key_state(kb_li_event); queue.Push(Event(key_state == LIBINPUT_KEY_STATE_PRESSED ? Event::KEY_DOWN : Event::KEY_UP, key_code)); } break; case LIBINPUT_EVENT_POINTER_MOTION: { libinput_event_pointer *ptr_li_event = libinput_event_get_pointer_event(li_event); if (-1.0 == x) x = 0.0; if (-1.0 == y) y = 0.0; x += libinput_event_pointer_get_dx(ptr_li_event); x = Clamp<double>(x, 0, width); y += libinput_event_pointer_get_dy(ptr_li_event); y = Clamp<double>(y, 0, height); queue.Push(Event(Event::MOUSE_MOTION, (unsigned) x, (unsigned) y)); } break; case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE: { libinput_event_pointer *ptr_li_event = libinput_event_get_pointer_event(li_event); x = libinput_event_pointer_get_absolute_x_transformed(ptr_li_event, width); y = libinput_event_pointer_get_absolute_y_transformed(ptr_li_event, height); queue.Push(Event(Event::MOUSE_MOTION, (unsigned) x, (unsigned) y)); } break; case LIBINPUT_EVENT_POINTER_BUTTON: { libinput_event_pointer *ptr_li_event = libinput_event_get_pointer_event(li_event); libinput_button_state btn_state = libinput_event_pointer_get_button_state(ptr_li_event); queue.Push(Event(btn_state == LIBINPUT_BUTTON_STATE_PRESSED ? Event::MOUSE_DOWN : Event::MOUSE_UP, (unsigned) x, (unsigned) y)); } break; case LIBINPUT_EVENT_POINTER_AXIS: { libinput_event_pointer *ptr_li_event = libinput_event_get_pointer_event(li_event); double axis_value = libinput_event_pointer_get_axis_value(ptr_li_event); Event event(Event::MOUSE_WHEEL, (unsigned) x, (unsigned) y); event.param = unsigned((int) axis_value); queue.Push(event); } break; case LIBINPUT_EVENT_TOUCH_DOWN: { libinput_event_touch *touch_li_event = libinput_event_get_touch_event(li_event); x = libinput_event_touch_get_x_transformed(touch_li_event, width); y = libinput_event_touch_get_y_transformed(touch_li_event, height); queue.Push(Event(Event::MOUSE_DOWN, (unsigned) x, (unsigned) y)); } break; case LIBINPUT_EVENT_TOUCH_UP: { queue.Push(Event(Event::MOUSE_UP, (unsigned) x, (unsigned) y)); } break; case LIBINPUT_EVENT_TOUCH_MOTION: { libinput_event_touch *touch_li_event = libinput_event_get_touch_event(li_event); x = libinput_event_touch_get_x_transformed(touch_li_event, width); y = libinput_event_touch_get_y_transformed(touch_li_event, height); queue.Push(Event(Event::MOUSE_MOTION, (unsigned) x, (unsigned) y)); } break; } }
void LibInputHandlerPrivate::_q_liEventHandler() { Q_Q(LibInputHandler); if (libinput_dispatch(li) != 0) { qCWarning(lcInput) << "Failed to dispatch libinput events"; return; } libinput_event *event; while ((event = libinput_get_event(li)) != Q_NULLPTR) { libinput_event_type type = libinput_event_get_type(event); libinput_device *device = libinput_event_get_device(event); switch (type) { // Devices case LIBINPUT_EVENT_DEVICE_ADDED: if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_KEYBOARD)) { ++keyboardCount; Q_EMIT q->capabilitiesChanged(); Q_EMIT q->keyboardCountChanged(keyboardCount); } if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_POINTER)) { ++pointerCount; Q_EMIT q->capabilitiesChanged(); Q_EMIT q->pointerCountChanged(pointerCount); } if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_TOUCH)) { QTouchDevice *td = touch->registerDevice(device); Q_EMIT q->touchDeviceRegistered(td); ++touchCount; Q_EMIT q->capabilitiesChanged(); Q_EMIT q->touchCountChanged(touchCount); } if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_GESTURE)) { ++gestureCount; Q_EMIT q->capabilitiesChanged(); Q_EMIT q->gestureCountChanged(gestureCount); } break; case LIBINPUT_EVENT_DEVICE_REMOVED: if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_KEYBOARD)) { --keyboardCount; Q_EMIT q->capabilitiesChanged(); Q_EMIT q->keyboardCountChanged(keyboardCount); } if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_POINTER)) { --pointerCount; Q_EMIT q->capabilitiesChanged(); Q_EMIT q->pointerCountChanged(pointerCount); } if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_TOUCH)) { QTouchDevice *td = Q_NULLPTR; touch->unregisterDevice(device, &td); Q_EMIT q->touchDeviceUnregistered(td); --touchCount; Q_EMIT q->capabilitiesChanged(); Q_EMIT q->touchCountChanged(touchCount); } if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_GESTURE)) { --gestureCount; Q_EMIT q->capabilitiesChanged(); Q_EMIT q->gestureCountChanged(gestureCount); } break; // Keyboard case LIBINPUT_EVENT_KEYBOARD_KEY: keyboard->handleKey(libinput_event_get_keyboard_event(event)); break; // Pointer case LIBINPUT_EVENT_POINTER_BUTTON: pointer->handleButton(libinput_event_get_pointer_event(event)); break; case LIBINPUT_EVENT_POINTER_AXIS: pointer->handleAxis(libinput_event_get_pointer_event(event)); break; case LIBINPUT_EVENT_POINTER_MOTION: pointer->handleMotion(libinput_event_get_pointer_event(event)); break; case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE: pointer->handleAbsoluteMotion(libinput_event_get_pointer_event(event)); break; // Touch case LIBINPUT_EVENT_TOUCH_UP: touch->handleTouchUp(libinput_event_get_touch_event(event)); break; case LIBINPUT_EVENT_TOUCH_DOWN: touch->handleTouchDown(libinput_event_get_touch_event(event)); break; case LIBINPUT_EVENT_TOUCH_FRAME: touch->handleTouchFrame(libinput_event_get_touch_event(event)); break; case LIBINPUT_EVENT_TOUCH_MOTION: touch->handleTouchMotion(libinput_event_get_touch_event(event)); break; case LIBINPUT_EVENT_TOUCH_CANCEL: touch->handleTouchCancel(libinput_event_get_touch_event(event)); break; // Gesture case LIBINPUT_EVENT_GESTURE_PINCH_BEGIN: gesture->handlePinchBegin(libinput_event_get_gesture_event(event)); break; case LIBINPUT_EVENT_GESTURE_PINCH_END: gesture->handlePinchEnd(libinput_event_get_gesture_event(event)); break; case LIBINPUT_EVENT_GESTURE_PINCH_UPDATE: gesture->handlePinchUpdate(libinput_event_get_gesture_event(event)); break; case LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN: gesture->handleSwipeBegin(libinput_event_get_gesture_event(event)); break; case LIBINPUT_EVENT_GESTURE_SWIPE_END: gesture->handleSwipeEnd(libinput_event_get_gesture_event(event)); break; case LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE: gesture->handleSwipeUpdate(libinput_event_get_gesture_event(event)); break; default: break; } libinput_event_destroy(event); } }