Porting to Eo: Job, Animator, Idler, Idle_Enterer, Idle_Exiter, Timer, Ecore_Poll

Signed-off-by: Yakov Goldberg <yakov.g@samsung.com>

SVN revision: 77722

1 files changed, 333 insertions, 164 deletions

diff --git a/legacy/ecore/src/lib/ecore/ecore_timer.c b/legacy/ecore/src/lib/ecore/ecore_timer.c
index 343c89f571..0ab4230dbe 100644
--- a/legacy/ecore/src/lib/ecore/ecore_timer.c
+++ b/legacy/ecore/src/lib/ecore/ecore_timer.c
@@ -8,6 +8,17 @@
 #include "Ecore.h"
 #include "ecore_private.h"
 
+#include "Eo.h"
+
+#define MY_CLASS ECORE_TIMER_CLASS
+#define MY_CLASS_NAME "ecore_timer"
+
+EAPI Eo_Op ECORE_TIMER_BASE_ID = EO_NOOP;
+
+#define ECORE_TIMER_CHECK(obj)                       \
+  if (!eo_isa((obj), ECORE_TIMER_CLASS)) \
+    return
+
 #ifdef WANT_ECORE_TIMER_DUMP
 # include <string.h>
 # include <execinfo.h>
@@ -15,10 +26,10 @@
 typedef void (*Ecore_Timer_Bt_Func)();
 #endif
 
-struct _Ecore_Timer
+struct _Ecore_Timer_Private_Data
 {
    EINA_INLIST;
-                       ECORE_MAGIC;
+   Ecore_Timer         *obj;
    double              in;
    double              at;
    double              pending;
@@ -35,9 +46,10 @@ struct _Ecore_Timer
    unsigned char       just_added : 1;
    unsigned char       frozen : 1;
 };
-GENERIC_ALLOC_SIZE_DECLARE(Ecore_Timer);
 
