summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorMike Blumenkrantz <zmike@samsung.com>2020-01-06 13:13:51 -0500
committerMarcel Hollerbach <mail@marcel-hollerbach.de>2020-01-07 16:08:23 +0100
commit227483e079de4e2dbe6977a4a3d0afdd4e761953 (patch)
treecd98034614418143587a49925e5bd3e2fc5934b4
parent33402436236c48677ab84fb94d05d7c6e3d2f946 (diff)
efl/gesture: correct namespacing of all gesture enums in C
these were flattened to all be EFL_GESTURE_$MEMBER, which made them impossible to read and use effectively Reviewed-by: Marcel Hollerbach <mail@marcel-hollerbach.de> Differential Revision: https://phab.enlightenment.org/D11026
-rw-r--r--src/bin/elementary/test_gesture_framework.c44
-rw-r--r--src/lib/evas/gesture/efl_canvas_gesture_manager.c46
-rw-r--r--src/lib/evas/gesture/efl_canvas_gesture_recognizer.c4
-rw-r--r--src/lib/evas/gesture/efl_canvas_gesture_recognizer_double_tap.c30
-rw-r--r--src/lib/evas/gesture/efl_canvas_gesture_recognizer_flick.c38
-rw-r--r--src/lib/evas/gesture/efl_canvas_gesture_recognizer_long_tap.c22
-rw-r--r--src/lib/evas/gesture/efl_canvas_gesture_recognizer_momentum.c22
-rw-r--r--src/lib/evas/gesture/efl_canvas_gesture_recognizer_tap.c24
-rw-r--r--src/lib/evas/gesture/efl_canvas_gesture_recognizer_triple_tap.c30
-rw-r--r--src/lib/evas/gesture/efl_canvas_gesture_recognizer_zoom.c34
-rw-r--r--src/lib/evas/gesture/efl_canvas_gesture_touch.c8
-rw-r--r--src/lib/evas/gesture/efl_canvas_gesture_types.eot8
12 files changed, 155 insertions, 155 deletions
diff --git a/src/bin/elementary/test_gesture_framework.c b/src/bin/elementary/test_gesture_framework.c
index 5e2e935e49..3b9e57a986 100644
--- a/src/bin/elementary/test_gesture_framework.c
+++ b/src/bin/elementary/test_gesture_framework.c
@@ -370,13 +370,13 @@ tap_gesture_cb(void *data , const Efl_Event *ev)
370 Efl_Canvas_Gesture *g = ev->info; 370 Efl_Canvas_Gesture *g = ev->info;
371 switch(efl_gesture_state_get(g)) 371 switch(efl_gesture_state_get(g))
372 { 372 {
373 case EFL_GESTURE_STARTED: 373 case EFL_GESTURE_STATE_STARTED:
374 finger_tap_start(data, g); 374 finger_tap_start(data, g);
375 break; 375 break;
376 case EFL_GESTURE_CANCELED: 376 case EFL_GESTURE_STATE_CANCELED:
377 finger_tap_abort(data, g); 377 finger_tap_abort(data, g);
378 break; 378 break;
379 case EFL_GESTURE_FINISHED: 379 case EFL_GESTURE_STATE_FINISHED:
380 finger_tap_end(data, g); 380 finger_tap_end(data, g);
381 break; 381 break;
382 default: 382 default:
@@ -390,13 +390,13 @@ flick_gesture_cb(void *data , const Efl_Event *ev)
390 Efl_Canvas_Gesture *g = ev->info; 390 Efl_Canvas_Gesture *g = ev->info;
391 switch(efl_gesture_state_get(g)) 391 switch(efl_gesture_state_get(g))
392 { 392 {
393 case EFL_GESTURE_STARTED: 393 case EFL_GESTURE_STATE_STARTED:
394 finger_flick_start(data, g); 394 finger_flick_start(data, g);
395 break; 395 break;
396 case EFL_GESTURE_CANCELED: 396 case EFL_GESTURE_STATE_CANCELED:
397 finger_flick_abort(data, g); 397 finger_flick_abort(data, g);
398 break; 398 break;
399 case EFL_GESTURE_FINISHED: 399 case EFL_GESTURE_STATE_FINISHED:
400 finger_flick_end(data, g); 400 finger_flick_end(data, g);
401 break; 401 break;
402 default: 402 default:
@@ -410,16 +410,16 @@ momentum_gesture_cb(void *data , const Efl_Event *ev)
410 Efl_Canvas_Gesture *g = ev->info; 410 Efl_Canvas_Gesture *g = ev->info;
411 switch(efl_gesture_state_get(g)) 411 switch(efl_gesture_state_get(g))
412 { 412 {
413 case EFL_GESTURE_STARTED: 413 case EFL_GESTURE_STATE_STARTED:
414 finger_momentum_start(data, g); 414 finger_momentum_start(data, g);
415 break; 415 break;
416 case EFL_GESTURE_UPDATED: 416 case EFL_GESTURE_STATE_UPDATED:
417 finger_momentum_update(data, g); 417 finger_momentum_update(data, g);
418 break; 418 break;
419 case EFL_GESTURE_CANCELED: 419 case EFL_GESTURE_STATE_CANCELED:
420 finger_momentum_abort(data, g); 420 finger_momentum_abort(data, g);
421 break; 421 break;
422 case EFL_GESTURE_FINISHED: 422 case EFL_GESTURE_STATE_FINISHED:
423 finger_momentum_end(data, g); 423 finger_momentum_end(data, g);
424 break; 424 break;
425 default: 425 default:
@@ -433,16 +433,16 @@ triple_tap_gesture_cb(void *data , const Efl_Event *ev)
433 Efl_Canvas_Gesture *g = ev->info; 433 Efl_Canvas_Gesture *g = ev->info;
434 switch(efl_gesture_state_get(g)) 434 switch(efl_gesture_state_get(g))
435 { 435 {
436 case EFL_GESTURE_STARTED: 436 case EFL_GESTURE_STATE_STARTED:
437 finger_triple_tap_start(data, g); 437 finger_triple_tap_start(data, g);
438 break; 438 break;
439 case EFL_GESTURE_UPDATED: 439 case EFL_GESTURE_STATE_UPDATED:
440 finger_triple_tap_update(data, g); 440 finger_triple_tap_update(data, g);
441 break; 441 break;
442 case EFL_GESTURE_CANCELED: 442 case EFL_GESTURE_STATE_CANCELED:
443 finger_triple_tap_abort(data, g); 443 finger_triple_tap_abort(data, g);
444 break; 444 break;
445 case EFL_GESTURE_FINISHED: 445 case EFL_GESTURE_STATE_FINISHED:
446 finger_triple_tap_end(data, g); 446 finger_triple_tap_end(data, g);
447 break; 447 break;
448 default: 448 default:
@@ -456,16 +456,16 @@ double_tap_gesture_cb(void *data , const Efl_Event *ev)
456 Efl_Canvas_Gesture *g = ev->info; 456 Efl_Canvas_Gesture *g = ev->info;
457 switch(efl_gesture_state_get(g)) 457 switch(efl_gesture_state_get(g))
458 { 458 {
459 case EFL_GESTURE_STARTED: 459 case EFL_GESTURE_STATE_STARTED:
460 finger_double_tap_start(data, g); 460 finger_double_tap_start(data, g);
461 break; 461 break;
462 case EFL_GESTURE_UPDATED: 462 case EFL_GESTURE_STATE_UPDATED:
463 finger_double_tap_update(data, g); 463 finger_double_tap_update(data, g);
464 break; 464 break;
465 case EFL_GESTURE_CANCELED: 465 case EFL_GESTURE_STATE_CANCELED:
466 finger_double_tap_abort(data, g); 466 finger_double_tap_abort(data, g);
467 break; 467 break;
468 case EFL_GESTURE_FINISHED: 468 case EFL_GESTURE_STATE_FINISHED:
469 finger_double_tap_end(data, g); 469 finger_double_tap_end(data, g);
470 break; 470 break;
471 default: 471 default:
@@ -479,16 +479,16 @@ long_tap_gesture_cb(void *data , const Efl_Event *ev)
479 Efl_Canvas_Gesture *g = ev->info; 479 Efl_Canvas_Gesture *g = ev->info;
480 switch(efl_gesture_state_get(g)) 480 switch(efl_gesture_state_get(g))
481 { 481 {
482 case EFL_GESTURE_STARTED: 482 case EFL_GESTURE_STATE_STARTED:
483 finger_long_tap_start(data, g); 483 finger_long_tap_start(data, g);
484 break; 484 break;
485 case EFL_GESTURE_UPDATED: 485 case EFL_GESTURE_STATE_UPDATED:
486 finger_long_tap_update(data, g); 486 finger_long_tap_update(data, g);
487 break; 487 break;
488 case EFL_GESTURE_CANCELED: 488 case EFL_GESTURE_STATE_CANCELED:
489 finger_long_tap_abort(data, g); 489 finger_long_tap_abort(data, g);
490 break; 490 break;
491 case EFL_GESTURE_FINISHED: 491 case EFL_GESTURE_STATE_FINISHED:
492 finger_long_tap_end(data, g); 492 finger_long_tap_end(data, g);
493 break; 493 break;
494 default: 494 default:
diff --git a/src/lib/evas/gesture/efl_canvas_gesture_manager.c b/src/lib/evas/gesture/efl_canvas_gesture_manager.c
index d5103186e1..a2d3077404 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_manager.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_manager.c
@@ -182,7 +182,7 @@ _efl_canvas_gesture_manager_filter_event(void *data, Eo *target, void *event)
182 182
183 //This is for handling the case that mouse event pairs dont match. 183 //This is for handling the case that mouse event pairs dont match.
184 //Such as the case of canceling gesture recognition after a mouse down. 184 //Such as the case of canceling gesture recognition after a mouse down.
185 if (efl_gesture_touch_state_get(touch_event) == EFL_GESTURE_TOUCH_UNKNOWN) 185 if (efl_gesture_touch_state_get(touch_event) == EFL_GESTURE_TOUCH_STATE_UNKNOWN)
186 continue; 186 continue;
187 187
188 recognizer = eina_hash_find(pd->m_recognizers, &gesture_type); 188 recognizer = eina_hash_find(pd->m_recognizers, &gesture_type);
@@ -194,30 +194,30 @@ _efl_canvas_gesture_manager_filter_event(void *data, Eo *target, void *event)
194 194
195 //Gesture detecting. 195 //Gesture detecting.
196 recog_result = efl_gesture_recognizer_recognize(recognizer, gesture, target, touch_event); 196 recog_result = efl_gesture_recognizer_recognize(recognizer, gesture, target, touch_event);
197 recog_state = recog_result & EFL_GESTURE_RESULT_MASK; 197 recog_state = recog_result & EFL_GESTURE_RECOGNIZER_RESULT_RESULT_MASK;
198 198
199 Efl_Canvas_Gesture_Recognizer_Data *rd = 199 Efl_Canvas_Gesture_Recognizer_Data *rd =
200 efl_data_scope_get(recognizer, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS); 200 efl_data_scope_get(recognizer, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS);
201 201
202 if (recog_state == EFL_GESTURE_TRIGGER) 202 if (recog_state == EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER)
203 { 203 {
204 if (efl_gesture_state_get(gesture) == EFL_GESTURE_NONE) 204 if (efl_gesture_state_get(gesture) == EFL_GESTURE_STATE_NONE)
205 efl_gesture_state_set(gesture, EFL_GESTURE_STARTED); 205 efl_gesture_state_set(gesture, EFL_GESTURE_STATE_STARTED);
206 else 206 else
207 efl_gesture_state_set(gesture, EFL_GESTURE_UPDATED); 207 efl_gesture_state_set(gesture, EFL_GESTURE_STATE_UPDATED);
208 } 208 }
209 else if (recog_state == EFL_GESTURE_FINISH) 209 else if (recog_state == EFL_GESTURE_RECOGNIZER_RESULT_FINISH)
210 { 210 {
211 efl_gesture_state_set(gesture, EFL_GESTURE_FINISHED); 211 efl_gesture_state_set(gesture, EFL_GESTURE_STATE_FINISHED);
212 } 212 }
213 else if (recog_state == EFL_GESTURE_MAYBE) 213 else if (recog_state == EFL_GESTURE_RECOGNIZER_RESULT_MAYBE)
214 { 214 {
215 continue; 215 continue;
216 } 216 }
217 else if (recog_state == EFL_GESTURE_CANCEL) 217 else if (recog_state == EFL_GESTURE_RECOGNIZER_RESULT_CANCEL)
218 { 218 {
219 if (efl_gesture_state_get(gesture) != EFL_GESTURE_NONE) 219 if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE)
220 efl_gesture_state_set(gesture, EFL_GESTURE_CANCELED); 220 efl_gesture_state_set(gesture, EFL_GESTURE_STATE_CANCELED);
221 else 221 else
222 { 222 {
223 //Need to recognize events that occur consecutively 223 //Need to recognize events that occur consecutively
@@ -226,7 +226,7 @@ _efl_canvas_gesture_manager_filter_event(void *data, Eo *target, void *event)
226 continue; 226 continue;
227 } 227 }
228 } 228 }
229 else if (recog_state == EFL_GESTURE_IGNORE) 229 else if (recog_state == EFL_GESTURE_RECOGNIZER_RESULT_IGNORE)
230 { 230 {
231 continue; 231 continue;
232 } 232 }
@@ -235,7 +235,7 @@ _efl_canvas_gesture_manager_filter_event(void *data, Eo *target, void *event)
235 efl_event_callback_call(target, gesture_type, gesture); 235 efl_event_callback_call(target, gesture_type, gesture);
236 236
237 //If the current event recognizes the gesture continuously, dont delete gesture. 237 //If the current event recognizes the gesture continuously, dont delete gesture.
238 if (((recog_state == EFL_GESTURE_FINISH) || (recog_state == EFL_GESTURE_CANCEL)) && 238 if (((recog_state == EFL_GESTURE_RECOGNIZER_RESULT_FINISH) || (recog_state == EFL_GESTURE_RECOGNIZER_RESULT_CANCEL)) &&
239 !rd->continues) 239 !rd->continues)
240 { 240 {
241 _cleanup_cached_gestures(pd, target, gesture_type); 241 _cleanup_cached_gestures(pd, target, gesture_type);
@@ -314,37 +314,37 @@ _find_match_recognizer(Efl_Canvas_Gesture_Manager_Data *pd, Efl_Canvas_Gesture_R
314 314
315 switch (type) 315 switch (type)
316 { 316 {
317 case EFL_GESTURE_TAP: 317 case EFL_GESTURE_RECOGNIZER_TYPE_TAP:
318 { 318 {
319 event_type = EFL_EVENT_GESTURE_TAP; 319 event_type = EFL_EVENT_GESTURE_TAP;
320 break; 320 break;
321 } 321 }
322 case EFL_GESTURE_DOUBLETAP: 322 case EFL_GESTURE_RECOGNIZER_TYPE_DOUBLETAP:
323 { 323 {
324 event_type = EFL_EVENT_GESTURE_DOUBLE_TAP; 324 event_type = EFL_EVENT_GESTURE_DOUBLE_TAP;
325 break; 325 break;
326 } 326 }
327 case EFL_GESTURE_TRIPLETAP: 327 case EFL_GESTURE_RECOGNIZER_TYPE_TRIPLETAP:
328 { 328 {
329 event_type = EFL_EVENT_GESTURE_TRIPLE_TAP; 329 event_type = EFL_EVENT_GESTURE_TRIPLE_TAP;
330 break; 330 break;
331 } 331 }
332 case EFL_GESTURE_LONGTAP: 332 case EFL_GESTURE_RECOGNIZER_TYPE_LONGTAP:
333 { 333 {
334 event_type = EFL_EVENT_GESTURE_LONG_TAP; 334 event_type = EFL_EVENT_GESTURE_LONG_TAP;
335 break; 335 break;
336 } 336 }
337 case EFL_GESTURE_MOMENTUM: 337 case EFL_GESTURE_RECOGNIZER_TYPE_MOMENTUM:
338 { 338 {
339 event_type = EFL_EVENT_GESTURE_MOMENTUM; 339 event_type = EFL_EVENT_GESTURE_MOMENTUM;
340 break; 340 break;
341 } 341 }
342 case EFL_GESTURE_FLICK: 342 case EFL_GESTURE_RECOGNIZER_TYPE_FLICK:
343 { 343 {
344 event_type = EFL_EVENT_GESTURE_FLICK; 344 event_type = EFL_EVENT_GESTURE_FLICK;
345 break; 345 break;
346 } 346 }
347 case EFL_GESTURE_ZOOM: 347 case EFL_GESTURE_RECOGNIZER_TYPE_ZOOM:
348 { 348 {
349 event_type = EFL_EVENT_GESTURE_ZOOM; 349 event_type = EFL_EVENT_GESTURE_ZOOM;
350 break; 350 break;
@@ -410,8 +410,8 @@ _get_state(Efl_Canvas_Gesture_Manager_Data *pd,
410 object_gesture->type == type) 410 object_gesture->type == type)
411 { 411 {
412 //The gesture is already processed waiting for cleanup 412 //The gesture is already processed waiting for cleanup
413 if (((efl_gesture_state_get(object_gesture->gesture) == EFL_GESTURE_FINISHED) || 413 if (((efl_gesture_state_get(object_gesture->gesture) == EFL_GESTURE_STATE_FINISHED) ||
414 (efl_gesture_state_get(object_gesture->gesture) == EFL_GESTURE_CANCELED)) && 414 (efl_gesture_state_get(object_gesture->gesture) == EFL_GESTURE_STATE_CANCELED)) &&
415 (!rd->continues)) 415 (!rd->continues))
416 { 416 {
417 _cleanup_cached_gestures(pd, target, type); 417 _cleanup_cached_gestures(pd, target, type);
diff --git a/src/lib/evas/gesture/efl_canvas_gesture_recognizer.c b/src/lib/evas/gesture/efl_canvas_gesture_recognizer.c
index 8a83e2f945..e7c242b11c 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer.c
@@ -2,7 +2,7 @@
2 2
3#define MY_CLASS EFL_CANVAS_GESTURE_RECOGNIZER_CLASS 3#define MY_CLASS EFL_CANVAS_GESTURE_RECOGNIZER_CLASS
4 4
5#define EFL_GESTURE_TAP_FINGER_SIZE 10 5#define EFL_GESTURE_RECOGNIZER_TYPE_TAP_FINGER_SIZE 10
6EOLIAN static Eina_Value * 6EOLIAN static Eina_Value *
7_efl_canvas_gesture_recognizer_config_get(const Eo *obj EINA_UNUSED, Efl_Canvas_Gesture_Recognizer_Data *pd, const char *name) 7_efl_canvas_gesture_recognizer_config_get(const Eo *obj EINA_UNUSED, Efl_Canvas_Gesture_Recognizer_Data *pd, const char *name)
8{ 8{
@@ -21,7 +21,7 @@ _efl_canvas_gesture_recognizer_efl_object_constructor(Eo *obj, Efl_Canvas_Gestur
21{ 21{
22 obj = efl_constructor(efl_super(obj, MY_CLASS)); 22 obj = efl_constructor(efl_super(obj, MY_CLASS));
23 23
24 pd->finger_size = EFL_GESTURE_TAP_FINGER_SIZE; 24 pd->finger_size = EFL_GESTURE_RECOGNIZER_TYPE_TAP_FINGER_SIZE;
25 25
26 return obj; 26 return obj;
27} 27}
diff --git a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_double_tap.c b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_double_tap.c
index 1656bb633f..4319ab77b0 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_double_tap.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_double_tap.c
@@ -29,7 +29,7 @@ _tap_timeout_cb(void *data)
29 rd = efl_data_scope_get(data, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS); 29 rd = efl_data_scope_get(data, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS);
30 pd = efl_data_scope_get(data, EFL_CANVAS_GESTURE_RECOGNIZER_DOUBLE_TAP_CLASS); 30 pd = efl_data_scope_get(data, EFL_CANVAS_GESTURE_RECOGNIZER_DOUBLE_TAP_CLASS);
31 31
32 efl_gesture_state_set(pd->gesture, EFL_GESTURE_CANCELED); 32 efl_gesture_state_set(pd->gesture, EFL_GESTURE_STATE_CANCELED);
33 efl_event_callback_call(pd->target, EFL_EVENT_GESTURE_DOUBLE_TAP, pd->gesture); 33 efl_event_callback_call(pd->target, EFL_EVENT_GESTURE_DOUBLE_TAP, pd->gesture);
34 34
35 efl_gesture_manager_gesture_clean_up(rd->manager, pd->target, EFL_EVENT_GESTURE_DOUBLE_TAP); 35 efl_gesture_manager_gesture_clean_up(rd->manager, pd->target, EFL_EVENT_GESTURE_DOUBLE_TAP);
@@ -50,7 +50,7 @@ _efl_canvas_gesture_recognizer_double_tap_efl_canvas_gesture_recognizer_recogniz
50 double timeout = TAP_TIME_OUT; 50 double timeout = TAP_TIME_OUT;
51 Eina_Position2D pos; 51 Eina_Position2D pos;
52 Eina_Vector2 dist; 52 Eina_Vector2 dist;
53 Efl_Canvas_Gesture_Recognizer_Result result = EFL_GESTURE_CANCEL; 53 Efl_Canvas_Gesture_Recognizer_Result result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
54 Efl_Canvas_Gesture_Recognizer_Data *rd = efl_data_scope_get(obj, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS); 54 Efl_Canvas_Gesture_Recognizer_Data *rd = efl_data_scope_get(obj, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS);
55 55
56 pd->target = watched; 56 pd->target = watched;
@@ -72,7 +72,7 @@ _efl_canvas_gesture_recognizer_double_tap_efl_canvas_gesture_recognizer_recogniz
72 72
73 switch (efl_gesture_touch_state_get(event)) 73 switch (efl_gesture_touch_state_get(event))
74 { 74 {
75 case EFL_GESTURE_TOUCH_BEGIN: 75 case EFL_GESTURE_TOUCH_STATE_BEGIN:
76 { 76 {
77 pos = efl_gesture_touch_start_point_get(event); 77 pos = efl_gesture_touch_start_point_get(event);
78 efl_gesture_hotspot_set(gesture, pos); 78 efl_gesture_hotspot_set(gesture, pos);
@@ -82,16 +82,16 @@ _efl_canvas_gesture_recognizer_double_tap_efl_canvas_gesture_recognizer_recogniz
82 else 82 else
83 pd->timeout = ecore_timer_add(timeout, _tap_timeout_cb, obj); 83 pd->timeout = ecore_timer_add(timeout, _tap_timeout_cb, obj);
84 84
85 result = EFL_GESTURE_TRIGGER; 85 result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
86 86
87 break; 87 break;
88 } 88 }
89 89
90 case EFL_GESTURE_TOUCH_UPDATE: 90 case EFL_GESTURE_TOUCH_STATE_UPDATE:
91 { 91 {
92 result = EFL_GESTURE_IGNORE; 92 result = EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
93 93
94 if (efl_gesture_state_get(gesture) != EFL_GESTURE_NONE && 94 if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
95 !efl_gesture_touch_multi_touch_get(event)) 95 !efl_gesture_touch_multi_touch_get(event))
96 { 96 {
97 dist = efl_gesture_touch_distance(event, 0); 97 dist = efl_gesture_touch_distance(event, 0);
@@ -105,7 +105,7 @@ _efl_canvas_gesture_recognizer_double_tap_efl_canvas_gesture_recognizer_recogniz
105 pd->timeout = NULL; 105 pd->timeout = NULL;
106 } 106 }
107 107
108 result = EFL_GESTURE_CANCEL; 108 result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
109 109
110 pd->tap_count = 0; 110 pd->tap_count = 0;
111 } 111 }
@@ -113,10 +113,10 @@ _efl_canvas_gesture_recognizer_double_tap_efl_canvas_gesture_recognizer_recogniz
113 113
114 break; 114 break;
115 } 115 }
116 case EFL_GESTURE_TOUCH_END: 116 case EFL_GESTURE_TOUCH_STATE_END:
117 { 117 {
118 118
119 if (efl_gesture_state_get(gesture) != EFL_GESTURE_NONE && 119 if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
120 !efl_gesture_touch_multi_touch_get(event)) 120 !efl_gesture_touch_multi_touch_get(event))
121 { 121 {
122 dist = efl_gesture_touch_distance(event, 0); 122 dist = efl_gesture_touch_distance(event, 0);
@@ -130,7 +130,7 @@ _efl_canvas_gesture_recognizer_double_tap_efl_canvas_gesture_recognizer_recogniz
130 if (pd->timeout) 130 if (pd->timeout)
131 ecore_timer_reset(pd->timeout); 131 ecore_timer_reset(pd->timeout);
132 132
133 result = EFL_GESTURE_TRIGGER; 133 result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
134 } 134 }
135 else 135 else
136 { 136 {
@@ -140,10 +140,10 @@ _efl_canvas_gesture_recognizer_double_tap_efl_canvas_gesture_recognizer_recogniz
140 pd->timeout = NULL; 140 pd->timeout = NULL;
141 } 141 }
142 142
143 if (efl_gesture_touch_state_get(event) == EFL_GESTURE_TOUCH_END) 143 if (efl_gesture_touch_state_get(event) == EFL_GESTURE_TOUCH_STATE_END)
144 result = EFL_GESTURE_FINISH; 144 result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
145 else 145 else
146 result = EFL_GESTURE_TRIGGER; 146 result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
147 147
148 pd->tap_count = 0; 148 pd->tap_count = 0;
149 } 149 }
@@ -156,7 +156,7 @@ _efl_canvas_gesture_recognizer_double_tap_efl_canvas_gesture_recognizer_recogniz
156 pd->timeout = NULL; 156 pd->timeout = NULL;
157 } 157 }
158 158
159 result = EFL_GESTURE_CANCEL; 159 result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
160 160
161 pd->tap_count = 0; 161 pd->tap_count = 0;
162 } 162 }
diff --git a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_flick.c b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_flick.c
index 4968c61b34..dee7ca364d 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_flick.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_flick.c
@@ -70,8 +70,8 @@ _single_line_process(Eo *obj,
70{ 70{
71 switch (efl_gesture_touch_state_get(event)) 71 switch (efl_gesture_touch_state_get(event))
72 { 72 {
73 case EFL_GESTURE_TOUCH_BEGIN: 73 case EFL_GESTURE_TOUCH_STATE_BEGIN:
74 case EFL_GESTURE_TOUCH_UPDATE: 74 case EFL_GESTURE_TOUCH_STATE_UPDATE:
75 if (!pd->t_st) 75 if (!pd->t_st)
76 { 76 {
77 pd->st_line = efl_gesture_touch_cur_point_get(event); 77 pd->st_line = efl_gesture_touch_cur_point_get(event);
@@ -84,7 +84,7 @@ _single_line_process(Eo *obj,
84 84
85 break; 85 break;
86 86
87 case EFL_GESTURE_TOUCH_END: 87 case EFL_GESTURE_TOUCH_STATE_END:
88 { 88 {
89 if (!pd->t_st) return; 89 if (!pd->t_st) return;
90 90
@@ -177,7 +177,7 @@ _efl_canvas_gesture_recognizer_flick_efl_canvas_gesture_recognizer_recognize(Eo
177 double angle; 177 double angle;
178 Eina_Value *val; 178 Eina_Value *val;
179 unsigned char glayer_continues_enable; 179 unsigned char glayer_continues_enable;
180 Efl_Canvas_Gesture_Recognizer_Result result = EFL_GESTURE_CANCEL; 180 Efl_Canvas_Gesture_Recognizer_Result result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
181 Eina_Bool touch_up = EINA_FALSE; 181 Eina_Bool touch_up = EINA_FALSE;
182 Efl_Canvas_Gesture_Flick_Data *fd = efl_data_scope_get(gesture, EFL_CANVAS_GESTURE_FLICK_CLASS); 182 Efl_Canvas_Gesture_Flick_Data *fd = efl_data_scope_get(gesture, EFL_CANVAS_GESTURE_FLICK_CLASS);
183 Efl_Canvas_Gesture_Recognizer_Data *rd = efl_data_scope_get(obj, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS); 183 Efl_Canvas_Gesture_Recognizer_Data *rd = efl_data_scope_get(obj, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS);
@@ -190,14 +190,14 @@ _efl_canvas_gesture_recognizer_flick_efl_canvas_gesture_recognizer_recognize(Eo
190 //without mouse up. 190 //without mouse up.
191 //Recognizing the gesture again, even though it was canceled during gesture 191 //Recognizing the gesture again, even though it was canceled during gesture
192 //recognition. 192 //recognition.
193 if (efl_gesture_state_get(gesture) == EFL_GESTURE_CANCELED) 193 if (efl_gesture_state_get(gesture) == EFL_GESTURE_STATE_CANCELED)
194 efl_gesture_state_set(gesture, EFL_GESTURE_NONE); 194 efl_gesture_state_set(gesture, EFL_GESTURE_STATE_NONE);
195 195
196 if (efl_gesture_touch_state_get(event) == EFL_GESTURE_TOUCH_END) 196 if (efl_gesture_touch_state_get(event) == EFL_GESTURE_TOUCH_STATE_END)
197 touch_up = EINA_TRUE; 197 touch_up = EINA_TRUE;
198 198
199 //This is to handle a case with a mouse click on the target object. 199 //This is to handle a case with a mouse click on the target object.
200 if (efl_gesture_touch_state_get(event) == EFL_GESTURE_TOUCH_END && !pd->touched) 200 if (efl_gesture_touch_state_get(event) == EFL_GESTURE_TOUCH_STATE_END && !pd->touched)
201 efl_gesture_manager_gesture_clean_up(rd->manager, watched, EFL_EVENT_GESTURE_FLICK); 201 efl_gesture_manager_gesture_clean_up(rd->manager, watched, EFL_EVENT_GESTURE_FLICK);
202 202
203 if (glayer_continues_enable && !pd->touched) 203 if (glayer_continues_enable && !pd->touched)
@@ -206,7 +206,7 @@ _efl_canvas_gesture_recognizer_flick_efl_canvas_gesture_recognizer_recognize(Eo
206 pd->line_angle = -1.0; 206 pd->line_angle = -1.0;
207 rd->continues = EINA_TRUE; 207 rd->continues = EINA_TRUE;
208 208
209 return EFL_GESTURE_IGNORE; 209 return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
210 } 210 }
211 211
212 _single_line_process(obj, pd, gesture, fd, event); 212 _single_line_process(obj, pd, gesture, fd, event);
@@ -238,7 +238,7 @@ _efl_canvas_gesture_recognizer_flick_efl_canvas_gesture_recognizer_recognize(Eo
238 238
239 if (touch_up) rd->continues = EINA_FALSE; 239 if (touch_up) rd->continues = EINA_FALSE;
240 240
241 return EFL_GESTURE_CANCEL; 241 return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
242 } 242 }
243 243
244 /* We may finish line if momentum is zero */ 244 /* We may finish line if momentum is zero */
@@ -273,7 +273,7 @@ _efl_canvas_gesture_recognizer_flick_efl_canvas_gesture_recognizer_recognize(Eo
273 273
274 if (touch_up) rd->continues = EINA_FALSE; 274 if (touch_up) rd->continues = EINA_FALSE;
275 275
276 return EFL_GESTURE_CANCEL; 276 return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
277 } 277 }
278 } 278 }
279 } 279 }
@@ -296,42 +296,42 @@ _efl_canvas_gesture_recognizer_flick_efl_canvas_gesture_recognizer_recognize(Eo
296 296
297 if (touch_up) rd->continues = EINA_FALSE; 297 if (touch_up) rd->continues = EINA_FALSE;
298 298
299 return EFL_GESTURE_CANCEL; 299 return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
300 } 300 }
301 301
302 switch (efl_gesture_touch_state_get(event)) 302 switch (efl_gesture_touch_state_get(event))
303 { 303 {
304 case EFL_GESTURE_TOUCH_BEGIN: 304 case EFL_GESTURE_TOUCH_STATE_BEGIN:
305 case EFL_GESTURE_TOUCH_UPDATE: 305 case EFL_GESTURE_TOUCH_STATE_UPDATE:
306 { 306 {
307 if (pd->t_st) 307 if (pd->t_st)
308 { 308 {
309 if (glayer_continues_enable && pd->t_end) 309 if (glayer_continues_enable && pd->t_end)
310 { 310 {
311 result = EFL_GESTURE_FINISH; 311 result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
312 } 312 }
313 else 313 else
314 { 314 {
315 result = EFL_GESTURE_TRIGGER; 315 result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
316 } 316 }
317 } 317 }
318 break; 318 break;
319 } 319 }
320 320
321 case EFL_GESTURE_TOUCH_END: 321 case EFL_GESTURE_TOUCH_STATE_END:
322 { 322 {
323 if (!pd->t_st) 323 if (!pd->t_st)
324 { 324 {
325 pd->touched = EINA_FALSE; 325 pd->touched = EINA_FALSE;
326 rd->continues = EINA_FALSE; 326 rd->continues = EINA_FALSE;
327 327
328 return EFL_GESTURE_CANCEL; 328 return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
329 } 329 }
330 if (pd->t_st && pd->t_end) 330 if (pd->t_st && pd->t_end)
331 { 331 {
332 rd->continues = EINA_FALSE; 332 rd->continues = EINA_FALSE;
333 333
334 result = EFL_GESTURE_FINISH; 334 result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
335 } 335 }
336 336
337 efl_gesture_hotspot_set(gesture, efl_gesture_touch_cur_point_get(event)); 337 efl_gesture_hotspot_set(gesture, efl_gesture_touch_cur_point_get(event));
diff --git a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_long_tap.c b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_long_tap.c
index 8f6773588b..f936a37dca 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_long_tap.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_long_tap.c
@@ -30,7 +30,7 @@ _long_tap_timeout_cb(void *data)
30 /* FIXME: Needs to propagate this event back to evas! */ 30 /* FIXME: Needs to propagate this event back to evas! */
31 pd->is_timeout = EINA_TRUE; 31 pd->is_timeout = EINA_TRUE;
32 32
33 efl_gesture_state_set(pd->gesture, EFL_GESTURE_UPDATED); 33 efl_gesture_state_set(pd->gesture, EFL_GESTURE_STATE_UPDATED);
34 efl_event_callback_call(pd->target, EFL_EVENT_GESTURE_LONG_TAP, pd->gesture); 34 efl_event_callback_call(pd->target, EFL_EVENT_GESTURE_LONG_TAP, pd->gesture);
35 35
36 return ECORE_CALLBACK_RENEW; 36 return ECORE_CALLBACK_RENEW;
@@ -47,7 +47,7 @@ _efl_canvas_gesture_recognizer_long_tap_efl_canvas_gesture_recognizer_recognize(
47 double timeout = EFL_GESTURE_LONG_TAP_TIME_OUT; 47 double timeout = EFL_GESTURE_LONG_TAP_TIME_OUT;
48 Eina_Position2D pos; 48 Eina_Position2D pos;
49 Eina_Vector2 dist; 49 Eina_Vector2 dist;
50 Efl_Canvas_Gesture_Recognizer_Result result = EFL_GESTURE_CANCEL; 50 Efl_Canvas_Gesture_Recognizer_Result result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
51 Efl_Canvas_Gesture_Recognizer_Data *rd = efl_data_scope_get(obj, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS); 51 Efl_Canvas_Gesture_Recognizer_Data *rd = efl_data_scope_get(obj, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS);
52 52
53 pd->target = watched; 53 pd->target = watched;
@@ -70,7 +70,7 @@ _efl_canvas_gesture_recognizer_long_tap_efl_canvas_gesture_recognizer_recognize(
70 70
71 switch (efl_gesture_touch_state_get(event)) 71 switch (efl_gesture_touch_state_get(event))
72 { 72 {
73 case EFL_GESTURE_TOUCH_BEGIN: 73 case EFL_GESTURE_TOUCH_STATE_BEGIN:
74 { 74 {
75 pos = efl_gesture_touch_start_point_get(event); 75 pos = efl_gesture_touch_start_point_get(event);
76 efl_gesture_hotspot_set(gesture, pos); 76 efl_gesture_hotspot_set(gesture, pos);
@@ -82,12 +82,12 @@ _efl_canvas_gesture_recognizer_long_tap_efl_canvas_gesture_recognizer_recognize(
82 pd->timeout = ecore_timer_add(timeout, 82 pd->timeout = ecore_timer_add(timeout,
83 _long_tap_timeout_cb, pd); 83 _long_tap_timeout_cb, pd);
84 84
85 result = EFL_GESTURE_TRIGGER; 85 result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
86 86
87 break; 87 break;
88 } 88 }
89 89
90 case EFL_GESTURE_TOUCH_UPDATE: 90 case EFL_GESTURE_TOUCH_STATE_UPDATE:
91 { 91 {
92 dist = efl_gesture_touch_distance(event, 0); 92 dist = efl_gesture_touch_distance(event, 0);
93 length = fabs(dist.x) + fabs(dist.y); 93 length = fabs(dist.x) + fabs(dist.y);
@@ -100,17 +100,17 @@ _efl_canvas_gesture_recognizer_long_tap_efl_canvas_gesture_recognizer_recognize(
100 pd->timeout = NULL; 100 pd->timeout = NULL;
101 } 101 }
102 102
103 result = EFL_GESTURE_CANCEL; 103 result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
104 } 104 }
105 else 105 else
106 { 106 {
107 result = EFL_GESTURE_MAYBE; 107 result = EFL_GESTURE_RECOGNIZER_RESULT_MAYBE;
108 } 108 }
109 109
110 break; 110 break;
111 } 111 }
112 112
113 case EFL_GESTURE_TOUCH_END: 113 case EFL_GESTURE_TOUCH_STATE_END:
114 { 114 {
115 if (pd->timeout) 115 if (pd->timeout)
116 { 116 {
@@ -118,18 +118,18 @@ _efl_canvas_gesture_recognizer_long_tap_efl_canvas_gesture_recognizer_recognize(
118 pd->timeout = NULL; 118 pd->timeout = NULL;
119 } 119 }
120 120
121 if (efl_gesture_state_get(gesture) != EFL_GESTURE_NONE && 121 if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
122 !efl_gesture_touch_multi_touch_get(event)) 122 !efl_gesture_touch_multi_touch_get(event))
123 { 123 {
124 dist = efl_gesture_touch_distance(event, 0); 124 dist = efl_gesture_touch_distance(event, 0);
125 length = fabs(dist.x) + fabs(dist.y); 125 length = fabs(dist.x) + fabs(dist.y);
126 if (length <= rd->finger_size && pd->is_timeout) 126 if (length <= rd->finger_size && pd->is_timeout)
127 { 127 {
128 result = EFL_GESTURE_FINISH; 128 result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
129 } 129 }
130 else 130 else
131 { 131 {
132 result = EFL_GESTURE_CANCEL; 132 result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
133 } 133 }
134 } 134 }
135 135
diff --git a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_momentum.c b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_momentum.c
index 2e007cc0f9..9926f92087 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_momentum.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_momentum.c
@@ -76,7 +76,7 @@ _efl_canvas_gesture_recognizer_momentum_efl_canvas_gesture_recognizer_recognize(
76{ 76{
77 Eina_Value *val; 77 Eina_Value *val;
78 unsigned char glayer_continues_enable; 78 unsigned char glayer_continues_enable;
79 Efl_Canvas_Gesture_Recognizer_Result result = EFL_GESTURE_CANCEL; 79 Efl_Canvas_Gesture_Recognizer_Result result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
80 Efl_Canvas_Gesture_Momentum_Data *md = efl_data_scope_get(gesture, EFL_CANVAS_GESTURE_MOMENTUM_CLASS); 80 Efl_Canvas_Gesture_Momentum_Data *md = efl_data_scope_get(gesture, EFL_CANVAS_GESTURE_MOMENTUM_CLASS);
81 81
82 val = efl_gesture_recognizer_config_get(obj, "glayer_continues_enable"); 82 val = efl_gesture_recognizer_config_get(obj, "glayer_continues_enable");
@@ -89,17 +89,17 @@ _efl_canvas_gesture_recognizer_momentum_efl_canvas_gesture_recognizer_recognize(
89 { 89 {
90 pd->touched = EINA_TRUE; 90 pd->touched = EINA_TRUE;
91 91
92 return EFL_GESTURE_IGNORE; 92 return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
93 } 93 }
94 94
95 switch (efl_gesture_touch_state_get(event)) 95 switch (efl_gesture_touch_state_get(event))
96 { 96 {
97 case EFL_GESTURE_TOUCH_BEGIN: 97 case EFL_GESTURE_TOUCH_STATE_BEGIN:
98 case EFL_GESTURE_TOUCH_UPDATE: 98 case EFL_GESTURE_TOUCH_STATE_UPDATE:
99 { 99 {
100 if (!pd->t_st) 100 if (!pd->t_st)
101 { 101 {
102 if (efl_gesture_touch_state_get(event) == EFL_GESTURE_TOUCH_BEGIN || 102 if (efl_gesture_touch_state_get(event) == EFL_GESTURE_TOUCH_STATE_BEGIN ||
103 glayer_continues_enable) 103 glayer_continues_enable)
104 { 104 {
105 pd->t_st = pd->t_end = efl_gesture_touch_cur_timestamp_get(event); 105 pd->t_st = pd->t_end = efl_gesture_touch_cur_timestamp_get(event);
@@ -109,7 +109,7 @@ _efl_canvas_gesture_recognizer_momentum_efl_canvas_gesture_recognizer_recognize(
109 109
110 efl_gesture_hotspot_set(gesture, pd->st_line); 110 efl_gesture_hotspot_set(gesture, pd->st_line);
111 111
112 return EFL_GESTURE_TRIGGER; 112 return EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
113 } 113 }
114 } 114 }
115 115
@@ -150,18 +150,18 @@ _efl_canvas_gesture_recognizer_momentum_efl_canvas_gesture_recognizer_recognize(
150 _momentum_set(obj, md, pd->st_line, efl_gesture_touch_cur_point_get(event), 150 _momentum_set(obj, md, pd->st_line, efl_gesture_touch_cur_point_get(event),
151 pd->t_st, efl_gesture_touch_cur_timestamp_get(event)); 151 pd->t_st, efl_gesture_touch_cur_timestamp_get(event));
152 152
153 result = EFL_GESTURE_TRIGGER; 153 result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
154 154
155 break; 155 break;
156 } 156 }
157 157
158 case EFL_GESTURE_TOUCH_END: 158 case EFL_GESTURE_TOUCH_STATE_END:
159 { 159 {
160 if (!pd->t_st) 160 if (!pd->t_st)
161 { 161 {
162 pd->touched = EINA_FALSE; 162 pd->touched = EINA_FALSE;
163 163
164 return EFL_GESTURE_CANCEL; 164 return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
165 } 165 }
166 166
167 if ((efl_gesture_touch_cur_timestamp_get(event) - MOMENTUM_TIMEOUT) > pd->t_end) 167 if ((efl_gesture_touch_cur_timestamp_get(event) - MOMENTUM_TIMEOUT) > pd->t_end)
@@ -177,9 +177,9 @@ _efl_canvas_gesture_recognizer_momentum_efl_canvas_gesture_recognizer_recognize(
177 177
178 if ((fabs(md->momentum.x) > EFL_GESTURE_MINIMUM_MOMENTUM) || 178 if ((fabs(md->momentum.x) > EFL_GESTURE_MINIMUM_MOMENTUM) ||
179 (fabs(md->momentum.y) > EFL_GESTURE_MINIMUM_MOMENTUM)) 179 (fabs(md->momentum.y) > EFL_GESTURE_MINIMUM_MOMENTUM))
180 result = EFL_GESTURE_FINISH; 180 result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
181 else 181 else
182 result = EFL_GESTURE_CANCEL; 182 result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
183 183
184 memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Momentum_Data)); 184 memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Momentum_Data));
185 185
diff --git a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_tap.c b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_tap.c
index 8f53a0585a..5f99d713d4 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_tap.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_tap.c
@@ -4,7 +4,7 @@
4 4
5//FIXME: It doesnt have matched config value. 5//FIXME: It doesnt have matched config value.
6// may using dobule tap timeout value? 6// may using dobule tap timeout value?
7#define EFL_GESTURE_TAP_TIME_OUT 0.33 7#define EFL_GESTURE_RECOGNIZER_TYPE_TAP_TIME_OUT 0.33
8 8
9EOLIAN static Efl_Canvas_Gesture * 9EOLIAN static Efl_Canvas_Gesture *
10_efl_canvas_gesture_recognizer_tap_efl_canvas_gesture_recognizer_add(Eo *obj, 10_efl_canvas_gesture_recognizer_tap_efl_canvas_gesture_recognizer_add(Eo *obj,
@@ -19,7 +19,7 @@ _tap_timeout_cb(void *data)
19{ 19{
20 Efl_Canvas_Gesture_Recognizer_Tap_Data *pd = data; 20 Efl_Canvas_Gesture_Recognizer_Tap_Data *pd = data;
21 21
22 efl_gesture_state_set(pd->gesture, EFL_GESTURE_CANCELED); 22 efl_gesture_state_set(pd->gesture, EFL_GESTURE_STATE_CANCELED);
23 efl_event_callback_call(pd->target, EFL_EVENT_GESTURE_TAP, pd->gesture); 23 efl_event_callback_call(pd->target, EFL_EVENT_GESTURE_TAP, pd->gesture);
24 24
25 return ECORE_CALLBACK_CANCEL; 25 return ECORE_CALLBACK_CANCEL;
@@ -36,7 +36,7 @@ _efl_canvas_gesture_recognizer_tap_efl_canvas_gesture_recognizer_recognize(Eo *o
36 double length; 36 double length;
37 Eina_Position2D pos; 37 Eina_Position2D pos;
38 Eina_Vector2 dist; 38 Eina_Vector2 dist;
39 Efl_Canvas_Gesture_Recognizer_Result result = EFL_GESTURE_CANCEL; 39 Efl_Canvas_Gesture_Recognizer_Result result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
40 Efl_Canvas_Gesture_Recognizer_Data *rd = efl_data_scope_get(obj, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS); 40 Efl_Canvas_Gesture_Recognizer_Data *rd = efl_data_scope_get(obj, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS);
41 41
42 pd->target = watched; 42 pd->target = watched;
@@ -44,22 +44,22 @@ _efl_canvas_gesture_recognizer_tap_efl_canvas_gesture_recognizer_recognize(Eo *o
44 44
45 switch (efl_gesture_touch_state_get(event)) 45 switch (efl_gesture_touch_state_get(event))
46 { 46 {
47 case EFL_GESTURE_TOUCH_BEGIN: 47 case EFL_GESTURE_TOUCH_STATE_BEGIN:
48 { 48 {
49 pos = efl_gesture_touch_start_point_get(event); 49 pos = efl_gesture_touch_start_point_get(event);
50 efl_gesture_hotspot_set(gesture, pos); 50 efl_gesture_hotspot_set(gesture, pos);
51 51
52 if (pd->timeout) 52 if (pd->timeout)
53 ecore_timer_del(pd->timeout); 53 ecore_timer_del(pd->timeout);
54 pd->timeout = ecore_timer_add(EFL_GESTURE_TAP_TIME_OUT, _tap_timeout_cb, pd); 54 pd->timeout = ecore_timer_add(EFL_GESTURE_RECOGNIZER_TYPE_TAP_TIME_OUT, _tap_timeout_cb, pd);
55 55
56 result = EFL_GESTURE_TRIGGER; 56 result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
57 57
58 break; 58 break;
59 } 59 }
60 60
61 case EFL_GESTURE_TOUCH_UPDATE: 61 case EFL_GESTURE_TOUCH_STATE_UPDATE:
62 case EFL_GESTURE_TOUCH_END: 62 case EFL_GESTURE_TOUCH_STATE_END:
63 { 63 {
64 if (pd->timeout) 64 if (pd->timeout)
65 { 65 {
@@ -67,17 +67,17 @@ _efl_canvas_gesture_recognizer_tap_efl_canvas_gesture_recognizer_recognize(Eo *o
67 pd->timeout = NULL; 67 pd->timeout = NULL;
68 } 68 }
69 69
70 if (efl_gesture_state_get(gesture) != EFL_GESTURE_NONE && 70 if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
71 !efl_gesture_touch_multi_touch_get(event)) 71 !efl_gesture_touch_multi_touch_get(event))
72 { 72 {
73 dist = efl_gesture_touch_distance(event, 0); 73 dist = efl_gesture_touch_distance(event, 0);
74 length = fabs(dist.x) + fabs(dist.y); 74 length = fabs(dist.x) + fabs(dist.y);
75 if (length <= rd->finger_size) 75 if (length <= rd->finger_size)
76 { 76 {
77 if (efl_gesture_touch_state_get(event) == EFL_GESTURE_TOUCH_END) 77 if (efl_gesture_touch_state_get(event) == EFL_GESTURE_TOUCH_STATE_END)
78 result = EFL_GESTURE_FINISH; 78 result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
79 else 79 else
80 result = EFL_GESTURE_TRIGGER; 80 result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
81 } 81 }
82 } 82 }
83 83
diff --git a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_triple_tap.c b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_triple_tap.c
index cd54d45886..04f2c28951 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_triple_tap.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_triple_tap.c
@@ -29,7 +29,7 @@ _tap_timeout_cb(void *data)
29 rd = efl_data_scope_get(data, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS); 29 rd = efl_data_scope_get(data, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS);
30 pd = efl_data_scope_get(data, EFL_CANVAS_GESTURE_RECOGNIZER_TRIPLE_TAP_CLASS); 30 pd = efl_data_scope_get(data, EFL_CANVAS_GESTURE_RECOGNIZER_TRIPLE_TAP_CLASS);
31 31
32 efl_gesture_state_set(pd->gesture, EFL_GESTURE_CANCELED); 32 efl_gesture_state_set(pd->gesture, EFL_GESTURE_STATE_CANCELED);
33 efl_event_callback_call(pd->target, EFL_EVENT_GESTURE_TRIPLE_TAP, pd->gesture); 33 efl_event_callback_call(pd->target, EFL_EVENT_GESTURE_TRIPLE_TAP, pd->gesture);
34 34
35 efl_gesture_manager_gesture_clean_up(rd->manager, pd->target, EFL_EVENT_GESTURE_TRIPLE_TAP); 35 efl_gesture_manager_gesture_clean_up(rd->manager, pd->target, EFL_EVENT_GESTURE_TRIPLE_TAP);
@@ -50,7 +50,7 @@ _efl_canvas_gesture_recognizer_triple_tap_efl_canvas_gesture_recognizer_recogniz
50 double timeout = TAP_TIME_OUT; 50 double timeout = TAP_TIME_OUT;
51 Eina_Position2D pos; 51 Eina_Position2D pos;
52 Eina_Vector2 dist; 52 Eina_Vector2 dist;
53 Efl_Canvas_Gesture_Recognizer_Result result = EFL_GESTURE_CANCEL; 53 Efl_Canvas_Gesture_Recognizer_Result result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
54 Efl_Canvas_Gesture_Recognizer_Data *rd = efl_data_scope_get(obj, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS); 54 Efl_Canvas_Gesture_Recognizer_Data *rd = efl_data_scope_get(obj, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS);
55 55
56 pd->target = watched; 56 pd->target = watched;
@@ -72,7 +72,7 @@ _efl_canvas_gesture_recognizer_triple_tap_efl_canvas_gesture_recognizer_recogniz
72 72
73 switch (efl_gesture_touch_state_get(event)) 73 switch (efl_gesture_touch_state_get(event))
74 { 74 {
75 case EFL_GESTURE_TOUCH_BEGIN: 75 case EFL_GESTURE_TOUCH_STATE_BEGIN:
76 { 76 {
77 pos = efl_gesture_touch_start_point_get(event); 77 pos = efl_gesture_touch_start_point_get(event);
78 efl_gesture_hotspot_set(gesture, pos); 78 efl_gesture_hotspot_set(gesture, pos);
@@ -82,16 +82,16 @@ _efl_canvas_gesture_recognizer_triple_tap_efl_canvas_gesture_recognizer_recogniz
82 else 82 else
83 pd->timeout = ecore_timer_add(timeout, _tap_timeout_cb, obj); 83 pd->timeout = ecore_timer_add(timeout, _tap_timeout_cb, obj);
84 84
85 result = EFL_GESTURE_TRIGGER; 85 result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
86 86
87 break; 87 break;
88 } 88 }
89 89
90 case EFL_GESTURE_TOUCH_UPDATE: 90 case EFL_GESTURE_TOUCH_STATE_UPDATE:
91 { 91 {
92 result = EFL_GESTURE_IGNORE; 92 result = EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
93 93
94 if (efl_gesture_state_get(gesture) != EFL_GESTURE_NONE && 94 if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
95 !efl_gesture_touch_multi_touch_get(event)) 95 !efl_gesture_touch_multi_touch_get(event))
96 { 96 {
97 dist = efl_gesture_touch_distance(event, 0); 97 dist = efl_gesture_touch_distance(event, 0);
@@ -105,7 +105,7 @@ _efl_canvas_gesture_recognizer_triple_tap_efl_canvas_gesture_recognizer_recogniz
105 pd->timeout = NULL; 105 pd->timeout = NULL;
106 } 106 }
107 107
108 result = EFL_GESTURE_CANCEL; 108 result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
109 109
110 pd->tap_count = 0; 110 pd->tap_count = 0;
111 } 111 }
@@ -113,10 +113,10 @@ _efl_canvas_gesture_recognizer_triple_tap_efl_canvas_gesture_recognizer_recogniz
113 113
114 break; 114 break;
115 } 115 }
116 case EFL_GESTURE_TOUCH_END: 116 case EFL_GESTURE_TOUCH_STATE_END:
117 { 117 {
118 118
119 if (efl_gesture_state_get(gesture) != EFL_GESTURE_NONE && 119 if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
120 !efl_gesture_touch_multi_touch_get(event)) 120 !efl_gesture_touch_multi_touch_get(event))
121 { 121 {
122 dist = efl_gesture_touch_distance(event, 0); 122 dist = efl_gesture_touch_distance(event, 0);
@@ -130,7 +130,7 @@ _efl_canvas_gesture_recognizer_triple_tap_efl_canvas_gesture_recognizer_recogniz
130 if (pd->timeout) 130 if (pd->timeout)
131 ecore_timer_reset(pd->timeout); 131 ecore_timer_reset(pd->timeout);
132 132
133 result = EFL_GESTURE_TRIGGER; 133 result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
134 } 134 }
135 else 135 else
136 { 136 {
@@ -140,10 +140,10 @@ _efl_canvas_gesture_recognizer_triple_tap_efl_canvas_gesture_recognizer_recogniz
140 pd->timeout = NULL; 140 pd->timeout = NULL;
141 } 141 }
142 142
143 if (efl_gesture_touch_state_get(event) == EFL_GESTURE_TOUCH_END) 143 if (efl_gesture_touch_state_get(event) == EFL_GESTURE_TOUCH_STATE_END)
144 result = EFL_GESTURE_FINISH; 144 result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
145 else 145 else
146 result = EFL_GESTURE_TRIGGER; 146 result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
147 147
148 pd->tap_count = 0; 148 pd->tap_count = 0;
149 } 149 }
@@ -156,7 +156,7 @@ _efl_canvas_gesture_recognizer_triple_tap_efl_canvas_gesture_recognizer_recogniz
156 pd->timeout = NULL; 156 pd->timeout = NULL;
157 } 157 }
158 158
159 result = EFL_GESTURE_CANCEL; 159 result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
160 160
161 pd->tap_count = 0; 161 pd->tap_count = 0;
162 } 162 }
diff --git a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_zoom.c b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_zoom.c
index 0bd41f55b6..504b3c3bcf 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_zoom.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_zoom.c
@@ -131,7 +131,7 @@ _efl_canvas_gesture_recognizer_zoom_efl_canvas_gesture_recognizer_recognize(Eo *
131 Eina_Value *val; 131 Eina_Value *val;
132 unsigned char zoom_finger_enable; 132 unsigned char zoom_finger_enable;
133 unsigned char glayer_continues_enable; 133 unsigned char glayer_continues_enable;
134 Efl_Canvas_Gesture_Recognizer_Result result = EFL_GESTURE_CANCEL; 134 Efl_Canvas_Gesture_Recognizer_Result result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
135 Efl_Canvas_Gesture_Zoom_Data *zd = efl_data_scope_get(gesture, EFL_CANVAS_GESTURE_ZOOM_CLASS); 135 Efl_Canvas_Gesture_Zoom_Data *zd = efl_data_scope_get(gesture, EFL_CANVAS_GESTURE_ZOOM_CLASS);
136 Efl_Canvas_Gesture_Touch_Data *td = efl_data_scope_get(event, EFL_CANVAS_GESTURE_TOUCH_CLASS); 136 Efl_Canvas_Gesture_Touch_Data *td = efl_data_scope_get(event, EFL_CANVAS_GESTURE_TOUCH_CLASS);
137 Efl_Canvas_Gesture_Recognizer_Data *rd = efl_data_scope_get(obj, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS); 137 Efl_Canvas_Gesture_Recognizer_Data *rd = efl_data_scope_get(obj, EFL_CANVAS_GESTURE_RECOGNIZER_CLASS);
@@ -164,26 +164,26 @@ _efl_canvas_gesture_recognizer_zoom_efl_canvas_gesture_recognizer_recognize(Eo *
164 164
165 switch (efl_gesture_touch_state_get(event)) 165 switch (efl_gesture_touch_state_get(event))
166 { 166 {
167 case EFL_GESTURE_TOUCH_UPDATE: 167 case EFL_GESTURE_TOUCH_STATE_UPDATE:
168 { 168 {
169 if ((!glayer_continues_enable) && (!pd->zoom_st.cur.timestamp)) 169 if ((!glayer_continues_enable) && (!pd->zoom_st.cur.timestamp))
170 { 170 {
171 return EFL_GESTURE_IGNORE; 171 return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
172 } 172 }
173 EINA_FALLTHROUGH; 173 EINA_FALLTHROUGH;
174 } 174 }
175 case EFL_GESTURE_TOUCH_BEGIN: 175 case EFL_GESTURE_TOUCH_STATE_BEGIN:
176 { 176 {
177 if (td->touch_down > 2) 177 if (td->touch_down > 2)
178 { 178 {
179 return EFL_GESTURE_CANCEL; 179 return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
180 } 180 }
181 181
182 if (!pd->zoom_st.cur.timestamp) /* Now scan touched-devices list 182 if (!pd->zoom_st.cur.timestamp) /* Now scan touched-devices list
183 * and find other finger */ 183 * and find other finger */
184 { 184 {
185 if (!efl_gesture_touch_multi_touch_get(event)) 185 if (!efl_gesture_touch_multi_touch_get(event))
186 return EFL_GESTURE_IGNORE; 186 return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
187 187
188 Pointer_Data *p1 = eina_hash_find(td->touch_points, &id1); 188 Pointer_Data *p1 = eina_hash_find(td->touch_points, &id1);
189 Pointer_Data *p2 = eina_hash_find(td->touch_points, &id2); 189 Pointer_Data *p2 = eina_hash_find(td->touch_points, &id2);
@@ -204,11 +204,11 @@ _efl_canvas_gesture_recognizer_zoom_efl_canvas_gesture_recognizer_recognize(Eo *
204 204
205 zd->radius = pd->zoom_base / 2.0; 205 zd->radius = pd->zoom_base / 2.0;
206 206
207 if ((efl_gesture_state_get(gesture) != EFL_GESTURE_STARTED) && 207 if ((efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_STARTED) &&
208 (efl_gesture_state_get(gesture) != EFL_GESTURE_UPDATED)) 208 (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_UPDATED))
209 return EFL_GESTURE_TRIGGER; 209 return EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
210 210
211 return EFL_GESTURE_CANCEL; 211 return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
212 } 212 }
213 213
214 Pointer_Data *p2 = eina_hash_find(td->touch_points, &id2); 214 Pointer_Data *p2 = eina_hash_find(td->touch_points, &id2);
@@ -232,13 +232,13 @@ _efl_canvas_gesture_recognizer_zoom_efl_canvas_gesture_recognizer_recognize(Eo *
232 { 232 {
233 pd->next_step = zd->zoom; 233 pd->next_step = zd->zoom;
234 234
235 return EFL_GESTURE_TRIGGER; 235 return EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
236 } 236 }
237 } 237 }
238 238
239 return EFL_GESTURE_IGNORE; 239 return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
240 } 240 }
241 case EFL_GESTURE_TOUCH_END: 241 case EFL_GESTURE_TOUCH_STATE_END:
242 { 242 {
243 if (td->touch_down == 0) 243 if (td->touch_down == 0)
244 { 244 {
@@ -247,20 +247,20 @@ _efl_canvas_gesture_recognizer_zoom_efl_canvas_gesture_recognizer_recognize(Eo *
247 memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Zoom_Data)); 247 memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Zoom_Data));
248 efl_gesture_manager_gesture_clean_up(rd->manager, watched, EFL_EVENT_GESTURE_ZOOM); 248 efl_gesture_manager_gesture_clean_up(rd->manager, watched, EFL_EVENT_GESTURE_ZOOM);
249 249
250 return EFL_GESTURE_IGNORE; 250 return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
251 } 251 }
252 if ((pd->zoom_base) && (pd->zoom_distance_tolerance == 0)) 252 if ((pd->zoom_base) && (pd->zoom_distance_tolerance == 0))
253 { 253 {
254 memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Zoom_Data)); 254 memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Zoom_Data));
255 255
256 return EFL_GESTURE_FINISH; 256 return EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
257 } 257 }
258 258
259 if (efl_gesture_state_get(gesture) != EFL_GESTURE_NONE) 259 if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE)
260 { 260 {
261 memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Zoom_Data)); 261 memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Zoom_Data));
262 262
263 return EFL_GESTURE_CANCEL; 263 return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
264 } 264 }
265 } 265 }
266 266
diff --git a/src/lib/evas/gesture/efl_canvas_gesture_touch.c b/src/lib/evas/gesture/efl_canvas_gesture_touch.c
index bec99b7539..c2c2900db4 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_touch.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_touch.c
@@ -17,7 +17,7 @@ _touch_points_reset(Efl_Canvas_Gesture_Touch_Data *pd)
17 eina_hash_free(pd->touch_points); 17 eina_hash_free(pd->touch_points);
18 pd->touch_points = eina_hash_int32_new(EINA_FREE_CB(_hash_free_cb)); 18 pd->touch_points = eina_hash_int32_new(EINA_FREE_CB(_hash_free_cb));
19 pd->touch_down = 0; 19 pd->touch_down = 0;
20 pd->state = EFL_GESTURE_TOUCH_UNKNOWN; 20 pd->state = EFL_GESTURE_TOUCH_STATE_UNKNOWN;
21} 21}
22 22
23EOLIAN static Efl_Object * 23EOLIAN static Efl_Object *
@@ -101,15 +101,15 @@ _efl_canvas_gesture_touch_point_record(Eo *obj EINA_UNUSED, Efl_Canvas_Gesture_T
101 101
102 if (!id && (action == EFL_POINTER_ACTION_DOWN)) 102 if (!id && (action == EFL_POINTER_ACTION_DOWN))
103 { 103 {
104 pd->state = EFL_GESTURE_TOUCH_BEGIN; 104 pd->state = EFL_GESTURE_TOUCH_STATE_BEGIN;
105 } 105 }
106 else if (action == EFL_POINTER_ACTION_UP) 106 else if (action == EFL_POINTER_ACTION_UP)
107 { 107 {
108 pd->state = EFL_GESTURE_TOUCH_END; 108 pd->state = EFL_GESTURE_TOUCH_STATE_END;
109 } 109 }
110 else 110 else
111 { 111 {
112 pd->state = EFL_GESTURE_TOUCH_UPDATE; 112 pd->state = EFL_GESTURE_TOUCH_STATE_UPDATE;
113 } 113 }
114 return; 114 return;
115 115
diff --git a/src/lib/evas/gesture/efl_canvas_gesture_types.eot b/src/lib/evas/gesture/efl_canvas_gesture_types.eot
index 96a2ff6293..8cde6e18a0 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_types.eot
+++ b/src/lib/evas/gesture/efl_canvas_gesture_types.eot
@@ -1,7 +1,7 @@
1enum @beta Efl.Canvas.Gesture_Touch_State 1enum @beta Efl.Canvas.Gesture_Touch_State
2{ 2{
3 [[ This enum type describes the state of a touch event. ]] 3 [[ This enum type describes the state of a touch event. ]]
4 legacy: efl_gesture_touch; 4 legacy: efl_gesture_touch_state;
5 unknown = 0, [[Gesture Touch State unknown]] 5 unknown = 0, [[Gesture Touch State unknown]]
6 begin , [[First fingure touch down]] 6 begin , [[First fingure touch down]]
7 update, [[fingure touch update]] 7 update, [[fingure touch update]]
@@ -11,7 +11,7 @@ enum @beta Efl.Canvas.Gesture_Touch_State
11enum @beta Efl.Canvas.Gesture_State 11enum @beta Efl.Canvas.Gesture_State
12{ 12{
13 [[ This enum type describes the state of a gesture. ]] 13 [[ This enum type describes the state of a gesture. ]]
14 legacy: efl_gesture; 14 legacy: efl_gesture_state;
15 none = 0, [[No gesture state]] 15 none = 0, [[No gesture state]]
16 started = 1, [[A continuous gesture has started.]] 16 started = 1, [[A continuous gesture has started.]]
17 updated, [[A gesture continues.]] 17 updated, [[A gesture continues.]]
@@ -22,7 +22,7 @@ enum @beta Efl.Canvas.Gesture_State
22enum @beta Efl.Canvas.Gesture_Recognizer_Result 22enum @beta Efl.Canvas.Gesture_Recognizer_Result
23{ 23{
24 [[ This enum type describes the state of a gesture recognizer. ]] 24 [[ This enum type describes the state of a gesture recognizer. ]]
25 legacy: efl_gesture; 25 legacy: efl_gesture_recognizer_result;
26 26
27 ignore = 0x0001, [[The event does not change the state of the recognizer.]] 27 ignore = 0x0001, [[The event does not change the state of the recognizer.]]
28 maybe = 0x0002, [[The event changed the internal state of the recognizer, but it isn't clear yet if it is a gesture or not. The recognizer needs to filter more events to decide.]] 28 maybe = 0x0002, [[The event changed the internal state of the recognizer, but it isn't clear yet if it is a gesture or not. The recognizer needs to filter more events to decide.]]
@@ -35,7 +35,7 @@ enum @beta Efl.Canvas.Gesture_Recognizer_Result
35enum @beta Efl.Canvas.Gesture_Recognizer_Type 35enum @beta Efl.Canvas.Gesture_Recognizer_Type
36{ 36{
37 [[ This enum type describes the state of a touch event. ]] 37 [[ This enum type describes the state of a touch event. ]]
38 legacy: efl_gesture; 38 legacy: efl_gesture_recognizer_type;
39 tap = 0, 39 tap = 0,
40 doubleTap, 40 doubleTap,
41 tripleTap, 41 tripleTap,