15 files changed, 1121 insertions, 1081 deletions

diff --git a/libraries/ecore/src/lib/ecore/Ecore.h b/libraries/ecore/src/lib/ecore/Ecore.h
index fbe4dda..eace560 100644
--- a/libraries/ecore/src/lib/ecore/Ecore.h
+++ b/libraries/ecore/src/lib/ecore/Ecore.h
@@ -9,7 +9,7 @@
    @mainpage Ecore
 
    @version 1.1
-   @date 2000-2011
+   @date 2000-2012
 
    Please see the @ref authors page for contact details.
 
@@ -22,7 +22,7 @@
    @li @ref Ecore_Main_Loop_Group
    @li @ref Ecore_File_Group
    @li @ref Ecore_Con_Group
-   @li @link Ecore_Evas.h   Ecore_Evas - Evas convenience functions. @endlink
+   @li @ref Ecore_Evas_Group
    @li @ref Ecore_FB_Group
    @li @link Ecore_Ipc.h    Ecore_IPC - Inter Process Communication functions. @endlink
    @li @link Ecore_X.h      Ecore_X - X Windows System wrapper. @endlink
@@ -35,21 +35,31 @@
    pkgconfig (.pc) files are installed for every ecore module.
    Thus, to compile using any of them, you can use something like the following:
 
-   @verbatim
-   gcc *.c $(pkg-config ecore ecore-$x ecore-$y [...] --cflags --libs)
-   @endverbatim
+@verbatim
+gcc *.c $(pkg-config ecore ecore-$x ecore-$y [...] --cflags --libs)
+@endverbatim
 
    @section install How is it installed?
 
-   Suggested configure options for evas for a Linux desktop X display:
+   Suggested configure options for ecore for a Linux desktop X display
+   with OpenGL and Software support, communication (networking) and
+   IPC (inter process communication):
 
-   @verbatim
-   ./configure \
-   make
-   su -
-   ...
-   make install
-   @endverbatim
+@verbatim
+./configure \
+    --enable-ecore-con \
+    --enable-ecore-ipc \
+    --enable-ecore-file \
+    --enable-ecore-input \
+    --enable-ecore-input-evas \
+    --enable-ecore-x \
+    --enable-ecore-evas \
+    --enable-ecore-evas-software-buffer \
+    --enable-ecore-evas-software-x11 \
+    --enable-ecore-evas-opengl-x11
+make
+sudo make install
+@endverbatim
 
  */
 
@@ -112,140 +122,175 @@
  */
 
 /**
-   @page Ecore_Main_Loop_Page The Ecore Main Loop
-
-   @section intro What is Ecore?
-
-   Ecore is a clean and tiny event loop library with many modules to do lots of
-   convenient things for a programmer, to save time and effort.
-
-   It's small and lean, designed to work on embedded systems all the way to
-   large and powerful multi-cpu workstations. It serialises all system signals,
-   events etc. into a single event queue, that is easily processed without
-   needing to worry about concurrency. A properly written, event-driven program
-   using this kind of programming doesn't need threads, nor has to worry about
-   concurrency. It turns a program into a state machine, and makes it very
-   robust and easy to follow.
-
-   Ecore gives you other handy primitives, such as timers to tick over for you
-   and call specified functions at particular times so the programmer can use
-   this to do things, like animate, or time out on connections or tasks that take
-   too long etc.
-
-   Idle handlers are provided too, as well as calls on entering an idle state
-   (often a very good time to update the state of the program). All events that
-   enter the system are passed to specific callback functions that the program
-   sets up to handle those events. Handling them is simple and other Ecore
-   modules produce more events on the queue, coming from other sources such as
-   file descriptors etc.
-
-   Ecore also lets you have functions called when file descriptors become active
-   for reading or writing, allowing for streamlined, non-blocking IO.
-
-   Here is an example of a simple program and its basic event loop flow:
-
-   @image html  prog_flow.png
-   @image latex prog_flow.eps width=\textwidth
-
-
-
-   @section work How does Ecore work?
-
-   Ecore is very easy to learn and use. All the function calls are designed to
-   be easy to remember, explicit in describing what they do, and heavily
-   name-spaced. Ecore programs can start and be very simple.
-
-   For example:
-
-   @code
-   #include <Ecore.h>
-
-   int
-   main(int argc, const char **argv)
-   {
-   ecore_init();
-   ecore_app_args_set(argc, argv);
-   ecore_main_loop_begin();
-   ecore_shutdown();
-   return 0;
-   }
-   @endcode
-
-   This program is very simple and doesn't check for errors, but it does start up
-   and begin a main loop waiting for events or timers to tick off. This program
-   doesn't set up any, but now we can expand on this simple program a little
-   more by adding some event handlers and timers.
-
-   @code
-   #include <Ecore.h>
-
-   Ecore_Timer         *timer1     = NULL;
-   Ecore_Event_Handler *handler1   = NULL;
-   double               start_time = 0.0;
-
-   int
-   timer_func(void *data)
-   {
-   printf("Tick timer. Sec: %3.2f\n", ecore_time_get() - start_time);
-   return 1;
-   }
-
-   int
-   exit_func(void *data, int ev_type, void *ev)
-   {
-   Ecore_Event_Signal_Exit *e;
-
-   e = (Ecore_Event_Signal_Exit *)ev;
-   if (e->interrupt)      printf("Exit: interrupt\n");
-   else if (e->quit)      printf("Exit: quit\n");
-   else if (e->terminate) printf("Exit: terminate\n");
-   ecore_main_loop_quit();
-   return 1;
-   }
-
-   int
-   main(int argc, const char **argv)
-   {
-   ecore_init();
-   ecore_app_args_set(argc, argv);
-   start_time = ecore_time_get();
-   handler1 = ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, exit_func, NULL);
-   timer1 = ecore_timer_add(0.5, timer_func, NULL);
-   ecore_main_loop_begin();
-   ecore_shutdown();
-   return 0;
-   }
-   @endcode
-
-   In the previous example, we initialize our application and get the time at
-   which our program has started so we can calculate an offset. We set
-   up a timer to tick off in 0.5 seconds, and since it returns 1, will
-   keep ticking off every 0.5 seconds until it returns 0, or is deleted
-   by hand. An event handler is set up to call a function -
-   exit_func(),
-   whenever an event of type ECORE_EVENT_SIGNAL_EXIT is received (CTRL-C
-   on the command line will cause such an event to happen). If this event
-   occurs it tells you what kind of exit signal was received, and asks
-   the main loop to quit when it is finished by calling
-   ecore_main_loop_quit().
-
-   The handles returned by ecore_timer_add() and
-   ecore_event_handler_add() are
-   only stored here as an example. If you don't need to address the timer or
-   event handler again you don't need to store the result, so just call the
-   function, and don't assign the result to any variable.
-
-   This program looks slightly more complex than needed to do these simple
-   things, but in principle, programs don't get any more complex. You add more
-   event handlers, for more events, will have more timers and such, BUT it all
-   follows the same principles as shown in this example.
-
+ * @page Ecore_Main_Loop_Page The Ecore Main Loop
+ *
+ * @section intro What is Ecore?
+ *
+ * Ecore is a clean and tiny event loop library with many modules to do lots of
+ * convenient things for a programmer, to save time and effort. It's small and
+ * lean, designed to work from embedded systems all the way up to large and
+ * powerful multi-cpu workstations. The main loop has a number of primitives to
+ * be used with its main loop. It serializes all the primitives and allows for
+ * great responsiveness without the need for threads(or any other concurrency).
+ *
+ * @subsection timers Timers
+ *
+ * Timers serve two main purposes: doing something at a specified time and
+ * repeatedly doing something with a set interval.
+ * @see Ecore_Timer_Group
+ *
+ * @subsection poolers Poolers
+ *
+ * Poolers allow for pooling to be centralized into a single place therefore
+ * alleviating the need for different parts of the program to wake up at
+ * different times to do pooling, thereby making the code simpler and more
+ * efficient.
+ * @see Ecore_Poller_Group
+ *
+ * @subsection idler Idlers
+ *
+ * There are three types of idlers, enterers, idlers(proper) and exiters, they
+ * are called, respectively, when the program is about to enter an idle state,
+ * when the program is idle and when the program is leaving an idle state. Idler
+ * enterers are usually a good place to update the program state. Proper idlers
+ * are the appropriate place to do heavy computational tasks thereby using what
+ * would otherwise be wasted CPU cycles. Exiters are the perfect place to do
+ * anything your program should do just before processing events(also timers,
+ * poolers, file descriptor handlers and animators)
+ * @see Ecore_Idle_Group
+ *
+ * @subsection fd_handler File descriptor handlers
+ *
+ * File descriptor handlers allow you to monitor when there is data available to
+ * read on file descriptors, when writing will not block or if there was an
+ * error. Any valid file descriptor can be used with this API, regardless of if
+ * was gotten with an OS specific API or from ecore.
+ * @see Ecore_FD_Handler_Group
+ *
+ * @subsection animators Animators
+ *
+ * Ecore provides a facility called animators, so named since the intended use
+ * was in animations, that facilitates knowing what percentage of a given
+ * interval has elapsed. This is perfect for performing animations, but is not
+ * limited to that use, it can, for example, also be used to create a progress
+ * bar.
+ * @see Ecore_Animator_Group
+ *
+ * @subsection ev_handlers Event handlers
+ *
+ * Event handlers are, arguably, the most important feature of the ecore main
+ * loop, they are what allows the programmer to easily handle user interaction.
+ * Events however are not only things the user does, events can represent
+ * anything for which a type is created.
+ * @see Ecore_Event_Group
+ *
+ * All of these primitives are discussed in more detail in their respective
+ * pages linked above.
+ *
+ * Here is a diagram of the main loop flow of a simple program:
+ *
+ * @image html  prog_flow.png
+ * @image latex prog_flow.eps width=\textwidth
+ *
+ *
+ *
+ * @section work How does Ecore work?
+ *
+ * Ecore is very easy to learn and use. All the function calls are designed to
+ * be easy to remember, explicit in describing what they do, and heavily
+ * name-spaced. Ecore programs can start and be very simple.
+ *
+ * For example:
+ *
+ * @code
+ * #include <Ecore.h>
+ *
+ * int
+ * main(int argc, const char **argv)
+ * {
+ *    ecore_init();
+ *    ecore_app_args_set(argc, argv);
+ *    ecore_main_loop_begin();
+ *    ecore_shutdown();
+ *    return 0;
+ * }
+ * @endcode
+ *
+ * This program is very simple and doesn't check for errors, but it does start up
+ * and begin a main loop waiting for events or timers to tick off. This program
+ * doesn't set up any, but now we can expand on this simple program a little
+ * more by adding some event handlers and timers.
+ *
+ * @code
+ * #include <Ecore.h>
+ *
+ * Ecore_Timer         *timer1     = NULL;
+ * Ecore_Event_Handler *handler1   = NULL;
+ * double               start_time = 0.0;
+ *
+ * int
+ * timer_func(void *data)
+ * {
+ *    printf("Tick timer. Sec: %3.2f\n", ecore_time_get() - start_time);
+ *    return 1;
+ * }
+ *
+ * int
+ * exit_func(void *data, int ev_type, void *ev)
+ * {
+ *    Ecore_Event_Signal_Exit *e;
+ *
+ *    e = (Ecore_Event_Signal_Exit *)ev;
+ *    if (e->interrupt)      printf("Exit: interrupt\n");
+ *    else if (e->quit)      printf("Exit: quit\n");
+ *    else if (e->terminate) printf("Exit: terminate\n");
+ *    ecore_main_loop_quit();
+ *    return 1;
+ * }
+ *
+ * int
+ * main(int argc, const char **argv)
+ * {
+ *    ecore_init();
+ *    ecore_app_args_set(argc, argv);
+ *    start_time = ecore_time_get();
+ *    handler1 = ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, exit_func, NULL);
+ *    timer1 = ecore_timer_add(0.5, timer_func, NULL);
+ *    ecore_main_loop_begin();
+ *    ecore_shutdown();
+ *    return 0;
+ * }
+ * @endcode
+ *
+ * In the previous example, we initialize our application and get the time at
+ * which our program has started so we can calculate an offset. We set
+ * up a timer to tick off in 0.5 seconds, and since it returns 1, will
+ * keep ticking off every 0.5 seconds until it returns 0, or is deleted
+ * by hand. An event handler is set up to call a function -
+ * exit_func(),
+ * whenever an event of type ECORE_EVENT_SIGNAL_EXIT is received (CTRL-C
+ * on the command line will cause such an event to happen). If this event
+ * occurs it tells you what kind of exit signal was received, and asks
+ * the main loop to quit when it is finished by calling
+ * ecore_main_loop_quit().
+ *
+ * The handles returned by ecore_timer_add() and
+ * ecore_event_handler_add() are
+ * only stored here as an example. If you don't need to address the timer or
+ * event handler again you don't need to store the result, so just call the
+ * function, and don't assign the result to any variable.
+ *
+ * This program looks slightly more complex than needed to do these simple
+ * things, but in principle, programs don't get any more complex. You add more
+ * event handlers, for more events, will have more timers and such, BUT it all
+ * follows the same principles as shown in this example.
+ *
  */
 
 /*
    @page Ecore_Config_Page The Enlightened Property Library
 
-   The Enlightened Property Library (Ecore_Config) is an adbstraction
+   The Enlightened Property Library (Ecore_Config) is an abstraction
    from the complexities of writing your own configuration. It provides
    many features using the Enlightenment 17 development libraries.
 
@@ -310,7 +355,9 @@
 # include <signal.h>
 #else
 # include <sys/time.h>
-# include <signal.h>
+# if !defined (EXOTIC_NO_SIGNAL)
+#  include <signal.h>
+# endif
 #endif
 
 #include <sys/types.h>
@@ -333,47 +380,21 @@ EAPI int ecore_shutdown(void);
  */
 
 /**
+ * @defgroup Ecore_Main_Loop_Group Ecore main loop
  *
- * @defgroup Ecore_Main_Loop_Group Ecore main loop functions
- *
- * These are functions acting on Ecore's main loop itself or on
- * events and infrastructure directly linked to it. This loop is
- * designed to work on embedded systems all the way to large and
- * powerful multi-cpu workstations.
+ * This group discusses functions that are acting on Ecore's main loop itself or
+ * on events and infrastructure directly linked to it. Most programs only need
+ * to start and end the main loop, the rest of the function discussed here are
+ * meant to be used in special situations, and with great care.
  *
- * It serialises all system signals and events into a single event
- * queue, that can be easily processed without needing to worry
- * about concurrency. A properly written, event-driven program
- * using this kind of programming does not need threads. It makes
- * the program very robust and easy to follow.
- *
- * For example, for the main loop to be of any use, you need to be
- * able to add @b events and event handlers on it. Events for file
- * descriptor events are covered in @ref Ecore_FD_Handler_Group.
- *
- * Timer functions are covered in @ref Ecore_Time_Group.
- *
- * There is also provision for callbacks for when the loop enters or
- * exits an @b idle state. See @ref Ecore_Idle_Group for more
- * information on it.
- *
- * Functions are also provided for spawning child processes using
- * @c fork(). See @ref Ecore_Exe_Group for more details on it.
- *
- * Here is an example of simple program and its basic event loop
- * flow:
- *
- * @image html prog_flow.png
- * @image latex prog_flow.eps width=\textwidth
- *
- * For examples of setting up and using a main loop, see
- * @ref Ecore_Main_Loop_Page.
+ * For details on the usage of ecore's main loop and how it interacts with other
+ * ecore facilities see: @ref Ecore_Main_Loop_Page.
  *
  * @{
  */
 
 #define ECORE_VERSION_MAJOR 1