-static void _ecore_timer_set(Ecore_Timer  *timer,
+typedef struct _Ecore_Timer_Private_Data Ecore_Timer_Private_Data;
+
+static void _ecore_timer_set(Ecore_Timer *timer,
                              double        at,
                              double        in,
                              Ecore_Task_Cb func,
@@ -49,9 +61,9 @@ static int _ecore_timer_cmp(const void *d1,
 
 static int timers_added = 0;
 static int timers_delete_me = 0;
-static Ecore_Timer *timers = NULL;
-static Ecore_Timer *timer_current = NULL;
-static Ecore_Timer *suspended = NULL;
+static Ecore_Timer_Private_Data *timers = NULL;
+static Ecore_Timer_Private_Data *timer_current = NULL;
+static Ecore_Timer_Private_Data *suspended = NULL;
 static double last_check = 0.0;
 static double precision = 10.0 / 1000000.0;
 
@@ -138,29 +150,89 @@ ecore_timer_add(double        in,
                 Ecore_Task_Cb func,
                 const void   *data)
 {
-   double now;
    Ecore_Timer *timer = NULL;
 
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   _ecore_lock();
-   if (!func) goto unlock;
+   timer = eo_add_custom(MY_CLASS, _ecore_parent, ecore_timer_constructor(in, func, data));
+   eo_unref(timer);
+   return timer;
+}
+
+static Eina_Bool
+_ecore_timer_add(Ecore_Timer *obj,
+                 Ecore_Timer_Private_Data *timer,
+                 double now,
+                 double in,
+                 Ecore_Task_Cb func,
+                 const void *data)
+{
+
+   if (EINA_UNLIKELY(!eina_main_loop_is()))
+     {
+        eo_error_set(obj);
+        EINA_MAIN_LOOP_CHECK_RETURN_VAL(EINA_FALSE);
+     }
+
+   timer->obj = obj;
+   eo_do_super(obj, eo_constructor());
+   eo_manual_free_set(obj, EINA_TRUE);
+
+   if (!func)
+     {
+        eo_error_set(obj);
+        ERR("callback function must be set up for an object of class: '%s'", MY_CLASS_NAME);
+        return EINA_FALSE;
+     }
+
    if (in < 0.0) in = 0.0;
-   timer = ecore_timer_calloc(1);
-   if (!timer) goto unlock;
-   ECORE_MAGIC_SET(timer, ECORE_MAGIC_TIMER);
-   now = ecore_time_get();
 
 #ifdef WANT_ECORE_TIMER_DUMP
    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);
+   return EINA_TRUE;
+}
 
-   _ecore_timer_set(timer, now + in, in, func, (void *)data);
-unlock:
+static void
+_timer_constructor(Eo *obj, void *_pd, va_list *list)
+{
+   double in = va_arg(*list, double);
+   Ecore_Task_Cb func = va_arg(*list, Ecore_Task_Cb);
+   const void *data = va_arg(*list, const void *);
+   double now;
+
+   _ecore_lock();
+   now = ecore_time_get();
+
+   Ecore_Timer_Private_Data *timer = _pd;
+   _ecore_timer_add(obj, timer, now, in, func, data);
    _ecore_unlock();
-   return timer;
 }
 
+static void
+_timer_loop_constructor(Eo *obj, void *_pd, va_list *list)
+{
+   double in = va_arg(*list, double);
+   Ecore_Task_Cb func = va_arg(*list, Ecore_Task_Cb);
+   const void *data = va_arg(*list, const void *);
+   double now;
+
+   _ecore_lock();
+   now = ecore_loop_time_get();
+
+   Ecore_Timer_Private_Data *timer = _pd;
+   _ecore_timer_add(obj, timer, now, in, func, data);
+}
+
+static void
+_constructor(Eo *obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED)
+{
+   eo_error_set(obj);
+   ERR("only custom constructor can be used with '%s' class", MY_CLASS_NAME);
+}
+
+
 /**
  * Creates a timer to call the given function in the given period of time.
  * @param   in   The interval in seconds from current loop time.
@@ -180,7 +252,6 @@ ecore_timer_loop_add(double        in,
 {
    Ecore_Timer *timer;
 
-   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
    timer = _ecore_timer_loop_add(in, func, data);
    _ecore_unlock();
@@ -205,16 +276,8 @@ ecore_timer_del(Ecore_Timer *timer)
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
 
-   if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
-     {
-        ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER,
-                         "ecore_timer_del");
-        goto unlock;
-     }
-
    data = _ecore_timer_del(timer);
 
-unlock:
    _ecore_unlock();
    return data;
 }
@@ -230,17 +293,20 @@ EAPI void
 ecore_timer_interval_set(Ecore_Timer *timer,
                          double       in)
 {
+   ECORE_TIMER_CHECK(timer);
+   eo_do(timer, ecore_obj_timer_interval_set(in));
+}
+
+static void
+_timer_interval_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
    EINA_MAIN_LOOP_CHECK_RETURN;
-   _ecore_lock();
+   double in = va_arg(*list, double);
    if (in < 0.0) in = 0.0;
-   if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
-     {
-        ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER,
-                         "ecore_timer_interval_set");
-        goto unlock;
-     }
+   Ecore_Timer_Private_Data *timer = _pd;
+
+   _ecore_lock();
    timer->in = in;
-unlock:
    _ecore_unlock();
 }
 
@@ -253,23 +319,24 @@ unlock:
 EAPI double
 ecore_timer_interval_get(Ecore_Timer *timer)
 {
-   double interval;
+   double interval = -1.0;
 
-   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0.0);
-   _ecore_lock();
+   ECORE_TIMER_CHECK(timer) interval;
+   eo_do(timer, ecore_obj_timer_interval_get(&interval));
+   return interval;
+}
 
-   if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
-     {
-        ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER,
-                         "ecore_timer_interval_get");
-        interval = -1.0;
-        goto unlock;
-     }
+static void
+_timer_interval_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   double *ret = va_arg(*list, double *);
+   *ret = -1.0;
 
-   interval = timer->in;
-unlock:
+   EINA_MAIN_LOOP_CHECK_RETURN;
+   Ecore_Timer_Private_Data *timer = _pd;
+   _ecore_lock();
+   *ret = timer->in;
    _ecore_unlock();
-   return interval;
 }
 
 /**
@@ -283,16 +350,18 @@ EAPI void
 ecore_timer_delay(Ecore_Timer *timer,
                   double       add)
 {
+   ECORE_TIMER_CHECK(timer);
+   eo_do(timer, ecore_obj_timer_delay(add));
+}
+
+static void
+_timer_delay(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
+{
+   double add = va_arg(*list, double);
    EINA_MAIN_LOOP_CHECK_RETURN;
-   if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
-     {
-        ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER,
-                         "ecore_timer_delay");
-        return;
-     }
 
    _ecore_lock();
-   _ecore_timer_delay(timer, add);
+   _ecore_timer_delay(obj, add);
    _ecore_unlock();
 }
 
@@ -309,14 +378,18 @@ ecore_timer_delay(Ecore_Timer *timer,
 EAPI void
 ecore_timer_reset(Ecore_Timer *timer)
 {
+   ECORE_TIMER_CHECK(timer);
+   eo_do(timer, ecore_obj_timer_reset());
+}
+
+static void
+_timer_reset(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
+{
    double now, add;
    EINA_MAIN_LOOP_CHECK_RETURN;
-   if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
-     {
-        ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER,
-                         __func__);
-        return;
-     }
+
+   Ecore_Timer_Private_Data *timer = _pd;
+
    _ecore_lock();
    now = ecore_time_get();
 
@@ -324,7 +397,7 @@ ecore_timer_reset(Ecore_Timer *timer)
      add = timer->pending;
    else
      add = timer->at - now;
-   _ecore_timer_delay(timer, timer->in - add);
+   _ecore_timer_delay(obj, timer->in - add);
    _ecore_unlock();
 }
 
@@ -338,30 +411,33 @@ ecore_timer_reset(Ecore_Timer *timer)
 EAPI double
 ecore_timer_pending_get(Ecore_Timer *timer)
 {
-   double now;
    double ret = 0.0;
 
-   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0.0);
-   _ecore_lock();
+   ECORE_TIMER_CHECK(timer) ret;
+   eo_do(timer, ecore_obj_timer_pending_get(&ret));
+   return ret;
+}
 
-   if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
-     {
-        ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER,
-                         "ecore_timer_pending_get");
-        goto unlock;
-     }
+static void
+_timer_pending_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   double now;
+   double *ret = va_arg(*list, double *);
+   *ret = 0.0;
+
+   EINA_MAIN_LOOP_CHECK_RETURN;
+
+   _ecore_lock();
+   Ecore_Timer_Private_Data *timer = _pd;
 
    now = ecore_time_get();
 
    if (timer->frozen)
-     ret = timer->pending;
+     *ret = timer->pending;
    else
-     ret = timer->at - now;
-unlock:
+     *ret = timer->at - now;
    _ecore_unlock();
-   return ret;
 }
-
 /**
  * Pauses a running timer.
  *
@@ -379,24 +455,26 @@ unlock:
 EAPI void
 ecore_timer_freeze(Ecore_Timer *timer)
 {
+   ECORE_TIMER_CHECK(timer);
+   eo_do(timer, eo_event_freeze());
+}
+
+static void
+_timer_freeze(Eo *obj EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED)
+{
    double now;
 
    EINA_MAIN_LOOP_CHECK_RETURN;
-   _ecore_lock();
 
-   if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
-     {
-        ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER,
-                         "ecore_timer_freeze");
-        goto unlock;
-     }
+   Ecore_Timer_Private_Data *timer = _pd;
+   _ecore_lock();
 
    /* Timer already frozen */
    if (timer->frozen)
      goto unlock;
 
-   timers = (Ecore_Timer *)eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer));
-   suspended = (Ecore_Timer *)eina_inlist_prepend(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
+   timers = (Ecore_Timer_Private_Data *)eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer));
+   suspended = (Ecore_Timer_Private_Data *)eina_inlist_prepend(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
 
    now = ecore_time_get();
 
@@ -423,26 +501,28 @@ unlock:
 EAPI void
 ecore_timer_thaw(Ecore_Timer *timer)
 {
+   ECORE_TIMER_CHECK(timer);
+   eo_do(timer, eo_event_thaw());
+}
+
+static void
+_timer_thaw(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
+{
    double now;
 
    EINA_MAIN_LOOP_CHECK_RETURN;
-   _ecore_lock();
+   Ecore_Timer_Private_Data *timer = _pd;
 
-   if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
-     {
-        ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER,
-                         "ecore_timer_thaw");
-        goto unlock;
-     }
+   _ecore_lock();
 
    /* Timer not frozen */
    if (!timer->frozen)
      goto unlock;
 
-   suspended = (Ecore_Timer *)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
+   suspended = (Ecore_Timer_Private_Data *)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
    now = ecore_time_get();
 
-   _ecore_timer_set(timer, timer->pending + now, timer->in, timer->func, timer->data);
+   _ecore_timer_set(obj, timer->pending + now, timer->in, timer->func, timer->data);
 unlock:
    _ecore_unlock();
 }
@@ -512,52 +592,50 @@ _ecore_timer_loop_add(double        in,
                       Ecore_Task_Cb func,
                       const void   *data)
 {
-   double now;
    Ecore_Timer *timer = NULL;
+   timer = eo_add_custom(MY_CLASS, _ecore_parent, ecore_timer_loop_constructor(in, func, data));
+   eo_unref(timer);
 
-   if (!func) return timer;
-   if (in < 0.0) in = 0.0;
-   timer = ecore_timer_calloc(1);
-   if (!timer) return timer;
-   ECORE_MAGIC_SET(timer, ECORE_MAGIC_TIMER);
-   now = ecore_loop_time_get();
-
-#ifdef WANT_ECORE_TIMER_DUMP
-   timer->timer_bt_num = backtrace((void **)(timer->timer_bt),
-                                   ECORE_TIMER_DEBUG_BT_NUM);
-#endif
-   _ecore_timer_set(timer, now + in, in, func, (void *)data);
    return timer;
 }
 
 EAPI void
-_ecore_timer_delay(Ecore_Timer *timer,
+_ecore_timer_delay(Ecore_Timer *obj,
                    double       add)
 {
+   Ecore_Timer_Private_Data *timer = eo_data_get(obj, MY_CLASS);
+
    if (timer->frozen)
      {
         timer->pending += add;
      }
    else
      {
-        timers = (Ecore_Timer *)eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer));
-        _ecore_timer_set(timer, timer->at + add, timer->in, timer->func, timer->data);
+        timers = (Ecore_Timer_Private_Data *)eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer));
+        _ecore_timer_set(obj, timer->at + add, timer->in, timer->func, timer->data);
      }
 }
 
 void *
