From 51b011f9ef912e00786999cb59e7607dfb19bc94 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Fri, 14 Jul 2017 21:02:45 +0900 Subject: [PATCH 01/16] support a palm_cover select/deselect Change-Id: Ieac116606af8e43a43d6c57aaf70b3e3b179c513 --- src/e_mod_gesture_events.c | 34 ++++++++- src/e_mod_main.c | 173 ++++++++++++++++++++++++++++++++++++++++++--- src/e_mod_main.h | 9 +++ 3 files changed, 205 insertions(+), 11 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index d1afb28..08c312a 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -617,6 +617,16 @@ _e_gesture_util_rect_get(int finger, int *x1, int *y1, int *x2, int *y2) } } +static struct wl_resource * +_e_gesture_util_eclient_surface_get(E_Client *ec) +{ + if (!ec) return NULL; + if (e_object_is_del(E_OBJECT(ec))) return NULL; + if (!ec->comp_data) return NULL; + + return ec->comp_data->surface; +} + static Eina_Bool _e_gesture_timer_pan_start(void *data) { @@ -1360,7 +1370,9 @@ _e_gesture_send_palm_cover(void) int cx = 0, cy = 0; unsigned int size = 0; wl_fixed_t pressure; - struct wl_resource *surface = NULL; + struct wl_resource *surface = NULL, *res = NULL, *focus_surface = NULL; + Eina_List *l; + E_Gesture_Select_Surface *sdata; time = (int)(ecore_time_get()*1000); @@ -1385,6 +1397,26 @@ _e_gesture_send_palm_cover(void) pressure = wl_fixed_from_double(0.0); + focus_surface = _e_gesture_util_eclient_surface_get(e_client_focused_get()); + if (focus_surface) + { + EINA_LIST_FOREACH(palm_covers->select_surface_list, l, sdata) + { + if (focus_surface == sdata->surface) + { + surface = sdata->surface; + res = sdata->res; + break; + } + } + } + + if (!surface || !res) + { + res = palm_covers->client_info.res; + surface = NULL; + } + tizen_gesture_send_palm_cover(palm_covers->client_info.res, surface, TIZEN_GESTURE_MODE_BEGIN, duration, size, pressure, cx, cy); tizen_gesture_send_palm_cover(palm_covers->client_info.res, surface, TIZEN_GESTURE_MODE_END, duration, size, pressure, cx, cy); diff --git a/src/e_mod_main.c b/src/e_mod_main.c index a682874..5871936 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -9,6 +9,7 @@ E_API E_Module_Api e_modapi = { E_MODULE_API_VERSION, "Gesture Module of Window static E_Gesture_Config_Data *_e_gesture_init(E_Module *m); static void _e_gesture_init_handlers(void); static void _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data); +static void _e_gesture_wl_surface_cb_destroy(struct wl_listener *l, void *data); static Eina_Bool _e_gesture_edge_swipe_boundary_check(E_Gesture_Event_Edge_Swipe_Finger *fingers, unsigned int edge, int sp, int ep) @@ -227,14 +228,11 @@ _e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int data->grabbed_gesture &= ~E_GESTURE_TYPE_EDGE_SWIPE; for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) { - if (data->edge_swipe_fingers[i].enabled || - data->edge_swipe_fingers[i].enabled || - data->edge_swipe_fingers[i].enabled || - data->edge_swipe_fingers[i].enabled) - { - data->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; - break; - } + if (data->edge_swipe_fingers[i].enabled) + { + data->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; + break; + } } } @@ -491,6 +489,131 @@ _e_gesture_ungrab_palm_cover(struct wl_client *client, struct wl_resource *resou return ret; } +static int +_e_gesture_add_surface_destroy_listener(struct wl_resource *surface, int type) +{ + struct wl_listener *destroy_listener = NULL; + Eina_List *l; + struct wl_resource *surface_data; + + EINA_SAFETY_ON_NULL_RETURN_VAL(surface, TIZEN_GESTURE_ERROR_INVALID_DATA); + if (type != E_GESTURE_TYPE_PALM_COVER) + return TIZEN_GESTURE_ERROR_INVALID_DATA; + + EINA_LIST_FOREACH(gesture->select_surface_list, l, surface_data) + { + if (surface_data == surface) + { + return TIZEN_GESTURE_ERROR_NONE; + } + } + + destroy_listener = E_NEW(struct wl_listener, 1); + if (!destroy_listener) + { + GTERR("Failed to allocate memory for wl_client destroy listener !\n"); + return TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES; + } + + destroy_listener->notify = _e_gesture_wl_surface_cb_destroy; + wl_resource_add_destroy_listener(surface, destroy_listener); + + gesture->select_surface_list = eina_list_append(gesture->select_surface_list, surface); + + return TIZEN_GESTURE_ERROR_NONE; +} + + +static int +_e_gesture_select_palm_cover(struct wl_client *client, struct wl_resource *resource, + struct wl_resource *surface) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + Eina_List *l; + E_Gesture_Event_Palm_Cover *palm_covers = &gesture->gesture_events.palm_covers; + E_Gesture_Select_Surface *sdata; + + EINA_LIST_FOREACH(palm_covers->select_surface_list, l, sdata) + { + if (sdata->surface == surface) + { + ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; + goto out; + } + } + + sdata = E_NEW(E_Gesture_Select_Surface, 1); + if (!sdata) + { + ret = TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES; + goto out; + } + + sdata->surface = surface; + sdata->res = resource; + + palm_covers->select_surface_list = eina_list_append(palm_covers->select_surface_list, sdata); + + _e_gesture_add_surface_destroy_listener(surface, E_GESTURE_TYPE_PALM_COVER); + +out: + return ret; +} + +static void +_e_gesture_remove_surface_destroy_listener(struct wl_resource *surface, int type) +{ + Eina_List *l, *l_next; + struct wl_resource *surface_data; + struct wl_listener *destroy_listener; + + EINA_SAFETY_ON_NULL_RETURN(surface); + if (type != E_GESTURE_TYPE_PALM_COVER) return; + + destroy_listener = wl_resource_get_destroy_listener(surface, _e_gesture_wl_surface_cb_destroy); + if (!destroy_listener) + { + GTWRN("surface(%p) is not gesture selected surface\n", surface); + } + + EINA_LIST_FOREACH_SAFE(gesture->select_surface_list, l, l_next, surface_data) + { + if (surface_data == surface) + { + gesture->select_surface_list = eina_list_remove_list(gesture->select_surface_list, l); + break; + } + } + + wl_list_remove(&destroy_listener->link); + E_FREE(destroy_listener); +} + +static int +_e_gesture_deselect_palm_cover(struct wl_client *client, struct wl_resource *resource, + struct wl_resource *surface) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + Eina_List *l, *l_next; + E_Gesture_Event_Palm_Cover *palm_covers = &gesture->gesture_events.palm_covers; + E_Gesture_Select_Surface *sdata; + + EINA_LIST_FOREACH_SAFE(palm_covers->select_surface_list, l, l_next, sdata) + { + if (sdata->surface == surface) + { + palm_covers->select_surface_list = eina_list_remove_list(palm_covers->select_surface_list, l); + E_FREE(sdata); + break; + } + } + + _e_gesture_remove_surface_destroy_listener(surface, E_GESTURE_TYPE_PALM_COVER); + + return ret; +} + + static void _e_gesture_cb_grab_edge_swipe(struct wl_client *client, struct wl_resource *resource, @@ -823,7 +946,7 @@ _e_gesture_cb_select_palm_cover(struct wl_client *client, { int ret = TIZEN_GESTURE_ERROR_NONE; - ret = TIZEN_GESTURE_ERROR_NOT_SUPPORTED; + ret = _e_gesture_select_palm_cover(client, resource, surface); tizen_gesture_send_palm_cover_notify(resource, surface, ret); } @@ -835,7 +958,7 @@ _e_gesture_cb_deselect_palm_cover(struct wl_client *client, { int ret = TIZEN_GESTURE_ERROR_NONE; - ret = TIZEN_GESTURE_ERROR_NOT_SUPPORTED; + ret = _e_gesture_deselect_palm_cover(client, resource, surface); tizen_gesture_send_palm_cover_notify(resource, surface, ret); } @@ -1317,6 +1440,36 @@ _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data) gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; } +static void +_e_gesture_wl_surface_cb_destroy(struct wl_listener *l, void *data) +{ + struct wl_resource *surface = (struct wl_resource *)data; + E_Gesture_Event_Palm_Cover *palm_covers = &gesture->gesture_events.palm_covers; + Eina_List *list, *l_next; + struct wl_resource *surface_data; + E_Gesture_Select_Surface *sdata; + + EINA_LIST_FOREACH_SAFE(gesture->select_surface_list, list, l_next, surface_data) + { + if (surface_data == surface) + { + gesture->select_surface_list = eina_list_remove_list(gesture->select_surface_list, list); + } + } + + EINA_LIST_FOREACH_SAFE(palm_covers->select_surface_list, list, l_next, sdata) + { + if (sdata->surface == surface) + { + palm_covers->select_surface_list = eina_list_remove_list(palm_covers->select_surface_list, list); + E_FREE(sdata); + } + } + + wl_list_remove(&l->link); + E_FREE(l); +} + void e_gesture_event_filter_enable(Eina_Bool enabled) { diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 0d0b21f..263ab7c 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -77,6 +77,7 @@ typedef struct _Rect Rect; typedef struct _E_Gesture_Finger E_Gesture_Finger; typedef struct _E_Gesture_Event_Info E_Gesture_Event_Info; typedef struct _E_Gesture_Event_Client E_Gesture_Event_Client; +typedef struct _E_Gesture_Select_Surface E_Gesture_Select_Surface; typedef enum _E_Gesture_Edge E_Gesture_Edge; typedef enum _E_Gesture_Event_State E_Gesture_Event_State; @@ -193,6 +194,12 @@ struct _E_Gesture_Event_Client struct wl_resource *res; }; +struct _E_Gesture_Select_Surface +{ + struct wl_resource *surface; + struct wl_resource *res; +}; + struct _E_Gesture_Event_Edge_Swipe_Finger_Edge { struct wl_client *client; @@ -282,6 +289,7 @@ struct _E_Gesture_Event_Pinch struct _E_Gesture_Event_Palm_Cover { E_Gesture_Event_Client client_info; + Eina_List *select_surface_list; unsigned int start_time; }; @@ -323,6 +331,7 @@ struct _E_Gesture Ecore_Event_Filter *ef_handler; Eina_List *handlers; Eina_List *grab_client_list; + Eina_List *select_surface_list; Eina_List *hooks; struct -- 2.7.4 From 02af0fb6aa1454e6798eadee54eae2327758fef8 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Mon, 24 Jul 2017 14:47:34 +0900 Subject: [PATCH 02/16] add a gesture activate/deactivate functions - Runtime selective gesture activation / deactivation Change-Id: I7fa86fd092b0e6a2c28b971054902fcb51d04b01 --- src/e_mod_gesture_events.c | 62 ++++++++++- src/e_mod_main.c | 265 ++++++++++++++++++++++++++++++++++++++++++++- src/e_mod_main.h | 30 ++++- 3 files changed, 351 insertions(+), 6 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index 08c312a..4698392 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -346,6 +346,8 @@ _e_gesture_process_edge_swipe_down(Ecore_Event_Mouse_Button *ev) int i; unsigned int idx = ev->multi.device+1; + if (!edge_swipes->activation.active) return; + if (gesture->gesture_events.recognized_gesture) _e_gesture_edge_swipe_cancel(); @@ -405,6 +407,8 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) Coords diff; unsigned int idx = ev->multi.device+1; + if (!edge_swipes->activation.active) return; + if (!(edge_swipes->enabled_finger & (1 << idx))) return; @@ -474,6 +478,9 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) static void _e_gesture_process_edge_swipe_up(Ecore_Event_Mouse_Button *ev) { + E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; + + if (!edge_swipes->activation.active) return; if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); _e_gesture_edge_swipe_cancel(); @@ -657,6 +664,8 @@ _e_gesture_process_pan_down(Ecore_Event_Mouse_Button *ev) { E_Gesture_Event_Pan *pans = &gesture->gesture_events.pans; + if (!pans->activation.active) return; + if (gesture->gesture_events.recognized_gesture && !((gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PAN) || (gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PINCH))) @@ -677,6 +686,8 @@ _e_gesture_process_pan_move(Ecore_Event_Mouse_Move *ev) Coords cur_point = {0,}; int idx, diff_x, diff_y, mode; + if (!pans->activation.active) return; + if (gesture->gesture_events.recognized_gesture && !((gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PAN) || (gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PINCH))) @@ -720,6 +731,9 @@ _e_gesture_process_pan_move(Ecore_Event_Mouse_Move *ev) static void _e_gesture_process_pan_up(Ecore_Event_Mouse_Button *ev) { + E_Gesture_Event_Pan *pans = &gesture->gesture_events.pans; + + if (!pans->activation.active) return; _e_gesture_pan_cancel(); } @@ -792,6 +806,8 @@ _e_gesture_process_pinch_down(Ecore_Event_Mouse_Button *ev) { E_Gesture_Event_Pinch *pinch = &gesture->gesture_events.pinchs; + if (!pinch->activation.active) return; + if (gesture->gesture_events.recognized_gesture && !((gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PAN) || (gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PINCH))) @@ -812,6 +828,8 @@ _e_gesture_process_pinch_move(Ecore_Event_Mouse_Move *ev) int idx, mode, cx = 0, cy = 0; double current_distance = 0.0, diff = 0.0, angle = 0.0; + if (!pinch->activation.active) return; + if (gesture->gesture_events.recognized_gesture && !((gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PAN) || (gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PINCH))) @@ -856,6 +874,9 @@ _e_gesture_process_pinch_move(Ecore_Event_Mouse_Move *ev) static void _e_gesture_process_pinch_up(Ecore_Event_Mouse_Button *ev) { + E_Gesture_Event_Pinch *pinch = &gesture->gesture_events.pinchs; + + if (!pinch->activation.active) return; _e_gesture_pinch_cancel(); } @@ -1052,6 +1073,8 @@ _e_gesture_process_tap_down(Ecore_Event_Mouse_Button *ev) { E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + if (!taps->activation.active) return; + if (gesture->gesture_events.recognized_gesture) _e_gesture_tap_cancel(); @@ -1109,6 +1132,8 @@ _e_gesture_process_tap_move(Ecore_Event_Mouse_Move *ev) Rect current_rect = {0, }; int xx1, yy1, xx2, yy2; + if (!taps->activation.active) return; + if (gesture->gesture_events.recognized_gesture) _e_gesture_tap_cancel(); @@ -1134,6 +1159,8 @@ _e_gesture_process_tap_up(Ecore_Event_Mouse_Button *ev) { E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + if (!taps->activation.active) return; + if (gesture->gesture_events.recognized_gesture) _e_gesture_tap_cancel(); @@ -1441,7 +1468,8 @@ _e_gesture_process_palm(int val) if (val <= 0) return; if (!gesture->grabbed_gesture) return; - if (!(gesture->gesture_filter & E_GESTURE_TYPE_PALM_COVER)) + if (!(gesture->gesture_filter & E_GESTURE_TYPE_PALM_COVER) && + gesture->gesture_events.palm_covers.activation.active) { _e_gesture_process_palm_cover(val); } @@ -1463,6 +1491,38 @@ _e_gesture_process_axis_update(void *event) return E_GESTURE_EVENT_STATE_PROPAGATE; } +void +e_gesture_event_deactivate_check(void) +{ + if (gesture->gesture_events.num_pressed <= 0) return; + if (gesture->gesture_filter == E_GESTURE_TYPE_ALL) return; + + if (!(gesture->gesture_filter & E_GESTURE_TYPE_EDGE_SWIPE) && + gesture->gesture_events.edge_swipes.activation.active) + { + _e_gesture_edge_swipe_cancel(); + } + + if (!(gesture->gesture_filter & E_GESTURE_TYPE_TAP) && + gesture->gesture_events.taps.activation.active) + { + _e_gesture_tap_cancel(); + } + + if (!(gesture->gesture_filter & E_GESTURE_TYPE_PAN) && + gesture->gesture_events.pans.activation.active) + { + _e_gesture_pan_cancel(); + } + + if (!(gesture->gesture_filter & E_GESTURE_TYPE_PINCH) && + gesture->gesture_events.pinchs.activation.active) + { + _e_gesture_pinch_cancel(); + } + +} + /* Function for checking the existing grab for a key and sending key event(s) */ Eina_Bool e_gesture_process_events(void *event, int type) diff --git a/src/e_mod_main.c b/src/e_mod_main.c index 5871936..cdbc9bd 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -613,6 +613,220 @@ _e_gesture_deselect_palm_cover(struct wl_client *client, struct wl_resource *res return ret; } +static Eina_Bool +_e_gesture_deactivate_find_surface(Eina_List *list, struct wl_resource *surface) +{ + Eina_List *l; + E_Gesture_Activate_Surface_Info *idata; + + EINA_LIST_FOREACH(list, l, idata) + { + if (surface == idata->surface) + { + return EINA_TRUE; + } + } + return EINA_FALSE; +} + +static char * +_e_gesture_util_type_to_string(unsigned int type) +{ + switch (type) + { + case E_GESTURE_TYPE_EDGE_SWIPE: + return "edge_swipe"; + case E_GESTURE_TYPE_TAP: + return "tap"; + case E_GESTURE_TYPE_PALM_COVER: + return "palm_cover"; + case E_GESTURE_TYPE_PAN: + return "pan"; + case E_GESTURE_TYPE_PINCH: + return "pinch"; + default: + return "unknown"; + } +} + +static void +_e_gesture_deactivate_list_unset(struct wl_client *client, struct wl_resource *surface, E_Gesture_Activate_Info *info, unsigned int type) +{ + Eina_List *l, *l_next; + struct wl_resource *surface_data; + + if (surface) + { + EINA_LIST_FOREACH_SAFE(info->surfaces, l, l_next, surface_data) + { + if (surface_data == surface) + { + info->surfaces = eina_list_remove_list(info->surfaces, l); + break; + } + } + } + else if (info->client && (info->client == client)) + { + info->client = NULL; + info->active = EINA_TRUE; + } + else + { + 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); + } +} + +static void +_e_gesture_deactivate_cb_client_listener(struct wl_listener *l, void *data) +{ + struct wl_client *client = data; + + _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.edge_swipes.activation, E_GESTURE_TYPE_EDGE_SWIPE); + _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP); + _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER); + _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN); + _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.pinchs.activation, E_GESTURE_TYPE_PINCH); + + wl_list_remove(&l->link); + E_FREE(l); +} + +static void +_e_gesture_deactivate_cb_surface_listener(struct wl_listener *l, void *data) +{ + struct wl_resource *surface = data; + + _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.edge_swipes.activation, E_GESTURE_TYPE_EDGE_SWIPE); + _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP); + _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER); + _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN); + _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.pinchs.activation, E_GESTURE_TYPE_PINCH); + + wl_list_remove(&l->link); + E_FREE(l); +} + +static int +_e_gesture_deactivate_listener_add(struct wl_client *client, struct wl_resource * surface) +{ + struct wl_listener *destroy_listener = NULL; + + EINA_SAFETY_ON_FALSE_RETURN_VAL(client || surface, TIZEN_GESTURE_ERROR_INVALID_DATA); + + destroy_listener = E_NEW(struct wl_listener, 1); + if (!destroy_listener) + { + GTERR("Failed to allocate memory for deactivate destroy listener !\n"); + return TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES; + } + + if (surface) + { + destroy_listener->notify = _e_gesture_deactivate_cb_surface_listener; + wl_resource_add_destroy_listener(surface, destroy_listener); + } + else + { + destroy_listener->notify = _e_gesture_deactivate_cb_client_listener; + wl_client_add_destroy_listener(client, destroy_listener); + } + + return TIZEN_GESTURE_ERROR_NONE; +} + +static int +_e_gesture_deactivate_list_set(struct wl_client *client, struct wl_resource *surface, E_Gesture_Activate_Info *info, unsigned int type) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + if (surface) + { + if (!_e_gesture_deactivate_find_surface(info->surfaces, surface)) + { + info->surfaces = eina_list_append(info->surfaces, surface); + _e_gesture_deactivate_listener_add(client, surface); + } + } + else if (!info->client) + { + info->client = client; + info->active = EINA_FALSE; + _e_gesture_deactivate_listener_add(client, surface); + } + else + { + GTWRN("Failed to deactivate %s !(request surface: %p, client: %p), already deactivated client: %p\n", + _e_gesture_util_type_to_string(type), surface, client, info->client); + ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; + } + + return ret; +} + +static int +_e_gesture_deactivate_set(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *surface, + uint32_t type) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + if (type & E_GESTURE_TYPE_EDGE_SWIPE) + { + ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.edge_swipes.activation, E_GESTURE_TYPE_EDGE_SWIPE); + } + if (type & E_GESTURE_TYPE_TAP) + { + ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP); + } + if (type & E_GESTURE_TYPE_PALM_COVER) + { + ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER); + } + if (type & E_GESTURE_TYPE_PAN) + { + ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN); + } + if (type & E_GESTURE_TYPE_PINCH) + { + ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.pinchs.activation, E_GESTURE_TYPE_PINCH); + } + + return ret; +} + +static int +_e_gesture_deactivate_unset(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *surface, + uint32_t type) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + if (type & E_GESTURE_TYPE_EDGE_SWIPE) + { + _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.edge_swipes.activation, E_GESTURE_TYPE_EDGE_SWIPE); + } + if (type & E_GESTURE_TYPE_TAP) + { + _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP); + } + if (type & E_GESTURE_TYPE_PALM_COVER) + { + _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER); + } + if (type & E_GESTURE_TYPE_PAN) + { + _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN); + } + if (type & E_GESTURE_TYPE_PINCH) + { + _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.pinchs.activation, E_GESTURE_TYPE_PINCH); + } + + return ret; +} static void _e_gesture_cb_grab_edge_swipe(struct wl_client *client, @@ -971,7 +1185,10 @@ _e_gesture_cb_activate_set(struct wl_client *client, { int ret = TIZEN_GESTURE_ERROR_NONE; - ret = TIZEN_GESTURE_ERROR_NOT_SUPPORTED; + if (!active) + ret = _e_gesture_deactivate_set(client, resource, surface, type); + else + ret = _e_gesture_deactivate_unset(client, resource, surface, type); tizen_gesture_send_activate_notify(resource, surface, type, active, ret); } @@ -1052,6 +1269,50 @@ _e_gesture_event_filter(void *data, void *loop_data EINA_UNUSED, int type, void } static void +_e_gesture_deactivate_surface_list_check(struct wl_resource *surface, E_Gesture_Activate_Info *info) +{ + Eina_Bool res; + + res = _e_gesture_deactivate_find_surface(info->surfaces, surface); + + if (res) info->active = EINA_FALSE; + else info->active = EINA_TRUE; +} + +static void +_e_gesture_deactivate_surface_check(E_Client *ec) +{ + struct wl_resource *surface; + + EINA_SAFETY_ON_NULL_RETURN(ec); + EINA_SAFETY_ON_NULL_RETURN(ec->comp_data); + + surface = ec->comp_data->wl_surface; + if (!surface) return; + + if (!gesture->gesture_events.edge_swipes.activation.client) + { + _e_gesture_deactivate_surface_list_check(surface, &gesture->gesture_events.edge_swipes.activation); + } + if (!gesture->gesture_events.taps.activation.client) + { + _e_gesture_deactivate_surface_list_check(surface, &gesture->gesture_events.taps.activation); + } + if (!gesture->gesture_events.palm_covers.activation.client) + { + _e_gesture_deactivate_surface_list_check(surface, &gesture->gesture_events.palm_covers.activation); + } + if (!gesture->gesture_events.pans.activation.client) + { + _e_gesture_deactivate_surface_list_check(surface, &gesture->gesture_events.pans.activation); + } + if (!gesture->gesture_events.pinchs.activation.client) + { + _e_gesture_deactivate_surface_list_check(surface, &gesture->gesture_events.pinchs.activation); + } +} + +static void _e_gesture_window_gesture_disabled_change(E_Client *ec) { if (ec->gesture_disable && gesture->enable) @@ -1083,6 +1344,8 @@ _e_gesture_cb_client_focus_in(void *data, int type, void *event) EINA_SAFETY_ON_NULL_RETURN_VAL(ec->comp_data, ECORE_CALLBACK_PASS_ON); _e_gesture_window_gesture_disabled_change(ec); + _e_gesture_deactivate_surface_check(ec); + e_gesture_event_deactivate_check(); return ECORE_CALLBACK_PASS_ON; } diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 263ab7c..fd12119 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -15,12 +15,13 @@ #define E_GESTURE_TYPE_EDGE_DRAG TIZEN_GESTURE_TYPE_EDGE_DRAG #define E_GESTURE_TYPE_TAP TIZEN_GESTURE_TYPE_TAP #define E_GESTURE_TYPE_PALM_COVER TIZEN_GESTURE_TYPE_PALM_COVER -#define E_GESTURE_TYPE_PAN (TIZEN_GESTURE_TYPE_PALM_COVER << 1) -#define E_GESTURE_TYPE_PINCH (TIZEN_GESTURE_TYPE_PALM_COVER << 2) +#define E_GESTURE_TYPE_PAN TIZEN_GESTURE_TYPE_PAN +#define E_GESTURE_TYPE_PINCH TIZEN_GESTURE_TYPE_PINCH +#define E_GESTURE_TYPE_PALM_SWIPE TIZEN_GESTURE_TYPE_PALM_SWIPE #define E_GESTURE_FINGER_MAX 3 -#define E_GESTURE_TYPE_MAX (E_GESTURE_TYPE_PINCH + 1) -#define E_GESTURE_TYPE_ALL (E_GESTURE_TYPE_EDGE_SWIPE | E_GESTURE_TYPE_EDGE_DRAG | E_GESTURE_TYPE_TAP | E_GESTURE_TYPE_PAN | E_GESTURE_TYPE_PINCH | E_GESTURE_TYPE_PALM_COVER) +#define E_GESTURE_TYPE_MAX (E_GESTURE_TYPE_PALM_SWIPE + 1) +#define E_GESTURE_TYPE_ALL (E_GESTURE_TYPE_EDGE_SWIPE | E_GESTURE_TYPE_EDGE_DRAG | E_GESTURE_TYPE_TAP | E_GESTURE_TYPE_PAN | E_GESTURE_TYPE_PINCH | E_GESTURE_TYPE_PALM_COVER | E_GESTURE_TYPE_PALM_SWIPE) #define E_GESTURE_KEYBOARD_NAME "Gesture Keyboard" #define E_GESTURE_AUX_HINT_GESTURE_DISABLE "wm.policy.win.gesture.disable" @@ -78,6 +79,8 @@ typedef struct _E_Gesture_Finger E_Gesture_Finger; typedef struct _E_Gesture_Event_Info E_Gesture_Event_Info; typedef struct _E_Gesture_Event_Client E_Gesture_Event_Client; typedef struct _E_Gesture_Select_Surface E_Gesture_Select_Surface; +typedef struct _E_Gesture_Activate_Surface_Info E_Gesture_Activate_Surface_Info; +typedef struct _E_Gesture_Activate_Info E_Gesture_Activate_Info; typedef enum _E_Gesture_Edge E_Gesture_Edge; typedef enum _E_Gesture_Event_State E_Gesture_Event_State; @@ -147,6 +150,19 @@ struct _E_Gesture_Event_Info void *event; }; +struct _E_Gesture_Activate_Surface_Info +{ + Eina_Bool active; + struct wl_resource *surface; +}; + +struct _E_Gesture_Activate_Info +{ + Eina_Bool active; + struct wl_client *client; + Eina_List *surfaces; +}; + struct _E_Gesture_Conf_Edd { char *key_device_name; @@ -217,6 +233,7 @@ struct _E_Gesture_Event_Edge_Swipe_Finger struct _E_Gesture_Event_Edge_Swipe { + E_Gesture_Activate_Info activation; E_Gesture_Event_Edge_Swipe_Finger fingers[E_GESTURE_FINGER_MAX + 2]; unsigned int edge; @@ -246,6 +263,7 @@ struct _E_Gesture_Event_Tap_Finger struct _E_Gesture_Event_Tap { + E_Gesture_Activate_Info activation; E_Gesture_Event_Tap_Finger fingers[E_GESTURE_FINGER_MAX + 2]; E_Gesture_Tap_State state; unsigned int enabled_finger; @@ -264,6 +282,7 @@ struct _E_Gesture_Event_Tap struct _E_Gesture_Event_Pan { + E_Gesture_Activate_Info activation; E_Gesture_Event_Client fingers[E_GESTURE_FINGER_MAX + 2]; E_Gesture_PanPinch_State state; Coords start_point; @@ -277,6 +296,7 @@ struct _E_Gesture_Event_Pan struct _E_Gesture_Event_Pinch { + E_Gesture_Activate_Info activation; E_Gesture_Event_Client fingers[E_GESTURE_FINGER_MAX + 2]; E_Gesture_PanPinch_State state; double distance; @@ -288,6 +308,7 @@ struct _E_Gesture_Event_Pinch struct _E_Gesture_Event_Palm_Cover { + E_Gesture_Activate_Info activation; E_Gesture_Event_Client client_info; Eina_List *select_surface_list; unsigned int start_time; @@ -359,6 +380,7 @@ E_API void *e_modapi_init(E_Module *m); E_API int e_modapi_shutdown(E_Module *m); E_API int e_modapi_save(E_Module *m); +void e_gesture_event_deactivate_check(void); Eina_Bool e_gesture_process_events(void *event, int type); int e_gesture_type_convert(uint32_t type); -- 2.7.4 From 5d9c855bdb6d7bc20fcc34caae6fb3182c890716 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Fri, 28 Jul 2017 12:07:45 +0900 Subject: [PATCH 03/16] support a edge_drag gesture Change-Id: I87a20321e01c9c2fb56835d564ef08f9a8686a11 --- src/e_mod_gesture_conf.c | 8 + src/e_mod_gesture_events.c | 489 +++++++++++++++++++++++++++++++++------------ src/e_mod_main.c | 334 ++++++++++++++++++++++++++----- src/e_mod_main.h | 51 ++++- 4 files changed, 692 insertions(+), 190 deletions(-) diff --git a/src/e_mod_gesture_conf.c b/src/e_mod_gesture_conf.c index d2e74e1..837adf2 100644 --- a/src/e_mod_gesture_conf.c +++ b/src/e_mod_gesture_conf.c @@ -19,6 +19,10 @@ _e_gesture_conf_value_check(E_Gesture_Config_Data* gconfig) if (conf->edge_swipe.compose_key <= 0) conf->edge_swipe.compose_key = E_GESTURE_EDGE_SWIPE_COMBINE_KEY; if (conf->edge_swipe.back_key <= 0) conf->edge_swipe.back_key = E_GESTURE_EDGE_SWIPE_BACK_KEY; + if (conf->edge_drag.time_begin <= 0.0) conf->edge_drag.time_begin = E_GESTURE_EDGE_DRAG_START_TIME; + if (conf->edge_drag.area_offset <= 0) conf->edge_drag.area_offset = E_GESTURE_EDGE_DRAG_START_AREA; + if (conf->edge_drag.diff_length <= 0) conf->edge_drag.diff_length = E_GESTURE_EDGE_DRAG_DIFF; + if (conf->tap.repeats_max <= 0) conf->tap.repeats_max = E_GESTURE_TAP_REPEATS_MAX; if (conf->tap.time_start <= 0.0) conf->tap.time_start = E_GESTURE_TAP_START_TIME; if (conf->tap.time_done <= 0.0) conf->tap.time_done = E_GESTURE_TAP_DONE_TIME; @@ -51,6 +55,10 @@ e_gesture_conf_init(E_Gesture_Config_Data *gconfig) E_CONFIG_VAL(D, T, edge_swipe.back_key, INT); E_CONFIG_VAL(D, T, edge_swipe.default_enable_back, CHAR); + E_CONFIG_VAL(D, T, edge_drag.time_begin, DOUBLE); + E_CONFIG_VAL(D, T, edge_drag.area_offset, INT); + E_CONFIG_VAL(D, T, edge_drag.diff_length, INT); + E_CONFIG_VAL(D, T, tap.repeats_max, INT); E_CONFIG_VAL(D, T, tap.time_start, DOUBLE); E_CONFIG_VAL(D, T, tap.time_done, DOUBLE); diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index 4698392..13f2b36 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -28,6 +28,8 @@ _e_gesture_event_print(void) } #endif //_E_GESTURE_DEBUG_ +static void _e_gesture_send_edge_drag(int fingers, int x, int y, int edge, int mode); + static void _e_gesture_event_queue(int type, void *event) { @@ -121,6 +123,108 @@ _e_gesture_event_drop(void) } static void +_e_gesture_util_center_axis_get(int num_finger, int *x, int *y) +{ + int i; + int calc_x = 0, calc_y = 0; + + if (num_finger <= 0) + { + *x = 0; + *y = 0; + return; + } + + for (i = 1; i <= num_finger; i++) + { + calc_x += gesture->gesture_events.base_point[i].axis.x; + calc_y += gesture->gesture_events.base_point[i].axis.y; + } + + calc_x = (int)(calc_x / num_finger); + calc_y = (int)(calc_y / num_finger); + + *x = calc_x; + *y = calc_y; +} + +static double +_e_gesture_util_distance_get(int x1, int y1, int x2, int y2) +{ + double distance; + + distance = sqrt(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1))); + + return distance; +} + +static double +_e_gesture_util_distances_get(int num_finger) +{ + int i, cx = 0, cy = 0; + double distance = 0.0; + + _e_gesture_util_center_axis_get(num_finger, &cx, &cy); + + for (i = 1; i <= num_finger; i++) + { + distance += _e_gesture_util_distance_get(cx, cy, + gesture->gesture_events.base_point[i].axis.x, + gesture->gesture_events.base_point[i].axis.y); + } + + return distance; +} + +static double +_e_gesture_util_angle_get(int x1, int y1, int x2, int y2) +{ + double angle, xx, yy; + + xx = fabs(x2 - x1); + yy = fabs(y2 - y1); + + angle = atan2(yy, xx); + if ((x1 > x2) && (y1 > y2)) angle = angle + M_PI_2; + else if ((x2 > x1) && (y2 > y1)) angle = angle + M_PI_2; + + angle = RAD2DEG(angle); + return angle; +} + +static void +_e_gesture_util_rect_get(int finger, int *x1, int *y1, int *x2, int *y2) +{ + int i; + + *x1 = *x2 = gesture->gesture_events.base_point[1].axis.x; + *y1 = *y2 = gesture->gesture_events.base_point[1].axis.y; + + for (i = 2; i < finger + 1; i++) + { + if (gesture->gesture_events.base_point[i].axis.x < *x1) + *x1 = gesture->gesture_events.base_point[i].axis.x; + else if (gesture->gesture_events.base_point[i].axis.x > *x2) + *x2 = gesture->gesture_events.base_point[i].axis.x; + + if (gesture->gesture_events.base_point[i].axis.y < *y1) + *y1 = gesture->gesture_events.base_point[i].axis.y; + else if (gesture->gesture_events.base_point[i].axis.y > *y2) + *y2 = gesture->gesture_events.base_point[i].axis.y; + } +} + +static struct wl_resource * +_e_gesture_util_eclient_surface_get(E_Client *ec) +{ + if (!ec) return NULL; + if (e_object_is_del(E_OBJECT(ec))) return NULL; + if (!ec->comp_data) return NULL; + + return ec->comp_data->surface; +} + +static void _e_gesture_edge_swipe_cancel(void) { E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; @@ -136,8 +240,8 @@ _e_gesture_edge_swipe_cancel(void) edge_swipes->done_timer = NULL; } - edge_swipes->enabled_finger = 0x0; - edge_swipes->edge = E_GESTURE_EDGE_NONE; + edge_swipes->base.enabled_finger = 0x0; + edge_swipes->base.edge = E_GESTURE_EDGE_NONE; gesture->gesture_filter |= E_GESTURE_TYPE_EDGE_SWIPE; } @@ -190,7 +294,7 @@ _e_gesture_send_edge_swipe(int fingers, int x, int y, int edge) Ecore_Event_Mouse_Button *ev_cancel; E_Gesture_Conf_Edd *conf = gesture->config->conf; Eina_List *l; - E_Gesture_Event_Edge_Swipe_Finger_Edge *edata; + E_Gesture_Event_Edge_Finger_Edge *edata; E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; int bp = -1; @@ -228,7 +332,7 @@ _e_gesture_send_edge_swipe(int fingers, int x, int y, int edge) bp = y; } - EINA_LIST_FOREACH(edge_swipes->fingers[fingers].edge[edge], l, edata) + EINA_LIST_FOREACH(edge_swipes->base.fingers[fingers].edge[edge], l, edata) { if (bp >= edata->sp && bp <= edata->ep) { @@ -256,27 +360,29 @@ _e_gesture_process_device_del(void *event) } static Eina_Bool -_e_gesture_event_edge_swipe_edge_check(unsigned int edge) +_e_gesture_event_edge_check(E_Gesture_Event_Edge_Finger *fingers, int type, unsigned int edge) { E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; - int idx = gesture->gesture_events.num_pressed; E_Gesture_Conf_Edd *conf = gesture->config->conf; Eina_List *l; - E_Gesture_Event_Edge_Swipe_Finger_Edge *edata; + E_Gesture_Event_Edge_Finger_Edge *edata; Coords coords; - if ((conf->edge_swipe.default_enable_back) && - (edge == TIZEN_GESTURE_EDGE_TOP || - ((edge_swipes->combined_keycode == conf->edge_swipe.compose_key) && - (edge_swipes->edge == TIZEN_GESTURE_EDGE_LEFT)))) + if (type == E_GESTURE_TYPE_EDGE_SWIPE) { - return EINA_TRUE; + if ((conf->edge_swipe.default_enable_back) && + (edge == TIZEN_GESTURE_EDGE_TOP || + ((edge_swipes->combined_keycode == conf->edge_swipe.compose_key) && + (edge_swipes->base.edge == TIZEN_GESTURE_EDGE_LEFT)))) + { + return EINA_TRUE; + } } - coords.x = edge_swipes->fingers[idx].start.x; - coords.y = edge_swipes->fingers[idx].start.y; + coords.x = fingers->start.x; + coords.y = fingers->start.y; - EINA_LIST_FOREACH(edge_swipes->fingers[idx].edge[edge], l, edata) + EINA_LIST_FOREACH(fingers->edge[edge], l, edata) { if (edge == TIZEN_GESTURE_EDGE_TOP || edge == TIZEN_GESTURE_EDGE_BOTTOM) @@ -308,14 +414,14 @@ _e_gesture_timer_edge_swipe_start(void *data) int idx = gesture->gesture_events.num_pressed; int i; - GTDBG("Edge_Swipe start timer is expired. Currently alived edge_swipe fingers: 0x%x\n", edge_swipes->enabled_finger); + GTDBG("Edge_Swipe start timer is expired. Currently alived edge_swipe fingers: 0x%x\n", edge_swipes->base.enabled_finger); for (i = E_GESTURE_FINGER_MAX; i > idx; i--) { - edge_swipes->enabled_finger &= ~(1 << i); + edge_swipes->base.enabled_finger &= ~(1 << i); } - if ((edge_swipes->enabled_finger == 0x0) || - (_e_gesture_event_edge_swipe_edge_check(edge_swipes->edge) == EINA_FALSE)) + if ((edge_swipes->base.enabled_finger == 0x0) || + (_e_gesture_event_edge_check(&edge_swipes->base.fingers[idx], E_GESTURE_TYPE_EDGE_SWIPE, edge_swipes->base.edge) == EINA_FALSE)) { if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); @@ -329,7 +435,7 @@ _e_gesture_timer_edge_swipe_done(void *data) { E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; - GTDBG("Edge_Swipe done timer is expired. Currently alived edge_swipe fingers: 0x%x\n", edge_swipes->enabled_finger); + GTDBG("Edge_Swipe done timer is expired. Currently alived edge_swipe fingers: 0x%x\n", edge_swipes->base.enabled_finger); if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); @@ -346,7 +452,7 @@ _e_gesture_process_edge_swipe_down(Ecore_Event_Mouse_Button *ev) int i; unsigned int idx = ev->multi.device+1; - if (!edge_swipes->activation.active) return; + if (!edge_swipes->base.activation.active) return; if (gesture->gesture_events.recognized_gesture) _e_gesture_edge_swipe_cancel(); @@ -355,28 +461,28 @@ _e_gesture_process_edge_swipe_down(Ecore_Event_Mouse_Button *ev) { for (i = 1; i < E_GESTURE_FINGER_MAX+1; i++) { - if (edge_swipes->fingers[i].enabled) + if (edge_swipes->base.fingers[i].enabled) { - edge_swipes->enabled_finger |= (1 << i); + edge_swipes->base.enabled_finger |= (1 << i); } } if (ev->y < conf->edge_swipe.area_offset) - edge_swipes->edge = E_GESTURE_EDGE_TOP; + edge_swipes->base.edge = E_GESTURE_EDGE_TOP; else if (ev->y > e_comp->h - conf->edge_swipe.area_offset) - edge_swipes->edge = E_GESTURE_EDGE_BOTTOM; + edge_swipes->base.edge = E_GESTURE_EDGE_BOTTOM; else if (ev->x < conf->edge_swipe.area_offset) - edge_swipes->edge = E_GESTURE_EDGE_LEFT; + edge_swipes->base.edge = E_GESTURE_EDGE_LEFT; else if (ev->x > e_comp->w - conf->edge_swipe.area_offset) - edge_swipes->edge = E_GESTURE_EDGE_RIGHT; + edge_swipes->base.edge = E_GESTURE_EDGE_RIGHT; - if (!((1 << (edge_swipes->edge)) & edge_swipes->enabled_edge)) - edge_swipes->edge = E_GESTURE_EDGE_NONE; + if (!((1 << (edge_swipes->base.edge)) & edge_swipes->base.enabled_edge)) + edge_swipes->base.edge = E_GESTURE_EDGE_NONE; - if (edge_swipes->edge != E_GESTURE_EDGE_NONE) + if (edge_swipes->base.edge != E_GESTURE_EDGE_NONE) { - edge_swipes->fingers[idx].start.x = ev->x; - edge_swipes->fingers[idx].start.y = ev->y; + edge_swipes->base.fingers[idx].start.x = ev->x; + edge_swipes->base.fingers[idx].start.y = ev->y; edge_swipes->start_timer = ecore_timer_add(conf->edge_swipe.time_begin, _e_gesture_timer_edge_swipe_start, NULL); edge_swipes->done_timer = ecore_timer_add(conf->edge_swipe.time_done, _e_gesture_timer_edge_swipe_done, NULL); } @@ -389,7 +495,7 @@ _e_gesture_process_edge_swipe_down(Ecore_Event_Mouse_Button *ev) } else { - edge_swipes->enabled_finger &= ~(1 << (gesture->gesture_events.num_pressed - 1)); + edge_swipes->base.enabled_finger &= ~(1 << (gesture->gesture_events.num_pressed - 1)); if (edge_swipes->start_timer == NULL) { if (gesture->gesture_events.event_keep) @@ -407,15 +513,15 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) Coords diff; unsigned int idx = ev->multi.device+1; - if (!edge_swipes->activation.active) return; + if (!edge_swipes->base.activation.active) return; - if (!(edge_swipes->enabled_finger & (1 << idx))) + if (!(edge_swipes->base.enabled_finger & (1 << idx))) return; - diff.x = ABS(edge_swipes->fingers[idx].start.x - ev->x); - diff.y = ABS(edge_swipes->fingers[idx].start.y - ev->y); + diff.x = ABS(edge_swipes->base.fingers[idx].start.x - ev->x); + diff.y = ABS(edge_swipes->base.fingers[idx].start.y - ev->y); - switch(edge_swipes->edge) + switch(edge_swipes->base.edge) { case E_GESTURE_EDGE_TOP: if (diff.x > conf->edge_swipe.min_length) @@ -427,7 +533,7 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) } if (diff.y > conf->edge_swipe.max_length) { - _e_gesture_send_edge_swipe(idx, edge_swipes->fingers[idx].start.x, edge_swipes->fingers[idx].start.y, E_GESTURE_EDGE_TOP); + _e_gesture_send_edge_swipe(idx, edge_swipes->base.fingers[idx].start.x, edge_swipes->base.fingers[idx].start.y, E_GESTURE_EDGE_TOP); } break; case E_GESTURE_EDGE_LEFT: @@ -440,7 +546,7 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) } if (diff.x > conf->edge_swipe.max_length) { - _e_gesture_send_edge_swipe(idx, edge_swipes->fingers[idx].start.x, edge_swipes->fingers[idx].start.y, E_GESTURE_EDGE_LEFT); + _e_gesture_send_edge_swipe(idx, edge_swipes->base.fingers[idx].start.x, edge_swipes->base.fingers[idx].start.y, E_GESTURE_EDGE_LEFT); } break; case E_GESTURE_EDGE_BOTTOM: @@ -453,7 +559,7 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) } if (diff.y > conf->edge_swipe.max_length) { - _e_gesture_send_edge_swipe(idx, edge_swipes->fingers[idx].start.x, edge_swipes->fingers[idx].start.y, E_GESTURE_EDGE_BOTTOM); + _e_gesture_send_edge_swipe(idx, edge_swipes->base.fingers[idx].start.x, edge_swipes->base.fingers[idx].start.y, E_GESTURE_EDGE_BOTTOM); } break; case E_GESTURE_EDGE_RIGHT: @@ -466,11 +572,11 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) } if (diff.x > conf->edge_swipe.max_length) { - _e_gesture_send_edge_swipe(idx, edge_swipes->fingers[idx].start.x, edge_swipes->fingers[idx].start.y, E_GESTURE_EDGE_RIGHT); + _e_gesture_send_edge_swipe(idx, edge_swipes->base.fingers[idx].start.x, edge_swipes->base.fingers[idx].start.y, E_GESTURE_EDGE_RIGHT); } break; default: - GTWRN("Invalid edge(%d)\n", edge_swipes->edge); + GTWRN("Invalid edge(%d)\n", edge_swipes->base.edge); break; } } @@ -480,18 +586,54 @@ _e_gesture_process_edge_swipe_up(Ecore_Event_Mouse_Button *ev) { E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; - if (!edge_swipes->activation.active) return; + if (!edge_swipes->base.activation.active) return; if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); _e_gesture_edge_swipe_cancel(); } static void -_e_gesture_pan_send(int mode, int fingers, int cx, int cy, struct wl_resource *res, struct wl_client *client) +_e_gesture_edge_drag_cancel(void) +{ + E_Gesture_Event_Edge_Drag *edge_drags = &gesture->gesture_events.edge_drags; + Coords current_point = {0, }; + + if (gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_EDGE_DRAG) + { + _e_gesture_util_center_axis_get(edge_drags->idx, ¤t_point.x, ¤t_point.y); + _e_gesture_send_edge_drag(edge_drags->idx, current_point.x, current_point.y, edge_drags->base.edge, TIZEN_GESTURE_MODE_END); + } + + if (edge_drags->start_timer) + { + ecore_timer_del(edge_drags->start_timer); + edge_drags->start_timer = NULL; + } + + edge_drags->base.enabled_finger = 0x0; + edge_drags->base.edge = E_GESTURE_EDGE_NONE; + edge_drags->start_point.x = edge_drags->center_point.x = 0; + edge_drags->start_point.y = edge_drags->center_point.y = 0; + edge_drags->idx = 0; + + gesture->gesture_filter |= E_GESTURE_TYPE_EDGE_DRAG; + gesture->gesture_events.recognized_gesture &= ~E_GESTURE_TYPE_EDGE_DRAG; +} + +static void +_e_gesture_send_edge_drag(int fingers, int x, int y, int edge, int mode) { Ecore_Event_Mouse_Button *ev_cancel; + Eina_List *l; + E_Gesture_Event_Edge_Finger_Edge *edata; + E_Gesture_Event_Edge_Drag *edge_drags = &gesture->gesture_events.edge_drags; + int bp = -1; - if (mode == TIZEN_GESTURE_MODE_BEGIN) + if (gesture->gesture_events.event_keep) + { + _e_gesture_event_drop(); + } + else { ev_cancel = E_NEW(Ecore_Event_Mouse_Button, 1); EINA_SAFETY_ON_NULL_RETURN(ev_cancel); @@ -502,136 +644,211 @@ _e_gesture_pan_send(int mode, int fingers, int cx, int cy, struct wl_resource *r ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, ev_cancel, NULL, NULL); } - GTINF("Send pan gesture %d fingers. (%d, %d) to client: %p, mode: %d\n", fingers, cx, cy, client, mode); + if (edge == TIZEN_GESTURE_EDGE_TOP || + edge == TIZEN_GESTURE_EDGE_BOTTOM) + { + bp = edge_drags->start_point.x; + } + else if (edge == TIZEN_GESTURE_EDGE_RIGHT || + edge == TIZEN_GESTURE_EDGE_LEFT) + { + bp = edge_drags->start_point.y; + } - gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_PAN; + EINA_LIST_FOREACH(edge_drags->base.fingers[fingers].edge[edge], l, edata) + { + if (bp >= edata->sp && bp <= edata->ep) + { + GTINF("Send edge drag gesture (fingers: %d, edge: %d) to client: %p\n", fingers, edge, edata->client); + tizen_gesture_send_edge_drag(edata->res, mode, fingers, x, y, edge); + break; + } + } + + gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_EDGE_DRAG; } -static void -_e_gesture_pan_cancel(void) +static Eina_Bool +_e_gesture_timer_edge_drag_start(void *data) { - E_Gesture_Event_Pan *pans = &gesture->gesture_events.pans; + E_Gesture_Event_Edge_Drag *edge_drags = &gesture->gesture_events.edge_drags; + int idx = gesture->gesture_events.num_pressed; + int i; + Coords start_point = {0, }; - if (pans->start_timer) + for (i = E_GESTURE_FINGER_MAX; i > idx; i--) { - ecore_timer_del(pans->start_timer); - pans->start_timer = NULL; + edge_drags->base.enabled_finger &= ~(1 << i); } - if (pans->move_timer) + + if ((edge_drags->base.enabled_finger == 0x0) || + (_e_gesture_event_edge_check(&edge_drags->base.fingers[idx], E_GESTURE_TYPE_EDGE_DRAG, edge_drags->base.edge) == EINA_FALSE)) { - ecore_timer_del(pans->move_timer); - pans->move_timer = NULL; + if (gesture->gesture_events.event_keep) + _e_gesture_event_flush(); + _e_gesture_edge_drag_cancel(); + } + else + { + _e_gesture_util_center_axis_get(idx, &start_point.x, &start_point.y); + edge_drags->start_point.x = edge_drags->center_point.x = start_point.x; + edge_drags->start_point.y = edge_drags->center_point.y = start_point.y; + edge_drags->idx = idx; + _e_gesture_send_edge_drag(edge_drags->idx, edge_drags->center_point.x, edge_drags->center_point.y, edge_drags->base.edge, TIZEN_GESTURE_MODE_BEGIN); } - if (pans->state == E_GESTURE_PANPINCH_STATE_MOVING) - _e_gesture_pan_send(TIZEN_GESTURE_MODE_END, pans->num_pan_fingers, 0, 0, - pans->fingers[pans->num_pan_fingers].res, - pans->fingers[pans->num_pan_fingers].client); - - gesture->gesture_filter |= E_GESTURE_TYPE_PAN; - pans->state = E_GESTURE_PANPINCH_STATE_DONE; + ecore_timer_del(edge_drags->start_timer); + edge_drags->start_timer = NULL; + return ECORE_CALLBACK_CANCEL; } static void -_e_gesture_util_center_axis_get(int num_finger, int *x, int *y) +_e_gesture_process_edge_drag_down(Ecore_Event_Mouse_Button *ev) { + E_Gesture_Event_Edge_Drag *edge_drags = &gesture->gesture_events.edge_drags; + E_Gesture_Conf_Edd *conf = gesture->config->conf; int i; - int calc_x = 0, calc_y = 0; + unsigned int idx = ev->multi.device+1; - if (num_finger <= 0) - { - *x = 0; - *y = 0; - return; - } + if (!edge_drags->base.activation.active) return; - for (i = 1; i <= num_finger; i++) + if (gesture->gesture_events.recognized_gesture) + _e_gesture_edge_drag_cancel(); + + if (gesture->gesture_events.num_pressed == 1) { - calc_x += gesture->gesture_events.base_point[i].axis.x; - calc_y += gesture->gesture_events.base_point[i].axis.y; - } + for (i = 1; i < E_GESTURE_FINGER_MAX+1; i++) + { + if (edge_drags->base.fingers[i].enabled) + { + edge_drags->base.enabled_finger |= (1 << i); + } + } - calc_x = (int)(calc_x / num_finger); - calc_y = (int)(calc_y / num_finger); + if (ev->y < conf->edge_drag.area_offset) + edge_drags->base.edge = E_GESTURE_EDGE_TOP; + else if (ev->y > e_comp->h - conf->edge_drag.area_offset) + edge_drags->base.edge = E_GESTURE_EDGE_BOTTOM; + else if (ev->x < conf->edge_drag.area_offset) + edge_drags->base.edge = E_GESTURE_EDGE_LEFT; + else if (ev->x > e_comp->w - conf->edge_drag.area_offset) + edge_drags->base.edge = E_GESTURE_EDGE_RIGHT; - *x = calc_x; - *y = calc_y; + if (!((1 << (edge_drags->base.edge)) & edge_drags->base.enabled_edge)) + edge_drags->base.edge = E_GESTURE_EDGE_NONE; + + if (edge_drags->base.edge != E_GESTURE_EDGE_NONE) + { + edge_drags->base.fingers[idx].start.x = ev->x; + edge_drags->base.fingers[idx].start.y = ev->y; + edge_drags->start_timer = ecore_timer_add(conf->edge_drag.time_begin, _e_gesture_timer_edge_drag_start, NULL); + } + else + { + if (gesture->gesture_events.event_keep) + _e_gesture_event_flush(); + _e_gesture_edge_drag_cancel(); + } + } + else + { + edge_drags->base.enabled_finger &= ~(1 << (gesture->gesture_events.num_pressed - 1)); + if (edge_drags->start_timer == NULL) + { + if (gesture->gesture_events.event_keep) + _e_gesture_event_flush(); + _e_gesture_edge_drag_cancel(); + } + } } -static double -_e_gesture_util_distance_get(int x1, int y1, int x2, int y2) +static void +_e_gesture_process_edge_drag_move(Ecore_Event_Mouse_Move *ev) { + E_Gesture_Event_Edge_Drag *edge_drags = &gesture->gesture_events.edge_drags; + E_Gesture_Conf_Edd *conf = gesture->config->conf; double distance; + Coords current_point = {0, }; + unsigned int idx = ev->multi.device+1; - distance = sqrt(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1))); - - return distance; -} + if (!edge_drags->base.activation.active) return; -static double -_e_gesture_util_distances_get(int num_finger) -{ - int i, cx = 0, cy = 0; - double distance = 0.0; + if (!(edge_drags->base.enabled_finger & (1 << idx))) + return; - _e_gesture_util_center_axis_get(num_finger, &cx, &cy); + if (edge_drags->start_timer) return; - for (i = 1; i <= num_finger; i++) + _e_gesture_util_center_axis_get(gesture->gesture_events.num_pressed, ¤t_point.x, ¤t_point.y); + distance = _e_gesture_util_distance_get(edge_drags->center_point.x, edge_drags->center_point.y, current_point.x, current_point.y); + if (distance < (double)conf->edge_drag.diff_length) { - distance += _e_gesture_util_distance_get(cx, cy, - gesture->gesture_events.base_point[i].axis.x, - gesture->gesture_events.base_point[i].axis.y); + return; } - return distance; + edge_drags->center_point.x = current_point.x; + edge_drags->center_point.y = current_point.y; + + _e_gesture_send_edge_drag(edge_drags->idx, + edge_drags->center_point.x, edge_drags->center_point.y, + edge_drags->base.edge, TIZEN_GESTURE_MODE_UPDATE); } -static double -_e_gesture_util_angle_get(int x1, int y1, int x2, int y2) +static void +_e_gesture_process_edge_drag_up(Ecore_Event_Mouse_Button *ev) { - double angle, xx, yy; - - xx = fabs(x2 - x1); - yy = fabs(y2 - y1); - - angle = atan2(yy, xx); - if ((x1 > x2) && (y1 > y2)) angle = angle + M_PI_2; - else if ((x2 > x1) && (y2 > y1)) angle = angle + M_PI_2; + E_Gesture_Event_Edge_Drag *edge_drags = &gesture->gesture_events.edge_drags; - angle = RAD2DEG(angle); - return angle; + if (!edge_drags->base.activation.active) return; + if (gesture->gesture_events.event_keep) + _e_gesture_event_flush(); + _e_gesture_edge_drag_cancel(); } + static void -_e_gesture_util_rect_get(int finger, int *x1, int *y1, int *x2, int *y2) +_e_gesture_pan_send(int mode, int fingers, int cx, int cy, struct wl_resource *res, struct wl_client *client) { - int i; - - *x1 = *x2 = gesture->gesture_events.base_point[1].axis.x; - *y1 = *y2 = gesture->gesture_events.base_point[1].axis.y; + Ecore_Event_Mouse_Button *ev_cancel; - for (i = 2; i < finger + 1; i++) + if (mode == TIZEN_GESTURE_MODE_BEGIN) { - if (gesture->gesture_events.base_point[i].axis.x < *x1) - *x1 = gesture->gesture_events.base_point[i].axis.x; - else if (gesture->gesture_events.base_point[i].axis.x > *x2) - *x2 = gesture->gesture_events.base_point[i].axis.x; + ev_cancel = E_NEW(Ecore_Event_Mouse_Button, 1); + EINA_SAFETY_ON_NULL_RETURN(ev_cancel); - if (gesture->gesture_events.base_point[i].axis.y < *y1) - *y1 = gesture->gesture_events.base_point[i].axis.y; - else if (gesture->gesture_events.base_point[i].axis.y > *y2) - *y2 = gesture->gesture_events.base_point[i].axis.y; + ev_cancel->timestamp = (int)(ecore_time_get()*1000); + ev_cancel->same_screen = 1; + + ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, ev_cancel, NULL, NULL); } + + GTINF("Send pan gesture %d fingers. (%d, %d) to client: %p, mode: %d\n", fingers, cx, cy, client, mode); + + gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_PAN; } -static struct wl_resource * -_e_gesture_util_eclient_surface_get(E_Client *ec) +static void +_e_gesture_pan_cancel(void) { - if (!ec) return NULL; - if (e_object_is_del(E_OBJECT(ec))) return NULL; - if (!ec->comp_data) return NULL; + E_Gesture_Event_Pan *pans = &gesture->gesture_events.pans; - return ec->comp_data->surface; + if (pans->start_timer) + { + ecore_timer_del(pans->start_timer); + pans->start_timer = NULL; + } + if (pans->move_timer) + { + ecore_timer_del(pans->move_timer); + pans->move_timer = NULL; + } + + if (pans->state == E_GESTURE_PANPINCH_STATE_MOVING) + _e_gesture_pan_send(TIZEN_GESTURE_MODE_END, pans->num_pan_fingers, 0, 0, + pans->fingers[pans->num_pan_fingers].res, + pans->fingers[pans->num_pan_fingers].client); + + gesture->gesture_filter |= E_GESTURE_TYPE_PAN; + pans->state = E_GESTURE_PANPINCH_STATE_DONE; } static Eina_Bool @@ -1243,6 +1460,10 @@ _e_gesture_process_mouse_button_down(void *event) { _e_gesture_process_edge_swipe_down(ev); } + if (!(gesture->gesture_filter & E_GESTURE_TYPE_EDGE_DRAG)) + { + _e_gesture_process_edge_drag_down(ev); + } if (!(gesture->gesture_filter & E_GESTURE_TYPE_PAN)) { _e_gesture_process_pan_down(ev); @@ -1285,6 +1506,10 @@ _e_gesture_process_mouse_button_up(void *event) { _e_gesture_process_edge_swipe_up(ev); } + if (!(gesture->gesture_filter & E_GESTURE_TYPE_EDGE_DRAG)) + { + _e_gesture_process_edge_drag_up(ev); + } if (!(gesture->gesture_filter & E_GESTURE_TYPE_PAN)) { _e_gesture_process_pan_up(ev); @@ -1344,6 +1569,10 @@ _e_gesture_process_mouse_move(void *event) { _e_gesture_process_edge_swipe_move(ev); } + if (!(gesture->gesture_filter & E_GESTURE_TYPE_EDGE_DRAG)) + { + _e_gesture_process_edge_drag_move(ev); + } if (!(gesture->gesture_filter & E_GESTURE_TYPE_PAN)) { _e_gesture_process_pan_move(ev); @@ -1498,7 +1727,7 @@ e_gesture_event_deactivate_check(void) if (gesture->gesture_filter == E_GESTURE_TYPE_ALL) return; if (!(gesture->gesture_filter & E_GESTURE_TYPE_EDGE_SWIPE) && - gesture->gesture_events.edge_swipes.activation.active) + gesture->gesture_events.edge_swipes.base.activation.active) { _e_gesture_edge_swipe_cancel(); } diff --git a/src/e_mod_main.c b/src/e_mod_main.c index cdbc9bd..a351fc8 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -12,17 +12,10 @@ static void _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data); static void _e_gesture_wl_surface_cb_destroy(struct wl_listener *l, void *data); static Eina_Bool -_e_gesture_edge_swipe_boundary_check(E_Gesture_Event_Edge_Swipe_Finger *fingers, unsigned int edge, int sp, int ep) +_e_gesture_edge_boundary_check(E_Gesture_Event_Edge_Finger *fingers, unsigned int edge, int sp, int ep) { Eina_List *l; - E_Gesture_Event_Edge_Swipe_Finger_Edge *edata; - E_Gesture_Conf_Edd *conf = gesture->config->conf; - - if ((conf->edge_swipe.default_enable_back) && - (edge == E_GESTURE_EDGE_TOP)) - { - return EINA_FALSE; - } + E_Gesture_Event_Edge_Finger_Edge *edata; EINA_LIST_FOREACH(fingers->edge[edge], l, edata) { @@ -34,11 +27,11 @@ _e_gesture_edge_swipe_boundary_check(E_Gesture_Event_Edge_Swipe_Finger *fingers, } static void -_e_gesture_edge_swipe_grab_add(E_Gesture_Event_Edge_Swipe_Finger *fingers, struct wl_client *client, struct wl_resource *res, unsigned int edge, unsigned int sp, unsigned int ep) +_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) { - E_Gesture_Event_Edge_Swipe_Finger_Edge *edata; + E_Gesture_Event_Edge_Finger_Edge *edata; - edata = E_NEW(E_Gesture_Event_Edge_Swipe_Finger_Edge, 1); + edata = E_NEW(E_Gesture_Event_Edge_Finger_Edge, 1); EINA_SAFETY_ON_NULL_RETURN(edata); edata->client = client; @@ -55,9 +48,13 @@ _e_gesture_set_client_to_list(E_Gesture_Grabbed_Client *gclient, struct wl_clien switch (mode) { case E_GESTURE_TYPE_EDGE_SWIPE: - _e_gesture_edge_swipe_grab_add(&gclient->edge_swipe_fingers[fingers], client, NULL, edge, sp, ep); + _e_gesture_edge_grab_add(&gclient->edge_swipe_fingers[fingers], client, NULL, edge, sp, ep); gclient->edge_swipe_fingers[fingers].enabled = EINA_TRUE; break; + case E_GESTURE_TYPE_EDGE_DRAG: + _e_gesture_edge_grab_add(&gclient->edge_drag_fingers[fingers], client, NULL, edge, sp, ep); + gclient->edge_drag_fingers[fingers].enabled = EINA_TRUE; + break; case E_GESTURE_TYPE_TAP: gclient->tap_fingers[fingers].repeats[repeat].client = client; break; @@ -130,12 +127,34 @@ _e_gesture_edge_swipe_current_list_check(void) { for (j = 0; j < E_GESTURE_EDGE_MAX+1; j++) { - if (eina_list_count(gev->edge_swipes.fingers[i].edge[j]) != 0) + if (eina_list_count(gev->edge_swipes.base.fingers[i].edge[j]) != 0) { return; } } - gev->edge_swipes.fingers[i].enabled = EINA_FALSE; + gev->edge_swipes.base.fingers[i].enabled = EINA_FALSE; + } + gesture->grabbed_gesture &= ~E_GESTURE_TYPE_EDGE_SWIPE; + if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE; +} + +static void +_e_gesture_edge_drag_current_list_check(void) +{ + int i, j; + E_Gesture_Event *gev; + + gev = &gesture->gesture_events; + for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) + { + for (j = 0; j < E_GESTURE_EDGE_MAX+1; j++) + { + if (eina_list_count(gev->edge_drags.base.fingers[i].edge[j]) != 0) + { + return; + } + } + gev->edge_drags.base.fingers[i].enabled = EINA_FALSE; } gesture->grabbed_gesture &= ~E_GESTURE_TYPE_EDGE_SWIPE; if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE; @@ -682,7 +701,7 @@ _e_gesture_deactivate_cb_client_listener(struct wl_listener *l, void *data) { struct wl_client *client = data; - _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.edge_swipes.activation, E_GESTURE_TYPE_EDGE_SWIPE); + _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.edge_swipes.base.activation, E_GESTURE_TYPE_EDGE_SWIPE); _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP); _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER); _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN); @@ -697,7 +716,7 @@ _e_gesture_deactivate_cb_surface_listener(struct wl_listener *l, void *data) { struct wl_resource *surface = data; - _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.edge_swipes.activation, E_GESTURE_TYPE_EDGE_SWIPE); + _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.edge_swipes.base.activation, E_GESTURE_TYPE_EDGE_SWIPE); _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP); _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER); _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN); @@ -774,7 +793,7 @@ _e_gesture_deactivate_set(struct wl_client *client, if (type & E_GESTURE_TYPE_EDGE_SWIPE) { - ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.edge_swipes.activation, E_GESTURE_TYPE_EDGE_SWIPE); + ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.edge_swipes.base.activation, E_GESTURE_TYPE_EDGE_SWIPE); } if (type & E_GESTURE_TYPE_TAP) { @@ -806,7 +825,7 @@ _e_gesture_deactivate_unset(struct wl_client *client, if (type & E_GESTURE_TYPE_EDGE_SWIPE) { - _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.edge_swipes.activation, E_GESTURE_TYPE_EDGE_SWIPE); + _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.edge_swipes.base.activation, E_GESTURE_TYPE_EDGE_SWIPE); } if (type & E_GESTURE_TYPE_TAP) { @@ -837,6 +856,7 @@ _e_gesture_cb_grab_edge_swipe(struct wl_client *client, E_Gesture_Event *gev; int sp = 0, ep = 0; unsigned int ret = TIZEN_GESTURE_ERROR_NONE; + E_Gesture_Conf_Edd *conf = gesture->config->conf; 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); if (fingers > E_GESTURE_FINGER_MAX) @@ -881,16 +901,21 @@ _e_gesture_cb_grab_edge_swipe(struct wl_client *client, goto out; } - if (_e_gesture_edge_swipe_boundary_check(&gev->edge_swipes.fingers[fingers], edge, sp, ep)) + if ((conf->edge_swipe.default_enable_back) && + (edge == E_GESTURE_EDGE_TOP)) { - _e_gesture_edge_swipe_grab_add(&gev->edge_swipes.fingers[fingers], client, resource, edge, sp, ep); + ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; + } + else if (_e_gesture_edge_boundary_check(&gev->edge_swipes.base.fingers[fingers], edge, sp, ep)) + { + _e_gesture_edge_grab_add(&gev->edge_swipes.base.fingers[fingers], client, resource, edge, sp, ep); e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge, 0, sp, ep); gesture->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; - gev->edge_swipes.fingers[fingers].enabled = EINA_TRUE; + gev->edge_swipes.base.fingers[fingers].enabled = EINA_TRUE; if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; - gev->edge_swipes.enabled_edge |= (1 << edge); + gev->edge_swipes.base.enabled_edge |= (1 << edge); ret = TIZEN_GESTURE_ERROR_NONE; } @@ -905,12 +930,12 @@ out: } static Eina_Bool -_e_gesture_edge_swipe_grabbed_client_check(struct wl_client *client) +_e_gesture_edge_grabbed_client_check(struct wl_client *client) { Eina_List *l; E_Gesture_Event *gev; int i, j; - E_Gesture_Event_Edge_Swipe_Finger_Edge *edata; + E_Gesture_Event_Edge_Finger_Edge *edata; gev = &gesture->gesture_events; @@ -918,7 +943,7 @@ _e_gesture_edge_swipe_grabbed_client_check(struct wl_client *client) { for (j = 1; j < E_GESTURE_EDGE_MAX + 1; j++) { - EINA_LIST_FOREACH(gev->edge_swipes.fingers[i].edge[j], l, edata) + EINA_LIST_FOREACH(gev->edge_swipes.base.fingers[i].edge[j], l, edata) { if (edata->client == client) return EINA_TRUE; } @@ -937,7 +962,7 @@ _e_gesture_cb_ungrab_edge_swipe(struct wl_client *client, int ret = TIZEN_GESTURE_ERROR_NONE; int i; Eina_List *l, *l_next; - E_Gesture_Event_Edge_Swipe_Finger_Edge *edata; + E_Gesture_Event_Edge_Finger_Edge *edata; Eina_Bool flag_removed = EINA_FALSE; int sp = 0, ep = 0; @@ -978,12 +1003,12 @@ _e_gesture_cb_ungrab_edge_swipe(struct wl_client *client, goto notify; } - EINA_LIST_FOREACH_SAFE(gev->edge_swipes.fingers[fingers].edge[edge], l, l_next, edata) + EINA_LIST_FOREACH_SAFE(gev->edge_swipes.base.fingers[fingers].edge[edge], l, l_next, edata) { if ((edata->client == client) && (edata->sp == sp) && (edata->ep == ep)) { - gev->edge_swipes.fingers[fingers].edge[edge] = eina_list_remove_list( - gev->edge_swipes.fingers[fingers].edge[edge], l); + gev->edge_swipes.base.fingers[fingers].edge[edge] = eina_list_remove_list( + gev->edge_swipes.base.fingers[fingers].edge[edge], l); E_FREE(edata); flag_removed = EINA_TRUE; } @@ -991,19 +1016,19 @@ _e_gesture_cb_ungrab_edge_swipe(struct wl_client *client, if (flag_removed) { - if (!_e_gesture_edge_swipe_grabbed_client_check(client)) + if (!_e_gesture_edge_grabbed_client_check(client)) { _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge, 0, sp, ep); _e_gesture_edge_swipe_current_list_check(); } } - gev->edge_swipes.enabled_edge &= ~( 1 << edge); + gev->edge_swipes.base.enabled_edge &= ~( 1 << edge); for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) { - if (eina_list_count(gev->edge_swipes.fingers[i].edge[edge]) > 0) + if (eina_list_count(gev->edge_swipes.base.fingers[i].edge[edge]) > 0) { - gev->edge_swipes.enabled_edge |= (1 << edge); + gev->edge_swipes.base.enabled_edge |= (1 << edge); break; } } @@ -1013,34 +1038,193 @@ notify: return; } +static int +_e_gesture_grab_edge_drag(struct wl_client *client, + struct wl_resource *resource, + uint32_t fingers, uint32_t edge, uint32_t edge_size, + uint32_t start_point, uint32_t end_point) +{ + E_Gesture_Event *gev; + int sp = 0, ep = 0; + int ret = TIZEN_GESTURE_ERROR_NONE; + + 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); + if (fingers > E_GESTURE_FINGER_MAX) + { + GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto out; + } + + if (edge < TIZEN_GESTURE_EDGE_TOP || edge > TIZEN_GESTURE_EDGE_LEFT) + { + GTWRN("Invalid edge(%d)\n", edge); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto out; + } + + if (edge_size == TIZEN_GESTURE_EDGE_SIZE_PARTIAL) + { + sp = start_point; + ep = end_point; + if (((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) && + (ep > e_comp->w)) + ep = e_comp->w; + else if (((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) && + (ep > e_comp->h)) + ep = e_comp->h; + } + else if (edge_size == TIZEN_GESTURE_EDGE_SIZE_FULL) + { + sp = 0; + if ((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) + ep = e_comp->w; + else if ((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) + ep = e_comp->h; + } + else + { + GTWRN("Invalid edge_size(%d)\n", edge_size); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto out; + } + + gev = &gesture->gesture_events; + + if (_e_gesture_edge_boundary_check(&gev->edge_drags.base.fingers[fingers], edge, sp, ep)) + { + _e_gesture_edge_grab_add(&gev->edge_drags.base.fingers[fingers], client, resource, edge, sp, ep); + + e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_DRAG, fingers, edge, 0, sp, ep); + + gesture->grabbed_gesture |= E_GESTURE_TYPE_EDGE_DRAG; + gev->edge_drags.base.fingers[fingers].enabled = EINA_TRUE; + if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; + gev->edge_drags.base.enabled_edge |= (1 << edge); + + ret = TIZEN_GESTURE_ERROR_NONE; + } + else + { + ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; + } + +out: + return ret; +} + +static int +_e_gesture_ungrab_edge_drag(struct wl_client *client, + struct wl_resource *resouce, + uint32_t fingers, uint32_t edge, uint32_t edge_size, + uint32_t start_point, uint32_t end_point) +{ + E_Gesture_Event *gev; + int ret = TIZEN_GESTURE_ERROR_NONE; + int i; + Eina_List *l, *l_next; + E_Gesture_Event_Edge_Finger_Edge *edata; + Eina_Bool flag_removed = EINA_FALSE; + int sp = 0, ep = 0; + + 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); + + if (fingers > E_GESTURE_FINGER_MAX) + { + GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto out; + } + + if (edge_size == TIZEN_GESTURE_EDGE_SIZE_PARTIAL) + { + sp = start_point; + ep = end_point; + if (((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) && + (ep > e_comp->w)) + ep = e_comp->w; + else if (((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) && + (ep > e_comp->h)) + ep = e_comp->h; + } + else if (edge_size == TIZEN_GESTURE_EDGE_SIZE_FULL) + { + sp = 0; + if ((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) + ep = e_comp->w; + else if ((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) + ep = e_comp->h; + } + else + { + GTWRN("Invalid edge_size(%d)\n", edge_size); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto out; + } + + gev = &gesture->gesture_events; + + EINA_LIST_FOREACH_SAFE(gev->edge_drags.base.fingers[fingers].edge[edge], l, l_next, edata) + { + if ((edata->client == client) && (edata->sp == sp) && (edata->ep == ep)) + { + gev->edge_drags.base.fingers[fingers].edge[edge] = eina_list_remove_list( + gev->edge_drags.base.fingers[fingers].edge[edge], l); + E_FREE(edata); + flag_removed = EINA_TRUE; + } + } + + if (flag_removed) + { + if (!_e_gesture_edge_grabbed_client_check(client)) + { + _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_DRAG, fingers, edge, 0, sp, ep); + _e_gesture_edge_drag_current_list_check(); + } + } + + gev->edge_drags.base.enabled_edge &= ~( 1 << edge); + for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) + { + if (eina_list_count(gev->edge_drags.base.fingers[i].edge[edge]) > 0) + { + gev->edge_drags.base.enabled_edge |= (1 << edge); + break; + } + } + +out: + return ret; +} + + static void _e_gesture_cb_grab_edge_drag(struct wl_client *client, - struct wl_resource *resouce, + struct wl_resource *resource, uint32_t fingers, uint32_t edge, uint32_t edge_size, uint32_t start_point, uint32_t end_point) { int ret = TIZEN_GESTURE_ERROR_NONE; - ret = TIZEN_GESTURE_ERROR_NOT_SUPPORTED; + ret = _e_gesture_grab_edge_drag(client, resource, fingers, edge, edge_size, start_point, end_point); - tizen_gesture_send_grab_edge_swipe_notify(resouce, fingers, edge, edge_size, start_point, end_point, ret); + tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, edge, edge_size, start_point, end_point, ret); } static void _e_gesture_cb_ungrab_edge_drag(struct wl_client *client, - struct wl_resource *resouce, + struct wl_resource *resource, uint32_t fingers, uint32_t edge, uint32_t edge_size, uint32_t start_point, uint32_t end_point) { int ret = TIZEN_GESTURE_ERROR_NONE; - ret = TIZEN_GESTURE_ERROR_NOT_SUPPORTED; + ret = _e_gesture_ungrab_edge_drag(client, resource, fingers, edge, edge_size, start_point, end_point); - tizen_gesture_send_grab_edge_swipe_notify(resouce, fingers, edge, edge_size, start_point, end_point, ret); + tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, edge, edge_size, start_point, end_point, ret); } - - static void _e_gesture_cb_grab_tap(struct wl_client *client, struct wl_resource *resource, @@ -1290,9 +1474,9 @@ _e_gesture_deactivate_surface_check(E_Client *ec) surface = ec->comp_data->wl_surface; if (!surface) return; - if (!gesture->gesture_events.edge_swipes.activation.client) + if (!gesture->gesture_events.edge_swipes.base.activation.client) { - _e_gesture_deactivate_surface_list_check(surface, &gesture->gesture_events.edge_swipes.activation); + _e_gesture_deactivate_surface_list_check(surface, &gesture->gesture_events.edge_swipes.base.activation); } if (!gesture->gesture_events.taps.activation.client) { @@ -1460,13 +1644,20 @@ _e_gesture_init(E_Module *m) gesture->gesture_filter = E_GESTURE_TYPE_MAX; + gesture->gesture_events.edge_swipes.base.activation.active = EINA_TRUE; + gesture->gesture_events.edge_drags.base.activation.active = EINA_TRUE; + gesture->gesture_events.taps.activation.active = EINA_TRUE; + gesture->gesture_events.palm_covers.activation.active = EINA_TRUE; + gesture->gesture_events.pans.activation.active = EINA_TRUE; + gesture->gesture_events.pinchs.activation.active = EINA_TRUE; + gesture->gesture_events.event_keep = gconfig->conf->event_keep; if (gconfig->conf->edge_swipe.default_enable_back) { gesture->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; - gesture->gesture_events.edge_swipes.fingers[1].enabled = EINA_TRUE; - _e_gesture_edge_swipe_grab_add(&gesture->gesture_events.edge_swipes.fingers[1], (void *)0x1, (void *)0x1, E_GESTURE_EDGE_TOP, 0, 0); - gesture->gesture_events.edge_swipes.enabled_edge |= (1 << TIZEN_GESTURE_EDGE_TOP); + gesture->gesture_events.edge_swipes.base.fingers[1].enabled = EINA_TRUE; + _e_gesture_edge_grab_add(&gesture->gesture_events.edge_swipes.base.fingers[1], (void *)0x1, (void *)0x1, E_GESTURE_EDGE_TOP, 0, 0); + gesture->gesture_events.edge_swipes.base.enabled_edge |= (1 << TIZEN_GESTURE_EDGE_TOP); if (gesture->gesture_events.event_keep) { gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; @@ -1542,7 +1733,7 @@ _e_gesture_remove_client_edge_swipe(struct wl_client *client, E_Gesture_Grabbed_ int i, j; Eina_List *l, *ll; E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; - E_Gesture_Event_Edge_Swipe_Finger_Edge *edata; + E_Gesture_Event_Edge_Finger_Edge *edata; for (i = 0; i < E_GESTURE_FINGER_MAX + 1; i++) { @@ -1550,11 +1741,11 @@ _e_gesture_remove_client_edge_swipe(struct wl_client *client, E_Gesture_Grabbed_ { for (j = 0; j < E_GESTURE_EDGE_MAX + 1; j++) { - EINA_LIST_FOREACH_SAFE(edge_swipes->fingers[i].edge[j], l, ll, edata) + EINA_LIST_FOREACH_SAFE(edge_swipes->base.fingers[i].edge[j], l, ll, edata) { if (edata->client == client) { - edge_swipes->fingers[i].edge[j] = eina_list_remove_list(edge_swipes->fingers[i].edge[j], l); + edge_swipes->base.fingers[i].edge[j] = eina_list_remove_list(edge_swipes->base.fingers[i].edge[j], l); E_FREE(edata); } } @@ -1572,6 +1763,42 @@ _e_gesture_remove_client_edge_swipe(struct wl_client *client, E_Gesture_Grabbed_ } static void +_e_gesture_remove_client_edge_drag(struct wl_client *client, E_Gesture_Grabbed_Client *gclient) +{ + int i, j; + Eina_List *l, *ll; + E_Gesture_Event_Edge_Drag *edge_drags = &gesture->gesture_events.edge_drags; + E_Gesture_Event_Edge_Finger_Edge *edata; + + for (i = 0; i < E_GESTURE_FINGER_MAX + 1; i++) + { + if (gclient->edge_drag_fingers[i].enabled) + { + for (j = 0; j < E_GESTURE_EDGE_MAX + 1; j++) + { + EINA_LIST_FOREACH_SAFE(edge_drags->base.fingers[i].edge[j], l, ll, edata) + { + if (edata->client == client) + { + edge_drags->base.fingers[i].edge[j] = eina_list_remove_list(edge_drags->base.fingers[i].edge[j], l); + E_FREE(edata); + } + } + EINA_LIST_FOREACH_SAFE(gclient->edge_drag_fingers[i].edge[j], l, ll, edata) + { + if (edata->client == client) + { + gclient->edge_drag_fingers[i].edge[j] = eina_list_remove_list(gclient->edge_drag_fingers[i].edge[j], l); + E_FREE(edata); + } + } + } + } + } +} + + +static void _e_gesture_remove_client_tap(struct wl_client *client, E_Gesture_Grabbed_Client *gclient) { int i, j; @@ -1654,6 +1881,11 @@ _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data) _e_gesture_remove_client_edge_swipe(client, client_data); removed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; } + if (client_data->grabbed_gesture & E_GESTURE_TYPE_EDGE_DRAG) + { + _e_gesture_remove_client_edge_drag(client, client_data); + removed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; + } if (client_data->grabbed_gesture & E_GESTURE_TYPE_TAP) { _e_gesture_remove_client_tap(client, client_data); @@ -1679,6 +1911,8 @@ _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data) if (removed_gesture & E_GESTURE_TYPE_EDGE_SWIPE) _e_gesture_edge_swipe_current_list_check(); + if (removed_gesture & E_GESTURE_TYPE_EDGE_DRAG) + _e_gesture_edge_drag_current_list_check(); if (removed_gesture & E_GESTURE_TYPE_TAP) _e_gesture_tap_current_list_check(); if (removed_gesture & E_GESTURE_TYPE_PAN) diff --git a/src/e_mod_main.h b/src/e_mod_main.h index fd12119..13e2510 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -38,6 +38,10 @@ #define E_GESTURE_EDGE_SWIPE_BACK_KEY 166 #define E_GESTURE_EDGE_SWIPE_BACK_DEFAULT_ENABLE EINA_TRUE +#define E_GESTURE_EDGE_DRAG_START_TIME 0.01 +#define E_GESTURE_EDGE_DRAG_START_AREA 50 +#define E_GESTURE_EDGE_DRAG_DIFF 10 + #define E_GESTURE_TAP_REPEATS_MAX 3 #define E_GESTURE_TAP_START_TIME 0.05 #define E_GESTURE_TAP_DONE_TIME 1.0 @@ -56,9 +60,11 @@ typedef struct _E_Gesture E_Gesture; typedef struct _E_Gesture* E_GesturePtr; typedef struct _E_Gesture_Event E_Gesture_Event; +typedef struct _E_Gesture_Event_Edge E_Gesture_Event_Edge; typedef struct _E_Gesture_Event_Edge_Swipe E_Gesture_Event_Edge_Swipe; -typedef struct _E_Gesture_Event_Edge_Swipe_Finger E_Gesture_Event_Edge_Swipe_Finger; -typedef struct _E_Gesture_Event_Edge_Swipe_Finger_Edge E_Gesture_Event_Edge_Swipe_Finger_Edge; +typedef struct _E_Gesture_Event_Edge_Drag E_Gesture_Event_Edge_Drag; +typedef struct _E_Gesture_Event_Edge_Finger E_Gesture_Event_Edge_Finger; +typedef struct _E_Gesture_Event_Edge_Finger_Edge E_Gesture_Event_Edge_Finger_Edge; typedef struct _E_Gesture_Grabbed_Client E_Gesture_Grabbed_Client; typedef struct _E_Gesture_Conf_Edd E_Gesture_Conf_Edd; typedef struct _E_Gesture_Config_Data E_Gesture_Config_Data; @@ -180,6 +186,12 @@ struct _E_Gesture_Conf_Edd } edge_swipe; struct { + double time_begin; + int area_offset; + int diff_length; + } edge_drag; + struct + { int repeats_max; double time_start; double time_done; @@ -216,7 +228,7 @@ struct _E_Gesture_Select_Surface struct wl_resource *res; }; -struct _E_Gesture_Event_Edge_Swipe_Finger_Edge +struct _E_Gesture_Event_Edge_Finger_Edge { struct wl_client *client; struct wl_resource *res; @@ -224,30 +236,47 @@ struct _E_Gesture_Event_Edge_Swipe_Finger_Edge unsigned int ep; }; -struct _E_Gesture_Event_Edge_Swipe_Finger +struct _E_Gesture_Event_Edge_Finger { Coords start; Eina_Bool enabled; Eina_List *edge[E_GESTURE_EDGE_MAX + 1]; }; -struct _E_Gesture_Event_Edge_Swipe +struct _E_Gesture_Event_Edge { E_Gesture_Activate_Info activation; - E_Gesture_Event_Edge_Swipe_Finger fingers[E_GESTURE_FINGER_MAX + 2]; + E_Gesture_Event_Edge_Finger fingers[E_GESTURE_FINGER_MAX + 2]; unsigned int edge; - unsigned int combined_keycode; - unsigned int back_keycode; - unsigned int enabled_finger; unsigned int enabled_edge; +}; + +struct _E_Gesture_Event_Edge_Swipe +{ + E_Gesture_Event_Edge base; + + unsigned int combined_keycode; + unsigned int back_keycode; Ecore_Timer *start_timer; Ecore_Timer *done_timer; }; +struct _E_Gesture_Event_Edge_Drag +{ + E_Gesture_Event_Edge base; + + Ecore_Timer *start_timer; + + int idx; + + Coords start_point; + Coords center_point; +}; + struct _E_Gesture_Event_Tap_Finger_Repeats { struct wl_client *client; @@ -320,7 +349,8 @@ struct _E_Gesture_Grabbed_Client struct wl_listener *destroy_listener; unsigned int grabbed_gesture; - E_Gesture_Event_Edge_Swipe_Finger edge_swipe_fingers[E_GESTURE_FINGER_MAX + 2]; + E_Gesture_Event_Edge_Finger edge_swipe_fingers[E_GESTURE_FINGER_MAX + 2]; + E_Gesture_Event_Edge_Finger edge_drag_fingers[E_GESTURE_FINGER_MAX + 2]; E_Gesture_Event_Tap_Finger tap_fingers[E_GESTURE_FINGER_MAX + 2]; E_Gesture_Event_Client pan_fingers[E_GESTURE_FINGER_MAX + 2]; E_Gesture_Event_Client pinch_fingers[E_GESTURE_FINGER_MAX + 2]; @@ -330,6 +360,7 @@ struct _E_Gesture_Grabbed_Client struct _E_Gesture_Event { E_Gesture_Event_Edge_Swipe edge_swipes; + E_Gesture_Event_Edge_Drag edge_drags; E_Gesture_Event_Tap taps; E_Gesture_Event_Pan pans; E_Gesture_Event_Pinch pinchs; -- 2.7.4 From fe54cb935d37516501723d7f1a4c3bb4223b3a67 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Wed, 2 Aug 2017 11:12:03 +0900 Subject: [PATCH 04/16] package version up to 0.2.0 Change-Id: Id01b08b2543cfad89a2d31dc83430bafd3a706b6 --- packaging/e-mod-tizen-gesture.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/e-mod-tizen-gesture.spec b/packaging/e-mod-tizen-gesture.spec index 75478b7..2d87bef 100644 --- a/packaging/e-mod-tizen-gesture.spec +++ b/packaging/e-mod-tizen-gesture.spec @@ -2,7 +2,7 @@ %bcond_with wayland Name: e-mod-tizen-gesture -Version: 0.1.9 +Version: 0.2.0 Release: 1 Summary: The Enlightenment Gesture Module for Tizen URL: http://www.enlightenment.org -- 2.7.4 From d1ab2e9927301055eb8d99b09df76ae83fbcf68c Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Thu, 3 Aug 2017 20:54:27 +0900 Subject: [PATCH 05/16] add comments for config values Change-Id: I37be65135497a644913c25d04265e288c08c012e --- src/e_mod_main.h | 43 ++++++++++++++++++++++--------------------- 1 file changed, 22 insertions(+), 21 deletions(-) diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 13e2510..07cf14f 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -171,41 +171,42 @@ struct _E_Gesture_Activate_Info struct _E_Gesture_Conf_Edd { - char *key_device_name; - Eina_Bool event_keep; + char *key_device_name; // The name of keyboard device to generate key events + Eina_Bool event_keep; // 1: Do not propagate events to client immediatly until recognizing gestures + // 0: Propagate events immediatly but send a cancel event after recognizing gestures (default) struct { - double time_done; - double time_begin; - int area_offset; - int min_length; - int max_length; - int compose_key; - int back_key; - Eina_Bool default_enable_back; + double time_done; // The duration to recognize a edge swipe + double time_begin; // The minimun of time to distinguish if it is a gesture or normal touch + int area_offset; // Edge region to start to calculate + int min_length; // Limit size to move cross direction + int max_length; // Moving length to recognize edge swipe + int compose_key; // Keycode of composed with gesture + int back_key; // Keycode of back key + Eina_Bool default_enable_back; // Convert a top edge swipe to back key } edge_swipe; struct { - double time_begin; - int area_offset; - int diff_length; + double time_begin; // The minimun of time to distinguish if it is a gesture or normal touch + int area_offset; // Edge region to start to calculate + int diff_length; // Moved length to generate edge drag events } edge_drag; struct { - int repeats_max; - double time_start; - double time_done; - double time_interval; - int moving_range; + int repeats_max; // Maximum number of repeats + double time_start; // Minimun of time to distinguish if it is a gesture or normal touch + double time_done; // Duration to release all fingers + double time_interval; // Interval duration between taps + int moving_range; // Limit region duriong taps } tap; struct { - double time_start; - int moving_range; + double time_start; // The minimun of time to distinguish if it is a gesture or normal touch + int moving_range; // Moved length to generate pan events } pan; struct { - double moving_distance_range; + double moving_distance_range; // Moved length to generate pinch events } pinch; }; -- 2.7.4 From 1192dc0f3ddeacb4a73367025f573e6f97c1860c Mon Sep 17 00:00:00 2001 From: "JunSeok, Kim" Date: Mon, 14 Aug 2017 14:41:48 +0900 Subject: [PATCH 06/16] e_mod_main: add implementation for version 3 of tizen_gesture The desturctor added to tizen_gesture so add the implementation of server side. Change-Id: I18a71240785863fd69c9b89518d9f7dd4ade97bc --- src/e_mod_main.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/e_mod_main.c b/src/e_mod_main.c index a351fc8..c350d77 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -1377,6 +1377,12 @@ _e_gesture_cb_activate_set(struct wl_client *client, tizen_gesture_send_activate_notify(resource, surface, type, active, ret); } +static void +_e_gesture_cb_destroy(struct wl_client *client, struct wl_resource *resource) +{ + wl_resource_destroy(resource); +} + static const struct tizen_gesture_interface _e_gesture_implementation = { _e_gesture_cb_grab_edge_swipe, _e_gesture_cb_ungrab_edge_swipe, @@ -1389,15 +1395,9 @@ static const struct tizen_gesture_interface _e_gesture_implementation = { _e_gesture_cb_select_palm_cover, _e_gesture_cb_deselect_palm_cover, _e_gesture_cb_activate_set, + _e_gesture_cb_destroy, }; -/* tizen_gesture global object destroy function */ -static void -_e_gesture_cb_destory(struct wl_resource *resource) -{ - /* TODO : destroy resources if exist */ -} - /* tizen_gesture global object bind function */ static void _e_gesture_cb_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id) @@ -1405,7 +1405,7 @@ _e_gesture_cb_bind(struct wl_client *client, void *data, uint32_t version, uint3 E_GesturePtr gesture_instance = data; struct wl_resource *resource; - resource = wl_resource_create(client, &tizen_gesture_interface, MAX(version, 1), id); + resource = wl_resource_create(client, &tizen_gesture_interface, MIN(version, 3), id); GTDBG("wl_resource_create(...,tizen_gesture_interface,...)\n"); @@ -1416,7 +1416,7 @@ _e_gesture_cb_bind(struct wl_client *client, void *data, uint32_t version, uint3 return; } - wl_resource_set_implementation(resource, &_e_gesture_implementation, gesture_instance, _e_gesture_cb_destory); + wl_resource_set_implementation(resource, &_e_gesture_implementation, gesture_instance, _e_gesture_cb_destroy); } static Eina_Bool @@ -1635,7 +1635,7 @@ _e_gesture_init(E_Module *m) GTDBG("pan time_start: %lf, moving_range: %d\n", gconfig->conf->pan.time_start, gconfig->conf->pan.moving_range); GTDBG("pinch moving_distance_range: %lf\n", gconfig->conf->pinch.moving_distance_range); - gesture->global = wl_global_create(e_comp_wl->wl.disp, &tizen_gesture_interface, 2, gesture, _e_gesture_cb_bind); + gesture->global = wl_global_create(e_comp_wl->wl.disp, &tizen_gesture_interface, 3, gesture, _e_gesture_cb_bind); if (!gesture->global) { GTERR("Failed to create global !\n"); -- 2.7.4 From 8f97f2f1db0e94d545fbfa08e3e0f4d64e62a562 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Thu, 17 Aug 2017 14:13:36 +0900 Subject: [PATCH 07/16] packaging: version up to 0.2.1 Change-Id: I1220e542da7c5ab6f42b21d3b23adf84ae278884 --- packaging/e-mod-tizen-gesture.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/e-mod-tizen-gesture.spec b/packaging/e-mod-tizen-gesture.spec index 2d87bef..1c87b1b 100644 --- a/packaging/e-mod-tizen-gesture.spec +++ b/packaging/e-mod-tizen-gesture.spec @@ -2,7 +2,7 @@ %bcond_with wayland Name: e-mod-tizen-gesture -Version: 0.2.0 +Version: 0.2.1 Release: 1 Summary: The Enlightenment Gesture Module for Tizen URL: http://www.enlightenment.org -- 2.7.4 From ad4e9563c5e32ce8c4569f52da7da05e51592704 Mon Sep 17 00:00:00 2001 From: "JunSeok, Kim" Date: Thu, 17 Aug 2017 21:48:17 +0900 Subject: [PATCH 08/16] e-mod-tizen-gesture: fix problem with double free Change-Id: Ia00b31ad06eda2f11aaf5ffd90a42e422f41ab56 --- src/e_mod_main.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/e_mod_main.c b/src/e_mod_main.c index c350d77..f2cc077 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -1416,7 +1416,7 @@ _e_gesture_cb_bind(struct wl_client *client, void *data, uint32_t version, uint3 return; } - wl_resource_set_implementation(resource, &_e_gesture_implementation, gesture_instance, _e_gesture_cb_destroy); + wl_resource_set_implementation(resource, &_e_gesture_implementation, NULL, NULL); } static Eina_Bool -- 2.7.4 From 9130283e6bf0211725bbe34c517da40d8b94a257 Mon Sep 17 00:00:00 2001 From: "JunSeok, Kim" Date: Tue, 29 Aug 2017 18:25:19 +0900 Subject: [PATCH 09/16] e-mod-tizen-gesture: change version of tizen_gesture from 3 to 2 Tizen_gesture interface version is reverted from 3 to 2. So, changed version of server side implementation. Change-Id: I400485ef4e1138ff2c43267e12523b419fa4c1de --- src/e_mod_main.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/e_mod_main.c b/src/e_mod_main.c index f2cc077..0cb9cfb 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -1405,7 +1405,7 @@ _e_gesture_cb_bind(struct wl_client *client, void *data, uint32_t version, uint3 E_GesturePtr gesture_instance = data; struct wl_resource *resource; - resource = wl_resource_create(client, &tizen_gesture_interface, MIN(version, 3), id); + resource = wl_resource_create(client, &tizen_gesture_interface, MIN(version, 2), id); GTDBG("wl_resource_create(...,tizen_gesture_interface,...)\n"); @@ -1635,7 +1635,7 @@ _e_gesture_init(E_Module *m) GTDBG("pan time_start: %lf, moving_range: %d\n", gconfig->conf->pan.time_start, gconfig->conf->pan.moving_range); GTDBG("pinch moving_distance_range: %lf\n", gconfig->conf->pinch.moving_distance_range); - gesture->global = wl_global_create(e_comp_wl->wl.disp, &tizen_gesture_interface, 3, gesture, _e_gesture_cb_bind); + gesture->global = wl_global_create(e_comp_wl->wl.disp, &tizen_gesture_interface, 2, gesture, _e_gesture_cb_bind); if (!gesture->global) { GTERR("Failed to create global !\n"); -- 2.7.4 From 41d77bb6ad7236dc3a189f5b879f90ca123aa468 Mon Sep 17 00:00:00 2001 From: "JunSeok, Kim" Date: Wed, 30 Aug 2017 16:44:08 +0900 Subject: [PATCH 10/16] Revert "e-mod-tizen-gesture: change version of tizen_gesture from 3 to 2" This reverts commit 9130283e6bf0211725bbe34c517da40d8b94a257. Change-Id: Id955d5fed9d57fc770891eaf5568027a52c5f4d0 --- src/e_mod_main.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/e_mod_main.c b/src/e_mod_main.c index 0cb9cfb..f2cc077 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -1405,7 +1405,7 @@ _e_gesture_cb_bind(struct wl_client *client, void *data, uint32_t version, uint3 E_GesturePtr gesture_instance = data; struct wl_resource *resource; - resource = wl_resource_create(client, &tizen_gesture_interface, MIN(version, 2), id); + resource = wl_resource_create(client, &tizen_gesture_interface, MIN(version, 3), id); GTDBG("wl_resource_create(...,tizen_gesture_interface,...)\n"); @@ -1635,7 +1635,7 @@ _e_gesture_init(E_Module *m) GTDBG("pan time_start: %lf, moving_range: %d\n", gconfig->conf->pan.time_start, gconfig->conf->pan.moving_range); GTDBG("pinch moving_distance_range: %lf\n", gconfig->conf->pinch.moving_distance_range); - gesture->global = wl_global_create(e_comp_wl->wl.disp, &tizen_gesture_interface, 2, gesture, _e_gesture_cb_bind); + gesture->global = wl_global_create(e_comp_wl->wl.disp, &tizen_gesture_interface, 3, gesture, _e_gesture_cb_bind); if (!gesture->global) { GTERR("Failed to create global !\n"); -- 2.7.4 From beda544a45a0588a62d614d8b10790321b3c60d7 Mon Sep 17 00:00:00 2001 From: "JunSeok, Kim" Date: Wed, 30 Aug 2017 17:31:44 +0900 Subject: [PATCH 11/16] packaging: version up to 0.2.2 Change-Id: I3cdc67c216546fe4bac7fe62d3f3771040755b30 --- packaging/e-mod-tizen-gesture.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/e-mod-tizen-gesture.spec b/packaging/e-mod-tizen-gesture.spec index 1c87b1b..f687a6f 100644 --- a/packaging/e-mod-tizen-gesture.spec +++ b/packaging/e-mod-tizen-gesture.spec @@ -2,7 +2,7 @@ %bcond_with wayland Name: e-mod-tizen-gesture -Version: 0.2.1 +Version: 0.2.2 Release: 1 Summary: The Enlightenment Gesture Module for Tizen URL: http://www.enlightenment.org -- 2.7.4 From 7b6db3eefe4d0807615620666daf903ad3405d54 Mon Sep 17 00:00:00 2001 From: Youngjae Shin Date: Fri, 8 Sep 2017 08:51:33 +0900 Subject: [PATCH 12/16] remove build warning Change-Id: I8c982521ba43b1a3a7cbc03540e3f8662cee70b3 --- src/e_mod_main.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/e_mod_main.c b/src/e_mod_main.c index f2cc077..7368f47 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -1402,7 +1402,6 @@ static const struct tizen_gesture_interface _e_gesture_implementation = { static void _e_gesture_cb_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id) { - E_GesturePtr gesture_instance = data; struct wl_resource *resource; resource = wl_resource_create(client, &tizen_gesture_interface, MIN(version, 3), id); -- 2.7.4 From 2b4ca5f01036b283b15e86456d4bd7c2237f2386 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Fri, 8 Sep 2017 11:10:01 +0900 Subject: [PATCH 13/16] revert version of tizen_gesture from 3 to 2 Change-Id: If2da49506519e652b07f2c0a3a6b2bc660132bfc --- src/e_mod_main.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/e_mod_main.c b/src/e_mod_main.c index 7368f47..e585a53 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -1404,7 +1404,7 @@ _e_gesture_cb_bind(struct wl_client *client, void *data, uint32_t version, uint3 { struct wl_resource *resource; - resource = wl_resource_create(client, &tizen_gesture_interface, MIN(version, 3), id); + resource = wl_resource_create(client, &tizen_gesture_interface, version, id); GTDBG("wl_resource_create(...,tizen_gesture_interface,...)\n"); @@ -1634,7 +1634,7 @@ _e_gesture_init(E_Module *m) GTDBG("pan time_start: %lf, moving_range: %d\n", gconfig->conf->pan.time_start, gconfig->conf->pan.moving_range); GTDBG("pinch moving_distance_range: %lf\n", gconfig->conf->pinch.moving_distance_range); - gesture->global = wl_global_create(e_comp_wl->wl.disp, &tizen_gesture_interface, 3, gesture, _e_gesture_cb_bind); + gesture->global = wl_global_create(e_comp_wl->wl.disp, &tizen_gesture_interface, 2, gesture, _e_gesture_cb_bind); if (!gesture->global) { GTERR("Failed to create global !\n"); -- 2.7.4 From 9cba03834ba8b9c2f6605100eec5314af45b6473 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Mon, 11 Sep 2017 14:33:57 +0900 Subject: [PATCH 14/16] support the server grab mode Change-Id: I60ad06185affb2d41e11dd24fa5929e54da24623 --- src/e_mod_gesture_events.c | 134 +++- src/e_mod_main.c | 1521 +++++++++++++++++++++++++------------------- src/e_mod_main.h | 11 +- 3 files changed, 979 insertions(+), 687 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index 13f2b36..c32b449 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -297,6 +297,7 @@ _e_gesture_send_edge_swipe(int fingers, int x, int y, int edge) E_Gesture_Event_Edge_Finger_Edge *edata; E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; int bp = -1; + E_Event_Gesture_Edge_Swipe *ev_swipe; if (gesture->gesture_events.event_keep) { @@ -337,7 +338,20 @@ _e_gesture_send_edge_swipe(int fingers, int x, int y, int edge) if (bp >= edata->sp && bp <= edata->ep) { GTINF("Send edge_swipe gesture (fingers: %d, edge: %d) to client: %p\n", fingers, edge, edata->client); - tizen_gesture_send_edge_swipe(edata->res, TIZEN_GESTURE_MODE_DONE, fingers, x, y, edge); + if (edata->client == E_GESTURE_SERVER_CLIENT) + { + ev_swipe = E_NEW(E_Event_Gesture_Edge_Swipe, 1); + EINA_SAFETY_ON_NULL_RETURN(ev_swipe); + + ev_swipe->mode = E_GESTURE_MODE_DONE; + ev_swipe->edge = edge; + ev_swipe->fingers = fingers; + ev_swipe->sx = x; + ev_swipe->sy = y; + ecore_event_add(E_EVENT_GESTURE_EDGE_SWIPE, ev_swipe, NULL, NULL); + } + else + tizen_gesture_send_edge_swipe(edata->res, TIZEN_GESTURE_MODE_DONE, fingers, x, y, edge); break; } } @@ -628,6 +642,7 @@ _e_gesture_send_edge_drag(int fingers, int x, int y, int edge, int mode) E_Gesture_Event_Edge_Finger_Edge *edata; E_Gesture_Event_Edge_Drag *edge_drags = &gesture->gesture_events.edge_drags; int bp = -1; + E_Event_Gesture_Edge_Drag *ev_drag; if (gesture->gesture_events.event_keep) { @@ -660,6 +675,19 @@ _e_gesture_send_edge_drag(int fingers, int x, int y, int edge, int mode) if (bp >= edata->sp && bp <= edata->ep) { GTINF("Send edge drag gesture (fingers: %d, edge: %d) to client: %p\n", fingers, edge, edata->client); + if (edata->client == E_GESTURE_SERVER_CLIENT) + { + ev_drag = E_NEW(E_Event_Gesture_Edge_Drag, 1); + EINA_SAFETY_ON_NULL_RETURN(ev_drag); + + ev_drag->mode = E_GESTURE_MODE_DONE; + ev_drag->edge = edge; + ev_drag->fingers = fingers; + ev_drag->cx = x; + ev_drag->cy = y; + ecore_event_add(E_EVENT_GESTURE_EDGE_DRAG, ev_drag, NULL, NULL); + } + else tizen_gesture_send_edge_drag(edata->res, mode, fingers, x, y, edge); break; } @@ -809,6 +837,7 @@ static void _e_gesture_pan_send(int mode, int fingers, int cx, int cy, struct wl_resource *res, struct wl_client *client) { Ecore_Event_Mouse_Button *ev_cancel; + E_Event_Gesture_Pan *ev_pan; if (mode == TIZEN_GESTURE_MODE_BEGIN) { @@ -822,6 +851,18 @@ _e_gesture_pan_send(int mode, int fingers, int cx, int cy, struct wl_resource *r } GTINF("Send pan gesture %d fingers. (%d, %d) to client: %p, mode: %d\n", fingers, cx, cy, client, mode); + if (client == E_GESTURE_SERVER_CLIENT) + { + ev_pan = E_NEW(E_Event_Gesture_Pan, 1); + EINA_SAFETY_ON_NULL_RETURN(ev_pan); + + ev_pan->mode = mode; + ev_pan->fingers = fingers; + ev_pan->cx = cx; + ev_pan->cy = cy; + + ecore_event_add(E_EVENT_GESTURE_PAN, ev_pan, NULL, NULL); + } gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_PAN; } @@ -958,6 +999,7 @@ static void _e_gesture_pinch_send(int mode, int fingers, double distance, double angle, int cx, int cy, struct wl_resource *res, struct wl_client *client) { Ecore_Event_Mouse_Button *ev_cancel; + E_Event_Gesture_Pinch *ev_pinch; if (mode == TIZEN_GESTURE_MODE_BEGIN) { @@ -971,6 +1013,20 @@ _e_gesture_pinch_send(int mode, int fingers, double distance, double angle, int } GTINF("Send pinch gesture (fingers: %d, distance: %lf, angle: %lf, cx: %d, cy: %d) to client: %p, mode: %d\n", fingers, distance, angle, cx, cy, client, mode); + if (client == E_GESTURE_SERVER_CLIENT) + { + ev_pinch = E_NEW(E_Event_Gesture_Pinch, 1); + EINA_SAFETY_ON_NULL_RETURN(ev_pinch); + + ev_pinch->mode = mode; + ev_pinch->fingers = fingers; + ev_pinch->distance = distance; + ev_pinch->angle = angle; + ev_pinch->cx = cx; + ev_pinch->cy = cy; + + ecore_event_add(E_EVENT_GESTURE_PINCH, ev_pinch, NULL, NULL); + } gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_PINCH; } @@ -1165,8 +1221,22 @@ _e_gesture_tap_cancel(void) static void _e_gesture_send_tap(int fingers, int repeats, struct wl_client *client, struct wl_resource *res) { + E_Event_Gesture_Tap *ev_tap; + GTINF("Send Tap gesture. %d fingers %d repeats to client (%p)\n", fingers, repeats, client); - tizen_gesture_send_tap(res, TIZEN_GESTURE_MODE_DONE, fingers, repeats); + if (client == E_GESTURE_SERVER_CLIENT) + { + ev_tap = E_NEW(E_Event_Gesture_Tap, 1); + EINA_SAFETY_ON_NULL_RETURN(ev_tap); + + ev_tap->mode = E_GESTURE_MODE_DONE; + ev_tap->fingers = fingers; + ev_tap->repeats = repeats; + + ecore_event_add(E_EVENT_GESTURE_TAP, ev_tap, NULL, NULL); + } + else + tizen_gesture_send_tap(res, TIZEN_GESTURE_MODE_DONE, fingers, repeats); _e_gesture_event_drop(); gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_TAP; @@ -1629,6 +1699,7 @@ _e_gesture_send_palm_cover(void) struct wl_resource *surface = NULL, *res = NULL, *focus_surface = NULL; Eina_List *l; E_Gesture_Select_Surface *sdata; + E_Event_Gesture_Palm_Cover *ev_palm_cover; time = (int)(ecore_time_get()*1000); @@ -1651,30 +1722,57 @@ _e_gesture_send_palm_cover(void) GTINF("Send palm_cover gesture to client: %p\n", palm_covers->client_info.client); - pressure = wl_fixed_from_double(0.0); + if (palm_covers->client_info.client == E_GESTURE_SERVER_CLIENT) + { + ev_palm_cover = E_NEW(E_Event_Gesture_Palm_Cover, 1); + EINA_SAFETY_ON_NULL_RETURN(ev_palm_cover); + + ev_palm_cover->mode = E_GESTURE_MODE_BEGIN; + ev_palm_cover->duration = duration; + ev_palm_cover->cx = cx; + ev_palm_cover->cy = cy; + ev_palm_cover->size = size; + ev_palm_cover->pressure = 0.0; + ecore_event_add(E_EVENT_GESTURE_PALM_COVER, ev_palm_cover, NULL, NULL); + + ev_palm_cover = E_NEW(E_Event_Gesture_Palm_Cover, 1); + EINA_SAFETY_ON_NULL_RETURN(ev_palm_cover); - focus_surface = _e_gesture_util_eclient_surface_get(e_client_focused_get()); - if (focus_surface) + ev_palm_cover->mode = E_GESTURE_MODE_END; + ev_palm_cover->duration = duration; + ev_palm_cover->cx = cx; + ev_palm_cover->cy = cy; + ev_palm_cover->size = size; + ev_palm_cover->pressure = 0.0; + ecore_event_add(E_EVENT_GESTURE_PALM_COVER, ev_palm_cover, NULL, NULL); + } + else { - EINA_LIST_FOREACH(palm_covers->select_surface_list, l, sdata) + pressure = wl_fixed_from_double(0.0); + + focus_surface = _e_gesture_util_eclient_surface_get(e_client_focused_get()); + if (focus_surface) { - if (focus_surface == sdata->surface) + EINA_LIST_FOREACH(palm_covers->select_surface_list, l, sdata) { - surface = sdata->surface; - res = sdata->res; - break; + if (focus_surface == sdata->surface) + { + surface = sdata->surface; + res = sdata->res; + break; + } } } - } - if (!surface || !res) - { - res = palm_covers->client_info.res; - surface = NULL; - } + if (!surface || !res) + { + res = palm_covers->client_info.res; + surface = NULL; + } - tizen_gesture_send_palm_cover(palm_covers->client_info.res, surface, TIZEN_GESTURE_MODE_BEGIN, duration, size, pressure, cx, cy); - tizen_gesture_send_palm_cover(palm_covers->client_info.res, surface, TIZEN_GESTURE_MODE_END, duration, size, pressure, cx, cy); + tizen_gesture_send_palm_cover(palm_covers->client_info.res, surface, TIZEN_GESTURE_MODE_BEGIN, duration, size, pressure, cx, cy); + tizen_gesture_send_palm_cover(palm_covers->client_info.res, surface, TIZEN_GESTURE_MODE_END, duration, size, pressure, cx, cy); + } gesture->event_state = E_GESTURE_EVENT_STATE_IGNORE; gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_PALM_COVER; diff --git a/src/e_mod_main.c b/src/e_mod_main.c index e585a53..9233cd1 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -73,6 +73,26 @@ _e_gesture_set_client_to_list(E_Gesture_Grabbed_Client *gclient, struct wl_clien gclient->grabbed_gesture |= mode; } +static char * +_e_gesture_util_type_to_string(unsigned int type) +{ + switch (type) + { + case E_GESTURE_TYPE_EDGE_SWIPE: + return "edge_swipe"; + case E_GESTURE_TYPE_TAP: + return "tap"; + case E_GESTURE_TYPE_PALM_COVER: + return "palm_cover"; + case E_GESTURE_TYPE_PAN: + return "pan"; + case E_GESTURE_TYPE_PINCH: + return "pinch"; + default: + return "unknown"; + } +} + /* Function for registering wl_client destroy listener */ int e_gesture_add_client_destroy_listener(struct wl_client *client, int mode, int fingers, unsigned int edge, unsigned int repeat, int sp, int ep) @@ -81,6 +101,8 @@ e_gesture_add_client_destroy_listener(struct wl_client *client, int mode, int fi Eina_List *l; E_Gesture_Grabbed_Client *grabbed_client, *data; + if (client == E_GESTURE_SERVER_CLIENT) return TIZEN_GESTURE_ERROR_NONE; + EINA_LIST_FOREACH(gesture->grab_client_list, l, data) { if (data->client == client) @@ -229,6 +251,40 @@ _e_gesture_pinch_current_list_check(void) } } +static int +_e_gesture_add_surface_destroy_listener(struct wl_resource *surface, int type) +{ + struct wl_listener *destroy_listener = NULL; + Eina_List *l; + struct wl_resource *surface_data; + + EINA_SAFETY_ON_NULL_RETURN_VAL(surface, TIZEN_GESTURE_ERROR_INVALID_DATA); + if (type != E_GESTURE_TYPE_PALM_COVER) + return TIZEN_GESTURE_ERROR_INVALID_DATA; + + EINA_LIST_FOREACH(gesture->select_surface_list, l, surface_data) + { + if (surface_data == surface) + { + return TIZEN_GESTURE_ERROR_NONE; + } + } + + destroy_listener = E_NEW(struct wl_listener, 1); + if (!destroy_listener) + { + GTERR("Failed to allocate memory for wl_client destroy listener !\n"); + return TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES; + } + + destroy_listener->notify = _e_gesture_wl_surface_cb_destroy; + wl_resource_add_destroy_listener(surface, destroy_listener); + + gesture->select_surface_list = eina_list_append(gesture->select_surface_list, surface); + + return TIZEN_GESTURE_ERROR_NONE; +} + static void _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) { @@ -321,883 +377,1063 @@ _e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int } } -#if 0 -static int -_e_gesture_grab_pan(struct wl_client *client, struct wl_resource *resource, uint32_t fingers) +static void +_e_gesture_remove_surface_destroy_listener(struct wl_resource *surface, int type) { - E_Gesture_Event *gev; - int ret = TIZEN_GESTURE_ERROR_NONE; + Eina_List *l, *l_next; + struct wl_resource *surface_data; + struct wl_listener *destroy_listener; - GTINF("The client %p request to grab pan gesture, fingers: %d\n", client, fingers); + EINA_SAFETY_ON_NULL_RETURN(surface); + if (type != E_GESTURE_TYPE_PALM_COVER) return; - if (fingers > E_GESTURE_FINGER_MAX) + destroy_listener = wl_resource_get_destroy_listener(surface, _e_gesture_wl_surface_cb_destroy); + if (!destroy_listener) { - GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); - ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto finish; + GTWRN("surface(%p) is not gesture selected surface\n", surface); } - gev = &gesture->gesture_events; - - if (gev->pans.fingers[fingers].client) + EINA_LIST_FOREACH_SAFE(gesture->select_surface_list, l, l_next, surface_data) { - GTWRN("%d finger is already grabbed by %p client\n", fingers, gev->pans.fingers[fingers].client); - ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; - goto finish; + if (surface_data == surface) + { + gesture->select_surface_list = eina_list_remove_list(gesture->select_surface_list, l); + break; + } } - e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_PAN, fingers, 0, 0); + wl_list_remove(&destroy_listener->link); + E_FREE(destroy_listener); +} - gev->pans.fingers[fingers].client = client; - gev->pans.fingers[fingers].res = resource; - gev->pans.state = E_GESTURE_PANPINCH_STATE_READY; +static Eina_Bool +_e_gesture_edge_grabbed_client_check(struct wl_client *client) +{ + Eina_List *l; + E_Gesture_Event *gev; + int i, j; + E_Gesture_Event_Edge_Finger_Edge *edata; - gesture->grabbed_gesture |= E_GESTURE_TYPE_PAN; - gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; + gev = &gesture->gesture_events; -finish: - return ret; + for (i = 1; i < E_GESTURE_FINGER_MAX + 1; i++) + { + for (j = 1; j < E_GESTURE_EDGE_MAX + 1; j++) + { + EINA_LIST_FOREACH(gev->edge_swipes.base.fingers[i].edge[j], l, edata) + { + if (edata->client == client) return EINA_TRUE; + } + } + } + return EINA_FALSE; } static int -_e_gesture_ungrab_pan(struct wl_client *client, struct wl_resource *resource, uint32_t fingers) +_e_gesture_grab_edge_swipe(struct wl_client *client, + struct wl_resource *resource, + uint32_t fingers, uint32_t edge, uint32_t edge_size, + uint32_t start_point, uint32_t end_point) { E_Gesture_Event *gev; + int sp = 0, ep = 0; int ret = TIZEN_GESTURE_ERROR_NONE; + E_Gesture_Conf_Edd *conf = gesture->config->conf; - GTINF("The client %p request to ungrab pan gesture, fingers: %d\n", client, fingers); - + 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); if (fingers > E_GESTURE_FINGER_MAX) { GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto finish; + return ret; } gev = &gesture->gesture_events; - if (gev->pans.fingers[fingers].client == client) + if (edge < TIZEN_GESTURE_EDGE_TOP || edge > TIZEN_GESTURE_EDGE_LEFT) { - gev->pans.fingers[fingers].client = NULL; - gev->pans.fingers[fingers].res = NULL; + GTWRN("Invalid edge(%d)\n", edge); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + return ret; } - _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_PAN, fingers, 0, 0); - _e_gesture_pan_current_list_check(); - -finish: - return ret; -} - -static int -_e_gesture_grab_pinch(struct wl_client *client, struct wl_resource *resource, uint32_t fingers) -{ - E_Gesture_Event *gev; - int ret = TIZEN_GESTURE_ERROR_NONE; - - GTINF("The client %p request to grab pinch gesture, fingers: %d\n", client, fingers); - - if (fingers > E_GESTURE_FINGER_MAX) + if (edge_size == TIZEN_GESTURE_EDGE_SIZE_PARTIAL) { - GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); + sp = start_point; + ep = end_point; + if (((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) && + (ep > e_comp->w)) + ep = e_comp->w; + else if (((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) && + (ep > e_comp->h)) + ep = e_comp->h; + } + else if (edge_size == TIZEN_GESTURE_EDGE_SIZE_FULL) + { + sp = 0; + if ((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) + ep = e_comp->w; + else if ((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) + ep = e_comp->h; + } + else + { + GTWRN("Invalid edge_size(%d)\n", edge_size); ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto finish; + return ret; } - gev = &gesture->gesture_events; - - if (gev->pinchs.fingers[fingers].client) + if ((conf->edge_swipe.default_enable_back) && + (edge == E_GESTURE_EDGE_TOP)) { - GTWRN("%d finger is already grabbed by %p client\n", fingers, gev->pinchs.fingers[fingers].client); ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; - goto finish; } + else if (_e_gesture_edge_boundary_check(&gev->edge_swipes.base.fingers[fingers], edge, sp, ep)) + { + _e_gesture_edge_grab_add(&gev->edge_swipes.base.fingers[fingers], client, resource, edge, sp, ep); - e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_PINCH, fingers, 0, 0); + e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge, 0, sp, ep); - gev->pinchs.fingers[fingers].client = client; - gev->pinchs.fingers[fingers].res = resource; + gesture->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; + gev->edge_swipes.base.fingers[fingers].enabled = EINA_TRUE; + if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; + gev->edge_swipes.base.enabled_edge |= (1 << edge); - gev->pinchs.state = E_GESTURE_PANPINCH_STATE_READY; - gesture->grabbed_gesture |= E_GESTURE_TYPE_PINCH; - gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; + ret = TIZEN_GESTURE_ERROR_NONE; + } + else + { + ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; + } -finish: return ret; } static int -_e_gesture_ungrab_pinch(struct wl_client *client, struct wl_resource *resource, uint32_t fingers) +_e_gesture_ungrab_edge_swipe(struct wl_client *client, + struct wl_resource *resource, + uint32_t fingers, uint32_t edge, uint32_t edge_size, + uint32_t start_point, uint32_t end_point) { E_Gesture_Event *gev; int ret = TIZEN_GESTURE_ERROR_NONE; + int i; + Eina_List *l, *l_next; + E_Gesture_Event_Edge_Finger_Edge *edata; + Eina_Bool flag_removed = EINA_FALSE; + int sp = 0, ep = 0; - GTINF("The client %p request to ungrab pinch gesture, fingers: %d\n", client, fingers); + 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); if (fingers > E_GESTURE_FINGER_MAX) { GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto finish; + return ret; } gev = &gesture->gesture_events; - if (gev->pinchs.fingers[fingers].client == client) + if (edge_size == TIZEN_GESTURE_EDGE_SIZE_PARTIAL) { - gev->pinchs.fingers[fingers].client = NULL; - gev->pinchs.fingers[fingers].res = NULL; + sp = start_point; + ep = end_point; + if (((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) && + (ep > e_comp->w)) + ep = e_comp->w; + else if (((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) && + (ep > e_comp->h)) + ep = e_comp->h; } - - _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_PINCH, fingers, 0, 0); - _e_gesture_pinch_current_list_check(); - -finish: - return ret; -} -#endif - -static int -_e_gesture_grab_palm_cover(struct wl_client *client, struct wl_resource *resource) -{ - E_Gesture_Event *gev; - int ret = TIZEN_GESTURE_ERROR_NONE; - - gev = &gesture->gesture_events; - - GTINF("The client %p request to grab palm hover gesture\n", client); - - if (gev->palm_covers.client_info.client) + else if (edge_size == TIZEN_GESTURE_EDGE_SIZE_FULL) { - GTWRN("Palm hover is already grabbed by %p client\n", gev->palm_covers.client_info.client); - goto finish; + sp = 0; + if ((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) + ep = e_comp->w; + else if ((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) + ep = e_comp->h; + } + else + { + GTWRN("Invalid edge_size(%d)\n", edge_size); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + return ret; } - e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_PALM_COVER, 0, 0, 0, 0, 0); - - gev->palm_covers.client_info.client = client; - gev->palm_covers.client_info.res = resource; - - gesture->grabbed_gesture |= E_GESTURE_TYPE_PALM_COVER; - gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; - -finish: - return ret; -} - -static int -_e_gesture_ungrab_palm_cover(struct wl_client *client, struct wl_resource *resource) -{ - E_Gesture_Event *gev; - int ret = TIZEN_GESTURE_ERROR_NONE; - - GTINF("The client %p request to ungrab palm hover gesture\n", client); - - gev = &gesture->gesture_events; - - if (gev->palm_covers.client_info.client == client) + EINA_LIST_FOREACH_SAFE(gev->edge_swipes.base.fingers[fingers].edge[edge], l, l_next, edata) { - gev->palm_covers.client_info.client = NULL; - gev->palm_covers.client_info.client = NULL; + if ((edata->client == client) && (edata->sp == sp) && (edata->ep == ep)) + { + gev->edge_swipes.base.fingers[fingers].edge[edge] = eina_list_remove_list( + gev->edge_swipes.base.fingers[fingers].edge[edge], l); + E_FREE(edata); + flag_removed = EINA_TRUE; + } } - _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_PALM_COVER, 0, 0, 0, 0, 0); - gesture->grabbed_gesture &= ~E_GESTURE_TYPE_PALM_COVER; - gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; - - return ret; -} - -static int -_e_gesture_add_surface_destroy_listener(struct wl_resource *surface, int type) -{ - struct wl_listener *destroy_listener = NULL; - Eina_List *l; - struct wl_resource *surface_data; - - EINA_SAFETY_ON_NULL_RETURN_VAL(surface, TIZEN_GESTURE_ERROR_INVALID_DATA); - if (type != E_GESTURE_TYPE_PALM_COVER) - return TIZEN_GESTURE_ERROR_INVALID_DATA; - - EINA_LIST_FOREACH(gesture->select_surface_list, l, surface_data) + if (flag_removed) { - if (surface_data == surface) + if (!_e_gesture_edge_grabbed_client_check(client)) { - return TIZEN_GESTURE_ERROR_NONE; + _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge, 0, sp, ep); + _e_gesture_edge_swipe_current_list_check(); } } - destroy_listener = E_NEW(struct wl_listener, 1); - if (!destroy_listener) + gev->edge_swipes.base.enabled_edge &= ~( 1 << edge); + for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) { - GTERR("Failed to allocate memory for wl_client destroy listener !\n"); - return TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES; + if (eina_list_count(gev->edge_swipes.base.fingers[i].edge[edge]) > 0) + { + gev->edge_swipes.base.enabled_edge |= (1 << edge); + break; + } } - destroy_listener->notify = _e_gesture_wl_surface_cb_destroy; - wl_resource_add_destroy_listener(surface, destroy_listener); - - gesture->select_surface_list = eina_list_append(gesture->select_surface_list, surface); - - return TIZEN_GESTURE_ERROR_NONE; + return ret; } - static int -_e_gesture_select_palm_cover(struct wl_client *client, struct wl_resource *resource, - struct wl_resource *surface) +_e_gesture_grab_edge_drag(struct wl_client *client, + struct wl_resource *resource, + uint32_t fingers, uint32_t edge, uint32_t edge_size, + uint32_t start_point, uint32_t end_point) { + E_Gesture_Event *gev; + int sp = 0, ep = 0; int ret = TIZEN_GESTURE_ERROR_NONE; - Eina_List *l; - E_Gesture_Event_Palm_Cover *palm_covers = &gesture->gesture_events.palm_covers; - E_Gesture_Select_Surface *sdata; - EINA_LIST_FOREACH(palm_covers->select_surface_list, l, sdata) + 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); + if (fingers > E_GESTURE_FINGER_MAX) { - if (sdata->surface == surface) - { - ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; - goto out; - } + GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto out; } - sdata = E_NEW(E_Gesture_Select_Surface, 1); - if (!sdata) + if (edge < TIZEN_GESTURE_EDGE_TOP || edge > TIZEN_GESTURE_EDGE_LEFT) { - ret = TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES; + GTWRN("Invalid edge(%d)\n", edge); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; goto out; } - sdata->surface = surface; - sdata->res = resource; + if (edge_size == TIZEN_GESTURE_EDGE_SIZE_PARTIAL) + { + sp = start_point; + ep = end_point; + if (((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) && + (ep > e_comp->w)) + ep = e_comp->w; + else if (((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) && + (ep > e_comp->h)) + ep = e_comp->h; + } + else if (edge_size == TIZEN_GESTURE_EDGE_SIZE_FULL) + { + sp = 0; + if ((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) + ep = e_comp->w; + else if ((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) + ep = e_comp->h; + } + else + { + GTWRN("Invalid edge_size(%d)\n", edge_size); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto out; + } - palm_covers->select_surface_list = eina_list_append(palm_covers->select_surface_list, sdata); + gev = &gesture->gesture_events; - _e_gesture_add_surface_destroy_listener(surface, E_GESTURE_TYPE_PALM_COVER); + if (_e_gesture_edge_boundary_check(&gev->edge_drags.base.fingers[fingers], edge, sp, ep)) + { + _e_gesture_edge_grab_add(&gev->edge_drags.base.fingers[fingers], client, resource, edge, sp, ep); + + e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_DRAG, fingers, edge, 0, sp, ep); + + gesture->grabbed_gesture |= E_GESTURE_TYPE_EDGE_DRAG; + gev->edge_drags.base.fingers[fingers].enabled = EINA_TRUE; + if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; + gev->edge_drags.base.enabled_edge |= (1 << edge); + + ret = TIZEN_GESTURE_ERROR_NONE; + } + else + { + ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; + } out: return ret; } -static void -_e_gesture_remove_surface_destroy_listener(struct wl_resource *surface, int type) +static int +_e_gesture_ungrab_edge_drag(struct wl_client *client, + struct wl_resource *resource, + uint32_t fingers, uint32_t edge, uint32_t edge_size, + uint32_t start_point, uint32_t end_point) { + E_Gesture_Event *gev; + int ret = TIZEN_GESTURE_ERROR_NONE; + int i; Eina_List *l, *l_next; - struct wl_resource *surface_data; - struct wl_listener *destroy_listener; + E_Gesture_Event_Edge_Finger_Edge *edata; + Eina_Bool flag_removed = EINA_FALSE; + int sp = 0, ep = 0; - EINA_SAFETY_ON_NULL_RETURN(surface); - if (type != E_GESTURE_TYPE_PALM_COVER) return; + 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); - destroy_listener = wl_resource_get_destroy_listener(surface, _e_gesture_wl_surface_cb_destroy); - if (!destroy_listener) + if (fingers > E_GESTURE_FINGER_MAX) { - GTWRN("surface(%p) is not gesture selected surface\n", surface); + GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto out; } - EINA_LIST_FOREACH_SAFE(gesture->select_surface_list, l, l_next, surface_data) + if (edge_size == TIZEN_GESTURE_EDGE_SIZE_PARTIAL) { - if (surface_data == surface) + sp = start_point; + ep = end_point; + if (((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) && + (ep > e_comp->w)) + ep = e_comp->w; + else if (((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) && + (ep > e_comp->h)) + ep = e_comp->h; + } + else if (edge_size == TIZEN_GESTURE_EDGE_SIZE_FULL) + { + sp = 0; + if ((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) + ep = e_comp->w; + else if ((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) + ep = e_comp->h; + } + else + { + GTWRN("Invalid edge_size(%d)\n", edge_size); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto out; + } + + gev = &gesture->gesture_events; + + EINA_LIST_FOREACH_SAFE(gev->edge_drags.base.fingers[fingers].edge[edge], l, l_next, edata) + { + if ((edata->client == client) && (edata->sp == sp) && (edata->ep == ep)) { - gesture->select_surface_list = eina_list_remove_list(gesture->select_surface_list, l); - break; + gev->edge_drags.base.fingers[fingers].edge[edge] = eina_list_remove_list( + gev->edge_drags.base.fingers[fingers].edge[edge], l); + E_FREE(edata); + flag_removed = EINA_TRUE; } } - wl_list_remove(&destroy_listener->link); - E_FREE(destroy_listener); -} - -static int -_e_gesture_deselect_palm_cover(struct wl_client *client, struct wl_resource *resource, - struct wl_resource *surface) -{ - int ret = TIZEN_GESTURE_ERROR_NONE; - Eina_List *l, *l_next; - E_Gesture_Event_Palm_Cover *palm_covers = &gesture->gesture_events.palm_covers; - E_Gesture_Select_Surface *sdata; + if (flag_removed) + { + if (!_e_gesture_edge_grabbed_client_check(client)) + { + _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_DRAG, fingers, edge, 0, sp, ep); + _e_gesture_edge_drag_current_list_check(); + } + } - EINA_LIST_FOREACH_SAFE(palm_covers->select_surface_list, l, l_next, sdata) + gev->edge_drags.base.enabled_edge &= ~( 1 << edge); + for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) { - if (sdata->surface == surface) + if (eina_list_count(gev->edge_drags.base.fingers[i].edge[edge]) > 0) { - palm_covers->select_surface_list = eina_list_remove_list(palm_covers->select_surface_list, l); - E_FREE(sdata); + gev->edge_drags.base.enabled_edge |= (1 << edge); break; } } - _e_gesture_remove_surface_destroy_listener(surface, E_GESTURE_TYPE_PALM_COVER); - +out: return ret; } -static Eina_Bool -_e_gesture_deactivate_find_surface(Eina_List *list, struct wl_resource *surface) +static int +_e_gesture_grab_tap(struct wl_client *client, + struct wl_resource *resource, + uint32_t fingers, uint32_t repeats) { - Eina_List *l; - E_Gesture_Activate_Surface_Info *idata; + E_Gesture_Event *gev; + int ret = TIZEN_GESTURE_ERROR_NONE; - EINA_LIST_FOREACH(list, l, idata) + GTINF("client %p requested to grab tap gesture (fingers: %d, repeats: %d)\n", client, fingers, repeats); + + if (fingers > E_GESTURE_FINGER_MAX || repeats > E_GESTURE_TAP_REPEATS_MAX) { - if (surface == idata->surface) - { - return EINA_TRUE; - } + GTWRN("Not supported fingers /repeats bigger than their maximum values\n"); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + return ret; } - return EINA_FALSE; -} -static char * -_e_gesture_util_type_to_string(unsigned int type) -{ - switch (type) - { - case E_GESTURE_TYPE_EDGE_SWIPE: - return "edge_swipe"; - case E_GESTURE_TYPE_TAP: - return "tap"; - case E_GESTURE_TYPE_PALM_COVER: - return "palm_cover"; - case E_GESTURE_TYPE_PAN: - return "pan"; - case E_GESTURE_TYPE_PINCH: - return "pinch"; - default: - return "unknown"; - } -} - -static void -_e_gesture_deactivate_list_unset(struct wl_client *client, struct wl_resource *surface, E_Gesture_Activate_Info *info, unsigned int type) -{ - Eina_List *l, *l_next; - struct wl_resource *surface_data; + gev = &gesture->gesture_events; - if (surface) - { - EINA_LIST_FOREACH_SAFE(info->surfaces, l, l_next, surface_data) - { - if (surface_data == surface) - { - info->surfaces = eina_list_remove_list(info->surfaces, l); - break; - } - } - } - else if (info->client && (info->client == client)) - { - info->client = NULL; - info->active = EINA_TRUE; - } - else + if (gev->taps.fingers[fingers].repeats[repeats].client) { - 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); + GTWRN("%d finger %d repeats is already grabbed by %p client\n", fingers, repeats, gev->taps.fingers[fingers].repeats[repeats].client); + ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; + return ret; } -} -static void -_e_gesture_deactivate_cb_client_listener(struct wl_listener *l, void *data) -{ - struct wl_client *client = data; - - _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.edge_swipes.base.activation, E_GESTURE_TYPE_EDGE_SWIPE); - _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP); - _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER); - _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN); - _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.pinchs.activation, E_GESTURE_TYPE_PINCH); + gev->taps.fingers[fingers].repeats[repeats].client = client; + gev->taps.fingers[fingers].repeats[repeats].res = resource; + gev->taps.fingers[fingers].enabled = EINA_TRUE; - wl_list_remove(&l->link); - E_FREE(l); -} + e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_TAP, fingers, 0, repeats, 0, 0); -static void -_e_gesture_deactivate_cb_surface_listener(struct wl_listener *l, void *data) -{ - struct wl_resource *surface = data; + if (gev->taps.max_fingers < fingers) + gev->taps.max_fingers = fingers; + if (gev->taps.fingers[fingers].max_repeats < repeats) + gev->taps.fingers[fingers].max_repeats = repeats; - _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.edge_swipes.base.activation, E_GESTURE_TYPE_EDGE_SWIPE); - _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP); - _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER); - _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN); - _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.pinchs.activation, E_GESTURE_TYPE_PINCH); + gesture->grabbed_gesture |= E_GESTURE_TYPE_TAP; + gev->taps.state = E_GESTURE_TAP_STATE_READY; + gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; + gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; - wl_list_remove(&l->link); - E_FREE(l); + return ret; } static int -_e_gesture_deactivate_listener_add(struct wl_client *client, struct wl_resource * surface) +_e_gesture_ungrab_tap(struct wl_client *client, + struct wl_resource *resource, + uint32_t fingers, uint32_t repeats) { - struct wl_listener *destroy_listener = NULL; + int i; + E_Gesture_Event *gev; + int ret = TIZEN_GESTURE_ERROR_NONE; - EINA_SAFETY_ON_FALSE_RETURN_VAL(client || surface, TIZEN_GESTURE_ERROR_INVALID_DATA); + GTINF("client %p requested to ungrab tap gesture (fingers: %d, repeats: %d)\n", client, fingers, fingers); - destroy_listener = E_NEW(struct wl_listener, 1); - if (!destroy_listener) + if (fingers > E_GESTURE_FINGER_MAX || repeats > E_GESTURE_TAP_REPEATS_MAX) { - GTERR("Failed to allocate memory for deactivate destroy listener !\n"); - return TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES; + GTWRN("Not supported fingers /repeats bigger than their maximum values\n"); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + return ret; } - if (surface) - { - destroy_listener->notify = _e_gesture_deactivate_cb_surface_listener; - wl_resource_add_destroy_listener(surface, destroy_listener); - } - else + gev = &gesture->gesture_events; + + if (gev->taps.fingers[fingers].repeats[repeats].client == client) { - destroy_listener->notify = _e_gesture_deactivate_cb_client_listener; - wl_client_add_destroy_listener(client, destroy_listener); + gev->taps.fingers[fingers].repeats[repeats].client = NULL; + gev->taps.fingers[fingers].repeats[repeats].res = NULL; } - return TIZEN_GESTURE_ERROR_NONE; -} - -static int -_e_gesture_deactivate_list_set(struct wl_client *client, struct wl_resource *surface, E_Gesture_Activate_Info *info, unsigned int type) -{ - int ret = TIZEN_GESTURE_ERROR_NONE; - - if (surface) + gev->taps.fingers[fingers].enabled = EINA_FALSE; + for (i = 0; i < E_GESTURE_TAP_REPEATS_MAX; i++) { - if (!_e_gesture_deactivate_find_surface(info->surfaces, surface)) + if (gev->taps.fingers[fingers].repeats[i].client) { - info->surfaces = eina_list_append(info->surfaces, surface); - _e_gesture_deactivate_listener_add(client, surface); + gev->taps.fingers[fingers].enabled = EINA_TRUE; + break; } } - else if (!info->client) - { - info->client = client; - info->active = EINA_FALSE; - _e_gesture_deactivate_listener_add(client, surface); - } - else - { - GTWRN("Failed to deactivate %s !(request surface: %p, client: %p), already deactivated client: %p\n", - _e_gesture_util_type_to_string(type), surface, client, info->client); - ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; - } + gev->taps.fingers[fingers].max_repeats = e_gesture_util_tap_max_repeats_get(fingers); + + _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_TAP, fingers, 0, repeats, 0, 0); + _e_gesture_tap_current_list_check(); return ret; } static int -_e_gesture_deactivate_set(struct wl_client *client, - struct wl_resource *resource, - struct wl_resource *surface, - uint32_t type) +_e_gesture_grab_pan(struct wl_client *client, struct wl_resource *resource, uint32_t fingers) { + E_Gesture_Event *gev; int ret = TIZEN_GESTURE_ERROR_NONE; - if (type & E_GESTURE_TYPE_EDGE_SWIPE) - { - ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.edge_swipes.base.activation, E_GESTURE_TYPE_EDGE_SWIPE); - } - if (type & E_GESTURE_TYPE_TAP) - { - ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP); - } - if (type & E_GESTURE_TYPE_PALM_COVER) - { - ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER); - } - if (type & E_GESTURE_TYPE_PAN) + GTINF("The client %p request to grab pan gesture, fingers: %d\n", client, fingers); + + if (fingers > E_GESTURE_FINGER_MAX) { - ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN); + GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto finish; } - if (type & E_GESTURE_TYPE_PINCH) + + gev = &gesture->gesture_events; + + if (gev->pans.fingers[fingers].client) { - ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.pinchs.activation, E_GESTURE_TYPE_PINCH); + GTWRN("%d finger is already grabbed by %p client\n", fingers, gev->pans.fingers[fingers].client); + ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; + goto finish; } + e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_PAN, fingers, 0, 0, 0, 0); + + gev->pans.fingers[fingers].client = client; + gev->pans.fingers[fingers].res = resource; + gev->pans.state = E_GESTURE_PANPINCH_STATE_READY; + + gesture->grabbed_gesture |= E_GESTURE_TYPE_PAN; + gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; + +finish: return ret; } static int -_e_gesture_deactivate_unset(struct wl_client *client, - struct wl_resource *resource, - struct wl_resource *surface, - uint32_t type) +_e_gesture_ungrab_pan(struct wl_client *client, struct wl_resource *resource, uint32_t fingers) { + E_Gesture_Event *gev; int ret = TIZEN_GESTURE_ERROR_NONE; - if (type & E_GESTURE_TYPE_EDGE_SWIPE) - { - _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.edge_swipes.base.activation, E_GESTURE_TYPE_EDGE_SWIPE); - } - if (type & E_GESTURE_TYPE_TAP) - { - _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP); - } - if (type & E_GESTURE_TYPE_PALM_COVER) - { - _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER); - } - if (type & E_GESTURE_TYPE_PAN) + GTINF("The client %p request to ungrab pan gesture, fingers: %d\n", client, fingers); + + if (fingers > E_GESTURE_FINGER_MAX) { - _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN); + GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto finish; } - if (type & E_GESTURE_TYPE_PINCH) + + gev = &gesture->gesture_events; + + if (gev->pans.fingers[fingers].client == client) { - _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.pinchs.activation, E_GESTURE_TYPE_PINCH); + gev->pans.fingers[fingers].client = NULL; + gev->pans.fingers[fingers].res = NULL; } + _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_PAN, fingers, 0, 0, 0, 0); + _e_gesture_pan_current_list_check(); + +finish: return ret; } -static void -_e_gesture_cb_grab_edge_swipe(struct wl_client *client, - struct wl_resource *resource, - uint32_t fingers, uint32_t edge, uint32_t edge_size, - uint32_t start_point, uint32_t end_point) +static int +_e_gesture_grab_pinch(struct wl_client *client, struct wl_resource *resource, uint32_t fingers) { E_Gesture_Event *gev; - int sp = 0, ep = 0; - unsigned int ret = TIZEN_GESTURE_ERROR_NONE; - E_Gesture_Conf_Edd *conf = gesture->config->conf; + int ret = TIZEN_GESTURE_ERROR_NONE; + + GTINF("The client %p request to grab pinch gesture, fingers: %d\n", client, fingers); - 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); if (fingers > E_GESTURE_FINGER_MAX) { GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto out; + goto finish; } gev = &gesture->gesture_events; - if (edge < TIZEN_GESTURE_EDGE_TOP || edge > TIZEN_GESTURE_EDGE_LEFT) + if (gev->pinchs.fingers[fingers].client) { - GTWRN("Invalid edge(%d)\n", edge); - ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto out; + GTWRN("%d finger is already grabbed by %p client\n", fingers, gev->pinchs.fingers[fingers].client); + ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; + goto finish; } - if (edge_size == TIZEN_GESTURE_EDGE_SIZE_PARTIAL) - { - sp = start_point; - ep = end_point; - if (((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) && - (ep > e_comp->w)) - ep = e_comp->w; - else if (((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) && - (ep > e_comp->h)) - ep = e_comp->h; - } - else if (edge_size == TIZEN_GESTURE_EDGE_SIZE_FULL) - { - sp = 0; - if ((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) - ep = e_comp->w; - else if ((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) - ep = e_comp->h; - } - else - { - GTWRN("Invalid edge_size(%d)\n", edge_size); - ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto out; - } + e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_PINCH, fingers, 0, 0, 0, 0); - if ((conf->edge_swipe.default_enable_back) && - (edge == E_GESTURE_EDGE_TOP)) - { - ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; - } - else if (_e_gesture_edge_boundary_check(&gev->edge_swipes.base.fingers[fingers], edge, sp, ep)) - { - _e_gesture_edge_grab_add(&gev->edge_swipes.base.fingers[fingers], client, resource, edge, sp, ep); + gev->pinchs.fingers[fingers].client = client; + gev->pinchs.fingers[fingers].res = resource; - e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge, 0, sp, ep); + gev->pinchs.state = E_GESTURE_PANPINCH_STATE_READY; + gesture->grabbed_gesture |= E_GESTURE_TYPE_PINCH; + gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; - gesture->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; - gev->edge_swipes.base.fingers[fingers].enabled = EINA_TRUE; - if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; - gev->edge_swipes.base.enabled_edge |= (1 << edge); +finish: + return ret; +} - ret = TIZEN_GESTURE_ERROR_NONE; +static int +_e_gesture_ungrab_pinch(struct wl_client *client, struct wl_resource *resource, uint32_t fingers) +{ + E_Gesture_Event *gev; + int ret = TIZEN_GESTURE_ERROR_NONE; + + GTINF("The client %p request to ungrab pinch gesture, fingers: %d\n", client, fingers); + + if (fingers > E_GESTURE_FINGER_MAX) + { + GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto finish; } - else + + gev = &gesture->gesture_events; + + if (gev->pinchs.fingers[fingers].client == client) { - ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; + gev->pinchs.fingers[fingers].client = NULL; + gev->pinchs.fingers[fingers].res = NULL; } -out: - tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, edge, edge_size, start_point, end_point, ret); - return; + _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_PINCH, fingers, 0, 0, 0, 0); + _e_gesture_pinch_current_list_check(); + +finish: + return ret; } -static Eina_Bool -_e_gesture_edge_grabbed_client_check(struct wl_client *client) +static int +_e_gesture_grab_palm_cover(struct wl_client *client, struct wl_resource *resource) { - Eina_List *l; E_Gesture_Event *gev; - int i, j; - E_Gesture_Event_Edge_Finger_Edge *edata; + int ret = TIZEN_GESTURE_ERROR_NONE; gev = &gesture->gesture_events; - for (i = 1; i < E_GESTURE_FINGER_MAX + 1; i++) + GTINF("The client %p request to grab palm hover gesture\n", client); + + if (gev->palm_covers.client_info.client) { - for (j = 1; j < E_GESTURE_EDGE_MAX + 1; j++) - { - EINA_LIST_FOREACH(gev->edge_swipes.base.fingers[i].edge[j], l, edata) - { - if (edata->client == client) return EINA_TRUE; - } - } + GTWRN("Palm hover is already grabbed by %p client\n", gev->palm_covers.client_info.client); + goto finish; } - return EINA_FALSE; + + e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_PALM_COVER, 0, 0, 0, 0, 0); + + gev->palm_covers.client_info.client = client; + gev->palm_covers.client_info.res = resource; + + gesture->grabbed_gesture |= E_GESTURE_TYPE_PALM_COVER; + gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; + +finish: + return ret; } -static void -_e_gesture_cb_ungrab_edge_swipe(struct wl_client *client, - struct wl_resource *resouce, - uint32_t fingers, uint32_t edge, uint32_t edge_size, - uint32_t start_point, uint32_t end_point) +static int +_e_gesture_ungrab_palm_cover(struct wl_client *client, struct wl_resource *resource) { E_Gesture_Event *gev; int ret = TIZEN_GESTURE_ERROR_NONE; - int i; - Eina_List *l, *l_next; - E_Gesture_Event_Edge_Finger_Edge *edata; - Eina_Bool flag_removed = EINA_FALSE; - int sp = 0, ep = 0; - - 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); - if (fingers > E_GESTURE_FINGER_MAX) - { - GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); - ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto notify; - } + GTINF("The client %p request to ungrab palm hover gesture\n", client); gev = &gesture->gesture_events; - if (edge_size == TIZEN_GESTURE_EDGE_SIZE_PARTIAL) - { - sp = start_point; - ep = end_point; - if (((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) && - (ep > e_comp->w)) - ep = e_comp->w; - else if (((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) && - (ep > e_comp->h)) - ep = e_comp->h; - } - else if (edge_size == TIZEN_GESTURE_EDGE_SIZE_FULL) - { - sp = 0; - if ((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) - ep = e_comp->w; - else if ((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) - ep = e_comp->h; - } - else + if (gev->palm_covers.client_info.client == client) { - GTWRN("Invalid edge_size(%d)\n", edge_size); - ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto notify; + gev->palm_covers.client_info.client = NULL; + gev->palm_covers.client_info.client = NULL; } - EINA_LIST_FOREACH_SAFE(gev->edge_swipes.base.fingers[fingers].edge[edge], l, l_next, edata) + _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_PALM_COVER, 0, 0, 0, 0, 0); + gesture->grabbed_gesture &= ~E_GESTURE_TYPE_PALM_COVER; + gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; + + return ret; +} + +static int +_e_gesture_select_palm_cover(struct wl_client *client, struct wl_resource *resource, + struct wl_resource *surface) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + Eina_List *l; + E_Gesture_Event_Palm_Cover *palm_covers = &gesture->gesture_events.palm_covers; + E_Gesture_Select_Surface *sdata; + + EINA_LIST_FOREACH(palm_covers->select_surface_list, l, sdata) { - if ((edata->client == client) && (edata->sp == sp) && (edata->ep == ep)) + if (sdata->surface == surface) { - gev->edge_swipes.base.fingers[fingers].edge[edge] = eina_list_remove_list( - gev->edge_swipes.base.fingers[fingers].edge[edge], l); - E_FREE(edata); - flag_removed = EINA_TRUE; + ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; + goto out; } } - if (flag_removed) + sdata = E_NEW(E_Gesture_Select_Surface, 1); + if (!sdata) { - if (!_e_gesture_edge_grabbed_client_check(client)) - { - _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge, 0, sp, ep); - _e_gesture_edge_swipe_current_list_check(); - } + ret = TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES; + goto out; } - gev->edge_swipes.base.enabled_edge &= ~( 1 << edge); - for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) + sdata->surface = surface; + sdata->res = resource; + + palm_covers->select_surface_list = eina_list_append(palm_covers->select_surface_list, sdata); + + _e_gesture_add_surface_destroy_listener(surface, E_GESTURE_TYPE_PALM_COVER); + +out: + return ret; +} + +static int +_e_gesture_deselect_palm_cover(struct wl_client *client, struct wl_resource *resource, + struct wl_resource *surface) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + Eina_List *l, *l_next; + E_Gesture_Event_Palm_Cover *palm_covers = &gesture->gesture_events.palm_covers; + E_Gesture_Select_Surface *sdata; + + EINA_LIST_FOREACH_SAFE(palm_covers->select_surface_list, l, l_next, sdata) { - if (eina_list_count(gev->edge_swipes.base.fingers[i].edge[edge]) > 0) + if (sdata->surface == surface) { - gev->edge_swipes.base.enabled_edge |= (1 << edge); + palm_covers->select_surface_list = eina_list_remove_list(palm_covers->select_surface_list, l); + E_FREE(sdata); break; } } -notify: - tizen_gesture_send_grab_edge_swipe_notify(resouce, fingers, edge, edge_size, start_point, end_point, ret); - return; + _e_gesture_remove_surface_destroy_listener(surface, E_GESTURE_TYPE_PALM_COVER); + + return ret; } static int -_e_gesture_grab_edge_drag(struct wl_client *client, - struct wl_resource *resource, - uint32_t fingers, uint32_t edge, uint32_t edge_size, - uint32_t start_point, uint32_t end_point) +_e_gesture_server_grab_edge_swipe(unsigned int fingers, + unsigned int edge, unsigned int edge_size, + unsigned int start_point, unsigned int end_point) { - E_Gesture_Event *gev; - int sp = 0, ep = 0; int ret = TIZEN_GESTURE_ERROR_NONE; - 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); - if (fingers > E_GESTURE_FINGER_MAX) + ret = _e_gesture_grab_edge_swipe(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, + fingers, edge, edge_size, start_point, end_point); + + return ret; +} + +static int +_e_gesture_server_ungrab_edge_swipe(unsigned int fingers, + unsigned int edge, unsigned int edge_size, + unsigned int start_point, unsigned int end_point) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_ungrab_edge_swipe(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers, edge, edge_size, start_point, end_point); + + return ret; +} + +static int +_e_gesture_server_grab_edge_drag(unsigned int fingers, + unsigned int edge, unsigned int edge_size, + unsigned int start_point, unsigned int end_point) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_grab_edge_drag(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers, edge, edge_size, start_point, end_point); + + return ret; +} + +static int +_e_gesture_server_ungrab_edge_drag(unsigned int fingers, unsigned int edge, unsigned int edge_size, + unsigned int start_point, unsigned int end_point) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_ungrab_edge_drag(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers, edge, edge_size, start_point, end_point); + + return ret; +} + +static int +_e_gesture_server_grab_tap(unsigned int fingers, unsigned int repeats) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_grab_tap(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers, repeats); + + return ret; +} + +static int +_e_gesture_server_ungrab_tap(unsigned int fingers, unsigned int repeats) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_ungrab_tap(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers, repeats); + + return ret; +} + +static int +_e_gesture_server_grab_palm_cover(void) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_grab_palm_cover(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT); + + return ret; +} + +static int +_e_gesture_server_ungrab_palm_cover(void) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_ungrab_palm_cover(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT); + + return ret; +} + +static int +_e_gesture_server_grab_pan(unsigned int fingers) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_grab_pan(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers); + + return ret; +} + +static int +_e_gesture_server_ungrab_pan(unsigned int fingers) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_ungrab_pan(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers); + + return ret; +} + +static int +_e_gesture_server_grab_pinch(unsigned int fingers) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_grab_pinch(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers); + + return ret; +} + +static int +_e_gesture_server_ungrab_pinch(unsigned int fingers) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_ungrab_pinch(E_GESTURE_SERVER_CLIENT, E_GESTURE_SERVER_CLIENT, fingers); + + return ret; +} + +static Eina_Bool +_e_gesture_deactivate_find_surface(Eina_List *list, struct wl_resource *surface) +{ + Eina_List *l; + E_Gesture_Activate_Surface_Info *idata; + + EINA_LIST_FOREACH(list, l, idata) { - GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); - ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto out; + if (surface == idata->surface) + { + return EINA_TRUE; + } } + return EINA_FALSE; +} - if (edge < TIZEN_GESTURE_EDGE_TOP || edge > TIZEN_GESTURE_EDGE_LEFT) +static void +_e_gesture_deactivate_list_unset(struct wl_client *client, struct wl_resource *surface, E_Gesture_Activate_Info *info, unsigned int type) +{ + Eina_List *l, *l_next; + struct wl_resource *surface_data; + + if (surface) { - GTWRN("Invalid edge(%d)\n", edge); - ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto out; + EINA_LIST_FOREACH_SAFE(info->surfaces, l, l_next, surface_data) + { + if (surface_data == surface) + { + info->surfaces = eina_list_remove_list(info->surfaces, l); + break; + } + } } + else if (info->client && (info->client == client)) + { + info->client = NULL; + info->active = EINA_TRUE; + } + else + { + 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); + } +} - if (edge_size == TIZEN_GESTURE_EDGE_SIZE_PARTIAL) +static void +_e_gesture_deactivate_cb_client_listener(struct wl_listener *l, void *data) +{ + struct wl_client *client = data; + + _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.edge_swipes.base.activation, E_GESTURE_TYPE_EDGE_SWIPE); + _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP); + _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER); + _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN); + _e_gesture_deactivate_list_unset(client, NULL, &gesture->gesture_events.pinchs.activation, E_GESTURE_TYPE_PINCH); + + wl_list_remove(&l->link); + E_FREE(l); +} + +static void +_e_gesture_deactivate_cb_surface_listener(struct wl_listener *l, void *data) +{ + struct wl_resource *surface = data; + + _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.edge_swipes.base.activation, E_GESTURE_TYPE_EDGE_SWIPE); + _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP); + _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER); + _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN); + _e_gesture_deactivate_list_unset(NULL, surface, &gesture->gesture_events.pinchs.activation, E_GESTURE_TYPE_PINCH); + + wl_list_remove(&l->link); + E_FREE(l); +} + +static int +_e_gesture_deactivate_listener_add(struct wl_client *client, struct wl_resource * surface) +{ + struct wl_listener *destroy_listener = NULL; + + EINA_SAFETY_ON_FALSE_RETURN_VAL(client || surface, TIZEN_GESTURE_ERROR_INVALID_DATA); + + destroy_listener = E_NEW(struct wl_listener, 1); + if (!destroy_listener) { - sp = start_point; - ep = end_point; - if (((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) && - (ep > e_comp->w)) - ep = e_comp->w; - else if (((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) && - (ep > e_comp->h)) - ep = e_comp->h; + GTERR("Failed to allocate memory for deactivate destroy listener !\n"); + return TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES; } - else if (edge_size == TIZEN_GESTURE_EDGE_SIZE_FULL) + + if (surface) { - sp = 0; - if ((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) - ep = e_comp->w; - else if ((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) - ep = e_comp->h; + destroy_listener->notify = _e_gesture_deactivate_cb_surface_listener; + wl_resource_add_destroy_listener(surface, destroy_listener); } else { - GTWRN("Invalid edge_size(%d)\n", edge_size); - ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto out; + destroy_listener->notify = _e_gesture_deactivate_cb_client_listener; + wl_client_add_destroy_listener(client, destroy_listener); } - gev = &gesture->gesture_events; - - if (_e_gesture_edge_boundary_check(&gev->edge_drags.base.fingers[fingers], edge, sp, ep)) - { - _e_gesture_edge_grab_add(&gev->edge_drags.base.fingers[fingers], client, resource, edge, sp, ep); - - e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_DRAG, fingers, edge, 0, sp, ep); + return TIZEN_GESTURE_ERROR_NONE; +} - gesture->grabbed_gesture |= E_GESTURE_TYPE_EDGE_DRAG; - gev->edge_drags.base.fingers[fingers].enabled = EINA_TRUE; - if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; - gev->edge_drags.base.enabled_edge |= (1 << edge); +static int +_e_gesture_deactivate_list_set(struct wl_client *client, struct wl_resource *surface, E_Gesture_Activate_Info *info, unsigned int type) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; - ret = TIZEN_GESTURE_ERROR_NONE; + if (surface) + { + if (!_e_gesture_deactivate_find_surface(info->surfaces, surface)) + { + info->surfaces = eina_list_append(info->surfaces, surface); + _e_gesture_deactivate_listener_add(client, surface); + } + } + else if (!info->client) + { + info->client = client; + info->active = EINA_FALSE; + _e_gesture_deactivate_listener_add(client, surface); } else { + GTWRN("Failed to deactivate %s !(request surface: %p, client: %p), already deactivated client: %p\n", + _e_gesture_util_type_to_string(type), surface, client, info->client); ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; } -out: return ret; } static int -_e_gesture_ungrab_edge_drag(struct wl_client *client, - struct wl_resource *resouce, - uint32_t fingers, uint32_t edge, uint32_t edge_size, - uint32_t start_point, uint32_t end_point) +_e_gesture_deactivate_set(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *surface, + uint32_t type) { - E_Gesture_Event *gev; int ret = TIZEN_GESTURE_ERROR_NONE; - int i; - Eina_List *l, *l_next; - E_Gesture_Event_Edge_Finger_Edge *edata; - Eina_Bool flag_removed = EINA_FALSE; - int sp = 0, ep = 0; - - 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); - if (fingers > E_GESTURE_FINGER_MAX) + if (type & E_GESTURE_TYPE_EDGE_SWIPE) { - GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); - ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto out; + ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.edge_swipes.base.activation, E_GESTURE_TYPE_EDGE_SWIPE); } - - if (edge_size == TIZEN_GESTURE_EDGE_SIZE_PARTIAL) + if (type & E_GESTURE_TYPE_TAP) { - sp = start_point; - ep = end_point; - if (((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) && - (ep > e_comp->w)) - ep = e_comp->w; - else if (((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) && - (ep > e_comp->h)) - ep = e_comp->h; + ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP); } - else if (edge_size == TIZEN_GESTURE_EDGE_SIZE_FULL) + if (type & E_GESTURE_TYPE_PALM_COVER) { - sp = 0; - if ((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) - ep = e_comp->w; - else if ((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) - ep = e_comp->h; + ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER); } - else + if (type & E_GESTURE_TYPE_PAN) { - GTWRN("Invalid edge_size(%d)\n", edge_size); - ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto out; + ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN); + } + if (type & E_GESTURE_TYPE_PINCH) + { + ret = _e_gesture_deactivate_list_set(client, surface, &gesture->gesture_events.pinchs.activation, E_GESTURE_TYPE_PINCH); } - gev = &gesture->gesture_events; + return ret; +} - EINA_LIST_FOREACH_SAFE(gev->edge_drags.base.fingers[fingers].edge[edge], l, l_next, edata) +static int +_e_gesture_deactivate_unset(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *surface, + uint32_t type) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + if (type & E_GESTURE_TYPE_EDGE_SWIPE) { - if ((edata->client == client) && (edata->sp == sp) && (edata->ep == ep)) - { - gev->edge_drags.base.fingers[fingers].edge[edge] = eina_list_remove_list( - gev->edge_drags.base.fingers[fingers].edge[edge], l); - E_FREE(edata); - flag_removed = EINA_TRUE; - } + _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.edge_swipes.base.activation, E_GESTURE_TYPE_EDGE_SWIPE); } - - if (flag_removed) + if (type & E_GESTURE_TYPE_TAP) { - if (!_e_gesture_edge_grabbed_client_check(client)) - { - _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_DRAG, fingers, edge, 0, sp, ep); - _e_gesture_edge_drag_current_list_check(); - } + _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.taps.activation, E_GESTURE_TYPE_TAP); } - - gev->edge_drags.base.enabled_edge &= ~( 1 << edge); - for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) + if (type & E_GESTURE_TYPE_PALM_COVER) { - if (eina_list_count(gev->edge_drags.base.fingers[i].edge[edge]) > 0) - { - gev->edge_drags.base.enabled_edge |= (1 << edge); - break; - } + _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.palm_covers.activation, E_GESTURE_TYPE_PALM_COVER); + } + if (type & E_GESTURE_TYPE_PAN) + { + _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.pans.activation, E_GESTURE_TYPE_PAN); + } + if (type & E_GESTURE_TYPE_PINCH) + { + _e_gesture_deactivate_list_unset(client, surface, &gesture->gesture_events.pinchs.activation, E_GESTURE_TYPE_PINCH); } -out: return ret; } +static void +_e_gesture_cb_grab_edge_swipe(struct wl_client *client, + struct wl_resource *resource, + uint32_t fingers, uint32_t edge, uint32_t edge_size, + uint32_t start_point, uint32_t end_point) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_grab_edge_swipe(client, resource, fingers, edge, edge_size, start_point, end_point); + + tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, edge, edge_size, start_point, end_point, ret); +} + +static void +_e_gesture_cb_ungrab_edge_swipe(struct wl_client *client, + struct wl_resource *resource, + uint32_t fingers, uint32_t edge, uint32_t edge_size, + uint32_t start_point, uint32_t end_point) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_ungrab_edge_swipe(client, resource, fingers, edge, edge_size, start_point, end_point); + + tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, edge, edge_size, start_point, end_point, ret); +} static void _e_gesture_cb_grab_edge_drag(struct wl_client *client, @@ -1230,44 +1466,10 @@ _e_gesture_cb_grab_tap(struct wl_client *client, struct wl_resource *resource, uint32_t fingers, uint32_t repeats) { - E_Gesture_Event *gev; int ret = TIZEN_GESTURE_ERROR_NONE; - GTINF("client %p requested to grab tap gesture (fingers: %d, repeats: %d)\n", client, fingers, repeats); - - if (fingers > E_GESTURE_FINGER_MAX || repeats > E_GESTURE_TAP_REPEATS_MAX) - { - GTWRN("Not supported fingers /repeats bigger than their maximum values\n"); - ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto finish; - } - - gev = &gesture->gesture_events; - - if (gev->taps.fingers[fingers].repeats[repeats].client) - { - GTWRN("%d finger %d repeats is already grabbed by %p client\n", fingers, repeats, gev->taps.fingers[fingers].repeats[repeats].client); - ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; - goto finish; - } - - gev->taps.fingers[fingers].repeats[repeats].client = client; - gev->taps.fingers[fingers].repeats[repeats].res = resource; - gev->taps.fingers[fingers].enabled = EINA_TRUE; - - e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_TAP, fingers, 0, repeats, 0, 0); - - if (gev->taps.max_fingers < fingers) - gev->taps.max_fingers = fingers; - if (gev->taps.fingers[fingers].max_repeats < repeats) - gev->taps.fingers[fingers].max_repeats = repeats; - - gesture->grabbed_gesture |= E_GESTURE_TYPE_TAP; - gev->taps.state = E_GESTURE_TAP_STATE_READY; - gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; - gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; + ret = _e_gesture_grab_tap(client, resource, fingers, repeats); -finish: tizen_gesture_send_tap_notify(resource, fingers, repeats, ret); } @@ -1276,42 +1478,10 @@ _e_gesture_cb_ungrab_tap(struct wl_client *client, struct wl_resource *resource, uint32_t fingers, uint32_t repeats) { - int i; - E_Gesture_Event *gev; int ret = TIZEN_GESTURE_ERROR_NONE; - GTINF("client %p requested to ungrab tap gesture (fingers: %d, repeats: %d)\n", client, fingers, fingers); - - if (fingers > E_GESTURE_FINGER_MAX || repeats > E_GESTURE_TAP_REPEATS_MAX) - { - GTWRN("Not supported fingers /repeats bigger than their maximum values\n"); - ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto finish; - } - - gev = &gesture->gesture_events; - - if (gev->taps.fingers[fingers].repeats[repeats].client == client) - { - gev->taps.fingers[fingers].repeats[repeats].client = NULL; - gev->taps.fingers[fingers].repeats[repeats].res = NULL; - } - - gev->taps.fingers[fingers].enabled = EINA_FALSE; - for (i = 0; i < E_GESTURE_TAP_REPEATS_MAX; i++) - { - if (gev->taps.fingers[fingers].repeats[i].client) - { - gev->taps.fingers[fingers].enabled = EINA_TRUE; - break; - } - } - gev->taps.fingers[fingers].max_repeats = e_gesture_util_tap_max_repeats_get(fingers); - - _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_TAP, fingers, 0, repeats, 0, 0); - _e_gesture_tap_current_list_check(); + ret = _e_gesture_ungrab_tap(client, resource, fingers, repeats); -finish: tizen_gesture_send_tap_notify(resource, fingers, repeats, ret); } @@ -1562,6 +1732,22 @@ _e_gesture_init_handlers(void) gesture->hooks = eina_list_append(gesture->hooks, e_client_hook_add(E_CLIENT_HOOK_AUX_HINT_CHANGE, _e_gesture_cb_aux_hint_change, NULL)); + + if (e_gesture) + { + e_gesture->edge_swipe.grab = _e_gesture_server_grab_edge_swipe; + e_gesture->edge_swipe.ungrab = _e_gesture_server_ungrab_edge_swipe; + e_gesture->edge_drag.grab = _e_gesture_server_grab_edge_drag; + e_gesture->edge_drag.ungrab = _e_gesture_server_ungrab_edge_drag; + e_gesture->tap.grab = _e_gesture_server_grab_tap; + e_gesture->tap.ungrab = _e_gesture_server_ungrab_tap; + e_gesture->palm_cover.grab = _e_gesture_server_grab_palm_cover; + e_gesture->palm_cover.ungrab = _e_gesture_server_ungrab_palm_cover; + e_gesture->pan.grab = _e_gesture_server_grab_pan; + e_gesture->pan.ungrab = _e_gesture_server_ungrab_pan; + e_gesture->pinch.grab = _e_gesture_server_grab_pinch; + e_gesture->pinch.ungrab = _e_gesture_server_ungrab_pinch; + } } static void @@ -1581,6 +1767,21 @@ _e_gesture_deinit_handlers(void) { e_client_hook_del(hook); } + if (e_gesture) + { + e_gesture->edge_swipe.grab = NULL; + e_gesture->edge_swipe.ungrab = NULL; + e_gesture->edge_drag.grab = NULL; + e_gesture->edge_drag.ungrab = NULL; + e_gesture->tap.grab = NULL; + e_gesture->tap.ungrab = NULL; + e_gesture->palm_cover.grab = NULL; + e_gesture->palm_cover.ungrab = NULL; + e_gesture->pan.grab = NULL; + e_gesture->pan.ungrab = NULL; + e_gesture->pinch.grab = NULL; + e_gesture->pinch.ungrab = NULL; + } } static E_Gesture_Config_Data * diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 07cf14f..890c9f2 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -11,6 +11,8 @@ #define GTINF(msg, ARG...) INF("[tizen_gesture][%s:%d] "msg, __FUNCTION__, __LINE__, ##ARG) #define GTDBG(msg, ARG...) DBG("[tizen_gesture][%s:%d] "msg, __FUNCTION__, __LINE__, ##ARG) +#define E_GESTURE_SERVER_CLIENT (void *)0x1 + #define E_GESTURE_TYPE_EDGE_SWIPE TIZEN_GESTURE_TYPE_EDGE_SWIPE #define E_GESTURE_TYPE_EDGE_DRAG TIZEN_GESTURE_TYPE_EDGE_DRAG #define E_GESTURE_TYPE_TAP TIZEN_GESTURE_TYPE_TAP @@ -54,7 +56,6 @@ #define E_GESTURE_PINCH_MOVING_DISTANCE_RANGE 15.0 #define ABS(x) (((x)>0)?(x):-(x)) - #define RAD2DEG(x) ((x) * 57.295779513) typedef struct _E_Gesture E_Gesture; @@ -97,14 +98,6 @@ extern E_GesturePtr gesture; #define E_GESTURE_EDGE_MAX 4 -enum _E_Gesture_Edge -{ - E_GESTURE_EDGE_NONE, - E_GESTURE_EDGE_TOP, - E_GESTURE_EDGE_RIGHT, - E_GESTURE_EDGE_BOTTOM, - E_GESTURE_EDGE_LEFT, -}; #define E_GESTURE_EDGE_ALL ((1 << E_GESTURE_EDGE_TOP) | (1 << E_GESTURE_EDGE_RIGHT) | (1 << E_GESTURE_EDGE_BOTTOM) | (1 << E_GESTURE_EDGE_LEFT)) enum _E_Gesture_Event_State -- 2.7.4 From 07a862bace182c32823a52c4bdcca48ebdcddbe2 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Wed, 13 Sep 2017 14:48:04 +0900 Subject: [PATCH 15/16] do not flush events if other gestures are remained Change-Id: I8e83bfbe70cbd436a37ed09a069e2e42695858e5 --- src/e_mod_gesture_events.c | 29 ++++++++++++++++------------- 1 file changed, 16 insertions(+), 13 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index c32b449..ce01a23 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -75,6 +75,7 @@ _e_gesture_event_flush(void) if (gesture->event_state == E_GESTURE_EVENT_STATE_IGNORE || gesture->gesture_events.recognized_gesture) return; + if (gesture->gesture_filter != E_GESTURE_TYPE_ALL) return; gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE; @@ -437,9 +438,9 @@ _e_gesture_timer_edge_swipe_start(void *data) if ((edge_swipes->base.enabled_finger == 0x0) || (_e_gesture_event_edge_check(&edge_swipes->base.fingers[idx], E_GESTURE_TYPE_EDGE_SWIPE, edge_swipes->base.edge) == EINA_FALSE)) { + _e_gesture_edge_swipe_cancel(); if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); - _e_gesture_edge_swipe_cancel(); } return ECORE_CALLBACK_CANCEL; } @@ -451,9 +452,9 @@ _e_gesture_timer_edge_swipe_done(void *data) GTDBG("Edge_Swipe done timer is expired. Currently alived edge_swipe fingers: 0x%x\n", edge_swipes->base.enabled_finger); + _e_gesture_edge_swipe_cancel(); if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); - _e_gesture_edge_swipe_cancel(); return ECORE_CALLBACK_CANCEL; } @@ -502,9 +503,9 @@ _e_gesture_process_edge_swipe_down(Ecore_Event_Mouse_Button *ev) } else { + _e_gesture_edge_swipe_cancel(); if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); - _e_gesture_edge_swipe_cancel(); } } else @@ -512,9 +513,9 @@ _e_gesture_process_edge_swipe_down(Ecore_Event_Mouse_Button *ev) edge_swipes->base.enabled_finger &= ~(1 << (gesture->gesture_events.num_pressed - 1)); if (edge_swipes->start_timer == NULL) { + _e_gesture_edge_swipe_cancel(); if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); - _e_gesture_edge_swipe_cancel(); } } } @@ -540,9 +541,9 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) case E_GESTURE_EDGE_TOP: if (diff.x > conf->edge_swipe.min_length) { + _e_gesture_edge_swipe_cancel(); if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); - _e_gesture_edge_swipe_cancel(); break; } if (diff.y > conf->edge_swipe.max_length) @@ -553,9 +554,9 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) case E_GESTURE_EDGE_LEFT: if (diff.y > conf->edge_swipe.min_length) { + _e_gesture_edge_swipe_cancel(); if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); - _e_gesture_edge_swipe_cancel(); break; } if (diff.x > conf->edge_swipe.max_length) @@ -566,9 +567,9 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) case E_GESTURE_EDGE_BOTTOM: if (diff.x > conf->edge_swipe.min_length) { + _e_gesture_edge_swipe_cancel(); if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); - _e_gesture_edge_swipe_cancel(); break; } if (diff.y > conf->edge_swipe.max_length) @@ -579,9 +580,9 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) case E_GESTURE_EDGE_RIGHT: if (diff.y > conf->edge_swipe.min_length) { + _e_gesture_edge_swipe_cancel(); if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); - _e_gesture_edge_swipe_cancel(); break; } if (diff.x > conf->edge_swipe.max_length) @@ -601,9 +602,9 @@ _e_gesture_process_edge_swipe_up(Ecore_Event_Mouse_Button *ev) E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; if (!edge_swipes->base.activation.active) return; + _e_gesture_edge_swipe_cancel(); if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); - _e_gesture_edge_swipe_cancel(); } static void @@ -712,9 +713,9 @@ _e_gesture_timer_edge_drag_start(void *data) if ((edge_drags->base.enabled_finger == 0x0) || (_e_gesture_event_edge_check(&edge_drags->base.fingers[idx], E_GESTURE_TYPE_EDGE_DRAG, edge_drags->base.edge) == EINA_FALSE)) { + _e_gesture_edge_drag_cancel(); if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); - _e_gesture_edge_drag_cancel(); } else { @@ -773,9 +774,9 @@ _e_gesture_process_edge_drag_down(Ecore_Event_Mouse_Button *ev) } else { + _e_gesture_edge_drag_cancel(); if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); - _e_gesture_edge_drag_cancel(); } } else @@ -783,9 +784,9 @@ _e_gesture_process_edge_drag_down(Ecore_Event_Mouse_Button *ev) edge_drags->base.enabled_finger &= ~(1 << (gesture->gesture_events.num_pressed - 1)); if (edge_drags->start_timer == NULL) { + _e_gesture_edge_drag_cancel(); if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); - _e_gesture_edge_drag_cancel(); } } } @@ -827,9 +828,9 @@ _e_gesture_process_edge_drag_up(Ecore_Event_Mouse_Button *ev) E_Gesture_Event_Edge_Drag *edge_drags = &gesture->gesture_events.edge_drags; if (!edge_drags->base.activation.active) return; + _e_gesture_edge_drag_cancel(); if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); - _e_gesture_edge_drag_cancel(); } @@ -1291,6 +1292,8 @@ _e_gesture_timer_tap_interval(void *data) } else { + /* All fingers are released. */ + gesture->gesture_filter = E_GESTURE_TYPE_ALL; _e_gesture_tap_cancel(); gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; -- 2.7.4 From f9f354af97da80f37e19d29b8b319abf201942cb Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Mon, 18 Sep 2017 14:47:03 +0900 Subject: [PATCH 16/16] tap: check a different number of fingers in each repeats Change-Id: Icad4afd323ea8842b025a7df4dcd7e284695ff2d --- src/e_mod_gesture_events.c | 7 +++++++ src/e_mod_main.h | 1 + 2 files changed, 8 insertions(+) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index ce01a23..ba460e8 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -1209,6 +1209,7 @@ _e_gesture_tap_cancel(void) taps->repeats = 0; taps->enabled_finger = 0; + taps->current_finger = 0; taps->state = E_GESTURE_TAP_STATE_READY; taps->base_rect.x1 = 0; taps->base_rect.y1 = 0; @@ -1343,6 +1344,7 @@ _e_gesture_tap_done(void) ecore_timer_del(taps->done_timer); taps->done_timer = NULL; } + taps->current_finger = 0; if (taps->repeats == taps->fingers[taps->enabled_finger].max_repeats) { ecore_timer_del(taps->interval_timer); @@ -1371,6 +1373,8 @@ _e_gesture_process_tap_down(Ecore_Event_Mouse_Button *ev) if (taps->enabled_finger < gesture->gesture_events.num_pressed) taps->enabled_finger = gesture->gesture_events.num_pressed; + taps->current_finger++; + if (taps->enabled_finger > taps->max_fingers) _e_gesture_tap_cancel(); @@ -1454,6 +1458,9 @@ _e_gesture_process_tap_up(Ecore_Event_Mouse_Button *ev) if (gesture->gesture_events.recognized_gesture) _e_gesture_tap_cancel(); + if (taps->enabled_finger != taps->current_finger) + _e_gesture_tap_cancel(); + switch (taps->state) { case E_GESTURE_TAP_STATE_NONE: diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 890c9f2..428c1b3 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -290,6 +290,7 @@ struct _E_Gesture_Event_Tap E_Gesture_Event_Tap_Finger fingers[E_GESTURE_FINGER_MAX + 2]; E_Gesture_Tap_State state; unsigned int enabled_finger; + unsigned int current_finger; unsigned int repeats; unsigned int max_fingers; -- 2.7.4