-#define ECORE_VERSION_MINOR 0
+#define ECORE_VERSION_MINOR 2
 
 typedef struct _Ecore_Version
 {
@@ -469,7 +490,7 @@ EAPI void *ecore_main_loop_thread_safe_call_sync(Ecore_Data_Cb callback, void *d
  * in this thread, if the main loop was suspended correctly. If not, it return @c -1.
  *
  * This function suspend the main loop in a know state, this let you
- * use any EFL call you want after it return. Be carefull, the main loop
+ * use any EFL call you want after it return. Be carefully, the main loop
  * is blocked until you call ecore_thread_main_loop_end(). This is
  * the only sane way to achieve pseudo thread safety.
  *
@@ -489,7 +510,7 @@ EAPI int ecore_thread_main_loop_begin(void);
  * the main loop is unlocked again. @c -1 will be returned if you are trying to unlock
  * when there wasn't enough call to ecore_thread_main_loop_begin().
  *
- * After a call to ecore_thread_main_loop_begin(), you need to absolutly
+ * After a call to ecore_thread_main_loop_begin(), you need to absolutely
  * call ecore_thread_main_loop_end(), or you application will stay frozen.
  */
 EAPI int ecore_thread_main_loop_end(void);
@@ -501,34 +522,51 @@ EAPI int ecore_thread_main_loop_end(void);
 /**
  * @defgroup Ecore_Event_Group Ecore Event functions
  *
- * Ecore events are used to wake up the Ecore main loop to warn
- * about state changes, tasks completed, data available for reading
- * or writing, etc. They are the base of the event oriented
- * programming.
- *
- * The idea is to write many functions (callbacks) that will be
- * registered to specific events, and called when these events
- * happen. This way, when the system state changes (a mouse click is
- * detected, a key is pressed, or the content of a file changes, for
- * example), the respective callbacks will be called with some
- * information about that event. Usually the function/callback will
- * have a data pointer to the event info (the position in the screen
- * where the mouse was clicked, the name of the key that was
- * pressed, or the name of the file that has changed).
- *
- * The basic usage, when one needs to watch for an existing event,
- * is to register a callback to it using ecore_event_add(). Of
- * course it's necessary to know beforehand what are the types of
- * events that the system/library will emmit.  This should be
- * available with the documentation from that system/library.
- *
- * When writing a library or group of functions that need to inform
- * about something, and you already are running on top of a main
- * loop, it is usually a good approach to use events. This way you
- * allow others to register as many callbacks as necessary to this
- * event, and don't have to care about who is registering to it. The
- * functions ecore_event_type_new() and ecore_event_add() are
- * available for this purpose.
+ * Ecore events provide two main features that are of use to those using ecore:
+ * creating events and being notified of events. Those two will usually be used
+ * in different contexts, creating events is mainly done by libraries wrapping
+ * some system functionality while being notified of events is mainly a
+ * necessity of applications.
+ *
+ * For a program to be notified of events it's interested in it needs to have a
+ * function to process the event and to register that function as the callback
+ * to the event, that's all:
+ * @code
+ * ecore_event_handler_add(EVENT_TYPE, _my_event_handler, some_data);
+ * ...
+ * static Eina_Bool
+ * _my_event_handler(void *data, int type, void *event)
+ * {
+ *    //data is some_data
+ *    //event is provided by whoever created the event
+ *    //Do really cool stuff with event
+ * }
+ * @endcode
+ *
+ * One very important thing to note here is the @c EVENT_TYPE, to register a
+ * handler for an event you must know it's type before hand. This information
+ * can be found on the documentation of the library emitting the signal, so,
+ * for example, for events related to windowing one would look in @ref
+ * Ecore_Evas_Group.
+ *
+ * Examples of libraries that integrate into ecore's main loop by providing
+ * events are @ref Ecore_Con_Group, @ref Ecore_Evas_Group and @ref
+ * Ecore_Exe_Group amongst others. This usage can be divided into two parts,
+ * setup and adding events. The setup is very simple, all that needs doing is
+ * getting a type id for the event:
+ * @code
+ * int MY_EV_TYPE = ecore_event_type_new();
+ * @endcode
+ * @note This variable should be declared in the header since it'll be needed by
+ * anyone wishing to register a handler to your event.
+ *
+ * The complexity of adding of an event to the queue depends on whether that
+ * event sends uses @c event, if it doesn't it a one-liner:
+ * @code
+ * ecore_event_add(MY_EV_TYPE, NULL, NULL, NULL);
+ * @endcode
+ * The usage when an @c event is needed is not that much more complex and can be
+ * seen in @ref ecore_event_add.
  *
  * Example that deals with events:
  *
@@ -582,7 +620,7 @@ struct _Ecore_Event_Signal_User    /** User signal event */
    int       number;  /**< The signal number. Either 1 or 2 */
    void     *ext_data;  /**< Extension data - not used */
 
-#if !defined (_WIN32) && !defined (__lv2ppu__)
+#if !defined (_WIN32) && !defined (__lv2ppu__) && !defined (EXOTIC_NO_SIGNAL)
    siginfo_t data; /**< Signal info */
 #endif
 };
@@ -591,7 +629,7 @@ struct _Ecore_Event_Signal_Hup    /** Hup signal event */
 {
    void     *ext_data;  /**< Extension data - not used */
 
-#if !defined (_WIN32) && !defined (__lv2ppu__)
+#if !defined (_WIN32) && !defined (__lv2ppu__) && !defined (EXOTIC_NO_SIGNAL)
    siginfo_t data; /**< Signal info */
 #endif
 };
@@ -600,10 +638,10 @@ struct _Ecore_Event_Signal_Exit    /** Exit request event */
 {
    Eina_Bool interrupt : 1; /**< Set if the exit request was an interrupt  signal*/
    Eina_Bool quit      : 1; /**< set if the exit request was a quit signal */
-   Eina_Bool terminate : 1; /**< Set if the exit request was a terminate singal */
+   Eina_Bool terminate : 1; /**< Set if the exit request was a terminate signal */
    void     *ext_data; /**< Extension data - not used */
 
-#if !defined (_WIN32) && !defined (__lv2ppu__)
+#if !defined (_WIN32) && !defined (__lv2ppu__) && !defined (EXOTIC_NO_SIGNAL)
    siginfo_t data; /**< Signal info */
 #endif
 };
@@ -612,7 +650,7 @@ struct _Ecore_Event_Signal_Power    /** Power event */
 {
    void     *ext_data;  /**< Extension data - not used */
 
-#if !defined (_WIN32) && !defined (__lv2ppu__)
+#if !defined (_WIN32) && !defined (__lv2ppu__) && !defined (EXOTIC_NO_SIGNAL)
    siginfo_t data; /**< Signal info */
 #endif
 };
@@ -621,21 +659,161 @@ struct _Ecore_Event_Signal_Realtime    /** Realtime event */
 {
    int       num; /**< The realtime signal's number */
 
-#if !defined (_WIN32) && !defined (__lv2ppu__)
+#if !defined (_WIN32) && !defined (__lv2ppu__) && !defined (EXOTIC_NO_SIGNAL)
    siginfo_t data; /**< Signal info */
 #endif
 };
 
+/**
+ * @brief Add an event handler.
+ * @param type The type of the event this handler will get called for
+ * @param func The function to call when the event is found in the queue
+ * @param data A data pointer to pass to the called function @p func
+ * @return A new Event handler, or NULL on failure
+ *
+ * Add an event handler to the list of handlers. This will, on success, return
+ * a handle to the event handler object that was created, that can be used
+ * later to remove the handler using ecore_event_handler_del(). The @p type
+ * parameter is the integer of the event type that will trigger this callback
+ * to be called. The callback @p func is called when this event is processed
+ * and will be passed the event type, a pointer to the private event
+ * structure that is specific to that event type, and a data pointer that is
+ * provided in this call as the @p data parameter.
+ *
+ * When the callback @p func is called, it must return 1 or 0. If it returns
+ * 1 (or ECORE_CALLBACK_PASS_ON), It will keep being called as per normal, for
+ * each handler set up for that event type. If it returns 0 (or
+ * ECORE_CALLBACK_DONE), it will cease processing handlers for that particular
+ * event, so all handler set to handle that event type that have not already
+ * been called, will not be.
+ */
 EAPI Ecore_Event_Handler *ecore_event_handler_add(int type, Ecore_Event_Handler_Cb func, const void *data);
+/**
+ * @brief Delete an event handler.
+ * @param event_handler Event handler handle to delete
+ * @return Data passed to handler
+ *
+ * Delete a specified event handler from the handler list. On success this will
+ * delete the event handler and return the pointer passed as @p data when the
+ * handler was added by ecore_event_handler_add(). On failure NULL will be
+ * returned. Once a handler is deleted it will no longer be called.
+ */
 EAPI void *ecore_event_handler_del(Ecore_Event_Handler *event_handler);
+/**
+ * @brief Add an event to the event queue.
+ * @param type The event type to add to the end of the event queue
+ * @param ev The data structure passed as @c event to event handlers
+ * @param func_free The function to be called to free @a ev
+ * @param data The data pointer to be passed to the free function
+ * @return A Handle for that event on success, otherwise NULL
+ *
+ * If it succeeds, an event of type @a type will be added to the queue for
+ * processing by event handlers added by ecore_event_handler_add(). The @a ev
+ * parameter will be passed as the @c event parameter of the handler. When the
+ * event is no longer needed, @a func_free will be called and passed @a ev for
+ * cleaning up. If @p func_free is NULL, free() will be called with the private
+ * structure pointer.
+ */
 EAPI Ecore_Event *ecore_event_add(int type, void *ev, Ecore_End_Cb func_free, void *data);
+/**
+ * @brief Delete an event from the queue.
+ * @param event The event handle to delete
+ * @return The data pointer originally set for the event free function
+ *
+ * This deletes the event @p event from the event queue, and returns the
+ * @p data parameter originally set when adding it with ecore_event_add(). This
+ * does not immediately call the free function, and it may be called later on
+ * cleanup, and so if the free function depends on the data pointer to work,
+ * you should defer cleaning of this till the free function is called later.
+ */
 EAPI void *ecore_event_del(Ecore_Event *event);
+/**
+ * @brief Get the data associated with an #Ecore_Event_Handler
+ * @param eh The event handler
+ * @return The data
+ *
+ * This function returns the data previously associated with @p eh by
+ * ecore_event_handler_add().
+ */
 EAPI void *ecore_event_handler_data_get(Ecore_Event_Handler *eh);
+/**
+ * @brief Set the data associated with an #Ecore_Event_Handler
+ * @param eh The event handler
+ * @param data The data to associate
+ * @return The previous data
+ *
+ * This function sets @p data to @p eh and returns the old data pointer
+ * which was previously associated with @p eh by ecore_event_handler_add().
+ */
 EAPI void *ecore_event_handler_data_set(Ecore_Event_Handler *eh, const void *data);
+/**
+ * @brief Allocate a new event type id sensibly and return the new id.
+ * @return A new event type id.
+ *
+ * This function allocates a new event type id and returns it. Once an event
+ * type has been allocated it can never be de-allocated during the life of
+ * the program. There is no guarantee of the contents of this event ID, or how
+ * it is calculated, except that the ID will be unique to the current instance
+ * of the process.
+ */
 EAPI int ecore_event_type_new(void);
+/**
+ * @brief Add a filter the current event queue.
+ *
+ * @param func_start Function to call just before filtering and return data
+ * @param func_filter Function to call on each event
+ * @param func_end Function to call after the queue has been filtered
+ * @param data Data to pass to the filter functions
+ * @return A filter handle on success, NULL otherwise
+ *
+ * Adds a callback to filter events from the event queue. Filters are called on
+ * the queue just before Event handler processing to try and remove redundant
+ * events. Just as processing is about to start @a func_start is called and
+ * passed the @a data pointer, the return value of this functions is passed to
+ * @a func_filter as loop_data. @a func_filter is also passed @a data and the
+ * event type and event structure. If this @a func_filter returns #EINA_FALSE,
+ * the event is removed from the queue, if it returns #EINA_TRUE, the event is
+ * kept. When processing is finished @p func_end is called and is passed the
+ * loop_data(returned by @c func_start) and @p data pointer to clean up.
+ */
 EAPI Ecore_Event_Filter *ecore_event_filter_add(Ecore_Data_Cb func_start, Ecore_Filter_Cb func_filter, Ecore_End_Cb func_end, const void *data);
+/**
+ * @brief Delete an event filter.
+ * @param ef The event filter handle
+ * @return The data set for the filter on success, NULL otherwise
+ *
+ * Delete a filter that has been added by its @p ef handle.
+ */
 EAPI void *ecore_event_filter_del(Ecore_Event_Filter *ef);
+/**
+ * @brief Return the current event type being handled.
+ * @return The current event type being handled if inside a handler callback,
+ * ECORE_EVENT_NONE otherwise
+ *
+ * If the program is currently inside an Ecore event handler callback this
+ * will return the type of the current event being processed.
+ *
+ * This is useful when certain Ecore modules such as Ecore_Evas "swallow"
+ * events and not all the original information is passed on. In special cases
+ * this extra information may be useful or needed and using this call can let
+ * the program know if the event type being handled is one it wants to get more
+ * information about.
+ */
 EAPI int ecore_event_current_type_get(void);
+/**
+ * @brief Return the current event type pointer handled.
+ * @return The current event pointer being handled if inside a handler callback,
+ * NULL otherwise
+ *
+ * If the program is currently inside an Ecore event handler callback this
+ * will return the pointer of the current event being processed.
+ *
+ * This is useful when certain Ecore modules such as Ecore_Evas "swallow"
+ * events and not all the original information is passed on. In special cases
+ * this extra information may be useful or needed and using this call can let
+ * the program access the event data if the type of the event is handled by
+ * the program.
+ */
 EAPI void *ecore_event_current_event_get(void);
 
 /**
@@ -652,7 +830,8 @@ EAPI void *ecore_event_current_event_get(void);
  * @{
  */
 
- #define ECORE_EXE_PRIORITY_INHERIT 9999
+/** Inherit priority from parent process */
+#define ECORE_EXE_PRIORITY_INHERIT 9999
 
 EAPI extern int ECORE_EXE_EVENT_ADD;     /**< A child process has been added */
 EAPI extern int ECORE_EXE_EVENT_DEL;     /**< A child process has been deleted (it exited, naming consistent with the rest of ecore). */
@@ -715,7 +894,7 @@ struct _Ecore_Exe_Event_Del    /** Process exit event */
    Eina_Bool  exited    : 1; /** < set to 1 if the process exited of its own accord */
    Eina_Bool  signalled : 1; /** < set to 1 id the process exited due to uncaught signal */
    void      *ext_data; /**< Extension data - not used */
-#if !defined (_WIN32) && !defined (__lv2ppu__)
+#if !defined (_WIN32) && !defined (__lv2ppu__) && !defined (EXOTIC_NO_SIGNAL)
    siginfo_t  data; /**< Signal info */
 #endif
 };
@@ -768,24 +947,30 @@ EAPI void ecore_exe_hup(Ecore_Exe *exe);
 /**
  * @defgroup Ecore_FD_Handler_Group File Event Handling Functions
  *
- * Functions that deal with file descriptor handlers.
+ * @brief Functions that deal with file descriptor handlers.
+ *
+ * File descriptor handlers facilitate reading, writing and checking for errors
+ * without blocking the program or doing expensive pooling. This can be used to
+ * monitor a socket, pipe, or other stream for which an FD can be had.
  *
- * The @ref Ecore_Fd_Handler can be used to watch a file descriptor
- * for data available for reading, for the availability to write
- * without blocking, and for errors on the file descriptor.
+ * @warning This function @b can't be used for monitoring to regular files!
  *
- *ecore_main_fd_handler_add() is used to setup a handler for a
- * given file descriptor. This file descriptor can be the standard
- * input, a network socket, a stream received through some driver
- * of a hardware decoder, etc. Thus it can contain errors, like a
- * disconnection, a broken pipe, and so, and that's why it's
- * possible to check for these errors with the @ref ECORE_FD_ERROR
- * flag.
+ * One common FD to be monitored is the standard input(stdin), monitoring it for
+ * reading requires a single call:
+ * @code
+ * static Eina_Bool
+ * _my_cb_func(void *data, Ecore_Fd_Handler *handler)
+ * {
+ *    char c;
+ *    scanf("%c", &c); //Guaranteed not to block
+ *    ... do stuff with c ...
+ * }
+ * ecore_main_fd_handler_add(STDIN_FILENO, ECORE_FD_READ, _my_cb_func, NULL, NULL, NULL);
+ * @endcode
  *
- * An @ref Ecore_Fd_Handler can be used to watch on a file
- * descriptor without blocking, still being able to receive events,
- * expire timers, and other watch for other things that happen in
- * the Ecore main loop.
+ * When using a socket, pipe or other stream it's important to remember that
+ * errors may occur and as such to monitor not only for reading/writing but also
+ * for errors using the @ref ECORE_FD_ERROR flag.
  *
  * Example of use of a file descriptor handler:
  * @li @ref ecore_fd_handler_example_c
@@ -823,11 +1008,93 @@ typedef void (*Ecore_Fd_Prep_Cb)(void *data, Ecore_Fd_Handler *fd_handler);
  */
 typedef Eina_Bool (*Ecore_Win32_Handle_Cb)(void *data, Ecore_Win32_Handler *wh);
 
+/**
+ * @brief Adds a callback for activity on the given file descriptor.
+ *
+ * @param fd The file descriptor to watch.
+ * @param flags To monitor it for reading use @c ECORE_FD_READ, for writing @c
+ * ECORE_FD_WRITE, and for error @c ECORE_FD_ERROR. Values bay |(ored).
+ * @param func The callback function.
+ * @param data The data to pass to the callback.
+ * @param buf_func The function to call to check if any data has been buffered
+ * and already read from the fd. May be @c NULL.
+ * @param buf_data The data to pass to the @p buf_func function.
+ * @return A fd handler handle on success, @c NULL otherwise.
+ *
+ * @a func will be called during the execution of @ref Ecore_Main_Loop_Page
+ * when the file descriptor is available for reading, writing, or there has been
+ * an error(depending on the given @a flags).
+ *
+ * When @a func returns ECORE_CALLBACK_CANCEL, it indicates that the
+ * handler should be marked for deletion (identical to calling @ref
+ * ecore_main_fd_handler_del).
+ *
+ * @warning @a buf_func is meant for @b internal use only and should be @b
+ * avoided.
+ *
+ * The return value of @a buf_func has a different meaning, when it returns
+ * ECORE_CALLBACK_CANCEL, it indicates that @a func @b shouldn't be called, and
+ * when it returns ECORE_CALLBACK_RENEW it indicates @a func should be called.
+ * The return value of @a buf_func will not cause the FD handler to be deleted.
+ *
+ * @a buf_func is called during event loop handling to check if data that has
+ * been read from the file descriptor is in a buffer and is available to read.
+ * Some systems, notably xlib, handle their own buffering, and would otherwise
+ * not work with select(). These systems should use a @a buf_func. This is a
+ * most annoying hack, only ecore_x uses it, so refer to that for an example.
+ */
 EAPI Ecore_Fd_Handler *ecore_main_fd_handler_add(int fd, Ecore_Fd_Handler_Flags flags, Ecore_Fd_Cb func, const void *data, Ecore_Fd_Cb buf_func, const void *buf_data);
