wip

efl_canvas_gesture: replace parse with import
we probebly want to use import here, as we want to rebuild this file when efl_canvas_gesture_events is changed. Differential Revision: https://phab.enlightenment.org/D11273
2020-02-05 10:19:09 +01:00 · 2020-02-05 10:19:09 +01:00 · 2020-02-05 10:19:09 +01:00 · 2020-02-05 10:19:08 +01:00 · 2020-02-05 10:19:08 +01:00 · 2020-02-05 10:19:08 +01:00
16 changed files with 254 additions and 182 deletions
--- a/src/lib/efl/Efl.h
+++ b/src/lib/efl/Efl.h
@ -234,6 +234,100 @@ EAPI Efl_Object *efl_part(const Eo *obj, const char *name);

 EAPI void efl_observable_tuple_free(Efl_Observable_Tuple *tuple);

+
+
+static inline Eina_Bool
+efl_config_bool_set(Efl_Config *obj, const char * name, Eina_Bool val)
+{
+   Eina_Value *v = eina_value_new(EINA_VALUE_TYPE_UCHAR);
+   Eina_Bool b;
+   eina_value_set(v, val);
+   b = efl_config_set(obj, name, v);
+   eina_value_free(v);
+   return b;
+}
+
+static inline Eina_Bool
+efl_config_bool_get(const Efl_Config *obj, const char * name)
+{
+   Eina_Value *v = efl_config_get(obj, name);
+   Eina_Bool b = 0;
+   if (eina_value_type_get(v) == EINA_VALUE_TYPE_UCHAR)
+     eina_value_get(v, &b);
+   eina_value_free(v);
+   return b;
+}
+
+static inline Eina_Bool
+efl_config_int_set(Efl_Config *obj, const char * name, int val)
+{
+   Eina_Value *v = eina_value_new(EINA_VALUE_TYPE_INT);
+   Eina_Bool b;
+   eina_value_set(v, val);
+   b = efl_config_set(obj, name, v);
+   eina_value_free(v);
+   return b;
+}
+
+static inline int
+efl_config_int_get(const Efl_Config *obj, const char * name)
+{
+   Eina_Value *v = efl_config_get(obj, name);
+   int b = 0;
+   if (eina_value_type_get(v) == EINA_VALUE_TYPE_INT)
+     eina_value_get(v, &b);
+   eina_value_free(v);
+   return b;
+}
+
+static inline Eina_Bool
+efl_config_double_set(Efl_Config *obj, const char * name, double val)
+{
+   Eina_Value *v = eina_value_new(EINA_VALUE_TYPE_DOUBLE);
+   Eina_Bool b;
+   eina_value_set(v, val);
+   b = efl_config_set(obj, name, v);
+   eina_value_free(v);
+   return b;
+}
+
+static inline double
+efl_config_double_get(const Efl_Config *obj, const char * name)
+{
+   Eina_Value *v = efl_config_get(obj, name);
+   double b = 0;
+   if (eina_value_type_get(v) == EINA_VALUE_TYPE_DOUBLE)
+     eina_value_get(v, &b);
+   eina_value_free(v);
+   return b;
+}
+
+static inline Eina_Bool
+efl_config_string_set(Efl_Config *obj, const char *name, const char *val)
+{
+   Eina_Value *v = eina_value_new(EINA_VALUE_TYPE_STRING);
+   Eina_Bool b;
+   eina_value_set(v, val);
+   b = efl_config_set(obj, name, v);
+   eina_value_free(v);
+   return b;
+}
+
+static inline Eina_Stringshare *
+efl_config_string_get(const Efl_Config *obj, const char *name)
+{
+   Eina_Value *v = efl_config_get(obj, name);
+   Eina_Stringshare *s = 0;
+   if (eina_value_type_get(v) == EINA_VALUE_TYPE_STRING)
+     {
+        const char *b = 0;
+        eina_value_get(v, &b);
+        s = eina_stringshare_add(b);
+     }
+   eina_value_free(v);
+   return s;
+}
+
 #else

 #ifndef EFL_NOLEGACY_API_SUPPORT
--- a/src/lib/efl/interfaces/efl_config.eo
+++ b/src/lib/efl/interfaces/efl_config.eo
@ -27,6 +27,9 @@ interface @beta Efl.Config
         }
      }
   }
