src/bin/e_input_evdev.c

   1 #include "e.h"
   2 #include "e_input_private.h"
   3 #include "e_device.h"
   4 #include "e_keyrouter_private.h"
   5 #include "e_input_event.h"
   6 #include "e_devicemgr.h"
   7
   8 #include <glib.h>
   9
  10 #define G_LIST_GET_DATA(list) ((list) ? (((GList *)(list))->data) : NULL)
  11
  12 static void  _device_modifiers_update(E_Input_Evdev *edev);
  13 static void  _device_configured_size_get(E_Input_Evdev *edev, int *x, int *y, int *w, int *h);
  14 static void  _device_output_assign(E_Input_Evdev *edev, E_Input_Seat_Capabilities cap);
  15
  16 void
  17 _device_calibration_set(E_Input_Evdev *edev)
  18 {
  19    E_Output *output;
  20    int w = 0, h = 0;
  21    int temp;
  22    E_Comp_Config *comp_conf;
  23
  24    if (e_comp->e_comp_screen->num_outputs > 1) //multiple outputs
  25      {
  26         comp_conf = e_comp_config_get();
  27         if (comp_conf && (comp_conf->input_output_assign_policy == 1)) //use output-assignment policy
  28           {
  29              _device_output_assign(edev, E_INPUT_SEAT_POINTER);
  30              _device_output_assign(edev, E_INPUT_SEAT_TOUCH);
  31           }
  32      }
  33
  34    output = e_comp_screen_primary_output_get(e_comp->e_comp_screen);
  35    e_output_size_get(output, &w, &h);
  36
  37    if (output)
  38      {
  39         edev->mouse.minx = edev->mouse.miny = 0;
  40         edev->mouse.maxw = w;
  41         edev->mouse.maxh = h;
  42
  43         if (libinput_device_has_capability(edev->device, LIBINPUT_DEVICE_CAP_POINTER))
  44           {
  45              edev->seat->ptr.dx = (double)(w / 2);
  46              edev->seat->ptr.dy = (double)(h / 2);
  47              edev->seat->ptr.ix = (int)edev->seat->ptr.dx;
  48              edev->seat->ptr.iy = (int)edev->seat->ptr.dy;
  49              edev->mouse.dx = edev->seat->ptr.dx;
  50              edev->mouse.dy = edev->seat->ptr.dy;
  51
  52              if (output->config.rotation == 90 || output->config.rotation == 270)
  53                {
  54                   temp = edev->mouse.minx;
  55                   edev->mouse.minx = edev->mouse.miny;
  56                   edev->mouse.miny = temp;
  57
  58                   temp = edev->mouse.maxw;
  59                   edev->mouse.maxw = edev->mouse.maxh;
  60                   edev->mouse.maxh = temp;
  61                }
  62           }
  63      }
  64
  65 //LCOV_EXCL_START
  66 #ifdef _F_E_INPUT_ENABLE_DEVICE_CALIBRATION_
  67    const char *sysname;
  68    float cal[6];
  69    const char *device;
  70    Eina_List *devices;
  71
  72    if ((!libinput_device_config_calibration_has_matrix(edev->device)) ||
  73        (libinput_device_config_calibration_get_default_matrix(edev->device, cal) != 0))
  74      return;
  75
  76    sysname = libinput_device_get_sysname(edev->device);
  77
  78    devices = eeze_udev_find_by_subsystem_sysname("input", sysname);
  79    if (eina_list_count(devices) < 1) return;
  80
  81 #ifdef _F_E_INPUT_USE_WL_CALIBRATION_
  82    const char *vals;
  83    enum libinput_config_status status;
  84
  85    EINA_LIST_FREE(devices, device)
  86      {
  87         vals = eeze_udev_syspath_get_property(device, "WL_CALIBRATION");
  88         if ((!vals) ||
  89             (sscanf(vals, "%f %f %f %f %f %f",
  90                     &cal[0], &cal[1], &cal[2], &cal[3], &cal[4], &cal[5]) != 6))
  91           goto cont;
  92
  93         cal[2] /= w;
  94         cal[5] /= h;
  95
  96         status =
  97           libinput_device_config_calibration_set_matrix(edev->device, cal);
  98
  99         if (status != LIBINPUT_CONFIG_STATUS_SUCCESS)
 100           ERR("Failed to apply calibration");
 101
 102 cont:
 103         eina_stringshare_del(device);
 104         continue;
 105      }
 106 #endif//_F_E_INPUT_USE_WL_CALIBRATION_
 107 #endif//_F_E_INPUT_ENABLE_DEVICE_CALIBRATION_
 108 //LCOV_EXCL_STOP
 109 }
 110
 111 static void
 112 _device_output_assign(E_Input_Evdev *edev, E_Input_Seat_Capabilities cap)
 113 {
 114    int last_output_idx;
 115    E_Input_Evdev *ed;
 116    Eina_List *l;
 117    Eina_Bool need_assign_output = EINA_FALSE;
 118    const char *output_name;
 119    E_Output *output;
 120
 121    if (!(edev->caps & cap)) return;
 122    if (edev->output_name) return; //already assigned
 123    if (e_comp->e_comp_screen->num_outputs <= 1) return;
 124
 125    last_output_idx = e_comp->e_comp_screen->num_outputs - 1;
 126    EINA_LIST_FOREACH(edev->seat->devices, l, ed)
 127      {
 128         if (!(ed->caps & cap)) continue;
 129         if (ed == edev) continue;
 130         if (ed->output_name)
 131           {
 132              need_assign_output = EINA_FALSE;
 133              break;
 134           }
 135           need_assign_output = EINA_TRUE;
 136      }
 137    if (need_assign_output)
 138      {
 139         output = e_output_find_by_index(last_output_idx);
 140         if (!output || !output->info.connected) return;
 141         output_name = e_output_output_id_get(output);
 142         if (output_name) edev->output_name = eina_stringshare_add(output_name);
 143         ELOGF("E_INPUT_EVDEV", "Device is assigned to output:%s", NULL, output_name);
 144      }
 145 }
 146
 147 static void
 148 _device_touch_count_update(E_Input_Evdev *edev)
 149 {
 150    unsigned int device_touch_count = 0;
 151    static unsigned int _max_device_touch_count = 0;
 152
 153    E_Input *ei = e_input_get();
 154    EINA_SAFETY_ON_NULL_RETURN(ei);
 155
 156    device_touch_count = libinput_device_touch_get_touch_count(edev->device);
 157
 158    if (_max_device_touch_count < device_touch_count)
 159      _max_device_touch_count = device_touch_count;
 160
 161    if (e_config->configured_max_touch.use)
 162      {
 163         if (_max_device_touch_count > 0 && e_config->configured_max_touch.count > _max_device_touch_count)
 164           {
 165              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",
 166                          NULL, e_config->configured_max_touch.count, _max_device_touch_count, _max_device_touch_count);
 167              ei->touch_max_count = _max_device_touch_count;
 168           }
 169         else
 170           {
 171              if (ei->touch_max_count != e_config->configured_max_touch.count)
 172              {
 173                 ELOGF("E_INPUT_EVDEV_TOUCH", "Touch_max_count has been updated to %d -> %d.\n",
 174                            NULL, ei->touch_max_count, e_config->configured_max_touch.count);
 175                 ei->touch_max_count = e_config->configured_max_touch.count;
 176              }
 177           }
 178      }
 179    else
 180      {
 181         if (ei->touch_max_count < _max_device_touch_count)
 182           {
 183              ELOGF("E_INPUT_EVDEV_TOUCH", "Touch_max_count has been updated to %d -> %d.\n", NULL,
 184                    ei->touch_max_count, _max_device_touch_count);
 185              ei->touch_max_count = _max_device_touch_count;
 186           }
 187      }
 188
 189    ei->touch_device_count++;
 190    ELOGF("E_INPUT_EVDEV_TOUCH", "Touch device count is %d.\n", NULL, ei->touch_device_count);
 191 }
 192
 193 static void
 194 _device_configure(E_Input_Evdev *edev)
 195 {
 196    if (libinput_device_config_tap_get_finger_count(edev->device) > 0)
 197      {
 198         Eina_Bool tap = EINA_FALSE;
 199
 200         tap = libinput_device_config_tap_get_default_enabled(edev->device);
 201         libinput_device_config_tap_set_enabled(edev->device, tap);
 202      }
 203
 204    _device_calibration_set(edev);
 205 }
 206
 207 static void
 208 _device_keyboard_setup(E_Input_Evdev *edev)
 209 {
 210    E_Input_Backend *input;
 211    xkb_mod_index_t xkb_idx;
 212
 213    if ((!edev) || (!edev->seat)) return;
 214    if (!(input = edev->seat->input)) return;
 215    if (!input->dev->xkb_ctx) return;
 216
 217    g_mutex_init(&edev->xkb.keymap_mutex);
 218
 219    /* create keymap from xkb context */
 220    g_mutex_lock(&edev->xkb.keymap_mutex);
 221    edev->xkb.keymap = _e_input_device_cached_keymap_get(input->dev->xkb_ctx, NULL, 0);
 222    if (!edev->xkb.keymap)
 223      {
 224         g_mutex_unlock(&edev->xkb.keymap_mutex);
 225         ERR("Failed to create keymap: %m");
 226         return;
 227      }
 228
 229    g_mutex_lock(&edev->xkb.state_mutex);
 230
 231    /* create xkb state */
 232    if (!(edev->xkb.state = xkb_state_new(edev->xkb.keymap)))
 233      {
 234         g_mutex_unlock(&edev->xkb.state_mutex);
 235         g_mutex_unlock(&edev->xkb.keymap_mutex);
 236         ERR("Failed to create xkb state: %m");
 237         return;
 238      }
 239
 240    g_mutex_unlock(&edev->xkb.state_mutex);
 241
 242    xkb_idx = xkb_map_mod_get_index(edev->xkb.keymap, XKB_MOD_NAME_CTRL);
 243    if (xkb_idx != XKB_MOD_INVALID)
 244      edev->xkb.ctrl_mask = 1 << xkb_idx;
 245    else
 246      edev->xkb.ctrl_mask = 0;
 247
 248    xkb_idx = xkb_map_mod_get_index(edev->xkb.keymap, XKB_MOD_NAME_ALT);
 249    if (xkb_idx != XKB_MOD_INVALID)
 250      edev->xkb.alt_mask = 1 << xkb_idx;
 251    else
 252      edev->xkb.alt_mask = 0;
 253
 254    xkb_idx = xkb_map_mod_get_index(edev->xkb.keymap, XKB_MOD_NAME_SHIFT);
 255    if (xkb_idx != XKB_MOD_INVALID)
 256      edev->xkb.shift_mask = 1 << xkb_idx;
 257    else
 258      edev->xkb.shift_mask = 0;
 259
 260    xkb_idx = xkb_map_mod_get_index(edev->xkb.keymap, XKB_MOD_NAME_LOGO);
 261    if (xkb_idx != XKB_MOD_INVALID)
 262      edev->xkb.win_mask = 1 << xkb_idx;
 263    else
 264      edev->xkb.win_mask = 0;
 265
 266    xkb_idx = xkb_map_mod_get_index(edev->xkb.keymap, XKB_LED_NAME_SCROLL);
 267    if (xkb_idx != XKB_MOD_INVALID)
 268      edev->xkb.scroll_mask = 1 << xkb_idx;
 269    else
 270      edev->xkb.scroll_mask = 0;
 271
 272    xkb_idx = xkb_map_mod_get_index(edev->xkb.keymap, XKB_LED_NAME_NUM);
 273    if (xkb_idx != XKB_MOD_INVALID)
 274      edev->xkb.num_mask = 1 << xkb_idx;
 275    else
 276      edev->xkb.num_mask = 0;
 277
 278    xkb_idx = xkb_map_mod_get_index(edev->xkb.keymap, XKB_MOD_NAME_CAPS);
 279    if (xkb_idx != XKB_MOD_INVALID)
 280      edev->xkb.caps_mask = 1 << xkb_idx;
 281    else
 282      edev->xkb.caps_mask = 0;
 283
 284    xkb_idx = xkb_map_mod_get_index(edev->xkb.keymap, "ISO_Level3_Shift");
 285    if (xkb_idx != XKB_MOD_INVALID)
 286      edev->xkb.altgr_mask = 1 << xkb_idx;
 287    else
 288      edev->xkb.altgr_mask = 0;
 289
 290    g_mutex_unlock(&edev->xkb.keymap_mutex);
 291 }
 292
 293 static int
 294 _device_keysym_translate(xkb_keysym_t keysym, unsigned int modifiers, char *buffer, int bytes)
 295 {
 296    unsigned long hbytes = 0;
 297    unsigned char c;
 298
 299    if (!keysym) return 0;
 300    hbytes = (keysym >> 8);
 301
 302    if (!(bytes &&
 303          ((hbytes == 0) ||
 304           ((hbytes == 0xFF) &&
 305            (((keysym >= XKB_KEY_BackSpace) && (keysym <= XKB_KEY_Clear)) ||
 306             (keysym == XKB_KEY_Return) || (keysym == XKB_KEY_Escape) ||
 307             (keysym == XKB_KEY_KP_Space) || (keysym == XKB_KEY_KP_Tab) ||
 308             (keysym == XKB_KEY_KP_Enter) ||
 309             ((keysym >= XKB_KEY_KP_Multiply) && (keysym <= XKB_KEY_KP_9)) ||
 310             (keysym == XKB_KEY_KP_Equal) || (keysym == XKB_KEY_Delete))))))
 311      return 0;
 312
 313    if (keysym == XKB_KEY_KP_Space)
 314      c = (XKB_KEY_space & 0x7F);
 315    else if (hbytes == 0xFF)
 316      c = (keysym & 0x7F);
 317    else
 318      c = (keysym & 0xFF);
 319
 320    if (modifiers & ECORE_EVENT_MODIFIER_CTRL)
 321      {
 322         if (((c >= '@') && (c < '\177')) || c == ' ')
 323           c &= 0x1F;
 324         else if (c == '2')
 325           c = '\000';
 326         else if ((c >= '3') && (c <= '7'))
 327           c -= ('3' - '\033');
 328         else if (c == '8')
 329           c = '\177';
 330         else if (c == '/')
 331           c = '_' & 0x1F;
 332      }
 333    buffer[0] = c;
 334    return 1;
 335 }
 336
 337 static void
 338 _device_modifiers_update_device(E_Input_Evdev *edev, E_Input_Evdev *from)
 339 {
 340    xkb_mod_mask_t mask;
 341
 342    g_mutex_lock(&from->xkb.state_mutex);
 343
 344    edev->xkb.depressed =
 345      xkb_state_serialize_mods(from->xkb.state, XKB_STATE_DEPRESSED);
 346    edev->xkb.latched =
 347      xkb_state_serialize_mods(from->xkb.state, XKB_STATE_LATCHED);
 348    edev->xkb.locked =
 349      xkb_state_serialize_mods(from->xkb.state, XKB_STATE_LOCKED);
 350    edev->xkb.group =
 351      xkb_state_serialize_mods(from->xkb.state, XKB_STATE_EFFECTIVE);
 352
 353    g_mutex_unlock(&from->xkb.state_mutex);
 354
 355    mask = (edev->xkb.depressed | edev->xkb.latched);
 356
 357    if (mask & from->xkb.ctrl_mask)
 358      edev->xkb.modifiers |= ECORE_EVENT_MODIFIER_CTRL;
 359    if (mask & from->xkb.alt_mask)
 360      edev->xkb.modifiers |= ECORE_EVENT_MODIFIER_ALT;
 361    if (mask & from->xkb.shift_mask)
 362      edev->xkb.modifiers |= ECORE_EVENT_MODIFIER_SHIFT;
 363    if (mask & from->xkb.win_mask)
 364      edev->xkb.modifiers |= ECORE_EVENT_MODIFIER_WIN;
 365    if (mask & from->xkb.scroll_mask)
 366      edev->xkb.modifiers |= ECORE_EVENT_LOCK_SCROLL;
 367    if (mask & from->xkb.num_mask)
 368      edev->xkb.modifiers |= ECORE_EVENT_LOCK_NUM;
 369    if (mask & from->xkb.caps_mask)
 370      edev->xkb.modifiers |= ECORE_EVENT_LOCK_CAPS;
 371    if (mask & from->xkb.altgr_mask)
 372      edev->xkb.modifiers |= ECORE_EVENT_MODIFIER_ALTGR;
 373 }
 374
 375 static void
 376 _device_modifiers_update(E_Input_Evdev *edev)
 377 {
 378    Eina_List *l;
 379    E_Input_Evdev *ed;
 380
 381    edev->xkb.modifiers = 0;
 382
 383    if (edev->caps & E_INPUT_SEAT_KEYBOARD)
 384      _device_modifiers_update_device(edev, edev);
 385    else
 386      {
 387         EINA_LIST_FOREACH(edev->seat->devices, l, ed)
 388           {
 389              if (!(ed->caps & E_INPUT_SEAT_KEYBOARD)) continue;
 390              _device_modifiers_update_device(edev, ed);
 391           }
 392      }
 393
 394 }
 395
 396 static int
 397 _device_remapped_key_get(E_Input_Evdev *edev, int code)
 398 {
 399    void *ret = NULL;
 400
 401    EINA_SAFETY_ON_NULL_RETURN_VAL(edev, code);
 402    if (!edev->key_remap_enabled) return code;
 403    EINA_SAFETY_ON_NULL_RETURN_VAL(edev->key_remap_hash, code);
 404
 405    ret = eina_hash_find(edev->key_remap_hash, &code);
 406
 407    if (ret) code = (int)(intptr_t)ret;
 408
 409    return code;
 410 }
 411
 412 EINTERN E_Device *
 413 e_input_evdev_get_e_device(const char *path, Ecore_Device_Class clas)
 414 {
 415    const GList *dev_list = NULL;
 416    const GList *l;
 417    E_Device *dev = NULL;
 418    const char *identifier;
 419
 420    if (!path) return NULL;
 421
 422    dev_list = e_device_list_get();
 423    if (!dev_list) return NULL;
 424
 425    l = dev_list;
 426    while (l)
 427      {
 428         dev = l->data;
 429         if (!dev) continue;
 430         identifier = e_device_identifier_get(dev);
 431         if (!identifier) continue;
 432         if ((e_device_class_get(dev) == clas) && !(strcmp(identifier, path)))
 433           return dev;
 434
 435         l = g_list_next(l);
 436      }
 437
 438    return NULL;
 439 }
 440
 441 EINTERN Ecore_Device *
 442 e_input_evdev_get_ecore_device(const char *path, Ecore_Device_Class clas)
 443 {
 444    const Eina_List *dev_list = NULL;
 445    const Eina_List *l;
 446    Ecore_Device *dev = NULL;
 447    const char *identifier;
 448
 449    if (!path) return NULL;
 450
 451    dev_list = ecore_device_list();
 452    if (!dev_list) return NULL;
 453    EINA_LIST_FOREACH(dev_list, l, dev)
 454      {
 455         if (!dev) continue;
 456         identifier = ecore_device_identifier_get(dev);
 457         if (!identifier) continue;
 458         if ((ecore_device_class_get(dev) == clas) && !(strcmp(identifier, path)))
 459           return dev;
 460      }
 461    return NULL;
 462 }
 463
 464 static void
 465 _e_input_event_mouse_move_cb_free(void *data EINA_UNUSED, void *event)
 466 {
 467    Ecore_Event_Mouse_Move *ev = event;
 468
 469    if (ev->dev) ecore_device_unref(ev->dev);
 470
 471    free(ev);
 472 }
 473
 474 static void
 475 _e_input_event_mouse_relative_move_cb_free(void *data EINA_UNUSED, void *event)
 476 {
 477    Ecore_Event_Mouse_Relative_Move *ev = event;
 478
 479    if (ev->dev) ecore_device_unref(ev->dev);
 480
 481    free(ev);
 482 }
 483
 484 static void
 485 _e_input_event_mouse_wheel_cb_free(void *data EINA_UNUSED, void *event)
 486 {
 487    Ecore_Event_Mouse_Wheel *ev = event;
 488
 489    if (ev->dev) ecore_device_unref(ev->dev);
 490
 491    free(ev);
 492 }
 493
 494 static void
 495 _e_input_event_mouse_button_cb_free(void *data EINA_UNUSED, void *event)
 496 {
 497    Ecore_Event_Mouse_Button *ev = event;
 498
 499    if (ev->dev) ecore_device_unref(ev->dev);
 500
 501    free(ev);
 502 }
 503
 504 static void
 505 _e_input_event_key_cb_free(void *data EINA_UNUSED, void *event)
 506 {
 507    Ecore_Event_Key *ev = event;
 508
 509    if (e_input_thread_mode_get())
 510      {
 511         if (ev->dev) g_object_unref(ev->dev);
 512      }
 513    else
 514      {
 515         if (ev->dev) ecore_device_unref(ev->dev);
 516      }
 517
 518    if (ev->data) E_FREE(ev->data);
 519
 520    free(ev);
 521 }
 522
 523 static void
 524 _device_handle_key(struct libinput_device *device, struct libinput_event_keyboard *event)
 525 {
 526    E_Input_Evdev *edev;
 527    E_Input_Backend *input;
 528    uint32_t timestamp;
 529    uint32_t code, nsyms;
 530    const xkb_keysym_t *syms;
 531    enum libinput_key_state state;
 532    int key_count;
 533    xkb_keysym_t sym = XKB_KEY_NoSymbol;
 534    char key[256] = {0, }, keyname[256] = {0, }, compose_buffer[256] = {0, };
 535    Ecore_Event_Key *e;
 536    char *tmp = NULL, *compose = NULL;
 537    E_Keyrouter_Event_Data *key_data;
 538    Ecore_Device *ecore_dev = NULL, *data;
 539    E_Device *e_dev = NULL, *e_dev_data;
 540    Eina_List *l = NULL, *l_next = NULL;
 541    GList *glist = NULL;
 542    E_Comp_Config *comp_conf = NULL;
 543    int *pressed_keycode = NULL, *idata = NULL;
 544    Eina_Bool dup_found = EINA_FALSE;
 545    const char* device_name = NULL;
 546    Ecore_Device_Subclass device_subclas = ECORE_DEVICE_SUBCLASS_NONE;
 547
 548    if (!(edev = libinput_device_get_user_data(device)))
 549      {
 550         return;
 551      }
 552
 553    if (!(input = edev->seat->input))
 554      {
 555         return;
 556      }
 557
 558    if (!e_input_thread_mode_get())
 559      {
 560         if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
 561         else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
 562           {
 563              EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
 564                {
 565                   if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_KEYBOARD)
 566                     {
 567                        ecore_dev = data;
 568                        break;
 569                     }
 570                }
 571           }
 572         else
 573           {
 574              edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_KEYBOARD);
 575              ecore_dev = edev->ecore_dev;
 576           }
 577
 578         if (!ecore_dev)
 579           {
 580              ERR("Failed to get source ecore device from event !\n");
 581              return;
 582           }
 583
 584         device_name = ecore_device_name_get(ecore_dev);
 585         device_subclas = ecore_device_subclass_get(ecore_dev);
 586      }
 587    else
 588      {
 589         if (edev->e_dev) e_dev = edev->e_dev;
 590         else if (edev->e_dev_list && g_list_length(edev->e_dev_list) > 0)
 591           {
 592              glist = edev->e_dev_list;
 593              while (glist)
 594                {
 595                   e_dev_data = glist->data;
 596                   if (e_device_class_get(e_dev_data) == ECORE_DEVICE_CLASS_KEYBOARD)
 597                     {
 598                        e_dev = e_dev_data;
 599                        break;
 600                     }
 601
 602                   glist = g_list_next(glist);
 603                }
 604           }
 605         else
 606           {
 607              edev->e_dev = e_input_evdev_get_e_device(edev->path, ECORE_DEVICE_CLASS_KEYBOARD);
 608              e_dev = edev->e_dev;
 609           }
 610
 611         if (!e_dev)
 612           {
 613              ERR("Failed to get source e device from event !\n");
 614              return;
 615           }
 616
 617         device_name = e_device_name_get(e_dev);
 618         device_subclas = e_device_subclass_get(e_dev);
 619      }
 620
 621    timestamp = libinput_event_keyboard_get_time(event);
 622    code = libinput_event_keyboard_get_key(event);
 623    code = _device_remapped_key_get(edev, code + 8);
 624    state = libinput_event_keyboard_get_key_state(event);
 625    key_count = libinput_event_keyboard_get_seat_key_count(event);
 626
 627    if (state == LIBINPUT_KEY_STATE_PRESSED)
 628      {
 629         if ((edev->seat->dev->blocked & E_INPUT_SEAT_KEYBOARD) ||
 630             (edev->seat->dev->server_blocked & E_INPUT_SEAT_KEYBOARD))
 631           {
 632              g_rec_mutex_lock(&edev->seat->dev->blocked_client_mutex);
 633              ELOGF("Key", "Press (keycode: %d, device: %s) is blocked by %p, server: 0x%x", NULL,
 634                    code, device_name, edev->seat->dev->blocked_client,
 635                    edev->seat->dev->server_blocked);
 636              g_rec_mutex_unlock(&edev->seat->dev->blocked_client_mutex);
 637              return;
 638           }
 639
 640         /* FIXME: Currently to maintain press/release event pair during input block,
 641          *        used Eina_List and this is method used in devicemgr module.
 642          *        But we need to consider which way is better to maintain key press/release pair.
 643          */
 644
 645         EINA_LIST_FOREACH(edev->xkb.pressed_keys, l, idata)
 646           {
 647              if (*idata == code)
 648                {
 649                   dup_found = EINA_TRUE;
 650                   break;
 651                }
 652           }
 653         if (!dup_found)
 654           {
 655              pressed_keycode = E_NEW(int, 1);
 656              EINA_SAFETY_ON_NULL_RETURN(pressed_keycode);
 657              *pressed_keycode = code;
 658
 659              edev->xkb.pressed_keys = eina_list_append(edev->xkb.pressed_keys, pressed_keycode);
 660           }
 661      }
 662    else
 663      {
 664         dup_found = EINA_FALSE;
 665         EINA_LIST_FOREACH_SAFE(edev->xkb.pressed_keys, l, l_next, idata)
 666           {
 667              if (code == *idata)
 668                {
 669                   edev->xkb.pressed_keys = eina_list_remove_list(edev->xkb.pressed_keys, l);
 670                   E_FREE(idata);
 671                   dup_found = EINA_TRUE;
 672                   break;
 673                }
 674           }
 675         if (!dup_found)
 676           {
 677              g_rec_mutex_lock(&edev->seat->dev->blocked_client_mutex);
 678              ELOGF("Key", "Release (keycode: %d, device: %s) is blocked by %p", NULL,
 679                    code, device_name, edev->seat->dev->blocked_client);
 680              g_rec_mutex_unlock(&edev->seat->dev->blocked_client_mutex);
 681              return;
 682           }
 683      }
 684
 685    /* ignore key events that are not seat wide state changes */
 686    if (((state == LIBINPUT_KEY_STATE_PRESSED) && (key_count != 1)) ||
 687        ((state == LIBINPUT_KEY_STATE_RELEASED) && (key_count != 0)))
 688      {
 689         return;
 690      }
 691
 692    e_input_keyboard_grab_key_cb func = e_input_keyboard_grab_key_handler_get();
 693    if (func)
 694      {
 695         if (e_devicemgr_keyboard_grab_subtype_is_grabbed(device_subclas))
 696           {
 697              func(code, state, timestamp);
 698              return;
 699           }
 700      }
 701
 702    g_mutex_lock(&edev->xkb.state_mutex);
 703    xkb_state_update_key(edev->xkb.state, code,
 704                         (state ? XKB_KEY_DOWN : XKB_KEY_UP));
 705
 706    /* get the keysym for this code */
 707    nsyms = xkb_key_get_syms(edev->xkb.state, code, &syms);
 708    g_mutex_unlock(&edev->xkb.state_mutex);
 709
 710    if (nsyms == 1) sym = syms[0];
 711
 712    /* If no keysym was found, name it "Keycode-NNN" */
 713    if (sym == XKB_KEY_NoSymbol)
 714      snprintf(key, sizeof(key), "Keycode-%u", code);
 715    else
 716      {
 717         /* get the keyname for this sym */
 718         xkb_keysym_get_name(sym, key, sizeof(key));
 719      }
 720
 721    if (key[0] == '\0')
 722      {
 723         /* If no keyname was found, name it "Keycode-NNN" */
 724         snprintf(keyname, sizeof(keyname), "Keycode-%u", code);
 725      }
 726    else
 727      {
 728         memcpy(keyname, key, sizeof(keyname));
 729      }
 730
 731    /* if shift is active, we need to transform the key to lower */
 732    g_mutex_lock(&edev->xkb.keymap_mutex);
 733    g_mutex_lock(&edev->xkb.state_mutex);
 734    if (xkb_state_mod_index_is_active(edev->xkb.state,
 735                                      xkb_map_mod_get_index(edev->xkb.keymap,
 736                                      XKB_MOD_NAME_SHIFT),
 737                                      XKB_STATE_MODS_EFFECTIVE))
 738      {
 739         if (keyname[0] != '\0')
 740           keyname[0] = tolower(keyname[0]);
 741      }
 742    g_mutex_unlock(&edev->xkb.keymap_mutex);
 743    g_mutex_unlock(&edev->xkb.state_mutex);
 744
 745    if (_device_keysym_translate(sym, edev->xkb.modifiers,
 746                                 compose_buffer, sizeof(compose_buffer)))
 747      {
 748         compose = eina_str_convert("ISO8859-1", "UTF-8", compose_buffer);
 749         if (!compose)
 750           {
 751              ERR("E Input cannot convert input key string '%s' to UTF-8. "
 752                  "Is Eina built with iconv support?", compose_buffer);
 753           }
 754         else
 755           tmp = compose;
 756      }
 757
 758    if (!compose) compose = compose_buffer;
 759
 760    e = calloc(1, sizeof(Ecore_Event_Key) + strlen(key) + strlen(keyname) +
 761               ((compose[0] != '\0') ? strlen(compose) : 0) + 3);
 762    if (!e)
 763      {
 764         E_FREE(tmp);
 765         return;
 766      }
 767    key_data = E_NEW(E_Keyrouter_Event_Data, 1);
 768    if (!key_data)
 769      {
 770         E_FREE(tmp);
 771         E_FREE(e);
 772         return;
 773      }
 774
 775    e->keyname = (char *)(e + 1);
 776    e->key = e->keyname + strlen(keyname) + 1;
 777    e->compose = strlen(compose) ? e->key + strlen(key) + 1 : NULL;
 778    e->string = e->compose;
 779
 780    strncpy((char *)e->keyname, keyname, strlen(keyname));
 781    strncpy((char *)e->key, key, strlen(key));
 782    if (strlen(compose)) strncpy((char *)e->compose, compose, strlen(compose));
 783
 784    e->window = (Ecore_Window)input->dev->window;
 785    e->event_window = (Ecore_Window)input->dev->window;
 786    e->root_window = (Ecore_Window)input->dev->window;
 787    e->timestamp = timestamp;
 788    e->same_screen = 1;
 789    e->keycode = code;
 790    e->data = key_data;
 791
 792    _device_modifiers_update(edev);
 793
 794    e->modifiers = edev->xkb.modifiers;
 795
 796    comp_conf = e_comp_config_get();
 797
 798    if (comp_conf && comp_conf->input_log_enable)
 799      ELOGF("Key", "%s (keyname: %s, keycode: %d, timestamp: %u, device: %s)", NULL, state?"Press":"Release", e->keyname, e->keycode, e->timestamp, device_name);
 800
 801    if (e_input_thread_mode_get())
 802      {
 803         e->dev = (Eo *)g_object_ref(e_dev);
 804         e_input_event_add(input->event_source, state ? ECORE_EVENT_KEY_DOWN : ECORE_EVENT_KEY_UP, e, _e_input_event_key_cb_free, NULL);
 805      }
 806    else
 807      {
 808         e->dev = ecore_device_ref(ecore_dev);
 809         ecore_event_add(state ? ECORE_EVENT_KEY_DOWN : ECORE_EVENT_KEY_UP, e, _e_input_event_key_cb_free, NULL);
 810      }
 811
 812    if (tmp) free(tmp);
 813 }
 814
 815 static void
 816 _device_pointer_motion(E_Input_Evdev *edev, struct libinput_event_pointer *event)
 817 {
 818    E_Input_Backend *input;
 819    Ecore_Event_Mouse_Move *ev;
 820    Ecore_Device *ecore_dev = NULL, *data, *detent_data = NULL;
 821    Eina_List *l;
 822    int x = 0, y = 0, w = 0, h = 0;
 823
 824    if (!(input = edev->seat->input)) return;
 825
 826    ecore_thread_main_loop_begin();
 827
 828    if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
 829    else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
 830      {
 831         EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
 832           {
 833              if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_MOUSE)
 834                {
 835                   ecore_dev = data;
 836                   break;
 837                }
 838              else if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_NONE)
 839                {
 840                   detent_data = data;
 841                }
 842           }
 843         if (!ecore_dev && e_devicemgr_detent_is_detent(libinput_device_get_name(edev->device)))
 844           {
 845              ecore_dev = detent_data;
 846           }
 847      }
 848    else
 849      {
 850         edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_MOUSE);
 851         ecore_dev = edev->ecore_dev;
 852      }
 853
 854    if (!ecore_dev)
 855      {
 856         ERR("Failed to get source ecore device from event !\n");
 857         goto end;
 858      }
 859    else if ((detent_data == ecore_dev) || e_devicemgr_detent_is_detent(ecore_device_name_get(ecore_dev)))
 860      {
 861         /* Do not process detent device's move events. */
 862         goto end;
 863      }
 864
 865    if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Move)))) return;
 866
 867    _device_configured_size_get(edev, &x, &y, &w, &h);
 868
 869    if (edev->seat->ptr.ix < x)
 870      edev->seat->ptr.dx = edev->seat->ptr.ix = x;
 871    else if (edev->seat->ptr.ix >= (x + w))
 872      edev->seat->ptr.dx = edev->seat->ptr.ix = (x + w - 1);
 873
 874    if (edev->seat->ptr.iy < y)
 875      edev->seat->ptr.dy = edev->seat->ptr.iy = y;
 876    else if (edev->seat->ptr.iy >= (y + h))
 877      edev->seat->ptr.dy = edev->seat->ptr.iy = (y + h - 1);
 878
 879    edev->mouse.dx = edev->seat->ptr.dx;
 880    edev->mouse.dy = edev->seat->ptr.dy;
 881
 882    ev->window = (Ecore_Window)input->dev->window;
 883    ev->event_window = (Ecore_Window)input->dev->window;
 884    ev->root_window = (Ecore_Window)input->dev->window;
 885    if (event) ev->timestamp = libinput_event_pointer_get_time(event);
 886    ev->same_screen = 1;
 887
 888    _device_modifiers_update(edev);
 889    ev->modifiers = edev->xkb.modifiers;
 890
 891    ev->x = edev->seat->ptr.ix;
 892    ev->y = edev->seat->ptr.iy;
 893    ev->root.x = ev->x;
 894    ev->root.y = ev->y;
 895
 896    ev->multi.device = edev->mt_slot;
 897    ev->multi.radius = 1;
 898    ev->multi.radius_x = 1;
 899    ev->multi.radius_y = 1;
 900    ev->multi.pressure = 1.0;
 901    ev->multi.angle = 0.0;
 902    ev->multi.x = ev->x;
 903    ev->multi.y = ev->y;
 904    ev->multi.root.x = ev->x;
 905    ev->multi.root.y = ev->y;
 906
 907    ev->dev = ecore_device_ref(ecore_dev);
 908
 909    ecore_event_add(ECORE_EVENT_MOUSE_MOVE, ev, _e_input_event_mouse_move_cb_free, NULL);
 910
 911 end:
 912    ecore_thread_main_loop_end();
 913 }
 914
 915 void
 916 _e_input_pointer_motion_post(E_Input_Evdev *edev)
 917 {
 918    _device_pointer_motion(edev, NULL);
 919 }
 920
 921 static void
 922 _device_pointer_relative_motion(E_Input_Evdev *edev, struct libinput_event_pointer *event, double dx[2], double dy[2])
 923 {
 924    E_Input_Backend *input;
 925    Ecore_Event_Mouse_Relative_Move *ev;
 926    Ecore_Device *ecore_dev = NULL, *data, *detent_data = NULL;
 927    Eina_List *l;
 928    E_Comp_Config *comp_conf;
 929
 930    if (!(input = edev->seat->input)) return;
 931
 932    ecore_thread_main_loop_begin();
 933
 934    if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
 935    else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
 936      {
 937         EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
 938           {
 939              if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_MOUSE)
 940                {
 941                   ecore_dev = data;
 942                   break;
 943                }
 944              else if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_NONE)
 945                {
 946                   detent_data = data;
 947                }
 948           }
 949         if (!ecore_dev && e_devicemgr_detent_is_detent(libinput_device_get_name(edev->device)))
 950           {
 951              ecore_dev = detent_data;
 952           }
 953      }
 954    else
 955      {
 956         edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_MOUSE);
 957         ecore_dev = edev->ecore_dev;
 958      }
 959
 960    if (!ecore_dev)
 961      {
 962         ERR("Failed to get source ecore device from event !\n");
 963         goto end;
 964      }
 965    else if ((detent_data == ecore_dev) || e_devicemgr_detent_is_detent(ecore_device_name_get(ecore_dev)))
 966      {
 967         /* Do not process detent device's move events. */
 968         goto end;
 969      }
 970
 971    if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Relative_Move)))) return;
 972
 973    ev->window = (Ecore_Window)input->dev->window;
 974    ev->event_window = (Ecore_Window)input->dev->window;
 975    if (event) ev->timestamp = libinput_event_pointer_get_time(event);
 976
 977    ev->modifiers = edev->xkb.modifiers;
 978
 979    ev->dx = (int)dx[0];
 980    ev->dy = (int)dy[0];
 981    ev->dx_unaccel = (int)dx[1];
 982    ev->dy_unaccel = (int)dy[1];
 983
 984    ev->dev = ecore_device_ref(ecore_dev);
 985
 986    comp_conf = e_comp_config_get();
 987    if (comp_conf && comp_conf->input_log_enable)
 988      ELOGF("Mouse", "Relative Move (dx: %d, dy: %d, unaccel(%d, %d) device: %s)", NULL, ev->dx, ev->dx, ev->dx_unaccel, ev->dy_unaccel, ecore_device_name_get(ev->dev));
 989
 990    ecore_event_add(ECORE_EVENT_MOUSE_RELATIVE_MOVE, ev, _e_input_event_mouse_relative_move_cb_free, NULL);
 991
 992 end:
 993    ecore_thread_main_loop_end();
 994 }
 995
 996 static void
 997 _device_pointer_motion_send(E_Input_Evdev *edev, struct libinput_event_pointer *event, double dx[2], double dy[2])
 998 {
 999    e_input_relative_motion_cb func = e_input_relative_motion_handler_get();
1000    if (func)
1001      {
1002         //func(dx, dy, time_us);
1003         _device_pointer_relative_motion(edev, event, dx, dy);
1004      }
1005    else
1006      {
1007         double seat_dx, seat_dy, temp;
1008         if (edev->disable_acceleration)
1009           {
1010               seat_dx = dx[1];
1011               seat_dy = dy[1];
1012           }
1013         else
1014           {
1015               seat_dx = dx[0];
1016               seat_dy = dy[0];
1017           }
1018
1019         if (edev->seat->ptr.swap)
1020           {
1021               temp = seat_dx;
1022               seat_dx = seat_dy;
1023               seat_dy = temp;
1024           }
1025         if (edev->seat->ptr.invert_x)
1026           seat_dx *= -1;
1027         if (edev->seat->ptr.invert_y)
1028           seat_dy *= -1;
1029
1030         edev->seat->ptr.dx += seat_dx;
1031         edev->seat->ptr.dy += seat_dy;
1032
1033         edev->mouse.dx = edev->seat->ptr.dx;
1034         edev->mouse.dy = edev->seat->ptr.dy;
1035
1036         if (floor(edev->seat->ptr.dx) == edev->seat->ptr.ix &&
1037             floor(edev->seat->ptr.dy) == edev->seat->ptr.iy)
1038           {
1039               return;
1040           }
1041
1042         edev->seat->ptr.ix = edev->seat->ptr.dx;
1043         edev->seat->ptr.iy = edev->seat->ptr.dy;
1044
1045         if ((edev->seat->dev->blocked & E_INPUT_SEAT_POINTER) ||
1046             (edev->seat->dev->server_blocked & E_INPUT_SEAT_POINTER))
1047           {
1048               return;
1049           }
1050
1051         _device_pointer_motion(edev, event);
1052      }
1053 }
1054
1055 static void
1056 _device_handle_pointer_motion(struct libinput_device *device, struct libinput_event_pointer *event)
1057 {
1058    E_Input_Evdev *edev;
1059    double delta_x[2]; /* delta_x[0] for accelerated, delta_x[1] for unaccelerated */
1060    double delta_y[2]; /* delta_y[0] for accelerated, delta_y[1] for unaccelerated */
1061
1062    if (!(edev = libinput_device_get_user_data(device)))
1063      {
1064         return;
1065      }
1066
1067    delta_x[0] = libinput_event_pointer_get_dx(event);
1068    delta_x[1] = libinput_event_pointer_get_dx_unaccelerated(event);
1069    delta_y[0] = libinput_event_pointer_get_dy(event);
1070    delta_y[1] = libinput_event_pointer_get_dy_unaccelerated(event);
1071
1072    _device_pointer_motion_send(edev, event, &delta_x[0], &delta_y[0]);
1073 }
1074
1075 static void
1076 _device_handle_pointer_motion_absolute(struct libinput_device *device, struct libinput_event_pointer *event)
1077 {
1078    E_Input_Evdev *edev;
1079    int w = 0, h = 0;
1080
1081    if (!(edev = libinput_device_get_user_data(device)))
1082      {
1083         return;
1084      }
1085
1086    e_output_size_get(e_comp_screen_primary_output_get(e_comp->e_comp_screen), &w, &h);
1087
1088    edev->mouse.dx = edev->seat->ptr.dx =
1089      libinput_event_pointer_get_absolute_x_transformed(event, w);
1090    edev->mouse.dy = edev->seat->ptr.dy =
1091      libinput_event_pointer_get_absolute_y_transformed(event, h);
1092
1093    if (floor(edev->seat->ptr.dx) == edev->seat->ptr.ix &&
1094        floor(edev->seat->ptr.dy) == edev->seat->ptr.iy)
1095      {
1096         return;
1097      }
1098
1099    edev->seat->ptr.ix = edev->seat->ptr.dx;
1100    edev->seat->ptr.iy = edev->seat->ptr.dy;
1101
1102    if ((edev->seat->dev->blocked & E_INPUT_SEAT_POINTER) ||
1103        (edev->seat->dev->server_blocked & E_INPUT_SEAT_POINTER))
1104      {
1105         return;
1106      }
1107
1108    _device_pointer_motion(edev, event);
1109 }
1110
1111 static void
1112 _device_handle_button(struct libinput_device *device, struct libinput_event_pointer *event)
1113 {
1114    E_Input_Evdev *edev;
1115    E_Input_Backend *input;
1116    Ecore_Event_Mouse_Button *ev;
1117    enum libinput_button_state state;
1118    uint32_t button, timestamp;
1119    Ecore_Device *ecore_dev = NULL, *detent_data = NULL, *data;
1120    Eina_List *l;
1121    E_Comp_Config *comp_conf = NULL;
1122
1123    if (!(edev = libinput_device_get_user_data(device)))
1124      {
1125         return;
1126      }
1127    if (!(input = edev->seat->input))
1128      {
1129         return;
1130      }
1131
1132    ecore_thread_main_loop_begin();
1133
1134    if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1135    else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1136      {
1137         EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1138           {
1139              if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_MOUSE)
1140                {
1141                   ecore_dev = data;
1142                   break;
1143                }
1144              else if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_NONE)
1145                {
1146                   detent_data = data;
1147                }
1148           }
1149         if (!ecore_dev && e_devicemgr_detent_is_detent(libinput_device_get_name(edev->device)))
1150           {
1151              ecore_dev = detent_data;
1152           }
1153      }
1154    else
1155      {
1156         edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_MOUSE);
1157         ecore_dev = edev->ecore_dev;
1158      }
1159
1160    if (!ecore_dev)
1161      {
1162         ERR("Failed to get source ecore device from event !\n");
1163         goto end;
1164      }
1165
1166    state = libinput_event_pointer_get_button_state(event);
1167    button = libinput_event_pointer_get_button(event);
1168    timestamp = libinput_event_pointer_get_time(event);
1169
1170    button = ((button & 0x00F) + 1);
1171    if (button == 3) button = 2;
1172    else if (button == 2) button = 3;
1173
1174    if (state)
1175      {
1176         if ((edev->seat->dev->blocked & E_INPUT_SEAT_POINTER) ||
1177             (edev->seat->dev->server_blocked & E_INPUT_SEAT_POINTER))
1178           {
1179              g_rec_mutex_lock(&edev->seat->dev->blocked_client_mutex);
1180              ELOGF("Mouse", "Button Press (btn: %d, device: %s) is blocked by %p, server: 0x%x", NULL,
1181                    button, ecore_device_name_get(ecore_dev), edev->seat->dev->blocked_client,
1182                    edev->seat->dev->server_blocked);
1183              g_rec_mutex_unlock(&edev->seat->dev->blocked_client_mutex);
1184              goto end;
1185           }
1186         else
1187           {
1188              edev->mouse.pressed_button |= (1 << button);
1189           }
1190      }
1191    else
1192      {
1193         if (!(edev->mouse.pressed_button & (1 << button)))
1194           {
1195              g_rec_mutex_lock(&edev->seat->dev->blocked_client_mutex);
1196              ELOGF("Mouse", "Button Release (btn: %d, device: %s) is blocked by %p, server: 0x%x", NULL,
1197                    button, ecore_device_name_get(ecore_dev), edev->seat->dev->blocked_client,
1198                    edev->seat->dev->server_blocked);
1199              g_rec_mutex_unlock(&edev->seat->dev->blocked_client_mutex);
1200              goto end;
1201           }
1202         edev->mouse.pressed_button &= ~(1 << button);
1203      }
1204
1205    if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Button))))
1206      {
1207         goto end;
1208      }
1209
1210    ev->window = (Ecore_Window)input->dev->window;
1211    ev->event_window = (Ecore_Window)input->dev->window;
1212    ev->root_window = (Ecore_Window)input->dev->window;
1213    ev->timestamp = timestamp;
1214    ev->same_screen = 1;
1215
1216    _device_modifiers_update(edev);
1217    ev->modifiers = edev->xkb.modifiers;
1218
1219    ev->x = edev->seat->ptr.ix;
1220    ev->y = edev->seat->ptr.iy;
1221    ev->root.x = ev->x;
1222    ev->root.y = ev->y;
1223
1224    ev->multi.device = edev->mt_slot;
1225    ev->multi.radius = 1;
1226    ev->multi.radius_x = 1;
1227    ev->multi.radius_y = 1;
1228    ev->multi.pressure = 1.0;
1229    ev->multi.angle = 0.0;
1230    ev->multi.x = ev->x;
1231    ev->multi.y = ev->y;
1232    ev->multi.root.x = ev->x;
1233    ev->multi.root.y = ev->y;
1234    ev->dev = ecore_device_ref(ecore_dev);
1235
1236    if (state)
1237      {
1238         unsigned int current;
1239
1240         current = timestamp;
1241         edev->mouse.did_double = EINA_FALSE;
1242         edev->mouse.did_triple = EINA_FALSE;
1243
1244         if (((current - edev->mouse.prev) <= edev->mouse.threshold) &&
1245             (button == edev->mouse.prev_button))
1246           {
1247              edev->mouse.did_double = EINA_TRUE;
1248              if (((current - edev->mouse.last) <= (2 * edev->mouse.threshold)) &&
1249                  (button == edev->mouse.last_button))
1250                {
1251                   edev->mouse.did_triple = EINA_TRUE;
1252                   edev->mouse.prev = 0;
1253                   edev->mouse.last = 0;
1254                   current = 0;
1255                }
1256           }
1257
1258         edev->mouse.last = edev->mouse.prev;
1259         edev->mouse.prev = current;
1260         edev->mouse.last_button = edev->mouse.prev_button;
1261         edev->mouse.prev_button = button;
1262      }
1263
1264    ev->buttons = button;
1265
1266    if (edev->mouse.did_double)
1267      ev->double_click = 1;
1268    if (edev->mouse.did_triple)
1269      ev->triple_click = 1;
1270
1271    comp_conf = e_comp_config_get();
1272    if (comp_conf && comp_conf->input_log_enable)
1273      ELOGF("Mouse", "Button %s (btn: %d, device: %s)", NULL, state?"Press":"Release", button, ecore_device_name_get(ev->dev));
1274
1275    if (state)
1276      ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, ev, _e_input_event_mouse_button_cb_free, NULL);
1277    else
1278      ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_UP, ev, _e_input_event_mouse_button_cb_free, NULL);
1279
1280 end:
1281    ecore_thread_main_loop_end();
1282 }
1283
1284 #if !LIBINPUT_HAVE_SCROLL_VALUE_V120
1285 static int
1286 _axis_value_get(struct libinput_event_pointer *pointer_event, enum libinput_pointer_axis axis)
1287 {
1288    enum libinput_pointer_axis_source source;
1289    double value = 0.0, value_discrete = 0.0;
1290    int ret = 0;
1291    E_Comp_Config *comp_conf = NULL;
1292
1293    comp_conf = e_comp_config_get();
1294    source = libinput_event_pointer_get_axis_source(pointer_event);
1295    switch (source)
1296      {
1297       case LIBINPUT_POINTER_AXIS_SOURCE_WHEEL:
1298         value_discrete = libinput_event_pointer_get_axis_value_discrete(pointer_event, axis);
1299         value = libinput_event_pointer_get_axis_value(pointer_event, axis);
1300         if (comp_conf && comp_conf->input_log_enable)
1301           {
1302              ELOGF("Axis", "SOURCE_WHEEL discrete: %lf (cf. value: %lf)", NULL, value_discrete, value);
1303           }
1304         ret = (int)value_discrete;
1305         break;
1306       case LIBINPUT_POINTER_AXIS_SOURCE_FINGER:
1307       case LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS:
1308         value = libinput_event_pointer_get_axis_value(pointer_event, axis);
1309         if (comp_conf && comp_conf->input_log_enable)
1310           {
1311              ELOGF("Axis", "SOURCE_FINGER/CONTINUOUS value: %lf", NULL, value);
1312           }
1313         if (value >= E_INPUT_FINGER_SCROLL_THRESHOLD)
1314           ret = 1;
1315         else if (value <= E_INPUT_FINGER_SCROLL_THRESHOLD * (-1))
1316           ret = -1;
1317         else
1318           ret = 0;
1319         break;
1320       default:
1321         break;
1322      }
1323
1324    return ret;
1325 }
1326
1327 static void
1328 _device_handle_axis(struct libinput_device *device, struct libinput_event_pointer *event)
1329 {
1330    E_Input_Evdev *edev;
1331    E_Input_Backend *input;
1332    Ecore_Event_Mouse_Wheel *ev;
1333    uint32_t timestamp;
1334    enum libinput_pointer_axis axis;
1335    Ecore_Device *ecore_dev = NULL, *detent_data = NULL, *data;
1336    Eina_List *l;
1337    E_Comp_Config *comp_conf = NULL;
1338    int direction = 0, z = 0;
1339
1340    if (!(edev = libinput_device_get_user_data(device)))
1341      {
1342         return;
1343      }
1344    if (!(input = edev->seat->input))
1345      {
1346         return;
1347      }
1348
1349    ecore_thread_main_loop_begin();
1350
1351    if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1352    else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1353      {
1354         EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1355           {
1356              if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_MOUSE)
1357                {
1358                   ecore_dev = data;
1359                   break;
1360                }
1361              else if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_NONE)
1362                {
1363                   detent_data = data;
1364                }
1365           }
1366         if (!ecore_dev && e_devicemgr_detent_is_detent(libinput_device_get_name(edev->device)))
1367           {
1368              ecore_dev = detent_data;
1369           }
1370      }
1371    else
1372      {
1373         edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_MOUSE);
1374         ecore_dev = edev->ecore_dev;
1375      }
1376
1377    if (!ecore_dev)
1378      {
1379         ERR("Failed to get source ecore device from event !\n");
1380         goto end;
1381      }
1382
1383    axis = LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL;
1384    if (libinput_event_pointer_has_axis(event, axis))
1385      z = _axis_value_get(event, axis);
1386
1387    axis = LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL;
1388    if (libinput_event_pointer_has_axis(event, axis))
1389      {
1390         direction = 1;
1391         z = _axis_value_get(event, axis);
1392      }
1393
1394   if (z == 0)
1395     {
1396        ELOGF("Mouse", "Axis event is ignored since it has zero value", NULL);
1397        goto end;
1398     }
1399
1400    comp_conf = e_comp_config_get();
1401    if (comp_conf && comp_conf->e_wheel_click_angle)
1402      {
1403         z = (int)(z * comp_conf->e_wheel_click_angle);
1404      }
1405
1406    if ((edev->seat->dev->blocked & E_INPUT_SEAT_POINTER) ||
1407        (edev->seat->dev->server_blocked & E_INPUT_SEAT_POINTER))
1408      {
1409         g_mutex_lock(&edev->seat->dev->blocked_client_mutex);
1410
1411         if (detent_data)
1412           ELOGF("Mouse", "Detent (direction: %d, value: %d) is blocked by %p, server: 0x%x", NULL,
1413                 direction, z, edev->seat->dev->blocked_client, edev->seat->dev->server_blocked);
1414         else
1415           ELOGF("Mouse", "Wheel (direction: %d, value: %d) is blocked by %p, server: 0x%x", NULL,
1416                 direction, z, edev->seat->dev->blocked_client, edev->seat->dev->server_blocked);
1417
1418         g_mutex_unlock(&edev->seat->dev->blocked_client_mutex);
1419         goto end;
1420      }
1421
1422    if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Wheel))))
1423      {
1424         goto end;
1425      }
1426
1427    timestamp = libinput_event_pointer_get_time(event);
1428
1429    ev->window = (Ecore_Window)input->dev->window;
1430    ev->event_window = (Ecore_Window)input->dev->window;
1431    ev->root_window = (Ecore_Window)input->dev->window;
1432    ev->timestamp = timestamp;
1433    ev->same_screen = 1;
1434
1435    _device_modifiers_update(edev);
1436    ev->modifiers = edev->xkb.modifiers;
1437
1438    ev->x = edev->seat->ptr.ix;
1439    ev->y = edev->seat->ptr.iy;
1440    ev->root.x = ev->x;
1441    ev->root.y = ev->y;
1442    ev->z = z;
1443    ev->direction = direction;
1444
1445    if (comp_conf && comp_conf->input_log_enable)
1446      {
1447         if (detent_data)
1448           ELOGF("Mouse", "Detent (direction: %d, value: %d)", NULL, ev->direction, ev->z);
1449         else
1450           ELOGF("Mouse", "Wheel (direction: %d, value: %d)", NULL, ev->direction, ev->z);
1451      }
1452
1453
1454    ev->dev = ecore_device_ref(ecore_dev);
1455    ecore_event_add(ECORE_EVENT_MOUSE_WHEEL, ev, _e_input_event_mouse_wheel_cb_free, NULL);
1456
1457 end:
1458    ecore_thread_main_loop_end();
1459 }
1460 #endif
1461
1462 #if LIBINPUT_HAVE_SCROLL_VALUE_V120
1463 static int
1464 _scroll_value_get(struct libinput_event_pointer *pointer_event, enum libinput_pointer_axis axis, E_Input_Axis_Source source)
1465 {
1466    double value = 0.0;
1467    double value_v120 = 0.0;
1468    int ret;
1469    E_Comp_Config *comp_conf = NULL;
1470
1471    comp_conf = e_comp_config_get();
1472    switch (source)
1473      {
1474       case E_INPUT_AXIS_SOURCE_WHEEL:
1475         value_v120 = libinput_event_pointer_get_scroll_value_v120(pointer_event, axis);
1476         value = libinput_event_pointer_get_scroll_value(pointer_event, axis);
1477         if (comp_conf && comp_conf->input_log_enable)
1478           {
1479              ELOGF("Scroll", "SOURCE_WHEEL value_v120: %lf (cf. value: %lf)", NULL, value_v120, value);
1480           }
1481         if (((int)value_v120 % E_INPUT_POINTER_AXIS_DISCRETE_STEP) != 0)
1482           {
1483              ERR("Wheel movements should be multiples (or fractions) of 120!\n");
1484              ret = 0;
1485           }
1486         else
1487           {
1488              ret = value_v120 / E_INPUT_POINTER_AXIS_DISCRETE_STEP;
1489           }
1490         break;
1491       case E_INPUT_AXIS_SOURCE_FINGER:
1492       case E_INPUT_AXIS_SOURCE_CONTINUOUS:
1493         value = libinput_event_pointer_get_scroll_value(pointer_event, axis);
1494         if (comp_conf && comp_conf->input_log_enable)
1495           {
1496              ELOGF("Scroll", "SOURCE_FINGER/CONTINUOUS value: %lf", NULL, value);
1497           }
1498         if (value >= E_INPUT_FINGER_SCROLL_THRESHOLD)
1499           ret = 1;
1500         else if (value <= E_INPUT_FINGER_SCROLL_THRESHOLD * (-1))
1501           ret = -1;
1502         else
1503           ret = 0;
1504         break;
1505       default:
1506         break;
1507      }
1508
1509    return ret;
1510 }
1511
1512 static void
1513 _device_handle_axis_v120(struct libinput_device *device, struct libinput_event_pointer *event, E_Input_Axis_Source source)
1514 {
1515    E_Input_Evdev *edev;
1516    E_Input_Backend *input;
1517    Ecore_Event_Mouse_Wheel *ev;
1518    uint32_t timestamp;
1519    enum libinput_pointer_axis axis;
1520    Ecore_Device *ecore_dev = NULL, *detent_data = NULL, *data;
1521    Eina_List *l;
1522    E_Comp_Config *comp_conf = NULL;
1523    int direction = 0, z = 0;
1524
1525    if (!(edev = libinput_device_get_user_data(device)))
1526      {
1527         return;
1528      }
1529    if (!(input = edev->seat->input))
1530      {
1531         return;
1532      }
1533
1534    ecore_thread_main_loop_begin();
1535
1536    if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1537    else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1538      {
1539         EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1540           {
1541              if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_MOUSE)
1542                {
1543                   ecore_dev = data;
1544                   break;
1545                }
1546              else if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_NONE)
1547                {
1548                   detent_data = data;
1549                }
1550           }
1551         if (!ecore_dev && e_devicemgr_detent_is_detent(libinput_device_get_name(edev->device)))
1552           {
1553              ecore_dev = detent_data;
1554           }
1555      }
1556    else
1557      {
1558         edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_MOUSE);
1559         ecore_dev = edev->ecore_dev;
1560      }
1561
1562    if (!ecore_dev)
1563      {
1564         ERR("Failed to get source ecore device from event !\n");
1565         goto end;
1566      }
1567
1568    axis = LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL;
1569    if (libinput_event_pointer_has_axis(event, axis))
1570      z = _scroll_value_get(event, axis, source);
1571
1572    axis = LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL;
1573    if (libinput_event_pointer_has_axis(event, axis))
1574      {
1575         direction = 1;
1576         z = _scroll_value_get(event, axis, source);
1577      }
1578
1579    if (z == 0)
1580      {
1581         ELOGF("Mouse", "Scroll event is ignored since it has zero value", NULL);
1582         goto end;
1583      }
1584
1585    comp_conf = e_comp_config_get();
1586    if (comp_conf && comp_conf->e_wheel_click_angle)
1587      {
1588         z = (int)(z * comp_conf->e_wheel_click_angle);
1589      }
1590
1591    if ((edev->seat->dev->blocked & E_INPUT_SEAT_POINTER) ||
1592        (edev->seat->dev->server_blocked & E_INPUT_SEAT_POINTER))
1593      {
1594         g_rec_mutex_lock(&edev->seat->dev->blocked_client_mutex);
1595         if (detent_data)
1596           ELOGF("Mouse", "Detent (direction: %d, value: %d) is blocked by %p, server: 0x%x", NULL,
1597                 direction, z, edev->seat->dev->blocked_client, edev->seat->dev->server_blocked);
1598         else
1599           ELOGF("Mouse", "Wheel (direction: %d, value: %d) is blocked by %p, server: 0x%x", NULL,
1600                 direction, z, edev->seat->dev->blocked_client, edev->seat->dev->server_blocked);
1601
1602         g_rec_mutex_unlock(&edev->seat->dev->blocked_client_mutex);
1603         goto end;
1604      }
1605
1606    if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Wheel))))
1607      {
1608         goto end;
1609      }
1610
1611    timestamp = libinput_event_pointer_get_time(event);
1612
1613    ev->window = (Ecore_Window)input->dev->window;
1614    ev->event_window = (Ecore_Window)input->dev->window;
1615    ev->root_window = (Ecore_Window)input->dev->window;
1616    ev->timestamp = timestamp;
1617    ev->same_screen = 1;
1618
1619    _device_modifiers_update(edev);
1620    ev->modifiers = edev->xkb.modifiers;
1621
1622    ev->x = edev->seat->ptr.ix;
1623    ev->y = edev->seat->ptr.iy;
1624    ev->root.x = ev->x;
1625    ev->root.y = ev->y;
1626    ev->z = z;
1627    ev->direction = direction;
1628
1629    if (comp_conf && comp_conf->input_log_enable)
1630      {
1631         if (detent_data)
1632           ELOGF("Mouse", "Detent (direction: %d, value: %d)", NULL, ev->direction, ev->z);
1633         else
1634           ELOGF("Mouse", "Wheel (direction: %d, value: %d)", NULL, ev->direction, ev->z);
1635      }
1636
1637    ev->dev = ecore_device_ref(ecore_dev);
1638    ecore_event_add(ECORE_EVENT_MOUSE_WHEEL, ev, _e_input_event_mouse_wheel_cb_free, NULL);
1639
1640 end:
1641    ecore_thread_main_loop_end();
1642 }
1643 #endif
1644
1645 static void
1646 _device_handle_touch_event_send(E_Input_Evdev *edev, struct libinput_event_touch *event, int state)
1647 {
1648    E_Input_Backend *input;
1649    Ecore_Event_Mouse_Button *ev;
1650    uint32_t timestamp, button = 0;
1651    Ecore_Device *ecore_dev = NULL, *data;
1652    Eina_List *l;
1653
1654    if (!edev) return;
1655    if (!(input = edev->seat->input)) return;
1656
1657    ecore_thread_main_loop_begin();
1658
1659    if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1660    else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1661      {
1662         EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1663           {
1664              if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_TOUCH)
1665                {
1666                   ecore_dev = data;
1667                   break;
1668                }
1669           }
1670      }
1671    else
1672      {
1673         edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_TOUCH);
1674         ecore_dev = edev->ecore_dev;
1675      }
1676
1677    if (!ecore_dev)
1678      {
1679         ERR("Failed to get source ecore device from event !\n");
1680         goto end;
1681      }
1682
1683    if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Button)))) goto end;
1684
1685    timestamp = libinput_event_touch_get_time(event);
1686
1687    ev->window = (Ecore_Window)input->dev->window;
1688    ev->event_window = (Ecore_Window)input->dev->window;
1689    ev->root_window = (Ecore_Window)input->dev->window;
1690    ev->timestamp = timestamp;
1691    ev->same_screen = 1;
1692
1693    _device_modifiers_update(edev);
1694    ev->modifiers = edev->xkb.modifiers;
1695
1696    ev->x = edev->seat->ptr.ix;
1697    ev->y = edev->seat->ptr.iy;
1698    ev->root.x = ev->x;
1699    ev->root.y = ev->y;
1700
1701    ev->multi.device = edev->mt_slot;
1702    ev->multi.radius = 1;
1703    ev->multi.radius_x = 1;
1704    ev->multi.radius_y = 1;
1705    ev->multi.pressure = 1.0;
1706    ev->multi.angle = 0.0;
1707 #if LIBINPUT_SUPPORT_EXTRA_TOUCH_EVENT
1708    if (libinput_event_get_type(libinput_event_touch_get_base_event(event))
1709        == LIBINPUT_EVENT_TOUCH_DOWN)
1710      {
1711         if (libinput_event_touch_has_minor(event))
1712           ev->multi.radius_x = libinput_event_touch_get_minor(event);
1713         if (libinput_event_touch_has_major(event))
1714           ev->multi.radius_y = libinput_event_touch_get_major(event);
1715         if (libinput_event_touch_has_pressure(event))
1716           ev->multi.pressure = libinput_event_touch_get_pressure(event);
1717         if (libinput_event_touch_has_orientation(event))
1718           ev->multi.angle = libinput_event_touch_get_orientation(event);
1719      }
1720 #endif
1721    ev->multi.x = ev->x;
1722    ev->multi.y = ev->y;
1723    ev->multi.root.x = ev->x;
1724    ev->multi.root.y = ev->y;
1725    ev->dev = ecore_device_ref(ecore_dev);
1726
1727    if (state == ECORE_EVENT_MOUSE_BUTTON_DOWN)
1728      {
1729         unsigned int current;
1730
1731         current = timestamp;
1732         edev->mouse.did_double = EINA_FALSE;
1733         edev->mouse.did_triple = EINA_FALSE;
1734
1735         if (((current - edev->mouse.prev) <= edev->mouse.threshold) &&
1736             (button == edev->mouse.prev_button))
1737           {
1738              edev->mouse.did_double = EINA_TRUE;
1739              if (((current - edev->mouse.last) <= (2 * edev->mouse.threshold)) &&
1740                  (button == edev->mouse.last_button))
1741                {
1742                   edev->mouse.did_triple = EINA_TRUE;
1743                   edev->mouse.prev = 0;
1744                   edev->mouse.last = 0;
1745                   current = 0;
1746                }
1747           }
1748
1749         edev->mouse.last = edev->mouse.prev;
1750         edev->mouse.prev = current;
1751         edev->mouse.last_button = edev->mouse.prev_button;
1752         edev->mouse.prev_button = button;
1753         edev->touch.pressed |= (1 << ev->multi.device);
1754      }
1755    else
1756      {
1757         edev->touch.pressed &= ~(1 << ev->multi.device);
1758      }
1759
1760    ev->buttons = ((button & 0x00F) + 1);
1761
1762    if (edev->mouse.did_double)
1763      ev->double_click = 1;
1764    if (edev->mouse.did_triple)
1765      ev->triple_click = 1;
1766
1767    ecore_event_add(state, ev, _e_input_event_mouse_button_cb_free, NULL);
1768
1769 end:
1770    ecore_thread_main_loop_end();
1771 }
1772
1773 static void
1774 _device_handle_touch_motion_send(E_Input_Evdev *edev, struct libinput_event_touch *event)
1775 {
1776    E_Input_Backend *input;
1777    Ecore_Event_Mouse_Move *ev;
1778    Ecore_Device *ecore_dev = NULL, *data;
1779    Eina_List *l;
1780
1781    if (!edev) return;
1782    if (!(input = edev->seat->input)) return;
1783
1784    ecore_thread_main_loop_begin();
1785
1786    if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1787    else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1788      {
1789         EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1790           {
1791              if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_TOUCH)
1792                {
1793                   ecore_dev = data;
1794                   break;
1795                }
1796           }
1797      }
1798    else
1799      {
1800         edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_TOUCH);
1801         ecore_dev = edev->ecore_dev;
1802      }
1803
1804    if (!ecore_dev)
1805      {
1806         ERR("Failed to get source ecore device from event !\n");
1807         goto end;
1808      }
1809
1810    if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Move)))) goto end;
1811
1812    ev->window = (Ecore_Window)input->dev->window;
1813    ev->event_window = (Ecore_Window)input->dev->window;
1814    ev->root_window = (Ecore_Window)input->dev->window;
1815    ev->timestamp = libinput_event_touch_get_time(event);
1816    ev->same_screen = 1;
1817
1818    _device_modifiers_update(edev);
1819    ev->modifiers = edev->xkb.modifiers;
1820
1821    ev->x = edev->seat->ptr.ix;
1822    ev->y = edev->seat->ptr.iy;
1823    ev->root.x = ev->x;
1824    ev->root.y = ev->y;
1825
1826    ev->multi.device = edev->mt_slot;
1827    ev->multi.radius = 1;
1828    ev->multi.radius_x = 1;
1829    ev->multi.radius_y = 1;
1830    ev->multi.pressure = 1.0;
1831    ev->multi.angle = 0.0;
1832 #if LIBINPUT_SUPPORT_EXTRA_TOUCH_EVENT
1833    if (libinput_event_touch_has_minor(event))
1834      ev->multi.radius_x = libinput_event_touch_get_minor(event);
1835    if (libinput_event_touch_has_major(event))
1836      ev->multi.radius_y = libinput_event_touch_get_major(event);
1837    if (libinput_event_touch_has_pressure(event))
1838      ev->multi.pressure = libinput_event_touch_get_pressure(event);
1839    if (libinput_event_touch_has_orientation(event))
1840      ev->multi.angle = libinput_event_touch_get_orientation(event);
1841 #endif
1842    ev->multi.x = ev->x;
1843    ev->multi.y = ev->y;
1844    ev->multi.root.x = ev->x;
1845    ev->multi.root.y = ev->y;
1846    ev->dev = ecore_device_ref(ecore_dev);
1847
1848    ecore_event_add(ECORE_EVENT_MOUSE_MOVE, ev, _e_input_event_mouse_move_cb_free, NULL);
1849
1850 end:
1851    ecore_thread_main_loop_end();
1852 }
1853
1854 static void
1855 _device_handle_touch_cancel_send(E_Input_Evdev *edev, struct libinput_event_touch *event)
1856 {
1857    E_Input_Backend *input;
1858    Ecore_Event_Mouse_Button *ev;
1859    uint32_t timestamp, button = 0;
1860    Ecore_Device *ecore_dev = NULL, *data;
1861    Eina_List *l;
1862
1863    if (!edev) return;
1864    if (!(input = edev->seat->input)) return;
1865
1866    ecore_thread_main_loop_begin();
1867
1868    if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1869    else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1870      {
1871         EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1872           {
1873              if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_TOUCH)
1874                {
1875                   ecore_dev = data;
1876                   break;
1877                }
1878           }
1879      }
1880    else
1881      {
1882         edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_TOUCH);
1883         ecore_dev = edev->ecore_dev;
1884      }
1885
1886    if (!ecore_dev)
1887      {
1888         ERR("Failed to get source ecore device from event !\n");
1889         goto end;
1890      }
1891
1892    if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Button)))) goto end;
1893
1894    timestamp = libinput_event_touch_get_time(event);
1895
1896    ev->window = (Ecore_Window)input->dev->window;
1897    ev->event_window = (Ecore_Window)input->dev->window;
1898    ev->root_window = (Ecore_Window)input->dev->window;
1899    ev->timestamp = timestamp;
1900    ev->same_screen = 1;
1901
1902    ev->x = edev->seat->ptr.ix;
1903    ev->y = edev->seat->ptr.iy;
1904    ev->root.x = ev->x;
1905    ev->root.y = ev->y;
1906
1907    ev->multi.device = edev->mt_slot;
1908    ev->multi.radius = 1;
1909    ev->multi.radius_x = 1;
1910    ev->multi.radius_y = 1;
1911    ev->multi.pressure = 1.0;
1912    ev->multi.angle = 0.0;
1913    ev->multi.x = ev->x;
1914    ev->multi.y = ev->y;
1915    ev->multi.root.x = ev->x;
1916    ev->multi.root.y = ev->y;
1917
1918    edev->touch.pressed &= ~(1 << ev->multi.device);
1919
1920    ev->buttons = ((button & 0x00F) + 1);
1921    ev->dev = ecore_device_ref(ecore_dev);
1922
1923    ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, ev, _e_input_event_mouse_button_cb_free, NULL);
1924
1925 end:
1926    ecore_thread_main_loop_end();
1927 }
1928
1929 static void
1930 _device_configured_size_get(E_Input_Evdev *edev, int *x, int *y, int *w, int *h)
1931 {
1932    E_Output *output = NULL;
1933
1934    EINA_SAFETY_ON_NULL_RETURN(edev);
1935
1936    if (!edev->output_configured)
1937      {
1938         if (edev->output_name)
1939           {
1940              output = e_output_find(edev->output_name);
1941              if (output)
1942                {
1943                   edev->mouse.minx = output->config.geom.x;
1944                   edev->mouse.miny = output->config.geom.y;
1945                   edev->mouse.maxw = output->config.geom.w;
1946                   edev->mouse.maxh = output->config.geom.h;
1947                   if (libinput_device_has_capability(edev->device, LIBINPUT_DEVICE_CAP_POINTER))
1948                     {
1949                        edev->seat->ptr.dx = (double)(edev->mouse.maxw / 2);
1950                        edev->seat->ptr.dy = (double)(edev->mouse.maxh / 2);
1951                        edev->seat->ptr.ix = (int)edev->seat->ptr.dx;
1952                        edev->seat->ptr.iy = (int)edev->seat->ptr.dy;
1953                        edev->mouse.dx = edev->seat->ptr.dx;
1954                        edev->mouse.dy = edev->seat->ptr.dy;
1955                     }
1956                }
1957           }
1958
1959           edev->output_configured = EINA_TRUE;
1960           ELOGF("E_INPUT_EVDEV", "Device is configured by output x:%d,y:%d (w:%d, h:%d)",
1961                 NULL, edev->mouse.minx, edev->mouse.miny, edev->mouse.maxw, edev->mouse.maxh);
1962      }
1963    if (x) *x = edev->mouse.minx;
1964    if (y) *y = edev->mouse.miny;
1965    if (w) *w = edev->mouse.maxw;
1966    if (h) *h = edev->mouse.maxh;
1967 }
1968
1969 static void
1970 _device_handle_touch_down(struct libinput_device *device, struct libinput_event_touch *event)
1971 {
1972    E_Input_Evdev *edev;
1973    int x = 0, y = 0, w = 0, h = 0;
1974    E_Comp_Config *comp_conf = NULL;
1975
1976    if (!(edev = libinput_device_get_user_data(device)))
1977      {
1978         return;
1979      }
1980
1981    _device_configured_size_get(edev, &x, &y, &w, &h);
1982
1983    edev->mouse.dx = edev->seat->ptr.ix = edev->seat->ptr.dx =
1984      x + libinput_event_touch_get_x_transformed(event, w);
1985    edev->mouse.dy = edev->seat->ptr.iy = edev->seat->ptr.dy =
1986      y + libinput_event_touch_get_y_transformed(event, h);
1987
1988    edev->mt_slot = libinput_event_touch_get_slot(event);
1989    if (edev->mt_slot < 0)
1990      {
1991         /* FIXME: The single touch device return slot id -1
1992          *        But currently we have no API to distinguish multi touch or single touch
1993          *        After libinput 1.11 version, libinput provides get_touch_count API,
1994          *        so we can distinguish multi touch device or single touch device.
1995          */
1996         if (edev->mt_slot == -1)
1997           edev->mt_slot = 0;
1998         else
1999           {
2000              WRN("%d slot touch down events are not supported\n", edev->mt_slot);
2001              return;
2002           }
2003      }
2004
2005    if (edev->mt_slot < e_input_touch_max_count_get())
2006      {
2007         edev->touch.coords[edev->mt_slot].x = edev->seat->ptr.ix;
2008         edev->touch.coords[edev->mt_slot].y = edev->seat->ptr.iy;
2009      }
2010
2011    comp_conf = e_comp_config_get();
2012    if (comp_conf && comp_conf->input_log_enable)
2013      ELOGF("Touch", "Down (id: %d, x: %d, y: %d)", NULL, edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy);
2014
2015    g_rec_mutex_lock(&edev->touch.raw_pressed_mutex);
2016    edev->touch.raw_pressed |= (1 << edev->mt_slot);
2017    g_rec_mutex_unlock(&edev->touch.raw_pressed_mutex);
2018
2019    g_rec_mutex_lock(&edev->touch.blocked_mutex);
2020    if (edev->touch.blocked)
2021      {
2022         g_rec_mutex_lock(&edev->seat->dev->blocked_client_mutex);
2023         ELOGF("Touch", "Down (id: %d, x: %d, y: %d) is blocked by %p, server: 0x%x", NULL,
2024               edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy, edev->seat->dev->blocked_client,
2025               edev->seat->dev->server_blocked);
2026         g_rec_mutex_unlock(&edev->seat->dev->blocked_client_mutex);
2027         g_rec_mutex_unlock(&edev->touch.blocked_mutex);
2028         return;
2029      }
2030
2031    g_rec_mutex_unlock(&edev->touch.blocked_mutex);
2032
2033    _device_handle_touch_motion_send(edev, event);
2034    _device_handle_touch_event_send(edev, event, ECORE_EVENT_MOUSE_BUTTON_DOWN);
2035 }
2036
2037 static void
2038 _device_handle_touch_motion(struct libinput_device *device, struct libinput_event_touch *event)
2039 {
2040    E_Input_Evdev *edev;
2041    int x = 0, y = 0, w = 0, h = 0;
2042
2043    if (!(edev = libinput_device_get_user_data(device)))
2044      {
2045         return;
2046      }
2047
2048    _device_configured_size_get(edev, &x, &y, &w, &h);
2049
2050    edev->mouse.dx = edev->seat->ptr.dx =
2051      x + libinput_event_touch_get_x_transformed(event, w);
2052    edev->mouse.dy = edev->seat->ptr.dy =
2053      y + libinput_event_touch_get_y_transformed(event, h);
2054
2055    if (floor(edev->seat->ptr.dx) == edev->seat->ptr.ix &&
2056        floor(edev->seat->ptr.dy) == edev->seat->ptr.iy)
2057      {
2058         return;
2059      }
2060
2061    edev->seat->ptr.ix = edev->seat->ptr.dx;
2062    edev->seat->ptr.iy = edev->seat->ptr.dy;
2063
2064    edev->mt_slot = libinput_event_touch_get_slot(event);
2065    if (edev->mt_slot < 0)
2066      {
2067         /* FIXME: The single touch device return slot id -1
2068          *        But currently we have no API to distinguish multi touch or single touch
2069          *        After libinput 1.11 version, libinput provides get_touch_count API,
2070          *        so we can distinguish multi touch device or single touch device.
2071          */
2072         if (edev->mt_slot == -1)
2073           edev->mt_slot = 0;
2074         else
2075           {
2076              WRN("%d slot touch motion events are not supported\n", edev->mt_slot);
2077              return;
2078           }
2079      }
2080
2081    if (edev->mt_slot < e_input_touch_max_count_get())
2082      {
2083         edev->touch.coords[edev->mt_slot].x = edev->seat->ptr.ix;
2084         edev->touch.coords[edev->mt_slot].y = edev->seat->ptr.iy;
2085      }
2086
2087    if (!(edev->touch.pressed & (1 << edev->mt_slot)))
2088      {
2089         g_rec_mutex_lock(&edev->touch.blocked_mutex);
2090         if (edev->touch.blocked)
2091           {
2092              g_rec_mutex_unlock(&edev->touch.blocked_mutex);
2093              return;
2094           }
2095         g_rec_mutex_unlock(&edev->touch.blocked_mutex);
2096      }
2097
2098    _device_handle_touch_motion_send(edev, event);
2099 }
2100
2101 static void
2102 _device_handle_touch_up(struct libinput_device *device, struct libinput_event_touch *event)
2103 {
2104    E_Input_Evdev *edev;
2105    E_Comp_Config *comp_conf = NULL;
2106
2107    if (!(edev = libinput_device_get_user_data(device)))
2108      {
2109         return;
2110      }
2111
2112    edev->mt_slot = libinput_event_touch_get_slot(event);
2113    if (edev->mt_slot < 0)
2114      {
2115         /* FIXME: The single touch device return slot id -1
2116          *        But currently we have no API to distinguish multi touch or single touch
2117          *        After libinput 1.11 version, libinput provides get_touch_count API,
2118          *        so we can distinguish multi touch device or single touch device.
2119          */
2120         if (edev->mt_slot == -1)
2121           edev->mt_slot = 0;
2122         else
2123           {
2124              WRN("%d slot touch up events are not supported\n", edev->mt_slot);
2125              return;
2126           }
2127      }
2128
2129    if (edev->mt_slot < e_input_touch_max_count_get())
2130      {
2131         edev->mouse.dx = edev->seat->ptr.dx = edev->seat->ptr.ix =
2132           edev->touch.coords[edev->mt_slot].x;
2133         edev->mouse.dy = edev->seat->ptr.dy = edev->seat->ptr.iy =
2134           edev->touch.coords[edev->mt_slot].y;
2135      }
2136
2137    comp_conf = e_comp_config_get();
2138    if (comp_conf && comp_conf->input_log_enable)
2139      ELOGF("Touch", "Up (id: %d, x: %d, y: %d)", NULL, edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy);
2140
2141    g_rec_mutex_lock(&edev->touch.raw_pressed_mutex);
2142    edev->touch.raw_pressed &= ~(1 << edev->mt_slot);
2143    g_rec_mutex_unlock(&edev->touch.raw_pressed_mutex);
2144
2145    g_rec_mutex_lock(&edev->touch.blocked_mutex);
2146    if (edev->touch.blocked)
2147      {
2148         if (!(edev->touch.pressed & (1 << edev->mt_slot)))
2149           {
2150              g_rec_mutex_lock(&edev->seat->dev->blocked_client_mutex);
2151              ELOGF("Touch", "Up (id: %d, x: %d, y: %d) is blocked by %p, server(0x%x)", NULL,
2152                    edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy, edev->seat->dev->blocked_client,
2153                    edev->seat->dev->server_blocked);
2154              g_rec_mutex_unlock(&edev->seat->dev->blocked_client_mutex);
2155
2156              g_rec_mutex_lock(&edev->touch.raw_pressed_mutex);
2157              if (edev->touch.raw_pressed == 0x0)
2158                {
2159                   edev->touch.blocked = EINA_FALSE;
2160                }
2161              g_rec_mutex_unlock(&edev->touch.raw_pressed_mutex);
2162              g_rec_mutex_unlock(&edev->touch.blocked_mutex);
2163              return;
2164           }
2165      }
2166
2167    g_rec_mutex_unlock(&edev->touch.blocked_mutex);
2168    _device_handle_touch_event_send(edev, event, ECORE_EVENT_MOUSE_BUTTON_UP);
2169 }
2170
2171 static void
2172 _device_handle_touch_cancel(struct libinput_device *device, struct libinput_event_touch *event)
2173 {
2174    E_Input_Evdev *edev;
2175    E_Comp_Config *comp_conf = NULL;
2176
2177    if (!(edev = libinput_device_get_user_data(device)))
2178      {
2179         return;
2180      }
2181
2182    edev->mt_slot = libinput_event_touch_get_slot(event);
2183    if (edev->mt_slot < 0)
2184      {
2185         /* FIXME: The single touch device return slot id -1
2186          *        But currently we have no API to distinguish multi touch or single touch
2187          *        After libinput 1.11 version, libinput provides get_touch_count API,
2188          *        so we can distinguish multi touch device or single touch device.
2189          */
2190         if (edev->mt_slot == -1)
2191           edev->mt_slot = 0;
2192         else
2193           {
2194              WRN("%d slot touch up events are not supported\n", edev->mt_slot);
2195              return;
2196           }
2197      }
2198
2199    comp_conf = e_comp_config_get();
2200    if (comp_conf && comp_conf->input_log_enable)
2201      ELOGF("Touch", "cancel (id: %d, x: %d, y: %d)", NULL, edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy);
2202
2203    _device_handle_touch_cancel_send(edev, event);
2204 }
2205
2206
2207 static void
2208 _device_handle_touch_frame(struct libinput_device *device EINA_UNUSED, struct libinput_event_touch *event EINA_UNUSED)
2209 {
2210    /* DBG("Unhandled Touch Frame Event"); */
2211 }
2212
2213 static void
2214 _e_input_aux_data_event_free(void *user_data EINA_UNUSED, void *ev)
2215 {
2216    Ecore_Event_Axis_Update *e = (Ecore_Event_Axis_Update *)ev;
2217
2218    if (e->axis) free(e->axis);
2219    if (e->dev) ecore_device_unref(e->dev);
2220
2221    free(e);
2222 }
2223
2224 static void
2225 _device_handle_touch_aux_data(struct libinput_device *device, struct libinput_event_touch_aux_data *event)
2226 {
2227    E_Input_Evdev *edev;
2228    E_Input_Backend *input;
2229    Ecore_Event_Axis_Update *ev;
2230    Ecore_Axis *axis;
2231    Ecore_Device *ecore_dev = NULL, *data;
2232    Eina_List *l;
2233    E_Comp_Config *comp_conf;
2234
2235    ecore_thread_main_loop_begin();
2236
2237    if (libinput_event_touch_aux_data_get_type(event) != LIBINPUT_TOUCH_AUX_DATA_TYPE_PALM &&
2238        libinput_event_touch_aux_data_get_value(event) > 0)
2239       goto end;
2240
2241    if (!(edev = libinput_device_get_user_data(device))) goto end;
2242    if (!(input = edev->seat->input)) goto end;
2243
2244    if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
2245    else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
2246      {
2247         EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
2248           {
2249              if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_TOUCH)
2250                {
2251                   ecore_dev = data;
2252                   break;
2253                }
2254           }
2255      }
2256    else
2257      {
2258         edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_TOUCH);
2259         ecore_dev = edev->ecore_dev;
2260      }
2261
2262    if (!ecore_dev)
2263      {
2264         ERR("Failed to get source ecore device from event !\n");
2265         goto end;
2266      }
2267
2268    if (!(ev = calloc(1, sizeof(Ecore_Event_Axis_Update)))) goto end;
2269
2270    ev->window = (Ecore_Window)input->dev->window;
2271    ev->event_window = (Ecore_Window)input->dev->window;
2272    ev->root_window = (Ecore_Window)input->dev->window;
2273    ev->timestamp = libinput_event_touch_aux_data_get_time(event);
2274
2275    axis = (Ecore_Axis *)calloc(1, sizeof(Ecore_Axis));
2276    if (axis)
2277      {
2278         axis->label = ECORE_AXIS_LABEL_TOUCH_PALM;
2279         axis->value = libinput_event_touch_aux_data_get_value(event);
2280         ev->naxis = 1;
2281      }
2282    ev->axis = axis;
2283
2284    comp_conf = e_comp_config_get();
2285    if (comp_conf && comp_conf->input_log_enable)
2286      ELOGF("Touch", "Axis (label: %d, value: %lf)", NULL, axis?axis->label:-1, axis?axis->value:0.0);
2287
2288    ev->dev = ecore_device_ref(ecore_dev);
2289
2290    ecore_event_add(ECORE_EVENT_AXIS_UPDATE, ev, _e_input_aux_data_event_free, NULL);
2291
2292 end:
2293    ecore_thread_main_loop_end();
2294 }
2295
2296 E_Input_Evdev *
2297 _e_input_evdev_device_create(E_Input_Seat *seat, struct libinput_device *device)
2298 {
2299    E_Input_Evdev *edev;
2300    E_Input_Backend *b_input;
2301    const char *output_name;
2302
2303    EINA_SAFETY_ON_NULL_RETURN_VAL(seat, NULL);
2304
2305    /* try to allocate space for new evdev */
2306    if (!(edev = calloc(1, sizeof(E_Input_Evdev)))) return NULL;
2307
2308    edev->seat = seat;
2309    edev->device = device;
2310    edev->path = eina_stringshare_printf("%s/%s", e_input_base_dir_get(), libinput_device_get_sysname(device));
2311
2312    g_rec_mutex_init(&edev->touch.raw_pressed_mutex);
2313    g_rec_mutex_init(&edev->touch.blocked_mutex);
2314
2315    if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_KEYBOARD))
2316      {
2317         edev->caps |= E_INPUT_SEAT_KEYBOARD;
2318         _device_keyboard_setup(edev);
2319      }
2320
2321    if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_POINTER))
2322      {
2323         edev->caps |= E_INPUT_SEAT_POINTER;
2324
2325         /* TODO: make this configurable */
2326         edev->mouse.threshold = 250;
2327
2328         b_input = seat->input;
2329         if (b_input->left_handed == EINA_TRUE)
2330           {
2331              if (libinput_device_config_left_handed_set(device, 1) !=
2332                  LIBINPUT_CONFIG_STATUS_SUCCESS)
2333                {
2334                   WRN("Failed to set left hand mode about device: %s\n",
2335                       libinput_device_get_name(device));
2336                }
2337           }
2338      }
2339
2340    if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_TOUCH))
2341      {
2342         int palm_code;
2343         edev->caps |= E_INPUT_SEAT_TOUCH;
2344         palm_code = libinput_device_touch_aux_data_get_code(LIBINPUT_TOUCH_AUX_DATA_TYPE_PALM);
2345         if (libinput_device_touch_has_aux_data(device, palm_code))
2346           {
2347              libinput_device_touch_set_aux_data(device, palm_code);
2348           }
2349
2350         _device_touch_count_update(edev);
2351
2352         edev->touch.coords = calloc(1, sizeof(E_Input_Coord)*e_input_touch_max_count_get());
2353
2354         if  (!edev->touch.coords)
2355           ERR("Failed to allocate memory for touch coords !\n");
2356      }
2357
2358    output_name = libinput_device_get_output_name(device);
2359    if (output_name)
2360      {
2361         eina_stringshare_replace(&edev->output_name, output_name);
2362         ELOGF("E_INPUT_EVDEV", "Device has output_name:%s", NULL, output_name);
2363      }
2364
2365    libinput_device_set_user_data(device, edev);
2366    libinput_device_ref(device);
2367
2368    /* configure device */
2369    _device_configure(edev);
2370
2371    return edev;
2372 }
2373
2374 void
2375 _e_input_evdev_device_destroy(E_Input_Evdev *edev)
2376 {
2377    Ecore_Device *dev;
2378
2379    EINA_SAFETY_ON_NULL_RETURN(edev);
2380
2381    ecore_thread_main_loop_begin();
2382
2383    if (edev->caps & E_INPUT_SEAT_KEYBOARD)
2384      {
2385         g_mutex_lock(&edev->xkb.state_mutex);
2386         if (edev->xkb.state) xkb_state_unref(edev->xkb.state);
2387         g_mutex_unlock(&edev->xkb.state_mutex);
2388
2389         g_mutex_lock(&edev->xkb.keymap_mutex);
2390         if (edev->xkb.keymap) xkb_map_unref(edev->xkb.keymap);
2391         g_mutex_unlock(&edev->xkb.keymap_mutex);
2392      }
2393
2394    if (edev->ecore_dev) ecore_device_del(edev->ecore_dev);
2395    if (edev->ecore_dev_list)
2396      EINA_LIST_FREE(edev->ecore_dev_list, dev)
2397        {
2398           ecore_device_del(dev);
2399        }
2400
2401    if (edev->e_dev) g_object_unref(edev->e_dev);
2402    if (edev->e_dev_list)
2403      {
2404         GList *glist = edev->e_dev_list;
2405         E_Device *e_dev;
2406         while (glist)
2407           {
2408              e_dev = glist->data;
2409              g_object_unref(e_dev);
2410
2411              glist = g_list_next(glist);
2412           }
2413      }
2414    if (edev->path) eina_stringshare_del(edev->path);
2415    if (edev->device) libinput_device_unref(edev->device);
2416    if (edev->key_remap_hash) eina_hash_free(edev->key_remap_hash);
2417    if (edev->touch.coords)
2418      {
2419         free(edev->touch.coords);
2420         edev->touch.coords = NULL;
2421      }
2422    g_rec_mutex_clear(&edev->touch.raw_pressed_mutex);
2423    g_rec_mutex_clear(&edev->touch.blocked_mutex);
2424    eina_stringshare_del(edev->output_name);
2425
2426    ecore_thread_main_loop_end();
2427
2428    free(edev);
2429 }
2430
2431 Eina_Bool
2432 _e_input_evdev_event_process(struct libinput_event *event)
2433 {
2434    struct libinput_device *device;
2435    Eina_Bool ret = EINA_TRUE;
2436
2437    device = libinput_event_get_device(event);
2438    switch (libinput_event_get_type(event))
2439      {
2440       case LIBINPUT_EVENT_KEYBOARD_KEY:
2441         _device_handle_key(device, libinput_event_get_keyboard_event(event));
2442         break;
2443       case LIBINPUT_EVENT_POINTER_MOTION:
2444         _device_handle_pointer_motion(device,
2445                                       libinput_event_get_pointer_event(event));
2446         break;
2447       case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE:
2448         _device_handle_pointer_motion_absolute(device,
2449                                                libinput_event_get_pointer_event(event));
2450         break;
2451       case LIBINPUT_EVENT_POINTER_BUTTON:
2452         _device_handle_button(device, libinput_event_get_pointer_event(event));
2453         break;
2454       case LIBINPUT_EVENT_POINTER_AXIS:
2455 #if !LIBINPUT_HAVE_SCROLL_VALUE_V120
2456         _device_handle_axis(device, libinput_event_get_pointer_event(event));
2457 #endif
2458         break;
2459 #if LIBINPUT_HAVE_SCROLL_VALUE_V120
2460       case LIBINPUT_EVENT_POINTER_SCROLL_WHEEL:
2461         _device_handle_axis_v120(device, libinput_event_get_pointer_event(event), E_INPUT_AXIS_SOURCE_WHEEL);
2462         break;
2463       case LIBINPUT_EVENT_POINTER_SCROLL_FINGER:
2464         _device_handle_axis_v120(device, libinput_event_get_pointer_event(event), E_INPUT_AXIS_SOURCE_FINGER);
2465         break;
2466       case LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS:
2467         _device_handle_axis_v120(device, libinput_event_get_pointer_event(event), E_INPUT_AXIS_SOURCE_CONTINUOUS);
2468         break;
2469 #endif
2470       case LIBINPUT_EVENT_TOUCH_DOWN:
2471         _device_handle_touch_down(device, libinput_event_get_touch_event(event));
2472         break;
2473       case LIBINPUT_EVENT_TOUCH_MOTION:
2474         _device_handle_touch_motion(device,
2475                                     libinput_event_get_touch_event(event));
2476         break;
2477       case LIBINPUT_EVENT_TOUCH_UP:
2478         _device_handle_touch_up(device, libinput_event_get_touch_event(event));
2479         break;
2480       case LIBINPUT_EVENT_TOUCH_CANCEL:
2481         _device_handle_touch_cancel(device, libinput_event_get_touch_event(event));
2482         break;
2483       case LIBINPUT_EVENT_TOUCH_FRAME:
2484         _device_handle_touch_frame(device, libinput_event_get_touch_event(event));
2485         break;
2486       case LIBINPUT_EVENT_TOUCH_AUX_DATA:
2487         _device_handle_touch_aux_data(device, libinput_event_get_touch_aux_data(event));
2488         break;
2489       default:
2490         ret = EINA_FALSE;
2491         break;
2492      }
2493
2494    return ret;
2495 }
2496
2497 /**
2498  * @brief Set the axis size of the given device.
2499  *
2500  * @param dev The device to set the axis size to.
2501  * @param w The width of the axis.
2502  * @param h The height of the axis.
2503  *
2504  * This function sets set the width @p w and height @p h of the axis
2505  * of device @p dev. If @p dev is a relative input device, a width and
2506  * height must set for it. If its absolute set the ioctl correctly, if
2507  * not, unsupported device.
2508  */
2509 EINTERN void
2510 e_input_evdev_axis_size_set(E_Input_Evdev *edev, int w, int h)
2511 {
2512    const char *sysname;
2513    float cal[6];
2514    const char *device;
2515    Eina_List *devices;
2516    const char *vals;
2517    enum libinput_config_status status;
2518
2519    EINA_SAFETY_ON_NULL_RETURN(edev);
2520    EINA_SAFETY_ON_TRUE_RETURN((w == 0) || (h == 0));
2521
2522    if ((!libinput_device_config_calibration_has_matrix(edev->device)) ||
2523        (libinput_device_config_calibration_get_default_matrix(edev->device, cal) != 0))
2524      return;
2525
2526    sysname = libinput_device_get_sysname(edev->device);
2527
2528    devices = eeze_udev_find_by_subsystem_sysname("input", sysname);
2529    if (eina_list_count(devices) < 1) return;
2530
2531    EINA_LIST_FREE(devices, device)
2532      {
2533         vals = eeze_udev_syspath_get_property(device, "WL_CALIBRATION");
2534         if ((!vals) ||
2535             (sscanf(vals, "%f %f %f %f %f %f",
2536                     &cal[0], &cal[1], &cal[2], &cal[3], &cal[4], &cal[5]) != 6))
2537           goto cont;
2538
2539         cal[2] /= w;
2540         cal[5] /= h;
2541
2542         status =
2543           libinput_device_config_calibration_set_matrix(edev->device, cal);
2544
2545         if (status != LIBINPUT_CONFIG_STATUS_SUCCESS)
2546           ERR("Failed to apply calibration");
2547
2548 cont:
2549         eina_stringshare_del(device);
2550         continue;
2551      }
2552 }
2553
2554 EINTERN const char *
2555 e_input_evdev_name_get(E_Input_Evdev *evdev)
2556 {
2557    EINA_SAFETY_ON_NULL_RETURN_VAL(evdev, NULL);
2558    EINA_SAFETY_ON_NULL_RETURN_VAL(evdev->device, NULL);
2559
2560    return libinput_device_get_name(evdev->device);
2561 }
2562
2563 EINTERN const char *
2564 e_input_evdev_sysname_get(E_Input_Evdev *evdev)
2565 {
2566    EINA_SAFETY_ON_NULL_RETURN_VAL(evdev, NULL);
2567    EINA_SAFETY_ON_NULL_RETURN_VAL(evdev->device, NULL);
2568
2569    return libinput_device_get_sysname(evdev->device);
2570 }
2571
2572 EINTERN Eina_Bool
2573 e_input_evdev_key_remap_enable(E_Input_Evdev *edev, Eina_Bool enable)
2574 {
2575    EINA_SAFETY_ON_NULL_RETURN_VAL(edev, EINA_FALSE);
2576    EINA_SAFETY_ON_NULL_RETURN_VAL(edev->device, EINA_FALSE);
2577
2578    edev->key_remap_enabled = enable;
2579
2580    if (enable == EINA_FALSE && edev->key_remap_hash)
2581      {
2582         eina_hash_free(edev->key_remap_hash);
2583         edev->key_remap_hash = NULL;
2584      }
2585
2586    return EINA_TRUE;
2587 }
2588
2589 EINTERN Eina_Bool
2590 e_input_evdev_key_remap_set(E_Input_Evdev *edev, int *from_keys, int *to_keys, int num)
2591 {
2592    int i;
2593
2594    EINA_SAFETY_ON_NULL_RETURN_VAL(edev, EINA_FALSE);
2595    EINA_SAFETY_ON_NULL_RETURN_VAL(edev->device, EINA_FALSE);
2596    EINA_SAFETY_ON_NULL_RETURN_VAL(from_keys, EINA_FALSE);
2597    EINA_SAFETY_ON_NULL_RETURN_VAL(to_keys, EINA_FALSE);
2598    EINA_SAFETY_ON_TRUE_RETURN_VAL(num <= 0, EINA_FALSE);
2599    EINA_SAFETY_ON_TRUE_RETURN_VAL(!edev->key_remap_enabled, EINA_FALSE);
2600
2601    if (edev->key_remap_hash == NULL)
2602      edev->key_remap_hash = eina_hash_int32_new(NULL);
2603
2604    if (edev->key_remap_hash == NULL)
2605      {
2606         ERR("Failed to set remap key information : creating a hash is failed.");
2607         return EINA_FALSE;
2608      }
2609
2610    for (i = 0; i < num ; i++)
2611      {
2612         if (!from_keys[i] || !to_keys[i])
2613           {
2614              ERR("Failed to set remap key information : given arguments are invalid.");
2615              return EINA_FALSE;
2616           }
2617      }
2618
2619    for (i = 0; i < num ; i++)
2620      {
2621         eina_hash_add(edev->key_remap_hash, &from_keys[i], (void *)(intptr_t)to_keys[i]);
2622      }
2623
2624    return EINA_TRUE;
2625 }
2626
2627 EINTERN int
2628 e_input_evdev_wheel_click_angle_get(E_Input_Evdev *dev)
2629 {
2630    EINA_SAFETY_ON_NULL_RETURN_VAL(dev, -1);
2631    return libinput_device_config_scroll_get_wheel_click_angle(dev->device);
2632 }
2633
2634 EINTERN Eina_Bool
2635 e_input_evdev_touch_calibration_set(E_Input_Evdev *edev, float matrix[6])
2636 {
2637    EINA_SAFETY_ON_NULL_RETURN_VAL(edev, EINA_FALSE);
2638    EINA_SAFETY_ON_NULL_RETURN_VAL(edev->device, EINA_FALSE);
2639
2640    if (!libinput_device_config_calibration_has_matrix(edev->device) ||
2641        !libinput_device_has_capability(edev->device, LIBINPUT_DEVICE_CAP_TOUCH))
2642      return EINA_FALSE;
2643
2644    if (libinput_device_config_calibration_set_matrix(edev->device, matrix) !=
2645        LIBINPUT_CONFIG_STATUS_SUCCESS)
2646      {
2647         WRN("Failed to set input transformation about device: %s\n",
2648             libinput_device_get_name(edev->device));
2649         return EINA_FALSE;
2650      }
2651
2652    return EINA_TRUE;
2653 }
2654
2655 EINTERN Eina_Bool
2656 e_input_evdev_mouse_accel_speed_set(E_Input_Evdev *edev, double speed)
2657 {
2658    EINA_SAFETY_ON_NULL_RETURN_VAL(edev, EINA_FALSE);
2659    EINA_SAFETY_ON_NULL_RETURN_VAL(edev->device, EINA_FALSE);
2660
2661    if (!libinput_device_has_capability(edev->device, LIBINPUT_DEVICE_CAP_POINTER))
2662      return EINA_FALSE;
2663
2664    if (!libinput_device_config_accel_is_available(edev->device))
2665      return EINA_FALSE;
2666
2667    if (libinput_device_config_accel_set_speed(edev->device, speed) !=
2668        LIBINPUT_CONFIG_STATUS_SUCCESS)
2669      {
2670         WRN("Failed to set mouse accel about device: %s\n",
2671             libinput_device_get_name(edev->device));
2672         return EINA_FALSE;
2673      }
2674
2675    return EINA_TRUE;
2676 }
2677
2678 EINTERN unsigned int
2679 e_input_evdev_touch_pressed_get(E_Input_Evdev *edev)
2680 {
2681    EINA_SAFETY_ON_NULL_RETURN_VAL(edev, 0x0);
2682
2683    return edev->touch.pressed;
2684 }
2685
2686 const char *
2687 e_input_evdev_seatname_get(E_Input_Evdev *evdev)
2688 {
2689    struct libinput_seat *libinput_seat;
2690    EINA_SAFETY_ON_NULL_RETURN_VAL(evdev, NULL);
2691    EINA_SAFETY_ON_NULL_RETURN_VAL(evdev->device, NULL);
2692
2693    libinput_seat = libinput_device_get_seat(evdev->device);
2694
2695    return libinput_seat_get_logical_name(libinput_seat);
2696 }
2697
2698 Eina_Bool
2699 e_input_evdev_seatname_set(E_Input_Evdev *evdev, const char *seatname)
2700 {
2701    Eina_Bool res = EINA_FALSE;
2702    E_Input_Backend *input;
2703
2704    EINA_SAFETY_ON_NULL_RETURN_VAL(seatname, EINA_FALSE);
2705    EINA_SAFETY_ON_NULL_RETURN_VAL(evdev, EINA_FALSE);
2706    EINA_SAFETY_ON_NULL_RETURN_VAL(evdev->device, EINA_FALSE);
2707
2708    if (libinput_device_set_seat_logical_name(evdev->device, seatname) == 0)
2709      {
2710         input = evdev->seat->input;
2711         if (!input) return EINA_FALSE;
2712         if (libinput_dispatch(input->libinput) != 0)
2713           {
2714              ERR("Failed to dispatch libinput events: %m");
2715              return EINA_FALSE;
2716           }
2717
2718         /* process pending events */
2719         _input_events_process(input);
2720         res = EINA_TRUE;
2721      }
2722
2723    return res;
2724 }