ecore - begin moving data into the efl loop data in the object

we really should have data inside the loop object, so begin moving it
one small thing at a time. this is the basics that will allow multiple
efl loops. make an eo efl object and class for fd handlers that is efl loop
bound make fd handlers really bound to their parent loop and not global  as
well as have a nice class/obj. create an message queue per loop and
put legacy ecore events on top of it... and a lot more.

this is not 100% done, but it's a lot of the core and groundwork.
various ecore_timer_add(), ecore_diler_add() etc. need changes.

The following still need doing:

  ecore_timer (internal usage for sure)
  ecore_idler (internal usage for sure)
  ecore_idle_enterer
  ecore_idle_exiter
  ecore_pollers? (is the new efl loop stuff ok?)
  ecore_exe (fork/spawn from any thread and track exe from that thread?)
  ecore_signal code
  ecore_throttle (should we have a single global too? we have per loop)
  ecore_app ? (should every loop be given its own argv/argc?)

Lots of internal ecore code uses/calls these legacy calls and we
should have efl loop replacements and/or use the ones we have

The following will bedifferently designed for loop to loop
control/messaging/ipc:

  ecore_thread
  ecore_pipe

32 files changed, 5063 insertions, 3973 deletions

diff --git a/src/Makefile_Ecore.am b/src/Makefile_Ecore.am
index f96773852a..d0680de060 100644
--- a/src/Makefile_Ecore.am
+++ b/src/Makefile_Ecore.am
@@ -3,12 +3,17 @@
 
 ecore_eolian_files_legacy = \
         lib/ecore/ecore_exe.eo \
+        lib/ecore/ecore_event_message.eo \
+        lib/ecore/ecore_event_message_handler.eo \
         lib/ecore/efl_loop_timer.eo
 
 ecore_eolian_files_public = \
         lib/ecore/efl_loop.eo \
         lib/ecore/efl_loop_consumer.eo \
         lib/ecore/efl_loop_fd.eo \
+        lib/ecore/efl_loop_handler.eo \
+        lib/ecore/efl_loop_message.eo \
+        lib/ecore/efl_loop_message_handler.eo \
         lib/ecore/efl_io_closer_fd.eo \
         lib/ecore/efl_io_positioner_fd.eo \
         lib/ecore/efl_io_reader_fd.eo \
@@ -84,8 +89,14 @@ lib/ecore/ecore_idle_exiter.c \
 lib/ecore/ecore_idler.c \
 lib/ecore/ecore_job.c \
 lib/ecore/ecore_main.c \
+lib/ecore/ecore_event_message.c \
+lib/ecore/ecore_event_message_handler.c \
+lib/ecore/efl_loop.c \
 lib/ecore/efl_loop_consumer.c \
 lib/ecore/efl_loop_fd.c \
+lib/ecore/efl_loop_handler.c \
+lib/ecore/efl_loop_message.c \
+lib/ecore/efl_loop_message_handler.c \
 lib/ecore/efl_io_closer_fd.c \
 lib/ecore/efl_io_positioner_fd.c \
 lib/ecore/efl_io_reader_fd.c \
@@ -115,6 +126,7 @@ lib/ecore/efl_interpolator_divisor.c \
 lib/ecore/efl_interpolator_bounce.c \
 lib/ecore/efl_interpolator_spring.c \
 lib/ecore/efl_interpolator_cubic_bezier.c \
+lib/ecore/ecore_main_timechanges.c \
 lib/ecore/ecore_pipe.c \
 lib/ecore/ecore_poller.c \
 lib/ecore/ecore_time.c \
@@ -124,7 +136,9 @@ lib/ecore/ecore_throttle.c \
 lib/ecore/ecore_exe.c \
 lib/ecore/ecore_exe_private.h \
 lib/ecore/ecore_private.h \
-lib/ecore/ecore_internal.h
+lib/ecore/ecore_internal.h \
+lib/ecore/ecore_main_common.h
+
 
 if HAVE_WIN32
 lib_ecore_libecore_la_SOURCES += lib/ecore/ecore_exe_win32.c
diff --git a/src/lib/ecore/Ecore_Eo.h b/src/lib/ecore/Ecore_Eo.h
index 9203bf1e4d..be1929aa42 100644
--- a/src/lib/ecore/Ecore_Eo.h
+++ b/src/lib/ecore/Ecore_Eo.h
@@ -29,12 +29,18 @@
  */
 
 
+#include "ecore_event_message.eo.h"
+#include "ecore_event_message_handler.eo.h"
+
 /**
  * @ingroup Ecore_MainLoop_Group
  *
  * @{
  */
 
