src/e_mod_gesture_events.c

   1 #define E_COMP_WL
   2 #include "e_mod_main.h"
   3 #include <string.h>
   4
   5 #ifdef _E_GESTURE_DEBUG_
   6 static char *
   7 _e_gesture_event_type_print(int type)
   8 {
   9    if (type == ECORE_EVENT_KEY_DOWN) return "KeyDown";
  10    else if (type == ECORE_EVENT_KEY_UP) return "KeyUp";
  11    else if (type == ECORE_EVENT_MOUSE_BUTTON_DOWN) return "MouseDown";
  12    else if (type == ECORE_EVENT_MOUSE_BUTTON_UP) return "MouseUp";
  13    else if (type == ECORE_EVENT_MOUSE_MOVE) return "MouseMove";
  14    else return "Unknown";
  15 }
  16
  17 static void
  18 _e_gesture_event_print(void)
  19 {
  20    Eina_List *l;
  21    E_Gesture_Event_Info *data;
  22    int c = 0;
  23
  24    EINA_LIST_FOREACH(gesture->event_queue, l, data)
  25      {
  26         GTERR("[%d]%s event is queue\n", ++c, _e_gesture_event_type_print(data->type));
  27      }
  28 }
  29 #endif //_E_GESTURE_DEBUG_
  30
  31 static void _e_gesture_send_edge_drag(int fingers, int x, int y, int edge, int mode);
  32
  33 static void
  34 _e_gesture_event_queue(int type, void *event)
  35 {
  36    E_Gesture_Event_Info *e_info = NULL;
  37    e_info = E_NEW(E_Gesture_Event_Info, 1);
  38    EINA_SAFETY_ON_NULL_RETURN(e_info);
  39
  40    if (type == ECORE_EVENT_KEY_DOWN ||
  41        type == ECORE_EVENT_KEY_UP)
  42      {
  43         e_info->event = E_NEW(Ecore_Event_Key, 1);
  44         e_info->type = type;
  45         if (e_info->event)
  46           memcpy(e_info->event, event, sizeof(Ecore_Event_Key));
  47      }
  48    else if (type == ECORE_EVENT_MOUSE_BUTTON_DOWN ||
  49        type == ECORE_EVENT_MOUSE_BUTTON_UP)
  50      {
  51         e_info->event = E_NEW(Ecore_Event_Mouse_Button, 1);
  52         e_info->type = type;
  53         if (e_info->event)
  54           memcpy(e_info->event, event, sizeof(Ecore_Event_Mouse_Button));
  55      }
  56    else if (type == ECORE_EVENT_MOUSE_MOVE)
  57      {
  58         e_info->event = E_NEW(Ecore_Event_Mouse_Move, 1);
  59         e_info->type = type;
  60         if (e_info->event)
  61           memcpy(e_info->event, event, sizeof(Ecore_Event_Mouse_Move));
  62      }
  63    else goto error;
  64
  65    if (e_info->event)
  66      gesture->event_queue = eina_list_append(gesture->event_queue, e_info);
  67    else
  68      E_FREE(e_info);
  69
  70    return;
  71
  72 error:
  73    E_FREE(e_info->event);
  74    E_FREE(e_info);
  75 }
  76
  77 static void
  78 _e_gesture_event_flush(void)
  79 {
  80    Eina_List *l, *l_next;
  81    E_Gesture_Event_Info *data;
  82
  83    if (gesture->event_state == E_GESTURE_EVENT_STATE_IGNORE ||
  84       gesture->gesture_events.recognized_gesture) return;
  85    if (gesture->gesture_filter != E_GESTURE_TYPE_ALL) return;
  86
  87    gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE;
  88
  89    EINA_LIST_FOREACH_SAFE(gesture->event_queue, l, l_next, data)
  90      {
  91         if (data->type == ECORE_EVENT_MOUSE_BUTTON_DOWN)
  92           {
  93              if (!e_devicemgr_is_blocking_event(ECORE_DEVICE_CLASS_TOUCH))
  94                ecore_event_evas_mouse_button_down(NULL, ECORE_EVENT_MOUSE_BUTTON_DOWN, data->event);
  95           }
  96         else if (data->type == ECORE_EVENT_MOUSE_BUTTON_UP)
  97           {
  98              if (!e_devicemgr_is_blocking_event(ECORE_DEVICE_CLASS_TOUCH))
  99                ecore_event_evas_mouse_button_up(NULL, ECORE_EVENT_MOUSE_BUTTON_UP, data->event);
 100           }
 101         else if (data->type == ECORE_EVENT_MOUSE_MOVE)
 102           {
 103              if (!e_devicemgr_is_blocking_event(ECORE_DEVICE_CLASS_TOUCH))
 104                ecore_event_evas_mouse_move(NULL, ECORE_EVENT_MOUSE_MOVE, data->event);
 105           }
 106         else if (data->type == ECORE_EVENT_KEY_DOWN)
 107           {
 108              if (!e_devicemgr_is_blocking_event(ECORE_DEVICE_CLASS_KEYBOARD))
 109                ecore_event_evas_key_down(NULL, ECORE_EVENT_KEY_DOWN, data->event);
 110           }
 111         else if (data->type == ECORE_EVENT_KEY_UP)
 112           {
 113              if (!e_devicemgr_is_blocking_event(ECORE_DEVICE_CLASS_KEYBOARD))
 114                ecore_event_evas_key_up(NULL, ECORE_EVENT_KEY_UP, data->event);
 115           }
 116         E_FREE(data->event);
 117         E_FREE(data);
 118         gesture->event_queue = eina_list_remove_list(gesture->event_queue, l);
 119      }
 120 }
 121
 122 static void
 123 _e_gesture_event_drop(void)
 124 {
 125    Eina_List *l, *l_next;
 126    E_Gesture_Event_Info *data;
 127
 128    gesture->event_state = E_GESTURE_EVENT_STATE_IGNORE;
 129
 130    EINA_LIST_FOREACH_SAFE(gesture->event_queue, l, l_next, data)
 131      {
 132         E_FREE(data->event);
 133         E_FREE(data);
 134         gesture->event_queue = eina_list_remove_list(gesture->event_queue, l);
 135      }
 136 }
 137
 138 static void
 139 _e_gesture_util_center_axis_get(int num_finger, int *x, int *y)
 140 {
 141    int i;
 142    int calc_x = 0, calc_y = 0;
 143
 144    if (num_finger <= 0)
 145      {
 146         *x = 0;
 147         *y = 0;
 148         return;
 149      }
 150
 151    for (i = 1; i <= num_finger; i++)
 152      {
 153         calc_x += gesture->gesture_events.base_point[i].axis.x;
 154         calc_y += gesture->gesture_events.base_point[i].axis.y;
 155      }
 156
 157    calc_x = (int)(calc_x / num_finger);
 158    calc_y = (int)(calc_y / num_finger);
 159
 160    *x = calc_x;
 161    *y = calc_y;
 162 }
 163
 164 static double
 165 _e_gesture_util_distance_get(int x1, int y1, int x2, int y2)
 166 {
 167    double distance;
 168
 169    distance = sqrt(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
 170
 171    return distance;
 172 }
 173
 174 static double
 175 _e_gesture_util_distances_get(int num_finger)
 176 {
 177    int i, cx = 0, cy = 0;
 178    double distance = 0.0;
 179
 180    _e_gesture_util_center_axis_get(num_finger, &cx, &cy);
 181
 182    for (i = 1; i <= num_finger; i++)
 183      {
 184         distance +=  _e_gesture_util_distance_get(cx, cy,
 185                        gesture->gesture_events.base_point[i].axis.x,
 186                        gesture->gesture_events.base_point[i].axis.y);
 187      }
 188
 189    return distance;
 190 }
 191
 192 static double
 193 _e_gesture_util_angle_get(int x1, int y1, int x2, int y2)
 194 {
 195    double angle, xx, yy;
 196
 197    xx = fabs(x2 - x1);
 198    yy = fabs(y2 - y1);
 199
 200    angle = atan2(yy, xx);
 201    if ((x1 > x2) && (y1 > y2)) angle = angle + M_PI_2;
 202    else if ((x2 > x1) && (y2 > y1)) angle = angle + M_PI_2;
 203
 204    angle = RAD2DEG(angle);
 205    return angle;
 206 }
 207
 208 static void
 209 _e_gesture_util_rect_get(int finger, int *x1, int *y1, int *x2, int *y2)
 210 {
 211    int i;
 212
 213    *x1 = *x2 = gesture->gesture_events.base_point[1].axis.x;
 214    *y1 = *y2 = gesture->gesture_events.base_point[1].axis.y;
 215
 216    for (i = 2; i < finger + 1; i++)
 217      {
 218         if (gesture->gesture_events.base_point[i].axis.x < *x1)
 219           *x1 = gesture->gesture_events.base_point[i].axis.x;
 220         else if (gesture->gesture_events.base_point[i].axis.x > *x2)
 221           *x2 = gesture->gesture_events.base_point[i].axis.x;
 222
 223         if (gesture->gesture_events.base_point[i].axis.y < *y1)
 224           *y1 = gesture->gesture_events.base_point[i].axis.y;
 225         else if (gesture->gesture_events.base_point[i].axis.y > *y2)
 226           *y2 = gesture->gesture_events.base_point[i].axis.y;
 227      }
 228 }
 229
 230 static void
 231 _e_gesture_util_rect_center_axis_get(Rect rect, int *cx, int *cy)
 232 {
 233    *cx = (int)((rect.x1 + rect.x2) / 2);
 234    *cy = (int)((rect.y1 + rect.y2) / 2);
 235 }
 236
 237 static struct wl_resource *
 238 _e_gesture_util_eclient_surface_get(E_Client *ec)
 239 {
 240    if (!ec) return NULL;
 241    if (e_object_is_del(E_OBJECT(ec))) return NULL;
 242    if (!ec->comp_data) return NULL;
 243
 244    return ec->comp_data->surface;
 245 }
 246
 247 static void
 248 _e_gesture_edge_swipe_cancel(void)
 249 {
 250    E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes;
 251
 252    if (edge_swipes->start_timer)
 253      {
 254         ecore_timer_del(edge_swipes->start_timer);
 255         edge_swipes->start_timer = NULL;
 256      }
 257    if (edge_swipes->done_timer)
 258      {
 259         ecore_timer_del(edge_swipes->done_timer);
 260         edge_swipes->done_timer = NULL;
 261      }
 262
 263    edge_swipes->base.enabled_finger = 0x0;
 264    edge_swipes->base.edge = E_GESTURE_EDGE_NONE;
 265
 266    gesture->gesture_filter |= E_GESTURE_TYPE_EDGE_SWIPE;
 267    gesture->gesture_events.recognized_gesture &= ~E_GESTURE_TYPE_EDGE_SWIPE;
 268 }
 269
 270 static void
 271 _e_gesture_keyevent_free(void *data EINA_UNUSED, void *ev)
 272 {
 273    Ecore_Event_Key *e = ev;
 274
 275    eina_stringshare_del(e->keyname);
 276    eina_stringshare_del(e->key);
 277    eina_stringshare_del(e->compose);
 278
 279    if (e->dev) ecore_device_unref(e->dev);
 280
 281    E_FREE(e);
 282 }
 283
 284 /* Optional: This function is currently used to generate back key.
 285  *           But how about change this function to generate every key?
 286  *           _e_gesture_send_key(char *keyname, Eina_Bool pressed)
 287  */
 288 static void
 289 _e_gesture_send_back_key(Eina_Bool pressed)
 290 {
 291    Ecore_Event_Key *ev;
 292    E_Gesture_Conf_Edd *conf = gesture->config->conf;
 293    E_Keyrouter_Event_Data *key_data;
 294
 295    ev = E_NEW(Ecore_Event_Key, 1);
 296    EINA_SAFETY_ON_NULL_RETURN(ev);
 297    key_data = E_NEW(E_Keyrouter_Event_Data, 1);
 298    EINA_SAFETY_ON_NULL_GOTO(key_data, failed);
 299
 300    ev->key = (char *)eina_stringshare_add("XF86Back");
 301    ev->keyname = (char *)eina_stringshare_add(ev->key);
 302    ev->compose = (char *)eina_stringshare_add(ev->key);
 303    ev->timestamp = e_util_timestamp_get();
 304    ev->same_screen = 1;
 305    ev->keycode = conf->edge_swipe.back_key;
 306    ev->dev = ecore_device_ref(gesture->device.kbd_device);
 307    ev->window = e_comp->ee_win;
 308    ev->data = key_data;
 309
 310    if (!e_input_thread_mode_get())
 311      {
 312         ecore_event_add(pressed ? ECORE_EVENT_KEY_DOWN : ECORE_EVENT_KEY_UP, ev, _e_gesture_keyevent_free, NULL);
 313      }
 314    else
 315      {
 316         E_Input_Event_Source *input_event_source = e_input_event_source_get();
 317         if (input_event_source)
 318           e_input_event_add(input_event_source, pressed ? ECORE_EVENT_KEY_DOWN : ECORE_EVENT_KEY_UP, ev, _e_gesture_keyevent_free, NULL);
 319         else
 320           _e_gesture_keyevent_free(NULL, ev);
 321      }
 322
 323    return;
 324
 325 failed:
 326    E_FREE(ev);
 327 }
 328
 329 static void
 330 _e_gesture_send_touch_cancel(void)
 331 {
 332    Ecore_Event_Mouse_Button *ev_cancel;
 333
 334    ev_cancel = E_NEW(Ecore_Event_Mouse_Button, 1);
 335    EINA_SAFETY_ON_NULL_RETURN(ev_cancel);
 336
 337    ev_cancel->timestamp = e_util_timestamp_get();
 338    ev_cancel->same_screen = 1;
 339
 340    ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, ev_cancel, NULL, NULL);
 341 }
 342
 343 static void
 344 _e_gesture_send_edge_swipe(int fingers, int x, int y, int edge)
 345 {
 346    E_Gesture_Conf_Edd *conf = gesture->config->conf;
 347    Eina_List *l;
 348    E_Gesture_Event_Edge_Finger_Edge *edata;
 349    E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes;
 350    int bp = -1;
 351    E_Event_Gesture_Edge_Swipe *ev_swipe;
 352
 353    if (gesture->gesture_events.event_keep)
 354      {
 355         _e_gesture_event_drop();
 356      }
 357    else
 358      _e_gesture_send_touch_cancel();
 359
 360    if (conf->edge_swipe.default_enable_back &&
 361        edge == E_GESTURE_EDGE_TOP)
 362      {
 363         _e_gesture_send_back_key(EINA_TRUE);
 364         _e_gesture_send_back_key(EINA_FALSE);
 365         goto finish;
 366      }
 367
 368    if (edge == E_GESTURE_EDGE_TOP ||
 369        edge == E_GESTURE_EDGE_BOTTOM)
 370      {
 371         bp = x;
 372      }
 373    else if (edge == E_GESTURE_EDGE_RIGHT ||
 374        edge == E_GESTURE_EDGE_LEFT)
 375      {
 376         bp = y;
 377      }
 378
 379    EINA_LIST_FOREACH(edge_swipes->base.fingers[fingers].edge[edge], l, edata)
 380      {
 381         if (bp >= edata->sp && bp <= edata->ep)
 382           {
 383              GTINF("Send edge_swipe gesture (fingers: %d, edge: %d) to client: %p\n", fingers, edge, edata->client);
 384              if (edata->client == E_GESTURE_SERVER_CLIENT)
 385                {
 386                   ev_swipe = E_NEW(E_Event_Gesture_Edge_Swipe, 1);
 387                   EINA_SAFETY_ON_NULL_RETURN(ev_swipe);
 388
 389                   ev_swipe->mode = E_GESTURE_MODE_DONE;
 390                   ev_swipe->edge = edge;
 391                   ev_swipe->fingers = fingers;
 392                   ev_swipe->sx = x;
 393                   ev_swipe->sy = y;
 394                   ecore_event_add(E_EVENT_GESTURE_EDGE_SWIPE, ev_swipe, NULL, NULL);
 395                }
 396              else
 397                tizen_gesture_send_edge_swipe(edata->res, E_GESTURE_MODE_DONE, fingers, x, y, edge);
 398              break;
 399           }
 400      }
 401
 402 finish:
 403    _e_gesture_edge_swipe_cancel();
 404 }
 405
 406 static E_Gesture_Event_State
 407 _e_gesture_process_device_add(void *event)
 408 {
 409    return e_gesture_device_add(event);
 410 }
 411
 412 static E_Gesture_Event_State
 413 _e_gesture_process_device_del(void *event)
 414 {
 415    return e_gesture_device_del(event);
 416 }
 417
 418 static Eina_Bool
 419 _e_gesture_event_edge_check(E_Gesture_Event_Edge_Finger *fingers, int type, unsigned int edge)
 420 {
 421    E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes;
 422    E_Gesture_Conf_Edd *conf = gesture->config->conf;
 423    Eina_List *l;
 424    E_Gesture_Event_Edge_Finger_Edge *edata;
 425    Coords coords;
 426
 427    if (type == E_GESTURE_TYPE_EDGE_SWIPE)
 428      {
 429         if ((conf->edge_swipe.default_enable_back) &&
 430             (edge == E_GESTURE_EDGE_TOP ||
 431             ((edge_swipes->combined_keycode == conf->edge_swipe.compose_key) &&
 432             (edge_swipes->base.edge == E_GESTURE_EDGE_LEFT))))
 433           {
 434              return EINA_TRUE;
 435           }
 436      }
 437
 438    coords.x = fingers->start.x;
 439    coords.y = fingers->start.y;
 440
 441    EINA_LIST_FOREACH(fingers->edge[edge], l, edata)
 442      {
 443         if (edge == E_GESTURE_EDGE_TOP ||
 444             edge == E_GESTURE_EDGE_BOTTOM)
 445           {
 446              if ((coords.x >= edata->sp) &&
 447                  (coords.x <= edata->ep))
 448                {
 449                   return EINA_TRUE;
 450                }
 451           }
 452         else if ((edge == E_GESTURE_EDGE_LEFT) ||
 453                  (edge == E_GESTURE_EDGE_RIGHT))
 454           {
 455              if (coords.y >= edata->sp &&
 456                  coords.y <= edata->ep)
 457                {
 458                   return EINA_TRUE;
 459                }
 460           }
 461      }
 462
 463    return EINA_FALSE;
 464 }
 465
 466 static Eina_Bool
 467 _e_gesture_timer_edge_swipe_start(void *data)
 468 {
 469    E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes;
 470    int idx = gesture->gesture_events.num_pressed;
 471    int i;
 472
 473    GTINF("Edge_Swipe start timer is expired. Currently alived edge_swipe fingers: 0x%x\n", edge_swipes->base.enabled_finger);
 474
 475    for (i = E_GESTURE_FINGER_MAX; i > idx; i--)
 476      {
 477         edge_swipes->base.enabled_finger &= ~(1 << i);
 478      }
 479    if ((edge_swipes->base.enabled_finger == 0x0) ||
 480        (_e_gesture_event_edge_check(&edge_swipes->base.fingers[idx], E_GESTURE_TYPE_EDGE_SWIPE, edge_swipes->base.edge) == EINA_FALSE))
 481      {
 482         _e_gesture_edge_swipe_cancel();
 483         if (gesture->gesture_events.event_keep)
 484           _e_gesture_event_flush();
 485      }
 486    return ECORE_CALLBACK_CANCEL;
 487 }
 488
 489 static Eina_Bool
 490 _e_gesture_timer_edge_swipe_done(void *data)
 491 {
 492    E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes;
 493
 494    GTDBG("Edge_Swipe done timer is expired. Currently alived edge_swipe fingers: 0x%x\n", edge_swipes->base.enabled_finger);
 495
 496    _e_gesture_edge_swipe_cancel();
 497    if (gesture->gesture_events.event_keep)
 498      _e_gesture_event_flush();
 499
 500    return ECORE_CALLBACK_CANCEL;
 501 }
 502
 503 static void
 504 _e_gesture_process_edge_swipe_down(Ecore_Event_Mouse_Button *ev)
 505 {
 506    E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes;
 507    E_Gesture_Conf_Edd *conf = gesture->config->conf;
 508    int i;
 509    unsigned int idx = ev->multi.device+1;
 510
 511    if (!edge_swipes->base.activation.active)
 512      {
 513         _e_gesture_edge_swipe_cancel();
 514         return;
 515      }
 516
 517    if (gesture->gesture_events.recognized_gesture)
 518      _e_gesture_edge_swipe_cancel();
 519
 520    if (gesture->gesture_events.num_pressed == 1)
 521      {
 522         for (i = 1; i < E_GESTURE_FINGER_MAX+1; i++)
 523           {
 524              if (edge_swipes->base.fingers[i].enabled)
 525                {
 526                   edge_swipes->base.enabled_finger |= (1 << i);
 527                }
 528           }
 529
 530         if (ev->y < conf->edge_swipe.area_offset)
 531           edge_swipes->base.edge = E_GESTURE_EDGE_TOP;
 532         else if (ev->y > e_comp->h - conf->edge_swipe.area_offset)
 533           edge_swipes->base.edge = E_GESTURE_EDGE_BOTTOM;
 534         else if (ev->x < conf->edge_swipe.area_offset)
 535           edge_swipes->base.edge = E_GESTURE_EDGE_LEFT;
 536         else if (ev->x > e_comp->w - conf->edge_swipe.area_offset)
 537           edge_swipes->base.edge = E_GESTURE_EDGE_RIGHT;
 538
 539         if (!((1 << (edge_swipes->base.edge)) & edge_swipes->base.enabled_edge))
 540           edge_swipes->base.edge = E_GESTURE_EDGE_NONE;
 541
 542         if (edge_swipes->base.edge != E_GESTURE_EDGE_NONE)
 543           {
 544              edge_swipes->base.fingers[idx].start.x = ev->x;
 545              edge_swipes->base.fingers[idx].start.y = ev->y;
 546              edge_swipes->start_timer = ecore_timer_add(conf->edge_swipe.time_begin, _e_gesture_timer_edge_swipe_start, NULL);
 547              edge_swipes->done_timer = ecore_timer_add(conf->edge_swipe.time_done, _e_gesture_timer_edge_swipe_done, NULL);
 548           }
 549         else
 550           {
 551              _e_gesture_edge_swipe_cancel();
 552              if (gesture->gesture_events.event_keep)
 553                _e_gesture_event_flush();
 554           }
 555      }
 556    else
 557      {
 558         edge_swipes->base.fingers[idx].start.x = ev->x;
 559         edge_swipes->base.fingers[idx].start.y = ev->y;
 560         edge_swipes->base.enabled_finger &= ~(1 << (gesture->gesture_events.num_pressed - 1));
 561         if (edge_swipes->start_timer == NULL)
 562           {
 563              _e_gesture_edge_swipe_cancel();
 564              if (gesture->gesture_events.event_keep)
 565                _e_gesture_event_flush();
 566           }
 567      }
 568 }
 569
 570 static void
 571 _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev)
 572 {
 573    E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes;
 574    E_Gesture_Conf_Edd *conf = gesture->config->conf;
 575    Coords diff;
 576    unsigned int idx = ev->multi.device+1;
 577
 578    if (!edge_swipes->base.activation.active)
 579      {
 580         _e_gesture_edge_swipe_cancel();
 581         return;
 582      }
 583
 584    if (!(edge_swipes->base.enabled_finger & (1 << idx)))
 585      return;
 586
 587    diff.x = ABS(edge_swipes->base.fingers[idx].start.x - ev->x);
 588    diff.y = ABS(edge_swipes->base.fingers[idx].start.y - ev->y);
 589
 590    switch(edge_swipes->base.edge)
 591      {
 592         case E_GESTURE_EDGE_TOP:
 593         case E_GESTURE_EDGE_BOTTOM:
 594            if (diff.x > conf->edge_swipe.min_length)
 595              {
 596                 _e_gesture_edge_swipe_cancel();
 597                 if (gesture->gesture_events.event_keep)
 598                   _e_gesture_event_flush();
 599                 break;
 600              }
 601            if (diff.y > conf->edge_swipe.max_length)
 602              {
 603                 _e_gesture_send_edge_swipe(idx, edge_swipes->base.fingers[idx].start.x, edge_swipes->base.fingers[idx].start.y, edge_swipes->base.edge);
 604              }
 605            break;
 606         case E_GESTURE_EDGE_LEFT:
 607         case E_GESTURE_EDGE_RIGHT:
 608            if (diff.y > conf->edge_swipe.min_length)
 609              {
 610                 _e_gesture_edge_swipe_cancel();
 611                 if (gesture->gesture_events.event_keep)
 612                   _e_gesture_event_flush();
 613                 break;
 614              }
 615            if (diff.x > conf->edge_swipe.max_length)
 616              {
 617                 _e_gesture_send_edge_swipe(idx, edge_swipes->base.fingers[idx].start.x, edge_swipes->base.fingers[idx].start.y, edge_swipes->base.edge);
 618              }
 619            break;
 620         default:
 621            GTWRN("Invalid edge(%d)\n", edge_swipes->base.edge);
 622            break;
 623      }
 624 }
 625
 626 static void
 627 _e_gesture_process_edge_swipe_up(Ecore_Event_Mouse_Button *ev)
 628 {
 629    E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes;
 630
 631    if (!edge_swipes->base.activation.active)
 632      {
 633         _e_gesture_edge_swipe_cancel();
 634         return;
 635      }
 636    _e_gesture_edge_swipe_cancel();
 637    if (gesture->gesture_events.event_keep)
 638      _e_gesture_event_flush();
 639 }
 640
 641 static void
 642 _e_gesture_edge_drag_cancel(void)
 643 {
 644    E_Gesture_Event_Edge_Drag *edge_drags = &gesture->gesture_events.edge_drags;
 645    Coords current_point = {0, };
 646
 647    if (gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_EDGE_DRAG)
 648      {
 649         _e_gesture_util_center_axis_get(edge_drags->idx, &current_point.x, &current_point.y);
 650         _e_gesture_send_edge_drag(edge_drags->idx, current_point.x, current_point.y, edge_drags->base.edge, E_GESTURE_MODE_END);
 651      }
 652
 653    if (edge_drags->start_timer)
 654      {
 655         ecore_timer_del(edge_drags->start_timer);
 656         edge_drags->start_timer = NULL;
 657      }
 658
 659    edge_drags->base.enabled_finger = 0x0;
 660    edge_drags->base.edge = E_GESTURE_EDGE_NONE;
 661    edge_drags->start_point.x = edge_drags->center_point.x = 0;
 662    edge_drags->start_point.y = edge_drags->center_point.y = 0;
 663    edge_drags->idx = 0;
 664
 665    gesture->gesture_filter |= E_GESTURE_TYPE_EDGE_DRAG;
 666    gesture->gesture_events.recognized_gesture &= ~E_GESTURE_TYPE_EDGE_DRAG;
 667 }
 668
 669 static void
 670 _e_gesture_send_edge_drag(int fingers, int x, int y, int edge, int mode)
 671 {
 672    Eina_List *l;
 673    E_Gesture_Event_Edge_Finger_Edge *edata;
 674    E_Gesture_Event_Edge_Drag *edge_drags = &gesture->gesture_events.edge_drags;
 675    int bp = -1;
 676    E_Event_Gesture_Edge_Drag *ev_drag;
 677
 678    if (gesture->gesture_events.event_keep)
 679      {
 680         _e_gesture_event_drop();
 681      }
 682    else
 683      _e_gesture_send_touch_cancel();
 684
 685    if (edge == E_GESTURE_EDGE_TOP ||
 686        edge == E_GESTURE_EDGE_BOTTOM)
 687      {
 688         bp = edge_drags->start_point.x;
 689      }
 690    else if (edge == E_GESTURE_EDGE_RIGHT ||
 691        edge == E_GESTURE_EDGE_LEFT)
 692      {
 693         bp = edge_drags->start_point.y;
 694      }
 695
 696    EINA_LIST_FOREACH(edge_drags->base.fingers[fingers].edge[edge], l, edata)
 697      {
 698         if (bp >= edata->sp && bp <= edata->ep)
 699           {
 700              GTINF("Send edge drag gesture (fingers: %d, edge: %d) to client: %p\n", fingers, edge, edata->client);
 701              if (edata->client == E_GESTURE_SERVER_CLIENT)
 702                {
 703                   ev_drag = E_NEW(E_Event_Gesture_Edge_Drag, 1);
 704                   EINA_SAFETY_ON_NULL_RETURN(ev_drag);
 705
 706                   ev_drag->mode = E_GESTURE_MODE_DONE;
 707                   ev_drag->edge = edge;
 708                   ev_drag->fingers = fingers;
 709                   ev_drag->cx = x;
 710                   ev_drag->cy = y;
 711                   ecore_event_add(E_EVENT_GESTURE_EDGE_DRAG, ev_drag, NULL, NULL);
 712                }
 713              else
 714              tizen_gesture_send_edge_drag(edata->res, mode, fingers, x, y, edge);
 715              break;
 716           }
 717      }
 718
 719    gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_EDGE_DRAG;
 720 }
 721
 722 static Eina_Bool
 723 _e_gesture_timer_edge_drag_start(void *data)
 724 {
 725    E_Gesture_Event_Edge_Drag *edge_drags = &gesture->gesture_events.edge_drags;
 726    int idx = gesture->gesture_events.num_pressed;
 727    int i;
 728    Coords start_point = {0, };
 729
 730    for (i = E_GESTURE_FINGER_MAX; i > idx; i--)
 731      {
 732         edge_drags->base.enabled_finger &= ~(1 << i);
 733      }
 734
 735    if ((edge_drags->base.enabled_finger == 0x0) ||
 736        (_e_gesture_event_edge_check(&edge_drags->base.fingers[idx], E_GESTURE_TYPE_EDGE_DRAG, edge_drags->base.edge) == EINA_FALSE))
 737      {
 738         _e_gesture_edge_drag_cancel();
 739         if (gesture->gesture_events.event_keep)
 740           _e_gesture_event_flush();
 741      }
 742    else
 743      {
 744         _e_gesture_util_center_axis_get(idx, &start_point.x, &start_point.y);
 745         edge_drags->start_point.x = edge_drags->center_point.x = start_point.x;
 746         edge_drags->start_point.y = edge_drags->center_point.y = start_point.y;
 747         edge_drags->idx = idx;
 748         _e_gesture_send_edge_drag(edge_drags->idx, edge_drags->center_point.x, edge_drags->center_point.y, edge_drags->base.edge, E_GESTURE_MODE_BEGIN);
 749      }
 750
 751    ecore_timer_del(edge_drags->start_timer);
 752    edge_drags->start_timer = NULL;
 753    return ECORE_CALLBACK_CANCEL;
 754 }
 755
 756 static void
 757 _e_gesture_process_edge_drag_down(Ecore_Event_Mouse_Button *ev)
 758 {
 759    E_Gesture_Event_Edge_Drag *edge_drags = &gesture->gesture_events.edge_drags;
 760    E_Gesture_Conf_Edd *conf = gesture->config->conf;
 761    int i;
 762    unsigned int idx = ev->multi.device+1;
 763
 764    if (!edge_drags->base.activation.active)
 765      {
 766         _e_gesture_edge_drag_cancel();
 767         return;
 768      }
 769
 770    if (gesture->gesture_events.recognized_gesture)
 771      _e_gesture_edge_drag_cancel();
 772
 773    if (gesture->gesture_events.num_pressed == 1)
 774      {
 775         for (i = 1; i < E_GESTURE_FINGER_MAX+1; i++)
 776           {
 777              if (edge_drags->base.fingers[i].enabled)
 778                {
 779                   edge_drags->base.enabled_finger |= (1 << i);
 780                }
 781           }
 782
 783         if (ev->y < conf->edge_drag.area_offset)
 784           edge_drags->base.edge = E_GESTURE_EDGE_TOP;
 785         else if (ev->y > e_comp->h - conf->edge_drag.area_offset)
 786           edge_drags->base.edge = E_GESTURE_EDGE_BOTTOM;
 787         else if (ev->x < conf->edge_drag.area_offset)
 788           edge_drags->base.edge = E_GESTURE_EDGE_LEFT;
 789         else if (ev->x > e_comp->w - conf->edge_drag.area_offset)
 790           edge_drags->base.edge = E_GESTURE_EDGE_RIGHT;
 791
 792         if (!((1 << (edge_drags->base.edge)) & edge_drags->base.enabled_edge))
 793           edge_drags->base.edge = E_GESTURE_EDGE_NONE;
 794
 795         if (edge_drags->base.edge != E_GESTURE_EDGE_NONE)
 796           {
 797              edge_drags->base.fingers[idx].start.x = ev->x;
 798              edge_drags->base.fingers[idx].start.y = ev->y;
 799              edge_drags->start_timer = ecore_timer_add(conf->edge_drag.time_begin, _e_gesture_timer_edge_drag_start, NULL);
 800           }
 801         else
 802           {
 803              _e_gesture_edge_drag_cancel();
 804              if (gesture->gesture_events.event_keep)
 805                _e_gesture_event_flush();
 806           }
 807      }
 808    else
 809      {
 810         edge_drags->base.fingers[idx].start.x = ev->x;
 811         edge_drags->base.fingers[idx].start.y = ev->y;
 812         edge_drags->base.enabled_finger &= ~(1 << (gesture->gesture_events.num_pressed - 1));
 813         if (edge_drags->start_timer == NULL)
 814           {
 815              _e_gesture_edge_drag_cancel();
 816              if (gesture->gesture_events.event_keep)
 817                _e_gesture_event_flush();
 818           }
 819      }
 820 }
 821
 822 static void
 823 _e_gesture_process_edge_drag_move(Ecore_Event_Mouse_Move *ev)
 824 {
 825    E_Gesture_Event_Edge_Drag *edge_drags = &gesture->gesture_events.edge_drags;
 826    E_Gesture_Conf_Edd *conf = gesture->config->conf;
 827    double distance;
 828    Coords current_point = {0, };
 829    unsigned int idx = ev->multi.device+1;
 830
 831    if (!edge_drags->base.activation.active)
 832      {
 833         _e_gesture_edge_drag_cancel();
 834         return;
 835      }
 836
 837    if (!(edge_drags->base.enabled_finger & (1 << idx)))
 838      return;
 839
 840    if (edge_drags->start_timer) return;
 841
 842    _e_gesture_util_center_axis_get(gesture->gesture_events.num_pressed, &current_point.x, &current_point.y);
 843    distance = _e_gesture_util_distance_get(edge_drags->center_point.x, edge_drags->center_point.y, current_point.x, current_point.y);
 844    if (distance < (double)conf->edge_drag.diff_length)
 845      {
 846         return;
 847      }
 848
 849    edge_drags->center_point.x = current_point.x;
 850    edge_drags->center_point.y = current_point.y;
 851
 852    _e_gesture_send_edge_drag(edge_drags->idx,
 853       edge_drags->center_point.x, edge_drags->center_point.y,
 854       edge_drags->base.edge, E_GESTURE_MODE_UPDATE);
 855 }
 856
 857 static void
 858 _e_gesture_process_edge_drag_up(Ecore_Event_Mouse_Button *ev)
 859 {
 860    E_Gesture_Event_Edge_Drag *edge_drags = &gesture->gesture_events.edge_drags;
 861
 862    if (!edge_drags->base.activation.active)
 863      {
 864         _e_gesture_edge_drag_cancel();
 865         return;
 866      }
 867    _e_gesture_edge_drag_cancel();
 868    if (gesture->gesture_events.event_keep)
 869      _e_gesture_event_flush();
 870 }
 871
 872
 873 static void
 874 _e_gesture_pan_send(int mode, int fingers, int cx, int cy, struct wl_resource *res, struct wl_client *client)
 875 {
 876    E_Event_Gesture_Pan *ev_pan;
 877
 878    if (mode == E_GESTURE_MODE_BEGIN)
 879      {
 880         _e_gesture_send_touch_cancel();
 881      }
 882
 883    GTINF("Send pan gesture %d fingers. (%d, %d) to client: %p, mode: %d\n", fingers, cx, cy, client, mode);
 884    if (client == E_GESTURE_SERVER_CLIENT)
 885      {
 886         ev_pan = E_NEW(E_Event_Gesture_Pan, 1);
 887         EINA_SAFETY_ON_NULL_RETURN(ev_pan);
 888
 889         ev_pan->mode = mode;
 890         ev_pan->fingers = fingers;
 891         ev_pan->cx = cx;
 892         ev_pan->cy = cy;
 893
 894         ecore_event_add(E_EVENT_GESTURE_PAN, ev_pan, NULL, NULL);
 895      }
 896
 897    gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_PAN;
 898 }
 899
 900 static void
 901 _e_gesture_pan_cancel(void)
 902 {
 903    E_Gesture_Event_Pan *pans = &gesture->gesture_events.pans;
 904    Coords cur_point = {0,};
 905
 906    if (pans->start_timer)
 907      {
 908         ecore_timer_del(pans->start_timer);
 909         pans->start_timer = NULL;
 910      }
 911    if (pans->move_timer)
 912      {
 913         ecore_timer_del(pans->move_timer);
 914         pans->move_timer = NULL;
 915      }
 916
 917    if (pans->state == E_GESTURE_PANPINCH_STATE_MOVING)
 918      {
 919         _e_gesture_util_center_axis_get(pans->num_pan_fingers, &cur_point.x, &cur_point.y);
 920         _e_gesture_pan_send(E_GESTURE_MODE_END, pans->num_pan_fingers, cur_point.x, cur_point.y,
 921                             pans->fingers[pans->num_pan_fingers].res,
 922                             pans->fingers[pans->num_pan_fingers].client);
 923      }
 924
 925    gesture->gesture_filter |= E_GESTURE_TYPE_PAN;
 926    pans->state = E_GESTURE_PANPINCH_STATE_DONE;
 927 }
 928
 929 static Eina_Bool
 930 _e_gesture_timer_pan_start(void *data)
 931 {
 932    E_Gesture_Event_Pan *pans = &gesture->gesture_events.pans;
 933    int num_pressed = gesture->gesture_events.num_pressed;
 934    int i;
 935
 936    if (pans->fingers[num_pressed].client)
 937      {
 938         for (i = 1; i <= num_pressed; i++)
 939           {
 940              pans->start_point.x += gesture->gesture_events.base_point[i].axis.x;
 941              pans->start_point.y += gesture->gesture_events.base_point[i].axis.y;
 942           }
 943         pans->center_point.x = pans->start_point.x = (int)(pans->start_point.x / num_pressed);
 944         pans->center_point.y = pans->start_point.y = (int)(pans->start_point.y / num_pressed);
 945         pans->state = E_GESTURE_PANPINCH_STATE_START;
 946      }
 947    else
 948      {
 949         _e_gesture_pan_cancel();
 950      }
 951    return ECORE_CALLBACK_CANCEL;
 952 }
 953
 954 static void
 955 _e_gesture_process_pan_down(Ecore_Event_Mouse_Button *ev)
 956 {
 957    E_Gesture_Event_Pan *pans = &gesture->gesture_events.pans;
 958
 959    if (!pans->activation.active)
 960      {
 961         _e_gesture_pan_cancel();
 962         return;
 963      }
 964
 965    if (gesture->gesture_events.recognized_gesture &&
 966        !((gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PAN) ||
 967        (gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PINCH)))
 968      _e_gesture_pan_cancel();
 969
 970    if (gesture->gesture_events.num_pressed == 1)
 971      {
 972         pans->state = E_GESTURE_PANPINCH_STATE_READY;
 973         if (pans->start_timer) ecore_timer_del(pans->start_timer);
 974         pans->start_timer = ecore_timer_add(E_GESTURE_PAN_START_TIME, _e_gesture_timer_pan_start, NULL);
 975      }
 976 }
 977
 978 static void
 979 _e_gesture_process_pan_move(Ecore_Event_Mouse_Move *ev)
 980 {
 981    E_Gesture_Event_Pan *pans = &gesture->gesture_events.pans;
 982    Coords cur_point = {0,};
 983    int idx, diff_x, diff_y, mode;
 984
 985    if (!pans->activation.active)
 986      {
 987         _e_gesture_pan_cancel();
 988         return;
 989      }
 990
 991    if (gesture->gesture_events.recognized_gesture &&
 992        !((gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PAN) ||
 993        (gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PINCH)))
 994      _e_gesture_pan_cancel();
 995
 996    idx = gesture->gesture_events.num_pressed;
 997    if (idx <= 0) return;
 998    if (pans->state == E_GESTURE_PANPINCH_STATE_READY) return;
 999
1000    _e_gesture_util_center_axis_get(gesture->gesture_events.num_pressed, &cur_point.x, &cur_point.y);
1001
1002    diff_x = cur_point.x - pans->center_point.x;
1003    diff_y = cur_point.y - pans->center_point.y;
1004
1005    if ((ABS(diff_x) > E_GESTURE_PAN_MOVING_RANGE) || (ABS(diff_y) > E_GESTURE_PAN_MOVING_RANGE))
1006      {
1007         switch (pans->state)
1008           {
1009              case E_GESTURE_PANPINCH_STATE_START:
1010                 mode = E_GESTURE_MODE_BEGIN;
1011                 pans->state = E_GESTURE_PANPINCH_STATE_MOVING;
1012                 pans->num_pan_fingers = idx;
1013                 break;
1014              case E_GESTURE_PANPINCH_STATE_MOVING:
1015                 mode = E_GESTURE_MODE_UPDATE;
1016                 break;
1017              default:
1018                 return;
1019           }
1020
1021         if (ABS(diff_x) > E_GESTURE_PAN_MOVING_RANGE) pans->center_point.x = cur_point.x;
1022         if (ABS(diff_y) > E_GESTURE_PAN_MOVING_RANGE) pans->center_point.y = cur_point.y;
1023
1024         _e_gesture_pan_send(mode, idx, cur_point.x, cur_point.y, pans->fingers[idx].res, pans->fingers[idx].client);
1025
1026         if (mode == E_GESTURE_MODE_BEGIN)
1027           mode = E_GESTURE_MODE_UPDATE;
1028      }
1029 }
1030
1031 static void
1032 _e_gesture_process_pan_up(Ecore_Event_Mouse_Button *ev)
1033 {
1034    //E_Gesture_Event_Pan *pans = &gesture->gesture_events.pans;
1035
1036    _e_gesture_pan_cancel();
1037 }
1038
1039 static void
1040 _e_gesture_pinch_send(int mode, int fingers, double distance, double angle, int cx, int cy, struct wl_resource *res, struct wl_client *client)
1041 {
1042    E_Event_Gesture_Pinch *ev_pinch;
1043
1044    if (mode == E_GESTURE_MODE_BEGIN)
1045      {
1046         _e_gesture_send_touch_cancel();
1047      }
1048
1049    GTINF("Send pinch gesture (fingers: %d, distance: %lf, angle: %lf, cx: %d, cy: %d) to client: %p, mode: %d\n", fingers, distance, angle, cx, cy, client, mode);
1050    if (client == E_GESTURE_SERVER_CLIENT)
1051      {
1052         ev_pinch = E_NEW(E_Event_Gesture_Pinch, 1);
1053         EINA_SAFETY_ON_NULL_RETURN(ev_pinch);
1054
1055         ev_pinch->mode = mode;
1056         ev_pinch->fingers = fingers;
1057         ev_pinch->distance = distance;
1058         ev_pinch->angle = angle;
1059         ev_pinch->cx = cx;
1060         ev_pinch->cy = cy;
1061
1062         ecore_event_add(E_EVENT_GESTURE_PINCH, ev_pinch, NULL, NULL);
1063      }
1064
1065    gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_PINCH;
1066 }
1067
1068 static void
1069 _e_gesture_pinch_cancel(void)
1070 {
1071    E_Gesture_Event_Pinch *pinchs = &gesture->gesture_events.pinchs;
1072
1073    if (pinchs->start_timer)
1074      {
1075         ecore_timer_del(pinchs->start_timer);
1076         pinchs->start_timer = NULL;
1077      }
1078    if (pinchs->move_timer)
1079      {
1080         ecore_timer_del(pinchs->move_timer);
1081         pinchs->move_timer = NULL;
1082      }
1083
1084    if (pinchs->state == E_GESTURE_PANPINCH_STATE_MOVING)
1085      _e_gesture_pinch_send(E_GESTURE_MODE_END, pinchs->num_pinch_fingers, 0.0, 0.0, 0, 0,
1086                            pinchs->fingers[pinchs->num_pinch_fingers].res,
1087                            pinchs->fingers[pinchs->num_pinch_fingers].client);
1088
1089    gesture->gesture_filter |= E_GESTURE_TYPE_PINCH;
1090    pinchs->state = E_GESTURE_PANPINCH_STATE_DONE;
1091 }
1092
1093 static Eina_Bool
1094 _e_gesture_timer_pinch_start(void *data)
1095 {
1096    E_Gesture_Event_Pinch *pinch = &gesture->gesture_events.pinchs;
1097    int num_pressed = gesture->gesture_events.num_pressed;
1098
1099    if (pinch->fingers[num_pressed].client)
1100      {
1101         pinch->distance = _e_gesture_util_distances_get(num_pressed);
1102         pinch->state = E_GESTURE_PANPINCH_STATE_START;
1103      }
1104    else
1105      {
1106         _e_gesture_pinch_cancel();
1107      }
1108    return ECORE_CALLBACK_CANCEL;
1109 }
1110
1111 static void
1112 _e_gesture_process_pinch_down(Ecore_Event_Mouse_Button *ev)
1113 {
1114    E_Gesture_Event_Pinch *pinch = &gesture->gesture_events.pinchs;
1115
1116    if (!pinch->activation.active)
1117      {
1118         _e_gesture_pinch_cancel();
1119         return;
1120      }
1121
1122    if (gesture->gesture_events.recognized_gesture &&
1123        !((gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PAN) ||
1124        (gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PINCH)))
1125      _e_gesture_pinch_cancel();
1126
1127    if (gesture->gesture_events.num_pressed == 1)
1128      {
1129         pinch->state = E_GESTURE_PANPINCH_STATE_READY;
1130         if (pinch->start_timer) ecore_timer_del(pinch->start_timer);
1131         pinch->start_timer = ecore_timer_add(E_GESTURE_PAN_START_TIME, _e_gesture_timer_pinch_start, NULL);
1132      }
1133 }
1134
1135 static void
1136 _e_gesture_process_pinch_move(Ecore_Event_Mouse_Move *ev)
1137 {
1138    E_Gesture_Event_Pinch *pinch = &gesture->gesture_events.pinchs;
1139    int idx, mode, cx = 0, cy = 0;
1140    double current_distance = 0.0, diff = 0.0, angle = 0.0;
1141
1142    if (!pinch->activation.active)
1143      {
1144         _e_gesture_pinch_cancel();
1145         return;
1146      }
1147
1148    if (gesture->gesture_events.recognized_gesture &&
1149        !((gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PAN) ||
1150        (gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PINCH)))
1151      _e_gesture_pan_cancel();
1152
1153    idx = gesture->gesture_events.num_pressed;
1154    if (idx <= 0) return;
1155    if (pinch->state == E_GESTURE_PANPINCH_STATE_READY) return;
1156
1157    current_distance = _e_gesture_util_distances_get(idx);
1158    diff = current_distance - pinch->distance;
1159
1160    if (ABS(diff) > E_GESTURE_PINCH_MOVING_DISTANCE_RANGE)
1161      {
1162         pinch->distance = current_distance;
1163         switch (pinch->state)
1164           {
1165              case E_GESTURE_PANPINCH_STATE_START:
1166                 mode = E_GESTURE_MODE_BEGIN;
1167                 pinch->state = E_GESTURE_PANPINCH_STATE_MOVING;
1168                 pinch->num_pinch_fingers = idx;
1169                 break;
1170              case E_GESTURE_PANPINCH_STATE_MOVING:
1171                 mode = E_GESTURE_MODE_UPDATE;
1172                 break;
1173              default:
1174                 return;
1175           }
1176
1177         if (idx == 2) angle = _e_gesture_util_angle_get(gesture->gesture_events.base_point[1].axis.x,
1178                                                         gesture->gesture_events.base_point[1].axis.y,
1179                                                         gesture->gesture_events.base_point[2].axis.x,
1180                                                         gesture->gesture_events.base_point[2].axis.y);
1181         else angle = 0.0;
1182
1183         _e_gesture_util_center_axis_get(idx, &cx, &cy);
1184
1185         _e_gesture_pinch_send(mode, idx, pinch->distance, angle, cx, cy, pinch->fingers[idx].res, pinch->fingers[idx].client);
1186      }
1187 }
1188
1189 static void
1190 _e_gesture_process_pinch_up(Ecore_Event_Mouse_Button *ev)
1191 {
1192    //E_Gesture_Event_Pinch *pinch = &gesture->gesture_events.pinchs;
1193
1194    _e_gesture_pinch_cancel();
1195 }
1196
1197
1198 unsigned int
1199 e_gesture_util_tap_max_fingers_get(void)
1200 {
1201    E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps;
1202    int i;
1203    unsigned int max = 0;
1204
1205    for (i = 0; i < E_GESTURE_FINGER_MAX +1; i++)
1206      {
1207         if (taps->fingers[i].enabled) max = i;
1208      }
1209
1210    return max;
1211 }
1212
1213 unsigned int
1214 e_gesture_util_tap_max_repeats_get(unsigned int fingers)
1215 {
1216    E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps;
1217    E_Gesture_Conf_Edd *conf = gesture->config->conf;
1218    int i;
1219    unsigned int max = 0;
1220
1221    for (i = 0; i < conf->tap.repeats_max + 1; i++)
1222      {
1223         if (taps->fingers[fingers].repeats[i].client) max = i;
1224      }
1225
1226    return max;
1227 }
1228
1229 static void
1230 _e_gesture_tap_cancel(void)
1231 {
1232    E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps;
1233
1234    if (taps->start_timer)
1235      {
1236         ecore_timer_del(taps->start_timer);
1237         taps->start_timer = NULL;
1238      }
1239    if (taps->done_timer)
1240      {
1241         ecore_timer_del(taps->done_timer);
1242         taps->done_timer = NULL;
1243      }
1244    if (taps->interval_timer)
1245      {
1246         ecore_timer_del(taps->interval_timer);
1247         taps->interval_timer = NULL;
1248      }
1249
1250    taps->repeats = 0;
1251    taps->enabled_finger = 0;
1252    taps->current_finger = 0;
1253    taps->state = E_GESTURE_TAP_STATE_READY;
1254    taps->base_rect.x1 = 0;
1255    taps->base_rect.y1 = 0;
1256    taps->base_rect.x2 = 0;
1257    taps->base_rect.y2 = 0;
1258    gesture->gesture_filter |= E_GESTURE_TYPE_TAP;
1259    _e_gesture_event_flush();
1260    gesture->gesture_events.recognized_gesture &= ~E_GESTURE_TYPE_TAP;
1261 }
1262
1263 static void
1264 _e_gesture_send_tap(int fingers, int repeats, int cx, int cy,
1265                     struct wl_client *client, struct wl_resource *res)
1266 {
1267    E_Event_Gesture_Tap *ev_tap;
1268
1269    GTINF("Send Tap gesture. %d fingers %d repeats to client (%p) with cx=%d and cy=%d\n",
1270           fingers, repeats, client, cx, cy);
1271    if (client == E_GESTURE_SERVER_CLIENT)
1272      {
1273         ev_tap = E_NEW(E_Event_Gesture_Tap, 1);
1274         EINA_SAFETY_ON_NULL_RETURN(ev_tap);
1275
1276         ev_tap->mode = E_GESTURE_MODE_DONE;
1277         ev_tap->fingers = fingers;
1278         ev_tap->repeats = repeats;
1279         ev_tap->cx = cx;
1280         ev_tap->cy = cy;
1281
1282         ecore_event_add(E_EVENT_GESTURE_TAP, ev_tap, NULL, NULL);
1283      }
1284    else
1285      tizen_gesture_send_tap(res, E_GESTURE_MODE_DONE, fingers, repeats);
1286    _e_gesture_event_drop();
1287    gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_TAP;
1288
1289    _e_gesture_tap_cancel();
1290 }
1291
1292 static Eina_Bool
1293 _e_gesture_timer_tap_start(void *data)
1294 {
1295    E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps;
1296
1297    if (taps->fingers[taps->enabled_finger].enabled)
1298      {
1299         taps->state = E_GESTURE_TAP_STATE_PROCESS;
1300      }
1301    else
1302      {
1303         _e_gesture_tap_cancel();
1304      }
1305
1306    taps->start_timer = NULL;
1307    return ECORE_CALLBACK_CANCEL;
1308 }
1309
1310 static Eina_Bool
1311 _e_gesture_timer_tap_done(void *data)
1312 {
1313    E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps;
1314
1315    if (gesture->gesture_events.num_pressed)
1316      {
1317         _e_gesture_tap_cancel();
1318      }
1319
1320    taps->done_timer = NULL;
1321    return ECORE_CALLBACK_CANCEL;
1322 }
1323
1324 static Eina_Bool
1325 _e_gesture_timer_tap_interval(void *data)
1326 {
1327    E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps;
1328    Coords cur_point = {0,};
1329
1330    if (taps->fingers[taps->enabled_finger].repeats[taps->repeats].client)
1331      {
1332        _e_gesture_util_rect_center_axis_get(taps->base_rect, &cur_point.x, &cur_point.y);
1333         _e_gesture_send_tap(taps->enabled_finger, taps->repeats,
1334                             cur_point.x, cur_point.y,
1335            taps->fingers[taps->enabled_finger].repeats[taps->repeats].client,
1336            taps->fingers[taps->enabled_finger].repeats[taps->repeats].res);
1337         gesture->event_state = E_GESTURE_EVENT_STATE_KEEP;
1338         gesture->gesture_events.recognized_gesture &= ~E_GESTURE_TYPE_TAP;
1339         gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture;
1340      }
1341    else
1342      {
1343         /* All fingers are released. */
1344         gesture->gesture_filter = E_GESTURE_TYPE_ALL;
1345         _e_gesture_tap_cancel();
1346
1347         gesture->event_state = E_GESTURE_EVENT_STATE_KEEP;
1348         gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture;
1349      }
1350
1351    taps->interval_timer = NULL;
1352    return ECORE_CALLBACK_CANCEL;
1353 }
1354
1355 static void
1356 _e_gesture_tap_start(void)
1357 {
1358    E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps;
1359    E_Gesture_Conf_Edd *conf = gesture->config->conf;
1360
1361    taps->state = E_GESTURE_TAP_STATE_START;
1362    if (!taps->start_timer)
1363      {
1364         taps->start_timer = ecore_timer_add(conf->tap.time_start, _e_gesture_timer_tap_start, NULL);
1365      }
1366    if (!taps->done_timer)
1367      {
1368         taps->done_timer = ecore_timer_add(conf->tap.time_done, _e_gesture_timer_tap_done, NULL);
1369      }
1370 }
1371
1372 static void
1373 _e_gesture_tap_done(void)
1374 {
1375    E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps;
1376    E_Gesture_Conf_Edd *conf = gesture->config->conf;
1377
1378    if (taps->repeats >= conf->tap.repeats_max)
1379      _e_gesture_tap_cancel();
1380
1381    if (!taps->fingers[taps->enabled_finger].enabled)
1382       _e_gesture_tap_cancel();
1383
1384    if (!(gesture->gesture_filter & E_GESTURE_TYPE_TAP) &&
1385        gesture->gesture_events.num_pressed == 0)
1386      {
1387         taps->state = E_GESTURE_TAP_STATE_WAIT;
1388         taps->repeats++;
1389         if (taps->done_timer)
1390           {
1391              ecore_timer_del(taps->done_timer);
1392              taps->done_timer = NULL;
1393           }
1394         taps->current_finger = 0;
1395         if (taps->repeats == taps->fingers[taps->enabled_finger].max_repeats)
1396           {
1397              ecore_timer_del(taps->interval_timer);
1398              _e_gesture_timer_tap_interval(NULL);
1399           }
1400         else
1401           {
1402              if (!taps->interval_timer)
1403                {
1404                   taps->interval_timer = ecore_timer_add(conf->tap.time_interval, _e_gesture_timer_tap_interval, NULL);
1405                }
1406           }
1407      }
1408 }
1409
1410 static Eina_Bool
1411 _e_gesture_tap_condition_check(E_Gesture_Event_Tap *taps)
1412 {
1413    if (!taps->activation.active)
1414      {
1415         _e_gesture_tap_cancel();
1416         return EINA_FALSE;
1417      }
1418
1419    if (gesture->gesture_events.recognized_gesture)
1420      _e_gesture_tap_cancel();
1421
1422    return EINA_TRUE;
1423 }
1424
1425 static void
1426 _e_gesture_process_tap_down(Ecore_Event_Mouse_Button *ev)
1427 {
1428    E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps;
1429
1430    if (!_e_gesture_tap_condition_check(taps))
1431      {
1432         return;
1433      }
1434
1435    if (taps->enabled_finger < gesture->gesture_events.num_pressed)
1436        taps->enabled_finger = gesture->gesture_events.num_pressed;
1437
1438    taps->current_finger++;
1439
1440    if (taps->enabled_finger > taps->max_fingers)
1441      _e_gesture_tap_cancel();
1442
1443    if (taps->state == E_GESTURE_TAP_STATE_READY ||
1444        taps->state == E_GESTURE_TAP_STATE_START ||
1445        taps->state == E_GESTURE_TAP_STATE_PROCESS)
1446      {
1447         _e_gesture_util_rect_get(taps->enabled_finger, &taps->base_rect.x1, &taps->base_rect.y1, &taps->base_rect.x2, &taps->base_rect.y2);
1448      }
1449
1450    switch (taps->state)
1451      {
1452         case E_GESTURE_TAP_STATE_NONE:
1453            return;
1454
1455         case E_GESTURE_TAP_STATE_READY:
1456            _e_gesture_tap_start();
1457            break;
1458
1459         case E_GESTURE_TAP_STATE_START:
1460            break;
1461
1462         case E_GESTURE_TAP_STATE_PROCESS:
1463            _e_gesture_tap_cancel();
1464            break;
1465
1466         case E_GESTURE_TAP_STATE_WAIT:
1467            if (taps->interval_timer)
1468              {
1469                 ecore_timer_del(taps->interval_timer);
1470                 taps->interval_timer = NULL;
1471              }
1472            _e_gesture_tap_start();
1473            break;
1474
1475         case E_GESTURE_TAP_STATE_DONE:
1476            break;
1477
1478         default:
1479            break;
1480      }
1481 }
1482
1483 static void
1484 _e_gesture_process_tap_move(Ecore_Event_Mouse_Move *ev)
1485 {
1486    E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps;
1487    E_Gesture_Conf_Edd *conf = gesture->config->conf;
1488    Rect current_rect = {0, };
1489    int xx1, yy1, xx2, yy2;
1490
1491    if (!_e_gesture_tap_condition_check(taps))
1492      {
1493         return;
1494      }
1495
1496    _e_gesture_util_rect_get(taps->enabled_finger, &current_rect.x1, &current_rect.y1, &current_rect.x2, &current_rect.y2);
1497
1498    xx1 = taps->base_rect.x1 - current_rect.x1;
1499    yy1 = taps->base_rect.y1 - current_rect.y1;
1500    xx2 = taps->base_rect.x2 - current_rect.x2;
1501    yy2 = taps->base_rect.y2 - current_rect.y2;
1502
1503    if (ABS(xx1) > conf->tap.moving_range ||
1504        ABS(yy1) > conf->tap.moving_range ||
1505        ABS(xx2) > conf->tap.moving_range ||
1506        ABS(yy2) > conf->tap.moving_range)
1507      {
1508         GTDBG("%d finger moving too large diff: (%d, %d)(%d, %d)\n", ev->multi.device, xx1, yy1, xx2, yy2);
1509         _e_gesture_tap_cancel();
1510      }
1511 }
1512
1513 static void
1514 _e_gesture_process_tap_up(Ecore_Event_Mouse_Button *ev)
1515 {
1516    E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps;
1517
1518    if (!_e_gesture_tap_condition_check(taps))
1519      {
1520         return;
1521      }
1522
1523    if (taps->enabled_finger != taps->current_finger)
1524      _e_gesture_tap_cancel();
1525
1526    switch (taps->state)
1527      {
1528         case E_GESTURE_TAP_STATE_NONE:
1529            return;
1530
1531         case E_GESTURE_TAP_STATE_READY:
1532            _e_gesture_tap_cancel();
1533            break;
1534
1535         case E_GESTURE_TAP_STATE_START:
1536            taps->state = E_GESTURE_TAP_STATE_PROCESS;
1537            if (taps->start_timer)
1538              {
1539                 ecore_timer_del(taps->start_timer);
1540                 taps->start_timer = NULL;
1541              }
1542            _e_gesture_tap_done();
1543            break;
1544
1545         case E_GESTURE_TAP_STATE_PROCESS:
1546            _e_gesture_tap_done();
1547            break;
1548
1549         case E_GESTURE_TAP_STATE_WAIT:
1550            if (taps->interval_timer)
1551              {
1552                 ecore_timer_del(taps->interval_timer);
1553                 taps->interval_timer = NULL;
1554              }
1555            _e_gesture_tap_start();
1556            break;
1557
1558         case E_GESTURE_TAP_STATE_DONE:
1559            break;
1560
1561         default:
1562            break;
1563      }
1564 }
1565
1566 static Eina_Bool
1567 _e_gesture_process_touch_check(Ecore_Device *dev, int finger)
1568 {
1569    if ((!gesture->grabbed_gesture) ||
1570        (e_gesture_is_touch_device(dev) == EINA_FALSE) ||
1571        (finger > E_GESTURE_FINGER_MAX))
1572      {
1573         return EINA_FALSE;
1574      }
1575    return EINA_TRUE;
1576 }
1577
1578 static E_Gesture_Event_State
1579 _e_gesture_process_mouse_button_down(void *event)
1580 {
1581    Ecore_Event_Mouse_Button *ev = event;
1582
1583    if (!_e_gesture_process_touch_check(ev->dev, ev->multi.device))
1584      return E_GESTURE_EVENT_STATE_PROPAGATE;
1585
1586    gesture->gesture_events.base_point[ev->multi.device + 1].pressed = EINA_TRUE;
1587    gesture->gesture_events.base_point[ev->multi.device + 1].axis.x = ev->x;
1588    gesture->gesture_events.base_point[ev->multi.device + 1].axis.y = ev->y;
1589
1590    if (gesture->gesture_events.recognized_gesture)
1591      {
1592         GTINF("Mouse Down. recognized_gesture has a value (%d). return E_GESTURE_EVENT_STATE_IGNORE",
1593               gesture->gesture_events.recognized_gesture);
1594         return E_GESTURE_EVENT_STATE_IGNORE;
1595      }
1596
1597    if (gesture->gesture_events.num_pressed == 1)
1598      {
1599         if (gesture->gesture_filter == E_GESTURE_TYPE_ALL)
1600           {
1601              gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE;
1602           }
1603      }
1604
1605    if (!(gesture->gesture_filter & E_GESTURE_TYPE_EDGE_SWIPE))
1606      {
1607         _e_gesture_process_edge_swipe_down(ev);
1608      }
1609    if (!(gesture->gesture_filter & E_GESTURE_TYPE_EDGE_DRAG))
1610      {
1611         _e_gesture_process_edge_drag_down(ev);
1612      }
1613    if (!(gesture->gesture_filter & E_GESTURE_TYPE_PAN))
1614      {
1615         _e_gesture_process_pan_down(ev);
1616      }
1617    if (!(gesture->gesture_filter & E_GESTURE_TYPE_PINCH))
1618      {
1619         _e_gesture_process_pinch_down(ev);
1620      }
1621    if (!(gesture->gesture_filter & E_GESTURE_TYPE_TAP))
1622      {
1623         _e_gesture_process_tap_down(ev);
1624      }
1625
1626    return gesture->event_state;
1627 }
1628
1629 static E_Gesture_Event_State
1630 _e_gesture_process_mouse_button_up(void *event)
1631 {
1632    Ecore_Event_Mouse_Button *ev = event;
1633
1634    if (!_e_gesture_process_touch_check(ev->dev, ev->multi.device))
1635      return E_GESTURE_EVENT_STATE_PROPAGATE;
1636
1637    gesture->gesture_events.base_point[ev->multi.device + 1].axis.x = ev->x;
1638    gesture->gesture_events.base_point[ev->multi.device + 1].axis.y = ev->y;
1639
1640    if (!(gesture->gesture_filter & E_GESTURE_TYPE_EDGE_SWIPE))
1641      {
1642         _e_gesture_process_edge_swipe_up(ev);
1643      }
1644    if (!(gesture->gesture_filter & E_GESTURE_TYPE_EDGE_DRAG))
1645      {
1646         _e_gesture_process_edge_drag_up(ev);
1647      }
1648    if (!(gesture->gesture_filter & E_GESTURE_TYPE_PAN))
1649      {
1650         _e_gesture_process_pan_up(ev);
1651      }
1652    if (!(gesture->gesture_filter & E_GESTURE_TYPE_PINCH))
1653      {
1654         _e_gesture_process_pinch_up(ev);
1655      }
1656    if (!(gesture->gesture_filter & E_GESTURE_TYPE_TAP))
1657      {
1658         _e_gesture_process_tap_up(ev);
1659      }
1660
1661    gesture->gesture_events.base_point[ev->multi.device + 1].pressed = EINA_FALSE;
1662    gesture->gesture_events.base_point[ev->multi.device + 1].axis.x = 0;
1663    gesture->gesture_events.base_point[ev->multi.device + 1].axis.y = 0;
1664
1665    if (gesture->gesture_events.recognized_gesture)
1666      {
1667         GTINF("Mouse Up. recognized_gesture has a value (%d). return E_GESTURE_EVENT_STATE_IGNORE",
1668               gesture->gesture_events.recognized_gesture);
1669         if (gesture->gesture_events.num_pressed == 0)
1670           {
1671              if (gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PALM_COVER)
1672                {
1673                   gesture->event_state = gesture->prev_event_state;
1674                }
1675              gesture->gesture_events.recognized_gesture = 0x0;
1676           }
1677         return E_GESTURE_EVENT_STATE_IGNORE;
1678      }
1679
1680    return gesture->event_state;
1681 }
1682
1683
1684 static E_Gesture_Event_State
1685 _e_gesture_process_mouse_move(void *event)
1686 {
1687    Ecore_Event_Mouse_Move *ev = event;
1688
1689    if (!_e_gesture_process_touch_check(ev->dev, ev->multi.device))
1690      return E_GESTURE_EVENT_STATE_PROPAGATE;
1691
1692    if (gesture->gesture_events.num_pressed == 0)
1693      {
1694         return gesture->event_state;
1695      }
1696
1697    if (gesture->gesture_events.base_point[ev->multi.device + 1].pressed != EINA_TRUE)
1698      {
1699         return gesture->event_state;
1700      }
1701    gesture->gesture_events.base_point[ev->multi.device + 1].axis.x = ev->x;
1702    gesture->gesture_events.base_point[ev->multi.device + 1].axis.y = ev->y;
1703
1704    if (!(gesture->gesture_filter & E_GESTURE_TYPE_EDGE_SWIPE))
1705      {
1706         _e_gesture_process_edge_swipe_move(ev);
1707      }
1708    if (!(gesture->gesture_filter & E_GESTURE_TYPE_EDGE_DRAG))
1709      {
1710         _e_gesture_process_edge_drag_move(ev);
1711      }
1712    if (!(gesture->gesture_filter & E_GESTURE_TYPE_PAN))
1713      {
1714         _e_gesture_process_pan_move(ev);
1715      }
1716    if (!(gesture->gesture_filter & E_GESTURE_TYPE_PINCH))
1717      {
1718         _e_gesture_process_pinch_move(ev);
1719      }
1720    if (!(gesture->gesture_filter & E_GESTURE_TYPE_TAP))
1721      {
1722         _e_gesture_process_tap_move(ev);
1723      }
1724
1725    return gesture->event_state;
1726 }
1727
1728 static E_Gesture_Event_State
1729 _e_gesture_process_key_down(void *event)
1730 {
1731    Ecore_Event_Key *ev = event;
1732    E_Gesture_Conf_Edd *conf = gesture->config->conf;
1733
1734    if (ev->keycode == conf->edge_swipe.compose_key)
1735      {
1736         gesture->gesture_events.edge_swipes.combined_keycode = conf->edge_swipe.compose_key;
1737      }
1738
1739    return E_GESTURE_EVENT_STATE_PROPAGATE;
1740 }
1741
1742 static E_Gesture_Event_State
1743 _e_gesture_process_key_up(void *event)
1744 {
1745    Ecore_Event_Key *ev = event;
1746    E_Gesture_Conf_Edd *conf = gesture->config->conf;
1747
1748    if (ev->keycode == conf->edge_swipe.compose_key)
1749      {
1750         gesture->gesture_events.edge_swipes.combined_keycode = 0;
1751      }
1752
1753    return E_GESTURE_EVENT_STATE_PROPAGATE;
1754 }
1755
1756 static void
1757 _e_gesture_send_palm_cover(void)
1758 {
1759    Ecore_Event_Mouse_Button *ev_cancel;
1760    E_Gesture_Event_Palm_Cover *palm_covers = &gesture->gesture_events.palm_covers;
1761    int duration = 0, time;
1762    int cx = 0, cy = 0;
1763    unsigned int size = 0;
1764    wl_fixed_t pressure;
1765    struct wl_resource *surface = NULL, *res = NULL, *focus_surface = NULL;
1766    Eina_List *l;
1767    E_Gesture_Select_Surface *sdata;
1768    E_Event_Gesture_Palm_Cover *ev_palm_cover;
1769
1770    time = e_util_timestamp_get();
1771
1772    if (gesture->event_state == E_GESTURE_EVENT_STATE_KEEP)
1773      {
1774         _e_gesture_event_drop();
1775      }
1776    else if (gesture->event_state == E_GESTURE_EVENT_STATE_PROPAGATE)
1777      {
1778         ev_cancel = E_NEW(Ecore_Event_Mouse_Button, 1);
1779         EINA_SAFETY_ON_NULL_RETURN(ev_cancel);
1780
1781         ev_cancel->timestamp = time;
1782         ev_cancel->same_screen = 1;
1783
1784         ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, ev_cancel, NULL, NULL);
1785      }
1786
1787    _e_gesture_util_center_axis_get(gesture->gesture_events.num_pressed, &cx, &cy);
1788
1789    GTINF("Send palm_cover gesture to client: %p\n", palm_covers->client_info.client);
1790
1791    if (palm_covers->client_info.client == E_GESTURE_SERVER_CLIENT)
1792      {
1793         ev_palm_cover = E_NEW(E_Event_Gesture_Palm_Cover, 1);
1794         EINA_SAFETY_ON_NULL_RETURN(ev_palm_cover);
1795
1796         ev_palm_cover->mode = E_GESTURE_MODE_BEGIN;
1797         ev_palm_cover->duration = duration;
1798         ev_palm_cover->cx = cx;
1799         ev_palm_cover->cy = cy;
1800         ev_palm_cover->size = size;
1801         ev_palm_cover->pressure = 0.0;
1802         ecore_event_add(E_EVENT_GESTURE_PALM_COVER, ev_palm_cover, NULL, NULL);
1803
1804         ev_palm_cover = E_NEW(E_Event_Gesture_Palm_Cover, 1);
1805         EINA_SAFETY_ON_NULL_RETURN(ev_palm_cover);
1806
1807         ev_palm_cover->mode = E_GESTURE_MODE_END;
1808         ev_palm_cover->duration = duration;
1809         ev_palm_cover->cx = cx;
1810         ev_palm_cover->cy = cy;
1811         ev_palm_cover->size = size;
1812         ev_palm_cover->pressure = 0.0;
1813         ecore_event_add(E_EVENT_GESTURE_PALM_COVER, ev_palm_cover, NULL, NULL);
1814      }
1815    else
1816      {
1817         pressure = wl_fixed_from_double(0.0);
1818
1819         focus_surface = _e_gesture_util_eclient_surface_get(e_client_focused_get());
1820         if (focus_surface)
1821           {
1822              EINA_LIST_FOREACH(palm_covers->select_surface_list, l, sdata)
1823                {
1824                   if (focus_surface == sdata->surface)
1825                     {
1826                        surface = sdata->surface;
1827                        res = sdata->res;
1828                        break;
1829                     }
1830                }
1831           }
1832
1833         if (!surface || !res)
1834           {
1835              res = palm_covers->client_info.res;
1836              surface = NULL;
1837           }
1838
1839         if (!res)
1840           {
1841              GTWRN("Failed to find grabbed client(%p), palm_grabbed: %d\n", palm_covers->client_info.client, gesture->grabbed_gesture & E_GESTURE_TYPE_PALM_COVER);
1842           }
1843         else
1844           {
1845              tizen_gesture_send_palm_cover(res, surface, E_GESTURE_MODE_BEGIN, duration, size, pressure, cx, cy);
1846              tizen_gesture_send_palm_cover(res, surface, E_GESTURE_MODE_END, duration, size, pressure, cx, cy);
1847           }
1848      }
1849
1850    gesture->prev_event_state = gesture->event_state;
1851    gesture->event_state = E_GESTURE_EVENT_STATE_IGNORE;
1852    gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_PALM_COVER;
1853 }
1854
1855 static void
1856 _e_gesture_process_palm_cover(int val)
1857 {
1858    if (gesture->gesture_events.recognized_gesture)
1859      {
1860         return;
1861      }
1862
1863    _e_gesture_send_palm_cover();
1864 }
1865
1866 static void
1867 _e_gesture_process_palm(int val)
1868 {
1869    if (val <= 0) return;
1870    if (!gesture->grabbed_gesture) return;
1871
1872    if (!(gesture->gesture_filter & E_GESTURE_TYPE_PALM_COVER) &&
1873        gesture->gesture_events.palm_covers.activation.active)
1874      {
1875         _e_gesture_process_palm_cover(val);
1876      }
1877 }
1878
1879 static E_Gesture_Event_State
1880 _e_gesture_process_axis_update(void *event)
1881 {
1882    Ecore_Event_Axis_Update *ev = event;
1883    int i;
1884
1885    for (i = 0; i < ev->naxis; i++)
1886      {
1887         if (ev->axis[i].label == ECORE_AXIS_LABEL_TOUCH_PALM)
1888           {
1889              _e_gesture_process_palm((int)ev->axis[i].value);
1890           }
1891      }
1892    return E_GESTURE_EVENT_STATE_PROPAGATE;
1893 }
1894
1895 /* Function for checking the existing grab for a key and sending key event(s) */
1896 Eina_Bool
1897 e_gesture_process_events(void *event, int type)
1898 {
1899    E_Gesture_Event_State res = E_GESTURE_EVENT_STATE_PROPAGATE;
1900    Eina_Bool ret = EINA_TRUE;
1901
1902    if (type == ECORE_EVENT_MOUSE_BUTTON_DOWN)
1903      res = _e_gesture_process_mouse_button_down(event);
1904    else if (type == ECORE_EVENT_MOUSE_BUTTON_UP)
1905      res = _e_gesture_process_mouse_button_up(event);
1906    else if (type == ECORE_EVENT_MOUSE_MOVE)
1907      res = _e_gesture_process_mouse_move(event);
1908    else if (type == ECORE_EVENT_KEY_DOWN)
1909      res = _e_gesture_process_key_down(event);
1910    else if (type == ECORE_EVENT_KEY_UP)
1911      res = _e_gesture_process_key_up(event);
1912    else if (type == ECORE_EVENT_DEVICE_ADD)
1913      res = _e_gesture_process_device_add(event);
1914    else if (type == ECORE_EVENT_DEVICE_DEL)
1915      res = _e_gesture_process_device_del(event);
1916    else if (type == ECORE_EVENT_AXIS_UPDATE)
1917      res = _e_gesture_process_axis_update(event);
1918    else return ret;
1919
1920    switch (res)
1921      {
1922         case E_GESTURE_EVENT_STATE_PROPAGATE:
1923            ret = EINA_TRUE;
1924            break;
1925         case E_GESTURE_EVENT_STATE_KEEP:
1926            _e_gesture_event_queue(type, event);
1927            ret = EINA_FALSE;
1928            break;
1929         case E_GESTURE_EVENT_STATE_IGNORE:
1930            ret = EINA_FALSE;
1931            break;
1932         default:
1933            return ret;
1934      }
1935
1936    if (gesture->gesture_events.num_pressed == 0 &&
1937        type == ECORE_EVENT_MOUSE_BUTTON_UP)
1938      {
1939         if (gesture->grabbed_gesture & E_GESTURE_TYPE_TAP ||
1940              ((gesture->grabbed_gesture & E_GESTURE_TYPE_EDGE_SWIPE) &&
1941               gesture->gesture_events.event_keep))
1942           gesture->event_state = E_GESTURE_EVENT_STATE_KEEP;
1943         gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture;
1944      }
1945
1946    return ret;
1947 }