From 943b993a02a9a4c2961c3c48a0d72a4a60248789 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Mon, 20 Feb 2017 16:05:32 +0900 Subject: [PATCH 01/16] Move a priority about the mouse event filtering logic Change-Id: Ic5520a3b4b0aef0b93a4a991b5eafd65f452f572 --- src/e_mod_gesture_events.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index 6627b5c..fde9512 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -502,6 +502,10 @@ _e_gesture_process_mouse_move(void *event) { Ecore_Event_Mouse_Move *ev = event; + if (e_gesture_is_touch_device(ev->dev) == EINA_FALSE) + { + return E_GESTURE_EVENT_STATE_PROPAGATE; + } if (gesture->gesture_events.num_pressed == 0) { return gesture->event_state; @@ -510,11 +514,6 @@ _e_gesture_process_mouse_move(void *event) { return E_GESTURE_EVENT_STATE_PROPAGATE; } - if (e_gesture_is_touch_device(ev->dev) == EINA_FALSE) - { - return E_GESTURE_EVENT_STATE_PROPAGATE; - } - if (gesture->gesture_events.recognized_gesture) { return E_GESTURE_EVENT_STATE_IGNORE; -- 2.7.4 From 1e599521b3ef72f7d7994f05d1fdf44ec1e83573 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Mon, 20 Feb 2017 16:06:13 +0900 Subject: [PATCH 02/16] Packaging : update version to 0.1.5 Change-Id: Id0519ac91a065059b4d088f6a671c7fdd973d4cb --- 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 5a1e11e..1f74a5f 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.4 +Version: 0.1.5 Release: 1 Summary: The Enlightenment Gesture Module for Tizen URL: http://www.enlightenment.org -- 2.7.4 From 47e942bc67d8d5732c6ff43ee040ab648f399085 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Wed, 8 Mar 2017 14:43:59 +0900 Subject: [PATCH 03/16] Check grabbed edge when process a edge_swipe gesture Change-Id: I3fdbba711ef7ca407dd683771b4606e78f4b5ad9 --- src/e_mod_gesture_events.c | 16 ++++++++++------ src/e_mod_main.c | 17 ++++++++++++++++- src/e_mod_main.h | 3 +++ 3 files changed, 29 insertions(+), 7 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index fde9512..19666b4 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -316,12 +316,10 @@ _e_gesture_process_edge_swipe_down(Ecore_Event_Mouse_Button *ev) edge_swipes->edge = E_GESTURE_EDGE_RIGHT; else if (ev->x > e_comp->w - conf->edge_swipe.area_offset) edge_swipes->edge = E_GESTURE_EDGE_LEFT; - else - { - if (edge_swipes->event_keep) - _e_gesture_event_flush(); - _e_gesture_edge_swipe_cancel(); - } + + if (!((1 << (edge_swipes->edge - 1)) & edge_swipes->enabled_edge)) + edge_swipes->edge = E_GESTURE_EDGE_NONE; + if (edge_swipes->edge != E_GESTURE_EDGE_NONE) { edge_swipes->fingers[idx].start.x = ev->x; @@ -329,6 +327,12 @@ _e_gesture_process_edge_swipe_down(Ecore_Event_Mouse_Button *ev) edge_swipes->start_timer = ecore_timer_add(conf->edge_swipe.time_begin, _e_gesture_timer_edge_swipe_start, NULL); edge_swipes->done_timer = ecore_timer_add(conf->edge_swipe.time_done, _e_gesture_timer_edge_swipe_done, NULL); } + else + { + if (edge_swipes->event_keep) + _e_gesture_event_flush(); + _e_gesture_edge_swipe_cancel(); + } } else { diff --git a/src/e_mod_main.c b/src/e_mod_main.c index c2ad892..ad13585 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -173,6 +173,7 @@ _e_gesture_cb_grab_edge_swipe(struct wl_client *client, 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; + gev->edge_swipes.enabled_edge |= grabbed_edge; if (!grabbed_edge) tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, edge, TIZEN_GESTURE_ERROR_NONE); @@ -197,7 +198,7 @@ _e_gesture_cb_ungrab_edge_swipe(struct wl_client *client, { GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); ret = TIZEN_GESTURE_ERROR_INVALID_DATA; - goto finish; + goto notify; } gev = &gesture->gesture_events; @@ -274,6 +275,20 @@ _e_gesture_cb_ungrab_edge_swipe(struct wl_client *client, } finish: + gev->edge_swipes.enabled_edge &= ~edge; + for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) + { + for (j = 1; j < E_GESTURE_EDGE_MAX+1; j++) + { + if (gev->edge_swipes.fingers[i].edge[j].client) + { + gev->edge_swipes.enabled_edge |= (1 << (j - 1)); + } + } + if (gev->edge_swipes.enabled_edge == E_GESTURE_EDGE_ALL) break; + } + +notify: tizen_gesture_send_grab_edge_swipe_notify(resouce, fingers, edge, ret); return; } diff --git a/src/e_mod_main.h b/src/e_mod_main.h index da12291..96c3cd8 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -51,6 +51,7 @@ typedef enum _E_Gesture_Event_State E_Gesture_Event_State; extern E_GesturePtr gesture; #define E_GESTURE_EDGE_MAX 4 +#define E_GESTURE_EDGE_ALL (TIZEN_GESTURE_EDGE_TOP | TIZEN_GESTURE_EDGE_RIGHT | TIZEN_GESTURE_EDGE_BOTTOM | TIZEN_GESTURE_EDGE_LEFT) enum _E_Gesture_Edge { @@ -135,6 +136,8 @@ struct _E_Gesture_Event_Edge_Swipe unsigned int back_keycode; unsigned int enabled_finger; + unsigned int enabled_edge; + Ecore_Timer *start_timer; Ecore_Timer *done_timer; -- 2.7.4 From 68c709bdb5ee91a031f8f7ba66b5fa6c6e0a22de Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Wed, 8 Mar 2017 14:48:57 +0900 Subject: [PATCH 04/16] Packaging: update version to 0.1.6 Change-Id: If45ecebc3633d9b384a8496b96338e469dcc0de0 --- 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 1f74a5f..149a0a6 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.5 +Version: 0.1.6 Release: 1 Summary: The Enlightenment Gesture Module for Tizen URL: http://www.enlightenment.org -- 2.7.4 From b938fbf2e6d7c64e4a743be2d2b8dfe40e045d7b Mon Sep 17 00:00:00 2001 From: Sung-Jin Park Date: Wed, 22 Mar 2017 17:41:35 +0900 Subject: [PATCH 05/16] packaging: update packaging file to install license file via %license macro Change-Id: Ia41e402c996d11baae09c055c6396a8334abd033 Signed-off-by: Sung-Jin Park --- packaging/e-mod-tizen-gesture.spec | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/packaging/e-mod-tizen-gesture.spec b/packaging/e-mod-tizen-gesture.spec index 149a0a6..6171fa7 100644 --- a/packaging/e-mod-tizen-gesture.spec +++ b/packaging/e-mod-tizen-gesture.spec @@ -38,10 +38,6 @@ make %install rm -rf %{buildroot} -# for license notification -mkdir -p %{buildroot}/%{TZ_SYS_RO_SHARE}/license -cp -a %{_builddir}/%{buildsubdir}/COPYING %{buildroot}/%{TZ_SYS_RO_SHARE}/license/%{name} - # install make install DESTDIR=%{buildroot} @@ -50,5 +46,5 @@ find %{buildroot}%{_libdir}/enlightenment/modules/%{name} -name *.la | xargs rm %files %defattr(-,root,root,-) +%license COPYING %{_libdir}/enlightenment/modules/e-mod-tizen-gesture -/%{TZ_SYS_RO_SHARE}/license/%{name} -- 2.7.4 From 0b331d8823b18cfd57fdb6b73d341c8dd9fb769d Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Thu, 23 Mar 2017 16:18:51 +0900 Subject: [PATCH 06/16] set (omitted) window variable of ecore key event with e_comp->ee_win Change-Id: I5414251cf7d6cfe437f531a6337481ef175d4e2a --- src/e_mod_gesture_events.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index 19666b4..e1de548 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -176,6 +176,7 @@ _e_gesture_send_back_key(Eina_Bool pressed) ev->same_screen = 1; ev->keycode = conf->edge_swipe.back_key; ev->dev = gesture->device.kbd_device; + ev->window = e_comp->ee_win; if (pressed) ecore_event_add(ECORE_EVENT_KEY_DOWN, ev, _e_gesture_keyevent_free, NULL); -- 2.7.4 From 54d1b1668412343d5968d95d4772301bf5b4bd7c Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Thu, 23 Mar 2017 16:23:04 +0900 Subject: [PATCH 07/16] Packaging: update version to 0.1.7 Change-Id: I1c1aa90a435fd25565e01a4cfd17d35ddecccc74 --- 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 6171fa7..0a1e2e5 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.6 +Version: 0.1.7 Release: 1 Summary: The Enlightenment Gesture Module for Tizen URL: http://www.enlightenment.org -- 2.7.4 From 174336bca573e31239e56b7b007c4aa3525a6acf Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Fri, 31 Mar 2017 14:09:28 +0900 Subject: [PATCH 08/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 09/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 10/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 11/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 12/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 13/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 14/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 15/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 16/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