+#include "efl_loop_message.eo.h"
+#include "efl_loop_message_handler.eo.h"
+
 #include "efl_loop.eo.h"
 
 /**
@@ -56,6 +62,7 @@ EAPI int efl_loop_exit_code_process(Eina_Value *value);
 EAPI Eina_Future_Scheduler *efl_loop_future_scheduler_get(Eo *obj);
 
 #include "efl_loop_fd.eo.h"
+#include "efl_loop_handler.eo.h"
 
 #include "efl_promise.eo.h"
 
diff --git a/src/lib/ecore/ecore.c b/src/lib/ecore/ecore.c
index 97dc4b2aa3..0c19d4b482 100644
--- a/src/lib/ecore/ecore.c
+++ b/src/lib/ecore/ecore.c
@@ -273,14 +273,12 @@ ecore_init(void)
    if (getenv("ECORE_FPS_DEBUG")) _ecore_fps_debug = 1;
    if (_ecore_fps_debug) _ecore_fps_debug_init();
    if (!ecore_mempool_init()) goto shutdown_mempool;
-   if (!_ecore_event_init()) goto shutdown_mempool;
    _ecore_main_loop_init();
+   if (!_ecore_event_init()) goto shutdown_event;
 
    vpath = efl_add(EFL_VPATH_CORE_CLASS, NULL);
    if (vpath) efl_vpath_manager_register(EFL_VPATH_MANAGER_CLASS, 0, vpath);
 
-   _mainloop_singleton = efl_add(EFL_LOOP_CLASS, NULL);
-
    _ecore_signal_init();
 #ifndef HAVE_EXOTIC
    _ecore_exe_init();
@@ -359,6 +357,9 @@ ecore_init(void)
 
    return _ecore_init_count;
 
+shutdown_event:
+   _ecore_event_shutdown();
+   _ecore_main_shutdown();
 shutdown_mempool:
    ecore_mempool_shutdown();
    efl_object_shutdown();
@@ -403,9 +404,6 @@ ecore_shutdown(void)
        }
 #endif
 
-     efl_del(_mainloop_singleton);
-     _mainloop_singleton = NULL;
-
      if (_ecore_fps_debug) _ecore_fps_debug_shutdown();
      _ecore_poller_shutdown();
      _ecore_animator_shutdown();
@@ -442,7 +440,6 @@ ecore_shutdown(void)
 #ifndef HAVE_EXOTIC
      _ecore_exe_shutdown();
 #endif
-     _efl_loop_timer_shutdown();
      _ecore_event_shutdown();
      _ecore_main_shutdown();
      _ecore_signal_shutdown();
diff --git a/src/lib/ecore/ecore_alloc.c b/src/lib/ecore/ecore_alloc.c
index 3196b82a2d..c98ef92335 100644
--- a/src/lib/ecore/ecore_alloc.c
+++ b/src/lib/ecore/ecore_alloc.c
@@ -33,9 +33,9 @@ struct _Ecore_Mempool
   }
 
 //GENERIC_ALLOC_FREE(Ecore_Animator, ecore_animator);
-GENERIC_ALLOC_FREE(Ecore_Event_Handler, ecore_event_handler);
-GENERIC_ALLOC_FREE(Ecore_Event_Filter, ecore_event_filter);
-GENERIC_ALLOC_FREE(Ecore_Event, ecore_event);
+//GENERIC_ALLOC_FREE(Ecore_Event_Handler, ecore_event_handler);
+//GENERIC_ALLOC_FREE(Ecore_Event_Filter, ecore_event_filter);
+//GENERIC_ALLOC_FREE(Ecore_Event, ecore_event);
 //GENERIC_ALLOC_FREE(Ecore_Idle_Exiter, ecore_idle_exiter);
 //GENERIC_ALLOC_FREE(Ecore_Idle_Enterer, ecore_idle_enterer);
 //GENERIC_ALLOC_FREE(Ecore_Idler, ecore_idler);
@@ -51,9 +51,9 @@ GENERIC_ALLOC_FREE(Ecore_Win32_Handler, ecore_win32_handler);
 
 static Ecore_Mempool *mempool_array[] = {
 //  &ecore_animator_mp,
-  &ecore_event_handler_mp,
-  &ecore_event_filter_mp,
-  &ecore_event_mp,
+//  &ecore_event_handler_mp,
+//  &ecore_event_filter_mp,
+//  &ecore_event_mp,
 //  &ecore_idle_exiter_mp,
 //  &ecore_idle_enterer_mp,
 //  &ecore_idler_mp,
@@ -78,9 +78,9 @@ ecore_mempool_init(void)
    Type##_mp.size = _ecore_sizeof_##TYPE
 
 //   MP_SIZE_INIT(Ecore_Animator, ecore_animator);
-   MP_SIZE_INIT(Ecore_Event_Handler, ecore_event_handler);
-   MP_SIZE_INIT(Ecore_Event_Filter, ecore_event_filter);
-   MP_SIZE_INIT(Ecore_Event, ecore_event);
+//   MP_SIZE_INIT(Ecore_Event_Handler, ecore_event_handler);
+//   MP_SIZE_INIT(Ecore_Event_Filter, ecore_event_filter);
+//   MP_SIZE_INIT(Ecore_Event, ecore_event);
 //   MP_SIZE_INIT(Ecore_Idle_Exiter, ecore_idle_exiter);
 //   MP_SIZE_INIT(Ecore_Idle_Enterer, ecore_idle_enterer);
 //   MP_SIZE_INIT(Ecore_Idler, ecore_idler);
diff --git a/src/lib/ecore/ecore_event_message.c b/src/lib/ecore/ecore_event_message.c
new file mode 100644
index 0000000000..ca072f8524
--- /dev/null
+++ b/src/lib/ecore/ecore_event_message.c
@@ -0,0 +1,81 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <Ecore.h>
+
+#include "ecore_private.h"
+
+#define MY_CLASS ECORE_EVENT_MESSAGE_CLASS
+
+//////////////////////////////////////////////////////////////////////////
+
+typedef struct _Ecore_Event_Message_Data Ecore_Event_Message_Data;
+
+struct _Ecore_Event_Message_Data
+{
+   int type;
+   void *ev;
+   Ecore_End_Cb free_func;
+   void *data;
+};
+
+//////////////////////////////////////////////////////////////////////////
+
+EOLIAN static void
+_ecore_event_message_data_set(Eo *obj EINA_UNUSED, Ecore_Event_Message_Data *pd, int type, void *data, void *free_func, void *free_data)
+{
+   pd->type = type;
+   pd->ev = data;
+   pd->free_func = free_func;
+   pd->data = free_data;
+}
+
+EOLIAN static void
+_ecore_event_message_data_get(Eo *obj EINA_UNUSED, Ecore_Event_Message_Data *pd, int *type, void **data, void **free_func, void **free_data)
+{
+   if (type) *type = pd->type;
+   if (data) *data = pd->ev;
+   if (free_func) *free_func = pd->free_func;
+   if (free_data) *free_data = pd->data;
+}
+
+EOLIAN static void
+_ecore_event_message_data_steal(Eo *obj EINA_UNUSED, Ecore_Event_Message_Data *pd, int *type, void **data, void **free_func, void **free_data)
+{
+   if (type) *type = pd->type;
+   if (data) *data = pd->ev;
+   if (free_func) *free_func = pd->free_func;
+   if (free_data) *free_data = pd->data;
+   pd->type = -1;
+   pd->ev = NULL;
+   pd->free_func = NULL;
+   pd->data = NULL;
+}
+
+EOLIAN static Efl_Object *
+_ecore_event_message_efl_object_constructor(Eo *obj, Ecore_Event_Message_Data *pd EINA_UNUSED)
+{
+   obj = efl_constructor(efl_super(obj, MY_CLASS));
+   pd->type = -1;
+   return obj;
+}
+
+EOLIAN static void
+_ecore_event_message_efl_object_destructor(Eo *obj EINA_UNUSED, Ecore_Event_Message_Data *pd EINA_UNUSED)
+{
+   if (pd->ev)
+     {
+        Ecore_End_Cb fn_free = pd->free_func;
+        void *ev = pd->ev;
+
+        pd->ev = NULL;
+        if (fn_free) fn_free(pd->data, ev);
+        else free(ev);
+     }
+   efl_destructor(efl_super(obj, MY_CLASS));
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+#include "ecore_event_message.eo.c"
diff --git a/src/lib/ecore/ecore_event_message.eo b/src/lib/ecore/ecore_event_message.eo
new file mode 100644
index 0000000000..002197a122
--- /dev/null
+++ b/src/lib/ecore/ecore_event_message.eo
@@ -0,0 +1,34 @@
+import efl_types;
+import eina_types;
+
+class Ecore.Event.Message (Efl.Loop.Message)
+{
+   [[ For Legacy API usage Only. Legacy Ecore Events ]]
+   methods {
+      @property data {
+         [[ Property of the legacy event - set and get it ]]
+         set { }
+         get { }
+         values {
+            type: int; [[ The event type ]]
+            data: void_ptr; [[ The event data ]]
+            free_func: void_ptr; [[ Being lazy for legacy ]]
+            free_data: void_ptr; [[ Free func data ]]
+         }
+      }
+      data_steal {
+         [[ Steal the data out and set internal values to -1
+            for type and NULL for other vals ]]
+         params {
+            @out type: int; [[ The event type ]]
+            @out data: void_ptr; [[ The event data ]]
+            @out free_func: void_ptr; [[ Being lazy for legacy ]]
+            @out free_data: void_ptr; [[ Free func data ]]
+         }
+      }
+   }
+   implements {
+      Efl.Object.constructor;
+      Efl.Object.destructor;
+   }
+}
diff --git a/src/lib/ecore/ecore_event_message_handler.c b/src/lib/ecore/ecore_event_message_handler.c
new file mode 100644
index 0000000000..3879c3c78e
--- /dev/null
+++ b/src/lib/ecore/ecore_event_message_handler.c
@@ -0,0 +1,414 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <Ecore.h>
+
+#include "ecore_private.h"
+
+#define MY_CLASS ECORE_EVENT_MESSAGE_HANDLER_CLASS
+
+//////////////////////////////////////////////////////////////////////////
+
+typedef struct _Handler Handler;
+typedef struct _Filter Filter;
+
+struct _Handler
+{
+   EINA_INLIST;
+   Ecore_Event_Handler_Cb  func;
+   void                   *data;
+   int                     type;
+   Eina_Bool               delete_me : 1;
+   Eina_Bool               to_add : 1;
+};
+
+struct _Filter
+{
+   EINA_INLIST;
+   Ecore_Data_Cb    func_start;
+   Ecore_Filter_Cb  func_filter;
+   Ecore_End_Cb     func_end;
+   void            *data;
+   void            *loop_data;
+   Eina_Bool        delete_me : 1;
+};
+
+typedef struct _Ecore_Event_Message_Handler_Data Ecore_Event_Message_Handler_Data;
+
+struct _Ecore_Event_Message_Handler_Data
+{
+   int           event_type_count;
+   Eina_Inlist **handlers; // array of event_type_count inlists of handlers
+   Eina_Inlist  *filters;
+   Eina_List    *handlers_delete;
+   Eina_List    *handlers_add;
+   Eina_List    *filters_delete;
+   Eina_List    *filters_add;
+   void         *current_event_data;
+   int           current_event_type;
+   int           handlers_walking;
+   int           filters_walking;
+};
+
+//////////////////////////////////////////////////////////////////////////
+
+Eina_Bool
+_ecore_event_do_filter(void *handler_pd, Eo *msg_handler, Eo *msg)
+{
+   Filter *f;
+   void *ev;
+   int type;
+   Ecore_Event_Message_Handler_Data *eemhd = handler_pd;
+
+   if (!eemhd->filters) return EINA_TRUE;
+   if (!efl_isa(msg_handler, MY_CLASS)) return EINA_TRUE;
+   eemhd->filters_walking++;
+   EINA_INLIST_FOREACH(eemhd->filters, f)
+     {
+        if (f->delete_me) continue;
+        type = -1;
+        ev = NULL;
+        ecore_event_message_data_get(msg, &type, &ev, NULL, NULL);
+        if (type >= 0)
+          {
+             if (!f->func_filter(f->data, f->loop_data, type, ev))
+               _efl_loop_message_unsend(msg);
+          }
+     }
+   eemhd->filters_walking--;
+   return EINA_TRUE;
+}
+
+void
+_ecore_event_filters_call(Eo *obj, Efl_Loop_Data *pd)
+{
+   Filter *f;
+   Ecore_Event_Message_Handler_Data *eemhd;
+   Eo *ecore_event_handler = efl_loop_message_handler_get
+     (EFL_LOOP_CLASS, obj, ECORE_EVENT_MESSAGE_HANDLER_CLASS);
+
+   if (!ecore_event_handler) return;
+   eemhd = efl_data_scope_get(ecore_event_handler, MY_CLASS);
+   if (!eemhd) return;
+   if (!eemhd->filters) return;
+   eemhd->filters_walking++;
+   EINA_INLIST_FOREACH(eemhd->filters, f)
+     {
+        if (f->delete_me) continue;
+        if (f->func_start) f->loop_data = f->func_start(f->data);
+     }
+   _efl_loop_messages_filter(obj, pd, eemhd);
+   EINA_INLIST_FOREACH(eemhd->filters, f)
+     {
+        if (f->delete_me) continue;
+        if (f->func_end) f->func_end(f->data, f->loop_data);
+     }
+   eemhd->filters_walking--;
+   if (eemhd->filters_walking == 0)
+     {
+        EINA_LIST_FREE(eemhd->filters_delete, f)
+          {
+             free(f);
+          }
+     }
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+EOLIAN static Ecore_Event_Message *
+_ecore_event_message_handler_message_type_add(Eo *obj, Ecore_Event_Message_Handler_Data *pd EINA_UNUSED)
+{
+   // XXX: implemented event obj cache
+   return efl_add(ECORE_EVENT_MESSAGE_CLASS, obj);
+}
+
+EOLIAN static int
+_ecore_event_message_handler_type_new(Eo *obj EINA_UNUSED, Ecore_Event_Message_Handler_Data *pd)
+{
+   Eina_Inlist **tmp;
+   int evnum;
+
+   evnum = pd->event_type_count + 1;
+   tmp = realloc(pd->handlers, sizeof(Eina_Inlist *) * (evnum + 1));
+   if (!tmp) return 0;
+   pd->handlers = tmp;
+   pd->handlers[evnum] = NULL;
+   pd->event_type_count = evnum;
+   return evnum;
+}
+
+EOLIAN static void *
+_ecore_event_message_handler_handler_add(Eo *obj EINA_UNUSED, Ecore_Event_Message_Handler_Data *pd, int type, void *func, void *data)
+{
+   Handler *h;
+
+   if ((type < 0) || (type > pd->event_type_count) || (!func)) return NULL;
+   h = calloc(1, sizeof(Handler));
+   if (!h) return NULL;
+   h->func = func;
+   h->data = data;
+   h->type = type;
+   if (pd->current_event_type == type)
+     {
+        h->to_add = EINA_TRUE;
+        pd->handlers_add = eina_list_append(pd->handlers_add, h);
+     }
+   else
+     pd->handlers[type] = eina_inlist_append(pd->handlers[type],
+                                             EINA_INLIST_GET(h));
+   return h;
+}
+
+EOLIAN static void *
+_ecore_event_message_handler_handler_del(Eo *obj EINA_UNUSED, Ecore_Event_Message_Handler_Data *pd, void *handler)
+{
+   Handler *h = handler;
+   void *data;
+
+   if (!h) return NULL;
+   if ((h->type < 0) || (h->type > pd->event_type_count)) return NULL;
+   data = h->data;
+   if (pd->handlers_walking > 0)
+     {
+        h->delete_me = EINA_TRUE;
+        pd->handlers_delete = eina_list_append(pd->handlers_delete, h);
+     }
+   else
+     {
+        if (h->to_add)
+          pd->handlers_add = eina_list_remove(pd->handlers_add, h);
+        else
+          pd->handlers[h->type] = eina_inlist_remove(pd->handlers[h->type],
+                                                     EINA_INLIST_GET(h));
+        free(h);
+     }
+   return data;
+}
+
+EOLIAN static void *
+_ecore_event_message_handler_handler_data_get(Eo *obj EINA_UNUSED, Ecore_Event_Message_Handler_Data *pd EINA_UNUSED, void *handler)
+{
+   Handler *h = handler;
+
+   if (!h) return NULL;
+   return h->data;
+}
+
+EOLIAN static void *
+_ecore_event_message_handler_handler_data_set(Eo *obj EINA_UNUSED, Ecore_Event_Message_Handler_Data *pd EINA_UNUSED, void *handler, void *data)
+{
+   Handler *h = handler;
+   void *prev_data;
+
+   if (!h) return NULL;
+   prev_data = h->data;
+   h->data = data;
+   return prev_data;
+}
+
+EOLIAN static void *
+_ecore_event_message_handler_filter_add(Eo *obj EINA_UNUSED, Ecore_Event_Message_Handler_Data *pd, void *func_start, void *func_filter, void *func_end, void *data)
+{
+   Filter *f;
+
+   if (!func_filter) return NULL;
+   f = calloc(1, sizeof(Filter));
+   if (!f) return NULL;
+   f->func_start = func_start;
+   f->func_filter = func_filter;
+   f->func_end = func_end;
+   f->data = data;
+   pd->filters = eina_inlist_append(pd->filters, EINA_INLIST_GET(f));
+   return f;
+}
+
+EOLIAN static void *
+_ecore_event_message_handler_filter_del(Eo *obj EINA_UNUSED, Ecore_Event_Message_Handler_Data *pd, void *filter)
+{
+   Filter *f = filter;
+   void *data;
+
+   if (!f) return NULL;
+   data = f->data;
+   if (pd->filters_walking > 0)
+     {
+        f->delete_me = EINA_TRUE;
+        pd->filters_delete = eina_list_append(pd->filters_delete, f);
+     }
+   else
+     {
+        pd->filters = eina_inlist_remove(pd->filters, EINA_INLIST_GET(f));
+        free(f);
+     }
+   return data;
+}
+
+EOLIAN static int
+_ecore_event_message_handler_current_type_get(Eo *obj EINA_UNUSED, Ecore_Event_Message_Handler_Data *pd)
+{
+   return pd->current_event_type;
+}
+
+EOLIAN static void *
+_ecore_event_message_handler_current_event_get(Eo *obj EINA_UNUSED, Ecore_Event_Message_Handler_Data *pd)
+{
+   return pd->current_event_data;
+}
+
+EOLIAN static Efl_Object *
+_ecore_event_message_handler_efl_object_constructor(Eo *obj, Ecore_Event_Message_Handler_Data *pd)
+{
+   obj = efl_constructor(efl_super(obj, MY_CLASS));
+   pd->event_type_count = -1;
+   pd->current_event_type = -1;
+   return obj;
+}
+
+EOLIAN static void
+_ecore_event_message_handler_efl_object_destructor(Eo *obj, Ecore_Event_Message_Handler_Data *pd)
+{
+   Handler *h;
+   int i;
+
+   if (pd->handlers_walking == 0)
+     {
+        EINA_LIST_FREE(pd->handlers_delete, h)
+          {
+             pd->handlers[h->type] =
+               eina_inlist_remove(pd->handlers[h->type],
+                                  EINA_INLIST_GET(h));
+             free(h);
+          }
+        EINA_LIST_FREE(pd->handlers_add, h)
+          {
+             free(h);
+          }
+        for (i = 0; i < pd->event_type_count; i++)
+          {
+             EINA_INLIST_FREE(pd->handlers[i], h) free(h);
+          }
+        free(pd->handlers);
+        pd->handlers = NULL;
+     }
+   else
+     {
+        ERR("Destruction of ecore_event_message_handler while walking events");
+     }
+   efl_destructor(efl_super(obj, MY_CLASS));
+}
+
+EOLIAN static void
+_ecore_event_message_handler_efl_loop_message_handler_message_call(Eo *obj, Ecore_Event_Message_Handler_Data *pd, Efl_Loop_Message *message)
+{
+   Handler *h;
+   int type = -1;
+   void *data = NULL, *free_func = NULL, *free_data = NULL;
+   Ecore_End_Cb fn_free = NULL;
+   Eina_List *l, *l2;
+   int handled = 0;
+
+   // call legacy handlers which are controled by this class' custom api
+   ecore_event_message_data_steal
+     (message, &type, &data, &free_func, &free_data);
+   if ((type >= 0) && (type <= pd->event_type_count))
+     {
+        if (free_func) fn_free = free_func;
+        pd->current_event_data = data;
+        pd->current_event_type = type;
+        pd->handlers_walking++;
+        EINA_INLIST_FOREACH(pd->handlers[type], h)
+          {
+             if (h->delete_me) continue;
+             handled++;
+             if (!h->func(h->data, h->type, data)) break;
+          }
+        pd->handlers_walking--;
+        pd->current_event_data = NULL;
+        pd->current_event_type = -1;
+        EINA_LIST_FOREACH_SAFE(pd->handlers_add, l, l2, h)
+          {
+             if (h->type == type)
+               {
+                  h->to_add = EINA_FALSE;
+                  pd->handlers_add =
+                    eina_list_remove_list(pd->handlers_add, l);
+                  pd->handlers[type] =
+                    eina_inlist_append(pd->handlers[type], EINA_INLIST_GET(h));
+               }
+          }
+        if (pd->handlers_walking == 0)
+          {
+             EINA_LIST_FREE(pd->handlers_delete, h)
+               {
+                  if (h->to_add)
+                    pd->handlers_add = eina_list_remove(pd->handlers_add, h);
+                  else
+                    pd->handlers[h->type] =
+                      eina_inlist_remove(pd->handlers[h->type],
+                                         EINA_INLIST_GET(h));
+                  free(h);
+               }
+          }
+        if ((type == ECORE_EVENT_SIGNAL_EXIT) && (handled == 0))
+          {
+             Eo *loop = efl_provider_find(obj, EFL_LOOP_CLASS);
+
+             if (loop)
+               {
+                  Eina_Value v = EINA_VALUE_EMPTY;
+                  int val = 0;
+
+                  eina_value_setup(&v, EINA_VALUE_TYPE_INT);
+                  eina_value_set(&v, &val);
+                  efl_loop_quit(loop, v);
+               }
+          }
+     }
+
+   efl_event_callback_call
+     (obj, ECORE_EVENT_MESSAGE_HANDLER_EVENT_MESSAGE_ECORE_EVENT, message);
+   efl_loop_message_handler_message_call
+     (efl_super(obj, MY_CLASS), message);
+
+   if (data)
+     {
+        if (fn_free) fn_free(free_data, data);
+        else free(data);
+     }
+}
+
+static Eina_Bool
+_flush_cb(void *data, void *handler EINA_UNUSED, void *message)
+{
+   int *type = data;
+   int evtype = -1;
+   void *evdata = NULL, *free_func = NULL, *free_data = NULL;
+   Ecore_End_Cb fn_free = NULL;
+
+   if (!efl_isa(message, ECORE_EVENT_MESSAGE_CLASS)) return EINA_TRUE;
+   ecore_event_message_data_steal(message, &evtype, &evdata, &free_func, &free_data);
+   if (*type != evtype) return EINA_TRUE;
+   if (free_func)
+     {
+        fn_free = free_func;
+        fn_free(free_data, evdata);
+     }
+   return EINA_FALSE;
+}
+
+EOLIAN static void
+_ecore_event_message_handler_type_flush(Eo *obj, Ecore_Event_Message_Handler_Data *pd EINA_UNUSED, int type)
+{
+   Eo *loop = efl_provider_find(obj, EFL_LOOP_CLASS);
+   Efl_Loop_Data *loop_data = efl_data_scope_get(loop, EFL_LOOP_CLASS);
+
+   if (loop && loop_data)
+     {
+        _efl_loop_messages_call(loop, loop_data, _flush_cb, &type);
+     }
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+#include "ecore_event_message_handler.eo.c"
diff --git a/src/lib/ecore/ecore_event_message_handler.eo b/src/lib/ecore/ecore_event_message_handler.eo
new file mode 100644
index 0000000000..78047164ca
--- /dev/null
+++ b/src/lib/ecore/ecore_event_message_handler.eo
@@ -0,0 +1,86 @@
+import efl_types;
+import eina_types;
+
+class Ecore.Event.Message.Handler (Efl.Loop.Message.Handler)
+{
+   [[ For Legacy API usage Only
+      This class is rather hacky/messy as it's really internal glue
+      to handle legacy ecore events alongside the new loop message
+      stuff merged together. This is ugly as it's internal only
+      to quickly glue things together and is destined for death in
+      EFL 2.0 or when we dump legacy.
+   ]]
+   methods {
+      message_type_add {
+         [[ ]]
+         return: Ecore.Event.Message; [[ ]]
+      }
+      type_new {
+         [[ ]]
+         return: int; [[ ]]
+      }
+      handler_add {
+         [[ Legacy list of callback handlers so they can return false ]]
+         params {
+            type: int;
+            func: void_ptr;
+            data: void_ptr;
+         }
+         return: void_ptr; [[ Lazy return handle ]]
+      }
+      handler_del {
+         params {
+            handler: void_ptr; [[ handler returned from handler_add() ]]
+         }
+         return: void_ptr; [[ handler data ptr ]]
+      }
+      handler_data_get {
+         params {
+            handler: void_ptr; [[ handler returned from handler_add() ]]
+         }
+         return: void_ptr; [[ handler data ptr ]]
+      }
+      handler_data_set {
+         params {
+            handler: void_ptr; [[ handler returned from handler_add() ]]
+            data: void_ptr;
+         }
+         return: void_ptr; [[ prev handler data ptr ]]
+      }
+      filter_add {
+         [[ Legacy event filter ]]
+         params {
+            func_start: void_ptr;
+            func_filter: void_ptr;
+            func_end: void_ptr;
+            data: void_ptr;
+         }
+         return: void_ptr; [[ Lazy return filter handle ]]
+      }
+      filter_del {
+         params {
+            filter: void_ptr; [[ filter returned from filter_add() ]]
+         }
+         return: void_ptr; [[ filter data ptr ]]
+      }
+      current_type_get {
+         return: int; [[ ]]
+      }
+      current_event_get {
+         return: void_ptr; [[ ]]
+      }
+      type_flush {
+         params {
+            type: int; [[ the event type to flush ]]
+         }
+      }
+   }
+   events {
+      message,ecore,event: Ecore.Event.Message; [[ Sample - override this ]]
+   }
+   implements {
+      Efl.Object.constructor;
+      Efl.Object.destructor;
+      Efl.Loop.Message.Handler.message_call; [[ Sample - override this ]]
+   }
+}
diff --git a/src/lib/ecore/ecore_events.c b/src/lib/ecore/ecore_events.c
index ed405edb39..2a123a58fe 100644
--- a/src/lib/ecore/ecore_events.c
+++ b/src/lib/ecore/ecore_events.c
@@ -7,47 +7,6 @@
 #include "Ecore.h"
 #include "ecore_private.h"
 
-static int inpurge = 0;
-
-struct _Ecore_Event_Handler
-{
-   EINA_INLIST;
-                          ECORE_MAGIC;
-   int                    type;
-   Ecore_Event_Handler_Cb func;
-   void                  *data;
-   int                    references;
-   Eina_Bool              delete_me : 1;
-};
-GENERIC_ALLOC_SIZE_DECLARE(Ecore_Event_Handler);
-
-struct _Ecore_Event_Filter
-{
-   EINA_INLIST;
-                   ECORE_MAGIC;
-   Ecore_Data_Cb   func_start;
-   Ecore_Filter_Cb func_filter;
-   Ecore_End_Cb    func_end;
-   void           *loop_data;
-   void           *data;
-   int             references;
-   Eina_Bool       delete_me : 1;
-};
-GENERIC_ALLOC_SIZE_DECLARE(Ecore_Event_Filter);
-
-struct _Ecore_Event
-{
-   EINA_INLIST;
-                ECORE_MAGIC;
-   int          type;
-   void        *event;
-   Ecore_End_Cb func_free;
-   void        *data;
-   int          references;
-   Eina_Bool    delete_me : 1;
-};
-GENERIC_ALLOC_SIZE_DECLARE(Ecore_Event);
-
 typedef struct _Ecore_Future_Schedule_Entry
 {
    Eina_Future_Schedule_Entry base;
@@ -57,131 +16,45 @@ typedef struct _Ecore_Future_Schedule_Entry
    Eina_Value value;
 } Ecore_Future_Schedule_Entry;
 
-static int events_num = 0;
-static Ecore_Event *events = NULL;
-static Ecore_Event *event_current = NULL;
-static Ecore_Event *purge_events = NULL;
-
-static Ecore_Event_Handler **event_handlers = NULL;
-static Ecore_Event_Handler *event_handler_current = NULL;
-static int event_handlers_num = 0;
-static int event_handlers_alloc_num = 0;
-static Eina_List *event_handlers_delete_list = NULL;
-
-static Ecore_Event_Handler *event_handlers_add_list = NULL;
-
-static Ecore_Event_Filter *event_filters = NULL;
-static Ecore_Event_Filter *event_filter_current = NULL;
-static Ecore_Event *event_filter_event_current = NULL;
-static int event_filters_delete_me = 0;
-static int event_id_max = ECORE_EVENT_COUNT;
-static int ecore_raw_event_type = ECORE_EVENT_NONE;
-static void *ecore_raw_event_event = NULL;
-static Ecore_Event_Handler *future_handler = NULL;
-static int ECORE_EV_FUTURE_ID = -1;
-static Eina_Mempool *mp_future_schedule_entry = NULL;
-static Eina_Bool shutting_down = EINA_FALSE;
-
-static void  _ecore_event_purge_deleted(void);
-static void *_ecore_event_del(Ecore_Event *event);
+//////
+// XXX: still using legacy ecore events
+static Ecore_Event_Handler *future_handler             = NULL;
+static Eina_Bool            shutting_down              = EINA_FALSE;
+static Eina_Mempool        *mp_future_schedule_entry   = NULL;
+static int                  ECORE_EV_FUTURE_ID         = -1;
+//
+//////
+
+static Ecore_Event_Message_Handler *_event_msg_handler = NULL;
 
 EAPI Ecore_Event_Handler *
 ecore_event_handler_add(int                    type,
                         Ecore_Event_Handler_Cb func,
                         const void            *data)
 {
-   Ecore_Event_Handler *eh = NULL;
-
-   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-
-   if (!func) return NULL;
-   if ((type <= ECORE_EVENT_NONE) || (type >= event_id_max)) return NULL;
-   eh = ecore_event_handler_calloc(1);
-   if (!eh) return NULL;
-   ECORE_MAGIC_SET(eh, ECORE_MAGIC_EVENT_HANDLER);
-   eh->type = type;
-   eh->func = func;
-   eh->data = (void *)data;
-   if (type >= (event_handlers_num - 1))
-     {
-        int p_alloc_num;
-
-        p_alloc_num = event_handlers_alloc_num;
-        event_handlers_num = type + 1;
-        if (event_handlers_num > event_handlers_alloc_num)
-          {
-             Ecore_Event_Handler **new_handlers;
-             int i;
-
-             event_handlers_alloc_num = ((event_handlers_num + 16) / 16) * 16;
-             new_handlers = realloc(event_handlers, event_handlers_alloc_num * sizeof(Ecore_Event_Handler *));
-             if (!new_handlers)
-               {
-                  ecore_event_handler_mp_free(eh);
-                  return NULL;
-               }
-             event_handlers = new_handlers;
-             for (i = p_alloc_num; i < event_handlers_alloc_num; i++)
-               event_handlers[i] = NULL;
-          }
-     }
-   if (ecore_raw_event_type == type)
-     event_handlers_add_list = (Ecore_Event_Handler *)eina_inlist_append(EINA_INLIST_GET(event_handlers_add_list), EINA_INLIST_GET(eh));
-   else if (type < event_handlers_alloc_num)
-     event_handlers[type] = (Ecore_Event_Handler *)eina_inlist_append(EINA_INLIST_GET(event_handlers[type]), EINA_INLIST_GET(eh));
-
-   return eh;
+   return ecore_event_message_handler_add(_event_msg_handler,
+                                          type, func, (void *)data);
 }
 
 EAPI void *
 ecore_event_handler_del(Ecore_Event_Handler *event_handler)
 {
-   if (!event_handler) return NULL;
-   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   if (!ECORE_MAGIC_CHECK(event_handler, ECORE_MAGIC_EVENT_HANDLER))
-     {
-        ECORE_MAGIC_FAIL(event_handler, ECORE_MAGIC_EVENT_HANDLER,
-                         "ecore_event_handler_del");
-        return NULL;
-     }
-   return _ecore_event_handler_del(event_handler);
+   return ecore_event_message_handler_del(_event_msg_handler,
+                                          event_handler);
 }
 
 EAPI void *
 ecore_event_handler_data_get(Ecore_Event_Handler *eh)
 {
-   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   if (!ECORE_MAGIC_CHECK(eh, ECORE_MAGIC_EVENT_HANDLER))
-     {
-        ECORE_MAGIC_FAIL(eh, ECORE_MAGIC_EVENT_HANDLER, "ecore_event_handler_data_get");
-        return NULL;
-     }
-   return eh->data;
+   return ecore_event_message_handler_data_get(_event_msg_handler, eh);
 }
 
 EAPI void *
 ecore_event_handler_data_set(Ecore_Event_Handler *eh,
                              const void          *data)
 {
-   void *old = NULL;
-
-   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   if (!ECORE_MAGIC_CHECK(eh, ECORE_MAGIC_EVENT_HANDLER))
-     {
-        ECORE_MAGIC_FAIL(eh, ECORE_MAGIC_EVENT_HANDLER, "ecore_event_handler_data_set");
-        return NULL;
-     }
-   old = eh->data;
-   eh->data = (void *)data;
-
-   return old;
-}
-
-static void
-_ecore_event_generic_free(void *data EINA_UNUSED,
-                          void *event)
-{ /* DO NOT MEMPOOL FREE THIS */
-   free(event);
+   return ecore_event_message_handler_data_set(_event_msg_handler, eh,
+                                               (void *)data);
 }
 
 EAPI Ecore_Event *
