bu5hm4n pushed a commit to branch master.

http://git.enlightenment.org/core/efl.git/commit/?id=f1bbd2bcabbd1107b37a6523325deabddd306ac0

commit f1bbd2bcabbd1107b37a6523325deabddd306ac0
Author: Mike Blumenkrantz <[email protected]>
Date:   Wed Jan 8 10:23:49 2020 -0500

    efl/gesture: formatting
    
    some parts of this were entirely unreadable due to mixed tabs/spaces and 
other
    bizarre formatting issues which somehow made it into the tree
    
    Reviewed-by: Xavi Artigas <[email protected]>
    Differential Revision: https://phab.enlightenment.org/D11053
---
 src/lib/evas/gesture/efl_canvas_gesture.c          |   2 -
 src/lib/evas/gesture/efl_canvas_gesture_manager.c  | 154 ++++++++--------
 .../evas/gesture/efl_canvas_gesture_recognizer.c   |   5 +-
 .../efl_canvas_gesture_recognizer_double_tap.c     | 118 ++++++-------
 .../gesture/efl_canvas_gesture_recognizer_flick.c  | 130 +++++++-------
 .../efl_canvas_gesture_recognizer_long_tap.c       | 119 +++++++------
 .../efl_canvas_gesture_recognizer_momentum.c       | 196 ++++++++++-----------
 .../gesture/efl_canvas_gesture_recognizer_tap.c    |  67 ++++---
 .../efl_canvas_gesture_recognizer_triple_tap.c     | 118 ++++++-------
 .../gesture/efl_canvas_gesture_recognizer_zoom.c   | 169 +++++++++---------
 src/lib/evas/gesture/efl_canvas_gesture_touch.c    |   7 +-
 11 files changed, 543 insertions(+), 542 deletions(-)

diff --git a/src/lib/evas/gesture/efl_canvas_gesture.c 
b/src/lib/evas/gesture/efl_canvas_gesture.c
index 26f279f557..077bc9b527 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture.c
@@ -28,7 +28,6 @@ _efl_canvas_gesture_hotspot_set(Eo *obj EINA_UNUSED, 
Efl_Canvas_Gesture_Data *pd
    pd->hotspot = hotspot;
 }
 
