From 174336bca573e31239e56b7b007c4aa3525a6acf Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Fri, 31 Mar 2017 14:09:28 +0900 Subject: [PATCH 01/16] Set top edge to enabled_edge if default back gesture is enabled Change-Id: I7a8fdc2dcca87803719521e7e038166ce8a836e6 --- src/e_mod_main.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/e_mod_main.c b/src/e_mod_main.c index ad13585..0edf9d4 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -498,6 +498,7 @@ _e_gesture_init(E_Module *m) gesture->gesture_events.edge_swipes.fingers[1].enabled = EINA_TRUE; gesture->gesture_events.edge_swipes.fingers[1].edge[E_GESTURE_EDGE_TOP].client = (void *)0x1; gesture->gesture_events.edge_swipes.fingers[1].edge[E_GESTURE_EDGE_TOP].res = (void *)0x1; + gesture->gesture_events.edge_swipes.enabled_edge |= TIZEN_GESTURE_EDGE_TOP; if (gesture->gesture_events.edge_swipes.event_keep) { gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; -- 2.7.4 From 1c5b63d1da8b627438a827f2129e95f9a6dd8940 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Fri, 31 Mar 2017 14:11:37 +0900 Subject: [PATCH 02/16] Remove unnecessary space and align codes following efl coding rule Change-Id: Iee1d74e325031de2563c5f48c1820bd2c67361f0 --- src/e_mod_main.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/src/e_mod_main.c b/src/e_mod_main.c index 0edf9d4..8ee5dbd 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -8,8 +8,6 @@ E_API E_Module_Api e_modapi = { E_MODULE_API_VERSION, "Gesture Module of Window static E_Gesture_Config_Data *_e_gesture_init(E_Module *m); static void _e_gesture_init_handlers(void); - - static void _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data); static void @@ -500,9 +498,9 @@ _e_gesture_init(E_Module *m) gesture->gesture_events.edge_swipes.fingers[1].edge[E_GESTURE_EDGE_TOP].res = (void *)0x1; gesture->gesture_events.edge_swipes.enabled_edge |= TIZEN_GESTURE_EDGE_TOP; if (gesture->gesture_events.edge_swipes.event_keep) - { - gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; - } + { + gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; + } } e_gesture_device_keydev_set(gesture->config->conf->key_device_name); -- 2.7.4 From 23dd1602df03925280ad1c1ba10a84abd99fd52f Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Fri, 31 Mar 2017 14:14:44 +0900 Subject: [PATCH 03/16] packaging: update version to 0.1.8 Change-Id: Ibd1dc737cbe27ede055d744e5c4c28ea4b1c5139 --- 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 0a1e2e5..4b9cff3 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.7 +Version: 0.1.8 Release: 1 Summary: The Enlightenment Gesture Module for Tizen URL: http://www.enlightenment.org -- 2.7.4 From 9ccb0f3fa83413b16c22d24763baf9e25a5bab31 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Tue, 21 Feb 2017 11:03:54 +0900 Subject: [PATCH 04/16] Add a tap gesture Change-Id: I8d9c594ac12c8748542fd95a7b83113593f075ca --- src/e_mod_gesture_events.c | 334 +++++++++++++++++++++++++++++++++++++++++++-- src/e_mod_main.c | 105 +++++++++++++- src/e_mod_main.h | 72 +++++++++- 3 files changed, 498 insertions(+), 13 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index e1de548..d95ae94 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -431,6 +431,291 @@ _e_gesture_process_edge_swipe_up(Ecore_Event_Mouse_Button *ev) _e_gesture_edge_swipe_cancel(); } +unsigned int +e_gesture_util_tap_max_fingers_get(void) +{ + E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + int i; + unsigned int max = 0; + + for (i = 0; i < E_GESTURE_FINGER_MAX +1; i++) + { + if (taps->fingers[i].enabled) max = i; + } + + return max; +} + +unsigned int +e_gesture_util_tap_max_repeats_get(unsigned int fingers) +{ + E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + int i; + unsigned int max = 0; + + for (i = 0; i < E_GESTURE_TAP_REPEATS_MAX + 1; i++) + { + if (taps->fingers[fingers].repeats[i].client) max = i; + } + + return max; +} + +static void +_e_gesture_tap_cancel(void) +{ + E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + + if (taps->start_timer) + { + ecore_timer_del(taps->start_timer); + taps->start_timer = NULL; + } + if (taps->done_timer) + { + ecore_timer_del(taps->done_timer); + taps->done_timer = NULL; + } + if (taps->interval_timer) + { + ecore_timer_del(taps->interval_timer); + taps->interval_timer = NULL; + } + + taps->repeats = 0; + taps->enabled_finger = 0; + taps->state = E_GESTURE_TAP_STATE_READY; + gesture->gesture_filter |= TIZEN_GESTURE_TYPE_TAP; + _e_gesture_event_flush(); + gesture->gesture_events.recognized_gesture &= ~TIZEN_GESTURE_TYPE_TAP; +} + +static void +_e_gesture_send_tap(int fingers, int repeats, struct wl_client *client, struct wl_resource *res) +{ + 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); + _e_gesture_event_drop(); + gesture->gesture_events.recognized_gesture |= TIZEN_GESTURE_TYPE_TAP; + + _e_gesture_tap_cancel(); +} + +static Eina_Bool +_e_gesture_timer_tap_start(void *data) +{ + E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + + if (taps->fingers[taps->enabled_finger].enabled) + { + taps->state = E_GESTURE_TAP_STATE_PROCESS; + } + else + { + _e_gesture_tap_cancel(); + } + + taps->start_timer = NULL; + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_e_gesture_timer_tap_done(void *data) +{ + E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + + if (gesture->gesture_events.num_pressed) + { + _e_gesture_tap_cancel(); + } + + taps->done_timer = NULL; + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_e_gesture_timer_tap_interval(void *data) +{ + E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + + if (taps->fingers[taps->enabled_finger].repeats[taps->repeats].client) + { + _e_gesture_send_tap(taps->enabled_finger, taps->repeats, + taps->fingers[taps->enabled_finger].repeats[taps->repeats].client, + taps->fingers[taps->enabled_finger].repeats[taps->repeats].res); + gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; + gesture->gesture_events.recognized_gesture &= ~TIZEN_GESTURE_TYPE_TAP; + gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; + } + else + { + _e_gesture_tap_cancel(); + + gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; + gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; + } + + taps->interval_timer = NULL; + return ECORE_CALLBACK_CANCEL; +} + +static void +_e_gesture_tap_start(void) +{ + E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + + taps->state = E_GESTURE_TAP_STATE_START; + if (!taps->start_timer) + { + taps->start_timer = ecore_timer_add(E_GESTURE_TAP_START_TIME, _e_gesture_timer_tap_start, NULL); + } + if (!taps->done_timer) + { + taps->done_timer = ecore_timer_add(E_GESTURE_TAP_DONE_TIME, _e_gesture_timer_tap_done, NULL); + } +} + +static void +_e_gesture_tap_done(void) +{ + E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + + if (taps->repeats >= E_GESTURE_TAP_REPEATS_MAX) + _e_gesture_tap_cancel(); + + if (!taps->fingers[taps->enabled_finger].enabled) + _e_gesture_tap_cancel(); + + if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_TAP) && + gesture->gesture_events.num_pressed == 0) + { + taps->state = E_GESTURE_TAP_STATE_WAIT; + taps->repeats++; + if (taps->done_timer) + { + ecore_timer_del(taps->done_timer); + taps->done_timer = NULL; + } + if (taps->repeats == taps->fingers[taps->enabled_finger].max_repeats) + { + ecore_timer_del(taps->interval_timer); + _e_gesture_timer_tap_interval(NULL); + } + else + { + if (!taps->interval_timer) + { + taps->interval_timer = ecore_timer_add(E_GESTURE_TAP_INTERVAL_TIME, _e_gesture_timer_tap_interval, NULL); + } + } + } +} + +static void +_e_gesture_process_tap_down(Ecore_Event_Mouse_Button *ev) +{ + E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + + if (taps->enabled_finger < gesture->gesture_events.num_pressed) + taps->enabled_finger = gesture->gesture_events.num_pressed; + + if (taps->enabled_finger > taps->max_fingers) + _e_gesture_tap_cancel(); + + switch (taps->state) + { + case E_GESTURE_TAP_STATE_NONE: + return; + + case E_GESTURE_TAP_STATE_READY: + _e_gesture_tap_start(); + break; + + case E_GESTURE_TAP_STATE_START: + break; + + case E_GESTURE_TAP_STATE_PROCESS: + _e_gesture_tap_cancel(); + break; + + case E_GESTURE_TAP_STATE_WAIT: + if (taps->interval_timer) + { + ecore_timer_del(taps->interval_timer); + taps->interval_timer = NULL; + } + _e_gesture_tap_start(); + break; + + case E_GESTURE_TAP_STATE_DONE: + break; + + default: + break; + } +} + +static void +_e_gesture_process_tap_move(Ecore_Event_Mouse_Move *ev) +{ + int diff_x, diff_y; + + diff_x = gesture->gesture_events.base_point[ev->multi.device].axis.x - ev->x; + diff_y = gesture->gesture_events.base_point[ev->multi.device].axis.y - ev->y; + + if (ABS(diff_x) > E_GESTURE_TAP_MOVING_LANGE || + ABS(diff_y) > E_GESTURE_TAP_MOVING_LANGE) + { + GTDBG("%d finger moving too large diff: (%d, %d)\n", ev->multi.device, diff_x, diff_y); + _e_gesture_tap_cancel(); + } +} + +static void +_e_gesture_process_tap_up(Ecore_Event_Mouse_Button *ev) +{ + E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + + switch (taps->state) + { + case E_GESTURE_TAP_STATE_NONE: + return; + + case E_GESTURE_TAP_STATE_READY: + _e_gesture_tap_cancel(); + break; + + case E_GESTURE_TAP_STATE_START: + taps->state = E_GESTURE_TAP_STATE_PROCESS; + if (taps->start_timer) + { + ecore_timer_del(taps->start_timer); + taps->start_timer = NULL; + } + _e_gesture_tap_done(); + break; + + case E_GESTURE_TAP_STATE_PROCESS: + _e_gesture_tap_done(); + break; + + case E_GESTURE_TAP_STATE_WAIT: + if (taps->interval_timer) + { + ecore_timer_del(taps->interval_timer); + taps->interval_timer = NULL; + } + _e_gesture_tap_start(); + break; + + case E_GESTURE_TAP_STATE_DONE: + break; + + default: + break; + } +} + static E_Gesture_Event_State _e_gesture_process_mouse_button_down(void *event) { @@ -449,6 +734,10 @@ _e_gesture_process_mouse_button_down(void *event) return E_GESTURE_EVENT_STATE_PROPAGATE; } + gesture->gesture_events.base_point[ev->multi.device].pressed = EINA_TRUE; + gesture->gesture_events.base_point[ev->multi.device].axis.x = ev->x; + gesture->gesture_events.base_point[ev->multi.device].axis.y = ev->y; + if (gesture->gesture_events.recognized_gesture) { return E_GESTURE_EVENT_STATE_IGNORE; @@ -466,6 +755,10 @@ _e_gesture_process_mouse_button_down(void *event) { _e_gesture_process_edge_swipe_down(ev); } + if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_TAP)) + { + _e_gesture_process_tap_down(ev); + } return gesture->event_state; } @@ -483,6 +776,23 @@ _e_gesture_process_mouse_button_up(void *event) { return E_GESTURE_EVENT_STATE_PROPAGATE; } + if (ev->multi.device > E_GESTURE_FINGER_MAX) + { + return E_GESTURE_EVENT_STATE_PROPAGATE; + } + + gesture->gesture_events.base_point[ev->multi.device].pressed = EINA_FALSE; + gesture->gesture_events.base_point[ev->multi.device].axis.x = 0; + gesture->gesture_events.base_point[ev->multi.device].axis.y = 0; + + if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_EDGE_SWIPE)) + { + _e_gesture_process_edge_swipe_up(ev); + } + if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_TAP)) + { + _e_gesture_process_tap_up(ev); + } if (gesture->gesture_events.recognized_gesture) { @@ -493,11 +803,6 @@ _e_gesture_process_mouse_button_up(void *event) return E_GESTURE_EVENT_STATE_IGNORE; } - if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_EDGE_SWIPE)) - { - _e_gesture_process_edge_swipe_up(ev); - } - return gesture->event_state; } @@ -511,6 +816,10 @@ _e_gesture_process_mouse_move(void *event) { return E_GESTURE_EVENT_STATE_PROPAGATE; } + if (ev->multi.device > E_GESTURE_FINGER_MAX) + { + return E_GESTURE_EVENT_STATE_PROPAGATE; + } if (gesture->gesture_events.num_pressed == 0) { return gesture->event_state; @@ -519,6 +828,10 @@ _e_gesture_process_mouse_move(void *event) { return E_GESTURE_EVENT_STATE_PROPAGATE; } + if (gesture->gesture_events.base_point[ev->multi.device].pressed != EINA_TRUE) + { + return gesture->event_state; + } if (gesture->gesture_events.recognized_gesture) { return E_GESTURE_EVENT_STATE_IGNORE; @@ -528,6 +841,10 @@ _e_gesture_process_mouse_move(void *event) { _e_gesture_process_edge_swipe_move(ev); } + if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_TAP)) + { + _e_gesture_process_tap_move(ev); + } return gesture->event_state; } @@ -602,9 +919,10 @@ e_gesture_process_events(void *event, int type) if (gesture->gesture_events.num_pressed == 0&& type == ECORE_EVENT_MOUSE_BUTTON_UP) { - if ((gesture->grabbed_gesture & TIZEN_GESTURE_TYPE_EDGE_SWIPE) && - gesture->gesture_events.edge_swipes.event_keep) - gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; + if (gesture->grabbed_gesture & TIZEN_GESTURE_TYPE_TAP || + ((gesture->grabbed_gesture & TIZEN_GESTURE_TYPE_EDGE_SWIPE) && + gesture->gesture_events.edge_swipes.event_keep)) + gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; } diff --git a/src/e_mod_main.c b/src/e_mod_main.c index 8ee5dbd..7f1a86e 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -291,9 +291,112 @@ notify: return; } +static void +_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; + + 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 |= TIZEN_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; + +finish: + tizen_gesture_send_tap_notify(resource, fingers, repeats, ret); +} + +static void +_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; + } + } + + gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_TAP; + gev->taps.state = E_GESTURE_TAP_STATE_NONE; + gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE; + for (i = 0; i < E_GESTURE_FINGER_MAX; i++) + { + if (gev->taps.fingers[i].enabled) + { + gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_TAP; + gev->taps.state = E_GESTURE_TAP_STATE_READY; + gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; + break; + } + } + + gev->taps.max_fingers = e_gesture_util_tap_max_fingers_get(); + gev->taps.fingers[fingers].max_repeats = e_gesture_util_tap_max_repeats_get(fingers); + +finish: + tizen_gesture_send_tap_notify(resource, fingers, repeats, ret); +} + static const struct tizen_gesture_interface _e_gesture_implementation = { _e_gesture_cb_grab_edge_swipe, - _e_gesture_cb_ungrab_edge_swipe + _e_gesture_cb_ungrab_edge_swipe, + _e_gesture_cb_grab_tap, + _e_gesture_cb_ungrab_tap }; /* tizen_gesture global object destroy function */ diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 96c3cd8..67fa909 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -12,8 +12,8 @@ #define GTDBG(msg, ARG...) DBG("[tizen_gesture][%s:%d] "msg, __FUNCTION__, __LINE__, ##ARG) #define E_GESTURE_FINGER_MAX 3 -#define E_GESTURE_TYPE_MAX TIZEN_GESTURE_TYPE_EDGE_SWIPE+1 -#define E_GESTURE_TYPE_ALL TIZEN_GESTURE_TYPE_EDGE_SWIPE +#define E_GESTURE_TYPE_MAX TIZEN_GESTURE_TYPE_TAP+1 +#define E_GESTURE_TYPE_ALL (TIZEN_GESTURE_TYPE_EDGE_SWIPE | TIZEN_GESTURE_TYPE_TAP) #define E_GESTURE_KEYBOARD_NAME "Gesture Keyboard" #define E_GESTURE_AUX_HINT_GESTURE_DISABLE "wm.policy.win.gesture.disable" @@ -30,7 +30,13 @@ #define E_GESTURE_EDGE_SWIPE_BACK_KEY 166 #define E_GESTURE_EDGE_SWIPE_BACK_DEFAULT_ENABLE EINA_TRUE -#define ABS(x) ((x)>0)?(x):-(x) +#define E_GESTURE_TAP_REPEATS_MAX 3 +#define E_GESTURE_TAP_START_TIME 0.05 +#define E_GESTURE_TAP_DONE_TIME 1 +#define E_GESTURE_TAP_INTERVAL_TIME 1 +#define E_GESTURE_TAP_MOVING_LANGE 25 + +#define ABS(x) (((x)>0)?(x):-(x)) typedef struct _E_Gesture E_Gesture; typedef struct _E_Gesture* E_GesturePtr; @@ -42,11 +48,17 @@ typedef struct _E_Gesture_Grabbed_Client E_Gesture_Grabbed_Client; typedef struct _E_Gesture_Conf_Edd E_Gesture_Conf_Edd; typedef struct _E_Gesture_Config_Data E_Gesture_Config_Data; +typedef struct _E_Gesture_Event_Tap_Finger_Repeats E_Gesture_Event_Tap_Finger_Repeats; +typedef struct _E_Gesture_Event_Tap_Finger E_Gesture_Event_Tap_Finger; +typedef struct _E_Gesture_Event_Tap E_Gesture_Event_Tap; + typedef struct _Coords Coords; +typedef struct _E_Gesture_Finger E_Gesture_Finger; typedef struct _E_Gesture_Event_Info E_Gesture_Event_Info; typedef enum _E_Gesture_Edge E_Gesture_Edge; typedef enum _E_Gesture_Event_State E_Gesture_Event_State; +typedef enum _E_Gesture_Tap_State E_Gesture_Tap_State; extern E_GesturePtr gesture; @@ -69,11 +81,27 @@ enum _E_Gesture_Event_State E_GESTURE_EVENT_STATE_IGNORE }; +enum _E_Gesture_Tap_State +{ + E_GESTURE_TAP_STATE_NONE, + E_GESTURE_TAP_STATE_READY, // tap is required, idle + E_GESTURE_TAP_STATE_START, // first finger is pressed + E_GESTURE_TAP_STATE_PROCESS, // all fingers are pressed or first release + E_GESTURE_TAP_STATE_WAIT, // all fingers are released and wait next tap + E_GESTURE_TAP_STATE_DONE +}; + struct _Coords { int x, y; }; +struct _E_Gesture_Finger +{ + Eina_Bool pressed; + Coords axis; +}; + struct _E_Gesture_Event_Info { int type; @@ -144,9 +172,41 @@ struct _E_Gesture_Event_Edge_Swipe Eina_Bool event_keep; }; +struct _E_Gesture_Event_Tap_Finger_Repeats +{ + struct wl_client *client; + struct wl_resource *res; +}; + +struct _E_Gesture_Event_Tap_Finger +{ + Eina_Bool enabled; + unsigned int max_repeats; + E_Gesture_Event_Tap_Finger_Repeats repeats[E_GESTURE_TAP_REPEATS_MAX+1]; +}; + +struct _E_Gesture_Event_Tap +{ + E_Gesture_Event_Tap_Finger fingers[E_GESTURE_FINGER_MAX+1]; + E_Gesture_Tap_State state; + unsigned int enabled_finger; + unsigned int repeats; + unsigned int max_fingers; + + /* pressed timer */ + Ecore_Timer *start_timer; + /* release timer */ + Ecore_Timer *done_timer; + /* interval timer */ + Ecore_Timer *interval_timer; +}; + struct _E_Gesture_Event { E_Gesture_Event_Edge_Swipe edge_swipes; + E_Gesture_Event_Tap taps; + + E_Gesture_Finger base_point[E_GESTURE_FINGER_MAX + 1]; int num_pressed; Eina_Bool recognized_gesture; @@ -171,7 +231,7 @@ struct _E_Gesture char *kbd_identifier; char *kbd_name; Ecore_Device *kbd_device; - }device; + } device; unsigned int grabbed_gesture; E_Gesture_Event gesture_events; @@ -205,4 +265,8 @@ void e_gesture_device_keydev_set(char *option); void e_gesture_event_filter_enable(Eina_Bool enabled); +/* Util functions */ +unsigned int e_gesture_util_tap_max_fingers_get(void); +unsigned int e_gesture_util_tap_max_repeats_get(unsigned int); + #endif -- 2.7.4 From cc8a25c436324cf4965ae443b5f42fc05279217b Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Tue, 21 Feb 2017 11:11:09 +0900 Subject: [PATCH 05/16] Add a pan gesture Change-Id: Ie6aefb3394a7d7cb6067778483c3540c9ee0c579 --- src/e_mod_gesture_events.c | 180 ++++++++++++++++++++++++++++++++++++++++++++- src/e_mod_main.c | 104 +++++++++++++++++++++++++- src/e_mod_main.h | 46 +++++++++++- 3 files changed, 321 insertions(+), 9 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index d95ae94..13109ad 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -431,6 +431,167 @@ _e_gesture_process_edge_swipe_up(Ecore_Event_Mouse_Button *ev) _e_gesture_edge_swipe_cancel(); } +static void +_e_gesture_pan_send(int mode, int fingers, int cx, int cy, struct wl_resource *res, struct wl_client *client) +{ + Ecore_Event_Mouse_Button *ev_cancel; + + if (mode == TIZEN_GESTURE_MODE_BEGIN) + { + ev_cancel = E_NEW(Ecore_Event_Mouse_Button, 1); + EINA_SAFETY_ON_NULL_RETURN(ev_cancel); + + ev_cancel->timestamp = (int)(ecore_time_get()*1000); + ev_cancel->same_screen = 1; + + ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, ev_cancel, NULL, NULL); + } + + GTINF("Send pan gesture %d fingers. (%d, %d) to client: %p, mode: %d\n", fingers, cx, cy, client, mode); + + tizen_gesture_send_pan(res, mode, fingers, cx, cy); + + gesture->gesture_events.recognized_gesture |= TIZEN_GESTURE_TYPE_PAN; +} + +static void +_e_gesture_pan_cancel(void) +{ + E_Gesture_Event_Pan *pans = &gesture->gesture_events.pans; + + if (pans->start_timer) + { + ecore_timer_del(pans->start_timer); + pans->start_timer = NULL; + } + if (pans->move_timer) + { + ecore_timer_del(pans->move_timer); + pans->move_timer = NULL; + } + + if (pans->state == E_GESTURE_PAN_STATE_MOVING) + _e_gesture_pan_send(TIZEN_GESTURE_MODE_END, pans->num_pan_fingers, 0, 0, + pans->fingers[pans->num_pan_fingers].res, + pans->fingers[pans->num_pan_fingers].client); + + gesture->gesture_filter |= TIZEN_GESTURE_TYPE_PAN; + pans->state = E_GESTURE_PAN_STATE_DONE; +} + +static void +_e_gesture_util_center_axis_get(int num_finger, int *x, int *y) +{ + int i; + int calc_x = 0, calc_y = 0; + + for (i = 1; i <= num_finger; i++) + { + calc_x += gesture->gesture_events.base_point[i].axis.x; + calc_y += gesture->gesture_events.base_point[i].axis.y; + } + + calc_x = (int)(calc_x / num_finger); + calc_y = (int)(calc_y / num_finger); + + *x = calc_x; + *y = calc_y; +} + +static Eina_Bool +_e_gesture_timer_pan_start(void *data) +{ + E_Gesture_Event_Pan *pans = &gesture->gesture_events.pans; + int num_pressed = gesture->gesture_events.num_pressed; + int i; + + if (pans->fingers[num_pressed].client) + { + for (i = 1; i <= num_pressed; i++) + { + pans->start_point.x += gesture->gesture_events.base_point[i].axis.x; + pans->start_point.y += gesture->gesture_events.base_point[i].axis.y; + } + pans->center_point.x = pans->start_point.x = (int)(pans->start_point.x / num_pressed); + pans->center_point.y = pans->start_point.y = (int)(pans->start_point.y / num_pressed); + pans->state = E_GESTURE_PAN_STATE_START; + } + else + { + _e_gesture_pan_cancel(); + } + return ECORE_CALLBACK_CANCEL; +} + +static void +_e_gesture_process_pan_down(Ecore_Event_Mouse_Button *ev) +{ + E_Gesture_Event_Pan *pans = &gesture->gesture_events.pans; + + if (gesture->gesture_events.recognized_gesture && + !((gesture->gesture_events.recognized_gesture & TIZEN_GESTURE_TYPE_PAN))) + _e_gesture_pan_cancel(); + + if (gesture->gesture_events.num_pressed == 1) + { + pans->state = E_GESTURE_PAN_STATE_READY; + if (pans->start_timer) ecore_timer_del(pans->start_timer); + pans->start_timer = ecore_timer_add(E_GESTURE_PAN_START_TIME, _e_gesture_timer_pan_start, NULL); + } +} + +static void +_e_gesture_process_pan_move(Ecore_Event_Mouse_Move *ev) +{ + E_Gesture_Event_Pan *pans = &gesture->gesture_events.pans; + Coords cur_point = {0,}; + int idx, diff_x, diff_y, mode; + + if (gesture->gesture_events.recognized_gesture && + !((gesture->gesture_events.recognized_gesture & TIZEN_GESTURE_TYPE_PAN))) + _e_gesture_pan_cancel(); + + idx = gesture->gesture_events.num_pressed; + if (idx <= 0) return; + if (pans->state == E_GESTURE_PAN_STATE_READY) return; + + _e_gesture_util_center_axis_get(gesture->gesture_events.num_pressed, &cur_point.x, &cur_point.y); + + diff_x = cur_point.x - pans->center_point.x; + diff_y = cur_point.y - pans->center_point.y; + + if ((ABS(diff_x) > E_GESTURE_PAN_MOVING_RANGE) || (ABS(diff_y) > E_GESTURE_PAN_MOVING_RANGE)) + { + switch (pans->state) + { + case E_GESTURE_PAN_STATE_START: + mode = TIZEN_GESTURE_MODE_BEGIN; + pans->state = E_GESTURE_PAN_STATE_MOVING; + pans->num_pan_fingers = idx; + break; + case E_GESTURE_PAN_STATE_MOVING: + mode = TIZEN_GESTURE_MODE_UPDATE; + break; + default: + return; + } + + if (ABS(diff_x) > E_GESTURE_PAN_MOVING_RANGE) pans->center_point.x = cur_point.x; + if (ABS(diff_y) > E_GESTURE_PAN_MOVING_RANGE) pans->center_point.y = cur_point.y; + + _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; + } +} + +static void +_e_gesture_process_pan_up(Ecore_Event_Mouse_Button *ev) +{ + _e_gesture_pan_cancel(); +} + unsigned int e_gesture_util_tap_max_fingers_get(void) { @@ -755,6 +916,10 @@ _e_gesture_process_mouse_button_down(void *event) { _e_gesture_process_edge_swipe_down(ev); } + if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_PAN)) + { + _e_gesture_process_pan_down(ev); + } if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_TAP)) { _e_gesture_process_tap_down(ev); @@ -789,6 +954,10 @@ _e_gesture_process_mouse_button_up(void *event) { _e_gesture_process_edge_swipe_up(ev); } + if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_PAN)) + { + _e_gesture_process_pan_up(ev); + } if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_TAP)) { _e_gesture_process_tap_up(ev); @@ -828,19 +997,22 @@ _e_gesture_process_mouse_move(void *event) { return E_GESTURE_EVENT_STATE_PROPAGATE; } + if (gesture->gesture_events.base_point[ev->multi.device].pressed != EINA_TRUE) { return gesture->event_state; } - if (gesture->gesture_events.recognized_gesture) - { - return E_GESTURE_EVENT_STATE_IGNORE; - } + gesture->gesture_events.base_point[ev->multi.device].axis.x = ev->x; + gesture->gesture_events.base_point[ev->multi.device].axis.y = ev->y; if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_EDGE_SWIPE)) { _e_gesture_process_edge_swipe_move(ev); } + if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_PAN)) + { + _e_gesture_process_pan_move(ev); + } if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_TAP)) { _e_gesture_process_tap_move(ev); diff --git a/src/e_mod_main.c b/src/e_mod_main.c index 7f1a86e..4223b31 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -66,6 +66,82 @@ e_gesture_add_client_destroy_listener(struct wl_client *client, int mode EINA_UN return TIZEN_KEYROUTER_ERROR_NONE; } +static int +_e_gesture_grab_pan(struct wl_client *client, struct wl_resource *resource, uint32_t num_of_fingers) +{ + E_Gesture_Event *gev; + int ret = TIZEN_GESTURE_ERROR_NONE; + + GTINF("The client %p request to grab pan gesture, fingers: %d\n", client, num_of_fingers); + + if (num_of_fingers > E_GESTURE_FINGER_MAX) + { + GTWRN("Do not support %d fingers (max: %d)\n", num_of_fingers, E_GESTURE_FINGER_MAX); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto finish; + } + + gev = &gesture->gesture_events; + + if (gev->pans.fingers[num_of_fingers].client) + { + GTWRN("%d finger is already grabbed by %p client\n", num_of_fingers, gev->pans.fingers[num_of_fingers].client); + ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; + goto finish; + } + + gev->pans.fingers[num_of_fingers].client = client; + gev->pans.fingers[num_of_fingers].res = resource; + gev->pans.state = E_GESTURE_PAN_STATE_READY; + + gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_PAN; + gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; + +finish: + return ret; +} + +static int +_e_gesture_ungrab_pan(struct wl_client *client, struct wl_resource *resource, uint32_t num_of_fingers) +{ + int i; + E_Gesture_Event *gev; + int ret = TIZEN_GESTURE_ERROR_NONE; + + GTINF("The client %p request to ungrab pan gesture, fingers: %d\n", client, num_of_fingers); + + if (num_of_fingers > E_GESTURE_FINGER_MAX) + { + GTWRN("Do not support %d fingers (max: %d)\n", num_of_fingers, E_GESTURE_FINGER_MAX); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto finish; + } + + gev = &gesture->gesture_events; + + if (gev->pans.fingers[num_of_fingers].client == client) + { + gev->pans.fingers[num_of_fingers].client = NULL; + gev->pans.fingers[num_of_fingers].res = NULL; + } + + gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_TAP; + gev->pans.state = E_GESTURE_PAN_STATE_NONE; + + for (i = 0; i < E_GESTURE_FINGER_MAX; i++) + { + if (gev->pans.fingers[i].client) + { + gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_PAN; + gev->pans.state = E_GESTURE_PAN_STATE_READY; + break; + } + } + +finish: + return ret; +} + static void _e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int fingers, unsigned int edge) { @@ -392,11 +468,37 @@ finish: tizen_gesture_send_tap_notify(resource, fingers, repeats, ret); } +static void +_e_gesture_cb_grab_pan(struct wl_client *client, + struct wl_resource *resource, + uint32_t num_of_fingers) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_grab_pan(client, resource, num_of_fingers); + + tizen_gesture_send_pan_notify(resource, num_of_fingers, ret); +} + +static void +_e_gesture_cb_ungrab_pan(struct wl_client *client, + struct wl_resource *resource, + uint32_t num_of_fingers) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_ungrab_pan(client, resource, num_of_fingers); + + tizen_gesture_send_pan_notify(resource, num_of_fingers, ret); +} + static const struct tizen_gesture_interface _e_gesture_implementation = { _e_gesture_cb_grab_edge_swipe, _e_gesture_cb_ungrab_edge_swipe, _e_gesture_cb_grab_tap, - _e_gesture_cb_ungrab_tap + _e_gesture_cb_ungrab_tap, + _e_gesture_cb_grab_pan, + _e_gesture_cb_ungrab_pan, }; /* tizen_gesture global object destroy function */ diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 67fa909..2c1aec1 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -36,8 +36,13 @@ #define E_GESTURE_TAP_INTERVAL_TIME 1 #define E_GESTURE_TAP_MOVING_LANGE 25 +#define E_GESTURE_PAN_START_TIME 0.05 +#define E_GESTURE_PAN_MOVING_RANGE 15 + #define ABS(x) (((x)>0)?(x):-(x)) +#define RAD2DEG(x) ((x) * 57.295779513) + typedef struct _E_Gesture E_Gesture; typedef struct _E_Gesture* E_GesturePtr; typedef struct _E_Gesture_Event E_Gesture_Event; @@ -52,13 +57,17 @@ typedef struct _E_Gesture_Event_Tap_Finger_Repeats E_Gesture_Event_Tap_Finger_Re typedef struct _E_Gesture_Event_Tap_Finger E_Gesture_Event_Tap_Finger; typedef struct _E_Gesture_Event_Tap E_Gesture_Event_Tap; +typedef struct _E_Gesture_Event_Pan E_Gesture_Event_Pan; + typedef struct _Coords Coords; typedef struct _E_Gesture_Finger E_Gesture_Finger; typedef struct _E_Gesture_Event_Info E_Gesture_Event_Info; +typedef struct _E_Gesture_Event_Client E_Gesture_Event_Client; typedef enum _E_Gesture_Edge E_Gesture_Edge; typedef enum _E_Gesture_Event_State E_Gesture_Event_State; typedef enum _E_Gesture_Tap_State E_Gesture_Tap_State; +typedef enum _E_Gesture_Pan_State E_Gesture_Pan_State; extern E_GesturePtr gesture; @@ -91,6 +100,15 @@ enum _E_Gesture_Tap_State E_GESTURE_TAP_STATE_DONE }; +enum _E_Gesture_Pan_State +{ + E_GESTURE_PAN_STATE_NONE, + E_GESTURE_PAN_STATE_READY, + E_GESTURE_PAN_STATE_START, + E_GESTURE_PAN_STATE_MOVING, + E_GESTURE_PAN_STATE_DONE +}; + struct _Coords { int x, y; @@ -132,6 +150,12 @@ struct _E_Gesture_Config_Data E_Gesture_Conf_Edd *conf; }; +struct _E_Gesture_Event_Client +{ + struct wl_client *client; + struct wl_resource *res; +}; + struct _E_Gesture_Event_Edge_Swipe_Finger_Edge { struct wl_client *client; @@ -150,13 +174,13 @@ struct _E_Gesture_Grabbed_Client struct wl_client *client; struct wl_listener *destroy_listener; - E_Gesture_Event_Edge_Swipe_Finger edge_swipe_fingers[E_GESTURE_FINGER_MAX+1]; + E_Gesture_Event_Edge_Swipe_Finger edge_swipe_fingers[E_GESTURE_FINGER_MAX+2]; }; struct _E_Gesture_Event_Edge_Swipe { - E_Gesture_Event_Edge_Swipe_Finger fingers[E_GESTURE_FINGER_MAX+1]; + E_Gesture_Event_Edge_Swipe_Finger fingers[E_GESTURE_FINGER_MAX+2]; unsigned int edge; @@ -187,7 +211,7 @@ struct _E_Gesture_Event_Tap_Finger struct _E_Gesture_Event_Tap { - E_Gesture_Event_Tap_Finger fingers[E_GESTURE_FINGER_MAX+1]; + E_Gesture_Event_Tap_Finger fingers[E_GESTURE_FINGER_MAX+2]; E_Gesture_Tap_State state; unsigned int enabled_finger; unsigned int repeats; @@ -201,12 +225,26 @@ struct _E_Gesture_Event_Tap Ecore_Timer *interval_timer; }; +struct _E_Gesture_Event_Pan +{ + E_Gesture_Event_Client fingers[E_GESTURE_FINGER_MAX + 2]; + E_Gesture_Pan_State state; + Coords start_point; + Coords prev_point; + Coords center_point; + int num_pan_fingers; + + Ecore_Timer *start_timer; + Ecore_Timer *move_timer; +}; + struct _E_Gesture_Event { E_Gesture_Event_Edge_Swipe edge_swipes; E_Gesture_Event_Tap taps; + E_Gesture_Event_Pan pans; - E_Gesture_Finger base_point[E_GESTURE_FINGER_MAX + 1]; + E_Gesture_Finger base_point[E_GESTURE_FINGER_MAX+2]; int num_pressed; Eina_Bool recognized_gesture; -- 2.7.4 From 3dff3cc5bc619184c4c571bfe768e151f16307e0 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Fri, 12 May 2017 14:25:00 +0900 Subject: [PATCH 06/16] fix a incorrect typo lange to range Change-Id: I0d70b673d1a7bd62a80deb98483bce34456e7734 --- src/e_mod_gesture_events.c | 4 ++-- src/e_mod_main.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index 13109ad..41c9954 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -824,8 +824,8 @@ _e_gesture_process_tap_move(Ecore_Event_Mouse_Move *ev) diff_x = gesture->gesture_events.base_point[ev->multi.device].axis.x - ev->x; diff_y = gesture->gesture_events.base_point[ev->multi.device].axis.y - ev->y; - if (ABS(diff_x) > E_GESTURE_TAP_MOVING_LANGE || - ABS(diff_y) > E_GESTURE_TAP_MOVING_LANGE) + if (ABS(diff_x) > E_GESTURE_TAP_MOVING_RANGE || + ABS(diff_y) > E_GESTURE_TAP_MOVING_RANGE) { GTDBG("%d finger moving too large diff: (%d, %d)\n", ev->multi.device, diff_x, diff_y); _e_gesture_tap_cancel(); diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 2c1aec1..869a42d 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -34,7 +34,7 @@ #define E_GESTURE_TAP_START_TIME 0.05 #define E_GESTURE_TAP_DONE_TIME 1 #define E_GESTURE_TAP_INTERVAL_TIME 1 -#define E_GESTURE_TAP_MOVING_LANGE 25 +#define E_GESTURE_TAP_MOVING_RANGE 25 #define E_GESTURE_PAN_START_TIME 0.05 #define E_GESTURE_PAN_MOVING_RANGE 15 -- 2.7.4 From 12d69346b2adf902fcf87576d7c8c98cc61b0e2e Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Fri, 12 May 2017 14:31:24 +0900 Subject: [PATCH 07/16] fix a incorrect array usage - base_point's index is same as finger index. but currently 0 index is used to 1st finger. so fixed it to 1 index is used to 1st finger. Change-Id: I4f7f72837c07409c68b0609e59074907506739ab --- src/e_mod_gesture_events.c | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index 41c9954..6b92137 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -821,8 +821,8 @@ _e_gesture_process_tap_move(Ecore_Event_Mouse_Move *ev) { int diff_x, diff_y; - diff_x = gesture->gesture_events.base_point[ev->multi.device].axis.x - ev->x; - diff_y = gesture->gesture_events.base_point[ev->multi.device].axis.y - ev->y; + diff_x = gesture->gesture_events.base_point[ev->multi.device + 1].axis.x - ev->x; + diff_y = gesture->gesture_events.base_point[ev->multi.device + 1].axis.y - ev->y; if (ABS(diff_x) > E_GESTURE_TAP_MOVING_RANGE || ABS(diff_y) > E_GESTURE_TAP_MOVING_RANGE) @@ -895,9 +895,9 @@ _e_gesture_process_mouse_button_down(void *event) return E_GESTURE_EVENT_STATE_PROPAGATE; } - gesture->gesture_events.base_point[ev->multi.device].pressed = EINA_TRUE; - gesture->gesture_events.base_point[ev->multi.device].axis.x = ev->x; - gesture->gesture_events.base_point[ev->multi.device].axis.y = ev->y; + gesture->gesture_events.base_point[ev->multi.device + 1].pressed = EINA_TRUE; + gesture->gesture_events.base_point[ev->multi.device + 1].axis.x = ev->x; + gesture->gesture_events.base_point[ev->multi.device + 1].axis.y = ev->y; if (gesture->gesture_events.recognized_gesture) { @@ -946,9 +946,9 @@ _e_gesture_process_mouse_button_up(void *event) return E_GESTURE_EVENT_STATE_PROPAGATE; } - gesture->gesture_events.base_point[ev->multi.device].pressed = EINA_FALSE; - gesture->gesture_events.base_point[ev->multi.device].axis.x = 0; - gesture->gesture_events.base_point[ev->multi.device].axis.y = 0; + gesture->gesture_events.base_point[ev->multi.device + 1].pressed = EINA_FALSE; + gesture->gesture_events.base_point[ev->multi.device + 1].axis.x = 0; + gesture->gesture_events.base_point[ev->multi.device + 1].axis.y = 0; if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_EDGE_SWIPE)) { @@ -998,12 +998,12 @@ _e_gesture_process_mouse_move(void *event) return E_GESTURE_EVENT_STATE_PROPAGATE; } - if (gesture->gesture_events.base_point[ev->multi.device].pressed != EINA_TRUE) + if (gesture->gesture_events.base_point[ev->multi.device + 1].pressed != EINA_TRUE) { return gesture->event_state; } - gesture->gesture_events.base_point[ev->multi.device].axis.x = ev->x; - gesture->gesture_events.base_point[ev->multi.device].axis.y = ev->y; + gesture->gesture_events.base_point[ev->multi.device + 1].axis.x = ev->x; + gesture->gesture_events.base_point[ev->multi.device + 1].axis.y = ev->y; if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_EDGE_SWIPE)) { -- 2.7.4 From 7ec045ecdc0b80b3f578569bee15bbada91c62fd Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Fri, 12 May 2017 14:34:41 +0900 Subject: [PATCH 08/16] following EFL coding rule Change-Id: I9aa2fe6a89ca9ed247cfdab84ae01f1385bb1bb4 --- src/e_mod_main.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 869a42d..a8dc2ac 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -166,7 +166,7 @@ struct _E_Gesture_Event_Edge_Swipe_Finger { Coords start; Eina_Bool enabled; - E_Gesture_Event_Edge_Swipe_Finger_Edge edge[E_GESTURE_EDGE_MAX+1]; + E_Gesture_Event_Edge_Swipe_Finger_Edge edge[E_GESTURE_EDGE_MAX + 1]; }; struct _E_Gesture_Grabbed_Client @@ -174,13 +174,13 @@ struct _E_Gesture_Grabbed_Client struct wl_client *client; struct wl_listener *destroy_listener; - E_Gesture_Event_Edge_Swipe_Finger edge_swipe_fingers[E_GESTURE_FINGER_MAX+2]; + E_Gesture_Event_Edge_Swipe_Finger edge_swipe_fingers[E_GESTURE_FINGER_MAX + 2]; }; struct _E_Gesture_Event_Edge_Swipe { - E_Gesture_Event_Edge_Swipe_Finger fingers[E_GESTURE_FINGER_MAX+2]; + E_Gesture_Event_Edge_Swipe_Finger fingers[E_GESTURE_FINGER_MAX + 2]; unsigned int edge; @@ -206,12 +206,12 @@ struct _E_Gesture_Event_Tap_Finger { Eina_Bool enabled; unsigned int max_repeats; - E_Gesture_Event_Tap_Finger_Repeats repeats[E_GESTURE_TAP_REPEATS_MAX+1]; + E_Gesture_Event_Tap_Finger_Repeats repeats[E_GESTURE_TAP_REPEATS_MAX + 1]; }; struct _E_Gesture_Event_Tap { - E_Gesture_Event_Tap_Finger fingers[E_GESTURE_FINGER_MAX+2]; + E_Gesture_Event_Tap_Finger fingers[E_GESTURE_FINGER_MAX + 2]; E_Gesture_Tap_State state; unsigned int enabled_finger; unsigned int repeats; @@ -244,7 +244,7 @@ struct _E_Gesture_Event E_Gesture_Event_Tap taps; E_Gesture_Event_Pan pans; - E_Gesture_Finger base_point[E_GESTURE_FINGER_MAX+2]; + E_Gesture_Finger base_point[E_GESTURE_FINGER_MAX + 2]; int num_pressed; Eina_Bool recognized_gesture; -- 2.7.4 From 72eb2d480000846f0b6fad45c59bd4e97395b989 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Fri, 12 May 2017 14:35:31 +0900 Subject: [PATCH 09/16] cancel gestures if gesture is already recognized Change-Id: I50988ac4cec367349b8ef78a894ca46c222d46b4 --- src/e_mod_gesture_events.c | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index 6b92137..4bdcc1d 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -299,6 +299,9 @@ _e_gesture_process_edge_swipe_down(Ecore_Event_Mouse_Button *ev) int i; unsigned int idx = ev->multi.device+1; + if (gesture->gesture_events.recognized_gesture) + _e_gesture_edge_swipe_cancel(); + if (gesture->gesture_events.num_pressed == 1) { for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) @@ -777,6 +780,9 @@ _e_gesture_process_tap_down(Ecore_Event_Mouse_Button *ev) { E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + if (gesture->gesture_events.recognized_gesture) + _e_gesture_tap_cancel(); + if (taps->enabled_finger < gesture->gesture_events.num_pressed) taps->enabled_finger = gesture->gesture_events.num_pressed; @@ -821,6 +827,9 @@ _e_gesture_process_tap_move(Ecore_Event_Mouse_Move *ev) { int diff_x, diff_y; + if (gesture->gesture_events.recognized_gesture) + _e_gesture_tap_cancel(); + diff_x = gesture->gesture_events.base_point[ev->multi.device + 1].axis.x - ev->x; diff_y = gesture->gesture_events.base_point[ev->multi.device + 1].axis.y - ev->y; @@ -837,6 +846,9 @@ _e_gesture_process_tap_up(Ecore_Event_Mouse_Button *ev) { E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + if (gesture->gesture_events.recognized_gesture) + _e_gesture_tap_cancel(); + switch (taps->state) { case E_GESTURE_TAP_STATE_NONE: -- 2.7.4 From feaacced6d2d217fa095be8feae04d34af99b1e1 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Wed, 10 May 2017 20:59:07 +0900 Subject: [PATCH 10/16] Add a pinch gesture Change-Id: Ibb1c9e342cb44632cc7bb5ad8b9ac49143d3a648 --- src/e_mod_gesture_events.c | 216 ++++++++++++++++++++++++++++++++++++++++++--- src/e_mod_main.c | 108 ++++++++++++++++++++++- src/e_mod_main.h | 32 +++++-- 3 files changed, 335 insertions(+), 21 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index 4bdcc1d..fa2992d 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -473,13 +473,13 @@ _e_gesture_pan_cancel(void) pans->move_timer = NULL; } - if (pans->state == E_GESTURE_PAN_STATE_MOVING) + if (pans->state == E_GESTURE_PANPINCH_STATE_MOVING) _e_gesture_pan_send(TIZEN_GESTURE_MODE_END, pans->num_pan_fingers, 0, 0, pans->fingers[pans->num_pan_fingers].res, pans->fingers[pans->num_pan_fingers].client); gesture->gesture_filter |= TIZEN_GESTURE_TYPE_PAN; - pans->state = E_GESTURE_PAN_STATE_DONE; + pans->state = E_GESTURE_PANPINCH_STATE_DONE; } static void @@ -501,6 +501,50 @@ _e_gesture_util_center_axis_get(int num_finger, int *x, int *y) *y = calc_y; } +static int +_e_gesture_util_distance_get(int x1, int y1, int x2, int y2) +{ + int distance; + + distance = sqrt(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1))); + + return distance; +} + +static int +_e_gesture_util_distances_get(int num_finger) +{ + int i; + int cx = 0, cy = 0, distance = 0; + + _e_gesture_util_center_axis_get(num_finger, &cx, &cy); + + for (i = 1; i <= num_finger; i++) + { + distance += _e_gesture_util_distance_get(cx, cy, + gesture->gesture_events.base_point[i].axis.x, + gesture->gesture_events.base_point[i].axis.y); + } + + return distance; +} + +static double +_e_gesture_util_angle_get(int x1, int y1, int x2, int y2) +{ + double angle, xx, yy; + + xx = fabs(x2 - x1); + yy = fabs(y2 - y1); + + angle = atan2(yy, xx); + if ((x1 > x2) && (y1 > y2)) angle = angle + M_PI_2; + else if ((x2 > x1) && (y2 > y1)) angle = angle + M_PI_2; + + angle = RAD2DEG(angle); + return angle; +} + static Eina_Bool _e_gesture_timer_pan_start(void *data) { @@ -517,7 +561,7 @@ _e_gesture_timer_pan_start(void *data) } pans->center_point.x = pans->start_point.x = (int)(pans->start_point.x / num_pressed); pans->center_point.y = pans->start_point.y = (int)(pans->start_point.y / num_pressed); - pans->state = E_GESTURE_PAN_STATE_START; + pans->state = E_GESTURE_PANPINCH_STATE_START; } else { @@ -532,12 +576,13 @@ _e_gesture_process_pan_down(Ecore_Event_Mouse_Button *ev) E_Gesture_Event_Pan *pans = &gesture->gesture_events.pans; if (gesture->gesture_events.recognized_gesture && - !((gesture->gesture_events.recognized_gesture & TIZEN_GESTURE_TYPE_PAN))) + !((gesture->gesture_events.recognized_gesture & TIZEN_GESTURE_TYPE_PAN) || + (gesture->gesture_events.recognized_gesture & TIZEN_GESTURE_TYPE_PINCH))) _e_gesture_pan_cancel(); if (gesture->gesture_events.num_pressed == 1) { - pans->state = E_GESTURE_PAN_STATE_READY; + pans->state = E_GESTURE_PANPINCH_STATE_READY; if (pans->start_timer) ecore_timer_del(pans->start_timer); pans->start_timer = ecore_timer_add(E_GESTURE_PAN_START_TIME, _e_gesture_timer_pan_start, NULL); } @@ -551,12 +596,13 @@ _e_gesture_process_pan_move(Ecore_Event_Mouse_Move *ev) int idx, diff_x, diff_y, mode; if (gesture->gesture_events.recognized_gesture && - !((gesture->gesture_events.recognized_gesture & TIZEN_GESTURE_TYPE_PAN))) + !((gesture->gesture_events.recognized_gesture & TIZEN_GESTURE_TYPE_PAN) || + (gesture->gesture_events.recognized_gesture & TIZEN_GESTURE_TYPE_PINCH))) _e_gesture_pan_cancel(); idx = gesture->gesture_events.num_pressed; if (idx <= 0) return; - if (pans->state == E_GESTURE_PAN_STATE_READY) return; + if (pans->state == E_GESTURE_PANPINCH_STATE_READY) return; _e_gesture_util_center_axis_get(gesture->gesture_events.num_pressed, &cur_point.x, &cur_point.y); @@ -567,12 +613,12 @@ _e_gesture_process_pan_move(Ecore_Event_Mouse_Move *ev) { switch (pans->state) { - case E_GESTURE_PAN_STATE_START: + case E_GESTURE_PANPINCH_STATE_START: mode = TIZEN_GESTURE_MODE_BEGIN; - pans->state = E_GESTURE_PAN_STATE_MOVING; + pans->state = E_GESTURE_PANPINCH_STATE_MOVING; pans->num_pan_fingers = idx; break; - case E_GESTURE_PAN_STATE_MOVING: + case E_GESTURE_PANPINCH_STATE_MOVING: mode = TIZEN_GESTURE_MODE_UPDATE; break; default: @@ -595,6 +641,144 @@ _e_gesture_process_pan_up(Ecore_Event_Mouse_Button *ev) _e_gesture_pan_cancel(); } +static void +_e_gesture_pinch_send(int mode, int fingers, int distance, int angle, int cx, int cy, struct wl_resource *res, struct wl_client *client) +{ + Ecore_Event_Mouse_Button *ev_cancel; + + if (mode == TIZEN_GESTURE_MODE_BEGIN) + { + ev_cancel = E_NEW(Ecore_Event_Mouse_Button, 1); + EINA_SAFETY_ON_NULL_RETURN(ev_cancel); + + ev_cancel->timestamp = (int)(ecore_time_get()*1000); + ev_cancel->same_screen = 1; + + ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, ev_cancel, NULL, NULL); + } + + GTINF("Send pinch gesture (fingers: %d, distance: %d, angle: %d, cx: %d, cy: %d) to client: %p, mode: %d\n", fingers, distance, angle, cx, cy, client, mode); + + tizen_gesture_send_pinch(res, mode, fingers, distance, angle, cx, cy); + + gesture->gesture_events.recognized_gesture |= TIZEN_GESTURE_TYPE_PINCH; +} + +static void +_e_gesture_pinch_cancel(void) +{ + E_Gesture_Event_Pinch *pinchs = &gesture->gesture_events.pinchs; + + if (pinchs->start_timer) + { + ecore_timer_del(pinchs->start_timer); + pinchs->start_timer = NULL; + } + if (pinchs->move_timer) + { + ecore_timer_del(pinchs->move_timer); + pinchs->move_timer = NULL; + } + + if (pinchs->state == E_GESTURE_PANPINCH_STATE_MOVING) + _e_gesture_pinch_send(TIZEN_GESTURE_MODE_END, pinchs->num_pinch_fingers, 0, 0, 0, 0, + pinchs->fingers[pinchs->num_pinch_fingers].res, + pinchs->fingers[pinchs->num_pinch_fingers].client); + + gesture->gesture_filter |= TIZEN_GESTURE_TYPE_PINCH; + pinchs->state = E_GESTURE_PANPINCH_STATE_DONE; +} + +static Eina_Bool +_e_gesture_timer_pinch_start(void *data) +{ + E_Gesture_Event_Pinch *pinch = &gesture->gesture_events.pinchs; + int num_pressed = gesture->gesture_events.num_pressed; + + if (pinch->fingers[num_pressed].client) + { + pinch->distance = _e_gesture_util_distances_get(num_pressed); + pinch->state = E_GESTURE_PANPINCH_STATE_START; + } + else + { + _e_gesture_pinch_cancel(); + } + return ECORE_CALLBACK_CANCEL; +} + +static void +_e_gesture_process_pinch_down(Ecore_Event_Mouse_Button *ev) +{ + E_Gesture_Event_Pinch *pinch = &gesture->gesture_events.pinchs; + + if (gesture->gesture_events.recognized_gesture && + !((gesture->gesture_events.recognized_gesture & TIZEN_GESTURE_TYPE_PAN) || + (gesture->gesture_events.recognized_gesture & TIZEN_GESTURE_TYPE_PINCH))) + _e_gesture_pinch_cancel(); + + if (gesture->gesture_events.num_pressed == 1) + { + pinch->state = E_GESTURE_PANPINCH_STATE_READY; + if (pinch->start_timer) ecore_timer_del(pinch->start_timer); + pinch->start_timer = ecore_timer_add(E_GESTURE_PAN_START_TIME, _e_gesture_timer_pinch_start, NULL); + } +} + +static void +_e_gesture_process_pinch_move(Ecore_Event_Mouse_Move *ev) +{ + E_Gesture_Event_Pinch *pinch = &gesture->gesture_events.pinchs; + int idx, current_distance, mode, diff, angle, cx = 0, cy = 0; + + if (gesture->gesture_events.recognized_gesture && + !((gesture->gesture_events.recognized_gesture & TIZEN_GESTURE_TYPE_PAN) || + (gesture->gesture_events.recognized_gesture & TIZEN_GESTURE_TYPE_PINCH))) + _e_gesture_pan_cancel(); + + idx = gesture->gesture_events.num_pressed; + if (idx <= 0) return; + if (pinch->state == E_GESTURE_PANPINCH_STATE_READY) return; + + current_distance = _e_gesture_util_distances_get(idx); + diff = current_distance - pinch->distance; + + if (ABS(diff) > E_GESTURE_PINCH_MOVING_DISTANCE_RANGE) + { + pinch->distance = current_distance; + switch (pinch->state) + { + case E_GESTURE_PANPINCH_STATE_START: + mode = TIZEN_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; + break; + default: + return; + } + + if (idx == 2) angle = _e_gesture_util_angle_get(gesture->gesture_events.base_point[1].axis.x, + gesture->gesture_events.base_point[1].axis.y, + gesture->gesture_events.base_point[2].axis.x, + gesture->gesture_events.base_point[2].axis.y); + else angle = 0; + + _e_gesture_util_center_axis_get(idx, &cx, &cy); + + _e_gesture_pinch_send(mode, idx, pinch->distance, angle, cx, cy, pinch->fingers[idx].res, pinch->fingers[idx].client); + } +} + +static void +_e_gesture_process_pinch_up(Ecore_Event_Mouse_Button *ev) +{ + _e_gesture_pinch_cancel(); +} + + unsigned int e_gesture_util_tap_max_fingers_get(void) { @@ -932,6 +1116,10 @@ _e_gesture_process_mouse_button_down(void *event) { _e_gesture_process_pan_down(ev); } + if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_PINCH)) + { + _e_gesture_process_pinch_down(ev); + } if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_TAP)) { _e_gesture_process_tap_down(ev); @@ -970,6 +1158,10 @@ _e_gesture_process_mouse_button_up(void *event) { _e_gesture_process_pan_up(ev); } + if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_PINCH)) + { + _e_gesture_process_pinch_up(ev); + } if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_TAP)) { _e_gesture_process_tap_up(ev); @@ -1025,6 +1217,10 @@ _e_gesture_process_mouse_move(void *event) { _e_gesture_process_pan_move(ev); } + if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_PINCH)) + { + _e_gesture_process_pinch_move(ev); + } if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_TAP)) { _e_gesture_process_tap_move(ev); diff --git a/src/e_mod_main.c b/src/e_mod_main.c index 4223b31..627f303 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -92,7 +92,7 @@ _e_gesture_grab_pan(struct wl_client *client, struct wl_resource *resource, uint gev->pans.fingers[num_of_fingers].client = client; gev->pans.fingers[num_of_fingers].res = resource; - gev->pans.state = E_GESTURE_PAN_STATE_READY; + gev->pans.state = E_GESTURE_PANPINCH_STATE_READY; gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_PAN; gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; @@ -126,14 +126,90 @@ _e_gesture_ungrab_pan(struct wl_client *client, struct wl_resource *resource, ui } gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_TAP; - gev->pans.state = E_GESTURE_PAN_STATE_NONE; + gev->pans.state = E_GESTURE_PANPINCH_STATE_NONE; for (i = 0; i < E_GESTURE_FINGER_MAX; i++) { if (gev->pans.fingers[i].client) { gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_PAN; - gev->pans.state = E_GESTURE_PAN_STATE_READY; + gev->pans.state = E_GESTURE_PANPINCH_STATE_READY; + break; + } + } + +finish: + return ret; +} + +static int +_e_gesture_grab_pinch(struct wl_client *client, struct wl_resource *resource, uint32_t num_of_fingers) +{ + E_Gesture_Event *gev; + int ret = TIZEN_GESTURE_ERROR_NONE; + + GTINF("The client %p request to grab pinch gesture, fingers: %d\n", client, num_of_fingers); + + if (num_of_fingers > E_GESTURE_FINGER_MAX) + { + GTWRN("Do not support %d fingers (max: %d)\n", num_of_fingers, E_GESTURE_FINGER_MAX); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto finish; + } + + gev = &gesture->gesture_events; + + if (gev->pinchs.fingers[num_of_fingers].client) + { + GTWRN("%d finger is already grabbed by %p client\n", num_of_fingers, gev->pinchs.fingers[num_of_fingers].client); + ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; + goto finish; + } + + gev->pinchs.fingers[num_of_fingers].client = client; + gev->pinchs.fingers[num_of_fingers].res = resource; + + gev->pinchs.state = E_GESTURE_PANPINCH_STATE_READY; + gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_PINCH; + gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; + +finish: + return ret; +} + +static int +_e_gesture_ungrab_pinch(struct wl_client *client, struct wl_resource *resource, uint32_t num_of_fingers) +{ + int i; + E_Gesture_Event *gev; + int ret = TIZEN_GESTURE_ERROR_NONE; + + GTINF("The client %p request to ungrab pinch gesture, fingers: %d\n", client, num_of_fingers); + + if (num_of_fingers > E_GESTURE_FINGER_MAX) + { + GTWRN("Do not support %d fingers (max: %d)\n", num_of_fingers, E_GESTURE_FINGER_MAX); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto finish; + } + + gev = &gesture->gesture_events; + + if (gev->pinchs.fingers[num_of_fingers].client == client) + { + gev->pinchs.fingers[num_of_fingers].client = NULL; + gev->pinchs.fingers[num_of_fingers].res = NULL; + } + + gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_PINCH; + gev->pinchs.state = E_GESTURE_PANPINCH_STATE_NONE; + + for (i = 0; i < E_GESTURE_FINGER_MAX; i++) + { + if (gev->pinchs.fingers[i].client) + { + gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_PINCH; + gev->pinchs.state = E_GESTURE_PANPINCH_STATE_READY; break; } } @@ -492,6 +568,30 @@ _e_gesture_cb_ungrab_pan(struct wl_client *client, tizen_gesture_send_pan_notify(resource, num_of_fingers, ret); } +static void +_e_gesture_cb_grab_pinch(struct wl_client *client, + struct wl_resource *resource, + uint32_t num_of_fingers) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_grab_pinch(client, resource, num_of_fingers); + + tizen_gesture_send_pinch_notify(resource, num_of_fingers, ret); +} + +static void +_e_gesture_cb_ungrab_pinch(struct wl_client *client, + struct wl_resource *resource, + uint32_t num_of_fingers) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_ungrab_pinch(client, resource, num_of_fingers); + + tizen_gesture_send_pinch_notify(resource, num_of_fingers, ret); +} + static const struct tizen_gesture_interface _e_gesture_implementation = { _e_gesture_cb_grab_edge_swipe, _e_gesture_cb_ungrab_edge_swipe, @@ -499,6 +599,8 @@ static const struct tizen_gesture_interface _e_gesture_implementation = { _e_gesture_cb_ungrab_tap, _e_gesture_cb_grab_pan, _e_gesture_cb_ungrab_pan, + _e_gesture_cb_grab_pinch, + _e_gesture_cb_ungrab_pinch }; /* tizen_gesture global object destroy function */ diff --git a/src/e_mod_main.h b/src/e_mod_main.h index a8dc2ac..4564713 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -39,6 +39,8 @@ #define E_GESTURE_PAN_START_TIME 0.05 #define E_GESTURE_PAN_MOVING_RANGE 15 +#define E_GESTURE_PINCH_MOVING_DISTANCE_RANGE 15 + #define ABS(x) (((x)>0)?(x):-(x)) #define RAD2DEG(x) ((x) * 57.295779513) @@ -59,6 +61,8 @@ typedef struct _E_Gesture_Event_Tap E_Gesture_Event_Tap; typedef struct _E_Gesture_Event_Pan E_Gesture_Event_Pan; +typedef struct _E_Gesture_Event_Pinch E_Gesture_Event_Pinch; + typedef struct _Coords Coords; typedef struct _E_Gesture_Finger E_Gesture_Finger; typedef struct _E_Gesture_Event_Info E_Gesture_Event_Info; @@ -67,7 +71,7 @@ typedef struct _E_Gesture_Event_Client E_Gesture_Event_Client; typedef enum _E_Gesture_Edge E_Gesture_Edge; typedef enum _E_Gesture_Event_State E_Gesture_Event_State; typedef enum _E_Gesture_Tap_State E_Gesture_Tap_State; -typedef enum _E_Gesture_Pan_State E_Gesture_Pan_State; +typedef enum _E_Gesture_PanPinch_State E_Gesture_PanPinch_State; extern E_GesturePtr gesture; @@ -100,13 +104,13 @@ enum _E_Gesture_Tap_State E_GESTURE_TAP_STATE_DONE }; -enum _E_Gesture_Pan_State +enum _E_Gesture_PanPinch_State { - E_GESTURE_PAN_STATE_NONE, - E_GESTURE_PAN_STATE_READY, - E_GESTURE_PAN_STATE_START, - E_GESTURE_PAN_STATE_MOVING, - E_GESTURE_PAN_STATE_DONE + E_GESTURE_PANPINCH_STATE_NONE, + E_GESTURE_PANPINCH_STATE_READY, + E_GESTURE_PANPINCH_STATE_START, + E_GESTURE_PANPINCH_STATE_MOVING, + E_GESTURE_PANPINCH_STATE_DONE }; struct _Coords @@ -228,7 +232,7 @@ struct _E_Gesture_Event_Tap struct _E_Gesture_Event_Pan { E_Gesture_Event_Client fingers[E_GESTURE_FINGER_MAX + 2]; - E_Gesture_Pan_State state; + E_Gesture_PanPinch_State state; Coords start_point; Coords prev_point; Coords center_point; @@ -238,11 +242,23 @@ struct _E_Gesture_Event_Pan Ecore_Timer *move_timer; }; +struct _E_Gesture_Event_Pinch +{ + E_Gesture_Event_Client fingers[E_GESTURE_FINGER_MAX + 2]; + E_Gesture_PanPinch_State state; + int distance; + int num_pinch_fingers; + + Ecore_Timer *start_timer; + Ecore_Timer *move_timer; +}; + struct _E_Gesture_Event { E_Gesture_Event_Edge_Swipe edge_swipes; E_Gesture_Event_Tap taps; E_Gesture_Event_Pan pans; + E_Gesture_Event_Pinch pinchs; E_Gesture_Finger base_point[E_GESTURE_FINGER_MAX + 2]; -- 2.7.4 From 57ca3af43330e81fd40925454fc8f0706aea843f Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Mon, 15 May 2017 16:14:25 +0900 Subject: [PATCH 11/16] change pinch event's arguments - change distance and angle's type int to double Change-Id: If3e9b0896fe643b7a2678cdcf89cf9de1c54e18d --- src/e_mod_gesture_events.c | 27 ++++++++++++++++----------- src/e_mod_main.h | 4 ++-- 2 files changed, 18 insertions(+), 13 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index fa2992d..fc8df1e 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -501,21 +501,21 @@ _e_gesture_util_center_axis_get(int num_finger, int *x, int *y) *y = calc_y; } -static int +static double _e_gesture_util_distance_get(int x1, int y1, int x2, int y2) { - int distance; + double distance; distance = sqrt(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1))); return distance; } -static int +static double _e_gesture_util_distances_get(int num_finger) { - int i; - int cx = 0, cy = 0, distance = 0; + int i, cx = 0, cy = 0; + double distance = 0.0; _e_gesture_util_center_axis_get(num_finger, &cx, &cy); @@ -642,9 +642,10 @@ _e_gesture_process_pan_up(Ecore_Event_Mouse_Button *ev) } static void -_e_gesture_pinch_send(int mode, int fingers, int distance, int angle, int cx, int cy, struct wl_resource *res, struct wl_client *client) +_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; + wl_fixed_t distance_fixed, angle_fixed; if (mode == TIZEN_GESTURE_MODE_BEGIN) { @@ -657,9 +658,12 @@ _e_gesture_pinch_send(int mode, int fingers, int distance, int angle, int cx, in ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, ev_cancel, NULL, NULL); } - GTINF("Send pinch gesture (fingers: %d, distance: %d, angle: %d, cx: %d, cy: %d) to client: %p, mode: %d\n", fingers, distance, angle, cx, cy, client, mode); + 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); + + distance_fixed = wl_fixed_from_double(distance); + angle_fixed = wl_fixed_from_double(angle); - tizen_gesture_send_pinch(res, mode, fingers, distance, angle, cx, cy); + tizen_gesture_send_pinch(res, mode, fingers, distance_fixed, angle_fixed, cx, cy); gesture->gesture_events.recognized_gesture |= TIZEN_GESTURE_TYPE_PINCH; } @@ -681,7 +685,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, + _e_gesture_pinch_send(TIZEN_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); @@ -729,7 +733,8 @@ static void _e_gesture_process_pinch_move(Ecore_Event_Mouse_Move *ev) { E_Gesture_Event_Pinch *pinch = &gesture->gesture_events.pinchs; - int idx, current_distance, mode, diff, angle, cx = 0, cy = 0; + int idx, mode, cx = 0, cy = 0; + double current_distance = 0.0, diff = 0.0, angle = 0.0; if (gesture->gesture_events.recognized_gesture && !((gesture->gesture_events.recognized_gesture & TIZEN_GESTURE_TYPE_PAN) || @@ -764,7 +769,7 @@ _e_gesture_process_pinch_move(Ecore_Event_Mouse_Move *ev) gesture->gesture_events.base_point[1].axis.y, gesture->gesture_events.base_point[2].axis.x, gesture->gesture_events.base_point[2].axis.y); - else angle = 0; + else angle = 0.0; _e_gesture_util_center_axis_get(idx, &cx, &cy); diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 4564713..3e99b21 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -39,7 +39,7 @@ #define E_GESTURE_PAN_START_TIME 0.05 #define E_GESTURE_PAN_MOVING_RANGE 15 -#define E_GESTURE_PINCH_MOVING_DISTANCE_RANGE 15 +#define E_GESTURE_PINCH_MOVING_DISTANCE_RANGE 15.0 #define ABS(x) (((x)>0)?(x):-(x)) @@ -246,7 +246,7 @@ struct _E_Gesture_Event_Pinch { E_Gesture_Event_Client fingers[E_GESTURE_FINGER_MAX + 2]; E_Gesture_PanPinch_State state; - int distance; + double distance; int num_pinch_fingers; Ecore_Timer *start_timer; -- 2.7.4 From cdf6b301724fe005d6fe02d8cd3bd1c049c117da Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Tue, 21 Feb 2017 11:17:33 +0900 Subject: [PATCH 12/16] Control client lifecycle about tap, pan and pinch gesture Change-Id: Id3ce7bdd64ec398bbe962f84cde1a8f372c10f94 --- src/e_mod_main.c | 525 ++++++++++++++++++++++++++++++++++++++----------------- src/e_mod_main.h | 21 ++- 2 files changed, 378 insertions(+), 168 deletions(-) diff --git a/src/e_mod_main.c b/src/e_mod_main.c index 627f303..491fef1 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -11,21 +11,38 @@ static void _e_gesture_init_handlers(void); static void _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data); static void -_e_gesture_edge_swipe_set_client_to_list(struct wl_client *client, E_Gesture_Event_Edge_Swipe_Finger *fingers, unsigned int edge) +_e_gesture_set_client_to_list(E_Gesture_Grabbed_Client *gclient, struct wl_client *client, int mode, int fingers, int edge, int repeat) { - if (edge & TIZEN_GESTURE_EDGE_TOP) - fingers->edge[E_GESTURE_EDGE_TOP].client = client; - if (edge & TIZEN_GESTURE_EDGE_RIGHT) - fingers->edge[E_GESTURE_EDGE_RIGHT].client = client; - if (edge & TIZEN_GESTURE_EDGE_BOTTOM) - fingers->edge[E_GESTURE_EDGE_BOTTOM].client = client; - if (edge & TIZEN_GESTURE_EDGE_LEFT) - fingers->edge[E_GESTURE_EDGE_LEFT].client = client; + switch (mode) + { + case TIZEN_GESTURE_TYPE_EDGE_SWIPE: + if (edge & TIZEN_GESTURE_EDGE_TOP) + gclient->edge_swipe_fingers[fingers].edge[E_GESTURE_EDGE_TOP].client = client; + if (edge & TIZEN_GESTURE_EDGE_RIGHT) + gclient->edge_swipe_fingers[fingers].edge[E_GESTURE_EDGE_RIGHT].client = client; + if (edge & TIZEN_GESTURE_EDGE_BOTTOM) + gclient->edge_swipe_fingers[fingers].edge[E_GESTURE_EDGE_BOTTOM].client = client; + if (edge & TIZEN_GESTURE_EDGE_LEFT) + gclient->edge_swipe_fingers[fingers].edge[E_GESTURE_EDGE_LEFT].client = client; + break; + case TIZEN_GESTURE_TYPE_TAP: + gclient->tap_fingers[fingers].repeats[repeat].client = client; + break; + case TIZEN_GESTURE_TYPE_PAN: + gclient->pan_fingers[fingers].client = client; + break; + case TIZEN_GESTURE_TYPE_PINCH: + gclient->pinch_fingers[fingers].client = client; + break; + default: + return; + } + gclient->grabbed_gesture |= mode; } /* Function for registering wl_client destroy listener */ int -e_gesture_add_client_destroy_listener(struct wl_client *client, int mode EINA_UNUSED, int fingers, unsigned int edge) +e_gesture_add_client_destroy_listener(struct wl_client *client, int mode, int fingers, unsigned int edge, unsigned int repeat) { struct wl_listener *destroy_listener = NULL; Eina_List *l; @@ -35,7 +52,7 @@ e_gesture_add_client_destroy_listener(struct wl_client *client, int mode EINA_UN { if (data->client == client) { - _e_gesture_edge_swipe_set_client_to_list(client, &data->edge_swipe_fingers[fingers], edge); + _e_gesture_set_client_to_list(data, client, mode, fingers, edge, repeat); return TIZEN_GESTURE_ERROR_NONE; } @@ -59,39 +76,220 @@ e_gesture_add_client_destroy_listener(struct wl_client *client, int mode EINA_UN wl_client_add_destroy_listener(client, destroy_listener); grabbed_client->client = client; grabbed_client->destroy_listener = destroy_listener; - _e_gesture_edge_swipe_set_client_to_list(client, &grabbed_client->edge_swipe_fingers[fingers], edge); + _e_gesture_set_client_to_list(grabbed_client, client, mode, fingers, edge, repeat); gesture->grab_client_list = eina_list_append(gesture->grab_client_list, grabbed_client); return TIZEN_KEYROUTER_ERROR_NONE; } +static void +_e_gesture_edge_swipe_current_list_check(void) +{ + int i, j; + E_Gesture_Event *gev; + + gev = &gesture->gesture_events; + for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) + { + for (j = 0; j < E_GESTURE_EDGE_MAX+1; j++) + { + if (gev->edge_swipes.fingers[i].edge[j].client) + { + return; + } + } + gev->edge_swipes.fingers[i].enabled = EINA_FALSE; + } + gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_EDGE_SWIPE; + if (gev->edge_swipes.event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE; +} + +static void +_e_gesture_tap_current_list_check(void) +{ + int i; + E_Gesture_Event *gev; + + gev = &gesture->gesture_events; + + gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_TAP; + gev->taps.state = E_GESTURE_TAP_STATE_NONE; + gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE; + for (i = 0; i < E_GESTURE_FINGER_MAX; i++) + { + if (gev->taps.fingers[i].enabled) + { + gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_TAP; + gev->taps.state = E_GESTURE_TAP_STATE_READY; + gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; + break; + } + } + + gev->taps.max_fingers = e_gesture_util_tap_max_fingers_get(); +} + +static void +_e_gesture_pan_current_list_check(void) +{ + int i; + E_Gesture_Event *gev; + + gev = &gesture->gesture_events; + + gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_TAP; + gev->pans.state = E_GESTURE_PANPINCH_STATE_NONE; + + for (i = 0; i < E_GESTURE_FINGER_MAX; i++) + { + if (gev->pans.fingers[i].client) + { + gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_PAN; + gev->pans.state = E_GESTURE_PANPINCH_STATE_READY; + break; + } + } +} + +static void +_e_gesture_pinch_current_list_check(void) +{ + int i; + E_Gesture_Event *gev; + + gev = &gesture->gesture_events; + + gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_PINCH; + gev->pinchs.state = E_GESTURE_PANPINCH_STATE_NONE; + + for (i = 0; i < E_GESTURE_FINGER_MAX; i++) + { + if (gev->pinchs.fingers[i].client) + { + gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_PINCH; + gev->pinchs.state = E_GESTURE_PANPINCH_STATE_READY; + break; + } + } +} + +static void +_e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int mode, unsigned int fingers, unsigned int edge, unsigned int repeat) +{ + Eina_List *l, *l_next; + E_Gesture_Grabbed_Client *data; + int i, j; + + EINA_LIST_FOREACH_SAFE(gesture->grab_client_list, l, l_next, data) + { + if (data->client == client) + { + if ((mode & TIZEN_GESTURE_TYPE_EDGE_SWIPE) && + (data->grabbed_gesture & TIZEN_GESTURE_TYPE_EDGE_SWIPE)) + { + _e_gesture_set_client_to_list(data, NULL, TIZEN_GESTURE_TYPE_EDGE_SWIPE, fingers, edge, 0); + data->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_EDGE_SWIPE; + for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) + { + if (data->edge_swipe_fingers[i].edge[E_GESTURE_EDGE_TOP].client || + data->edge_swipe_fingers[i].edge[E_GESTURE_EDGE_RIGHT].client || + data->edge_swipe_fingers[i].edge[E_GESTURE_EDGE_BOTTOM].client || + data->edge_swipe_fingers[i].edge[E_GESTURE_EDGE_LEFT].client) + { + data->grabbed_gesture |= TIZEN_GESTURE_TYPE_EDGE_SWIPE; + break; + } + } + } + + if ((mode & TIZEN_GESTURE_TYPE_TAP) && + (data->grabbed_gesture & TIZEN_GESTURE_TYPE_TAP)) + { + _e_gesture_set_client_to_list(data, NULL, TIZEN_GESTURE_TYPE_TAP, fingers, 0, repeat); + data->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_TAP; + for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) + { + for (j = 0; j < E_GESTURE_TAP_REPEATS_MAX + 1; j++) + { + if (data->tap_fingers[i].repeats[j].client) + { + data->grabbed_gesture |= TIZEN_GESTURE_TYPE_TAP; + break; + } + } + } + } + + if ((mode & TIZEN_GESTURE_TYPE_PAN) && + (data->grabbed_gesture & TIZEN_GESTURE_TYPE_PAN)) + { + _e_gesture_set_client_to_list(data, NULL, TIZEN_GESTURE_TYPE_PAN, fingers, 0, 0); + data->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_PAN; + for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) + { + if (data->pan_fingers[i].client) + { + data->grabbed_gesture |= TIZEN_GESTURE_TYPE_PAN; + break; + } + } + } + + if ((mode & TIZEN_GESTURE_TYPE_PINCH) && + (data->grabbed_gesture & TIZEN_GESTURE_TYPE_PINCH)) + { + _e_gesture_set_client_to_list(data, NULL, TIZEN_GESTURE_TYPE_PINCH, fingers, 0, 0); + data->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_PINCH; + for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) + { + if (data->pan_fingers[i].client) + { + data->grabbed_gesture |= TIZEN_GESTURE_TYPE_PINCH; + break; + } + } + } + + if (!data->grabbed_gesture) + { + wl_list_remove(&data->destroy_listener->link); + E_FREE(data->destroy_listener); + gesture->grab_client_list = eina_list_remove(gesture->grab_client_list, data); + E_FREE(data); + } + } + } +} + static int -_e_gesture_grab_pan(struct wl_client *client, struct wl_resource *resource, uint32_t num_of_fingers) +_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; - GTINF("The client %p request to grab pan gesture, fingers: %d\n", client, num_of_fingers); + GTINF("The client %p request to grab pan gesture, fingers: %d\n", client, fingers); - if (num_of_fingers > E_GESTURE_FINGER_MAX) + if (fingers > E_GESTURE_FINGER_MAX) { - GTWRN("Do not support %d fingers (max: %d)\n", num_of_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; } gev = &gesture->gesture_events; - if (gev->pans.fingers[num_of_fingers].client) + if (gev->pans.fingers[fingers].client) { - GTWRN("%d finger is already grabbed by %p client\n", num_of_fingers, gev->pans.fingers[num_of_fingers].client); + GTWRN("%d finger is already grabbed by %p client\n", fingers, gev->pans.fingers[fingers].client); ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; goto finish; } - gev->pans.fingers[num_of_fingers].client = client; - gev->pans.fingers[num_of_fingers].res = resource; + e_gesture_add_client_destroy_listener(client, TIZEN_GESTURE_TYPE_PAN, fingers, 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 |= TIZEN_GESTURE_TYPE_PAN; @@ -102,72 +300,63 @@ finish: } static int -_e_gesture_ungrab_pan(struct wl_client *client, struct wl_resource *resource, uint32_t num_of_fingers) +_e_gesture_ungrab_pan(struct wl_client *client, struct wl_resource *resource, uint32_t fingers) { - int i; E_Gesture_Event *gev; int ret = TIZEN_GESTURE_ERROR_NONE; - GTINF("The client %p request to ungrab pan gesture, fingers: %d\n", client, num_of_fingers); + GTINF("The client %p request to ungrab pan gesture, fingers: %d\n", client, fingers); - if (num_of_fingers > E_GESTURE_FINGER_MAX) + if (fingers > E_GESTURE_FINGER_MAX) { - GTWRN("Do not support %d fingers (max: %d)\n", num_of_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; } gev = &gesture->gesture_events; - if (gev->pans.fingers[num_of_fingers].client == client) + if (gev->pans.fingers[fingers].client == client) { - gev->pans.fingers[num_of_fingers].client = NULL; - gev->pans.fingers[num_of_fingers].res = NULL; + gev->pans.fingers[fingers].client = NULL; + gev->pans.fingers[fingers].res = NULL; } - gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_TAP; - gev->pans.state = E_GESTURE_PANPINCH_STATE_NONE; - - for (i = 0; i < E_GESTURE_FINGER_MAX; i++) - { - if (gev->pans.fingers[i].client) - { - gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_PAN; - gev->pans.state = E_GESTURE_PANPINCH_STATE_READY; - break; - } - } + _e_gesture_remove_client_destroy_listener(client, TIZEN_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 num_of_fingers) +_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, num_of_fingers); + GTINF("The client %p request to grab pinch gesture, fingers: %d\n", client, fingers); - if (num_of_fingers > E_GESTURE_FINGER_MAX) + if (fingers > E_GESTURE_FINGER_MAX) { - GTWRN("Do not support %d fingers (max: %d)\n", num_of_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; } gev = &gesture->gesture_events; - if (gev->pinchs.fingers[num_of_fingers].client) + if (gev->pinchs.fingers[fingers].client) { - GTWRN("%d finger is already grabbed by %p client\n", num_of_fingers, gev->pinchs.fingers[num_of_fingers].client); + GTWRN("%d finger is already grabbed by %p client\n", fingers, gev->pinchs.fingers[fingers].client); ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; goto finish; } - gev->pinchs.fingers[num_of_fingers].client = client; - gev->pinchs.fingers[num_of_fingers].res = resource; + e_gesture_add_client_destroy_listener(client, TIZEN_GESTURE_TYPE_PINCH, fingers, 0, 0); + + gev->pinchs.fingers[fingers].client = client; + gev->pinchs.fingers[fingers].res = resource; gev->pinchs.state = E_GESTURE_PANPINCH_STATE_READY; gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_PINCH; @@ -178,78 +367,36 @@ finish: } static int -_e_gesture_ungrab_pinch(struct wl_client *client, struct wl_resource *resource, uint32_t num_of_fingers) +_e_gesture_ungrab_pinch(struct wl_client *client, struct wl_resource *resource, uint32_t fingers) { - int i; E_Gesture_Event *gev; int ret = TIZEN_GESTURE_ERROR_NONE; - GTINF("The client %p request to ungrab pinch gesture, fingers: %d\n", client, num_of_fingers); + GTINF("The client %p request to ungrab pinch gesture, fingers: %d\n", client, fingers); - if (num_of_fingers > E_GESTURE_FINGER_MAX) + if (fingers > E_GESTURE_FINGER_MAX) { - GTWRN("Do not support %d fingers (max: %d)\n", num_of_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; } gev = &gesture->gesture_events; - if (gev->pinchs.fingers[num_of_fingers].client == client) + if (gev->pinchs.fingers[fingers].client == client) { - gev->pinchs.fingers[num_of_fingers].client = NULL; - gev->pinchs.fingers[num_of_fingers].res = NULL; + gev->pinchs.fingers[fingers].client = NULL; + gev->pinchs.fingers[fingers].res = NULL; } - gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_PINCH; - gev->pinchs.state = E_GESTURE_PANPINCH_STATE_NONE; - - for (i = 0; i < E_GESTURE_FINGER_MAX; i++) - { - if (gev->pinchs.fingers[i].client) - { - gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_PINCH; - gev->pinchs.state = E_GESTURE_PANPINCH_STATE_READY; - break; - } - } + _e_gesture_remove_client_destroy_listener(client, TIZEN_GESTURE_TYPE_PINCH, fingers, 0, 0); + _e_gesture_pinch_current_list_check(); finish: return ret; } static void -_e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int fingers, unsigned int edge) -{ - Eina_List *l, *l_next; - E_Gesture_Grabbed_Client *data; - int i; - - EINA_LIST_FOREACH_SAFE(gesture->grab_client_list, l, l_next, data) - { - if (data->client == client) - { - _e_gesture_edge_swipe_set_client_to_list(NULL, &data->edge_swipe_fingers[fingers], edge); - - for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) - { - if (data->edge_swipe_fingers[i].edge[E_GESTURE_EDGE_TOP].client || - data->edge_swipe_fingers[i].edge[E_GESTURE_EDGE_RIGHT].client || - data->edge_swipe_fingers[i].edge[E_GESTURE_EDGE_BOTTOM].client || - data->edge_swipe_fingers[i].edge[E_GESTURE_EDGE_LEFT].client) - { - return; - } - } - wl_list_remove(&data->destroy_listener->link); - E_FREE(data->destroy_listener); - gesture->grab_client_list = eina_list_remove(gesture->grab_client_list, data); - E_FREE(data); - } - } -} - -static void _e_gesture_cb_grab_edge_swipe(struct wl_client *client, struct wl_resource *resource, uint32_t fingers, uint32_t edge) @@ -319,7 +466,7 @@ _e_gesture_cb_grab_edge_swipe(struct wl_client *client, if (grabbed_edge) tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, grabbed_edge, TIZEN_GESTURE_ERROR_GRABBED_ALREADY); - e_gesture_add_client_destroy_listener(client, TIZEN_GESTURE_TYPE_EDGE_SWIPE, fingers, edge & ~grabbed_edge); + e_gesture_add_client_destroy_listener(client, TIZEN_GESTURE_TYPE_EDGE_SWIPE, fingers, edge & ~grabbed_edge, 0); gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_EDGE_SWIPE; gev->edge_swipes.fingers[fingers].enabled = EINA_TRUE; if (gev->edge_swipes.event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; @@ -337,10 +484,10 @@ _e_gesture_cb_ungrab_edge_swipe(struct wl_client *client, struct wl_resource *resouce, uint32_t fingers, uint32_t edge) { - int i, j; E_Gesture_Event *gev; unsigned int ungrabbed_edge = 0x0; int ret = TIZEN_GESTURE_ERROR_NONE; + int i, j; GTINF("client %p is request ungrab edge swipe gesture, fingers: %d, edge: 0x%x, client: %p\n", client, fingers, edge, gesture->gesture_events.edge_swipes.fingers[0].edge[3].client); @@ -408,23 +555,10 @@ _e_gesture_cb_ungrab_edge_swipe(struct wl_client *client, if (edge & ~ungrabbed_edge) { - _e_gesture_remove_client_destroy_listener(client, fingers, edge & ~ungrabbed_edge); - for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) - { - for (j = 0; j < E_GESTURE_EDGE_MAX+1; j++) - { - if (gev->edge_swipes.fingers[i].edge[j].client) - { - goto finish; - } - } - gev->edge_swipes.fingers[i].enabled = EINA_FALSE; - } - gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_EDGE_SWIPE; - if (gev->edge_swipes.event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE; + _e_gesture_remove_client_destroy_listener(client, TIZEN_GESTURE_TYPE_EDGE_SWIPE, fingers, edge & ~ungrabbed_edge, 0); + _e_gesture_edge_swipe_current_list_check(); } -finish: gev->edge_swipes.enabled_edge &= ~edge; for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) { @@ -473,6 +607,8 @@ _e_gesture_cb_grab_tap(struct wl_client *client, gev->taps.fingers[fingers].repeats[repeats].res = resource; gev->taps.fingers[fingers].enabled = EINA_TRUE; + e_gesture_add_client_destroy_listener(client, TIZEN_GESTURE_TYPE_TAP, fingers, 0, repeats); + if (gev->taps.max_fingers < fingers) gev->taps.max_fingers = fingers; if (gev->taps.fingers[fingers].max_repeats < repeats) @@ -522,24 +658,11 @@ _e_gesture_cb_ungrab_tap(struct wl_client *client, break; } } - - gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_TAP; - gev->taps.state = E_GESTURE_TAP_STATE_NONE; - gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE; - for (i = 0; i < E_GESTURE_FINGER_MAX; i++) - { - if (gev->taps.fingers[i].enabled) - { - gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_TAP; - gev->taps.state = E_GESTURE_TAP_STATE_READY; - gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; - break; - } - } - - gev->taps.max_fingers = e_gesture_util_tap_max_fingers_get(); gev->taps.fingers[fingers].max_repeats = e_gesture_util_tap_max_repeats_get(fingers); + _e_gesture_remove_client_destroy_listener(client, TIZEN_GESTURE_TYPE_TAP, fingers, 0, repeats); + _e_gesture_tap_current_list_check(); + finish: tizen_gesture_send_tap_notify(resource, fingers, repeats, ret); } @@ -547,49 +670,49 @@ finish: static void _e_gesture_cb_grab_pan(struct wl_client *client, struct wl_resource *resource, - uint32_t num_of_fingers) + uint32_t fingers) { int ret = TIZEN_GESTURE_ERROR_NONE; - ret = _e_gesture_grab_pan(client, resource, num_of_fingers); + ret = _e_gesture_grab_pan(client, resource, fingers); - tizen_gesture_send_pan_notify(resource, num_of_fingers, ret); + tizen_gesture_send_pan_notify(resource, fingers, ret); } static void _e_gesture_cb_ungrab_pan(struct wl_client *client, struct wl_resource *resource, - uint32_t num_of_fingers) + uint32_t fingers) { int ret = TIZEN_GESTURE_ERROR_NONE; - ret = _e_gesture_ungrab_pan(client, resource, num_of_fingers); + ret = _e_gesture_ungrab_pan(client, resource, fingers); - tizen_gesture_send_pan_notify(resource, num_of_fingers, ret); + tizen_gesture_send_pan_notify(resource, fingers, ret); } static void _e_gesture_cb_grab_pinch(struct wl_client *client, struct wl_resource *resource, - uint32_t num_of_fingers) + uint32_t fingers) { int ret = TIZEN_GESTURE_ERROR_NONE; - ret = _e_gesture_grab_pinch(client, resource, num_of_fingers); + ret = _e_gesture_grab_pinch(client, resource, fingers); - tizen_gesture_send_pinch_notify(resource, num_of_fingers, ret); + tizen_gesture_send_pinch_notify(resource, fingers, ret); } static void _e_gesture_cb_ungrab_pinch(struct wl_client *client, struct wl_resource *resource, - uint32_t num_of_fingers) + uint32_t fingers) { int ret = TIZEN_GESTURE_ERROR_NONE; - ret = _e_gesture_ungrab_pinch(client, resource, num_of_fingers); + ret = _e_gesture_ungrab_pinch(client, resource, fingers); - tizen_gesture_send_pinch_notify(resource, num_of_fingers, ret); + tizen_gesture_send_pinch_notify(resource, fingers, ret); } static const struct tizen_gesture_interface _e_gesture_implementation = { @@ -851,18 +974,15 @@ e_modapi_save(E_Module *m) } static void -_e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data) +_e_gesture_remove_client_edge_swipe(struct wl_client *client, E_Gesture_Grabbed_Client *gclient) { - struct wl_client *client = data; int i, j; - Eina_List *l_list, *l_next; - E_Gesture_Grabbed_Client *client_data; - if (gesture->grabbed_gesture & TIZEN_GESTURE_TYPE_EDGE_SWIPE) + for (i = 0; i < E_GESTURE_FINGER_MAX + 1; i++) { - for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) + for (j = 0; j < E_GESTURE_EDGE_MAX + 1; j++) { - for (j = 0; j < E_GESTURE_EDGE_MAX+1; j++) + if (gclient->edge_swipe_fingers[i].edge[j].client) { if (gesture->gesture_events.edge_swipes.fingers[i].edge[j].client == client) { @@ -870,25 +990,112 @@ _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data) gesture->gesture_events.edge_swipes.fingers[i].edge[j].res = NULL; } } + gclient->edge_swipe_fingers[i].edge[j].client = NULL; } + } +} - for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) +static void +_e_gesture_remove_client_tap(struct wl_client *client, E_Gesture_Grabbed_Client *gclient) +{ + int i, j; + + for (i = 0; i < E_GESTURE_FINGER_MAX + 1; i++) + { + for (j = 0; j < E_GESTURE_TAP_REPEATS_MAX + 1; j++) { - for (j = 0; j < E_GESTURE_EDGE_MAX+1; j++) + if (gclient->tap_fingers[i].repeats[j].client) { - if (gesture->gesture_events.edge_swipes.fingers[i].edge[j].client) + if (gesture->gesture_events.taps.fingers[i].repeats[j].client == client) { - goto out; + gesture->gesture_events.taps.fingers[i].repeats[j].client = NULL; + gesture->gesture_events.taps.fingers[i].repeats[j].res = NULL; } } - gesture->gesture_events.edge_swipes.fingers[i].enabled = EINA_FALSE; + gclient->tap_fingers[i].repeats[j].client = NULL; } - gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_EDGE_SWIPE; } +} -out: +static void +_e_gesture_remove_client_pan(struct wl_client *client, E_Gesture_Grabbed_Client *gclient) +{ + int i; + + for (i = 0; i < E_GESTURE_FINGER_MAX + 1; i++) + { + if (gclient->pan_fingers[i].client) + { + gesture->gesture_events.pans.fingers[i].client = NULL; + gesture->gesture_events.pans.fingers[i].res = NULL; + } + gclient->pan_fingers[i].client = NULL; + } +} + +static void +_e_gesture_remove_client_pinch(struct wl_client *client, E_Gesture_Grabbed_Client *gclient) +{ + int i; + + for (i = 0; i < E_GESTURE_FINGER_MAX + 1; i++) + { + if (gclient->pinch_fingers[i].client) + { + gesture->gesture_events.pinchs.fingers[i].client = NULL; + gesture->gesture_events.pinchs.fingers[i].res = NULL; + } + gclient->pinch_fingers[i].client = NULL; + } +} + +static void +_e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data) +{ + struct wl_client *client = data; + Eina_List *l_list, *l_next; + E_Gesture_Grabbed_Client *client_data; + unsigned int removed_gesture = 0x0; + + EINA_LIST_FOREACH_SAFE(gesture->grab_client_list, l_list, l_next, client_data) + { + if (client_data->client == client) + { + if (client_data->grabbed_gesture & TIZEN_GESTURE_TYPE_EDGE_SWIPE) + { + _e_gesture_remove_client_edge_swipe(client, client_data); + removed_gesture |= TIZEN_GESTURE_TYPE_EDGE_SWIPE; + } + if (client_data->grabbed_gesture & TIZEN_GESTURE_TYPE_TAP) + { + _e_gesture_remove_client_tap(client, client_data); + removed_gesture |= TIZEN_GESTURE_TYPE_TAP; + } + if (client_data->grabbed_gesture & TIZEN_GESTURE_TYPE_PAN) + { + _e_gesture_remove_client_pan(client, client_data); + removed_gesture |= TIZEN_GESTURE_TYPE_PAN; + } + if (client_data->grabbed_gesture & TIZEN_GESTURE_TYPE_PINCH) + { + _e_gesture_remove_client_pinch(client, client_data); + removed_gesture |= TIZEN_GESTURE_TYPE_PINCH; + } + } + } + + if (removed_gesture & TIZEN_GESTURE_TYPE_EDGE_SWIPE) + _e_gesture_edge_swipe_current_list_check(); + if (removed_gesture & TIZEN_GESTURE_TYPE_TAP) + _e_gesture_tap_current_list_check(); + if (removed_gesture & TIZEN_GESTURE_TYPE_PAN) + _e_gesture_pan_current_list_check(); + if (removed_gesture & TIZEN_GESTURE_TYPE_PINCH) + _e_gesture_pinch_current_list_check(); + + wl_list_remove(&l->link); E_FREE(l); - l = NULL; + EINA_LIST_FOREACH_SAFE(gesture->grab_client_list, l_list, l_next, client_data) { if (client_data->client == client) diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 3e99b21..a2d6dc2 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -173,15 +173,6 @@ struct _E_Gesture_Event_Edge_Swipe_Finger E_Gesture_Event_Edge_Swipe_Finger_Edge edge[E_GESTURE_EDGE_MAX + 1]; }; -struct _E_Gesture_Grabbed_Client -{ - struct wl_client *client; - struct wl_listener *destroy_listener; - - E_Gesture_Event_Edge_Swipe_Finger edge_swipe_fingers[E_GESTURE_FINGER_MAX + 2]; -}; - - struct _E_Gesture_Event_Edge_Swipe { E_Gesture_Event_Edge_Swipe_Finger fingers[E_GESTURE_FINGER_MAX + 2]; @@ -253,6 +244,18 @@ struct _E_Gesture_Event_Pinch Ecore_Timer *move_timer; }; +struct _E_Gesture_Grabbed_Client +{ + struct wl_client *client; + struct wl_listener *destroy_listener; + unsigned int grabbed_gesture; + + E_Gesture_Event_Edge_Swipe_Finger edge_swipe_fingers[E_GESTURE_FINGER_MAX + 2]; + E_Gesture_Event_Tap_Finger tap_fingers[E_GESTURE_FINGER_MAX + 2]; + E_Gesture_Event_Client pan_fingers[E_GESTURE_FINGER_MAX + 2]; + E_Gesture_Event_Client pinch_fingers[E_GESTURE_FINGER_MAX + 2]; +}; + struct _E_Gesture_Event { E_Gesture_Event_Edge_Swipe edge_swipes; -- 2.7.4 From 14c8e5328b4b09a97ec2c05abaac3b802ac3cb7d Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Tue, 21 Feb 2017 11:25:12 +0900 Subject: [PATCH 13/16] Clean up allocated memory when the gesture is shutdown Change-Id: Ifdecd0be5fdea8786ab6540bc52e4dcd18079c9f --- src/e_mod_main.c | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/src/e_mod_main.c b/src/e_mod_main.c index 491fef1..cfd64ff 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -955,10 +955,33 @@ e_modapi_init(E_Module *m) E_API int e_modapi_shutdown(E_Module *m) { + Eina_List *l, *l_next; + E_Gesture_Grabbed_Client *gclient; + E_Gesture_Event_Info *event_info; E_Gesture_Config_Data *gconfig = m->data; + e_gesture_conf_deinit(gconfig); e_gesture_device_shutdown(); _e_gesture_deinit_handlers(); + + EINA_LIST_FOREACH_SAFE(gesture->grab_client_list, l, l_next, gclient) + { + if (gclient->destroy_listener) + { + wl_list_remove(&gclient->destroy_listener->link); + E_FREE(gclient->destroy_listener); + } + E_FREE(gclient); + gesture->grab_client_list = eina_list_remove_list(gesture->grab_client_list, l); + } + + EINA_LIST_FOREACH_SAFE(gesture->event_queue, l, l_next, event_info) + { + E_FREE(event_info->event); + E_FREE(event_info); + gesture->event_queue = eina_list_remove_list(gesture->event_queue, l); + } + return 1; } -- 2.7.4 From 9ca26a924c1d7ab9a9366b6120a8ab7bc553e021 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Mon, 29 May 2017 14:28:57 +0900 Subject: [PATCH 14/16] packaging: update version to 0.1.9 Change-Id: Iace0f88770da167924d464f3ccfdfaa9ca1396b5 --- 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 4b9cff3..75478b7 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.8 +Version: 0.1.9 Release: 1 Summary: The Enlightenment Gesture Module for Tizen URL: http://www.enlightenment.org -- 2.7.4 From 3db1a9dbf29b89e59d348299db31934560627cf0 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Tue, 13 Jun 2017 16:16:31 +0900 Subject: [PATCH 15/16] update supported tizen_gesture version 1 -> 2 Change-Id: I82189c1706c4a6e3ed36fd5b079dca86da842579 --- 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 cfd64ff..de5833d 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -740,7 +740,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, 1), id); + resource = wl_resource_create(client, &tizen_gesture_interface, MAX(version, 1), id); GTDBG("wl_resource_create(...,tizen_gesture_interface,...)\n"); @@ -910,7 +910,7 @@ _e_gesture_init(E_Module *m) GTDBG("area_offset: %d, min_length: %d, max_length: %d\n", gconfig->conf->edge_swipe.area_offset, gconfig->conf->edge_swipe.min_length, gconfig->conf->edge_swipe.max_length); GTDBG("compose key: %d, back: %d, default: %d\n", gconfig->conf->edge_swipe.compose_key, gconfig->conf->edge_swipe.back_key, gconfig->conf->edge_swipe.default_enable_back); - gesture->global = wl_global_create(e_comp_wl->wl.disp, &tizen_gesture_interface, 1, 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 c2dfb6e4dc96de029ffb3db59af0ca2b50e696ba Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Wed, 14 Jun 2017 16:47:34 +0900 Subject: [PATCH 16/16] modify logics to recognize gesture to use touch moving range in tap Change-Id: I03623d8a5329e4f8cf7e3751cafe71cdec67a04d --- src/e_mod_gesture_events.c | 53 ++++++++++++++++++++++++++++++++++++++++------ src/e_mod_main.h | 9 ++++++++ 2 files changed, 56 insertions(+), 6 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index fc8df1e..d726941 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -545,6 +545,28 @@ _e_gesture_util_angle_get(int x1, int y1, int x2, int y2) return angle; } +static void +_e_gesture_util_rect_get(int finger, int *x1, int *y1, int *x2, int *y2) +{ + int i; + + *x1 = *x2 = gesture->gesture_events.base_point[1].axis.x; + *y1 = *y2 = gesture->gesture_events.base_point[1].axis.y; + + for (i = 2; i < finger + 1; i++) + { + if (gesture->gesture_events.base_point[i].axis.x < *x1) + *x1 = gesture->gesture_events.base_point[i].axis.x; + else if (gesture->gesture_events.base_point[i].axis.x > *x2) + *x2 = gesture->gesture_events.base_point[i].axis.x; + + if (gesture->gesture_events.base_point[i].axis.y < *y1) + *y1 = gesture->gesture_events.base_point[i].axis.y; + else if (gesture->gesture_events.base_point[i].axis.y > *y2) + *y2 = gesture->gesture_events.base_point[i].axis.y; + } +} + static Eina_Bool _e_gesture_timer_pan_start(void *data) { @@ -838,6 +860,10 @@ _e_gesture_tap_cancel(void) taps->repeats = 0; taps->enabled_finger = 0; taps->state = E_GESTURE_TAP_STATE_READY; + taps->base_rect.x1 = 0; + taps->base_rect.y1 = 0; + taps->base_rect.x2 = 0; + taps->base_rect.y2 = 0; gesture->gesture_filter |= TIZEN_GESTURE_TYPE_TAP; _e_gesture_event_flush(); gesture->gesture_events.recognized_gesture &= ~TIZEN_GESTURE_TYPE_TAP; @@ -978,6 +1004,13 @@ _e_gesture_process_tap_down(Ecore_Event_Mouse_Button *ev) if (taps->enabled_finger > taps->max_fingers) _e_gesture_tap_cancel(); + if (taps->state == E_GESTURE_TAP_STATE_READY || + taps->state == E_GESTURE_TAP_STATE_START || + taps->state == E_GESTURE_TAP_STATE_PROCESS) + { + _e_gesture_util_rect_get(taps->enabled_finger, &taps->base_rect.x1, &taps->base_rect.y1, &taps->base_rect.x2, &taps->base_rect.y2); + } + switch (taps->state) { case E_GESTURE_TAP_STATE_NONE: @@ -1014,18 +1047,26 @@ _e_gesture_process_tap_down(Ecore_Event_Mouse_Button *ev) static void _e_gesture_process_tap_move(Ecore_Event_Mouse_Move *ev) { - int diff_x, diff_y; + E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + Rect current_rect = {0, }; + int xx1, yy1, xx2, yy2; if (gesture->gesture_events.recognized_gesture) _e_gesture_tap_cancel(); - diff_x = gesture->gesture_events.base_point[ev->multi.device + 1].axis.x - ev->x; - diff_y = gesture->gesture_events.base_point[ev->multi.device + 1].axis.y - ev->y; + _e_gesture_util_rect_get(taps->enabled_finger, ¤t_rect.x1, ¤t_rect.y1, ¤t_rect.x2, ¤t_rect.y2); + + xx1 = taps->base_rect.x1 - current_rect.x1; + yy1 = taps->base_rect.y1 - current_rect.y1; + xx2 = taps->base_rect.x2 - current_rect.x2; + yy2 = taps->base_rect.y2 - current_rect.y2; - if (ABS(diff_x) > E_GESTURE_TAP_MOVING_RANGE || - ABS(diff_y) > E_GESTURE_TAP_MOVING_RANGE) + if (ABS(xx1) > E_GESTURE_TAP_MOVING_RANGE || + ABS(yy1) > E_GESTURE_TAP_MOVING_RANGE || + ABS(xx2) > E_GESTURE_TAP_MOVING_RANGE || + ABS(yy2) > E_GESTURE_TAP_MOVING_RANGE) { - GTDBG("%d finger moving too large diff: (%d, %d)\n", ev->multi.device, diff_x, diff_y); + GTDBG("%d finger moving too large diff: (%d, %d)(%d, %d)\n", ev->multi.device, xx1, yy1, xx2, yy2); _e_gesture_tap_cancel(); } } diff --git a/src/e_mod_main.h b/src/e_mod_main.h index a2d6dc2..53e02f1 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -64,6 +64,7 @@ typedef struct _E_Gesture_Event_Pan E_Gesture_Event_Pan; typedef struct _E_Gesture_Event_Pinch E_Gesture_Event_Pinch; typedef struct _Coords Coords; +typedef struct _Rect Rect; typedef struct _E_Gesture_Finger E_Gesture_Finger; typedef struct _E_Gesture_Event_Info E_Gesture_Event_Info; typedef struct _E_Gesture_Event_Client E_Gesture_Event_Client; @@ -118,6 +119,12 @@ struct _Coords int x, y; }; +struct _Rect +{ + int x1, y1; + int x2, y2; +}; + struct _E_Gesture_Finger { Eina_Bool pressed; @@ -218,6 +225,8 @@ struct _E_Gesture_Event_Tap Ecore_Timer *done_timer; /* interval timer */ Ecore_Timer *interval_timer; + + Rect base_rect; }; struct _E_Gesture_Event_Pan -- 2.7.4