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
  12
  13 static void _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data);
  14
  15 static void
  16 _e_gesture_edge_swipe_set_client_to_list(struct wl_client *client, E_Gesture_Event_Edge_Swipe_Finger *fingers, unsigned int edge)
  17 {
  18    if (edge & TIZEN_GESTURE_EDGE_TOP)
  19      fingers->edge[E_GESTURE_EDGE_TOP].client = client;
  20    if (edge & TIZEN_GESTURE_EDGE_RIGHT)
  21      fingers->edge[E_GESTURE_EDGE_RIGHT].client = client;
  22    if (edge & TIZEN_GESTURE_EDGE_BOTTOM)
  23      fingers->edge[E_GESTURE_EDGE_BOTTOM].client = client;
  24    if (edge & TIZEN_GESTURE_EDGE_LEFT)
  25      fingers->edge[E_GESTURE_EDGE_LEFT].client = client;
  26 }
  27
  28 /* Function for registering wl_client destroy listener */
  29 int
  30 e_gesture_add_client_destroy_listener(struct wl_client *client, int mode EINA_UNUSED, int fingers, unsigned int edge)
  31 {
  32    struct wl_listener *destroy_listener = NULL;
  33    Eina_List *l;
  34    E_Gesture_Grabbed_Client *grabbed_client, *data;
  35
  36    EINA_LIST_FOREACH(gesture->grab_client_list, l, data)
  37      {
  38         if (data->client == client)
  39           {
  40              _e_gesture_edge_swipe_set_client_to_list(client, &data->edge_swipe_fingers[fingers], edge);
  41
  42              return TIZEN_GESTURE_ERROR_NONE;
  43           }
  44      }
  45
  46    destroy_listener = E_NEW(struct wl_listener, 1);
  47    if (!destroy_listener)
  48      {
  49         GTERR("Failed to allocate memory for wl_client destroy listener !\n");
  50         return TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES;
  51      }
  52
  53    grabbed_client = E_NEW(E_Gesture_Grabbed_Client, 1);
  54    if (!grabbed_client)
  55      {
  56         GTERR("Failed to allocate memory to save client information !\n");
  57         return TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES;
  58      }
  59
  60    destroy_listener->notify = _e_gesture_wl_client_cb_destroy;
  61    wl_client_add_destroy_listener(client, destroy_listener);
  62    grabbed_client->client = client;
  63    grabbed_client->destroy_listener = destroy_listener;
  64    _e_gesture_edge_swipe_set_client_to_list(client, &grabbed_client->edge_swipe_fingers[fingers], edge);
  65
  66    gesture->grab_client_list = eina_list_append(gesture->grab_client_list, grabbed_client);
  67
  68    return TIZEN_KEYROUTER_ERROR_NONE;
  69 }
  70
  71 static void
  72 _e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int fingers, unsigned int edge)
  73 {
  74    Eina_List *l, *l_next;
  75    E_Gesture_Grabbed_Client *data;
  76    int i;
  77
  78    EINA_LIST_FOREACH_SAFE(gesture->grab_client_list, l, l_next, data)
  79      {
  80         if (data->client == client)
  81           {
  82              _e_gesture_edge_swipe_set_client_to_list(NULL, &data->edge_swipe_fingers[fingers], edge);
  83
  84              for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++)
  85                {
  86                   if (data->edge_swipe_fingers[i].edge[E_GESTURE_EDGE_TOP].client ||
  87                       data->edge_swipe_fingers[i].edge[E_GESTURE_EDGE_RIGHT].client ||
  88                       data->edge_swipe_fingers[i].edge[E_GESTURE_EDGE_BOTTOM].client ||
  89                       data->edge_swipe_fingers[i].edge[E_GESTURE_EDGE_LEFT].client)
  90                     {
  91                        return;
  92                     }
  93                }
  94              wl_list_remove(&data->destroy_listener->link);
  95              E_FREE(data->destroy_listener);
  96              gesture->grab_client_list = eina_list_remove(gesture->grab_client_list, data);
  97              E_FREE(data);
  98           }
  99      }
 100 }
 101
 102 static void
 103 _e_gesture_cb_grab_edge_swipe(struct wl_client *client,
 104                    struct wl_resource *resource,
 105                    uint32_t fingers, uint32_t edge)
 106 {
 107    E_Gesture_Event *gev;
 108    unsigned int grabbed_edge = 0x0;
 109
 110    GTINF("client %p is request grab gesture, fingers: %d, edge: 0x%x\n", client, fingers, edge);
 111    if (fingers > E_GESTURE_FINGER_MAX)
 112      {
 113         GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX);
 114         tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, edge, TIZEN_GESTURE_ERROR_INVALID_DATA);
 115         goto out;
 116      }
 117
 118    gev = &gesture->gesture_events;
 119
 120    if (edge & TIZEN_GESTURE_EDGE_TOP)
 121      {
 122         if (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_TOP].client)
 123            {
 124               grabbed_edge |= TIZEN_GESTURE_EDGE_TOP;
 125            }
 126         else
 127            {
 128               gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_TOP].client = client;
 129               gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_TOP].res = resource;
 130            }
 131      }
 132    if (edge & TIZEN_GESTURE_EDGE_RIGHT)
 133      {
 134         if (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_RIGHT].client)
 135            {
 136               grabbed_edge |= TIZEN_GESTURE_EDGE_RIGHT;
 137            }
 138         else
 139            {
 140               gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_RIGHT].client = client;
 141               gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_RIGHT].res = resource;
 142            }
 143      }
 144    if (edge & TIZEN_GESTURE_EDGE_BOTTOM)
 145      {
 146         if (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_BOTTOM].client)
 147            {
 148               grabbed_edge |= TIZEN_GESTURE_EDGE_BOTTOM;
 149            }
 150         else
 151            {
 152               gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_BOTTOM].client = client;
 153               gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_BOTTOM].res = resource;
 154            }
 155      }
 156    if (edge & TIZEN_GESTURE_EDGE_LEFT)
 157      {
 158         if (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_LEFT].client)
 159            {
 160               grabbed_edge |= TIZEN_GESTURE_EDGE_LEFT;
 161            }
 162         else
 163            {
 164               gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_LEFT].client = client;
 165               gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_LEFT].res = resource;
 166            }
 167      }
 168
 169    if (grabbed_edge)
 170      tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, grabbed_edge, TIZEN_GESTURE_ERROR_GRABBED_ALREADY);
 171
 172    e_gesture_add_client_destroy_listener(client, TIZEN_GESTURE_TYPE_EDGE_SWIPE, fingers, edge & ~grabbed_edge);
 173    gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_EDGE_SWIPE;
 174    gev->edge_swipes.fingers[fingers].enabled = EINA_TRUE;
 175    if (gev->edge_swipes.event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_KEEP;
 176    gev->edge_swipes.enabled_edge |= grabbed_edge;
 177
 178    if (!grabbed_edge)
 179      tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, edge, TIZEN_GESTURE_ERROR_NONE);
 180
 181 out:
 182    return;
 183 }
 184
 185 static void
 186 _e_gesture_cb_ungrab_edge_swipe(struct wl_client *client,
 187                            struct wl_resource *resouce,
 188                            uint32_t fingers, uint32_t edge)
 189 {
 190    int i, j;
 191    E_Gesture_Event *gev;
 192    unsigned int ungrabbed_edge = 0x0;
 193    int ret = TIZEN_GESTURE_ERROR_NONE;
 194
 195    GTINF("client %p is request ungrab edge swipe gesture, fingers: %d, edge: 0x%x, client: %p\n", client, fingers, edge, gesture->gesture_events.edge_swipes.fingers[0].edge[3].client);
 196
 197    if (fingers > E_GESTURE_FINGER_MAX)
 198      {
 199         GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX);
 200         ret = TIZEN_GESTURE_ERROR_INVALID_DATA;
 201         goto notify;
 202      }
 203
 204    gev = &gesture->gesture_events;
 205
 206    if (edge & TIZEN_GESTURE_EDGE_TOP)
 207      {
 208         if ((gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_TOP].client) &&
 209             (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_TOP].client == client))
 210            {
 211               gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_TOP].client = NULL;
 212               gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_TOP].res = NULL;
 213            }
 214         else
 215            {
 216               ungrabbed_edge |= TIZEN_GESTURE_EDGE_TOP;
 217            }
 218      }
 219    if (edge & TIZEN_GESTURE_EDGE_RIGHT)
 220      {
 221         if ((gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_RIGHT].client) &&
 222             (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_RIGHT].client == client))
 223            {
 224               gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_RIGHT].client = NULL;
 225               gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_RIGHT].res = NULL;
 226            }
 227         else
 228            {
 229               ungrabbed_edge |= TIZEN_GESTURE_EDGE_RIGHT;
 230            }
 231      }
 232    if (edge & TIZEN_GESTURE_EDGE_BOTTOM)
 233      {
 234         if ((gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_BOTTOM].client) &&
 235             (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_BOTTOM].client == client))
 236            {
 237               gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_BOTTOM].client = NULL;
 238               gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_BOTTOM].res = NULL;
 239            }
 240         else
 241            {
 242               ungrabbed_edge |= TIZEN_GESTURE_EDGE_BOTTOM;
 243            }
 244      }
 245    if (edge & TIZEN_GESTURE_EDGE_LEFT)
 246      {
 247         if ((gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_LEFT].client) &&
 248             (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_LEFT].client == client))
 249            {
 250               gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_LEFT].client = NULL;
 251               gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_LEFT].res = NULL;
 252            }
 253         else
 254            {
 255               ungrabbed_edge |= TIZEN_GESTURE_EDGE_LEFT;
 256            }
 257      }
 258
 259    if (edge & ~ungrabbed_edge)
 260      {
 261         _e_gesture_remove_client_destroy_listener(client, fingers, edge & ~ungrabbed_edge);
 262         for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++)
 263           {
 264              for (j = 0; j < E_GESTURE_EDGE_MAX+1; j++)
 265                {
 266                   if (gev->edge_swipes.fingers[i].edge[j].client)
 267                     {
 268                        goto finish;
 269                     }
 270                }
 271              gev->edge_swipes.fingers[i].enabled = EINA_FALSE;
 272           }
 273         gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_EDGE_SWIPE;
 274         if (gev->edge_swipes.event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE;
 275      }
 276
 277 finish:
 278    gev->edge_swipes.enabled_edge &= ~edge;
 279    for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++)
 280      {
 281         for (j = 1; j < E_GESTURE_EDGE_MAX+1; j++)
 282           {
 283              if (gev->edge_swipes.fingers[i].edge[j].client)
 284                {
 285                   gev->edge_swipes.enabled_edge |= (1 <<  (j - 1));
 286                }
 287           }
 288         if (gev->edge_swipes.enabled_edge == E_GESTURE_EDGE_ALL) break;
 289      }
 290
 291 notify:
 292    tizen_gesture_send_grab_edge_swipe_notify(resouce, fingers, edge, ret);
 293    return;
 294 }
 295
 296 static const struct tizen_gesture_interface _e_gesture_implementation = {
 297    _e_gesture_cb_grab_edge_swipe,
 298    _e_gesture_cb_ungrab_edge_swipe
 299 };
 300
 301 /* tizen_gesture global object destroy function */
 302 static void
 303 _e_gesture_cb_destory(struct wl_resource *resource)
 304 {
 305    /* TODO : destroy resources if exist */
 306 }
 307
 308 /* tizen_keyrouter global object bind function */
 309 static void
 310 _e_gesture_cb_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id)
 311 {
 312    E_GesturePtr gesture_instance = data;
 313    struct wl_resource *resource;
 314
 315    resource = wl_resource_create(client, &tizen_gesture_interface, MIN(version, 1), id);
 316
 317    GTDBG("wl_resource_create(...,tizen_gesture_interface,...)\n");
 318
 319    if (!resource)
 320      {
 321         GTERR("Failed to create resource ! (version :%d, id:%d)\n", version, id);
 322         wl_client_post_no_memory(client);
 323          return;
 324      }
 325
 326    wl_resource_set_implementation(resource, &_e_gesture_implementation, gesture_instance, _e_gesture_cb_destory);
 327 }
 328
 329 static Eina_Bool
 330 _e_gesture_event_filter(void *data, void *loop_data EINA_UNUSED, int type, void *event)
 331 {
 332    (void) data;
 333
 334    if (type == ECORE_EVENT_MOUSE_BUTTON_DOWN)
 335      {
 336         gesture->gesture_events.num_pressed++;
 337      }
 338    else if (type == ECORE_EVENT_MOUSE_BUTTON_UP)
 339      {
 340         gesture->gesture_events.num_pressed--;
 341         if (gesture->gesture_events.num_pressed < 0)
 342           gesture->gesture_events.num_pressed = 0;
 343         if (gesture->gesture_events.num_pressed == 0)
 344           {
 345              if (!gesture->enable && gesture->enabled_window)
 346                {
 347                   e_gesture_event_filter_enable(EINA_TRUE);
 348                   return EINA_TRUE;
 349                }
 350              else if (gesture->enable && !gesture->enabled_window)
 351                {
 352                   e_gesture_event_filter_enable(EINA_FALSE);
 353                   return e_gesture_process_events(event, type);
 354                }
 355           }
 356      }
 357    if (!gesture->enable) return EINA_TRUE;
 358
 359    return e_gesture_process_events(event, type);
 360 }
 361
 362 static void
 363 _e_gesture_window_gesture_disabled_change(E_Client *ec)
 364 {
 365    if (ec->gesture_disable && gesture->enable)
 366      {
 367         GTINF("Gesture disabled window\n");
 368         gesture->enabled_window = EINA_FALSE;
 369      }
 370    else if (!ec->gesture_disable && !gesture->enable)
 371      {
 372         GTINF("Gesture enabled window\n");
 373         gesture->enabled_window = EINA_TRUE;
 374      }
 375
 376    if (gesture->gesture_events.num_pressed == 0)
 377      {
 378         e_gesture_event_filter_enable(gesture->enabled_window);
 379      }
 380 }
 381
 382 static Eina_Bool
 383 _e_gesture_cb_client_focus_in(void *data, int type, void *event)
 384 {
 385    E_Client *ec;
 386    E_Event_Client *ev = (E_Event_Client *)event;
 387
 388    EINA_SAFETY_ON_NULL_RETURN_VAL(ev, ECORE_CALLBACK_PASS_ON);
 389    ec = ev->ec;
 390    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, ECORE_CALLBACK_PASS_ON);
 391    EINA_SAFETY_ON_NULL_RETURN_VAL(ec->comp_data, ECORE_CALLBACK_PASS_ON);
 392
 393    _e_gesture_window_gesture_disabled_change(ec);
 394
 395    return ECORE_CALLBACK_PASS_ON;
 396 }
 397
 398 static void
 399 _e_gesture_cb_aux_hint_change(void *data EINA_UNUSED, E_Client *ec)
 400 {
 401    E_Client *qp_ec;
 402    if (e_object_is_del(E_OBJECT(ec)) || !ec->comp_data) return;
 403    if (!ec->comp_data->aux_hint.changed) return;
 404
 405    qp_ec = e_service_quickpanel_client_get();
 406
 407    /* Return if the aux hint change didn't happen to the focused ec */
 408    if ((ec != qp_ec) &&
 409        (ec != e_client_focused_get()))
 410      return;
 411
 412    _e_gesture_window_gesture_disabled_change(ec);
 413 }
 414
 415 static void
 416 _e_gesture_init_handlers(void)
 417 {
 418    gesture->ef_handler = ecore_event_filter_add(NULL, _e_gesture_event_filter, NULL, NULL);
 419
 420    gesture->handlers = eina_list_append(gesture->handlers,
 421                                         ecore_event_handler_add(E_EVENT_CLIENT_FOCUS_IN,
 422                                                                 _e_gesture_cb_client_focus_in, NULL));
 423
 424    gesture->hooks = eina_list_append(gesture->hooks,
 425                                      e_client_hook_add(E_CLIENT_HOOK_AUX_HINT_CHANGE,
 426                                                        _e_gesture_cb_aux_hint_change, NULL));
 427 }
 428
 429 static void
 430 _e_gesture_deinit_handlers(void)
 431 {
 432    Ecore_Event_Handler *event_handler;
 433    E_Client_Hook *hook;
 434
 435    ecore_event_filter_del(gesture->ef_handler);
 436
 437    EINA_LIST_FREE(gesture->handlers, event_handler)
 438      {
 439         ecore_event_handler_del(event_handler);
 440      }
 441
 442    EINA_LIST_FREE(gesture->hooks, hook)
 443      {
 444         e_client_hook_del(hook);
 445      }
 446 }
 447
 448 static E_Gesture_Config_Data *
 449 _e_gesture_init(E_Module *m)
 450 {
 451    E_Gesture_Config_Data *gconfig = NULL;
 452    gesture = E_NEW(E_Gesture, 1);
 453
 454    if (!gesture)
 455      {
 456         GTERR("Failed to allocate memory for gesture !\n");
 457         return NULL;
 458      }
 459
 460    if (!e_comp)
 461      {
 462         GTERR("Failed to initialize gesture module ! (e_comp == NULL)\n");
 463         goto err;
 464      }
 465
 466    /* Add filtering mechanism
 467     * FIXME: Add handlers after first gesture is grabbed
 468     */
 469    _e_gesture_init_handlers();
 470
 471    /* Init config */
 472    gconfig = E_NEW(E_Gesture_Config_Data, 1);
 473    EINA_SAFETY_ON_NULL_GOTO(gconfig, err);
 474    gconfig->module = m;
 475
 476    e_gesture_conf_init(gconfig);
 477    EINA_SAFETY_ON_NULL_GOTO(gconfig->conf, err);
 478    gesture->config = gconfig;
 479
 480    GTDBG("config value\n");
 481    GTDBG("keyboard: %s, time_done: %lf, time_begin: %lf\n", gconfig->conf->key_device_name, gconfig->conf->edge_swipe.time_done, gconfig->conf->edge_swipe.time_begin);
 482    GTDBG("area_offset: %d, min_length: %d, max_length: %d\n", gconfig->conf->edge_swipe.area_offset, gconfig->conf->edge_swipe.min_length, gconfig->conf->edge_swipe.max_length);
 483    GTDBG("compose key: %d, back: %d, default: %d\n", gconfig->conf->edge_swipe.compose_key, gconfig->conf->edge_swipe.back_key, gconfig->conf->edge_swipe.default_enable_back);
 484
 485    gesture->global = wl_global_create(e_comp_wl->wl.disp, &tizen_gesture_interface, 1, gesture, _e_gesture_cb_bind);
 486    if (!gesture->global)
 487      {
 488         GTERR("Failed to create global !\n");
 489         goto err;
 490      }
 491
 492    gesture->gesture_filter = E_GESTURE_TYPE_MAX;
 493
 494    gesture->gesture_events.edge_swipes.event_keep = gconfig->conf->edge_swipe.event_keep;
 495    if (gconfig->conf->edge_swipe.default_enable_back)
 496      {
 497         gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_EDGE_SWIPE;
 498         gesture->gesture_events.edge_swipes.fingers[1].enabled = EINA_TRUE;
 499         gesture->gesture_events.edge_swipes.fingers[1].edge[E_GESTURE_EDGE_TOP].client = (void *)0x1;
 500         gesture->gesture_events.edge_swipes.fingers[1].edge[E_GESTURE_EDGE_TOP].res = (void *)0x1;
 501         gesture->gesture_events.edge_swipes.enabled_edge |= TIZEN_GESTURE_EDGE_TOP;
 502         if (gesture->gesture_events.edge_swipes.event_keep)
 503             {
 504                gesture->event_state = E_GESTURE_EVENT_STATE_KEEP;
 505             }
 506      }
 507
 508    e_gesture_device_keydev_set(gesture->config->conf->key_device_name);
 509    gesture->enable = EINA_TRUE;
 510
 511    return gconfig;
 512
 513 err:
 514    if (gconfig) e_gesture_conf_deinit(gconfig);
 515    if (gesture && gesture->ef_handler) ecore_event_filter_del(gesture->ef_handler);
 516    if (gesture) E_FREE(gesture);
 517
 518    return NULL;
 519 }
 520
 521 E_API void *
 522 e_modapi_init(E_Module *m)
 523 {
 524    return _e_gesture_init(m);
 525 }
 526
 527 E_API int
 528 e_modapi_shutdown(E_Module *m)
 529 {
 530    E_Gesture_Config_Data *gconfig = m->data;
 531    e_gesture_conf_deinit(gconfig);
 532    e_gesture_device_shutdown();
 533    _e_gesture_deinit_handlers();
 534    return 1;
 535 }
 536
 537 E_API int
 538 e_modapi_save(E_Module *m)
 539 {
 540    /* Save something to be kept */
 541    E_Gesture_Config_Data *gconfig = m->data;
 542    e_config_domain_save("module.gesture",
 543                         gconfig->conf_edd,
 544                         gconfig->conf);
 545    return 1;
 546 }
 547
 548 static void
 549 _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data)
 550 {
 551    struct wl_client *client = data;
 552    int i, j;
 553    Eina_List *l_list, *l_next;
 554    E_Gesture_Grabbed_Client *client_data;
 555
 556    if (gesture->grabbed_gesture & TIZEN_GESTURE_TYPE_EDGE_SWIPE)
 557      {
 558         for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++)
 559           {
 560              for (j = 0; j < E_GESTURE_EDGE_MAX+1; j++)
 561                {
 562                   if (gesture->gesture_events.edge_swipes.fingers[i].edge[j].client == client)
 563                     {
 564                        gesture->gesture_events.edge_swipes.fingers[i].edge[j].client = NULL;
 565                        gesture->gesture_events.edge_swipes.fingers[i].edge[j].res = NULL;
 566                     }
 567                }
 568           }
 569
 570         for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++)
 571           {
 572              for (j = 0; j < E_GESTURE_EDGE_MAX+1; j++)
 573                {
 574                   if (gesture->gesture_events.edge_swipes.fingers[i].edge[j].client)
 575                     {
 576                        goto out;
 577                     }
 578                }
 579              gesture->gesture_events.edge_swipes.fingers[i].enabled = EINA_FALSE;
 580           }
 581         gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_EDGE_SWIPE;
 582      }
 583
 584 out:
 585    E_FREE(l);
 586    l = NULL;
 587    EINA_LIST_FOREACH_SAFE(gesture->grab_client_list, l_list, l_next, client_data)
 588      {
 589         if (client_data->client == client)
 590           {
 591              gesture->grab_client_list = eina_list_remove(gesture->grab_client_list, client_data);
 592              E_FREE(client_data);
 593           }
 594      }
 595 }
 596
 597 void
 598 e_gesture_event_filter_enable(Eina_Bool enabled)
 599 {
 600    if (enabled && !gesture->enable)
 601      {
 602         GTINF("Gestures will be enabled by for now.\n");
 603         gesture->enable = EINA_TRUE;
 604      }
 605    else if (!enabled && gesture->enable)
 606      {
 607         GTINF("Gestures will be enabled from now.\n");
 608         gesture->enable = EINA_FALSE;
 609      }
 610 }