cedric pushed a commit to branch master.

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

commit 93af61f25593410110046f62281d0e60c60d5e0b
Author: Cedric BAIL <ced...@osg.samsung.com>
Date:   Tue May 3 14:42:20 2016 -0700

    ecore: rename ecore_timer to efl_timer.
---
 src/Makefile_Ecore.am                          |   2 +-
 src/lib/ecore/Ecore_Eo.h                       |   2 +-
 src/lib/ecore/Ecore_Legacy.h                   |   2 +-
 src/lib/ecore/Makefile.am                      |   2 +-
 src/lib/ecore/ecore.c                          |   2 +-
 src/lib/ecore/ecore_main.c                     |  60 +++----
 src/lib/ecore/ecore_private.h                  |  22 +--
 src/lib/ecore/ecore_timer.c                    | 206 ++++++++++++-------------
 src/lib/ecore/{ecore_timer.eo => efl_timer.eo} |   4 +-
 9 files changed, 151 insertions(+), 151 deletions(-)

diff --git a/src/Makefile_Ecore.am b/src/Makefile_Ecore.am
index 2eefeaa..b48d49f 100644
--- a/src/Makefile_Ecore.am
+++ b/src/Makefile_Ecore.am
@@ -2,7 +2,7 @@
 ### Library
 
 ecore_eolian_files_legacy = \
-       lib/ecore/ecore_timer.eo \
+       lib/ecore/efl_timer.eo \
        lib/ecore/ecore_poller.eo \
        lib/ecore/ecore_exe.eo \
        lib/ecore/ecore_animator.eo