-_ecore_timer_del(Ecore_Timer *timer)
+_ecore_timer_del(Ecore_Timer *obj)
 {
+   Ecore_Timer_Private_Data *timer = eo_data_get(obj, MY_CLASS);
+
    if (timer->frozen && !timer->references)
      {
         void *data = timer->data;
 
-        suspended = (Ecore_Timer *)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
+        suspended = (Ecore_Timer_Private_Data *)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
 
         if (timer->delete_me)
           timers_delete_me--;
 
-        ecore_timer_mp_free(timer);
+        eo_parent_set(obj, NULL);
+
+        if (eo_destructed_is(obj))
+          eo_manual_free(obj);
+        else
+          eo_manual_free_set(obj, EINA_FALSE);
         return data;
      }
 
@@ -567,23 +645,45 @@ _ecore_timer_del(Ecore_Timer *timer)
    return timer->data;
 }
 
+static void
+_destructor(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
+{
+   Ecore_Timer_Private_Data *pd = _pd;
+
+   if (!pd->delete_me)
+   {
+     pd->delete_me = 1;
+     timers_delete_me++;
+   }
+
+   eo_do_super(obj, eo_destructor());
+}
+
 void
 _ecore_timer_shutdown(void)
 {
-   Ecore_Timer *timer;
+   Ecore_Timer_Private_Data *timer;
 
    while ((timer = timers))
      {
-        timers = (Ecore_Timer *)eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timers));
-        ECORE_MAGIC_SET(timer, ECORE_MAGIC_NONE);
-        ecore_timer_mp_free(timer);
+        timers = (Ecore_Timer_Private_Data *)eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timers));
+
+        eo_parent_set(timer->obj, NULL);
+        if (eo_destructed_is(timer->obj))
+          eo_manual_free(timer->obj);
+        else
+          eo_manual_free_set(timer->obj, EINA_FALSE);
      }
 
    while ((timer = suspended))
      {
-        suspended = (Ecore_Timer *)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(suspended));
-        ECORE_MAGIC_SET(timer, ECORE_MAGIC_NONE);
-        ecore_timer_mp_free(timer);
+        suspended = (Ecore_Timer_Private_Data *)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(suspended));
+
+        eo_parent_set(timer->obj, NULL);
+        if (eo_destructed_is(timer->obj))
+          eo_manual_free(timer->obj);
+        else
+          eo_manual_free_set(timer->obj, EINA_FALSE);
      }
 
    timer_current = NULL;