+   events {
+      config,changed: string; [[Called when a config value has been changed for the manager object. Passed string is the name of the value or NULL if all values were changed.]]
+   }
 }

 /* NOTES:
--- a/src/lib/elementary/efl_ui_win.c
+++ b/src/lib/elementary/efl_ui_win.c
@ -5148,46 +5148,43 @@ static void
 _gesture_manager_config_load(Eo *obj)
 {
   Eina_Value val;
-   Efl_Canvas_Gesture_Manager *gm = efl_provider_find(obj, EFL_CANVAS_GESTURE_MANAGER_CLASS);
+   Eo *gm = efl_provider_find(obj, EFL_CONFIG_INTERFACE);

   eina_value_setup(&val, EINA_VALUE_TYPE_DOUBLE);
   eina_value_set(&val, _elm_config->glayer_long_tap_start_timeout);
-   efl_gesture_manager_config_set(gm, "glayer_long_tap_start_timeout", &val);
+   efl_config_set(gm, "glayer_long_tap_start_timeout", &val);

   eina_value_set(&val, _elm_config->glayer_double_tap_timeout);
-   efl_gesture_manager_config_set(gm, "glayer_double_tap_timeout", &val);
+   efl_config_set(gm, "glayer_double_tap_timeout", &val);

-   eina_value_set(&val, _elm_config->thumbscroll_friction);
-   efl_gesture_manager_config_set(gm, "thumbscroll_friction", &val);
-
-   eina_value_set(&val, _elm_config->thumbscroll_momentum_threshold);
-   efl_gesture_manager_config_set(gm, "thumbscroll_momentum_threshold", &val);
+   elm_config_scroll_thumbscroll_friction_set(_elm_config->thumbscroll_friction);
+   elm_config_scroll_thumbscroll_momentum_threshold_set(_elm_config->thumbscroll_momentum_threshold);

   eina_value_set(&val, _elm_config->glayer_line_min_length);
-   efl_gesture_manager_config_set(gm, "glayer_line_min_length", &val);
+   efl_config_set(gm, "glayer_line_min_length", &val);

   eina_value_set(&val, _elm_config->glayer_line_distance_tolerance);
-   efl_gesture_manager_config_set(gm, "glayer_line_distance_tolerance", &val);
+   efl_config_set(gm, "glayer_line_distance_tolerance", &val);

   eina_value_set(&val, _elm_config->glayer_line_angular_tolerance);
-   efl_gesture_manager_config_set(gm, "glayer_line_angular_tolerance", &val);
+   efl_config_set(gm, "glayer_line_angular_tolerance", &val);

   eina_value_set(&val, _elm_config->glayer_zoom_finger_factor);
-   efl_gesture_manager_config_set(gm, "glayer_zoom_finger_factor", &val);
+   efl_config_set(gm, "glayer_zoom_finger_factor", &val);

   eina_value_set(&val, _elm_config->glayer_zoom_distance_tolerance);
-   efl_gesture_manager_config_set(gm, "glayer_zoom_distance_tolerance", &val);
+   efl_config_set(gm, "glayer_zoom_distance_tolerance", &val);

   eina_value_setup(&val, EINA_VALUE_TYPE_UINT);
   eina_value_set(&val, _elm_config->glayer_flick_time_limit_ms);
-   efl_gesture_manager_config_set(gm, "glayer_flick_time_limit_ms", &val);
+   efl_config_set(gm, "glayer_flick_time_limit_ms", &val);

   eina_value_setup(&val, EINA_VALUE_TYPE_UCHAR);
   eina_value_set(&val, _elm_config->glayer_continues_enable);
-   efl_gesture_manager_config_set(gm, "glayer_continues_enable", &val);
+   efl_config_set(gm, "glayer_continues_enable", &val);

   eina_value_set(&val, _elm_config->glayer_zoom_finger_enable);
-   efl_gesture_manager_config_set(gm, "glayer_zoom_finger_enable", &val);
+   efl_config_set(gm, "glayer_zoom_finger_enable", &val);
 }

 static Eo *
--- a/src/lib/elementary/elm_config.c
+++ b/src/lib/elementary/elm_config.c
@ -2053,6 +2053,7 @@ _config_flush_get(void)
   _elm_config_key_binding_hash();
   _elm_win_access(_elm_config->access_mode);
   ecore_event_add(ELM_EVENT_CONFIG_ALL_CHANGED, NULL, NULL, NULL);
+   efl_event_callback_call(_efl_config_obj, EFL_CONFIG_EVENT_CONFIG_CHANGED, NULL);
 }

 static const char *
@ -4509,6 +4510,7 @@ _elm_config_reload(void)
   _elm_old_clouseau_reload();
   _elm_config_key_binding_hash();
   ecore_event_add(ELM_EVENT_CONFIG_ALL_CHANGED, NULL, NULL, NULL);
+   efl_event_callback_call(_efl_config_obj, EFL_CONFIG_EVENT_CONFIG_CHANGED, NULL);
   if (ptheme) eina_stringshare_del(ptheme);
   if (pmodules) eina_stringshare_del(pmodules);
   if (picon_theme) eina_stringshare_del(picon_theme);
@ -4936,12 +4938,14 @@ _efl_config_global_efl_config_config_set(Eo *obj EINA_UNUSED, void *_pd EINA_UNU
             return EINA_FALSE; \
          } \
        elm_config_ ## opt ## _set(v); \
+        efl_event_callback_call(_efl_config_obj, EFL_CONFIG_EVENT_CONFIG_CHANGED, (void*)name); \
        return EINA_TRUE; \
     } \
   } while (0)

 #define CONFIG_SETB(opt) CONFIG_SET(opt, Eina_Bool, UCHAR, int)
 #define CONFIG_SETI(opt) CONFIG_SET(opt, int, INT, int)
+#define CONFIG_SETU(opt) CONFIG_SET(opt, unsigned int, UINT, int)
 #define CONFIG_SETD(opt) CONFIG_SET(opt, double, DOUBLE, int)
 #define CONFIG_SETS(opt) CONFIG_SET(opt, const char *, STRING, cstring)

@ -4972,6 +4976,7 @@ _efl_config_global_efl_config_config_set(Eo *obj EINA_UNUSED, void *_pd EINA_UNU
             return EINA_FALSE; \
          } \
        elm_config_ ## opt ## _set(v); \
+        efl_event_callback_call(_efl_config_obj, EFL_CONFIG_EVENT_CONFIG_CHANGED, (void*)name); \
        return EINA_TRUE; \
     } \
   } while (0)
@ -5039,8 +5044,7 @@ _efl_config_global_efl_config_config_set(Eo *obj EINA_UNUSED, void *_pd EINA_UNU
   CONFIG_SETB(first_item_focus_on_first_focusin);
   CONFIG_SETB(mirrored);
   CONFIG_SETB(clouseau_enabled);
-   CONFIG_SETD(glayer_long_tap_start_timeout);
-   CONFIG_SETD(glayer_double_tap_timeout);
+
   //color_overlay const char *color_class,
   //elm_config.h:EAPI void      elm_config_color_overlay_unset(const char *color_class);
   CONFIG_SETB(magnifier_enable);
@ -5054,6 +5058,52 @@ _efl_config_global_efl_config_config_set(Eo *obj EINA_UNUSED, void *_pd EINA_UNU
   CONFIG_SETB(offline);
   CONFIG_SETI(powersave);

+   CONFIG_SETD(glayer_long_tap_start_timeout);
+   CONFIG_SETD(glayer_double_tap_timeout);
+
+#undef CONFIG_SET
+#define CONFIG_SET(opt, primityp, valtyp, alttyp) do { \
+   if (!strcmp(name, #opt)) \
+     { \
+        primityp v = 0; \
+        alttyp alt = 0; \
+        const Eina_Value_Type *typ = EINA_VALUE_TYPE_ ## valtyp; \
+        if (eina_value_type_get(val) == typ)  \
+          { \
+             if (!eina_value_get(val, &v)) return EINA_FALSE; \
+          } \
+        else if (_eina_value_to_ ## alttyp(val, &alt)) \
+          { \
+             v = alt; \
+          } \
+        else \
+          { \
+             ERR("Invalid value type for config '%s' (got %s wanted %s)", \
+                 name, eina_value_type_name_get(eina_value_type_get(val)), \
+                 eina_value_type_name_get(EINA_VALUE_TYPE_ ## valtyp)); \
+             return EINA_FALSE; \
+          } \
+        efl_event_callback_call(_efl_config_obj, EFL_CONFIG_EVENT_CONFIG_CHANGED, (void*)name); \
+        return EINA_TRUE; \
+     } \
+   } while (0)
+
+
+   CONFIG_SETB(glayer_zoom_finger_enable);
+   CONFIG_SETD(glayer_zoom_finger_factor);
+   CONFIG_SETD(glayer_zoom_wheel_factor);
+   CONFIG_SETD(glayer_zoom_distance_tolerance);
+   CONFIG_SETD(glayer_rotate_finger_enable);
+   CONFIG_SETD(glayer_rotate_angular_tolerance);
+   CONFIG_SETD(glayer_line_min_length);
+   CONFIG_SETD(glayer_line_distance_tolerance);
+   CONFIG_SETD(glayer_line_angular_tolerance);
+   CONFIG_SETU(glayer_flick_time_limit_ms);
+   CONFIG_SETD(glayer_long_tap_start_timeout);
+   CONFIG_SETD(glayer_double_tap_timeout);
+   CONFIG_SETI(glayer_tap_finger_size);
+   CONFIG_SETB(glayer_continues_enable);
+
   const size_t len = sizeof("audio_mute") - 1;
   if (!strncmp(name, "audio_mute", len))
     {
@ -5073,6 +5123,7 @@ _efl_config_global_efl_config_config_set(Eo *obj EINA_UNUSED, void *_pd EINA_UNU
          }
        elm_config_audio_mute_set(chan, !!v);
 #ifdef ENABLE_MULTISENSE
+        efl_event_callback_call(_efl_config_obj, EFL_CONFIG_EVENT_CONFIG_CHANGED, (void*)name);
        return EINA_TRUE;
 #else
        return EINA_FALSE;
@ -5104,6 +5155,7 @@ _efl_config_global_efl_config_config_get(const Eo *obj EINA_UNUSED, void *_pd EI

 #define CONFIG_GETB(opt) CONFIG_GET(opt, Eina_Bool, UCHAR)
 #define CONFIG_GETI(opt) CONFIG_GET(opt, int, INT)
+#define CONFIG_GETU(opt) CONFIG_GET(opt, unsigned int, UINT)
 #define CONFIG_GETD(opt) CONFIG_GET(opt, double, DOUBLE)
 #define CONFIG_GETS(opt) CONFIG_GET(opt, const char *, STRING)

@ -5182,8 +5234,7 @@ _efl_config_global_efl_config_config_get(const Eo *obj EINA_UNUSED, void *_pd EI
   CONFIG_GETB(first_item_focus_on_first_focusin);
   CONFIG_GETB(mirrored);
   CONFIG_GETB(clouseau_enabled);
-   CONFIG_GETD(glayer_long_tap_start_timeout);
-   CONFIG_GETD(glayer_double_tap_timeout);
+
   //color_overlay
   //color_overlay_unset
   CONFIG_GETB(magnifier_enable);
@ -5198,6 +5249,32 @@ _efl_config_global_efl_config_config_get(const Eo *obj EINA_UNUSED, void *_pd EI
   CONFIG_GETI(powersave);
   CONFIG_GETD(drag_anim_duration);

+   CONFIG_GETD(glayer_long_tap_start_timeout);
+   CONFIG_GETD(glayer_double_tap_timeout);
+#undef CONFIG_GET
+#define CONFIG_GET(opt, primityp, valtyp) do { \
+   if (!strcmp(name, #opt)) \
+     { \
+        val = eina_value_new(EINA_VALUE_TYPE_ ## valtyp); \
+        eina_value_set(val, _elm_config->opt); \
+        return val; \
+     } \
+   } while (0)
+   CONFIG_GETB(glayer_zoom_finger_enable);
+   CONFIG_GETD(glayer_zoom_finger_factor);
+   CONFIG_GETD(glayer_zoom_wheel_factor);
+   CONFIG_GETD(glayer_zoom_distance_tolerance);
+   CONFIG_GETD(glayer_rotate_finger_enable);
+   CONFIG_GETD(glayer_rotate_angular_tolerance);
+   CONFIG_GETD(glayer_line_min_length);
+   CONFIG_GETD(glayer_line_distance_tolerance);
+   CONFIG_GETD(glayer_line_angular_tolerance);
+   CONFIG_GETU(glayer_flick_time_limit_ms);
+   CONFIG_GETD(glayer_long_tap_start_timeout);
+   CONFIG_GETD(glayer_double_tap_timeout);
+   CONFIG_GETI(glayer_tap_finger_size);
+   CONFIG_GETB(glayer_continues_enable);
+
   const size_t len = sizeof("audio_mute") - 1;
   if (!strncmp(name, "audio_mute", len))
     {
@ -5217,7 +5294,6 @@ _efl_config_global_efl_config_config_get(const Eo *obj EINA_UNUSED, void *_pd EI
        return val;
     }

-   ERR("Config '%s' does not exist", name);
   return NULL;
 }

--- a/src/lib/elementary/elm_config.h
+++ b/src/lib/elementary/elm_config.h
@ -2370,104 +2370,6 @@ EAPI double elm_config_drag_anim_duration_get(void);
  */
 EAPI void elm_config_drag_anim_duration_set(double set);