+/**
+ * @brief Set the prepare callback with data for a given #Ecore_Fd_Handler
+ *
+ * @param fd_handler The fd handler
+ * @param func The prep function
+ * @param data The data to pass to the prep function
+ *
+ * This function will be called prior to any fd handler's callback function
+ * (even the other fd handlers), before entering the main loop select function.
+ *
+ * @note Once a prepare callback is set for a fd handler, it cannot be changed.
+ * You need to delete the fd handler and create a new one, to set another
+ * callback.
+ * @note You probably don't need this function. It is only necessary for very
+ * uncommon cases that need special behavior.
+ */
 EAPI void ecore_main_fd_handler_prepare_callback_set(Ecore_Fd_Handler *fd_handler, Ecore_Fd_Prep_Cb func, const void *data);
+/**
+ * @brief Marks an FD handler for deletion.
+ * @param fd_handler The FD handler.
+ * @return The data pointer set using @ref ecore_main_fd_handler_add, for @a
+ * fd_handler on success, @c NULL otherwise.
+ * This function marks an fd handler to be deleted during an iteration of the
+ * main loop. It does NOT close the associated fd!
+ *
+ * @warning If the underlying fd is already closed ecore may complain if the
+ * main loop is using epoll internally, and also in some rare cases this may
+ * cause crashes and instability. Remember to delete your fd handlers before the
+ * fds they listen to are closed.
+ */
 EAPI void *ecore_main_fd_handler_del(Ecore_Fd_Handler *fd_handler);
+/**
+ * @brief Retrieves the file descriptor that the given handler is handling.
+ * @param fd_handler The given FD handler.
+ * @return The file descriptor the handler is watching.
+ */
 EAPI int ecore_main_fd_handler_fd_get(Ecore_Fd_Handler *fd_handler);
+/**
+ * @brief Gets which flags are active on an FD handler.
+ * @param fd_handler The given FD handler.
+ * @param flags The flags, @c ECORE_FD_READ, @c ECORE_FD_WRITE or @c
+ * ECORE_FD_ERROR to query.
+ * @return  #EINA_TRUE if any of the given flags are active, #EINA_FALSE
+ * otherwise.
+ */
 EAPI Eina_Bool ecore_main_fd_handler_active_get(Ecore_Fd_Handler *fd_handler, Ecore_Fd_Handler_Flags flags);
+/**
+ * @brief Set what active streams the given FD handler should be monitoring.
+ * @param fd_handler The given FD handler.
+ * @param flags The flags to be watching.
+ */
 EAPI void ecore_main_fd_handler_active_set(Ecore_Fd_Handler *fd_handler, Ecore_Fd_Handler_Flags flags);
 
 EAPI Ecore_Win32_Handler *ecore_main_win32_handler_add(void *h, Ecore_Win32_Handle_Cb func, const void *data);
@@ -840,13 +1107,30 @@ EAPI void *ecore_main_win32_handler_del(Ecore_Win32_Handler *win32_handler);
 /**
  * @defgroup Ecore_Poller_Group Ecore Poll functions
  *
- * These functions are for the need to poll information, but provide
- * a shared abstracted API to pool such polling to minimise wakeup
- * and ensure all the polling happens in as few spots as possible
- * areound a core poll interval.  For now only 1 core poller type is
- * supprted: ECORE_POLLER_CORE
+ * Ecore poller provides infrastructure for the creation of pollers. Pollers
+ * are, in essence, callbacks that share a single timer per type. Because not
+ * all pollers need to be called at the same frequency the user may specify the
+ * frequency in ticks(each expiration of the shared timer is called a tick, in
+ * ecore poller parlance) for each added poller. Ecore pollers should only be
+ * used when the poller doesn't have specific requirements on the exact times
+ * to poll.
  *
- * Example of @ref Ecore_Poller :
+ * This architecture means that the main loop is only woken up once to handle
+ * all pollers of that type, this will save power as the CPU has more of a
+ * chance to go into a low power state the longer it is asleep for, so this
+ * should be used in situations where power usage is a concern.
+ *
+ * For now only 1 core poller type is supported: ECORE_POLLER_CORE, the default
+ * interval for ECORE_POLLER_CORE is 0.125(or 1/8th) second.
+ *
+ * The creation of a poller is extremely simple and only required one line:
+ * @code
+ * ecore_poller_add(ECORE_POLLER_CORE, 1, my_poller_function, NULL);
+ * @endcode
+ * This sample creates a poller to call @c my_poller_function at every tick with
+ * @c NULL as data.
+ *
+ * Example:
  * @li @ref ecore_poller_example_c
  *
  * @ingroup Ecore_Main_Loop_Group
@@ -862,11 +1146,76 @@ typedef enum _Ecore_Poller_Type Ecore_Poller_Type;
 
 typedef struct _Ecore_Poller    Ecore_Poller; /**< A handle for pollers */
 
+/**
+ * @brief Sets the time(in seconds) between ticks for the given poller type.
+ * @param type The poller type to adjust.
+ * @param poll_time The time(in seconds) between ticks of the timer.
+ *
+ * This will adjust the time between ticks of the given timer type defined by
+ * @p type to the time period defined by @p poll_time.
+ */
 EAPI void ecore_poller_poll_interval_set(Ecore_Poller_Type type, double poll_time);
+/**
+ * @brief Gets the time(in seconds) between ticks for the given poller type.
+ * @param type The poller type to query.
+ * @return The time in seconds between ticks of the poller timer.
+ *
+ * This will get the time between ticks of the specified poller timer.
+ */
 EAPI double ecore_poller_poll_interval_get(Ecore_Poller_Type type);
+/**
+ * @brief Changes the polling interval rate of @p poller.
+ * @param poller The Ecore_Poller to change the interval of.
+ * @param interval The tick interval to set; must be a power of 2 and <= 32768.
+ * @return Returns true on success, false on failure.
+ *
+ * This allows the changing of a poller's polling interval. It is useful when
+ * you want to alter a poll rate without deleting and re-creating a poller.
+ */
 EAPI Eina_Bool ecore_poller_poller_interval_set(Ecore_Poller *poller, int interval);
+/**
+ * @brief Gets the polling interval rate of @p poller.
+ * @param poller The Ecore_Poller to change the interval of.
+ * @return Returns the interval, in ticks, that @p poller polls at.
+ *
+ * This returns a poller's polling interval, or 0 on error.
+ */
 EAPI int ecore_poller_poller_interval_get(Ecore_Poller *poller);
+/**
+ * @brief Creates a poller to call the given function at a particular tick interval.
+ * @param type The ticker type to attach the poller to. Must be ECORE_POLLER_CORE.
+ * @param interval The poll interval.
+ * @param func The poller function.
+ * @param data Data to pass to @a func when it is called.
+ * @return A poller object on success, @c NULL otherwise.
+ *
+ * This function adds @a func as a poller callback that will be called every @a
+ * interval ticks together with other pollers of type @a type. @a func will be
+ * passed the @p data pointer as a parameter.
+ *
+ * The @p interval must be between 1 and 32768 inclusive, and must be a power of
+ * 2 (i.e. 1, 2, 4, 8, 16, ... 16384, 32768). The exact tick in which @a func
+ * will be called is undefined, as only the interval between calls can be
+ * defined. Ecore will endeavor to keep pollers synchronized and to call as
+ * many in 1 wakeup event as possible. If @a interval is not a power of two, the
+ * closest power of 2 greater than @a interval will be used.
+ *
+ * When the poller @p func is called, it must return a value of either
+ * ECORE_CALLBACK_RENEW(or 1) or ECORE_CALLBACK_CANCEL(or 0). If it
+ * returns 1, it will be called again at the next tick, or if it returns
+ * 0 it will be deleted automatically making any references/handles for it
+ * invalid.
+ */
 EAPI Ecore_Poller *ecore_poller_add(Ecore_Poller_Type type, int interval, Ecore_Task_Cb func, const void *data);
+/**
+ * @brief Delete the specified poller from the timer list.
+ * @param poller The poller to delete.
+ * @return The data pointer set for the timer when @ref ecore_poller_add was
+ * called on success, @c NULL otherwise.
+ *
+ * @note @a poller must be a valid handle. If the poller function has already
+ * returned 0, the handle is no longer valid (and does not need to be deleted).
+ */
 EAPI void *ecore_poller_del(Ecore_Poller *poller);
 
 /**
@@ -941,7 +1290,7 @@ typedef enum _Ecore_Animator_Source Ecore_Animator_Source;
 typedef Eina_Bool (*Ecore_Timeline_Cb)(void *data, double pos);
 
 /**
- * @brief Add an animator to call @p func at every animaton tick during main
+ * @brief Add an animator to call @p func at every animation tick during main
  * loop execution.
  *
  * @param func The function to call when it ticks off
@@ -1011,7 +1360,7 @@ EAPI void *ecore_animator_del(Ecore_Animator *animator);
  *
  * @param animator The animator to delete
  *
- * The specified @p animator will be temporarly removed from the set of
+ * The specified @p animator will be temporarily removed from the set of
  * animators that are executed during main loop.
  *
  * @warning Freezing an animator doesn't freeze accounting of how long that
@@ -1069,7 +1418,7 @@ EAPI double ecore_animator_frametime_get(void);
  * has "overshot" the mark) using some interpolation (mapping) algorithm.
  *
  * This function useful to create non-linear animations. It offers a variety
- * of possible animaton curves to be used:
+ * of possible animation curves to be used:
  * @li ECORE_POS_MAP_LINEAR - Linear, returns @p pos
  * @li ECORE_POS_MAP_ACCELERATE - Start slow then speed up
  * @li ECORE_POS_MAP_DECELERATE - Start fast then slow down
@@ -1107,7 +1456,7 @@ EAPI double ecore_animator_frametime_get(void);
  * y = (y1 * out) + (y2 * (1.0 - out));
  * move_my_object_to(myobject, x, y);
  * @endcode
- * This will make an animaton that bounces 7 each times diminishing by a
+ * This will make an animation that bounces 7 each times diminishing by a
  * factor of 1.8.
  *
  * @see _Ecore_Pos_Map
@@ -1205,16 +1554,39 @@ EAPI void ecore_animator_custom_tick(void);
  */
 
 /**
- * @defgroup Ecore_Time_Group Ecore Time functions
- *
- * Functions that deal with time. These functions include those
- * that simply retrieve it in a given format, and those that create
- * events based on it.
+ * @defgroup Ecore_Time_Group Ecore time functions
  *
- * The timer allows callbacks to be called at specific intervals.
+ * These are function to retrieve time in a given format.
  *
- * Examples with functions that deal with time:
+ * Examples:
  * @li @ref ecore_time_functions_example_c
+ * @{
+ */
+EAPI double ecore_time_get(void);
+EAPI double ecore_time_unix_get(void);
+EAPI double ecore_loop_time_get(void);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup Ecore_Timer_Group Ecore Timer functions
+ *
+ * Ecore provides very flexible timer functionality. The basic usage of timers,
+ * to call a certain function at a certain interval can be achieved with a
+ * single line:
+ * @code
+ * Eina_Bool my_func(void *data) {
+ *    do_funky_stuff_with_data(data);
+ *    return EINA_TRUE;
+ * }
+ * ecore_timer_add(interval_in_seconds, my_func, data_given_to_function);
+ * @endcode
+ * @note If the function was to be executed only once simply return EINA_FALSE
+ * instead.
+ *
+ * An example that shows the usage of a lot of these:
  * @li @ref ecore_timer_example_c
  *
  * @ingroup Ecore_Main_Loop_Group
@@ -1224,10 +1596,6 @@ EAPI void ecore_animator_custom_tick(void);
 
 typedef struct _Ecore_Timer Ecore_Timer; /**< A handle for timers */
 
-EAPI double ecore_time_get(void);
-EAPI double ecore_time_unix_get(void);
-EAPI double ecore_loop_time_get(void);
-
 EAPI Ecore_Timer *ecore_timer_add(double in, Ecore_Task_Cb func, const void *data);
 EAPI Ecore_Timer *ecore_timer_loop_add(double in, Ecore_Task_Cb func, const void *data);
 EAPI void *ecore_timer_del(Ecore_Timer *timer);
