From fe54cb935d37516501723d7f1a4c3bb4223b3a67 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Wed, 2 Aug 2017 11:12:03 +0900 Subject: [PATCH 01/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 02/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 03/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 04/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 05/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 06/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 07/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 08/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 09/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 10/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 11/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 12/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 13/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 From 8caa142250cbb7a51e0d2799b20136091437c480 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Mon, 18 Sep 2017 15:32:31 +0900 Subject: [PATCH 14/16] packaging: version up to 0.2.3 Change-Id: Ie5294b2c518216c6552ef48b27e234be9058b655 --- 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 f687a6f..35124fc 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.2 +Version: 0.2.3 Release: 1 Summary: The Enlightenment Gesture Module for Tizen URL: http://www.enlightenment.org -- 2.7.4 From 117929292bfd88f4fd41c240de06fc5ab865fba3 Mon Sep 17 00:00:00 2001 From: Sung-Jin Park Date: Tue, 26 Sep 2017 11:47:35 +0900 Subject: [PATCH 15/16] e_mod_main.h: remove Ecore_Drm.h file inclusion Change-Id: Ie75354aba7a796cbb8f8ae470fe23f8b1dd6d3dd Signed-off-by: Sung-Jin Park --- src/e_mod_main.h | 1 - 1 file changed, 1 deletion(-) diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 428c1b3..680cda8 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -3,7 +3,6 @@ #include #include -#include #include #define GTERR(msg, ARG...) ERR("[tizen_gesture][%s:%d] "msg, __FUNCTION__, __LINE__, ##ARG) -- 2.7.4 From 1865b9b45942e870b2cbb9ae263f5355636b8293 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Wed, 27 Sep 2017 21:39:35 +0900 Subject: [PATCH 16/16] fix coverity issues - use E_GESTURE_ enum insteads of TIZEN_GESTURE - remove not necessary condition Change-Id: I25c613f472f58b743b50ef3ce67271f7b3589652 --- src/e_mod_gesture_events.c | 64 +++++++++++++++++++++++----------------------- src/e_mod_main.c | 55 ++++++++++++++++++++------------------- 2 files changed, 60 insertions(+), 59 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index ba460e8..81c6dd9 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -64,7 +64,7 @@ _e_gesture_event_queue(int type, void *event) error: if (e_info->event) E_FREE(e_info->event); - if (e_info) E_FREE(e_info); + E_FREE(e_info); } static void @@ -323,13 +323,13 @@ _e_gesture_send_edge_swipe(int fingers, int x, int y, int edge) goto finish; } - if (edge == TIZEN_GESTURE_EDGE_TOP || - edge == TIZEN_GESTURE_EDGE_BOTTOM) + if (edge == E_GESTURE_EDGE_TOP || + edge == E_GESTURE_EDGE_BOTTOM) { bp = x; } - else if (edge == TIZEN_GESTURE_EDGE_RIGHT || - edge == TIZEN_GESTURE_EDGE_LEFT) + else if (edge == E_GESTURE_EDGE_RIGHT || + edge == E_GESTURE_EDGE_LEFT) { bp = y; } @@ -352,7 +352,7 @@ _e_gesture_send_edge_swipe(int fingers, int x, int y, int edge) 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); + tizen_gesture_send_edge_swipe(edata->res, E_GESTURE_MODE_DONE, fingers, x, y, edge); break; } } @@ -386,9 +386,9 @@ _e_gesture_event_edge_check(E_Gesture_Event_Edge_Finger *fingers, int type, unsi if (type == E_GESTURE_TYPE_EDGE_SWIPE) { if ((conf->edge_swipe.default_enable_back) && - (edge == TIZEN_GESTURE_EDGE_TOP || + (edge == E_GESTURE_EDGE_TOP || ((edge_swipes->combined_keycode == conf->edge_swipe.compose_key) && - (edge_swipes->base.edge == TIZEN_GESTURE_EDGE_LEFT)))) + (edge_swipes->base.edge == E_GESTURE_EDGE_LEFT)))) { return EINA_TRUE; } @@ -399,8 +399,8 @@ _e_gesture_event_edge_check(E_Gesture_Event_Edge_Finger *fingers, int type, unsi EINA_LIST_FOREACH(fingers->edge[edge], l, edata) { - if (edge == TIZEN_GESTURE_EDGE_TOP || - edge == TIZEN_GESTURE_EDGE_BOTTOM) + if (edge == E_GESTURE_EDGE_TOP || + edge == E_GESTURE_EDGE_BOTTOM) { if ((coords.x >= edata->sp) && (coords.x <= edata->ep)) @@ -408,8 +408,8 @@ _e_gesture_event_edge_check(E_Gesture_Event_Edge_Finger *fingers, int type, unsi return EINA_TRUE; } } - else if ((edge == TIZEN_GESTURE_EDGE_LEFT) || - (edge == TIZEN_GESTURE_EDGE_RIGHT)) + else if ((edge == E_GESTURE_EDGE_LEFT) || + (edge == E_GESTURE_EDGE_RIGHT)) { if (coords.y >= edata->sp && coords.y <= edata->ep) @@ -616,7 +616,7 @@ _e_gesture_edge_drag_cancel(void) 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); + _e_gesture_send_edge_drag(edge_drags->idx, current_point.x, current_point.y, edge_drags->base.edge, E_GESTURE_MODE_END); } if (edge_drags->start_timer) @@ -660,13 +660,13 @@ _e_gesture_send_edge_drag(int fingers, int x, int y, int edge, int mode) ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, ev_cancel, NULL, NULL); } - if (edge == TIZEN_GESTURE_EDGE_TOP || - edge == TIZEN_GESTURE_EDGE_BOTTOM) + if (edge == E_GESTURE_EDGE_TOP || + edge == E_GESTURE_EDGE_BOTTOM) { bp = edge_drags->start_point.x; } - else if (edge == TIZEN_GESTURE_EDGE_RIGHT || - edge == TIZEN_GESTURE_EDGE_LEFT) + else if (edge == E_GESTURE_EDGE_RIGHT || + edge == E_GESTURE_EDGE_LEFT) { bp = edge_drags->start_point.y; } @@ -723,7 +723,7 @@ _e_gesture_timer_edge_drag_start(void *data) 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); + _e_gesture_send_edge_drag(edge_drags->idx, edge_drags->center_point.x, edge_drags->center_point.y, edge_drags->base.edge, E_GESTURE_MODE_BEGIN); } ecore_timer_del(edge_drags->start_timer); @@ -819,7 +819,7 @@ _e_gesture_process_edge_drag_move(Ecore_Event_Mouse_Move *ev) _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); + edge_drags->base.edge, E_GESTURE_MODE_UPDATE); } static void @@ -840,7 +840,7 @@ _e_gesture_pan_send(int mode, int fingers, int cx, int cy, struct wl_resource *r Ecore_Event_Mouse_Button *ev_cancel; E_Event_Gesture_Pan *ev_pan; - if (mode == TIZEN_GESTURE_MODE_BEGIN) + if (mode == E_GESTURE_MODE_BEGIN) { ev_cancel = E_NEW(Ecore_Event_Mouse_Button, 1); EINA_SAFETY_ON_NULL_RETURN(ev_cancel); @@ -885,7 +885,7 @@ _e_gesture_pan_cancel(void) } if (pans->state == E_GESTURE_PANPINCH_STATE_MOVING) - _e_gesture_pan_send(TIZEN_GESTURE_MODE_END, pans->num_pan_fingers, 0, 0, + _e_gesture_pan_send(E_GESTURE_MODE_END, pans->num_pan_fingers, 0, 0, pans->fingers[pans->num_pan_fingers].res, pans->fingers[pans->num_pan_fingers].client); @@ -966,12 +966,12 @@ _e_gesture_process_pan_move(Ecore_Event_Mouse_Move *ev) switch (pans->state) { case E_GESTURE_PANPINCH_STATE_START: - mode = TIZEN_GESTURE_MODE_BEGIN; + mode = E_GESTURE_MODE_BEGIN; pans->state = E_GESTURE_PANPINCH_STATE_MOVING; pans->num_pan_fingers = idx; break; case E_GESTURE_PANPINCH_STATE_MOVING: - mode = TIZEN_GESTURE_MODE_UPDATE; + mode = E_GESTURE_MODE_UPDATE; break; default: return; @@ -982,8 +982,8 @@ _e_gesture_process_pan_move(Ecore_Event_Mouse_Move *ev) _e_gesture_pan_send(mode, idx, cur_point.x, cur_point.y, pans->fingers[idx].res, pans->fingers[idx].client); - if (mode == TIZEN_GESTURE_MODE_BEGIN) - mode = TIZEN_GESTURE_MODE_UPDATE; + if (mode == E_GESTURE_MODE_BEGIN) + mode = E_GESTURE_MODE_UPDATE; } } @@ -1002,7 +1002,7 @@ _e_gesture_pinch_send(int mode, int fingers, double distance, double angle, int Ecore_Event_Mouse_Button *ev_cancel; E_Event_Gesture_Pinch *ev_pinch; - if (mode == TIZEN_GESTURE_MODE_BEGIN) + if (mode == E_GESTURE_MODE_BEGIN) { ev_cancel = E_NEW(Ecore_Event_Mouse_Button, 1); EINA_SAFETY_ON_NULL_RETURN(ev_cancel); @@ -1049,7 +1049,7 @@ _e_gesture_pinch_cancel(void) } if (pinchs->state == E_GESTURE_PANPINCH_STATE_MOVING) - _e_gesture_pinch_send(TIZEN_GESTURE_MODE_END, pinchs->num_pinch_fingers, 0.0, 0.0, 0, 0, + _e_gesture_pinch_send(E_GESTURE_MODE_END, pinchs->num_pinch_fingers, 0.0, 0.0, 0, 0, pinchs->fingers[pinchs->num_pinch_fingers].res, pinchs->fingers[pinchs->num_pinch_fingers].client); @@ -1122,12 +1122,12 @@ _e_gesture_process_pinch_move(Ecore_Event_Mouse_Move *ev) switch (pinch->state) { case E_GESTURE_PANPINCH_STATE_START: - mode = TIZEN_GESTURE_MODE_BEGIN; + mode = E_GESTURE_MODE_BEGIN; pinch->state = E_GESTURE_PANPINCH_STATE_MOVING; pinch->num_pinch_fingers = idx; break; case E_GESTURE_PANPINCH_STATE_MOVING: - mode = TIZEN_GESTURE_MODE_UPDATE; + mode = E_GESTURE_MODE_UPDATE; break; default: return; @@ -1238,7 +1238,7 @@ _e_gesture_send_tap(int fingers, int repeats, struct wl_client *client, struct w ecore_event_add(E_EVENT_GESTURE_TAP, ev_tap, NULL, NULL); } else - tizen_gesture_send_tap(res, TIZEN_GESTURE_MODE_DONE, fingers, repeats); + tizen_gesture_send_tap(res, E_GESTURE_MODE_DONE, fingers, repeats); _e_gesture_event_drop(); gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_TAP; @@ -1780,8 +1780,8 @@ _e_gesture_send_palm_cover(void) 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, E_GESTURE_MODE_BEGIN, duration, size, pressure, cx, cy); + tizen_gesture_send_palm_cover(palm_covers->client_info.res, surface, E_GESTURE_MODE_END, duration, size, pressure, cx, cy); } gesture->event_state = E_GESTURE_EVENT_STATE_IGNORE; diff --git a/src/e_mod_main.c b/src/e_mod_main.c index 9233cd1..096fb04 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -124,6 +124,7 @@ e_gesture_add_client_destroy_listener(struct wl_client *client, int mode, int fi if (!grabbed_client) { GTERR("Failed to allocate memory to save client information !\n"); + E_FREE(destroy_listener); return TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES; } @@ -450,30 +451,30 @@ _e_gesture_grab_edge_swipe(struct wl_client *client, gev = &gesture->gesture_events; - if (edge < TIZEN_GESTURE_EDGE_TOP || edge > TIZEN_GESTURE_EDGE_LEFT) + if (edge < E_GESTURE_EDGE_TOP || edge > E_GESTURE_EDGE_LEFT) { GTWRN("Invalid edge(%d)\n", edge); ret = TIZEN_GESTURE_ERROR_INVALID_DATA; return ret; } - if (edge_size == TIZEN_GESTURE_EDGE_SIZE_PARTIAL) + if (edge_size == E_GESTURE_EDGE_SIZE_PARTIAL) { sp = start_point; ep = end_point; - if (((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) && + if (((edge == E_GESTURE_EDGE_TOP) || (edge == E_GESTURE_EDGE_BOTTOM)) && (ep > e_comp->w)) ep = e_comp->w; - else if (((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) && + else if (((edge == E_GESTURE_EDGE_RIGHT) || (edge == E_GESTURE_EDGE_LEFT)) && (ep > e_comp->h)) ep = e_comp->h; } - else if (edge_size == TIZEN_GESTURE_EDGE_SIZE_FULL) + else if (edge_size == E_GESTURE_EDGE_SIZE_FULL) { sp = 0; - if ((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) + if ((edge == E_GESTURE_EDGE_TOP) || (edge == E_GESTURE_EDGE_BOTTOM)) ep = e_comp->w; - else if ((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) + else if ((edge == E_GESTURE_EDGE_RIGHT) || (edge == E_GESTURE_EDGE_LEFT)) ep = e_comp->h; } else @@ -534,23 +535,23 @@ _e_gesture_ungrab_edge_swipe(struct wl_client *client, gev = &gesture->gesture_events; - if (edge_size == TIZEN_GESTURE_EDGE_SIZE_PARTIAL) + if (edge_size == E_GESTURE_EDGE_SIZE_PARTIAL) { sp = start_point; ep = end_point; - if (((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) && + if (((edge == E_GESTURE_EDGE_TOP) || (edge == E_GESTURE_EDGE_BOTTOM)) && (ep > e_comp->w)) ep = e_comp->w; - else if (((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) && + else if (((edge == E_GESTURE_EDGE_RIGHT) || (edge == E_GESTURE_EDGE_LEFT)) && (ep > e_comp->h)) ep = e_comp->h; } - else if (edge_size == TIZEN_GESTURE_EDGE_SIZE_FULL) + else if (edge_size == E_GESTURE_EDGE_SIZE_FULL) { sp = 0; - if ((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) + if ((edge == E_GESTURE_EDGE_TOP) || (edge == E_GESTURE_EDGE_BOTTOM)) ep = e_comp->w; - else if ((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) + else if ((edge == E_GESTURE_EDGE_RIGHT) || (edge == E_GESTURE_EDGE_LEFT)) ep = e_comp->h; } else @@ -611,30 +612,30 @@ _e_gesture_grab_edge_drag(struct wl_client *client, goto out; } - if (edge < TIZEN_GESTURE_EDGE_TOP || edge > TIZEN_GESTURE_EDGE_LEFT) + if (edge < E_GESTURE_EDGE_TOP || edge > E_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) + if (edge_size == E_GESTURE_EDGE_SIZE_PARTIAL) { sp = start_point; ep = end_point; - if (((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) && + if (((edge == E_GESTURE_EDGE_TOP) || (edge == E_GESTURE_EDGE_BOTTOM)) && (ep > e_comp->w)) ep = e_comp->w; - else if (((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) && + else if (((edge == E_GESTURE_EDGE_RIGHT) || (edge == E_GESTURE_EDGE_LEFT)) && (ep > e_comp->h)) ep = e_comp->h; } - else if (edge_size == TIZEN_GESTURE_EDGE_SIZE_FULL) + else if (edge_size == E_GESTURE_EDGE_SIZE_FULL) { sp = 0; - if ((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) + if ((edge == E_GESTURE_EDGE_TOP) || (edge == E_GESTURE_EDGE_BOTTOM)) ep = e_comp->w; - else if ((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) + else if ((edge == E_GESTURE_EDGE_RIGHT) || (edge == E_GESTURE_EDGE_LEFT)) ep = e_comp->h; } else @@ -691,23 +692,23 @@ _e_gesture_ungrab_edge_drag(struct wl_client *client, goto out; } - if (edge_size == TIZEN_GESTURE_EDGE_SIZE_PARTIAL) + if (edge_size == E_GESTURE_EDGE_SIZE_PARTIAL) { sp = start_point; ep = end_point; - if (((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) && + if (((edge == E_GESTURE_EDGE_TOP) || (edge == E_GESTURE_EDGE_BOTTOM)) && (ep > e_comp->w)) ep = e_comp->w; - else if (((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) && + else if (((edge == E_GESTURE_EDGE_RIGHT) || (edge == E_GESTURE_EDGE_LEFT)) && (ep > e_comp->h)) ep = e_comp->h; } - else if (edge_size == TIZEN_GESTURE_EDGE_SIZE_FULL) + else if (edge_size == E_GESTURE_EDGE_SIZE_FULL) { sp = 0; - if ((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) + if ((edge == E_GESTURE_EDGE_TOP) || (edge == E_GESTURE_EDGE_BOTTOM)) ep = e_comp->w; - else if ((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) + else if ((edge == E_GESTURE_EDGE_RIGHT) || (edge == E_GESTURE_EDGE_LEFT)) ep = e_comp->h; } else @@ -1857,7 +1858,7 @@ _e_gesture_init(E_Module *m) gesture->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; 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); + gesture->gesture_events.edge_swipes.base.enabled_edge |= (1 << E_GESTURE_EDGE_TOP); if (gesture->gesture_events.event_keep) { gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; -- 2.7.4