@@ -190,34 +63,27 @@ ecore_event_add(int          type,
                 Ecore_End_Cb func_free,
                 void        *data)
 {
-   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
+   Ecore_Event_Message *msg;
 
-   if (type <= ECORE_EVENT_NONE) return NULL;
-   if (type >= event_id_max) return NULL;
-   if ((ev) && (!func_free)) func_free = _ecore_event_generic_free;
-   return _ecore_event_add(type, ev, func_free, data);
+   msg = ecore_event_message_handler_message_type_add(_event_msg_handler);
+   ecore_event_message_data_set(msg, type, ev, func_free, data);
+   efl_loop_message_handler_message_send(_event_msg_handler, msg);
+   return (Ecore_Event *)msg;
 }
 
 EAPI void *
 ecore_event_del(Ecore_Event *event)
 {
-   if (!event) return NULL;
-   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   if (!ECORE_MAGIC_CHECK(event, ECORE_MAGIC_EVENT))
-     {
-        ECORE_MAGIC_FAIL(event, ECORE_MAGIC_EVENT, "ecore_event_del");
-        return NULL;
-     }
-   EINA_SAFETY_ON_TRUE_RETURN_VAL(event->delete_me, NULL);
-   event->delete_me = 1;
-   return event->data;
+   void *data = NULL;
+   ecore_event_message_data_get((Eo *)event, NULL, &data, NULL, NULL);
+   _efl_loop_message_unsend((Eo *)event);
+   return data;
 }
 
 EAPI int
 ecore_event_type_new(void)
 {
-   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
-   return event_id_max++;
+   return ecore_event_message_handler_type_new(_event_msg_handler);
 }
 
 EAPI Ecore_Event_Filter *
@@ -226,59 +92,27 @@ ecore_event_filter_add(Ecore_Data_Cb   func_start,
                        Ecore_End_Cb    func_end,
                        const void     *data)
 {
-   Ecore_Event_Filter *ef = NULL;
-
-   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   if (!func_filter) return NULL;
-   ef = ecore_event_filter_calloc(1);
-   if (!ef) return NULL;
-   ECORE_MAGIC_SET(ef, ECORE_MAGIC_EVENT_FILTER);
-   ef->func_start = func_start;
-   ef->func_filter = func_filter;
-   ef->func_end = func_end;
-   ef->data = (void *)data;
-   event_filters = (Ecore_Event_Filter *)eina_inlist_append(EINA_INLIST_GET(event_filters), EINA_INLIST_GET(ef));
-
-   return ef;
+   return ecore_event_message_handler_filter_add(_event_msg_handler,
+                                                 func_start, func_filter,
+                                                 func_end, (void *)data);
 }
 
 EAPI void *
 ecore_event_filter_del(Ecore_Event_Filter *ef)
 {
-   if (!ef) return NULL;
-   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   if (!ECORE_MAGIC_CHECK(ef, ECORE_MAGIC_EVENT_FILTER))
-     {
-        ECORE_MAGIC_FAIL(ef, ECORE_MAGIC_EVENT_FILTER, "ecore_event_filter_del");
-        return NULL;
-     }
-   EINA_SAFETY_ON_TRUE_RETURN_VAL(ef->delete_me, NULL);
-   ef->delete_me = 1;
-   event_filters_delete_me = 1;
-   return ef->data;
+   return ecore_event_message_handler_filter_del(_event_msg_handler, ef);
 }
 
 EAPI int
 ecore_event_current_type_get(void)
 {
-   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
-   return ecore_raw_event_type;
+   return ecore_event_message_handler_current_type_get(_event_msg_handler);
 }
 
 EAPI void *
 ecore_event_current_event_get(void)
 {
-   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   return ecore_raw_event_event;
-}
-
-EAPI void *
-_ecore_event_handler_del(Ecore_Event_Handler *event_handler)
-{
-   EINA_SAFETY_ON_TRUE_RETURN_VAL(event_handler->delete_me, NULL);
-   event_handler->delete_me = 1;
-   event_handlers_delete_list = eina_list_append(event_handlers_delete_list, event_handler);
-   return event_handler->data;
+   return ecore_event_message_handler_current_event_get(_event_msg_handler);
 }
 
 static Eina_Bool