-/* new efl.config interface helpers in C */
-
-/* FIXME these depend on stuff from Efl.h but this is included before that */
-#ifdef EFL_BETA_API_SUPPORT
-
-static inline Eina_Bool
-efl_config_bool_set(Efl_Config *obj, const char * name, Eina_Bool val)
-{
-   Eina_Value *v = eina_value_new(EINA_VALUE_TYPE_UCHAR);
-   Eina_Bool b;
-   eina_value_set(v, val);
-   b = efl_config_set(obj, name, v);
-   eina_value_free(v);
-   return b;
-}
-
-static inline Eina_Bool
-efl_config_bool_get(const Efl_Config *obj, const char * name)
-{
-   Eina_Value *v = efl_config_get(obj, name);
-   Eina_Bool b = 0;
-   if (eina_value_type_get(v) == EINA_VALUE_TYPE_UCHAR)
-     eina_value_get(v, &b);
-   eina_value_free(v);
-   return b;
-}
-
-static inline Eina_Bool
-efl_config_int_set(Efl_Config *obj, const char * name, int val)
-{
-   Eina_Value *v = eina_value_new(EINA_VALUE_TYPE_INT);
-   Eina_Bool b;
-   eina_value_set(v, val);
-   b = efl_config_set(obj, name, v);
-   eina_value_free(v);
-   return b;
-}
-
-static inline int
-efl_config_int_get(const Efl_Config *obj, const char * name)
-{
-   Eina_Value *v = efl_config_get(obj, name);
-   int b = 0;
-   if (eina_value_type_get(v) == EINA_VALUE_TYPE_INT)
-     eina_value_get(v, &b);
-   eina_value_free(v);
-   return b;
-}
-
-static inline Eina_Bool
-efl_config_double_set(Efl_Config *obj, const char * name, double val)
-{
-   Eina_Value *v = eina_value_new(EINA_VALUE_TYPE_DOUBLE);
-   Eina_Bool b;
-   eina_value_set(v, val);
-   b = efl_config_set(obj, name, v);
-   eina_value_free(v);
-   return b;
-}
-
-static inline double
-efl_config_double_get(const Efl_Config *obj, const char * name)
-{
-   Eina_Value *v = efl_config_get(obj, name);
-   double b = 0;
-   if (eina_value_type_get(v) == EINA_VALUE_TYPE_DOUBLE)
-     eina_value_get(v, &b);
-   eina_value_free(v);
-   return b;
-}
-
-static inline Eina_Bool
-efl_config_string_set(Efl_Config *obj, const char *name, const char *val)
-{
-   Eina_Value *v = eina_value_new(EINA_VALUE_TYPE_STRING);
-   Eina_Bool b;
-   eina_value_set(v, val);
-   b = efl_config_set(obj, name, v);
-   eina_value_free(v);
-   return b;
-}
-
-static inline Eina_Stringshare *
-efl_config_string_get(const Efl_Config *obj, const char *name)
-{
-   Eina_Value *v = efl_config_get(obj, name);
-   Eina_Stringshare *s = 0;
-   if (eina_value_type_get(v) == EINA_VALUE_TYPE_STRING)
-     {
-        const char *b = 0;
-        eina_value_get(v, &b);
-        s = eina_stringshare_add(b);
-     }
-   eina_value_free(v);
-   return s;
-}
-
-#endif

 /**
 * @}
--- a/src/lib/evas/gesture/efl_canvas_gesture.eo
+++ b/src/lib/evas/gesture/efl_canvas_gesture.eo
@ -1,5 +1,5 @@
 import efl_canvas_gesture_types;
-parse efl_canvas_gesture_events;
+import efl_canvas_gesture_events;

 abstract @beta Efl.Canvas.Gesture extends Efl.Object
 {
--- a/src/lib/evas/gesture/efl_canvas_gesture_manager.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_manager.c
@ -27,12 +27,11 @@ typedef struct _Efl_Canvas_Gesture_Manager_Data
   //Lazy deletion of gestures
   Eina_Array *m_gestures_to_delete;
   //Kepps config values for gesture recognize
-   Eina_Hash *m_config;
   Eina_Bool processing : 1;
 } Efl_Canvas_Gesture_Manager_Data;

 static void _cleanup_cached_gestures(Efl_Canvas_Gesture_Manager_Data *pd,
-                                      Eo *target, const Efl_Event_Description *type, Efl_Canvas_Gesture_Recognizer *recognizer);
+                                      const Eo *target, const Efl_Event_Description *type, const Efl_Canvas_Gesture_Recognizer *recognizer);
 static Efl_Canvas_Gesture *
            _get_state(Efl_Canvas_Gesture_Manager_Data *pd, Eo *target,
           Efl_Canvas_Gesture_Recognizer *recognizer, const Efl_Event_Description *type);
@ -98,9 +97,19 @@ _update_finger_sizes(Efl_Canvas_Gesture_Manager_Data *pd, int finger_size)
   zd->finger_size = finger_size;
 }

+static void
+_gesture_manager_config_changed(void *data, const Efl_Event *ev)
+{
+   Efl_Canvas_Gesture_Manager_Data *pd = data;
+
+   if ((!ev->info) || eina_streq(ev->info, "glayer_tap_finger_size"))
+     _update_finger_sizes(pd, efl_config_int_get(ev->object, "glayer_tap_finger_size"));
+}
+
 EOLIAN static Efl_Object *
 _efl_canvas_gesture_manager_efl_object_constructor(Eo *obj, Efl_Canvas_Gesture_Manager_Data *pd)
 {
+   Eo *config;
   obj = efl_constructor(efl_super(obj, MY_CLASS));

   pd->m_recognizers = eina_hash_pointer_new(EINA_FREE_CB(_hash_unref_cb));
@ -109,9 +118,10 @@ _efl_canvas_gesture_manager_efl_object_constructor(Eo *obj, Efl_Canvas_Gesture_M
   pd->m_object_gestures = NULL;
   pd->m_gestures_to_delete = eina_array_new(1);;

-   pd->m_config = eina_hash_string_superfast_new(EINA_FREE_CB(eina_value_free));
   /* this needs to always be present */