@@ -1249,14 +1617,15 @@ EAPI char *ecore_timer_dump(void);
 /**
  * @defgroup Ecore_Idle_Group Ecore Idle functions
  *
- * Callbacks that are called when the program enters or exits an
- * idle state.
+ * The idler functionality in Ecore allows for callbacks to be called when the
+ * program isn't handling @ref Ecore_Event_Group "events", @ref Ecore_Timer_Group
+ * "timers" or @ref Ecore_FD_Handler_Group "fd handlers".
  *
- * The ecore main loop enters an idle state when it is waiting for
- * timers to time out, data to come in on a file descriptor or any
- * other event to occur.  You can set callbacks to be called when
- * the main loop enters an idle state, during an idle state or just
- * after the program wakes up.
+ * There are three types of idlers: Enterers, Idlers(proper) and Exiters. They
+ * are called, respectively, when the program is about to enter an idle state,
+ * when the program is in an idle state and when the program has just left an
+ * idle state and will begin processing @ref Ecore_Event_Group "events", @ref
+ * Ecore_Timer_Group "timers" or @ref Ecore_FD_Handler_Group "fd handlers".
  *
  * Enterer callbacks are good for updating your program's state, if
  * it has a state engine.  Once all of the enterer handlers are
@@ -1266,14 +1635,13 @@ EAPI char *ecore_timer_dump(void);
  * enterer handlers.  They are useful for interfaces that require
  * polling and timers would be too slow to use.
  *
+ * Exiter callbacks are called when the main loop wakes up from an idle state.
+ *
  * If no idler callbacks are specified, then the process literally
  * goes to sleep.  Otherwise, the idler callbacks are called
  * continuously while the loop is "idle", using as much CPU as is
  * available to the process.
  *
- * Exiter callbacks are called when the main loop wakes up from an
- * idle state.
- *
  * @note Idle state doesn't mean that the @b program is idle, but
  * that the <b>main loop</b> is idle. It doesn't have any timers,
  * events, fd handlers or anything else to process (which in most
@@ -1343,7 +1711,7 @@ EAPI void *ecore_idle_exiter_del(Ecore_Idle_Exiter *idle_exiter);
  * thread, the one running the main loop. This problem can be solved
  * by running a thread that sends messages to the main one using an
  * @ref Ecore_Pipe_Group "Ecore_Pipe", but when you need to handle other
- * things like cancelling the thread, your code grows in coplexity and gets
+ * things like cancelling the thread, your code grows in complexity and gets
  * much harder to maintain.
  *
  * Ecore Thread is here to solve that problem. It is @b not a simple wrapper
@@ -1514,7 +1882,7 @@ EAPI Ecore_Thread *ecore_thread_run(Ecore_Thread_Cb func_blocking, Ecore_Thread_
  * with ecore_thread_feedback().
  *
  * Like with ecore_thread_run(), a new thread will be launched to run
- * @p func_heavy unless the maximum number of simultaneous threadas has been
+ * @p func_heavy unless the maximum number of simultaneous threads has been
  * reached, in which case the function will be scheduled to run whenever a
  * running task ends and a thread becomes free. But if @p try_no_queue is
  * set, Ecore will first try to launch a thread outside of the pool to run
@@ -2076,7 +2444,7 @@ EAPI int ecore_pipe_wait(Ecore_Pipe *p, int message_count, double wait);
  * also will be executed in the order in which they were added.
  *
  * A good use for them is when you don't want to execute an action
- * immeditately, but want to give the control back to the main loop
+ * immediately, but want to give the control back to the main loop
  * so that it will call your job callback when jobs start being
  * processed (and if there are other jobs added before yours, they
  * will be processed first). This also gives the chance to other
diff --git a/libraries/ecore/src/lib/ecore/Makefile.am b/libraries/ecore/src/lib/ecore/Makefile.am
index ec3d99f..6f14387 100644
--- a/libraries/ecore/src/lib/ecore/Makefile.am
+++ b/libraries/ecore/src/lib/ecore/Makefile.am
@@ -47,6 +47,12 @@ libecore_la_SOURCES += ecore_exe_ps3.c
 
 else
 
+if ECORE_HAVE_EXOTIC
+
+libecore_la_SOURCES +=
+
+else
+
 libecore_la_SOURCES += ecore_signal.c ecore_exe.c
 
 endif
@@ -55,6 +61,8 @@ endif
 
 endif
 
+endif
+
 libecore_la_LIBADD = @dlopen_libs@ @EINA_LIBS@ @EVIL_LIBS@ @GLIB_LIBS@ @WIN32_LIBS@ @LTLIBINTL@ @EFL_PTHREAD_LIBS@ @rt_libs@ -lm
 libecore_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@ @EFL_PTHREAD_LIBS@
 
diff --git a/libraries/ecore/src/lib/ecore/Makefile.in b/libraries/ecore/src/lib/ecore/Makefile.in
index 66a25cd..71e2ac4 100644
--- a/libraries/ecore/src/lib/ecore/Makefile.in
+++ b/libraries/ecore/src/lib/ecore/Makefile.in
@@ -38,7 +38,8 @@ host_triplet = @host@
 @ECORE_HAVE_WIN32_TRUE@am__append_1 = ecore_exe_win32.c
 @ECORE_HAVE_WIN32_FALSE@@ECORE_HAVE_WINCE_TRUE@am__append_2 = ecore_exe_wince.c
 @ECORE_HAVE_PS3_TRUE@@ECORE_HAVE_WIN32_FALSE@@ECORE_HAVE_WINCE_FALSE@am__append_3 = ecore_exe_ps3.c
-@ECORE_HAVE_PS3_FALSE@@ECORE_HAVE_WIN32_FALSE@@ECORE_HAVE_WINCE_FALSE@am__append_4 = ecore_signal.c ecore_exe.c
+@ECORE_HAVE_EXOTIC_TRUE@@ECORE_HAVE_PS3_FALSE@@ECORE_HAVE_WIN32_FALSE@@ECORE_HAVE_WINCE_FALSE@am__append_4 = 
+@ECORE_HAVE_EXOTIC_FALSE@@ECORE_HAVE_PS3_FALSE@@ECORE_HAVE_WIN32_FALSE@@ECORE_HAVE_WINCE_FALSE@am__append_5 = ecore_signal.c ecore_exe.c
 subdir = src/lib/ecore
 DIST_COMMON = $(includes_HEADERS) $(srcdir)/Makefile.am \
         $(srcdir)/Makefile.in
@@ -54,16 +55,15 @@ am__aclocal_m4_deps = $(top_srcdir)/m4/ac_attribute.m4 \
         $(top_srcdir)/m4/efl_path_max.m4 $(top_srcdir)/m4/efl_tests.m4 \
         $(top_srcdir)/m4/efl_threads.m4 $(top_srcdir)/m4/gettext.m4 \
         $(top_srcdir)/m4/iconv.m4 $(top_srcdir)/m4/intlmacosx.m4 \
-        $(top_srcdir)/m4/isc-posix.m4 $(top_srcdir)/m4/lib-ld.m4 \
-        $(top_srcdir)/m4/lib-link.m4 $(top_srcdir)/m4/lib-prefix.m4 \
-        $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
-        $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
-        $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/m4/nls.m4 \
-        $(top_srcdir)/m4/po.m4 $(top_srcdir)/m4/progtest.m4 \
-        $(top_srcdir)/configure.ac
+        $(top_srcdir)/m4/lib-ld.m4 $(top_srcdir)/m4/lib-link.m4 \
+        $(top_srcdir)/m4/lib-prefix.m4 $(top_srcdir)/m4/libtool.m4 \
+        $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
+        $(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
+        $(top_srcdir)/m4/nls.m4 $(top_srcdir)/m4/po.m4 \
+        $(top_srcdir)/m4/progtest.m4 $(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
         $(ACLOCAL_M4)
-mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
+mkinstalldirs = $(install_sh) -d
 CONFIG_HEADER = $(top_builddir)/config.h
 CONFIG_CLEAN_FILES =
 CONFIG_CLEAN_VPATH_FILES =
@@ -100,15 +100,16 @@ am__libecore_la_SOURCES_DIST = ecore.c ecore_alloc.c ecore_anim.c \
 @ECORE_HAVE_WIN32_TRUE@am__objects_1 = ecore_exe_win32.lo
 @ECORE_HAVE_WIN32_FALSE@@ECORE_HAVE_WINCE_TRUE@am__objects_2 = ecore_exe_wince.lo
 @ECORE_HAVE_PS3_TRUE@@ECORE_HAVE_WIN32_FALSE@@ECORE_HAVE_WINCE_FALSE@am__objects_3 = ecore_exe_ps3.lo
-@ECORE_HAVE_PS3_FALSE@@ECORE_HAVE_WIN32_FALSE@@ECORE_HAVE_WINCE_FALSE@am__objects_4 = ecore_signal.lo \
-@ECORE_HAVE_PS3_FALSE@@ECORE_HAVE_WIN32_FALSE@@ECORE_HAVE_WINCE_FALSE@  ecore_exe.lo
+am__objects_4 =
+@ECORE_HAVE_EXOTIC_FALSE@@ECORE_HAVE_PS3_FALSE@@ECORE_HAVE_WIN32_FALSE@@ECORE_HAVE_WINCE_FALSE@am__objects_5 = ecore_signal.lo \
+@ECORE_HAVE_EXOTIC_FALSE@@ECORE_HAVE_PS3_FALSE@@ECORE_HAVE_WIN32_FALSE@@ECORE_HAVE_WINCE_FALSE@ ecore_exe.lo
 am_libecore_la_OBJECTS = ecore.lo ecore_alloc.lo ecore_anim.lo \
         ecore_app.lo ecore_events.lo ecore_getopt.lo \
         ecore_idle_enterer.lo ecore_idle_exiter.lo ecore_idler.lo \
         ecore_job.lo ecore_main.lo ecore_pipe.lo ecore_poll.lo \
         ecore_time.lo ecore_timer.lo ecore_thread.lo ecore_glib.lo \
         ecore_throttle.lo $(am__objects_1) $(am__objects_2) \
-        $(am__objects_3) $(am__objects_4)
+        $(am__objects_3) $(am__objects_4) $(am__objects_5)
 libecore_la_OBJECTS = $(am_libecore_la_OBJECTS)
 AM_V_lt = $(am__v_lt_$(V))
 am__v_lt_ = $(am__v_lt_$(AM_DEFAULT_VERBOSITY))
@@ -211,6 +212,8 @@ EVAS_LIBS = @EVAS_LIBS@
 EVIL_CFLAGS = @EVIL_CFLAGS@
 EVIL_LIBS = @EVIL_LIBS@
 EXEEXT = @EXEEXT@
+EXOTIC_CFLAGS = @EXOTIC_CFLAGS@
+EXOTIC_LIBS = @EXOTIC_LIBS@
 FGREP = @FGREP@
 GETTEXT_MACRO_VERSION = @GETTEXT_MACRO_VERSION@
 GLIB_CFLAGS = @GLIB_CFLAGS@
@@ -266,6 +269,8 @@ PATH_SEPARATOR = @PATH_SEPARATOR@
 PIXMAN_CFLAGS = @PIXMAN_CFLAGS@
 PIXMAN_LIBS = @PIXMAN_LIBS@
 PKG_CONFIG = @PKG_CONFIG@
+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
 POSUB = @POSUB@
 RANLIB = @RANLIB@
 SCIM_CFLAGS = @SCIM_CFLAGS@
@@ -276,6 +281,7 @@ SDL_LIBS = @SDL_LIBS@
 SED = @SED@
 SET_MAKE = @SET_MAKE@
 SHELL = @SHELL@
+SHM_OPEN_LIBS = @SHM_OPEN_LIBS@
 SSL_CFLAGS = @SSL_CFLAGS@
 SSL_LIBS = @SSL_LIBS@
 STRIP = @STRIP@
@@ -503,7 +509,8 @@ libecore_la_SOURCES = ecore.c ecore_alloc.c ecore_anim.c ecore_app.c \
         ecore_idle_exiter.c ecore_idler.c ecore_job.c ecore_main.c \
         ecore_pipe.c ecore_poll.c ecore_time.c ecore_timer.c \
         ecore_thread.c ecore_glib.c ecore_throttle.c $(am__append_1) \
-        $(am__append_2) $(am__append_3) $(am__append_4)
+        $(am__append_2) $(am__append_3) $(am__append_4) \
+        $(am__append_5)
 libecore_la_LIBADD = @dlopen_libs@ @EINA_LIBS@ @EVIL_LIBS@ @GLIB_LIBS@ @WIN32_LIBS@ @LTLIBINTL@ @EFL_PTHREAD_LIBS@ @rt_libs@ -lm
 libecore_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@ @EFL_PTHREAD_LIBS@
 EXTRA_DIST = ecore_private.h
diff --git a/libraries/ecore/src/lib/ecore/ecore.c b/libraries/ecore/src/lib/ecore/ecore.c
index 7e0f973..d8b8723 100644
--- a/libraries/ecore/src/lib/ecore/ecore.c
+++ b/libraries/ecore/src/lib/ecore/ecore.c
@@ -163,8 +163,10 @@ ecore_init(void)
    if (!ecore_mempool_init()) goto shutdown_mempool;
    _ecore_main_loop_init();
    _ecore_signal_init();
-   _ecore_thread_init();
+#ifndef HAVE_EXOTIC
    _ecore_exe_init();
+#endif
+   _ecore_thread_init();
    _ecore_glib_init();
    _ecore_job_init();
    _ecore_time_init();
@@ -252,7 +254,9 @@ ecore_shutdown(void)
      _ecore_glib_shutdown();
      _ecore_job_shutdown();
      _ecore_thread_shutdown();
+#ifndef HAVE_EXOTIC
      _ecore_exe_shutdown();
+#endif
      _ecore_idle_enterer_shutdown();
      _ecore_idle_exiter_shutdown();
      _ecore_idler_shutdown();
diff --git a/libraries/ecore/src/lib/ecore/ecore_anim.c b/libraries/ecore/src/lib/ecore/ecore_anim.c
index 78abad7..22c1f8c 100644
--- a/libraries/ecore/src/lib/ecore/ecore_anim.c
+++ b/libraries/ecore/src/lib/ecore/ecore_anim.c
@@ -272,11 +272,11 @@ ecore_animator_pos_map(double        pos,
          return pos;
 
        case ECORE_POS_MAP_ACCELERATE:
-         pos = 1.0 - _pos_map_sin((M_PI / 2.0) + ((pos * M_PI) / 2.0));
+         pos = 1.0 - _pos_map_sin(M_PI_2 + pos * M_PI_2);
          return pos;
 
        case ECORE_POS_MAP_DECELERATE:
-         pos = _pos_map_sin((pos * M_PI) / 2.0);
+         pos = _pos_map_sin(pos * M_PI_2);
          return pos;
 
        case ECORE_POS_MAP_SINUSOIDAL:
diff --git a/libraries/ecore/src/lib/ecore/ecore_events.c b/libraries/ecore/src/lib/ecore/ecore_events.c
index 0550224..500cf74 100644
--- a/libraries/ecore/src/lib/ecore/ecore_events.c
+++ b/libraries/ecore/src/lib/ecore/ecore_events.c
@@ -72,35 +72,6 @@ static void *ecore_raw_event_event = NULL;
 static void  _ecore_event_purge_deleted(void);
 static void *_ecore_event_del(Ecore_Event *event);
 
-/**
- * @addtogroup Ecore_Event_Group
- *
- * @{
- */
-
-/**
- * Add an event handler.
- * @param type The type of the event this handler will get called for
- * @param func The function to call when the event is found in the queue
- * @param data A data pointer to pass to the called function @p func
- * @return A new Event handler, or NULL on failure
- *
- * Add an event handler to the list of handlers. This will, on success, return
- * a handle to the event handler object that was created, that can be used
- * later to remove the handler using ecore_event_handler_del(). The @p type
- * parameter is the integer of the event type that will trigger this callback
- * to be called. The callback @p func is called when this event is processed
- * and will be passed the event type, a pointer to the private event
- * structure that is specific to that event type, and a data pointer that is
- * provided in this call as the @p data parameter.
- *
- * When the callback @p func is called, it must return 1 or 0. If it returns
- * 1 (or ECORE_CALLBACK_PASS_ON), It will keep being called as per normal, for
- * each handler set up for that event type. If it returns 0 (or
- * ECORE_CALLBACK_DONE), it will cease processing handlers for that particular
- * event, so all handler set to handle that event type that have not already
- * been called, will not be.
- */
 EAPI Ecore_Event_Handler *
 ecore_event_handler_add(int                    type,
                         Ecore_Event_Handler_Cb func,
@@ -151,16 +122,6 @@ unlock:
    return eh;
 }
 
-/**
- * Delete an event handler.
- * @param event_handler Event handler handle to delete
- * @return Data passed to handler
- *
- * Delete a specified event handler from the handler list. On success this will
- * delete the event handler and return the pointer passed as @p data when the
- * handler was added by ecore_event_handler_add(). On failure NULL will be
- * returned. Once a handler is deleted it will no longer be called.
- */
 EAPI void *
 ecore_event_handler_del(Ecore_Event_Handler *event_handler)
 {
@@ -180,14 +141,6 @@ unlock:
    return data;
 }
 
-/**
- * @brief Get the data associated with an #Ecore_Event_Handler
- * @param eh The event handler
- * @return The data
- *
- * This function returns the data previously associated with @p eh by
- * ecore_event_handler_add().
- */
 EAPI void *
 ecore_event_handler_data_get(Ecore_Event_Handler *eh)
 {
@@ -205,15 +158,6 @@ unlock:
    return data;
 }
 
-/**
- * @brief Set the data associated with an #Ecore_Event_Handler
- * @param eh The event handler
- * @param data The data to associate
- * @return The previous data
- *
- * This function sets @p data to @p eh and returns the old data pointer
- * which was previously associated with @p eh by ecore_event_handler_add().
- */
 EAPI void *
 ecore_event_handler_data_set(Ecore_Event_Handler *eh,
                              const void          *data)
@@ -238,27 +182,9 @@ static void
 _ecore_event_generic_free(void *data __UNUSED__,
                           void *event)
 { /* DO NOT MEMPOOL FREE THIS */
-   free (event);
+   free(event);
 }
 
-/**
- * Add an event to the event queue.
- * @param type The event type to add to the end of the event queue
- * @param ev The private data structure for this event type
- * @param func_free The function to be called to free this private structure
- * @param data The data pointer to be passed to the free function
- * @return A Handle for that event
- *
- * On success this function returns a handle to an event on the event queue, or
- * NULL if it fails. If it succeeds, an event of type @p type will be added
- * to the queue for processing by event handlers added by
- * ecore_event_handler_add(). The @p ev parameter will be a pointer to the event
- * private data that is specific to that event type. When the event is no
- * longer needed, @p func_free will be called and passed the private structure
- * pointer for cleaning up. If @p func_free is NULL, free() will be called
- * with the private structure pointer.
- * func_free is passed @p data as its data parameter.
- */
 EAPI Ecore_Event *
 ecore_event_add(int          type,
                 void        *ev,
@@ -279,17 +205,6 @@ unlock:
    return event;
 }
 
-/**
- * Delete an event from the queue.
- * @param event The event handle to delete
- * @return The data pointer originally set for the event free function
- *
- * This deletes the event @p event from the event queue, and returns the
- * @p data parameer originally set when adding it with ecore_event_add(). This
- * does not immediately call the free function, and it may be called later on
- * cleanup, and so if the free function depends on the data pointer to work,
- * you should defer cleaning of this till the free function is called later.
- */
 EAPI void *
 ecore_event_del(Ecore_Event *event)
 {
@@ -309,16 +224,6 @@ unlock:
    return data;
 }
 
-/**
- * Allocate a new event type id sensibly and return the new id.
- * @return A new event type id.
- *
- * This function allocates a new event type id and returns it. Once an event
- * type has been allocated it can never be de-allocated during the life of
- * the program. There is no guarantee of the contents of this event ID, or how
- * it is calculated, except that the ID will be unique to the current instance
- * of the process.
- */
 EAPI int
 ecore_event_type_new(void)
 {
@@ -331,26 +236,6 @@ ecore_event_type_new(void)
    return id;
 }
 
-/**
- * Add a filter the current event queue.
- * @param func_start Function to call just before filtering and return data
- * @param func_filter Function to call on each event
- * @param func_end Function to call after the queu has been filtered
- * @param data Data to pass to the filter functions
- * @return A filter handle
- *
- * This adds a filter to call callbacks to loop through the event queue and
- * filter events out of the queue. On failure NULL is returned. On success a
- * Filter handle is returned. Filters are called on the queue just before
- * Event handler processing to try and remove redundant events. Just as
- * processing starts @p func_start is called and passed the @p data pointer.
- * This function returns a pointer that is used as loop_data that is now passed to
- * @p func_filter as loop_data. @p func_filter is also passed @p data and the
- * event type and private event structure. If this callback returns 0, the
- * event is removed from the queue. If it returns 1, the event is kept. When
- * processing is finished @p func_end is called and is passed the loop_data
- * and @p data pointer to clean up.
- */
 EAPI Ecore_Event_Filter *
 ecore_event_filter_add(Ecore_Data_Cb   func_start,
                        Ecore_Filter_Cb func_filter,
@@ -374,15 +259,6 @@ unlock:
    return ef;
 }
 
-/**
- * Delete an event filter.
- * @param ef The event filter handle
- * @return The data set for the filter
- *
- * Delete a filter that has been added by its @p ef handle. On success this
- * will return the data pointer set when this filter was added. On failure
- * NULL is returned.
- */
 EAPI void *
 ecore_event_filter_del(Ecore_Event_Filter *ef)
 {
@@ -404,50 +280,18 @@ unlock:
    return data;
 }
 
-/**
- * Return the current event type being handled.
- * @return The current event type being handled if inside a handler callback
- *
- * If the program is currently inside an Ecore event handler callback this
- * will return the type of the current event being processed. If Ecore is
- * not inside an event handler, ECORE_EVENT_NONE is returned.
- *
- * This is useful when certain Ecore modules such as Ecore_Evas "swallow"
- * events and not all the original information is passed on. In special cases
- * this extra information may be useful or needed and using this call can let
- * the program know if the event type being handled is one it wants to get more
- * information about.
- */
 EAPI int
 ecore_event_current_type_get(void)
 {
    return ecore_raw_event_type;
 }
 
-/**
- * Return the current event type pointer handled.
- * @return The current event pointer being handled if inside a handler callback
- *
- * If the program is currently inside an Ecore event handler callback this
- * will return the pointer of the current event being processed. If Ecore is
- * not inside an event handler, NULL will be returned.
- *
- * This is useful when certain Ecore modules such as Ecore_Evas "swallow"
- * events and not all the original information is passed on. In special cases
- * this extra information may be useful or needed and using this call can let
- * the program access the event data if the type of the event is handled by
- * the program.
- */
 EAPI void *
 ecore_event_current_event_get(void)
 {
    return ecore_raw_event_event;
 }
 
