13 files changed, 123 insertions, 123 deletions

diff --git a/src/lib/ecore/Ecore_Eo.h b/src/lib/ecore/Ecore_Eo.h
index 60d43670e5..a7e8d93403 100644
--- a/src/lib/ecore/Ecore_Eo.h
+++ b/src/lib/ecore/Ecore_Eo.h
@@ -54,7 +54,7 @@ extern "C" {
 
 #include "efl_loop_fd.eo.h"
 
-/* We ue the factory pattern here, so you shouldn't call eo_add directly. */
+/* We ue the factory pattern here, so you shouldn't call efl_add directly. */
 EAPI Eo *ecore_main_loop_get(void);
 
 /**
diff --git a/src/lib/ecore/ecore.c b/src/lib/ecore/ecore.c
index 3a96c1c4aa..b09184ea9f 100644
--- a/src/lib/ecore/ecore.c
+++ b/src/lib/ecore/ecore.c
@@ -243,17 +243,17 @@ ecore_init(void)
         goto shutdown_log_dom;
      }
 
-   eo_init();
+   efl_object_init();
 
    if (getenv("ECORE_FPS_DEBUG")) _ecore_fps_debug = 1;
    if (_ecore_fps_debug) _ecore_fps_debug_init();
    if (!ecore_mempool_init()) goto shutdown_mempool;
    _ecore_main_loop_init();
 
-   vpath = eo_add(EFL_VPATH_CORE_CLASS, NULL);
+   vpath = efl_add(EFL_VPATH_CORE_CLASS, NULL);
    if (vpath) efl_vpath_manager_register(EFL_VPATH_MANAGER_CLASS, 0, vpath);
 
-   _mainloop_singleton = eo_add(EFL_LOOP_CLASS, NULL);
+   _mainloop_singleton = efl_add(EFL_LOOP_CLASS, NULL);
 
    _ecore_signal_init();
 #ifndef HAVE_EXOTIC
@@ -277,7 +277,7 @@ ecore_init(void)
 #if defined(GLIB_INTEGRATION_ALWAYS)
    if (_ecore_glib_always_integrate) ecore_main_loop_glib_integrate();
 #endif
-   _ecore_parent = eo_add(ECORE_PARENT_CLASS, NULL);
+   _ecore_parent = efl_add(ECORE_PARENT_CLASS, NULL);
 
 #if defined(HAVE_MALLINFO) || defined(HAVE_MALLOC_INFO)
    if (getenv("ECORE_MEM_STAT"))
@@ -323,7 +323,7 @@ ecore_init(void)
 
 shutdown_mempool:
    ecore_mempool_shutdown();
-   eo_shutdown();
+   efl_object_shutdown();
 shutdown_log_dom:
    eina_shutdown();
 shutdown_evil:
@@ -439,8 +439,8 @@ ecore_shutdown(void)
      eina_prefix_free(_ecore_pfx);
      _ecore_pfx = NULL;
 
-     eo_unref(_ecore_parent);
-     eo_shutdown();
+     efl_unref(_ecore_parent);
+     efl_object_shutdown();
 
      eina_shutdown();
 #ifdef HAVE_EVIL
diff --git a/src/lib/ecore/ecore_exe.c b/src/lib/ecore/ecore_exe.c
index d48219dec6..e1616ce4b9 100644
--- a/src/lib/ecore/ecore_exe.c
+++ b/src/lib/ecore/ecore_exe.c
@@ -68,10 +68,10 @@ ecore_exe_pipe_run(const char     *exe_cmd,
                    const void     *data)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   Ecore_Exe *ret = eo_add(MY_CLASS, NULL, ecore_obj_exe_command_set(eo_self, exe_cmd, flags));
+   Ecore_Exe *ret = efl_add(MY_CLASS, NULL, ecore_obj_exe_command_set(efl_self, exe_cmd, flags));
    if (ret)
      {
-        Ecore_Exe_Data *pd = eo_data_scope_get(ret, MY_CLASS);
+        Ecore_Exe_Data *pd = efl_data_scope_get(ret, MY_CLASS);
         pd->data = (void *) data;
      }
 
@@ -97,7 +97,7 @@ EOLIAN static Eo *
 _ecore_exe_efl_object_finalize(Eo *obj, Ecore_Exe_Data *exe)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   obj = efl_finalize(eo_super(obj, MY_CLASS));
+   obj = efl_finalize(efl_super(obj, MY_CLASS));
 
    if (!obj)
       return obj;
@@ -110,8 +110,8 @@ ecore_exe_callback_pre_free_set(Ecore_Exe   *obj,
                                 Ecore_Exe_Cb func)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return;
    exe->pre_free_cb = func;
 }
@@ -122,8 +122,8 @@ ecore_exe_send(Ecore_Exe  *obj,
                int         size)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(EINA_FALSE);
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return EINA_FALSE;
 
    if (exe->close_stdin)
@@ -140,8 +140,8 @@ EAPI void
 ecore_exe_close_stdin(Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return;
 
    exe->close_stdin = 1;
@@ -155,8 +155,8 @@ ecore_exe_auto_limits_set(Ecore_Exe *obj,
                           int        end_lines)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return;
 
    _impl_ecore_exe_auto_limits_set(obj, exe, start_bytes, end_bytes, start_lines, end_lines);
@@ -167,8 +167,8 @@ ecore_exe_event_data_get(Ecore_Exe      *obj,
                          Ecore_Exe_Flags flags)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return NULL;
 
    return _impl_ecore_exe_event_data_get(obj, exe, flags);
@@ -179,8 +179,8 @@ ecore_exe_tag_set(Ecore_Exe  *obj,
                   const char *tag)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return;
 
    IF_FREE(exe->tag);
@@ -194,8 +194,8 @@ EAPI const char *
 ecore_exe_tag_get(const Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return NULL;
 
    return exe->tag;
@@ -205,8 +205,8 @@ EAPI void *
 ecore_exe_free(Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return NULL;
 
    void *data = exe->data;
@@ -218,7 +218,7 @@ ecore_exe_free(Ecore_Exe *obj)
 EOLIAN static void
 _ecore_exe_efl_object_destructor(Eo *obj, Ecore_Exe_Data *exe)
 {
-   efl_destructor(eo_super(obj, ECORE_EXE_CLASS));
+   efl_destructor(efl_super(obj, ECORE_EXE_CLASS));
 
    _impl_ecore_exe_efl_object_destructor(obj, exe);
 }
@@ -236,8 +236,8 @@ EAPI pid_t
 ecore_exe_pid_get(const Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return -1;
 
    return exe->pid;
@@ -258,8 +258,8 @@ EAPI void *
 ecore_exe_data_get(const Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return NULL;
 
    return exe->data;
@@ -271,8 +271,8 @@ ecore_exe_data_set(Ecore_Exe *obj,
 {
    void *ret;
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return NULL;
 
    ret = exe->data;
@@ -284,8 +284,8 @@ EAPI Ecore_Exe_Flags
 ecore_exe_flags_get(const Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return 0;
 
    return exe->flags;
@@ -322,8 +322,8 @@ EAPI void
 ecore_exe_interrupt(Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return;
 
    _impl_ecore_exe_interrupt(obj, exe);
@@ -333,8 +333,8 @@ EAPI void
 ecore_exe_quit(Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return;
 
    _impl_ecore_exe_quit(obj, exe);
@@ -344,8 +344,8 @@ EAPI void
 ecore_exe_terminate(Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return;
 
    _impl_ecore_exe_terminate(obj, exe);
@@ -355,8 +355,8 @@ EAPI void
 ecore_exe_kill(Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return;
 
    _impl_ecore_exe_kill(obj, exe);
@@ -367,8 +367,8 @@ ecore_exe_signal(Ecore_Exe *obj,
                  int        num)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return;
 
    _impl_ecore_exe_signal(obj, exe, num);
@@ -378,8 +378,8 @@ EAPI void
 ecore_exe_hup(Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
-   if (!eo_isa(obj, MY_CLASS))
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+   if (!efl_isa(obj, MY_CLASS))
       return;
 
    _impl_ecore_exe_hup(obj, exe);
@@ -411,7 +411,7 @@ _ecore_exe_find(pid_t pid)
 
    EINA_LIST_FOREACH(_ecore_exe_exes, itr, obj)
    {
-      Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
+      Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
       if (exe->pid == pid)
         return obj;
    }
diff --git a/src/lib/ecore/ecore_exe_posix.c b/src/lib/ecore/ecore_exe_posix.c
index 2babbbf6a5..5ad60f9010 100644
--- a/src/lib/ecore/ecore_exe_posix.c
+++ b/src/lib/ecore/ecore_exe_posix.c
@@ -889,7 +889,7 @@ _ecore_exe_make_sure_its_dead(void *data)
 
       if ((obj = _ecore_exe_is_it_alive(dead->pid)))
       {
-         Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
+         Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
          if (dead->cmd)
            INF("Sending KILL signal to allegedly dead %s (%d).",
                dead->cmd, dead->pid);
@@ -922,7 +922,7 @@ _ecore_exe_make_sure_its_really_dead(void *data)
 
       if ((obj = _ecore_exe_is_it_alive(dead->pid)))
       {
-         Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
+         Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
          ERR("RUN!  The zombie wants to eat your brains!  And your CPU!");
          if (dead->cmd)
            INF("%s (%d) is not really dead.", dead->cmd, dead->pid);
@@ -939,7 +939,7 @@ _ecore_exe_make_sure_its_really_dead(void *data)
 Ecore_Timer *
 _ecore_exe_doomsday_clock_get(Ecore_Exe *obj)
 {
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
    return exe->doomsday_clock;
 }
 
@@ -947,7 +947,7 @@ void
 _ecore_exe_doomsday_clock_set(Ecore_Exe   *obj,
                               Ecore_Timer *dc)
 {
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
    exe->doomsday_clock = dc;
 }
 
@@ -1070,7 +1070,7 @@ _ecore_exe_data_generic_handler(void             *data,
    int event_type;
    const Efl_Event_Description *eo_event = NULL;
 
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
 
    /* Sort out what sort of handler we are. */
    if (flags & ECORE_EXE_PIPE_READ)
@@ -1223,7 +1223,7 @@ _ecore_exe_data_write_handler(void             *data,
                               Ecore_Fd_Handler *fd_handler EINA_UNUSED)
 {
    Ecore_Exe *obj = data;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
 
    if ((exe->write_fd_handler) &&
        (ecore_main_fd_handler_active_get
@@ -1253,7 +1253,7 @@ static void
 _ecore_exe_flush(Ecore_Exe *obj)
 {
    int count;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
 
    /* check whether we need to write anything at all. */
    if ((exe->child_fd_write == -1) || (!exe->write_data_buf))
@@ -1291,7 +1291,7 @@ static void
 _ecore_exe_dead_attach(Ecore_Exe *obj)
 {
    struct _ecore_exe_dead_exe *dead;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, MY_CLASS);
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
 
    if (exe->doomsday_clock_dead) return;
    dead = calloc(1, sizeof(struct _ecore_exe_dead_exe));
diff --git a/src/lib/ecore/ecore_exe_win32.c b/src/lib/ecore/ecore_exe_win32.c
index 0316754027..e2ef5ac94e 100644
--- a/src/lib/ecore/ecore_exe_win32.c
+++ b/src/lib/ecore/ecore_exe_win32.c
@@ -39,7 +39,7 @@ static int run_pri = NORMAL_PRIORITY_CLASS;
 static void
 _ecore_exe_threads_terminate(Ecore_Exe *obj)
 {
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, ECORE_EXE_CLASS);
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, ECORE_EXE_CLASS);
    HANDLE threads[2] = { NULL, NULL };
    int i = 0;
 
@@ -68,7 +68,7 @@ _ecore_exe_close_cb(void *data,
 {
    Ecore_Exe_Event_Del *e;
    Ecore_Exe *obj = data;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, ECORE_EXE_CLASS);
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, ECORE_EXE_CLASS);
    DWORD exit_code = 0;
 
    _ecore_exe_threads_terminate(obj);
@@ -105,7 +105,7 @@ _ecore_exe_pipe_read_thread_cb(void *data)
 {
    char buf[64];
    Ecore_Exe *obj = data;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, ECORE_EXE_CLASS);
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, ECORE_EXE_CLASS);
    Ecore_Exe_Event_Data *event_data;
    char *current_buf = NULL;
    DWORD size;
@@ -175,7 +175,7 @@ _ecore_exe_pipe_error_thread_cb(void *data)
 {
    char buf[64];
    Ecore_Exe *obj = data;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, ECORE_EXE_CLASS);
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, ECORE_EXE_CLASS);
    Ecore_Exe_Event_Data *event_data;
    char *current_buf = NULL;
    DWORD size;
@@ -253,7 +253,7 @@ _ecore_exe_enum_windows_procedure(HWND window,
                                   LPARAM data)
 {
    Ecore_Exe *obj = (Ecore_Exe *) data;
-   Ecore_Exe_Data *exe = eo_data_scope_get(obj, ECORE_EXE_CLASS);
+   Ecore_Exe_Data *exe = efl_data_scope_get(obj, ECORE_EXE_CLASS);
    DWORD thread_id;
 
    thread_id = GetWindowThreadProcessId(window, NULL);
diff --git a/src/lib/ecore/ecore_idle_enterer.c b/src/lib/ecore/ecore_idle_enterer.c
index ecc74dc923..08e7d9d95a 100644
--- a/src/lib/ecore/ecore_idle_enterer.c
+++ b/src/lib/ecore/ecore_idle_enterer.c
@@ -9,7 +9,7 @@
 #include "Ecore.h"
 #include "ecore_private.h"
 
-EO_CALLBACKS_ARRAY_DEFINE(ecore_idle_enterer_callbacks,
+EFL_CALLBACKS_ARRAY_DEFINE(ecore_idle_enterer_callbacks,
                           { EFL_LOOP_EVENT_IDLE_ENTER, _ecore_factorized_idle_process },
                           { EFL_EVENT_DEL, _ecore_factorized_idle_event_del });
 
@@ -31,7 +31,7 @@ ecore_idle_enterer_before_add(Ecore_Task_Cb func,
    // This avoid us duplicating code and should only be slightly slower
    // due to a useless cycle of callback registration
    efl_event_callback_array_del(_mainloop_singleton, ecore_idle_enterer_callbacks(), ie);
-   efl_event_callback_array_priority_add(_mainloop_singleton, ecore_idle_enterer_callbacks(), EO_CALLBACK_PRIORITY_BEFORE, ie);
+   efl_event_callback_array_priority_add(_mainloop_singleton, ecore_idle_enterer_callbacks(), EFL_CALLBACK_PRIORITY_BEFORE, ie);
 
    return ie;
 }
diff --git a/src/lib/ecore/ecore_idle_exiter.c b/src/lib/ecore/ecore_idle_exiter.c
index c53a182081..8295af24f8 100644
--- a/src/lib/ecore/ecore_idle_exiter.c
+++ b/src/lib/ecore/ecore_idle_exiter.c
@@ -9,7 +9,7 @@
 #include "Ecore.h"
 #include "ecore_private.h"
 
-EO_CALLBACKS_ARRAY_DEFINE(ecore_idle_exiter_callbacks,
+EFL_CALLBACKS_ARRAY_DEFINE(ecore_idle_exiter_callbacks,
                           { EFL_LOOP_EVENT_IDLE_EXIT, _ecore_factorized_idle_process },
                           { EFL_EVENT_DEL, _ecore_factorized_idle_event_del });
 
diff --git a/src/lib/ecore/ecore_idler.c b/src/lib/ecore/ecore_idler.c
index 3c94e6d0a0..e116852853 100644
--- a/src/lib/ecore/ecore_idler.c
+++ b/src/lib/ecore/ecore_idler.c
@@ -96,7 +96,7 @@ _ecore_factorized_idle_add(const Efl_Callback_Array_Item *desc,
 
 /* Specific to Ecore_Idler implementation */
 
-EO_CALLBACKS_ARRAY_DEFINE(ecore_idler_callbacks,
+EFL_CALLBACKS_ARRAY_DEFINE(ecore_idler_callbacks,
                           { EFL_LOOP_EVENT_IDLE, _ecore_factorized_idle_process },
                           { EFL_EVENT_DEL, _ecore_factorized_idle_event_del });
 
@@ -122,7 +122,7 @@ _ecore_idler_all_call(Eo *loop)
 int
 _ecore_idler_exist(Eo *loop)
 {
-   Efl_Loop_Data *dt = eo_data_scope_get(loop, EFL_LOOP_CLASS);
+   Efl_Loop_Data *dt = efl_data_scope_get(loop, EFL_LOOP_CLASS);
 
    return dt->idlers;
 }
diff --git a/src/lib/ecore/ecore_main.c b/src/lib/ecore/ecore_main.c
index f0e18787fc..5e941ed3d7 100644
--- a/src/lib/ecore/ecore_main.c
+++ b/src/lib/ecore/ecore_main.c
@@ -2721,7 +2721,7 @@ _efl_loop_main_get(Efl_Class *klass EINA_UNUSED, void *_pd EINA_UNUSED)
 {
    if (!_mainloop_singleton)
      {
-        _mainloop_singleton = eo_add(EFL_LOOP_CLASS, NULL);
+        _mainloop_singleton = efl_add(EFL_LOOP_CLASS, NULL);
      }
 
    return _mainloop_singleton;
@@ -2768,7 +2768,7 @@ _efl_loop_efl_object_provider_find(Eo *obj, Efl_Loop_Data *pd, const Efl_Object
    r = eina_hash_find(pd->providers, &klass);
    if (r) return r;
 
-   return efl_provider_find(eo_super(obj, EFL_LOOP_CLASS), klass);
+   return efl_provider_find(efl_super(obj, EFL_LOOP_CLASS), klass);
 }
 
 static void
@@ -2803,19 +2803,19 @@ _check_event_catcher_del(void *data, const Eo_Event *event)
      }
 }
 
-EO_CALLBACKS_ARRAY_DEFINE(event_catcher_watch,
+EFL_CALLBACKS_ARRAY_DEFINE(event_catcher_watch,
                           { EFL_EVENT_CALLBACK_ADD, _check_event_catcher_add },
                           { EFL_EVENT_CALLBACK_DEL, _check_event_catcher_del });
 
 EOLIAN static Efl_Object *
 _efl_loop_efl_object_constructor(Eo *obj, Efl_Loop_Data *pd)
 {
-   obj = efl_constructor(eo_super(obj, EFL_LOOP_CLASS));
+   obj = efl_constructor(efl_super(obj, EFL_LOOP_CLASS));
    if (!obj) return NULL;
 
    efl_event_callback_array_add(obj, event_catcher_watch(), pd);
 
-   pd->providers = eina_hash_pointer_new((void*) eo_unref);
+   pd->providers = eina_hash_pointer_new((void*) efl_unref);
 
    return obj;
 }
@@ -2823,7 +2823,7 @@ _efl_loop_efl_object_constructor(Eo *obj, Efl_Loop_Data *pd)
 EOLIAN static void
 _efl_loop_efl_object_destructor(Eo *obj, Efl_Loop_Data *pd)
 {
-   efl_destructor(eo_super(obj, EFL_LOOP_CLASS));
+   efl_destructor(efl_super(obj, EFL_LOOP_CLASS));
 
    eina_hash_free(pd->providers);
 }
@@ -2905,7 +2905,7 @@ ecore_loop_arguments_send(int argc, const char **argv)
 static void _efl_loop_timeout_force_cancel_cb(void *data, const Eo_Event *event EINA_UNUSED);
 static void _efl_loop_timeout_cb(void *data, const Eo_Event *event EINA_UNUSED);
 
-EO_CALLBACKS_ARRAY_DEFINE(timeout,
+EFL_CALLBACKS_ARRAY_DEFINE(timeout,
                           { EFL_LOOP_TIMER_EVENT_TICK, _efl_loop_timeout_cb },
                           { EFL_EVENT_DEL, _efl_loop_timeout_force_cancel_cb });
 
@@ -3007,9 +3007,9 @@ _efl_loop_timeout(Eo *obj, Efl_Loop_Data *pd EINA_UNUSED, double time, const voi
    if (!t) goto on_error;
 
    t->job_is = EINA_FALSE;
-   t->u.timer = eo_add(EFL_LOOP_TIMER_CLASS, obj,
-                       efl_loop_timer_interval_set(eo_self, time),
-                       efl_event_callback_array_add(eo_self, timeout(), t));
+   t->u.timer = efl_add(EFL_LOOP_TIMER_CLASS, obj,
+                       efl_loop_timer_interval_set(efl_self, time),
+                       efl_event_callback_array_add(efl_self, timeout(), t));
 
    if (!t->u.timer) goto on_error;
 
@@ -3026,11 +3026,11 @@ static Eina_Bool
 _efl_loop_register(Eo *obj EINA_UNUSED, Efl_Loop_Data *pd, const Efl_Class *klass, const Efl_Object *provider)
 {
    // The passed object does not provide that said class.
-   if (!eo_isa(provider, klass)) return EINA_FALSE;
+   if (!efl_isa(provider, klass)) return EINA_FALSE;
 
-   // Note: I would prefer to use eo_xref here, but I can't figure a nice way to
-   // call eo_xunref on hash destruction.
-   return eina_hash_add(pd->providers, &klass, eo_ref(provider));
+   // Note: I would prefer to use efl_xref here, but I can't figure a nice way to
+   // call efl_xunref on hash destruction.
+   return eina_hash_add(pd->providers, &klass, efl_ref(provider));
 }
 
 static Eina_Bool
diff --git a/src/lib/ecore/ecore_poller.c b/src/lib/ecore/ecore_poller.c
index cc4e4f406e..d1c645a5bd 100644
--- a/src/lib/ecore/ecore_poller.c
+++ b/src/lib/ecore/ecore_poller.c
@@ -14,7 +14,7 @@
 #define MY_CLASS_NAME "Ecore_Poller"
 
 #define ECORE_POLLER_CHECK(obj)                       \
-  if (!eo_isa((obj), ECORE_POLLER_CLASS)) \
+  if (!efl_isa((obj), ECORE_POLLER_CLASS)) \
     return
 
 struct _Ecore_Poller_Data
@@ -174,10 +174,10 @@ _ecore_poller_cb_timer(void *data EINA_UNUSED)
                         pollers[i] = (Ecore_Poller_Data *)eina_inlist_remove(EINA_INLIST_GET(pollers[i]), EINA_INLIST_GET(poller));
 
                         efl_parent_set(poller->obj, NULL);
-                        if (eo_destructed_is(poller->obj))
-                           eo_manual_free(poller->obj);
+                        if (efl_destructed_is(poller->obj))
+                           efl_manual_free(poller->obj);
                         else
-                           eo_manual_free_set(poller->obj, EINA_FALSE);
+                           efl_manual_free_set(poller->obj, EINA_FALSE);
 
                         poller_delete_count--;
                         changes++;
@@ -237,7 +237,7 @@ ecore_poller_add(Ecore_Poller_Type type EINA_UNUSED,
                  const void       *data)
 {
    Ecore_Poller *poller;
-   poller = eo_add(MY_CLASS, _ecore_parent, ecore_poller_constructor(eo_self, type, interval, func, data));
+   poller = efl_add(MY_CLASS, _ecore_parent, ecore_poller_constructor(efl_self, type, interval, func, data));
    return poller;
 }
 
@@ -253,7 +253,7 @@ _ecore_poller_constructor(Eo *obj, Ecore_Poller_Data *poller, Ecore_Poller_Type
          EINA_MAIN_LOOP_CHECK_RETURN;
       }
 
-   eo_manual_free_set(obj, EINA_TRUE);
+   efl_manual_free_set(obj, EINA_TRUE);
 
    if (!func)
      {
@@ -337,7 +337,7 @@ ecore_poller_del(Ecore_Poller *obj)
 
    if (!obj) return NULL;
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   Ecore_Poller_Data *poller = eo_data_scope_get(obj, MY_CLASS);
+   Ecore_Poller_Data *poller = efl_data_scope_get(obj, MY_CLASS);
    /* we are walking the poller list - a bad idea to remove from it while
     * walking it, so just flag it as delete_me and come back to it after
     * the loop has finished */
@@ -352,10 +352,10 @@ ecore_poller_del(Ecore_Poller *obj)
    pollers[poller->ibit] = (Ecore_Poller_Data *)eina_inlist_remove(EINA_INLIST_GET(pollers[poller->ibit]), EINA_INLIST_GET(poller));
 
    efl_parent_set(poller->obj, NULL);
-   if (eo_destructed_is(poller->obj))
-      eo_manual_free(obj);
+   if (efl_destructed_is(poller->obj))
+      efl_manual_free(obj);
    else
-      eo_manual_free_set(obj, EINA_FALSE);
+      efl_manual_free_set(obj, EINA_FALSE);
 
    _ecore_poller_next_tick_eval();
    return data;
@@ -370,7 +370,7 @@ _ecore_poller_efl_object_destructor(Eo *obj, Ecore_Poller_Data *pd)
      poller_delete_count++;
    }
 
-   efl_destructor(eo_super(obj, MY_CLASS));
+   efl_destructor(efl_super(obj, MY_CLASS));
 }
 
 EOLIAN static Eo *
@@ -381,7 +381,7 @@ _ecore_poller_efl_object_finalize(Eo *obj, Ecore_Poller_Data *pd)
       return NULL;
    }
 
-   return efl_finalize(eo_super(obj, MY_CLASS));
+   return efl_finalize(efl_super(obj, MY_CLASS));
 }
 
 void
@@ -396,10 +396,10 @@ _ecore_poller_shutdown(void)
           {
              pollers[i] = (Ecore_Poller_Data *)eina_inlist_remove(EINA_INLIST_GET(pollers[i]), EINA_INLIST_GET(pollers[i]));
              efl_parent_set(poller->obj, NULL);
-             if (eo_destructed_is(poller->obj))
-                eo_manual_free(poller->obj);
+             if (efl_destructed_is(poller->obj))
+                efl_manual_free(poller->obj);
              else
-                eo_manual_free_set(poller->obj, EINA_FALSE);
+                efl_manual_free_set(poller->obj, EINA_FALSE);
           }
      }
 }
diff --git a/src/lib/ecore/ecore_timer.c b/src/lib/ecore/ecore_timer.c
index d9572f0075..9998ff3126 100644
--- a/src/lib/ecore/ecore_timer.c
+++ b/src/lib/ecore/ecore_timer.c
@@ -14,7 +14,7 @@
 #define MY_CLASS_NAME "Efl_Loop_Timer"
 
 #define ECORE_TIMER_CHECK(obj)                       \
-  if (!eo_isa((obj), MY_CLASS)) \
+  if (!efl_isa((obj), MY_CLASS)) \
     return
 
 struct _Efl_Loop_Timer_Data
@@ -112,14 +112,14 @@ _check_timer_event_catcher_del(void *data, const Eo_Event *event)
      }
 }
 
-EO_CALLBACKS_ARRAY_DEFINE(timer_watch,
+EFL_CALLBACKS_ARRAY_DEFINE(timer_watch,
                           { EFL_EVENT_CALLBACK_ADD, _check_timer_event_catcher_add },
                           { EFL_EVENT_CALLBACK_DEL, _check_timer_event_catcher_del });
 
 EOLIAN static Eo *
 _efl_loop_timer_efl_object_constructor(Eo *obj, Efl_Loop_Timer_Data *timer)
 {
-   efl_constructor(eo_super(obj, MY_CLASS));
+   efl_constructor(efl_super(obj, MY_CLASS));
 
    efl_event_callback_array_add(obj, timer_watch(), timer);
 
@@ -137,7 +137,7 @@ _efl_loop_timer_efl_object_finalize(Eo *obj, Efl_Loop_Timer_Data *pd)
 {
    _efl_loop_timer_util_instanciate(pd);
 
-   return efl_finalize(eo_super(obj, MY_CLASS));
+   return efl_finalize(efl_super(obj, MY_CLASS));
 }
 
 typedef struct _Ecore_Timer_Legacy Ecore_Timer_Legacy;
@@ -172,7 +172,7 @@ _ecore_timer_legacy_tick(void *data, const Eo_Event *event)
      legacy->inside_call = 0;
 }
 
-EO_CALLBACKS_ARRAY_DEFINE(legacy_timer,
+EFL_CALLBACKS_ARRAY_DEFINE(legacy_timer,
                           { EFL_LOOP_TIMER_EVENT_TICK, _ecore_timer_legacy_tick },
                           { EFL_EVENT_DEL, _ecore_timer_legacy_del });
 
@@ -190,10 +190,10 @@ ecore_timer_add(double        in,
 
    legacy->func = func;
    legacy->data = data;
-   timer = eo_add(MY_CLASS, ecore_main_loop_get(),
-                  efl_event_callback_array_add(eo_self, legacy_timer(), legacy),
-                  efl_key_data_set(eo_self, "_legacy", legacy),
-                  efl_loop_timer_interval_set(eo_self, in));
+   timer = efl_add(MY_CLASS, ecore_main_loop_get(),
+                  efl_event_callback_array_add(efl_self, legacy_timer(), legacy),
+                  efl_key_data_set(efl_self, "_legacy", legacy),
+                  efl_loop_timer_interval_set(efl_self, in));
 
    return timer;
 }
@@ -212,11 +212,11 @@ ecore_timer_loop_add(double        in,
 
    legacy->func = func;
    legacy->data = data;
-   timer = eo_add(MY_CLASS, ecore_main_loop_get(),
-                  efl_event_callback_array_add(eo_self, legacy_timer(), legacy),
-                  efl_key_data_set(eo_self, "_legacy", legacy),
-                  efl_loop_timer_loop_reset(eo_self),
-                  efl_loop_timer_interval_set(eo_self, in));
+   timer = efl_add(MY_CLASS, ecore_main_loop_get(),
+                  efl_event_callback_array_add(efl_self, legacy_timer(), legacy),
+                  efl_key_data_set(efl_self, "_legacy", legacy),
+                  efl_loop_timer_loop_reset(efl_self),
+                  efl_loop_timer_interval_set(efl_self, in));
 
    return timer;
 }
@@ -236,7 +236,7 @@ ecore_timer_del(Ecore_Timer *timer)
      {
         // Just in case it is an Eo timer, but not a legacy one.
         ERR("You are trying to destroy a timer which seems dead already.");
-        eo_unref(timer);
+        efl_unref(timer);
         return NULL;
      }
 
@@ -356,7 +356,7 @@ _efl_loop_timer_efl_object_event_freeze(Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data
 
    EINA_MAIN_LOOP_CHECK_RETURN;
 
-   efl_event_freeze(eo_super(obj, MY_CLASS));
+   efl_event_freeze(efl_super(obj, MY_CLASS));
 
    /* Timer already frozen */
    if (timer->frozen)
@@ -404,7 +404,7 @@ _efl_loop_timer_efl_object_event_thaw(Eo *obj, Efl_Loop_Timer_Data *timer)
 
    EINA_MAIN_LOOP_CHECK_RETURN;
 
-   efl_event_thaw(eo_super(obj, MY_CLASS));
+   efl_event_thaw(efl_super(obj, MY_CLASS));
 
    /* Timer not frozen */
    if (!timer->frozen)
@@ -479,7 +479,7 @@ _efl_loop_timer_efl_object_parent_set(Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data *
    else if (first == suspended)
      suspended = eina_inlist_remove(suspended, EINA_INLIST_GET(pd));
 
-   efl_parent_set(eo_super(obj, EFL_LOOP_USER_CLASS), parent);
+   efl_parent_set(efl_super(obj, EFL_LOOP_USER_CLASS), parent);
 
    if (efl_parent_get(obj) != parent)
      return ;
@@ -511,7 +511,7 @@ _efl_loop_timer_efl_object_destructor(Eo *obj, Efl_Loop_Timer_Data *pd)
    else if (first == suspended)
      suspended = eina_inlist_remove(suspended, EINA_INLIST_GET(pd));
 
-   efl_destructor(eo_super(obj, MY_CLASS));
+   efl_destructor(efl_super(obj, MY_CLASS));
 }
 
 void
@@ -575,7 +575,7 @@ _efl_loop_timer_next_get(void)
    object = _efl_loop_timer_first_get();
    if (!object) return -1;
 
-   first = _efl_loop_timer_after_get(eo_data_scope_get(object, MY_CLASS));
+   first = _efl_loop_timer_after_get(efl_data_scope_get(object, MY_CLASS));
 
    now = ecore_loop_time_get();
    in = first->at - now;
@@ -656,7 +656,7 @@ _efl_loop_timer_expired_call(double when)
              continue;
           }
 
-        eo_ref(timer->object);
+        efl_ref(timer->object);
         eina_evlog("+timer", timer, 0.0, NULL);
         efl_event_callback_call(timer->object, EFL_LOOP_TIMER_EVENT_TICK, NULL);
         eina_evlog("-timer", timer, 0.0, NULL);
@@ -667,7 +667,7 @@ _efl_loop_timer_expired_call(double when)
           timer_current = (Efl_Loop_Timer_Data *)EINA_INLIST_GET(timer_current)->next;
 
         _efl_loop_timer_reschedule(timer, when);
-        eo_unref(timer->object);
+        efl_unref(timer->object);
      }
    return 0;
 }
diff --git a/src/lib/ecore/efl_loop_fd.c b/src/lib/ecore/efl_loop_fd.c
index dc7f472349..672dc187fe 100644
--- a/src/lib/ecore/efl_loop_fd.c
+++ b/src/lib/ecore/efl_loop_fd.c
@@ -146,14 +146,14 @@ _check_fd_event_catcher_del(void *data, const Eo_Event *event)
      }
 }
 
