efl_interpolator: rename subclasses of Efl.Interpolator

Subclasses of Efl.Interpolator are renamed intuitively from backward
order to forward order.

src/Makefile_Ecore.am

@@ -33,14 +33,14 @@ ecore_eolian_files_public = \
 	lib/ecore/efl_io_file.eo \
         lib/ecore/efl_io_copier.eo \
         lib/ecore/efl_io_buffered_stream.eo \
-	lib/ecore/efl_interpolator_linear.eo \
+	lib/ecore/efl_linear_interpolator.eo \
-	lib/ecore/efl_interpolator_accelerate.eo \
+	lib/ecore/efl_accelerate_interpolator.eo \
-	lib/ecore/efl_interpolator_decelerate.eo \
+	lib/ecore/efl_decelerate_interpolator.eo \
-	lib/ecore/efl_interpolator_sinusoidal.eo \
+	lib/ecore/efl_sinusoidal_interpolator.eo \
-	lib/ecore/efl_interpolator_divisor.eo \
+	lib/ecore/efl_divisor_interpolator.eo \
-	lib/ecore/efl_interpolator_bounce.eo \
+	lib/ecore/efl_bounce_interpolator.eo \
-	lib/ecore/efl_interpolator_spring.eo \
+	lib/ecore/efl_spring_interpolator.eo \
-	lib/ecore/efl_interpolator_cubic_bezier.eo \
+	lib/ecore/efl_cubic_bezier_interpolator.eo \
 	lib/ecore/efl_model_item.eo \
 	lib/ecore/efl_model_container.eo \
 	lib/ecore/efl_model_container_item.eo \
@@ -126,14 +126,14 @@ lib/ecore/efl_model_composite_boolean.c \
 lib/ecore/efl_model_composite_selection.c \
 lib/ecore/efl_model_accessor_view.c \
 lib/ecore/efl_model_accessor_view_private.h \
-lib/ecore/efl_interpolator_linear.c \
+lib/ecore/efl_linear_interpolator.c \
-lib/ecore/efl_interpolator_accelerate.c \
+lib/ecore/efl_accelerate_interpolator.c \
-lib/ecore/efl_interpolator_decelerate.c \
+lib/ecore/efl_decelerate_interpolator.c \
-lib/ecore/efl_interpolator_sinusoidal.c \
+lib/ecore/efl_sinusoidal_interpolator.c \
-lib/ecore/efl_interpolator_divisor.c \
+lib/ecore/efl_divisor_interpolator.c \
-lib/ecore/efl_interpolator_bounce.c \
+lib/ecore/efl_bounce_interpolator.c \
-lib/ecore/efl_interpolator_spring.c \
+lib/ecore/efl_spring_interpolator.c \
-lib/ecore/efl_interpolator_cubic_bezier.c \
+lib/ecore/efl_cubic_bezier_interpolator.c \
 lib/ecore/efl_task.c \
 lib/ecore/efl_exe.c \
 lib/ecore/efl_thread.c \

src/bin/elementary/test_efl_anim_interpolator.c

@@ -28,37 +28,37 @@ _interpolator_create(int index, Evas_Object *win)
 
    if (index == 0)
      {
-        interp = efl_add(EFL_INTERPOLATOR_LINEAR_CLASS, win);
+        interp = efl_add(EFL_LINEAR_INTERPOLATOR_CLASS, win);
      }
    else if (index == 1)
      {
-        interp = efl_add(EFL_INTERPOLATOR_SINUSOIDAL_CLASS, win);
+        interp = efl_add(EFL_SINUSOIDAL_INTERPOLATOR_CLASS, win);
-        efl_interpolator_sinusoidal_factor_set(interp, 1.0);
+        efl_sinusoidal_interpolator_factor_set(interp, 1.0);
      }
    else if (index == 2)
      {
-        interp = efl_add(EFL_INTERPOLATOR_DECELERATE_CLASS, win);
+        interp = efl_add(EFL_DECELERATE_INTERPOLATOR_CLASS, win);
-        efl_interpolator_decelerate_factor_set(interp, 1.0);
+        efl_decelerate_interpolator_factor_set(interp, 1.0);
      }
    else if (index == 3)
      {
-        interp = efl_add(EFL_INTERPOLATOR_ACCELERATE_CLASS, win);
+        interp = efl_add(EFL_ACCELERATE_INTERPOLATOR_CLASS, win);
-        efl_interpolator_accelerate_factor_set(interp, 1.0);
+        efl_accelerate_interpolator_factor_set(interp, 1.0);
      }
    else if (index == 4)
      {
-        interp = efl_add(EFL_INTERPOLATOR_DIVISOR_CLASS, win);
+        interp = efl_add(EFL_DIVISOR_INTERPOLATOR_CLASS, win);
-        efl_interpolator_divisor_factors_set(interp, 1.0, 1.0);
+        efl_divisor_interpolator_factors_set(interp, 1.0, 1.0);
      }
    else if (index == 5)
      {
-        interp = efl_add(EFL_INTERPOLATOR_BOUNCE_CLASS, win);
+        interp = efl_add(EFL_BOUNCE_INTERPOLATOR_CLASS, win);
-        efl_interpolator_bounce_factors_set(interp, 1.0, 1.0);
+        efl_bounce_interpolator_factors_set(interp, 1.0, 1.0);
      }
    else if (index == 6)
      {
-        interp = efl_add(EFL_INTERPOLATOR_SPRING_CLASS, win);
+        interp = efl_add(EFL_SPRING_INTERPOLATOR_CLASS, win);
-        efl_interpolator_spring_factors_set(interp, 1.0, 1.0);
+        efl_spring_interpolator_factors_set(interp, 1.0, 1.0);
      }
 
    return interp;

