2 #include "e_input_private.h"
4 static void _device_modifiers_update(E_Input_Evdev *edev);
5 static void _device_configured_size_get(E_Input_Evdev *edev, int *x, int *y, int *w, int *h);
6 static void _device_output_assign(E_Input_Evdev *edev, E_Input_Seat_Capabilities cap);
9 _device_calibration_set(E_Input_Evdev *edev)
14 E_Comp_Config *comp_conf;
16 if (e_comp->e_comp_screen->num_outputs > 1) //multiple outputs
18 comp_conf = e_comp_config_get();
19 if (comp_conf && (comp_conf->input_output_assign_policy == 1)) //use output-assignment policy
21 _device_output_assign(edev, E_INPUT_SEAT_POINTER);
22 _device_output_assign(edev, E_INPUT_SEAT_TOUCH);
26 output = e_comp_screen_primary_output_get(e_comp->e_comp_screen);
27 e_output_size_get(output, &w, &h);
31 edev->mouse.minx = edev->mouse.miny = 0;
35 if (libinput_device_has_capability(edev->device, LIBINPUT_DEVICE_CAP_POINTER))
37 edev->seat->ptr.dx = (double)(w / 2);
38 edev->seat->ptr.dy = (double)(h / 2);
39 edev->seat->ptr.ix = (int)edev->seat->ptr.dx;
40 edev->seat->ptr.iy = (int)edev->seat->ptr.dy;
41 edev->mouse.dx = edev->seat->ptr.dx;
42 edev->mouse.dy = edev->seat->ptr.dy;
44 if (output->config.rotation == 90 || output->config.rotation == 270)
46 temp = edev->mouse.minx;
47 edev->mouse.minx = edev->mouse.miny;
48 edev->mouse.miny = temp;
50 temp = edev->mouse.maxw;
51 edev->mouse.maxw = edev->mouse.maxh;
52 edev->mouse.maxh = temp;
58 #ifdef _F_E_INPUT_ENABLE_DEVICE_CALIBRATION_
64 if ((!libinput_device_config_calibration_has_matrix(edev->device)) ||
65 (libinput_device_config_calibration_get_default_matrix(edev->device, cal) != 0))
68 sysname = libinput_device_get_sysname(edev->device);
70 devices = eeze_udev_find_by_subsystem_sysname("input", sysname);
71 if (eina_list_count(devices) < 1) return;
73 #ifdef _F_E_INPUT_USE_WL_CALIBRATION_
75 enum libinput_config_status status;
77 EINA_LIST_FREE(devices, device)
79 vals = eeze_udev_syspath_get_property(device, "WL_CALIBRATION");
81 (sscanf(vals, "%f %f %f %f %f %f",
82 &cal[0], &cal[1], &cal[2], &cal[3], &cal[4], &cal[5]) != 6))
89 libinput_device_config_calibration_set_matrix(edev->device, cal);
91 if (status != LIBINPUT_CONFIG_STATUS_SUCCESS)
92 ERR("Failed to apply calibration");
95 eina_stringshare_del(device);
98 #endif//_F_E_INPUT_USE_WL_CALIBRATION_
99 #endif//_F_E_INPUT_ENABLE_DEVICE_CALIBRATION_
104 _device_output_assign(E_Input_Evdev *edev, E_Input_Seat_Capabilities cap)
109 Eina_Bool need_assign_output = EINA_FALSE;
110 const char *output_name;
113 if (!(edev->caps & cap)) return;
114 if (edev->output_name) return; //already assigned
115 if (e_comp->e_comp_screen->num_outputs <= 1) return;
117 last_output_idx = e_comp->e_comp_screen->num_outputs - 1;
118 EINA_LIST_FOREACH(edev->seat->devices, l, ed)
120 if (!(ed->caps & cap)) continue;
121 if (ed == edev) continue;
124 need_assign_output = EINA_FALSE;
127 need_assign_output = EINA_TRUE;
129 if (need_assign_output)
131 output = e_output_find_by_index(last_output_idx);
132 if (!output || !output->info.connected) return;
133 output_name = e_output_output_id_get(output);
134 if (output_name) edev->output_name = eina_stringshare_add(output_name);
135 ELOGF("E_INPUT_EVDEV", "Device is assigned to output:%s", NULL, output_name);
140 _device_touch_count_update(E_Input_Evdev *edev)
142 unsigned int device_touch_count = 0;
143 static unsigned int _max_device_touch_count = 0;
145 E_Input *ei = e_input_get();
146 EINA_SAFETY_ON_NULL_RETURN(ei);
148 device_touch_count = libinput_device_touch_get_touch_count(edev->device);
150 if (_max_device_touch_count < device_touch_count)
151 _max_device_touch_count = device_touch_count;
153 if (e_config->configured_max_touch.use)
155 if (_max_device_touch_count > 0 && e_config->configured_max_touch.count > _max_device_touch_count)
157 ELOGF("E_INPUT_EVDEV_TOUCH", "Touch max count(%d) must be less or equal to device's touch count(%d) !\nTouch max count has been shrinken to %d.\n",
158 NULL, e_config->configured_max_touch.count, _max_device_touch_count, _max_device_touch_count);
159 ei->touch_max_count = _max_device_touch_count;
163 if (ei->touch_max_count != e_config->configured_max_touch.count)
165 ELOGF("E_INPUT_EVDEV_TOUCH", "Touch_max_count has been updated to %d -> %d.\n",
166 NULL, ei->touch_max_count, e_config->configured_max_touch.count);
167 ei->touch_max_count = e_config->configured_max_touch.count;
173 if (ei->touch_max_count < _max_device_touch_count)
175 ELOGF("E_INPUT_EVDEV_TOUCH", "Touch_max_count has been updated to %d -> %d.\n", NULL,
176 ei->touch_max_count, _max_device_touch_count);
177 ei->touch_max_count = _max_device_touch_count;
181 ei->touch_device_count++;
182 ELOGF("E_INPUT_EVDEV_TOUCH", "Touch device count is %d.\n", NULL, ei->touch_device_count);
186 _device_configure(E_Input_Evdev *edev)
188 if (libinput_device_config_tap_get_finger_count(edev->device) > 0)
190 Eina_Bool tap = EINA_FALSE;
192 tap = libinput_device_config_tap_get_default_enabled(edev->device);
193 libinput_device_config_tap_set_enabled(edev->device, tap);
196 _device_calibration_set(edev);
200 _device_keyboard_setup(E_Input_Evdev *edev)
202 E_Input_Backend *input;
203 xkb_mod_index_t xkb_idx;
205 if ((!edev) || (!edev->seat)) return;
206 if (!(input = edev->seat->input)) return;
207 if (!input->dev->xkb_ctx) return;
209 /* create keymap from xkb context */
210 edev->xkb.keymap = _e_input_device_cached_keymap_get(input->dev->xkb_ctx, NULL, 0);
211 if (!edev->xkb.keymap)
213 ERR("Failed to create keymap: %m");
217 /* create xkb state */
218 if (!(edev->xkb.state = xkb_state_new(edev->xkb.keymap)))
220 ERR("Failed to create xkb state: %m");
224 xkb_idx = xkb_map_mod_get_index(edev->xkb.keymap, XKB_MOD_NAME_CTRL);
225 if (xkb_idx != XKB_MOD_INVALID)
226 edev->xkb.ctrl_mask = 1 << xkb_idx;
228 edev->xkb.ctrl_mask = 0;
230 xkb_idx = xkb_map_mod_get_index(edev->xkb.keymap, XKB_MOD_NAME_ALT);
231 if (xkb_idx != XKB_MOD_INVALID)
232 edev->xkb.alt_mask = 1 << xkb_idx;
234 edev->xkb.alt_mask = 0;
236 xkb_idx = xkb_map_mod_get_index(edev->xkb.keymap, XKB_MOD_NAME_SHIFT);
237 if (xkb_idx != XKB_MOD_INVALID)
238 edev->xkb.shift_mask = 1 << xkb_idx;
240 edev->xkb.shift_mask = 0;
242 xkb_idx = xkb_map_mod_get_index(edev->xkb.keymap, XKB_MOD_NAME_LOGO);
243 if (xkb_idx != XKB_MOD_INVALID)
244 edev->xkb.win_mask = 1 << xkb_idx;
246 edev->xkb.win_mask = 0;
248 xkb_idx = xkb_map_mod_get_index(edev->xkb.keymap, XKB_LED_NAME_SCROLL);
249 if (xkb_idx != XKB_MOD_INVALID)
250 edev->xkb.scroll_mask = 1 << xkb_idx;
252 edev->xkb.scroll_mask = 0;
254 xkb_idx = xkb_map_mod_get_index(edev->xkb.keymap, XKB_LED_NAME_NUM);
255 if (xkb_idx != XKB_MOD_INVALID)
256 edev->xkb.num_mask = 1 << xkb_idx;
258 edev->xkb.num_mask = 0;
260 xkb_idx = xkb_map_mod_get_index(edev->xkb.keymap, XKB_MOD_NAME_CAPS);
261 if (xkb_idx != XKB_MOD_INVALID)
262 edev->xkb.caps_mask = 1 << xkb_idx;
264 edev->xkb.caps_mask = 0;
266 xkb_idx = xkb_map_mod_get_index(edev->xkb.keymap, "ISO_Level3_Shift");
267 if (xkb_idx != XKB_MOD_INVALID)
268 edev->xkb.altgr_mask = 1 << xkb_idx;
270 edev->xkb.altgr_mask = 0;
274 _device_keysym_translate(xkb_keysym_t keysym, unsigned int modifiers, char *buffer, int bytes)
276 unsigned long hbytes = 0;
279 if (!keysym) return 0;
280 hbytes = (keysym >> 8);
285 (((keysym >= XKB_KEY_BackSpace) && (keysym <= XKB_KEY_Clear)) ||
286 (keysym == XKB_KEY_Return) || (keysym == XKB_KEY_Escape) ||
287 (keysym == XKB_KEY_KP_Space) || (keysym == XKB_KEY_KP_Tab) ||
288 (keysym == XKB_KEY_KP_Enter) ||
289 ((keysym >= XKB_KEY_KP_Multiply) && (keysym <= XKB_KEY_KP_9)) ||
290 (keysym == XKB_KEY_KP_Equal) || (keysym == XKB_KEY_Delete))))))
293 if (keysym == XKB_KEY_KP_Space)
294 c = (XKB_KEY_space & 0x7F);
295 else if (hbytes == 0xFF)
300 if (modifiers & ECORE_EVENT_MODIFIER_CTRL)
302 if (((c >= '@') && (c < '\177')) || c == ' ')
306 else if ((c >= '3') && (c <= '7'))
318 _device_modifiers_update_device(E_Input_Evdev *edev, E_Input_Evdev *from)
322 edev->xkb.depressed =
323 xkb_state_serialize_mods(from->xkb.state, XKB_STATE_DEPRESSED);
325 xkb_state_serialize_mods(from->xkb.state, XKB_STATE_LATCHED);
327 xkb_state_serialize_mods(from->xkb.state, XKB_STATE_LOCKED);
329 xkb_state_serialize_mods(from->xkb.state, XKB_STATE_EFFECTIVE);
331 mask = (edev->xkb.depressed | edev->xkb.latched);
333 if (mask & from->xkb.ctrl_mask)
334 edev->xkb.modifiers |= ECORE_EVENT_MODIFIER_CTRL;
335 if (mask & from->xkb.alt_mask)
336 edev->xkb.modifiers |= ECORE_EVENT_MODIFIER_ALT;
337 if (mask & from->xkb.shift_mask)
338 edev->xkb.modifiers |= ECORE_EVENT_MODIFIER_SHIFT;
339 if (mask & from->xkb.win_mask)
340 edev->xkb.modifiers |= ECORE_EVENT_MODIFIER_WIN;
341 if (mask & from->xkb.scroll_mask)
342 edev->xkb.modifiers |= ECORE_EVENT_LOCK_SCROLL;
343 if (mask & from->xkb.num_mask)
344 edev->xkb.modifiers |= ECORE_EVENT_LOCK_NUM;
345 if (mask & from->xkb.caps_mask)
346 edev->xkb.modifiers |= ECORE_EVENT_LOCK_CAPS;
347 if (mask & from->xkb.altgr_mask)
348 edev->xkb.modifiers |= ECORE_EVENT_MODIFIER_ALTGR;
352 _device_modifiers_update(E_Input_Evdev *edev)
357 edev->xkb.modifiers = 0;
359 if (edev->caps & E_INPUT_SEAT_KEYBOARD)
360 _device_modifiers_update_device(edev, edev);
363 EINA_LIST_FOREACH(edev->seat->devices, l, ed)
365 if (!(ed->caps & E_INPUT_SEAT_KEYBOARD)) continue;
366 _device_modifiers_update_device(edev, ed);
373 _device_remapped_key_get(E_Input_Evdev *edev, int code)
377 EINA_SAFETY_ON_NULL_RETURN_VAL(edev, code);
378 if (!edev->key_remap_enabled) return code;
379 EINA_SAFETY_ON_NULL_RETURN_VAL(edev->key_remap_hash, code);
381 ret = eina_hash_find(edev->key_remap_hash, &code);
383 if (ret) code = (int)(intptr_t)ret;
389 e_input_evdev_get_ecore_device(const char *path, Ecore_Device_Class clas)
391 const Eina_List *dev_list = NULL;
393 Ecore_Device *dev = NULL;
394 const char *identifier;
396 if (!path) return NULL;
398 dev_list = ecore_device_list();
399 if (!dev_list) return NULL;
400 EINA_LIST_FOREACH(dev_list, l, dev)
403 identifier = ecore_device_identifier_get(dev);
404 if (!identifier) continue;
405 if ((ecore_device_class_get(dev) == clas) && !(strcmp(identifier, path)))
412 _e_input_event_mouse_move_cb_free(void *data EINA_UNUSED, void *event)
414 Ecore_Event_Mouse_Move *ev = event;
416 if (ev->dev) ecore_device_unref(ev->dev);
422 _e_input_event_mouse_wheel_cb_free(void *data EINA_UNUSED, void *event)
424 Ecore_Event_Mouse_Wheel *ev = event;
426 if (ev->dev) ecore_device_unref(ev->dev);
432 _e_input_event_mouse_button_cb_free(void *data EINA_UNUSED, void *event)
434 Ecore_Event_Mouse_Button *ev = event;
436 if (ev->dev) ecore_device_unref(ev->dev);
442 _e_input_event_key_cb_free(void *data EINA_UNUSED, void *event)
444 Ecore_Event_Key *ev = event;
446 if (ev->dev) ecore_device_unref(ev->dev);
447 if (ev->data) E_FREE(ev->data);
453 _device_handle_key(struct libinput_device *device, struct libinput_event_keyboard *event)
456 E_Input_Backend *input;
458 uint32_t code, nsyms;
459 const xkb_keysym_t *syms;
460 enum libinput_key_state state;
462 xkb_keysym_t sym = XKB_KEY_NoSymbol;
463 char key[256] = {0, }, keyname[256] = {0, }, compose_buffer[256] = {0, };
465 char *tmp = NULL, *compose = NULL;
466 E_Keyrouter_Event_Data *key_data;
467 Ecore_Device *ecore_dev = NULL, *data;
468 Eina_List *l, *l_next;
469 E_Comp_Config *comp_conf = NULL;
470 int *pressed_keycode = NULL, *idata = NULL;
471 Eina_Bool dup_found = EINA_FALSE;
473 if (!(edev = libinput_device_get_user_data(device)))
478 if (!(input = edev->seat->input))
483 if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
484 else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
486 EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
488 if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_KEYBOARD)
497 edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_KEYBOARD);
498 ecore_dev = edev->ecore_dev;
503 ERR("Failed to get source ecore device from event !\n");
507 timestamp = libinput_event_keyboard_get_time(event);
508 code = libinput_event_keyboard_get_key(event);
509 code = _device_remapped_key_get(edev, code + 8);
510 state = libinput_event_keyboard_get_key_state(event);
511 key_count = libinput_event_keyboard_get_seat_key_count(event);
513 if (state == LIBINPUT_KEY_STATE_PRESSED)
515 if ((edev->seat->dev->blocked & E_INPUT_SEAT_KEYBOARD) ||
516 (edev->seat->dev->server_blocked & E_INPUT_SEAT_KEYBOARD))
518 ELOGF("Key", "Press (keycode: %d, device: %s) is blocked by %p, server: 0x%x", NULL,
519 code, ecore_device_name_get(ecore_dev), edev->seat->dev->blocked_client,
520 edev->seat->dev->server_blocked);
524 /* FIXME: Currently to maintain press/release event pair during input block,
525 * used Eina_List and this is method used in devicemgr module.
526 * But we need to consider which way is better to maintain key press/release pair.
529 EINA_LIST_FOREACH(edev->xkb.pressed_keys, l, idata)
533 dup_found = EINA_TRUE;
539 pressed_keycode = E_NEW(int, 1);
540 EINA_SAFETY_ON_NULL_RETURN(pressed_keycode);
541 *pressed_keycode = code;
543 edev->xkb.pressed_keys = eina_list_append(edev->xkb.pressed_keys, pressed_keycode);
548 dup_found = EINA_FALSE;
549 EINA_LIST_FOREACH_SAFE(edev->xkb.pressed_keys, l, l_next, idata)
553 edev->xkb.pressed_keys = eina_list_remove_list(edev->xkb.pressed_keys, l);
555 dup_found = EINA_TRUE;
561 ELOGF("Key", "Release (keycode: %d, device: %s) is blocked by %p", NULL,
562 code, ecore_device_name_get(ecore_dev), edev->seat->dev->blocked_client);
567 /* ignore key events that are not seat wide state changes */
568 if (((state == LIBINPUT_KEY_STATE_PRESSED) && (key_count != 1)) ||
569 ((state == LIBINPUT_KEY_STATE_RELEASED) && (key_count != 0)))
574 xkb_state_update_key(edev->xkb.state, code,
575 (state ? XKB_KEY_DOWN : XKB_KEY_UP));
577 /* get the keysym for this code */
578 nsyms = xkb_key_get_syms(edev->xkb.state, code, &syms);
579 if (nsyms == 1) sym = syms[0];
581 /* If no keysym was found, name it "Keycode-NNN" */
582 if (sym == XKB_KEY_NoSymbol)
583 snprintf(key, sizeof(key), "Keycode-%u", code);
586 /* get the keyname for this sym */
587 xkb_keysym_get_name(sym, key, sizeof(key));
592 /* If no keyname was found, name it "Keycode-NNN" */
593 snprintf(keyname, sizeof(keyname), "Keycode-%u", code);
597 memcpy(keyname, key, sizeof(keyname));
600 /* if shift is active, we need to transform the key to lower */
601 if (xkb_state_mod_index_is_active(edev->xkb.state,
602 xkb_map_mod_get_index(edev->xkb.keymap,
604 XKB_STATE_MODS_EFFECTIVE))
606 if (keyname[0] != '\0')
607 keyname[0] = tolower(keyname[0]);
610 if (_device_keysym_translate(sym, edev->xkb.modifiers,
611 compose_buffer, sizeof(compose_buffer)))
613 compose = eina_str_convert("ISO8859-1", "UTF-8", compose_buffer);
616 ERR("E Input cannot convert input key string '%s' to UTF-8. "
617 "Is Eina built with iconv support?", compose_buffer);
623 if (!compose) compose = compose_buffer;
625 e = calloc(1, sizeof(Ecore_Event_Key) + strlen(key) + strlen(keyname) +
626 ((compose[0] != '\0') ? strlen(compose) : 0) + 3);
632 key_data = E_NEW(E_Keyrouter_Event_Data, 1);
640 e->keyname = (char *)(e + 1);
641 e->key = e->keyname + strlen(keyname) + 1;
642 e->compose = strlen(compose) ? e->key + strlen(key) + 1 : NULL;
643 e->string = e->compose;
645 strncpy((char *)e->keyname, keyname, strlen(keyname));
646 strncpy((char *)e->key, key, strlen(key));
647 if (strlen(compose)) strncpy((char *)e->compose, compose, strlen(compose));
649 e->window = (Ecore_Window)input->dev->window;
650 e->event_window = (Ecore_Window)input->dev->window;
651 e->root_window = (Ecore_Window)input->dev->window;
652 e->timestamp = timestamp;
657 _device_modifiers_update(edev);
659 e->modifiers = edev->xkb.modifiers;
660 e->dev = ecore_device_ref(ecore_dev);
662 comp_conf = e_comp_config_get();
663 if (comp_conf && comp_conf->input_log_enable)
664 ELOGF("Key", "%s (keyname: %s, keycode: %d, device: %s)", NULL, state?"Press":"Release", e->keyname, e->keycode, ecore_device_name_get(e->dev));
667 ecore_event_add(ECORE_EVENT_KEY_DOWN, e, _e_input_event_key_cb_free, NULL);
669 ecore_event_add(ECORE_EVENT_KEY_UP, e, _e_input_event_key_cb_free, NULL);
675 _device_pointer_motion(E_Input_Evdev *edev, struct libinput_event_pointer *event)
677 E_Input_Backend *input;
678 Ecore_Event_Mouse_Move *ev;
679 Ecore_Device *ecore_dev = NULL, *data, *detent_data = NULL;
681 int x = 0, y = 0, w = 0, h = 0;
683 if (!(input = edev->seat->input)) return;
685 if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
686 else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
688 EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
690 if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_MOUSE)
695 else if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_NONE)
700 if (!ecore_dev && e_devicemgr_detent_is_detent(libinput_device_get_name(edev->device)))
702 ecore_dev = detent_data;
707 edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_MOUSE);
708 ecore_dev = edev->ecore_dev;
713 ERR("Failed to get source ecore device from event !\n");
716 else if ((detent_data == ecore_dev) || e_devicemgr_detent_is_detent(ecore_device_name_get(ecore_dev)))
718 /* Do not process detent device's move events. */
722 if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Move)))) return;
724 _device_configured_size_get(edev, &x, &y, &w, &h);
726 if (edev->seat->ptr.ix < x)
727 edev->seat->ptr.dx = edev->seat->ptr.ix = x;
728 else if (edev->seat->ptr.ix >= (x + w))
729 edev->seat->ptr.dx = edev->seat->ptr.ix = (x + w - 1);
731 if (edev->seat->ptr.iy < y)
732 edev->seat->ptr.dy = edev->seat->ptr.iy = y;
733 else if (edev->seat->ptr.iy >= (y + h))
734 edev->seat->ptr.dy = edev->seat->ptr.iy = (y + h - 1);
736 edev->mouse.dx = edev->seat->ptr.dx;
737 edev->mouse.dy = edev->seat->ptr.dy;
739 ev->window = (Ecore_Window)input->dev->window;
740 ev->event_window = (Ecore_Window)input->dev->window;
741 ev->root_window = (Ecore_Window)input->dev->window;
742 if (event) ev->timestamp = libinput_event_pointer_get_time(event);
745 _device_modifiers_update(edev);
746 ev->modifiers = edev->xkb.modifiers;
748 ev->x = edev->seat->ptr.ix;
749 ev->y = edev->seat->ptr.iy;
753 ev->multi.device = edev->mt_slot;
754 ev->multi.radius = 1;
755 ev->multi.radius_x = 1;
756 ev->multi.radius_y = 1;
757 ev->multi.pressure = 1.0;
758 ev->multi.angle = 0.0;
761 ev->multi.root.x = ev->x;
762 ev->multi.root.y = ev->y;
763 ev->dev = ecore_device_ref(ecore_dev);
765 ecore_event_add(ECORE_EVENT_MOUSE_MOVE, ev, _e_input_event_mouse_move_cb_free, NULL);
769 _e_input_pointer_motion_post(E_Input_Evdev *edev)
771 _device_pointer_motion(edev, NULL);
775 _device_handle_pointer_motion(struct libinput_device *device, struct libinput_event_pointer *event)
780 if (!(edev = libinput_device_get_user_data(device)))
785 if (edev->disable_acceleration)
787 dx = libinput_event_pointer_get_dx_unaccelerated(event);
788 dy = libinput_event_pointer_get_dy_unaccelerated(event);
792 dx = libinput_event_pointer_get_dx(event);
793 dy = libinput_event_pointer_get_dy(event);
796 if (edev->seat->ptr.swap)
802 if (edev->seat->ptr.invert_x)
804 if (edev->seat->ptr.invert_y)
807 edev->seat->ptr.dx += dx;
808 edev->seat->ptr.dy += dy;
810 edev->mouse.dx = edev->seat->ptr.dx;
811 edev->mouse.dy = edev->seat->ptr.dy;
813 if (floor(edev->seat->ptr.dx) == edev->seat->ptr.ix &&
814 floor(edev->seat->ptr.dy) == edev->seat->ptr.iy)
819 edev->seat->ptr.ix = edev->seat->ptr.dx;
820 edev->seat->ptr.iy = edev->seat->ptr.dy;
822 if ((edev->seat->dev->blocked & E_INPUT_SEAT_POINTER) ||
823 (edev->seat->dev->server_blocked & E_INPUT_SEAT_POINTER))
828 _device_pointer_motion(edev, event);
832 _device_handle_pointer_motion_absolute(struct libinput_device *device, struct libinput_event_pointer *event)
837 if (!(edev = libinput_device_get_user_data(device)))
842 e_output_size_get(e_comp_screen_primary_output_get(e_comp->e_comp_screen), &w, &h);
844 edev->mouse.dx = edev->seat->ptr.dx =
845 libinput_event_pointer_get_absolute_x_transformed(event, w);
846 edev->mouse.dy = edev->seat->ptr.dy =
847 libinput_event_pointer_get_absolute_y_transformed(event, h);
849 if (floor(edev->seat->ptr.dx) == edev->seat->ptr.ix &&
850 floor(edev->seat->ptr.dy) == edev->seat->ptr.iy)
855 edev->seat->ptr.ix = edev->seat->ptr.dx;
856 edev->seat->ptr.iy = edev->seat->ptr.dy;
858 if ((edev->seat->dev->blocked & E_INPUT_SEAT_POINTER) ||
859 (edev->seat->dev->server_blocked & E_INPUT_SEAT_POINTER))
864 _device_pointer_motion(edev, event);
868 _device_handle_button(struct libinput_device *device, struct libinput_event_pointer *event)
871 E_Input_Backend *input;
872 Ecore_Event_Mouse_Button *ev;
873 enum libinput_button_state state;
874 uint32_t button, timestamp;
875 Ecore_Device *ecore_dev = NULL, *detent_data = NULL, *data;
877 E_Comp_Config *comp_conf = NULL;
879 if (!(edev = libinput_device_get_user_data(device)))
883 if (!(input = edev->seat->input))
888 if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
889 else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
891 EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
893 if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_MOUSE)
898 else if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_NONE)
903 if (!ecore_dev && e_devicemgr_detent_is_detent(libinput_device_get_name(edev->device)))
905 ecore_dev = detent_data;
910 edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_MOUSE);
911 ecore_dev = edev->ecore_dev;
916 ERR("Failed to get source ecore device from event !\n");
920 state = libinput_event_pointer_get_button_state(event);
921 button = libinput_event_pointer_get_button(event);
922 timestamp = libinput_event_pointer_get_time(event);
924 button = ((button & 0x00F) + 1);
925 if (button == 3) button = 2;
926 else if (button == 2) button = 3;
930 if ((edev->seat->dev->blocked & E_INPUT_SEAT_POINTER) ||
931 (edev->seat->dev->server_blocked & E_INPUT_SEAT_POINTER))
933 ELOGF("Mouse", "Button Press (btn: %d, device: %s) is blocked by %p, server: 0x%x", NULL,
934 button, ecore_device_name_get(ecore_dev), edev->seat->dev->blocked_client,
935 edev->seat->dev->server_blocked);
940 edev->mouse.pressed_button |= (1 << button);
945 if (!(edev->mouse.pressed_button & (1 << button)))
947 ELOGF("Mouse", "Button Release (btn: %d, device: %s) is blocked by %p, server: 0x%x", NULL,
948 button, ecore_device_name_get(ecore_dev), edev->seat->dev->blocked_client,
949 edev->seat->dev->server_blocked);
952 edev->mouse.pressed_button &= ~(1 << button);
955 if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Button))))
960 ev->window = (Ecore_Window)input->dev->window;
961 ev->event_window = (Ecore_Window)input->dev->window;
962 ev->root_window = (Ecore_Window)input->dev->window;
963 ev->timestamp = timestamp;
966 _device_modifiers_update(edev);
967 ev->modifiers = edev->xkb.modifiers;
969 ev->x = edev->seat->ptr.ix;
970 ev->y = edev->seat->ptr.iy;
974 ev->multi.device = edev->mt_slot;
975 ev->multi.radius = 1;
976 ev->multi.radius_x = 1;
977 ev->multi.radius_y = 1;
978 ev->multi.pressure = 1.0;
979 ev->multi.angle = 0.0;
982 ev->multi.root.x = ev->x;
983 ev->multi.root.y = ev->y;
984 ev->dev = ecore_device_ref(ecore_dev);
988 unsigned int current;
991 edev->mouse.did_double = EINA_FALSE;
992 edev->mouse.did_triple = EINA_FALSE;
994 if (((current - edev->mouse.prev) <= edev->mouse.threshold) &&
995 (button == edev->mouse.prev_button))
997 edev->mouse.did_double = EINA_TRUE;
998 if (((current - edev->mouse.last) <= (2 * edev->mouse.threshold)) &&
999 (button == edev->mouse.last_button))
1001 edev->mouse.did_triple = EINA_TRUE;
1002 edev->mouse.prev = 0;
1003 edev->mouse.last = 0;
1008 edev->mouse.last = edev->mouse.prev;
1009 edev->mouse.prev = current;
1010 edev->mouse.last_button = edev->mouse.prev_button;
1011 edev->mouse.prev_button = button;
1014 ev->buttons = button;
1016 if (edev->mouse.did_double)
1017 ev->double_click = 1;
1018 if (edev->mouse.did_triple)
1019 ev->triple_click = 1;
1021 comp_conf = e_comp_config_get();
1022 if (comp_conf && comp_conf->input_log_enable)
1023 ELOGF("Mouse", "Button %s (btn: %d, device: %s)", NULL, state?"Press":"Release", button, ecore_device_name_get(ev->dev));
1026 ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, ev, _e_input_event_mouse_button_cb_free, NULL);
1028 ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_UP, ev, _e_input_event_mouse_button_cb_free, NULL);
1031 #if !LIBINPUT_HAVE_SCROLL_VALUE_V120
1033 _axis_value_get(struct libinput_event_pointer *pointer_event, enum libinput_pointer_axis axis)
1035 enum libinput_pointer_axis_source source;
1036 double value = 0.0, value_discrete = 0.0;
1038 E_Comp_Config *comp_conf = NULL;
1040 comp_conf = e_comp_config_get();
1041 source = libinput_event_pointer_get_axis_source(pointer_event);
1044 case LIBINPUT_POINTER_AXIS_SOURCE_WHEEL:
1045 value_discrete = libinput_event_pointer_get_axis_value_discrete(pointer_event, axis);
1046 value = libinput_event_pointer_get_axis_value(pointer_event, axis);
1047 if (comp_conf && comp_conf->input_log_enable)
1049 ELOGF("Axis", "SOURCE_WHEEL discrete: %lf (cf. value: %lf)", NULL, value_discrete, value);
1051 ret = (int)value_discrete;
1053 case LIBINPUT_POINTER_AXIS_SOURCE_FINGER:
1054 case LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS:
1055 value = libinput_event_pointer_get_axis_value(pointer_event, axis);
1056 if (comp_conf && comp_conf->input_log_enable)
1058 ELOGF("Axis", "SOURCE_FINGER/CONTINUOUS value: %lf", NULL, value);
1060 if (value >= E_INPUT_FINGER_SCROLL_THRESHOLD)
1062 else if (value <= E_INPUT_FINGER_SCROLL_THRESHOLD * (-1))
1075 _device_handle_axis(struct libinput_device *device, struct libinput_event_pointer *event)
1077 E_Input_Evdev *edev;
1078 E_Input_Backend *input;
1079 Ecore_Event_Mouse_Wheel *ev;
1081 enum libinput_pointer_axis axis;
1082 Ecore_Device *ecore_dev = NULL, *detent_data = NULL, *data;
1084 E_Comp_Config *comp_conf = NULL;
1085 int direction = 0, z = 0;
1087 if (!(edev = libinput_device_get_user_data(device)))
1091 if (!(input = edev->seat->input))
1096 if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1097 else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1099 EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1101 if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_MOUSE)
1106 else if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_NONE)
1111 if (!ecore_dev && e_devicemgr_detent_is_detent(libinput_device_get_name(edev->device)))
1113 ecore_dev = detent_data;
1118 edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_MOUSE);
1119 ecore_dev = edev->ecore_dev;
1124 ERR("Failed to get source ecore device from event !\n");
1128 axis = LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL;
1129 if (libinput_event_pointer_has_axis(event, axis))
1130 z = _axis_value_get(event, axis);
1132 axis = LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL;
1133 if (libinput_event_pointer_has_axis(event, axis))
1136 z = _axis_value_get(event, axis);
1141 ELOGF("Mouse", "Axis event is ignored since it has zero value", NULL);
1145 comp_conf = e_comp_config_get();
1146 if (comp_conf && comp_conf->e_wheel_click_angle)
1148 z = (int)(z * comp_conf->e_wheel_click_angle);
1151 if ((edev->seat->dev->blocked & E_INPUT_SEAT_POINTER) ||
1152 (edev->seat->dev->server_blocked & E_INPUT_SEAT_POINTER))
1155 ELOGF("Mouse", "Detent (direction: %d, value: %d) is blocked by %p, server: 0x%x", NULL,
1156 direction, z, edev->seat->dev->blocked_client, edev->seat->dev->server_blocked);
1158 ELOGF("Mouse", "Wheel (direction: %d, value: %d) is blocked by %p, server: 0x%x", NULL,
1159 direction, z, edev->seat->dev->blocked_client, edev->seat->dev->server_blocked);
1163 if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Wheel))))
1168 timestamp = libinput_event_pointer_get_time(event);
1170 ev->window = (Ecore_Window)input->dev->window;
1171 ev->event_window = (Ecore_Window)input->dev->window;
1172 ev->root_window = (Ecore_Window)input->dev->window;
1173 ev->timestamp = timestamp;
1174 ev->same_screen = 1;
1176 _device_modifiers_update(edev);
1177 ev->modifiers = edev->xkb.modifiers;
1179 ev->x = edev->seat->ptr.ix;
1180 ev->y = edev->seat->ptr.iy;
1183 ev->dev = ecore_device_ref(ecore_dev);
1186 ev->direction = direction;
1188 if (comp_conf && comp_conf->input_log_enable)
1191 ELOGF("Mouse", "Detent (direction: %d, value: %d)", NULL, ev->direction, ev->z);
1193 ELOGF("Mouse", "Wheel (direction: %d, value: %d)", NULL, ev->direction, ev->z);
1196 ecore_event_add(ECORE_EVENT_MOUSE_WHEEL, ev, _e_input_event_mouse_wheel_cb_free, NULL);
1200 #if LIBINPUT_HAVE_SCROLL_VALUE_V120
1202 _scroll_value_get(struct libinput_event_pointer *pointer_event, enum libinput_pointer_axis axis, E_Input_Axis_Source source)
1205 double value_v120 = 0.0;
1207 E_Comp_Config *comp_conf = NULL;
1209 comp_conf = e_comp_config_get();
1212 case E_INPUT_AXIS_SOURCE_WHEEL:
1213 value_v120 = libinput_event_pointer_get_scroll_value_v120(pointer_event, axis);
1214 value = libinput_event_pointer_get_scroll_value(pointer_event, axis);
1215 if (comp_conf && comp_conf->input_log_enable)
1217 ELOGF("Scroll", "SOURCE_WHEELL value_v120: %lf (cf. value: %lf)", NULL, value_v120, value);
1219 if (((int)value_v120 % E_INPUT_POINTER_AXIS_DISCRETE_STEP) != 0)
1221 ERR("Wheel movements should be multiples (or fractions) of 120!\n");
1226 ret = value_v120 / E_INPUT_POINTER_AXIS_DISCRETE_STEP;
1229 case E_INPUT_AXIS_SOURCE_FINGER:
1230 case E_INPUT_AXIS_SOURCE_CONTINUOUS:
1231 value = libinput_event_pointer_get_scroll_value(pointer_event, axis);
1232 if (comp_conf && comp_conf->input_log_enable)
1234 ELOGF("Scroll", "SOURCE_FINGER/CONTINUOUS value: %lf", NULL, value);
1236 if (value >= E_INPUT_FINGER_SCROLL_THRESHOLD)
1238 else if (value <= E_INPUT_FINGER_SCROLL_THRESHOLD * (-1))
1251 _device_handle_axis_v120(struct libinput_device *device, struct libinput_event_pointer *event, E_Input_Axis_Source source)
1253 E_Input_Evdev *edev;
1254 E_Input_Backend *input;
1255 Ecore_Event_Mouse_Wheel *ev;
1257 enum libinput_pointer_axis axis;
1258 Ecore_Device *ecore_dev = NULL, *detent_data = NULL, *data;
1260 E_Comp_Config *comp_conf = NULL;
1261 int direction = 0, z = 0;
1263 if (!(edev = libinput_device_get_user_data(device)))
1267 if (!(input = edev->seat->input))
1272 if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1273 else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1275 EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1277 if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_MOUSE)
1282 else if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_NONE)
1287 if (!ecore_dev && e_devicemgr_detent_is_detent(libinput_device_get_name(edev->device)))
1289 ecore_dev = detent_data;
1294 edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_MOUSE);
1295 ecore_dev = edev->ecore_dev;
1300 ERR("Failed to get source ecore device from event !\n");
1304 axis = LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL;
1305 if (libinput_event_pointer_has_axis(event, axis))
1306 z = _scroll_value_get(event, axis, source);
1308 axis = LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL;
1309 if (libinput_event_pointer_has_axis(event, axis))
1312 z = _scroll_value_get(event, axis, source);
1317 ELOGF("Mouse", "Scroll event is ignored since it has zero value", NULL);
1321 comp_conf = e_comp_config_get();
1322 if (comp_conf && comp_conf->e_wheel_click_angle)
1324 z = (int)(z * comp_conf->e_wheel_click_angle);
1327 if ((edev->seat->dev->blocked & E_INPUT_SEAT_POINTER) ||
1328 (edev->seat->dev->server_blocked & E_INPUT_SEAT_POINTER))
1331 ELOGF("Mouse", "Detent (direction: %d, value: %d) is blocked by %p, server: 0x%x", NULL,
1332 direction, z, edev->seat->dev->blocked_client, edev->seat->dev->server_blocked);
1334 ELOGF("Mouse", "Wheel (direction: %d, value: %d) is blocked by %p, server: 0x%x", NULL,
1335 direction, z, edev->seat->dev->blocked_client, edev->seat->dev->server_blocked);
1339 if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Wheel))))
1344 timestamp = libinput_event_pointer_get_time(event);
1346 ev->window = (Ecore_Window)input->dev->window;
1347 ev->event_window = (Ecore_Window)input->dev->window;
1348 ev->root_window = (Ecore_Window)input->dev->window;
1349 ev->timestamp = timestamp;
1350 ev->same_screen = 1;
1352 _device_modifiers_update(edev);
1353 ev->modifiers = edev->xkb.modifiers;
1355 ev->x = edev->seat->ptr.ix;
1356 ev->y = edev->seat->ptr.iy;
1359 ev->dev = ecore_device_ref(ecore_dev);
1362 ev->direction = direction;
1364 if (comp_conf && comp_conf->input_log_enable)
1367 ELOGF("Mouse", "Detent (direction: %d, value: %d)", NULL, ev->direction, ev->z);
1369 ELOGF("Mouse", "Wheel (direction: %d, value: %d)", NULL, ev->direction, ev->z);
1372 ecore_event_add(ECORE_EVENT_MOUSE_WHEEL, ev, _e_input_event_mouse_wheel_cb_free, NULL);
1377 _device_handle_touch_event_send(E_Input_Evdev *edev, struct libinput_event_touch *event, int state)
1379 E_Input_Backend *input;
1380 Ecore_Event_Mouse_Button *ev;
1381 uint32_t timestamp, button = 0;
1382 Ecore_Device *ecore_dev = NULL, *data;
1386 if (!(input = edev->seat->input)) return;
1388 if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1389 else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1391 EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1393 if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_TOUCH)
1402 edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_TOUCH);
1403 ecore_dev = edev->ecore_dev;
1408 ERR("Failed to get source ecore device from event !\n");
1412 if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Button)))) return;
1414 timestamp = libinput_event_touch_get_time(event);
1416 ev->window = (Ecore_Window)input->dev->window;
1417 ev->event_window = (Ecore_Window)input->dev->window;
1418 ev->root_window = (Ecore_Window)input->dev->window;
1419 ev->timestamp = timestamp;
1420 ev->same_screen = 1;
1422 _device_modifiers_update(edev);
1423 ev->modifiers = edev->xkb.modifiers;
1425 ev->x = edev->seat->ptr.ix;
1426 ev->y = edev->seat->ptr.iy;
1430 ev->multi.device = edev->mt_slot;
1431 ev->multi.radius = 1;
1432 ev->multi.radius_x = 1;
1433 ev->multi.radius_y = 1;
1434 ev->multi.pressure = 1.0;
1435 ev->multi.angle = 0.0;
1436 #if LIBINPUT_SUPPORT_EXTRA_TOUCH_EVENT
1437 if (libinput_event_get_type(libinput_event_touch_get_base_event(event))
1438 == LIBINPUT_EVENT_TOUCH_DOWN)
1440 if (libinput_event_touch_has_minor(event))
1441 ev->multi.radius_x = libinput_event_touch_get_minor(event);
1442 if (libinput_event_touch_has_major(event))
1443 ev->multi.radius_y = libinput_event_touch_get_major(event);
1444 if (libinput_event_touch_has_pressure(event))
1445 ev->multi.pressure = libinput_event_touch_get_pressure(event);
1446 if (libinput_event_touch_has_orientation(event))
1447 ev->multi.angle = libinput_event_touch_get_orientation(event);
1450 ev->multi.x = ev->x;
1451 ev->multi.y = ev->y;
1452 ev->multi.root.x = ev->x;
1453 ev->multi.root.y = ev->y;
1454 ev->dev = ecore_device_ref(ecore_dev);
1456 if (state == ECORE_EVENT_MOUSE_BUTTON_DOWN)
1458 unsigned int current;
1460 current = timestamp;
1461 edev->mouse.did_double = EINA_FALSE;
1462 edev->mouse.did_triple = EINA_FALSE;
1464 if (((current - edev->mouse.prev) <= edev->mouse.threshold) &&
1465 (button == edev->mouse.prev_button))
1467 edev->mouse.did_double = EINA_TRUE;
1468 if (((current - edev->mouse.last) <= (2 * edev->mouse.threshold)) &&
1469 (button == edev->mouse.last_button))
1471 edev->mouse.did_triple = EINA_TRUE;
1472 edev->mouse.prev = 0;
1473 edev->mouse.last = 0;
1478 edev->mouse.last = edev->mouse.prev;
1479 edev->mouse.prev = current;
1480 edev->mouse.last_button = edev->mouse.prev_button;
1481 edev->mouse.prev_button = button;
1482 edev->touch.pressed |= (1 << ev->multi.device);
1486 edev->touch.pressed &= ~(1 << ev->multi.device);
1489 ev->buttons = ((button & 0x00F) + 1);
1491 if (edev->mouse.did_double)
1492 ev->double_click = 1;
1493 if (edev->mouse.did_triple)
1494 ev->triple_click = 1;
1496 ecore_event_add(state, ev, _e_input_event_mouse_button_cb_free, NULL);
1500 _device_handle_touch_motion_send(E_Input_Evdev *edev, struct libinput_event_touch *event)
1502 E_Input_Backend *input;
1503 Ecore_Event_Mouse_Move *ev;
1504 Ecore_Device *ecore_dev = NULL, *data;
1508 if (!(input = edev->seat->input)) return;
1510 if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1511 else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1513 EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1515 if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_TOUCH)
1524 edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_TOUCH);
1525 ecore_dev = edev->ecore_dev;
1530 ERR("Failed to get source ecore device from event !\n");
1534 if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Move)))) return;
1536 ev->window = (Ecore_Window)input->dev->window;
1537 ev->event_window = (Ecore_Window)input->dev->window;
1538 ev->root_window = (Ecore_Window)input->dev->window;
1539 ev->timestamp = libinput_event_touch_get_time(event);
1540 ev->same_screen = 1;
1542 _device_modifiers_update(edev);
1543 ev->modifiers = edev->xkb.modifiers;
1545 ev->x = edev->seat->ptr.ix;
1546 ev->y = edev->seat->ptr.iy;
1550 ev->multi.device = edev->mt_slot;
1551 ev->multi.radius = 1;
1552 ev->multi.radius_x = 1;
1553 ev->multi.radius_y = 1;
1554 ev->multi.pressure = 1.0;
1555 ev->multi.angle = 0.0;
1556 #if LIBINPUT_SUPPORT_EXTRA_TOUCH_EVENT
1557 if (libinput_event_touch_has_minor(event))
1558 ev->multi.radius_x = libinput_event_touch_get_minor(event);
1559 if (libinput_event_touch_has_major(event))
1560 ev->multi.radius_y = libinput_event_touch_get_major(event);
1561 if (libinput_event_touch_has_pressure(event))
1562 ev->multi.pressure = libinput_event_touch_get_pressure(event);
1563 if (libinput_event_touch_has_orientation(event))
1564 ev->multi.angle = libinput_event_touch_get_orientation(event);
1566 ev->multi.x = ev->x;
1567 ev->multi.y = ev->y;
1568 ev->multi.root.x = ev->x;
1569 ev->multi.root.y = ev->y;
1570 ev->dev = ecore_device_ref(ecore_dev);
1572 ecore_event_add(ECORE_EVENT_MOUSE_MOVE, ev, _e_input_event_mouse_move_cb_free, NULL);
1576 _device_handle_touch_cancel_send(E_Input_Evdev *edev, struct libinput_event_touch *event)
1578 E_Input_Backend *input;
1579 Ecore_Event_Mouse_Button *ev;
1580 uint32_t timestamp, button = 0;
1581 Ecore_Device *ecore_dev = NULL, *data;
1585 if (!(input = edev->seat->input)) return;
1587 if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1588 else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1590 EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1592 if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_TOUCH)
1601 edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_TOUCH);
1602 ecore_dev = edev->ecore_dev;
1607 ERR("Failed to get source ecore device from event !\n");
1611 if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Button)))) return;
1613 timestamp = libinput_event_touch_get_time(event);
1615 ev->window = (Ecore_Window)input->dev->window;
1616 ev->event_window = (Ecore_Window)input->dev->window;
1617 ev->root_window = (Ecore_Window)input->dev->window;
1618 ev->timestamp = timestamp;
1619 ev->same_screen = 1;
1621 ev->x = edev->seat->ptr.ix;
1622 ev->y = edev->seat->ptr.iy;
1626 ev->multi.device = edev->mt_slot;
1627 ev->multi.radius = 1;
1628 ev->multi.radius_x = 1;
1629 ev->multi.radius_y = 1;
1630 ev->multi.pressure = 1.0;
1631 ev->multi.angle = 0.0;
1632 ev->multi.x = ev->x;
1633 ev->multi.y = ev->y;
1634 ev->multi.root.x = ev->x;
1635 ev->multi.root.y = ev->y;
1636 ev->dev = ecore_device_ref(ecore_dev);
1638 edev->touch.pressed &= ~(1 << ev->multi.device);
1640 ev->buttons = ((button & 0x00F) + 1);
1642 ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, ev, _e_input_event_mouse_button_cb_free, NULL);
1646 _device_configured_size_get(E_Input_Evdev *edev, int *x, int *y, int *w, int *h)
1648 E_Output *output = NULL;
1650 EINA_SAFETY_ON_NULL_RETURN(edev);
1652 if (!edev->output_configured)
1654 if (edev->output_name)
1656 output = e_output_find(edev->output_name);
1659 edev->mouse.minx = output->config.geom.x;
1660 edev->mouse.miny = output->config.geom.y;
1661 edev->mouse.maxw = output->config.geom.w;
1662 edev->mouse.maxh = output->config.geom.h;
1663 if (libinput_device_has_capability(edev->device, LIBINPUT_DEVICE_CAP_POINTER))
1665 edev->seat->ptr.dx = (double)(edev->mouse.maxw / 2);
1666 edev->seat->ptr.dy = (double)(edev->mouse.maxh / 2);
1667 edev->seat->ptr.ix = (int)edev->seat->ptr.dx;
1668 edev->seat->ptr.iy = (int)edev->seat->ptr.dy;
1669 edev->mouse.dx = edev->seat->ptr.dx;
1670 edev->mouse.dy = edev->seat->ptr.dy;
1675 edev->output_configured = EINA_TRUE;
1676 ELOGF("E_INPUT_EVDEV", "Device is configured by output x:%d,y:%d (w:%d, h:%d)",
1677 NULL, edev->mouse.minx, edev->mouse.miny, edev->mouse.maxw, edev->mouse.maxh);
1679 if (x) *x = edev->mouse.minx;
1680 if (y) *y = edev->mouse.miny;
1681 if (w) *w = edev->mouse.maxw;
1682 if (h) *h = edev->mouse.maxh;
1686 _device_handle_touch_down(struct libinput_device *device, struct libinput_event_touch *event)
1688 E_Input_Evdev *edev;
1689 int x = 0, y = 0, w = 0, h = 0;
1690 E_Comp_Config *comp_conf = NULL;
1692 if (!(edev = libinput_device_get_user_data(device)))
1697 _device_configured_size_get(edev, &x, &y, &w, &h);
1699 edev->mouse.dx = edev->seat->ptr.ix = edev->seat->ptr.dx =
1700 x + libinput_event_touch_get_x_transformed(event, w);
1701 edev->mouse.dy = edev->seat->ptr.iy = edev->seat->ptr.dy =
1702 y + libinput_event_touch_get_y_transformed(event, h);
1704 edev->mt_slot = libinput_event_touch_get_slot(event);
1705 if (edev->mt_slot < 0)
1707 /* FIXME: The single touch device return slot id -1
1708 * But currently we have no API to distinguish multi touch or single touch
1709 * After libinput 1.11 version, libinput provides get_touch_count API,
1710 * so we can distinguish multi touch device or single touch device.
1712 if (edev->mt_slot == -1)
1716 WRN("%d slot touch down events are not supported\n", edev->mt_slot);
1721 if (edev->mt_slot < e_input_touch_max_count_get())
1723 edev->touch.coords[edev->mt_slot].x = edev->seat->ptr.ix;
1724 edev->touch.coords[edev->mt_slot].y = edev->seat->ptr.iy;
1727 comp_conf = e_comp_config_get();
1728 if (comp_conf && comp_conf->input_log_enable)
1729 ELOGF("Touch", "Down (id: %d, x: %d, y: %d)", NULL, edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy);
1731 edev->touch.raw_pressed |= (1 << edev->mt_slot);
1733 if (edev->touch.blocked)
1735 ELOGF("Touch", "Down (id: %d, x: %d, y: %d) is blocked by %p, server: 0x%x", NULL,
1736 edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy, edev->seat->dev->blocked_client,
1737 edev->seat->dev->server_blocked);
1741 _device_handle_touch_motion_send(edev, event);
1742 _device_handle_touch_event_send(edev, event, ECORE_EVENT_MOUSE_BUTTON_DOWN);
1746 _device_handle_touch_motion(struct libinput_device *device, struct libinput_event_touch *event)
1748 E_Input_Evdev *edev;
1749 int x = 0, y = 0, w = 0, h = 0;
1751 if (!(edev = libinput_device_get_user_data(device)))
1756 _device_configured_size_get(edev, &x, &y, &w, &h);
1758 edev->mouse.dx = edev->seat->ptr.dx =
1759 x + libinput_event_touch_get_x_transformed(event, w);
1760 edev->mouse.dy = edev->seat->ptr.dy =
1761 y + libinput_event_touch_get_y_transformed(event, h);
1763 if (floor(edev->seat->ptr.dx) == edev->seat->ptr.ix &&
1764 floor(edev->seat->ptr.dy) == edev->seat->ptr.iy)
1769 edev->seat->ptr.ix = edev->seat->ptr.dx;
1770 edev->seat->ptr.iy = edev->seat->ptr.dy;
1772 edev->mt_slot = libinput_event_touch_get_slot(event);
1773 if (edev->mt_slot < 0)
1775 /* FIXME: The single touch device return slot id -1
1776 * But currently we have no API to distinguish multi touch or single touch
1777 * After libinput 1.11 version, libinput provides get_touch_count API,
1778 * so we can distinguish multi touch device or single touch device.
1780 if (edev->mt_slot == -1)
1784 WRN("%d slot touch motion events are not supported\n", edev->mt_slot);
1789 if (edev->mt_slot < e_input_touch_max_count_get())
1791 edev->touch.coords[edev->mt_slot].x = edev->seat->ptr.ix;
1792 edev->touch.coords[edev->mt_slot].y = edev->seat->ptr.iy;
1795 if (!(edev->touch.pressed & (1 << edev->mt_slot)))
1797 if (edev->touch.blocked)
1803 _device_handle_touch_motion_send(edev, event);
1807 _device_handle_touch_up(struct libinput_device *device, struct libinput_event_touch *event)
1809 E_Input_Evdev *edev;
1810 E_Comp_Config *comp_conf = NULL;
1812 if (!(edev = libinput_device_get_user_data(device)))
1817 edev->mt_slot = libinput_event_touch_get_slot(event);
1818 if (edev->mt_slot < 0)
1820 /* FIXME: The single touch device return slot id -1
1821 * But currently we have no API to distinguish multi touch or single touch
1822 * After libinput 1.11 version, libinput provides get_touch_count API,
1823 * so we can distinguish multi touch device or single touch device.
1825 if (edev->mt_slot == -1)
1829 WRN("%d slot touch up events are not supported\n", edev->mt_slot);
1834 if (edev->mt_slot < e_input_touch_max_count_get())
1836 edev->mouse.dx = edev->seat->ptr.dx = edev->seat->ptr.ix =
1837 edev->touch.coords[edev->mt_slot].x;
1838 edev->mouse.dy = edev->seat->ptr.dy = edev->seat->ptr.iy =
1839 edev->touch.coords[edev->mt_slot].y;
1842 comp_conf = e_comp_config_get();
1843 if (comp_conf && comp_conf->input_log_enable)
1844 ELOGF("Touch", "Up (id: %d, x: %d, y: %d)", NULL, edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy);
1846 edev->touch.raw_pressed &= ~(1 << edev->mt_slot);
1848 if (edev->touch.blocked)
1850 if (!(edev->touch.pressed & (1 << edev->mt_slot)))
1852 ELOGF("Touch", "Up (id: %d, x: %d, y: %d) is blocked by %p, server(0x%x)", NULL,
1853 edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy, edev->seat->dev->blocked_client,
1854 edev->seat->dev->server_blocked);
1855 if (edev->touch.raw_pressed == 0x0)
1857 edev->touch.blocked = EINA_FALSE;
1863 _device_handle_touch_event_send(edev, event, ECORE_EVENT_MOUSE_BUTTON_UP);
1867 _device_handle_touch_cancel(struct libinput_device *device, struct libinput_event_touch *event)
1869 E_Input_Evdev *edev;
1870 E_Comp_Config *comp_conf = NULL;
1872 if (!(edev = libinput_device_get_user_data(device)))
1877 edev->mt_slot = libinput_event_touch_get_slot(event);
1878 if (edev->mt_slot < 0)
1880 /* FIXME: The single touch device return slot id -1
1881 * But currently we have no API to distinguish multi touch or single touch
1882 * After libinput 1.11 version, libinput provides get_touch_count API,
1883 * so we can distinguish multi touch device or single touch device.
1885 if (edev->mt_slot == -1)
1889 WRN("%d slot touch up events are not supported\n", edev->mt_slot);
1894 comp_conf = e_comp_config_get();
1895 if (comp_conf && comp_conf->input_log_enable)
1896 ELOGF("Touch", "cancel (id: %d, x: %d, y: %d)", NULL, edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy);
1898 _device_handle_touch_cancel_send(edev, event);
1903 _device_handle_touch_frame(struct libinput_device *device EINA_UNUSED, struct libinput_event_touch *event EINA_UNUSED)
1905 /* DBG("Unhandled Touch Frame Event"); */
1909 _e_input_aux_data_event_free(void *user_data EINA_UNUSED, void *ev)
1911 Ecore_Event_Axis_Update *e = (Ecore_Event_Axis_Update *)ev;
1913 if (e->axis) free(e->axis);
1914 if (e->dev) ecore_device_unref(e->dev);
1920 _device_handle_touch_aux_data(struct libinput_device *device, struct libinput_event_touch_aux_data *event)
1922 E_Input_Evdev *edev;
1923 E_Input_Backend *input;
1924 Ecore_Event_Axis_Update *ev;
1926 Ecore_Device *ecore_dev = NULL, *data;
1928 E_Comp_Config *comp_conf;
1930 if (libinput_event_touch_aux_data_get_type(event) != LIBINPUT_TOUCH_AUX_DATA_TYPE_PALM &&
1931 libinput_event_touch_aux_data_get_value(event) > 0)
1934 if (!(edev = libinput_device_get_user_data(device))) goto end;
1935 if (!(input = edev->seat->input)) goto end;
1937 if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1938 else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1940 EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1942 if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_TOUCH)
1951 edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_TOUCH);
1952 ecore_dev = edev->ecore_dev;
1957 ERR("Failed to get source ecore device from event !\n");
1961 if (!(ev = calloc(1, sizeof(Ecore_Event_Axis_Update))))goto end;
1963 ev->window = (Ecore_Window)input->dev->window;
1964 ev->event_window = (Ecore_Window)input->dev->window;
1965 ev->root_window = (Ecore_Window)input->dev->window;
1966 ev->timestamp = libinput_event_touch_aux_data_get_time(event);
1968 axis = (Ecore_Axis *)calloc(1, sizeof(Ecore_Axis));
1971 axis->label = ECORE_AXIS_LABEL_TOUCH_PALM;
1972 axis->value = libinput_event_touch_aux_data_get_value(event);
1976 ev->dev = ecore_device_ref(ecore_dev);
1978 comp_conf = e_comp_config_get();
1979 if (comp_conf && comp_conf->input_log_enable)
1980 ELOGF("Touch", "Axis (label: %d, value: %lf)", NULL, axis?axis->label:-1, axis?axis->value:0.0);
1982 ecore_event_add(ECORE_EVENT_AXIS_UPDATE, ev, _e_input_aux_data_event_free, NULL);
1989 _e_input_evdev_device_create(E_Input_Seat *seat, struct libinput_device *device)
1991 E_Input_Evdev *edev;
1992 E_Input_Backend *b_input;
1993 const char *output_name;
1995 EINA_SAFETY_ON_NULL_RETURN_VAL(seat, NULL);
1997 /* try to allocate space for new evdev */
1998 if (!(edev = calloc(1, sizeof(E_Input_Evdev)))) return NULL;
2001 edev->device = device;
2002 edev->path = eina_stringshare_printf("%s/%s", e_input_base_dir_get(), libinput_device_get_sysname(device));
2004 if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_KEYBOARD))
2006 edev->caps |= E_INPUT_SEAT_KEYBOARD;
2007 _device_keyboard_setup(edev);
2010 if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_POINTER))
2012 edev->caps |= E_INPUT_SEAT_POINTER;
2014 /* TODO: make this configurable */
2015 edev->mouse.threshold = 250;
2017 b_input = seat->input;
2018 if (b_input->left_handed == EINA_TRUE)
2020 if (libinput_device_config_left_handed_set(device, 1) !=
2021 LIBINPUT_CONFIG_STATUS_SUCCESS)
2023 WRN("Failed to set left hand mode about device: %s\n",
2024 libinput_device_get_name(device));
2029 if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_TOUCH))
2032 edev->caps |= E_INPUT_SEAT_TOUCH;
2033 palm_code = libinput_device_touch_aux_data_get_code(LIBINPUT_TOUCH_AUX_DATA_TYPE_PALM);
2034 if (libinput_device_touch_has_aux_data(device, palm_code))
2036 libinput_device_touch_set_aux_data(device, palm_code);
2039 _device_touch_count_update(edev);
2041 edev->touch.coords = calloc(1, sizeof(E_Input_Coord)*e_input_touch_max_count_get());
2043 if (!edev->touch.coords)
2044 ERR("Failed to allocate memory for touch coords !\n");
2047 output_name = libinput_device_get_output_name(device);
2050 eina_stringshare_replace(&edev->output_name, output_name);
2051 ELOGF("E_INPUT_EVDEV", "Device has output_name:%s", NULL, output_name);
2054 libinput_device_set_user_data(device, edev);
2055 libinput_device_ref(device);
2057 /* configure device */
2058 _device_configure(edev);
2064 _e_input_evdev_device_destroy(E_Input_Evdev *edev)
2068 EINA_SAFETY_ON_NULL_RETURN(edev);
2070 if (edev->caps & E_INPUT_SEAT_KEYBOARD)
2072 if (edev->xkb.state) xkb_state_unref(edev->xkb.state);
2073 if (edev->xkb.keymap) xkb_map_unref(edev->xkb.keymap);
2076 if (edev->ecore_dev) ecore_device_del(edev->ecore_dev);
2077 if (edev->ecore_dev_list)
2078 EINA_LIST_FREE(edev->ecore_dev_list, dev)
2080 ecore_device_del(dev);
2082 if (edev->path) eina_stringshare_del(edev->path);
2083 if (edev->device) libinput_device_unref(edev->device);
2084 if (edev->key_remap_hash) eina_hash_free(edev->key_remap_hash);
2085 if (edev->touch.coords)
2087 free(edev->touch.coords);
2088 edev->touch.coords = NULL;
2090 eina_stringshare_del(edev->output_name);
2096 _e_input_evdev_event_process(struct libinput_event *event)
2098 struct libinput_device *device;
2099 Eina_Bool ret = EINA_TRUE;
2101 device = libinput_event_get_device(event);
2102 switch (libinput_event_get_type(event))
2104 case LIBINPUT_EVENT_KEYBOARD_KEY:
2105 _device_handle_key(device, libinput_event_get_keyboard_event(event));
2107 case LIBINPUT_EVENT_POINTER_MOTION:
2108 _device_handle_pointer_motion(device,
2109 libinput_event_get_pointer_event(event));
2111 case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE:
2112 _device_handle_pointer_motion_absolute(device,
2113 libinput_event_get_pointer_event(event));
2115 case LIBINPUT_EVENT_POINTER_BUTTON:
2116 _device_handle_button(device, libinput_event_get_pointer_event(event));
2118 case LIBINPUT_EVENT_POINTER_AXIS:
2119 #if !LIBINPUT_HAVE_SCROLL_VALUE_V120
2120 _device_handle_axis(device, libinput_event_get_pointer_event(event));
2123 #if LIBINPUT_HAVE_SCROLL_VALUE_V120
2124 case LIBINPUT_EVENT_POINTER_SCROLL_WHEEL:
2125 _device_handle_axis_v120(device, libinput_event_get_pointer_event(event), E_INPUT_AXIS_SOURCE_WHEEL);
2127 case LIBINPUT_EVENT_POINTER_SCROLL_FINGER:
2128 _device_handle_axis_v120(device, libinput_event_get_pointer_event(event), E_INPUT_AXIS_SOURCE_FINGER);
2130 case LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS:
2131 _device_handle_axis_v120(device, libinput_event_get_pointer_event(event), E_INPUT_AXIS_SOURCE_CONTINUOUS);
2134 case LIBINPUT_EVENT_TOUCH_DOWN:
2135 _device_handle_touch_down(device, libinput_event_get_touch_event(event));
2137 case LIBINPUT_EVENT_TOUCH_MOTION:
2138 _device_handle_touch_motion(device,
2139 libinput_event_get_touch_event(event));
2141 case LIBINPUT_EVENT_TOUCH_UP:
2142 _device_handle_touch_up(device, libinput_event_get_touch_event(event));
2144 case LIBINPUT_EVENT_TOUCH_CANCEL:
2145 _device_handle_touch_cancel(device, libinput_event_get_touch_event(event));
2147 case LIBINPUT_EVENT_TOUCH_FRAME:
2148 _device_handle_touch_frame(device, libinput_event_get_touch_event(event));
2150 case LIBINPUT_EVENT_TOUCH_AUX_DATA:
2151 _device_handle_touch_aux_data(device, libinput_event_get_touch_aux_data(event));
2162 * @brief Set the axis size of the given device.
2164 * @param dev The device to set the axis size to.
2165 * @param w The width of the axis.
2166 * @param h The height of the axis.
2168 * This function sets set the width @p w and height @p h of the axis
2169 * of device @p dev. If @p dev is a relative input device, a width and
2170 * height must set for it. If its absolute set the ioctl correctly, if
2171 * not, unsupported device.
2174 e_input_evdev_axis_size_set(E_Input_Evdev *edev, int w, int h)
2176 const char *sysname;
2181 enum libinput_config_status status;
2183 EINA_SAFETY_ON_NULL_RETURN(edev);
2184 EINA_SAFETY_ON_TRUE_RETURN((w == 0) || (h == 0));
2186 if ((!libinput_device_config_calibration_has_matrix(edev->device)) ||
2187 (libinput_device_config_calibration_get_default_matrix(edev->device, cal) != 0))
2190 sysname = libinput_device_get_sysname(edev->device);
2192 devices = eeze_udev_find_by_subsystem_sysname("input", sysname);
2193 if (eina_list_count(devices) < 1) return;
2195 EINA_LIST_FREE(devices, device)
2197 vals = eeze_udev_syspath_get_property(device, "WL_CALIBRATION");
2199 (sscanf(vals, "%f %f %f %f %f %f",
2200 &cal[0], &cal[1], &cal[2], &cal[3], &cal[4], &cal[5]) != 6))
2207 libinput_device_config_calibration_set_matrix(edev->device, cal);
2209 if (status != LIBINPUT_CONFIG_STATUS_SUCCESS)
2210 ERR("Failed to apply calibration");
2213 eina_stringshare_del(device);
2219 e_input_evdev_name_get(E_Input_Evdev *evdev)
2221 EINA_SAFETY_ON_NULL_RETURN_VAL(evdev, NULL);
2222 EINA_SAFETY_ON_NULL_RETURN_VAL(evdev->device, NULL);
2224 return libinput_device_get_name(evdev->device);
2227 EINTERN const char *
2228 e_input_evdev_sysname_get(E_Input_Evdev *evdev)
2230 EINA_SAFETY_ON_NULL_RETURN_VAL(evdev, NULL);
2231 EINA_SAFETY_ON_NULL_RETURN_VAL(evdev->device, NULL);
2233 return libinput_device_get_sysname(evdev->device);
2237 e_input_evdev_key_remap_enable(E_Input_Evdev *edev, Eina_Bool enable)
2239 EINA_SAFETY_ON_NULL_RETURN_VAL(edev, EINA_FALSE);
2240 EINA_SAFETY_ON_NULL_RETURN_VAL(edev->device, EINA_FALSE);
2242 edev->key_remap_enabled = enable;
2244 if (enable == EINA_FALSE && edev->key_remap_hash)
2246 eina_hash_free(edev->key_remap_hash);
2247 edev->key_remap_hash = NULL;
2254 e_input_evdev_key_remap_set(E_Input_Evdev *edev, int *from_keys, int *to_keys, int num)
2258 EINA_SAFETY_ON_NULL_RETURN_VAL(edev, EINA_FALSE);
2259 EINA_SAFETY_ON_NULL_RETURN_VAL(edev->device, EINA_FALSE);
2260 EINA_SAFETY_ON_NULL_RETURN_VAL(from_keys, EINA_FALSE);
2261 EINA_SAFETY_ON_NULL_RETURN_VAL(to_keys, EINA_FALSE);
2262 EINA_SAFETY_ON_TRUE_RETURN_VAL(num <= 0, EINA_FALSE);
2263 EINA_SAFETY_ON_TRUE_RETURN_VAL(!edev->key_remap_enabled, EINA_FALSE);
2265 if (edev->key_remap_hash == NULL)
2266 edev->key_remap_hash = eina_hash_int32_new(NULL);
2268 if (edev->key_remap_hash == NULL)
2270 ERR("Failed to set remap key information : creating a hash is failed.");
2274 for (i = 0; i < num ; i++)
2276 if (!from_keys[i] || !to_keys[i])
2278 ERR("Failed to set remap key information : given arguments are invalid.");
2283 for (i = 0; i < num ; i++)
2285 eina_hash_add(edev->key_remap_hash, &from_keys[i], (void *)(intptr_t)to_keys[i]);
2292 e_input_evdev_wheel_click_angle_get(E_Input_Evdev *dev)
2294 EINA_SAFETY_ON_NULL_RETURN_VAL(dev, -1);
2295 return libinput_device_config_scroll_get_wheel_click_angle(dev->device);
2299 e_input_evdev_touch_calibration_set(E_Input_Evdev *edev, float matrix[6])
2301 EINA_SAFETY_ON_NULL_RETURN_VAL(edev, EINA_FALSE);
2302 EINA_SAFETY_ON_NULL_RETURN_VAL(edev->device, EINA_FALSE);
2304 if (!libinput_device_config_calibration_has_matrix(edev->device) ||
2305 !libinput_device_has_capability(edev->device, LIBINPUT_DEVICE_CAP_TOUCH))
2308 if (libinput_device_config_calibration_set_matrix(edev->device, matrix) !=
2309 LIBINPUT_CONFIG_STATUS_SUCCESS)
2311 WRN("Failed to set input transformation about device: %s\n",
2312 libinput_device_get_name(edev->device));
2320 e_input_evdev_mouse_accel_speed_set(E_Input_Evdev *edev, double speed)
2322 EINA_SAFETY_ON_NULL_RETURN_VAL(edev, EINA_FALSE);
2323 EINA_SAFETY_ON_NULL_RETURN_VAL(edev->device, EINA_FALSE);
2325 if (!libinput_device_has_capability(edev->device, LIBINPUT_DEVICE_CAP_POINTER))
2328 if (!libinput_device_config_accel_is_available(edev->device))
2331 if (libinput_device_config_accel_set_speed(edev->device, speed) !=
2332 LIBINPUT_CONFIG_STATUS_SUCCESS)
2334 WRN("Failed to set mouse accel about device: %s\n",
2335 libinput_device_get_name(edev->device));
2342 EINTERN unsigned int
2343 e_input_evdev_touch_pressed_get(E_Input_Evdev *edev)
2345 EINA_SAFETY_ON_NULL_RETURN_VAL(edev, 0x0);
2347 return edev->touch.pressed;
2351 e_input_evdev_seatname_get(E_Input_Evdev *evdev)
2353 struct libinput_seat *libinput_seat;
2354 EINA_SAFETY_ON_NULL_RETURN_VAL(evdev, NULL);
2355 EINA_SAFETY_ON_NULL_RETURN_VAL(evdev->device, NULL);
2357 libinput_seat = libinput_device_get_seat(evdev->device);
2359 return libinput_seat_get_logical_name(libinput_seat);
2363 e_input_evdev_seatname_set(E_Input_Evdev *evdev, const char *seatname)
2365 Eina_Bool res = EINA_FALSE;
2366 E_Input_Backend *input;
2368 EINA_SAFETY_ON_NULL_RETURN_VAL(seatname, EINA_FALSE);
2369 EINA_SAFETY_ON_NULL_RETURN_VAL(evdev, EINA_FALSE);
2370 EINA_SAFETY_ON_NULL_RETURN_VAL(evdev->device, EINA_FALSE);
2372 if (libinput_device_set_seat_logical_name(evdev->device, seatname) == 0)
2374 input = evdev->seat->input;
2375 if (!input) return EINA_FALSE;
2376 if (libinput_dispatch(input->libinput) != 0)
2378 ERR("Failed to dispatch libinput events: %m");
2382 /* process pending events */
2383 _input_events_process(input);
2391 e_input_evdev_mouse_accel_enable(E_Input_Evdev *edev, Eina_Bool enable)
2393 EINA_SAFETY_ON_NULL_RETURN_VAL(edev, EINA_FALSE);
2394 edev->disable_acceleration = !enable;