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 || !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 EINTERN 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 #if !LIBINPUT_HAVE_SCROLL_VALUE_V120
1032 static int
1033 _axis_value_get(struct libinput_event_pointer *pointer_event, enum libinput_pointer_axis axis)
1034 {
1035    enum libinput_pointer_axis_source source;
1036    double value = 0.0, value_discrete = 0.0;
1037    int ret = 0;
1038    E_Comp_Config *comp_conf = NULL;
1039
1040    comp_conf = e_comp_config_get();
1041    source = libinput_event_pointer_get_axis_source(pointer_event);
1042    switch (source)
1043      {
1044       case LIBINPUT_POINTER_AXIS_SOURCE_WHEEL:
1045         value_discrete = libinput_event_pointer_get_axis_value_discrete(pointer_event, axis);
1046         value = libinput_event_pointer_get_axis_value(pointer_event, axis);
1047         if (comp_conf && comp_conf->input_log_enable)
1048           {
1049              ELOGF("Axis", "SOURCE_WHEEL discrete: %lf (cf. value: %lf)", NULL, value_discrete, value);
1050           }
1051         ret = (int)value_discrete;
1052         break;
1053       case LIBINPUT_POINTER_AXIS_SOURCE_FINGER:
1054       case LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS:
1055         value = libinput_event_pointer_get_axis_value(pointer_event, axis);
1056         if (comp_conf && comp_conf->input_log_enable)
1057           {
1058              ELOGF("Axis", "SOURCE_FINGER/CONTINUOUS value: %lf", NULL, value);
1059           }
1060         if (value >= E_INPUT_FINGER_SCROLL_THRESHOLD)
1061           ret = 1;
1062         else if (value <= E_INPUT_FINGER_SCROLL_THRESHOLD * (-1))
1063           ret = -1;
1064         else
1065           ret = 0;
1066         break;
1067       default:
1068         break;
1069      }
1070
1071    return ret;
1072 }
1073
1074 static void
1075 _device_handle_axis(struct libinput_device *device, struct libinput_event_pointer *event)
1076 {
1077    E_Input_Evdev *edev;
1078    E_Input_Backend *input;
1079    Ecore_Event_Mouse_Wheel *ev;
1080    uint32_t timestamp;
1081    enum libinput_pointer_axis axis;
1082    Ecore_Device *ecore_dev = NULL, *detent_data = NULL, *data;
1083    Eina_List *l;
1084    E_Comp_Config *comp_conf = NULL;
1085    int direction = 0, z = 0;
1086
1087    if (!(edev = libinput_device_get_user_data(device)))
1088      {
1089         return;
1090      }
1091    if (!(input = edev->seat->input))
1092      {
1093         return;
1094      }
1095
1096    if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1097    else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1098      {
1099         EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1100           {
1101              if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_MOUSE)
1102                {
1103                   ecore_dev = data;
1104                   break;
1105                }
1106              else if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_NONE)
1107                {
1108                   detent_data = data;
1109                }
1110           }
1111         if (!ecore_dev && e_devicemgr_detent_is_detent(libinput_device_get_name(edev->device)))
1112           {
1113              ecore_dev = detent_data;
1114           }
1115      }
1116    else
1117      {
1118         edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_MOUSE);
1119         ecore_dev = edev->ecore_dev;
1120      }
1121
1122    if (!ecore_dev)
1123      {
1124         ERR("Failed to get source ecore device from event !\n");
1125         return;
1126      }
1127
1128    axis = LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL;
1129    if (libinput_event_pointer_has_axis(event, axis))
1130      z = _axis_value_get(event, axis);
1131
1132    axis = LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL;
1133    if (libinput_event_pointer_has_axis(event, axis))
1134      {
1135         direction = 1;
1136         z = _axis_value_get(event, axis);
1137      }
1138
1139   if (z == 0)
1140     {
1141        ELOGF("Mouse", "Axis event is ignored since it has zero value", NULL);
1142        return;
1143     }
1144
1145    comp_conf = e_comp_config_get();
1146    if (comp_conf && comp_conf->e_wheel_click_angle)
1147      {
1148         z = (int)(z * comp_conf->e_wheel_click_angle);
1149      }
1150
1151    if ((edev->seat->dev->blocked & E_INPUT_SEAT_POINTER) ||
1152        (edev->seat->dev->server_blocked & E_INPUT_SEAT_POINTER))
1153      {
1154         if (detent_data)
1155           ELOGF("Mouse", "Detent (direction: %d, value: %d) is blocked by %p, server: 0x%x", NULL,
1156                 direction, z, edev->seat->dev->blocked_client, edev->seat->dev->server_blocked);
1157         else
1158           ELOGF("Mouse", "Wheel (direction: %d, value: %d) is blocked by %p, server: 0x%x", NULL,
1159                 direction, z, edev->seat->dev->blocked_client, edev->seat->dev->server_blocked);
1160         return;
1161      }
1162
1163    if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Wheel))))
1164      {
1165         return;
1166      }
1167
1168    timestamp = libinput_event_pointer_get_time(event);
1169
1170    ev->window = (Ecore_Window)input->dev->window;
1171    ev->event_window = (Ecore_Window)input->dev->window;
1172    ev->root_window = (Ecore_Window)input->dev->window;
1173    ev->timestamp = timestamp;
1174    ev->same_screen = 1;
1175
1176    _device_modifiers_update(edev);
1177    ev->modifiers = edev->xkb.modifiers;
1178
1179    ev->x = edev->seat->ptr.ix;
1180    ev->y = edev->seat->ptr.iy;
1181    ev->root.x = ev->x;
1182    ev->root.y = ev->y;
1183    ev->dev = ecore_device_ref(ecore_dev);
1184
1185    ev->z = z;
1186    ev->direction = direction;
1187
1188    if (comp_conf && comp_conf->input_log_enable)
1189      {
1190         if (detent_data)
1191           ELOGF("Mouse", "Detent (direction: %d, value: %d)", NULL, ev->direction, ev->z);
1192         else
1193           ELOGF("Mouse", "Wheel (direction: %d, value: %d)", NULL, ev->direction, ev->z);
1194      }
1195
1196    ecore_event_add(ECORE_EVENT_MOUSE_WHEEL, ev, _e_input_event_mouse_wheel_cb_free, NULL);
1197 }
1198 #endif
1199
1200 #if LIBINPUT_HAVE_SCROLL_VALUE_V120
1201 static int
1202 _scroll_value_get(struct libinput_event_pointer *pointer_event, enum libinput_pointer_axis axis, E_Input_Axis_Source source)
1203 {
1204    double value = 0.0;
1205    double value_v120 = 0.0;
1206    int ret;
1207    E_Comp_Config *comp_conf = NULL;
1208
1209    comp_conf = e_comp_config_get();
1210    switch (source)
1211      {
1212       case E_INPUT_AXIS_SOURCE_WHEEL:
1213         value_v120 = libinput_event_pointer_get_scroll_value_v120(pointer_event, axis);
1214         value = libinput_event_pointer_get_scroll_value(pointer_event, axis);
1215         if (comp_conf && comp_conf->input_log_enable)
1216           {
1217              ELOGF("Scroll", "SOURCE_WHEELL value_v120: %lf (cf. value: %lf)", NULL, value_v120, value);
1218           }
1219         if (((int)value_v120 % E_INPUT_POINTER_AXIS_DISCRETE_STEP) != 0)
1220           {
1221              ERR("Wheel movements should be multiples (or fractions) of 120!\n");
1222              ret = 0;
1223           }
1224         else
1225           {
1226              ret = value_v120 / E_INPUT_POINTER_AXIS_DISCRETE_STEP;
1227           }
1228         break;
1229       case E_INPUT_AXIS_SOURCE_FINGER:
1230       case E_INPUT_AXIS_SOURCE_CONTINUOUS:
1231         value = libinput_event_pointer_get_scroll_value(pointer_event, axis);
1232         if (comp_conf && comp_conf->input_log_enable)
1233           {
1234              ELOGF("Scroll", "SOURCE_FINGER/CONTINUOUS value: %lf", NULL, value);
1235           }
1236         if (value >= E_INPUT_FINGER_SCROLL_THRESHOLD)
1237           ret = 1;
1238         else if (value <= E_INPUT_FINGER_SCROLL_THRESHOLD * (-1))
1239           ret = -1;
1240         else
1241           ret = 0;
1242         break;
1243       default:
1244         break;
1245      }
1246
1247    return ret;
1248 }
1249
1250 static void
1251 _device_handle_axis_v120(struct libinput_device *device, struct libinput_event_pointer *event, E_Input_Axis_Source source)
1252 {
1253    E_Input_Evdev *edev;
1254    E_Input_Backend *input;
1255    Ecore_Event_Mouse_Wheel *ev;
1256    uint32_t timestamp;
1257    enum libinput_pointer_axis axis;
1258    Ecore_Device *ecore_dev = NULL, *detent_data = NULL, *data;
1259    Eina_List *l;
1260    E_Comp_Config *comp_conf = NULL;
1261    int direction = 0, z = 0;
1262
1263    if (!(edev = libinput_device_get_user_data(device)))
1264      {
1265         return;
1266      }
1267    if (!(input = edev->seat->input))
1268      {
1269         return;
1270      }
1271
1272    if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1273    else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1274      {
1275         EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1276           {
1277              if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_MOUSE)
1278                {
1279                   ecore_dev = data;
1280                   break;
1281                }
1282              else if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_NONE)
1283                {
1284                   detent_data = data;
1285                }
1286           }
1287         if (!ecore_dev && e_devicemgr_detent_is_detent(libinput_device_get_name(edev->device)))
1288           {
1289              ecore_dev = detent_data;
1290           }
1291      }
1292    else
1293      {
1294         edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_MOUSE);
1295         ecore_dev = edev->ecore_dev;
1296      }
1297
1298    if (!ecore_dev)
1299      {
1300         ERR("Failed to get source ecore device from event !\n");
1301         return;
1302      }
1303
1304    axis = LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL;
1305    if (libinput_event_pointer_has_axis(event, axis))
1306      z = _scroll_value_get(event, axis, source);
1307
1308    axis = LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL;
1309    if (libinput_event_pointer_has_axis(event, axis))
1310      {
1311         direction = 1;
1312         z = _scroll_value_get(event, axis, source);
1313      }
1314
1315    if (z == 0)
1316      {
1317         ELOGF("Mouse", "Scroll event is ignored since it has zero value", NULL);
1318         return;
1319      }
1320
1321    comp_conf = e_comp_config_get();
1322    if (comp_conf && comp_conf->e_wheel_click_angle)
1323      {
1324         z = (int)(z * comp_conf->e_wheel_click_angle);
1325      }
1326
1327    if ((edev->seat->dev->blocked & E_INPUT_SEAT_POINTER) ||
1328        (edev->seat->dev->server_blocked & E_INPUT_SEAT_POINTER))
1329      {
1330         if (detent_data)
1331           ELOGF("Mouse", "Detent (direction: %d, value: %d) is blocked by %p, server: 0x%x", NULL,
1332                 direction, z, edev->seat->dev->blocked_client, edev->seat->dev->server_blocked);
1333         else
1334           ELOGF("Mouse", "Wheel (direction: %d, value: %d) is blocked by %p, server: 0x%x", NULL,
1335                 direction, z, edev->seat->dev->blocked_client, edev->seat->dev->server_blocked);
1336         return;
1337      }
1338
1339    if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Wheel))))
1340      {
1341         return;
1342      }
1343
1344    timestamp = libinput_event_pointer_get_time(event);
1345
1346    ev->window = (Ecore_Window)input->dev->window;
1347    ev->event_window = (Ecore_Window)input->dev->window;
1348    ev->root_window = (Ecore_Window)input->dev->window;
1349    ev->timestamp = timestamp;
1350    ev->same_screen = 1;
1351
1352    _device_modifiers_update(edev);
1353    ev->modifiers = edev->xkb.modifiers;
1354
1355    ev->x = edev->seat->ptr.ix;
1356    ev->y = edev->seat->ptr.iy;
1357    ev->root.x = ev->x;
1358    ev->root.y = ev->y;
1359    ev->dev = ecore_device_ref(ecore_dev);
1360
1361    ev->z = z;
1362    ev->direction = direction;
1363
1364    if (comp_conf && comp_conf->input_log_enable)
1365      {
1366         if (detent_data)
1367           ELOGF("Mouse", "Detent (direction: %d, value: %d)", NULL, ev->direction, ev->z);
1368         else
1369           ELOGF("Mouse", "Wheel (direction: %d, value: %d)", NULL, ev->direction, ev->z);
1370      }
1371
1372    ecore_event_add(ECORE_EVENT_MOUSE_WHEEL, ev, _e_input_event_mouse_wheel_cb_free, NULL);
1373 }
1374 #endif
1375
1376 static void
1377 _device_handle_touch_event_send(E_Input_Evdev *edev, struct libinput_event_touch *event, int state)
1378 {
1379    E_Input_Backend *input;
1380    Ecore_Event_Mouse_Button *ev;
1381    uint32_t timestamp, button = 0;
1382    Ecore_Device *ecore_dev = NULL, *data;
1383    Eina_List *l;
1384
1385    if (!edev) return;
1386    if (!(input = edev->seat->input)) return;
1387
1388    if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1389    else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1390      {
1391         EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1392           {
1393              if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_TOUCH)
1394                {
1395                   ecore_dev = data;
1396                   break;
1397                }
1398           }
1399      }
1400    else
1401      {
1402         edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_TOUCH);
1403         ecore_dev = edev->ecore_dev;
1404      }
1405
1406    if (!ecore_dev)
1407      {
1408         ERR("Failed to get source ecore device from event !\n");
1409         return;
1410      }
1411
1412    if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Button)))) return;
1413
1414    timestamp = libinput_event_touch_get_time(event);
1415
1416    ev->window = (Ecore_Window)input->dev->window;
1417    ev->event_window = (Ecore_Window)input->dev->window;
1418    ev->root_window = (Ecore_Window)input->dev->window;
1419    ev->timestamp = timestamp;
1420    ev->same_screen = 1;
1421
1422    _device_modifiers_update(edev);
1423    ev->modifiers = edev->xkb.modifiers;
1424
1425    ev->x = edev->seat->ptr.ix;
1426    ev->y = edev->seat->ptr.iy;
1427    ev->root.x = ev->x;
1428    ev->root.y = ev->y;
1429
1430    ev->multi.device = edev->mt_slot;
1431    ev->multi.radius = 1;
1432    ev->multi.radius_x = 1;
1433    ev->multi.radius_y = 1;
1434    ev->multi.pressure = 1.0;
1435    ev->multi.angle = 0.0;
1436 #if LIBINPUT_SUPPORT_EXTRA_TOUCH_EVENT
1437    if (libinput_event_get_type(libinput_event_touch_get_base_event(event))
1438        == LIBINPUT_EVENT_TOUCH_DOWN)
1439      {
1440         if (libinput_event_touch_has_minor(event))
1441           ev->multi.radius_x = libinput_event_touch_get_minor(event);
1442         if (libinput_event_touch_has_major(event))
1443           ev->multi.radius_y = libinput_event_touch_get_major(event);
1444         if (libinput_event_touch_has_pressure(event))
1445           ev->multi.pressure = libinput_event_touch_get_pressure(event);
1446         if (libinput_event_touch_has_orientation(event))
1447           ev->multi.angle = libinput_event_touch_get_orientation(event);
1448      }
1449 #endif
1450    ev->multi.x = ev->x;
1451    ev->multi.y = ev->y;
1452    ev->multi.root.x = ev->x;
1453    ev->multi.root.y = ev->y;
1454    ev->dev = ecore_device_ref(ecore_dev);
1455
1456    if (state == ECORE_EVENT_MOUSE_BUTTON_DOWN)
1457      {
1458         unsigned int current;
1459
1460         current = timestamp;
1461         edev->mouse.did_double = EINA_FALSE;
1462         edev->mouse.did_triple = EINA_FALSE;
1463
1464         if (((current - edev->mouse.prev) <= edev->mouse.threshold) &&
1465             (button == edev->mouse.prev_button))
1466           {
1467              edev->mouse.did_double = EINA_TRUE;
1468              if (((current - edev->mouse.last) <= (2 * edev->mouse.threshold)) &&
1469                  (button == edev->mouse.last_button))
1470                {
1471                   edev->mouse.did_triple = EINA_TRUE;
1472                   edev->mouse.prev = 0;
1473                   edev->mouse.last = 0;
1474                   current = 0;
1475                }
1476           }
1477
1478         edev->mouse.last = edev->mouse.prev;
1479         edev->mouse.prev = current;
1480         edev->mouse.last_button = edev->mouse.prev_button;
1481         edev->mouse.prev_button = button;
1482         edev->touch.pressed |= (1 << ev->multi.device);
1483      }
1484    else
1485      {
1486         edev->touch.pressed &= ~(1 << ev->multi.device);
1487      }
1488
1489    ev->buttons = ((button & 0x00F) + 1);
1490
1491    if (edev->mouse.did_double)
1492      ev->double_click = 1;
1493    if (edev->mouse.did_triple)
1494      ev->triple_click = 1;
1495
1496    ecore_event_add(state, ev, _e_input_event_mouse_button_cb_free, NULL);
1497 }
1498
1499 static void
1500 _device_handle_touch_motion_send(E_Input_Evdev *edev, struct libinput_event_touch *event)
1501 {
1502    E_Input_Backend *input;
1503    Ecore_Event_Mouse_Move *ev;
1504    Ecore_Device *ecore_dev = NULL, *data;
1505    Eina_List *l;
1506
1507    if (!edev) return;
1508    if (!(input = edev->seat->input)) return;
1509
1510    if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1511    else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1512      {
1513         EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1514           {
1515              if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_TOUCH)
1516                {
1517                   ecore_dev = data;
1518                   break;
1519                }
1520           }
1521      }
1522    else
1523      {
1524         edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_TOUCH);
1525         ecore_dev = edev->ecore_dev;
1526      }
1527
1528    if (!ecore_dev)
1529      {
1530         ERR("Failed to get source ecore device from event !\n");
1531         return;
1532      }
1533
1534    if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Move)))) return;
1535
1536    ev->window = (Ecore_Window)input->dev->window;
1537    ev->event_window = (Ecore_Window)input->dev->window;
1538    ev->root_window = (Ecore_Window)input->dev->window;
1539    ev->timestamp = libinput_event_touch_get_time(event);
1540    ev->same_screen = 1;
1541
1542    _device_modifiers_update(edev);
1543    ev->modifiers = edev->xkb.modifiers;
1544
1545    ev->x = edev->seat->ptr.ix;
1546    ev->y = edev->seat->ptr.iy;
1547    ev->root.x = ev->x;
1548    ev->root.y = ev->y;
1549
1550    ev->multi.device = edev->mt_slot;
1551    ev->multi.radius = 1;
1552    ev->multi.radius_x = 1;
1553    ev->multi.radius_y = 1;
1554    ev->multi.pressure = 1.0;
1555    ev->multi.angle = 0.0;
1556 #if LIBINPUT_SUPPORT_EXTRA_TOUCH_EVENT
1557    if (libinput_event_touch_has_minor(event))
1558      ev->multi.radius_x = libinput_event_touch_get_minor(event);
1559    if (libinput_event_touch_has_major(event))
1560      ev->multi.radius_y = libinput_event_touch_get_major(event);
1561    if (libinput_event_touch_has_pressure(event))
1562      ev->multi.pressure = libinput_event_touch_get_pressure(event);
1563    if (libinput_event_touch_has_orientation(event))
1564      ev->multi.angle = libinput_event_touch_get_orientation(event);
1565 #endif
1566    ev->multi.x = ev->x;
1567    ev->multi.y = ev->y;
1568    ev->multi.root.x = ev->x;
1569    ev->multi.root.y = ev->y;
1570    ev->dev = ecore_device_ref(ecore_dev);
1571
1572    ecore_event_add(ECORE_EVENT_MOUSE_MOVE, ev, _e_input_event_mouse_move_cb_free, NULL);
1573 }
1574
1575 static void
1576 _device_handle_touch_cancel_send(E_Input_Evdev *edev, struct libinput_event_touch *event)
1577 {
1578    E_Input_Backend *input;
1579    Ecore_Event_Mouse_Button *ev;
1580    uint32_t timestamp, button = 0;
1581    Ecore_Device *ecore_dev = NULL, *data;
1582    Eina_List *l;
1583
1584    if (!edev) return;
1585    if (!(input = edev->seat->input)) return;
1586
1587    if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1588    else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1589      {
1590         EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1591           {
1592              if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_TOUCH)
1593                {
1594                   ecore_dev = data;
1595                   break;
1596                }
1597           }
1598      }
1599    else
1600      {
1601         edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_TOUCH);
1602         ecore_dev = edev->ecore_dev;
1603      }
1604
1605    if (!ecore_dev)
1606      {
1607         ERR("Failed to get source ecore device from event !\n");
1608         return;
1609      }
1610
1611    if (!(ev = calloc(1, sizeof(Ecore_Event_Mouse_Button)))) return;
1612
1613    timestamp = libinput_event_touch_get_time(event);
1614
1615    ev->window = (Ecore_Window)input->dev->window;
1616    ev->event_window = (Ecore_Window)input->dev->window;
1617    ev->root_window = (Ecore_Window)input->dev->window;
1618    ev->timestamp = timestamp;
1619    ev->same_screen = 1;
1620
1621    ev->x = edev->seat->ptr.ix;
1622    ev->y = edev->seat->ptr.iy;
1623    ev->root.x = ev->x;
1624    ev->root.y = ev->y;
1625
1626    ev->multi.device = edev->mt_slot;
1627    ev->multi.radius = 1;
1628    ev->multi.radius_x = 1;
1629    ev->multi.radius_y = 1;
1630    ev->multi.pressure = 1.0;
1631    ev->multi.angle = 0.0;
1632    ev->multi.x = ev->x;
1633    ev->multi.y = ev->y;
1634    ev->multi.root.x = ev->x;
1635    ev->multi.root.y = ev->y;
1636    ev->dev = ecore_device_ref(ecore_dev);
1637
1638    edev->touch.pressed &= ~(1 << ev->multi.device);
1639
1640    ev->buttons = ((button & 0x00F) + 1);
1641
1642    ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, ev, _e_input_event_mouse_button_cb_free, NULL);
1643 }
1644
1645 static void
1646 _device_configured_size_get(E_Input_Evdev *edev, int *x, int *y, int *w, int *h)
1647 {
1648    E_Output *output = NULL;
1649
1650    EINA_SAFETY_ON_NULL_RETURN(edev);
1651
1652    if (!edev->output_configured)
1653      {
1654         if (edev->output_name)
1655           {
1656              output = e_output_find(edev->output_name);
1657              if (output)
1658                {
1659                   edev->mouse.minx = output->config.geom.x;
1660                   edev->mouse.miny = output->config.geom.y;
1661                   edev->mouse.maxw = output->config.geom.w;
1662                   edev->mouse.maxh = output->config.geom.h;
1663                   if (libinput_device_has_capability(edev->device, LIBINPUT_DEVICE_CAP_POINTER))
1664                     {
1665                        edev->seat->ptr.dx = (double)(edev->mouse.maxw / 2);
1666                        edev->seat->ptr.dy = (double)(edev->mouse.maxh / 2);
1667                        edev->seat->ptr.ix = (int)edev->seat->ptr.dx;
1668                        edev->seat->ptr.iy = (int)edev->seat->ptr.dy;
1669                        edev->mouse.dx = edev->seat->ptr.dx;
1670                        edev->mouse.dy = edev->seat->ptr.dy;
1671                     }
1672                }
1673           }
1674
1675           edev->output_configured = EINA_TRUE;
1676           ELOGF("E_INPUT_EVDEV", "Device is configured by output x:%d,y:%d (w:%d, h:%d)",
1677                 NULL, edev->mouse.minx, edev->mouse.miny, edev->mouse.maxw, edev->mouse.maxh);
1678      }
1679    if (x) *x = edev->mouse.minx;
1680    if (y) *y = edev->mouse.miny;
1681    if (w) *w = edev->mouse.maxw;
1682    if (h) *h = edev->mouse.maxh;
1683 }
1684
1685 static void
1686 _device_handle_touch_down(struct libinput_device *device, struct libinput_event_touch *event)
1687 {
1688    E_Input_Evdev *edev;
1689    int x = 0, y = 0, w = 0, h = 0;
1690    E_Comp_Config *comp_conf = NULL;
1691
1692    if (!(edev = libinput_device_get_user_data(device)))
1693      {
1694         return;
1695      }
1696
1697    _device_configured_size_get(edev, &x, &y, &w, &h);
1698
1699    edev->mouse.dx = edev->seat->ptr.ix = edev->seat->ptr.dx =
1700      x + libinput_event_touch_get_x_transformed(event, w);
1701    edev->mouse.dy = edev->seat->ptr.iy = edev->seat->ptr.dy =
1702      y + libinput_event_touch_get_y_transformed(event, h);
1703
1704    edev->mt_slot = libinput_event_touch_get_slot(event);
1705    if (edev->mt_slot < 0)
1706      {
1707         /* FIXME: The single touch device return slot id -1
1708          *        But currently we have no API to distinguish multi touch or single touch
1709          *        After libinput 1.11 version, libinput provides get_touch_count API,
1710          *        so we can distinguish multi touch device or single touch device.
1711          */
1712         if (edev->mt_slot == -1)
1713           edev->mt_slot = 0;
1714         else
1715           {
1716              WRN("%d slot touch down events are not supported\n", edev->mt_slot);
1717              return;
1718           }
1719      }
1720
1721    if (edev->mt_slot < e_input_touch_max_count_get())
1722      {
1723         edev->touch.coords[edev->mt_slot].x = edev->seat->ptr.ix;
1724         edev->touch.coords[edev->mt_slot].y = edev->seat->ptr.iy;
1725      }
1726
1727    comp_conf = e_comp_config_get();
1728    if (comp_conf && comp_conf->input_log_enable)
1729      ELOGF("Touch", "Down (id: %d, x: %d, y: %d)", NULL, edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy);
1730
1731    edev->touch.raw_pressed |= (1 << edev->mt_slot);
1732
1733    if (edev->touch.blocked)
1734      {
1735         ELOGF("Touch", "Down (id: %d, x: %d, y: %d) is blocked by %p, server: 0x%x", NULL,
1736               edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy, edev->seat->dev->blocked_client,
1737               edev->seat->dev->server_blocked);
1738         return;
1739      }
1740
1741    _device_handle_touch_motion_send(edev, event);
1742    _device_handle_touch_event_send(edev, event, ECORE_EVENT_MOUSE_BUTTON_DOWN);
1743 }
1744
1745 static void
1746 _device_handle_touch_motion(struct libinput_device *device, struct libinput_event_touch *event)
1747 {
1748    E_Input_Evdev *edev;
1749    int x = 0, y = 0, w = 0, h = 0;
1750
1751    if (!(edev = libinput_device_get_user_data(device)))
1752      {
1753         return;
1754      }
1755
1756    _device_configured_size_get(edev, &x, &y, &w, &h);
1757
1758    edev->mouse.dx = edev->seat->ptr.dx =
1759      x + libinput_event_touch_get_x_transformed(event, w);
1760    edev->mouse.dy = edev->seat->ptr.dy =
1761      y + libinput_event_touch_get_y_transformed(event, h);
1762
1763    if (floor(edev->seat->ptr.dx) == edev->seat->ptr.ix &&
1764        floor(edev->seat->ptr.dy) == edev->seat->ptr.iy)
1765      {
1766         return;
1767      }
1768
1769    edev->seat->ptr.ix = edev->seat->ptr.dx;
1770    edev->seat->ptr.iy = edev->seat->ptr.dy;
1771
1772    edev->mt_slot = libinput_event_touch_get_slot(event);
1773    if (edev->mt_slot < 0)
1774      {
1775         /* FIXME: The single touch device return slot id -1
1776          *        But currently we have no API to distinguish multi touch or single touch
1777          *        After libinput 1.11 version, libinput provides get_touch_count API,
1778          *        so we can distinguish multi touch device or single touch device.
1779          */
1780         if (edev->mt_slot == -1)
1781           edev->mt_slot = 0;
1782         else
1783           {
1784              WRN("%d slot touch motion events are not supported\n", edev->mt_slot);
1785              return;
1786           }
1787      }
1788
1789    if (edev->mt_slot < e_input_touch_max_count_get())
1790      {
1791         edev->touch.coords[edev->mt_slot].x = edev->seat->ptr.ix;
1792         edev->touch.coords[edev->mt_slot].y = edev->seat->ptr.iy;
1793      }
1794
1795    if (!(edev->touch.pressed & (1 << edev->mt_slot)))
1796      {
1797         if (edev->touch.blocked)
1798           {
1799              return;
1800           }
1801      }
1802
1803    _device_handle_touch_motion_send(edev, event);
1804 }
1805
1806 static void
1807 _device_handle_touch_up(struct libinput_device *device, struct libinput_event_touch *event)
1808 {
1809    E_Input_Evdev *edev;
1810    E_Comp_Config *comp_conf = NULL;
1811
1812    if (!(edev = libinput_device_get_user_data(device)))
1813      {
1814         return;
1815      }
1816
1817    edev->mt_slot = libinput_event_touch_get_slot(event);
1818    if (edev->mt_slot < 0)
1819      {
1820         /* FIXME: The single touch device return slot id -1
1821          *        But currently we have no API to distinguish multi touch or single touch
1822          *        After libinput 1.11 version, libinput provides get_touch_count API,
1823          *        so we can distinguish multi touch device or single touch device.
1824          */
1825         if (edev->mt_slot == -1)
1826           edev->mt_slot = 0;
1827         else
1828           {
1829              WRN("%d slot touch up events are not supported\n", edev->mt_slot);
1830              return;
1831           }
1832      }
1833
1834    if (edev->mt_slot < e_input_touch_max_count_get())
1835      {
1836         edev->mouse.dx = edev->seat->ptr.dx = edev->seat->ptr.ix =
1837           edev->touch.coords[edev->mt_slot].x;
1838         edev->mouse.dy = edev->seat->ptr.dy = edev->seat->ptr.iy =
1839           edev->touch.coords[edev->mt_slot].y;
1840      }
1841
1842    comp_conf = e_comp_config_get();
1843    if (comp_conf && comp_conf->input_log_enable)
1844      ELOGF("Touch", "Up (id: %d, x: %d, y: %d)", NULL, edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy);
1845
1846    edev->touch.raw_pressed &= ~(1 << edev->mt_slot);
1847
1848    if (edev->touch.blocked)
1849      {
1850         if (!(edev->touch.pressed & (1 << edev->mt_slot)))
1851           {
1852              ELOGF("Touch", "Up (id: %d, x: %d, y: %d) is blocked by %p, server(0x%x)", NULL,
1853                    edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy, edev->seat->dev->blocked_client,
1854                    edev->seat->dev->server_blocked);
1855              if (edev->touch.raw_pressed == 0x0)
1856                {
1857                   edev->touch.blocked = EINA_FALSE;
1858                }
1859              return;
1860           }
1861      }
1862
1863    _device_handle_touch_event_send(edev, event, ECORE_EVENT_MOUSE_BUTTON_UP);
1864 }
1865
1866 static void
1867 _device_handle_touch_cancel(struct libinput_device *device, struct libinput_event_touch *event)
1868 {
1869    E_Input_Evdev *edev;
1870    E_Comp_Config *comp_conf = NULL;
1871
1872    if (!(edev = libinput_device_get_user_data(device)))
1873      {
1874         return;
1875      }
1876
1877    edev->mt_slot = libinput_event_touch_get_slot(event);
1878    if (edev->mt_slot < 0)
1879      {
1880         /* FIXME: The single touch device return slot id -1
1881          *        But currently we have no API to distinguish multi touch or single touch
1882          *        After libinput 1.11 version, libinput provides get_touch_count API,
1883          *        so we can distinguish multi touch device or single touch device.
1884          */
1885         if (edev->mt_slot == -1)
1886           edev->mt_slot = 0;
1887         else
1888           {
1889              WRN("%d slot touch up events are not supported\n", edev->mt_slot);
1890              return;
1891           }
1892      }
1893
1894    comp_conf = e_comp_config_get();
1895    if (comp_conf && comp_conf->input_log_enable)
1896      ELOGF("Touch", "cancel (id: %d, x: %d, y: %d)", NULL, edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy);
1897
1898    _device_handle_touch_cancel_send(edev, event);
1899 }
1900
1901
1902 static void
1903 _device_handle_touch_frame(struct libinput_device *device EINA_UNUSED, struct libinput_event_touch *event EINA_UNUSED)
1904 {
1905    /* DBG("Unhandled Touch Frame Event"); */
1906 }
1907
1908 static void
1909 _e_input_aux_data_event_free(void *user_data EINA_UNUSED, void *ev)
1910 {
1911    Ecore_Event_Axis_Update *e = (Ecore_Event_Axis_Update *)ev;
1912
1913    if (e->axis) free(e->axis);
1914    if (e->dev) ecore_device_unref(e->dev);
1915
1916    free(e);
1917 }
1918
1919 static void
1920 _device_handle_touch_aux_data(struct libinput_device *device, struct libinput_event_touch_aux_data *event)
1921 {
1922    E_Input_Evdev *edev;
1923    E_Input_Backend *input;
1924    Ecore_Event_Axis_Update *ev;
1925    Ecore_Axis *axis;
1926    Ecore_Device *ecore_dev = NULL, *data;
1927    Eina_List *l;
1928    E_Comp_Config *comp_conf;
1929
1930    if (libinput_event_touch_aux_data_get_type(event) != LIBINPUT_TOUCH_AUX_DATA_TYPE_PALM &&
1931        libinput_event_touch_aux_data_get_value(event) > 0)
1932       goto end;
1933
1934    if (!(edev = libinput_device_get_user_data(device))) goto end;
1935    if (!(input = edev->seat->input)) goto end;
1936
1937    if (edev->ecore_dev) ecore_dev = edev->ecore_dev;
1938    else if (edev->ecore_dev_list && eina_list_count(edev->ecore_dev_list) > 0)
1939      {
1940         EINA_LIST_FOREACH(edev->ecore_dev_list, l, data)
1941           {
1942              if (ecore_device_class_get(data) == ECORE_DEVICE_CLASS_TOUCH)
1943                {
1944                   ecore_dev = data;
1945                   break;
1946                }
1947           }
1948      }
1949    else
1950      {
1951         edev->ecore_dev = e_input_evdev_get_ecore_device(edev->path, ECORE_DEVICE_CLASS_TOUCH);
1952         ecore_dev = edev->ecore_dev;
1953      }
1954
1955    if (!ecore_dev)
1956      {
1957         ERR("Failed to get source ecore device from event !\n");
1958         goto end;
1959      }
1960
1961    if (!(ev = calloc(1, sizeof(Ecore_Event_Axis_Update))))goto end;
1962
1963    ev->window = (Ecore_Window)input->dev->window;
1964    ev->event_window = (Ecore_Window)input->dev->window;
1965    ev->root_window = (Ecore_Window)input->dev->window;
1966    ev->timestamp = libinput_event_touch_aux_data_get_time(event);
1967
1968    axis = (Ecore_Axis *)calloc(1, sizeof(Ecore_Axis));
1969    if (axis)
1970      {
1971         axis->label = ECORE_AXIS_LABEL_TOUCH_PALM;
1972         axis->value = libinput_event_touch_aux_data_get_value(event);
1973         ev->naxis = 1;
1974      }
1975    ev->axis = axis;
1976    ev->dev = ecore_device_ref(ecore_dev);
1977
1978    comp_conf = e_comp_config_get();
1979    if (comp_conf && comp_conf->input_log_enable)
1980      ELOGF("Touch", "Axis (label: %d, value: %lf)", NULL, axis?axis->label:-1, axis?axis->value:0.0);
1981
1982    ecore_event_add(ECORE_EVENT_AXIS_UPDATE, ev, _e_input_aux_data_event_free, NULL);
1983
1984 end:
1985    ;
1986 }
1987
1988 E_Input_Evdev *
1989 _e_input_evdev_device_create(E_Input_Seat *seat, struct libinput_device *device)
1990 {
1991    E_Input_Evdev *edev;
1992    E_Input_Backend *b_input;
1993    const char *output_name;
1994
1995    EINA_SAFETY_ON_NULL_RETURN_VAL(seat, NULL);
1996
1997    /* try to allocate space for new evdev */
1998    if (!(edev = calloc(1, sizeof(E_Input_Evdev)))) return NULL;
1999
2000    edev->seat = seat;
2001    edev->device = device;
2002    edev->path = eina_stringshare_printf("%s/%s", e_input_base_dir_get(), libinput_device_get_sysname(device));
2003
2004    if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_KEYBOARD))
2005      {
2006         edev->caps |= E_INPUT_SEAT_KEYBOARD;
2007         _device_keyboard_setup(edev);
2008      }
2009
2010    if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_POINTER))
2011      {
2012         edev->caps |= E_INPUT_SEAT_POINTER;
2013
2014         /* TODO: make this configurable */
2015         edev->mouse.threshold = 250;
2016
2017         b_input = seat->input;
2018         if (b_input->left_handed == EINA_TRUE)
2019           {
2020              if (libinput_device_config_left_handed_set(device, 1) !=
2021                  LIBINPUT_CONFIG_STATUS_SUCCESS)
2022                {
2023                   WRN("Failed to set left hand mode about device: %s\n",
2024                       libinput_device_get_name(device));
2025                }
2026           }
2027      }
2028
2029    if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_TOUCH))
2030      {
2031         int palm_code;
2032         edev->caps |= E_INPUT_SEAT_TOUCH;
2033         palm_code = libinput_device_touch_aux_data_get_code(LIBINPUT_TOUCH_AUX_DATA_TYPE_PALM);
2034         if (libinput_device_touch_has_aux_data(device, palm_code))
2035           {
2036              libinput_device_touch_set_aux_data(device, palm_code);
2037           }
2038
2039         _device_touch_count_update(edev);
2040
2041         edev->touch.coords = calloc(1, sizeof(E_Input_Coord)*e_input_touch_max_count_get());
2042
2043         if  (!edev->touch.coords)
2044           ERR("Failed to allocate memory for touch coords !\n");
2045      }
2046
2047    output_name = libinput_device_get_output_name(device);
2048    if (output_name)
2049      {
2050         eina_stringshare_replace(&edev->output_name, output_name);
2051         ELOGF("E_INPUT_EVDEV", "Device has output_name:%s", NULL, output_name);
2052      }
2053
2054    libinput_device_set_user_data(device, edev);
2055    libinput_device_ref(device);
2056
2057    /* configure device */
2058    _device_configure(edev);
2059
2060    return edev;
2061 }
2062
2063 void
2064 _e_input_evdev_device_destroy(E_Input_Evdev *edev)
2065 {
2066    Ecore_Device *dev;
2067
2068    EINA_SAFETY_ON_NULL_RETURN(edev);
2069
2070    if (edev->caps & E_INPUT_SEAT_KEYBOARD)
2071      {
2072         if (edev->xkb.state) xkb_state_unref(edev->xkb.state);
2073         if (edev->xkb.keymap) xkb_map_unref(edev->xkb.keymap);
2074      }
2075
2076    if (edev->ecore_dev) ecore_device_del(edev->ecore_dev);
2077    if (edev->ecore_dev_list)
2078      EINA_LIST_FREE(edev->ecore_dev_list, dev)
2079        {
2080           ecore_device_del(dev);
2081        }
2082    if (edev->path) eina_stringshare_del(edev->path);
2083    if (edev->device) libinput_device_unref(edev->device);
2084    if (edev->key_remap_hash) eina_hash_free(edev->key_remap_hash);
2085    if (edev->touch.coords)
2086      {
2087         free(edev->touch.coords);
2088         edev->touch.coords = NULL;
2089      }
2090    eina_stringshare_del(edev->output_name);
2091
2092    free(edev);
2093 }
2094
2095 Eina_Bool
2096 _e_input_evdev_event_process(struct libinput_event *event)
2097 {
2098    struct libinput_device *device;
2099    Eina_Bool ret = EINA_TRUE;
2100
2101    device = libinput_event_get_device(event);
2102    switch (libinput_event_get_type(event))
2103      {
2104       case LIBINPUT_EVENT_KEYBOARD_KEY:
2105         _device_handle_key(device, libinput_event_get_keyboard_event(event));
2106         break;
2107       case LIBINPUT_EVENT_POINTER_MOTION:
2108         _device_handle_pointer_motion(device,
2109                                       libinput_event_get_pointer_event(event));
2110         break;
2111       case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE:
2112         _device_handle_pointer_motion_absolute(device,
2113                                                libinput_event_get_pointer_event(event));
2114         break;
2115       case LIBINPUT_EVENT_POINTER_BUTTON:
2116         _device_handle_button(device, libinput_event_get_pointer_event(event));
2117         break;
2118       case LIBINPUT_EVENT_POINTER_AXIS:
2119 #if !LIBINPUT_HAVE_SCROLL_VALUE_V120
2120         _device_handle_axis(device, libinput_event_get_pointer_event(event));
2121 #endif
2122         break;
2123 #if LIBINPUT_HAVE_SCROLL_VALUE_V120
2124       case LIBINPUT_EVENT_POINTER_SCROLL_WHEEL:
2125         _device_handle_axis_v120(device, libinput_event_get_pointer_event(event), E_INPUT_AXIS_SOURCE_WHEEL);
2126         break;
2127       case LIBINPUT_EVENT_POINTER_SCROLL_FINGER:
2128         _device_handle_axis_v120(device, libinput_event_get_pointer_event(event), E_INPUT_AXIS_SOURCE_FINGER);
2129         break;
2130       case LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS:
2131         _device_handle_axis_v120(device, libinput_event_get_pointer_event(event), E_INPUT_AXIS_SOURCE_CONTINUOUS);
2132         break;
2133 #endif
2134       case LIBINPUT_EVENT_TOUCH_DOWN:
2135         _device_handle_touch_down(device, libinput_event_get_touch_event(event));
2136         break;
2137       case LIBINPUT_EVENT_TOUCH_MOTION:
2138         _device_handle_touch_motion(device,
2139                                     libinput_event_get_touch_event(event));
2140         break;
2141       case LIBINPUT_EVENT_TOUCH_UP:
2142         _device_handle_touch_up(device, libinput_event_get_touch_event(event));
2143         break;
2144       case LIBINPUT_EVENT_TOUCH_CANCEL:
2145         _device_handle_touch_cancel(device, libinput_event_get_touch_event(event));
2146         break;
2147       case LIBINPUT_EVENT_TOUCH_FRAME:
2148         _device_handle_touch_frame(device, libinput_event_get_touch_event(event));
2149         break;
2150       case LIBINPUT_EVENT_TOUCH_AUX_DATA:
2151         _device_handle_touch_aux_data(device, libinput_event_get_touch_aux_data(event));
2152         break;
2153       default:
2154         ret = EINA_FALSE;
2155         break;
2156      }
2157
2158    return ret;
2159 }
2160
2161 /**
2162  * @brief Set the axis size of the given device.
2163  *
2164  * @param dev The device to set the axis size to.
2165  * @param w The width of the axis.
2166  * @param h The height of the axis.
2167  *
2168  * This function sets set the width @p w and height @p h of the axis
2169  * of device @p dev. If @p dev is a relative input device, a width and
2170  * height must set for it. If its absolute set the ioctl correctly, if
2171  * not, unsupported device.
2172  */
2173 EINTERN void
2174 e_input_evdev_axis_size_set(E_Input_Evdev *edev, int w, int h)
2175 {
2176    const char *sysname;
2177    float cal[6];
2178    const char *device;
2179    Eina_List *devices;
2180    const char *vals;
2181    enum libinput_config_status status;
2182
2183    EINA_SAFETY_ON_NULL_RETURN(edev);
2184    EINA_SAFETY_ON_TRUE_RETURN((w == 0) || (h == 0));
2185
2186    if ((!libinput_device_config_calibration_has_matrix(edev->device)) ||
2187        (libinput_device_config_calibration_get_default_matrix(edev->device, cal) != 0))
2188      return;
2189
2190    sysname = libinput_device_get_sysname(edev->device);
2191
2192    devices = eeze_udev_find_by_subsystem_sysname("input", sysname);
2193    if (eina_list_count(devices) < 1) return;
2194
2195    EINA_LIST_FREE(devices, device)
2196      {
2197         vals = eeze_udev_syspath_get_property(device, "WL_CALIBRATION");
2198         if ((!vals) ||
2199             (sscanf(vals, "%f %f %f %f %f %f",
2200                     &cal[0], &cal[1], &cal[2], &cal[3], &cal[4], &cal[5]) != 6))
2201           goto cont;
2202
2203         cal[2] /= w;
2204         cal[5] /= h;
2205
2206         status =
2207           libinput_device_config_calibration_set_matrix(edev->device, cal);
2208
2209         if (status != LIBINPUT_CONFIG_STATUS_SUCCESS)
2210           ERR("Failed to apply calibration");
2211
2212 cont:
2213         eina_stringshare_del(device);
2214         continue;
2215      }
2216 }
2217
2218 EINTERN const char *
2219 e_input_evdev_name_get(E_Input_Evdev *evdev)
2220 {
2221    EINA_SAFETY_ON_NULL_RETURN_VAL(evdev, NULL);
2222    EINA_SAFETY_ON_NULL_RETURN_VAL(evdev->device, NULL);
2223
2224    return libinput_device_get_name(evdev->device);
2225 }
2226
2227 EINTERN const char *
2228 e_input_evdev_sysname_get(E_Input_Evdev *evdev)
2229 {
2230    EINA_SAFETY_ON_NULL_RETURN_VAL(evdev, NULL);
2231    EINA_SAFETY_ON_NULL_RETURN_VAL(evdev->device, NULL);
2232
2233    return libinput_device_get_sysname(evdev->device);
2234 }
2235
2236 EINTERN Eina_Bool
2237 e_input_evdev_key_remap_enable(E_Input_Evdev *edev, Eina_Bool enable)
2238 {
2239    EINA_SAFETY_ON_NULL_RETURN_VAL(edev, EINA_FALSE);
2240    EINA_SAFETY_ON_NULL_RETURN_VAL(edev->device, EINA_FALSE);
2241
2242    edev->key_remap_enabled = enable;
2243
2244    if (enable == EINA_FALSE && edev->key_remap_hash)
2245      {
2246         eina_hash_free(edev->key_remap_hash);
2247         edev->key_remap_hash = NULL;
2248      }
2249
2250    return EINA_TRUE;
2251 }
2252
2253 EINTERN Eina_Bool
2254 e_input_evdev_key_remap_set(E_Input_Evdev *edev, int *from_keys, int *to_keys, int num)
2255 {
2256    int i;
2257
2258    EINA_SAFETY_ON_NULL_RETURN_VAL(edev, EINA_FALSE);
2259    EINA_SAFETY_ON_NULL_RETURN_VAL(edev->device, EINA_FALSE);
2260    EINA_SAFETY_ON_NULL_RETURN_VAL(from_keys, EINA_FALSE);
2261    EINA_SAFETY_ON_NULL_RETURN_VAL(to_keys, EINA_FALSE);
2262    EINA_SAFETY_ON_TRUE_RETURN_VAL(num <= 0, EINA_FALSE);
2263    EINA_SAFETY_ON_TRUE_RETURN_VAL(!edev->key_remap_enabled, EINA_FALSE);
2264
2265    if (edev->key_remap_hash == NULL)
2266      edev->key_remap_hash = eina_hash_int32_new(NULL);
2267
2268    if (edev->key_remap_hash == NULL)
2269      {
2270         ERR("Failed to set remap key information : creating a hash is failed.");
2271         return EINA_FALSE;
2272      }
2273
2274    for (i = 0; i < num ; i++)
2275      {
2276         if (!from_keys[i] || !to_keys[i])
2277           {
2278              ERR("Failed to set remap key information : given arguments are invalid.");
2279              return EINA_FALSE;
2280           }
2281      }
2282
2283    for (i = 0; i < num ; i++)
2284      {
2285         eina_hash_add(edev->key_remap_hash, &from_keys[i], (void *)(intptr_t)to_keys[i]);
2286      }
2287
2288    return EINA_TRUE;
2289 }
2290
2291 EINTERN int
2292 e_input_evdev_wheel_click_angle_get(E_Input_Evdev *dev)
2293 {
2294    EINA_SAFETY_ON_NULL_RETURN_VAL(dev, -1);
2295    return libinput_device_config_scroll_get_wheel_click_angle(dev->device);
2296 }
2297
2298 EINTERN Eina_Bool
2299 e_input_evdev_touch_calibration_set(E_Input_Evdev *edev, float matrix[6])
2300 {
2301    EINA_SAFETY_ON_NULL_RETURN_VAL(edev, EINA_FALSE);
2302    EINA_SAFETY_ON_NULL_RETURN_VAL(edev->device, EINA_FALSE);
2303
2304    if (!libinput_device_config_calibration_has_matrix(edev->device) ||
2305        !libinput_device_has_capability(edev->device, LIBINPUT_DEVICE_CAP_TOUCH))
2306      return EINA_FALSE;
2307
2308    if (libinput_device_config_calibration_set_matrix(edev->device, matrix) !=
2309        LIBINPUT_CONFIG_STATUS_SUCCESS)
2310      {
2311         WRN("Failed to set input transformation about device: %s\n",
2312             libinput_device_get_name(edev->device));
2313         return EINA_FALSE;
2314      }
2315
2316    return EINA_TRUE;
2317 }
2318
2319 EINTERN Eina_Bool
2320 e_input_evdev_mouse_accel_speed_set(E_Input_Evdev *edev, double speed)
2321 {
2322    EINA_SAFETY_ON_NULL_RETURN_VAL(edev, EINA_FALSE);
2323    EINA_SAFETY_ON_NULL_RETURN_VAL(edev->device, EINA_FALSE);
2324
2325    if (!libinput_device_has_capability(edev->device, LIBINPUT_DEVICE_CAP_POINTER))
2326      return EINA_FALSE;
2327
2328    if (!libinput_device_config_accel_is_available(edev->device))
2329      return EINA_FALSE;
2330
2331    if (libinput_device_config_accel_set_speed(edev->device, speed) !=
2332        LIBINPUT_CONFIG_STATUS_SUCCESS)
2333      {
2334         WRN("Failed to set mouse accel about device: %s\n",
2335             libinput_device_get_name(edev->device));
2336         return EINA_FALSE;
2337      }
2338
2339    return EINA_TRUE;
2340 }
2341
2342 EINTERN unsigned int
2343 e_input_evdev_touch_pressed_get(E_Input_Evdev *edev)
2344 {
2345    EINA_SAFETY_ON_NULL_RETURN_VAL(edev, 0x0);
2346
2347    return edev->touch.pressed;
2348 }
2349
2350 const char *
2351 e_input_evdev_seatname_get(E_Input_Evdev *evdev)
2352 {
2353    struct libinput_seat *libinput_seat;
2354    EINA_SAFETY_ON_NULL_RETURN_VAL(evdev, NULL);
2355    EINA_SAFETY_ON_NULL_RETURN_VAL(evdev->device, NULL);
2356
2357    libinput_seat = libinput_device_get_seat(evdev->device);
2358
2359    return libinput_seat_get_logical_name(libinput_seat);
2360 }
2361
2362 Eina_Bool
2363 e_input_evdev_seatname_set(E_Input_Evdev *evdev, const char *seatname)
2364 {
2365    Eina_Bool res = EINA_FALSE;
2366    E_Input_Backend *input;
2367
2368    EINA_SAFETY_ON_NULL_RETURN_VAL(seatname, EINA_FALSE);
2369    EINA_SAFETY_ON_NULL_RETURN_VAL(evdev, EINA_FALSE);
2370    EINA_SAFETY_ON_NULL_RETURN_VAL(evdev->device, EINA_FALSE);
2371
2372    if (libinput_device_set_seat_logical_name(evdev->device, seatname) == 0)
2373      {
2374         input = evdev->seat->input;
2375         if (!input) return EINA_FALSE;
2376         if (libinput_dispatch(input->libinput) != 0)
2377           {
2378              ERR("Failed to dispatch libinput events: %m");
2379              return EINA_FALSE;
2380           }
2381
2382         /* process pending events */
2383         _input_events_process(input);
2384         res = EINA_TRUE;
2385      }
2386
2387    return res;
2388 }
2389
2390 EINTERN Eina_Bool
2391 e_input_evdev_mouse_accel_enable(E_Input_Evdev *edev, Eina_Bool enable)
2392 {
2393    EINA_SAFETY_ON_NULL_RETURN_VAL(edev, EINA_FALSE);
2394    edev->disable_acceleration = !enable;
2395
2396    return EINA_TRUE;
2397 }