@@ -294,12 +128,6 @@ static void
 ecore_future_free(void *user_data, void *func_data EINA_UNUSED)
 {
    Ecore_Future_Schedule_Entry *entry = user_data;
-   /*
-     In case entry->event is not NULL, it means
-     that ecore is shutting down. In this case,
-     we must cancel the future otherwise Eina may
-     try to use it and lead to crashes.
-    */
    if (entry->event)
      {
         eina_future_cancel(entry->future);
@@ -355,6 +183,44 @@ _ecore_event_init(void)
    const char *choice = getenv("EINA_MEMPOOL");
    if ((!choice) || (!choice[0])) choice = "chained_mempool";
 
+   _event_msg_handler =
+     efl_loop_message_handler_get(EFL_LOOP_CLASS,
+                                  _mainloop_singleton,
+                                  ECORE_EVENT_MESSAGE_HANDLER_CLASS);
+   if (!_event_msg_handler)
+     {
+        ERR("Cannot create legacy ecore event message handler");
+        return EINA_FALSE;
+     }
+   // init some core legacy event types in t he same order and numbering as before
+   // ECORE_EVENT_NONE                     0
+   // no need to do as ev types start at 1
+
+   // ECORE_EVENT_SIGNAL_USER              1
+   ecore_event_message_handler_type_new(_event_msg_handler);
+   // ECORE_EVENT_SIGNAL_HUP               2
+   ecore_event_message_handler_type_new(_event_msg_handler);
+   // ECORE_EVENT_SIGNAL_EXIT              3
+   ecore_event_message_handler_type_new(_event_msg_handler);
+   // ECORE_EVENT_SIGNAL_POWER             4
+   ecore_event_message_handler_type_new(_event_msg_handler);
+   // ECORE_EVENT_SIGNAL_REALTIME          5
+   ecore_event_message_handler_type_new(_event_msg_handler);
+   // ECORE_EVENT_MEMORY_STATE             6
+   ecore_event_message_handler_type_new(_event_msg_handler);
+   // ECORE_EVENT_POWER_STATE              7
+   ecore_event_message_handler_type_new(_event_msg_handler);
+   // ECORE_EVENT_LOCALE_CHANGED           8
+   ecore_event_message_handler_type_new(_event_msg_handler);
+   // ECORE_EVENT_HOSTNAME_CHANGED         9
+   ecore_event_message_handler_type_new(_event_msg_handler);
+   // ECORE_EVENT_SYSTEM_TIMEDATE_CHANGED  10
+   ecore_event_message_handler_type_new(_event_msg_handler);
+   // ECORE_EVENT_COUNT                    11
+   // no need to do as it was a count, nto an event
+
+   //////
+   // XXX: ecore future still using legacy...
    shutting_down = EINA_FALSE;
    ECORE_EV_FUTURE_ID = ecore_event_type_new();
    future_handler = ecore_event_handler_add(ECORE_EV_FUTURE_ID, ecore_future_dispatched, NULL);
@@ -364,6 +230,8 @@ _ecore_event_init(void)
                                                NULL, sizeof(Ecore_Future_Schedule_Entry),
                                                512);
    EINA_SAFETY_ON_NULL_GOTO(mp_future_schedule_entry, err_pool);
+   //
+   //////
 
    return EINA_TRUE;
 
@@ -378,337 +246,42 @@ _ecore_event_init(void)
 void
 _ecore_event_shutdown(void)
 {
-   int i;
-   Ecore_Event_Handler *eh;
-   Ecore_Event_Filter *ef;
-
    shutting_down = EINA_TRUE;
+
+   //////
+   // XXX: ecore future still using legacy...
    ecore_event_handler_del(future_handler);
    future_handler = NULL;
-   while (events) _ecore_event_del(events);
-   event_current = NULL;
-   for (i = 0; i < event_handlers_num; i++)
-     {
-        while ((eh = event_handlers[i]))
-          {
-             event_handlers[i] = (Ecore_Event_Handler *)eina_inlist_remove(EINA_INLIST_GET(event_handlers[i]), EINA_INLIST_GET(event_handlers[i]));
-             ECORE_MAGIC_SET(eh, ECORE_MAGIC_NONE);
-             if (!eh->delete_me) ecore_event_handler_mp_free(eh);
-          }
-     }
-   EINA_LIST_FREE(event_handlers_delete_list, eh)
-     ecore_event_handler_mp_free(eh);
-   if (event_handlers) free(event_handlers);
-   event_handlers = NULL;
-   event_handlers_num = 0;
-   event_handlers_alloc_num = 0;
-   while ((ef = event_filters))
-     {
-        event_filters = (Ecore_Event_Filter *)eina_inlist_remove(EINA_INLIST_GET(event_filters), EINA_INLIST_GET(event_filters));
-        ECORE_MAGIC_SET(ef, ECORE_MAGIC_NONE);
-        ecore_event_filter_mp_free(ef);
-     }
-   event_filters_delete_me = 0;
-   event_filter_current = NULL;
-   event_filter_event_current = NULL;
    ECORE_EV_FUTURE_ID = -1;
-}
-
-int
-_ecore_event_exist(void)
-{
-   Ecore_Event *e;
-   EINA_INLIST_FOREACH(events, e)
-     if (!e->delete_me) return 1;
-   return 0;
-}
-
-Ecore_Event *
-_ecore_event_add(int          type,
-                 void        *ev,
-                 Ecore_End_Cb func_free,
-                 void        *data)
-{
-   Ecore_Event *e;
-
-   e = ecore_event_calloc(1);
-   if (!e) return NULL;
-   ECORE_MAGIC_SET(e, ECORE_MAGIC_EVENT);
-   e->type = type;
-   e->event = ev;
-   e->func_free = func_free;
-   e->data = data;
-   if (inpurge > 0)
-     {
-        purge_events = (Ecore_Event *)eina_inlist_append(EINA_INLIST_GET(purge_events), EINA_INLIST_GET(e));
-        events_num++;
-     }
-   else
-     {
-        events = (Ecore_Event *)eina_inlist_append(EINA_INLIST_GET(events), EINA_INLIST_GET(e));
-        events_num++;
-     }
-   return e;
-}
-
-void *
-_ecore_event_del(Ecore_Event *event)
-{
-   void *data;
-
-   data = event->data;
-   if (event->func_free) _ecore_call_end_cb(event->func_free, event->data, event->event);
-   events = (Ecore_Event *)eina_inlist_remove(EINA_INLIST_GET(events), EINA_INLIST_GET(event));
-   ECORE_MAGIC_SET(event, ECORE_MAGIC_NONE);
-   ecore_event_mp_free(event);
-   events_num--;
-   return data;
-}
-
-static void
-_ecore_event_purge_deleted(void)
-{
-   Ecore_Event *itr = events;
+   //
+   //////
 
-   inpurge++;
-   while (itr)
-     {
-        Ecore_Event *next = (Ecore_Event *)EINA_INLIST_GET(itr)->next;
-        if ((!itr->references) && (itr->delete_me))
-          _ecore_event_del(itr);
-        itr = next;
-     }
-   inpurge--;
-   while (purge_events)
-     {
-        Ecore_Event *e = purge_events;
-        purge_events = (Ecore_Event *)eina_inlist_remove(EINA_INLIST_GET(purge_events), EINA_INLIST_GET(purge_events));
-        events = (Ecore_Event *)eina_inlist_append(EINA_INLIST_GET(events), EINA_INLIST_GET(e));
-     }
-}
-
-static inline void
-_ecore_event_filters_apply(void)
-{
-   if (!event_filter_current)
-     {
-        /* regular main loop, start from head */
-         event_filter_current = event_filters;
-     }
-   else
-     {
-        /* recursive main loop, continue from where we were */
-         event_filter_current = (Ecore_Event_Filter *)EINA_INLIST_GET(event_filter_current)->next;
-     }
-   if ((!event_filter_current) && (!event_filters_delete_me) && (!purge_events)) return;
-   eina_evlog("+event_filter", NULL, 0.0, NULL);
-   while (event_filter_current)
-     {
-        Ecore_Event_Filter *ef = event_filter_current;
-
-        if (!ef->delete_me)
-          {
-             ef->references++;
-
-             if (ef->func_start)
-               ef->loop_data = _ecore_call_data_cb(ef->func_start, ef->data);
-
-             if (!event_filter_event_current)
-               {
-     /* regular main loop, start from head */
-                   event_filter_event_current = events;
-               }
-             else
-               {
-     /* recursive main loop, continue from where we were */
-                   event_filter_event_current = (Ecore_Event *)EINA_INLIST_GET(event_filter_event_current)->next;
-               }
-
-             while (event_filter_event_current)
-               {
-                  Ecore_Event *e = event_filter_event_current;
-
-                  if (!_ecore_call_filter_cb(ef->func_filter, ef->data,
-                                             ef->loop_data, e->type, e->event))
-                    {
-                       ecore_event_del(e);
-                    }
-
-                  if (event_filter_event_current) /* may have changed in recursive main loops */
-                    event_filter_event_current = (Ecore_Event *)EINA_INLIST_GET(event_filter_event_current)->next;
-               }
-             if (ef->func_end)
-               _ecore_call_end_cb(ef->func_end, ef->data, ef->loop_data);
-
-             ef->references--;
-          }
-
-        if (event_filter_current) /* may have changed in recursive main loops */
-          event_filter_current = (Ecore_Event_Filter *)EINA_INLIST_GET(event_filter_current)->next;
-     }
-   eina_evlog("-event_filter", NULL, 0.0, NULL);
-   if (event_filters_delete_me)
-     {
-        int deleted_in_use = 0;
-        Ecore_Event_Filter *l;
-        for (l = event_filters; l; )
-          {
-             Ecore_Event_Filter *ef = l;
-             l = (Ecore_Event_Filter *)EINA_INLIST_GET(l)->next;
-             if (ef->delete_me)
-               {
-                  if (ef->references)
-                    {
-                       deleted_in_use++;
-                       continue;
-                    }
-
-                  event_filters = (Ecore_Event_Filter *)eina_inlist_remove(EINA_INLIST_GET(event_filters), EINA_INLIST_GET(ef));
-                  ECORE_MAGIC_SET(ef, ECORE_MAGIC_NONE);
-                  ecore_event_filter_mp_free(ef);
-               }
-          }
-        if (!deleted_in_use)
-          event_filters_delete_me = 0;
-     }
-}
-
-void
-_ecore_event_call(void)
-{
-   Eina_List *l, *l_next;
-   Ecore_Event_Handler *eh;
-
-   _ecore_event_filters_apply();
-
-   if (!event_current)
-     {
-        /* regular main loop, start from head */
-         event_current = events;
-         event_handler_current = NULL;
-     }
-   if ((!event_current) && (!event_handlers_delete_list)) return;
-   eina_evlog("+events", NULL, 0.0, NULL);
-   while (event_current)
-     {
-        Ecore_Event *e = event_current;
-        int handle_count = 0;
-
-        if (e->delete_me)
-          {
-             event_current = (Ecore_Event *)EINA_INLIST_GET(event_current)->next;
-             continue;
-          }
-
-        ecore_raw_event_type = e->type;
-        ecore_raw_event_event = e->event;
-        e->references++;
-        if ((e->type >= 0) && (e->type < event_handlers_num))
-          {
-             if (!event_handler_current)
-               {
-     /* regular main loop, start from head */
-                   event_handler_current = event_handlers[e->type];
-               }
-             else
-               {
-     /* recursive main loop, continue from where we were */
-                   event_handler_current = (Ecore_Event_Handler *)EINA_INLIST_GET(event_handler_current)->next;
-               }
-
-             while ((event_handler_current) && (!e->delete_me))
-               {
-                  eh = event_handler_current;
-                  if (!eh->delete_me)
-                    {
-                       Eina_Bool ret;
-
-                       handle_count++;
-
-                       eh->references++;
-                       ret = _ecore_call_handler_cb(eh->func, eh->data, e->type, e->event);
-                       eh->references--;
-
-                       if (!ret)
-                         {
-                            event_handler_current = NULL;
-                            break;  /* 0 == "call no further handlers" */
-                         }
-                    }
-
-                  if (event_handler_current) /* may have changed in recursive main loops */
-                    event_handler_current = (Ecore_Event_Handler *)EINA_INLIST_GET(event_handler_current)->next;
-               }
-          }
-        while (event_handlers_add_list)
-          {
-             eh = event_handlers_add_list;
-             event_handlers_add_list = (Ecore_Event_Handler *)eina_inlist_remove(EINA_INLIST_GET(event_handlers_add_list), EINA_INLIST_GET(eh));
-             event_handlers[eh->type] = (Ecore_Event_Handler *)eina_inlist_append(EINA_INLIST_GET(event_handlers[eh->type]), EINA_INLIST_GET(eh));
-          }
-        /* if no handlers were set for EXIT signal - then default is */
-        /* to quit the main loop */
-        if ((e->type == ECORE_EVENT_SIGNAL_EXIT) && (handle_count == 0))
-          ecore_main_loop_quit();
-        e->references--;
-        e->delete_me = 1;
-
-        if (event_current) /* may have changed in recursive main loops */
-          event_current = (Ecore_Event *)EINA_INLIST_GET(event_current)->next;
-     }
-   eina_evlog("-events", NULL, 0.0, NULL);
-
-   ecore_raw_event_type = ECORE_EVENT_NONE;
-   ecore_raw_event_event = NULL;
-
-   _ecore_event_purge_deleted();
-
-   EINA_LIST_FOREACH_SAFE(event_handlers_delete_list, l, l_next, eh)
-     {
-        if (eh->references) continue;
-
-        event_handlers_delete_list = eina_list_remove_list(event_handlers_delete_list, l);
-
-        event_handlers[eh->type] = (Ecore_Event_Handler *)eina_inlist_remove(EINA_INLIST_GET(event_handlers[eh->type]), EINA_INLIST_GET(eh));
-        ECORE_MAGIC_SET(eh, ECORE_MAGIC_NONE);
-        ecore_event_handler_mp_free(eh);
-     }
+   efl_loop_message_handler_message_clear(_event_msg_handler);
+   _event_msg_handler = NULL;
 }
 
 void *
 _ecore_event_signal_user_new(void)
 {
-   Ecore_Event_Signal_User *e;
-
-   e = calloc(1, sizeof(Ecore_Event_Signal_User));
-   return e;
+   return calloc(1, sizeof(Ecore_Event_Signal_User));
 }
 
 void *
 _ecore_event_signal_hup_new(void)
 {
-   Ecore_Event_Signal_Hup *e;
-
-   e = calloc(1, sizeof(Ecore_Event_Signal_Hup));
-   return e;
+   return calloc(1, sizeof(Ecore_Event_Signal_Hup));
 }
 
 void *
 _ecore_event_signal_exit_new(void)
 {
-   Ecore_Event_Signal_Exit *e;
-
-   e = calloc(1, sizeof(Ecore_Event_Signal_Exit));
-   return e;
+   return calloc(1, sizeof(Ecore_Event_Signal_Exit));
 }
 
 void *
 _ecore_event_signal_power_new(void)
 {
-   Ecore_Event_Signal_Power *e;
-
-   e = calloc(1, sizeof(Ecore_Event_Signal_Power));
-   return e;
+   return calloc(1, sizeof(Ecore_Event_Signal_Power));
 }
 
 void *
@@ -720,58 +293,17 @@ _ecore_event_signal_realtime_new(void)
 EAPI void
 ecore_event_type_flush_internal(int type, ...)
 {
-   Eina_Inarray types;
-   Ecore_Event *event;
-   Eina_Inlist *l;
-   int *itr;
    va_list args;
-   Eina_Bool wrong_type = EINA_FALSE;
 
-   // In case of an empty list of event
    if (type == ECORE_EVENT_NONE) return;
-
-   eina_inarray_step_set(&types, sizeof (Eina_Inarray), sizeof (int), 4);
-
-   eina_inarray_push(&types, &type);
+   ecore_event_message_handler_type_flush(_event_msg_handler, type);
 
    va_start(args, type);
-   do
+   for (;;)
      {
         type = va_arg(args, int);
-        if (type == ECORE_EVENT_NONE) break ;
-        eina_inarray_push(&types, &type);
+        if (type == ECORE_EVENT_NONE) break;
+        ecore_event_message_handler_type_flush(_event_msg_handler, type);
      }
-   while (1);
    va_end(args);
-
-   EINA_INARRAY_FOREACH(&types, itr)
-     {
-        if (*itr >= 0 && *itr < event_id_max) continue;
-
-        ERR("Invalid event flush requested: %i", *itr);
-        wrong_type = EINA_TRUE;
-     }
-
-   if (wrong_type)
-     {
-        eina_inarray_flush(&types);
-        return ;
-     }
-
-   EINA_INLIST_FOREACH_SAFE((Eina_Inlist *) events, l, event)
-     {
-        Eina_Bool found = EINA_FALSE;
-
-        EINA_INARRAY_FOREACH(&types, itr)
-          if (event->type == *itr)
-            found = EINA_TRUE;
-        if (!found) continue ;
-
-        if (event->delete_me) continue ;
-        event->delete_me = 1;
-     }
-
-   _ecore_event_purge_deleted();
-
-   eina_inarray_flush(&types);
 }
diff --git a/src/lib/ecore/ecore_exe.c b/src/lib/ecore/ecore_exe.c
index 22486cd609..908f677539 100644
--- a/src/lib/ecore/ecore_exe.c
+++ b/src/lib/ecore/ecore_exe.c
@@ -38,8 +38,6 @@ EAPI int ECORE_EXE_EVENT_DEL = 0;
 EAPI int ECORE_EXE_EVENT_DATA = 0;
 EAPI int ECORE_EXE_EVENT_ERROR = 0;
 
-Eina_List *_ecore_exe_exes = NULL;
-
 EAPI void
 ecore_exe_run_priority_set(int pri)
 {
@@ -63,18 +61,19 @@ ecore_exe_run(const char *exe_cmd,
 }
 
 EAPI Ecore_Exe *
-ecore_exe_pipe_run(const char     *exe_cmd,
-                   Ecore_Exe_Flags flags,
-                   const void     *data)
+ecore_exe_pipe_run(const char      *exe_cmd,
+                   Ecore_Exe_Flags  flags,
+                   const void      *data)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
-   Ecore_Exe *ret = efl_add(MY_CLASS, NULL, ecore_obj_exe_command_set(efl_added, exe_cmd, flags));
+   Ecore_Exe *ret = efl_add(MY_CLASS, efl_loop_main_get(EFL_LOOP_CLASS),
+                            ecore_obj_exe_command_set(efl_added, exe_cmd,
+                                                      flags));
    if (ret)
      {
         Ecore_Exe_Data *pd = efl_data_scope_get(ret, MY_CLASS);
         pd->data = (void *) data;
      }
-
    return ret;
 }
 
@@ -98,10 +97,7 @@ _ecore_exe_efl_object_finalize(Eo *obj, Ecore_Exe_Data *exe)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    obj = efl_finalize(efl_super(obj, MY_CLASS));
-
-   if (!obj)
-      return obj;
-
+   if (!obj) return obj;
    return _impl_ecore_exe_efl_object_finalize(obj, exe);
 }
 
@@ -111,8 +107,7 @@ ecore_exe_callback_pre_free_set(Ecore_Exe   *obj,
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return;
+   if (!efl_isa(obj, MY_CLASS)) return;
    exe->pre_free_cb = func;
 }
 
@@ -123,18 +118,15 @@ ecore_exe_send(Ecore_Exe  *obj,
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(EINA_FALSE);
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return EINA_FALSE;
+   if (!efl_isa(obj, MY_CLASS)) return EINA_FALSE;
 
    EINA_SAFETY_ON_TRUE_RETURN_VAL(size == 0, EINA_TRUE);
-
    if (exe->close_stdin)
-   {
-      ERR("Ecore_Exe %p stdin is closed! Cannot send %d bytes from %p",
-          exe, size, data);
-      return EINA_FALSE;
-   }
-
+     {
+        ERR("Ecore_Exe %p stdin is closed! Cannot send %d bytes from %p",
+            exe, size, data);
+        return EINA_FALSE;
+     }
    return _impl_ecore_exe_send(obj, exe, data, size);
 }
 
@@ -143,9 +135,7 @@ ecore_exe_close_stdin(Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return;
-
+   if (!efl_isa(obj, MY_CLASS)) return;
    exe->close_stdin = 1;
 }
 
@@ -158,10 +148,9 @@ ecore_exe_auto_limits_set(Ecore_Exe *obj,
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
    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);
+   if (!efl_isa(obj, MY_CLASS)) return;
+   _impl_ecore_exe_auto_limits_set(obj, exe, start_bytes, end_bytes,
+                                   start_lines, end_lines);
 }
 
 EAPI Ecore_Exe_Event_Data *
@@ -170,9 +159,7 @@ ecore_exe_event_data_get(Ecore_Exe      *obj,
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return NULL;
-
+   if (!efl_isa(obj, MY_CLASS)) return NULL;
    return _impl_ecore_exe_event_data_get(obj, exe, flags);
 }
 
@@ -182,14 +169,10 @@ ecore_exe_tag_set(Ecore_Exe  *obj,
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return;
-
+   if (!efl_isa(obj, MY_CLASS)) return;
    IF_FREE(exe->tag);
-   if (tag)
-     exe->tag = strdup(tag);
-   else
-     exe->tag = NULL;
+   if (tag) exe->tag = strdup(tag);
+   else exe->tag = NULL;
 }
 
 EAPI const char *
@@ -197,9 +180,7 @@ ecore_exe_tag_get(const Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return NULL;
-
+   if (!efl_isa(obj, MY_CLASS)) return NULL;
    return exe->tag;
 }
 
@@ -208,12 +189,9 @@ ecore_exe_free(Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return NULL;
-
+   if (!efl_isa(obj, MY_CLASS)) return NULL;
    void *data = exe->data;
    efl_del(obj);
-
    return data;
 }
 
@@ -221,7 +199,6 @@ EOLIAN static void
 _ecore_exe_efl_object_destructor(Eo *obj, Ecore_Exe_Data *exe)
 {
    efl_destructor(efl_super(obj, ECORE_EXE_CLASS));
-
    _impl_ecore_exe_efl_object_destructor(obj, exe);
 }
 
@@ -239,9 +216,7 @@ ecore_exe_pid_get(const Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return -1;
-
+   if (!efl_isa(obj, MY_CLASS)) return -1;
    return exe->pid;
 }
 
@@ -250,9 +225,7 @@ ecore_exe_cmd_get(const Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    const char *ret = NULL;
-
    ecore_obj_exe_command_get(obj, &ret, NULL);
-
    return ret;
 }
 
@@ -261,9 +234,7 @@ ecore_exe_data_get(const Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return NULL;
-
+   if (!efl_isa(obj, MY_CLASS)) return NULL;
    return exe->data;
 }
 
