src/e_mod_main.c

   1 #define E_COMP_WL
   2 #include "e_mod_main.h"
   3 #include <string.h>
   4 #include "e_service_quickpanel.h"
   5
   6 E_GesturePtr gesture = NULL;
   7 E_API E_Module_Api e_modapi = { E_MODULE_API_VERSION, "Gesture Module of Window Manager" };
   8
   9 static E_Gesture_Config_Data *_e_gesture_init(E_Module *m);
  10 static void _e_gesture_init_handlers(void);
  11 static void _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data);
  12 static void _e_gesture_wl_surface_cb_destroy(struct wl_listener *l, void *data);
  13
  14 static Eina_Bool
  15 _e_gesture_edge_boundary_check(E_Gesture_Event_Edge_Finger *fingers, unsigned int edge, int sp, int ep)
  16 {
  17    Eina_List *l;
  18    E_Gesture_Event_Edge_Finger_Edge *edata;
  19
  20    EINA_LIST_FOREACH(fingers->edge[edge], l, edata)
  21      {
  22         if (!(sp > edata->ep || ep < edata->sp))
  23           return EINA_FALSE;
  24      }
  25
  26    return EINA_TRUE;
  27 }
  28
  29 static void
  30 _e_gesture_edge_grab_add(E_Gesture_Event_Edge_Finger *fingers, struct wl_client *client, struct wl_resource *res, unsigned int edge, unsigned int sp, unsigned int ep)
  31 {
  32    E_Gesture_Event_Edge_Finger_Edge *edata;
  33
  34    edata = E_NEW(E_Gesture_Event_Edge_Finger_Edge, 1);
  35    EINA_SAFETY_ON_NULL_RETURN(edata);
  36
  37    edata->client = client;
  38    edata->res = res;
  39    edata->sp = sp;
  40    edata->ep = ep;
  41
  42    fingers->edge[edge] = eina_list_append(fingers->edge[edge], edata);
  43 }
  44
  45 static void
  46 _e_gesture_set_client_to_list(E_Gesture_Grabbed_Client *gclient, struct wl_client *client, int mode, int fingers, int edge, int repeat, int sp, int ep)
  47 {
  48    switch (mode)
  49      {
  50         case E_GESTURE_TYPE_EDGE_SWIPE:
  51            _e_gesture_edge_grab_add(&gclient->edge_swipe_fingers[fingers], client, NULL, edge, sp, ep);
  52            gclient->edge_swipe_fingers[fingers].enabled = EINA_TRUE;
  53            break;
  54         case E_GESTURE_TYPE_EDGE_DRAG:
  55            _e_gesture_edge_grab_add(&gclient->edge_drag_fingers[fingers], client, NULL, edge, sp, ep);
  56            gclient->edge_drag_fingers[fingers].enabled = EINA_TRUE;
  57            break;
  58         case E_GESTURE_TYPE_TAP:
  59            gclient->tap_fingers[fingers].repeats[repeat].client = client;
  60            break;
  61         case E_GESTURE_TYPE_PAN:
  62            gclient->pan_fingers[fingers].client = client;
  63            break;
  64         case E_GESTURE_TYPE_PINCH:
  65            gclient->pinch_fingers[fingers].client = client;
  66            break;
  67         case E_GESTURE_TYPE_PALM_COVER:
  68            gclient->palm_cover.client = client;
  69            break;
  70         default:
  71            return;
  72      }
  73    gclient->grabbed_gesture |= mode;
  74 }
  75
  76 static char *
  77 _e_gesture_util_type_to_string(unsigned int type)
  78 {
  79    switch (type)
  80      {
  81         case E_GESTURE_TYPE_EDGE_SWIPE:
  82           return "edge_swipe";
  83         case E_GESTURE_TYPE_TAP:
  84           return "tap";
  85         case E_GESTURE_TYPE_PALM_COVER:
  86           return "palm_cover";
  87         case E_GESTURE_TYPE_PAN:
  88           return "pan";
  89         case E_GESTURE_TYPE_PINCH:
  90           return "pinch";
  91         default:
  92           return "unknown";
  93      }
  94 }
  95
  96 /* Function for registering wl_client destroy listener */
  97 int
  98 e_gesture_add_client_destroy_listener(struct wl_client *client, int mode, int fingers, unsigned int edge, unsigned int repeat, int sp, int ep)
  99 {
 100    struct wl_listener *destroy_listener = NULL;
 101    Eina_List *l;
 102    E_Gesture_Grabbed_Client *grabbed_client, *data;
 103
 104    if (client == E_GESTURE_SERVER_CLIENT) return TIZEN_GESTURE_ERROR_NONE;
 105
 106    EINA_LIST_FOREACH(gesture->grab_client_list, l, data)
 107      {
 108         if (data->client == client)
 109           {
 110              _e_gesture_set_client_to_list(data, client, mode, fingers, edge, repeat, sp, ep);
 111
 112              return TIZEN_GESTURE_ERROR_NONE;
 113           }
 114      }
 115
 116    destroy_listener = E_NEW(struct wl_listener, 1);
 117    if (!destroy_listener)
 118      {
 119         GTERR("Failed to allocate memory for wl_client destroy listener !\n");
 120         return TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES;
 121      }
 122
 123    grabbed_client = E_NEW(E_Gesture_Grabbed_Client, 1);
 124    if (!grabbed_client)
 125      {
 126         GTERR("Failed to allocate memory to save client information !\n");
 127         E_FREE(destroy_listener);
 128         return TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES;
 129      }
 130
 131    destroy_listener->notify = _e_gesture_wl_client_cb_destroy;
 132    wl_client_add_destroy_listener(client, destroy_listener);
 133    grabbed_client->client = client;
 134    grabbed_client->destroy_listener = destroy_listener;
 135    _e_gesture_set_client_to_list(grabbed_client, client, mode, fingers, edge, repeat, sp, ep);
 136
 137    gesture->grab_client_list = eina_list_append(gesture->grab_client_list, grabbed_client);
 138
 139    return TIZEN_GESTURE_ERROR_NONE;
 140 }
 141
 142 static void
 143 _e_gesture_edge_swipe_current_list_check(void)
 144 {
 145    int i, j;
 146    E_Gesture_Event *gev;
 147
 148    gev = &gesture->gesture_events;
 149    for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++)
 150      {
 151         for (j = 0; j < E_GESTURE_EDGE_MAX+1; j++)
 152           {
 153              if (eina_list_count(gev->edge_swipes.base.fingers[i].edge[j]) != 0)
 154                {
 155                   return;
 156                }
 157           }
 158         gev->edge_swipes.base.fingers[i].enabled = EINA_FALSE;
 159      }
 160    gesture->grabbed_gesture &= ~E_GESTURE_TYPE_EDGE_SWIPE;
 161    if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE;
 162 }
 163
 164 static void
 165 _e_gesture_edge_drag_current_list_check(void)
 166 {
 167    int i, j;
 168    E_Gesture_Event *gev;
 169
 170    gev = &gesture->gesture_events;
 171    for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++)
 172      {
 173         for (j = 0; j < E_GESTURE_EDGE_MAX+1; j++)
 174           {
 175              if (eina_list_count(gev->edge_drags.base.fingers[i].edge[j]) != 0)
 176                {
 177                   return;
 178                }
 179           }
 180         gev->edge_drags.base.fingers[i].enabled = EINA_FALSE;
 181      }
 182    gesture->grabbed_gesture &= ~E_GESTURE_TYPE_EDGE_SWIPE;
 183    if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE;
 184 }
 185
 186 static void
 187 _e_gesture_tap_current_list_check(void)
 188 {
 189    int i;
 190    E_Gesture_Event *gev;
 191
 192    gev = &gesture->gesture_events;
 193
 194    gesture->grabbed_gesture &= ~E_GESTURE_TYPE_TAP;
 195    gev->taps.state = E_GESTURE_TAP_STATE_NONE;
 196    gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE;
 197    for (i = 0; i < E_GESTURE_FINGER_MAX; i++)
 198      {
 199         if (gev->taps.fingers[i].enabled)
 200           {
 201              gesture->grabbed_gesture |= E_GESTURE_TYPE_TAP;
 202              gev->taps.state = E_GESTURE_TAP_STATE_READY;
 203              gesture->event_state = E_GESTURE_EVENT_STATE_KEEP;
 204              break;
 205           }
 206      }
 207
 208    gev->taps.max_fingers = e_gesture_util_tap_max_fingers_get();
 209 }
 210
 211 static void
 212 _e_gesture_pan_current_list_check(void)
 213 {
 214    int i;
 215    E_Gesture_Event *gev;
 216
 217    gev = &gesture->gesture_events;
 218
 219    gesture->grabbed_gesture &= ~E_GESTURE_TYPE_PAN;
 220    gev->pans.state = E_GESTURE_PANPINCH_STATE_NONE;
 221
 222    for (i = 0; i < E_GESTURE_FINGER_MAX; i++)
 223      {
 224         if (gev->pans.fingers[i].client)
 225           {
 226              gesture->grabbed_gesture |= E_GESTURE_TYPE_PAN;
 227              gev->pans.state = E_GESTURE_PANPINCH_STATE_READY;
 228              break;
 229           }
 230      }
 231 }
 232
 233 static void
 234 _e_gesture_pinch_current_list_check(void)
 235 {
 236    int i;
 237    E_Gesture_Event *gev;
 238
 239    gev = &gesture->gesture_events;
 240
 241    gesture->grabbed_gesture &= ~E_GESTURE_TYPE_PINCH;
 242    gev->pinchs.state = E_GESTURE_PANPINCH_STATE_NONE;
 243
 244    for (i = 0; i < E_GESTURE_FINGER_MAX; i++)
 245      {
 246         if (gev->pinchs.fingers[i].client)
 247           {
 248              gesture->grabbed_gesture |= E_GESTURE_TYPE_PINCH;
 249              gev->pinchs.state = E_GESTURE_PANPINCH_STATE_READY;
 250              break;
 251           }
 252      }
 253 }
 254
 255 static int
 256 _e_gesture_add_surface_destroy_listener(struct wl_resource *surface, int type)
 257 {
 258    struct wl_listener *destroy_listener = NULL;
 259    Eina_List *l;
 260    struct wl_resource *surface_data;
 261
 262    EINA_SAFETY_ON_NULL_RETURN_VAL(surface, TIZEN_GESTURE_ERROR_INVALID_DATA);
 263    if (type != E_GESTURE_TYPE_PALM_COVER)
 264      return TIZEN_GESTURE_ERROR_INVALID_DATA;
 265
 266    EINA_LIST_FOREACH(gesture->select_surface_list, l, surface_data)
 267      {
 268         if (surface_data == surface)
 269           {
 270              return TIZEN_GESTURE_ERROR_NONE;
 271           }
 272      }
 273
 274    destroy_listener = E_NEW(struct wl_listener, 1);
 275    if (!destroy_listener)
 276      {
 277         GTERR("Failed to allocate memory for wl_client destroy listener !\n");
 278         return TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES;
 279      }
 280
 281    destroy_listener->notify = _e_gesture_wl_surface_cb_destroy;
 282    wl_resource_add_destroy_listener(surface, destroy_listener);
 283
 284    gesture->select_surface_list = eina_list_append(gesture->select_surface_list, surface);
 285
 286    return TIZEN_GESTURE_ERROR_NONE;
 287 }
 288
 289 static void
 290 _e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int mode, unsigned int fingers, unsigned int edge, unsigned int repeat, int sp, int ep)
 291 {
 292    Eina_List *l, *l_next;
 293    E_Gesture_Grabbed_Client *data;
 294    int i, j;
 295
 296    EINA_LIST_FOREACH_SAFE(gesture->grab_client_list, l, l_next, data)
 297      {
 298         if (data->client == client)
 299           {
 300              if ((mode & E_GESTURE_TYPE_EDGE_SWIPE) &&
 301                  (data->grabbed_gesture & E_GESTURE_TYPE_EDGE_SWIPE))
 302                {
 303                   _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge, 0, sp, ep);
 304                   data->grabbed_gesture &= ~E_GESTURE_TYPE_EDGE_SWIPE;
 305                   for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++)
 306                     {
 307                        if (data->edge_swipe_fingers[i].enabled)
 308                          {
 309                             data->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE;
 310                             break;
 311                          }
 312                     }
 313                }
 314
 315              if ((mode & E_GESTURE_TYPE_TAP) &&
 316                  (data->grabbed_gesture & E_GESTURE_TYPE_TAP))
 317                {
 318                   _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_TAP, fingers, 0, repeat, 0, 0);
 319                   data->grabbed_gesture &= ~E_GESTURE_TYPE_TAP;
 320                   for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++)
 321                     {
 322                        for (j = 0; j < E_GESTURE_TAP_REPEATS_MAX + 1; j++)
 323                          {
 324                             if (data->tap_fingers[i].repeats[j].client)
 325                               {
 326                                  data->grabbed_gesture |= E_GESTURE_TYPE_TAP;
 327                                  break;
 328                               }
 329                          }
 330                     }
 331                }
 332
 333              if ((mode & E_GESTURE_TYPE_PAN) &&
 334                  (data->grabbed_gesture & E_GESTURE_TYPE_PAN))
 335                {
 336                   _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_PAN, fingers, 0, 0, 0, 0);
 337                   data->grabbed_gesture &= ~E_GESTURE_TYPE_PAN;
 338                   for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++)
 339                     {
 340                        if (data->pan_fingers[i].client)
 341                          {
 342                             data->grabbed_gesture |= E_GESTURE_TYPE_PAN;
 343                             break;
 344                          }
 345                     }
 346                }
 347
 348              if ((mode & E_GESTURE_TYPE_PINCH) &&
 349                  (data->grabbed_gesture & E_GESTURE_TYPE_PINCH))
 350                {
 351                   _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_PINCH, fingers, 0, 0, 0, 0);
 352                   data->grabbed_gesture &= ~E_GESTURE_TYPE_PINCH;
 353                   for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++)
 354                     {
 355                        if (data->pan_fingers[i].client)
 356                          {
 357                             data->grabbed_gesture |= E_GESTURE_TYPE_PINCH;
 358                             break;
 359                          }
 360                     }
 361                }
 362
 363              if ((mode & E_GESTURE_TYPE_PALM_COVER) &&
 364                  (data->grabbed_gesture & E_GESTURE_TYPE_PALM_COVER))
 365                {
 366                   _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_PALM_COVER, 0, 0, 0, 0, 0);
 367                   data->grabbed_gesture &= ~E_GESTURE_TYPE_PALM_COVER;
 368                }
 369
 370              if (!data->grabbed_gesture)
 371                {
 372                   wl_list_remove(&data->destroy_listener->link);
 373                   E_FREE(data->destroy_listener);
 374                   gesture->grab_client_list = eina_list_remove(gesture->grab_client_list, data);
 375                   E_FREE(data);
 376                }
 377           }
 378      }
 379 }
 380
 381 static void
 382 _e_gesture_remove_surface_destroy_listener(struct wl_resource *surface, int type)
 383 {
 384    Eina_List *l, *l_next;
 385    struct wl_resource *surface_data;
 386    struct wl_listener *destroy_listener;
 387
 388    EINA_SAFETY_ON_NULL_RETURN(surface);
 389    if (type != E_GESTURE_TYPE_PALM_COVER) return;
 390
 391    EINA_LIST_FOREACH_SAFE(gesture->select_surface_list, l, l_next, surface_data)
 392      {
 393         if (surface_data == surface)
 394           {
 395              gesture->select_surface_list = eina_list_remove_list(gesture->select_surface_list, l);
 396              break;
 397           }
 398      }
 399
 400    destroy_listener = wl_resource_get_destroy_listener(surface, _e_gesture_wl_surface_cb_destroy);
 401    if (destroy_listener)
 402      {
 403         wl_list_remove(&destroy_listener->link);
 404         E_FREE(destroy_listener);
 405      }
 406    else
 407      {
 408         GTWRN("surface(%p) is not gesture selected surface\n", surface);
 409      }
 410 }
 411
 412 static Eina_Bool
 413 _e_gesture_edge_grabbed_client_check(struct wl_client *client)
 414 {
 415    Eina_List *l;
 416    E_Gesture_Event *gev;
 417    int i, j;
 418    E_Gesture_Event_Edge_Finger_Edge *edata;
 419
 420    gev = &gesture->gesture_events;
 421
 422    for (i = 1; i < E_GESTURE_FINGER_MAX + 1; i++)
 423      {
 424         for (j = 1; j < E_GESTURE_EDGE_MAX + 1; j++)
 425           {
 426              EINA_LIST_FOREACH(gev->edge_swipes.base.fingers[i].edge[j], l, edata)
 427                {
 428                   if (edata->client == client) return EINA_TRUE;
 429                }
 430           }
 431      }
 432    return EINA_FALSE;
 433 }
 434
 435 static int
 436 _e_gesture_grab_edge_swipe(struct wl_client *client,
 437                            struct wl_resource *resource,
 438                            uint32_t fingers, uint32_t edge, uint32_t edge_size,
 439                            uint32_t start_point, uint32_t end_point)
 440 {
 441    E_Gesture_Event *gev;
 442    int sp = 0, ep = 0;
 443    int ret = TIZEN_GESTURE_ERROR_NONE;
 444    E_Gesture_Conf_Edd *conf = gesture->config->conf;
 445
 446    GTINF("client %p is request grab gesture, fingers: %d, edge: 0x%x, edge_size: %d, point( %d - %d)\n", client, fingers, edge, edge_size, start_point, end_point);
 447    if (fingers > E_GESTURE_FINGER_MAX)
 448      {
 449         GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX);
 450         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 451         return ret;
 452      }
 453
 454    gev = &gesture->gesture_events;
 455
 456    if (edge < E_GESTURE_EDGE_TOP || edge > E_GESTURE_EDGE_LEFT)
 457      {
 458         GTWRN("Invalid edge(%d)\n", edge);
 459         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 460         return ret;
 461      }
 462
 463    if (edge_size == E_GESTURE_EDGE_SIZE_PARTIAL)
 464      {
 465         sp = start_point;
 466         ep = end_point;
 467         if (((edge == E_GESTURE_EDGE_TOP) || (edge == E_GESTURE_EDGE_BOTTOM)) &&
 468             (ep > e_comp->w))
 469           ep = e_comp->w;
 470         else if (((edge == E_GESTURE_EDGE_RIGHT) || (edge == E_GESTURE_EDGE_LEFT)) &&
 471                  (ep > e_comp->h))
 472           ep = e_comp->h;
 473      }
 474    else if (edge_size == E_GESTURE_EDGE_SIZE_FULL)
 475      {
 476         sp = 0;
 477         if ((edge == E_GESTURE_EDGE_TOP) || (edge == E_GESTURE_EDGE_BOTTOM))
 478           ep = e_comp->w;
 479         else if ((edge == E_GESTURE_EDGE_RIGHT) || (edge == E_GESTURE_EDGE_LEFT))
 480           ep = e_comp->h;
 481      }
 482    else
 483      {
 484         GTWRN("Invalid edge_size(%d)\n", edge_size);
 485         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 486         return ret;
 487      }
 488
 489    if ((conf->edge_swipe.default_enable_back) &&
 490        (edge == E_GESTURE_EDGE_TOP))
 491      {
 492         ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY;
 493      }
 494    else if (_e_gesture_edge_boundary_check(&gev->edge_swipes.base.fingers[fingers], edge, sp, ep))
 495      {
 496         _e_gesture_edge_grab_add(&gev->edge_swipes.base.fingers[fingers], client, resource, edge, sp, ep);
 497
 498         e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge, 0, sp, ep);
 499
 500         gesture->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE;
 501         gev->edge_swipes.base.fingers[fingers].enabled = EINA_TRUE;
 502         if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_KEEP;
 503         gev->edge_swipes.base.enabled_edge |= (1 << edge);
 504
 505         gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture;
 506
 507         ret = TIZEN_GESTURE_ERROR_NONE;
 508      }
 509    else
 510      {
 511         ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY;
 512      }
 513
 514    return ret;
 515 }
 516
 517 static int
 518 _e_gesture_ungrab_edge_swipe(struct wl_client *client,
 519                              struct wl_resource *resource,
 520                              uint32_t fingers, uint32_t edge, uint32_t edge_size,
 521                              uint32_t start_point, uint32_t end_point)
 522 {
 523    E_Gesture_Event *gev;
 524    int ret = TIZEN_GESTURE_ERROR_NONE;
 525    int i;
 526    Eina_List *l, *l_next;
 527    E_Gesture_Event_Edge_Finger_Edge *edata;
 528    Eina_Bool flag_removed = EINA_FALSE;
 529    int sp = 0, ep = 0;
 530
 531    GTINF("client %p is request ungrab edge swipe gesture, fingers: %d, edge: 0x%x, edge_size: %d, (%d ~ %d)\n", client, fingers, edge, edge_size, start_point, end_point);
 532
 533    if (fingers > E_GESTURE_FINGER_MAX)
 534      {
 535         GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX);
 536         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 537         return ret;
 538      }
 539
 540    gev = &gesture->gesture_events;
 541
 542    if (edge_size == E_GESTURE_EDGE_SIZE_PARTIAL)
 543      {
 544         sp = start_point;
 545         ep = end_point;
 546         if (((edge == E_GESTURE_EDGE_TOP) || (edge == E_GESTURE_EDGE_BOTTOM)) &&
 547             (ep > e_comp->w))
 548           ep = e_comp->w;
 549         else if (((edge == E_GESTURE_EDGE_RIGHT) || (edge == E_GESTURE_EDGE_LEFT)) &&
 550                  (ep > e_comp->h))
 551           ep = e_comp->h;
 552      }
 553    else if (edge_size == E_GESTURE_EDGE_SIZE_FULL)
 554      {
 555         sp = 0;
 556         if ((edge == E_GESTURE_EDGE_TOP) || (edge == E_GESTURE_EDGE_BOTTOM))
 557           ep = e_comp->w;
 558         else if ((edge == E_GESTURE_EDGE_RIGHT) || (edge == E_GESTURE_EDGE_LEFT))
 559           ep = e_comp->h;
 560      }
 561    else
 562      {
 563         GTWRN("Invalid edge_size(%d)\n", edge_size);
 564         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 565         return ret;
 566      }
 567
 568    EINA_LIST_FOREACH_SAFE(gev->edge_swipes.base.fingers[fingers].edge[edge], l, l_next, edata)
 569      {
 570         if ((edata->client == client) && (edata->sp == sp) && (edata->ep == ep))
 571           {
 572              gev->edge_swipes.base.fingers[fingers].edge[edge] = eina_list_remove_list(
 573                 gev->edge_swipes.base.fingers[fingers].edge[edge], l);
 574              E_FREE(edata);
 575              flag_removed = EINA_TRUE;
 576           }
 577      }
 578
 579    if (flag_removed)
 580      {
 581         if (!_e_gesture_edge_grabbed_client_check(client))
 582           {
 583              _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge, 0, sp, ep);
 584              _e_gesture_edge_swipe_current_list_check();
 585           }
 586      }
 587
 588    gev->edge_swipes.base.enabled_edge &= ~( 1 << edge);
 589    for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++)
 590      {
 591         if (eina_list_count(gev->edge_swipes.base.fingers[i].edge[edge]) > 0)
 592           {
 593              gev->edge_swipes.base.enabled_edge |= (1 << edge);
 594              break;
 595           }
 596      }
 597
 598    return ret;
 599 }
 600
 601 static int
 602 _e_gesture_grab_edge_drag(struct wl_client *client,
 603                           struct wl_resource *resource,
 604                           uint32_t fingers, uint32_t edge, uint32_t edge_size,
 605                           uint32_t start_point, uint32_t end_point)
 606 {
 607    E_Gesture_Event *gev;
 608    int sp = 0, ep = 0;
 609    int ret = TIZEN_GESTURE_ERROR_NONE;
 610
 611    GTINF("client %p is request edge_drag grab, fingers: %d, edge: 0x%x, edge_size: %d, point( %d - %d)\n", client, fingers, edge, edge_size, start_point, end_point);
 612    if (fingers > E_GESTURE_FINGER_MAX)
 613      {
 614         GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX);
 615         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 616         goto out;
 617      }
 618
 619    if (edge < E_GESTURE_EDGE_TOP || edge > E_GESTURE_EDGE_LEFT)
 620      {
 621         GTWRN("Invalid edge(%d)\n", edge);
 622         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 623         goto out;
 624      }
 625
 626    if (edge_size == E_GESTURE_EDGE_SIZE_PARTIAL)
 627      {
 628         sp = start_point;
 629         ep = end_point;
 630         if (((edge == E_GESTURE_EDGE_TOP) || (edge == E_GESTURE_EDGE_BOTTOM)) &&
 631             (ep > e_comp->w))
 632           ep = e_comp->w;
 633         else if (((edge == E_GESTURE_EDGE_RIGHT) || (edge == E_GESTURE_EDGE_LEFT)) &&
 634                  (ep > e_comp->h))
 635           ep = e_comp->h;
 636      }
 637    else if (edge_size == E_GESTURE_EDGE_SIZE_FULL)
 638      {
 639         sp = 0;
 640         if ((edge == E_GESTURE_EDGE_TOP) || (edge == E_GESTURE_EDGE_BOTTOM))
 641           ep = e_comp->w;
 642         else if ((edge == E_GESTURE_EDGE_RIGHT) || (edge == E_GESTURE_EDGE_LEFT))
 643           ep = e_comp->h;
 644      }
 645    else
 646      {
 647         GTWRN("Invalid edge_size(%d)\n", edge_size);
 648         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 649         goto out;
 650      }
 651
 652    gev = &gesture->gesture_events;
 653
 654    if (_e_gesture_edge_boundary_check(&gev->edge_drags.base.fingers[fingers], edge, sp, ep))
 655      {
 656         _e_gesture_edge_grab_add(&gev->edge_drags.base.fingers[fingers], client, resource, edge, sp, ep);
 657
 658         e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_DRAG, fingers, edge, 0, sp, ep);
 659
 660         gesture->grabbed_gesture |= E_GESTURE_TYPE_EDGE_DRAG;
 661         gev->edge_drags.base.fingers[fingers].enabled = EINA_TRUE;
 662         if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_KEEP;
 663         gev->edge_drags.base.enabled_edge |= (1 << edge);
 664
 665         gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture;
 666
 667         ret = TIZEN_GESTURE_ERROR_NONE;
 668      }
 669    else
 670      {
 671         ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY;
 672      }
 673
 674 out:
 675    return ret;
 676 }
 677
 678 static int
 679 _e_gesture_ungrab_edge_drag(struct wl_client *client,
 680                        struct wl_resource *resource,
 681                        uint32_t fingers, uint32_t edge, uint32_t edge_size,
 682                        uint32_t start_point, uint32_t end_point)
 683 {
 684    E_Gesture_Event *gev;
 685    int ret = TIZEN_GESTURE_ERROR_NONE;
 686    int i;
 687    Eina_List *l, *l_next;
 688    E_Gesture_Event_Edge_Finger_Edge *edata;
 689    Eina_Bool flag_removed = EINA_FALSE;
 690    int sp = 0, ep = 0;
 691
 692    GTINF("client %p is request ungrab edge drag gesture, fingers: %d, edge: 0x%x, edge_size: %d, (%d ~ %d)\n", client, fingers, edge, edge_size, start_point, end_point);
 693
 694    if (fingers > E_GESTURE_FINGER_MAX)
 695      {
 696         GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX);
 697         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 698         goto out;
 699      }
 700
 701    if (edge_size == E_GESTURE_EDGE_SIZE_PARTIAL)
 702      {
 703         sp = start_point;
 704         ep = end_point;
 705         if (((edge == E_GESTURE_EDGE_TOP) || (edge == E_GESTURE_EDGE_BOTTOM)) &&
 706             (ep > e_comp->w))
 707           ep = e_comp->w;
 708         else if (((edge == E_GESTURE_EDGE_RIGHT) || (edge == E_GESTURE_EDGE_LEFT)) &&
 709                  (ep > e_comp->h))
 710           ep = e_comp->h;
 711      }
 712    else if (edge_size == E_GESTURE_EDGE_SIZE_FULL)
 713      {
 714         sp = 0;
 715         if ((edge == E_GESTURE_EDGE_TOP) || (edge == E_GESTURE_EDGE_BOTTOM))
 716           ep = e_comp->w;
 717         else if ((edge == E_GESTURE_EDGE_RIGHT) || (edge == E_GESTURE_EDGE_LEFT))
 718           ep = e_comp->h;
 719      }
 720    else
 721      {
 722         GTWRN("Invalid edge_size(%d)\n", edge_size);
 723         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 724         goto out;
 725      }
 726
 727    gev = &gesture->gesture_events;
 728
 729    EINA_LIST_FOREACH_SAFE(gev->edge_drags.base.fingers[fingers].edge[edge], l, l_next, edata)
 730      {
 731         if ((edata->client == client) && (edata->sp == sp) && (edata->ep == ep))
 732           {
 733              gev->edge_drags.base.fingers[fingers].edge[edge] = eina_list_remove_list(
 734                 gev->edge_drags.base.fingers[fingers].edge[edge], l);
 735              E_FREE(edata);
 736              flag_removed = EINA_TRUE;
 737           }
 738      }
 739
 740    if (flag_removed)
 741      {
 742         if (!_e_gesture_edge_grabbed_client_check(client))
 743           {
 744              _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_DRAG, fingers, edge, 0, sp, ep);
 745              _e_gesture_edge_drag_current_list_check();
 746           }
 747      }
 748
 749    gev->edge_drags.base.enabled_edge &= ~( 1 << edge);
 750    for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++)
 751      {
 752         if (eina_list_count(gev->edge_drags.base.fingers[i].edge[edge]) > 0)
 753           {
 754              gev->edge_drags.base.enabled_edge |= (1 << edge);
 755              break;
 756           }
 757      }
 758
 759 out:
 760    return ret;
 761 }
 762
 763 static int
 764 _e_gesture_grab_tap(struct wl_client *client,
 765                     struct wl_resource *resource,
 766                     uint32_t fingers, uint32_t repeats)
 767 {
 768    E_Gesture_Event *gev;
 769    int ret = TIZEN_GESTURE_ERROR_NONE;
 770
 771    GTINF("client %p requested to grab tap gesture (fingers: %d, repeats: %d)\n", client, fingers, repeats);
 772
 773    if (fingers > E_GESTURE_FINGER_MAX || repeats > E_GESTURE_TAP_REPEATS_MAX)
 774      {
 775         GTWRN("Not supported fingers /repeats bigger than their maximum values\n");
 776         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 777         return ret;
 778      }
 779
 780    gev = &gesture->gesture_events;
 781
 782    if (gev->taps.fingers[fingers].repeats[repeats].client)
 783      {
 784         GTWRN("%d finger %d repeats is already grabbed by %p client\n", fingers, repeats, gev->taps.fingers[fingers].repeats[repeats].client);
 785         ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY;
 786         return ret;
 787      }
 788
 789    gev->taps.fingers[fingers].repeats[repeats].client = client;
 790    gev->taps.fingers[fingers].repeats[repeats].res = resource;
 791    gev->taps.fingers[fingers].enabled = EINA_TRUE;
 792
 793    e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_TAP, fingers, 0, repeats, 0, 0);
 794
 795    if (gev->taps.max_fingers < fingers)
 796      gev->taps.max_fingers = fingers;
 797    if (gev->taps.fingers[fingers].max_repeats < repeats)
 798      gev->taps.fingers[fingers].max_repeats = repeats;
 799
 800    gesture->grabbed_gesture |= E_GESTURE_TYPE_TAP;
 801    gev->taps.state = E_GESTURE_TAP_STATE_READY;
 802    gesture->event_state = E_GESTURE_EVENT_STATE_KEEP;
 803    gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture;
 804
 805    return ret;
 806 }
 807
 808 static int
 809 _e_gesture_ungrab_tap(struct wl_client *client,
 810                    struct wl_resource *resource,
 811                    uint32_t fingers, uint32_t repeats)
 812 {
 813    int i;
 814    E_Gesture_Event *gev;
 815    int ret = TIZEN_GESTURE_ERROR_NONE;
 816
 817    GTINF("client %p requested to ungrab tap gesture (fingers: %d, repeats: %d)\n", client, fingers, fingers);
 818
 819    if (fingers > E_GESTURE_FINGER_MAX || repeats > E_GESTURE_TAP_REPEATS_MAX)
 820      {
 821         GTWRN("Not supported fingers /repeats bigger than their maximum values\n");
 822         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 823         return ret;
 824      }
 825
 826    gev = &gesture->gesture_events;
 827
 828    if (gev->taps.fingers[fingers].repeats[repeats].client == client)
 829      {
 830         gev->taps.fingers[fingers].repeats[repeats].client = NULL;
 831         gev->taps.fingers[fingers].repeats[repeats].res = NULL;
 832      }
 833
 834    gev->taps.fingers[fingers].enabled = EINA_FALSE;
 835    for (i = 0; i < E_GESTURE_TAP_REPEATS_MAX; i++)
 836      {
 837         if (gev->taps.fingers[fingers].repeats[i].client)
 838           {
 839              gev->taps.fingers[fingers].enabled = EINA_TRUE;
 840              break;
 841           }
 842      }
 843    gev->taps.fingers[fingers].max_repeats = e_gesture_util_tap_max_repeats_get(fingers);
 844
 845    _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_TAP, fingers, 0, repeats, 0, 0);
 846    _e_gesture_tap_current_list_check();
 847
 848    return ret;
 849 }
 850
 851 static int
 852 _e_gesture_grab_pan(struct wl_client *client, struct wl_resource *resource, uint32_t fingers)
 853 {
 854    E_Gesture_Event *gev;
 855    int ret = TIZEN_GESTURE_ERROR_NONE;
 856
 857    GTINF("The client %p request to grab pan gesture, fingers: %d\n", client, fingers);
 858
 859    if (fingers > E_GESTURE_FINGER_MAX)
 860      {
 861         GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX);
 862         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 863         goto finish;
 864      }
 865
 866    gev = &gesture->gesture_events;
 867
 868    if (gev->pans.fingers[fingers].client)
 869      {
 870         GTWRN("%d finger is already grabbed by %p client\n", fingers, gev->pans.fingers[fingers].client);
 871         ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY;
 872         goto finish;
 873      }
 874
 875    e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_PAN, fingers, 0, 0, 0, 0);
 876
 877    gev->pans.fingers[fingers].client = client;
 878    gev->pans.fingers[fingers].res = resource;
 879    gev->pans.state = E_GESTURE_PANPINCH_STATE_READY;
 880
 881    gesture->grabbed_gesture |= E_GESTURE_TYPE_PAN;
 882    gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture;
 883
 884 finish:
 885    return ret;
 886 }
 887
 888 static int
 889 _e_gesture_ungrab_pan(struct wl_client *client, struct wl_resource *resource, uint32_t fingers)
 890 {
 891    E_Gesture_Event *gev;
 892    int ret = TIZEN_GESTURE_ERROR_NONE;
 893
 894    GTINF("The client %p request to ungrab pan gesture, fingers: %d\n", client, fingers);
 895
 896    if (fingers > E_GESTURE_FINGER_MAX)
 897      {
 898         GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX);
 899         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 900         goto finish;
 901      }
 902
 903    gev = &gesture->gesture_events;
 904
 905    if (gev->pans.fingers[fingers].client == client)
 906      {
 907         gev->pans.fingers[fingers].client = NULL;
 908         gev->pans.fingers[fingers].res = NULL;
 909      }
 910
 911    _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_PAN, fingers, 0, 0, 0, 0);
 912    _e_gesture_pan_current_list_check();
 913
 914 finish:
 915    return ret;
 916 }
 917
 918 static int
 919 _e_gesture_grab_pinch(struct wl_client *client, struct wl_resource *resource, uint32_t fingers)
 920 {
 921    E_Gesture_Event *gev;
 922    int ret = TIZEN_GESTURE_ERROR_NONE;
 923
 924    GTINF("The client %p request to grab pinch gesture, fingers: %d\n", client, fingers);
 925
 926    if (fingers > E_GESTURE_FINGER_MAX)
 927      {
 928         GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX);
 929         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 930         goto finish;
 931      }
 932
 933    gev = &gesture->gesture_events;
 934
 935    if (gev->pinchs.fingers[fingers].client)
 936      {
 937         GTWRN("%d finger is already grabbed by %p client\n", fingers, gev->pinchs.fingers[fingers].client);
 938         ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY;
 939         goto finish;
 940      }
 941
 942    e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_PINCH, fingers, 0, 0, 0, 0);
 943
 944    gev->pinchs.fingers[fingers].client = client;
 945    gev->pinchs.fingers[fingers].res = resource;
 946
 947    gev->pinchs.state = E_GESTURE_PANPINCH_STATE_READY;
 948    gesture->grabbed_gesture |= E_GESTURE_TYPE_PINCH;
 949    gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture;
 950
 951 finish:
 952    return ret;
 953 }
 954
 955 static int
 956 _e_gesture_ungrab_pinch(struct wl_client *client, struct wl_resource *resource, uint32_t fingers)
 957 {
 958    E_Gesture_Event *gev;
 959    int ret = TIZEN_GESTURE_ERROR_NONE;
 960
 961    GTINF("The client %p request to ungrab pinch gesture, fingers: %d\n", client, fingers);
 962
 963    if (fingers > E_GESTURE_FINGER_MAX)
 964      {
 965         GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX);
 966         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 967         goto finish;
 968      }
 969
 970    gev = &gesture->gesture_events;
 971
 972    if (gev->pinchs.fingers[fingers].client == client)
 973      {
 974         gev->pinchs.fingers[fingers].client = NULL;
 975         gev->pinchs.fingers[fingers].res = NULL;
 976      }
 977
 978    _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_PINCH, fingers, 0, 0, 0, 0);
 979    _e_gesture_pinch_current_list_check();
 980
 981 finish:
 982    return ret;
 983 }
 984
 985 static int
 986 _e_gesture_grab_palm_cover(struct wl_client *client, struct wl_resource *resource)
 987 {
 988    E_Gesture_Event *gev;
 989    int ret = TIZEN_GESTURE_ERROR_NONE;
 990
 991    gev = &gesture->gesture_events;
 992
 993    GTINF("The client %p request to grab palm hover gesture\n", client);
 994
 995    if (gev->palm_covers.client_info.client)
 996      {
 997         GTWRN("Palm hover is already grabbed by %p client\n", gev->palm_covers.client_info.client);
 998         goto finish;
 999      }
1000
1001    e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_PALM_COVER, 0, 0, 0, 0, 0);
1002
1003    gev->palm_covers.client_info.client = client;
1004    gev->palm_covers.client_info.res = resource;
1005
1006    gesture->grabbed_gesture |= E_GESTURE_TYPE_PALM_COVER;
1007    gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture;
1008
1009 finish:
1010    return ret;
1011 }
1012
1013 static int
1014 _e_gesture_ungrab_palm_cover(struct wl_client *client, struct wl_resource *resource)
1015 {
1016    E_Gesture_Event *gev;
1017    int ret = TIZEN_GESTURE_ERROR_NONE;
1018
1019    GTINF("The client %p request to ungrab palm hover gesture\n", client);
1020
1021    gev = &gesture->gesture_events;
1022
1023    if (gev->palm_covers.client_info.client == client)
1024      {
1025         gev->palm_covers.client_info.client = NULL;
1026         gev->palm_covers.client_info.client = NULL;
1027      }
1028
1029    _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_PALM_COVER, 0, 0, 0, 0, 0);
1030    gesture->grabbed_gesture &= ~E_GESTURE_TYPE_PALM_COVER;
1031    gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture;
1032
1033    return ret;
1034 }
1035
1036 static int
1037 _e_gesture_select_palm_cover(struct wl_client *client, struct wl_resource *resource,
1038                              struct wl_resource *surface)
1039 {
1040    int ret = TIZEN_GESTURE_ERROR_NONE;
1041    Eina_List *l;
1042    E_Gesture_Event_Palm_Cover *palm_covers = &gesture->gesture_events.palm_covers;
1043    E_Gesture_Select_Surface *sdata;
1044
1045    EINA_LIST_FOREACH(palm_covers->select_surface_list, l, sdata)
1046      {
1047         if (sdata->surface == surface)
1048           {
1049              ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY;
1050              goto out;
1051           }
1052      }
1053
1054    sdata = E_NEW(E_Gesture_Select_Surface, 1);
1055    if (!sdata)
1056      {
1057         ret = TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES;
1058         goto out;
1059      }
1060
1061    sdata->surface = surface;
1062    sdata->res = resource;
1063
1064    palm_covers->select_surface_list = eina_list_append(palm_covers->select_surface_list, sdata);
1065
1066    _e_gesture_add_surface_destroy_listener(surface, E_GESTURE_TYPE_PALM_COVER);
1067
1068 out:
1069    return ret;
1070 }
1071
1072 static int
1073 _e_gesture_deselect_palm_cover(struct wl_client *client, struct wl_resource *resource,
1074                              struct wl_resource *surface)
1075 {
1076    int ret = TIZEN_GESTURE_ERROR_NONE;
1077    Eina_List *l, *l_next;
1078    E_Gesture_Event_Palm_Cover *palm_covers = &gesture->gesture_events.palm_covers;
1079    E_Gesture_Select_Surface *sdata;
1080
1081    EINA_LIST_FOREACH_SAFE(palm_covers->select_surface_list, l, l_next, sdata)
1082      {
1083         if (sdata->surface == surface)
1084           {
1085              palm_covers->select_surface_list = eina_list_remove_list(palm_covers->select_surface_list, l);
1086              E_FREE(sdata);
1087              break;
1088           }
1089      }
1090
1091    _e_gesture_remove_surface_destroy_listener(surface, E_GESTURE_TYPE_PALM_COVER);
1092
1093    return ret;
1094 }
1095
1096 static int
1097 _e_gesture_server_grab_edge_swipe(unsigned int fingers,
1098                                   unsigned int edge, unsigned int edge_size,
1099                                   unsigned int start_point, unsigned int end_point)
1100 {
1101    int ret = TIZEN_GESTURE_ERROR_NONE;
1102
1103    ret = _e_gesture_grab_edge_swipe(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT,
1104                                     fingers, edge, edge_size, start_point, end_point);
1105
1106    return ret;
1107 }
1108
1109 static int
1110 _e_gesture_server_ungrab_edge_swipe(unsigned int fingers,
1111                                     unsigned int edge, unsigned int edge_size,
1112                                     unsigned int start_point, unsigned int end_point)
1113 {
1114    int ret = TIZEN_GESTURE_ERROR_NONE;
1115
1116    ret = _e_gesture_ungrab_edge_swipe(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers, edge, edge_size, start_point, end_point);
1117
1118    return ret;
1119 }
1120
1121 static int
1122 _e_gesture_server_grab_edge_drag(unsigned int fingers,
1123                         unsigned int edge, unsigned int edge_size,
1124                         unsigned int start_point, unsigned int end_point)
1125 {
1126    int ret = TIZEN_GESTURE_ERROR_NONE;
1127
1128    ret = _e_gesture_grab_edge_drag(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers, edge, edge_size, start_point, end_point);
1129
1130    return ret;
1131 }
1132
1133 static int
1134 _e_gesture_server_ungrab_edge_drag(unsigned int fingers, unsigned int edge, unsigned int edge_size,
1135                           unsigned int start_point, unsigned int end_point)
1136 {
1137    int ret = TIZEN_GESTURE_ERROR_NONE;
1138
1139    ret = _e_gesture_ungrab_edge_drag(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers, edge, edge_size, start_point, end_point);
1140
1141    return ret;
1142 }
1143
1144 static int
1145 _e_gesture_server_grab_tap(unsigned int fingers, unsigned int repeats)
1146 {
1147    int ret = TIZEN_GESTURE_ERROR_NONE;
1148
1149    ret = _e_gesture_grab_tap(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers, repeats);
1150
1151    return ret;
1152 }
1153
1154 static int
1155 _e_gesture_server_ungrab_tap(unsigned int fingers, unsigned int repeats)
1156 {
1157    int ret = TIZEN_GESTURE_ERROR_NONE;
1158
1159    ret = _e_gesture_ungrab_tap(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers, repeats);
1160
1161    return ret;
1162 }
1163
1164 static int
1165 _e_gesture_server_grab_palm_cover(void)
1166 {
1167    int ret = TIZEN_GESTURE_ERROR_NONE;
1168
1169    ret = _e_gesture_grab_palm_cover(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT);
1170
1171    return ret;
1172 }
1173
1174 static int
1175 _e_gesture_server_ungrab_palm_cover(void)
1176 {
1177    int ret = TIZEN_GESTURE_ERROR_NONE;
1178
1179    ret = _e_gesture_ungrab_palm_cover(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT);
1180
1181    return ret;
1182 }
1183
1184 static int
1185 _e_gesture_server_grab_pan(unsigned int fingers)
1186 {
1187    int ret = TIZEN_GESTURE_ERROR_NONE;
1188
1189    ret = _e_gesture_grab_pan(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers);
1190
1191    return ret;
1192 }
1193
1194 static int
1195 _e_gesture_server_ungrab_pan(unsigned int fingers)
1196 {
1197    int ret = TIZEN_GESTURE_ERROR_NONE;
1198
1199    ret = _e_gesture_ungrab_pan(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers);
1200
1201    return ret;
1202 }
1203
1204 static int
1205 _e_gesture_server_grab_pinch(unsigned int fingers)
1206 {
1207    int ret = TIZEN_GESTURE_ERROR_NONE;
1208
1209    ret = _e_gesture_grab_pinch(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers);
1210
1211    return ret;
1212 }
1213
1214 static int
1215 _e_gesture_server_ungrab_pinch(unsigned int fingers)
1216 {
1217    int ret = TIZEN_GESTURE_ERROR_NONE;
1218
1219    ret = _e_gesture_ungrab_pinch(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers);
1220
1221    return ret;
1222 }
1223
1224 static Eina_Bool
1225 _e_gesture_deactivate_find_surface(Eina_List *list, struct wl_resource *surface)
1226 {
1227    Eina_List *l;
1228    E_Gesture_Activate_Surface_Info *idata;
1229
1230    EINA_LIST_FOREACH(list, l, idata)
1231      {
1232         if (surface == idata->surface)
1233           {
1234              return EINA_TRUE;
1235           }
1236      }
1237    return EINA_FALSE;
1238 }
1239
1240 static void
1241 _e_gesture_deactivate_list_unset(struct wl_client *client, struct wl_resource *surface, E_Gesture_Activate_Info *info, unsigned int type)
1242 {
1243    Eina_List *l, *l_next;
1244    struct wl_resource *surface_data;
1245
1246    if (surface)
1247      {
1248         EINA_LIST_FOREACH_SAFE(info->surfaces, l, l_next, surface_data)
1249           {
1250              if (surface_data == surface)
1251                {
1252                   info->surfaces = eina_list_remove_list(info->surfaces, l);
1253                   break;
1254                }
1255           }
1256      }
1257    else if (info->client && (info->client == client))
1258      {
1259         info->client = NULL;
1260         info->active = EINA_TRUE;
1261      }
1262    else
1263      {
1264         GTWRN("Failed to unset %s deactivate. surface: %p, client: %p (already deactivated client: %p)\n", _e_gesture_util_type_to_string(type), surface, client, info->client);
1265      }
1266 }
1267
1268 static void
1269 _e_gesture_deactivate_cb_client_listener(struct wl_listener *l, void *data)
1270 {
1271    struct wl_client *client = data;
1272
1273    _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.edge_swipes.base.activation, E_GESTURE_TYPE_EDGE_SWIPE);
1274    _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP);
1275    _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER);
1276    _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN);
1277    _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.pinchs.activation, E_GESTURE_TYPE_PINCH);
1278
1279    wl_list_remove(&l->link);
1280    E_FREE(l);
1281 }
1282
1283 static void
1284 _e_gesture_deactivate_cb_surface_listener(struct wl_listener *l, void *data)
1285 {
1286    struct wl_resource *surface = data;
1287
1288    _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.edge_swipes.base.activation, E_GESTURE_TYPE_EDGE_SWIPE);
1289    _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP);
1290    _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER);
1291    _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN);
1292    _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.pinchs.activation, E_GESTURE_TYPE_PINCH);
1293
1294    wl_list_remove(&l->link);
1295    E_FREE(l);
1296 }
1297
1298 static int
1299 _e_gesture_deactivate_listener_add(struct wl_client *client, struct wl_resource * surface)
1300 {
1301    struct wl_listener *destroy_listener = NULL;
1302
1303    EINA_SAFETY_ON_FALSE_RETURN_VAL(client || surface, TIZEN_GESTURE_ERROR_INVALID_DATA);
1304
1305    destroy_listener = E_NEW(struct wl_listener, 1);
1306    if (!destroy_listener)
1307      {
1308         GTERR("Failed to allocate memory for deactivate destroy listener !\n");
1309         return TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES;
1310      }
1311
1312    if (surface)
1313      {
1314         destroy_listener->notify = _e_gesture_deactivate_cb_surface_listener;
1315         wl_resource_add_destroy_listener(surface, destroy_listener);
1316      }
1317    else
1318      {
1319         destroy_listener->notify = _e_gesture_deactivate_cb_client_listener;
1320         wl_client_add_destroy_listener(client, destroy_listener);
1321      }
1322
1323    return TIZEN_GESTURE_ERROR_NONE;
1324 }
1325
1326 static int
1327 _e_gesture_deactivate_list_set(struct wl_client *client, struct wl_resource *surface, E_Gesture_Activate_Info *info, unsigned int type)
1328 {
1329    int ret = TIZEN_GESTURE_ERROR_NONE;
1330
1331    if (surface)
1332      {
1333         if (!_e_gesture_deactivate_find_surface(info->surfaces, surface))
1334           {
1335              info->surfaces = eina_list_append(info->surfaces, surface);
1336              _e_gesture_deactivate_listener_add(client, surface);
1337           }
1338      }
1339    else if (!info->client)
1340      {
1341         info->client = client;
1342         info->active = EINA_FALSE;
1343         _e_gesture_deactivate_listener_add(client, surface);
1344      }
1345    else
1346      {
1347         GTWRN("Failed to deactivate %s !(request surface: %p, client: %p), already deactivated client: %p\n",
1348               _e_gesture_util_type_to_string(type), surface, client, info->client);
1349         ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY;
1350      }
1351
1352    return ret;
1353 }
1354
1355 static int
1356 _e_gesture_deactivate_set(struct wl_client *client,
1357                         struct wl_resource *resource,
1358                         struct wl_resource *surface,
1359                         uint32_t type)
1360 {
1361    int ret = TIZEN_GESTURE_ERROR_NONE;
1362
1363    if (type & E_GESTURE_TYPE_EDGE_SWIPE)
1364      {
1365         ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.edge_swipes.base.activation, E_GESTURE_TYPE_EDGE_SWIPE);
1366      }
1367    if (type & E_GESTURE_TYPE_TAP)
1368      {
1369         ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP);
1370      }
1371    if (type & E_GESTURE_TYPE_PALM_COVER)
1372      {
1373         ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER);
1374      }
1375    if (type & E_GESTURE_TYPE_PAN)
1376      {
1377         ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN);
1378      }
1379    if (type & E_GESTURE_TYPE_PINCH)
1380      {
1381         ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.pinchs.activation, E_GESTURE_TYPE_PINCH);
1382      }
1383
1384    return ret;
1385 }
1386
1387 static int
1388 _e_gesture_deactivate_unset(struct wl_client *client,
1389                           struct wl_resource *resource,
1390                           struct wl_resource *surface,
1391                           uint32_t type)
1392 {
1393    int ret = TIZEN_GESTURE_ERROR_NONE;
1394
1395    if (type & E_GESTURE_TYPE_EDGE_SWIPE)
1396      {
1397         _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.edge_swipes.base.activation, E_GESTURE_TYPE_EDGE_SWIPE);
1398      }
1399    if (type & E_GESTURE_TYPE_TAP)
1400      {
1401         _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP);
1402      }
1403    if (type & E_GESTURE_TYPE_PALM_COVER)
1404      {
1405         _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER);
1406      }
1407    if (type & E_GESTURE_TYPE_PAN)
1408      {
1409         _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN);
1410      }
1411    if (type & E_GESTURE_TYPE_PINCH)
1412      {
1413         _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.pinchs.activation, E_GESTURE_TYPE_PINCH);
1414      }
1415
1416    return ret;
1417 }
1418
1419 static void
1420 _e_gesture_cb_grab_edge_swipe(struct wl_client *client,
1421                    struct wl_resource *resource,
1422                    uint32_t fingers, uint32_t edge, uint32_t edge_size,
1423                    uint32_t start_point, uint32_t end_point)
1424 {
1425    int ret = TIZEN_GESTURE_ERROR_NONE;
1426
1427    ret = _e_gesture_grab_edge_swipe(client, resource, fingers, edge, edge_size, start_point, end_point);
1428
1429    tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, edge, edge_size, start_point, end_point, ret);
1430 }
1431
1432 static void
1433 _e_gesture_cb_ungrab_edge_swipe(struct wl_client *client,
1434                            struct wl_resource *resource,
1435                            uint32_t fingers, uint32_t edge, uint32_t edge_size,
1436                            uint32_t start_point, uint32_t end_point)
1437 {
1438    int ret = TIZEN_GESTURE_ERROR_NONE;
1439
1440    ret = _e_gesture_ungrab_edge_swipe(client, resource, fingers, edge, edge_size, start_point, end_point);
1441
1442    tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, edge, edge_size, start_point, end_point, ret);
1443 }
1444
1445 static void
1446 _e_gesture_cb_grab_edge_drag(struct wl_client *client,
1447                         struct wl_resource *resource,
1448                         uint32_t fingers, uint32_t edge, uint32_t edge_size,
1449                         uint32_t start_point, uint32_t end_point)
1450 {
1451    int ret = TIZEN_GESTURE_ERROR_NONE;
1452
1453    ret = _e_gesture_grab_edge_drag(client, resource, fingers, edge, edge_size, start_point, end_point);
1454
1455    tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, edge, edge_size, start_point, end_point, ret);
1456 }
1457
1458 static void
1459 _e_gesture_cb_ungrab_edge_drag(struct wl_client *client,
1460                           struct wl_resource *resource,
1461                           uint32_t fingers, uint32_t edge, uint32_t edge_size,
1462                           uint32_t start_point, uint32_t end_point)
1463 {
1464    int ret = TIZEN_GESTURE_ERROR_NONE;
1465
1466    ret = _e_gesture_ungrab_edge_drag(client, resource, fingers, edge, edge_size, start_point, end_point);
1467
1468    tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, edge, edge_size, start_point, end_point, ret);
1469 }
1470
1471 static void
1472 _e_gesture_cb_grab_tap(struct wl_client *client,
1473                    struct wl_resource *resource,
1474                    uint32_t fingers, uint32_t repeats)
1475 {
1476    int ret = TIZEN_GESTURE_ERROR_NONE;
1477
1478    ret = _e_gesture_grab_tap(client, resource, fingers, repeats);
1479
1480    tizen_gesture_send_tap_notify(resource, fingers, repeats, ret);
1481 }
1482
1483 static void
1484 _e_gesture_cb_ungrab_tap(struct wl_client *client,
1485                    struct wl_resource *resource,
1486                    uint32_t fingers, uint32_t repeats)
1487 {
1488    int ret = TIZEN_GESTURE_ERROR_NONE;
1489
1490    ret = _e_gesture_ungrab_tap(client, resource, fingers, repeats);
1491
1492    tizen_gesture_send_tap_notify(resource, fingers, repeats, ret);
1493 }
1494
1495 static void
1496 _e_gesture_cb_grab_palm_cover(struct wl_client *client,
1497                         struct wl_resource *resource)
1498 {
1499    int ret = TIZEN_GESTURE_ERROR_NONE;
1500
1501    ret = _e_gesture_grab_palm_cover(client, resource);
1502
1503    tizen_gesture_send_palm_cover_notify(resource, NULL, ret);
1504 }
1505
1506 static void
1507 _e_gesture_cb_ungrab_palm_cover(struct wl_client *client,
1508                         struct wl_resource *resource)
1509 {
1510    int ret = TIZEN_GESTURE_ERROR_NONE;
1511
1512    ret = _e_gesture_ungrab_palm_cover(client, resource);
1513
1514    tizen_gesture_send_palm_cover_notify(resource, NULL, ret);
1515 }
1516
1517 static void
1518 _e_gesture_cb_select_palm_cover(struct wl_client *client,
1519                                 struct wl_resource *resource,
1520                                 struct wl_resource *surface)
1521 {
1522    int ret = TIZEN_GESTURE_ERROR_NONE;
1523
1524    ret = _e_gesture_select_palm_cover(client, resource, surface);
1525
1526    tizen_gesture_send_palm_cover_notify(resource, surface, ret);
1527 }
1528
1529 static void
1530 _e_gesture_cb_deselect_palm_cover(struct wl_client *client,
1531                                 struct wl_resource *resource,
1532                                 struct wl_resource *surface)
1533 {
1534    int ret = TIZEN_GESTURE_ERROR_NONE;
1535
1536    ret = _e_gesture_deselect_palm_cover(client, resource, surface);
1537
1538    tizen_gesture_send_palm_cover_notify(resource, surface, ret);
1539 }
1540
1541 static void
1542 _e_gesture_cb_activate_set(struct wl_client *client,
1543                            struct wl_resource *resource,
1544                            struct wl_resource *surface,
1545                            uint32_t type, uint32_t active)
1546 {
1547    int ret = TIZEN_GESTURE_ERROR_NONE;
1548
1549    if (!active)
1550      ret = _e_gesture_deactivate_set(client, resource, surface, type);
1551    else
1552      ret = _e_gesture_deactivate_unset(client, resource, surface, type);
1553
1554    tizen_gesture_send_activate_notify(resource, surface, type, active, ret);
1555 }
1556
1557 static void
1558 _e_gesture_cb_destroy(struct wl_client *client, struct wl_resource *resource)
1559 {
1560    wl_resource_destroy(resource);
1561 }
1562
1563 static const struct tizen_gesture_interface _e_gesture_implementation = {
1564    _e_gesture_cb_grab_edge_swipe,
1565    _e_gesture_cb_ungrab_edge_swipe,
1566    _e_gesture_cb_grab_edge_drag,
1567    _e_gesture_cb_ungrab_edge_drag,
1568    _e_gesture_cb_grab_tap,
1569    _e_gesture_cb_ungrab_tap,
1570    _e_gesture_cb_grab_palm_cover,
1571    _e_gesture_cb_ungrab_palm_cover,
1572    _e_gesture_cb_select_palm_cover,
1573    _e_gesture_cb_deselect_palm_cover,
1574    _e_gesture_cb_activate_set,
1575    _e_gesture_cb_destroy,
1576 };
1577
1578 /* tizen_gesture global object bind function */
1579 static void
1580 _e_gesture_cb_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id)
1581 {
1582    struct wl_resource *resource;
1583
1584    resource = wl_resource_create(client, &tizen_gesture_interface, version, id);
1585
1586    GTDBG("wl_resource_create(...,tizen_gesture_interface,...)\n");
1587
1588    if (!resource)
1589      {
1590         GTERR("Failed to create resource ! (version :%d, id:%d)\n", version, id);
1591         wl_client_post_no_memory(client);
1592          return;
1593      }
1594
1595    wl_resource_set_implementation(resource, &_e_gesture_implementation, NULL, NULL);
1596 }
1597
1598 static Eina_Bool
1599 _e_gesture_event_filter(void *data, void *loop_data EINA_UNUSED, int type, void *event)
1600 {
1601    (void) data;
1602
1603    if (type == ECORE_EVENT_MOUSE_BUTTON_DOWN)
1604      {
1605         gesture->gesture_events.num_pressed++;
1606      }
1607    else if (type == ECORE_EVENT_MOUSE_BUTTON_UP)
1608      {
1609         gesture->gesture_events.num_pressed--;
1610         if (gesture->gesture_events.num_pressed < 0)
1611           gesture->gesture_events.num_pressed = 0;
1612         if (gesture->gesture_events.num_pressed == 0)
1613           {
1614              if (!gesture->enable && gesture->enabled_window)
1615                {
1616                   e_gesture_event_filter_enable(EINA_TRUE);
1617                   return EINA_TRUE;
1618                }
1619              else if (gesture->enable && !gesture->enabled_window)
1620                {
1621                   e_gesture_event_filter_enable(EINA_FALSE);
1622                   return e_gesture_process_events(event, type);
1623                }
1624           }
1625      }
1626    if (!gesture->enable) return EINA_TRUE;
1627
1628    return e_gesture_process_events(event, type);
1629 }
1630
1631 static void
1632 _e_gesture_deactivate_surface_list_check(struct wl_resource *surface, E_Gesture_Activate_Info *info)
1633 {
1634    Eina_Bool res;
1635
1636    res = _e_gesture_deactivate_find_surface(info->surfaces, surface);
1637
1638    if (res) info->active = EINA_FALSE;
1639    else info->active = EINA_TRUE;
1640 }
1641
1642 static void
1643 _e_gesture_deactivate_surface_check(E_Client *ec)
1644 {
1645    struct wl_resource *surface;
1646
1647    EINA_SAFETY_ON_NULL_RETURN(ec);
1648    EINA_SAFETY_ON_NULL_RETURN(ec->comp_data);
1649
1650    surface = ec->comp_data->wl_surface;
1651    if (!surface) return;
1652
1653    if (!gesture->gesture_events.edge_swipes.base.activation.client)
1654      {
1655         _e_gesture_deactivate_surface_list_check(surface, &gesture->gesture_events.edge_swipes.base.activation);
1656      }
1657    if (!gesture->gesture_events.taps.activation.client)
1658      {
1659         _e_gesture_deactivate_surface_list_check(surface, &gesture->gesture_events.taps.activation);
1660      }
1661    if (!gesture->gesture_events.palm_covers.activation.client)
1662      {
1663         _e_gesture_deactivate_surface_list_check(surface, &gesture->gesture_events.palm_covers.activation);
1664      }
1665    if (!gesture->gesture_events.pans.activation.client)
1666      {
1667         _e_gesture_deactivate_surface_list_check(surface, &gesture->gesture_events.pans.activation);
1668      }
1669    if (!gesture->gesture_events.pinchs.activation.client)
1670      {
1671         _e_gesture_deactivate_surface_list_check(surface, &gesture->gesture_events.pinchs.activation);
1672      }
1673 }
1674
1675 static void
1676 _e_gesture_window_gesture_disabled_change(E_Client *ec)
1677 {
1678    if (ec->gesture_disable && gesture->enable)
1679      {
1680         GTINF("Gesture disabled window\n");
1681         gesture->enabled_window = EINA_FALSE;
1682      }
1683    else if (!ec->gesture_disable && !gesture->enable)
1684      {
1685         GTINF("Gesture enabled window\n");
1686         gesture->enabled_window = EINA_TRUE;
1687      }
1688
1689    if (gesture->gesture_events.num_pressed == 0)
1690      {
1691         e_gesture_event_filter_enable(gesture->enabled_window);
1692      }
1693 }
1694
1695 static Eina_Bool
1696 _e_gesture_cb_client_focus_in(void *data, int type, void *event)
1697 {
1698    E_Client *ec;
1699    E_Event_Client *ev = (E_Event_Client *)event;
1700
1701    EINA_SAFETY_ON_NULL_RETURN_VAL(ev, ECORE_CALLBACK_PASS_ON);
1702    ec = ev->ec;
1703    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, ECORE_CALLBACK_PASS_ON);
1704    EINA_SAFETY_ON_NULL_RETURN_VAL(ec->comp_data, ECORE_CALLBACK_PASS_ON);
1705
1706    _e_gesture_window_gesture_disabled_change(ec);
1707    _e_gesture_deactivate_surface_check(ec);
1708    e_gesture_event_deactivate_check();
1709
1710    return ECORE_CALLBACK_PASS_ON;
1711 }
1712
1713 static void
1714 _e_gesture_cb_aux_hint_change(void *data EINA_UNUSED, E_Client *ec)
1715 {
1716    E_Client *qp_ec;
1717    Eina_List *list, *l;
1718    Eina_Bool res_return = EINA_FALSE;
1719    if (e_object_is_del(E_OBJECT(ec)) || !ec->comp_data) return;
1720    if (!ec->comp_data->aux_hint.changed) return;
1721
1722    list = e_service_quickpanels_get();
1723    EINA_LIST_FOREACH(list, l, qp_ec)
1724      {
1725         /* Return if the aux hint change didn't happen to the focused ec */
1726         if ((ec != qp_ec) &&
1727             (ec != e_client_focused_get()))
1728           {
1729              res_return = EINA_TRUE;
1730              break;
1731           }
1732      }
1733    list = eina_list_free(list);
1734
1735    if (res_return) return;
1736
1737    _e_gesture_window_gesture_disabled_change(ec);
1738 }
1739
1740 static void
1741 _e_gesture_init_handlers(void)
1742 {
1743    gesture->ef_handler = ecore_event_filter_add(NULL, _e_gesture_event_filter, NULL, NULL);
1744
1745    gesture->handlers = eina_list_append(gesture->handlers,
1746                                         ecore_event_handler_add(E_EVENT_CLIENT_FOCUS_IN,
1747                                                                 _e_gesture_cb_client_focus_in, NULL));
1748
1749    gesture->hooks = eina_list_append(gesture->hooks,
1750                                      e_client_hook_add(E_CLIENT_HOOK_AUX_HINT_CHANGE,
1751                                                        _e_gesture_cb_aux_hint_change, NULL));
1752
1753    if (e_gesture)
1754      {
1755         e_gesture->edge_swipe.grab = _e_gesture_server_grab_edge_swipe;
1756         e_gesture->edge_swipe.ungrab = _e_gesture_server_ungrab_edge_swipe;
1757         e_gesture->edge_drag.grab = _e_gesture_server_grab_edge_drag;
1758         e_gesture->edge_drag.ungrab = _e_gesture_server_ungrab_edge_drag;
1759         e_gesture->tap.grab = _e_gesture_server_grab_tap;
1760         e_gesture->tap.ungrab = _e_gesture_server_ungrab_tap;
1761         e_gesture->palm_cover.grab = _e_gesture_server_grab_palm_cover;
1762         e_gesture->palm_cover.ungrab = _e_gesture_server_ungrab_palm_cover;
1763         e_gesture->pan.grab = _e_gesture_server_grab_pan;
1764         e_gesture->pan.ungrab = _e_gesture_server_ungrab_pan;
1765         e_gesture->pinch.grab = _e_gesture_server_grab_pinch;
1766         e_gesture->pinch.ungrab = _e_gesture_server_ungrab_pinch;
1767      }
1768 }
1769
1770 static void
1771 _e_gesture_deinit_handlers(void)
1772 {
1773    Ecore_Event_Handler *event_handler;
1774    E_Client_Hook *hook;
1775
1776    ecore_event_filter_del(gesture->ef_handler);
1777
1778    EINA_LIST_FREE(gesture->handlers, event_handler)
1779      {
1780         ecore_event_handler_del(event_handler);
1781      }
1782
1783    EINA_LIST_FREE(gesture->hooks, hook)
1784      {
1785         e_client_hook_del(hook);
1786      }
1787    if (e_gesture)
1788      {
1789         e_gesture->edge_swipe.grab = NULL;
1790         e_gesture->edge_swipe.ungrab = NULL;
1791         e_gesture->edge_drag.grab = NULL;
1792         e_gesture->edge_drag.ungrab = NULL;
1793         e_gesture->tap.grab = NULL;
1794         e_gesture->tap.ungrab = NULL;
1795         e_gesture->palm_cover.grab = NULL;
1796         e_gesture->palm_cover.ungrab = NULL;
1797         e_gesture->pan.grab = NULL;
1798         e_gesture->pan.ungrab = NULL;
1799         e_gesture->pinch.grab = NULL;
1800         e_gesture->pinch.ungrab = NULL;
1801      }
1802 }
1803
1804 static E_Gesture_Config_Data *
1805 _e_gesture_init(E_Module *m)
1806 {
1807    E_Gesture_Config_Data *gconfig = NULL;
1808
1809    gesture = E_NEW(E_Gesture, 1);
1810    if (!gesture)
1811      {
1812         GTERR("Failed to allocate memory for gesture !\n");
1813         return NULL;
1814      }
1815
1816    if (!e_comp)
1817      {
1818         GTERR("Failed to initialize gesture module ! (e_comp == NULL)\n");
1819         goto err;
1820      }
1821
1822    /* Add filtering mechanism
1823     * FIXME: Add handlers after first gesture is grabbed
1824     */
1825    _e_gesture_init_handlers();
1826
1827    /* Init config */
1828    gconfig = E_NEW(E_Gesture_Config_Data, 1);
1829    EINA_SAFETY_ON_NULL_GOTO(gconfig, err);
1830    gconfig->module = m;
1831
1832    e_gesture_conf_init(gconfig);
1833    EINA_SAFETY_ON_NULL_GOTO(gconfig->conf, err);
1834    gesture->config = gconfig;
1835
1836    GTDBG("gesture config value\n");
1837    GTDBG("key_device_name: %s, event_keep: %d\n", gconfig->conf->key_device_name, gconfig->conf->event_keep);
1838    GTDBG("edge_swipe\n");
1839    GTDBG("\ttime_done: %lf, time_begin: %lf, area_offset: %d\n", gconfig->conf->edge_swipe.time_done,
1840                                                                  gconfig->conf->edge_swipe.time_begin,
1841                                                                  gconfig->conf->edge_swipe.area_offset);
1842    GTDBG("\tmin_length: %d, max_length: %d, compose_key: %d, back_key: %d\n", gconfig->conf->edge_swipe.min_length,
1843                                                                               gconfig->conf->edge_swipe.max_length,
1844                                                                               gconfig->conf->edge_swipe.compose_key,
1845                                                                               gconfig->conf->edge_swipe.back_key);
1846    GTDBG("tap\n");
1847    GTDBG("\trepeats_max: %d, moving_range: %d\n", gconfig->conf->tap.repeats_max,
1848                                                   gconfig->conf->tap.moving_range);
1849    GTDBG("\ttime_start: %lf, time_done: %lf, time_interval: %lf\n", gconfig->conf->tap.time_start,
1850                                                                     gconfig->conf->tap.time_done,
1851                                                                     gconfig->conf->tap.time_interval);
1852    GTDBG("pan time_start: %lf, moving_range: %d\n", gconfig->conf->pan.time_start, gconfig->conf->pan.moving_range);
1853    GTDBG("pinch moving_distance_range: %lf\n", gconfig->conf->pinch.moving_distance_range);
1854
1855    gesture->global = wl_global_create(e_comp_wl->wl.disp, &tizen_gesture_interface, 2, gesture, _e_gesture_cb_bind);
1856    if (!gesture->global)
1857      {
1858         GTERR("Failed to create global !\n");
1859         goto err;
1860      }
1861
1862    gesture->gesture_filter = E_GESTURE_TYPE_MAX;
1863
1864    gesture->gesture_events.edge_swipes.base.activation.active = EINA_TRUE;
1865    gesture->gesture_events.edge_drags.base.activation.active = EINA_TRUE;
1866    gesture->gesture_events.taps.activation.active = EINA_TRUE;
1867    gesture->gesture_events.palm_covers.activation.active = EINA_TRUE;
1868    gesture->gesture_events.pans.activation.active = EINA_TRUE;
1869    gesture->gesture_events.pinchs.activation.active = EINA_TRUE;
1870
1871    gesture->gesture_events.event_keep = gconfig->conf->event_keep;
1872    if (gconfig->conf->edge_swipe.default_enable_back)
1873      {
1874         gesture->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE;
1875         gesture->gesture_events.edge_swipes.base.fingers[1].enabled = EINA_TRUE;
1876         _e_gesture_edge_grab_add(&gesture->gesture_events.edge_swipes.base.fingers[1], (void *)0x1, (void *)0x1, E_GESTURE_EDGE_TOP, 0, 0);
1877         gesture->gesture_events.edge_swipes.base.enabled_edge |= (1 << E_GESTURE_EDGE_TOP);
1878         if (gesture->gesture_events.event_keep)
1879           {
1880              gesture->event_state = E_GESTURE_EVENT_STATE_KEEP;
1881           }
1882      }
1883
1884    e_gesture_device_keydev_set(gesture->config->conf->key_device_name);
1885    gesture->enable = EINA_TRUE;
1886
1887    return gconfig;
1888
1889 err:
1890    if (gconfig) e_gesture_conf_deinit(gconfig);
1891    if (gesture && gesture->ef_handler) ecore_event_filter_del(gesture->ef_handler);
1892    if (gesture) E_FREE(gesture);
1893
1894    return NULL;
1895 }
1896
1897 E_API void *
1898 e_modapi_init(E_Module *m)
1899 {
1900    return _e_gesture_init(m);
1901 }
1902
1903 E_API int
1904 e_modapi_shutdown(E_Module *m)
1905 {
1906    Eina_List *l, *l_next;
1907    E_Gesture_Grabbed_Client *gclient;
1908    E_Gesture_Event_Info *event_info;
1909    E_Gesture_Config_Data *gconfig = m->data;
1910
1911    e_gesture_conf_deinit(gconfig);
1912    e_gesture_device_shutdown();
1913    _e_gesture_deinit_handlers();
1914
1915    EINA_LIST_FOREACH_SAFE(gesture->grab_client_list, l, l_next, gclient)
1916      {
1917         if (gclient->destroy_listener)
1918           {
1919              wl_list_remove(&gclient->destroy_listener->link);
1920              E_FREE(gclient->destroy_listener);
1921           }
1922         E_FREE(gclient);
1923         gesture->grab_client_list = eina_list_remove_list(gesture->grab_client_list, l);
1924      }
1925
1926    EINA_LIST_FOREACH_SAFE(gesture->event_queue, l, l_next, event_info)
1927      {
1928         E_FREE(event_info->event);
1929         E_FREE(event_info);
1930         gesture->event_queue = eina_list_remove_list(gesture->event_queue, l);
1931      }
1932
1933    return 1;
1934 }
1935
1936 E_API int
1937 e_modapi_save(E_Module *m)
1938 {
1939    /* Save something to be kept */
1940    E_Gesture_Config_Data *gconfig = m->data;
1941    e_config_domain_save("module.gesture",
1942                         gconfig->conf_edd,
1943                         gconfig->conf);
1944    return 1;
1945 }
1946
1947 static void
1948 _e_gesture_remove_client_edge_swipe(struct wl_client *client, E_Gesture_Grabbed_Client *gclient)
1949 {
1950    int i, j;
1951    Eina_List *l, *ll;
1952    E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes;
1953    E_Gesture_Event_Edge_Finger_Edge *edata;
1954
1955    for (i = 0; i < E_GESTURE_FINGER_MAX + 1; i++)
1956      {
1957         if (gclient->edge_swipe_fingers[i].enabled)
1958           {
1959              for (j = 0; j < E_GESTURE_EDGE_MAX + 1; j++)
1960                {
1961                   EINA_LIST_FOREACH_SAFE(edge_swipes->base.fingers[i].edge[j], l, ll, edata)
1962                     {
1963                        if (edata->client == client)
1964                          {
1965                             edge_swipes->base.fingers[i].edge[j] = eina_list_remove_list(edge_swipes->base.fingers[i].edge[j], l);
1966                             E_FREE(edata);
1967                          }
1968                     }
1969                   EINA_LIST_FOREACH_SAFE(gclient->edge_swipe_fingers[i].edge[j], l, ll, edata)
1970                     {
1971                        if (edata->client == client)
1972                          {
1973                             gclient->edge_swipe_fingers[i].edge[j] = eina_list_remove_list(gclient->edge_swipe_fingers[i].edge[j], l);
1974                             E_FREE(edata);
1975                          }
1976                     }
1977                }
1978           }
1979      }
1980 }
1981
1982 static void
1983 _e_gesture_remove_client_edge_drag(struct wl_client *client, E_Gesture_Grabbed_Client *gclient)
1984 {
1985    int i, j;
1986    Eina_List *l, *ll;
1987    E_Gesture_Event_Edge_Drag *edge_drags = &gesture->gesture_events.edge_drags;
1988    E_Gesture_Event_Edge_Finger_Edge *edata;
1989
1990    for (i = 0; i < E_GESTURE_FINGER_MAX + 1; i++)
1991      {
1992         if (gclient->edge_drag_fingers[i].enabled)
1993           {
1994              for (j = 0; j < E_GESTURE_EDGE_MAX + 1; j++)
1995                {
1996                   EINA_LIST_FOREACH_SAFE(edge_drags->base.fingers[i].edge[j], l, ll, edata)
1997                     {
1998                        if (edata->client == client)
1999                          {
2000                             edge_drags->base.fingers[i].edge[j] = eina_list_remove_list(edge_drags->base.fingers[i].edge[j], l);
2001                             E_FREE(edata);
2002                          }
2003                     }
2004                   EINA_LIST_FOREACH_SAFE(gclient->edge_drag_fingers[i].edge[j], l, ll, edata)
2005                     {
2006                        if (edata->client == client)
2007                          {
2008                             gclient->edge_drag_fingers[i].edge[j] = eina_list_remove_list(gclient->edge_drag_fingers[i].edge[j], l);
2009                             E_FREE(edata);
2010                          }
2011                     }
2012                }
2013           }
2014      }
2015 }
2016
2017
2018 static void
2019 _e_gesture_remove_client_tap(struct wl_client *client, E_Gesture_Grabbed_Client *gclient)
2020 {
2021    int i, j;
2022
2023    for (i = 0; i < E_GESTURE_FINGER_MAX + 1; i++)
2024      {
2025         for (j = 0; j < E_GESTURE_TAP_REPEATS_MAX + 1; j++)
2026           {
2027              if (gclient->tap_fingers[i].repeats[j].client)
2028                {
2029                   if (gesture->gesture_events.taps.fingers[i].repeats[j].client == client)
2030                     {
2031                        gesture->gesture_events.taps.fingers[i].repeats[j].client = NULL;
2032                        gesture->gesture_events.taps.fingers[i].repeats[j].res = NULL;
2033                     }
2034                }
2035              gclient->tap_fingers[i].repeats[j].client = NULL;
2036           }
2037      }
2038 }
2039
2040 static void
2041 _e_gesture_remove_client_pan(struct wl_client *client, E_Gesture_Grabbed_Client *gclient)
2042 {
2043    int i;
2044
2045    for (i = 0; i < E_GESTURE_FINGER_MAX + 1; i++)
2046      {
2047         if (gclient->pan_fingers[i].client)
2048           {
2049              gesture->gesture_events.pans.fingers[i].client = NULL;
2050              gesture->gesture_events.pans.fingers[i].res = NULL;
2051           }
2052         gclient->pan_fingers[i].client = NULL;
2053      }
2054 }
2055
2056 static void
2057 _e_gesture_remove_client_pinch(struct wl_client *client, E_Gesture_Grabbed_Client *gclient)
2058 {
2059    int i;
2060
2061    for (i = 0; i < E_GESTURE_FINGER_MAX + 1; i++)
2062      {
2063         if (gclient->pinch_fingers[i].client)
2064           {
2065              gesture->gesture_events.pinchs.fingers[i].client = NULL;
2066              gesture->gesture_events.pinchs.fingers[i].res = NULL;
2067           }
2068         gclient->pinch_fingers[i].client = NULL;
2069      }
2070 }
2071
2072 static void
2073 _e_gesture_remove_client_palm_cover(struct wl_client *client, E_Gesture_Grabbed_Client *gclient)
2074 {
2075    if (gclient->palm_cover.client)
2076      {
2077         gesture->gesture_events.palm_covers.client_info.client = NULL;
2078         gesture->gesture_events.palm_covers.client_info.res = NULL;
2079      }
2080    gclient->palm_cover.client = NULL;
2081 }
2082
2083
2084 static void
2085 _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data)
2086 {
2087    struct wl_client *client = data;
2088    Eina_List *l_list, *l_next;
2089    E_Gesture_Grabbed_Client *client_data;
2090    unsigned int removed_gesture = 0x0;
2091
2092    EINA_LIST_FOREACH_SAFE(gesture->grab_client_list, l_list, l_next, client_data)
2093      {
2094         if (client_data->client == client)
2095           {
2096              if (client_data->grabbed_gesture & E_GESTURE_TYPE_EDGE_SWIPE)
2097                {
2098                   _e_gesture_remove_client_edge_swipe(client, client_data);
2099                   removed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE;
2100                }
2101              if (client_data->grabbed_gesture & E_GESTURE_TYPE_EDGE_DRAG)
2102                {
2103                   _e_gesture_remove_client_edge_drag(client, client_data);
2104                   removed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE;
2105                }
2106              if (client_data->grabbed_gesture & E_GESTURE_TYPE_TAP)
2107                {
2108                   _e_gesture_remove_client_tap(client, client_data);
2109                   removed_gesture |= E_GESTURE_TYPE_TAP;
2110                }
2111              if (client_data->grabbed_gesture & E_GESTURE_TYPE_PAN)
2112                {
2113                   _e_gesture_remove_client_pan(client, client_data);
2114                   removed_gesture |= E_GESTURE_TYPE_PAN;
2115                }
2116              if (client_data->grabbed_gesture & E_GESTURE_TYPE_PINCH)
2117                {
2118                   _e_gesture_remove_client_pinch(client, client_data);
2119                   removed_gesture |= E_GESTURE_TYPE_PINCH;
2120                }
2121              if (client_data->grabbed_gesture & E_GESTURE_TYPE_PALM_COVER)
2122                {
2123                   _e_gesture_remove_client_palm_cover(client, client_data);
2124                   removed_gesture |= E_GESTURE_TYPE_PALM_COVER;
2125                }
2126           }
2127      }
2128
2129    if (removed_gesture & E_GESTURE_TYPE_EDGE_SWIPE)
2130      _e_gesture_edge_swipe_current_list_check();
2131    if (removed_gesture & E_GESTURE_TYPE_EDGE_DRAG)
2132      _e_gesture_edge_drag_current_list_check();
2133    if (removed_gesture & E_GESTURE_TYPE_TAP)
2134      _e_gesture_tap_current_list_check();
2135    if (removed_gesture & E_GESTURE_TYPE_PAN)
2136      _e_gesture_pan_current_list_check();
2137    if (removed_gesture & E_GESTURE_TYPE_PINCH)
2138      _e_gesture_pinch_current_list_check();
2139    if (removed_gesture & E_GESTURE_TYPE_PALM_COVER)
2140      gesture->grabbed_gesture &= ~E_GESTURE_TYPE_PALM_COVER;
2141
2142    wl_list_remove(&l->link);
2143    E_FREE(l);
2144
2145    EINA_LIST_FOREACH_SAFE(gesture->grab_client_list, l_list, l_next, client_data)
2146      {
2147         if (client_data->client == client)
2148           {
2149              gesture->grab_client_list = eina_list_remove(gesture->grab_client_list, client_data);
2150              E_FREE(client_data);
2151           }
2152      }
2153
2154    gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture;
2155 }
2156
2157 static void
2158 _e_gesture_wl_surface_cb_destroy(struct wl_listener *l, void *data)
2159 {
2160    struct wl_resource *surface = (struct wl_resource *)data;
2161    E_Gesture_Event_Palm_Cover *palm_covers = &gesture->gesture_events.palm_covers;
2162    Eina_List *list, *l_next;
2163    struct wl_resource *surface_data;
2164    E_Gesture_Select_Surface *sdata;
2165
2166    EINA_LIST_FOREACH_SAFE(gesture->select_surface_list, list, l_next, surface_data)
2167      {
2168         if (surface_data == surface)
2169           {
2170              gesture->select_surface_list = eina_list_remove_list(gesture->select_surface_list, list);
2171           }
2172      }
2173
2174    EINA_LIST_FOREACH_SAFE(palm_covers->select_surface_list, list, l_next, sdata)
2175      {
2176         if (sdata->surface == surface)
2177           {
2178              palm_covers->select_surface_list = eina_list_remove_list(palm_covers->select_surface_list, list);
2179              E_FREE(sdata);
2180           }
2181      }
2182
2183    wl_list_remove(&l->link);
2184    E_FREE(l);
2185 }
2186
2187 void
2188 e_gesture_event_filter_enable(Eina_Bool enabled)
2189 {
2190    if (enabled && !gesture->enable)
2191      {
2192         GTINF("Gestures will be enabled by for now.\n");
2193         gesture->enable = EINA_TRUE;
2194      }
2195    else if (!enabled && gesture->enable)
2196      {
2197         GTINF("Gestures will be enabled from now.\n");
2198         gesture->enable = EINA_FALSE;
2199      }
2200 }