@@ -592,15 +692,15 @@ _ecore_timer_shutdown(void)
 void
 _ecore_timer_cleanup(void)
 {
-   Ecore_Timer *l;
+   Ecore_Timer_Private_Data *l;
    int in_use = 0, todo = timers_delete_me, done = 0;
 
    if (!timers_delete_me) return;
    for (l = timers; l; )
      {
-        Ecore_Timer *timer = l;
+        Ecore_Timer_Private_Data *timer = l;
 
-        l = (Ecore_Timer *)EINA_INLIST_GET(l)->next;
+        l = (Ecore_Timer_Private_Data *)EINA_INLIST_GET(l)->next;
         if (timer->delete_me)
           {
              if (timer->references)
@@ -608,9 +708,13 @@ _ecore_timer_cleanup(void)
                   in_use++;
                   continue;
                }
-             timers = (Ecore_Timer *)eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer));
-             ECORE_MAGIC_SET(timer, ECORE_MAGIC_NONE);
-             ecore_timer_mp_free(timer);
+             timers = (Ecore_Timer_Private_Data *)eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer));
+
+             eo_parent_set(timer->obj, NULL);
+             if (eo_destructed_is(timer->obj))
+               eo_manual_free(timer->obj);
+             else
+               eo_manual_free_set(timer->obj, EINA_FALSE);
              timers_delete_me--;
              done++;
              if (timers_delete_me == 0) return;
