src/e_mod_gesture_events.c

   1 #define E_COMP_WL
   2 #include "e_mod_main.h"
   3 #include <string.h>
   4
   5 static void
   6 _e_gesture_swipe_cancel(void)
   7 {
   8    E_Gesture_Event_Swipe *swipes = &gesture->gesture_events.swipes;
   9
  10    if (swipes->start_timer)
  11      {
  12         ecore_timer_del(swipes->start_timer);
  13         swipes->start_timer = NULL;
  14      }
  15    if (swipes->done_timer)
  16      {
  17         ecore_timer_del(swipes->done_timer);
  18         swipes->done_timer = NULL;
  19      }
  20
  21    swipes->enabled_finger = 0x0;
  22    swipes->direction = E_GESTURE_DIRECTION_NONE;
  23
  24    gesture->gesture_filter |= TIZEN_GESTURE_TYPE_SWIPE;
  25 }
  26
  27 static Eina_Bool
  28 _e_gesture_is_touch_device(Ecore_Device *dev)
  29 {
  30    Eina_List *l;
  31    char *data;
  32    const char *identifier;
  33
  34    EINA_SAFETY_ON_NULL_RETURN_VAL(dev, EINA_FALSE);
  35
  36    identifier = ecore_device_identifier_get(dev);
  37    if (!identifier) return EINA_FALSE;
  38
  39    EINA_LIST_FOREACH(gesture->touch_devices, l, data)
  40      {
  41         if (!strncmp(data, identifier, strlen(identifier)))
  42           {
  43              return EINA_TRUE;
  44           }
  45      }
  46    return EINA_FALSE;
  47 }
  48
  49 static void
  50 _e_gesture_send_swipe(int fingers, int x, int y, int direction, struct wl_client *client, struct wl_resource *res)
  51 {
  52    enum tizen_gesture_direction dir = 0;
  53    Ecore_Event_Mouse_Button *ev_cancel;
  54    switch (direction)
  55      {
  56         case E_GESTURE_DIRECTION_DOWN:
  57            dir = TIZEN_GESTURE_DIRECTION_DOWN;
  58            break;
  59         case E_GESTURE_DIRECTION_LEFT:
  60            dir = TIZEN_GESTURE_DIRECTION_LEFT;
  61            break;
  62         case E_GESTURE_DIRECTION_UP:
  63            dir = TIZEN_GESTURE_DIRECTION_UP;
  64            break;
  65         case E_GESTURE_DIRECTION_RIGHT:
  66            dir = TIZEN_GESTURE_DIRECTION_RIGHT;
  67            break;
  68      }
  69
  70    ev_cancel = E_NEW(Ecore_Event_Mouse_Button, 1);
  71    EINA_SAFETY_ON_NULL_RETURN(ev_cancel);
  72
  73    ev_cancel->timestamp = (int)(ecore_time_get()*1000);
  74    ev_cancel->same_screen = 1;
  75
  76    ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, ev_cancel, NULL, NULL);
  77
  78    GTINF("Send swipe gesture (direction: %d) to client: %p\n", dir, client);
  79
  80    tizen_gesture_send_swipe(res, fingers, TIZEN_GESTURE_MODE_DONE, x, y, dir);
  81    _e_gesture_swipe_cancel();
  82
  83    gesture->gesture_events.recognized_gesture |= TIZEN_GESTURE_TYPE_SWIPE;
  84 }
  85
  86 static Eina_Bool
  87 _e_gesture_process_device_add(void *event)
  88 {
  89    Ecore_Event_Device_Info *ev = event;
  90
  91    if (ev->clas == ECORE_DEVICE_CLASS_TOUCH)
  92      {
  93         gesture->touch_devices = eina_list_append(gesture->touch_devices, ev->identifier);
  94         GTINF("%s(%s) device is touch device: add list\n", ev->name, ev->identifier);
  95      }
  96    return EINA_TRUE;
  97 }
  98
  99 static Eina_Bool
 100 _e_gesture_process_device_del(void *event)
 101 {
 102    Ecore_Event_Device_Info *ev = event;
 103    Eina_List *l, *l_next;
 104    char *data;
 105
 106    if (ev->clas == ECORE_DEVICE_CLASS_TOUCH)
 107      {
 108         EINA_LIST_FOREACH_SAFE(gesture->touch_devices, l, l_next, data)
 109           {
 110              if (!strncmp(data, ev->identifier, strlen(ev->identifier)))
 111                {
 112                   GTINF("%s(%s) device is touch device: remove list\n", ev->name, ev->identifier);
 113                   gesture->touch_devices = eina_list_remove(gesture->touch_devices, data);
 114                   E_FREE(data);
 115                }
 116           }
 117      }
 118    return EINA_TRUE;
 119 }
 120
 121 static Eina_Bool
 122 _e_gesture_timer_swipe_start(void *data)
 123 {
 124    E_Gesture_Event_Swipe *swipes = &gesture->gesture_events.swipes;
 125    int idx = gesture->gesture_events.num_pressed;
 126    int i;
 127
 128    GTDBG("Swipe start timer is expired. Currently alived swipe fingers: 0x%x\n", swipes->enabled_finger);
 129
 130    for (i = E_GESTURE_FINGER_MAX; i > idx; i--)
 131      {
 132         swipes->enabled_finger &= ~(1 << i);
 133      }
 134    if ((swipes->direction == E_GESTURE_DIRECTION_DOWN && !swipes->fingers[idx].direction[E_GESTURE_DIRECTION_DOWN].client) ||
 135        (swipes->direction == E_GESTURE_DIRECTION_LEFT && !swipes->fingers[idx].direction[E_GESTURE_DIRECTION_LEFT].client) ||
 136        (swipes->direction == E_GESTURE_DIRECTION_UP && !swipes->fingers[idx].direction[E_GESTURE_DIRECTION_UP].client) ||
 137        (swipes->direction == E_GESTURE_DIRECTION_RIGHT && !swipes->fingers[idx].direction[E_GESTURE_DIRECTION_RIGHT].client))
 138      {
 139         _e_gesture_swipe_cancel();
 140      }
 141    return ECORE_CALLBACK_CANCEL;
 142 }
 143
 144 static Eina_Bool
 145 _e_gesture_timer_swipe_done(void *data)
 146 {
 147    E_Gesture_Event_Swipe *swipes = &gesture->gesture_events.swipes;
 148
 149    GTDBG("Swipe done timer is expired. Currently alived swipe fingers: 0x%x\n", swipes->enabled_finger);
 150
 151    _e_gesture_swipe_cancel();
 152
 153    return ECORE_CALLBACK_CANCEL;
 154 }
 155
 156 static void
 157 _e_gesture_process_swipe_down(Ecore_Event_Mouse_Button *ev)
 158 {
 159    E_Gesture_Event_Swipe *swipes = &gesture->gesture_events.swipes;
 160    int i;
 161    unsigned int idx = ev->multi.device+1;
 162
 163    if (gesture->gesture_events.num_pressed == 1)
 164      {
 165         for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++)
 166           {
 167              if (swipes->fingers[i].enabled)
 168                {
 169                   swipes->enabled_finger |= (1 << i);
 170                }
 171           }
 172
 173         if (ev->y < E_GESTURE_SWIPE_START_AREA)
 174           swipes->direction = E_GESTURE_DIRECTION_DOWN;
 175         else if (ev->y > e_comp->h - E_GESTURE_SWIPE_START_AREA)
 176           swipes->direction = E_GESTURE_DIRECTION_UP;
 177         else if (ev->x < E_GESTURE_SWIPE_START_AREA)
 178           swipes->direction = E_GESTURE_DIRECTION_RIGHT;
 179         else if (ev->x > e_comp->w - E_GESTURE_SWIPE_START_AREA)
 180           swipes->direction = E_GESTURE_DIRECTION_LEFT;
 181
 182         if (swipes->direction != E_GESTURE_DIRECTION_DOWN &&
 183        !((swipes->combined_keycode == E_GESTURE_SWIPE_COMBINE_KEY) && swipes->direction == E_GESTURE_DIRECTION_RIGHT))
 184           {
 185              _e_gesture_swipe_cancel();
 186           }
 187         else
 188           {
 189              swipes->fingers[idx].start.x = ev->x;
 190              swipes->fingers[idx].start.y = ev->y;
 191              swipes->start_timer = ecore_timer_add(E_GESTURE_SWIPE_START_TIME, _e_gesture_timer_swipe_start, NULL);
 192              swipes->done_timer = ecore_timer_add(E_GESTURE_SWIPE_DONE_TIME, _e_gesture_timer_swipe_done, NULL);
 193           }
 194      }
 195    else
 196      {
 197         swipes->enabled_finger &= ~(1 << (gesture->gesture_events.num_pressed - 1));
 198         if (swipes->start_timer == NULL)
 199           {
 200              _e_gesture_swipe_cancel();
 201           }
 202      }
 203 }
 204
 205 static void
 206 _e_gesture_process_swipe_move(Ecore_Event_Mouse_Move *ev)
 207 {
 208    E_Gesture_Event_Swipe *swipes = &gesture->gesture_events.swipes;
 209    Coords diff;
 210    unsigned int idx = ev->multi.device+1;
 211
 212    if (!(swipes->enabled_finger & (1 << idx)))
 213      return;
 214
 215    diff.x = ABS(swipes->fingers[idx].start.x - ev->x);
 216    diff.y = ABS(swipes->fingers[idx].start.y - ev->y);
 217
 218    switch(swipes->direction)
 219      {
 220         case E_GESTURE_DIRECTION_DOWN:
 221            if (diff.x > E_GESTURE_SWIPE_DIFF_FAIL)
 222              {
 223                 _e_gesture_swipe_cancel();
 224                 break;
 225              }
 226            if (diff.y > E_GESTURE_SWIPE_DIFF_SUCCESS)
 227              {
 228                 _e_gesture_send_swipe(idx, swipes->fingers[idx].start.x, swipes->fingers[idx].start.y, swipes->direction, swipes->fingers[idx].direction[E_GESTURE_DIRECTION_DOWN].client, swipes->fingers[idx].direction[E_GESTURE_DIRECTION_DOWN].res);
 229              }
 230            break;
 231         case E_GESTURE_DIRECTION_LEFT:
 232            if (diff.y > E_GESTURE_SWIPE_DIFF_FAIL)
 233              {
 234                 _e_gesture_swipe_cancel();
 235                 break;
 236              }
 237            if (diff.x > E_GESTURE_SWIPE_DIFF_SUCCESS)
 238              {
 239                 _e_gesture_send_swipe(idx, swipes->fingers[idx].start.x, swipes->fingers[idx].start.y, swipes->direction, swipes->fingers[idx].direction[E_GESTURE_DIRECTION_LEFT].client, swipes->fingers[idx].direction[E_GESTURE_DIRECTION_LEFT].res);
 240              }
 241            break;
 242         case E_GESTURE_DIRECTION_UP:
 243            if (diff.x > E_GESTURE_SWIPE_DIFF_FAIL)
 244              {
 245                 _e_gesture_swipe_cancel();
 246                 break;
 247              }
 248            if (diff.y > E_GESTURE_SWIPE_DIFF_SUCCESS)
 249              {
 250                 _e_gesture_send_swipe(idx, swipes->fingers[idx].start.x, swipes->fingers[idx].start.y, swipes->direction, swipes->fingers[idx].direction[E_GESTURE_DIRECTION_UP].client, swipes->fingers[idx].direction[E_GESTURE_DIRECTION_UP].res);
 251              }
 252            break;
 253         case E_GESTURE_DIRECTION_RIGHT:
 254            if (diff.y > E_GESTURE_SWIPE_DIFF_FAIL)
 255              {
 256                 _e_gesture_swipe_cancel();
 257                 break;
 258              }
 259            if (diff.x > E_GESTURE_SWIPE_DIFF_SUCCESS)
 260              {
 261                 _e_gesture_send_swipe(idx, swipes->fingers[idx].start.x, swipes->fingers[idx].start.y, swipes->direction, swipes->fingers[idx].direction[E_GESTURE_DIRECTION_RIGHT].client, swipes->fingers[idx].direction[E_GESTURE_DIRECTION_RIGHT].res);
 262              }
 263            break;
 264         default:
 265            GTWRN("Invalid direction(%d)\n", swipes->direction);
 266            break;
 267      }
 268 }
 269
 270 static void
 271 _e_gesture_process_swipe_up(Ecore_Event_Mouse_Button *ev)
 272 {
 273    _e_gesture_swipe_cancel();
 274 }
 275
 276 static Eina_Bool
 277 _e_gesture_process_mouse_button_down(void *event)
 278 {
 279    Ecore_Event_Mouse_Button *ev = event;
 280
 281    gesture->gesture_events.num_pressed++;
 282
 283    if (!gesture->grabbed_gesture)
 284      {
 285         return EINA_TRUE;
 286      }
 287    if (_e_gesture_is_touch_device(ev->dev) == EINA_FALSE)
 288      {
 289         return EINA_TRUE;
 290      }
 291    if (ev->multi.device > E_GESTURE_FINGER_MAX)
 292      {
 293         return EINA_TRUE;
 294      }
 295
 296    if (gesture->gesture_events.num_pressed == 1)
 297      {
 298         gesture->gesture_events.recognized_gesture = 0x0;
 299      }
 300
 301    if (gesture->gesture_events.recognized_gesture)
 302      {
 303         return EINA_FALSE;
 304      }
 305
 306    if (gesture->gesture_events.num_pressed == 1)
 307      {
 308         gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture;
 309      }
 310
 311    if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_SWIPE))
 312      {
 313         _e_gesture_process_swipe_down(ev);
 314      }
 315
 316    return EINA_TRUE;
 317 }
 318
 319 static Eina_Bool
 320 _e_gesture_process_mouse_button_up(void *event)
 321 {
 322    Ecore_Event_Mouse_Button *ev = event;
 323
 324    gesture->gesture_events.num_pressed--;
 325
 326    if (!gesture->grabbed_gesture)
 327      {
 328         return EINA_TRUE;
 329      }
 330    if (_e_gesture_is_touch_device(ev->dev) == EINA_FALSE)
 331      {
 332         return EINA_TRUE;
 333      }
 334
 335    if (gesture->gesture_events.recognized_gesture)
 336      {
 337         return EINA_FALSE;
 338      }
 339
 340    if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_SWIPE))
 341      {
 342         _e_gesture_process_swipe_up(ev);
 343      }
 344
 345    return EINA_TRUE;
 346 }
 347
 348
 349 static Eina_Bool
 350 _e_gesture_process_mouse_move(void *event)
 351 {
 352    Ecore_Event_Mouse_Move *ev = event;
 353
 354    if (!gesture->grabbed_gesture)
 355      {
 356         return EINA_TRUE;
 357      }
 358    if (_e_gesture_is_touch_device(ev->dev) == EINA_FALSE)
 359      {
 360         return EINA_TRUE;
 361      }
 362
 363    if (gesture->gesture_events.recognized_gesture)
 364      {
 365         return EINA_FALSE;
 366      }
 367
 368    if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_SWIPE))
 369      {
 370         _e_gesture_process_swipe_move(ev);
 371      }
 372
 373    return EINA_TRUE;
 374 }
 375
 376 static Eina_Bool
 377 _e_gesture_process_key_down(void *event)
 378 {
 379    Ecore_Event_Key *ev = event;
 380
 381    if (ev->keycode == E_GESTURE_SWIPE_COMBINE_KEY)
 382      {
 383         gesture->gesture_events.swipes.combined_keycode = E_GESTURE_SWIPE_COMBINE_KEY;
 384      }
 385
 386    return EINA_TRUE;
 387 }
 388
 389 static Eina_Bool
 390 _e_gesture_process_key_up(void *event)
 391 {
 392    Ecore_Event_Key *ev = event;
 393
 394    if (ev->keycode == E_GESTURE_SWIPE_COMBINE_KEY)
 395      {
 396         gesture->gesture_events.swipes.combined_keycode = 0;
 397      }
 398
 399    return EINA_TRUE;
 400 }
 401
 402 /* Function for checking the existing grab for a key and sending key event(s) */
 403 Eina_Bool
 404 e_gesture_process_events(void *event, int type)
 405 {
 406    Eina_Bool res = EINA_TRUE;
 407
 408    if (type == ECORE_EVENT_MOUSE_BUTTON_DOWN)
 409      res = _e_gesture_process_mouse_button_down(event);
 410    else if (type == ECORE_EVENT_MOUSE_BUTTON_UP)
 411      res = _e_gesture_process_mouse_button_up(event);
 412    else if (type == ECORE_EVENT_MOUSE_MOVE)
 413      res = _e_gesture_process_mouse_move(event);
 414    else if (type == ECORE_EVENT_KEY_DOWN)
 415      res = _e_gesture_process_key_down(event);
 416    else if (type == ECORE_EVENT_KEY_UP)
 417      res = _e_gesture_process_key_up(event);
 418    else if (type == ECORE_EVENT_DEVICE_ADD)
 419      res = _e_gesture_process_device_add(event);
 420    else if (type == ECORE_EVENT_DEVICE_DEL)
 421      res = _e_gesture_process_device_del(event);
 422
 423    return res;
 424 }