-EO_CALLBACKS_ARRAY_DEFINE(fd_watch,
+EFL_CALLBACKS_ARRAY_DEFINE(fd_watch,
                           { EFL_EVENT_CALLBACK_ADD, _check_fd_event_catcher_add },
                           { EFL_EVENT_CALLBACK_DEL, _check_fd_event_catcher_del });
 
 static Efl_Object *
 _efl_loop_fd_efl_object_constructor(Eo *obj, Efl_Loop_Fd_Data *pd)
 {
-   efl_constructor(eo_super(obj, MY_CLASS));
+   efl_constructor(efl_super(obj, MY_CLASS));
 
    efl_event_callback_array_add(obj, fd_watch(), pd);
 
@@ -168,7 +168,7 @@ _efl_loop_fd_efl_object_parent_set(Eo *obj, Efl_Loop_Fd_Data *pd, Efl_Object *pa
    if (pd->handler) ecore_main_fd_handler_del(pd->handler);
    pd->handler = NULL;
 
-   efl_parent_set(eo_super(obj, MY_CLASS), parent);
+   efl_parent_set(efl_super(obj, MY_CLASS), parent);
 
    if (parent == NULL) return ;
 
@@ -178,7 +178,7 @@ _efl_loop_fd_efl_object_parent_set(Eo *obj, Efl_Loop_Fd_Data *pd, Efl_Object *pa
 static void
 _efl_loop_fd_efl_object_destructor(Eo *obj, Efl_Loop_Fd_Data *pd)
 {
-   efl_destructor(eo_super(obj, MY_CLASS));
+   efl_destructor(efl_super(obj, MY_CLASS));
 
    ecore_main_fd_handler_del(pd->handler);
 }
diff --git a/src/lib/ecore/efl_loop_user.c b/src/lib/ecore/efl_loop_user.c
index 3dc8ffaa9e..78ac3a83d7 100644
--- a/src/lib/ecore/efl_loop_user.c
+++ b/src/lib/ecore/efl_loop_user.c
@@ -23,7 +23,7 @@ _efl_loop_user_efl_object_parent_set(Eo *obj, Efl_Loop_User_Data *pd EINA_UNUSED
    if (parent != NULL && efl_provider_find(parent, EFL_LOOP_CLASS) == NULL)
      return ;
 
-   efl_parent_set(eo_super(obj, EFL_LOOP_USER_CLASS), parent);
+   efl_parent_set(efl_super(obj, EFL_LOOP_USER_CLASS), parent);
 }
 
 #include "efl_loop_user.eo.c"