From 377a304b2c71efc3032f87d64972aab44dd4f1e6 Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Mon, 5 Dec 2016 20:33:40 +0900 Subject: [PATCH] Modify swipe to edge_swipe Change-Id: Ie1671eecade977c40c15857685dd7002b07badaa --- src/e_mod_gesture_conf.c | 31 ++-- src/e_mod_gesture_device.c | 8 +- src/e_mod_gesture_events.c | 445 +++++++++++++++++++++++++++++++-------------- src/e_mod_main.c | 223 ++++++++++++----------- src/e_mod_main.h | 87 +++++---- 5 files changed, 498 insertions(+), 296 deletions(-) diff --git a/src/e_mod_gesture_conf.c b/src/e_mod_gesture_conf.c index beb0422..4a7fe80 100644 --- a/src/e_mod_gesture_conf.c +++ b/src/e_mod_gesture_conf.c @@ -10,13 +10,13 @@ _e_gesture_conf_value_check(E_Gesture_Config_Data* gconfig) conf = gconfig->conf; if (!conf->key_device_name) conf->key_device_name = strdup(E_GESTURE_KEYBOARD_DEVICE); - if (conf->swipe.time_done <= 0.0) conf->swipe.time_done = E_GESTURE_SWIPE_DONE_TIME; - if (conf->swipe.time_begin <= 0.0) conf->swipe.time_begin = E_GESTURE_SWIPE_START_TIME; - if (conf->swipe.area_offset <= 0) conf->swipe.area_offset = E_GESTURE_SWIPE_START_AREA; - if (conf->swipe.min_length <= 0) conf->swipe.min_length = E_GESTURE_SWIPE_DIFF_FAIL; - if (conf->swipe.max_length <= 0) conf->swipe.max_length = E_GESTURE_SWIPE_DIFF_SUCCESS; - if (conf->swipe.compose_key <= 0) conf->swipe.compose_key = E_GESTURE_SWIPE_COMBINE_KEY; - if (conf->swipe.back_key <= 0) conf->swipe.back_key = E_GESTURE_SWIPE_BACK_KEY; + 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; + if (conf->edge_swipe.area_offset <= 0) conf->edge_swipe.area_offset = E_GESTURE_EDGE_SWIPE_START_AREA; + if (conf->edge_swipe.min_length <= 0) conf->edge_swipe.min_length = E_GESTURE_EDGE_SWIPE_DIFF_FAIL; + 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; } void @@ -28,14 +28,15 @@ 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, swipe.time_done, DOUBLE); - E_CONFIG_VAL(D, T, swipe.time_begin, DOUBLE); - E_CONFIG_VAL(D, T, swipe.area_offset, INT); - E_CONFIG_VAL(D, T, swipe.min_length, INT); - E_CONFIG_VAL(D, T, swipe.max_length, INT); - E_CONFIG_VAL(D, T, swipe.compose_key, INT); - E_CONFIG_VAL(D, T, swipe.back_key, INT); - E_CONFIG_VAL(D, T, swipe.default_enable_back, 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); + E_CONFIG_VAL(D, T, edge_swipe.min_length, INT); + E_CONFIG_VAL(D, T, edge_swipe.max_length, INT); + 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); #undef T #undef D diff --git a/src/e_mod_gesture_device.c b/src/e_mod_gesture_device.c index 38aa14b..25b5446 100644 --- a/src/e_mod_gesture_device.c +++ b/src/e_mod_gesture_device.c @@ -84,7 +84,7 @@ _e_gesture_device_ecore_device_get(char *path, unsigned int clas) return NULL; } -Eina_Bool +E_Gesture_Event_State e_gesture_device_add(Ecore_Event_Device_Info *ev) { if (ev->clas == ECORE_DEVICE_CLASS_TOUCH) @@ -112,10 +112,10 @@ e_gesture_device_add(Ecore_Event_Device_Info *ev) gesture->device.kbd_device = _e_gesture_device_ecore_device_get(gesture->device.kbd_identifier, ECORE_DEVICE_CLASS_KEYBOARD); } } - return EINA_TRUE; + return E_GESTURE_EVENT_STATE_PROPAGATE; } -Eina_Bool +E_Gesture_Event_State e_gesture_device_del(Ecore_Event_Device_Info *ev) { Eina_List *l, *l_next; @@ -143,7 +143,7 @@ e_gesture_device_del(Ecore_Event_Device_Info *ev) E_FREE(gesture->device.kbd_name); } } - return EINA_TRUE; + return E_GESTURE_EVENT_STATE_PROPAGATE; } Eina_Bool diff --git a/src/e_mod_gesture_events.c b/src/e_mod_gesture_events.c index e03280d..a72ea62 100644 --- a/src/e_mod_gesture_events.c +++ b/src/e_mod_gesture_events.c @@ -2,26 +2,144 @@ #include "e_mod_main.h" #include +#ifdef _E_GESTURE_DEBUG_ +static char * +_e_gesture_event_type_print(int type) +{ + if (type == ECORE_EVENT_KEY_DOWN) return "KeyDown"; + else if (type == ECORE_EVENT_KEY_UP) return "KeyUp"; + else if (type == ECORE_EVENT_MOUSE_BUTTON_DOWN) return "MouseDown"; + else if (type == ECORE_EVENT_MOUSE_BUTTON_UP) return "MouseUp"; + else if (type == ECORE_EVENT_MOUSE_MOVE) return "MouseMove"; + else return "Unknown"; +} + +static void +_e_gesture_event_print(void) +{ + Eina_List *l; + E_Gesture_Event_Info *data; + int c = 0; + + EINA_LIST_FOREACH(gesture->event_queue, l, data) + { + GTERR("[%d]%s event is queue\n", ++c, _e_gesture_event_type_print(data->type)); + } +} +#endif //_E_GESTURE_DEBUG_ + +static void +_e_gesture_event_queue(int type, void *event) +{ + E_Gesture_Event_Info *e_info = NULL; + e_info = E_NEW(E_Gesture_Event_Info, 1); + EINA_SAFETY_ON_NULL_RETURN(e_info); + + if (type == ECORE_EVENT_KEY_DOWN || + type == ECORE_EVENT_KEY_UP) + { + e_info->event = E_NEW(Ecore_Event_Key, 1); + e_info->type = type; + memcpy(e_info->event, event, sizeof(Ecore_Event_Key)); + } + else if (type == ECORE_EVENT_MOUSE_BUTTON_DOWN || + type == ECORE_EVENT_MOUSE_BUTTON_UP) + { + e_info->event = E_NEW(Ecore_Event_Mouse_Button, 1); + e_info->type = type; + memcpy(e_info->event, event, sizeof(Ecore_Event_Mouse_Button)); + } + else if (type == ECORE_EVENT_MOUSE_MOVE) + { + e_info->event = E_NEW(Ecore_Event_Mouse_Move, 1); + e_info->type = type; + memcpy(e_info->event, event, sizeof(Ecore_Event_Mouse_Move)); + } + else goto error; + + gesture->event_queue = eina_list_append(gesture->event_queue, e_info); + return; + +error: + if (e_info->event) E_FREE(e_info->event); + if (e_info) E_FREE(e_info); +} + +static void +_e_gesture_event_flush(void) +{ + Eina_List *l, *l_next; + E_Gesture_Event_Info *data; + + if (gesture->event_state == E_GESTURE_EVENT_STATE_IGNORE || + gesture->gesture_events.recognized_gesture) return; + + gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE; + + EINA_LIST_FOREACH_SAFE(gesture->event_queue, l, l_next, data) + { + if (data->type == ECORE_EVENT_MOUSE_BUTTON_DOWN) + { + ecore_event_evas_mouse_button_down(NULL, ECORE_EVENT_MOUSE_BUTTON_DOWN, data->event); + } + else if (data->type == ECORE_EVENT_MOUSE_BUTTON_UP) + { + ecore_event_evas_mouse_button_up(NULL, ECORE_EVENT_MOUSE_BUTTON_UP, data->event); + } + else if (data->type == ECORE_EVENT_MOUSE_MOVE) + { + ecore_event_evas_mouse_move(NULL, ECORE_EVENT_MOUSE_MOVE, data->event); + } + else if (data->type == ECORE_EVENT_KEY_DOWN) + { + ecore_event_evas_key_down(NULL, ECORE_EVENT_KEY_DOWN, data->event); + } + else if (data->type == ECORE_EVENT_KEY_UP) + { + ecore_event_evas_key_up(NULL, ECORE_EVENT_KEY_UP, data->event); + } + E_FREE(data->event); + E_FREE(data); + gesture->event_queue = eina_list_remove_list(gesture->event_queue, l); + } +} + +static void +_e_gesture_event_drop(void) +{ + Eina_List *l, *l_next; + E_Gesture_Event_Info *data; + + gesture->event_state = E_GESTURE_EVENT_STATE_IGNORE; + + EINA_LIST_FOREACH_SAFE(gesture->event_queue, l, l_next, data) + { + E_FREE(data->event); + E_FREE(data); + gesture->event_queue = eina_list_remove_list(gesture->event_queue, l); + } +} + static void -_e_gesture_swipe_cancel(void) +_e_gesture_edge_swipe_cancel(void) { - E_Gesture_Event_Swipe *swipes = &gesture->gesture_events.swipes; + E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; - if (swipes->start_timer) + if (edge_swipes->start_timer) { - ecore_timer_del(swipes->start_timer); - swipes->start_timer = NULL; + ecore_timer_del(edge_swipes->start_timer); + edge_swipes->start_timer = NULL; } - if (swipes->done_timer) + if (edge_swipes->done_timer) { - ecore_timer_del(swipes->done_timer); - swipes->done_timer = NULL; + ecore_timer_del(edge_swipes->done_timer); + edge_swipes->done_timer = NULL; } - swipes->enabled_finger = 0x0; - swipes->direction = E_GESTURE_DIRECTION_NONE; + edge_swipes->enabled_finger = 0x0; + edge_swipes->edge = E_GESTURE_EDGE_NONE; - gesture->gesture_filter |= TIZEN_GESTURE_TYPE_SWIPE; + gesture->gesture_filter |= TIZEN_GESTURE_TYPE_EDGE_SWIPE; } static void @@ -56,7 +174,7 @@ _e_gesture_send_back_key(Eina_Bool pressed) ev->compose = (char *)eina_stringshare_add(ev->key); ev->timestamp = (int)(ecore_time_get()*1000); ev->same_screen = 1; - ev->keycode = conf->swipe.back_key; + ev->keycode = conf->edge_swipe.back_key; ev->dev = gesture->device.kbd_device; if (pressed) @@ -66,105 +184,116 @@ _e_gesture_send_back_key(Eina_Bool pressed) } static void -_e_gesture_send_swipe(int fingers, int x, int y, int direction, struct wl_client *client, struct wl_resource *res) +_e_gesture_send_edge_swipe(int fingers, int x, int y, int edge, struct wl_client *client, struct wl_resource *res) { - enum tizen_gesture_direction dir = 0; + 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 (direction) + switch (edge) { - case E_GESTURE_DIRECTION_DOWN: - dir = TIZEN_GESTURE_DIRECTION_DOWN; + case E_GESTURE_EDGE_TOP: + dir = TIZEN_GESTURE_EDGE_TOP; break; - case E_GESTURE_DIRECTION_LEFT: - dir = TIZEN_GESTURE_DIRECTION_LEFT; + case E_GESTURE_EDGE_LEFT: + dir = TIZEN_GESTURE_EDGE_LEFT; break; - case E_GESTURE_DIRECTION_UP: - dir = TIZEN_GESTURE_DIRECTION_UP; + case E_GESTURE_EDGE_BOTTOM: + dir = TIZEN_GESTURE_EDGE_BOTTOM; break; - case E_GESTURE_DIRECTION_RIGHT: - dir = TIZEN_GESTURE_DIRECTION_RIGHT; + case E_GESTURE_EDGE_RIGHT: + dir = TIZEN_GESTURE_EDGE_RIGHT; break; } - ev_cancel = E_NEW(Ecore_Event_Mouse_Button, 1); - EINA_SAFETY_ON_NULL_RETURN(ev_cancel); + if (edge_swipes->event_keep) + { + _e_gesture_event_drop(); + } + else + { + 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; + 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); + ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, ev_cancel, NULL, NULL); + } - GTINF("Send swipe gesture (direction: %d) to client: %p\n", dir, client); + GTINF("Send edge_swipe gesture (edge: %d) to client: %p\n", dir, client); - if (conf->swipe.default_enable_back && - direction == E_GESTURE_DIRECTION_DOWN) + if (conf->edge_swipe.default_enable_back && + edge == E_GESTURE_EDGE_TOP) { _e_gesture_send_back_key(EINA_TRUE); _e_gesture_send_back_key(EINA_FALSE); goto finish; } - tizen_gesture_send_swipe(res, fingers, TIZEN_GESTURE_MODE_DONE, x, y, dir); - _e_gesture_swipe_cancel(); + tizen_gesture_send_edge_swipe(res, fingers, TIZEN_GESTURE_MODE_DONE, x, y, dir); finish: - _e_gesture_swipe_cancel(); - gesture->gesture_events.recognized_gesture |= TIZEN_GESTURE_TYPE_SWIPE; + _e_gesture_edge_swipe_cancel(); + gesture->gesture_events.recognized_gesture |= TIZEN_GESTURE_TYPE_EDGE_SWIPE; } -static Eina_Bool +static E_Gesture_Event_State _e_gesture_process_device_add(void *event) { return e_gesture_device_add(event); } -static Eina_Bool +static E_Gesture_Event_State _e_gesture_process_device_del(void *event) { return e_gesture_device_del(event); } static Eina_Bool -_e_gesture_timer_swipe_start(void *data) +_e_gesture_timer_edge_swipe_start(void *data) { - E_Gesture_Event_Swipe *swipes = &gesture->gesture_events.swipes; + E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; int idx = gesture->gesture_events.num_pressed; int i; - GTDBG("Swipe start timer is expired. Currently alived swipe fingers: 0x%x\n", swipes->enabled_finger); + GTDBG("Edge_Swipe start timer is expired. Currently alived edge_swipe fingers: 0x%x\n", edge_swipes->enabled_finger); for (i = E_GESTURE_FINGER_MAX; i > idx; i--) { - swipes->enabled_finger &= ~(1 << i); + edge_swipes->enabled_finger &= ~(1 << i); } - if ((swipes->direction == E_GESTURE_DIRECTION_DOWN && !swipes->fingers[idx].direction[E_GESTURE_DIRECTION_DOWN].client) || - (swipes->direction == E_GESTURE_DIRECTION_LEFT && !swipes->fingers[idx].direction[E_GESTURE_DIRECTION_LEFT].client) || - (swipes->direction == E_GESTURE_DIRECTION_UP && !swipes->fingers[idx].direction[E_GESTURE_DIRECTION_UP].client) || - (swipes->direction == E_GESTURE_DIRECTION_RIGHT && !swipes->fingers[idx].direction[E_GESTURE_DIRECTION_RIGHT].client)) + 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)) { - _e_gesture_swipe_cancel(); + if (edge_swipes->event_keep) + _e_gesture_event_flush(); + _e_gesture_edge_swipe_cancel(); } return ECORE_CALLBACK_CANCEL; } static Eina_Bool -_e_gesture_timer_swipe_done(void *data) +_e_gesture_timer_edge_swipe_done(void *data) { - E_Gesture_Event_Swipe *swipes = &gesture->gesture_events.swipes; + E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; - GTDBG("Swipe done timer is expired. Currently alived swipe fingers: 0x%x\n", swipes->enabled_finger); + GTDBG("Edge_Swipe done timer is expired. Currently alived edge_swipe fingers: 0x%x\n", edge_swipes->enabled_finger); - _e_gesture_swipe_cancel(); + if (edge_swipes->event_keep) + _e_gesture_event_flush(); + _e_gesture_edge_swipe_cancel(); return ECORE_CALLBACK_CANCEL; } static void -_e_gesture_process_swipe_down(Ecore_Event_Mouse_Button *ev) +_e_gesture_process_edge_swipe_down(Ecore_Event_Mouse_Button *ev) { - E_Gesture_Event_Swipe *swipes = &gesture->gesture_events.swipes; + E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; E_Gesture_Conf_Edd *conf = gesture->config->conf; int i; unsigned int idx = ev->multi.device+1; @@ -173,117 +302,129 @@ _e_gesture_process_swipe_down(Ecore_Event_Mouse_Button *ev) { for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) { - if (swipes->fingers[i].enabled) + if (edge_swipes->fingers[i].enabled) { - swipes->enabled_finger |= (1 << i); + edge_swipes->enabled_finger |= (1 << i); } } - if (ev->y < conf->swipe.area_offset) - swipes->direction = E_GESTURE_DIRECTION_DOWN; - else if (ev->y > e_comp->h - conf->swipe.area_offset) - swipes->direction = E_GESTURE_DIRECTION_UP; - else if (ev->x < conf->swipe.area_offset) - swipes->direction = E_GESTURE_DIRECTION_RIGHT; - else if (ev->x > e_comp->w - conf->swipe.area_offset) - swipes->direction = E_GESTURE_DIRECTION_LEFT; - - if (swipes->direction != E_GESTURE_DIRECTION_DOWN && - !((swipes->combined_keycode == conf->swipe.compose_key) && swipes->direction == E_GESTURE_DIRECTION_RIGHT)) - { - _e_gesture_swipe_cancel(); - } + if (ev->y < conf->edge_swipe.area_offset) + edge_swipes->edge = E_GESTURE_EDGE_TOP; + 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 { - swipes->fingers[idx].start.x = ev->x; - swipes->fingers[idx].start.y = ev->y; - swipes->start_timer = ecore_timer_add(conf->swipe.time_begin, _e_gesture_timer_swipe_start, NULL); - swipes->done_timer = ecore_timer_add(conf->swipe.time_done, _e_gesture_timer_swipe_done, NULL); + if (edge_swipes->event_keep) + _e_gesture_event_flush(); + _e_gesture_edge_swipe_cancel(); } + + edge_swipes->fingers[idx].start.x = ev->x; + edge_swipes->fingers[idx].start.y = ev->y; + edge_swipes->start_timer = ecore_timer_add(conf->edge_swipe.time_begin, _e_gesture_timer_edge_swipe_start, NULL); + edge_swipes->done_timer = ecore_timer_add(conf->edge_swipe.time_done, _e_gesture_timer_edge_swipe_done, NULL); } else { - swipes->enabled_finger &= ~(1 << (gesture->gesture_events.num_pressed - 1)); - if (swipes->start_timer == NULL) + edge_swipes->enabled_finger &= ~(1 << (gesture->gesture_events.num_pressed - 1)); + if (edge_swipes->start_timer == NULL) { - _e_gesture_swipe_cancel(); + if (edge_swipes->event_keep) + _e_gesture_event_flush(); + _e_gesture_edge_swipe_cancel(); } } } static void -_e_gesture_process_swipe_move(Ecore_Event_Mouse_Move *ev) +_e_gesture_process_edge_swipe_move(Ecore_Event_Mouse_Move *ev) { - E_Gesture_Event_Swipe *swipes = &gesture->gesture_events.swipes; + E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; E_Gesture_Conf_Edd *conf = gesture->config->conf; Coords diff; unsigned int idx = ev->multi.device+1; - if (!(swipes->enabled_finger & (1 << idx))) + if (!(edge_swipes->enabled_finger & (1 << idx))) return; - diff.x = ABS(swipes->fingers[idx].start.x - ev->x); - diff.y = ABS(swipes->fingers[idx].start.y - ev->y); + diff.x = ABS(edge_swipes->fingers[idx].start.x - ev->x); + diff.y = ABS(edge_swipes->fingers[idx].start.y - ev->y); - switch(swipes->direction) + switch(edge_swipes->edge) { - case E_GESTURE_DIRECTION_DOWN: - if (diff.x > conf->swipe.min_length) + case E_GESTURE_EDGE_TOP: + if (diff.x > conf->edge_swipe.min_length) { - _e_gesture_swipe_cancel(); + if (edge_swipes->event_keep) + _e_gesture_event_flush(); + _e_gesture_edge_swipe_cancel(); break; } - if (diff.y > conf->swipe.max_length) + if (diff.y > conf->edge_swipe.max_length) { - _e_gesture_send_swipe(idx, swipes->fingers[idx].start.x, swipes->fingers[idx].start.y, swipes->direction, swipes->fingers[idx].direction[E_GESTURE_DIRECTION_DOWN].client, swipes->fingers[idx].direction[E_GESTURE_DIRECTION_DOWN].res); + _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); } break; - case E_GESTURE_DIRECTION_LEFT: - if (diff.y > conf->swipe.min_length) + case E_GESTURE_EDGE_LEFT: + if (diff.y > conf->edge_swipe.min_length) { - _e_gesture_swipe_cancel(); + if (edge_swipes->event_keep) + _e_gesture_event_flush(); + _e_gesture_edge_swipe_cancel(); break; } - if (diff.x > conf->swipe.max_length) + if (diff.x > conf->edge_swipe.max_length) { - _e_gesture_send_swipe(idx, swipes->fingers[idx].start.x, swipes->fingers[idx].start.y, swipes->direction, swipes->fingers[idx].direction[E_GESTURE_DIRECTION_LEFT].client, swipes->fingers[idx].direction[E_GESTURE_DIRECTION_LEFT].res); + _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); } break; - case E_GESTURE_DIRECTION_UP: - if (diff.x > conf->swipe.min_length) + case E_GESTURE_EDGE_BOTTOM: + if (diff.x > conf->edge_swipe.min_length) { - _e_gesture_swipe_cancel(); + if (edge_swipes->event_keep) + _e_gesture_event_flush(); + _e_gesture_edge_swipe_cancel(); break; } - if (diff.y > conf->swipe.max_length) + if (diff.y > conf->edge_swipe.max_length) { - _e_gesture_send_swipe(idx, swipes->fingers[idx].start.x, swipes->fingers[idx].start.y, swipes->direction, swipes->fingers[idx].direction[E_GESTURE_DIRECTION_UP].client, swipes->fingers[idx].direction[E_GESTURE_DIRECTION_UP].res); + _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); } break; - case E_GESTURE_DIRECTION_RIGHT: - if (diff.y > conf->swipe.min_length) + case E_GESTURE_EDGE_RIGHT: + if (diff.y > conf->edge_swipe.min_length) { - _e_gesture_swipe_cancel(); + if (edge_swipes->event_keep) + _e_gesture_event_flush(); + _e_gesture_edge_swipe_cancel(); break; } - if (diff.x > conf->swipe.max_length) + if (diff.x > conf->edge_swipe.max_length) { - _e_gesture_send_swipe(idx, swipes->fingers[idx].start.x, swipes->fingers[idx].start.y, swipes->direction, swipes->fingers[idx].direction[E_GESTURE_DIRECTION_RIGHT].client, swipes->fingers[idx].direction[E_GESTURE_DIRECTION_RIGHT].res); + _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); } break; default: - GTWRN("Invalid direction(%d)\n", swipes->direction); + GTWRN("Invalid edge(%d)\n", edge_swipes->edge); break; } } static void -_e_gesture_process_swipe_up(Ecore_Event_Mouse_Button *ev) +_e_gesture_process_edge_swipe_up(Ecore_Event_Mouse_Button *ev) { - _e_gesture_swipe_cancel(); + E_Gesture_Event_Edge_Swipe *edge_swipes = &gesture->gesture_events.edge_swipes; + + if (edge_swipes->event_keep) + _e_gesture_event_flush(); + _e_gesture_edge_swipe_cancel(); } -static Eina_Bool +static E_Gesture_Event_State _e_gesture_process_mouse_button_down(void *event) { Ecore_Event_Mouse_Button *ev = event; @@ -292,36 +433,39 @@ _e_gesture_process_mouse_button_down(void *event) if (!gesture->grabbed_gesture) { - return EINA_TRUE; + return E_GESTURE_EVENT_STATE_PROPAGATE; } if (e_gesture_is_touch_device(ev->dev) == EINA_FALSE) { - return EINA_TRUE; + return E_GESTURE_EVENT_STATE_PROPAGATE; } if (ev->multi.device > E_GESTURE_FINGER_MAX) { - return EINA_TRUE; + return E_GESTURE_EVENT_STATE_PROPAGATE; } if (gesture->gesture_events.recognized_gesture) { - return EINA_FALSE; + return E_GESTURE_EVENT_STATE_IGNORE; } if (gesture->gesture_events.num_pressed == 1) { - gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; + if (gesture->gesture_filter == E_GESTURE_TYPE_ALL) + { + gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE; + } } - if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_SWIPE)) + if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_EDGE_SWIPE)) { - _e_gesture_process_swipe_down(ev); + _e_gesture_process_edge_swipe_down(ev); } - return EINA_TRUE; + return gesture->event_state; } -static Eina_Bool +static E_Gesture_Event_State _e_gesture_process_mouse_button_up(void *event) { Ecore_Event_Mouse_Button *ev = event; @@ -334,11 +478,11 @@ _e_gesture_process_mouse_button_up(void *event) gesture->gesture_events.num_pressed--; if (!gesture->grabbed_gesture) { - return EINA_TRUE; + return E_GESTURE_EVENT_STATE_PROPAGATE; } if (e_gesture_is_touch_device(ev->dev) == EINA_FALSE) { - return EINA_TRUE; + return E_GESTURE_EVENT_STATE_PROPAGATE; } if (gesture->gesture_events.recognized_gesture) @@ -355,19 +499,19 @@ _e_gesture_process_mouse_button_up(void *event) e_gesture_event_filter_enable(EINA_FALSE); } } - return EINA_FALSE; + return E_GESTURE_EVENT_STATE_IGNORE; } - if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_SWIPE)) + if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_EDGE_SWIPE)) { - _e_gesture_process_swipe_up(ev); + _e_gesture_process_edge_swipe_up(ev); } - return EINA_TRUE; + return gesture->event_state; } -static Eina_Bool +static E_Gesture_Event_State _e_gesture_process_mouse_move(void *event) { Ecore_Event_Mouse_Move *ev = event; @@ -378,59 +522,60 @@ _e_gesture_process_mouse_move(void *event) } if (!gesture->grabbed_gesture) { - return EINA_TRUE; + return E_GESTURE_EVENT_STATE_PROPAGATE; } if (e_gesture_is_touch_device(ev->dev) == EINA_FALSE) { - return EINA_TRUE; + return E_GESTURE_EVENT_STATE_PROPAGATE; } if (gesture->gesture_events.recognized_gesture) { - return EINA_FALSE; + return E_GESTURE_EVENT_STATE_IGNORE; } - if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_SWIPE)) + if (!(gesture->gesture_filter & TIZEN_GESTURE_TYPE_EDGE_SWIPE)) { - _e_gesture_process_swipe_move(ev); + _e_gesture_process_edge_swipe_move(ev); } - return EINA_TRUE; + return gesture->event_state; } -static Eina_Bool +static E_Gesture_Event_State _e_gesture_process_key_down(void *event) { Ecore_Event_Key *ev = event; E_Gesture_Conf_Edd *conf = gesture->config->conf; - if (ev->keycode == conf->swipe.compose_key) + if (ev->keycode == conf->edge_swipe.compose_key) { - gesture->gesture_events.swipes.combined_keycode = conf->swipe.compose_key; + gesture->gesture_events.edge_swipes.combined_keycode = conf->edge_swipe.compose_key; } - return EINA_TRUE; + return E_GESTURE_EVENT_STATE_PROPAGATE; } -static Eina_Bool +static E_Gesture_Event_State _e_gesture_process_key_up(void *event) { Ecore_Event_Key *ev = event; E_Gesture_Conf_Edd *conf = gesture->config->conf; - if (ev->keycode == conf->swipe.compose_key) + if (ev->keycode == conf->edge_swipe.compose_key) { - gesture->gesture_events.swipes.combined_keycode = 0; + gesture->gesture_events.edge_swipes.combined_keycode = 0; } - return EINA_TRUE; + 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) { - Eina_Bool res = EINA_TRUE; + E_Gesture_Event_State res = E_GESTURE_EVENT_STATE_PROPAGATE; + Eina_Bool ret = EINA_TRUE; if (type == ECORE_EVENT_MOUSE_BUTTON_DOWN) res = _e_gesture_process_mouse_button_down(event); @@ -446,6 +591,32 @@ 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 return ret; + + switch (res) + { + case E_GESTURE_EVENT_STATE_PROPAGATE: + ret = EINA_TRUE; + break; + case E_GESTURE_EVENT_STATE_KEEP: + _e_gesture_event_queue(type, event); + ret = EINA_FALSE; + break; + case E_GESTURE_EVENT_STATE_IGNORE: + ret = EINA_FALSE; + break; + default: + return ret; + } + + if (gesture->gesture_events.num_pressed == 0&& + type == ECORE_EVENT_MOUSE_BUTTON_UP) + { + if ((gesture->grabbed_gesture & TIZEN_GESTURE_TYPE_EDGE_SWIPE) && + gesture->gesture_events.edge_swipes.event_keep) + gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; + gesture->gesture_filter = E_GESTURE_TYPE_ALL & ~gesture->grabbed_gesture; + } - return res; + return ret; } diff --git a/src/e_mod_main.c b/src/e_mod_main.c index e0c24bf..95035cc 100644 --- a/src/e_mod_main.c +++ b/src/e_mod_main.c @@ -12,21 +12,21 @@ 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_swipe_set_client_to_list(struct wl_client *client, E_Gesture_Event_Swipe_Finger *fingers, unsigned int direction) +_e_gesture_edge_swipe_set_client_to_list(struct wl_client *client, E_Gesture_Event_Edge_Swipe_Finger *fingers, unsigned int edge) { - if (direction & TIZEN_GESTURE_DIRECTION_DOWN) - fingers->direction[E_GESTURE_DIRECTION_DOWN].client = client; - if (direction & TIZEN_GESTURE_DIRECTION_LEFT) - fingers->direction[E_GESTURE_DIRECTION_LEFT].client = client; - if (direction & TIZEN_GESTURE_DIRECTION_UP) - fingers->direction[E_GESTURE_DIRECTION_UP].client = client; - if (direction & TIZEN_GESTURE_DIRECTION_RIGHT) - fingers->direction[E_GESTURE_DIRECTION_RIGHT].client = client; + 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; } /* Function for registering wl_client destroy listener */ int -e_gesture_add_client_destroy_listener(struct wl_client *client, int mode EINA_UNUSED, int num_of_fingers, unsigned int direction) +e_gesture_add_client_destroy_listener(struct wl_client *client, int mode EINA_UNUSED, int fingers, unsigned int edge) { struct wl_listener *destroy_listener = NULL; Eina_List *l; @@ -36,7 +36,7 @@ e_gesture_add_client_destroy_listener(struct wl_client *client, int mode EINA_UN { if (data->client == client) { - _e_gesture_swipe_set_client_to_list(client, &data->swipe_fingers[num_of_fingers], direction); + _e_gesture_edge_swipe_set_client_to_list(client, &data->edge_swipe_fingers[fingers], edge); return TIZEN_GESTURE_ERROR_NONE; } @@ -60,7 +60,7 @@ 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_swipe_set_client_to_list(client, &grabbed_client->swipe_fingers[num_of_fingers], direction); + _e_gesture_edge_swipe_set_client_to_list(client, &grabbed_client->edge_swipe_fingers[fingers], edge); gesture->grab_client_list = eina_list_append(gesture->grab_client_list, grabbed_client); @@ -68,7 +68,7 @@ e_gesture_add_client_destroy_listener(struct wl_client *client, int mode EINA_UN } static void -_e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int num_of_fingers, unsigned int direction) +_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; @@ -78,14 +78,14 @@ _e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int { if (data->client == client) { - _e_gesture_swipe_set_client_to_list(NULL, &data->swipe_fingers[num_of_fingers], direction); + _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->swipe_fingers[i].direction[E_GESTURE_DIRECTION_DOWN].client || - data->swipe_fingers[i].direction[E_GESTURE_DIRECTION_LEFT].client || - data->swipe_fingers[i].direction[E_GESTURE_DIRECTION_UP].client || - data->swipe_fingers[i].direction[E_GESTURE_DIRECTION_RIGHT].client) + 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; } @@ -99,185 +99,187 @@ _e_gesture_remove_client_destroy_listener(struct wl_client *client, unsigned int } static void -_e_gesture_cb_grab_swipe(struct wl_client *client, +_e_gesture_cb_grab_edge_swipe(struct wl_client *client, struct wl_resource *resource, - uint32_t num_of_fingers, uint32_t direction) + uint32_t fingers, uint32_t edge) { E_Gesture_Event *gev; - unsigned int grabbed_direction = 0x0; + unsigned int grabbed_edge = 0x0; - GTINF("client %p is request grab gesture, fingers: %d, direction: 0x%x\n", client, num_of_fingers, direction); - if (num_of_fingers > E_GESTURE_FINGER_MAX) + GTINF("client %p is request grab gesture, fingers: %d, edge: 0x%x\n", client, fingers, edge); + if (fingers > E_GESTURE_FINGER_MAX) { - GTWRN("Do not support %d fingers (max: %d)\n", num_of_fingers, E_GESTURE_FINGER_MAX); - tizen_gesture_send_grab_swipe_notify(resource, num_of_fingers, direction, TIZEN_GESTURE_ERROR_INVALID_DATA); + 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); goto out; } gev = &gesture->gesture_events; - if (direction & TIZEN_GESTURE_DIRECTION_DOWN) + if (edge & TIZEN_GESTURE_EDGE_TOP) { - if (gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_DOWN].client) + if (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_TOP].client) { - grabbed_direction |= TIZEN_GESTURE_DIRECTION_DOWN; + grabbed_edge |= TIZEN_GESTURE_EDGE_TOP; } else { - gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_DOWN].client = client; - gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_DOWN].res = resource; + 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 (direction & TIZEN_GESTURE_DIRECTION_LEFT) + if (edge & TIZEN_GESTURE_EDGE_RIGHT) { - if (gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_LEFT].client) + if (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_RIGHT].client) { - grabbed_direction |= TIZEN_GESTURE_DIRECTION_LEFT; + grabbed_edge |= TIZEN_GESTURE_EDGE_RIGHT; } else { - gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_LEFT].client = client; - gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_LEFT].res = resource; + 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 (direction & TIZEN_GESTURE_DIRECTION_UP) + if (edge & TIZEN_GESTURE_EDGE_BOTTOM) { - if (gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_UP].client) + if (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_BOTTOM].client) { - grabbed_direction |= TIZEN_GESTURE_DIRECTION_UP; + grabbed_edge |= TIZEN_GESTURE_EDGE_BOTTOM; } else { - gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_UP].client = client; - gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_UP].res = resource; + 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 (direction & TIZEN_GESTURE_DIRECTION_RIGHT) + if (edge & TIZEN_GESTURE_EDGE_LEFT) { - if (gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_RIGHT].client) + if (gev->edge_swipes.fingers[fingers].edge[E_GESTURE_EDGE_LEFT].client) { - grabbed_direction |= TIZEN_GESTURE_DIRECTION_RIGHT; + grabbed_edge |= TIZEN_GESTURE_EDGE_LEFT; } else { - gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_RIGHT].client = client; - gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_RIGHT].res = resource; + 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_direction) - tizen_gesture_send_grab_swipe_notify(resource, num_of_fingers, grabbed_direction, TIZEN_GESTURE_ERROR_GRABBED_ALREADY); + 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_SWIPE, num_of_fingers, direction & ~grabbed_direction); - gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_SWIPE; - gev->swipes.fingers[num_of_fingers].enabled = EINA_TRUE; + e_gesture_add_client_destroy_listener(client, TIZEN_GESTURE_TYPE_EDGE_SWIPE, fingers, edge & ~grabbed_edge); + 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 (!grabbed_direction) - tizen_gesture_send_grab_swipe_notify(resource, num_of_fingers, direction, TIZEN_GESTURE_ERROR_NONE); + if (!grabbed_edge) + tizen_gesture_send_grab_edge_swipe_notify(resource, fingers, edge, TIZEN_GESTURE_ERROR_NONE); out: return; } static void -_e_gesture_cb_ungrab_swipe(struct wl_client *client, +_e_gesture_cb_ungrab_edge_swipe(struct wl_client *client, struct wl_resource *resouce, - uint32_t num_of_fingers, uint32_t direction) + uint32_t fingers, uint32_t edge) { int i, j; E_Gesture_Event *gev; - unsigned int ungrabbed_direction = 0x0; + unsigned int ungrabbed_edge = 0x0; int ret = TIZEN_GESTURE_ERROR_NONE; - GTINF("client %p is request ungrab swipe gesture, fingers: %d, direction: 0x%x, client: %p\n", client, num_of_fingers, direction, gesture->gesture_events.swipes.fingers[0].direction[3].client); + 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); - 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 (direction & TIZEN_GESTURE_DIRECTION_DOWN) + if (edge & TIZEN_GESTURE_EDGE_TOP) { - if ((gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_DOWN].client) && - (gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_DOWN].client == client)) + 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->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_DOWN].client = NULL; - gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_DOWN].res = NULL; + 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_direction |= TIZEN_GESTURE_DIRECTION_DOWN; + ungrabbed_edge |= TIZEN_GESTURE_EDGE_TOP; } } - if (direction & TIZEN_GESTURE_DIRECTION_LEFT) + if (edge & TIZEN_GESTURE_EDGE_RIGHT) { - if ((gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_LEFT].client) && - (gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_LEFT].client == client)) + 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->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_LEFT].client = NULL; - gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_LEFT].res = NULL; + 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_direction |= TIZEN_GESTURE_DIRECTION_LEFT; + ungrabbed_edge |= TIZEN_GESTURE_EDGE_RIGHT; } } - if (direction & TIZEN_GESTURE_DIRECTION_UP) + if (edge & TIZEN_GESTURE_EDGE_BOTTOM) { - if ((gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_UP].client) && - (gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_UP].client == client)) + 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->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_UP].client = NULL; - gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_UP].res = NULL; + 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_direction |= TIZEN_GESTURE_DIRECTION_UP; + ungrabbed_edge |= TIZEN_GESTURE_EDGE_BOTTOM; } } - if (direction & TIZEN_GESTURE_DIRECTION_RIGHT) + if (edge & TIZEN_GESTURE_EDGE_LEFT) { - if ((gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_RIGHT].client) && - (gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_RIGHT].client == client)) + 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->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_RIGHT].client = NULL; - gev->swipes.fingers[num_of_fingers].direction[E_GESTURE_DIRECTION_RIGHT].res = NULL; + 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_direction |= TIZEN_GESTURE_DIRECTION_RIGHT; + ungrabbed_edge |= TIZEN_GESTURE_EDGE_LEFT; } } - if (direction & ~ungrabbed_direction) + if (edge & ~ungrabbed_edge) { - _e_gesture_remove_client_destroy_listener(client, num_of_fingers, direction & ~ungrabbed_direction); + _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_DIRECTION_MAX+1; j++) + for (j = 0; j < E_GESTURE_EDGE_MAX+1; j++) { - if (gev->swipes.fingers[i].direction[j].client) + if (gev->edge_swipes.fingers[i].edge[j].client) { goto finish; } } - gev->swipes.fingers[i].enabled = EINA_FALSE; + gev->edge_swipes.fingers[i].enabled = EINA_FALSE; } - gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_SWIPE; + gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_EDGE_SWIPE; + if (gev->edge_swipes.event_keep) gesture->event_state = E_GESTURE_EVENT_STATE_PROPAGATE; } finish: - tizen_gesture_send_grab_swipe_notify(resouce, num_of_fingers, direction, ret); + tizen_gesture_send_grab_edge_swipe_notify(resouce, fingers, edge, ret); return; } static const struct tizen_gesture_interface _e_gesture_implementation = { - _e_gesture_cb_grab_swipe, - _e_gesture_cb_ungrab_swipe + _e_gesture_cb_grab_edge_swipe, + _e_gesture_cb_ungrab_edge_swipe }; /* tizen_gesture global object destroy function */ @@ -390,9 +392,9 @@ _e_gesture_init(E_Module *m) gesture->config = gconfig; GTDBG("config value\n"); - GTDBG("keyboard: %s, time_done: %lf, time_begin: %lf\n", gconfig->conf->key_device_name, gconfig->conf->swipe.time_done, gconfig->conf->swipe.time_begin); - GTDBG("area_offset: %d, min_length: %d, max_length: %d\n", gconfig->conf->swipe.area_offset, gconfig->conf->swipe.min_length, gconfig->conf->swipe.max_length); - GTDBG("compose key: %d, back: %d, default: %d\n", gconfig->conf->swipe.compose_key, gconfig->conf->swipe.back_key, gconfig->conf->swipe.default_enable_back); + 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); gesture->global = wl_global_create(e_comp_wl->wl.disp, &tizen_gesture_interface, 1, gesture, _e_gesture_cb_bind); if (!gesture->global) @@ -403,12 +405,17 @@ _e_gesture_init(E_Module *m) gesture->gesture_filter = E_GESTURE_TYPE_MAX; - if (gconfig->conf->swipe.default_enable_back) + gesture->gesture_events.edge_swipes.event_keep = gconfig->conf->edge_swipe.event_keep; + if (gconfig->conf->edge_swipe.default_enable_back) { - gesture->grabbed_gesture |= TIZEN_GESTURE_TYPE_SWIPE; - gesture->gesture_events.swipes.fingers[1].enabled = EINA_TRUE; - gesture->gesture_events.swipes.fingers[1].direction[E_GESTURE_DIRECTION_DOWN].client = (void *)0x1; - gesture->gesture_events.swipes.fingers[1].direction[E_GESTURE_DIRECTION_DOWN].res = (void *)0x1; + gesture->grabbed_gesture |= TIZEN_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; + if (gesture->gesture_events.edge_swipes.event_keep) + { + gesture->event_state = E_GESTURE_EVENT_STATE_KEEP; + } } e_gesture_device_keydev_set(gesture->config->conf->key_device_name); @@ -459,32 +466,32 @@ _e_gesture_wl_client_cb_destroy(struct wl_listener *l, void *data) Eina_List *l_list, *l_next; E_Gesture_Grabbed_Client *client_data; - if (gesture->grabbed_gesture & TIZEN_GESTURE_TYPE_SWIPE) + if (gesture->grabbed_gesture & TIZEN_GESTURE_TYPE_EDGE_SWIPE) { for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) { - for (j = 0; j < E_GESTURE_DIRECTION_MAX+1; j++) + for (j = 0; j < E_GESTURE_EDGE_MAX+1; j++) { - if (gesture->gesture_events.swipes.fingers[i].direction[j].client == client) + if (gesture->gesture_events.edge_swipes.fingers[i].edge[j].client == client) { - gesture->gesture_events.swipes.fingers[i].direction[j].client = NULL; - gesture->gesture_events.swipes.fingers[i].direction[j].res = NULL; + gesture->gesture_events.edge_swipes.fingers[i].edge[j].client = NULL; + gesture->gesture_events.edge_swipes.fingers[i].edge[j].res = NULL; } } } for (i = 0; i < E_GESTURE_FINGER_MAX+1; i++) { - for (j = 0; j < E_GESTURE_DIRECTION_MAX+1; j++) + for (j = 0; j < E_GESTURE_EDGE_MAX+1; j++) { - if (gesture->gesture_events.swipes.fingers[i].direction[j].client) + if (gesture->gesture_events.edge_swipes.fingers[i].edge[j].client) { goto out; } } - gesture->gesture_events.swipes.fingers[i].enabled = EINA_FALSE; + gesture->gesture_events.edge_swipes.fingers[i].enabled = EINA_FALSE; } - gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_SWIPE; + gesture->grabbed_gesture &= ~TIZEN_GESTURE_TYPE_EDGE_SWIPE; } out: diff --git a/src/e_mod_main.h b/src/e_mod_main.h index 62b8d21..9179932 100644 --- a/src/e_mod_main.h +++ b/src/e_mod_main.h @@ -4,6 +4,7 @@ #include #include #include +#include #define GTERR(msg, ARG...) ERR("[tizen_gesture][%s:%d] "msg, __FUNCTION__, __LINE__, ##ARG) #define GTWRN(msg, ARG...) WRN("[tizen_gesture][%s:%d] "msg, __FUNCTION__, __LINE__, ##ARG) @@ -11,49 +12,59 @@ #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_SWIPE+1 -#define E_GESTURE_TYPE_ALL TIZEN_GESTURE_TYPE_SWIPE +#define E_GESTURE_TYPE_MAX TIZEN_GESTURE_TYPE_EDGE_SWIPE+1 +#define E_GESTURE_TYPE_ALL TIZEN_GESTURE_TYPE_EDGE_SWIPE #define E_GESTURE_KEYBOARD_NAME "Gesture Keyboard" /* FIX ME: Set values in contiguration file, do not use definition */ #define E_GESTURE_KEYBOARD_DEVICE "Any" -#define E_GESTURE_SWIPE_DONE_TIME 0.5 -#define E_GESTURE_SWIPE_START_TIME 0.01 -#define E_GESTURE_SWIPE_START_AREA 50 -#define E_GESTURE_SWIPE_DIFF_FAIL 100 -#define E_GESTURE_SWIPE_DIFF_SUCCESS 300 +#define E_GESTURE_EDGE_SWIPE_DONE_TIME 0.5 +#define E_GESTURE_EDGE_SWIPE_START_TIME 0.01 +#define E_GESTURE_EDGE_SWIPE_START_AREA 50 +#define E_GESTURE_EDGE_SWIPE_DIFF_FAIL 100 +#define E_GESTURE_EDGE_SWIPE_DIFF_SUCCESS 300 /* FIX ME: Key code will be get from keymap */ -#define E_GESTURE_SWIPE_COMBINE_KEY 124 -#define E_GESTURE_SWIPE_BACK_KEY 166 -#define E_GESTURE_SWIPE_BACK_DEFAULT_ENABLE EINA_TRUE +#define E_GESTURE_EDGE_SWIPE_COMBINE_KEY 124 +#define E_GESTURE_EDGE_SWIPE_BACK_KEY 166 +#define E_GESTURE_EDGE_SWIPE_BACK_DEFAULT_ENABLE EINA_TRUE #define ABS(x) ((x)>0)?(x):-(x) typedef struct _E_Gesture E_Gesture; typedef struct _E_Gesture* E_GesturePtr; typedef struct _E_Gesture_Event E_Gesture_Event; -typedef struct _E_Gesture_Event_Swipe E_Gesture_Event_Swipe; -typedef struct _E_Gesture_Event_Swipe_Finger E_Gesture_Event_Swipe_Finger; -typedef struct _E_Gesture_Event_Swipe_Finger_Direction E_Gesture_Event_Swipe_Finger_Direction; +typedef struct _E_Gesture_Event_Edge_Swipe E_Gesture_Event_Edge_Swipe; +typedef struct _E_Gesture_Event_Edge_Swipe_Finger E_Gesture_Event_Edge_Swipe_Finger; +typedef struct _E_Gesture_Event_Edge_Swipe_Finger_Edge E_Gesture_Event_Edge_Swipe_Finger_Edge; typedef struct _E_Gesture_Grabbed_Client E_Gesture_Grabbed_Client; typedef struct _E_Gesture_Conf_Edd E_Gesture_Conf_Edd; typedef struct _E_Gesture_Config_Data E_Gesture_Config_Data; typedef struct _Coords Coords; +typedef struct _E_Gesture_Event_Info E_Gesture_Event_Info; -typedef enum _E_Gesture_Direction E_Gesture_Direction; +typedef enum _E_Gesture_Edge E_Gesture_Edge; +typedef enum _E_Gesture_Event_State E_Gesture_Event_State; extern E_GesturePtr gesture; -#define E_GESTURE_DIRECTION_MAX 4 -enum _E_Gesture_Direction +#define E_GESTURE_EDGE_MAX 4 + +enum _E_Gesture_Edge { - E_GESTURE_DIRECTION_NONE, - E_GESTURE_DIRECTION_DOWN, //Start point is North - E_GESTURE_DIRECTION_LEFT, // Start point is East - E_GESTURE_DIRECTION_UP, // Start point is South - E_GESTURE_DIRECTION_RIGHT // Start point is West + E_GESTURE_EDGE_NONE, + E_GESTURE_EDGE_TOP, + E_GESTURE_EDGE_RIGHT, + E_GESTURE_EDGE_BOTTOM, + E_GESTURE_EDGE_LEFT +}; + +enum _E_Gesture_Event_State +{ + E_GESTURE_EVENT_STATE_PROPAGATE, + E_GESTURE_EVENT_STATE_KEEP, + E_GESTURE_EVENT_STATE_IGNORE }; struct _Coords @@ -61,6 +72,12 @@ struct _Coords int x, y; }; +struct _E_Gesture_Event_Info +{ + int type; + void *event; +}; + struct _E_Gesture_Conf_Edd { char *key_device_name; @@ -74,7 +91,8 @@ struct _E_Gesture_Conf_Edd int compose_key; int back_key; Eina_Bool default_enable_back; - } swipe; + Eina_Bool event_keep; + } edge_swipe; }; struct _E_Gesture_Config_Data @@ -84,17 +102,17 @@ struct _E_Gesture_Config_Data E_Gesture_Conf_Edd *conf; }; -struct _E_Gesture_Event_Swipe_Finger_Direction +struct _E_Gesture_Event_Edge_Swipe_Finger_Edge { struct wl_client *client; struct wl_resource *res; }; -struct _E_Gesture_Event_Swipe_Finger +struct _E_Gesture_Event_Edge_Swipe_Finger { Coords start; Eina_Bool enabled; - E_Gesture_Event_Swipe_Finger_Direction direction[E_GESTURE_DIRECTION_MAX+1]; + E_Gesture_Event_Edge_Swipe_Finger_Edge edge[E_GESTURE_EDGE_MAX+1]; }; struct _E_Gesture_Grabbed_Client @@ -102,15 +120,15 @@ struct _E_Gesture_Grabbed_Client struct wl_client *client; struct wl_listener *destroy_listener; - E_Gesture_Event_Swipe_Finger swipe_fingers[E_GESTURE_FINGER_MAX+1]; + E_Gesture_Event_Edge_Swipe_Finger edge_swipe_fingers[E_GESTURE_FINGER_MAX+1]; }; -struct _E_Gesture_Event_Swipe +struct _E_Gesture_Event_Edge_Swipe { - E_Gesture_Event_Swipe_Finger fingers[E_GESTURE_FINGER_MAX+1]; + E_Gesture_Event_Edge_Swipe_Finger fingers[E_GESTURE_FINGER_MAX+1]; - E_Gesture_Direction direction; + unsigned int edge; unsigned int combined_keycode; unsigned int back_keycode; @@ -118,11 +136,13 @@ struct _E_Gesture_Event_Swipe unsigned int enabled_finger; Ecore_Timer *start_timer; Ecore_Timer *done_timer; + + Eina_Bool event_keep; }; struct _E_Gesture_Event { - E_Gesture_Event_Swipe swipes; + E_Gesture_Event_Edge_Swipe edge_swipes; int num_pressed; Eina_Bool recognized_gesture; @@ -150,6 +170,9 @@ struct _E_Gesture unsigned int grabbed_gesture; E_Gesture_Event gesture_events; + E_Gesture_Event_State event_state; + + Eina_List *event_queue; unsigned int gesture_filter; unsigned int gesture_recognized; @@ -170,8 +193,8 @@ void e_gesture_conf_deinit(E_Gesture_Config_Data *gconfig); /* Device control */ void e_gesture_device_shutdown(void); -Eina_Bool e_gesture_device_add(Ecore_Event_Device_Info *ev); -Eina_Bool e_gesture_device_del(Ecore_Event_Device_Info *ev); +E_Gesture_Event_State e_gesture_device_add(Ecore_Event_Device_Info *ev); +E_Gesture_Event_State e_gesture_device_del(Ecore_Event_Device_Info *ev); Eina_Bool e_gesture_is_touch_device(const Ecore_Device *dev); void e_gesture_device_keydev_set(char *option); -- 2.7.4