src/bin/e_input_evdev.c

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