@@ -618,9 +722,9 @@ _ecore_timer_cleanup(void)
      }
    for (l = suspended; l; )
      {
-        Ecore_Timer *timer = l;
+        Ecore_Timer_Private_Data *timer = l;
 
-        l = (Ecore_Timer *)EINA_INLIST_GET(l)->next;
+        l = (Ecore_Timer_Private_Data *)EINA_INLIST_GET(l)->next;
         if (timer->delete_me)
           {
              if (timer->references)
@@ -628,9 +732,13 @@ _ecore_timer_cleanup(void)
                   in_use++;
                   continue;
                }
-             suspended = (Ecore_Timer *)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
-             ECORE_MAGIC_SET(timer, ECORE_MAGIC_NONE);
-             ecore_timer_mp_free(timer);
+             suspended = (Ecore_Timer_Private_Data *)eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
+
+             eo_parent_set(timer->obj, NULL);
+             if (eo_destructed_is(timer->obj))
+                eo_manual_free(timer->obj);
+             else
+                eo_manual_free_set(timer->obj, EINA_FALSE);
              timers_delete_me--;
              done++;
              if (timers_delete_me == 0) return;
@@ -650,7 +758,7 @@ _ecore_timer_cleanup(void)
 void
 _ecore_timer_enable_new(void)
 {
-   Ecore_Timer *timer;
+   Ecore_Timer_Private_Data *timer;
 
    if (!timers_added) return;
    timers_added = 0;
@@ -660,10 +768,10 @@ _ecore_timer_enable_new(void)
 int
 _ecore_timers_exists(void)
 {
-   Ecore_Timer *timer = timers;
+   Ecore_Timer_Private_Data *timer = timers;
 
    while ((timer) && (timer->delete_me))
-     timer = (Ecore_Timer *)EINA_INLIST_GET(timer)->next;
+     timer = (Ecore_Timer_Private_Data *)EINA_INLIST_GET(timer)->next;
 
    return !!timer;
 }
@@ -671,29 +779,37 @@ _ecore_timers_exists(void)
 static inline Ecore_Timer *
 _ecore_timer_first_get(void)
 {
-   Ecore_Timer *timer = timers;
+   Ecore_Timer *ret = NULL;
+   Ecore_Timer_Private_Data *timer = timers;
 
    while ((timer) && ((timer->delete_me) || (timer->just_added)))
-     timer = (Ecore_Timer *)EINA_INLIST_GET(timer)->next;
+     timer = (Ecore_Timer_Private_Data *)EINA_INLIST_GET(timer)->next;
 
-   return timer;
+   if (timer)
+     ret = timer->obj;
+   return ret;
 }
 
 static inline Ecore_Timer *
-_ecore_timer_after_get(Ecore_Timer *base)
+_ecore_timer_after_get(Ecore_Timer *obj)
 {
-   Ecore_Timer *timer = (Ecore_Timer *)EINA_INLIST_GET(base)->next;
-   Ecore_Timer *valid_timer = NULL;
+   Ecore_Timer *ret = NULL;
+   Ecore_Timer_Private_Data *base = eo_data_get(obj, MY_CLASS);
+
+   Ecore_Timer_Private_Data *timer = (Ecore_Timer_Private_Data *)EINA_INLIST_GET(base)->next;
+   Ecore_Timer_Private_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 *)EINA_INLIST_GET(timer)->next;
+        timer = (Ecore_Timer_Private_Data *)EINA_INLIST_GET(timer)->next;
      }
 
-   return valid_timer;
+   if (valid_timer)
+     ret = valid_timer->obj;
+   return ret;
 }
 
 double