-
 EOLIAN static Eina_Position2D
 _efl_canvas_gesture_hotspot_get(const Eo *obj EINA_UNUSED, 
Efl_Canvas_Gesture_Data *pd)
 {
@@ -41,7 +40,6 @@ _efl_canvas_gesture_timestamp_set(Eo *obj EINA_UNUSED, 
Efl_Canvas_Gesture_Data *
    pd->timestamp = timestamp;
 }
 
-
 EOLIAN static unsigned int
 _efl_canvas_gesture_timestamp_get(const Eo *obj EINA_UNUSED, 
Efl_Canvas_Gesture_Data *pd)
 {
diff --git a/src/lib/evas/gesture/efl_canvas_gesture_manager.c 
b/src/lib/evas/gesture/efl_canvas_gesture_manager.c
index f283985d4d..5a28b04fbf 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_manager.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_manager.c
@@ -4,33 +4,33 @@
 
 typedef struct _Object_Gesture
 {
-   Eo                                    *object;
-   const Efl_Event_Description           *type;
-   Efl_Canvas_Gesture                    *gesture;
-   Efl_Canvas_Gesture_Recognizer         *recognizer;
+   Eo                            *object;
+   const Efl_Event_Description   *type;
+   Efl_Canvas_Gesture            *gesture;
+   Efl_Canvas_Gesture_Recognizer *recognizer;
 } Object_Gesture;
 
 typedef struct _Efl_Canvas_Gesture_Manager_Data
 {
    //Keeps track of all the gesture request for a particular target
-   Eina_Hash    *m_gesture_contex;  // (*target, *event_desc)
+   Eina_Hash *m_gesture_contex;     // (*target, *event_desc)
    //Keeps all the event directed to this particular object from touch_begin 
till touch_end
-   Eina_Hash    *m_object_events;  // (*target, *efl_gesture_touch)
+   Eina_Hash *m_object_events;     // (*target, *efl_gesture_touch)
    //Keeps all the recognizer registered to gesture manager
-   Eina_Hash    *m_recognizers; // (*gesture_type, *recognizer)
+   Eina_Hash *m_recognizers;    // (*gesture_type, *recognizer)
    //Keeps track of all current object gestures.
-   Eina_List    *m_object_gestures; //(List of *object_gesture)
+   Eina_List *m_object_gestures;    //(List of *object_gesture)
    //Lazy deletion of gestures
-   Eina_List    *m_gestures_to_delete;
+   Eina_List *m_gestures_to_delete;
    //Kepps config values for gesture recognize
-   Eina_Hash    *m_config;
+   Eina_Hash *m_config;
 } Efl_Canvas_Gesture_Manager_Data;
 
 static void _cleanup_cached_gestures(Efl_Canvas_Gesture_Manager_Data *pd,
-                                     Eo *target, const Efl_Event_Description 
*type);
-static Efl_Canvas_Gesture*
-_get_state(Efl_Canvas_Gesture_Manager_Data *pd, Eo *target,
-                       Efl_Canvas_Gesture_Recognizer *recognizer, const 
Efl_Event_Description *type);
+                                      Eo *target, const Efl_Event_Description 
*type);
+static Efl_Canvas_Gesture *
+            _get_state(Efl_Canvas_Gesture_Manager_Data *pd, Eo *target,
+           Efl_Canvas_Gesture_Recognizer *recognizer, const 
Efl_Event_Description *type);
 
 static void
 _cleanup_object(Eina_List *list)
@@ -131,7 +131,7 @@ _efl_canvas_gesture_manager_callback_add_hook(void *data, 
Eo *target, const Efl_
 {
    Efl_Canvas_Gesture_Manager_Data *pd = data;
    //If there is a recognizer registered for that event then add it to the 
gesture context
-   Efl_Canvas_Gesture_Recognizer *recognizer = eina_hash_find 
(pd->m_recognizers, &type);
+   Efl_Canvas_Gesture_Recognizer *recognizer = 
eina_hash_find(pd->m_recognizers, &type);
    if (recognizer)
      {
         //Add it to the gesture context.
@@ -144,7 +144,7 @@ _efl_canvas_gesture_manager_callback_del_hook(void *data, 
Eo *target, const Efl_
 {
    Efl_Canvas_Gesture_Manager_Data *pd = data;
    //If there is a recognizer registered for that event then add it to the 
gesture context
-   Efl_Canvas_Gesture_Recognizer *recognizer = eina_hash_find 
(pd->m_recognizers, &type);
+   Efl_Canvas_Gesture_Recognizer *recognizer = 
eina_hash_find(pd->m_recognizers, &type);
    if (recognizer)
      {
         eina_hash_list_remove(pd->m_gesture_contex, &target, type);
@@ -181,18 +181,18 @@ _efl_canvas_gesture_manager_filter_event(void *data, Eo 
*target, void *event)
              efl_gesture_touch_point_record(touch_event, event);
 
              //This is for handling the case that mouse event pairs dont match.
-                        //Such as the case of canceling gesture recognition 
after a mouse down.
+             //Such as the case of canceling gesture recognition after a mouse 
down.
              if (efl_gesture_touch_state_get(touch_event) == 
EFL_GESTURE_TOUCH_STATE_UNKNOWN)
                continue;
 
              recognizer = eina_hash_find(pd->m_recognizers, &gesture_type);
 
-                        //If the gesture canceled or already finished by 
recognizer.
+             //If the gesture canceled or already finished by recognizer.
              gesture = _get_state(pd, target, recognizer, gesture_type);
              if (!gesture)
                continue;
 
-                        //Gesture detecting.
+             //Gesture detecting.
              recog_result = efl_gesture_recognizer_recognize(recognizer, 
gesture, target, touch_event);
              recog_state = recog_result & 
EFL_GESTURE_RECOGNIZER_RESULT_RESULT_MASK;
 
@@ -242,7 +242,6 @@ post_event:
                   //FIXME: delete it by object not list.
                   _cleanup_object(pd->m_gestures_to_delete);
                   pd->m_gestures_to_delete = NULL;
-
                }
           }
      }
@@ -271,7 +270,7 @@ _efl_canvas_gesture_manager_recognizer_register(Eo *obj 
EINA_UNUSED, Efl_Canvas_
 
 EOLIAN static void
 _efl_canvas_gesture_manager_recognizer_unregister(Eo *obj EINA_UNUSED, 
Efl_Canvas_Gesture_Manager_Data *pd,
-                                           Efl_Canvas_Gesture_Recognizer 
*recognizer)
+                                                  
Efl_Canvas_Gesture_Recognizer *recognizer)
 {
    Eina_List *l, *l_next;
    Object_Gesture *object_gesture;
@@ -282,7 +281,7 @@ _efl_canvas_gesture_manager_recognizer_unregister(Eo *obj 
EINA_UNUSED, Efl_Canva
 
    //Find the type of the recognizer
    dummy = efl_gesture_recognizer_add(recognizer, 0);
-   if (!dummy)return;
+   if (!dummy) return;
 
    type = _efl_gesture_type_get(dummy);
    efl_del(dummy);
@@ -313,43 +312,50 @@ _find_match_recognizer(Efl_Canvas_Gesture_Manager_Data 
*pd, Efl_Canvas_Gesture_R
 
    switch (type)
      {
-       case EFL_GESTURE_RECOGNIZER_TYPE_TAP:
-         {
-            event_type = EFL_EVENT_GESTURE_TAP;
-            break;
-         }
-       case EFL_GESTURE_RECOGNIZER_TYPE_DOUBLETAP:
-         {
-            event_type = EFL_EVENT_GESTURE_DOUBLE_TAP;
-            break;
-         }
-       case EFL_GESTURE_RECOGNIZER_TYPE_TRIPLETAP:
-         {
-            event_type = EFL_EVENT_GESTURE_TRIPLE_TAP;
-            break;
-         }
-       case EFL_GESTURE_RECOGNIZER_TYPE_LONGTAP:
-         {
-            event_type = EFL_EVENT_GESTURE_LONG_TAP;
-            break;
-         }
-       case EFL_GESTURE_RECOGNIZER_TYPE_MOMENTUM:
-         {
-            event_type = EFL_EVENT_GESTURE_MOMENTUM;
-            break;
-         }
-       case EFL_GESTURE_RECOGNIZER_TYPE_FLICK:
-         {
-            event_type = EFL_EVENT_GESTURE_FLICK;
-            break;
-         }
-       case EFL_GESTURE_RECOGNIZER_TYPE_ZOOM:
-         {
-            event_type = EFL_EVENT_GESTURE_ZOOM;
-            break;
-         }
-       default:
-         return NULL;
+      case EFL_GESTURE_RECOGNIZER_TYPE_TAP:
+      {
+         event_type = EFL_EVENT_GESTURE_TAP;
+         break;
+      }
+
+      case EFL_GESTURE_RECOGNIZER_TYPE_DOUBLETAP:
+      {
+         event_type = EFL_EVENT_GESTURE_DOUBLE_TAP;
+         break;
+      }
+
+      case EFL_GESTURE_RECOGNIZER_TYPE_TRIPLETAP:
+      {
+         event_type = EFL_EVENT_GESTURE_TRIPLE_TAP;
+         break;
+      }
+
+      case EFL_GESTURE_RECOGNIZER_TYPE_LONGTAP:
+      {
+         event_type = EFL_EVENT_GESTURE_LONG_TAP;
+         break;
+      }
+
+      case EFL_GESTURE_RECOGNIZER_TYPE_MOMENTUM:
+      {
+         event_type = EFL_EVENT_GESTURE_MOMENTUM;
+         break;
+      }
+
+      case EFL_GESTURE_RECOGNIZER_TYPE_FLICK:
+      {
+         event_type = EFL_EVENT_GESTURE_FLICK;
+         break;
+      }
+
+      case EFL_GESTURE_RECOGNIZER_TYPE_ZOOM:
+      {
+         event_type = EFL_EVENT_GESTURE_ZOOM;
+         break;
+      }
+
+      default:
+        return NULL;
      }
 
    return eina_hash_find(pd->m_recognizers, &event_type);
@@ -386,7 +392,7 @@ _efl_canvas_gesture_manager_recognizer_get(Eo *obj 
EINA_UNUSED, Efl_Canvas_Gestu
 // }
 
 //Get or create a gesture object that will represent the state for a given 
object, used by the recognizer
-Efl_Canvas_Gesture*
+Efl_Canvas_Gesture *
 _get_state(Efl_Canvas_Gesture_Manager_Data *pd,
            Eo *target, Efl_Canvas_Gesture_Recognizer *recognizer, const 
Efl_Event_Description *type)
 {
@@ -407,20 +413,20 @@ _get_state(Efl_Canvas_Gesture_Manager_Data *pd,
         if (object_gesture->object == target &&
             object_gesture->recognizer == recognizer &&
             object_gesture->type == type)
-         {
-            //The gesture is already processed waiting for cleanup
-            if (((efl_gesture_state_get(object_gesture->gesture) == 
EFL_GESTURE_STATE_FINISHED) ||
-                (efl_gesture_state_get(object_gesture->gesture) == 
EFL_GESTURE_STATE_CANCELED)) &&
-                (!rd->continues))
-              {
-                 _cleanup_cached_gestures(pd, target, type);
-                 eina_hash_del(pd->m_object_events, &type, NULL);
-                 _cleanup_object(pd->m_gestures_to_delete);
-                 pd->m_gestures_to_delete = NULL;
-                 return NULL;
-              }
-            return object_gesture->gesture;
-         }
+          {
+             //The gesture is already processed waiting for cleanup
+             if (((efl_gesture_state_get(object_gesture->gesture) == 
EFL_GESTURE_STATE_FINISHED) ||
+                  (efl_gesture_state_get(object_gesture->gesture) == 
EFL_GESTURE_STATE_CANCELED)) &&
+                 (!rd->continues))
+               {
+                  _cleanup_cached_gestures(pd, target, type);
+                  eina_hash_del(pd->m_object_events, &type, NULL);
+                  _cleanup_object(pd->m_gestures_to_delete);
+                  pd->m_gestures_to_delete = NULL;
+                  return NULL;
+               }
+             return object_gesture->gesture;
+          }
      }
 
    gesture = efl_gesture_recognizer_add(recognizer, target);
diff --git a/src/lib/evas/gesture/efl_canvas_gesture_recognizer.c 
b/src/lib/evas/gesture/efl_canvas_gesture_recognizer.c
index e7c242b11c..c3dfc61476 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer.c
@@ -1,6 +1,6 @@
 #include "efl_canvas_gesture_private.h"
 
-#define MY_CLASS EFL_CANVAS_GESTURE_RECOGNIZER_CLASS
+#define MY_CLASS                                    
EFL_CANVAS_GESTURE_RECOGNIZER_CLASS
 
 #define EFL_GESTURE_RECOGNIZER_TYPE_TAP_FINGER_SIZE 10
 EOLIAN static Eina_Value *
@@ -11,9 +11,8 @@ _efl_canvas_gesture_recognizer_config_get(const Eo *obj 
EINA_UNUSED, Efl_Canvas_
 
 EOLIAN static void
 _efl_canvas_gesture_recognizer_reset(Eo *obj EINA_UNUSED, 
Efl_Canvas_Gesture_Recognizer_Data *pd EINA_UNUSED,
-                              Efl_Canvas_Gesture *gesture EINA_UNUSED)
+                                     Efl_Canvas_Gesture *gesture EINA_UNUSED)
 {
-
 }
 
 EOLIAN static Efl_Object *
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 4319ab77b0..c676e0e515 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
@@ -1,6 +1,6 @@
 #include "efl_canvas_gesture_private.h"
 
-#define MY_CLASS EFL_CANVAS_GESTURE_RECOGNIZER_DOUBLE_TAP_CLASS
+#define MY_CLASS     EFL_CANVAS_GESTURE_RECOGNIZER_DOUBLE_TAP_CLASS
 
 #define TAP_TIME_OUT 0.33
 
@@ -59,7 +59,7 @@ 
_efl_canvas_gesture_recognizer_double_tap_efl_canvas_gesture_recognizer_recogniz
    if (!pd->start_timeout)
      {
         double time;
-        Eina_Value *val =  efl_gesture_recognizer_config_get(obj, 
"glayer_doublee_tap_timeout");
+        Eina_Value *val = efl_gesture_recognizer_config_get(obj, 
"glayer_doublee_tap_timeout");
 
         if (val)
           {
@@ -73,80 +73,64 @@ 
_efl_canvas_gesture_recognizer_double_tap_efl_canvas_gesture_recognizer_recogniz
    switch (efl_gesture_touch_state_get(event))
      {
       case EFL_GESTURE_TOUCH_STATE_BEGIN:
-           {
-              pos = efl_gesture_touch_start_point_get(event);
-              efl_gesture_hotspot_set(gesture, pos);
+      {
+         pos = efl_gesture_touch_start_point_get(event);
+         efl_gesture_hotspot_set(gesture, pos);
 
-              if (pd->timeout)
-                ecore_timer_reset(pd->timeout);
-              else
-                pd->timeout = ecore_timer_add(timeout, _tap_timeout_cb, obj);
+         if (pd->timeout)
+           ecore_timer_reset(pd->timeout);
+         else
+           pd->timeout = ecore_timer_add(timeout, _tap_timeout_cb, obj);
 
-              result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
+         result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
 
-              break;
-           }
+         break;
+      }
 
       case EFL_GESTURE_TOUCH_STATE_UPDATE:
+      {
+         result = EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
+
+         if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
+             !efl_gesture_touch_multi_touch_get(event))
            {
-              result = EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
+              dist = efl_gesture_touch_distance(event, 0);
+              length = fabs(dist.x) + fabs(dist.y);
 
-              if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
-                  !efl_gesture_touch_multi_touch_get(event))
+              if (length > rd->finger_size)
                 {
-                   dist = efl_gesture_touch_distance(event, 0);
-                   length = fabs(dist.x) + fabs(dist.y);
-
-                   if (length > rd->finger_size)
+                   if (pd->timeout)
                      {
-                        if (pd->timeout)
-                          {
-                             ecore_timer_del(pd->timeout);
-                             pd->timeout = NULL;
-                          }
+                        ecore_timer_del(pd->timeout);
+                        pd->timeout = NULL;
+                     }
 
-                        result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
+                   result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
 
-                        pd->tap_count = 0;
-                     }
+                   pd->tap_count = 0;
                 }
-
-              break;
            }
+
+         break;
+      }
+
       case EFL_GESTURE_TOUCH_STATE_END:
+      {
+         if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
+             !efl_gesture_touch_multi_touch_get(event))
            {
+              dist = efl_gesture_touch_distance(event, 0);
+              length = fabs(dist.x) + fabs(dist.y);
 
-              if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
-                  !efl_gesture_touch_multi_touch_get(event))
+              if (length <= rd->finger_size)
                 {
-                   dist = efl_gesture_touch_distance(event, 0);
-                   length = fabs(dist.x) + fabs(dist.y);
-
-                   if (length <= rd->finger_size)
+                   pd->tap_count++;
+                   if (pd->tap_count == 1)
                      {
-                        pd->tap_count++;
-                        if (pd->tap_count == 1)
-                          {
-                             if (pd->timeout)
-                               ecore_timer_reset(pd->timeout);
+                        if (pd->timeout)
+                          ecore_timer_reset(pd->timeout);
 
-                             result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
-                          }
-                        else
-                          {
-                             if (pd->timeout)
-                               {
-                                  ecore_timer_del(pd->timeout);
-                                  pd->timeout = NULL;
-                               }
-
-                             if (efl_gesture_touch_state_get(event) == 
EFL_GESTURE_TOUCH_STATE_END)
-                               result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
-                             else
-                               result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
-
-                             pd->tap_count = 0;
-                          }
+                        result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
                      }
                    else
                      {
@@ -156,15 +140,31 @@ 
_efl_canvas_gesture_recognizer_double_tap_efl_canvas_gesture_recognizer_recogniz
                              pd->timeout = NULL;
                           }
 
-                        result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
+                        if (efl_gesture_touch_state_get(event) == 
EFL_GESTURE_TOUCH_STATE_END)
+                          result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
+                        else
+                          result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
 
                         pd->tap_count = 0;
                      }
                 }
+              else
+                {
+                   if (pd->timeout)
+                     {
+                        ecore_timer_del(pd->timeout);
+                        pd->timeout = NULL;
+                     }
 
-              break;
+                   result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
+
+                   pd->tap_count = 0;
+                }
            }
 
+         break;
+      }
+
       default:
 
         break;
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 dee7ca364d..3529381df6 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_flick.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_flick.c
@@ -1,11 +1,11 @@
 #include "efl_canvas_gesture_private.h"
 
-#define MY_CLASS EFL_CANVAS_GESTURE_RECOGNIZER_FLICK_CLASS
+#define MY_CLASS                       
EFL_CANVAS_GESTURE_RECOGNIZER_FLICK_CLASS
 
-#define MOMENTUM_TIMEOUT 50
-#define THUMBSCROLL_FRICTION 0.95
+#define MOMENTUM_TIMEOUT               50
+#define THUMBSCROLL_FRICTION           0.95
 #define THUMBSCROLL_MOMENTUM_THRESHOLD 100.0
-#define EFL_GESTURE_MINIMUM_MOMENTUM 0.001
+#define EFL_GESTURE_MINIMUM_MOMENTUM   0.001
 
 #define RAD2DEG(x) ((x) * 57.295779513)
 #define DEG2RAD(x) ((x) / 57.295779513)
@@ -70,32 +70,32 @@ _single_line_process(Eo *obj,
 {
    switch (efl_gesture_touch_state_get(event))
      {
-       case EFL_GESTURE_TOUCH_STATE_BEGIN:
-       case EFL_GESTURE_TOUCH_STATE_UPDATE:
-         if (!pd->t_st)
-           {
-              pd->st_line = efl_gesture_touch_cur_point_get(event);
-              pd->t_st = efl_gesture_touch_cur_timestamp_get(event);
+      case EFL_GESTURE_TOUCH_STATE_BEGIN:
+      case EFL_GESTURE_TOUCH_STATE_UPDATE:
+        if (!pd->t_st)
+          {
+             pd->st_line = efl_gesture_touch_cur_point_get(event);
+             pd->t_st = efl_gesture_touch_cur_timestamp_get(event);
 
-              efl_gesture_hotspot_set(gesture, pd->st_line);
+             efl_gesture_hotspot_set(gesture, pd->st_line);
 
-              return;
-           }
+             return;
+          }
 
-         break;
+        break;
 
-       case EFL_GESTURE_TOUCH_STATE_END:
-         {
-            if (!pd->t_st) return;
+      case EFL_GESTURE_TOUCH_STATE_END:
+      {
+         if (!pd->t_st) return;
 
-            pd->t_end = efl_gesture_touch_cur_timestamp_get(event);
+         pd->t_end = efl_gesture_touch_cur_timestamp_get(event);
 
-            break;
-         }
+         break;
+      }
 
-       default:
+      default:
 
-         return;
+        return;
      }
 
    _momentum_set(obj, fd, pd->st_line, efl_gesture_touch_cur_point_get(event),
@@ -135,8 +135,8 @@ _angle_get(Evas_Coord xx1,
              if (xx2 < xx1) rt = 180;
              else rt = 0.0;
           }
-        else
-          {  /* Vertical line */
+        else /* Vertical line */
+          {
              if (yy2 < yy1) rt = 90;
              else rt = 270;
           }
@@ -153,7 +153,6 @@ _angle_get(Evas_Coord xx1,
    return rt;
 }
 
-
 static void
 _vector_get(Eina_Position2D v1,
             Eina_Position2D v2,
@@ -202,11 +201,11 @@ 
_efl_canvas_gesture_recognizer_flick_efl_canvas_gesture_recognizer_recognize(Eo
 
    if (glayer_continues_enable && !pd->touched)
      {
-       pd->touched = EINA_TRUE;
-       pd->line_angle = -1.0;
-       rd->continues = EINA_TRUE;
+        pd->touched = EINA_TRUE;
+        pd->line_angle = -1.0;
+        rd->continues = EINA_TRUE;
 
-       return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
+        return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
      }
 
    _single_line_process(obj, pd, gesture, fd, event);
@@ -262,7 +261,6 @@ 
_efl_canvas_gesture_recognizer_flick_efl_canvas_gesture_recognizer_recognize(Eo
 
              if (pd->line_length >= line_min_length)
                fd->angle = pd->line_angle = angle;
-
           }
 
         if (pd->t_end)
@@ -291,57 +289,57 @@ 
_efl_canvas_gesture_recognizer_flick_efl_canvas_gesture_recognizer_recognize(Eo
    else time_limit_ms = 120;
 
    if ((tm_end - pd->t_st) > time_limit_ms)
-   {
-     memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Flick_Data));
+     {
+        memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Flick_Data));
 
-     if (touch_up) rd->continues = EINA_FALSE;
+        if (touch_up) rd->continues = EINA_FALSE;
 
-     return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
-   }
+        return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
+     }
 
    switch (efl_gesture_touch_state_get(event))
      {
       case EFL_GESTURE_TOUCH_STATE_BEGIN:
       case EFL_GESTURE_TOUCH_STATE_UPDATE:
-        {
-           if (pd->t_st)
-             {
-                if (glayer_continues_enable && pd->t_end)
-                  {
-                     result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
-                  }
-                else
-                  {
-                     result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
-                  }
-             }
-           break;
-        }
+      {
+         if (pd->t_st)
+           {
+              if (glayer_continues_enable && pd->t_end)
+                {
+                   result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
+                }
+              else
+                {
+                   result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
+                }
+           }
+         break;
+      }
 
       case EFL_GESTURE_TOUCH_STATE_END:
-        {
-           if (!pd->t_st)
-             {
-                pd->touched = EINA_FALSE;
-                rd->continues = EINA_FALSE;
+      {
+         if (!pd->t_st)
+           {
+              pd->touched = EINA_FALSE;
+              rd->continues = EINA_FALSE;
 
-                return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
-             }
-           if (pd->t_st && pd->t_end)
-             {
-                rd->continues = EINA_FALSE;
+              return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
+           }
+         if (pd->t_st && pd->t_end)
+           {
+              rd->continues = EINA_FALSE;
 
-                result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
-             }
+              result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
+           }
 
-           efl_gesture_hotspot_set(gesture, 
efl_gesture_touch_cur_point_get(event));
+         efl_gesture_hotspot_set(gesture, 
efl_gesture_touch_cur_point_get(event));
 
-           memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Flick_Data));
+         memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Flick_Data));
 
-                  rd->continues = EINA_FALSE;
+         rd->continues = EINA_FALSE;
 
-           break;
-        }
+         break;
+      }
 
       default:
 
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 f936a37dca..ecea7a42c3 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
@@ -1,6 +1,6 @@
 #include "efl_canvas_gesture_private.h"
 
-#define MY_CLASS EFL_CANVAS_GESTURE_RECOGNIZER_LONG_TAP_CLASS
+#define MY_CLASS                      
EFL_CANVAS_GESTURE_RECOGNIZER_LONG_TAP_CLASS
 
 #define EFL_GESTURE_LONG_TAP_TIME_OUT 1.2
 
@@ -56,7 +56,7 @@ 
_efl_canvas_gesture_recognizer_long_tap_efl_canvas_gesture_recognizer_recognize(
    if (!pd->start_timeout)
      {
         double time;
-        Eina_Value *val =  efl_gesture_recognizer_config_get(obj, 
"glayer_long_tap_start_timeout");
+        Eina_Value *val = efl_gesture_recognizer_config_get(obj, 
"glayer_long_tap_start_timeout");
 
         if (val)
           {
@@ -67,74 +67,73 @@ 
_efl_canvas_gesture_recognizer_long_tap_efl_canvas_gesture_recognizer_recognize(
    else
      timeout = pd->start_timeout;
 
-
    switch (efl_gesture_touch_state_get(event))
      {
       case EFL_GESTURE_TOUCH_STATE_BEGIN:
-        {
-           pos = efl_gesture_touch_start_point_get(event);
-           efl_gesture_hotspot_set(gesture, pos);
+      {
+         pos = efl_gesture_touch_start_point_get(event);
+         efl_gesture_hotspot_set(gesture, pos);
 
-           if (pd->timeout)
-             {
-                ecore_timer_del(pd->timeout);
-             }
-           pd->timeout = ecore_timer_add(timeout,
-                                         _long_tap_timeout_cb, pd);
+         if (pd->timeout)
+           {
+              ecore_timer_del(pd->timeout);
+           }
+         pd->timeout = ecore_timer_add(timeout,
+                                       _long_tap_timeout_cb, pd);
 
-           result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
+         result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
 
-           break;
-        }
+         break;
+      }
 
       case EFL_GESTURE_TOUCH_STATE_UPDATE:
-        {
-           dist = efl_gesture_touch_distance(event, 0);
-           length = fabs(dist.x) + fabs(dist.y);
-
-           if ((efl_gesture_touch_multi_touch_get(event)) || (length > 
rd->finger_size))
-             {
-                if (pd->timeout)
-                  {
-                     ecore_timer_del(pd->timeout);
-                     pd->timeout = NULL;
-                  }
-
-                result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
-             }
-           else
-             {
-                result = EFL_GESTURE_RECOGNIZER_RESULT_MAYBE;
-             }
-
-           break;
-        }
+      {
+         dist = efl_gesture_touch_distance(event, 0);
+         length = fabs(dist.x) + fabs(dist.y);
+
+         if ((efl_gesture_touch_multi_touch_get(event)) || (length > 
rd->finger_size))
+           {
+              if (pd->timeout)
+                {
+                   ecore_timer_del(pd->timeout);
+                   pd->timeout = NULL;
+                }
+
+              result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
+           }
+         else
+           {
+              result = EFL_GESTURE_RECOGNIZER_RESULT_MAYBE;
+           }
+
+         break;
+      }
 
       case EFL_GESTURE_TOUCH_STATE_END:
-        {
-           if (pd->timeout)
-             {
-                ecore_timer_del(pd->timeout);
-                pd->timeout = NULL;
-             }
-
-           if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
-               !efl_gesture_touch_multi_touch_get(event))
-             {
-                dist = efl_gesture_touch_distance(event, 0);
-                length = fabs(dist.x) + fabs(dist.y);
-                if (length <= rd->finger_size && pd->is_timeout)
-                  {
-                     result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
-                  }
-                else
-                  {
-                     result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
-                  }
-             }
-
-           break;
-        }
+      {
+         if (pd->timeout)
+           {
+              ecore_timer_del(pd->timeout);
+              pd->timeout = NULL;
+           }
+
+         if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
+             !efl_gesture_touch_multi_touch_get(event))
+           {
+              dist = efl_gesture_touch_distance(event, 0);
+              length = fabs(dist.x) + fabs(dist.y);
+              if (length <= rd->finger_size && pd->is_timeout)
+                {
+                   result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
+                }
+              else
+                {
+                   result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
+                }
+           }
+
+         break;
+      }
 
       default:
 
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 9926f92087..77f433e264 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_momentum.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_momentum.c
@@ -1,11 +1,11 @@
 #include "efl_canvas_gesture_private.h"
 
-#define MY_CLASS EFL_CANVAS_GESTURE_RECOGNIZER_MOMENTUM_CLASS
+#define MY_CLASS                       
EFL_CANVAS_GESTURE_RECOGNIZER_MOMENTUM_CLASS
 
-#define MOMENTUM_TIMEOUT 50
-#define THUMBSCROLL_FRICTION 0.95
+#define MOMENTUM_TIMEOUT               50
+#define THUMBSCROLL_FRICTION           0.95
 #define THUMBSCROLL_MOMENTUM_THRESHOLD 100.0
-#define EFL_GESTURE_MINIMUM_MOMENTUM 0.001
+#define EFL_GESTURE_MINIMUM_MOMENTUM   0.001
 
 EOLIAN static Efl_Canvas_Gesture *
 _efl_canvas_gesture_recognizer_momentum_efl_canvas_gesture_recognizer_add(Eo 
*obj, Efl_Canvas_Gesture_Recognizer_Momentum_Data *pd EINA_UNUSED, Efl_Object 
*target EINA_UNUSED)
@@ -32,7 +32,7 @@ _momentum_set(Eo *obj,
      {
         velx = (dx * 1000) / dt;
         vely = (dy * 1000) / dt;
-        }
+     }
 
    vel = sqrt((velx * velx) + (vely * vely));
 
@@ -70,9 +70,9 @@ _direction_get(Evas_Coord xx1,
 
 EOLIAN static Efl_Canvas_Gesture_Recognizer_Result
 
_efl_canvas_gesture_recognizer_momentum_efl_canvas_gesture_recognizer_recognize(Eo
 *obj,
-                                                                               
   Efl_Canvas_Gesture_Recognizer_Momentum_Data *pd,
-                                                                               
   Efl_Canvas_Gesture *gesture, Efl_Object *watched EINA_UNUSED,
-                                                                               
   Efl_Canvas_Gesture_Touch *event)
+                                                                               
 Efl_Canvas_Gesture_Recognizer_Momentum_Data *pd,
+                                                                               
 Efl_Canvas_Gesture *gesture, Efl_Object *watched EINA_UNUSED,
+                                                                               
 Efl_Canvas_Gesture_Touch *event)
 {
    Eina_Value *val;
    unsigned char glayer_continues_enable;
@@ -87,104 +87,104 @@ 
_efl_canvas_gesture_recognizer_momentum_efl_canvas_gesture_recognizer_recognize(
    //It does not have any meanging of this gesture.
    if (glayer_continues_enable && !pd->touched)
      {
-       pd->touched = EINA_TRUE;
+        pd->touched = EINA_TRUE;
 
-          return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
-        }
+        return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
+     }
 
    switch (efl_gesture_touch_state_get(event))
      {
       case EFL_GESTURE_TOUCH_STATE_BEGIN:
       case EFL_GESTURE_TOUCH_STATE_UPDATE:
-        {
-           if (!pd->t_st)
-             {
-                if (efl_gesture_touch_state_get(event) == 
EFL_GESTURE_TOUCH_STATE_BEGIN ||
-                    glayer_continues_enable)
-                  {
-                     pd->t_st = pd->t_end =  
efl_gesture_touch_cur_timestamp_get(event);
-
-                     pd->st_line = pd->end_line =
-                        efl_gesture_touch_start_point_get(event);
-
-                     efl_gesture_hotspot_set(gesture, pd->st_line);
-
-                     return EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
-                  }
-             }
-
-           if ((efl_gesture_touch_cur_timestamp_get(event) - MOMENTUM_TIMEOUT) 
>
-               pd->t_end)
-             {
-                pd->st_line = efl_gesture_touch_cur_point_get(event);
-                               pd->t_st = 
efl_gesture_touch_cur_timestamp_get(event);
-                               pd->xdir = pd->ydir = 0;
-                        }
-                  else
-                    {
-                int xdir, ydir;
-                Eina_Position2D cur_p = efl_gesture_touch_cur_point_get(event);
-
-                xdir = _direction_get(pd->end_line.x, cur_p.x);
-                ydir = _direction_get(pd->end_line.y, cur_p.y);
-
-                if (xdir && (xdir != pd->xdir))
-                  {
-                     pd->st_line.x = pd->end_line.x;
-                                        pd->t_st = pd->t_end;
-                     pd->xdir = xdir;
-                  }
-
-                if (ydir && (ydir != pd->ydir))
-                  {
-                     pd->st_line.y = pd->end_line.y;
-                                        pd->t_st = pd->t_end;
-                     pd->ydir = ydir;
-                  }
-             }
-
-           pd->end_line = efl_gesture_touch_cur_point_get(event);
-                  pd->t_end = efl_gesture_touch_cur_timestamp_get(event);
-           efl_gesture_hotspot_set(gesture, pd->end_line);
-
-           _momentum_set(obj, md, pd->st_line, 
efl_gesture_touch_cur_point_get(event),
-                         pd->t_st, efl_gesture_touch_cur_timestamp_get(event));
-
-           result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
-
-           break;
-        }
+      {
+         if (!pd->t_st)
+           {
+              if (efl_gesture_touch_state_get(event) == 
EFL_GESTURE_TOUCH_STATE_BEGIN ||
+                  glayer_continues_enable)
+                {
+                   pd->t_st = pd->t_end = 
efl_gesture_touch_cur_timestamp_get(event);
+
+                   pd->st_line = pd->end_line =
+                       efl_gesture_touch_start_point_get(event);
+
+                   efl_gesture_hotspot_set(gesture, pd->st_line);
+
+                   return EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
+                }
+           }
+
+         if ((efl_gesture_touch_cur_timestamp_get(event) - MOMENTUM_TIMEOUT) >
+             pd->t_end)
+           {
+              pd->st_line = efl_gesture_touch_cur_point_get(event);
+              pd->t_st = efl_gesture_touch_cur_timestamp_get(event);
+              pd->xdir = pd->ydir = 0;
+           }
+         else
+           {
+              int xdir, ydir;
+              Eina_Position2D cur_p = efl_gesture_touch_cur_point_get(event);
+
+              xdir = _direction_get(pd->end_line.x, cur_p.x);
+              ydir = _direction_get(pd->end_line.y, cur_p.y);
+
+              if (xdir && (xdir != pd->xdir))
+                {
+                   pd->st_line.x = pd->end_line.x;
+                   pd->t_st = pd->t_end;
+                   pd->xdir = xdir;
+                }
+
+              if (ydir && (ydir != pd->ydir))
+                {
+                   pd->st_line.y = pd->end_line.y;
+                   pd->t_st = pd->t_end;
+                   pd->ydir = ydir;
+                }
+           }
+
+         pd->end_line = efl_gesture_touch_cur_point_get(event);
+         pd->t_end = efl_gesture_touch_cur_timestamp_get(event);
+         efl_gesture_hotspot_set(gesture, pd->end_line);
+
+         _momentum_set(obj, md, pd->st_line, 
efl_gesture_touch_cur_point_get(event),
+                       pd->t_st, efl_gesture_touch_cur_timestamp_get(event));
+
+         result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
+
+         break;
+      }
 
       case EFL_GESTURE_TOUCH_STATE_END:
-        {
-           if (!pd->t_st)
-             {
-                pd->touched = EINA_FALSE;
-
-                return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
-             }
-
-           if ((efl_gesture_touch_cur_timestamp_get(event) - MOMENTUM_TIMEOUT) 
> pd->t_end)
-             {
-                pd->st_line = efl_gesture_touch_cur_point_get(event);
-                pd->t_st = efl_gesture_touch_cur_timestamp_get(event);
-                pd->xdir = pd->ydir = 0;
-             }
-
-           pd->end_line = efl_gesture_touch_cur_point_get(event);
-                  pd->t_end = efl_gesture_touch_cur_timestamp_get(event);
-           efl_gesture_hotspot_set(gesture, pd->end_line);
-
-           if ((fabs(md->momentum.x) > EFL_GESTURE_MINIMUM_MOMENTUM) ||
-               (fabs(md->momentum.y) > EFL_GESTURE_MINIMUM_MOMENTUM))
-                result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
-           else
-                result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
-
-           memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Momentum_Data));
-
-                  break;
-        }
+      {
+         if (!pd->t_st)
+           {
+              pd->touched = EINA_FALSE;
+
+              return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
+           }
+
+         if ((efl_gesture_touch_cur_timestamp_get(event) - MOMENTUM_TIMEOUT) > 
pd->t_end)
+           {
+              pd->st_line = efl_gesture_touch_cur_point_get(event);
+              pd->t_st = efl_gesture_touch_cur_timestamp_get(event);
+              pd->xdir = pd->ydir = 0;
+           }
+
+         pd->end_line = efl_gesture_touch_cur_point_get(event);
+         pd->t_end = efl_gesture_touch_cur_timestamp_get(event);
+         efl_gesture_hotspot_set(gesture, pd->end_line);
+
+         if ((fabs(md->momentum.x) > EFL_GESTURE_MINIMUM_MOMENTUM) ||
+             (fabs(md->momentum.y) > EFL_GESTURE_MINIMUM_MOMENTUM))
+           result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
+         else
+           result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
+
+         memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Momentum_Data));
+
+         break;
+      }
 
       default:
 
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 5f99d713d4..c6c0e860f3 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_tap.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_tap.c
@@ -1,6 +1,6 @@
 #include "efl_canvas_gesture_private.h"
 
-#define MY_CLASS EFL_CANVAS_GESTURE_RECOGNIZER_TAP_CLASS
+#define MY_CLASS                                 
EFL_CANVAS_GESTURE_RECOGNIZER_TAP_CLASS
 
 //FIXME: It doesnt have matched config value.
 //       may using dobule tap timeout value?
@@ -25,7 +25,6 @@ _tap_timeout_cb(void *data)
    return ECORE_CALLBACK_CANCEL;
 }
 
-
 EOLIAN static Efl_Canvas_Gesture_Recognizer_Result
 _efl_canvas_gesture_recognizer_tap_efl_canvas_gesture_recognizer_recognize(Eo 
*obj,
                                                                            
Efl_Canvas_Gesture_Recognizer_Tap_Data *pd,
@@ -45,44 +44,44 @@ 
_efl_canvas_gesture_recognizer_tap_efl_canvas_gesture_recognizer_recognize(Eo *o
    switch (efl_gesture_touch_state_get(event))
      {
       case EFL_GESTURE_TOUCH_STATE_BEGIN:
-        {
-           pos = efl_gesture_touch_start_point_get(event);
-           efl_gesture_hotspot_set(gesture, pos);
+      {
+         pos = efl_gesture_touch_start_point_get(event);
+         efl_gesture_hotspot_set(gesture, pos);
 
-           if (pd->timeout)
-             ecore_timer_del(pd->timeout);
-           pd->timeout = 
ecore_timer_add(EFL_GESTURE_RECOGNIZER_TYPE_TAP_TIME_OUT, _tap_timeout_cb, pd);
+         if (pd->timeout)
+           ecore_timer_del(pd->timeout);
+         pd->timeout = 
ecore_timer_add(EFL_GESTURE_RECOGNIZER_TYPE_TAP_TIME_OUT, _tap_timeout_cb, pd);
 
-           result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
+         result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
 
-           break;
-        }
+         break;
+      }
 
       case EFL_GESTURE_TOUCH_STATE_UPDATE:
       case EFL_GESTURE_TOUCH_STATE_END:
-        {
-           if (pd->timeout)
-             {
-                ecore_timer_del(pd->timeout);
-                pd->timeout = NULL;
-             }
-
-           if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
-               !efl_gesture_touch_multi_touch_get(event))
-             {
-                dist = efl_gesture_touch_distance(event, 0);
-                length = fabs(dist.x) + fabs(dist.y);
-                if (length <= rd->finger_size)
-                  {
-                     if (efl_gesture_touch_state_get(event) == 
EFL_GESTURE_TOUCH_STATE_END)
-                       result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
-                     else
-                       result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
-                  }
-             }
-
-           break;
-        }
+      {
+         if (pd->timeout)
+           {
+              ecore_timer_del(pd->timeout);
+              pd->timeout = NULL;
+           }
+
+         if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
+             !efl_gesture_touch_multi_touch_get(event))
+           {
+              dist = efl_gesture_touch_distance(event, 0);
+              length = fabs(dist.x) + fabs(dist.y);
+              if (length <= rd->finger_size)
+                {
+                   if (efl_gesture_touch_state_get(event) == 
EFL_GESTURE_TOUCH_STATE_END)
+                     result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
+                   else
+                     result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
+                }
+           }
+
+         break;
+      }
 
       default:
 
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 04f2c28951..99d651aa6a 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
@@ -1,6 +1,6 @@
 #include "efl_canvas_gesture_private.h"
 
-#define MY_CLASS EFL_CANVAS_GESTURE_RECOGNIZER_TRIPLE_TAP_CLASS
+#define MY_CLASS     EFL_CANVAS_GESTURE_RECOGNIZER_TRIPLE_TAP_CLASS
 
 #define TAP_TIME_OUT 0.33
 
@@ -59,7 +59,7 @@ 
_efl_canvas_gesture_recognizer_triple_tap_efl_canvas_gesture_recognizer_recogniz
    if (!pd->start_timeout)
      {
         double time;
-        Eina_Value *val =  efl_gesture_recognizer_config_get(obj, 
"glayer_doublee_tap_timeout");
+        Eina_Value *val = efl_gesture_recognizer_config_get(obj, 
"glayer_doublee_tap_timeout");
 
         if (val)
           {
@@ -73,80 +73,64 @@ 
_efl_canvas_gesture_recognizer_triple_tap_efl_canvas_gesture_recognizer_recogniz
    switch (efl_gesture_touch_state_get(event))
      {
       case EFL_GESTURE_TOUCH_STATE_BEGIN:
-           {
-              pos = efl_gesture_touch_start_point_get(event);
-              efl_gesture_hotspot_set(gesture, pos);
+      {
+         pos = efl_gesture_touch_start_point_get(event);
+         efl_gesture_hotspot_set(gesture, pos);
 
-              if (pd->timeout)
-                ecore_timer_reset(pd->timeout);
-              else
-                pd->timeout = ecore_timer_add(timeout, _tap_timeout_cb, obj);
+         if (pd->timeout)
+           ecore_timer_reset(pd->timeout);
+         else
+           pd->timeout = ecore_timer_add(timeout, _tap_timeout_cb, obj);
 
-              result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
+         result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
 
-              break;
-           }
+         break;
+      }
 
       case EFL_GESTURE_TOUCH_STATE_UPDATE:
+      {
+         result = EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
+
+         if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
+             !efl_gesture_touch_multi_touch_get(event))
            {
-              result = EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
+              dist = efl_gesture_touch_distance(event, 0);
+              length = fabs(dist.x) + fabs(dist.y);
 
-              if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
-                  !efl_gesture_touch_multi_touch_get(event))
+              if (length > rd->finger_size)
                 {
-                   dist = efl_gesture_touch_distance(event, 0);
-                   length = fabs(dist.x) + fabs(dist.y);
-
-                   if (length > rd->finger_size)
+                   if (pd->timeout)
                      {
-                        if (pd->timeout)
-                          {
-                             ecore_timer_del(pd->timeout);
-                             pd->timeout = NULL;
-                          }
+                        ecore_timer_del(pd->timeout);
+                        pd->timeout = NULL;
+                     }
 
-                        result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
+                   result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
 
-                        pd->tap_count = 0;
-                     }
+                   pd->tap_count = 0;
                 }
-
-              break;
            }
+
+         break;
+      }
+
       case EFL_GESTURE_TOUCH_STATE_END:
+      {
+         if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
+             !efl_gesture_touch_multi_touch_get(event))
            {
+              dist = efl_gesture_touch_distance(event, 0);
+              length = fabs(dist.x) + fabs(dist.y);
 
-              if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE &&
-                  !efl_gesture_touch_multi_touch_get(event))
+              if (length <= rd->finger_size)
                 {
-                   dist = efl_gesture_touch_distance(event, 0);
-                   length = fabs(dist.x) + fabs(dist.y);
-
-                   if (length <= rd->finger_size)
+                   pd->tap_count++;
+                   if (pd->tap_count < 3)
                      {
-                        pd->tap_count++;
-                        if (pd->tap_count < 3)
-                          {
-                             if (pd->timeout)
-                               ecore_timer_reset(pd->timeout);
+                        if (pd->timeout)
+                          ecore_timer_reset(pd->timeout);
 
-                             result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
-                          }
-                        else
-                          {
-                             if (pd->timeout)
-                               {
-                                  ecore_timer_del(pd->timeout);
-                                  pd->timeout = NULL;
-                               }
-
-                             if (efl_gesture_touch_state_get(event) == 
EFL_GESTURE_TOUCH_STATE_END)
-                               result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
-                             else
-                               result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
-
-                             pd->tap_count = 0;
-                          }
+                        result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
                      }
                    else
                      {
@@ -156,15 +140,31 @@ 
_efl_canvas_gesture_recognizer_triple_tap_efl_canvas_gesture_recognizer_recogniz
                              pd->timeout = NULL;
                           }
 
-                        result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
+                        if (efl_gesture_touch_state_get(event) == 
EFL_GESTURE_TOUCH_STATE_END)
+                          result = EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
+                        else
+                          result = EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
 
                         pd->tap_count = 0;
                      }
                 }
+              else
+                {
+                   if (pd->timeout)
+                     {
+                        ecore_timer_del(pd->timeout);
+                        pd->timeout = NULL;
+                     }
 
-              break;
+                   result = EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
+
+                   pd->tap_count = 0;
+                }
            }
 
+         break;
+      }
+
       default:
 
         break;
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 504b3c3bcf..0603098539 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_zoom.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_zoom.c
@@ -4,11 +4,11 @@
 
 static Evas_Coord
 _finger_gap_length_get(Evas_Coord xx1,
-               Evas_Coord yy1,
-               Evas_Coord xx2,
-               Evas_Coord yy2,
-               Evas_Coord *x,
-               Evas_Coord *y)
+                       Evas_Coord yy1,
+                       Evas_Coord xx2,
+                       Evas_Coord yy2,
+                       Evas_Coord *x,
+                       Evas_Coord *y)
 {
    double a, b, xx, yy, gap;
    xx = abs(xx2 - xx1);
@@ -67,7 +67,7 @@ _zoom_compute(Efl_Canvas_Gesture_Recognizer_Zoom_Data *pd,
    //unsigned int tm_end = (pd->zoom_mv.cur.timestamp > 
pd->zoom_mv1.cur.timestamp) ?
    //   pd->zoom_mv.cur.timestamp : pd->zoom_mv1.cur.timestamp;
 
-   int x,y; //Hot spot
+   int x, y; //Hot spot
    Evas_Coord diam = _finger_gap_length_get(xx1, yy1, xx2, yy2,
                                             &x, &y);
 
@@ -80,7 +80,7 @@ _zoom_compute(Efl_Canvas_Gesture_Recognizer_Zoom_Data *pd,
      }
 
    if (pd->zoom_distance_tolerance) /* zoom tolerance <> ZERO, means
-                                     * zoom action NOT started yet */
+                                    * zoom action NOT started yet */
      {
         /* avoid jump with zoom value when break tolerance */
         if (diam < (pd->zoom_base - pd->zoom_distance_tolerance))
@@ -147,7 +147,7 @@ 
_efl_canvas_gesture_recognizer_zoom_efl_canvas_gesture_recognizer_recognize(Eo *
    else zoom_finger_enable = 1;
 
    val = efl_gesture_recognizer_config_get(obj, "glayer_zoom_finger_factor");
-   if (val)  eina_value_get(val, &pd->zoom_finger_factor);
+   if (val) eina_value_get(val, &pd->zoom_finger_factor);
    else pd->zoom_finger_factor = 1.0;
 
    rd->continues = EINA_TRUE;
@@ -156,7 +156,7 @@ 
_efl_canvas_gesture_recognizer_zoom_efl_canvas_gesture_recognizer_recognize(Eo *
      {
         pd->calc_temp = EINA_TRUE;
         val = efl_gesture_recognizer_config_get(obj, 
"glayer_zoom_distance_tolerance");
-        if (val)  eina_value_get(val, &pd->zoom_distance_tolerance);
+        if (val) eina_value_get(val, &pd->zoom_distance_tolerance);
         else pd->zoom_distance_tolerance = 1.0;
 
         pd->zoom_distance_tolerance *= rd->finger_size;
@@ -165,108 +165,109 @@ 
_efl_canvas_gesture_recognizer_zoom_efl_canvas_gesture_recognizer_recognize(Eo *
    switch (efl_gesture_touch_state_get(event))
      {
       case EFL_GESTURE_TOUCH_STATE_UPDATE:
-        {
-           if ((!glayer_continues_enable) && (!pd->zoom_st.cur.timestamp))
-             {
-                return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
-             }
-           EINA_FALLTHROUGH;
-        }
+      {
+         if ((!glayer_continues_enable) && (!pd->zoom_st.cur.timestamp))
+           {
+              return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
+           }
+         EINA_FALLTHROUGH;
+      }
+
       case EFL_GESTURE_TOUCH_STATE_BEGIN:
-        {
-           if (td->touch_down > 2)
-             {
-                return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
-             }
+      {
+         if (td->touch_down > 2)
+           {
+              return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
+           }
 
-           if (!pd->zoom_st.cur.timestamp) /* Now scan touched-devices list
+         if (!pd->zoom_st.cur.timestamp)   /* Now scan touched-devices list
                                             * and find other finger */
-             {
-                if (!efl_gesture_touch_multi_touch_get(event))
-                  return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
+           {
+              if (!efl_gesture_touch_multi_touch_get(event))
+                return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
 
-                Pointer_Data *p1 = eina_hash_find(td->touch_points, &id1);
-                Pointer_Data *p2 = eina_hash_find(td->touch_points, &id2);
+              Pointer_Data *p1 = eina_hash_find(td->touch_points, &id1);
+              Pointer_Data *p2 = eina_hash_find(td->touch_points, &id2);
 
-                memcpy(&pd->zoom_st, p2, sizeof(Pointer_Data));
-                memcpy(&pd->zoom_st1, p1, sizeof(Pointer_Data));
+              memcpy(&pd->zoom_st, p2, sizeof(Pointer_Data));
+              memcpy(&pd->zoom_st1, p1, sizeof(Pointer_Data));
 
-                memcpy(&pd->zoom_mv, p2, sizeof(Pointer_Data));
-                memcpy(&pd->zoom_mv1, p1, sizeof(Pointer_Data));
+              memcpy(&pd->zoom_mv, p2, sizeof(Pointer_Data));
+              memcpy(&pd->zoom_mv1, p1, sizeof(Pointer_Data));
 
-                int x,y; //Hot spot
-                zd->zoom = 1.0;
-                pd->zoom_base = _finger_gap_length_get(pd->zoom_st1.cur.pos.x,
-                                                       pd->zoom_st1.cur.pos.y,
-                                                       pd->zoom_st.cur.pos.x,
-                                                       pd->zoom_st.cur.pos.y,
-                                                       &x, &y);
+              int x, y;  //Hot spot
+              zd->zoom = 1.0;
+              pd->zoom_base = _finger_gap_length_get(pd->zoom_st1.cur.pos.x,
+                                                     pd->zoom_st1.cur.pos.y,
+                                                     pd->zoom_st.cur.pos.x,
+                                                     pd->zoom_st.cur.pos.y,
+                                                     &x, &y);
 
-                zd->radius = pd->zoom_base / 2.0;
+              zd->radius = pd->zoom_base / 2.0;
 
-                if ((efl_gesture_state_get(gesture) != 
EFL_GESTURE_STATE_STARTED) &&
-                    (efl_gesture_state_get(gesture) != 
EFL_GESTURE_STATE_UPDATED))
-                  return EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
+              if ((efl_gesture_state_get(gesture) != 
EFL_GESTURE_STATE_STARTED) &&
+                  (efl_gesture_state_get(gesture) != 
EFL_GESTURE_STATE_UPDATED))
+                return EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
 
-                return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
-             }
+              return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
+           }
 
-           Pointer_Data *p2 = eina_hash_find(td->touch_points, &id2);
-           if (p2->id == pd->zoom_mv.id)
-             memcpy(&pd->zoom_mv, p2, sizeof(Pointer_Data));
-           else if (p2->id == pd->zoom_mv1.id)
-             memcpy(&pd->zoom_mv1, p2, sizeof(Pointer_Data));
+         Pointer_Data *p2 = eina_hash_find(td->touch_points, &id2);
+         if (p2->id == pd->zoom_mv.id)
+           memcpy(&pd->zoom_mv, p2, sizeof(Pointer_Data));
+         else if (p2->id == pd->zoom_mv1.id)
+           memcpy(&pd->zoom_mv1, p2, sizeof(Pointer_Data));
 
-           zd->zoom = _zoom_compute(pd, zd, pd->zoom_mv.cur.pos.x,
-                                    pd->zoom_mv.cur.pos.y, 
pd->zoom_mv1.cur.pos.x,
-                                    pd->zoom_mv1.cur.pos.y, 
pd->zoom_finger_factor);
+         zd->zoom = _zoom_compute(pd, zd, pd->zoom_mv.cur.pos.x,
+                                  pd->zoom_mv.cur.pos.y, 
pd->zoom_mv1.cur.pos.x,
+                                  pd->zoom_mv1.cur.pos.y, 
pd->zoom_finger_factor);
 
+         if (!pd->zoom_distance_tolerance)
+           {
+              double d = zd->zoom - pd->next_step;
 
-           if (!pd->zoom_distance_tolerance)
-             {
-                double d = zd->zoom - pd->next_step;
+              if (d < 0.0) d = (-d);
 
-                if (d < 0.0) d = (-d);
+              if (d >= pd->zoom_step)
+                {
+                   pd->next_step = zd->zoom;
 
-                if (d >= pd->zoom_step)
-                  {
-                     pd->next_step = zd->zoom;
+                   return EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
+                }
+           }
 
-                     return EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER;
-                  }
-             }
+         return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
+      }
 
-           return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
-        }
       case EFL_GESTURE_TOUCH_STATE_END:
-        {
-           if (td->touch_down == 0)
-             {
-                rd->continues = EINA_FALSE;
+      {
+         if (td->touch_down == 0)
+           {
+              rd->continues = EINA_FALSE;
 
-                memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Zoom_Data));
-                efl_gesture_manager_gesture_clean_up(rd->manager, watched, 
EFL_EVENT_GESTURE_ZOOM);
+              memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Zoom_Data));
+              efl_gesture_manager_gesture_clean_up(rd->manager, watched, 
EFL_EVENT_GESTURE_ZOOM);
 
-                return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
-             }
-           if ((pd->zoom_base) && (pd->zoom_distance_tolerance == 0))
-             {
-                memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Zoom_Data));
+              return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
+           }
+         if ((pd->zoom_base) && (pd->zoom_distance_tolerance == 0))
+           {
+              memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Zoom_Data));
 
-                return EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
-             }
+              return EFL_GESTURE_RECOGNIZER_RESULT_FINISH;
+           }
 
-           if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE)
-             {
-                memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Zoom_Data));
+         if (efl_gesture_state_get(gesture) != EFL_GESTURE_STATE_NONE)
+           {
+              memset(pd, 0, sizeof(Efl_Canvas_Gesture_Recognizer_Zoom_Data));
 
-                return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
-             }
-        }
+              return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL;
+           }
+      }
 
       default:
 
-         break;
+        break;
      }
 
    return result;
diff --git a/src/lib/evas/gesture/efl_canvas_gesture_touch.c 
b/src/lib/evas/gesture/efl_canvas_gesture_touch.c
index c2c2900db4..6ddb3be59e 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_touch.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_touch.c
@@ -6,7 +6,8 @@
 //that are directed to a particular object from the
 //first finger down to the last finger up
 
-static void _hash_free_cb(Pointer_Data *point)
+static void
+_hash_free_cb(Pointer_Data *point)
 {
    free(point);
 }
@@ -99,11 +100,11 @@ _efl_canvas_gesture_touch_point_record(Eo *obj 
EINA_UNUSED, Efl_Canvas_Gesture_T
      }
    point->action = action;
 
-   if (!id && (action ==  EFL_POINTER_ACTION_DOWN))
+   if (!id && (action == EFL_POINTER_ACTION_DOWN))
      {
         pd->state = EFL_GESTURE_TOUCH_STATE_BEGIN;
      }
-   else if (action ==  EFL_POINTER_ACTION_UP)
+   else if (action == EFL_POINTER_ACTION_UP)
      {
         pd->state = EFL_GESTURE_TOUCH_STATE_END;
      }

-- 


Reply via email to