src/lib/ecore/CMakeLists.txt

@@ -38,14 +38,14 @@ set(PUBLIC_EO_FILES
   efl_loop_timer.eo
   efl_loop_user.eo
   efl_promise.eo
-  efl_interpolator_linear.eo
+  efl_linear_interpolator.eo
-  efl_interpolator_accelerate.eo
+  efl_accelerate_interpolator.eo
-  efl_interpolator_decelerate.eo
+  efl_decelerate_interpolator.eo
-  efl_interpolator_sinusoidal.eo
+  efl_sinusoidal_interpolator.eo
-  efl_interpolator_divisor.eo
+  efl_divisor_interpolator.eo
-  efl_interpolator_bounce.eo
+  efl_bounce_interpolator.eo
-  efl_interpolator_spring.eo
+  efl_spring_interpolator.eo
-  efl_interpolator_cubic_bezier.eo
+  efl_cubic_bezier_interpolator.eo
 )
 
 set(PUBLIC_HEADERS

src/lib/ecore/Ecore_Eo.h

@@ -78,14 +78,14 @@ EAPI Eina_Promise *efl_loop_promise_new(const Eo *obj, Eina_Promise_Cancel_Cb ca
 #include "efl_loop_fd.eo.h"
 #include "efl_loop_handler.eo.h"
 
-#include "efl_interpolator_linear.eo.h"
+#include "efl_linear_interpolator.eo.h"
-#include "efl_interpolator_accelerate.eo.h"
+#include "efl_accelerate_interpolator.eo.h"
-#include "efl_interpolator_decelerate.eo.h"
+#include "efl_decelerate_interpolator.eo.h"
-#include "efl_interpolator_sinusoidal.eo.h"
+#include "efl_sinusoidal_interpolator.eo.h"
-#include "efl_interpolator_divisor.eo.h"
+#include "efl_divisor_interpolator.eo.h"
-#include "efl_interpolator_bounce.eo.h"
+#include "efl_bounce_interpolator.eo.h"
-#include "efl_interpolator_spring.eo.h"
+#include "efl_spring_interpolator.eo.h"
-#include "efl_interpolator_cubic_bezier.eo.h"
+#include "efl_cubic_bezier_interpolator.eo.h"
 
 /* We ue the factory pattern here, so you shouldn't call eo_add directly. */
 EAPI Eo *efl_main_loop_get(void);

src/lib/ecore/efl_accelerate_interpolator.c

@@ -0,0 +1,55 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "Ecore.h"
+#include "ecore_private.h"
+
+#define MY_CLASS EFL_ACCELERATE_INTERPOLATOR_CLASS
+
+typedef struct _Efl_Accelerate_Interpolator_Data Efl_Accelerate_Interpolator_Data;
+
+struct _Efl_Accelerate_Interpolator_Data
+{
+   double factor;
+};
+
+EOLIAN static double
+_efl_accelerate_interpolator_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUSED,
+                                                          Efl_Accelerate_Interpolator_Data *pd EINA_UNUSED,
+                                                          double progress)
+{
+   if ((progress < 0.0) || (progress > 1.0))
+     return progress;
+
+   return ecore_animator_pos_map(progress, ECORE_POS_MAP_ACCELERATE_FACTOR,
+                                 pd->factor, 0);
+}
+
+EOLIAN static void
+_efl_accelerate_interpolator_factor_set(Eo *eo_obj EINA_UNUSED,
+                                        Efl_Accelerate_Interpolator_Data *pd,
+                                        double factor)
+{
+   pd->factor = factor;
+}
+
+EOLIAN static double
+_efl_accelerate_interpolator_factor_get(const Eo *eo_obj EINA_UNUSED,
+                                        Efl_Accelerate_Interpolator_Data *pd EINA_UNUSED)
+{
+   return pd->factor;
+}
+
+EOLIAN static Efl_Object *
+_efl_accelerate_interpolator_efl_object_constructor(Eo *eo_obj,
+                                                    Efl_Accelerate_Interpolator_Data *pd)
+{
+   eo_obj = efl_constructor(efl_super(eo_obj, MY_CLASS));
+
+   pd->factor = 1.0;
+
+   return eo_obj;
+}
+
+#include "efl_accelerate_interpolator.eo.c"

src/lib/ecore/efl_accelerate_interpolator.eo

@@ -1,10 +1,10 @@
-class Efl.Interpolator_Accelerate (Efl.Object, Efl.Interpolator)
+class Efl.Accelerate_Interpolator (Efl.Object, Efl.Interpolator)
 {
    [[Efl accelerate interpolator class
 
      output = 1 - sin(Pi / 2 + input * Pi / 2);
    ]]
-   data: Efl_Interpolator_Accelerate_Data;
+   data: Efl_Accelerate_Interpolator_Data;
    methods {
       @property factor {
          [[Factor property]]

src/lib/ecore/efl_bounce_interpolator.c

@@ -5,18 +5,18 @@
 #include "Ecore.h"
 #include "ecore_private.h"
 
-#define MY_CLASS EFL_INTERPOLATOR_BOUNCE_CLASS
+#define MY_CLASS EFL_BOUNCE_INTERPOLATOR_CLASS
 
-typedef struct _Efl_Interpolator_Bounce_Data Efl_Interpolator_Bounce_Data;
+typedef struct _Efl_Bounce_Interpolator_Data Efl_Bounce_Interpolator_Data;
 
-struct _Efl_Interpolator_Bounce_Data
+struct _Efl_Bounce_Interpolator_Data
 {
    double factor[2];
 };
 
 EOLIAN static double
-_efl_interpolator_bounce_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUSED,
+_efl_bounce_interpolator_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUSED,
-                                                      Efl_Interpolator_Bounce_Data *pd EINA_UNUSED,
+                                                      Efl_Bounce_Interpolator_Data *pd EINA_UNUSED,
                                                       double progress)
 {
    if ((progress < 0.0) || (progress > 1.0))
@@ -27,8 +27,8 @@ _efl_interpolator_bounce_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUSED,
 }
 
 EOLIAN static void
-_efl_interpolator_bounce_factors_set(Eo *eo_obj EINA_UNUSED,
+_efl_bounce_interpolator_factors_set(Eo *eo_obj EINA_UNUSED,
-                                     Efl_Interpolator_Bounce_Data *pd,
+                                     Efl_Bounce_Interpolator_Data *pd,
                                      double factor1, double factor2)
 {
    pd->factor[0] = factor1;
@@ -36,8 +36,8 @@ _efl_interpolator_bounce_factors_set(Eo *eo_obj EINA_UNUSED,
 }
 
 EOLIAN static void
-_efl_interpolator_bounce_factors_get(const Eo *eo_obj EINA_UNUSED,
+_efl_bounce_interpolator_factors_get(const Eo *eo_obj EINA_UNUSED,
-                                     Efl_Interpolator_Bounce_Data *pd,
+                                     Efl_Bounce_Interpolator_Data *pd,
                                      double *factor1, double *factor2)
 {
    if (factor1)
@@ -48,8 +48,8 @@ _efl_interpolator_bounce_factors_get(const Eo *eo_obj EINA_UNUSED,
 }
 
 EOLIAN static Efl_Object *
-_efl_interpolator_bounce_efl_object_constructor(Eo *eo_obj,
+_efl_bounce_interpolator_efl_object_constructor(Eo *eo_obj,
-                                                Efl_Interpolator_Bounce_Data *pd)
+                                                Efl_Bounce_Interpolator_Data *pd)
 {
    eo_obj = efl_constructor(efl_super(eo_obj, MY_CLASS));
 
@@ -59,4 +59,4 @@ _efl_interpolator_bounce_efl_object_constructor(Eo *eo_obj,
    return eo_obj;
 }
 
-#include "efl_interpolator_bounce.eo.c"
+#include "efl_bounce_interpolator.eo.c"

src/lib/ecore/efl_bounce_interpolator.eo

@@ -1,7 +1,7 @@
-class Efl.Interpolator_Bounce (Efl.Object, Efl.Interpolator)
+class Efl.Bounce_Interpolator (Efl.Object, Efl.Interpolator)
 {
    [[Efl bounce interpolator class]]
-   data: Efl_Interpolator_Bounce_Data;
+   data: Efl_Bounce_Interpolator_Data;
    methods {
       @property factors {
          [[Factors property]]

src/lib/ecore/efl_cubic_bezier_interpolator.c

@@ -5,18 +5,18 @@
 #include "Ecore.h"
 #include "ecore_private.h"
 
-#define MY_CLASS EFL_INTERPOLATOR_CUBIC_BEZIER_CLASS
+#define MY_CLASS EFL_CUBIC_BEZIER_INTERPOLATOR_CLASS
 
-typedef struct _Efl_Interpolator_Cubic_Bezier_Data Efl_Interpolator_Cubic_Bezier_Data;
+typedef struct _Efl_Cubic_Bezier_Interpolator_Data Efl_Cubic_Bezier_Interpolator_Data;
 
-struct _Efl_Interpolator_Cubic_Bezier_Data
+struct _Efl_Cubic_Bezier_Interpolator_Data
 {
    double factor[4];
 };
 
 EOLIAN static double
-_efl_interpolator_cubic_bezier_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUSED,
+_efl_cubic_bezier_interpolator_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUSED,
-                                                            Efl_Interpolator_Cubic_Bezier_Data *pd EINA_UNUSED,
+                                                            Efl_Cubic_Bezier_Interpolator_Data *pd EINA_UNUSED,
                                                             double progress)
 {
    if ((progress < 0.0) || (progress > 1.0))
@@ -27,8 +27,8 @@ _efl_interpolator_cubic_bezier_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUS
 }
 
 EOLIAN static void
-_efl_interpolator_cubic_bezier_factors_set(Eo *eo_obj EINA_UNUSED,
+_efl_cubic_bezier_interpolator_factors_set(Eo *eo_obj EINA_UNUSED,
-                                           Efl_Interpolator_Cubic_Bezier_Data *pd,
+                                           Efl_Cubic_Bezier_Interpolator_Data *pd,
                                            double factor1, double factor2,
                                            double factor3, double factor4)
 {
@@ -39,8 +39,8 @@ _efl_interpolator_cubic_bezier_factors_set(Eo *eo_obj EINA_UNUSED,
 }
 
 EOLIAN static void
-_efl_interpolator_cubic_bezier_factors_get(const Eo *eo_obj EINA_UNUSED,
+_efl_cubic_bezier_interpolator_factors_get(const Eo *eo_obj EINA_UNUSED,
-                                           Efl_Interpolator_Cubic_Bezier_Data *pd,
+                                           Efl_Cubic_Bezier_Interpolator_Data *pd,
                                            double *factor1, double *factor2,
                                            double *factor3, double *factor4)
 {
@@ -58,8 +58,8 @@ _efl_interpolator_cubic_bezier_factors_get(const Eo *eo_obj EINA_UNUSED,
 }
 
 EOLIAN static Efl_Object *
-_efl_interpolator_cubic_bezier_efl_object_constructor(Eo *eo_obj,
+_efl_cubic_bezier_interpolator_efl_object_constructor(Eo *eo_obj,
-                                                      Efl_Interpolator_Cubic_Bezier_Data *pd)
+                                                      Efl_Cubic_Bezier_Interpolator_Data *pd)
 {
    eo_obj = efl_constructor(efl_super(eo_obj, MY_CLASS));
 
@@ -71,4 +71,4 @@ _efl_interpolator_cubic_bezier_efl_object_constructor(Eo *eo_obj,
    return eo_obj;
 }
 
-#include "efl_interpolator_cubic_bezier.eo.c"
+#include "efl_cubic_bezier_interpolator.eo.c"

src/lib/ecore/efl_cubic_bezier_interpolator.eo

@@ -1,7 +1,7 @@
-class Efl.Interpolator_Cubic_Bezier (Efl.Object, Efl.Interpolator)
+class Efl.Cubic_Bezier_Interpolator (Efl.Object, Efl.Interpolator)
 {
    [[Efl cubic_bezier interpolator class]]
-   data: Efl_Interpolator_Cubic_Bezier_Data;
+   data: Efl_Cubic_Bezier_Interpolator_Data;
    methods {
       @property factors {
          [[Factors property]]

src/lib/ecore/efl_decelerate_interpolator.c

@@ -0,0 +1,55 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "Ecore.h"
+#include "ecore_private.h"
+
+#define MY_CLASS EFL_DECELERATE_INTERPOLATOR_CLASS
+
+typedef struct _Efl_Decelerate_Interpolator_Data Efl_Decelerate_Interpolator_Data;
+
+struct _Efl_Decelerate_Interpolator_Data
+{
+   double factor;
+};
+
+EOLIAN static double
+_efl_decelerate_interpolator_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUSED,
+                                                          Efl_Decelerate_Interpolator_Data *pd EINA_UNUSED,
+                                                          double progress)
+{
+   if ((progress < 0.0) || (progress > 1.0))
+     return progress;
+
+   return ecore_animator_pos_map(progress, ECORE_POS_MAP_DECELERATE_FACTOR,
+                                 pd->factor, 0);
+}
+
+EOLIAN static void
+_efl_decelerate_interpolator_factor_set(Eo *eo_obj EINA_UNUSED,
+                                        Efl_Decelerate_Interpolator_Data *pd,
+                                        double factor)
+{
+   pd->factor = factor;
+}
+
+EOLIAN static double
+_efl_decelerate_interpolator_factor_get(const Eo *eo_obj EINA_UNUSED,
+                                        Efl_Decelerate_Interpolator_Data *pd EINA_UNUSED)
+{
+   return pd->factor;
+}
+
+EOLIAN static Efl_Object *
+_efl_decelerate_interpolator_efl_object_constructor(Eo *eo_obj,
+                                                    Efl_Decelerate_Interpolator_Data *pd)
+{
+   eo_obj = efl_constructor(efl_super(eo_obj, MY_CLASS));
+
+   pd->factor = 1.0;
+
+   return eo_obj;
+}
+
+#include "efl_decelerate_interpolator.eo.c"

src/lib/ecore/efl_decelerate_interpolator.eo

@@ -1,10 +1,10 @@
-class Efl.Interpolator_Decelerate (Efl.Object, Efl.Interpolator)
+class Efl.Decelerate_Interpolator (Efl.Object, Efl.Interpolator)
 {
    [[Efl decelerate interpolator class
 
      output = sin(input * Pi / 2);
    ]]
-   data: Efl_Interpolator_Decelerate_Data;
+   data: Efl_Decelerate_Interpolator_Data;
    methods {
       @property factor {
          [[Factor property]]

src/lib/ecore/efl_divisor_interpolator.c

@@ -5,18 +5,18 @@
 #include "Ecore.h"
 #include "ecore_private.h"
 
-#define MY_CLASS EFL_INTERPOLATOR_DIVISOR_CLASS
+#define MY_CLASS EFL_DIVISOR_INTERPOLATOR_CLASS
 
-typedef struct _Efl_Interpolator_Divisor_Data Efl_Interpolator_Divisor_Data;
+typedef struct _Efl_Divisor_Interpolator_Data Efl_Divisor_Interpolator_Data;
 
-struct _Efl_Interpolator_Divisor_Data
+struct _Efl_Divisor_Interpolator_Data
 {
    double factor[2];
 };
 
 EOLIAN static double
-_efl_interpolator_divisor_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUSED,
+_efl_divisor_interpolator_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUSED,
-                                                       Efl_Interpolator_Divisor_Data *pd EINA_UNUSED,
+                                                       Efl_Divisor_Interpolator_Data *pd EINA_UNUSED,
                                                        double progress)
 {
    if ((progress < 0.0) || (progress > 1.0))
@@ -27,8 +27,8 @@ _efl_interpolator_divisor_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUSED,
 }
 
 EOLIAN static void
-_efl_interpolator_divisor_factors_set(Eo *eo_obj EINA_UNUSED,
+_efl_divisor_interpolator_factors_set(Eo *eo_obj EINA_UNUSED,
-                                      Efl_Interpolator_Divisor_Data *pd,
+                                      Efl_Divisor_Interpolator_Data *pd,
                                       double factor1, double factor2)
 {
    pd->factor[0] = factor1;
@@ -36,8 +36,8 @@ _efl_interpolator_divisor_factors_set(Eo *eo_obj EINA_UNUSED,
 }
 
 EOLIAN static void
-_efl_interpolator_divisor_factors_get(const Eo *eo_obj EINA_UNUSED,
+_efl_divisor_interpolator_factors_get(const Eo *eo_obj EINA_UNUSED,
-                                      Efl_Interpolator_Divisor_Data *pd,
+                                      Efl_Divisor_Interpolator_Data *pd,
                                       double *factor1, double *factor2)
 {
    if (factor1)
@@ -48,8 +48,8 @@ _efl_interpolator_divisor_factors_get(const Eo *eo_obj EINA_UNUSED,
 }
 
 EOLIAN static Efl_Object *
-_efl_interpolator_divisor_efl_object_constructor(Eo *eo_obj,
+_efl_divisor_interpolator_efl_object_constructor(Eo *eo_obj,
-                                                 Efl_Interpolator_Divisor_Data *pd)
+                                                 Efl_Divisor_Interpolator_Data *pd)
 {
    eo_obj = efl_constructor(efl_super(eo_obj, MY_CLASS));
 
@@ -59,4 +59,4 @@ _efl_interpolator_divisor_efl_object_constructor(Eo *eo_obj,
    return eo_obj;
 }
 
-#include "efl_interpolator_divisor.eo.c"
+#include "efl_divisor_interpolator.eo.c"

src/lib/ecore/efl_divisor_interpolator.eo

@@ -1,7 +1,7 @@
-class Efl.Interpolator_Divisor (Efl.Object, Efl.Interpolator)
+class Efl.Divisor_Interpolator (Efl.Object, Efl.Interpolator)
 {
    [[Efl divisor interpolator class]]
-   data: Efl_Interpolator_Divisor_Data;
+   data: Efl_Divisor_Interpolator_Data;
    methods {
       @property factors {
          [[Factors property]]

src/lib/ecore/efl_interpolator_accelerate.c

@@ -1,55 +0,0 @@
-#ifdef HAVE_CONFIG_H
-# include <config.h>
-#endif
-
-#include "Ecore.h"
-#include "ecore_private.h"
-
-#define MY_CLASS EFL_INTERPOLATOR_ACCELERATE_CLASS
-
-typedef struct _Efl_Interpolator_Accelerate_Data Efl_Interpolator_Accelerate_Data;
-
-struct _Efl_Interpolator_Accelerate_Data
-{
-   double factor;
-};
-
-EOLIAN static double
-_efl_interpolator_accelerate_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUSED,
-                                                          Efl_Interpolator_Accelerate_Data *pd EINA_UNUSED,
-                                                          double progress)
-{
-   if ((progress < 0.0) || (progress > 1.0))
-     return progress;
-
-   return ecore_animator_pos_map(progress, ECORE_POS_MAP_ACCELERATE_FACTOR,
-                                 pd->factor, 0);
-}
-
-EOLIAN static void
-_efl_interpolator_accelerate_factor_set(Eo *eo_obj EINA_UNUSED,
-                                        Efl_Interpolator_Accelerate_Data *pd,
-                                        double factor)
-{
-   pd->factor = factor;
-}
-
-EOLIAN static double
-_efl_interpolator_accelerate_factor_get(const Eo *eo_obj EINA_UNUSED,
-                                        Efl_Interpolator_Accelerate_Data *pd EINA_UNUSED)
-{
-   return pd->factor;
-}
-
-EOLIAN static Efl_Object *
-_efl_interpolator_accelerate_efl_object_constructor(Eo *eo_obj,
-                                                    Efl_Interpolator_Accelerate_Data *pd)
-{
-   eo_obj = efl_constructor(efl_super(eo_obj, MY_CLASS));
-
-   pd->factor = 1.0;
-
-   return eo_obj;
-}
-
-#include "efl_interpolator_accelerate.eo.c"

src/lib/ecore/efl_interpolator_decelerate.c

@@ -1,55 +0,0 @@
-#ifdef HAVE_CONFIG_H
-# include <config.h>
-#endif
-
-#include "Ecore.h"
-#include "ecore_private.h"
-
-#define MY_CLASS EFL_INTERPOLATOR_DECELERATE_CLASS
-
-typedef struct _Efl_Interpolator_Decelerate_Data Efl_Interpolator_Decelerate_Data;
-
-struct _Efl_Interpolator_Decelerate_Data
-{
-   double factor;
-};
-
-EOLIAN static double
-_efl_interpolator_decelerate_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUSED,
-                                                          Efl_Interpolator_Decelerate_Data *pd EINA_UNUSED,
-                                                          double progress)
-{
-   if ((progress < 0.0) || (progress > 1.0))
-     return progress;
-
-   return ecore_animator_pos_map(progress, ECORE_POS_MAP_DECELERATE_FACTOR,
-                                 pd->factor, 0);
-}
-
-EOLIAN static void
-_efl_interpolator_decelerate_factor_set(Eo *eo_obj EINA_UNUSED,
-                                        Efl_Interpolator_Decelerate_Data *pd,
-                                        double factor)
-{
-   pd->factor = factor;
-}
-
-EOLIAN static double
-_efl_interpolator_decelerate_factor_get(const Eo *eo_obj EINA_UNUSED,
-                                        Efl_Interpolator_Decelerate_Data *pd EINA_UNUSED)
-{
-   return pd->factor;
-}
-
-EOLIAN static Efl_Object *
-_efl_interpolator_decelerate_efl_object_constructor(Eo *eo_obj,
-                                                    Efl_Interpolator_Decelerate_Data *pd)
-{
-   eo_obj = efl_constructor(efl_super(eo_obj, MY_CLASS));
-
-   pd->factor = 1.0;
-
-   return eo_obj;
-}
-
-#include "efl_interpolator_decelerate.eo.c"

src/lib/ecore/efl_interpolator_linear.c

@@ -1,27 +0,0 @@
-#ifdef HAVE_CONFIG_H
-# include <config.h>
-#endif
-
-#include "Ecore.h"
-#include "ecore_private.h"
-
-#define MY_CLASS EFL_INTERPOLATOR_LINEAR_CLASS
-
-typedef struct _Efl_Interpolator_Linear_Data Efl_Interpolator_Linear_Data;
-
-struct _Efl_Interpolator_Linear_Data
-{
-};
-
-EOLIAN static double
-_efl_interpolator_linear_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUSED,
-                                                      Efl_Interpolator_Linear_Data *pd EINA_UNUSED,
-                                                      double progress)
-{
-   if ((progress < 0.0) || (progress > 1.0))
-     return progress;
-
-   return ecore_animator_pos_map(progress, ECORE_POS_MAP_LINEAR, 0, 0);
-}
-
-#include "efl_interpolator_linear.eo.c"

src/lib/ecore/efl_interpolator_linear.eo

@@ -1,8 +0,0 @@
-class Efl.Interpolator_Linear (Efl.Object, Efl.Interpolator)
-{
-   [[Efl linear interpolator class]]
-   data: Efl_Interpolator_Linear_Data;
-   implements {
-      Efl.Interpolator.interpolate;
-   }
-}

src/lib/ecore/efl_interpolator_sinusoidal.c

@@ -1,55 +0,0 @@
-#ifdef HAVE_CONFIG_H
-# include <config.h>
-#endif
-
-#include "Ecore.h"
-#include "ecore_private.h"
-
-#define MY_CLASS EFL_INTERPOLATOR_SINUSOIDAL_CLASS
-
-typedef struct _Efl_Interpolator_Sinusoidal_Data Efl_Interpolator_Sinusoidal_Data;
-
-struct _Efl_Interpolator_Sinusoidal_Data
-{
-   double factor;
-};
-
-EOLIAN static double
-_efl_interpolator_sinusoidal_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUSED,
-                                                          Efl_Interpolator_Sinusoidal_Data *pd EINA_UNUSED,
-                                                          double progress)
-{
-   if ((progress < 0.0) || (progress > 1.0))
-     return progress;
-
-   return ecore_animator_pos_map(progress, ECORE_POS_MAP_SINUSOIDAL_FACTOR,
-                                 pd->factor, 0);
-}
-
-EOLIAN static void
-_efl_interpolator_sinusoidal_factor_set(Eo *eo_obj EINA_UNUSED,
-                                        Efl_Interpolator_Sinusoidal_Data *pd,
-                                        double factor)
-{
-   pd->factor = factor;
-}
-
-EOLIAN static double
-_efl_interpolator_sinusoidal_factor_get(const Eo *eo_obj EINA_UNUSED,
-                                        Efl_Interpolator_Sinusoidal_Data *pd EINA_UNUSED)
-{
-   return pd->factor;
-}
-
-EOLIAN static Efl_Object *
-_efl_interpolator_sinusoidal_efl_object_constructor(Eo *eo_obj,
-                                                    Efl_Interpolator_Sinusoidal_Data *pd)
-{
-   eo_obj = efl_constructor(efl_super(eo_obj, MY_CLASS));
-
-   pd->factor = 1.0;
-
-   return eo_obj;
-}
-
-#include "efl_interpolator_sinusoidal.eo.c"

src/lib/ecore/efl_linear_interpolator.c

@@ -0,0 +1,27 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "Ecore.h"
+#include "ecore_private.h"
+
+#define MY_CLASS EFL_LINEAR_INTERPOLATOR_CLASS
+
+typedef struct _Efl_Linear_Interpolator_Data Efl_Linear_Interpolator_Data;
+
+struct _Efl_Linear_Interpolator_Data
+{
+};
+
+EOLIAN static double
+_efl_linear_interpolator_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUSED,
+                                                      Efl_Linear_Interpolator_Data *pd EINA_UNUSED,
+                                                      double progress)
+{
+   if ((progress < 0.0) || (progress > 1.0))
+     return progress;
+
+   return ecore_animator_pos_map(progress, ECORE_POS_MAP_LINEAR, 0, 0);
+}
+
+#include "efl_linear_interpolator.eo.c"

src/lib/ecore/efl_linear_interpolator.eo

@@ -0,0 +1,8 @@
+class Efl.Linear_Interpolator (Efl.Object, Efl.Interpolator)
+{
+   [[Efl linear interpolator class]]
+   data: Efl_Linear_Interpolator_Data;
+   implements {
+      Efl.Interpolator.interpolate;
+   }
+}

src/lib/ecore/efl_sinusoidal_interpolator.c

@@ -0,0 +1,55 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "Ecore.h"
+#include "ecore_private.h"
+
+#define MY_CLASS EFL_SINUSOIDAL_INTERPOLATOR_CLASS
+
+typedef struct _Efl_Sinusoidal_Interpolator_Data Efl_Sinusoidal_Interpolator_Data;
+
+struct _Efl_Sinusoidal_Interpolator_Data
+{
+   double factor;
+};
+
+EOLIAN static double
+_efl_sinusoidal_interpolator_efl_interpolator_interpolate(Eo *eo_obj EINA_UNUSED,
+                                                          Efl_Sinusoidal_Interpolator_Data *pd EINA_UNUSED,
+                                                          double progress)
+{
+   if ((progress < 0.0) || (progress > 1.0))
+     return progress;
+
+   return ecore_animator_pos_map(progress, ECORE_POS_MAP_SINUSOIDAL_FACTOR,
+                                 pd->factor, 0);
+}
+
+EOLIAN static void
+_efl_sinusoidal_interpolator_factor_set(Eo *eo_obj EINA_UNUSED,
+                                        Efl_Sinusoidal_Interpolator_Data *pd,
+                                        double factor)
+{
+   pd->factor = factor;
+}
+
+EOLIAN static double
+_efl_sinusoidal_interpolator_factor_get(const Eo *eo_obj EINA_UNUSED,
+                                        Efl_Sinusoidal_Interpolator_Data *pd EINA_UNUSED)
+{
+   return pd->factor;
+}
+
+EOLIAN static Efl_Object *
+_efl_sinusoidal_interpolator_efl_object_constructor(Eo *eo_obj,
+                                                    Efl_Sinusoidal_Interpolator_Data *pd)
+{
+   eo_obj = efl_constructor(efl_super(eo_obj, MY_CLASS));
+
+   pd->factor = 1.0;
+
+   return eo_obj;
+}
+
+#include "efl_sinusoidal_interpolator.eo.c"

src/lib/ecore/efl_sinusoidal_interpolator.eo

@@ -1,10 +1,10 @@
-class Efl.Interpolator_Sinusoidal (Efl.Object, Efl.Interpolator)
+class Efl.Sinusoidal_Interpolator (Efl.Object, Efl.Interpolator)
 {
    [[Efl sinusoidal interpolator class
 
      output = (1 - cos(input * Pi)) / 2;
    ]]
-   data: Efl_Interpolator_Sinusoidal_Data;
+   data: Efl_Sinusoidal_Interpolator_Data;
    methods {
       @property factor {
          [[Factor property]]

src/lib/ecore/efl_spring_interpolator.c

@@ -5,18 +5,18 @@
 #include "Ecore.h"
 #include "ecore_private.h"
 
-#define MY_CLASS EFL_INTERPOLATOR_SPRING_CLASS
+#define MY_CLASS EFL_SPRING_INTERPOLATOR_CLASS
 
-typedef struct _Efl_Interpolator_Spring_Data Efl_Interpolator_Spring_Data;
+typedef struct _Efl_Spring_Interpolator_Data Efl_Spring_Interpolator_Data;
 
-struct _Efl_Interpolator_Spring_Data
+struct _Efl_Spring_Interpolator_Data
 {
    double factor[2];
 };
 
 EOLIAN static double
-_efl_interpolator_spring_efl_interpolator_interpolate(Eo *obj EINA_UNUSED,
+_efl_spring_interpolator_efl_interpolator_interpolate(Eo *obj EINA_UNUSED,
-                                                      Efl_Interpolator_Spring_Data *pd EINA_UNUSED,
+                                                      Efl_Spring_Interpolator_Data *pd EINA_UNUSED,
                                                       double progress)
 {
    if ((progress < 0.0) || (progress > 1.0))
@@ -27,8 +27,8 @@ _efl_interpolator_spring_efl_interpolator_interpolate(Eo *obj EINA_UNUSED,
 }
 
 EOLIAN static void
-_efl_interpolator_spring_factors_set(Eo *eo_obj EINA_UNUSED,
+_efl_spring_interpolator_factors_set(Eo *eo_obj EINA_UNUSED,
-                                     Efl_Interpolator_Spring_Data *pd,
+                                     Efl_Spring_Interpolator_Data *pd,
                                      double factor1, double factor2)
 {
    pd->factor[0] = factor1;
@@ -36,8 +36,8 @@ _efl_interpolator_spring_factors_set(Eo *eo_obj EINA_UNUSED,
 }
 
 EOLIAN static void
-_efl_interpolator_spring_factors_get(const Eo *eo_obj EINA_UNUSED,
+_efl_spring_interpolator_factors_get(const Eo *eo_obj EINA_UNUSED,
-                                     Efl_Interpolator_Spring_Data *pd,
+                                     Efl_Spring_Interpolator_Data *pd,
                                      double *factor1, double *factor2)
 {
    if (factor1)
@@ -48,8 +48,8 @@ _efl_interpolator_spring_factors_get(const Eo *eo_obj EINA_UNUSED,
 }
 
 EOLIAN static Efl_Object *
-_efl_interpolator_spring_efl_object_constructor(Eo *eo_obj,
+_efl_spring_interpolator_efl_object_constructor(Eo *eo_obj,
-                                                Efl_Interpolator_Spring_Data *pd)
+                                                Efl_Spring_Interpolator_Data *pd)
 {
    eo_obj = efl_constructor(efl_super(eo_obj, MY_CLASS));
 
@@ -59,4 +59,4 @@ _efl_interpolator_spring_efl_object_constructor(Eo *eo_obj,
    return eo_obj;
 }
 
-#include "efl_interpolator_spring.eo.c"
+#include "efl_spring_interpolator.eo.c"

src/lib/ecore/efl_spring_interpolator.eo

@@ -1,7 +1,7 @@
-class Efl.Interpolator_Spring (Efl.Object, Efl.Interpolator)
+class Efl.Spring_Interpolator (Efl.Object, Efl.Interpolator)
 {
    [[Efl spring interpolator class]]
-   data: Efl_Interpolator_Spring_Data;
+   data: Efl_Spring_Interpolator_Data;
    methods {
       @property factors {
          [[Factors property]]

src/lib/ecore/meson.build

@@ -57,14 +57,14 @@ pub_eo_files = [
   'efl_io_file.eo',
   'efl_io_copier.eo',
   'efl_io_buffered_stream.eo',
-  'efl_interpolator_linear.eo',
+  'efl_linear_interpolator.eo',
-  'efl_interpolator_accelerate.eo',
+  'efl_accelerate_interpolator.eo',
-  'efl_interpolator_decelerate.eo',
+  'efl_decelerate_interpolator.eo',
-  'efl_interpolator_sinusoidal.eo',
+  'efl_sinusoidal_interpolator.eo',
-  'efl_interpolator_divisor.eo',
+  'efl_divisor_interpolator.eo',
-  'efl_interpolator_bounce.eo',
+  'efl_bounce_interpolator.eo',
-  'efl_interpolator_spring.eo',
+  'efl_spring_interpolator.eo',
-  'efl_interpolator_cubic_bezier.eo',
+  'efl_cubic_bezier_interpolator.eo',
   'efl_loop_message_future_handler.eo',
   'efl_loop_message_future.eo',
   'efl_model_item.eo',
@@ -153,14 +153,14 @@ ecore_src = [
   'efl_model_composite_selection.c',
   'efl_model_accessor_view.c',
   'efl_model_accessor_view_private.h',
-  'efl_interpolator_linear.c',
+  'efl_linear_interpolator.c',
-  'efl_interpolator_accelerate.c',
+  'efl_accelerate_interpolator.c',
-  'efl_interpolator_decelerate.c',
+  'efl_decelerate_interpolator.c',
-  'efl_interpolator_sinusoidal.c',
+  'efl_sinusoidal_interpolator.c',
-  'efl_interpolator_divisor.c',
+  'efl_divisor_interpolator.c',
-  'efl_interpolator_bounce.c',
+  'efl_bounce_interpolator.c',
-  'efl_interpolator_spring.c',
+  'efl_spring_interpolator.c',
-  'efl_interpolator_cubic_bezier.c',
+  'efl_cubic_bezier_interpolator.c',
   'ecore_main_timechanges.c',
   'ecore_pipe.c',
   'ecore_poller.c',