From 7ec045ecdc0b80b3f578569bee15bbada91c62fd Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Fri, 12 May 2017 14:34:41 +0900 Subject: [PATCH 01/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 02/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 03/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 04/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 05/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 06/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 07/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 08/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 09/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 From f4e5ca4b06f88c7f675bb6f0bb004aa07fe09f08 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Mon, 19 Jun 2017 21:05:59 +0900 Subject: [PATCH 10/16] change config options to a configurable file from definition Change-Id: Ic4cc5f3f778b7fedebdfefa5268abb07dcd93ddd --- src/e_mod_gesture_conf.c | 26 ++++++++++++++++++++++++- src/e_mod_gesture_events.c | 47 +++++++++++++++++++++++----------------------- src/e_mod_main.c | 32 ++++++++++++++++++++++--------- src/e_mod_main.h | 26 ++++++++++++++++++++----- 4 files changed, 93 insertions(+), 38 deletions(-) diff --git a/src/e_mod_gesture_conf.c b/src/e_mod_gesture_conf.c index 4a7fe80..d2e74e1 100644 --- a/src/e_mod_gesture_conf.c +++ b/src/e_mod_gesture_conf.c @@ -9,6 +9,7 @@ _e_gesture_conf_value_check(E_Gesture_Config_Data* gconfig) EINA_SAFETY_ON_NULL_RETURN(gconfig->conf); conf = gconfig->conf; + if (!conf->key_device_name) conf->key_device_name = strdup(E_GESTURE_KEYBOARD_DEVICE); if (conf->edge_swipe.time_done <= 0.0) conf->edge_swipe.time_done = E_GESTURE_EDGE_SWIPE_DONE_TIME; if (conf->edge_swipe.time_begin <= 0.0) conf->edge_swipe.time_begin = E_GESTURE_EDGE_SWIPE_START_TIME; @@ -17,6 +18,17 @@ _e_gesture_conf_value_check(E_Gesture_Config_Data* gconfig) if (conf->edge_swipe.max_length <= 0) conf->edge_swipe.max_length = E_GESTURE_EDGE_SWIPE_DIFF_SUCCESS; if (conf->edge_swipe.compose_key <= 0) conf->edge_swipe.compose_key = E_GESTURE_EDGE_SWIPE_COMBINE_KEY; if (conf->edge_swipe.back_key <= 0) conf->edge_swipe.back_key = E_GESTURE_EDGE_SWIPE_BACK_KEY; + + if (conf->tap.repeats_max <= 0) conf->tap.repeats_max = E_GESTURE_TAP_REPEATS_MAX; + if (conf->tap.time_start <= 0.0) conf->tap.time_start = E_GESTURE_TAP_START_TIME; + if (conf->tap.time_done <= 0.0) conf->tap.time_done = E_GESTURE_TAP_DONE_TIME; + if (conf->tap.time_interval <= 0.0) conf->tap.time_interval = E_GESTURE_TAP_INTERVAL_TIME; + if (conf->tap.moving_range <= 0) conf->tap.moving_range = E_GESTURE_TAP_MOVING_RANGE; + + if (conf->pan.time_start <= 0.0) conf->pan.time_start = E_GESTURE_PAN_START_TIME; + if (conf->pan.moving_range <= 0) conf->pan.moving_range = E_GESTURE_PAN_MOVING_RANGE; + + if (conf->pinch.moving_distance_range <= 0.0) conf->pinch.moving_distance_range = E_GESTURE_PINCH_MOVING_DISTANCE_RANGE; } void @@ -28,6 +40,8 @@ e_gesture_conf_init(E_Gesture_Config_Data *gconfig) #define T E_Gesture_Conf_Edd #define D gconfig->conf_edd E_CONFIG_VAL(D, T, key_device_name, STR); + E_CONFIG_VAL(D, T, event_keep, CHAR); + E_CONFIG_VAL(D, T, edge_swipe.time_done, DOUBLE); E_CONFIG_VAL(D, T, edge_swipe.time_begin, DOUBLE); E_CONFIG_VAL(D, T, edge_swipe.area_offset, INT); @@ -36,7 +50,17 @@ e_gesture_conf_init(E_Gesture_Config_Data *gconfig) E_CONFIG_VAL(D, T, edge_swipe.compose_key, INT); E_CONFIG_VAL(D, T, edge_swipe.back_key, INT); E_CONFIG_VAL(D, T, edge_swipe.default_enable_back, CHAR); - E_CONFIG_VAL(D, T, edge_swipe.event_keep, CHAR); + + E_CONFIG_VAL(D, T, tap.repeats_max, INT); + E_CONFIG_VAL(D, T, tap.time_start, DOUBLE); + E_CONFIG_VAL(D, T, tap.time_done, DOUBLE); + E_CONFIG_VAL(D, T, tap.time_interval, DOUBLE); + E_CONFIG_VAL(D, T, tap.moving_range, INT); + + E_CONFIG_VAL(D, T, pan.time_start, DOUBLE); + E_CONFIG_VAL(D, T, pan.moving_range, INT); + + E_CONFIG_VAL(D, T, pinch.moving_distance_range, DOUBLE); #undef T #undef D diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index d726941..bed157e 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -190,7 +190,6 @@ _e_gesture_send_edge_swipe(int fingers, int x, int y, int edge, struct wl_client enum tizen_gesture_edge dir = 0; Ecore_Event_Mouse_Button *ev_cancel; E_Gesture_Conf_Edd *conf = gesture->config->conf; - E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; switch (edge) { @@ -208,7 +207,7 @@ _e_gesture_send_edge_swipe(int fingers, int x, int y, int edge, struct wl_client break; } - if (edge_swipes->event_keep) + if (gesture->gesture_events.event_keep) { _e_gesture_event_drop(); } @@ -270,7 +269,7 @@ _e_gesture_timer_edge_swipe_start(void *data) (edge_swipes->edge == E_GESTURE_EDGE_BOTTOM && !edge_swipes->fingers[idx].edge[E_GESTURE_EDGE_BOTTOM].client) || (edge_swipes->edge == E_GESTURE_EDGE_RIGHT && !edge_swipes->fingers[idx].edge[E_GESTURE_EDGE_RIGHT].client)) { - if (edge_swipes->event_keep) + if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); _e_gesture_edge_swipe_cancel(); } @@ -284,7 +283,7 @@ _e_gesture_timer_edge_swipe_done(void *data) GTDBG("Edge_Swipe done timer is expired. Currently alived edge_swipe fingers: 0x%x\n", edge_swipes->enabled_finger); - if (edge_swipes->event_keep) + if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); _e_gesture_edge_swipe_cancel(); @@ -333,7 +332,7 @@ _e_gesture_process_edge_swipe_down(Ecore_Event_Mouse_Button *ev) } else { - if (edge_swipes->event_keep) + if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); _e_gesture_edge_swipe_cancel(); } @@ -343,7 +342,7 @@ _e_gesture_process_edge_swipe_down(Ecore_Event_Mouse_Button *ev) edge_swipes->enabled_finger &= ~(1 << (gesture->gesture_events.num_pressed - 1)); if (edge_swipes->start_timer == NULL) { - if (edge_swipes->event_keep) + if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); _e_gesture_edge_swipe_cancel(); } @@ -369,7 +368,7 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) case E_GESTURE_EDGE_TOP: if (diff.x > conf->edge_swipe.min_length) { - if (edge_swipes->event_keep) + if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); _e_gesture_edge_swipe_cancel(); break; @@ -382,7 +381,7 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) case E_GESTURE_EDGE_LEFT: if (diff.y > conf->edge_swipe.min_length) { - if (edge_swipes->event_keep) + if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); _e_gesture_edge_swipe_cancel(); break; @@ -395,7 +394,7 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) case E_GESTURE_EDGE_BOTTOM: if (diff.x > conf->edge_swipe.min_length) { - if (edge_swipes->event_keep) + if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); _e_gesture_edge_swipe_cancel(); break; @@ -408,7 +407,7 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) case E_GESTURE_EDGE_RIGHT: if (diff.y > conf->edge_swipe.min_length) { - if (edge_swipes->event_keep) + if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); _e_gesture_edge_swipe_cancel(); break; @@ -427,9 +426,7 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) static void _e_gesture_process_edge_swipe_up(Ecore_Event_Mouse_Button *ev) { - E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; - - if (edge_swipes->event_keep) + if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); _e_gesture_edge_swipe_cancel(); } @@ -825,10 +822,11 @@ unsigned int e_gesture_util_tap_max_repeats_get(unsigned int fingers) { E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + E_Gesture_Conf_Edd *conf = gesture->config->conf; int i; unsigned int max = 0; - for (i = 0; i < E_GESTURE_TAP_REPEATS_MAX + 1; i++) + for (i = 0; i < conf->tap.repeats_max + 1; i++) { if (taps->fingers[fingers].repeats[i].client) max = i; } @@ -942,15 +940,16 @@ static void _e_gesture_tap_start(void) { E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + E_Gesture_Conf_Edd *conf = gesture->config->conf; 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); + taps->start_timer = ecore_timer_add(conf->tap.time_start, _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); + taps->done_timer = ecore_timer_add(conf->tap.time_done, _e_gesture_timer_tap_done, NULL); } } @@ -958,8 +957,9 @@ static void _e_gesture_tap_done(void) { E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + E_Gesture_Conf_Edd *conf = gesture->config->conf; - if (taps->repeats >= E_GESTURE_TAP_REPEATS_MAX) + if (taps->repeats >= conf->tap.repeats_max) _e_gesture_tap_cancel(); if (!taps->fingers[taps->enabled_finger].enabled) @@ -984,7 +984,7 @@ _e_gesture_tap_done(void) { if (!taps->interval_timer) { - taps->interval_timer = ecore_timer_add(E_GESTURE_TAP_INTERVAL_TIME, _e_gesture_timer_tap_interval, NULL); + taps->interval_timer = ecore_timer_add(conf->tap.time_interval, _e_gesture_timer_tap_interval, NULL); } } } @@ -1048,6 +1048,7 @@ static void _e_gesture_process_tap_move(Ecore_Event_Mouse_Move *ev) { E_Gesture_Event_Tap *taps = &gesture->gesture_events.taps; + E_Gesture_Conf_Edd *conf = gesture->config->conf; Rect current_rect = {0, }; int xx1, yy1, xx2, yy2; @@ -1061,10 +1062,10 @@ _e_gesture_process_tap_move(Ecore_Event_Mouse_Move *ev) xx2 = taps->base_rect.x2 - current_rect.x2; yy2 = taps->base_rect.y2 - current_rect.y2; - 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) + if (ABS(xx1) > conf->tap.moving_range || + ABS(yy1) > conf->tap.moving_range || + ABS(xx2) > conf->tap.moving_range || + ABS(yy2) > conf->tap.moving_range) { GTDBG("%d finger moving too large diff: (%d, %d)(%d, %d)\n", ev->multi.device, xx1, yy1, xx2, yy2); _e_gesture_tap_cancel(); @@ -1347,7 +1348,7 @@ e_gesture_process_events(void *event, int type) { if (gesture->grabbed_gesture & TIZEN_GESTURE_TYPE_TAP || ((gesture->grabbed_gesture & TIZEN_GESTURE_TYPE_EDGE_SWIPE) && - gesture->gesture_events.edge_swipes.event_keep)) + gesture->gesture_events.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 de5833d..896bf55 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -102,7 +102,7 @@ _e_gesture_edge_swipe_current_list_check(void) 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; + if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE; } static void @@ -469,7 +469,7 @@ _e_gesture_cb_grab_edge_swipe(struct wl_client *client, 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; + if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; gev->edge_swipes.enabled_edge |= grabbed_edge; if (!grabbed_edge) @@ -877,8 +877,8 @@ static E_Gesture_Config_Data * _e_gesture_init(E_Module *m) { E_Gesture_Config_Data *gconfig = NULL; - gesture = E_NEW(E_Gesture, 1); + gesture = E_NEW(E_Gesture, 1); if (!gesture) { GTERR("Failed to allocate memory for gesture !\n"); @@ -905,10 +905,24 @@ _e_gesture_init(E_Module *m) EINA_SAFETY_ON_NULL_GOTO(gconfig->conf, err); gesture->config = gconfig; - GTDBG("config value\n"); - GTDBG("keyboard: %s, time_done: %lf, time_begin: %lf\n", gconfig->conf->key_device_name, gconfig->conf->edge_swipe.time_done, gconfig->conf->edge_swipe.time_begin); - 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); + GTDBG("gesture config value\n"); + GTDBG("key_device_name: %s, event_keep: %d\n", gconfig->conf->key_device_name, gconfig->conf->event_keep); + GTDBG("edge_swipe\n"); + GTDBG("\ttime_done: %lf, time_begin: %lf, area_offset: %d\n", gconfig->conf->edge_swipe.time_done, + gconfig->conf->edge_swipe.time_begin, + gconfig->conf->edge_swipe.area_offset); + GTDBG("\tmin_length: %d, max_length: %d, compose_key: %d, back_key: %d\n", gconfig->conf->edge_swipe.min_length, + gconfig->conf->edge_swipe.max_length, + gconfig->conf->edge_swipe.compose_key, + gconfig->conf->edge_swipe.back_key); + GTDBG("tap\n"); + GTDBG("\trepeats_max: %d, moving_range: %d\n", gconfig->conf->tap.repeats_max, + gconfig->conf->tap.moving_range); + GTDBG("\ttime_start: %lf, time_done: %lf, time_interval: %lf\n", gconfig->conf->tap.time_start, + gconfig->conf->tap.time_done, + gconfig->conf->tap.time_interval); + GTDBG("pan time_start: %lf, moving_range: %d\n", gconfig->conf->pan.time_start, gconfig->conf->pan.moving_range); + GTDBG("pinch moving_distance_range: %lf\n", gconfig->conf->pinch.moving_distance_range); gesture->global = wl_global_create(e_comp_wl->wl.disp, &tizen_gesture_interface, 2, gesture, _e_gesture_cb_bind); if (!gesture->global) @@ -919,7 +933,7 @@ _e_gesture_init(E_Module *m) gesture->gesture_filter = E_GESTURE_TYPE_MAX; - gesture->gesture_events.edge_swipes.event_keep = gconfig->conf->edge_swipe.event_keep; + gesture->gesture_events.event_keep = gconfig->conf->event_keep; if (gconfig->conf->edge_swipe.default_enable_back) { gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_EDGE_SWIPE; @@ -927,7 +941,7 @@ _e_gesture_init(E_Module *m) 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) + if (gesture->gesture_events.event_keep) { gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; } diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 53e02f1..2afb315 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -32,8 +32,8 @@ #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_DONE_TIME 1.0 +#define E_GESTURE_TAP_INTERVAL_TIME 1.0 #define E_GESTURE_TAP_MOVING_RANGE 25 #define E_GESTURE_PAN_START_TIME 0.05 @@ -140,6 +140,7 @@ struct _E_Gesture_Event_Info struct _E_Gesture_Conf_Edd { char *key_device_name; + Eina_Bool event_keep; struct { double time_done; @@ -150,8 +151,24 @@ struct _E_Gesture_Conf_Edd int compose_key; int back_key; Eina_Bool default_enable_back; - Eina_Bool event_keep; } edge_swipe; + struct + { + int repeats_max; + double time_start; + double time_done; + double time_interval; + int moving_range; + } tap; + struct + { + double time_start; + int moving_range; + } pan; + struct + { + double moving_distance_range; + } pinch; }; struct _E_Gesture_Config_Data @@ -194,8 +211,6 @@ struct _E_Gesture_Event_Edge_Swipe Ecore_Timer *start_timer; Ecore_Timer *done_timer; - - Eina_Bool event_keep; }; struct _E_Gesture_Event_Tap_Finger_Repeats @@ -276,6 +291,7 @@ struct _E_Gesture_Event int num_pressed; Eina_Bool recognized_gesture; + Eina_Bool event_keep; }; struct _E_Gesture -- 2.7.4 From 730a9db6b4c253ddd7600ab5c8c7b43f1c75ea48 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Mon, 15 May 2017 20:53:12 +0900 Subject: [PATCH 11/16] add a palm_cover gesture Change-Id: I8c981961ac07b34e1410c8d3bd1450d64c76df60 --- src/e_mod_gesture_events.c | 84 ++++++++++++++++++++++++++++++++++ src/e_mod_main.c | 109 ++++++++++++++++++++++++++++++++++++++++++++- src/e_mod_main.h | 14 +++++- 3 files changed, 204 insertions(+), 3 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index bed157e..8defaa8 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -485,6 +485,13 @@ _e_gesture_util_center_axis_get(int num_finger, int *x, int *y) int i; int calc_x = 0, calc_y = 0; + if (num_finger <= 0) + { + *x = 0; + *y = 0; + return; + } + for (i = 1; i <= num_finger; i++) { calc_x += gesture->gesture_events.base_point[i].axis.x; @@ -1304,6 +1311,81 @@ _e_gesture_process_key_up(void *event) return E_GESTURE_EVENT_STATE_PROPAGATE; } +static void +_e_gesture_send_palm_cover(void) +{ + Ecore_Event_Mouse_Button *ev_cancel; + E_Gesture_Event_Palm_Cover *palm_covers = &gesture->gesture_events.palm_covers; + int time; + int cx = 0, cy = 0; + + time = (int)(ecore_time_get()*1000); + + if (gesture->event_state == E_GESTURE_EVENT_STATE_KEEP) + { + _e_gesture_event_drop(); + } + else if (gesture->event_state == E_GESTURE_EVENT_STATE_PROPAGATE) + { + ev_cancel = E_NEW(Ecore_Event_Mouse_Button, 1); + EINA_SAFETY_ON_NULL_RETURN(ev_cancel); + + ev_cancel->timestamp = time; + ev_cancel->same_screen = 1; + + ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, ev_cancel, NULL, NULL); + } + + _e_gesture_util_center_axis_get(gesture->gesture_events.num_pressed, &cx, &cy); + + GTINF("Send palm_cover gesture to client: %p\n", palm_covers->client_info.client); + + tizen_gesture_send_palm_cover(palm_covers->client_info.res, TIZEN_GESTURE_MODE_BEGIN, time, cx, cy); + tizen_gesture_send_palm_cover(palm_covers->client_info.res, TIZEN_GESTURE_MODE_END, time, cx, cy); + + gesture->event_state = E_GESTURE_EVENT_STATE_IGNORE; + gesture->gesture_events.recognized_gesture |= TIZEN_GESTURE_TYPE_PALM_COVER; +} + +static void +_e_gesture_process_palm_cover(int val) +{ + if (gesture->gesture_events.recognized_gesture) + { + return; + } + + _e_gesture_send_palm_cover(); +} + +static void +_e_gesture_process_palm(int val) +{ + if (val <= 0) return; + if (!gesture->grabbed_gesture) return; + + if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_PALM_COVER)) + { + _e_gesture_process_palm_cover(val); + } +} + +static E_Gesture_Event_State +_e_gesture_process_axis_update(void *event) +{ + Ecore_Event_Axis_Update *ev = event; + int i; + + for (i = 0; i < ev->naxis; i++) + { + if (ev->axis[i].label == ECORE_AXIS_LABEL_TOUCH_PALM) + { + _e_gesture_process_palm((int)ev->axis[i].value); + } + } + return E_GESTURE_EVENT_STATE_PROPAGATE; +} + /* Function for checking the existing grab for a key and sending key event(s) */ Eina_Bool e_gesture_process_events(void *event, int type) @@ -1325,6 +1407,8 @@ e_gesture_process_events(void *event, int type) res = _e_gesture_process_device_add(event); else if (type == ECORE_EVENT_DEVICE_DEL) res = _e_gesture_process_device_del(event); + else if (type == ECORE_EVENT_AXIS_UPDATE) + res = _e_gesture_process_axis_update(event); else return ret; switch (res) diff --git a/src/e_mod_main.c b/src/e_mod_main.c index 896bf55..086485f 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -34,6 +34,9 @@ _e_gesture_set_client_to_list(E_Gesture_Grabbed_Client *gclient, struct wl_clien case TIZEN_GESTURE_TYPE_PINCH: gclient->pinch_fingers[fingers].client = client; break; + case TIZEN_GESTURE_TYPE_PALM_COVER: + gclient->palm_cover.client = client; + break; default: return; } @@ -251,6 +254,13 @@ _e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int } } + if ((mode & TIZEN_GESTURE_TYPE_PALM_COVER) && + (data->grabbed_gesture & TIZEN_GESTURE_TYPE_PALM_COVER)) + { + _e_gesture_set_client_to_list(data, NULL, TIZEN_GESTURE_TYPE_PALM_COVER, 0, 0, 0); + data->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_PALM_COVER; + } + if (!data->grabbed_gesture) { wl_list_remove(&data->destroy_listener->link); @@ -396,6 +406,58 @@ finish: return ret; } +static int +_e_gesture_grab_palm_cover(struct wl_client *client, struct wl_resource *resource) +{ + E_Gesture_Event *gev; + int ret = TIZEN_GESTURE_ERROR_NONE; + + gev = &gesture->gesture_events; + + GTINF("The client %p request to grab palm hover gesture\n", client); + + if (gev->palm_covers.client_info.client) + { + GTWRN("Palm hover is already grabbed by %p client\n", gev->palm_covers.client_info.client); + goto finish; + } + + e_gesture_add_client_destroy_listener(client, TIZEN_GESTURE_TYPE_PALM_COVER, 0, 0, 0); + + gev->palm_covers.client_info.client = client; + gev->palm_covers.client_info.res = resource; + + gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_PALM_COVER; + gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; + +finish: + return ret; +} + +static int +_e_gesture_ungrab_palm_cover(struct wl_client *client, struct wl_resource *resource) +{ + E_Gesture_Event *gev; + int ret = TIZEN_GESTURE_ERROR_NONE; + + GTINF("The client %p request to ungrab palm hover gesture\n", client); + + gev = &gesture->gesture_events; + + if (gev->palm_covers.client_info.client == client) + { + gev->palm_covers.client_info.client = NULL; + gev->palm_covers.client_info.client = NULL; + } + + _e_gesture_remove_client_destroy_listener(client, TIZEN_GESTURE_TYPE_PALM_COVER, 0, 0, 0); + gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_PALM_COVER; + gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; + + return ret; +} + + static void _e_gesture_cb_grab_edge_swipe(struct wl_client *client, struct wl_resource *resource, @@ -715,6 +777,28 @@ _e_gesture_cb_ungrab_pinch(struct wl_client *client, tizen_gesture_send_pinch_notify(resource, fingers, ret); } +static void +_e_gesture_cb_grab_palm_cover(struct wl_client *client, + struct wl_resource *resource) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_grab_palm_cover(client, resource); + + tizen_gesture_send_palm_cover_notify(resource, ret); +} + +static void +_e_gesture_cb_ungrab_palm_cover(struct wl_client *client, + struct wl_resource *resource) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = _e_gesture_ungrab_palm_cover(client, resource); + + tizen_gesture_send_palm_cover_notify(resource, ret); +} + static const struct tizen_gesture_interface _e_gesture_implementation = { _e_gesture_cb_grab_edge_swipe, _e_gesture_cb_ungrab_edge_swipe, @@ -723,7 +807,9 @@ static const struct tizen_gesture_interface _e_gesture_implementation = { _e_gesture_cb_grab_pan, _e_gesture_cb_ungrab_pan, _e_gesture_cb_grab_pinch, - _e_gesture_cb_ungrab_pinch + _e_gesture_cb_ungrab_pinch, + _e_gesture_cb_grab_palm_cover, + _e_gesture_cb_ungrab_palm_cover }; /* tizen_gesture global object destroy function */ @@ -1087,6 +1173,18 @@ _e_gesture_remove_client_pinch(struct wl_client *client, E_Gesture_Grabbed_Clien } static void +_e_gesture_remove_client_palm_cover(struct wl_client *client, E_Gesture_Grabbed_Client *gclient) +{ + if (gclient->palm_cover.client) + { + gesture->gesture_events.palm_covers.client_info.client = NULL; + gesture->gesture_events.palm_covers.client_info.res = NULL; + } + gclient->palm_cover.client = NULL; +} + + +static void _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data) { struct wl_client *client = data; @@ -1118,6 +1216,11 @@ _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data) _e_gesture_remove_client_pinch(client, client_data); removed_gesture |= TIZEN_GESTURE_TYPE_PINCH; } + if (client_data->grabbed_gesture & TIZEN_GESTURE_TYPE_PALM_COVER) + { + _e_gesture_remove_client_palm_cover(client, client_data); + removed_gesture |= TIZEN_GESTURE_TYPE_PALM_COVER; + } } } @@ -1129,6 +1232,8 @@ _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data) _e_gesture_pan_current_list_check(); if (removed_gesture & TIZEN_GESTURE_TYPE_PINCH) _e_gesture_pinch_current_list_check(); + if (removed_gesture & TIZEN_GESTURE_TYPE_PALM_COVER) + gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_PALM_COVER; wl_list_remove(&l->link); E_FREE(l); @@ -1141,6 +1246,8 @@ _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data) E_FREE(client_data); } } + + gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; } void diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 2afb315..23d3ea8 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_TAP+1 -#define E_GESTURE_TYPE_ALL (TIZEN_GESTURE_TYPE_EDGE_SWIPE | TIZEN_GESTURE_TYPE_TAP) +#define E_GESTURE_TYPE_MAX (TIZEN_GESTURE_TYPE_PALM_COVER + 1) +#define E_GESTURE_TYPE_ALL (TIZEN_GESTURE_TYPE_EDGE_SWIPE | TIZEN_GESTURE_TYPE_TAP | TIZEN_GESTURE_TYPE_PAN | TIZEN_GESTURE_TYPE_PINCH | TIZEN_GESTURE_TYPE_PALM_COVER) #define E_GESTURE_KEYBOARD_NAME "Gesture Keyboard" #define E_GESTURE_AUX_HINT_GESTURE_DISABLE "wm.policy.win.gesture.disable" @@ -63,6 +63,8 @@ typedef struct _E_Gesture_Event_Pan E_Gesture_Event_Pan; typedef struct _E_Gesture_Event_Pinch E_Gesture_Event_Pinch; +typedef struct _E_Gesture_Event_Palm_Cover E_Gesture_Event_Palm_Cover; + typedef struct _Coords Coords; typedef struct _Rect Rect; typedef struct _E_Gesture_Finger E_Gesture_Finger; @@ -268,6 +270,12 @@ struct _E_Gesture_Event_Pinch Ecore_Timer *move_timer; }; +struct _E_Gesture_Event_Palm_Cover +{ + E_Gesture_Event_Client client_info; + unsigned int start_time; +}; + struct _E_Gesture_Grabbed_Client { struct wl_client *client; @@ -278,6 +286,7 @@ struct _E_Gesture_Grabbed_Client 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]; + E_Gesture_Event_Client palm_cover; }; struct _E_Gesture_Event @@ -286,6 +295,7 @@ struct _E_Gesture_Event E_Gesture_Event_Tap taps; E_Gesture_Event_Pan pans; E_Gesture_Event_Pinch pinchs; + E_Gesture_Event_Palm_Cover palm_covers; E_Gesture_Finger base_point[E_GESTURE_FINGER_MAX + 2]; -- 2.7.4 From ed05cdac1a8ab7f0c97172d75edd9ecf238917ea Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Thu, 29 Jun 2017 12:51:14 +0900 Subject: [PATCH 12/16] fix incorrect syntax Change-Id: I5b896f2718f61ce97490c224bfe50d4bda29387a --- 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 086485f..8da66f7 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -83,7 +83,7 @@ e_gesture_add_client_destroy_listener(struct wl_client *client, int mode, int fi gesture->grab_client_list = eina_list_append(gesture->grab_client_list, grabbed_client); - return TIZEN_KEYROUTER_ERROR_NONE; + return TIZEN_GESTURE_ERROR_NONE; } static void @@ -819,7 +819,7 @@ _e_gesture_cb_destory(struct wl_resource *resource) /* TODO : destroy resources if exist */ } -/* tizen_keyrouter global object bind function */ +/* tizen_gesture global object bind function */ static void _e_gesture_cb_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id) { -- 2.7.4 From dabe21ae209e968be059206db4c848ce43bf6b08 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Thu, 29 Jun 2017 14:22:11 +0900 Subject: [PATCH 13/16] remove pan / pinch gesture wayland protocols - pan / pinch gestures are used in server side, so do not remove recognization part in source code Change-Id: Ie1dada871e123fd6a4966694679f5458899393ea --- src/e_mod_gesture_events.c | 78 +++++++++--------- src/e_mod_main.c | 192 +++++++++++++++++---------------------------- src/e_mod_main.h | 10 ++- 3 files changed, 114 insertions(+), 166 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index 8defaa8..c8fa1b8 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -139,7 +139,7 @@ _e_gesture_edge_swipe_cancel(void) edge_swipes->enabled_finger = 0x0; edge_swipes->edge = E_GESTURE_EDGE_NONE; - gesture->gesture_filter |= TIZEN_GESTURE_TYPE_EDGE_SWIPE; + gesture->gesture_filter |= E_GESTURE_TYPE_EDGE_SWIPE; } static void @@ -236,7 +236,7 @@ _e_gesture_send_edge_swipe(int fingers, int x, int y, int edge, struct wl_client finish: _e_gesture_edge_swipe_cancel(); - gesture->gesture_events.recognized_gesture |= TIZEN_GESTURE_TYPE_EDGE_SWIPE; + gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; } static E_Gesture_Event_State @@ -449,9 +449,7 @@ _e_gesture_pan_send(int mode, int fingers, int cx, int cy, struct wl_resource *r GTINF("Send pan gesture %d fingers. (%d, %d) to client: %p, mode: %d\n", fingers, cx, cy, client, mode); - tizen_gesture_send_pan(res, mode, fingers, cx, cy); - - gesture->gesture_events.recognized_gesture |= TIZEN_GESTURE_TYPE_PAN; + gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_PAN; } static void @@ -475,7 +473,7 @@ _e_gesture_pan_cancel(void) pans->fingers[pans->num_pan_fingers].res, pans->fingers[pans->num_pan_fingers].client); - gesture->gesture_filter |= TIZEN_GESTURE_TYPE_PAN; + gesture->gesture_filter |= E_GESTURE_TYPE_PAN; pans->state = E_GESTURE_PANPINCH_STATE_DONE; } @@ -602,8 +600,8 @@ _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_PINCH))) + !((gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PAN) || + (gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PINCH))) _e_gesture_pan_cancel(); if (gesture->gesture_events.num_pressed == 1) @@ -622,8 +620,8 @@ _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_PINCH))) + !((gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PAN) || + (gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PINCH))) _e_gesture_pan_cancel(); idx = gesture->gesture_events.num_pressed; @@ -671,7 +669,6 @@ static void _e_gesture_pinch_send(int mode, int fingers, double distance, double angle, int cx, int cy, struct wl_resource *res, struct wl_client *client) { Ecore_Event_Mouse_Button *ev_cancel; - wl_fixed_t distance_fixed, angle_fixed; if (mode == TIZEN_GESTURE_MODE_BEGIN) { @@ -686,12 +683,7 @@ _e_gesture_pinch_send(int mode, int fingers, double distance, double angle, int GTINF("Send pinch gesture (fingers: %d, distance: %lf, angle: %lf, cx: %d, cy: %d) to client: %p, mode: %d\n", fingers, distance, angle, cx, cy, client, mode); - distance_fixed = wl_fixed_from_double(distance); - angle_fixed = wl_fixed_from_double(angle); - - tizen_gesture_send_pinch(res, mode, fingers, distance_fixed, angle_fixed, cx, cy); - - gesture->gesture_events.recognized_gesture |= TIZEN_GESTURE_TYPE_PINCH; + gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_PINCH; } static void @@ -715,7 +707,7 @@ _e_gesture_pinch_cancel(void) pinchs->fingers[pinchs->num_pinch_fingers].res, pinchs->fingers[pinchs->num_pinch_fingers].client); - gesture->gesture_filter |= TIZEN_GESTURE_TYPE_PINCH; + gesture->gesture_filter |= E_GESTURE_TYPE_PINCH; pinchs->state = E_GESTURE_PANPINCH_STATE_DONE; } @@ -743,8 +735,8 @@ _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))) + !((gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PAN) || + (gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PINCH))) _e_gesture_pinch_cancel(); if (gesture->gesture_events.num_pressed == 1) @@ -763,8 +755,8 @@ _e_gesture_process_pinch_move(Ecore_Event_Mouse_Move *ev) 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) || - (gesture->gesture_events.recognized_gesture & TIZEN_GESTURE_TYPE_PINCH))) + !((gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PAN) || + (gesture->gesture_events.recognized_gesture & E_GESTURE_TYPE_PINCH))) _e_gesture_pan_cancel(); idx = gesture->gesture_events.num_pressed; @@ -869,9 +861,9 @@ _e_gesture_tap_cancel(void) taps->base_rect.y1 = 0; taps->base_rect.x2 = 0; taps->base_rect.y2 = 0; - gesture->gesture_filter |= TIZEN_GESTURE_TYPE_TAP; + gesture->gesture_filter |= E_GESTURE_TYPE_TAP; _e_gesture_event_flush(); - gesture->gesture_events.recognized_gesture &= ~TIZEN_GESTURE_TYPE_TAP; + gesture->gesture_events.recognized_gesture &= ~E_GESTURE_TYPE_TAP; } static void @@ -880,7 +872,7 @@ _e_gesture_send_tap(int fingers, int repeats, struct wl_client *client, struct w 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; + gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_TAP; _e_gesture_tap_cancel(); } @@ -928,7 +920,7 @@ _e_gesture_timer_tap_interval(void *data) 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_events.recognized_gesture &= ~E_GESTURE_TYPE_TAP; gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; } else @@ -972,7 +964,7 @@ _e_gesture_tap_done(void) if (!taps->fingers[taps->enabled_finger].enabled) _e_gesture_tap_cancel(); - if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_TAP) && + if (!(gesture->gesture_filter & E_GESTURE_TYPE_TAP) && gesture->gesture_events.num_pressed == 0) { taps->state = E_GESTURE_TAP_STATE_WAIT; @@ -1162,19 +1154,19 @@ _e_gesture_process_mouse_button_down(void *event) } } - if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_EDGE_SWIPE)) + if (!(gesture->gesture_filter & E_GESTURE_TYPE_EDGE_SWIPE)) { _e_gesture_process_edge_swipe_down(ev); } - if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_PAN)) + if (!(gesture->gesture_filter & E_GESTURE_TYPE_PAN)) { _e_gesture_process_pan_down(ev); } - if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_PINCH)) + if (!(gesture->gesture_filter & E_GESTURE_TYPE_PINCH)) { _e_gesture_process_pinch_down(ev); } - if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_TAP)) + if (!(gesture->gesture_filter & E_GESTURE_TYPE_TAP)) { _e_gesture_process_tap_down(ev); } @@ -1204,19 +1196,19 @@ _e_gesture_process_mouse_button_up(void *event) 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)) + if (!(gesture->gesture_filter & E_GESTURE_TYPE_EDGE_SWIPE)) { _e_gesture_process_edge_swipe_up(ev); } - if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_PAN)) + if (!(gesture->gesture_filter & E_GESTURE_TYPE_PAN)) { _e_gesture_process_pan_up(ev); } - if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_PINCH)) + if (!(gesture->gesture_filter & E_GESTURE_TYPE_PINCH)) { _e_gesture_process_pinch_up(ev); } - if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_TAP)) + if (!(gesture->gesture_filter & E_GESTURE_TYPE_TAP)) { _e_gesture_process_tap_up(ev); } @@ -1263,19 +1255,19 @@ _e_gesture_process_mouse_move(void *event) 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)) + if (!(gesture->gesture_filter & E_GESTURE_TYPE_EDGE_SWIPE)) { _e_gesture_process_edge_swipe_move(ev); } - if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_PAN)) + if (!(gesture->gesture_filter & E_GESTURE_TYPE_PAN)) { _e_gesture_process_pan_move(ev); } - if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_PINCH)) + if (!(gesture->gesture_filter & E_GESTURE_TYPE_PINCH)) { _e_gesture_process_pinch_move(ev); } - if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_TAP)) + if (!(gesture->gesture_filter & E_GESTURE_TYPE_TAP)) { _e_gesture_process_tap_move(ev); } @@ -1344,7 +1336,7 @@ _e_gesture_send_palm_cover(void) tizen_gesture_send_palm_cover(palm_covers->client_info.res, TIZEN_GESTURE_MODE_END, time, cx, cy); gesture->event_state = E_GESTURE_EVENT_STATE_IGNORE; - gesture->gesture_events.recognized_gesture |= TIZEN_GESTURE_TYPE_PALM_COVER; + gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_PALM_COVER; } static void @@ -1364,7 +1356,7 @@ _e_gesture_process_palm(int val) if (val <= 0) return; if (!gesture->grabbed_gesture) return; - if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_PALM_COVER)) + if (!(gesture->gesture_filter & E_GESTURE_TYPE_PALM_COVER)) { _e_gesture_process_palm_cover(val); } @@ -1430,8 +1422,8 @@ 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_TAP || - ((gesture->grabbed_gesture & TIZEN_GESTURE_TYPE_EDGE_SWIPE) && + if (gesture->grabbed_gesture & E_GESTURE_TYPE_TAP || + ((gesture->grabbed_gesture & E_GESTURE_TYPE_EDGE_SWIPE) && gesture->gesture_events.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 8da66f7..b4784dc 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -15,7 +15,7 @@ _e_gesture_set_client_to_list(E_Gesture_Grabbed_Client *gclient, struct wl_clien { switch (mode) { - case TIZEN_GESTURE_TYPE_EDGE_SWIPE: + case E_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) @@ -25,16 +25,16 @@ _e_gesture_set_client_to_list(E_Gesture_Grabbed_Client *gclient, struct wl_clien if (edge & TIZEN_GESTURE_EDGE_LEFT) gclient->edge_swipe_fingers[fingers].edge[E_GESTURE_EDGE_LEFT].client = client; break; - case TIZEN_GESTURE_TYPE_TAP: + case E_GESTURE_TYPE_TAP: gclient->tap_fingers[fingers].repeats[repeat].client = client; break; - case TIZEN_GESTURE_TYPE_PAN: + case E_GESTURE_TYPE_PAN: gclient->pan_fingers[fingers].client = client; break; - case TIZEN_GESTURE_TYPE_PINCH: + case E_GESTURE_TYPE_PINCH: gclient->pinch_fingers[fingers].client = client; break; - case TIZEN_GESTURE_TYPE_PALM_COVER: + case E_GESTURE_TYPE_PALM_COVER: gclient->palm_cover.client = client; break; default: @@ -104,7 +104,7 @@ _e_gesture_edge_swipe_current_list_check(void) } gev->edge_swipes.fingers[i].enabled = EINA_FALSE; } - gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_EDGE_SWIPE; + gesture->grabbed_gesture &= ~E_GESTURE_TYPE_EDGE_SWIPE; if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE; } @@ -116,14 +116,14 @@ _e_gesture_tap_current_list_check(void) gev = &gesture->gesture_events; - gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_TAP; + gesture->grabbed_gesture &= ~E_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; + gesture->grabbed_gesture |= E_GESTURE_TYPE_TAP; gev->taps.state = E_GESTURE_TAP_STATE_READY; gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; break; @@ -141,14 +141,14 @@ _e_gesture_pan_current_list_check(void) gev = &gesture->gesture_events; - gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_TAP; + gesture->grabbed_gesture &= ~E_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; + gesture->grabbed_gesture |= E_GESTURE_TYPE_PAN; gev->pans.state = E_GESTURE_PANPINCH_STATE_READY; break; } @@ -163,14 +163,14 @@ _e_gesture_pinch_current_list_check(void) gev = &gesture->gesture_events; - gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_PINCH; + gesture->grabbed_gesture &= ~E_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; + gesture->grabbed_gesture |= E_GESTURE_TYPE_PINCH; gev->pinchs.state = E_GESTURE_PANPINCH_STATE_READY; break; } @@ -188,11 +188,11 @@ _e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int { if (data->client == client) { - if ((mode & TIZEN_GESTURE_TYPE_EDGE_SWIPE) && - (data->grabbed_gesture & TIZEN_GESTURE_TYPE_EDGE_SWIPE)) + if ((mode & E_GESTURE_TYPE_EDGE_SWIPE) && + (data->grabbed_gesture & E_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; + _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge, 0); + data->grabbed_gesture &= ~E_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 || @@ -200,65 +200,65 @@ _e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int 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; + data->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; break; } } } - if ((mode & TIZEN_GESTURE_TYPE_TAP) && - (data->grabbed_gesture & TIZEN_GESTURE_TYPE_TAP)) + if ((mode & E_GESTURE_TYPE_TAP) && + (data->grabbed_gesture & E_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; + _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_TAP, fingers, 0, repeat); + data->grabbed_gesture &= ~E_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; + data->grabbed_gesture |= E_GESTURE_TYPE_TAP; break; } } } } - if ((mode & TIZEN_GESTURE_TYPE_PAN) && - (data->grabbed_gesture & TIZEN_GESTURE_TYPE_PAN)) + if ((mode & E_GESTURE_TYPE_PAN) && + (data->grabbed_gesture & E_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; + _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_PAN, fingers, 0, 0); + data->grabbed_gesture &= ~E_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; + data->grabbed_gesture |= E_GESTURE_TYPE_PAN; break; } } } - if ((mode & TIZEN_GESTURE_TYPE_PINCH) && - (data->grabbed_gesture & TIZEN_GESTURE_TYPE_PINCH)) + if ((mode & E_GESTURE_TYPE_PINCH) && + (data->grabbed_gesture & E_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; + _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_PINCH, fingers, 0, 0); + data->grabbed_gesture &= ~E_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; + data->grabbed_gesture |= E_GESTURE_TYPE_PINCH; break; } } } - if ((mode & TIZEN_GESTURE_TYPE_PALM_COVER) && - (data->grabbed_gesture & TIZEN_GESTURE_TYPE_PALM_COVER)) + if ((mode & E_GESTURE_TYPE_PALM_COVER) && + (data->grabbed_gesture & E_GESTURE_TYPE_PALM_COVER)) { - _e_gesture_set_client_to_list(data, NULL, TIZEN_GESTURE_TYPE_PALM_COVER, 0, 0, 0); - data->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_PALM_COVER; + _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_PALM_COVER, 0, 0, 0); + data->grabbed_gesture &= ~E_GESTURE_TYPE_PALM_COVER; } if (!data->grabbed_gesture) @@ -272,6 +272,7 @@ _e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int } } +#if 0 static int _e_gesture_grab_pan(struct wl_client *client, struct wl_resource *resource, uint32_t fingers) { @@ -296,13 +297,13 @@ _e_gesture_grab_pan(struct wl_client *client, struct wl_resource *resource, uint goto finish; } - e_gesture_add_client_destroy_listener(client, TIZEN_GESTURE_TYPE_PAN, fingers, 0, 0); + e_gesture_add_client_destroy_listener(client, E_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; + gesture->grabbed_gesture |= E_GESTURE_TYPE_PAN; gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; finish: @@ -332,7 +333,7 @@ _e_gesture_ungrab_pan(struct wl_client *client, struct wl_resource *resource, ui gev->pans.fingers[fingers].res = NULL; } - _e_gesture_remove_client_destroy_listener(client, TIZEN_GESTURE_TYPE_PAN, fingers, 0, 0); + _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_PAN, fingers, 0, 0); _e_gesture_pan_current_list_check(); finish: @@ -363,13 +364,13 @@ _e_gesture_grab_pinch(struct wl_client *client, struct wl_resource *resource, ui goto finish; } - e_gesture_add_client_destroy_listener(client, TIZEN_GESTURE_TYPE_PINCH, fingers, 0, 0); + e_gesture_add_client_destroy_listener(client, E_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; + gesture->grabbed_gesture |= E_GESTURE_TYPE_PINCH; gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; finish: @@ -399,12 +400,13 @@ _e_gesture_ungrab_pinch(struct wl_client *client, struct wl_resource *resource, gev->pinchs.fingers[fingers].res = NULL; } - _e_gesture_remove_client_destroy_listener(client, TIZEN_GESTURE_TYPE_PINCH, fingers, 0, 0); + _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_PINCH, fingers, 0, 0); _e_gesture_pinch_current_list_check(); finish: return ret; } +#endif static int _e_gesture_grab_palm_cover(struct wl_client *client, struct wl_resource *resource) @@ -422,12 +424,12 @@ _e_gesture_grab_palm_cover(struct wl_client *client, struct wl_resource *resourc goto finish; } - e_gesture_add_client_destroy_listener(client, TIZEN_GESTURE_TYPE_PALM_COVER, 0, 0, 0); + e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_PALM_COVER, 0, 0, 0); gev->palm_covers.client_info.client = client; gev->palm_covers.client_info.res = resource; - gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_PALM_COVER; + gesture->grabbed_gesture |= E_GESTURE_TYPE_PALM_COVER; gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; finish: @@ -450,8 +452,8 @@ _e_gesture_ungrab_palm_cover(struct wl_client *client, struct wl_resource *resou gev->palm_covers.client_info.client = NULL; } - _e_gesture_remove_client_destroy_listener(client, TIZEN_GESTURE_TYPE_PALM_COVER, 0, 0, 0); - gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_PALM_COVER; + _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_PALM_COVER, 0, 0, 0); + gesture->grabbed_gesture &= ~E_GESTURE_TYPE_PALM_COVER; gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; return ret; @@ -528,8 +530,8 @@ _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, 0); - gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_EDGE_SWIPE; + e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge & ~grabbed_edge, 0); + gesture->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; gev->edge_swipes.fingers[fingers].enabled = EINA_TRUE; if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; gev->edge_swipes.enabled_edge |= grabbed_edge; @@ -617,7 +619,7 @@ _e_gesture_cb_ungrab_edge_swipe(struct wl_client *client, if (edge & ~ungrabbed_edge) { - _e_gesture_remove_client_destroy_listener(client, TIZEN_GESTURE_TYPE_EDGE_SWIPE, fingers, edge & ~ungrabbed_edge, 0); + _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge & ~ungrabbed_edge, 0); _e_gesture_edge_swipe_current_list_check(); } @@ -669,14 +671,14 @@ _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); + e_gesture_add_client_destroy_listener(client, E_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) gev->taps.fingers[fingers].max_repeats = repeats; - gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_TAP; + gesture->grabbed_gesture |= E_GESTURE_TYPE_TAP; gev->taps.state = E_GESTURE_TAP_STATE_READY; gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; @@ -722,7 +724,7 @@ _e_gesture_cb_ungrab_tap(struct wl_client *client, } 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_remove_client_destroy_listener(client, E_GESTURE_TYPE_TAP, fingers, 0, repeats); _e_gesture_tap_current_list_check(); finish: @@ -730,54 +732,6 @@ finish: } static void -_e_gesture_cb_grab_pan(struct wl_client *client, - struct wl_resource *resource, - uint32_t fingers) -{ - int ret = TIZEN_GESTURE_ERROR_NONE; - - ret = _e_gesture_grab_pan(client, resource, fingers); - - 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 fingers) -{ - int ret = TIZEN_GESTURE_ERROR_NONE; - - ret = _e_gesture_ungrab_pan(client, resource, fingers); - - 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 fingers) -{ - int ret = TIZEN_GESTURE_ERROR_NONE; - - ret = _e_gesture_grab_pinch(client, resource, fingers); - - 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 fingers) -{ - int ret = TIZEN_GESTURE_ERROR_NONE; - - ret = _e_gesture_ungrab_pinch(client, resource, fingers); - - tizen_gesture_send_pinch_notify(resource, fingers, ret); -} - -static void _e_gesture_cb_grab_palm_cover(struct wl_client *client, struct wl_resource *resource) { @@ -804,10 +758,6 @@ static const struct tizen_gesture_interface _e_gesture_implementation = { _e_gesture_cb_ungrab_edge_swipe, _e_gesture_cb_grab_tap, _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, _e_gesture_cb_grab_palm_cover, _e_gesture_cb_ungrab_palm_cover }; @@ -1022,7 +972,7 @@ _e_gesture_init(E_Module *m) gesture->gesture_events.event_keep = gconfig->conf->event_keep; if (gconfig->conf->edge_swipe.default_enable_back) { - gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_EDGE_SWIPE; + gesture->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; 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; @@ -1196,44 +1146,44 @@ _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data) { if (client_data->client == client) { - if (client_data->grabbed_gesture & TIZEN_GESTURE_TYPE_EDGE_SWIPE) + if (client_data->grabbed_gesture & E_GESTURE_TYPE_EDGE_SWIPE) { _e_gesture_remove_client_edge_swipe(client, client_data); - removed_gesture |= TIZEN_GESTURE_TYPE_EDGE_SWIPE; + removed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; } - if (client_data->grabbed_gesture & TIZEN_GESTURE_TYPE_TAP) + if (client_data->grabbed_gesture & E_GESTURE_TYPE_TAP) { _e_gesture_remove_client_tap(client, client_data); - removed_gesture |= TIZEN_GESTURE_TYPE_TAP; + removed_gesture |= E_GESTURE_TYPE_TAP; } - if (client_data->grabbed_gesture & TIZEN_GESTURE_TYPE_PAN) + if (client_data->grabbed_gesture & E_GESTURE_TYPE_PAN) { _e_gesture_remove_client_pan(client, client_data); - removed_gesture |= TIZEN_GESTURE_TYPE_PAN; + removed_gesture |= E_GESTURE_TYPE_PAN; } - if (client_data->grabbed_gesture & TIZEN_GESTURE_TYPE_PINCH) + if (client_data->grabbed_gesture & E_GESTURE_TYPE_PINCH) { _e_gesture_remove_client_pinch(client, client_data); - removed_gesture |= TIZEN_GESTURE_TYPE_PINCH; + removed_gesture |= E_GESTURE_TYPE_PINCH; } - if (client_data->grabbed_gesture & TIZEN_GESTURE_TYPE_PALM_COVER) + if (client_data->grabbed_gesture & E_GESTURE_TYPE_PALM_COVER) { _e_gesture_remove_client_palm_cover(client, client_data); - removed_gesture |= TIZEN_GESTURE_TYPE_PALM_COVER; + removed_gesture |= E_GESTURE_TYPE_PALM_COVER; } } } - if (removed_gesture & TIZEN_GESTURE_TYPE_EDGE_SWIPE) + if (removed_gesture & E_GESTURE_TYPE_EDGE_SWIPE) _e_gesture_edge_swipe_current_list_check(); - if (removed_gesture & TIZEN_GESTURE_TYPE_TAP) + if (removed_gesture & E_GESTURE_TYPE_TAP) _e_gesture_tap_current_list_check(); - if (removed_gesture & TIZEN_GESTURE_TYPE_PAN) + if (removed_gesture & E_GESTURE_TYPE_PAN) _e_gesture_pan_current_list_check(); - if (removed_gesture & TIZEN_GESTURE_TYPE_PINCH) + if (removed_gesture & E_GESTURE_TYPE_PINCH) _e_gesture_pinch_current_list_check(); - if (removed_gesture & TIZEN_GESTURE_TYPE_PALM_COVER) - gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_PALM_COVER; + if (removed_gesture & E_GESTURE_TYPE_PALM_COVER) + gesture->grabbed_gesture &= ~E_GESTURE_TYPE_PALM_COVER; wl_list_remove(&l->link); E_FREE(l); diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 23d3ea8..49e39ea 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -11,9 +11,15 @@ #define GTINF(msg, ARG...) INF("[tizen_gesture][%s:%d] "msg, __FUNCTION__, __LINE__, ##ARG) #define GTDBG(msg, ARG...) DBG("[tizen_gesture][%s:%d] "msg, __FUNCTION__, __LINE__, ##ARG) +#define E_GESTURE_TYPE_EDGE_SWIPE TIZEN_GESTURE_TYPE_EDGE_SWIPE +#define E_GESTURE_TYPE_TAP TIZEN_GESTURE_TYPE_TAP +#define E_GESTURE_TYPE_PALM_COVER TIZEN_GESTURE_TYPE_PALM_COVER +#define E_GESTURE_TYPE_PAN (TIZEN_GESTURE_TYPE_PALM_COVER << 1) +#define E_GESTURE_TYPE_PINCH (TIZEN_GESTURE_TYPE_PALM_COVER << 2) + #define E_GESTURE_FINGER_MAX 3 -#define E_GESTURE_TYPE_MAX (TIZEN_GESTURE_TYPE_PALM_COVER + 1) -#define E_GESTURE_TYPE_ALL (TIZEN_GESTURE_TYPE_EDGE_SWIPE | TIZEN_GESTURE_TYPE_TAP | TIZEN_GESTURE_TYPE_PAN | TIZEN_GESTURE_TYPE_PINCH | TIZEN_GESTURE_TYPE_PALM_COVER) +#define E_GESTURE_TYPE_MAX (E_GESTURE_TYPE_PINCH + 1) +#define E_GESTURE_TYPE_ALL (E_GESTURE_TYPE_EDGE_SWIPE | E_GESTURE_TYPE_TAP | E_GESTURE_TYPE_PAN | E_GESTURE_TYPE_PINCH | E_GESTURE_TYPE_PALM_COVER) #define E_GESTURE_KEYBOARD_NAME "Gesture Keyboard" #define E_GESTURE_AUX_HINT_GESTURE_DISABLE "wm.policy.win.gesture.disable" -- 2.7.4 From 83378597018a5e19aaf71e0fbe3eac7dfcdc64f1 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Thu, 6 Jul 2017 11:41:37 +0900 Subject: [PATCH 14/16] grab/ungrab edge_swipe with given area Change-Id: I8c3ef8f4d0b60b026c21aa8fb64793c812057b57 --- src/e_mod_gesture_events.c | 116 ++++++++++---- src/e_mod_main.c | 391 +++++++++++++++++++++++++-------------------- src/e_mod_main.h | 8 +- 3 files changed, 306 insertions(+), 209 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index c8fa1b8..0ba3154 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -185,27 +185,14 @@ _e_gesture_send_back_key(Eina_Bool pressed) } static void -_e_gesture_send_edge_swipe(int fingers, int x, int y, int edge, struct wl_client *client, struct wl_resource *res) +_e_gesture_send_edge_swipe(int fingers, int x, int y, int edge) { - enum tizen_gesture_edge dir = 0; Ecore_Event_Mouse_Button *ev_cancel; E_Gesture_Conf_Edd *conf = gesture->config->conf; - - switch (edge) - { - case E_GESTURE_EDGE_TOP: - dir = TIZEN_GESTURE_EDGE_TOP; - break; - case E_GESTURE_EDGE_LEFT: - dir = TIZEN_GESTURE_EDGE_LEFT; - break; - case E_GESTURE_EDGE_BOTTOM: - dir = TIZEN_GESTURE_EDGE_BOTTOM; - break; - case E_GESTURE_EDGE_RIGHT: - dir = TIZEN_GESTURE_EDGE_RIGHT; - break; - } + Eina_List *l; + E_Gesture_Event_Edge_Swipe_Finger_Edge *edata; + E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; + int bp = -1; if (gesture->gesture_events.event_keep) { @@ -222,8 +209,6 @@ _e_gesture_send_edge_swipe(int fingers, int x, int y, int edge, struct wl_client ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, ev_cancel, NULL, NULL); } - GTINF("Send edge_swipe gesture (edge: %d) to client: %p\n", dir, client); - if (conf->edge_swipe.default_enable_back && edge == E_GESTURE_EDGE_TOP) { @@ -231,8 +216,27 @@ _e_gesture_send_edge_swipe(int fingers, int x, int y, int edge, struct wl_client _e_gesture_send_back_key(EINA_FALSE); goto finish; } - - tizen_gesture_send_edge_swipe(res, fingers, TIZEN_GESTURE_MODE_DONE, x, y, dir); + + if (edge == TIZEN_GESTURE_EDGE_TOP || + edge == TIZEN_GESTURE_EDGE_BOTTOM) + { + bp = x; + } + else if (edge == TIZEN_GESTURE_EDGE_RIGHT || + edge == TIZEN_GESTURE_EDGE_LEFT) + { + bp = y; + } + + EINA_LIST_FOREACH(edge_swipes->fingers[fingers].edge[edge], l, edata) + { + if (bp >= edata->sp && bp <= edata->ep) + { + GTINF("Send edge_swipe gesture (fingers: %d, edge: %d) to client: %p\n", fingers, edge, edata->client); + tizen_gesture_send_edge_swipe(edata->res, TIZEN_GESTURE_MODE_DONE, fingers, x, y, edge); + break; + } + } finish: _e_gesture_edge_swipe_cancel(); @@ -252,6 +256,52 @@ _e_gesture_process_device_del(void *event) } static Eina_Bool +_e_gesture_event_edge_swipe_edge_check(unsigned int edge) +{ + E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; + int idx = gesture->gesture_events.num_pressed; + E_Gesture_Conf_Edd *conf = gesture->config->conf; + Eina_List *l; + E_Gesture_Event_Edge_Swipe_Finger_Edge *edata; + Coords coords; + + if ((conf->edge_swipe.default_enable_back) && + (edge == TIZEN_GESTURE_EDGE_TOP || + ((edge_swipes->combined_keycode == conf->edge_swipe.compose_key) && + (edge_swipes->edge == TIZEN_GESTURE_EDGE_LEFT)))) + { + return EINA_TRUE; + } + + coords.x = edge_swipes->fingers[idx].start.x; + coords.y = edge_swipes->fingers[idx].start.y; + + EINA_LIST_FOREACH(edge_swipes->fingers[idx].edge[edge], l, edata) + { + if (edge == TIZEN_GESTURE_EDGE_TOP || + edge == TIZEN_GESTURE_EDGE_BOTTOM) + { + if ((coords.x >= edata->sp) && + (coords.x <= edata->ep)) + { + return EINA_TRUE; + } + } + else if ((edge == TIZEN_GESTURE_EDGE_LEFT) || + (edge == TIZEN_GESTURE_EDGE_RIGHT)) + { + if (coords.y >= edata->sp && + coords.y <= edata->ep) + { + return EINA_TRUE; + } + } + } + + return EINA_FALSE; +} + +static Eina_Bool _e_gesture_timer_edge_swipe_start(void *data) { E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; @@ -264,10 +314,8 @@ _e_gesture_timer_edge_swipe_start(void *data) { edge_swipes->enabled_finger &= ~(1 << i); } - if ((edge_swipes->edge == E_GESTURE_EDGE_TOP && !edge_swipes->fingers[idx].edge[E_GESTURE_EDGE_TOP].client) || - (edge_swipes->edge == E_GESTURE_EDGE_LEFT && !edge_swipes->fingers[idx].edge[E_GESTURE_EDGE_LEFT].client) || - (edge_swipes->edge == E_GESTURE_EDGE_BOTTOM && !edge_swipes->fingers[idx].edge[E_GESTURE_EDGE_BOTTOM].client) || - (edge_swipes->edge == E_GESTURE_EDGE_RIGHT && !edge_swipes->fingers[idx].edge[E_GESTURE_EDGE_RIGHT].client)) + if ((edge_swipes->enabled_finger == 0x0) || + (_e_gesture_event_edge_swipe_edge_check(edge_swipes->edge) == EINA_FALSE)) { if (gesture->gesture_events.event_keep) _e_gesture_event_flush(); @@ -303,7 +351,7 @@ _e_gesture_process_edge_swipe_down(Ecore_Event_Mouse_Button *ev) if (gesture->gesture_events.num_pressed == 1) { - for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) + for (i = 1; i < E_GESTURE_FINGER_MAX+1; i++) { if (edge_swipes->fingers[i].enabled) { @@ -316,11 +364,11 @@ _e_gesture_process_edge_swipe_down(Ecore_Event_Mouse_Button *ev) else if (ev->y > e_comp->h - conf->edge_swipe.area_offset) edge_swipes->edge = E_GESTURE_EDGE_BOTTOM; else if (ev->x < conf->edge_swipe.area_offset) - 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 (ev->x > e_comp->w - conf->edge_swipe.area_offset) + edge_swipes->edge = E_GESTURE_EDGE_RIGHT; - if (!((1 << (edge_swipes->edge - 1)) & edge_swipes->enabled_edge)) + if (!((1 << (edge_swipes->edge)) & edge_swipes->enabled_edge)) edge_swipes->edge = E_GESTURE_EDGE_NONE; if (edge_swipes->edge != E_GESTURE_EDGE_NONE) @@ -375,7 +423,7 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) } if (diff.y > conf->edge_swipe.max_length) { - _e_gesture_send_edge_swipe(idx, edge_swipes->fingers[idx].start.x, edge_swipes->fingers[idx].start.y, edge_swipes->edge, edge_swipes->fingers[idx].edge[E_GESTURE_EDGE_TOP].client, edge_swipes->fingers[idx].edge[E_GESTURE_EDGE_TOP].res); + _e_gesture_send_edge_swipe(idx, edge_swipes->fingers[idx].start.x, edge_swipes->fingers[idx].start.y, E_GESTURE_EDGE_TOP); } break; case E_GESTURE_EDGE_LEFT: @@ -388,7 +436,7 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) } if (diff.x > conf->edge_swipe.max_length) { - _e_gesture_send_edge_swipe(idx, edge_swipes->fingers[idx].start.x, edge_swipes->fingers[idx].start.y, edge_swipes->edge, edge_swipes->fingers[idx].edge[E_GESTURE_EDGE_LEFT].client, edge_swipes->fingers[idx].edge[E_GESTURE_EDGE_LEFT].res); + _e_gesture_send_edge_swipe(idx, edge_swipes->fingers[idx].start.x, edge_swipes->fingers[idx].start.y, E_GESTURE_EDGE_LEFT); } break; case E_GESTURE_EDGE_BOTTOM: @@ -401,7 +449,7 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) } if (diff.y > conf->edge_swipe.max_length) { - _e_gesture_send_edge_swipe(idx, edge_swipes->fingers[idx].start.x, edge_swipes->fingers[idx].start.y, edge_swipes->edge, edge_swipes->fingers[idx].edge[E_GESTURE_EDGE_BOTTOM].client, edge_swipes->fingers[idx].edge[E_GESTURE_EDGE_BOTTOM].res); + _e_gesture_send_edge_swipe(idx, edge_swipes->fingers[idx].start.x, edge_swipes->fingers[idx].start.y, E_GESTURE_EDGE_BOTTOM); } break; case E_GESTURE_EDGE_RIGHT: @@ -414,7 +462,7 @@ _e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) } if (diff.x > conf->edge_swipe.max_length) { - _e_gesture_send_edge_swipe(idx, edge_swipes->fingers[idx].start.x, edge_swipes->fingers[idx].start.y, edge_swipes->edge, edge_swipes->fingers[idx].edge[E_GESTURE_EDGE_RIGHT].client, edge_swipes->fingers[idx].edge[E_GESTURE_EDGE_RIGHT].res); + _e_gesture_send_edge_swipe(idx, edge_swipes->fingers[idx].start.x, edge_swipes->fingers[idx].start.y, E_GESTURE_EDGE_RIGHT); } break; default: diff --git a/src/e_mod_main.c b/src/e_mod_main.c index b4784dc..68b8ad2 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -10,20 +10,52 @@ 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 Eina_Bool +_e_gesture_edge_swipe_boundary_check(E_Gesture_Event_Edge_Swipe_Finger *fingers, unsigned int edge, int sp, int ep) +{ + Eina_List *l; + E_Gesture_Event_Edge_Swipe_Finger_Edge *edata; + E_Gesture_Conf_Edd *conf = gesture->config->conf; + + if ((conf->edge_swipe.default_enable_back) && + (edge == E_GESTURE_EDGE_TOP)) + { + return EINA_FALSE; + } + + EINA_LIST_FOREACH(fingers->edge[edge], l, edata) + { + if (!(sp > edata->ep || ep < edata->sp)) + return EINA_FALSE; + } + + return EINA_TRUE; +} + static void -_e_gesture_set_client_to_list(E_Gesture_Grabbed_Client *gclient, struct wl_client *client, int mode, int fingers, int edge, int repeat) +_e_gesture_edge_swipe_grab_add(E_Gesture_Event_Edge_Swipe_Finger *fingers, struct wl_client *client, struct wl_resource *res, unsigned int edge, unsigned int sp, unsigned int ep) +{ + E_Gesture_Event_Edge_Swipe_Finger_Edge *edata; + + edata = E_NEW(E_Gesture_Event_Edge_Swipe_Finger_Edge, 1); + EINA_SAFETY_ON_NULL_RETURN(edata); + + edata->client = client; + edata->res = res; + edata->sp = sp; + edata->ep = ep; + + fingers->edge[edge] = eina_list_append(fingers->edge[edge], edata); +} + +static void +_e_gesture_set_client_to_list(E_Gesture_Grabbed_Client *gclient, struct wl_client *client, int mode, int fingers, int edge, int repeat, int sp, int ep) { switch (mode) { case E_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; + _e_gesture_edge_swipe_grab_add(&gclient->edge_swipe_fingers[fingers], client, NULL, edge, sp, ep); + gclient->edge_swipe_fingers[fingers].enabled = EINA_TRUE; break; case E_GESTURE_TYPE_TAP: gclient->tap_fingers[fingers].repeats[repeat].client = client; @@ -45,7 +77,7 @@ _e_gesture_set_client_to_list(E_Gesture_Grabbed_Client *gclient, struct wl_clien /* Function for registering wl_client destroy listener */ int -e_gesture_add_client_destroy_listener(struct wl_client *client, int mode, int fingers, unsigned int edge, unsigned int repeat) +e_gesture_add_client_destroy_listener(struct wl_client *client, int mode, int fingers, unsigned int edge, unsigned int repeat, int sp, int ep) { struct wl_listener *destroy_listener = NULL; Eina_List *l; @@ -55,7 +87,7 @@ e_gesture_add_client_destroy_listener(struct wl_client *client, int mode, int fi { if (data->client == client) { - _e_gesture_set_client_to_list(data, client, mode, fingers, edge, repeat); + _e_gesture_set_client_to_list(data, client, mode, fingers, edge, repeat, sp, ep); return TIZEN_GESTURE_ERROR_NONE; } @@ -79,7 +111,7 @@ e_gesture_add_client_destroy_listener(struct wl_client *client, int mode, int fi wl_client_add_destroy_listener(client, destroy_listener); grabbed_client->client = client; grabbed_client->destroy_listener = destroy_listener; - _e_gesture_set_client_to_list(grabbed_client, client, mode, fingers, edge, repeat); + _e_gesture_set_client_to_list(grabbed_client, client, mode, fingers, edge, repeat, sp, ep); gesture->grab_client_list = eina_list_append(gesture->grab_client_list, grabbed_client); @@ -97,7 +129,7 @@ _e_gesture_edge_swipe_current_list_check(void) { for (j = 0; j < E_GESTURE_EDGE_MAX+1; j++) { - if (gev->edge_swipes.fingers[i].edge[j].client) + if (eina_list_count(gev->edge_swipes.fingers[i].edge[j]) != 0) { return; } @@ -178,7 +210,7 @@ _e_gesture_pinch_current_list_check(void) } static void -_e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int mode, unsigned int fingers, unsigned int edge, unsigned int repeat) +_e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int mode, unsigned int fingers, unsigned int edge, unsigned int repeat, int sp, int ep) { Eina_List *l, *l_next; E_Gesture_Grabbed_Client *data; @@ -191,14 +223,14 @@ _e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int if ((mode & E_GESTURE_TYPE_EDGE_SWIPE) && (data->grabbed_gesture & E_GESTURE_TYPE_EDGE_SWIPE)) { - _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge, 0); + _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge, 0, sp, ep); data->grabbed_gesture &= ~E_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) + if (data->edge_swipe_fingers[i].enabled || + data->edge_swipe_fingers[i].enabled || + data->edge_swipe_fingers[i].enabled || + data->edge_swipe_fingers[i].enabled) { data->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; break; @@ -209,7 +241,7 @@ _e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int if ((mode & E_GESTURE_TYPE_TAP) && (data->grabbed_gesture & E_GESTURE_TYPE_TAP)) { - _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_TAP, fingers, 0, repeat); + _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_TAP, fingers, 0, repeat, 0, 0); data->grabbed_gesture &= ~E_GESTURE_TYPE_TAP; for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) { @@ -227,7 +259,7 @@ _e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int if ((mode & E_GESTURE_TYPE_PAN) && (data->grabbed_gesture & E_GESTURE_TYPE_PAN)) { - _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_PAN, fingers, 0, 0); + _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_PAN, fingers, 0, 0, 0, 0); data->grabbed_gesture &= ~E_GESTURE_TYPE_PAN; for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) { @@ -242,7 +274,7 @@ _e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int if ((mode & E_GESTURE_TYPE_PINCH) && (data->grabbed_gesture & E_GESTURE_TYPE_PINCH)) { - _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_PINCH, fingers, 0, 0); + _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_PINCH, fingers, 0, 0, 0, 0); data->grabbed_gesture &= ~E_GESTURE_TYPE_PINCH; for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) { @@ -257,7 +289,7 @@ _e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int if ((mode & E_GESTURE_TYPE_PALM_COVER) && (data->grabbed_gesture & E_GESTURE_TYPE_PALM_COVER)) { - _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_PALM_COVER, 0, 0, 0); + _e_gesture_set_client_to_list(data, NULL, E_GESTURE_TYPE_PALM_COVER, 0, 0, 0, 0, 0); data->grabbed_gesture &= ~E_GESTURE_TYPE_PALM_COVER; } @@ -424,7 +456,7 @@ _e_gesture_grab_palm_cover(struct wl_client *client, struct wl_resource *resourc goto finish; } - e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_PALM_COVER, 0, 0, 0); + e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_PALM_COVER, 0, 0, 0, 0, 0); gev->palm_covers.client_info.client = client; gev->palm_covers.client_info.res = resource; @@ -452,108 +484,127 @@ _e_gesture_ungrab_palm_cover(struct wl_client *client, struct wl_resource *resou gev->palm_covers.client_info.client = NULL; } - _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_PALM_COVER, 0, 0, 0); + _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_PALM_COVER, 0, 0, 0, 0, 0); gesture->grabbed_gesture &= ~E_GESTURE_TYPE_PALM_COVER; gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; return ret; } - static void _e_gesture_cb_grab_edge_swipe(struct wl_client *client, struct wl_resource *resource, - uint32_t fingers, uint32_t edge) + uint32_t fingers, uint32_t edge, uint32_t edge_size, + uint32_t start_point, uint32_t end_point) { E_Gesture_Event *gev; - unsigned int grabbed_edge = 0x0; + int sp = 0, ep = 0; + unsigned int ret = TIZEN_GESTURE_ERROR_NONE; - GTINF("client %p is request grab gesture, fingers: %d, edge: 0x%x\n", client, fingers, edge); + GTINF("client %p is request grab gesture, fingers: %d, edge: 0x%x, edge_size: %d, point( %d - %d)\n", client, fingers, edge, edge_size, start_point, end_point); if (fingers > E_GESTURE_FINGER_MAX) { GTWRN("Do not support %d fingers (max: %d)\n", fingers, E_GESTURE_FINGER_MAX); - tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, edge, TIZEN_GESTURE_ERROR_INVALID_DATA); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; goto out; } gev = &gesture->gesture_events; - if (edge & TIZEN_GESTURE_EDGE_TOP) - { - if (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_TOP].client) - { - grabbed_edge |= TIZEN_GESTURE_EDGE_TOP; - } - else - { - gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_TOP].client = client; - gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_TOP].res = resource; - } - } - if (edge & TIZEN_GESTURE_EDGE_RIGHT) - { - if (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_RIGHT].client) - { - grabbed_edge |= TIZEN_GESTURE_EDGE_RIGHT; - } - else - { - gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_RIGHT].client = client; - gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_RIGHT].res = resource; - } - } - if (edge & TIZEN_GESTURE_EDGE_BOTTOM) - { - if (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_BOTTOM].client) - { - grabbed_edge |= TIZEN_GESTURE_EDGE_BOTTOM; - } - else - { - gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_BOTTOM].client = client; - gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_BOTTOM].res = resource; - } - } - if (edge & TIZEN_GESTURE_EDGE_LEFT) - { - if (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_LEFT].client) - { - grabbed_edge |= TIZEN_GESTURE_EDGE_LEFT; - } - else - { - gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_LEFT].client = client; - gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_LEFT].res = resource; - } - } - - 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, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge & ~grabbed_edge, 0); - gesture->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; - gev->edge_swipes.fingers[fingers].enabled = EINA_TRUE; - if (gev->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); + if (edge < TIZEN_GESTURE_EDGE_TOP || edge > TIZEN_GESTURE_EDGE_LEFT) + { + GTWRN("Invalid edge(%d)\n", edge); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto out; + } + + if (edge_size == TIZEN_GESTURE_EDGE_SIZE_PARTIAL) + { + sp = start_point; + ep = end_point; + if (((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) && + (ep > e_comp->w)) + ep = e_comp->w; + else if (((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) && + (ep > e_comp->h)) + ep = e_comp->h; + } + else if (edge_size == TIZEN_GESTURE_EDGE_SIZE_FULL) + { + sp = 0; + if ((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) + ep = e_comp->w; + else if ((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) + ep = e_comp->h; + } + else + { + GTWRN("Invalid edge_size(%d)\n", edge_size); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto out; + } + + if (_e_gesture_edge_swipe_boundary_check(&gev->edge_swipes.fingers[fingers], edge, sp, ep)) + { + _e_gesture_edge_swipe_grab_add(&gev->edge_swipes.fingers[fingers], client, resource, edge, sp, ep); + + e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge, 0, sp, ep); + + gesture->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; + gev->edge_swipes.fingers[fingers].enabled = EINA_TRUE; + if (gev->event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; + gev->edge_swipes.enabled_edge |= (1 << edge); + + ret = TIZEN_GESTURE_ERROR_NONE; + } + else + { + ret = TIZEN_GESTURE_ERROR_GRABBED_ALREADY; + } out: + tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, edge, edge_size, start_point, end_point, ret); return; } +static Eina_Bool +_e_gesture_edge_swipe_grabbed_client_check(struct wl_client *client) +{ + Eina_List *l; + E_Gesture_Event *gev; + int i, j; + E_Gesture_Event_Edge_Swipe_Finger_Edge *edata; + + gev = &gesture->gesture_events; + + for (i = 1; i < E_GESTURE_FINGER_MAX + 1; i++) + { + for (j = 1; j < E_GESTURE_EDGE_MAX + 1; j++) + { + EINA_LIST_FOREACH(gev->edge_swipes.fingers[i].edge[j], l, edata) + { + if (edata->client == client) return EINA_TRUE; + } + } + } + return EINA_FALSE; +} + static void _e_gesture_cb_ungrab_edge_swipe(struct wl_client *client, struct wl_resource *resouce, - uint32_t fingers, uint32_t edge) + uint32_t fingers, uint32_t edge, uint32_t edge_size, + uint32_t start_point, uint32_t end_point) { E_Gesture_Event *gev; - unsigned int ungrabbed_edge = 0x0; int ret = TIZEN_GESTURE_ERROR_NONE; - int i, j; + int i; + Eina_List *l, *l_next; + E_Gesture_Event_Edge_Swipe_Finger_Edge *edata; + Eina_Bool flag_removed = EINA_FALSE; + int sp = 0, ep = 0; - GTINF("client %p is request ungrab edge swipe gesture, fingers: %d, edge: 0x%x, client: %p\n", client, fingers, edge, gesture->gesture_events.edge_swipes.fingers[0].edge[3].client); + GTINF("client %p is request ungrab edge swipe gesture, fingers: %d, edge: 0x%x, edge_size: %d, (%d ~ %d)\n", client, fingers, edge, edge_size, start_point, end_point); if (fingers > E_GESTURE_FINGER_MAX) { @@ -564,80 +615,64 @@ _e_gesture_cb_ungrab_edge_swipe(struct wl_client *client, gev = &gesture->gesture_events; - if (edge & TIZEN_GESTURE_EDGE_TOP) - { - if ((gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_TOP].client) && - (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_TOP].client == client)) - { - gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_TOP].client = NULL; - gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_TOP].res = NULL; - } - else - { - ungrabbed_edge |= TIZEN_GESTURE_EDGE_TOP; - } - } - if (edge & TIZEN_GESTURE_EDGE_RIGHT) - { - if ((gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_RIGHT].client) && - (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_RIGHT].client == client)) - { - gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_RIGHT].client = NULL; - gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_RIGHT].res = NULL; - } - else - { - ungrabbed_edge |= TIZEN_GESTURE_EDGE_RIGHT; - } - } - if (edge & TIZEN_GESTURE_EDGE_BOTTOM) - { - if ((gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_BOTTOM].client) && - (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_BOTTOM].client == client)) - { - gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_BOTTOM].client = NULL; - gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_BOTTOM].res = NULL; - } - else - { - ungrabbed_edge |= TIZEN_GESTURE_EDGE_BOTTOM; - } - } - if (edge & TIZEN_GESTURE_EDGE_LEFT) - { - if ((gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_LEFT].client) && - (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_LEFT].client == client)) - { - gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_LEFT].client = NULL; - gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_LEFT].res = NULL; - } - else - { - ungrabbed_edge |= TIZEN_GESTURE_EDGE_LEFT; - } - } - - if (edge & ~ungrabbed_edge) - { - _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge & ~ungrabbed_edge, 0); - _e_gesture_edge_swipe_current_list_check(); - } - - gev->edge_swipes.enabled_edge &= ~edge; + if (edge_size == TIZEN_GESTURE_EDGE_SIZE_PARTIAL) + { + sp = start_point; + ep = end_point; + if (((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) && + (ep > e_comp->w)) + ep = e_comp->w; + else if (((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) && + (ep > e_comp->h)) + ep = e_comp->h; + } + else if (edge_size == TIZEN_GESTURE_EDGE_SIZE_FULL) + { + sp = 0; + if ((edge == TIZEN_GESTURE_EDGE_TOP) || (edge == TIZEN_GESTURE_EDGE_BOTTOM)) + ep = e_comp->w; + else if ((edge == TIZEN_GESTURE_EDGE_RIGHT) || (edge == TIZEN_GESTURE_EDGE_LEFT)) + ep = e_comp->h; + } + else + { + GTWRN("Invalid edge_size(%d)\n", edge_size); + ret = TIZEN_GESTURE_ERROR_INVALID_DATA; + goto notify; + } + + EINA_LIST_FOREACH_SAFE(gev->edge_swipes.fingers[fingers].edge[edge], l, l_next, edata) + { + if ((edata->client == client) && (edata->sp == sp) && (edata->ep == ep)) + { + gev->edge_swipes.fingers[fingers].edge[edge] = eina_list_remove_list( + gev->edge_swipes.fingers[fingers].edge[edge], l); + E_FREE(edata); + flag_removed = EINA_TRUE; + } + } + + if (flag_removed) + { + if (!_e_gesture_edge_swipe_grabbed_client_check(client)) + { + _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_EDGE_SWIPE, fingers, edge, 0, sp, ep); + _e_gesture_edge_swipe_current_list_check(); + } + } + + gev->edge_swipes.enabled_edge &= ~( 1 << edge); for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) { - for (j = 1; j < E_GESTURE_EDGE_MAX+1; j++) + if (eina_list_count(gev->edge_swipes.fingers[i].edge[edge]) > 0) { - if (gev->edge_swipes.fingers[i].edge[j].client) - { - gev->edge_swipes.enabled_edge |= (1 << (j - 1)); - } + gev->edge_swipes.enabled_edge |= (1 << edge); + break; } - if (gev->edge_swipes.enabled_edge == E_GESTURE_EDGE_ALL) break; } notify: - tizen_gesture_send_grab_edge_swipe_notify(resouce, fingers, edge, ret); + tizen_gesture_send_grab_edge_swipe_notify(resouce, fingers, edge, edge_size, start_point, end_point, ret); return; } @@ -671,7 +706,7 @@ _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, E_GESTURE_TYPE_TAP, fingers, 0, repeats); + e_gesture_add_client_destroy_listener(client, E_GESTURE_TYPE_TAP, fingers, 0, repeats, 0, 0); if (gev->taps.max_fingers < fingers) gev->taps.max_fingers = fingers; @@ -724,7 +759,7 @@ _e_gesture_cb_ungrab_tap(struct wl_client *client, } gev->taps.fingers[fingers].max_repeats = e_gesture_util_tap_max_repeats_get(fingers); - _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_TAP, fingers, 0, repeats); + _e_gesture_remove_client_destroy_listener(client, E_GESTURE_TYPE_TAP, fingers, 0, repeats, 0, 0); _e_gesture_tap_current_list_check(); finish: @@ -974,9 +1009,8 @@ _e_gesture_init(E_Module *m) { gesture->grabbed_gesture |= E_GESTURE_TYPE_EDGE_SWIPE; 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; + _e_gesture_edge_swipe_grab_add(&gesture->gesture_events.edge_swipes.fingers[1], (void *)0x1, (void *)0x1, E_GESTURE_EDGE_TOP, 0, 0); + gesture->gesture_events.edge_swipes.enabled_edge |= (1 << TIZEN_GESTURE_EDGE_TOP); if (gesture->gesture_events.event_keep) { gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; @@ -1050,20 +1084,33 @@ static void _e_gesture_remove_client_edge_swipe(struct wl_client *client, E_Gesture_Grabbed_Client *gclient) { int i, j; + Eina_List *l, *ll; + E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; + E_Gesture_Event_Edge_Swipe_Finger_Edge *edata; for (i = 0; i < E_GESTURE_FINGER_MAX + 1; i++) { - for (j = 0; j < E_GESTURE_EDGE_MAX + 1; j++) + if (gclient->edge_swipe_fingers[i].enabled) { - if (gclient->edge_swipe_fingers[i].edge[j].client) + for (j = 0; j < E_GESTURE_EDGE_MAX + 1; j++) { - if (gesture->gesture_events.edge_swipes.fingers[i].edge[j].client == client) + EINA_LIST_FOREACH_SAFE(edge_swipes->fingers[i].edge[j], l, ll, edata) { - gesture->gesture_events.edge_swipes.fingers[i].edge[j].client = NULL; - gesture->gesture_events.edge_swipes.fingers[i].edge[j].res = NULL; + if (edata->client == client) + { + edge_swipes->fingers[i].edge[j] = eina_list_remove_list(edge_swipes->fingers[i].edge[j], l); + E_FREE(edata); + } + } + EINA_LIST_FOREACH_SAFE(gclient->edge_swipe_fingers[i].edge[j], l, ll, edata) + { + if (edata->client == client) + { + gclient->edge_swipe_fingers[i].edge[j] = eina_list_remove_list(gclient->edge_swipe_fingers[i].edge[j], l); + E_FREE(edata); + } } } - gclient->edge_swipe_fingers[i].edge[j].client = NULL; } } } diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 49e39ea..8e40744 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -85,7 +85,6 @@ typedef enum _E_Gesture_PanPinch_State E_Gesture_PanPinch_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 { @@ -93,8 +92,9 @@ enum _E_Gesture_Edge E_GESTURE_EDGE_TOP, E_GESTURE_EDGE_RIGHT, E_GESTURE_EDGE_BOTTOM, - E_GESTURE_EDGE_LEFT + E_GESTURE_EDGE_LEFT, }; +#define E_GESTURE_EDGE_ALL ((1 << E_GESTURE_EDGE_TOP) | (1 << E_GESTURE_EDGE_RIGHT) | (1 << E_GESTURE_EDGE_BOTTOM) | (1 << E_GESTURE_EDGE_LEFT)) enum _E_Gesture_Event_State { @@ -196,13 +196,15 @@ struct _E_Gesture_Event_Edge_Swipe_Finger_Edge { struct wl_client *client; struct wl_resource *res; + unsigned int sp; + unsigned int ep; }; 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]; + Eina_List *edge[E_GESTURE_EDGE_MAX + 1]; }; struct _E_Gesture_Event_Edge_Swipe -- 2.7.4 From 9620ed6b3f47150db649189591706aab26a45651 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Thu, 6 Jul 2017 13:38:49 +0900 Subject: [PATCH 15/16] expand palm_cover's value - duration, size, pressure Change-Id: Ic353d6440c871d68d419fd82282d5f8411ea0a51 --- src/e_mod_gesture_events.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index 0ba3154..0822a2a 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -1356,8 +1356,10 @@ _e_gesture_send_palm_cover(void) { Ecore_Event_Mouse_Button *ev_cancel; E_Gesture_Event_Palm_Cover *palm_covers = &gesture->gesture_events.palm_covers; - int time; + int duration = 0, time; int cx = 0, cy = 0; + unsigned int size = 0; + wl_fixed_t pressure; time = (int)(ecore_time_get()*1000); @@ -1380,8 +1382,10 @@ _e_gesture_send_palm_cover(void) GTINF("Send palm_cover gesture to client: %p\n", palm_covers->client_info.client); - tizen_gesture_send_palm_cover(palm_covers->client_info.res, TIZEN_GESTURE_MODE_BEGIN, time, cx, cy); - tizen_gesture_send_palm_cover(palm_covers->client_info.res, TIZEN_GESTURE_MODE_END, time, cx, cy); + pressure = wl_fixed_from_double(0.0); + + tizen_gesture_send_palm_cover(palm_covers->client_info.res, TIZEN_GESTURE_MODE_BEGIN, duration, size, pressure, cx, cy); + tizen_gesture_send_palm_cover(palm_covers->client_info.res, TIZEN_GESTURE_MODE_END, duration, size, pressure, cx, cy); gesture->event_state = E_GESTURE_EVENT_STATE_IGNORE; gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_PALM_COVER; -- 2.7.4 From 3601543144af1503e02f2a37f0e0189daa22f82a Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Thu, 6 Jul 2017 14:33:59 +0900 Subject: [PATCH 16/16] support expanded tizen_gesture protocols - add select / deselect palm cover - add a activate gesture - add a error not supported Change-Id: If747e0d1ab95a0374e3f7aee5a8e96adb707f10a --- src/e_mod_gesture_events.c | 5 +-- src/e_mod_main.c | 76 ++++++++++++++++++++++++++++++++++++++++++++-- src/e_mod_main.h | 3 +- 3 files changed, 78 insertions(+), 6 deletions(-) diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index 0822a2a..d1afb28 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -1360,6 +1360,7 @@ _e_gesture_send_palm_cover(void) int cx = 0, cy = 0; unsigned int size = 0; wl_fixed_t pressure; + struct wl_resource *surface = NULL; time = (int)(ecore_time_get()*1000); @@ -1384,8 +1385,8 @@ _e_gesture_send_palm_cover(void) pressure = wl_fixed_from_double(0.0); - tizen_gesture_send_palm_cover(palm_covers->client_info.res, TIZEN_GESTURE_MODE_BEGIN, duration, size, pressure, cx, cy); - tizen_gesture_send_palm_cover(palm_covers->client_info.res, TIZEN_GESTURE_MODE_END, duration, size, pressure, cx, cy); + tizen_gesture_send_palm_cover(palm_covers->client_info.res, surface, TIZEN_GESTURE_MODE_BEGIN, duration, size, pressure, cx, cy); + tizen_gesture_send_palm_cover(palm_covers->client_info.res, surface, TIZEN_GESTURE_MODE_END, duration, size, pressure, cx, cy); gesture->event_state = E_GESTURE_EVENT_STATE_IGNORE; gesture->gesture_events.recognized_gesture |= E_GESTURE_TYPE_PALM_COVER; diff --git a/src/e_mod_main.c b/src/e_mod_main.c index 68b8ad2..a682874 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -677,6 +677,34 @@ notify: } static void +_e_gesture_cb_grab_edge_drag(struct wl_client *client, + struct wl_resource *resouce, + uint32_t fingers, uint32_t edge, uint32_t edge_size, + uint32_t start_point, uint32_t end_point) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = TIZEN_GESTURE_ERROR_NOT_SUPPORTED; + + tizen_gesture_send_grab_edge_swipe_notify(resouce, fingers, edge, edge_size, start_point, end_point, ret); +} + +static void +_e_gesture_cb_ungrab_edge_drag(struct wl_client *client, + struct wl_resource *resouce, + uint32_t fingers, uint32_t edge, uint32_t edge_size, + uint32_t start_point, uint32_t end_point) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = TIZEN_GESTURE_ERROR_NOT_SUPPORTED; + + tizen_gesture_send_grab_edge_swipe_notify(resouce, fingers, edge, edge_size, start_point, end_point, ret); +} + + + +static void _e_gesture_cb_grab_tap(struct wl_client *client, struct wl_resource *resource, uint32_t fingers, uint32_t repeats) @@ -774,7 +802,7 @@ _e_gesture_cb_grab_palm_cover(struct wl_client *client, ret = _e_gesture_grab_palm_cover(client, resource); - tizen_gesture_send_palm_cover_notify(resource, ret); + tizen_gesture_send_palm_cover_notify(resource, NULL, ret); } static void @@ -785,16 +813,58 @@ _e_gesture_cb_ungrab_palm_cover(struct wl_client *client, ret = _e_gesture_ungrab_palm_cover(client, resource); - tizen_gesture_send_palm_cover_notify(resource, ret); + tizen_gesture_send_palm_cover_notify(resource, NULL, ret); +} + +static void +_e_gesture_cb_select_palm_cover(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *surface) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = TIZEN_GESTURE_ERROR_NOT_SUPPORTED; + + tizen_gesture_send_palm_cover_notify(resource, surface, ret); +} + +static void +_e_gesture_cb_deselect_palm_cover(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *surface) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = TIZEN_GESTURE_ERROR_NOT_SUPPORTED; + + tizen_gesture_send_palm_cover_notify(resource, surface, ret); +} + +static void +_e_gesture_cb_activate_set(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *surface, + uint32_t type, uint32_t active) +{ + int ret = TIZEN_GESTURE_ERROR_NONE; + + ret = TIZEN_GESTURE_ERROR_NOT_SUPPORTED; + + tizen_gesture_send_activate_notify(resource, surface, type, active, 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_edge_drag, + _e_gesture_cb_ungrab_edge_drag, _e_gesture_cb_grab_tap, _e_gesture_cb_ungrab_tap, _e_gesture_cb_grab_palm_cover, - _e_gesture_cb_ungrab_palm_cover + _e_gesture_cb_ungrab_palm_cover, + _e_gesture_cb_select_palm_cover, + _e_gesture_cb_deselect_palm_cover, + _e_gesture_cb_activate_set, }; /* tizen_gesture global object destroy function */ diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 8e40744..0d0b21f 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -12,6 +12,7 @@ #define GTDBG(msg, ARG...) DBG("[tizen_gesture][%s:%d] "msg, __FUNCTION__, __LINE__, ##ARG) #define E_GESTURE_TYPE_EDGE_SWIPE TIZEN_GESTURE_TYPE_EDGE_SWIPE +#define E_GESTURE_TYPE_EDGE_DRAG TIZEN_GESTURE_TYPE_EDGE_DRAG #define E_GESTURE_TYPE_TAP TIZEN_GESTURE_TYPE_TAP #define E_GESTURE_TYPE_PALM_COVER TIZEN_GESTURE_TYPE_PALM_COVER #define E_GESTURE_TYPE_PAN (TIZEN_GESTURE_TYPE_PALM_COVER << 1) @@ -19,7 +20,7 @@ #define E_GESTURE_FINGER_MAX 3 #define E_GESTURE_TYPE_MAX (E_GESTURE_TYPE_PINCH + 1) -#define E_GESTURE_TYPE_ALL (E_GESTURE_TYPE_EDGE_SWIPE | E_GESTURE_TYPE_TAP | E_GESTURE_TYPE_PAN | E_GESTURE_TYPE_PINCH | E_GESTURE_TYPE_PALM_COVER) +#define E_GESTURE_TYPE_ALL (E_GESTURE_TYPE_EDGE_SWIPE | E_GESTURE_TYPE_EDGE_DRAG | E_GESTURE_TYPE_TAP | E_GESTURE_TYPE_PAN | E_GESTURE_TYPE_PINCH | E_GESTURE_TYPE_PALM_COVER) #define E_GESTURE_KEYBOARD_NAME "Gesture Keyboard" #define E_GESTURE_AUX_HINT_GESTURE_DISABLE "wm.policy.win.gesture.disable" -- 2.7.4