@@ -274,9 +245,7 @@ ecore_exe_data_set(Ecore_Exe *obj,
    void *ret;
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return NULL;
-
+   if (!efl_isa(obj, MY_CLASS)) return NULL;
    ret = exe->data;
    exe->data = data;
    return ret;
@@ -287,9 +256,7 @@ ecore_exe_flags_get(const Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return 0;
-
+   if (!efl_isa(obj, MY_CLASS)) return 0;
    return exe->flags;
 }
 
@@ -309,15 +276,8 @@ EOLIAN static void
 _ecore_exe_efl_control_suspend_set(Eo *obj EINA_UNUSED, Ecore_Exe_Data *exe, Eina_Bool suspend)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
-
-   if (suspend)
-     {
-        _impl_ecore_exe_pause(obj, exe);
-     }
-   else
-     {
-        _impl_ecore_exe_continue(obj, exe);
-     }
+   if (suspend) _impl_ecore_exe_pause(obj, exe);
+   else _impl_ecore_exe_continue(obj, exe);
 }
 
 EAPI void
@@ -325,9 +285,7 @@ ecore_exe_interrupt(Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return;
-
+   if (!efl_isa(obj, MY_CLASS)) return;
    _impl_ecore_exe_interrupt(obj, exe);
 }
 
@@ -336,9 +294,7 @@ ecore_exe_quit(Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return;
-
+   if (!efl_isa(obj, MY_CLASS)) return;
    _impl_ecore_exe_quit(obj, exe);
 }
 
@@ -347,9 +303,7 @@ ecore_exe_terminate(Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return;
-
+   if (!efl_isa(obj, MY_CLASS)) return;
    _impl_ecore_exe_terminate(obj, exe);
 }
 
@@ -358,9 +312,7 @@ ecore_exe_kill(Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return;
-
+   if (!efl_isa(obj, MY_CLASS)) return;
    _impl_ecore_exe_kill(obj, exe);
 }
 
@@ -370,9 +322,7 @@ ecore_exe_signal(Ecore_Exe *obj,
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return;
-
+   if (!efl_isa(obj, MY_CLASS)) return;
    _impl_ecore_exe_signal(obj, exe, num);
 }
 
@@ -381,9 +331,7 @@ ecore_exe_hup(Ecore_Exe *obj)
 {
    EINA_MAIN_LOOP_CHECK_RETURN;
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-   if (!efl_isa(obj, MY_CLASS))
-      return;
-
+   if (!efl_isa(obj, MY_CLASS)) return;
    _impl_ecore_exe_hup(obj, exe);
 }
 
