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
#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
return NULL;
}
-Eina_Bool
+E_Gesture_Event_State
e_gesture_device_add(Ecore_Event_Device_Info *ev)
{
if (ev->clas == ECORE_DEVICE_CLASS_TOUCH)
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;
E_FREE(gesture->device.kbd_name);
}
}
- return EINA_TRUE;
+ return E_GESTURE_EVENT_STATE_PROPAGATE;
}
Eina_Bool
#include "e_mod_main.h"
#include <string.h>
+#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
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)
}
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;
{
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;
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;
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)
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;
}
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);
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;
}
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;
{
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;
}
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);
}
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;
{
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;
}
}
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 */
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)
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);
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:
#include <e.h>
#include <tizen-extension-server-protocol.h>
#include <Ecore_Drm.h>
+#include <Ecore_Input_Evas.h>
#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)
#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
int x, y;
};
+struct _E_Gesture_Event_Info
+{
+ int type;
+ void *event;
+};
+
struct _E_Gesture_Conf_Edd
{
char *key_device_name;
int compose_key;
int back_key;
Eina_Bool default_enable_back;
- } swipe;
+ Eina_Bool event_keep;
+ } edge_swipe;
};
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
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;
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;
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;
/* 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);
projects / platform / core / uifw / e-mod-tizen-gesture.git / commitdiff