diff --git a/src/lib/ecore/Ecore_Eo.h b/src/lib/ecore/Ecore_Eo.h
index edd352a..9db6e79 100644
--- a/src/lib/ecore/Ecore_Eo.h
+++ b/src/lib/ecore/Ecore_Eo.h
@@ -35,7 +35,7 @@ extern "C" {
  * @{
  */
 
-#include "ecore_timer.eo.h"
+#include "efl_timer.eo.h"
 
 /**
  * @}
diff --git a/src/lib/ecore/Ecore_Legacy.h b/src/lib/ecore/Ecore_Legacy.h
index 4c5145c..80626de 100644
--- a/src/lib/ecore/Ecore_Legacy.h
+++ b/src/lib/ecore/Ecore_Legacy.h
@@ -235,7 +235,7 @@ EAPI Eina_Bool ecore_timer_freeze_get(Ecore_Timer *timer);
 
 EAPI void ecore_timer_thaw(Ecore_Timer *timer);
 
-#include "ecore_timer.eo.legacy.h"
+#include "efl_timer.eo.legacy.h"
 
 /**
  * @}
diff --git a/src/lib/ecore/Makefile.am b/src/lib/ecore/Makefile.am
index 73eed3e..5abf8d8 100644
--- a/src/lib/ecore/Makefile.am
+++ b/src/lib/ecore/Makefile.am
@@ -5,7 +5,7 @@ include ../../Makefile_Eolian_Subbuild_Helper.am
 ### Library
 
 ecore_eolian_files_legacy = \
-       ecore_timer.eo \
+       efl_timer.eo \
        ecore_poller.eo \
        ecore_job.eo \
        ecore_exe.eo \
diff --git a/src/lib/ecore/ecore.c b/src/lib/ecore/ecore.c
index 758cd02..e403a0d 100644
--- a/src/lib/ecore/ecore.c
+++ b/src/lib/ecore/ecore.c
@@ -404,7 +404,7 @@ ecore_shutdown(void)
 #ifndef HAVE_EXOTIC
      _ecore_exe_shutdown();
 #endif
-     _ecore_timer_shutdown();
+     _efl_timer_shutdown();
      _ecore_event_shutdown();
      _ecore_main_shutdown();
      _ecore_signal_shutdown();
diff --git a/src/lib/ecore/ecore_main.c b/src/lib/ecore/ecore_main.c
index ad838be..394fd17 100644
--- a/src/lib/ecore/ecore_main.c
+++ b/src/lib/ecore/ecore_main.c
@@ -460,8 +460,8 @@ _ecore_main_uv_poll_cb(uv_poll_t* handle, int status, int 
events)
   _ecore_signal_received_process();
   _ecore_event_call();
   _ecore_main_fd_handlers_cleanup();
-  _ecore_timer_expired_timers_call(_ecore_time_loop_time);
-  _ecore_timer_cleanup();
+  _efl_timer_expired_timers_call(_ecore_time_loop_time);
+  _efl_timer_cleanup();
 }
 
 static int
@@ -705,8 +705,8 @@ _ecore_main_gsource_prepare(GSource *source EINA_UNUSED,
    if (!ecore_idling && !_ecore_glib_idle_enterer_called)
      {
         _ecore_time_loop_time = ecore_time_get();
-        _ecore_timer_expired_timers_call(_ecore_time_loop_time);
-        _ecore_timer_cleanup();
+        _efl_timer_expired_timers_call(_ecore_time_loop_time);
+        _efl_timer_cleanup();
 
         _ecore_idle_enterer_call(_mainloop_singleton);
         _ecore_throttle();
@@ -724,10 +724,10 @@ _ecore_main_gsource_prepare(GSource *source EINA_UNUSED,
         /* only set idling state in dispatch */
          if (ecore_idling && !_ecore_idler_exist(_mainloop_singleton) && 
!_ecore_event_exist())
            {
-              if (_ecore_timers_exists())
+              if (_efl_timers_exists())
                 {
                    int r = -1;
-                   double t = _ecore_timer_next_get();
+                   double t = _efl_timer_next_get();
                    if (timer_fd >= 0 && t > 0.0)
                      {
                         struct itimerspec ts;
@@ -823,8 +823,8 @@ _ecore_main_gsource_check(GSource *source EINA_UNUSED)
      ret = TRUE;
 
    /* check timers after updating loop time */
-   if (!ret && _ecore_timers_exists())
-     ret = (0.0 == _ecore_timer_next_get());
+   if (!ret && _efl_timers_exists())
+     ret = (0.0 == _efl_timer_next_get());
 
    in_main_loop--;
 
@@ -841,11 +841,11 @@ _ecore_main_gsource_dispatch(GSource    *source 
EINA_UNUSED,
    double next_time;
 
    _ecore_time_loop_time = ecore_time_get();
-   _ecore_timer_enable_new();
-   next_time = _ecore_timer_next_get();
+   _efl_timer_enable_new();
+   next_time = _efl_timer_next_get();
 
    events_ready = _ecore_event_exist();
-   timers_ready = _ecore_timers_exists() && (0.0 == next_time);
+   timers_ready = _efl_timers_exists() && (0.0 == next_time);
    idlers_ready = _ecore_idler_exist(_mainloop_singleton);
 
    in_main_loop++;
@@ -888,8 +888,8 @@ _ecore_main_gsource_dispatch(GSource    *source EINA_UNUSED,
         _ecore_event_call();
         _ecore_main_fd_handlers_cleanup();
 
-        _ecore_timer_expired_timers_call(_ecore_time_loop_time);
-        _ecore_timer_cleanup();
+        _efl_timer_expired_timers_call(_ecore_time_loop_time);
+        _efl_timer_cleanup();
 
         _ecore_idle_enterer_call(_mainloop_singleton);
         _ecore_throttle();
@@ -1022,8 +1022,8 @@ _ecore_main_loop_uv_check(uv_check_t* handle EINA_UNUSED)
        _ecore_signal_received_process();
        _ecore_event_call();
        _ecore_main_fd_handlers_cleanup();
-       _ecore_timer_expired_timers_call(_ecore_time_loop_time);
-       _ecore_timer_cleanup();
+       _efl_timer_expired_timers_call(_ecore_time_loop_time);
+       _efl_timer_cleanup();
      }
    while(fd_handlers_to_call);
 quit:
@@ -2112,7 +2112,7 @@ _ecore_main_loop_uv_prepare(uv_prepare_t* handle 
EINA_UNUSED)
        t = -1;
 
        _ecore_time_loop_time = ecore_time_get();
-       _ecore_timer_enable_new();
+       _efl_timer_enable_new();
 
        goto done;
      }
@@ -2120,10 +2120,10 @@ _ecore_main_loop_uv_prepare(uv_prepare_t* handle 
EINA_UNUSED)
    assert(!fd_handlers_to_call);
 
    _ecore_time_loop_time = ecore_time_get();
-   _ecore_timer_enable_new();
-   if (_ecore_timers_exists() || t >= 0)
+   _efl_timer_enable_new();
+   if (_efl_timers_exists() || t >= 0)
      {
-       double t1 = _ecore_timer_next_get();
+       double t1 = _efl_timer_next_get();
        if(t < 0 || (t1 >= 0 && t1 < t)) t = t1;
        DBG("Should awake after %f", t);
        
@@ -2183,7 +2183,7 @@ _ecore_main_loop_spin_no_timers(void)
           if (action != SPIN_MORE) return action;
           /* if an idler has added a timer then we need to go through
            * the start of the spin cycle again to handle cases properly */
-          if (_ecore_timers_exists()) return SPIN_RESTART;
+          if (_efl_timers_exists()) return SPIN_RESTART;
        }
      /* just contiune handling events etc. */
      return LOOP_CONTINUE;
@@ -2201,7 +2201,7 @@ _ecore_main_loop_spin_timers(void)
           /* if next timer expires now or in the past - stop spinning and
            * continue the mainloop walk as our "select" timeout has
            * expired now */
-          if (_ecore_timer_next_get() <= 0.0) return LOOP_CONTINUE;
+          if (_efl_timer_next_get() <= 0.0) return LOOP_CONTINUE;
        }
      /* just contiune handling events etc. */
      return LOOP_CONTINUE;
@@ -2229,8 +2229,8 @@ _ecore_main_loop_iterate_internal(int once_only)
 
    in_main_loop++;
    /* expire any timers */
-   _ecore_timer_expired_timers_call(_ecore_time_loop_time);
-   _ecore_timer_cleanup();
+   _efl_timer_expired_timers_call(_ecore_time_loop_time);
+   _efl_timer_cleanup();
 
    /* process signals into events .... */
    _ecore_signal_received_process();
@@ -2244,7 +2244,7 @@ _ecore_main_loop_iterate_internal(int once_only)
         /* now quickly poll to see which input fd's are active */
         _ecore_main_select(0.0);
         /* allow newly queued timers to expire from now on */
-        _ecore_timer_enable_new();
+        _efl_timer_enable_new();
         /* go straight to processing the events we had queued */
         goto process_all;
      }
@@ -2257,7 +2257,7 @@ _ecore_main_loop_iterate_internal(int once_only)
          * merged together */
         if (_ecore_main_select(0.0) | _ecore_signal_count_get())
           {
-             _ecore_timer_enable_new();
+             _efl_timer_enable_new();
              goto process_all;
           }
      }
@@ -2277,7 +2277,7 @@ _ecore_main_loop_iterate_internal(int once_only)
    if (_ecore_event_exist())
      {
         _ecore_main_select(0.0);
-        _ecore_timer_enable_new();
+        _efl_timer_enable_new();
         goto process_all;
      }
 
@@ -2286,7 +2286,7 @@ _ecore_main_loop_iterate_internal(int once_only)
         /* in once_only mode enter idle here instead and then return */
         _ecore_idle_enterer_call(_mainloop_singleton);
         _ecore_throttle();
-        _ecore_timer_enable_new();
+        _efl_timer_enable_new();
         goto done;
      }
 
@@ -2295,17 +2295,17 @@ _ecore_main_loop_iterate_internal(int once_only)
    /* start of the sleeping or looping section */
 start_loop: /*-*************************************************************/
    /* any timers re-added as a result of these are allowed to go */
-   _ecore_timer_enable_new();
+   _efl_timer_enable_new();
    /* if we have been asked to quit the mainloop then exit at this point */
    if (do_quit)
      {
-        _ecore_timer_enable_new();
+        _efl_timer_enable_new();
         goto done;
      }
    if (!_ecore_event_exist())
      {
         /* init flags */
-        next_time = _ecore_timer_next_get();
+        next_time = _efl_timer_next_get();
         /* no idlers */
         if (!_ecore_idler_exist(_mainloop_singleton))
           {
diff --git a/src/lib/ecore/ecore_private.h b/src/lib/ecore/ecore_private.h
index 7b47e2b..bba1361 100644
--- a/src/lib/ecore/ecore_private.h
+++ b/src/lib/ecore/ecore_private.h
@@ -158,20 +158,20 @@ EAPI void _ecore_magic_fail(const void *d,
 
 void         _ecore_time_init(void);
 
-Ecore_Timer *_ecore_timer_loop_add(double in,
+Ecore_Timer *_efl_timer_loop_add(double in,
                                    Ecore_Task_Cb func,
                                    const void *data);
-void        *_ecore_timer_del(Ecore_Timer *timer);
-void         _ecore_timer_util_delay(Ecore_Timer *timer,
+void        *_efl_timer_del(Ecore_Timer *timer);
+void         _efl_timer_util_delay(Ecore_Timer *timer,
                                 double add);
-void         _ecore_timer_shutdown(void);
-void         _ecore_timer_cleanup(void);
-void         _ecore_timer_enable_new(void);
-double       _ecore_timer_next_get(void);
-void         _ecore_timer_expired_timers_call(double when);
-int          _ecore_timers_exists(void);
-
-int          _ecore_timer_expired_call(double when);
+void         _efl_timer_shutdown(void);
+void         _efl_timer_cleanup(void);
+void         _efl_timer_enable_new(void);
+double       _efl_timer_next_get(void);
+void         _efl_timer_expired_timers_call(double when);
+int          _efl_timers_exists(void);
+
+int          _efl_timer_expired_call(double when);
 
 Ecore_Factorized_Idle *_ecore_factorized_idle_add(const 
Eo_Callback_Array_Item*desc,
                                                   Ecore_Task_Cb func,
diff --git a/src/lib/ecore/ecore_timer.c b/src/lib/ecore/ecore_timer.c
index 89823e2..d65fdd6 100644
--- a/src/lib/ecore/ecore_timer.c
+++ b/src/lib/ecore/ecore_timer.c
@@ -10,11 +10,11 @@
 #include "Ecore.h"
 #include "ecore_private.h"
 
-#define MY_CLASS ECORE_TIMER_CLASS
-#define MY_CLASS_NAME "Ecore_Timer"
+#define MY_CLASS EFL_TIMER_CLASS
+#define MY_CLASS_NAME "Efl_Timer"
 
 #define ECORE_TIMER_CHECK(obj)                       \
-  if (!eo_isa((obj), ECORE_TIMER_CLASS)) \
+  if (!eo_isa((obj), MY_CLASS)) \
     return
 
 #ifdef WANT_ECORE_TIMER_DUMP
@@ -24,7 +24,7 @@
 typedef void (*Ecore_Timer_Bt_Func)();
 #endif
 
-struct _Ecore_Timer_Data
+struct _Efl_Timer_Data
 {
    EINA_INLIST;
    Ecore_Timer         *obj;
@@ -45,23 +45,23 @@ struct _Ecore_Timer_Data
    unsigned char       frozen : 1;
 };
 
-typedef struct _Ecore_Timer_Data Ecore_Timer_Data;
+typedef struct _Efl_Timer_Data Efl_Timer_Data;
 
-static void _ecore_timer_set(Ecore_Timer *timer,
+static void _efl_timer_set(Ecore_Timer *timer,
                              double        at,
                              double        in,
                              Ecore_Task_Cb func,
                              void         *data);
 #ifdef WANT_ECORE_TIMER_DUMP
-static int _ecore_timer_cmp(const void *d1,
+static int _efl_timer_cmp(const void *d1,
                             const void *d2);
 #endif
 
 static int timers_added = 0;
 static int timers_delete_me = 0;
-static Ecore_Timer_Data *timers = NULL;
-static Ecore_Timer_Data *timer_current = NULL;
-static Ecore_Timer_Data *suspended = NULL;
+static Efl_Timer_Data *timers = NULL;
+static Efl_Timer_Data *timer_current = NULL;
+static Efl_Timer_Data *suspended = NULL;
 static double last_check = 0.0;
 static double precision = 10.0 / 1000000.0;
 
@@ -93,13 +93,13 @@ ecore_timer_add(double        in,
    Ecore_Timer *timer = NULL;
 
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   timer = eo_add(MY_CLASS, _ecore_parent, 
ecore_obj_timer_constructor(eo_self, in, func, data));
+   timer = eo_add(MY_CLASS, _ecore_parent, efl_timer_constructor(eo_self, in, 
func, data));
    return timer;
 }
 
 static Eina_Bool
-_ecore_timer_add(Ecore_Timer *obj,
-                 Ecore_Timer_Data *timer,
+_efl_timer_add(Ecore_Timer *obj,
+                 Efl_Timer_Data *timer,
                  double now,
                  double in,
                  Ecore_Task_Cb func,
@@ -126,28 +126,28 @@ _ecore_timer_add(Ecore_Timer *obj,
    timer->timer_bt_num = backtrace((void **)(timer->timer_bt),
                                    ECORE_TIMER_DEBUG_BT_NUM);
 #endif
-   _ecore_timer_set(obj, now + in, in, func, (void *)data);
+   _efl_timer_set(obj, now + in, in, func, (void *)data);
    return EINA_TRUE;
 }
 
 EOLIAN static void
-_ecore_timer_constructor(Eo *obj, Ecore_Timer_Data *timer, double in, 
Ecore_Task_Cb func, const void *data)
+_efl_timer_constructor(Eo *obj, Efl_Timer_Data *timer, double in, 
Ecore_Task_Cb func, const void *data)
 {
    double now;
 
    now = ecore_time_get();
 
-   _ecore_timer_add(obj, timer, now, in, func, data);
+   _efl_timer_add(obj, timer, now, in, func, data);
 }
 
 EOLIAN static void
-_ecore_timer_loop_constructor(Eo *obj, Ecore_Timer_Data *timer, double in, 
Ecore_Task_Cb func, const void *data)
+_efl_timer_loop_constructor(Eo *obj, Efl_Timer_Data *timer, double in, 
Ecore_Task_Cb func, const void *data)
 {
    double now;
 
    now = ecore_loop_time_get();
 
-   _ecore_timer_add(obj, timer, now, in, func, data);
+   _efl_timer_add(obj, timer, now, in, func, data);
 }
 
 EAPI Ecore_Timer *
@@ -155,7 +155,7 @@ ecore_timer_loop_add(double        in,
                      Ecore_Task_Cb func,
                      const void   *data)
 {
-   return _ecore_timer_loop_add(in, func, data);
+   return _efl_timer_loop_add(in, func, data);
 }
 
 EAPI void *
@@ -164,11 +164,11 @@ ecore_timer_del(Ecore_Timer *timer)
    if (!timer) return NULL;
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
 
-   return _ecore_timer_del(timer);
+   return _efl_timer_del(timer);
 }
 
 EOLIAN static void
-_ecore_timer_interval_set(Eo *obj EINA_UNUSED, Ecore_Timer_Data *timer, double 
in)
+_efl_timer_interval_set(Eo *obj EINA_UNUSED, Efl_Timer_Data *timer, double in)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
    if (in < 0.0) in = 0.0;
@@ -177,7 +177,7 @@ _ecore_timer_interval_set(Eo *obj EINA_UNUSED, 
Ecore_Timer_Data *timer, double i
 }
 
 EOLIAN static double
-_ecore_timer_interval_get(Eo *obj EINA_UNUSED, Ecore_Timer_Data *timer)
+_efl_timer_interval_get(Eo *obj EINA_UNUSED, Efl_Timer_Data *timer)
 {
    double ret = -1.0;
 
@@ -188,15 +188,15 @@ _ecore_timer_interval_get(Eo *obj EINA_UNUSED, 
Ecore_Timer_Data *timer)
 }
 
 EOLIAN static void
-_ecore_timer_delay(Eo *obj, Ecore_Timer_Data *_pd EINA_UNUSED, double add)
+_efl_timer_delay(Eo *obj, Efl_Timer_Data *_pd EINA_UNUSED, double add)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
 
-   _ecore_timer_util_delay(obj, add);
+   _efl_timer_util_delay(obj, add);
 }
 
 EOLIAN static void
-_ecore_timer_reset(Eo *obj, Ecore_Timer_Data *timer)
+_efl_timer_reset(Eo *obj, Efl_Timer_Data *timer)
 {
    double now, add;
    EINA_MAIN_LOOP_CHECK_RETURN;
@@ -207,11 +207,11 @@ _ecore_timer_reset(Eo *obj, Ecore_Timer_Data *timer)
      add = timer->pending;
    else
      add = timer->at - now;
-   _ecore_timer_util_delay(obj, timer->in - add);
+   _efl_timer_util_delay(obj, timer->in - add);
 }
 
 EOLIAN static double
-_ecore_timer_pending_get(Eo *obj EINA_UNUSED, Ecore_Timer_Data *timer)
+_efl_timer_pending_get(Eo *obj EINA_UNUSED, Efl_Timer_Data *timer)
 {
    double now;
    double ret = 0.0;
@@ -236,7 +236,7 @@ ecore_timer_freeze(Ecore_Timer *timer)
 }
 
 EOLIAN static void
-_ecore_timer_eo_base_event_freeze(Eo *obj EINA_UNUSED, Ecore_Timer_Data *timer)
+_efl_timer_eo_base_event_freeze(Eo *obj EINA_UNUSED, Efl_Timer_Data *timer)
 {
    double now;
 
@@ -246,8 +246,8 @@ _ecore_timer_eo_base_event_freeze(Eo *obj EINA_UNUSED, 
Ecore_Timer_Data *timer)
    if (timer->frozen)
      return;
 
-   timers = (Ecore_Timer_Data *)eina_inlist_remove(EINA_INLIST_GET(timers), 
EINA_INLIST_GET(timer));
-   suspended = (Ecore_Timer_Data 
*)eina_inlist_prepend(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
+   timers = (Efl_Timer_Data *)eina_inlist_remove(EINA_INLIST_GET(timers), 
EINA_INLIST_GET(timer));
+   suspended = (Efl_Timer_Data 
*)eina_inlist_prepend(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
 
    now = ecore_time_get();
 
@@ -266,7 +266,7 @@ ecore_timer_freeze_get(Ecore_Timer *timer)
 }
 
 EOLIAN static int
-_ecore_timer_eo_base_event_freeze_count_get(Eo *obj EINA_UNUSED, 
Ecore_Timer_Data *timer)
+_efl_timer_eo_base_event_freeze_count_get(Eo *obj EINA_UNUSED, Efl_Timer_Data 
*timer)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
 
@@ -281,7 +281,7 @@ ecore_timer_thaw(Ecore_Timer *timer)
 }
 
 EOLIAN static void
-_ecore_timer_eo_base_event_thaw(Eo *obj, Ecore_Timer_Data *timer)
+_efl_timer_eo_base_event_thaw(Eo *obj, Efl_Timer_Data *timer)
 {
    double now;
 
@@ -291,19 +291,19 @@ _ecore_timer_eo_base_event_thaw(Eo *obj, Ecore_Timer_Data 
*timer)
    if (!timer->frozen)
      return ;
 
-   suspended = (Ecore_Timer_Data 
*)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
+   suspended = (Efl_Timer_Data 
*)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
    now = ecore_time_get();
 
-   _ecore_timer_set(obj, timer->pending + now, timer->in, timer->func, 
timer->data);
+   _efl_timer_set(obj, timer->pending + now, timer->in, timer->func, 
timer->data);
 }
 
 EAPI char *
 ecore_timer_dump(void)
 {
-#ifdef WANT_ECORE_TIMER_DUMP
+#ifdef WANT_EFL_TIMER_DUMP
    Eina_Strbuf *result;
    char *out;
-   Ecore_Timer_Data *tm;
+   Efl_Timer_Data *tm;
    Eina_List *tmp = NULL;
    int living_timer = 0;
    int unknow_timer = 0;
@@ -312,7 +312,7 @@ ecore_timer_dump(void)
    result = eina_strbuf_new();
 
    EINA_INLIST_FOREACH(timers, tm)
-     tmp = eina_list_sorted_insert(tmp, _ecore_timer_cmp, tm);
+     tmp = eina_list_sorted_insert(tmp, _efl_timer_cmp, tm);
 
    EINA_LIST_FREE(tmp, tm)
      {
@@ -352,21 +352,21 @@ ecore_timer_dump(void)
 }
 
 Ecore_Timer *
-_ecore_timer_loop_add(double        in,
+_efl_timer_loop_add(double        in,
                       Ecore_Task_Cb func,
                       const void   *data)
 {
    Ecore_Timer *timer = NULL;
-   timer = eo_add(MY_CLASS, _ecore_parent, 
ecore_obj_timer_loop_constructor(eo_self, in, func, data));
+   timer = eo_add(MY_CLASS, _ecore_parent, efl_timer_loop_constructor(eo_self, 
in, func, data));
 
    return timer;
 }
 
 EAPI void
-_ecore_timer_util_delay(Ecore_Timer *obj,
+_efl_timer_util_delay(Ecore_Timer *obj,
                    double       add)
 {
-   Ecore_Timer_Data *timer = eo_data_scope_get(obj, MY_CLASS);
+   Efl_Timer_Data *timer = eo_data_scope_get(obj, MY_CLASS);
 
    if (timer->frozen)
      {
@@ -374,16 +374,16 @@ _ecore_timer_util_delay(Ecore_Timer *obj,
      }
    else
      {
-        timers = (Ecore_Timer_Data 
*)eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer));
+        timers = (Efl_Timer_Data *)eina_inlist_remove(EINA_INLIST_GET(timers), 
EINA_INLIST_GET(timer));
         eo_data_unref(obj, timer);
-        _ecore_timer_set(obj, timer->at + add, timer->in, timer->func, 
timer->data);
+        _efl_timer_set(obj, timer->at + add, timer->in, timer->func, 
timer->data);
      }
 }
 
 void *
-_ecore_timer_del(Ecore_Timer *obj)
+_efl_timer_del(Ecore_Timer *obj)
 {
-   Ecore_Timer_Data *timer = eo_data_scope_get(obj, MY_CLASS);
+   Efl_Timer_Data *timer = eo_data_scope_get(obj, MY_CLASS);
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(timer, NULL);
 
@@ -392,7 +392,7 @@ _ecore_timer_del(Ecore_Timer *obj)
         void *data = timer->data;
 
         eo_data_unref(obj, timer);
-        suspended = (Ecore_Timer_Data 
*)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
+        suspended = (Efl_Timer_Data 
*)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
 
         if (timer->delete_me)
           timers_delete_me--;
@@ -413,7 +413,7 @@ _ecore_timer_del(Ecore_Timer *obj)
 }
 
 EOLIAN static void
-_ecore_timer_eo_base_destructor(Eo *obj, Ecore_Timer_Data *pd)
+_efl_timer_eo_base_destructor(Eo *obj, Efl_Timer_Data *pd)
 {
    if (!pd->delete_me)
    {
@@ -425,7 +425,7 @@ _ecore_timer_eo_base_destructor(Eo *obj, Ecore_Timer_Data 
*pd)
 }
 
 EOLIAN static Eo *
-_ecore_timer_eo_base_finalize(Eo *obj, Ecore_Timer_Data *pd)
+_efl_timer_eo_base_finalize(Eo *obj, Efl_Timer_Data *pd)
 {
    if (!pd->func)
    {
@@ -436,13 +436,13 @@ _ecore_timer_eo_base_finalize(Eo *obj, Ecore_Timer_Data 
*pd)
 }
 
 void
-_ecore_timer_shutdown(void)
+_efl_timer_shutdown(void)
 {
-   Ecore_Timer_Data *timer;
+   Efl_Timer_Data *timer;
 
    while ((timer = timers))
      {
-        timers = (Ecore_Timer_Data 
*)eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timers));
+        timers = (Efl_Timer_Data *)eina_inlist_remove(EINA_INLIST_GET(timers), 
EINA_INLIST_GET(timers));
 
         eo_data_unref(timer->obj, timer);
         eo_parent_set(timer->obj, NULL);
@@ -454,7 +454,7 @@ _ecore_timer_shutdown(void)
 
    while ((timer = suspended))
      {
-        suspended = (Ecore_Timer_Data 
*)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(suspended));
+        suspended = (Efl_Timer_Data 
*)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(suspended));
 
         eo_data_unref(timer->obj, timer);
         eo_parent_set(timer->obj, NULL);
@@ -468,17 +468,17 @@ _ecore_timer_shutdown(void)
 }
 
 void
-_ecore_timer_cleanup(void)
+_efl_timer_cleanup(void)
 {
-   Ecore_Timer_Data *l;
+   Efl_Timer_Data *l;
    int in_use = 0, todo = timers_delete_me, done = 0;
 
    if (!timers_delete_me) return;
    for (l = timers; l; )
      {
-        Ecore_Timer_Data *timer = l;
+        Efl_Timer_Data *timer = l;
 
-        l = (Ecore_Timer_Data *)EINA_INLIST_GET(l)->next;
+        l = (Efl_Timer_Data *)EINA_INLIST_GET(l)->next;
         if (timer->delete_me)
           {
              if (timer->references)
@@ -486,7 +486,7 @@ _ecore_timer_cleanup(void)
                   in_use++;
                   continue;
                }
-             timers = (Ecore_Timer_Data 
*)eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer));
+             timers = (Efl_Timer_Data 
*)eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer));
 
              eo_data_unref(timer->obj, timer);
              eo_parent_set(timer->obj, NULL);
@@ -501,9 +501,9 @@ _ecore_timer_cleanup(void)
      }
    for (l = suspended; l; )
      {
-        Ecore_Timer_Data *timer = l;
+        Efl_Timer_Data *timer = l;
 
-        l = (Ecore_Timer_Data *)EINA_INLIST_GET(l)->next;
+        l = (Efl_Timer_Data *)EINA_INLIST_GET(l)->next;
         if (timer->delete_me)
           {
              if (timer->references)
@@ -511,7 +511,7 @@ _ecore_timer_cleanup(void)
                   in_use++;
                   continue;
                }
-             suspended = (Ecore_Timer_Data 
*)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
+             suspended = (Efl_Timer_Data 
*)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
 
              eo_data_unref(timer->obj, timer);
              eo_parent_set(timer->obj, NULL);
@@ -536,9 +536,9 @@ _ecore_timer_cleanup(void)
 }
 
 void
-_ecore_timer_enable_new(void)
+_efl_timer_enable_new(void)
 {
-   Ecore_Timer_Data *timer;
+   Efl_Timer_Data *timer;
 
    if (!timers_added) return;
    timers_added = 0;
@@ -546,24 +546,24 @@ _ecore_timer_enable_new(void)
 }
 
 int
-_ecore_timers_exists(void)
+_efl_timers_exists(void)
 {
-   Ecore_Timer_Data *timer = timers;
+   Efl_Timer_Data *timer = timers;
 
    while ((timer) && (timer->delete_me))
-     timer = (Ecore_Timer_Data *)EINA_INLIST_GET(timer)->next;
+     timer = (Efl_Timer_Data *)EINA_INLIST_GET(timer)->next;
 
    return !!timer;
 }
 
 static inline Ecore_Timer *
-_ecore_timer_first_get(void)
+_efl_timer_first_get(void)
 {
    Ecore_Timer *ret = NULL;
-   Ecore_Timer_Data *timer = timers;
+   Efl_Timer_Data *timer = timers;
 
    while ((timer) && ((timer->delete_me) || (timer->just_added)))
-     timer = (Ecore_Timer_Data *)EINA_INLIST_GET(timer)->next;
+     timer = (Efl_Timer_Data *)EINA_INLIST_GET(timer)->next;
 
    if (timer)
      ret = timer->obj;
@@ -571,20 +571,20 @@ _ecore_timer_first_get(void)
 }
 
 static inline Ecore_Timer *
-_ecore_timer_after_get(Ecore_Timer *obj)
+_efl_timer_after_get(Ecore_Timer *obj)
 {
    Ecore_Timer *ret = NULL;
-   Ecore_Timer_Data *base = eo_data_scope_get(obj, MY_CLASS);
+   Efl_Timer_Data *base = eo_data_scope_get(obj, MY_CLASS);
 
-   Ecore_Timer_Data *timer = (Ecore_Timer_Data *)EINA_INLIST_GET(base)->next;
-   Ecore_Timer_Data *valid_timer = NULL;
+   Efl_Timer_Data *timer = (Efl_Timer_Data *)EINA_INLIST_GET(base)->next;
+   Efl_Timer_Data *valid_timer = NULL;
    double maxtime = base->at + precision;
 
    while ((timer) && (timer->at < maxtime))
      {
         if (!((timer->delete_me) || (timer->just_added)))
           valid_timer = timer;
-        timer = (Ecore_Timer_Data *)EINA_INLIST_GET(timer)->next;
+        timer = (Efl_Timer_Data *)EINA_INLIST_GET(timer)->next;
      }
 
    if (valid_timer)
@@ -593,17 +593,17 @@ _ecore_timer_after_get(Ecore_Timer *obj)
 }
 
 double
-_ecore_timer_next_get(void)
+_efl_timer_next_get(void)
 {
    double now;
    double in;
    Ecore_Timer *first_obj, *second_obj;
-   Ecore_Timer_Data *first;
+   Efl_Timer_Data *first;
 
-   first_obj = _ecore_timer_first_get();
+   first_obj = _efl_timer_first_get();
    if (!first_obj) return -1;
 
-   second_obj = _ecore_timer_after_get(first_obj);
+   second_obj = _efl_timer_after_get(first_obj);
    if (second_obj) first_obj = second_obj;
 
    first = eo_data_scope_get(first_obj, MY_CLASS);
@@ -615,13 +615,13 @@ _ecore_timer_next_get(void)
 }
 
 static inline void
-_ecore_timer_reschedule(Ecore_Timer *obj,
+_efl_timer_reschedule(Ecore_Timer *obj,
                         double       when)
 {
-   Ecore_Timer_Data *timer = eo_data_scope_get(obj, MY_CLASS);
+   Efl_Timer_Data *timer = eo_data_scope_get(obj, MY_CLASS);
    if ((timer->delete_me) || (timer->frozen)) return;
 
-   timers = (Ecore_Timer_Data *)eina_inlist_remove(EINA_INLIST_GET(timers), 
EINA_INLIST_GET(timer));
+   timers = (Efl_Timer_Data *)eina_inlist_remove(EINA_INLIST_GET(timers), 
EINA_INLIST_GET(timer));
    eo_data_unref(obj, timer);
 
    /* if the timer would have gone off more than 15 seconds ago,
@@ -634,25 +634,25 @@ _ecore_timer_reschedule(Ecore_Timer *obj,
     * really slow within the main loop.
     */
    if ((timer->at + timer->in) < (when - 15.0))
-     _ecore_timer_set(obj, when + timer->in, timer->in, timer->func, 
timer->data);
+     _efl_timer_set(obj, when + timer->in, timer->in, timer->func, 
timer->data);
    else
-     _ecore_timer_set(obj, timer->at + timer->in, timer->in, timer->func, 
timer->data);
+     _efl_timer_set(obj, timer->at + timer->in, timer->in, timer->func, 
timer->data);
 }
 
 void
-_ecore_timer_expired_timers_call(double when)
+_efl_timer_expired_timers_call(double when)
 {
    /* call the first expired timer until no expired timers exist */
-    while (_ecore_timer_expired_call(when)) ;
+    while (_efl_timer_expired_call(when)) ;
 }
 
 int
-_ecore_timer_expired_call(double when)
+_efl_timer_expired_call(double when)
 {
    if (!timers) return 0;
    if (last_check > when)
      {
-        Ecore_Timer_Data *timer;
+        Efl_Timer_Data *timer;
         /* User set time backwards */
         EINA_INLIST_FOREACH(timers, timer) timer->at -= (last_check - when);
      }
@@ -666,14 +666,14 @@ _ecore_timer_expired_call(double when)
    else
      {
         /* recursive main loop, continue from where we were */
-        Ecore_Timer_Data *timer_old = timer_current;
-        timer_current = (Ecore_Timer_Data 
*)EINA_INLIST_GET(timer_current)->next;
-        _ecore_timer_reschedule(timer_old->obj, when);
+        Efl_Timer_Data *timer_old = timer_current;
+        timer_current = (Efl_Timer_Data *)EINA_INLIST_GET(timer_current)->next;
+        _efl_timer_reschedule(timer_old->obj, when);
      }
 
    while (timer_current)
      {
-        Ecore_Timer_Data *timer = timer_current;
+        Efl_Timer_Data *timer = timer_current;
 
         if (timer->at > when)
           {
@@ -683,7 +683,7 @@ _ecore_timer_expired_call(double when)
 
         if ((timer->just_added) || (timer->delete_me))
           {
-             timer_current = (Ecore_Timer_Data 
*)EINA_INLIST_GET(timer_current)->next;
+             timer_current = (Efl_Timer_Data 
*)EINA_INLIST_GET(timer_current)->next;
              continue;
           }
 
@@ -691,29 +691,29 @@ _ecore_timer_expired_call(double when)
         eina_evlog("+timer", timer, 0.0, NULL);
         if (!_ecore_call_task_cb(timer->func, timer->data))
           {
-             if (!timer->delete_me) _ecore_timer_del(timer->obj);
+             if (!timer->delete_me) _efl_timer_del(timer->obj);
           }
         eina_evlog("-timer", timer, 0.0, NULL);
         timer->references--;
 
         if (timer_current) /* may have changed in recursive main loops */
-          timer_current = (Ecore_Timer_Data 
*)EINA_INLIST_GET(timer_current)->next;
+          timer_current = (Efl_Timer_Data 
*)EINA_INLIST_GET(timer_current)->next;
 
-        _ecore_timer_reschedule(timer->obj, when);
+        _efl_timer_reschedule(timer->obj, when);
      }
    return 0;
 }
 
 static void
-_ecore_timer_set(Ecore_Timer  *obj,
+_efl_timer_set(Ecore_Timer  *obj,
                  double        at,
                  double        in,
                  Ecore_Task_Cb func,
                  void         *data)
 {
-   Ecore_Timer_Data *t2;
+   Efl_Timer_Data *t2;
 
-   Ecore_Timer_Data *timer = eo_data_ref(obj, MY_CLASS);
+   Efl_Timer_Data *timer = eo_data_ref(obj, MY_CLASS);
 
    timers_added = 1;
    timer->at = at;
@@ -729,24 +729,24 @@ _ecore_timer_set(Ecore_Timer  *obj,
           {
              if (timer->at > t2->at)
                {
-                  timers = (Ecore_Timer_Data 
*)eina_inlist_append_relative(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer), 
EINA_INLIST_GET(t2));
+                  timers = (Efl_Timer_Data 
*)eina_inlist_append_relative(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer), 
EINA_INLIST_GET(t2));
                   return;
                }
           }
      }
-   timers = (Ecore_Timer_Data *)eina_inlist_prepend(EINA_INLIST_GET(timers), 
EINA_INLIST_GET(timer));
+   timers = (Efl_Timer_Data *)eina_inlist_prepend(EINA_INLIST_GET(timers), 
EINA_INLIST_GET(timer));
 }
 
 #ifdef WANT_ECORE_TIMER_DUMP
 static int
-_ecore_timer_cmp(const void *d1,
+_efl_timer_cmp(const void *d1,
                  const void *d2)
 {
-   const Ecore_Timer_Data *t1 = d1;
-   const Ecore_Timer_Data *t2 = d2;
+   const Efl_Timer_Data *t1 = d1;
+   const Efl_Timer_Data *t2 = d2;
 
    return (int)((t1->in - t2->in) * 100);
 }
 #endif
 
-#include "ecore_timer.eo.c"
+#include "efl_timer.eo.c"
diff --git a/src/lib/ecore/ecore_timer.eo b/src/lib/ecore/efl_timer.eo
similarity index 98%
rename from src/lib/ecore/ecore_timer.eo
rename to src/lib/ecore/efl_timer.eo
index 81804b9..9a3b54f 100644
--- a/src/lib/ecore/ecore_timer.eo
+++ b/src/lib/ecore/efl_timer.eo
@@ -1,6 +1,6 @@
 import ecore_types;
 
-class Ecore.Timer (Eo.Base)
+class Efl.Timer (Eo.Base)
 {
    [[Timers are objects that will call a given callback at some point
      in the future.
@@ -11,7 +11,7 @@ class Ecore.Timer (Eo.Base)
      properly. They do not guarantee exact timing, but try to work on a "best
      effort" basis.
    ]]
-   eo_prefix: ecore_obj_timer;
+   legacy_prefix: ecore_timer;
    methods {
       @property interval {
          [[Interval the timer ticks on.]]

-- 


Reply via email to