-   eina_hash_add(pd->m_config, "glayer_tap_finger_size", eina_value_int_new(EFL_GESTURE_RECOGNIZER_TYPE_TAP_FINGER_SIZE));
+   config = efl_provider_find(efl_main_loop_get(), EFL_CONFIG_INTERFACE);
+   efl_config_int_set(config, "glayer_tap_finger_size", EFL_GESTURE_RECOGNIZER_TYPE_TAP_FINGER_SIZE);
+   efl_event_callback_add(config, EFL_CONFIG_EVENT_CONFIG_CHANGED, _gesture_manager_config_changed, pd);

   //Register all types of recognizers at very first time.
   efl_gesture_manager_recognizer_register(obj, efl_add(EFL_CANVAS_GESTURE_RECOGNIZER_TAP_CLASS, obj));
@ -126,35 +136,15 @@ _efl_canvas_gesture_manager_efl_object_constructor(Eo *obj, Efl_Canvas_Gesture_M
   return obj;
 }

-EOLIAN static Eina_Value *
-_efl_canvas_gesture_manager_config_get(const Eo *obj EINA_UNUSED, Efl_Canvas_Gesture_Manager_Data *pd, const char *name)
-{
-   return eina_hash_find(pd->m_config, name);
-}
-
 EOLIAN static void