@@ -701,13 +817,16 @@ _ecore_timer_next_get(void)
 {
    double now;
    double in;
-   Ecore_Timer *first, *second;
+   Ecore_Timer *first_obj, *second_obj;
+   Ecore_Timer_Private_Data *first;
+
+   first_obj = _ecore_timer_first_get();
+   if (!first_obj) return -1;
 
-   first = _ecore_timer_first_get();
-   if (!first) return -1;
+   second_obj = _ecore_timer_after_get(first_obj);
+   if (second_obj) first_obj = second_obj;
 
-   second = _ecore_timer_after_get(first);
-   if (second) first = second;
+   first = eo_data_get(first_obj, MY_CLASS);
 
    now = ecore_loop_time_get();
    in = first->at - now;
@@ -716,12 +835,13 @@ _ecore_timer_next_get(void)
 }
 
 static inline void
-_ecore_timer_reschedule(Ecore_Timer *timer,
+_ecore_timer_reschedule(Ecore_Timer *obj,
                         double       when)
 {
+   Ecore_Timer_Private_Data *timer = eo_data_get(obj, MY_CLASS);
    if ((timer->delete_me) || (timer->frozen)) return;
 
-   timers = (Ecore_Timer *)eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer));
+   timers = (Ecore_Timer_Private_Data *)eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer));
 
    /* if the timer would have gone off more than 15 seconds ago,
     * assume that the system hung and set the timer to go off
@@ -733,9 +853,9 @@ _ecore_timer_reschedule(Ecore_Timer *timer,
     * really slow within the main loop.
     */
    if ((timer->at + timer->in) < (when - 15.0))