-/**
- * @}
- */
-
 EAPI void *
 _ecore_event_handler_del(Ecore_Event_Handler *event_handler)
 {
diff --git a/libraries/ecore/src/lib/ecore/ecore_exe.c b/libraries/ecore/src/lib/ecore/ecore_exe.c
index d5465fc..47f8dc9 100644
--- a/libraries/ecore/src/lib/ecore/ecore_exe.c
+++ b/libraries/ecore/src/lib/ecore/ecore_exe.c
@@ -331,15 +331,15 @@ static int run_pri = ECORE_EXE_PRIORITY_INHERIT;
  * This sets the priority of processes run by ecore_exe_run() and
  * ecore_exe_pipe_run().
  * @li On Windows, the child process is created by default with the
- * #ECORE_EXE_WIN32_PRIORITY_NORMAL priority, unless the calling
- * process is in #ECORE_EXE_WIN32_PRIORITY_IDLE or
- * #ECORE_EXE_WIN32_PRIORITY_BELOW_NORMAL priority. In that case, the
+ * @ref ECORE_EXE_WIN32_PRIORITY_NORMAL priority, unless the calling
+ * process is in @ref ECORE_EXE_WIN32_PRIORITY_IDLE or
+ * @ref ECORE_EXE_WIN32_PRIORITY_BELOW_NORMAL priority. In that case, the
  * child process inherits this priority.
- * @li On other platforms, if set to #ECORE_EXE_PRIORITY_INHERIT child
+ * @li On other platforms, if set to @ref ECORE_EXE_PRIORITY_INHERIT child
  * processes inherits the priority of their parent. This is the default.
  *
  * @param   pri value a Ecore_Exe_Win32_Priority value on Windows, -20
- * to 19 or ECORE_EXE_PRIORITY_INHERIT on other OS.
+ * to 19 or @ref ECORE_EXE_PRIORITY_INHERIT on other OS.
  */
 EAPI void
 ecore_exe_run_priority_set(int pri)
diff --git a/libraries/ecore/src/lib/ecore/ecore_getopt.c b/libraries/ecore/src/lib/ecore/ecore_getopt.c
index 76272d3..cd68189 100644
--- a/libraries/ecore/src/lib/ecore/ecore_getopt.c
+++ b/libraries/ecore/src/lib/ecore/ecore_getopt.c
@@ -38,6 +38,10 @@ void *alloca(size_t);
 # include <Evil.h>
 #endif
 
+#ifdef HAVE_EXOTIC
+# include <Exotic.h>
+#endif
+
 #include "Ecore.h"
 #include "Ecore_Getopt.h"
 
diff --git a/libraries/ecore/src/lib/ecore/ecore_main.c b/libraries/ecore/src/lib/ecore/ecore_main.c
index 76aced6..587c83b 100644
--- a/libraries/ecore/src/lib/ecore/ecore_main.c
+++ b/libraries/ecore/src/lib/ecore/ecore_main.c
@@ -229,10 +229,14 @@ static Eina_Bool win32_handlers_delete_me = EINA_FALSE;
 #ifdef _WIN32
 Ecore_Select_Function main_loop_select = _ecore_main_win32_select;
 #else
-# ifdef HAVE_SYS_SELECT_H
-#  include <sys/select.h>
-# endif
+# if !defined EXOTIC_NO_SELECT
+#  ifdef HAVE_SYS_SELECT_H
+#   include <sys/select.h>
+#  endif
 Ecore_Select_Function main_loop_select = select;
+# else
+Ecore_Select_Function main_loop_select = NULL;
+# endif
 #endif
 
 #ifndef USE_G_MAIN_LOOP
@@ -848,6 +852,21 @@ _ecore_main_fd_handler_del(Ecore_Fd_Handler *fd_handler)
  * DO NOT use this function unless you are the person God comes to ask for
  * advice when He has trouble managing the Universe.
  */
+
+EAPI int
+ecore_main_loop_iterate_may_block(int may_block)
+{
+#ifndef USE_G_MAIN_LOOP
+   _ecore_lock();
+in_main_loop++;
+   _ecore_main_loop_iterate_internal(!may_block);
+in_main_loop--;
+   _ecore_unlock();
+   return _ecore_event_exist();
+#else
+   return g_main_context_iteration(NULL, may_block);
+#endif
+}
 EAPI void
 ecore_main_loop_iterate(void)
 {
@@ -945,39 +964,6 @@ ecore_main_loop_select_func_get(void)
    return main_loop_select;
 }
 
-/**
- * Adds a callback for activity on the given file descriptor.
- *
- * @p func will be called during the execution of @ref ecore_main_loop_begin
- * when the file descriptor is available for reading, or writing, or both.
- *
- * Normally when @p func returns ECORE_CALLBACK_CANCEL, it indicates that the
- * handler should be marked for deletion (identical to calling @ref ecore_main_fd_handler_del).
- * However, if the @p buf_func is supplied, then the return value from the @p func indicates that
- * @p func should be called repeatedly until it returns ECORE_CALLBACK_CANCEL.
- *
- * @p buf_func is called during event loop handling to check if data that has
- * been read from the file descriptor is in a buffer and is available to
- * read.  Some systems (notably xlib) handle their own buffering, and would
- * otherwise not work with select().  These systems should use a @p buf_func.
- * This is a most annoying hack, only ecore_x uses it, so refer to that for
- * an example.  NOTE - @p func should probably return ECORE_CALLBACK_RENEW always if
- * @p buf_func is used, to avoid confusion with the other return value
- * semantics.
- *
- * @param   fd       The file descriptor to watch.
- * @param   flags    To watch it for read (@c ECORE_FD_READ) and/or
- *                   (@c ECORE_FD_WRITE) write ability.  @c ECORE_FD_ERROR
- *
- * @param   func     The callback function.
- * @param   data     The data to pass to the callback.
- * @param   buf_func The function to call to check if any data has been
- *                   buffered and already read from the fd.  Can be @c NULL.
- * @param   buf_data The data to pass to the @p buf_func function.
- * @return  A fd handler handle if successful.  @c NULL otherwise.
- * @note This function CANNOT be used for reading/writing to regular files!
- * @ingroup Ecore_FD_Handler_Group
- */
 EAPI Ecore_Fd_Handler *
 ecore_main_fd_handler_add(int                    fd,
                           Ecore_Fd_Handler_Flags flags,
@@ -1059,20 +1045,6 @@ ecore_main_win32_handler_add(void                 *h __UNUSED__,
 
 #endif
 
-/**
- * Marks an FD handler for deletion.
- * @param   fd_handler The FD handler.
- * @return  The data pointer set using @ref ecore_main_fd_handler_add,
- *          for @p fd_handler on success.  @c NULL otherwise.
- * @ingroup Ecore_FD_Handler_Group
- * This function marks an fd handler to be deleted during an iteration of the main loop.
- * It does NOT close the associated fd!
- *
- * @note If the underlying fd is already closed ecore may complain if the main loop
- * is using epoll internally, and also in some rare cases this may cause
- * crashes and instability. Remember to delete your fd handlers before the
- * fds they listen to are closed.
- */
 EAPI void *
 ecore_main_fd_handler_del(Ecore_Fd_Handler *fd_handler)
 {
@@ -1116,24 +1088,6 @@ ecore_main_win32_handler_del(Ecore_Win32_Handler *win32_handler __UNUSED__)
 
 #endif
 
-/**
- * @brief Set the prepare callback with data for a given #Ecore_Fd_Handler
- *
- * @param fd_handler The fd handler
- * @param func The prep function
- * @param data The data to pass to the prep function
- *
- * This function will be called prior to any fd handler's callback function
- * (even the other fd handlers), before entering the main loop select function.
- *
- * @note Once a prepare callback is set for a fd handler, it cannot be changed.
- * You need to delete the fd handler and create a new one, to set another
- * callback.
- * @note You probably don't need this function. It is only necessary for very
- * uncommon cases that need special behavior.
- *
- * @ingroup Ecore_FD_Handler_Group
- */
 EAPI void
 ecore_main_fd_handler_prepare_callback_set(Ecore_Fd_Handler *fd_handler,
                                            Ecore_Fd_Prep_Cb  func,
@@ -1157,12 +1111,6 @@ unlock:
    _ecore_unlock();
 }
 
-/**
- * Retrieves the file descriptor that the given handler is handling.
- * @param   fd_handler The given FD handler.
- * @return  The file descriptor the handler is watching.
- * @ingroup Ecore_FD_Handler_Group
- */
 EAPI int
 ecore_main_fd_handler_fd_get(Ecore_Fd_Handler *fd_handler)
 {
@@ -1182,15 +1130,6 @@ unlock:
    return fd;
 }
 
-/**
- * Return if read, write or error, or a combination thereof, is active on the
- * file descriptor of the given FD handler.
- * @param   fd_handler The given FD handler.
- * @param   flags      The flags, @c ECORE_FD_READ, @c ECORE_FD_WRITE or
- *                     @c ECORE_FD_ERROR to query.
- * @return  #EINA_TRUE if any of the given flags are active. #EINA_FALSE otherwise.
- * @ingroup Ecore_FD_Handler_Group
- */
 EAPI Eina_Bool
 ecore_main_fd_handler_active_get(Ecore_Fd_Handler      *fd_handler,
                                  Ecore_Fd_Handler_Flags flags)
@@ -1213,12 +1152,6 @@ unlock:
    return ret;
 }
 
-/**
- * Set what active streams the given FD handler should be monitoring.
- * @param   fd_handler The given FD handler.
- * @param   flags      The flags to be watching.
- * @ingroup Ecore_FD_Handler_Group
- */
 EAPI void
 ecore_main_fd_handler_active_set(Ecore_Fd_Handler      *fd_handler,
                                  Ecore_Fd_Handler_Flags flags)
@@ -1742,14 +1675,14 @@ _ecore_main_loop_iterate_internal(int once_only)
    if (_ecore_event_exist())
      {
         /* but first conceptually enter an idle state */
-         _ecore_idle_enterer_call();
-         _ecore_throttle();
-         /* now quickly poll to see which input fd's are active */
-         _ecore_main_select(0.0);
-         /* allow newly queued timers to expire from now on */
-         _ecore_timer_enable_new();
-         /* go straight to processing the events we had queued */
-         goto process_all;
+        _ecore_idle_enterer_call();
+        _ecore_throttle();
+        /* now quickly poll to see which input fd's are active */
+        _ecore_main_select(0.0);
+        /* allow newly queued timers to expire from now on */
+        _ecore_timer_enable_new();
+        /* go straight to processing the events we had queued */
+        goto process_all;
      }
 
    if (once_only)
@@ -1758,17 +1691,17 @@ _ecore_main_loop_iterate_internal(int once_only)
          * if we got any events or signals, allow new timers to process.
          * use bitwise or to force both conditions to be tested and
          * merged together */
-          if (_ecore_main_select(0.0) | _ecore_signal_count_get())
-            {
-               _ecore_timer_enable_new();
-               goto process_all;
-            }
+        if (_ecore_main_select(0.0) | _ecore_signal_count_get())
+          {
+             _ecore_timer_enable_new();
+             goto process_all;
+          }
      }
    else
      {
         /* call idle enterers ... */
-         _ecore_idle_enterer_call();
-         _ecore_throttle();
+        _ecore_idle_enterer_call();
+        _ecore_throttle();
      }
 
    /* if these calls caused any buffered events to appear - deal with them */
@@ -1787,10 +1720,10 @@ _ecore_main_loop_iterate_internal(int once_only)
    if (once_only)
      {
         /* in once_only mode enter idle here instead and then return */
-         _ecore_idle_enterer_call();
-         _ecore_throttle();
-         _ecore_timer_enable_new();
-         goto done;
+        _ecore_idle_enterer_call();
+        _ecore_throttle();
+        _ecore_timer_enable_new();
+        goto done;
      }
 
    _ecore_fps_marker_1();
@@ -1808,23 +1741,23 @@ start_loop: /***************************************************************/
    if (!_ecore_event_exist())
      {
         /* init flags */
-         next_time = _ecore_timer_next_get();
-         /* no idlers */
-         if (!_ecore_idler_exist())
-           {
-     /* sleep until timeout or forever (-1.0) waiting for on fds */
-               _ecore_main_select(next_time);
-           }
-         else
-           {
-              int action = LOOP_CONTINUE;
+        next_time = _ecore_timer_next_get();
+        /* no idlers */
+        if (!_ecore_idler_exist())
+          {
+             /* sleep until timeout or forever (-1.0) waiting for on fds */
+             _ecore_main_select(next_time);
+          }
+        else
+          {
+             int action = LOOP_CONTINUE;
 
-     /* no timers - spin */
-              if (next_time < 0) action = _ecore_main_loop_spin_no_timers();
-     /* timers - spin */
-              else action = _ecore_main_loop_spin_timers();
-              if (action == SPIN_RESTART) goto start_loop;
-           }
+             /* no timers - spin */
+             if (next_time < 0) action = _ecore_main_loop_spin_no_timers();
+             /* timers - spin */
+             else action = _ecore_main_loop_spin_timers();
+             if (action == SPIN_RESTART) goto start_loop;
+          }
      }
    _ecore_fps_marker_2();
 
@@ -1847,8 +1780,8 @@ process_all: /***********************************************************/
    if (once_only)
      {
         /* if in once_only mode handle idle exiting */
-         _ecore_idle_enterer_call();
-         _ecore_throttle();
+        _ecore_idle_enterer_call();
+        _ecore_throttle();
      }
 
 done: /*******************************************************************/
diff --git a/libraries/ecore/src/lib/ecore/ecore_pipe.c b/libraries/ecore/src/lib/ecore/ecore_pipe.c
index aa640cd..ea7453e 100644
--- a/libraries/ecore/src/lib/ecore/ecore_pipe.c
+++ b/libraries/ecore/src/lib/ecore/ecore_pipe.c
@@ -36,15 +36,13 @@
 # include <Escape.h>
 #endif
 
+#ifdef HAVE_EXOTIC
+# include <Exotic.h>
+#endif
+
 #include "Ecore.h"
 #include "ecore_private.h"
 
-#ifdef _WIN32
-# define FMT_SSIZE_T "%Id"
-#else
-# define FMT_SSIZE_T "%zd"
-#endif
-
 /* How of then we should retry to write to the pipe */
 #define ECORE_PIPE_WRITE_RETRY 6
 
@@ -80,6 +78,9 @@
 
 #endif /* ! _WIN32 */
 
+#include <Ecore.h>
+#include "ecore_private.h"
+
 struct _Ecore_Pipe
 {
                      ECORE_MAGIC;
@@ -414,7 +415,7 @@ ecore_pipe_write(Ecore_Pipe  *p,
           ;
         else
           {
-             ERR("An unhandled error (ret: " FMT_SSIZE_T " errno: %d)"
+             ERR("An unhandled error (ret: %zd errno: %d)"
                  "occurred while writing to the pipe the length",
                  ret, errno);
           }
@@ -448,7 +449,7 @@ ecore_pipe_write(Ecore_Pipe  *p,
           ;
         else
           {
-             ERR("An unhandled error (ret: " FMT_SSIZE_T " errno: %d)"
+             ERR("An unhandled error (ret: %zd errno: %d)"
                  "occurred while writing to the pipe the length",
                  ret, errno);
           }
diff --git a/libraries/ecore/src/lib/ecore/ecore_poll.c b/libraries/ecore/src/lib/ecore/ecore_poll.c
index 732850b..bf4da6a 100644
--- a/libraries/ecore/src/lib/ecore/ecore_poll.c
+++ b/libraries/ecore/src/lib/ecore/ecore_poll.c
@@ -189,20 +189,6 @@ _ecore_poller_cb_timer(void *data __UNUSED__)
    return ECORE_CALLBACK_RENEW;
 }
 
-/**
- * @addtogroup Ecore_Poller_Group
- *
- * @{
- */
-
-/**
- * Sets the time between ticks (in seconds) for the given ticker clock.
- * @param   type The ticker type to adjust
- * @param   poll_time The time (in seconds) between ticks of the clock
- *
- * This will adjust the time between ticks of the given ticker type defined
- * by @p type to the time period defined by @p poll_time.
- */
 EAPI void
 ecore_poller_poll_interval_set(Ecore_Poller_Type type __UNUSED__,
                                double            poll_time)
@@ -211,65 +197,12 @@ ecore_poller_poll_interval_set(Ecore_Poller_Type type __UNUSED__,
    _ecore_poller_next_tick_eval();
 }
 
-/**
- * Gets the time between ticks (in seconds) for the given ticker clock.
- * @param   type The ticker type to query
- * @return  The time in seconds between ticks of the ticker clock
- *
- * This will get the time between ticks of the specified ticker clock.
- */
 EAPI double
 ecore_poller_poll_interval_get(Ecore_Poller_Type type __UNUSED__)
 {
    return poll_interval;
 }
 
-/**
- * Creates a poller to call the given function at a particular tick interval.
- * @param   type The ticker type to attach the poller to
- * @param   interval The poll interval
- * @param   func The given function.  If @p func returns 1, the poller is
- *               rescheduled for the next tick interval.
- * @param   data Data to pass to @p func when it is called.
- * @return  A poller object on success.  @c NULL on failure.
- *
- * This function adds a poller callback that is to be called regularly
- * along with all other poller callbacks so the pollers are synchronized with
- * all other pollers running off the same poller type and at the same tick
- * interval. This should be used for polling things when polling is desired
- * or required, and you do not have specific requirements on the exact times
- * to poll and want to avoid extra process wakeups for polling. This will
- * save power as the CPU has more of a chance to go into a low power state
- * the longer it is asleep for, so this should be used if you are at all
- * power conscious.
- *
- * The @p type parameter defines the poller tick type (there is a virtual
- * clock ticking all the time - though ecore avoids making it tick when
- * there will not be any work to do at that tick point). There is only one
- * ticker at the moment - that is ECORE_POLLER_CORE. This is here for future
- * expansion if multiple clocks with different frequencies are really required.
- * The default time between ticks for the ECORE_POLLER_CORE ticker is 0.125
- * seconds.
- *
- * The @p interval is the number of ticker ticks that will pass by in between
- * invocations of the @p func callback. This must be between 1 and 32768
- * inclusive, and must be a power of 2 (i.e. 1, 2, 4, 8, 16, ... 16384, 32768).
- * If it is 1, then the function will be called every tick. if it is 2, then it
- * will be called every 2nd tick, if it is 8, then every 8th tick etc. Exactly
- * which tick is undefined, as only the interval between calls can be defined.
- * Ecore will endeavour to keep pollers synchronised and to call as many in
- * 1 wakeup event as possible.
- *
- * This function adds a poller and returns its handle on success and NULL on
- * failure. The function @p func will be called at tick intervals described
- * above. The function will be passed the @p data pointer as its parameter.
- *
- * When the poller @p func is called, it must return a value of either
- * 1 (or ECORE_CALLBACK_RENEW) or 0 (or ECORE_CALLBACK_CANCEL). If it
- * returns 1, it will be called again at the next tick, or if it returns
- * 0 it will be deleted automatically making any references/handles for it
- * invalid.
- */
 EAPI Ecore_Poller *
 ecore_poller_add(Ecore_Poller_Type type __UNUSED__,
                  int               interval,
@@ -307,16 +240,6 @@ ecore_poller_add(Ecore_Poller_Type type __UNUSED__,
    return poller;
 }
 
-/**
- * Changes the polling interval rate of @p poller.
- *
- * @param poller The Ecore_Poller to change the interval of
- * @param interval The tick interval to set; must be a power of 2 but <= 32768
- * @return Returns true on success, false on failure
- *
- * This allows the changing of a poller's polling interval.  It is useful when you want to alter
- * a poll rate without deleting and re-creating a poller.
- */
 EAPI Eina_Bool
 ecore_poller_poller_interval_set(Ecore_Poller *poller,
                                  int           interval)
@@ -353,14 +276,6 @@ ecore_poller_poller_interval_set(Ecore_Poller *poller,
    return EINA_TRUE;
 }
 
-/**
- * Gets the polling interval rate of @p poller.
- *
- * @param poller The Ecore_Poller to change the interval of
- * @return Returns the interval, in ticks, that @p poller polls at
- *
- * This returns a poller's polling interval, or 0 on error.
- */
 EAPI int
 ecore_poller_poller_interval_get(Ecore_Poller *poller)
 {
@@ -382,15 +297,6 @@ ecore_poller_poller_interval_get(Ecore_Poller *poller)
    return interval;
 }
 
-/**
- * Delete the specified poller from the timer list.
- * @param   poller The poller to delete.
- * @return  The data pointer set for the timer when @ref ecore_poller_add was
- *          called.  @c NULL is returned if the function is unsuccessful.
- *
- * Note: @p poller must be a valid handle. If the poller function has already
- * returned 0, the handle is no longer valid (and does not need to be delete).
- */
 EAPI void *
 ecore_poller_del(Ecore_Poller *poller)
 {
diff --git a/libraries/ecore/src/lib/ecore/ecore_private.h b/libraries/ecore/src/lib/ecore/ecore_private.h
index 50d502c..f0c5d6b 100644
--- a/libraries/ecore/src/lib/ecore/ecore_private.h
+++ b/libraries/ecore/src/lib/ecore/ecore_private.h
@@ -174,7 +174,7 @@ void      *_ecore_main_fd_handler_del(Ecore_Fd_Handler *fd_handler);
 
 void       _ecore_main_shutdown(void);
 
-#if defined (_WIN32) || defined (__lv2ppu__)
+#if defined (_WIN32) || defined (__lv2ppu__) || defined (HAVE_EXOTIC)
 static inline void _ecore_signal_shutdown(void) { }
 
 static inline void _ecore_signal_init(void) { }
@@ -237,14 +237,14 @@ _ecore_lock(void)
    EINA_MAIN_LOOP_CHECK_RETURN;
 #endif
    _ecore_main_lock_count++;
-   assert(_ecore_main_lock_count == 1);
+   /* assert(_ecore_main_lock_count == 1); */
 }
 
 static inline void
 _ecore_unlock(void)
 {
    _ecore_main_lock_count--;
-   assert(_ecore_main_lock_count == 0);
+   /* assert(_ecore_main_lock_count == 0); */
 #ifdef HAVE_THREAD_SAFETY
    eina_lock_release(&_ecore_main_loop_lock);
 #endif
diff --git a/libraries/ecore/src/lib/ecore/ecore_thread.c b/libraries/ecore/src/lib/ecore/ecore_thread.c
index 4444ad4..85fbe64 100644
--- a/libraries/ecore/src/lib/ecore/ecore_thread.c
+++ b/libraries/ecore/src/lib/ecore/ecore_thread.c
@@ -17,6 +17,25 @@
 
 #ifdef EFL_HAVE_THREADS
 
+# define LK(x) Eina_Lock x
+# define LKI(x) eina_lock_new(&(x))
+# define LKD(x) eina_lock_free(&(x))
+# define LKL(x) eina_lock_take(&(x))
+# define LKU(x) eina_lock_release(&(x))
+
+# define CD(x) Eina_Condition x
+# define CDI(x, m) eina_condition_new(&(x), &(m))
+# define CDD(x) eina_condition_free(&(x))
+# define CDB(x) eina_condition_broadcast(&(x))
+# define CDW(x, t) eina_condition_timedwait(&(x), t)
+
+# define LRWK(x) Eina_RWLock x
+# define LRWKI(x) eina_rwlock_new(&(x));
+# define LRWKD(x) eina_rwlock_free(&(x));
+# define LRWKWL(x) eina_rwlock_take_write(&(x));
+# define LRWKRL(x) eina_rwlock_take_read(&(x));
+# define LRWKU(x) eina_rwlock_release(&(x));
+
 # ifdef EFL_HAVE_POSIX_THREADS
 #  include <pthread.h>
 #  ifdef __linux__
@@ -31,28 +50,9 @@
 #  define PHE(x, y)    pthread_equal(x, y)
 #  define PHS()        pthread_self()
 #  define PHC(x, f, d) pthread_create(&(x), NULL, (void *)f, d)
-#  define PHJ(x, p)    pthread_join(x, (void **)(&(p)))
+#  define PHJ(x)       pthread_join(x, NULL)
 #  define PHA(x)       pthread_cancel(x)
 
-#  define CD(x)        pthread_cond_t x
-#  define CDI(x)       pthread_cond_init(&(x), NULL);
-#  define CDD(x)       pthread_cond_destroy(&(x));
-#  define CDB(x)       pthread_cond_broadcast(&(x));
-#  define CDW(x, y, t) pthread_cond_timedwait(&(x), &(y), t);
-
-#  define LK(x)        pthread_mutex_t x
-#  define LKI(x)       pthread_mutex_init(&(x), NULL);
-#  define LKD(x)       pthread_mutex_destroy(&(x));
-#  define LKL(x)       pthread_mutex_lock(&(x));
-#  define LKU(x)       pthread_mutex_unlock(&(x));
-
-#  define LRWK(x)      pthread_rwlock_t x
-#  define LRWKI(x)     pthread_rwlock_init(&(x), NULL);
-#  define LRWKD(x)     pthread_rwlock_destroy(&(x));
-#  define LRWKWL(x)    pthread_rwlock_wrlock(&(x));
-#  define LRWKRL(x)    pthread_rwlock_rdlock(&(x));
-#  define LRWKU(x)     pthread_rwlock_unlock(&(x));
-
 # else /* EFL_HAVE_WIN32_THREADS */
 
 #  define WIN32_LEAN_AND_MEAN
@@ -108,209 +108,9 @@ _ecore_thread_win32_join(win32_thread *x,
    return 0;
 }
 
-#  define PHJ(x, p) _ecore_thread_win32_join(x, (void **)(&(p)))
+#  define PHJ(x) _ecore_thread_win32_join(x, NULL)
 #  define PHA(x)    TerminateThread(x->thread, 0)
 
-#  define LK(x)     HANDLE x
-#  define LKI(x)    x = CreateMutex(NULL, FALSE, NULL)
-#  define LKD(x)    CloseHandle(x)
-#  define LKL(x)    WaitForSingleObject(x, INFINITE)
-#  define LKU(x)    ReleaseMutex(x)
-
-typedef struct
-{
-   HANDLE           semaphore;
-   LONG             threads_count;
-   CRITICAL_SECTION threads_count_lock;
-} win32_cond;
-
-#  define CD(x) win32_cond * x
-
-#  define CDI(x)                                                       \
-  do {                                                                 \
-       x = (win32_cond *)calloc(1, sizeof(win32_cond));                \
-       if (x)                                                          \
-         {                                                             \
-            x->semaphore = CreateSemaphore(NULL, 0, 0x7fffffff, NULL); \
-            if (x->semaphore)                                          \
-              InitializeCriticalSection(&x->threads_count_lock);       \
-            else                                                       \
-              {                                                        \
-                 free(x);                                              \
-                 x = NULL;                                             \
-              }                                                        \
-         }                                                             \
-    } while (0)
-
-#  define CDD(x)                  \
-  do {                            \
-       CloseHandle(x->semaphore); \
-       free(x);                   \
-       x = NULL;                  \
-    } while (0)
-
-#  define CDB(x)                                                  \
-  do {                                                            \
-       EnterCriticalSection(&x->threads_count_lock);              \
-       if (x->threads_count > 0)                                  \
-         ReleaseSemaphore(x->semaphore, x->threads_count, NULL);  \
-       LeaveCriticalSection (&x->threads_count_lock);             \
-    } while (0)
-
-int
-_ecore_thread_win32_cond_timedwait(win32_cond     *c,
-                                   HANDLE         *external_mutex,
-                                   struct timeval *t)
-{
-   DWORD res;
-   DWORD val = t->tv_sec * 1000 + (t->tv_usec / 1000);
-   LKL(external_mutex);
-   EnterCriticalSection (&c->threads_count_lock);
-   c->threads_count++;
-   LeaveCriticalSection (&c->threads_count_lock);
-   LKU(external_mutex);
-   res = WaitForSingleObject(c->semaphore, val);
-   if (res == WAIT_OBJECT_0)
-     return 0;
-   else
-     return -1;
-}
-
-#  define CDW(x, y, t) _ecore_thread_win32_cond_timedwait(x, y, t)
-
-typedef struct
-{
-   LONG readers_count;
-   LONG writers_count;
-   int  readers;
-   int  writers;
-   LK(mutex);
-   CD(cond_read);
-   CD(cond_write);
-} win32_rwl;
-
-#  define LRWK(x) win32_rwl * x
-#  define LRWKI(x)                                    \
-  do {                                                \
-       x = (win32_rwl *)calloc(1, sizeof(win32_rwl)); \
-       if (x)                                         \
-         {                                            \
-            LKI(x->mutex);                            \
-            if (x->mutex)                             \
-              {                                       \
-                 CDI(x->cond_read);                   \
-                 if (x->cond_read)                    \
-                   {                                  \
-                      CDI(x->cond_write);             \
-                      if (!x->cond_write)             \
-                        {                             \
-                           CDD(x->cond_read);         \
-                           LKD(x->mutex);             \
-                           free(x);                   \
-                           x = NULL;                  \
-                        }                             \
-                   }                                  \
-                 else                                 \
-                   {                                  \
-                      LKD(x->mutex);                  \
-                      free(x);                        \
-                      x = NULL;                       \
-                   }                                  \
-              }                                       \
-            else                                      \
-              {                                       \
-                 free(x);                             \
-                 x = NULL;                            \
-              }                                       \
-         }                                            \
-    } while (0)
-
-#  define LRWKD(x)         \
-  do {                     \
-       LKU(x->mutex);      \
-       LKD(x->mutex);      \
-       CDD(x->cond_write); \
-       CDD(x->cond_read);  \
-       free(x);            \
-    } while (0)
-#  define LRWKWL(x)                                                             \
-  do {                                                                          \
-       DWORD res;                                                               \
-       LKU(x->mutex);                                                           \
-       if (x->writers || x->readers > 0)                                        \
-         {                                                                      \
-            x->writers_count++;                                                 \
-            while (x->writers || x->readers > 0)                                \
-              {                                                                 \
-                 EnterCriticalSection(&x->cond_write->threads_count_lock);      \
-                 x->cond_read->threads_count++;                                 \
-                 LeaveCriticalSection(&x->cond_write->threads_count_lock);      \
-                 res = WaitForSingleObject(x->cond_write->semaphore, INFINITE); \
-                 if (res != WAIT_OBJECT_0) break;                               \
-              }                                                                 \
-            x->writers_count--;                                                 \
-         }                                                                      \
-       if (res == 0) x->writers_count = 1;                                      \
-       LKU(x->mutex);                                                           \
-    } while (0)
-#  define LRWKRL(x)                                                             \
-  do {                                                                          \
-       DWORD res;                                                               \
-       LKL(x->mutex);                                                           \
-       if (x->writers)                                                          \
-         {                                                                      \
-            x->readers_count++;                                                 \
-            while (x->writers)                                                  \
-              {                                                                 \
-                 EnterCriticalSection(&x->cond_write->threads_count_lock);      \
-                 x->cond_read->threads_count++;                                 \
-                 LeaveCriticalSection(&x->cond_write->threads_count_lock);      \
-                 res = WaitForSingleObject(x->cond_write->semaphore, INFINITE); \
-                 if (res != WAIT_OBJECT_0) break;                               \
-              }                                                                 \
-            x->readers_count--;                                                 \
-         }                                                                      \
-       if (res == 0)                                                            \
-         x->readers++;                                                          \
-       LKU(x->mutex);                                                           \
-    } while (0)
-#  define LRWKU(x)                                                          \
-  do {                                                                      \
-       LKL(x->mutex);                                                       \
-       if (x->writers)                                                      \
-         {                                                                  \
-            x->writers = 0;                                                 \
-            if (x->readers_count == 1)                                      \
-              {                                                             \
-                 EnterCriticalSection(&x->cond_read->threads_count_lock);   \
-                 if (x->cond_read->threads_count > 0)                       \
-                   ReleaseSemaphore(x->cond_read->semaphore, 1, 0);         \
-                 LeaveCriticalSection(&x->cond_read->threads_count_lock);   \
-              }                                                             \
-            else if (x->readers_count > 0)                                  \
-              CDB(x->cond_read);                                            \
-            else if (x->writers_count > 0)                                  \
-              {                                                             \
-                 EnterCriticalSection (&x->cond_write->threads_count_lock); \
-                 if (x->cond_write->threads_count > 0)                      \
-                   ReleaseSemaphore(x->cond_write->semaphore, 1, 0);        \
-                 LeaveCriticalSection (&x->cond_write->threads_count_lock); \
-              }                                                             \
-         }                                                                  \
-       else if (x->readers > 0)                                             \
-         {                                                                  \
-            x->readers--;                                                   \
-            if (x->readers == 0 && x->writers_count > 0)                    \
-              {                                                             \
-                 EnterCriticalSection (&x->cond_write->threads_count_lock); \
-                 if (x->cond_write->threads_count > 0)                      \
-                   ReleaseSemaphore(x->cond_write->semaphore, 1, 0);        \
-                 LeaveCriticalSection (&x->cond_write->threads_count_lock); \
-              }                                                             \
-         }                                                                  \
-       LKU(x->mutex);                                                       \
-    } while (0)
-
 # endif
 
 #endif
@@ -336,14 +136,24 @@ struct _Ecore_Pthread_Worker
       {
          Ecore_Thread_Cb        func_heavy;
          Ecore_Thread_Notify_Cb func_notify;
-         Ecore_Pipe            *notify;
 
-         Ecore_Pipe            *direct_pipe;
          Ecore_Pthread_Worker  *direct_worker;
 
          int                    send;
          int                    received;
       } feedback_run;
+      struct {
+         Ecore_Thread_Cb func_main;
+         Ecore_Thread_Notify_Cb func_notify;
+
+         Ecore_Pipe            *send;
+         Ecore_Pthread_Worker  *direct_worker;
+
+         struct {
+            int send;
+            int received;
+         } from, to;
+      } message_run;
    } u;
 
    Ecore_Thread_Cb func_cancel;
@@ -357,47 +167,63 @@ struct _Ecore_Pthread_Worker
 
    const void     *data;
 
-   Eina_Bool       cancel : 1;
-   Eina_Bool       feedback_run : 1;
-   Eina_Bool       kill : 1;
-   Eina_Bool       reschedule : 1;
-   Eina_Bool       no_queue : 1;
+   volatile int cancel;
+
+#ifdef EFL_HAVE_THREADS
+   LK(cancel_mutex);
+#endif
+
+   Eina_Bool message_run : 1;
+   Eina_Bool feedback_run : 1;
+   Eina_Bool kill : 1;
+   Eina_Bool reschedule : 1;
+   Eina_Bool no_queue : 1;
 };
 
 #ifdef EFL_HAVE_THREADS
 typedef struct _Ecore_Pthread_Data Ecore_Pthread_Data;
-
 struct _Ecore_Pthread_Data
 {
    Ecore_Pthread_Worker *death_job;
-   Ecore_Pipe           *p;
    void                 *data;
                          PH(thread);
 };
+
+typedef struct _Ecore_Pthread_Notify Ecore_Pthread_Notify;
+struct _Ecore_Pthread_Notify
+{
+   Ecore_Pthread_Worker *work;
+   const void *user_data;
+};
+
+typedef void *(*Ecore_Thread_Sync_Cb)(void* data, Ecore_Thread *thread);
+
+typedef struct _Ecore_Pthread_Message Ecore_Pthread_Message;
+struct _Ecore_Pthread_Message
+{
+   union {
+      Ecore_Thread_Cb async;
+      Ecore_Thread_Sync_Cb sync;
+   } u;
+
+   const void *data;
+
+   int code;
+
+   Eina_Bool callback : 1;
+   Eina_Bool sync : 1;
+};
+
 #endif
 
 static int _ecore_thread_count_max = 0;
-static int ECORE_THREAD_PIPE_DEL = 0;
-static Eina_Array *_ecore_thread_pipe = NULL;
 
 #ifdef EFL_HAVE_THREADS
 
-static void _ecore_thread_handler(void        *data __UNUSED__,
-                                  void        *buffer,
-                                  unsigned int nbyte);
-
-static Ecore_Pipe *
-_ecore_thread_pipe_get(void)
-{
-   if (eina_array_count(_ecore_thread_pipe) > 0)
-     return eina_array_pop(_ecore_thread_pipe);
-
-   return ecore_pipe_add(_ecore_thread_handler, NULL);
-}
+static void _ecore_thread_handler(void *data);
 
 static int _ecore_thread_count = 0;
 
-static Ecore_Event_Handler *del_handler = NULL;
 static Eina_List *_ecore_active_job_threads = NULL;
 static Eina_List *_ecore_pending_job_threads = NULL;
 static Eina_List *_ecore_pending_job_threads_feedback = NULL;
@@ -435,6 +261,10 @@ static PH(get_main_loop_thread) (void)
 static void
 _ecore_thread_worker_free(Ecore_Pthread_Worker *worker)
 {
+   LKD(worker->cancel_mutex);
+   CDD(worker->cond);
+   LKD(worker->mutex);
+
    if (_ecore_thread_worker_count > (_ecore_thread_count_max + 1) * 16)
      {
         free(worker);
@@ -454,38 +284,15 @@ _ecore_thread_data_free(void *data)
 }
 
 static void
-_ecore_thread_pipe_free(void *data __UNUSED__,
-                        void *event)
-{
-   Ecore_Pipe *p = event;
-
-   if (eina_array_count(_ecore_thread_pipe) < 50)
-     eina_array_push(_ecore_thread_pipe, p);
-   else
-     ecore_pipe_del(p);
-   eina_threads_shutdown();
-}
-
-static Eina_Bool
-_ecore_thread_pipe_del(void *data __UNUSED__,
-                       int   type __UNUSED__,
-                       void *event __UNUSED__)
-{
-   /* This is a hack to delay pipe destruction until we are out of its internal loop. */
-    return ECORE_CALLBACK_CANCEL;
-}
-
-static void
 _ecore_thread_end(Ecore_Pthread_Data *pth,
                   Ecore_Thread       *work)
 {
    Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *)work;
-   Ecore_Pipe *p;
 
-   if (!worker->feedback_run || (worker->feedback_run && !worker->no_queue))
+   if (!worker->message_run || !worker->feedback_run || (worker->feedback_run && !worker->no_queue))
      _ecore_thread_count--;
 
-   if (PHJ(pth->thread, p) != 0)
+   if (PHJ(pth->thread) != 0)
      return;
 
    if (eina_list_count(_ecore_pending_job_threads) > 0
@@ -496,7 +303,7 @@ _ecore_thread_end(Ecore_Pthread_Data *pth,
          INF("spawning threads because of still pending jobs.");
 
          pth->death_job = _ecore_thread_worker_new();
-         if (!pth->p || !pth->death_job) goto end;
+         if (!pth->death_job) goto end;
 
          eina_threads_init();
 
@@ -514,7 +321,6 @@ end:
 
    _ecore_active_job_threads = eina_list_remove(_ecore_active_job_threads, pth);
 
-   ecore_event_add(ECORE_THREAD_PIPE_DEL, pth->p, _ecore_thread_pipe_free, NULL);
    free(pth);
 }
 
@@ -534,30 +340,18 @@ _ecore_thread_kill(Ecore_Pthread_Worker *work)
 
    if (work->feedback_run)
      {
-        ecore_pipe_del(work->u.feedback_run.notify);
-
-        if (work->u.feedback_run.direct_pipe)
-          eina_array_push(_ecore_thread_pipe, work->u.feedback_run.direct_pipe);
         if (work->u.feedback_run.direct_worker)
           _ecore_thread_worker_free(work->u.feedback_run.direct_worker);
      }
-   CDD(work->cond);
-   LKD(work->mutex);
    if (work->hash)
      eina_hash_free(work->hash);
    _ecore_thread_worker_free(work);
 }
 
 static void
-_ecore_thread_handler(void        *data __UNUSED__,
-                      void        *buffer,
-                      unsigned int nbyte)
+_ecore_thread_handler(void *data)
 {
-   Ecore_Pthread_Worker *work;
-
-   if (nbyte != sizeof (Ecore_Pthread_Worker *)) return;
-
-   work = *(Ecore_Pthread_Worker **)buffer;
+   Ecore_Pthread_Worker *work = data;
 
    if (work->feedback_run)
      {
@@ -571,17 +365,20 @@ _ecore_thread_handler(void        *data __UNUSED__,
    _ecore_thread_kill(work);
 }
 
+#if 0
 static void
-_ecore_notify_handler(void        *data,
-                      void        *buffer,
-                      unsigned int nbyte)
+_ecore_nothing_handler(void *data __UNUSED__, void *buffer __UNUSED__, unsigned int nbyte __UNUSED__)
 {
-   Ecore_Pthread_Worker *work = data;
-   void *user_data;
+}
+#endif
 
-   if (nbyte != sizeof (Ecore_Pthread_Worker *)) return;
+static void
+_ecore_notify_handler(void *data)
+{
+   Ecore_Pthread_Notify *notify = data;
+   Ecore_Pthread_Worker *work = notify->work;
+   void *user_data = (void*) notify->user_data;
 
-   user_data = *(void **)buffer;
    work->u.feedback_run.received++;
 
    if (work->u.feedback_run.func_notify)
@@ -592,16 +389,64 @@ _ecore_notify_handler(void        *data,
      {
         _ecore_thread_kill(work);
      }
+
+   free(notify);
+}
+
+static void
+_ecore_message_notify_handler(void *data)
+{
+   Ecore_Pthread_Notify *notify = data;
+   Ecore_Pthread_Worker *work = notify->work;
+   Ecore_Pthread_Message *user_data = (void *) notify->user_data;
+   Eina_Bool delete = EINA_TRUE;
+
+   work->u.message_run.from.received++;
+
+   if (!user_data->callback)
+     {
+        if (work->u.message_run.func_notify)
+          work->u.message_run.func_notify((void *) work->data, (Ecore_Thread *) work, (void *) user_data->data);
+     }
+   else
+     {
+        if (user_data->sync)
+          {
+             user_data->data = user_data->u.sync((void*) user_data->data, (Ecore_Thread *) work);
+             user_data->callback = EINA_FALSE;
+             user_data->code = INT_MAX;
+             ecore_pipe_write(work->u.message_run.send, &user_data, sizeof (Ecore_Pthread_Message *));
+
+             delete = EINA_FALSE;
+          }
+        else
+          {
+             user_data->u.async((void*) user_data->data, (Ecore_Thread *) work);
+          }
+     }
+
+   if (delete)
+     {
+        free(user_data);
+     }
+
+   /* Force reading all notify event before killing the thread */
+   if (work->kill && work->u.message_run.from.send == work->u.message_run.from.received)
+     {
+        _ecore_thread_kill(work);
+     }
+   free(notify);
 }
 
 static void
-_ecore_short_job(Ecore_Pipe *end_pipe,
-                 PH(thread))
+_ecore_short_job(PH(thread))
 {
    Ecore_Pthread_Worker *work;
 
    while (_ecore_pending_job_threads)
      {
+        int cancel;
+
         LKL(_ecore_pending_job_threads_mutex);
 
         if (!_ecore_pending_job_threads)
@@ -616,9 +461,12 @@ _ecore_short_job(Ecore_Pipe *end_pipe,
 
         LKU(_ecore_pending_job_threads_mutex);
 
+        LKL(work->cancel_mutex);
+        cancel = work->cancel;
+        LKU(work->cancel_mutex);
         work->self = thread;
-        if (!work->cancel)
-          work->u.short_run.func_blocking((void *)work->data, (Ecore_Thread *)work);
+        if (!cancel)
+          work->u.short_run.func_blocking((void *) work->data, (Ecore_Thread*) work);
 
         if (work->reschedule)
           {
@@ -630,19 +478,20 @@ _ecore_short_job(Ecore_Pipe *end_pipe,
           }
         else
           {
-             ecore_pipe_write(end_pipe, &work, sizeof (Ecore_Pthread_Worker *));
+             ecore_main_loop_thread_safe_call_async(_ecore_thread_handler, work);
           }
      }
 }
 
 static void
-_ecore_feedback_job(Ecore_Pipe *end_pipe,
-                    PH(thread))
+_ecore_feedback_job(PH(thread))
 {
    Ecore_Pthread_Worker *work;
 
    while (_ecore_pending_job_threads_feedback)
      {
+        int cancel;
+
         LKL(_ecore_pending_job_threads_mutex);
 
         if (!_ecore_pending_job_threads_feedback)
@@ -657,9 +506,12 @@ _ecore_feedback_job(Ecore_Pipe *end_pipe,
 
         LKU(_ecore_pending_job_threads_mutex);
 
+        LKL(work->cancel_mutex);
+        cancel = work->cancel;
+        LKU(work->cancel_mutex);
         work->self = thread;
-        if (!work->cancel)
-          work->u.feedback_run.func_heavy((void *)work->data, (Ecore_Thread *)work);
+        if (!cancel)
+          work->u.feedback_run.func_heavy((void *) work->data, (Ecore_Thread *) work);
 
         if (work->reschedule)
           {
@@ -671,7 +523,7 @@ _ecore_feedback_job(Ecore_Pipe *end_pipe,
           }
         else
           {
-             ecore_pipe_write(end_pipe, &work, sizeof (Ecore_Pthread_Worker *));
+             ecore_main_loop_thread_safe_call_async(_ecore_thread_handler, work);
           }
      }
 }
@@ -679,6 +531,7 @@ _ecore_feedback_job(Ecore_Pipe *end_pipe,
 static void *
 _ecore_direct_worker(Ecore_Pthread_Worker *work)
 {
+   Ecore_Pthread_Worker *end;
    Ecore_Pthread_Data *pth;
 
 #ifdef EFL_POSIX_THREADS
@@ -691,40 +544,49 @@ _ecore_direct_worker(Ecore_Pthread_Worker *work)
    pth = malloc(sizeof (Ecore_Pthread_Data));
    if (!pth) return NULL;
 
-   pth->p = work->u.feedback_run.direct_pipe;
-   if (!pth->p)
-     {
-        free(pth);
-        return NULL;
-     }
    pth->thread = PHS();
 
    work->self = pth->thread;
-   work->u.feedback_run.func_heavy((void *)work->data, (Ecore_Thread *)work);
+   if (work->message_run)
+     work->u.message_run.func_main((void *) work->data, (Ecore_Thread *) work);
+   else
+     work->u.feedback_run.func_heavy((void *) work->data, (Ecore_Thread *) work);
 
-   ecore_pipe_write(pth->p, &work, sizeof (Ecore_Pthread_Worker *));
+   if (work->message_run)
+     {
+        end = work->u.message_run.direct_worker;
+        work->u.message_run.direct_worker = NULL;
+     }
+   else
+     {
+        end = work->u.feedback_run.direct_worker;
+        work->u.feedback_run.direct_worker = NULL;
+     }
 
-   work = work->u.feedback_run.direct_worker;
-   if (!work)
+   ecore_main_loop_thread_safe_call_async(_ecore_thread_handler, work);
+
+   if (!end)
      {
         free(pth);
         return NULL;
      }
 
-   work->data = pth;
-   work->u.short_run.func_blocking = NULL;
-   work->func_end = (void *)_ecore_thread_end;
-   work->func_cancel = NULL;
-   work->cancel = EINA_FALSE;
-   work->feedback_run = EINA_FALSE;
-   work->kill = EINA_FALSE;
-   work->hash = NULL;
-   CDI(work->cond);
-   LKI(work->mutex);
-
-   ecore_pipe_write(pth->p, &work, sizeof (Ecore_Pthread_Worker *));
+   end->data = pth;
+   end->u.short_run.func_blocking = NULL;
+   end->func_end = (void *)_ecore_thread_end;
+   end->func_cancel = NULL;
+   end->cancel = EINA_FALSE;
+   end->feedback_run = EINA_FALSE;
+   end->message_run = EINA_FALSE;
+   end->no_queue = EINA_FALSE;
+   end->kill = EINA_FALSE;
+   end->hash = NULL;
+   LKI(end->mutex);
+   CDI(end->cond, end->mutex);
+
+   ecore_main_loop_thread_safe_call_async(_ecore_thread_handler, end);
 
-   return pth->p;
+   return NULL;
 }
 
 static void *
@@ -740,8 +602,8 @@ _ecore_thread_worker(Ecore_Pthread_Data *pth)
    eina_sched_prio_drop();
 
 restart:
-   if (_ecore_pending_job_threads) _ecore_short_job(pth->p, pth->thread);
-   if (_ecore_pending_job_threads_feedback) _ecore_feedback_job(pth->p, pth->thread);
+   if (_ecore_pending_job_threads) _ecore_short_job(pth->thread);
+   if (_ecore_pending_job_threads_feedback) _ecore_feedback_job(pth->thread);
 
    /* FIXME: Check if there is feedback running task todo, and switch to feedback run handler. */
 
@@ -777,14 +639,14 @@ restart:
    work->func_cancel = NULL;
    work->cancel = EINA_FALSE;
    work->feedback_run = EINA_FALSE;
+   work->message_run = EINA_FALSE;
    work->kill = EINA_FALSE;
+   work->no_queue = EINA_FALSE;
    work->hash = NULL;
-   CDI(work->cond);
-   LKI(work->mutex);
 
-   ecore_pipe_write(pth->p, &work, sizeof (Ecore_Pthread_Worker *));
+   ecore_main_loop_thread_safe_call_async(_ecore_thread_handler, work);
 
-   return pth->p;
+   return NULL;
 }
 
 #endif
@@ -800,6 +662,10 @@ _ecore_thread_worker_new(void)
    if (!result) result = malloc(sizeof (Ecore_Pthread_Worker));
    else _ecore_thread_worker_count--;
 
+   LKI(result->cancel_mutex);
+   LKI(result->mutex);
+   CDI(result->cond, result->mutex);
+
    return result;
 #else
    return malloc(sizeof (Ecore_Pthread_Worker));
@@ -813,16 +679,11 @@ _ecore_thread_init(void)
    if (_ecore_thread_count_max <= 0)
      _ecore_thread_count_max = 1;
 
-   ECORE_THREAD_PIPE_DEL = ecore_event_type_new();
-   _ecore_thread_pipe = eina_array_new(8);
-
 #ifdef EFL_HAVE_THREADS
-   del_handler = ecore_event_handler_add(ECORE_THREAD_PIPE_DEL, _ecore_thread_pipe_del, NULL);
-
    LKI(_ecore_pending_job_threads_mutex);
    LRWKI(_ecore_thread_global_hash_lock);
    LKI(_ecore_thread_global_hash_mutex);
-   CDI(_ecore_thread_global_hash_cond);
+   CDI(_ecore_thread_global_hash_cond, _ecore_thread_global_hash_mutex);
 #endif
 }
 
@@ -830,10 +691,6 @@ void
 _ecore_thread_shutdown(void)
 {
    /* FIXME: If function are still running in the background, should we kill them ? */
-    Ecore_Pipe *p;
-    Eina_Array_Iterator it;
-    unsigned int i;
-
 #ifdef EFL_HAVE_THREADS
     Ecore_Pthread_Worker *work;
     Ecore_Pthread_Data *pth;
@@ -843,46 +700,39 @@ _ecore_thread_shutdown(void)
     EINA_LIST_FREE(_ecore_pending_job_threads, work)
       {
          if (work->func_cancel)
-           work->func_cancel((void *)work->data, (Ecore_Thread *)work);
+           work->func_cancel((void *)work->data, (Ecore_Thread *) work);
          free(work);
       }
 
     EINA_LIST_FREE(_ecore_pending_job_threads_feedback, work)
       {
          if (work->func_cancel)
-           work->func_cancel((void *)work->data, (Ecore_Thread *)work);
+           work->func_cancel((void *)work->data, (Ecore_Thread *) work);
          free(work);
       }
 
     LKU(_ecore_pending_job_threads_mutex);
 
-    /* Improve emergency shutdown */
+    /* FIXME: Improve emergency shutdown, now that we use async call, we can do something */
     EINA_LIST_FREE(_ecore_active_job_threads, pth)
       {
-         Ecore_Pipe *ep;
-
          PHA(pth->thread);
-         PHJ(pth->thread, ep);
-
-         ecore_pipe_del(pth->p);
+         PHJ(pth->thread);
       }
     if (_ecore_thread_global_hash)
       eina_hash_free(_ecore_thread_global_hash);
-    _ecore_event_handler_del(del_handler);
     have_main_loop_thread = 0;
-    del_handler = NULL;
+
+    while ((work = eina_trash_pop(&_ecore_thread_worker_trash)))
+      {
+         free(work);
+      }
 
     LKD(_ecore_pending_job_threads_mutex);
     LRWKD(_ecore_thread_global_hash_lock);
     LKD(_ecore_thread_global_hash_mutex);
     CDD(_ecore_thread_global_hash_cond);
 #endif
-
-    EINA_ARRAY_ITER_NEXT(_ecore_thread_pipe, i, p, it)
-    ecore_pipe_del(p);
-
-    eina_array_free(_ecore_thread_pipe);
-    _ecore_thread_pipe = NULL;
 }
 
 void
@@ -927,15 +777,15 @@ ecore_thread_run(Ecore_Thread_Cb func_blocking,
    work->func_cancel = func_cancel;
    work->cancel = EINA_FALSE;
    work->feedback_run = EINA_FALSE;
+   work->message_run = EINA_FALSE;
    work->kill = EINA_FALSE;
    work->reschedule = EINA_FALSE;
+   work->no_queue = EINA_FALSE;
    work->data = data;
 
 #ifdef EFL_HAVE_THREADS
    work->self = 0;
    work->hash = NULL;
-   CDI(work->cond);
-   LKI(work->mutex);
 
    LKL(_ecore_pending_job_threads_mutex);
    _ecore_pending_job_threads = eina_list_append(_ecore_pending_job_threads, work);
@@ -952,9 +802,8 @@ ecore_thread_run(Ecore_Thread_Cb func_blocking,
    pth = malloc(sizeof (Ecore_Pthread_Data));
    if (!pth) goto on_error;
 
-   pth->p = _ecore_thread_pipe_get();
    pth->death_job = _ecore_thread_worker_new();
-   if (!pth->p || !pth->death_job) goto on_error;
+   if (!pth->death_job) goto on_error;
 
    eina_threads_init();
 
@@ -969,7 +818,6 @@ ecore_thread_run(Ecore_Thread_Cb func_blocking,
 on_error:
    if (pth)
      {
-        if (pth->p) eina_array_push(_ecore_thread_pipe, pth->p);
         if (pth->death_job) _ecore_thread_worker_free(pth->death_job);
         free(pth);
      }
@@ -981,7 +829,11 @@ on_error:
         LKU(_ecore_pending_job_threads_mutex);
 
         if (work->func_cancel)
-          work->func_cancel((void *)work->data, (Ecore_Thread *)work);
+          work->func_cancel((void *) work->data, (Ecore_Thread *) work);
+
+        CDD(work->cond);
+        LKD(work->mutex);
+        LKD(work->cancel_mutex);
         free(work);
         work = NULL;
      }
@@ -1013,12 +865,16 @@ EAPI Eina_Bool
 ecore_thread_cancel(Ecore_Thread *thread)
 {
 #ifdef EFL_HAVE_THREADS
-   Ecore_Pthread_Worker *work = (Ecore_Pthread_Worker *)thread;
+   Ecore_Pthread_Worker *volatile work = (Ecore_Pthread_Worker *)thread;
    Eina_List *l;
+   int cancel;
 
    if (!work)
      return EINA_TRUE;
-   if (work->cancel)
+   LKL(work->cancel_mutex);
+   cancel = work->cancel;
+   LKU(work->cancel_mutex);
+   if (cancel)
      return EINA_FALSE;
 
    if (work->feedback_run)
@@ -1070,9 +926,14 @@ ecore_thread_cancel(Ecore_Thread *thread)
 
    LKU(_ecore_pending_job_threads_mutex);
 
+   work = (Ecore_Pthread_Worker *)thread;
+
    /* Delay the destruction */
-on_exit:
-   ((Ecore_Pthread_Worker *)thread)->cancel = EINA_TRUE;
+ on_exit:
+   LKL(work->cancel_mutex);
+   work->cancel = EINA_TRUE;
+   LKU(work->cancel_mutex);
+
    return EINA_FALSE;
 #else
    (void) thread;
@@ -1083,10 +944,23 @@ on_exit:
 EAPI Eina_Bool
 ecore_thread_check(Ecore_Thread *thread)
 {
-   Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *)thread;
+   Ecore_Pthread_Worker *volatile worker = (Ecore_Pthread_Worker *) thread;
+   int cancel;
 
    if (!worker) return EINA_TRUE;
-   return worker->cancel;
+#ifdef EFL_HAVE_THREADS
+   LKL(worker->cancel_mutex);
+#endif
+   cancel = worker->cancel;
+   /* FIXME: there is an insane bug driving me nuts here. I don't know if
+    it's a race condition, some cache issue or some alien attack on our software.
+    But ecore_thread_check will only work correctly with a printf, all the volatile,
+    lock and even usleep don't help here... */
+   /* fprintf(stderr, "wc: %i\n", cancel); */
+#ifdef EFL_HAVE_THREADS
+   LKU(worker->cancel_mutex);
+#endif
+   return cancel;
 }
 
 EAPI Ecore_Thread *
@@ -1109,12 +983,11 @@ ecore_thread_feedback_run(Ecore_Thread_Cb        func_heavy,
    worker->u.feedback_run.func_heavy = func_heavy;
    worker->u.feedback_run.func_notify = func_notify;
    worker->hash = NULL;
-   CDI(worker->cond);
-   LKI(worker->mutex);
    worker->func_cancel = func_cancel;
    worker->func_end = func_end;
    worker->data = data;
    worker->cancel = EINA_FALSE;
+   worker->message_run = EINA_FALSE;
    worker->feedback_run = EINA_TRUE;
    worker->kill = EINA_FALSE;
    worker->reschedule = EINA_FALSE;
@@ -1123,15 +996,12 @@ ecore_thread_feedback_run(Ecore_Thread_Cb        func_heavy,
    worker->u.feedback_run.send = 0;
    worker->u.feedback_run.received = 0;
 
-   worker->u.feedback_run.notify = ecore_pipe_add(_ecore_notify_handler, worker);
-   worker->u.feedback_run.direct_pipe = NULL;
    worker->u.feedback_run.direct_worker = NULL;
 
-   if (!try_no_queue)
+   if (try_no_queue)
      {
         PH(t);
 
-        worker->u.feedback_run.direct_pipe = _ecore_thread_pipe_get();
         worker->u.feedback_run.direct_worker = _ecore_thread_worker_new();
         worker->no_queue = EINA_TRUE;
 
@@ -1140,6 +1010,12 @@ ecore_thread_feedback_run(Ecore_Thread_Cb        func_heavy,
         if (PHC(t, _ecore_direct_worker, worker) == 0)
           return (Ecore_Thread *)worker;
 
+        if (worker->u.feedback_run.direct_worker)
+          {
+             _ecore_thread_worker_free(worker->u.feedback_run.direct_worker);
+             worker->u.feedback_run.direct_worker = NULL;
+          }
+
         eina_threads_shutdown();
      }
 
@@ -1160,9 +1036,8 @@ ecore_thread_feedback_run(Ecore_Thread_Cb        func_heavy,
    pth = malloc(sizeof (Ecore_Pthread_Data));
    if (!pth) goto on_error;
 
-   pth->p = _ecore_thread_pipe_get();
    pth->death_job = _ecore_thread_worker_new();
-   if (!pth->p || !pth->death_job) goto on_error;
+   if (!pth->death_job) goto on_error;
 
    eina_threads_init();
 
@@ -1177,7 +1052,6 @@ ecore_thread_feedback_run(Ecore_Thread_Cb        func_heavy,
 on_error:
    if (pth)
      {
-        if (pth->p) eina_array_push(_ecore_thread_pipe, pth->p);
         if (pth->death_job) _ecore_thread_worker_free(pth->death_job);
         free(pth);
      }
@@ -1193,7 +1067,8 @@ on_error:
 
         if (worker)
           {
-             ecore_pipe_del(worker->u.feedback_run.notify);
+             CDD(worker->cond);
+             LKD(worker->mutex);
              free(worker);
              worker = NULL;
           }
@@ -1211,7 +1086,6 @@ on_error:
     */
    worker.u.feedback_run.func_heavy = func_heavy;
    worker.u.feedback_run.func_notify = func_notify;
-   worker.u.feedback_run.notify = NULL;
    worker.u.feedback_run.send = 0;
    worker.u.feedback_run.received = 0;
    worker.func_cancel = func_cancel;
@@ -1219,6 +1093,7 @@ on_error:
    worker.data = data;
    worker.cancel = EINA_FALSE;
    worker.feedback_run = EINA_TRUE;
+   worker.message_run = EINA_FALSE;
    worker.kill = EINA_FALSE;
 
    do {
@@ -1241,13 +1116,48 @@ ecore_thread_feedback(Ecore_Thread *thread,
    Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *)thread;
 
    if (!worker) return EINA_FALSE;
-   if (!worker->feedback_run) return EINA_FALSE;
 
 #ifdef EFL_HAVE_THREADS
    if (!PHE(worker->self, PHS())) return EINA_FALSE;
 
-   worker->u.feedback_run.send++;
-   ecore_pipe_write(worker->u.feedback_run.notify, &data, sizeof (void *));
+   if (worker->feedback_run)
+     {
+        Ecore_Pthread_Notify *notify;
+
+        notify = malloc(sizeof (Ecore_Pthread_Notify));
+        if (!notify) return EINA_FALSE;
+
+        notify->user_data = data;
+        notify->work = worker;
+        worker->u.feedback_run.send++;
+
+        ecore_main_loop_thread_safe_call_async(_ecore_notify_handler, notify);
+     }
+   else if (worker->message_run)
+     {
+        Ecore_Pthread_Message *msg;
+        Ecore_Pthread_Notify *notify;
+
+        msg = malloc(sizeof (Ecore_Pthread_Message*));
+        if (!msg) return EINA_FALSE;
+        msg->data = data;
+        msg->callback = EINA_FALSE;
+        msg->sync = EINA_FALSE;
+
+        notify = malloc(sizeof (Ecore_Pthread_Notify));
+        if (!notify)
+          {
+             free(msg);
+             return EINA_FALSE;
+          }
+        notify->work = worker;
+        notify->user_data = msg;
+
+        worker->u.message_run.from.send++;
+        ecore_main_loop_thread_safe_call_async(_ecore_message_notify_handler, notify);
+     }
+   else
+     return EINA_FALSE;
 
    return EINA_TRUE;
 #else
@@ -1257,6 +1167,71 @@ ecore_thread_feedback(Ecore_Thread *thread,
 #endif
 }
 
+#if 0
+EAPI Ecore_Thread *
+ecore_thread_message_run(Ecore_Thread_Cb func_main,
+                         Ecore_Thread_Notify_Cb func_notify,
+                         Ecore_Thread_Cb func_end,
+                         Ecore_Thread_Cb func_cancel,
+                         const void *data)
+{
+#ifdef EFL_HAVE_THREADS
+  Ecore_Pthread_Worker *worker;
+  PH(t);
+
+  if (!func_main) return NULL;
+
+  worker = _ecore_thread_worker_new();
+  if (!worker) return NULL;
+
+  worker->u.message_run.func_main = func_main;
+  worker->u.message_run.func_notify = func_notify;
+  worker->u.message_run.direct_worker = _ecore_thread_worker_new();
+  worker->u.message_run.send = ecore_pipe_add(_ecore_nothing_handler, worker);
+  worker->u.message_run.from.send = 0;
+  worker->u.message_run.from.received = 0;
+  worker->u.message_run.to.send = 0;
+  worker->u.message_run.to.received = 0;
+
+  ecore_pipe_freeze(worker->u.message_run.send);
+
+  worker->func_cancel = func_cancel;
+  worker->func_end = func_end;
+  worker->hash = NULL;
+  worker->data = data;
+
+  worker->cancel = EINA_FALSE;
+  worker->message_run = EINA_TRUE;
+  worker->feedback_run = EINA_FALSE;
+  worker->kill = EINA_FALSE;
+  worker->reschedule = EINA_FALSE;
+  worker->no_queue = EINA_FALSE;
+  worker->self = 0;
+
+  eina_threads_init();
+
+  if (PHC(t, _ecore_direct_worker, worker) == 0)
+    return (Ecore_Thread*) worker;
+
+  eina_threads_shutdown();
+
+  if (worker->u.message_run.direct_worker) _ecore_thread_worker_free(worker->u.message_run.direct_worker);
+  if (worker->u.message_run.send) ecore_pipe_del(worker->u.message_run.send);
+
+  CDD(worker->cond);
+  LKD(worker->mutex);
+#else
+  /* Note: This type of thread can't and never will work without thread support */
+  WRN("ecore_thread_message_run called, but threads disable in Ecore, things will go wrong. Starting now !");
+# warning "You disabled threads support in ecore, I hope you know what you are doing !"
+#endif
+
+  func_cancel((void *) data, NULL);
+
+  return NULL;
+}
+#endif
+
 EAPI Eina_Bool
 ecore_thread_reschedule(Ecore_Thread *thread)
 {
@@ -1641,24 +1616,13 @@ ecore_thread_global_data_wait(const char *key,
 
    while (1)
      {
-#ifndef _WIN32
-        struct timespec t = { 0, 0 };
-
-        t.tv_sec = (long int)tm;
-        t.tv_nsec = (long int)((tm - (double)t.tv_sec) * 1000000000);
-#else
-        struct timeval t = { 0, 0 };
-
-        t.tv_sec = (long int)tm;
-        t.tv_usec = (long int)((tm - (double)t.tv_sec) * 1000000);
-#endif
         LRWKRL(_ecore_thread_global_hash_lock);
         ret = eina_hash_find(_ecore_thread_global_hash, key);
         LRWKU(_ecore_thread_global_hash_lock);
         if ((ret) || (!seconds) || ((seconds > 0) && (tm <= ecore_time_get())))
           break;
         LKL(_ecore_thread_global_hash_mutex);
-        CDW(_ecore_thread_global_hash_cond, _ecore_thread_global_hash_mutex, &t);
+        CDW(_ecore_thread_global_hash_cond, tm);
         LKU(_ecore_thread_global_hash_mutex);
      }
    if (ret) return ret->data;
diff --git a/libraries/ecore/src/lib/ecore/ecore_time.c b/libraries/ecore/src/lib/ecore/ecore_time.c
index 8e7611b..0eeb1d6 100644
--- a/libraries/ecore/src/lib/ecore/ecore_time.c
+++ b/libraries/ecore/src/lib/ecore/ecore_time.c
@@ -21,7 +21,7 @@
 
 #include <time.h>
 
-#ifdef HAVE_CLOCK_GETTIME
+#if defined (HAVE_CLOCK_GETTIME) || defined (EXOTIC_PROVIDE_CLOCK_GETTIME)
 static clockid_t _ecore_time_clock_id = -1;
 #elif defined(__APPLE__) && defined(__MACH__)
 static double _ecore_time_clock_conversion = 1e-9;
@@ -52,7 +52,7 @@ double _ecore_time_loop_time = -1.0;
 EAPI double
 ecore_time_get(void)
 {
-#ifdef HAVE_CLOCK_GETTIME
+#if defined (HAVE_CLOCK_GETTIME) || defined (EXOTIC_PROVIDE_CLOCK_GETTIME) 
    struct timespec t;
 
    if (EINA_UNLIKELY(_ecore_time_clock_id < 0))
@@ -136,7 +136,7 @@ ecore_loop_time_get(void)
 void
 _ecore_time_init(void)
 {
-#ifdef HAVE_CLOCK_GETTIME
+#if defined (HAVE_CLOCK_GETTIME) || defined (EXOTIC_PROVIDE_CLOCK_GETTIME)
    struct timespec t;
 
    if (_ecore_time_clock_id != -1) return;
diff --git a/libraries/ecore/src/lib/ecore/ecore_timer.c b/libraries/ecore/src/lib/ecore/ecore_timer.c
index cc19e3f..d76733b 100644
--- a/libraries/ecore/src/lib/ecore/ecore_timer.c
+++ b/libraries/ecore/src/lib/ecore/ecore_timer.c
@@ -56,7 +56,7 @@ static double last_check = 0.0;
 static double precision = 10.0 / 1000000.0;
 
 /**
- * @addtogroup Ecore_Time_Group
+ * @addtogroup Ecore_Timer_Group
  *
  * @{
  */
@@ -73,12 +73,15 @@ ecore_timer_precision_get(void)
 }
 
 /**
- * Sets the precision to be used by timer infrastructure.
+ * @brief Sets the precision to be used by timer infrastructure.
  *
- * When system calculates time to expire the next timer we'll be able
- * to delay the timer by the given amount so more timers will fit in
- * the same dispatch, waking up the system less often and thus being
- * able to save power.
+ * @param value allowed introduced timeout delay, in seconds.
+ *
+ * This sets the precision for @b all timers. The precision determines how much
+ * of an difference from the requested interval is acceptable. One common reason
+ * to use this function is to @b increase the allowed timeout and thus @b
+ * decrease precision of the timers, this is because less precise the timers
+ * result in the system waking up less often and thus consuming less resources.
  *
  * Be aware that kernel may delay delivery even further, these delays
  * are always possible due other tasks having higher priorities or
@@ -93,8 +96,6 @@ ecore_timer_precision_get(void)
  * @note Ecore is smart enough to see if there are timers in the
  * precision range, if it does not, in our example if no second timer
  * in (T + precision) existed, then it would use the minimum timeout.
- *
- * @param value allowed introduced timeout delay, in seconds.
  */
 EAPI void
 ecore_timer_precision_set(double value)
@@ -322,7 +323,7 @@ ecore_timer_reset(Ecore_Timer *timer)
  * Get the pending time regarding a timer.
  *
  * @param        timer The timer to learn from.
- * @ingroup        Ecore_Time_Group
+ * @ingroup        Ecore_Timer_Group
  */
 EAPI double
 ecore_timer_pending_get(Ecore_Timer *timer)