-_efl_canvas_gesture_manager_config_set(Eo *obj, Efl_Canvas_Gesture_Manager_Data *pd, const char *name, Eina_Value *value)
-{
-   Eina_Value *v;
-   int finger_size;
-
-   EINA_SAFETY_ON_NULL_RETURN(name);
-   v = eina_value_new(eina_value_type_get(value));
-   eina_value_copy(value, v);
-   eina_hash_add(pd->m_config, name, v);
-   efl_event_callback_call(obj, EFL_GESTURE_MANAGER_EVENT_CONFIG_CHANGED, (void*)name);
-   if (!eina_streq(name, "glayer_tap_finger_size")) return;
-   eina_value_get(value, &finger_size);
-   _update_finger_sizes(pd, finger_size);
-}
-
-EOLIAN static void
-_efl_canvas_gesture_manager_efl_object_destructor(Eo *obj, Efl_Canvas_Gesture_Manager_Data *pd EINA_UNUSED)
+_efl_canvas_gesture_manager_efl_object_destructor(Eo *obj, Efl_Canvas_Gesture_Manager_Data *pd)
 {
   Efl_Canvas_Gesture_Recognizer *recognizer;
   void *ptr;
+   Eo *config = efl_provider_find(efl_main_loop_get(), EFL_CONFIG_INTERFACE);
+   if (config)
+     efl_event_callback_del(config, EFL_CONFIG_EVENT_CONFIG_CHANGED, _gesture_manager_config_changed, pd);

-   eina_hash_free(pd->m_config);
   eina_hash_free(pd->m_recognizers);
   EINA_LIST_FREE(pd->custom_recognizers, recognizer)
     efl_unref(recognizer);
@ -486,7 +476,7 @@ _get_state(Efl_Canvas_Gesture_Manager_Data *pd,

 static void
 _cleanup_cached_gestures(Efl_Canvas_Gesture_Manager_Data *pd,
-                         Eo *target, const Efl_Event_Description *type, Efl_Canvas_Gesture_Recognizer *recognizer)
+                         const Eo *target, const Efl_Event_Description *type, const Efl_Canvas_Gesture_Recognizer *recognizer)
 {
   Eina_List *l, *l_next;
   Object_Gesture *object_gesture;
@ -503,12 +493,20 @@ _cleanup_cached_gestures(Efl_Canvas_Gesture_Manager_Data *pd,
     }
 }

-void
-efl_gesture_manager_gesture_clean_up(Eo *obj, Eo *target, const Efl_Event_Description *type, Efl_Canvas_Gesture_Recognizer *recognizer)
+EOLIAN static void
+_efl_canvas_gesture_manager_recognizer_cleanup(Eo *obj EINA_UNUSED, Efl_Canvas_Gesture_Manager_Data *pd, const Efl_Canvas_Gesture_Recognizer *recognizer, const Eo *target)
 {
-   Efl_Canvas_Gesture_Manager_Data *pd = efl_data_scope_get(obj, MY_CLASS);
+   const Efl_Event_Description *type;
+   Efl_Canvas_Gesture *dummy;

   EINA_SAFETY_ON_NULL_RETURN(recognizer);
+
+   //Find the type of the recognizer
+   dummy = efl_gesture_recognizer_add((void*)recognizer, 0);
+   EINA_SAFETY_ON_NULL_RETURN(dummy);
+
+   type = _efl_gesture_type_get(dummy);
+   efl_del(dummy);
   _cleanup_cached_gestures(pd, target, type, recognizer);
   eina_hash_del(pd->m_object_events, &recognizer, NULL);
   _cleanup_object(pd->m_gestures_to_delete);
--- a/src/lib/evas/gesture/efl_canvas_gesture_manager.eo
+++ b/src/lib/evas/gesture/efl_canvas_gesture_manager.eo
@ -22,23 +22,14 @@ class @beta Efl.Canvas.Gesture_Manager extends Efl.Object
            @in recognizer: Efl.Canvas.Gesture_Recognizer; [[The gesture recognizer object.]]
         }
      }