@@ -401,7 +349,9 @@ _ecore_exe_shutdown(void)
 {
    Ecore_Exe *exe = NULL;
    Eina_List *l1, *l2;
-   EINA_LIST_FOREACH_SAFE(_ecore_exe_exes, l1, l2, exe)
+   Efl_Loop_Data *loop = EFL_LOOP_DATA;
+
+   EINA_LIST_FOREACH_SAFE(loop->exes, l1, l2, exe)
       ecore_exe_free(exe);
 
    ecore_event_type_flush(ECORE_EXE_EVENT_ADD,
@@ -415,22 +365,20 @@ _ecore_exe_find(pid_t pid)
 {
    Eina_List *itr;
    Ecore_Exe *obj;
+   Efl_Loop_Data *loop = EFL_LOOP_DATA;
 
-   EINA_LIST_FOREACH(_ecore_exe_exes, itr, obj)
-   {
-      Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-      if (exe->pid == pid)
-        return obj;
-   }
+   EINA_LIST_FOREACH(loop->exes, itr, obj)
+     {
+        Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
+        if (exe->pid == pid) return obj;
+     }
    return NULL;
 }
 
 void *
 _ecore_exe_event_del_new(void)
 {
-   Ecore_Exe_Event_Del *e;
-
-   e = calloc(1, sizeof(Ecore_Exe_Event_Del));
+   Ecore_Exe_Event_Del *e = calloc(1, sizeof(Ecore_Exe_Event_Del));
    return e;
 }
 
@@ -438,11 +386,8 @@ void
 _ecore_exe_event_del_free(void *data EINA_UNUSED,
                           void *ev)
 {
-   Ecore_Exe_Event_Del *e;
-
-   e = ev;
-   if (e->exe)
-     ecore_exe_free(e->exe);
+   Ecore_Exe_Event_Del *e = ev;
+   if (e->exe) ecore_exe_free(e->exe);
    free(e);
 }
 
@@ -450,18 +395,14 @@ void
 _ecore_exe_event_exe_data_free(void *data EINA_UNUSED,
                                void *ev)
 {
-   Ecore_Exe_Event_Data *e;
-
-   e = ev;
+   Ecore_Exe_Event_Data *e = ev;
    ecore_exe_event_data_free(e);
 }
 
 Ecore_Exe_Event_Add *
 _ecore_exe_event_add_new(void)
 {
-   Ecore_Exe_Event_Add *e;
-
-   e = calloc(1, sizeof(Ecore_Exe_Event_Add));
+   Ecore_Exe_Event_Add *e = calloc(1, sizeof(Ecore_Exe_Event_Add));
    return e;
 }
 
@@ -469,9 +410,7 @@ void
 _ecore_exe_event_add_free(void *data EINA_UNUSED,
                           void *ev)
 {
-   Ecore_Exe_Event_Add *e;
-
-   e = ev;
+   Ecore_Exe_Event_Add *e = ev;
    free(e);
 }
 
diff --git a/src/lib/ecore/ecore_exe_posix.c b/src/lib/ecore/ecore_exe_posix.c
index bebfce26a1..21d8861ef2 100644
--- a/src/lib/ecore/ecore_exe_posix.c
+++ b/src/lib/ecore/ecore_exe_posix.c
@@ -43,60 +43,51 @@
  * appended with a preceding space.  The first is the command off course.
  */
 
-struct _ecore_exe_dead_exe
-{
-   pid_t pid;
-   char *cmd;
-};
-
-static inline void _ecore_exe_exec_it(const char *exe_cmd,
+static inline void _ecore_exe_exec_it(const char     *exe_cmd,
                                       Ecore_Exe_Flags flags);
-static Eina_Bool   _ecore_exe_data_generic_handler(void *data,
+static Eina_Bool   _ecore_exe_data_generic_handler(void             *data,
                                                    Ecore_Fd_Handler *fd_handler,
-                                                   Ecore_Exe_Flags flags);
-static Eina_Bool   _ecore_exe_data_error_handler(void *data,
-                                                 Ecore_Fd_Handler *fd_handler);
-static Eina_Bool   _ecore_exe_data_read_handler(void *data,
-                                                Ecore_Fd_Handler *fd_handler);
-static Eina_Bool   _ecore_exe_data_write_handler(void *data,
-                                                 Ecore_Fd_Handler *fd_handler);
-static void        _ecore_exe_flush(Ecore_Exe *obj);
-static Ecore_Exe  *_ecore_exe_is_it_alive(pid_t pid);
-static Eina_Bool   _ecore_exe_make_sure_its_dead(void *data);
-static Eina_Bool   _ecore_exe_make_sure_its_really_dead(void *data);
-static void        _ecore_exe_dead_attach(Ecore_Exe *obj);
+                                                   Ecore_Exe_Flags   flags);
+static Eina_Bool            _ecore_exe_data_error_handler(void             *data,
+                                                          Ecore_Fd_Handler *fd_handler);
+static Eina_Bool            _ecore_exe_data_read_handler(void             *data,
+                                                         Ecore_Fd_Handler *fd_handler);
+static Eina_Bool            _ecore_exe_data_write_handler(void             *data,
+                                                          Ecore_Fd_Handler *fd_handler);
+static void                 _ecore_exe_flush(Ecore_Exe *obj);
+static void                 _ecore_exe_make_sure_its_dead(void *data, const Efl_Event *event);
+static void                 _ecore_exe_make_sure_its_really_dead(void *data, const Efl_Event *event);
+static void                 _ecore_exe_dead_attach(Ecore_Exe *obj);
 
 static const char *shell = NULL;
 
 /* FIXME: This errno checking stuff should be put elsewhere for everybody to use.
  * For now it lives here though, just to make testing easier.
  */
-static int         _ecore_exe_check_errno(int result,
-                                          const char *file,
-                                          int line);
+static int _ecore_exe_check_errno(int         result,
+                                  const char *file,
+                                  int         line);
 
-#define E_IF_NO_ERRNO(result, foo, ok)                                                \
-  while (((ok) = _ecore_exe_check_errno((result) = (foo), __FILE__, __LINE__)) == -1) \
-    sleep(1);                                                                         \
-  if (ok)
+#define E_IF_NO_ERRNO(result, foo, ok)                                                           \
+  while (((ok) = _ecore_exe_check_errno((result) = (foo), __FILE__, __LINE__)) == -1) sleep(1);  \
+          if (ok)
 
-#define E_NO_ERRNO(result, foo, ok)                                                   \
-  while (((ok) = _ecore_exe_check_errno((result) = (foo), __FILE__, __LINE__)) == -1) \
-    sleep(1)
+#define E_NO_ERRNO(result, foo, ok) \
+  while (((ok) = _ecore_exe_check_errno((result) = (foo), __FILE__, __LINE__)) == -1) sleep(1)
 
 #define E_IF_NO_ERRNO_NOLOOP(result, foo, ok) \
   if (((ok) = _ecore_exe_check_errno((result) = (foo), __FILE__, __LINE__)))
 
 static int
-_ecore_exe_check_errno(int result,
+_ecore_exe_check_errno(int         result,
                        const char *file EINA_UNUSED,
-                       int line EINA_UNUSED)
+                       int         line EINA_UNUSED)
 {
    int saved_errno = errno;
 
    if (result == -1)
-     {
-        perror("*** errno reports ");
+   {
+      perror("*** errno reports ");
 /* What is currently supported -
  *
  *   pipe
@@ -152,63 +143,63 @@ _ecore_exe_check_errno(int result,
  *        // Something failed, cleanup.
  *     }
  */
-        switch (saved_errno)
-          {
-           case EACCES:
-           case EAGAIN:
-           case EINTR:
-           { /* Not now, try later. */
-             ERR("*** Must try again in %s @%u.", file, line);
-             result = -1;
-             break;
-           }
-
-           case EMFILE:
-           case ENFILE:
-           case ENOLCK:
-           { /* Low on resources. */
-             ERR("*** Low on resources in %s @%u.", file,
-                 line);
-             result = 0;
-             break;
-           }
-
-           case EIO:
-           { /* I/O error. */
-             ERR("*** I/O error in %s @%u.", file, line);
-             result = 0;
-             break;
-           }
-
-           case EFAULT:
-           case EBADF:
-           case EINVAL:
-           case EROFS:
-           case EISDIR:
-           case EDEADLK:
-           case EPERM:
-           case EBUSY:
-           { /* Programmer fucked up. */
-             ERR("*** NAUGHTY PROGRAMMER!!!\n"
-                 "*** SPANK SPANK SPANK!!!\n"
-                 "*** Now go fix your code in %s @%u. Tut tut tut!",
-                 file, line);
-             result = 0;
-             break;
-           }
-
-           default:
-           { /* Unsupported errno code, please add this one. */
-             ERR("*** NAUGHTY PROGRAMMER!!!\n"
-                 "*** SPANK SPANK SPANK!!!\n"
-                 "*** Unsupported errno code %d, please add this one.\n"
-                 "*** Now go fix your code in %s @%u, from %s @%u. Tut tut tut!",
-                 saved_errno, __FILE__, __LINE__, file, line);
-             result = 0;
-             break;
-           }
-          }
-     }
+      switch (saved_errno)
+      {
+       case EACCES:
+       case EAGAIN:
+       case EINTR:
+         { /* Not now, try later. */
+            ERR("*** Must try again in %s @%u.", file, line);
+            result = -1;
+            break;
+         }
+
+       case EMFILE:
+       case ENFILE:
+       case ENOLCK:
+         { /* Low on resources. */
+            ERR("*** Low on resources in %s @%u.", file,
+                line);
+            result = 0;
+            break;
+         }
+
+       case EIO:
+         { /* I/O error. */
+            ERR("*** I/O error in %s @%u.", file, line);
+            result = 0;
+            break;
+         }
+
+       case EFAULT:
+       case EBADF:
+       case EINVAL:
+       case EROFS:
+       case EISDIR:
+       case EDEADLK:
+       case EPERM:
+       case EBUSY:
+         { /* Programmer fucked up. */
+            ERR("*** NAUGHTY PROGRAMMER!!!\n"
+                "*** SPANK SPANK SPANK!!!\n"
+                "*** Now go fix your code in %s @%u. Tut tut tut!",
+                file, line);
+            result = 0;
+            break;
+         }
+
+       default:
+         { /* Unsupported errno code, please add this one. */
+            ERR("*** NAUGHTY PROGRAMMER!!!\n"
+                "*** SPANK SPANK SPANK!!!\n"
+                "*** Unsupported errno code %d, please add this one.\n"
+                "*** Now go fix your code in %s @%u, from %s @%u. Tut tut tut!",
+                saved_errno, __FILE__, __LINE__, file, line);
+            result = 0;
+            break;
+         }
+      }
+   }
    else /* Everything is fine. */
      result = 1;
 
@@ -260,319 +251,327 @@ _impl_ecore_exe_efl_object_finalize(Eo *obj, Ecore_Exe_Data *exe)
 
    /*  Create some pipes. */
    if (ok)
-     {
-        E_IF_NO_ERRNO_NOLOOP(result, pipe(statusPipe), ok)
-        {
-        }
-     }
+   {
+      E_IF_NO_ERRNO_NOLOOP(result, pipe(statusPipe), ok)
+      {
+      }
+   }
    if (ok && (flags & ECORE_EXE_PIPE_ERROR))
-     {
-        E_IF_NO_ERRNO_NOLOOP(result, pipe(errorPipe), ok)
-        {
-           exe->child_fd_error = errorPipe[0];
-           exe->child_fd_error_x = errorPipe[1];
-        }
-     }
+   {
+      E_IF_NO_ERRNO_NOLOOP(result, pipe(errorPipe), ok)
+      {
+         exe->child_fd_error = errorPipe[0];
+         exe->child_fd_error_x = errorPipe[1];
+      }
+   }
    if (ok && (flags & ECORE_EXE_PIPE_READ))
-     {
-        E_IF_NO_ERRNO_NOLOOP(result, pipe(readPipe), ok)
-        {
-           exe->child_fd_read = readPipe[0];
-           exe->child_fd_read_x = readPipe[1];
-        }
-     }
+   {
+      E_IF_NO_ERRNO_NOLOOP(result, pipe(readPipe), ok)
+      {
+         exe->child_fd_read = readPipe[0];
+         exe->child_fd_read_x = readPipe[1];
+      }
+   }
    if (ok && (flags & ECORE_EXE_PIPE_WRITE))
-     {
-        E_IF_NO_ERRNO_NOLOOP(result, pipe(writePipe), ok)
-        {
-           exe->child_fd_write = writePipe[1];
-           exe->child_fd_write_x = writePipe[0];
-        }
-     }
+   {
+      E_IF_NO_ERRNO_NOLOOP(result, pipe(writePipe), ok)
+      {
+         exe->child_fd_write = writePipe[1];
+         exe->child_fd_write_x = writePipe[0];
+      }
+   }
    if (ok)
-     {
-        pid_t pid = 0;
-        volatile int vfork_exec_errno = 0;
-
-        /* FIXME: I should double check this.  After a quick look around, this is already done, but via a more modern method. */
-        /* signal(SIGPIPE, SIG_IGN);    We only want EPIPE on errors */
-        pid = fork();
-
-        if (pid == -1)
-          {
-             ERR("Failed to fork process");
-             pid = 0;
-          }
-        else if (pid == 0) /* child */
-          {
+   {
+      pid_t pid = 0;
+      volatile int vfork_exec_errno = 0;
+
+      /* FIXME: I should double check this.  After a quick look around, this is already done, but via a more modern method. */
+      /* signal(SIGPIPE, SIG_IGN);    We only want EPIPE on errors */
+      pid = fork();
+
+      if (pid == -1)
+      {
+         ERR("Failed to fork process");
+         pid = 0;
+      }
+      else if (pid == 0) /* child */
+      {
 #ifdef HAVE_SYSTEMD
-             unsetenv("NOTIFY_SOCKET");
+         unsetenv("NOTIFY_SOCKET");
 #endif
-             if (run_pri != ECORE_EXE_PRIORITY_INHERIT)
-               {
-#ifdef PRIO_PROCESS
-                  if ((run_pri >= -20) && (run_pri <= 19))
-                    setpriority(PRIO_PROCESS, 0, run_pri);
+         if (run_pri != ECORE_EXE_PRIORITY_INHERIT)
+         {
+#ifdef PRIO_PROCESS            
+            if ((run_pri >= -20) && (run_pri <= 19))
+              setpriority(PRIO_PROCESS, 0, run_pri);
 #else
 #warning "Your OS/libc does not provide PRIO_PROCESS (and possibly setpriority())"
 #warning "This is a POSIX-1.2001 standard and it is highly encouraged that you"
 #warning "Have support for this"
 #endif
-               }
-             if (ok && (flags & ECORE_EXE_ISOLATE_IO))
-               {
-                  int devnull;
-
-                  /* we want to isolatie the stdin/out/err of the process so
-                   * it can't share those of the parent, so close and replace with
-                   * /dev/null */
-                  devnull = open("/dev/null", O_RDONLY);
-                  if (devnull >= 0)
-                    {
-                       E_NO_ERRNO(result, close(STDIN_FILENO), ok);
-                       E_NO_ERRNO(result, dup2(devnull, STDIN_FILENO), ok);
-                       E_NO_ERRNO(result, close(devnull), ok);
-                    }
-
-                  devnull = open("/dev/null", O_WRONLY);
-                  if (devnull >= 0)
-                    {
-                       E_NO_ERRNO(result, close(STDOUT_FILENO), ok);
-                       E_NO_ERRNO(result, dup2(devnull, STDOUT_FILENO), ok);
-                       E_NO_ERRNO(result, close(devnull), ok);
-                    }
-
-                  devnull = open("/dev/null", O_WRONLY);
-                  if (devnull >= 0)
-                    {
-                       E_NO_ERRNO(result, close(STDERR_FILENO), ok);
-                       E_NO_ERRNO(result, dup2(devnull, STDERR_FILENO), ok);
-                       E_NO_ERRNO(result, close(devnull), ok);
-                    }
-               }
-             else
-               {
-                  /* dup2 STDERR, STDIN, and STDOUT.  dup2() allegedly closes the
-                   * second pipe if it's open. On the other hand, there was the
-                   * Great FD Leak Scare of '06, so let's be paranoid. */
-                  if (ok && (flags & ECORE_EXE_PIPE_ERROR))
-                    {
-                       E_NO_ERRNO(result, close(STDERR_FILENO), ok);
-                       E_NO_ERRNO(result, dup2(errorPipe[1], STDERR_FILENO), ok);
-                    }
-                  if (ok && (flags & ECORE_EXE_PIPE_READ))
-                    {
-                       E_NO_ERRNO(result, close(STDOUT_FILENO), ok);
-                       E_NO_ERRNO(result, dup2(readPipe[1], STDOUT_FILENO), ok);
-                    }
-                  if (ok && (flags & ECORE_EXE_PIPE_WRITE))
-                    {
-                       E_NO_ERRNO(result, close(STDIN_FILENO), ok);
-                       E_NO_ERRNO(result, dup2(writePipe[0], STDIN_FILENO), ok);
-                    }
-               }
-
-             if (ok)
-               {
-                  /* Setup the status pipe. */
-                  E_NO_ERRNO(result, close(statusPipe[0]), ok);
-                  E_IF_NO_ERRNO(result, eina_file_close_on_exec(statusPipe[1], EINA_TRUE), ok) /* close on exec shows success */
-                  {
-                     /* Run the actual command. */
-                     _ecore_exe_exec_it(exe_cmd, flags); /* no return */
-                  }
-               }
-
-             /* Something went 'orribly wrong. */
-             vfork_exec_errno = errno;
-
-             /* Close the pipes. */
-             if (flags & ECORE_EXE_PIPE_ERROR)
-               E_NO_ERRNO(result, close(errorPipe[1]), ok);
-             if (flags & ECORE_EXE_PIPE_READ)
-               E_NO_ERRNO(result, close(readPipe[1]), ok);
-             if (flags & ECORE_EXE_PIPE_WRITE)
-               E_NO_ERRNO(result, close(writePipe[0]), ok);
-             E_NO_ERRNO(result, close(statusPipe[1]), ok);
-
-             _exit(-1);
-          }
-        else /* parent */
-          {
-             /* Close the unused pipes. */
-             E_NO_ERRNO(result, close(statusPipe[1]), ok);
-
-             /* FIXME: after having a good look at the current e fd
-              * handling, investigate fcntl(dataPipe[x], F_SETSIG, ...) */
-             /* FIXME: above F_SETSIG etc. - this is async SIGIO based IO
-              * which is also linux specific so we probably don't want to
-              * do this as long as select() is working fine. the only time
-              * we really want to think of SIGIO async IO is when it all
-              * actually works basically everywhere and we can turn all
-              * IO into DMA async activities (i.e. you do a read() then
-              * the read is complete not on return but when you get a
-              * SIGIO - the read() just starts the transfer and it is
-              * completed in the background by DMA (or whatever mechanism
-              * the kernel choses)) */
-
-             /* Wait for it to start executing. */
-             /* FIXME: this doesn't seem very nice - we sit and block
-              * waiting on a child process... even though it's just
-              * the segment between the fork() and the exec) it just feels
-              * wrong */
-             for (;; )
-               {
-                  char buf;
-
-                  E_NO_ERRNO(result, read(statusPipe[0], &buf, 1), ok);
-                  if (result == 0)
-                    {
-                       if (vfork_exec_errno != 0)
-                         {
-                            n = vfork_exec_errno;
-                            ERR("Could not start \"%s\"", exe_cmd);
-                            pid = 0;
-                         }
-                       break;
-                    }
-               }
+         }
+         if (ok && (flags & ECORE_EXE_ISOLATE_IO))
+           {
+              int devnull;
+
+              /* we want to isolatie the stdin/out/err of the process so
+               * it can't share those of the parent, so close and replace with
+               * /dev/null */
+              devnull = open("/dev/null", O_RDONLY);
+              if (devnull >= 0)
+                {
+                   E_NO_ERRNO(result, close(STDIN_FILENO), ok);
+                   E_NO_ERRNO(result, dup2(devnull, STDIN_FILENO), ok);
+                   E_NO_ERRNO(result, close(devnull), ok);
+                }
+
+              devnull = open("/dev/null", O_WRONLY);
+              if (devnull >= 0)
+                {
+                   E_NO_ERRNO(result, close(STDOUT_FILENO), ok);
+                   E_NO_ERRNO(result, dup2(devnull, STDOUT_FILENO), ok);
+                   E_NO_ERRNO(result, close(devnull), ok);
+                }
+
+              devnull = open("/dev/null", O_WRONLY);
+              if (devnull >= 0)
+                {
+                   E_NO_ERRNO(result, close(STDERR_FILENO), ok);
+                   E_NO_ERRNO(result, dup2(devnull, STDERR_FILENO), ok);
+                   E_NO_ERRNO(result, close(devnull), ok);
+                }
+           }
+         else
+           {
+              /* dup2 STDERR, STDIN, and STDOUT.  dup2() allegedly closes the
+               * second pipe if it's open. On the other hand, there was the
+               * Great FD Leak Scare of '06, so let's be paranoid. */
+              if (ok && (flags & ECORE_EXE_PIPE_ERROR))
+                {
+                   E_NO_ERRNO(result, close(STDERR_FILENO), ok);
+                   E_NO_ERRNO(result, dup2(errorPipe[1], STDERR_FILENO), ok);
+                }
+              if (ok && (flags & ECORE_EXE_PIPE_READ))
+                {
+                   E_NO_ERRNO(result, close(STDOUT_FILENO), ok);
+                   E_NO_ERRNO(result, dup2(readPipe[1], STDOUT_FILENO), ok);
+                }
+              if (ok && (flags & ECORE_EXE_PIPE_WRITE))
+                {
+                   E_NO_ERRNO(result, close(STDIN_FILENO), ok);
+                   E_NO_ERRNO(result, dup2(writePipe[0], STDIN_FILENO), ok);
+                }
+           }
 
-             /* Close the status pipe. */
+         if (ok)
+         {
+            /* Setup the status pipe. */
              E_NO_ERRNO(result, close(statusPipe[0]), ok);
+             E_IF_NO_ERRNO(result, eina_file_close_on_exec(statusPipe[1], EINA_TRUE), ok) /* close on exec shows success */
+             {
+                /* Run the actual command. */
+                 _ecore_exe_exec_it(exe_cmd, flags); /* no return */
+             }
+         }
+
+         /* Something went 'orribly wrong. */
+         vfork_exec_errno = errno;
+
+         /* Close the pipes. */
+         if (flags & ECORE_EXE_PIPE_ERROR)
+           E_NO_ERRNO(result, close(errorPipe[1]), ok);
+         if (flags & ECORE_EXE_PIPE_READ)
+           E_NO_ERRNO(result, close(readPipe[1]), ok);
+         if (flags & ECORE_EXE_PIPE_WRITE)
+           E_NO_ERRNO(result, close(writePipe[0]), ok);
+         E_NO_ERRNO(result, close(statusPipe[1]), ok);
+
+         _exit(-1);
+      }
+      else   /* parent */
+      {
+         /* Close the unused pipes. */
+          E_NO_ERRNO(result, close(statusPipe[1]), ok);
+
+          /* FIXME: after having a good look at the current e fd
+           * handling, investigate fcntl(dataPipe[x], F_SETSIG, ...) */
+          /* FIXME: above F_SETSIG etc. - this is async SIGIO based IO
+           * which is also linux specific so we probably don't want to
+           * do this as long as select() is working fine. the only time
+           * we really want to think of SIGIO async IO is when it all
+           * actually works basically everywhere and we can turn all
+           * IO into DMA async activities (i.e. you do a read() then
+           * the read is complete not on return but when you get a
+           * SIGIO - the read() just starts the transfer and it is
+           * completed in the background by DMA (or whatever mechanism
+           * the kernel choses)) */
+
+          /* Wait for it to start executing. */
+          /* FIXME: this doesn't seem very nice - we sit and block
+           * waiting on a child process... even though it's just
+           * the segment between the fork() and the exec) it just feels
+           * wrong */
+          for (;; )
+          {
+             char buf;
+
+             E_NO_ERRNO(result, read(statusPipe[0], &buf, 1), ok);
+             if (result == 0)
+             {
+                if (vfork_exec_errno != 0)
+                {
+                   n = vfork_exec_errno;
+                   ERR("Could not start \"%s\"", exe_cmd);
+                   pid = 0;
+                }
+                break;
+             }
           }
 
-        if (pid)
+          /* Close the status pipe. */
+          E_NO_ERRNO(result, close(statusPipe[0]), ok);
+      }
+
+      if (pid)
+      {
+         /* Setup the exe structure. */
+          exe->start_bytes = -1;
+          exe->end_bytes = -1;
+          exe->start_lines = -1;
+          exe->end_lines = -1;
+          exe->pid = pid;
+          exe->flags = flags;
+          if (exe->cmd)
           {
-             /* Setup the exe structure. */
-             exe->start_bytes = -1;
-             exe->end_bytes = -1;
-             exe->start_lines = -1;
-             exe->end_lines = -1;
-             exe->pid = pid;
-             exe->flags = flags;
-             if (exe->cmd)
-               {
-                  if (flags & ECORE_EXE_PIPE_ERROR) /* Setup the error stuff. */
-                    {
-                       E_IF_NO_ERRNO(result,
-                                     fcntl(exe->child_fd_error, F_SETFL,
-                                           O_NONBLOCK), ok) {
-                       }
-                       E_IF_NO_ERRNO(result,
-                                     eina_file_close_on_exec(exe->child_fd_error, EINA_TRUE),
-                                     ok) {
-                       }
-                       E_IF_NO_ERRNO(result,
-                                     eina_file_close_on_exec(exe->child_fd_error_x, EINA_TRUE),
-                                     ok) {
-                       }
-                       {
-                          exe->error_fd_handler =
-                            ecore_main_fd_handler_add(exe->child_fd_error,
-                                                      ECORE_FD_READ,
-                                                      _ecore_exe_data_error_handler,
-                                                      obj, NULL, NULL);
-                          if (!exe->error_fd_handler)
-                            ok = 0;
-                       }
-                    }
-                  if (ok && (flags & ECORE_EXE_PIPE_READ)) /* Setup the read stuff. */
-                    {
-                       E_IF_NO_ERRNO(result,
-                                     fcntl(exe->child_fd_read, F_SETFL,
-                                           O_NONBLOCK), ok) {
-                       }
-                       E_IF_NO_ERRNO(result,
-                                     eina_file_close_on_exec(exe->child_fd_read, EINA_TRUE),
-                                     ok) {
-                       }
-                       E_IF_NO_ERRNO(result,
-                                     eina_file_close_on_exec(exe->child_fd_read_x, EINA_TRUE),
-                                     ok) {
-                       }
-                       {
-                          exe->read_fd_handler =
-                            ecore_main_fd_handler_add(exe->child_fd_read,
-                                                      ECORE_FD_READ,
-                                                      _ecore_exe_data_read_handler,
-                                                      obj, NULL, NULL);
-                          if (!exe->read_fd_handler)
-                            ok = 0;
-                       }
-                    }
-                  if (ok && (flags & ECORE_EXE_PIPE_WRITE)) /* Setup the write stuff. */
-                    {
-                       E_IF_NO_ERRNO(result,
-                                     fcntl(exe->child_fd_write, F_SETFL,
-                                           O_NONBLOCK), ok) {
-                       }
-                       E_IF_NO_ERRNO(result,
-                                     eina_file_close_on_exec(exe->child_fd_write, EINA_TRUE),
-                                     ok) {
-                       }
-                       E_IF_NO_ERRNO(result,
-                                     eina_file_close_on_exec(exe->child_fd_write_x, EINA_TRUE),
-                                     ok) {
-                       }
-                       {
-                          exe->write_fd_handler =
-                            ecore_main_fd_handler_add(exe->child_fd_write,
-                                                      ECORE_FD_WRITE,
-                                                      _ecore_exe_data_write_handler,
-                                                      obj, NULL, NULL);
-                          if (exe->write_fd_handler)
-                            ecore_main_fd_handler_active_set(exe->write_fd_handler, 0);  /* Nothing to write to start with. */
-                          else
-                            ok = 0;
-                       }
-                    }
-
-                  _ecore_exe_exes = eina_list_append(_ecore_exe_exes, obj);
-                  n = 0;
-               }
-             else
-               ok = 0;
+             if (flags & ECORE_EXE_PIPE_ERROR) /* Setup the error stuff. */
+             {
+                E_IF_NO_ERRNO(result,
+                              fcntl(exe->child_fd_error, F_SETFL,
+                                    O_NONBLOCK), ok) {
+                }
+                E_IF_NO_ERRNO(result,
+                              eina_file_close_on_exec(exe->child_fd_error, EINA_TRUE),
+                              ok) {
+                }
+                E_IF_NO_ERRNO(result,
+                              eina_file_close_on_exec(exe->child_fd_error_x, EINA_TRUE),
+                              ok) {
+                }
+                {
+                   // XXX: eoify ecore fd handlers
+                   exe->error_fd_handler =
+                     ecore_main_fd_handler_add(exe->child_fd_error,
+                                               ECORE_FD_READ,
+                                               _ecore_exe_data_error_handler,
+                                               obj, NULL, NULL);
+                   if (!exe->error_fd_handler)
+                     ok = 0;
+                }
+             }
+             if (ok && (flags & ECORE_EXE_PIPE_READ)) /* Setup the read stuff. */
+             {
+                E_IF_NO_ERRNO(result,
+                              fcntl(exe->child_fd_read, F_SETFL,
+                                    O_NONBLOCK), ok) {
+                }
+                E_IF_NO_ERRNO(result,
+                              eina_file_close_on_exec(exe->child_fd_read, EINA_TRUE),
+                              ok) {
+                }
+                E_IF_NO_ERRNO(result,
+                              eina_file_close_on_exec(exe->child_fd_read_x, EINA_TRUE),
+                              ok) {
+                }
+                {
+                   // XXX: eoify ecore fd handlers
+                   exe->read_fd_handler =
+                     ecore_main_fd_handler_add(exe->child_fd_read,
+                                               ECORE_FD_READ,
+                                               _ecore_exe_data_read_handler,
+                                               obj, NULL, NULL);
+                   if (!exe->read_fd_handler)
+                     ok = 0;
+                }
+             }
+             if (ok && (flags & ECORE_EXE_PIPE_WRITE)) /* Setup the write stuff. */
+             {
+                E_IF_NO_ERRNO(result,
+                              fcntl(exe->child_fd_write, F_SETFL,
+                                    O_NONBLOCK), ok) {
+                }
+                E_IF_NO_ERRNO(result,
+                              eina_file_close_on_exec(exe->child_fd_write, EINA_TRUE),
+                              ok) {
+                }
+                E_IF_NO_ERRNO(result,
+                              eina_file_close_on_exec(exe->child_fd_write_x, EINA_TRUE),
+                              ok) {
+                }
+                {
+                   // XXX: eoify ecore fd handlers
+                   exe->write_fd_handler =
+                     ecore_main_fd_handler_add(exe->child_fd_write,
+                                               ECORE_FD_WRITE,
+                                               _ecore_exe_data_write_handler,
+                                               obj, NULL, NULL);
+                   // XXX: eoify ecore fd handlers
+                   if (exe->write_fd_handler)
+                     ecore_main_fd_handler_active_set(exe->write_fd_handler, 0);  /* Nothing to write to start with. */
+                   else
+                     ok = 0;
+                }
+             }
+
+             exe->loop = efl_provider_find(obj, EFL_LOOP_CLASS);
+             Efl_Loop_Data *loop = efl_data_scope_get(exe->loop, EFL_LOOP_CLASS);
+             if (loop) loop->exes = eina_list_append(loop->exes, obj);
+             n = 0;
           }
-        else
-          ok = 0;
-     }
+          else
+            ok = 0;
+      }
+      else
+        ok = 0;
+   }
 
    if (!ok) /* Something went wrong, so pull down everything. */
-     {
-        if (exe->pid) ecore_exe_terminate(obj);
-        obj = NULL;
-     }
+   {
+      // XXX: eoify terminate method
+      if (exe->pid) ecore_exe_terminate(obj);
+      obj = NULL;
+   }
    else
-     {
-        Ecore_Exe_Event_Add *e;
+   {
+      Ecore_Exe_Event_Add *e;
 
-        e = _ecore_exe_event_add_new();
-        if (e)
-          {
-             e->exe = obj;
-             /* Send the event. */
-             ecore_event_add(ECORE_EXE_EVENT_ADD, e,
-                             _ecore_exe_event_add_free, NULL);
-          }
-        /* INF("Running as %d for %s.\n", exe->pid, exe->cmd); */
-     }
+      e = _ecore_exe_event_add_new();
+      if (e)
+        {
+           e->exe = obj;
+           // XXX: eoify ecore_event_add
+           /* Send the event. */
+           ecore_event_add(ECORE_EXE_EVENT_ADD, e,
+                           _ecore_exe_event_add_free, NULL);
+        }
+      /* INF("Running as %d for %s.\n", exe->pid, exe->cmd); */
+   }
 
    errno = n;
    return obj;
 }
 
 Eina_Bool
-_impl_ecore_exe_send(Ecore_Exe *obj EINA_UNUSED,
-                     Ecore_Exe_Data *exe,
-                     const void *data,
-                     int size)
+_impl_ecore_exe_send(Ecore_Exe  *obj EINA_UNUSED,
+               Ecore_Exe_Data *exe,
+               const void *data,
+               int         size)
 {
    void *buf;
 
    if (exe->child_fd_write == -1)
      {
         ERR("Ecore_Exe %p created without ECORE_EXE_PIPE_WRITE! "
-            "Cannot send %d bytes from %p", exe, size, data);
+              "Cannot send %d bytes from %p", exe, size, data);
         return EINA_FALSE;
      }
 
@@ -583,19 +582,20 @@ _impl_ecore_exe_send(Ecore_Exe *obj EINA_UNUSED,
    memcpy((char *)exe->write_data_buf + exe->write_data_size, data, size);
    exe->write_data_size += size;
 
+   // XXX: eoify ecore_fd_handlers
    if (exe->write_fd_handler)
-     ecore_main_fd_handler_active_set(exe->write_fd_handler, ECORE_FD_WRITE);
+      ecore_main_fd_handler_active_set(exe->write_fd_handler, ECORE_FD_WRITE);
 
    return EINA_TRUE;
 }
 
 void
 _impl_ecore_exe_auto_limits_set(Ecore_Exe *obj EINA_UNUSED,
-                                Ecore_Exe_Data *exe,
-                                int start_bytes,
-                                int end_bytes,
-                                int start_lines,
-                                int end_lines)
+                          Ecore_Exe_Data *exe,
+                          int        start_bytes,
+                          int        end_bytes,
+                          int        start_lines,
+                          int        end_lines)
 {
    /* FIXME: sanitize the input. */
    exe->start_bytes = start_bytes;
@@ -644,9 +644,9 @@ _impl_ecore_exe_auto_limits_set(Ecore_Exe *obj EINA_UNUSED,
 }
 
 Ecore_Exe_Event_Data *
-_impl_ecore_exe_event_data_get(Ecore_Exe *obj,
-                               Ecore_Exe_Data *exe,
-                               Ecore_Exe_Flags flags)
+_impl_ecore_exe_event_data_get(Ecore_Exe      *obj,
+                         Ecore_Exe_Data *exe,
+                         Ecore_Exe_Flags flags)
 {
    Ecore_Exe_Event_Data *e = NULL;
    int is_buffered = 0;
@@ -655,130 +655,130 @@ _impl_ecore_exe_event_data_get(Ecore_Exe *obj,
 
    /* Sort out what sort of event we are. */
    if (flags & ECORE_EXE_PIPE_READ)
-     {
-        flags = ECORE_EXE_PIPE_READ;
-        if (exe->flags & ECORE_EXE_PIPE_READ_LINE_BUFFERED)
-          is_buffered = 1;
-     }
+   {
+      flags = ECORE_EXE_PIPE_READ;
+      if (exe->flags & ECORE_EXE_PIPE_READ_LINE_BUFFERED)
+        is_buffered = 1;
+   }
    else
-     {
-        flags = ECORE_EXE_PIPE_ERROR;
-        if (exe->flags & ECORE_EXE_PIPE_ERROR_LINE_BUFFERED)
-          is_buffered = 1;
-     }
+   {
+      flags = ECORE_EXE_PIPE_ERROR;
+      if (exe->flags & ECORE_EXE_PIPE_ERROR_LINE_BUFFERED)
+        is_buffered = 1;
+   }
 
    /* Get the data. */
    if (flags & ECORE_EXE_PIPE_READ)
-     {
-        inbuf = exe->read_data_buf;
-        inbuf_num = exe->read_data_size;
-        exe->read_data_buf = NULL;
-        exe->read_data_size = 0;
-     }
+   {
+      inbuf = exe->read_data_buf;
+      inbuf_num = exe->read_data_size;
+      exe->read_data_buf = NULL;
+      exe->read_data_size = 0;
+   }
    else
-     {
-        inbuf = exe->error_data_buf;
-        inbuf_num = exe->error_data_size;
-        exe->error_data_buf = NULL;
-        exe->error_data_size = 0;
-     }
+   {
+      inbuf = exe->error_data_buf;
+      inbuf_num = exe->error_data_size;
+      exe->error_data_buf = NULL;
+      exe->error_data_size = 0;
+   }
 
    e = calloc(1, sizeof(Ecore_Exe_Event_Data));
    if (e)
-     {
-        e->exe = obj;
-        e->data = inbuf;
-        e->size = inbuf_num;
-
-        if (is_buffered) /* Deal with line buffering. */
-          {
-             int max = 0;
-             int count = 0;
-             int i;
-             int last = 0;
-             char *c;
-
-             c = (char *)inbuf;
-             for (i = 0; i < inbuf_num; i++) /* Find the lines. */
-               {
-                  if (inbuf[i] == '\n')
-                    {
-                       if (count >= max)
-                         {
-                            Ecore_Exe_Event_Data_Line *lines;
-
-                            /* In testing, the lines seem to arrive in batches of 500 to 1000 lines at most, roughly speaking. */
-                            max += 10; /* FIXME: Maybe keep track of the largest number of lines ever sent, and add half that many instead of 10. */
-                            lines = realloc(e->lines, sizeof(Ecore_Exe_Event_Data_Line) * (max + 1)); /* Allow room for the NULL termination. */
-                            if (!lines)
-                              {
-                                 ERR("Out of memory adding exe data lines to event");
-                                 break;
-                              }
-                            e->lines = lines;
-                         }
-                       /* raster said to leave the line endings as line endings, however -
-                        * This is line buffered mode, we are not dealing with binary here, but lines.
-                        * If we are not dealing with binary, we must be dealing with ASCII, unicode, or some other text format.
-                        * Thus the user is most likely gonna deal with this text as strings.
-                        * Thus the user is most likely gonna pass this data to str functions.
-                        * rasters way - the endings are always gonna be '\n';  onefangs way - they will always be '\0'
-                        * We are handing them the string length as a convenience.
-                        * Thus if they really want it in raw format, they can e->lines[i].line[e->lines[i].size - 1] = '\n'; easily enough.
-                        * In the default case, we can do this conversion quicker than the user can, as we already have the index and pointer.
-                        * Let's make it easy on them to use these as standard C strings.
-                        *
-                        * onefang is proud to announce that he has just set a new personal record for the
-                        * most over documentation of a simple assignment statement.  B-)
-                        */
-                       inbuf[i] = '\0';
-                       e->lines[count].line = c;
-                       e->lines[count].size = i - last;
-                       last = i + 1;
-                       c = (char *)&inbuf[last];
-                       count++;
-                    }
-               }
-             if (i > last) /* Partial line left over, save it for next time. */
-               {
-                  if (count != 0) e->size = last;
-                  if (flags & ECORE_EXE_PIPE_READ)
-                    {
-                       exe->read_data_size = i - last;
-                       exe->read_data_buf = malloc(exe->read_data_size);
-                       if (exe->read_data_buf)
-                         memcpy(exe->read_data_buf, c, exe->read_data_size);
-                       else
-                         {
-                            exe->read_data_size = 0;
-                            ERR("Out of memory in allocating exe pipe data");
-                         }
-                    }
-                  else
-                    {
-                       exe->error_data_size = i - last;
-                       exe->error_data_buf = malloc(exe->error_data_size);
-                       if (exe->error_data_buf)
-                         memcpy(exe->error_data_buf, c, exe->error_data_size);
-                       else
-                         {
-                            exe->error_data_size = 0;
-                            ERR("Out of memory in allocating exe pipe data");
-                         }
-                    }
-               }
-             if (count == 0) /* No lines to send, cancel the event. */
-               {
-                  _ecore_exe_event_exe_data_free(NULL, e);
-                  e = NULL;
-               }
-             else /* NULL terminate the array, so that people know where the end is. */
+   {
+      e->exe = obj;
+      e->data = inbuf;
+      e->size = inbuf_num;
+
+      if (is_buffered) /* Deal with line buffering. */
+      {
+         int max = 0;
+         int count = 0;
+         int i;
+         int last = 0;
+         char *c;
+
+         c = (char *)inbuf;
+         for (i = 0; i < inbuf_num; i++) /* Find the lines. */
+         {
+            if (inbuf[i] == '\n')
+            {
+               if (count >= max)
                {
-                  e->lines[count].line = NULL;
-                  e->lines[count].size = 0;
+                  Ecore_Exe_Event_Data_Line *lines;
+
+                  /* In testing, the lines seem to arrive in batches of 500 to 1000 lines at most, roughly speaking. */
+                   max += 10; /* FIXME: Maybe keep track of the largest number of lines ever sent, and add half that many instead of 10. */
+                   lines = realloc(e->lines, sizeof(Ecore_Exe_Event_Data_Line) * (max + 1)); /* Allow room for the NULL termination. */
+                   if (!lines)
+                   {
+                      ERR("Out of memory adding exe data lines to event");
+                      break;
+                   }
+                   e->lines = lines;
                }
-          }
-     }
+               /* raster said to leave the line endings as line endings, however -
+                * This is line buffered mode, we are not dealing with binary here, but lines.
+                * If we are not dealing with binary, we must be dealing with ASCII, unicode, or some other text format.
+                * Thus the user is most likely gonna deal with this text as strings.
+                * Thus the user is most likely gonna pass this data to str functions.
+                * rasters way - the endings are always gonna be '\n';  onefangs way - they will always be '\0'
+                * We are handing them the string length as a convenience.
+                * Thus if they really want it in raw format, they can e->lines[i].line[e->lines[i].size - 1] = '\n'; easily enough.
+                * In the default case, we can do this conversion quicker than the user can, as we already have the index and pointer.
+                * Let's make it easy on them to use these as standard C strings.
+                *
+                * onefang is proud to announce that he has just set a new personal record for the
+                * most over documentation of a simple assignment statement.  B-)
+                */
+               inbuf[i] = '\0';
+               e->lines[count].line = c;
+               e->lines[count].size = i - last;
+               last = i + 1;
+               c = (char *)&inbuf[last];
+               count++;
+            }
+         }
+         if (i > last) /* Partial line left over, save it for next time. */
+         {
+            if (count != 0) e->size = last;
+            if (flags & ECORE_EXE_PIPE_READ)
+            {
+               exe->read_data_size = i - last;
+               exe->read_data_buf = malloc(exe->read_data_size);
+               if (exe->read_data_buf)
+                 memcpy(exe->read_data_buf, c, exe->read_data_size);
+               else
+                 {
+                    exe->read_data_size = 0;
+                    ERR("Out of memory in allocating exe pipe data");
+                 }
+            }
+            else
+            {
+               exe->error_data_size = i - last;
+               exe->error_data_buf = malloc(exe->error_data_size);
+               if (exe->error_data_buf)
+                 memcpy(exe->error_data_buf, c, exe->error_data_size);
+               else
+                 {
+                    exe->error_data_size = 0;
+                    ERR("Out of memory in allocating exe pipe data");
+                 }
+            }
+         }
+         if (count == 0) /* No lines to send, cancel the event. */
+         {
+            _ecore_exe_event_exe_data_free(NULL, e);
+            e = NULL;
+         }
+         else /* NULL terminate the array, so that people know where the end is. */
+         {
+            e->lines[count].line = NULL;
+            e->lines[count].size = 0;
+         }
+      }
+   }
 
    return e;
 }
@@ -795,20 +795,9 @@ _impl_ecore_exe_efl_object_destructor(Eo *obj, Ecore_Exe_Data *exe)
    if (exe->pre_free_cb)
      exe->pre_free_cb(data, obj);
 
-   if (exe->doomsday_clock)
-     {
-        struct _ecore_exe_dead_exe *dead;
+   exe->doomsday_clock = NULL;
 
-        ecore_timer_del(exe->doomsday_clock);
-        exe->doomsday_clock = NULL;
-        dead = exe->doomsday_clock_dead;
-        if (dead)
-          {
-             IF_FREE(dead->cmd);
-             free(dead);
-             exe->doomsday_clock_dead = NULL;
-          }
-     }
+   // XXX: eoify ecore fd handlers
    IF_FN_DEL(ecore_main_fd_handler_del, exe->write_fd_handler);
    IF_FN_DEL(ecore_main_fd_handler_del, exe->read_fd_handler);
    IF_FN_DEL(ecore_main_fd_handler_del, exe->error_fd_handler);
@@ -829,7 +818,8 @@ _impl_ecore_exe_efl_object_destructor(Eo *obj, Ecore_Exe_Data *exe)
    IF_FREE(exe->error_data_buf);
    IF_FREE(exe->cmd);
 
-   _ecore_exe_exes = eina_list_remove(_ecore_exe_exes, obj);
+   Efl_Loop_Data *loop = efl_data_scope_get(exe->loop, EFL_LOOP_CLASS);
+   if (loop) loop->exes = eina_list_remove(loop->exes, obj);
    IF_FREE(exe->tag);
 }
 
@@ -870,25 +860,21 @@ _impl_ecore_exe_terminate(Ecore_Exe *obj, Ecore_Exe_Data *exe)
 void
 _impl_ecore_exe_kill(Ecore_Exe *obj EINA_UNUSED, Ecore_Exe_Data *exe)
 {
-   struct _ecore_exe_dead_exe *dead;
-   dead = calloc(1, sizeof(struct _ecore_exe_dead_exe));
-   if (dead)
-     {
-        dead->pid = exe->pid;
-        dead->cmd = strdup(exe->cmd);
-        IF_FN_DEL(ecore_timer_del, exe->doomsday_clock);
-        exe->doomsday_clock =
-          ecore_timer_add(10.0, _ecore_exe_make_sure_its_really_dead, dead);
-     }
-
+   efl_del(exe->doomsday_clock);
+   exe->doomsday_clock = efl_add(EFL_LOOP_TIMER_CLASS, obj,
+                                 efl_event_callback_add(efl_added,
+                                                        EFL_LOOP_TIMER_EVENT_TICK,
+                                                        _ecore_exe_make_sure_its_really_dead,
+                                                        obj),
+                                 efl_loop_timer_interval_set(efl_added, 10.0));
    INF("Sending KILL signal to %s (%d).", exe->cmd, exe->pid);
    kill(exe->pid, SIGKILL);
 }
 
 void
 _impl_ecore_exe_signal(Ecore_Exe *obj EINA_UNUSED,
-                       Ecore_Exe_Data *exe,
-                       int num)
+                 Ecore_Exe_Data *exe,
+                 int        num)
 {
    if (num == 1)
      kill(exe->pid, SIGUSR1);
@@ -902,102 +888,41 @@ _impl_ecore_exe_hup(Ecore_Exe *obj EINA_UNUSED, Ecore_Exe_Data *exe)
    kill(exe->pid, SIGHUP);
 }
 
-static Ecore_Exe *
-_ecore_exe_is_it_alive(pid_t pid)
-{
-   Ecore_Exe *exe = NULL;
-
-   /* FIXME: There is no nice, safe, OS independent way to tell if a
-    * particular PID is still alive.  I have written code to do so
-    * for my urunlevel busybox applet (http://urunlevel.sourceforge.net/),
-    * but it's for linux only, and still not guaranteed.
-    *
-    * So for now, we just check that a valid Ecore_Exe structure
-    * exists for it.  Even that is not a guarantee, as the structure
-    * can be freed without killing the process.
-    *
-    * I think we can safely put exe's into two categories, those users
-    * that care about the life of the exe, and the run and forget type.
-    * The run and forget type starts up the exe, then free's the
-    * Ecore_Exe structure straight away.  They can never call any of
-    * the functions that can call this, so we don't worry about them.
-    *
-    * Those user's that care about the life of exe's will keep the
-    * Ecore_Exe structure around, terminate them eventually, or
-    * register for exit events.  For these ones the assumption
-    * that valid Ecore_Exe struct == live exe is almost valid.
-    *
-    * I will probably copy my urunlevel code into here someday.
-    */
-   exe = _ecore_exe_find(pid);
-
-   return exe;
-}
-
-static Eina_Bool
-_ecore_exe_make_sure_its_dead(void *data)
+static void
+_ecore_exe_make_sure_its_dead(void *data, const Efl_Event *event EINA_UNUSED)
 {
-   struct _ecore_exe_dead_exe *dead;
-
-   dead = data;
-   if (dead)
+   Eo *exe_obj = data;
+   Ecore_Exe_Data *exe = efl_data_scope_get(exe_obj, MY_CLASS);
+   if (exe)
      {
-        Ecore_Exe *obj = NULL;
-
-        if ((obj = _ecore_exe_is_it_alive(dead->pid)))
-          {
-             Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-             if (exe)
-               {
-                  if (dead->cmd)
-                    INF("Sending KILL signal to allegedly dead %s (%d).",
-                        dead->cmd, dead->pid);
-                  else
-                    INF("Sending KILL signal to allegedly dead PID %d.",
-                        dead->pid);
-                  exe->doomsday_clock =
-                    ecore_timer_add(10.0, _ecore_exe_make_sure_its_really_dead,
-                                    dead);
-                  kill(dead->pid, SIGKILL);
-               }
-          }
+        if (exe->cmd)
+          INF("Sending KILL signal to allegedly dead %s (%d).", exe->cmd, exe->pid);
         else
-          {
-             IF_FREE(dead->cmd);
-             free(dead);
-          }
+          INF("Sending KILL signal to allegedly dead PID %d.", exe->pid);
+        exe->doomsday_clock = efl_add(EFL_LOOP_TIMER_CLASS, exe_obj,
+                                      efl_event_callback_add(efl_added,
+                                                             EFL_LOOP_TIMER_EVENT_TICK,
+                                                             _ecore_exe_make_sure_its_really_dead,
+                                                             exe_obj),
+                                      efl_loop_timer_interval_set(efl_added, 10.0));
+        kill(exe->pid, SIGKILL);
      }
-   return ECORE_CALLBACK_CANCEL;
 }
 
-static Eina_Bool
-_ecore_exe_make_sure_its_really_dead(void *data)
+static void
+_ecore_exe_make_sure_its_really_dead(void *data, const Efl_Event *event EINA_UNUSED)
 {
-   struct _ecore_exe_dead_exe *dead;
-
-   dead = data;
-   if (dead)
+   Eo *exe_obj = data;
+   Ecore_Exe_Data *exe = efl_data_scope_get(exe_obj, MY_CLASS);
+   if (exe)
      {
-        Ecore_Exe *obj = NULL;
-
-        if ((obj = _ecore_exe_is_it_alive(dead->pid)))
-          {
-             Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
-
-             if (exe)
-               {
-                  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);
-                  else
-                    INF("PID %d is not really dead.", dead->pid);
-                  exe->doomsday_clock = NULL;
-               }
-             IF_FREE(dead->cmd);
-             free(dead);
-          }
+        ERR("RUN!  The zombie wants to eat your brains!  And your CPU!");
+        if (exe->cmd)
+          INF("%s (%d) is not really dead.", exe->cmd, exe->pid);
+        else
+          INF("PID %d is not really dead.", exe->pid);
+        exe->doomsday_clock = NULL;
      }
-   return ECORE_CALLBACK_CANCEL;
 }
 
 Ecore_Timer *
@@ -1009,7 +934,7 @@ _ecore_exe_doomsday_clock_get(Ecore_Exe *obj)
 }
 
 void
-_ecore_exe_doomsday_clock_set(Ecore_Exe *obj,
+_ecore_exe_doomsday_clock_set(Ecore_Exe   *obj,
                               Ecore_Timer *dc)
 {
    Ecore_Exe_Data *exe = efl_data_scope_get(obj, MY_CLASS);
@@ -1018,7 +943,7 @@ _ecore_exe_doomsday_clock_set(Ecore_Exe *obj,
 }
 
 static inline void
-_ecore_exe_exec_it(const char *exe_cmd,
+_ecore_exe_exec_it(const char     *exe_cmd,
                    Ecore_Exe_Flags flags)
 {
    char use_sh = 1;
@@ -1033,55 +958,55 @@ _ecore_exe_exec_it(const char *exe_cmd,
     * If we don't find them, we can call the exe directly.
     */
    if (!strpbrk(exe_cmd, "|&;<>()$`\\\"'*?#"))
-     {
-        char *token;
-        char pre_command = 1;
-        int num_tokens = 0;
-        int len;
-
-        len = strlen(exe_cmd);
-        buf = alloca(len + 1);
-        strcpy(buf, exe_cmd);
-        buf[len] = 0;
-
-        token = strtok(buf, " \t\n\v");
-        while (token)
-          {
-             if (token[0] == '~')
-               break;
-             if (pre_command)
-               {
-                  if (token[0] == '[')
-                    break;
-                  if (strchr(token, '='))
-                    break;
-                  else
-                    pre_command = 0;
-               }
-             num_tokens++;
-             token = strtok(NULL, " \t\n\v");
-          }
-        if ((!token) && (num_tokens))
-          {
-             int i = 0;
-
-             len = strlen(exe_cmd);
-             buf = alloca(len + 1);
-             strcpy(buf, exe_cmd);
-             buf[len] = 0;
-
-             token = strtok(buf, " \t\n\v");
-             use_sh = 0;
-             args = alloca((num_tokens + 1) * sizeof(char *));
-             for (i = 0; i < num_tokens; i++)
-               {
-                  if (token)
-                    args[i] = token;
-                  token = strtok(NULL, " \t\n\v");
-               }
-             args[num_tokens] = NULL;
-          }
-     }
+   {
+      char *token;
+      char pre_command = 1;
+      int num_tokens = 0;
+      int len;
+
+      len = strlen(exe_cmd);
+      buf = alloca(len + 1);
+      strcpy(buf, exe_cmd);
+      buf[len] = 0;
+
+      token = strtok(buf, " \t\n\v");
+      while (token)
+      {
+         if (token[0] == '~')
+           break;
+         if (pre_command)
+         {
+            if (token[0] == '[')
+              break;
+            if (strchr(token, '='))
+              break;
+            else
+              pre_command = 0;
+         }
+         num_tokens++;
+         token = strtok(NULL, " \t\n\v");
+      }
+      if ((!token) && (num_tokens))
+      {
+         int i = 0;
+
+         len = strlen(exe_cmd);
+         buf = alloca(len + 1);
+         strcpy(buf, exe_cmd);
+         buf[len] = 0;
+
+         token = strtok(buf, " \t\n\v");
+         use_sh = 0;
+         args = alloca((num_tokens + 1) * sizeof(char *));
+         for (i = 0; i < num_tokens; i++)
+         {
+            if (token)
+              args[i] = token;
+            token = strtok(NULL, " \t\n\v");
+         }
+         args[num_tokens] = NULL;
+      }
+   }
 
 #ifdef HAVE_PRCTL
    if ((flags & ECORE_EXE_TERM_WITH_PARENT))
@@ -1092,34 +1017,34 @@ _ecore_exe_exec_it(const char *exe_cmd,
 
    if (!(flags & ECORE_EXE_NOT_LEADER)) setsid();
    if ((flags & ECORE_EXE_USE_SH))
-     {
-        errno = 0;
-        execl("/bin/sh", "/bin/sh", "-c", exe_cmd, (char *)NULL);
-     }
+   {
+      errno = 0;
+      execl("/bin/sh", "/bin/sh", "-c", exe_cmd, (char *)NULL);
+   }
    else if (use_sh) /* We have to use a shell to run this. */
-     {
-        if (!shell) /* Find users preferred shell. */
-          {
+   {
+      if (!shell) /* Find users preferred shell. */
+      {
 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
-             if (getuid() == geteuid())
+         if (getuid() == geteuid())
 #endif
-             shell = getenv("SHELL");
-             if (!shell)
-               shell = "/bin/sh";
-          }
-        errno = 0;
-        execl(shell, shell, "-c", exe_cmd, (char *)NULL);
-     }
-   else /* We can run this directly. */
-     {
-        if (!args)
-          {
-             ERR("arg[0] is NULL!");
-             return;
-          }
-        errno = 0;
-        if (args[0]) execvp(args[0], args);
-     }
+           shell = getenv("SHELL");
+         if (!shell)
+           shell = "/bin/sh";
+      }
+      errno = 0;
+      execl(shell, shell, "-c", exe_cmd, (char *)NULL);
+   }
+   else
+   { /* We can run this directly. */
+      if (!args)
+      {
+         ERR("arg[0] is NULL!");
+         return;
+      }
+      errno = 0;
+      if (args[0]) execvp(args[0], args);
+   }
 
    save_errno = errno;
    errno = save_errno;
@@ -1127,9 +1052,9 @@ _ecore_exe_exec_it(const char *exe_cmd,
 }
 
 static Eina_Bool
-_ecore_exe_data_generic_handler(void *data,
+_ecore_exe_data_generic_handler(void             *data,
                                 Ecore_Fd_Handler *fd_handler,
-                                Ecore_Exe_Flags flags)
+                                Ecore_Exe_Flags   flags)
 {
    Ecore_Exe *obj = data;
    int child_fd;
@@ -1141,139 +1066,142 @@ _ecore_exe_data_generic_handler(void *data,
 
    /* Sort out what sort of handler we are. */
    if (flags & ECORE_EXE_PIPE_READ)
-     {
-        flags = ECORE_EXE_PIPE_READ;
-        event_type = ECORE_EXE_EVENT_DATA;
-        eo_event = ECORE_EXE_EVENT_DATA_GET;
-        child_fd = exe->child_fd_read;
-     }
+   {
+      flags = ECORE_EXE_PIPE_READ;
+      event_type = ECORE_EXE_EVENT_DATA;
+      eo_event = ECORE_EXE_EVENT_DATA_GET;
+      child_fd = exe->child_fd_read;
+   }
    else
-     {
-        flags = ECORE_EXE_PIPE_ERROR;
-        event_type = ECORE_EXE_EVENT_ERROR;
-        eo_event = ECORE_EXE_EVENT_DATA_ERROR;
-        child_fd = exe->child_fd_error;
-     }
+   {
+      flags = ECORE_EXE_PIPE_ERROR;
+      event_type = ECORE_EXE_EVENT_ERROR;
+      eo_event = ECORE_EXE_EVENT_DATA_ERROR;
+      child_fd = exe->child_fd_error;
+   }
 
    if ((fd_handler)
        && (ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_READ)))
-     {
-        unsigned char *inbuf, *temp;
-        int inbuf_num;
-
-        /* Get any left over data from last time. */
-        if (flags & ECORE_EXE_PIPE_READ)
-          {
-             inbuf = exe->read_data_buf;
-             inbuf_num = exe->read_data_size;
-             exe->read_data_buf = NULL;
-             exe->read_data_size = 0;
-          }
-        else
-          {
-             inbuf = exe->error_data_buf;
-             inbuf_num = exe->error_data_size;
-             exe->error_data_buf = NULL;
-             exe->error_data_size = 0;
-          }
-
-        for (;; )
-          {
-             int num, lost_exe;
-             char buf[READBUFSIZ];
-
-             lost_exe = 0;
-             errno = 0;
-             if ((num = read(child_fd, buf, READBUFSIZ)) < 1)
+   {
+      unsigned char *inbuf, *temp;
+      int inbuf_num;
+
+      /* Get any left over data from last time. */
+      if (flags & ECORE_EXE_PIPE_READ)
+      {
+         inbuf = exe->read_data_buf;
+         inbuf_num = exe->read_data_size;
+         exe->read_data_buf = NULL;
+         exe->read_data_size = 0;
+      }
+      else
+      {
+         inbuf = exe->error_data_buf;
+         inbuf_num = exe->error_data_size;
+         exe->error_data_buf = NULL;
+         exe->error_data_size = 0;
+      }
+
+      for (;; )
+      {
+         int num, lost_exe;
+         char buf[READBUFSIZ];
+
+         lost_exe = 0;
+         errno = 0;
+         if ((num = read(child_fd, buf, READBUFSIZ)) < 1)
+         {
+            /* FIXME: SPEED/SIZE TRADE OFF - add a smaller READBUFSIZE
+             * (currently 64k) to inbuf, use that instead of buf, and
+             * save ourselves a memcpy(). */
+              lost_exe = ((errno == EIO) ||
+                          (errno == EBADF) ||
+                          (errno == EPIPE) ||
+                          (errno == EINVAL) || (errno == ENOSPC));
+              if ((errno != EAGAIN) && (errno != EINTR))
+                perror("_ecore_exe_generic_handler() read problem ");
+         }
+         if (num > 0) /* data got read. */
+         {
+            temp = inbuf;
+            inbuf = realloc(inbuf, inbuf_num + num);
+            if (inbuf)
+              {
+                 memcpy(inbuf + inbuf_num, buf, num);
+                 inbuf_num += num;
+              }
+            else // realloc fails and returns NULL.
+              {
+                 ERR("Out of memory in exe generic data handler");
+                 inbuf = temp;
+              }
+         }
+         else
+         { /* No more data to read. */
+            if (inbuf)
+            {
+               Ecore_Exe_Event_Data *e;
+
+               /* Stash the data away for later. */
+               if (flags & ECORE_EXE_PIPE_READ)
                {
-                  /* FIXME: SPEED/SIZE TRADE OFF - add a smaller READBUFSIZE
-                   * (currently 64k) to inbuf, use that instead of buf, and
-                   * save ourselves a memcpy(). */
-                  lost_exe = ((errno == EIO) ||
-                              (errno == EBADF) ||
-                              (errno == EPIPE) ||
-                              (errno == EINVAL) || (errno == ENOSPC));
-                  if ((errno != EAGAIN) && (errno != EINTR))
-                    perror("_ecore_exe_generic_handler() read problem ");
+                  exe->read_data_buf = inbuf;
+                  exe->read_data_size = inbuf_num;
                }
-             if (num > 0) /* data got read. */
+               else
                {
-                  temp = inbuf;
-                  inbuf = realloc(inbuf, inbuf_num + num);
-                  if (inbuf)
-                    {
-                       memcpy(inbuf + inbuf_num, buf, num);
-                       inbuf_num += num;
-                    }
-                  else // realloc fails and returns NULL.
-                    {
-                       ERR("Out of memory in exe generic data handler");
-                       inbuf = temp;
-                    }
+                  exe->error_data_buf = inbuf;
+                  exe->error_data_size = inbuf_num;
                }
-             else /* No more data to read. */
+
+               if (!(exe->flags & ECORE_EXE_PIPE_AUTO))
                {
-                  if (inbuf)
-                    {
-                       Ecore_Exe_Event_Data *e;
-
-                       /* Stash the data away for later. */
-                       if (flags & ECORE_EXE_PIPE_READ)
-                         {
-                            exe->read_data_buf = inbuf;
+                  // XXX: use eo method
+                  e = ecore_exe_event_data_get(obj, flags);
+                  if (e) /* Send the event. */