-     _ecore_timer_set(timer, when + timer->in, timer->in, timer->func, timer->data);
+     _ecore_timer_set(obj, when + timer->in, timer->in, timer->func, timer->data);
    else
-     _ecore_timer_set(timer, timer->at + timer->in, timer->in, timer->func, timer->data);
+     _ecore_timer_set(obj, timer->at + timer->in, timer->in, timer->func, timer->data);
 }
 
 /* assume that we hold the ecore lock when entering this function */
@@ -753,7 +873,7 @@ _ecore_timer_expired_call(double when)
    if (!timers) return 0;
    if (last_check > when)
      {
-        Ecore_Timer *timer;
+        Ecore_Timer_Private_Data *timer;
         /* User set time backwards */
         EINA_INLIST_FOREACH(timers, timer) timer->at -= (last_check - when);
      }
@@ -762,19 +882,19 @@ _ecore_timer_expired_call(double when)
    if (!timer_current)
      {
         /* regular main loop, start from head */
-         timer_current = timers;
+        timer_current = timers;
      }
    else
      {
         /* recursive main loop, continue from where we were */
-         Ecore_Timer *timer_old = timer_current;
-         timer_current = (Ecore_Timer *)EINA_INLIST_GET(timer_current)->next;
-         _ecore_timer_reschedule(timer_old, when);
+        Ecore_Timer_Private_Data *timer_old = timer_current;
+        timer_current = (Ecore_Timer_Private_Data *)EINA_INLIST_GET(timer_current)->next;
+        _ecore_timer_reschedule(timer_old->obj, when);
      }
 
    while (timer_current)
      {
-        Ecore_Timer *timer = timer_current;
+        Ecore_Timer_Private_Data *timer = timer_current;
 
         if (timer->at > when)
           {
@@ -784,33 +904,35 @@ _ecore_timer_expired_call(double when)
 
         if ((timer->just_added) || (timer->delete_me))
           {
-             timer_current = (Ecore_Timer *)EINA_INLIST_GET(timer_current)->next;
+             timer_current = (Ecore_Timer_Private_Data *)EINA_INLIST_GET(timer_current)->next;
              continue;
           }
 
         timer->references++;
         if (!_ecore_call_task_cb(timer->func, timer->data))
           {
-             if (!timer->delete_me) _ecore_timer_del(timer);
+             if (!timer->delete_me) _ecore_timer_del(timer->obj);
           }
         timer->references--;
 
         if (timer_current) /* may have changed in recursive main loops */
-          timer_current = (Ecore_Timer *)EINA_INLIST_GET(timer_current)->next;
+          timer_current = (Ecore_Timer_Private_Data *)EINA_INLIST_GET(timer_current)->next;
 
-        _ecore_timer_reschedule(timer, when);
+        _ecore_timer_reschedule(timer->obj, when);
      }
    return 0;
 }
 
 static void
-_ecore_timer_set(Ecore_Timer  *timer,
+_ecore_timer_set(Ecore_Timer  *obj,
                  double        at,
                  double        in,
                  Ecore_Task_Cb func,
                  void         *data)
 {
-   Ecore_Timer *t2;
+   Ecore_Timer_Private_Data *t2;
+
+   Ecore_Timer_Private_Data *timer = eo_data_get(obj, MY_CLASS);
 
    timers_added = 1;
    timer->at = at;
@@ -826,12 +948,12 @@ _ecore_timer_set(Ecore_Timer  *timer,
           {
              if (timer->at > t2->at)
                {
-                  timers = (Ecore_Timer *)eina_inlist_append_relative(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer), EINA_INLIST_GET(t2));
+                  timers = (Ecore_Timer_Private_Data *)eina_inlist_append_relative(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer), EINA_INLIST_GET(t2));
                   return;
                }
           }
      }