-      @property config {
-         [[This property holds configuration values for the recognizer.]]
-         set {
-         }
-         get {
-         }
-         keys {
-            name: string; [[Property name.]]
-         }
-         values {
-            value: any_value_ref; [[Value of the property.]]
+      recognizer_cleanup {
+         [[Perform cleanup for a gesture which ends after a delay.]]
+         params {
+            @in recognizer: const(Efl.Canvas.Gesture_Recognizer); [[The gesture recognizer object.]]
+            @in target: const(Efl.Canvas.Object); [[The target object being processed by the recognizer.]]
         }
      }
   }
-   events {
-      config,changed: string; [[Called when a config value has been changed for the manager object. Passed string is the name of the value.]]
-   }
   implements {
      Efl.Object.constructor;
      Efl.Object.destructor;
--- a/src/lib/evas/gesture/efl_canvas_gesture_private.h
+++ b/src/lib/evas/gesture/efl_canvas_gesture_private.h
@ -12,7 +12,6 @@
 #define TAP_TOUCH_TIME_THRESHOLD (0.1 * 1000)

 const Efl_Event_Description * _efl_gesture_type_get(const Eo *obj);
-void efl_gesture_manager_gesture_clean_up(Eo *obj, Eo *target, const Efl_Event_Description *type, Efl_Canvas_Gesture_Recognizer *recognizer);
 int _direction_get(Evas_Coord xx1, Evas_Coord xx2);
 Eina_Value *_recognizer_config_get(const Eo *obj, const char *name);

--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer.c
@ -7,9 +7,9 @@
 Eina_Value *
 _recognizer_config_get(const Eo *obj, const char *name)
 {
-   Eo *manager = efl_provider_find(obj, EFL_CANVAS_GESTURE_MANAGER_CLASS);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(manager, NULL);
-   return efl_gesture_manager_config_get(manager, name);
+   Eo *config = efl_provider_find(obj, EFL_CONFIG_INTERFACE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(config, NULL);
+   return efl_config_get(config, name);
 }

 EOLIAN static void
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer.eo
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer.eo
@ -7,8 +7,8 @@ abstract @beta Efl.Canvas.Gesture_Recognizer extends Efl.Object
     Gesture recognizers listen to events that occur on a target object
     to see if a particular gesture has occurred.

-     Recognizer-specific configuration values can be modified through @Efl.Canvas.Gesture_Manager.config,
-     and the recognizer's manager can be found using @Efl.Object.provider_find.
+     Recognizer-specific configuration values can be modified through @Efl.Config.config,
+     and the global config object can be found using @Efl.Object.provider_find.
     Default configuration values are taken from the system's configuration.
   ]]
   c_prefix: efl_gesture_recognizer;
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_double_tap.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_double_tap.c
@ -30,8 +30,8 @@ _tap_timeout_cb(void *data)
   efl_gesture_state_set(pd->gesture, EFL_GESTURE_STATE_CANCELED);
   efl_event_callback_call(pd->target, EFL_EVENT_GESTURE_DOUBLE_TAP, pd->gesture);

-   efl_gesture_manager_gesture_clean_up(efl_provider_find(data, EFL_CANVAS_GESTURE_MANAGER_CLASS),
-     pd->target, EFL_EVENT_GESTURE_DOUBLE_TAP, data);
+   efl_gesture_manager_recognizer_cleanup(efl_provider_find(data, EFL_CANVAS_GESTURE_MANAGER_CLASS), data,
+     pd->target);

   pd->timeout = NULL;
   pd->tap_count = 0;
@ -68,6 +68,8 @@ _efl_canvas_gesture_recognizer_double_tap_efl_canvas_gesture_recognizer_recogniz
   else
     timeout = start_timeout;

+   printf("RECOG %d %d %d\n",efl_gesture_touch_state_get(event), efl_gesture_touch_cur_data_get(event)->action, pd->finger_size);
+
   switch (efl_gesture_touch_state_get(event))
     {
      case EFL_GESTURE_TOUCH_STATE_BEGIN:
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_flick.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_flick.c
@ -212,7 +212,7 @@ _efl_canvas_gesture_recognizer_flick_efl_canvas_gesture_recognizer_recognize(Eo
   //This is to handle a case with a mouse click on the target object.
   if (efl_gesture_touch_state_get(event) == EFL_GESTURE_TOUCH_STATE_END && !pd->touched)
     {
-        efl_gesture_manager_gesture_clean_up(efl_provider_find(obj, EFL_CANVAS_GESTURE_MANAGER_CLASS), watched, EFL_EVENT_GESTURE_FLICK, obj);
+        efl_gesture_manager_recognizer_cleanup(efl_provider_find(obj, EFL_CANVAS_GESTURE_MANAGER_CLASS), obj, watched);
        dead = EINA_TRUE;
     }

--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_triple_tap.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_triple_tap.c
@ -30,7 +30,7 @@ _tap_timeout_cb(void *data)
   efl_gesture_state_set(pd->gesture, EFL_GESTURE_STATE_CANCELED);
   efl_event_callback_call(pd->target, EFL_EVENT_GESTURE_TRIPLE_TAP, pd->gesture);

-   efl_gesture_manager_gesture_clean_up(efl_provider_find(data, EFL_CANVAS_GESTURE_MANAGER_CLASS), pd->target, EFL_EVENT_GESTURE_TRIPLE_TAP, data);
+   efl_gesture_manager_recognizer_cleanup(efl_provider_find(data, EFL_CANVAS_GESTURE_MANAGER_CLASS), data, pd->target);

   pd->timeout = NULL;
   pd->tap_count = 0;
--- a/src/lib/evas/gesture/efl_canvas_gesture_recognizer_zoom.c
+++ b/src/lib/evas/gesture/efl_canvas_gesture_recognizer_zoom.c
@ -267,7 +267,7 @@ _efl_canvas_gesture_recognizer_zoom_efl_canvas_gesture_recognizer_recognize(Eo *
              rd->continues = EINA_FALSE;

              _reset_recognizer(pd);
-              efl_gesture_manager_gesture_clean_up(efl_provider_find(obj, EFL_CANVAS_GESTURE_MANAGER_CLASS), watched, EFL_EVENT_GESTURE_ZOOM, obj);
+              efl_gesture_manager_recognizer_cleanup(efl_provider_find(obj, EFL_CANVAS_GESTURE_MANAGER_CLASS), obj, watched);

              return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE;
           }
--- a/src/tests/elementary/efl_ui_test_gesture.c
+++ b/src/tests/elementary/efl_ui_test_gesture.c
@ -100,7 +100,7 @@ setup(void)
 EFL_START_TEST(test_efl_ui_gesture_taps)
 {
   Eo *rect = setup();
-
+#if 0
   /* basic tap */
   click_object(rect);
   CHECK_ALL(TAP, 1, 0, 1, 0);
@ -191,7 +191,17 @@ EFL_START_TEST(test_efl_ui_gesture_taps)
   /* this is two fingers, so we have a zoom start */
   CHECK_ALL(ZOOM, 1, 0, 0, 1);
   RESET;
-
+#endif
+   printf("NOW\n");
+   printf("NOW\n");
+   printf("NOW\n");
+   click_object_at(rect, 10, 10);
+   click_object_at(rect, 12, 12);
+   CHECK_ALL(DOUBLE_TAP, 1, 2, 1, 0);
+   RESET;
+   printf("NOW\n");
+   printf("NOW\n");
+   printf("NOW\n");
 }
 EFL_END_TEST

@ -202,7 +212,7 @@ EFL_START_TEST(test_efl_ui_gesture_long_tap)
   Eina_Value *val;
   Eo *e = efl_provider_find(rect, EVAS_CANVAS_CLASS);

-   val = efl_gesture_manager_config_get(efl_provider_find(rect, EFL_CANVAS_GESTURE_MANAGER_CLASS), "glayer_long_tap_start_timeout");
+   val = efl_config_get(efl_provider_find(rect, EFL_CONFIG_INTERFACE), "glayer_long_tap_start_timeout");
   eina_value_get(val, &timeout);

   /* press */
@ -586,8 +596,8 @@ EFL_END_TEST
 void efl_ui_test_gesture(TCase *tc)
 {
   tcase_add_test(tc, test_efl_ui_gesture_taps);
-   tcase_add_test(tc, test_efl_ui_gesture_long_tap);
+   /*tcase_add_test(tc, test_efl_ui_gesture_long_tap);
   tcase_add_test(tc, test_efl_ui_gesture_flick);
   tcase_add_test(tc, test_efl_ui_gesture_zoom);
-   tcase_add_test(tc, test_efl_ui_gesture_custom);
+   tcase_add_test(tc, test_efl_ui_gesture_custom);*/
 }
Author	SHA1	Message	Date
Marcel Hollerbach	a693561f68	wip	2020-02-05 10:19:09 +01:00
Marcel Hollerbach	c2bb55517a	efl_canvas_gesture: replace parse with import we probebly want to use import here, as we want to rebuild this file when efl_canvas_gesture_events is changed. Differential Revision: https://phab.enlightenment.org/D11273	2020-02-05 10:19:09 +01:00
Mike Blumenkrantz	7f157be59a	efl/config: merge all gesture manager config code into efl.config this is all just duplicated code, so we can deduplicate it with minimal effort to clean up the api	2020-02-05 10:19:09 +01:00
Mike Blumenkrantz	af67c97999	efl/config: add missing gesture config value handlers these are stored in the config here so they should be manageable here as well	2020-02-05 10:19:08 +01:00
Mike Blumenkrantz	62d5ad9e8e	efl/win: change a couple config init sets for gesture manager to use legacy config these values are deprecated, so stop setting them in efl_config	2020-02-05 10:19:08 +01:00
Mike Blumenkrantz	87ea5a5e71	efl/gesture: remove manager config we can just use efl.config here instead of duplicating it	2020-02-05 10:19:08 +01:00
Mike Blumenkrantz	bc543ee1b9	efl/config: move C wrappers for this out of elm_config.h to Efl.h this is beta API and belongs in its proper header	2020-02-05 10:19:08 +01:00
Mike Blumenkrantz	9c4c087cd1	efl/gesture: move manager's recognizer cleanup function to eo this is needed by recognizers which use timers in order to do timeouts on gestures Differential Revision: https://phab.enlightenment.org/D11245	2020-02-05 10:19:08 +01:00