json_object *ipc_json_describe_input(struct libinput_device *device) {
char* identifier = libinput_dev_unique_id(device);
int vendor = libinput_device_get_id_vendor(device);
int product = libinput_device_get_id_product(device);
const char *name = libinput_device_get_name(device);
double width = -1, height = -1;
int has_size = libinput_device_get_size(device, &width, &height);
json_object *device_object = json_object_new_object();
json_object_object_add(device_object,"identifier",
identifier ? json_object_new_string(identifier) : NULL);
json_object_object_add(device_object,
"vendor", json_object_new_int(vendor));
json_object_object_add(device_object,
"product", json_object_new_int(product));
json_object_object_add(device_object,
"name", json_object_new_string(name));
if (has_size == 0) {
json_object *size_object = json_object_new_object();
json_object_object_add(size_object,
"width", json_object_new_double(width));
json_object_object_add(size_object,
"height", json_object_new_double(height));
} else {
json_object_object_add(device_object, "size", NULL);
}
struct {
enum libinput_device_capability cap;
const char *name;
// If anyone feels like implementing device-specific IPC output,
// be my guest
json_object *(*describe)(struct libinput_device *);
} caps[] = {
{ LIBINPUT_DEVICE_CAP_KEYBOARD, "keyboard", NULL },
{ LIBINPUT_DEVICE_CAP_POINTER, "pointer", NULL },
{ LIBINPUT_DEVICE_CAP_TOUCH, "touch", NULL },
{ LIBINPUT_DEVICE_CAP_TABLET_TOOL, "tablet_tool", NULL },
{ LIBINPUT_DEVICE_CAP_TABLET_PAD, "tablet_pad", NULL },
{ LIBINPUT_DEVICE_CAP_GESTURE, "gesture", NULL },
#ifdef LIBINPUT_DEVICE_CAP_SWITCH // libinput 1.7.0+
{ LIBINPUT_DEVICE_CAP_SWITCH, "switch", NULL },
#endif
};
json_object *_caps = json_object_new_array();
for (size_t i = 0; i < sizeof(caps) / sizeof(caps[0]); ++i) {
if (libinput_device_has_capability(device, caps[i].cap)) {
json_object_array_add(_caps, json_object_new_string(caps[i].name));
if (caps[i].describe) {
json_object *desc = caps[i].describe(device);
json_object_object_add(device_object, caps[i].name, desc);
}
}
}
json_object_object_add(device_object, "capabilities", _caps);
free(identifier);
return device_object;
}
ClutterInputDeviceType
_clutter_input_device_evdev_determine_type (struct libinput_device *ldev)
{
/* This setting is specific to touchpads and alike, only in these
* devices there is this additional layer of touch event interpretation.
*/
if (libinput_device_config_tap_get_finger_count (ldev) > 0)
return CLUTTER_TOUCHPAD_DEVICE;
else if (libinput_device_has_capability (ldev, LIBINPUT_DEVICE_CAP_POINTER))
return CLUTTER_POINTER_DEVICE;
else if (libinput_device_has_capability (ldev, LIBINPUT_DEVICE_CAP_TOUCH))
return CLUTTER_TOUCHSCREEN_DEVICE;
else if (libinput_device_has_capability (ldev, LIBINPUT_DEVICE_CAP_KEYBOARD))
return CLUTTER_KEYBOARD_DEVICE;
else
return CLUTTER_EXTENSION_DEVICE;
}
/*
* _clutter_input_device_evdev_new:
* @manager: the device manager
* @seat: the seat the device will belong to
* @libinput_device: the libinput device
*
* Create a new ClutterInputDevice given a libinput device and associate
* it with the provided seat.
*/
ClutterInputDevice *
_clutter_input_device_evdev_new (ClutterDeviceManager *manager,
ClutterSeatEvdev *seat,
struct libinput_device *libinput_device)
{
ClutterInputDeviceEvdev *device;
ClutterInputDeviceType type;
ClutterDeviceManagerEvdev *manager_evdev;
gchar *vendor, *product;
gint device_id, n_rings = 0, n_strips = 0, n_groups = 1;
gchar *node_path;
gdouble width, height;
type = _clutter_input_device_evdev_determine_type (libinput_device);
vendor = g_strdup_printf ("%.4x", libinput_device_get_id_vendor (libinput_device));
product = g_strdup_printf ("%.4x", libinput_device_get_id_product (libinput_device));
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (manager);
device_id = _clutter_device_manager_evdev_acquire_device_id (manager_evdev);
node_path = g_strdup_printf ("/dev/input/%s", libinput_device_get_sysname (libinput_device));
if (libinput_device_has_capability (libinput_device,
LIBINPUT_DEVICE_CAP_TABLET_PAD))
{
n_rings = libinput_device_tablet_pad_get_num_rings (libinput_device);
n_strips = libinput_device_tablet_pad_get_num_strips (libinput_device);
n_groups = libinput_device_tablet_pad_get_num_mode_groups (libinput_device);
}
device = g_object_new (CLUTTER_TYPE_INPUT_DEVICE_EVDEV,
"id", device_id,
"name", libinput_device_get_name (libinput_device),
"device-manager", manager,
"device-type", type,
"device-mode", CLUTTER_INPUT_MODE_SLAVE,
"enabled", TRUE,
"vendor-id", vendor,
"product-id", product,
"n-rings", n_rings,
"n-strips", n_strips,
"n-mode-groups", n_groups,
"device-node", node_path,
NULL);
device->seat = seat;
device->libinput_device = libinput_device;
libinput_device_set_user_data (libinput_device, device);
libinput_device_ref (libinput_device);
g_free (vendor);
g_free (product);
g_free (node_path);
if (libinput_device_get_size (libinput_device, &width, &height) == 0)
device->device_aspect_ratio = width / height;
return CLUTTER_INPUT_DEVICE (device);
}
END_TEST
START_TEST(device_wheel_only)
{
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
ck_assert(libinput_device_has_capability(device,
LIBINPUT_DEVICE_CAP_POINTER));
}
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);
}
}
static void
print_device_notify(struct libinput_event *ev)
{
struct libinput_device *dev = libinput_event_get_device(ev);
struct libinput_seat *seat = libinput_device_get_seat(dev);
struct libinput_device_group *group;
double w, h;
static int next_group_id = 0;
intptr_t group_id;
const char *devnode;
char *str;
group = libinput_device_get_device_group(dev);
group_id = (intptr_t)libinput_device_group_get_user_data(group);
if (!group_id) {
group_id = ++next_group_id;
libinput_device_group_set_user_data(group, (void*)group_id);
}
devnode = udev_device_get_devnode(
libinput_device_get_udev_device(dev));
printf("Device: %s\n"
"Kernel: %s\n"
"Group: %d\n"
"Seat: %s, %s\n",
libinput_device_get_name(dev),
devnode,
(int)group_id,
libinput_seat_get_physical_name(seat),
libinput_seat_get_logical_name(seat));
if (libinput_device_get_size(dev, &w, &h) == 0)
printf("Size: %.2fx%.2fmm\n", w, h);
printf("Capabilities: ");
if (libinput_device_has_capability(dev,
LIBINPUT_DEVICE_CAP_KEYBOARD))
printf("keyboard ");
if (libinput_device_has_capability(dev,
LIBINPUT_DEVICE_CAP_POINTER))
printf("pointer ");
if (libinput_device_has_capability(dev,
LIBINPUT_DEVICE_CAP_TOUCH))
printf("touch");
printf("\n");
printf("Tap-to-click: %s\n", tap_default(dev));
printf("Left-handed: %s\n", left_handed_default(dev));
printf("Nat.scrolling: %s\n", nat_scroll_default(dev));
str = calibration_default(dev);
printf("Calibration: %s\n", str);
free(str);
str = scroll_defaults(dev);
printf("Scroll methods: %s\n", str);
free(str);
str = click_defaults(dev);
printf("Click methods: %s\n", str);
free(str);
printf("\n");
}