-   timers = (Ecore_Timer *)eina_inlist_prepend(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer));
+   timers = (Ecore_Timer_Private_Data *)eina_inlist_prepend(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer));
 }
 
 #ifdef WANT_ECORE_TIMER_DUMP
@@ -845,3 +967,50 @@ _ecore_timer_cmp(const void *d1,
    return (int)((t1->in - t2->in) * 100);
 }
 #endif
+
+static void
+_class_constructor(Eo_Class *klass)
+{
+   const Eo_Op_Func_Description func_desc[] = {
+        EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor),
+        EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor),
+
+        EO_OP_FUNC(ECORE_TIMER_ID(ECORE_TIMER_SUB_ID_CONSTRUCTOR), _timer_constructor),
+        EO_OP_FUNC(ECORE_TIMER_ID(ECORE_TIMER_SUB_ID_LOOP_CONSTRUCTOR), _timer_loop_constructor),
+        EO_OP_FUNC(ECORE_TIMER_ID(ECORE_TIMER_SUB_ID_INTERVAL_SET), _timer_interval_set),
+        EO_OP_FUNC(ECORE_TIMER_ID(ECORE_TIMER_SUB_ID_INTERVAL_GET), _timer_interval_get),
+
+        EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_EVENT_FREEZE), _timer_freeze),
+        EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_EVENT_THAW), _timer_thaw),
+
+        EO_OP_FUNC(ECORE_TIMER_ID(ECORE_TIMER_SUB_ID_DELAY), _timer_delay),
+        EO_OP_FUNC(ECORE_TIMER_ID(ECORE_TIMER_SUB_ID_RESET), _timer_reset),
+        EO_OP_FUNC(ECORE_TIMER_ID(ECORE_TIMER_SUB_ID_PENDING_GET), _timer_pending_get),
+        EO_OP_FUNC_SENTINEL
+   };
+
+   eo_class_funcs_set(klass, func_desc);
+}
+
+static const Eo_Op_Description op_desc[] = {
+     EO_OP_DESCRIPTION(ECORE_TIMER_SUB_ID_CONSTRUCTOR, "Creates a timer to call the given function in the given period of time."),
+     EO_OP_DESCRIPTION(ECORE_TIMER_SUB_ID_LOOP_CONSTRUCTOR, "Creates a timer to call the given function in the given period of time."),
+     EO_OP_DESCRIPTION(ECORE_TIMER_SUB_ID_INTERVAL_SET, "Change the interval the timer ticks of."),
+     EO_OP_DESCRIPTION(ECORE_TIMER_SUB_ID_INTERVAL_GET, "Get the interval the timer ticks on."),
+     EO_OP_DESCRIPTION(ECORE_TIMER_SUB_ID_DELAY, "Add some delay for the next occurrence of a timer."),
+     EO_OP_DESCRIPTION(ECORE_TIMER_SUB_ID_RESET, "Reset a timer to its full interval"),
+     EO_OP_DESCRIPTION(ECORE_TIMER_SUB_ID_PENDING_GET, "Get the pending time regarding a timer."),
+     EO_OP_DESCRIPTION_SENTINEL
+};
+static const Eo_Class_Description class_desc = {
+     EO_VERSION,
+     MY_CLASS_NAME,
+     EO_CLASS_TYPE_REGULAR,
+     EO_CLASS_DESCRIPTION_OPS(&ECORE_TIMER_BASE_ID, op_desc, ECORE_TIMER_SUB_ID_LAST),
+     NULL,
+     sizeof(Ecore_Timer_Private_Data),
+     _class_constructor,
+     NULL
+};
+
+EO_DEFINE_CLASS(ecore_timer_class_get, &class_desc, EO_BASE_CLASS, NULL)