src/bin/e_input_evdev.c

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